@logixjs/react 0.1.0

package/dist/ModuleScope.cjs

@@ -0,0 +1,2695 @@
+"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/ModuleScope.ts
+var ModuleScope_exports = {};
+__export(ModuleScope_exports, {
+  ModuleScope: () => ModuleScope
+});
+module.exports = __toCommonJS(ModuleScope_exports);
+var import_react10 = __toESM(require("react"), 1);
+var Logix10 = __toESM(require("@logixjs/core"), 1);
+
+// src/internal/hooks/useModule.ts
+var import_react7 = __toESM(require("react"), 1);
+var Logix7 = __toESM(require("@logixjs/core"), 1);
+var import_effect8 = require("effect");
+
+// src/internal/hooks/useModuleRuntime.ts
+var import_react4 = require("react");
+var Logix4 = __toESM(require("@logixjs/core"), 1);
+var import_effect5 = require("effect");
+
+// src/internal/hooks/useRuntime.ts
+var import_react3 = require("react");
+var import_effect2 = require("effect");
+
+// src/internal/provider/ReactContext.ts
+var import_react = require("react");
+var RuntimeContext = (0, import_react.createContext)(null);
+
+// src/internal/provider/env.ts
+var import_Env = require("@logixjs/core/Env");
+
+// src/internal/provider/runtimeBindings.ts
+var import_react2 = require("react");
+var import_effect = require("effect");
+var Logix = __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_react2.useRef)(null);
+  const [state, setState] = (0, import_react2.useState)(() => ({
+    binding: null,
+    isLoading: enabled && !!layer,
+    runtime,
+    layer,
+    enabled
+  }));
+  (0, import_react2.useEffect)(() => {
+    if (!enabled || !layer) {
+      const current2 = activeBindingRef.current;
+      if (current2) {
+        activeBindingRef.current = null;
+        void runtime.runPromise(import_effect.Scope.close(current2.scope, import_effect.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_effect.Scope.close(current.scope, import_effect.Exit.void)).catch(debugScopeCloseFailure);
+    }
+    let cancelled = false;
+    setState({
+      binding: null,
+      isLoading: true,
+      runtime,
+      layer,
+      enabled
+    });
+    const newScope = import_effect.Effect.runSync(import_effect.Scope.make());
+    const buildEffect = import_effect.Effect.gen(function* () {
+      const context = yield* import_effect.Layer.buildWithScope(layer, newScope);
+      const applyEnv = (effect) => import_effect.Effect.mapInputContext(
+        import_effect.Scope.extend(effect, newScope),
+        (parent) => import_effect.Context.merge(parent, context)
+      );
+      const loggers = yield* applyEnv(import_effect.FiberRef.get(import_effect.FiberRef.currentLoggers));
+      const logLevel = yield* applyEnv(import_effect.FiberRef.get(import_effect.FiberRef.currentLogLevel));
+      const debugSinks = yield* applyEnv(
+        import_effect.FiberRef.get(Logix.Debug.internal.currentDebugSinks)
+      );
+      return { context, loggers, logLevel, debugSinks };
+    });
+    const assignBinding = (result) => {
+      if (cancelled) {
+        return runtime.runPromise(import_effect.Scope.close(newScope, import_effect.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_effect.Scope.close(previous.scope, import_effect.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_effect.Cause.die(error);
+          runtime.runFork(
+            onError(cause, { source: "provider", phase: "provider.layer.build" }).pipe(
+              import_effect.Effect.catchAllCause(() => import_effect.Effect.void)
+            )
+          );
+        }
+        void runtime.runPromise(import_effect.Scope.close(newScope, import_effect.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_effect.Scope.close(current2.scope, import_effect.Exit.void)).catch(debugScopeCloseFailure);
+        return;
+      }
+      void runtime.runPromise(import_effect.Scope.close(newScope, import_effect.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_effect.Effect.mapInputContext(
+        acc,
+        (parent) => import_effect.Context.merge(parent, ctx)
+      ),
+      scopes.reduceRight(
+        (acc, scope) => import_effect.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_effect.Effect.locally(import_effect.FiberRef.currentLoggers, last)(result);
+    }
+    if (logLevel) {
+      result = import_effect.Effect.locally(import_effect.FiberRef.currentLogLevel, logLevel)(result);
+    }
+    if (sinks && sinks.length > 0) {
+      result = import_effect.Effect.locally(
+        Logix.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/provider/errors.ts
+var RuntimeProviderNotFoundError = class extends Error {
+  constructor(hookName) {
+    super(
+      `[${hookName}] RuntimeProvider not found.
+
+Fix:
+- Wrap your app (or the calling component subtree) with <RuntimeProvider runtime={runtime}>.
+- If using nested providers, ensure an ancestor RuntimeProvider provides \`runtime\`.
+- If you intended to call this hook outside React, use @logixjs/core directly.
+`
+    );
+    this.name = "RuntimeProviderNotFoundError";
+  }
+};
+
+// src/internal/hooks/useRuntime.ts
+function useRuntime(options) {
+  const context = (0, import_react3.useContext)(RuntimeContext);
+  if (!context) {
+    throw new RuntimeProviderNotFoundError("useRuntime");
+  }
+  const mergedLayerCacheRef = (0, import_react3.useRef)(null);
+  const mergedLayer = (0, import_react3.useMemo)(() => {
+    if (!options) {
+      return void 0;
+    }
+    const { layer, layers } = options;
+    const hasLayersArray = Array.isArray(layers) && layers.length > 0;
+    if (!layer && !hasLayersArray) {
+      return void 0;
+    }
+    if (hasLayersArray) {
+      const all = layer ? [layer, ...layers] : layers;
+      const cached = mergedLayerCacheRef.current;
+      const shallowEqual = cached && cached.layers.length === all.length && cached.layers.every((item, idx) => item === all[idx]);
+      if (shallowEqual) {
+        return cached.merged;
+      }
+      const merged = import_effect2.Layer.mergeAll(...all);
+      mergedLayerCacheRef.current = { layers: all, merged };
+      return merged;
+    }
+    return layer;
+  }, [options?.layer, options?.layers]);
+  const lastLayersRef = (0, import_react3.useRef)(null);
+  const shallowEqualLayers = (a, b) => !!a && !!b && a.length === b.length && a.every((item, idx) => item === b[idx]);
+  (0, import_react3.useEffect)(() => {
+    if (!(0, import_Env.isDevEnv)()) {
+      return;
+    }
+    if (options?.layers && lastLayersRef.current && lastLayersRef.current !== options.layers && !shallowEqualLayers(lastLayersRef.current, options.layers)) {
+      console.warn(
+        "[RuntimeProvider] useRuntime received a new layers reference. Memoize the layers array with useMemo to avoid rebuilding Layers on every render (performance jitter)."
+      );
+    }
+    lastLayersRef.current = options?.layers ?? null;
+  }, [options?.layers]);
+  const { binding } = useLayerBinding(context.runtime, mergedLayer, !!mergedLayer);
+  return (0, import_react3.useMemo)(() => {
+    if (!binding) {
+      return context.runtime;
+    }
+    return createRuntimeAdapter(
+      context.runtime,
+      [binding.context],
+      [binding.scope],
+      [binding.loggers],
+      [binding.logLevel],
+      [binding.debugSinks]
+    );
+  }, [context.runtime, binding]);
+}
+
+// src/internal/store/ModuleRef.ts
+var isModuleRef = (value) => typeof value === "object" && value !== null && "runtime" in value && "actions" in value && "dispatch" in value;
+var makeModuleActions = (dispatch) => {
+  const cache = /* @__PURE__ */ new Map();
+  const api = new Proxy(
+    {},
+    {
+      get: (_target, prop) => {
+        if (cache.has(prop)) {
+          return cache.get(prop);
+        }
+        if (prop === "dispatch") {
+          cache.set(prop, dispatch);
+          return dispatch;
+        }
+        if (prop === "then" || typeof prop !== "string") {
+          return void 0;
+        }
+        const fn = (...args) => {
+          const payload = args[0];
+          dispatch({ _tag: prop, payload });
+        };
+        cache.set(prop, fn);
+        return fn;
+      }
+    }
+  );
+  return api;
+};
+function makeModuleDispatchers(dispatch, tokens) {
+  const cache = /* @__PURE__ */ new Map();
+  if (tokens) {
+    const out = {};
+    for (const [key, token] of Object.entries(tokens)) {
+      const fn = Object.assign(
+        ((...args) => {
+          const action = token(...args);
+          dispatch(action);
+          return action;
+        }),
+        token
+      );
+      out[key] = fn;
+    }
+    return out;
+  }
+  const api = new Proxy(
+    {},
+    {
+      get: (_target, prop) => {
+        if (cache.has(prop)) {
+          return cache.get(prop);
+        }
+        if (prop === "then" || prop === "dispatch" || typeof prop !== "string") {
+          return void 0;
+        }
+        const fn = (...args) => {
+          const payload = args[0];
+          const action = { _tag: prop, payload };
+          dispatch(action);
+          return action;
+        };
+        cache.set(prop, fn);
+        return fn;
+      }
+    }
+  );
+  return api;
+}
+var HANDLE_EXTEND = /* @__PURE__ */ Symbol.for("logix.module.handle.extend");
+var isObjectLike = (value) => typeof value === "object" && value !== null || typeof value === "function";
+var applyHandleExtend = (tag, runtime, base) => {
+  if (!isObjectLike(tag)) {
+    return base;
+  }
+  const extend = tag[HANDLE_EXTEND];
+  if (typeof extend !== "function") {
+    return base;
+  }
+  const next = extend(
+    runtime,
+    base
+  );
+  if (!next || typeof next !== "object") {
+    return base;
+  }
+  return { ...base, ...next };
+};
+
+// src/internal/store/ModuleCache.ts
+var Logix3 = __toESM(require("@logixjs/core"), 1);
+var import_effect4 = require("effect");
+
+// src/internal/store/perfWorkloads.ts
+var Logix2 = __toESM(require("@logixjs/core"), 1);
+var import_effect3 = require("effect");
+var PerfCounterStateSchema = import_effect3.Schema.Struct({
+  value: import_effect3.Schema.Number
+});
+var 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(
+        Logix3.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)() || Logix3.Debug.isDevtoolsEnabled()) {
+        void this.runtime.runPromise(
+          Logix3.Debug.record({
+            type: "trace:react.module.init",
+            moduleId: ownerId,
+            instanceId: value.instanceId,
+            data: {
+              mode: "suspend",
+              key,
+              durationMs: Math.round(durationMs * 100) / 100,
+              yieldStrategy: yieldDecision.strategy,
+              yieldReason: yieldDecision.reason,
+              yieldP95Ms: yieldDecision.p95Ms
+            }
+          })
+        ).catch((error) => {
+          debugBestEffortFailure("[ModuleCache] Debug.record failed", error);
+        });
+        void this.runtime.runPromise(
+          Logix3.Debug.record({
+            type: "trace:react.module-instance",
+            moduleId: ownerId,
+            instanceId: value.instanceId,
+            data: {
+              event: "attach",
+              key,
+              mode: "suspend",
+              gcTime: 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)() || Logix3.Debug.isDevtoolsEnabled()) {
+        void this.runtime.runPromise(
+          Logix3.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(
+          Logix3.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;
+};
+var hashOf = (value) => {
+  if (value === null) {
+    return "null";
+  }
+  const type = typeof value;
+  if (type === "string") {
+    return `s:${value}`;
+  }
+  if (type === "number") {
+    return `n:${value}`;
+  }
+  if (type === "boolean") {
+    return `b:${value}`;
+  }
+  return `${type}:${Object.prototype.toString.call(value)}`;
+};
+var stableHash = (deps) => {
+  if ((0, import_Env.isDevEnv)()) {
+    const hasNonPrimitive = deps.some((value) => {
+      if (value === null) return false;
+      const type = typeof value;
+      return type === "object" || type === "function";
+    });
+    if (hasNonPrimitive) {
+      console.warn(
+        "[ModuleCache] deps contains non-primitive values. stableHash() only distinguishes primitives (string/number/boolean/null/undefined); object/function entries may not trigger expected cache updates. Consider passing explicit primitive deps or controlling invalidation via `key`."
+      );
+    }
+  }
+  return deps.map(hashOf).join("|");
+};
+
+// src/internal/hooks/useModuleRuntime.ts
+var isModuleRuntime = (value) => typeof value === "object" && value !== null && "dispatch" in value && "getState" in value;
+function useModuleRuntime(handle) {
+  const runtime = useRuntime();
+  const runtimeContext = (0, import_react4.useContext)(RuntimeContext);
+  if (!runtimeContext) {
+    throw new RuntimeProviderNotFoundError("useModuleRuntime");
+  }
+  const cache = (0, import_react4.useMemo)(
+    () => getModuleCache(runtimeContext.runtime, runtimeContext.reactConfigSnapshot, runtimeContext.configVersion),
+    [runtimeContext.runtime, runtimeContext.reactConfigSnapshot, runtimeContext.configVersion]
+  );
+  const isTagHandle = !isModuleRef(handle) && !isModuleRuntime(handle);
+  const resolved = (0, import_react4.useMemo)(() => {
+    if (isModuleRef(handle)) {
+      return handle.runtime;
+    }
+    if (isModuleRuntime(handle)) {
+      return handle;
+    }
+    const tag = handle;
+    const tokenId = tag.id ?? "ModuleTag";
+    const preloadKey = runtimeContext.policy.preload?.keysByTagId.get(tokenId);
+    const key = preloadKey ?? `tag:${tokenId}`;
+    const mode = runtimeContext.policy.moduleTagMode;
+    const factory = (scope) => tag.pipe(import_effect5.Scope.extend(scope));
+    return mode === "suspend" ? cache.read(key, factory, void 0, tokenId, {
+      entrypoint: "react.useModuleRuntime",
+      policyMode: runtimeContext.policy.mode,
+      yield: runtimeContext.policy.yield
+    }) : cache.readSync(key, factory, void 0, tokenId, {
+      entrypoint: "react.useModuleRuntime",
+      policyMode: runtimeContext.policy.mode,
+      warnSyncBlockingThresholdMs: 5
+    });
+  }, [cache, runtimeContext.policy, handle]);
+  (0, import_react4.useEffect)(() => {
+    if (!isTagHandle) {
+      return;
+    }
+    if (!(0, import_Env.isDevEnv)() && !Logix4.Debug.isDevtoolsEnabled()) {
+      return;
+    }
+    const tokenId = handle?.id ?? "ModuleTag";
+    const effect = Logix4.Debug.record({
+      type: "trace:react.moduleTag.resolve",
+      moduleId: resolved.moduleId,
+      instanceId: resolved.instanceId,
+      data: {
+        mode: runtimeContext.policy.moduleTagMode,
+        tokenId,
+        yieldStrategy: runtimeContext.policy.yield.strategy
+      }
+    });
+    runtime.runFork(effect);
+  }, [runtime, runtimeContext.policy, resolved, handle, isTagHandle]);
+  return resolved;
+}
+
+// src/internal/hooks/useSelector.ts
+var import_react5 = require("react");
+var import_with_selector = require("use-sync-external-store/shim/with-selector");
+var Logix5 = __toESM(require("@logixjs/core"), 1);
+
+// src/internal/store/ModuleRuntimeExternalStore.ts
+var import_effect6 = require("effect");
+var storesByRuntime = /* @__PURE__ */ new WeakMap();
+var getStoreMapForRuntime = (runtime) => {
+  const cached = storesByRuntime.get(runtime);
+  if (cached) return cached;
+  const next = /* @__PURE__ */ new WeakMap();
+  storesByRuntime.set(runtime, next);
+  return next;
+};
+var getModuleRuntimeExternalStore = (runtime, moduleRuntime, options) => {
+  const byModule = getStoreMapForRuntime(runtime);
+  const cached = byModule.get(moduleRuntime);
+  if (cached) {
+    return cached;
+  }
+  let currentState;
+  const listeners = /* @__PURE__ */ new Set();
+  const lowPriorityDelayMs = options?.lowPriorityDelayMs ?? 16;
+  const lowPriorityMaxDelayMs = options?.lowPriorityMaxDelayMs ?? 50;
+  let notifyScheduled = false;
+  let notifyScheduledLow = false;
+  let lowTimeoutId;
+  let lowMaxTimeoutId;
+  let lowRafId;
+  const cancelLow = () => {
+    if (!notifyScheduledLow) return;
+    notifyScheduledLow = false;
+    if (lowTimeoutId != null) {
+      clearTimeout(lowTimeoutId);
+      lowTimeoutId = void 0;
+    }
+    if (lowMaxTimeoutId != null) {
+      clearTimeout(lowMaxTimeoutId);
+      lowMaxTimeoutId = void 0;
+    }
+    const cancel = globalThis.cancelAnimationFrame;
+    if (cancel && typeof lowRafId === "number") {
+      cancel(lowRafId);
+      lowRafId = void 0;
+    }
+  };
+  const flushNotify = () => {
+    notifyScheduled = false;
+    cancelLow();
+    for (const listener of listeners) {
+      listener();
+    }
+  };
+  const scheduleNotify = (priority) => {
+    if (priority === "low") {
+      if (notifyScheduled) return;
+      if (notifyScheduledLow) return;
+      notifyScheduledLow = true;
+      const flush = () => {
+        if (!notifyScheduledLow) return;
+        flushNotify();
+      };
+      const raf = globalThis.requestAnimationFrame;
+      if (raf) {
+        lowRafId = raf(flush);
+      } else {
+        lowTimeoutId = setTimeout(flush, lowPriorityDelayMs);
+      }
+      lowMaxTimeoutId = setTimeout(flush, lowPriorityMaxDelayMs);
+      return;
+    }
+    cancelLow();
+    if (notifyScheduled) return;
+    notifyScheduled = true;
+    queueMicrotask(flushNotify);
+  };
+  let fiber;
+  const ensureSubscription = () => {
+    if (fiber) return;
+    fiber = runtime.runFork(
+      import_effect6.Stream.runForEach(
+        moduleRuntime.changesWithMeta((state) => state),
+        ({ value: state, meta }) => import_effect6.Effect.sync(() => {
+          currentState = state;
+          scheduleNotify(meta.priority);
+        })
+      )
+    );
+  };
+  const refreshSnapshotIfStale = () => {
+    if (currentState === void 0) {
+      return;
+    }
+    try {
+      const latest = runtime.runSync(moduleRuntime.getState);
+      if (currentState === void 0 || !Object.is(currentState, latest)) {
+        currentState = latest;
+        scheduleNotify("normal");
+      }
+    } catch {
+    }
+  };
+  const getSnapshot = () => {
+    if (currentState !== void 0) return currentState;
+    currentState = runtime.runSync(moduleRuntime.getState);
+    return currentState;
+  };
+  const subscribe = (listener) => {
+    listeners.add(listener);
+    ensureSubscription();
+    refreshSnapshotIfStale();
+    return () => {
+      listeners.delete(listener);
+      if (listeners.size > 0) return;
+      const running = fiber;
+      if (!running) return;
+      fiber = void 0;
+      cancelLow();
+      runtime.runFork(import_effect6.Fiber.interrupt(running));
+    };
+  };
+  const store = { getSnapshot, subscribe };
+  byModule.set(moduleRuntime, store);
+  return store;
+};
+
+// src/internal/store/ModuleRuntimeSelectorExternalStore.ts
+var import_effect7 = require("effect");
+
+// src/internal/hooks/shallow.ts
+var hasObjectShape = (value) => typeof value === "object" && value !== null;
+var hasIterator = (value) => hasObjectShape(value) && typeof value[Symbol.iterator] === "function";
+var shallow = (previous, next) => {
+  if (Object.is(previous, next)) return true;
+  if (!hasObjectShape(previous) || !hasObjectShape(next)) {
+    return false;
+  }
+  if (Array.isArray(previous) && Array.isArray(next)) {
+    if (previous.length !== next.length) return false;
+    for (let i = 0; i < previous.length; i++) {
+      if (!Object.is(previous[i], next[i])) return false;
+    }
+    return true;
+  }
+  if (previous instanceof Map && next instanceof Map) {
+    if (previous.size !== next.size) return false;
+    for (const [key, value] of previous) {
+      if (!next.has(key)) return false;
+      if (!Object.is(value, next.get(key))) return false;
+    }
+    return true;
+  }
+  if (previous instanceof Set && next instanceof Set) {
+    if (previous.size !== next.size) return false;
+    for (const value of previous) {
+      if (!next.has(value)) return false;
+    }
+    return true;
+  }
+  if (hasIterator(previous) && hasIterator(next)) {
+    const a = previous[Symbol.iterator]();
+    const b = next[Symbol.iterator]();
+    while (true) {
+      const ra = a.next();
+      const rb = b.next();
+      if (ra.done || rb.done) return ra.done === rb.done;
+      if (!Object.is(ra.value, rb.value)) return false;
+    }
+  }
+  const prevKeys = Object.keys(previous);
+  const nextKeys = Object.keys(next);
+  if (prevKeys.length !== nextKeys.length) return false;
+  for (const key of prevKeys) {
+    if (!Object.prototype.hasOwnProperty.call(next, key)) return false;
+    if (!Object.is(previous[key], next[key])) return false;
+  }
+  return true;
+};
+
+// src/internal/store/ModuleRuntimeSelectorExternalStore.ts
+var storesByRuntime2 = /* @__PURE__ */ new WeakMap();
+var getStoreMapForRuntime2 = (runtime) => {
+  const cached = storesByRuntime2.get(runtime);
+  if (cached) return cached;
+  const next = /* @__PURE__ */ new WeakMap();
+  storesByRuntime2.set(runtime, next);
+  return next;
+};
+var getOrCreateSelectorMapForModule = (byModule, moduleRuntime) => {
+  const cached = byModule.get(moduleRuntime);
+  if (cached) return cached;
+  const next = /* @__PURE__ */ new Map();
+  byModule.set(moduleRuntime, next);
+  return next;
+};
+var equalsValue = (readQuery, a, b) => {
+  if (readQuery.equalsKind === "custom" && typeof readQuery.equals === "function") {
+    return readQuery.equals(a, b);
+  }
+  if (readQuery.equalsKind === "shallowStruct") {
+    return shallow(a, b);
+  }
+  return Object.is(a, b);
+};
+var getModuleRuntimeSelectorExternalStore = (runtime, moduleRuntime, selectorReadQuery, options) => {
+  const byModule = getStoreMapForRuntime2(runtime);
+  const bySelector = getOrCreateSelectorMapForModule(byModule, moduleRuntime);
+  const cached = bySelector.get(selectorReadQuery.selectorId);
+  if (cached) {
+    return cached;
+  }
+  let currentValue;
+  const listeners = /* @__PURE__ */ new Set();
+  const lowPriorityDelayMs = options?.lowPriorityDelayMs ?? 16;
+  const lowPriorityMaxDelayMs = options?.lowPriorityMaxDelayMs ?? 50;
+  let notifyScheduled = false;
+  let notifyScheduledLow = false;
+  let lowTimeoutId;
+  let lowMaxTimeoutId;
+  let lowRafId;
+  const cancelLow = () => {
+    if (!notifyScheduledLow) return;
+    notifyScheduledLow = false;
+    if (lowTimeoutId != null) {
+      clearTimeout(lowTimeoutId);
+      lowTimeoutId = void 0;
+    }
+    if (lowMaxTimeoutId != null) {
+      clearTimeout(lowMaxTimeoutId);
+      lowMaxTimeoutId = void 0;
+    }
+    const cancel = globalThis.cancelAnimationFrame;
+    if (cancel && typeof lowRafId === "number") {
+      cancel(lowRafId);
+      lowRafId = void 0;
+    }
+  };
+  const flushNotify = () => {
+    notifyScheduled = false;
+    cancelLow();
+    for (const listener of listeners) {
+      listener();
+    }
+  };
+  const scheduleNotify = (priority) => {
+    if (priority === "low") {
+      if (notifyScheduled) return;
+      if (notifyScheduledLow) return;
+      notifyScheduledLow = true;
+      const flush = () => {
+        if (!notifyScheduledLow) return;
+        flushNotify();
+      };
+      const raf = globalThis.requestAnimationFrame;
+      if (raf) {
+        lowRafId = raf(flush);
+      } else {
+        lowTimeoutId = setTimeout(flush, lowPriorityDelayMs);
+      }
+      lowMaxTimeoutId = setTimeout(flush, lowPriorityMaxDelayMs);
+      return;
+    }
+    cancelLow();
+    if (notifyScheduled) return;
+    notifyScheduled = true;
+    queueMicrotask(flushNotify);
+  };
+  let fiber;
+  const ensureSubscription = () => {
+    if (fiber) return;
+    fiber = runtime.runFork(
+      import_effect7.Stream.runForEach(
+        moduleRuntime.changesReadQueryWithMeta(selectorReadQuery),
+        ({ value, meta }) => import_effect7.Effect.sync(() => {
+          currentValue = value;
+          scheduleNotify(meta.priority);
+        })
+      )
+    );
+  };
+  const refreshSnapshotIfStale = () => {
+    if (currentValue === void 0) {
+      return;
+    }
+    try {
+      const state = runtime.runSync(moduleRuntime.getState);
+      const next = selectorReadQuery.select(state);
+      if (currentValue === void 0 || !equalsValue(selectorReadQuery, currentValue, next)) {
+        currentValue = next;
+        scheduleNotify("normal");
+      }
+    } catch {
+    }
+  };
+  const getSnapshot = () => {
+    if (currentValue !== void 0) return currentValue;
+    const state = runtime.runSync(moduleRuntime.getState);
+    currentValue = selectorReadQuery.select(state);
+    return currentValue;
+  };
+  const subscribe = (listener) => {
+    listeners.add(listener);
+    ensureSubscription();
+    refreshSnapshotIfStale();
+    return () => {
+      listeners.delete(listener);
+      if (listeners.size > 0) return;
+      const running = fiber;
+      if (!running) return;
+      fiber = void 0;
+      cancelLow();
+      runtime.runFork(import_effect7.Fiber.interrupt(running));
+    };
+  };
+  const store = { getSnapshot, subscribe };
+  bySelector.set(selectorReadQuery.selectorId, store);
+  return store;
+};
+
+// src/internal/hooks/useSelector.ts
+function useSelector(handle, selector, equalityFn) {
+  const runtimeContext = (0, import_react5.useContext)(RuntimeContext);
+  if (!runtimeContext) {
+    throw new RuntimeProviderNotFoundError("useSelector");
+  }
+  const runtime = runtimeContext.runtime;
+  const moduleRuntime = useModuleRuntime(handle);
+  const actualSelector = selector ?? ((state) => state);
+  const selectorReadQuery = (0, import_react5.useMemo)(
+    () => typeof selector === "function" ? Logix5.ReadQuery.compile(selector) : void 0,
+    [selector]
+  );
+  const actualEqualityFn = (0, import_react5.useMemo)(() => {
+    if (typeof equalityFn === "function") return equalityFn;
+    if (typeof selector !== "function") return Object.is;
+    return selectorReadQuery?.equalsKind === "shallowStruct" ? shallow : Object.is;
+  }, [equalityFn, selector, selectorReadQuery?.equalsKind]);
+  const useStaticLane = typeof selector === "function" && selectorReadQuery?.lane === "static";
+  const store = (0, import_react5.useMemo)(
+    () => useStaticLane && selectorReadQuery ? getModuleRuntimeSelectorExternalStore(
+      runtime,
+      moduleRuntime,
+      selectorReadQuery,
+      {
+        lowPriorityDelayMs: runtimeContext.reactConfigSnapshot.lowPriorityDelayMs,
+        lowPriorityMaxDelayMs: runtimeContext.reactConfigSnapshot.lowPriorityMaxDelayMs
+      }
+    ) : getModuleRuntimeExternalStore(
+      runtime,
+      moduleRuntime,
+      {
+        lowPriorityDelayMs: runtimeContext.reactConfigSnapshot.lowPriorityDelayMs,
+        lowPriorityMaxDelayMs: runtimeContext.reactConfigSnapshot.lowPriorityMaxDelayMs
+      }
+    ),
+    [
+      moduleRuntime,
+      runtime,
+      runtimeContext.reactConfigSnapshot.lowPriorityDelayMs,
+      runtimeContext.reactConfigSnapshot.lowPriorityMaxDelayMs,
+      selectorReadQuery,
+      useStaticLane
+    ]
+  );
+  const selected = (0, import_with_selector.useSyncExternalStoreWithSelector)(
+    store.subscribe,
+    store.getSnapshot,
+    store.getSnapshot,
+    useStaticLane ? (snapshot) => snapshot : (snapshot) => actualSelector(snapshot),
+    actualEqualityFn
+  );
+  (0, import_react5.useEffect)(() => {
+    if (!(0, import_Env.isDevEnv)() && !Logix5.Debug.isDevtoolsEnabled()) {
+      return;
+    }
+    const instanceId = moduleRuntime.instanceId;
+    let fieldPaths;
+    let selectorKey;
+    if (typeof selector === "function") {
+      const meta = selector;
+      const rawFieldPaths = meta.fieldPaths;
+      if (Array.isArray(rawFieldPaths)) {
+        const paths = rawFieldPaths.filter((p) => typeof p === "string");
+        fieldPaths = paths.length > 0 ? paths.slice() : void 0;
+      }
+      const rawDebugKey = meta.debugKey;
+      selectorKey = typeof rawDebugKey === "string" && rawDebugKey.length > 0 ? rawDebugKey : typeof selector.name === "string" && selector.name.length > 0 ? selector.name : void 0;
+    }
+    const effect = Logix5.Debug.record({
+      type: "trace:react-selector",
+      moduleId: moduleRuntime.moduleId,
+      instanceId,
+      data: {
+        componentLabel: "useSelector",
+        selectorKey,
+        fieldPaths,
+        selectorId: selectorReadQuery?.selectorId,
+        lane: selectorReadQuery?.lane,
+        producer: selectorReadQuery?.producer,
+        fallbackReason: selectorReadQuery?.fallbackReason,
+        readsDigest: selectorReadQuery?.readsDigest,
+        equalsKind: selectorReadQuery?.equalsKind,
+        strictModePhase: "commit"
+      }
+    });
+    runtime.runFork(effect);
+  }, [runtime, moduleRuntime, selector, selected, selectorReadQuery]);
+  return selected;
+}
+
+// src/internal/store/resolveImportedModuleRef.ts
+var Logix6 = __toESM(require("@logixjs/core"), 1);
+var getOrCreateWeakMap = (map, key, make) => {
+  const cached = map.get(key);
+  if (cached) return cached;
+  const next = make();
+  map.set(key, next);
+  return next;
+};
+var cacheByRuntime = /* @__PURE__ */ new WeakMap();
+var resolveImportedModuleRef = (runtime, parentRuntime, module2) => {
+  const byParent = getOrCreateWeakMap(
+    cacheByRuntime,
+    runtime,
+    () => /* @__PURE__ */ new WeakMap()
+  );
+  const byModule = getOrCreateWeakMap(
+    byParent,
+    parentRuntime,
+    () => /* @__PURE__ */ new WeakMap()
+  );
+  const cached = byModule.get(module2);
+  if (cached) {
+    return cached;
+  }
+  const importsScope = Logix6.InternalContracts.getImportsScope(parentRuntime);
+  const childRuntime = importsScope.get(module2);
+  if (childRuntime) {
+    const dispatch = Object.assign(
+      (action) => {
+        runtime.runFork(childRuntime.dispatch(action));
+      },
+      {
+        batch: (actions2) => {
+          runtime.runFork(
+            childRuntime.dispatchBatch(
+              actions2
+            )
+          );
+        },
+        lowPriority: (action) => {
+          runtime.runFork(
+            childRuntime.dispatchLowPriority(action)
+          );
+        }
+      }
+    );
+    const actions = makeModuleActions(dispatch);
+    const dispatchers = makeModuleDispatchers(dispatch, module2.actions);
+    const ref = {
+      def: module2,
+      runtime: childRuntime,
+      dispatch,
+      actions,
+      dispatchers,
+      imports: {
+        get: (m) => resolveImportedModuleRef(runtime, childRuntime, m)
+      },
+      getState: childRuntime.getState,
+      setState: childRuntime.setState,
+      actions$: childRuntime.actions$,
+      changes: childRuntime.changes,
+      ref: childRuntime.ref
+    };
+    byModule.set(module2, ref);
+    return ref;
+  }
+  const parentId = parentRuntime.moduleId;
+  const tokenId = String(module2.id);
+  const parentInstanceId = parentRuntime.instanceId;
+  const fix = (0, import_Env.isDevEnv)() ? [
+    "- Ensure the child is imported in the same scope.",
+    `  Example: ${parentId}.implement({ imports: [${tokenId}.impl], ... })`,
+    "- Ensure parentRuntime is an instance scope (not a ModuleTag singleton).",
+    "  Example: useModule(ParentImpl, { key }) / useModule(ParentImpl) / useLocalModule(ParentModule, ...)",
+    "- If you intentionally want a singleton (not an imported child), use useModule(Child.tag) (ModuleTag) in the current React runtime environment.",
+    "- If you intentionally want the root provider singleton (ignore RuntimeProvider.layer overrides), use runtime.runSync(Root.resolve(Child.tag))."
+  ] : [];
+  const err = new Error(
+    (0, import_Env.isDevEnv)() ? [
+      "[MissingImportedModuleError] Cannot resolve imported module from parent imports scope.",
+      "",
+      `tokenId: ${tokenId}`,
+      "entrypoint: react.useImportedModule/imports.get",
+      "mode: strict",
+      `startScope: moduleId=${parentId}, instanceId=${parentInstanceId}`,
+      "",
+      "fix:",
+      ...fix
+    ].join("\n") : "[MissingImportedModuleError] imported module runtime not found"
+  );
+  err.tokenId = tokenId;
+  err.entrypoint = "react.useImportedModule/imports.get";
+  err.mode = "strict";
+  err.startScope = {
+    moduleId: parentId,
+    instanceId: parentInstanceId
+  };
+  err.fix = fix;
+  err.name = "MissingImportedModuleError";
+  throw err;
+};
+
+// src/internal/hooks/useStableId.ts
+var import_react6 = __toESM(require("react"), 1);
+var useStableId = () => {
+  return import_react6.default.useId();
+};
+
+// src/internal/hooks/useModule.ts
+var isModuleImpl = (handle) => Boolean(handle) && typeof handle === "object" && handle._tag === "ModuleImpl";
+var isModule = (handle) => Logix7.Module.hasImpl(handle);
+var isModuleDef = (handle) => Logix7.Module.is(handle) && handle._kind === "ModuleDef";
+function useModule(handle, selectorOrOptions, equalityFn) {
+  const runtimeBase = useRuntime();
+  const runtimeContext = import_react7.default.useContext(RuntimeContext);
+  if (!runtimeContext) {
+    throw new RuntimeProviderNotFoundError("useModule");
+  }
+  const normalizedHandle = isModule(handle) ? handle.impl : isModuleDef(handle) ? handle.tag : handle;
+  let selector;
+  let options;
+  if (isModuleImpl(normalizedHandle)) {
+    if (typeof selectorOrOptions === "function") {
+      selector = selectorOrOptions;
+    } else if (selectorOrOptions && typeof selectorOrOptions === "object") {
+      options = selectorOrOptions;
+    }
+  } else {
+    if (typeof selectorOrOptions === "function" || selectorOrOptions === void 0) {
+      selector = selectorOrOptions;
+    } else if (selectorOrOptions && typeof selectorOrOptions === "object") {
+      throw new Error("useModule(handle, options) \u4EC5\u652F\u6301 ModuleImpl \u53E5\u67C4");
+    }
+  }
+  let runtime;
+  if (isModuleImpl(normalizedHandle)) {
+    const cache = import_react7.default.useMemo(
+      () => getModuleCache(runtimeBase, runtimeContext.reactConfigSnapshot, runtimeContext.configVersion),
+      [runtimeBase, runtimeContext.reactConfigSnapshot, runtimeContext.configVersion]
+    );
+    const deps = options?.deps ?? [];
+    const depsHash = stableHash(deps);
+    const explicitSuspend = options?.suspend === true;
+    const suspend = explicitSuspend || options?.suspend !== false && runtimeContext.policy.moduleImplMode === "suspend";
+    const gcTime = options?.gcTime ?? runtimeContext.reactConfigSnapshot.gcTime;
+    let initTimeoutMs = suspend ? options?.initTimeoutMs : void 0;
+    if (suspend && initTimeoutMs === void 0) {
+      initTimeoutMs = runtimeContext.reactConfigSnapshot.initTimeoutMs;
+    }
+    if (explicitSuspend && (!options || !options.key)) {
+      if ((0, import_Env.isDevEnv)()) {
+        throw new Error(
+          "[useModule] suspend:true \u6A21\u5F0F\u5FC5\u987B\u663E\u5F0F\u63D0\u4F9B options.key\uFF1B\u8BF7\u5728 Suspense \u8FB9\u754C\u5916\u751F\u6210\u7A33\u5B9A ID\uFF08\u4F8B\u5982 useId() \u6216\u4E1A\u52A1 id\uFF09\uFF0C\u5E76\u5728 useModule(Impl, { suspend: true, key }) \u4E2D\u4F20\u5165\u8BE5\u503C\u3002"
+        );
+      }
+    }
+    const componentId = useStableId();
+    const moduleId = normalizedHandle.module.id ?? "ModuleImpl";
+    const preloadKey = runtimeContext.policy.preload?.keysByModuleId.get(moduleId);
+    const baseKey = preloadKey ?? options?.key ?? (suspend ? `impl:${moduleId}` : `impl:${moduleId}:${componentId}`);
+    const key = depsHash ? `${baseKey}:${depsHash}` : baseKey;
+    const ownerId = moduleId;
+    const baseFactory = import_react7.default.useMemo(
+      () => (scope) => import_effect8.Layer.buildWithScope(normalizedHandle.layer, scope).pipe(
+        import_effect8.Effect.map(
+          (context) => import_effect8.Context.get(context, normalizedHandle.module)
+        )
+      ),
+      [normalizedHandle]
+    );
+    const factory = import_react7.default.useMemo(() => {
+      if (!suspend || initTimeoutMs === void 0) {
+        return baseFactory;
+      }
+      return (scope) => baseFactory(scope).pipe(
+        import_effect8.Effect.timeoutFail({
+          duration: initTimeoutMs,
+          onTimeout: () => new Error(`[useModule] Module "${ownerId}" initialization timed out after ${initTimeoutMs}ms`)
+        })
+      );
+    }, [baseFactory, suspend, initTimeoutMs, ownerId]);
+    const moduleRuntime = suspend ? cache.read(key, factory, gcTime, ownerId, {
+      entrypoint: "react.useModule",
+      policyMode: runtimeContext.policy.mode,
+      yield: runtimeContext.policy.yield
+    }) : cache.readSync(key, factory, gcTime, ownerId, {
+      entrypoint: "react.useModule",
+      policyMode: runtimeContext.policy.mode,
+      warnSyncBlockingThresholdMs: 5
+    });
+    import_react7.default.useEffect(() => cache.retain(key), [cache, key]);
+    runtime = moduleRuntime;
+  } else {
+    runtime = useModuleRuntime(normalizedHandle);
+  }
+  import_react7.default.useEffect(() => {
+    if (!isModuleImpl(normalizedHandle)) {
+      return;
+    }
+    const opt = options;
+    const label = opt && "label" in opt && opt.label || opt && opt.key;
+    if (!label) {
+      return;
+    }
+    const effect = Logix7.Debug.record({
+      type: "trace:instanceLabel",
+      moduleId: normalizedHandle.module.id,
+      instanceId: runtime.instanceId,
+      data: { label }
+    });
+    runtimeBase.runFork(effect);
+  }, [runtimeBase, runtime, normalizedHandle, options]);
+  import_react7.default.useEffect(() => {
+    if (!(0, import_Env.isDevEnv)() && !Logix7.Debug.isDevtoolsEnabled()) {
+      return;
+    }
+    if (!runtime.instanceId) {
+      return;
+    }
+    const effect = Logix7.Debug.record({
+      type: "trace:react-render",
+      moduleId: runtime.moduleId,
+      instanceId: runtime.instanceId,
+      data: {
+        componentLabel: "useModule",
+        strictModePhase: "commit"
+      }
+    });
+    runtimeBase.runFork(effect);
+  }, [runtimeBase, runtime]);
+  if (selector) {
+    if (isModuleImpl(normalizedHandle)) {
+      return useSelector(runtime, selector, equalityFn);
+    }
+    return useSelector(normalizedHandle, selector, equalityFn);
+  }
+  const def = import_react7.default.useMemo(() => {
+    if (isModule(handle) || isModuleDef(handle)) {
+      return handle;
+    }
+    if (isModuleRef(handle)) {
+      return handle.def;
+    }
+    if (isModuleImpl(handle)) {
+      return handle.module;
+    }
+    if (handle && (typeof handle === "object" || typeof handle === "function") && handle._kind === "ModuleTag") {
+      return handle;
+    }
+    if (isModuleImpl(normalizedHandle)) {
+      return normalizedHandle.module;
+    }
+    if (isModuleRef(normalizedHandle)) {
+      return normalizedHandle.def;
+    }
+    if (normalizedHandle && (typeof normalizedHandle === "object" || typeof normalizedHandle === "function") && normalizedHandle._kind === "ModuleTag") {
+      return normalizedHandle;
+    }
+    return void 0;
+  }, [handle, normalizedHandle]);
+  const tokens = import_react7.default.useMemo(() => {
+    if (!def || typeof def !== "object" && typeof def !== "function") {
+      return void 0;
+    }
+    const candidate = def;
+    if (!candidate.actions || typeof candidate.actions !== "object") {
+      return void 0;
+    }
+    return candidate.actions;
+  }, [def]);
+  const dispatch = import_react7.default.useMemo(() => {
+    const base = (action) => {
+      runtimeBase.runFork(runtime.dispatch(action));
+    };
+    return Object.assign(base, {
+      batch: (actions2) => {
+        runtimeBase.runFork(runtime.dispatchBatch(actions2));
+      },
+      lowPriority: (action) => {
+        runtimeBase.runFork(runtime.dispatchLowPriority(action));
+      }
+    });
+  }, [runtimeBase, runtime]);
+  const extendTag = import_react7.default.useMemo(() => {
+    if (isModuleImpl(normalizedHandle)) {
+      return normalizedHandle.module;
+    }
+    return normalizedHandle;
+  }, [normalizedHandle]);
+  const actions = import_react7.default.useMemo(() => makeModuleActions(dispatch), [dispatch]);
+  const dispatchers = import_react7.default.useMemo(
+    () => tokens ? makeModuleDispatchers(dispatch, tokens) : makeModuleDispatchers(dispatch),
+    [dispatch, tokens]
+  );
+  return import_react7.default.useMemo(() => {
+    const base = {
+      def,
+      runtime,
+      dispatch,
+      actions,
+      dispatchers,
+      imports: {
+        get: (module2) => resolveImportedModuleRef(runtimeBase, runtime, module2)
+      },
+      getState: runtime.getState,
+      setState: runtime.setState,
+      actions$: runtime.actions$,
+      changes: runtime.changes,
+      ref: runtime.ref
+    };
+    return applyHandleExtend(extendTag, runtime, base);
+  }, [runtimeBase, runtime, dispatch, actions, dispatchers, extendTag, def]);
+}
+
+// src/internal/provider/RuntimeProvider.tsx
+var import_react9 = __toESM(require("react"), 1);
+var import_effect10 = require("effect");
+var Logix9 = __toESM(require("@logixjs/core"), 1);
+
+// src/internal/provider/config.ts
+var import_effect9 = require("effect");
+var ReactRuntimeConfigTag = class extends import_effect9.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_effect9.Config.number("logix.react.gc_time").pipe(import_effect9.Config.withDefault(DEFAULT_CONFIG.gcTime)),
+  /**
+   * Default init timeout (ms), only effective when suspend:true.
+   * - Uses Option<number> to represent "optional config": missing means init timeout is disabled.
+   * - Callers can map Option.none to undefined.
+   */
+  initTimeoutMs: import_effect9.Config.option(import_effect9.Config.number("logix.react.init_timeout_ms")),
+  /**
+   * Delay (ms) for low-priority notification scheduling.
+   * - Roughly "defer to the next frame" cadence (default 16ms).
+   */
+  lowPriorityDelayMs: import_effect9.Config.number("logix.react.low_priority_delay_ms").pipe(
+    import_effect9.Config.withDefault(DEFAULT_CONFIG.lowPriorityDelayMs ?? 16)
+  ),
+  /**
+   * Maximum delay upper bound (ms) for low-priority notification scheduling.
+   * - Ensures eventual delivery, avoiding indefinite coalescing under extreme high-frequency scenarios.
+   * - Default 50ms.
+   */
+  lowPriorityMaxDelayMs: import_effect9.Config.number("logix.react.low_priority_max_delay_ms").pipe(
+    import_effect9.Config.withDefault(DEFAULT_CONFIG.lowPriorityMaxDelayMs ?? 50)
+  )
+};
+var ReactModuleConfig = {
+  gcTime: import_effect9.Effect.gen(function* () {
+    const override = yield* import_effect9.Effect.serviceOption(ReactRuntimeConfigTag);
+    if (import_effect9.Option.isSome(override)) {
+      return override.value.gcTime;
+    }
+    const value = yield* ReactModuleConfigFromEnv.gcTime;
+    return value;
+  }),
+  initTimeoutMs: import_effect9.Effect.gen(function* () {
+    const override = yield* import_effect9.Effect.serviceOption(ReactRuntimeConfigTag);
+    if (import_effect9.Option.isSome(override)) {
+      const v = override.value.initTimeoutMs;
+      return v === void 0 ? import_effect9.Option.none() : import_effect9.Option.some(v);
+    }
+    const opt = yield* ReactModuleConfigFromEnv.initTimeoutMs;
+    return opt;
+  }),
+  lowPriorityDelayMs: import_effect9.Effect.gen(function* () {
+    const override = yield* import_effect9.Effect.serviceOption(ReactRuntimeConfigTag);
+    if (import_effect9.Option.isSome(override)) {
+      return override.value.lowPriorityDelayMs ?? DEFAULT_CONFIG.lowPriorityDelayMs ?? 16;
+    }
+    const value = yield* ReactModuleConfigFromEnv.lowPriorityDelayMs;
+    return value;
+  }),
+  lowPriorityMaxDelayMs: import_effect9.Effect.gen(function* () {
+    const override = yield* import_effect9.Effect.serviceOption(ReactRuntimeConfigTag);
+    if (import_effect9.Option.isSome(override)) {
+      return override.value.lowPriorityMaxDelayMs ?? DEFAULT_CONFIG.lowPriorityMaxDelayMs ?? 50;
+    }
+    const value = yield* ReactModuleConfigFromEnv.lowPriorityMaxDelayMs;
+    return value;
+  })
+};
+var ReactRuntimeConfigSnapshot = {
+  load: import_effect9.Effect.gen(function* () {
+    const runtimeOverride = yield* import_effect9.Effect.serviceOption(ReactRuntimeConfigTag);
+    if (import_effect9.Option.isSome(runtimeOverride)) {
+      return {
+        gcTime: runtimeOverride.value.gcTime,
+        initTimeoutMs: runtimeOverride.value.initTimeoutMs,
+        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_effect9.Option.getOrUndefined(envInitTimeoutOpt);
+    const envLowPriorityDelayMs = yield* ReactModuleConfigFromEnv.lowPriorityDelayMs;
+    const envLowPriorityMaxDelayMs = yield* ReactModuleConfigFromEnv.lowPriorityMaxDelayMs;
+    const fromConfig = envGcTime !== DEFAULT_CONFIG.gcTime || import_effect9.Option.isSome(envInitTimeoutOpt) || envLowPriorityDelayMs !== (DEFAULT_CONFIG.lowPriorityDelayMs ?? 16) || envLowPriorityMaxDelayMs !== (DEFAULT_CONFIG.lowPriorityMaxDelayMs ?? 50);
+    if (fromConfig) {
+      return {
+        gcTime: envGcTime,
+        initTimeoutMs: envInitTimeout,
+        lowPriorityDelayMs: envLowPriorityDelayMs,
+        lowPriorityMaxDelayMs: envLowPriorityMaxDelayMs,
+        source: "config"
+      };
+    }
+    return DEFAULT_CONFIG_SNAPSHOT;
+  })
+};
+
+// src/internal/provider/fallback.tsx
+var import_react8 = require("react");
+var Logix8 = __toESM(require("@logixjs/core"), 1);
+
+// 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_react8.useState)(0);
+  (0, import_react8.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)() && !Logix8.Debug.isDevtoolsEnabled()) {
+    return;
+  }
+  void args.runtime.runPromise(
+    Logix8.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_react8.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)() || Logix8.Debug.isDevtoolsEnabled();
+  const Impl = enabled ? FallbackProbeEnabled : FallbackProbeNoop;
+  return /* @__PURE__ */ (0, import_jsx_runtime.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 isModuleImpl2 = (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 (isModuleImpl2(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 (isModuleImpl2(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_react9.useContext)(RuntimeContext);
+  const baseRuntime = useRuntimeResolution(runtime, parent);
+  const resolvedPolicy = (0, import_react9.useMemo)(
+    () => resolveRuntimeProviderPolicy({
+      policy,
+      parentPolicy: parent?.policy ?? null
+    }),
+    [policy, parent?.policy]
+  );
+  const onErrorRef = import_react9.default.useRef(onError);
+  onErrorRef.current = onError;
+  const { binding: layerBinding } = useLayerBinding(baseRuntime, layer, Boolean(layer), onErrorRef.current);
+  const onErrorSink = (0, import_react9.useMemo)(() => {
+    if (!onError) return null;
+    const sink = {
+      record: (event) => {
+        const handler = onErrorRef.current;
+        if (!handler) {
+          return import_effect10.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_effect10.Effect.catchAllCause(() => import_effect10.Effect.void));
+        }
+        if (event.type === "diagnostic" && event.severity === "error") {
+          return handler(
+            import_effect10.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_effect10.Effect.catchAllCause(() => import_effect10.Effect.void));
+        }
+        return import_effect10.Effect.void;
+      }
+    };
+    return sink;
+  }, [Boolean(onError)]);
+  const inheritedDebugSinks = (0, import_react9.useMemo)(() => {
+    if (!onErrorSink) {
+      return [];
+    }
+    if (layerBinding) {
+      return layerBinding.debugSinks;
+    }
+    try {
+      return baseRuntime.runSync(
+        import_effect10.FiberRef.get(Logix9.Debug.internal.currentDebugSinks)
+      );
+    } catch {
+      return [];
+    }
+  }, [baseRuntime, layerBinding, onErrorSink]);
+  const runtimeWithBindings = (0, import_react9.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_react9.default.useRef(false);
+  const [configState, setConfigState] = (0, import_react9.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_react9.useEffect)(() => {
+    if (configState.loadMode !== "sync") {
+      return;
+    }
+    if (didReportSyncConfigSnapshotRef.current) {
+      return;
+    }
+    didReportSyncConfigSnapshotRef.current = true;
+    void runtimeWithBindings.runPromise(
+      Logix9.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_react9.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(
+        Logix9.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_react9.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_react9.useState)(false);
+  (0, import_react9.useEffect)(() => {
+    if (resolvedPolicy.mode !== "defer") {
+      setDeferReady(false);
+      return;
+    }
+    setDeferReady(false);
+  }, [resolvedPolicy.mode]);
+  const preloadCancelsRef = import_react9.default.useRef(null);
+  (0, import_react9.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_effect10.Layer.buildWithScope(handle.layer, scope).pipe(
+            import_effect10.Effect.map((context) => import_effect10.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(
+            Logix9.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_effect10.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(
+          Logix9.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_effect10.Cause.die(error), { source: "provider", phase: "provider.layer.build" }).pipe(import_effect10.Effect.catchAllCause(() => import_effect10.Effect.void))
+        );
+      }
+      setDeferReady(true);
+    });
+    return () => {
+      cancelled = true;
+      preloadCancelsRef.current = null;
+      for (const cancel of allCancels) cancel();
+    };
+  }, [resolvedPolicy, isLayerReady, isConfigReady, runtimeWithBindings, configState, onErrorRef]);
+  (0, import_react9.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_react9.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_react9.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;
+};
+
+// src/ModuleScope.ts
+var makeModuleScope = (handle, defaults) => {
+  const Context5 = import_react10.default.createContext(null);
+  const toUseModuleOptions = (options) => {
+    const { scopeId, ...rest } = options;
+    return scopeId != null ? { ...rest, key: scopeId } : rest;
+  };
+  const getRegistryOrThrow = (runtime, where) => {
+    try {
+      const registry = runtime.runSync(Logix10.ScopeRegistry.ScopeRegistryTag);
+      if (!registry) {
+        throw new Error("ScopeRegistry service is undefined");
+      }
+      return registry;
+    } catch {
+      throw new Error(
+        `${where} Missing Logix.ScopeRegistry in current runtime. If you are using Logix.Runtime.make, it should be provided by default. If you are using ManagedRuntime.make, include Logix.ScopeRegistry.layer() in your Layer.`
+      );
+    }
+  };
+  const moduleToken = Logix10.Module.hasImpl(handle) ? handle.tag : handle.module;
+  const Provider = ({ children, options }) => {
+    const runtime = useRuntime();
+    const merged = defaults || options ? { ...defaults ?? {}, ...options ?? {} } : void 0;
+    const ref = merged ? useModule(handle, toUseModuleOptions(merged)) : useModule(handle);
+    const scopeId = merged?.scopeId;
+    import_react10.default.useEffect(() => {
+      if (!scopeId) return;
+      const registry = getRegistryOrThrow(runtime, "[ModuleScope]");
+      const leaseRuntime = registry.register(scopeId, Logix10.ScopeRegistry.ScopedRuntimeTag, runtime);
+      const leaseModule = registry.register(scopeId, moduleToken, ref.runtime);
+      return () => {
+        leaseModule.release();
+        leaseRuntime.release();
+      };
+    }, [runtime, scopeId, ref.runtime]);
+    return import_react10.default.createElement(Context5.Provider, { value: ref }, children);
+  };
+  const use = () => {
+    const ref = import_react10.default.useContext(Context5);
+    if (!ref) {
+      throw new Error("[ModuleScope] Provider not found");
+    }
+    return ref;
+  };
+  const useImported = (module2) => {
+    const host = use();
+    return host.imports.get(module2);
+  };
+  const Bridge = ({ scopeId, children }) => {
+    const runtime = useRuntime();
+    const registry = getRegistryOrThrow(runtime, "[ModuleScope.Bridge]");
+    const scopedRuntime = registry.get(scopeId, Logix10.ScopeRegistry.ScopedRuntimeTag);
+    const moduleRuntime = registry.get(
+      scopeId,
+      moduleToken
+    );
+    if (!scopedRuntime || !moduleRuntime) {
+      throw new Error(
+        `[ModuleScope.Bridge] Scope "${scopeId}" is not registered (or has been disposed). Ensure you have a corresponding <ModuleScope.Provider options={{ scopeId }}> mounted.`
+      );
+    }
+    return import_react10.default.createElement(
+      RuntimeProvider,
+      { runtime: scopedRuntime },
+      import_react10.default.createElement(BridgeInner, { moduleRuntime, Context: Context5 }, children)
+    );
+  };
+  const BridgeInner = ({
+    moduleRuntime,
+    Context: Context6,
+    children
+  }) => {
+    const ref = useModule(moduleRuntime);
+    return import_react10.default.createElement(Context6.Provider, { value: ref }, children);
+  };
+  return { Provider, use, useImported, Context: Context5, Bridge };
+};
+var ModuleScope = {
+  make: makeModuleScope
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ModuleScope
+});