@logixjs/react 0.1.0

package/dist/Hooks.cjs

@@ -0,0 +1,2194 @@
+"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/Hooks.ts
+var Hooks_exports = {};
+__export(Hooks_exports, {
+  shallow: () => shallow,
+  useDispatch: () => useDispatch,
+  useImportedModule: () => useImportedModule,
+  useLayerModule: () => useLayerModule,
+  useLocalModule: () => useLocalModule,
+  useModule: () => useModule,
+  useModuleList: () => useModuleList,
+  useProcesses: () => useProcesses,
+  useRuntime: () => useRuntime,
+  useSelector: () => useSelector
+});
+module.exports = __toCommonJS(Hooks_exports);
+
+// 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/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/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/hooks/useLocalModule.ts
+var import_react8 = __toESM(require("react"), 1);
+var Logix8 = __toESM(require("@logixjs/core"), 1);
+var import_effect9 = require("effect");
+function isModuleTag(source) {
+  if (!source || typeof source !== "object" && typeof source !== "function") {
+    return false;
+  }
+  const candidate = source;
+  return candidate._kind === "ModuleTag";
+}
+function useLocalModule(source, second) {
+  const runtime = useRuntime();
+  const runtimeContext = import_react8.default.useContext(RuntimeContext);
+  if (!runtimeContext) {
+    throw new RuntimeProviderNotFoundError("useLocalModule");
+  }
+  const cache = (0, import_react8.useMemo)(
+    () => getModuleCache(runtime, runtimeContext.reactConfigSnapshot, runtimeContext.configVersion),
+    [runtime, runtimeContext.reactConfigSnapshot, runtimeContext.configVersion]
+  );
+  const componentId = useStableId();
+  const moduleTag = import_react8.default.useMemo(() => {
+    if (Logix8.Module.is(source)) {
+      return source.tag;
+    }
+    if (isModuleTag(source)) {
+      return source;
+    }
+    return null;
+  }, [source]);
+  const def = import_react8.default.useMemo(() => {
+    if (Logix8.Module.is(source) || isModuleTag(source)) {
+      return source;
+    }
+    return void 0;
+  }, [source]);
+  const isModule2 = moduleTag !== null;
+  const moduleOptions = isModule2 ? second : void 0;
+  const deps = isModule2 ? moduleOptions?.deps ?? [] : second ?? [];
+  const { key, ownerId } = (0, import_react8.useMemo)(() => {
+    const depsHash = stableHash(deps);
+    if (isModule2) {
+      const module2 = moduleTag;
+      const baseKey = moduleOptions?.key ?? module2.id ?? "module";
+      return {
+        key: `local:${baseKey}:${componentId}:${depsHash}`,
+        ownerId: module2.id ?? "Module"
+      };
+    }
+    return {
+      key: `local:factory:${componentId}:${depsHash}`,
+      ownerId: void 0
+    };
+  }, [isModule2, moduleTag, moduleOptions?.key, deps, componentId]);
+  const factory = (0, import_react8.useMemo)(() => {
+    if (isModule2) {
+      return createModuleTagFactory(moduleTag, moduleOptions);
+    }
+    const factoryFn = source;
+    return (scope) => factoryFn().pipe(import_effect9.Scope.extend(scope));
+  }, [isModule2, moduleTag, source, moduleOptions]);
+  const moduleRuntime = cache.readSync(key, factory, void 0, ownerId, {
+    entrypoint: "react.useLocalModule",
+    policyMode: runtimeContext.policy.mode,
+    warnSyncBlockingThresholdMs: 5
+  });
+  (0, import_react8.useEffect)(() => cache.retain(key), [cache, key]);
+  const dispatch = (0, import_react8.useMemo)(() => {
+    const base = (action) => {
+      runtime.runFork(moduleRuntime.dispatch(action));
+    };
+    return Object.assign(base, {
+      batch: (actions2) => {
+        runtime.runFork(moduleRuntime.dispatchBatch(actions2));
+      },
+      lowPriority: (action) => {
+        runtime.runFork(moduleRuntime.dispatchLowPriority(action));
+      }
+    });
+  }, [runtime, moduleRuntime]);
+  const tokens = (0, import_react8.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 actions = (0, import_react8.useMemo)(() => makeModuleActions(dispatch), [dispatch]);
+  const dispatchers = (0, import_react8.useMemo)(
+    () => tokens ? makeModuleDispatchers(dispatch, tokens) : makeModuleDispatchers(dispatch),
+    [dispatch, tokens]
+  );
+  return (0, import_react8.useMemo)(
+    () => ({
+      def,
+      runtime: moduleRuntime,
+      dispatch,
+      actions,
+      dispatchers,
+      imports: {
+        get: (module2) => resolveImportedModuleRef(runtime, moduleRuntime, module2)
+      },
+      getState: moduleRuntime.getState,
+      setState: moduleRuntime.setState,
+      actions$: moduleRuntime.actions$,
+      changes: moduleRuntime.changes,
+      ref: moduleRuntime.ref
+    }),
+    [runtime, moduleRuntime, dispatch, actions, dispatchers, def]
+  );
+}
+function createModuleTagFactory(module2, options) {
+  if (!options || options.initial === void 0) {
+    throw new Error("useLocalModule(module, options) \u9700\u8981\u63D0\u4F9B initial \u72B6\u6001");
+  }
+  const logics = options.logics ?? [];
+  return (scope) => import_effect9.Layer.buildWithScope(module2.live(options.initial, ...logics), scope).pipe(
+    import_effect9.Effect.map((context) => {
+      const runtime = import_effect9.Context.get(context, module2);
+      return runtime;
+    })
+  );
+}
+
+// src/internal/hooks/useLayerModule.ts
+var import_react9 = __toESM(require("react"), 1);
+var import_effect10 = require("effect");
+function useLayerModule(module2, layer, deps = []) {
+  const factory = import_react9.default.useCallback(
+    () => import_effect10.Layer.build(layer).pipe(
+      import_effect10.Effect.scoped,
+      import_effect10.Effect.map((context) => import_effect10.Context.get(context, module2))
+    ),
+    // layer/module are typically constants; deps lets callers opt into rebuilding when needed.
+    [layer, module2]
+  );
+  return useLocalModule(factory, deps);
+}
+
+// src/internal/hooks/useDispatch.ts
+var import_react10 = require("react");
+function useDispatch(handle) {
+  const runtime = useRuntime();
+  const moduleRuntime = useModuleRuntime(handle);
+  return (0, import_react10.useMemo)(() => {
+    const base = (action) => {
+      runtime.runFork(moduleRuntime.dispatch(action));
+    };
+    return Object.assign(base, {
+      batch: (actions) => {
+        runtime.runFork(moduleRuntime.dispatchBatch(actions));
+      },
+      lowPriority: (action) => {
+        runtime.runFork(moduleRuntime.dispatchLowPriority(action));
+      }
+    });
+  }, [runtime, moduleRuntime]);
+}
+
+// src/internal/hooks/useModuleList.ts
+var import_react11 = require("react");
+function useModuleList(items, keyFn, factory) {
+  const cache = (0, import_react11.useMemo)(() => /* @__PURE__ */ new Map(), []);
+  const keyFnRef = (0, import_react11.useRef)(keyFn);
+  keyFnRef.current = keyFn;
+  const factoryRef = (0, import_react11.useRef)(factory);
+  factoryRef.current = factory;
+  return (0, import_react11.useMemo)(() => {
+    return items.map((item) => {
+      const key = keyFnRef.current(item);
+      if (!cache.has(key)) {
+        cache.set(key, factoryRef.current(key, item));
+      }
+      return cache.get(key);
+    });
+  }, [items, cache]);
+}
+
+// src/internal/hooks/useImportedModule.ts
+var import_react12 = __toESM(require("react"), 1);
+function useImportedModule(parent, module2) {
+  const runtime = useRuntime();
+  const parentRuntime = useModuleRuntime(parent);
+  return import_react12.default.useMemo(() => resolveImportedModuleRef(runtime, parentRuntime, module2), [runtime, parentRuntime, module2]);
+}
+
+// src/internal/hooks/useProcesses.ts
+var import_react13 = __toESM(require("react"), 1);
+var import_effect11 = require("effect");
+var Logix9 = __toESM(require("@logixjs/core"), 1);
+var ProcessSubtreeRegistry = class {
+  constructor(runtime) {
+    this.runtime = runtime;
+    this.entries = /* @__PURE__ */ new Map();
+  }
+  retain(args) {
+    const existing = this.entries.get(args.key);
+    if (existing) {
+      if (existing.signature !== args.signature) {
+        throw new Error(
+          `[useProcesses] subtreeId "${args.key}" has already been claimed by a different process set. previous="${existing.signature}" current="${args.signature}". Use a different subtreeId or keep the processes list stable for the same subtree.`
+        );
+      }
+      existing.refCount += 1;
+      if (existing.gcTimeout) {
+        clearTimeout(existing.gcTimeout);
+        existing.gcTimeout = void 0;
+      }
+      return () => this.release({ key: args.key, gcTime: args.gcTime });
+    }
+    const scope = import_effect11.Effect.runSync(import_effect11.Scope.make());
+    const entry = {
+      key: args.key,
+      signature: args.signature,
+      scope,
+      refCount: 1
+    };
+    this.entries.set(args.key, entry);
+    args.install(scope);
+    return () => this.release({ key: args.key, gcTime: args.gcTime });
+  }
+  release(args) {
+    const entry = this.entries.get(args.key);
+    if (!entry) return;
+    entry.refCount = Math.max(0, entry.refCount - 1);
+    if (entry.refCount > 0) return;
+    this.scheduleGC(entry, args.gcTime);
+  }
+  scheduleGC(entry, gcTime) {
+    if (entry.gcTimeout) return;
+    if (!Number.isFinite(gcTime)) {
+      return;
+    }
+    const timeoutMs = gcTime <= 0 ? 0 : gcTime;
+    entry.gcTimeout = setTimeout(() => {
+      const current = this.entries.get(entry.key);
+      if (!current || current !== entry) return;
+      if (current.refCount > 0) return;
+      void this.runtime.runPromise(import_effect11.Scope.close(entry.scope, import_effect11.Exit.void)).catch(() => {
+      });
+      this.entries.delete(entry.key);
+    }, timeoutMs);
+  }
+};
+var RUNTIME_PROCESS_REGISTRY = /* @__PURE__ */ new WeakMap();
+var getRegistry = (runtime) => {
+  const existing = RUNTIME_PROCESS_REGISTRY.get(runtime);
+  if (existing) return existing;
+  const created = new ProcessSubtreeRegistry(runtime);
+  RUNTIME_PROCESS_REGISTRY.set(runtime, created);
+  return created;
+};
+var stableProcessSignature = (processes) => {
+  const ids = [];
+  for (let i = 0; i < processes.length; i++) {
+    const def = Logix9.Process.getDefinition(processes[i]);
+    ids.push(def?.processId ?? `legacy#${i}`);
+  }
+  return ids.join("|");
+};
+function useProcesses(processes, options) {
+  const context = (0, import_react13.useContext)(RuntimeContext);
+  if (!context) {
+    throw new RuntimeProviderNotFoundError("useProcesses");
+  }
+  const isDev = (0, import_Env.isDevEnv)();
+  const lastProcessesRef = (0, import_react13.useRef)(null);
+  const shallowEqualProcesses = (a, b) => !!a && !!b && a.length === b.length && a.every((item, idx) => item === b[idx]);
+  (0, import_react13.useEffect)(() => {
+    if (!isDev) return;
+    if (!lastProcessesRef.current) {
+      lastProcessesRef.current = processes;
+      return;
+    }
+    if (lastProcessesRef.current !== processes && !shallowEqualProcesses(lastProcessesRef.current, processes)) {
+      console.warn(
+        "[useProcesses] received a new processes list. Memoize the list (useMemo) to avoid unnecessary install/uninstall churn."
+      );
+    }
+    lastProcessesRef.current = processes;
+  }, [isDev, processes]);
+  const defaultSubtreeId = import_react13.default.useId();
+  const subtreeId = options?.subtreeId ?? `ui:${defaultSubtreeId}`;
+  const signature = (0, import_react13.useMemo)(() => stableProcessSignature(processes), [processes]);
+  const gcTime = options?.gcTime ?? context.reactConfigSnapshot.gcTime;
+  const mode = options?.mode ?? "switch";
+  const deps = options?.deps ? [...options.deps, context.runtime, subtreeId, signature, gcTime, mode] : [context.runtime, subtreeId, signature, gcTime, mode];
+  (0, import_react13.useEffect)(() => {
+    if (!processes || processes.length === 0) {
+      return;
+    }
+    const runtime = context.runtime;
+    const registry = getRegistry(runtime);
+    return registry.retain({
+      key: subtreeId,
+      signature,
+      gcTime,
+      install: (scope) => {
+        const program = import_effect11.Effect.forEach(
+          processes,
+          (process) => Logix9.InternalContracts.installProcess(process, {
+            scope: { type: "uiSubtree", subtreeId },
+            enabled: true,
+            installedAt: "uiSubtree",
+            mode
+          }).pipe(
+            import_effect11.Effect.flatMap((installation) => {
+              if (installation !== void 0) {
+                return import_effect11.Effect.void;
+              }
+              return import_effect11.Effect.forkScoped(process).pipe(import_effect11.Effect.asVoid);
+            }),
+            import_effect11.Effect.catchAll(() => import_effect11.Effect.forkScoped(process).pipe(import_effect11.Effect.asVoid))
+          ),
+          { discard: true }
+        ).pipe(import_effect11.Effect.provideService(import_effect11.Scope.Scope, scope));
+        void runtime.runPromise(program).catch(() => {
+        });
+      }
+    });
+  }, deps);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  shallow,
+  useDispatch,
+  useImportedModule,
+  useLayerModule,
+  useLocalModule,
+  useModule,
+  useModuleList,
+  useProcesses,
+  useRuntime,
+  useSelector
+});