@ai-matrx/summon 0.0.0-stage → 0.1.0

package/dist/react.js

@@ -0,0 +1,718 @@
+"use client";
+
+// src/react/SummonProvider.tsx
+import { useEffect as useEffect2, useMemo, useRef, useState } from "react";
+import { Provider } from "react-redux";
+import { resolvePorts } from "@ai-matrx/summon";
+import { createSummonStore } from "@ai-matrx/summon";
+
+// src/react/context.ts
+import { createContext } from "react";
+var SummonStoreContext = createContext(null);
+SummonStoreContext.displayName = "SummonStoreContext";
+var SummonPortsContext = createContext(null);
+SummonPortsContext.displayName = "SummonPortsContext";
+var SummonConfigContext = createContext(null);
+SummonConfigContext.displayName = "SummonConfigContext";
+
+// src/react/fallbacks.tsx
+import { useEffect } from "react";
+import { Button } from "@ai-matrx/design-system";
+
+// src/react/storeHooks.ts
+import { useContext } from "react";
+import {
+  createDispatchHook,
+  createSelectorHook,
+  createStoreHook
+} from "react-redux";
+import { DEFAULT_PORTS } from "@ai-matrx/summon";
+var useSummonSelector = createSelectorHook(SummonStoreContext).withTypes();
+var useSummonDispatch = createDispatchHook(SummonStoreContext).withTypes();
+var useSummonStore = createStoreHook(SummonStoreContext).withTypes();
+var MISSING_PROVIDER = "[summon] No <SummonProvider> above this component. Wrap the app (or the part that opens overlays) in <SummonProvider>.";
+function useSummonPorts() {
+  const ports = useContext(SummonPortsContext);
+  if (!ports) throw new Error(MISSING_PROVIDER);
+  return ports;
+}
+function useOptionalSummonPorts() {
+  return useContext(SummonPortsContext) ?? DEFAULT_PORTS;
+}
+function useSummonConfig() {
+  const config = useContext(SummonConfigContext);
+  if (!config) throw new Error(MISSING_PROVIDER);
+  return config;
+}
+
+// src/react/fallbacks.tsx
+import { jsx, jsxs } from "react/jsx-runtime";
+function normalizeOverlayError(error) {
+  if (error instanceof Error) {
+    const isChunkLoadError = error.name === "ChunkLoadError" || /Loading chunk [\w-]+ failed|Failed to fetch dynamically imported module|Importing a module script failed/i.test(
+      error.message
+    );
+    return { name: error.name, message: error.message, stack: error.stack ?? null, isChunkLoadError };
+  }
+  return { name: "Error", message: typeof error === "string" ? error : String(error), stack: null, isChunkLoadError: false };
+}
+function OverlayLoadingFallback({ overlayId, label }) {
+  const ports = useSummonPorts();
+  const { stallWarnMs } = useSummonConfig();
+  useEffect(() => {
+    const timer = setTimeout(() => {
+      ports.errors.capture(new Error(`Overlay "${overlayId}" still loading after ${stallWarnMs}ms`), {
+        stage: "overlay-load-stall",
+        overlayId,
+        level: "warning"
+      });
+    }, stallWarnMs);
+    return () => clearTimeout(timer);
+  }, [ports, overlayId, stallWarnMs]);
+  return /* @__PURE__ */ jsx("div", { className: "pointer-events-none fixed inset-0 z-[2147483000] flex items-center justify-center p-4", children: /* @__PURE__ */ jsxs(
+    "div",
+    {
+      role: "status",
+      "aria-label": `Loading ${label}`,
+      className: "pointer-events-auto flex items-center gap-3 rounded-xl border border-border bg-card px-5 py-4 text-sm text-muted-foreground shadow-[var(--elevation-2)]",
+      children: [
+        /* @__PURE__ */ jsx("span", { "aria-hidden": true, className: "size-4 animate-spin rounded-full border-2 border-border border-t-primary" }),
+        /* @__PURE__ */ jsx("span", { children: "Loading\u2026" })
+      ]
+    }
+  ) });
+}
+function OverlayErrorFallback({ label, error, retry, close, extras }) {
+  const e = normalizeOverlayError(error);
+  return /* @__PURE__ */ jsx("div", { className: "pointer-events-none fixed inset-0 z-[2147483001] flex items-center justify-center p-4", children: /* @__PURE__ */ jsxs(
+    "div",
+    {
+      role: "alertdialog",
+      "aria-label": `${label} failed to load`,
+      className: "pointer-events-auto flex max-h-[85dvh] w-full max-w-lg flex-col overflow-hidden rounded-xl border border-destructive bg-card shadow-[var(--elevation-3)]",
+      children: [
+        /* @__PURE__ */ jsxs("div", { className: "border-b border-border px-5 py-4", children: [
+          /* @__PURE__ */ jsxs("h2", { className: "text-sm font-semibold text-foreground", children: [
+            label,
+            " failed to load"
+          ] }),
+          /* @__PURE__ */ jsx("p", { className: "mt-1 text-xs text-muted-foreground", children: e.isChunkLoadError ? "Part of it did not finish loading." : "It hit an error while rendering." })
+        ] }),
+        /* @__PURE__ */ jsx("div", { className: "min-h-0 flex-1 overflow-auto px-5 py-4", children: /* @__PURE__ */ jsxs("div", { className: "rounded-lg bg-muted px-3 py-2 font-mono text-xs text-foreground", children: [
+          /* @__PURE__ */ jsx("span", { className: "text-destructive", children: e.name }),
+          ": ",
+          e.message
+        ] }) }),
+        /* @__PURE__ */ jsxs("div", { className: "flex items-center justify-between gap-2 border-t border-border px-5 py-3", children: [
+          /* @__PURE__ */ jsx("div", { children: extras }),
+          /* @__PURE__ */ jsxs("div", { className: "flex items-center gap-2", children: [
+            /* @__PURE__ */ jsx(Button, { variant: "ghost", size: "sm", onClick: close, children: "Close" }),
+            /* @__PURE__ */ jsx(Button, { variant: "primary", size: "sm", onClick: retry, children: "Try again" }),
+            /* @__PURE__ */ jsx(
+              Button,
+              {
+                variant: "outline",
+                size: "sm",
+                onClick: () => {
+                  if (typeof window !== "undefined") window.location.reload();
+                },
+                children: "Reload page"
+              }
+            )
+          ] })
+        ] })
+      ]
+    }
+  ) });
+}
+
+// src/react/keepAlive.ts
+var KeepAliveRegistry = class {
+  constructor(limit) {
+    this.limit = limit;
+  }
+  limit;
+  order = [];
+  evictors = /* @__PURE__ */ new Map();
+  setLimit(limit) {
+    this.limit = Math.max(0, Math.floor(limit));
+    this.trim();
+  }
+  /** Mark `key` as hidden-alive (most recent). `evict` unmounts it when the cap is exceeded. */
+  retain(key, evict) {
+    this.drop(key);
+    this.order.push(key);
+    this.evictors.set(key, evict);
+    this.trim();
+  }
+  /** `key` reopened or its slot went away: no longer counted. */
+  release(key) {
+    this.drop(key);
+  }
+  size() {
+    return this.order.length;
+  }
+  drop(key) {
+    const at = this.order.indexOf(key);
+    if (at >= 0) this.order.splice(at, 1);
+    this.evictors.delete(key);
+  }
+  trim() {
+    while (this.order.length > this.limit) {
+      const oldest = this.order.shift();
+      if (oldest === void 0) return;
+      const evict = this.evictors.get(oldest);
+      this.evictors.delete(oldest);
+      evict?.();
+    }
+  }
+};
+
+// src/react/loaderCache.ts
+import { lazy } from "react";
+function chunkTimeoutError(key, timeoutMs) {
+  const error = new Error(
+    `Overlay "${key}" render module did not load within ${timeoutMs}ms. The import() did not resolve before the recovery timeout.`
+  );
+  error.name = "ChunkLoadError";
+  return error;
+}
+function raceTimeout(key, real, timeoutMs) {
+  real.catch(() => void 0);
+  let timer;
+  const timeout = new Promise((_, reject) => {
+    timer = setTimeout(() => reject(chunkTimeoutError(key, timeoutMs)), timeoutMs);
+  });
+  return Promise.race([real, timeout]).finally(() => {
+    if (timer !== void 0) clearTimeout(timer);
+  });
+}
+var LoaderCache = class {
+  constructor(options) {
+    this.options = options;
+  }
+  options;
+  entries = /* @__PURE__ */ new Map();
+  create(key, loader, attempt) {
+    const Component2 = lazy(() => {
+      this.options.onImportStart?.(key, attempt);
+      return raceTimeout(key, loader(), this.options.timeoutMs());
+    });
+    return { attempt, Component: Component2 };
+  }
+  /** The current lazy component for `key`, created on first request. */
+  get(key, loader) {
+    const existing = this.entries.get(key);
+    if (existing) return existing;
+    const created = this.create(key, loader, 0);
+    this.entries.set(key, created);
+    return created;
+  }
+  /** Replace `key`'s lazy with a fresh one so the next render re-imports. */
+  retry(key, loader, failedAttempt) {
+    const existing = this.entries.get(key);
+    if (existing && existing.attempt > failedAttempt) return;
+    const next = this.create(key, loader, failedAttempt + 1);
+    this.entries.set(key, next);
+  }
+};
+
+// src/react/SummonProvider.tsx
+import { jsx as jsx2 } from "react/jsx-runtime";
+var DEFAULT_KEEP_ALIVE_LIMIT = 8;
+var DEFAULT_IMPORT_TIMEOUT_MS = 12e3;
+var DEFAULT_STALL_WARN_MS = 1e4;
+function SummonProvider({
+  store,
+  ports,
+  fallbacks,
+  errorReportExtras,
+  renderWrapper,
+  keepAliveLimit = DEFAULT_KEEP_ALIVE_LIMIT,
+  importTimeoutMs = DEFAULT_IMPORT_TIMEOUT_MS,
+  stallWarnMs = DEFAULT_STALL_WARN_MS,
+  children
+}) {
+  const resolvedPorts = useMemo(() => resolvePorts(ports), [ports]);
+  const [privateStore] = useState(() => store ? null : createSummonStore({ ports: resolvedPorts }));
+  const activeStore = store ?? privateStore;
+  const timeoutRef = useRef(importTimeoutMs);
+  timeoutRef.current = importTimeoutMs;
+  const [keepAlive] = useState(() => new KeepAliveRegistry(keepAliveLimit));
+  const [loaders] = useState(() => new LoaderCache({ timeoutMs: () => timeoutRef.current }));
+  useEffect2(() => keepAlive.setLimit(keepAliveLimit), [keepAlive, keepAliveLimit]);
+  const loading = fallbacks?.loading ?? OverlayLoadingFallback;
+  const error = fallbacks?.error ?? OverlayErrorFallback;
+  const config = useMemo(
+    () => ({
+      loadingFallback: loading,
+      errorFallback: error,
+      errorReportExtras: errorReportExtras ?? null,
+      renderWrapper: renderWrapper ?? null,
+      importTimeoutMs,
+      stallWarnMs,
+      keepAlive,
+      loaders
+    }),
+    [loading, error, errorReportExtras, renderWrapper, importTimeoutMs, stallWarnMs, keepAlive, loaders]
+  );
+  return /* @__PURE__ */ jsx2(Provider, { store: activeStore, context: SummonStoreContext, children: /* @__PURE__ */ jsx2(SummonPortsContext.Provider, { value: resolvedPorts, children: /* @__PURE__ */ jsx2(SummonConfigContext.Provider, { value: config, children }) }) });
+}
+
+// src/react/defineOverlay.tsx
+import { useCallback as useCallback2, useEffect as useEffect4, useMemo as useMemo3, useRef as useRef3, useState as useState2 } from "react";
+import {
+  DEFAULT_INSTANCE_ID as DEFAULT_INSTANCE_ID2,
+  instanceKey as toInstanceKey
+} from "@ai-matrx/summon";
+import { selectIsOverlayOpen } from "@ai-matrx/summon";
+
+// src/react/dispatchers.ts
+import { closeOverlay, openOverlay } from "@ai-matrx/summon";
+import { DEFAULT_INSTANCE_ID } from "@ai-matrx/summon";
+function newInstanceId(overlayId) {
+  return `${overlayId}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+}
+function dispatchOpen(dispatch, overlayId, instanceId, data) {
+  dispatch(
+    openOverlay({
+      overlayId,
+      instanceId,
+      data: data ?? null
+    })
+  );
+}
+function dispatchClose(dispatch, overlayId, instanceId = DEFAULT_INSTANCE_ID) {
+  dispatch(closeOverlay({ overlayId, instanceId }));
+}
+
+// src/react/events.ts
+import { createEventChannel, getEventChannel } from "@ai-matrx/summon/handles";
+function openOverlayEventChannel(owner, getHandlers) {
+  const channel = createEventChannel({ owner });
+  channel.subscribe((message) => {
+    const handlers = getHandlers();
+    handlers?.[message.type]?.(message.payload);
+  });
+  return channel.id;
+}
+function emitOverlayEvent(channelId, type, payload) {
+  getEventChannel(channelId)?.emit({ type, payload });
+}
+
+// src/react/instanceBody.tsx
+import { Suspense, useEffect as useEffect3, useMemo as useMemo2, useRef as useRef2 } from "react";
+
+// src/react/OverlayErrorBoundary.tsx
+import { Component } from "react";
+import { jsx as jsx3 } from "react/jsx-runtime";
+var CLEAR = { error: null, hasError: false, componentStack: null };
+var OverlayErrorBoundary = class extends Component {
+  state = CLEAR;
+  static getDerivedStateFromError(error) {
+    return { error, hasError: true };
+  }
+  componentDidCatch(error, info) {
+    const componentStack = info.componentStack ?? null;
+    this.setState({ componentStack });
+    const e = normalizeOverlayError(error);
+    this.props.errors.capture(error, {
+      boundary: "OverlayErrorBoundary",
+      overlayId: this.props.overlayId,
+      instanceId: this.props.instanceId,
+      errorName: e.name,
+      isChunkLoadError: e.isChunkLoadError,
+      componentStack
+    });
+  }
+  retry = () => {
+    this.props.onRetry();
+    this.setState(CLEAR);
+  };
+  render() {
+    const { hasError, error, componentStack } = this.state;
+    if (!hasError) return this.props.children;
+    const { overlayId, instanceId, instanceKey, label, extras, onClose } = this.props;
+    const Fallback = this.props.fallback;
+    const renderedExtras = extras ? extras({ overlayId, instanceId, instanceKey, label, error, componentStack }) : null;
+    return /* @__PURE__ */ jsx3(
+      Fallback,
+      {
+        overlayId,
+        instanceId,
+        label,
+        error,
+        componentStack,
+        retry: this.retry,
+        close: onClose,
+        extras: renderedExtras
+      }
+    );
+  }
+};
+
+// src/react/instance.tsx
+import { createContext as createContext2, useCallback, useContext as useContext2 } from "react";
+import { selectOverlayStateValue, setOverlayStateValue } from "@ai-matrx/summon";
+var OverlayInstanceContext = createContext2(null);
+OverlayInstanceContext.displayName = "OverlayInstanceContext";
+function useOverlayInstance() {
+  const value = useContext2(OverlayInstanceContext);
+  if (!value) {
+    throw new Error("[summon] useOverlayInstance() was called outside a rendered overlay.");
+  }
+  return value;
+}
+function useOptionalOverlayInstance() {
+  return useContext2(OverlayInstanceContext);
+}
+function useOverlayState(name, initial) {
+  const { instanceKey } = useOverlayInstance();
+  const dispatch = useSummonDispatch();
+  const store = useSummonStore();
+  const stored = useSummonSelector((state) => selectOverlayStateValue(state, instanceKey, name));
+  const value = stored === void 0 ? initial : stored;
+  const setValue = useCallback(
+    (next) => {
+      const current = selectOverlayStateValue(store.getState(), instanceKey, name);
+      const previous = current === void 0 ? initial : current;
+      const resolved = typeof next === "function" ? next(previous) : next;
+      dispatch(setOverlayStateValue({ key: instanceKey, name, value: resolved }));
+    },
+    // `initial` is the first-render default, like useState's; its identity never re-binds.
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [dispatch, store, instanceKey, name]
+  );
+  return [value, setValue];
+}
+
+// src/react/instanceBody.tsx
+import { jsx as jsx4 } from "react/jsx-runtime";
+function LazyRender({ overlayId, instanceId, data, hidden, close, render, attemptRef }) {
+  const { loaders } = useSummonConfig();
+  const entry = loaders.get(overlayId, render);
+  attemptRef.current = entry.attempt;
+  const Render = entry.Component;
+  return /* @__PURE__ */ jsx4(Render, { overlayId, instanceId, data, isOpen: true, close, hidden });
+}
+function createInstanceBody(overlayId, label, render, parse, refusable) {
+  function OverlayInstanceBody({ instanceId, instanceKey, data, hidden, close }) {
+    const config = useSummonConfig();
+    const ports = useSummonPorts();
+    const attemptRef = useRef2(0);
+    const parsed = useMemo2(() => parse(data), [data]);
+    const refused = refusable && parsed === null;
+    useEffect3(() => {
+      if (!refused) return;
+      if (process.env.NODE_ENV !== "production") {
+        ports.notify.warn(`Overlay "${overlayId}" was opened with data its parse() refused; closing it.`, {
+          id: `overlays-parse-${instanceKey}`
+        });
+      }
+      close();
+    }, [refused, ports, instanceKey, close]);
+    const instance = useMemo2(
+      () => ({ overlayId, instanceId, instanceKey, close, hidden, rawData: data }),
+      [instanceId, instanceKey, close, hidden, data]
+    );
+    if (refused) return null;
+    const context = { overlayId, instanceId, instanceKey, label };
+    const body = /* @__PURE__ */ jsx4(
+      OverlayErrorBoundary,
+      {
+        overlayId,
+        instanceId,
+        instanceKey,
+        label,
+        errors: ports.errors,
+        fallback: config.errorFallback,
+        extras: config.errorReportExtras,
+        onRetry: () => config.loaders.retry(overlayId, render, attemptRef.current),
+        onClose: close,
+        children: /* @__PURE__ */ jsx4(Suspense, { fallback: /* @__PURE__ */ jsx4(config.loadingFallback, { overlayId, label }), children: /* @__PURE__ */ jsx4(
+          LazyRender,
+          {
+            overlayId,
+            instanceId,
+            data: parsed,
+            hidden,
+            close,
+            render,
+            attemptRef
+          }
+        ) })
+      }
+    );
+    return /* @__PURE__ */ jsx4(OverlayInstanceContext.Provider, { value: instance, children: config.renderWrapper ? config.renderWrapper(body, context) : body });
+  }
+  OverlayInstanceBody.displayName = `Overlay(${overlayId})`;
+  return OverlayInstanceBody;
+}
+
+// src/react/defineOverlay.tsx
+var CALLBACK_GROUP_KEY = "callbackGroupId";
+function openWith(dispatch, id, multi, options) {
+  const instanceId = options?.instanceId ?? (multi ? newInstanceId(id) : DEFAULT_INSTANCE_ID2);
+  const key = toInstanceKey(id, instanceId);
+  const data = {};
+  const given = options?.data;
+  if (typeof given === "object" && given !== null) Object.assign(data, given);
+  const handlers = options?.handlers;
+  if (handlers) data[CALLBACK_GROUP_KEY] = openOverlayEventChannel(key, () => handlers);
+  dispatchOpen(dispatch, id, instanceId, data);
+  return { overlayId: id, instanceId, close: () => dispatchClose(dispatch, id, instanceId) };
+}
+function dataSignature(data) {
+  try {
+    return JSON.stringify(data, (_key, value) => typeof value === "function" ? void 0 : value);
+  } catch {
+    return String(Date.now());
+  }
+}
+function defineOverlay() {
+  return function define(spec) {
+    const id = spec.id;
+    const multi = spec.instance === "multi";
+    const parse = spec.parse ?? ((raw) => raw);
+    const Body = createInstanceBody(id, spec.label, spec.render, parse, spec.parse !== void 0);
+    const meta = spec;
+    function useSummon() {
+      const dispatch = useSummonDispatch();
+      return useCallback2((options) => openWith(dispatch, id, multi, options), [dispatch]);
+    }
+    function useIsOpen(instanceId = DEFAULT_INSTANCE_ID2) {
+      return useSummonSelector((state) => selectIsOverlayOpen(state, id, instanceId));
+    }
+    function useClose() {
+      const dispatch = useSummonDispatch();
+      return useCallback2((instanceId) => dispatchClose(dispatch, id, instanceId ?? DEFAULT_INSTANCE_ID2), [dispatch]);
+    }
+    function useEmit() {
+      const instance = useOptionalOverlayInstance();
+      const channelId = instance?.overlayId === id ? instance.rawData?.[CALLBACK_GROUP_KEY] : void 0;
+      return useCallback2(
+        (event, payload) => {
+          if (typeof channelId === "string") emitOverlayEvent(channelId, event, payload);
+        },
+        [channelId]
+      );
+    }
+    function Controller(props) {
+      const dispatch = useSummonDispatch();
+      const [ownInstanceId] = useState2(() => multi ? newInstanceId(id) : DEFAULT_INSTANCE_ID2);
+      const instanceId = props.instanceId ?? ownInstanceId;
+      const handlersRef = useRef3(props.handlers);
+      handlersRef.current = props.handlers;
+      const hasHandlers = props.handlers !== void 0;
+      const data = useMemo3(() => {
+        const out = {};
+        for (const [key, value] of Object.entries(props)) {
+          if (key !== "instanceId" && key !== "handlers") out[key] = value;
+        }
+        return out;
+      }, [props]);
+      const signature = dataSignature(data);
+      const dataRef = useRef3(data);
+      dataRef.current = data;
+      useEffect4(() => {
+        const key = toInstanceKey(id, instanceId);
+        const open = { ...dataRef.current };
+        if (hasHandlers) open[CALLBACK_GROUP_KEY] = openOverlayEventChannel(key, () => handlersRef.current);
+        dispatchOpen(dispatch, id, instanceId, open);
+        return () => dispatchClose(dispatch, id, instanceId);
+      }, [dispatch, instanceId, signature, hasHandlers]);
+      return null;
+    }
+    Controller.displayName = `${id}Controller`;
+    return {
+      ...spec,
+      id,
+      label: spec.label,
+      instance: multi ? "multi" : "single",
+      keepAlive: spec.keepAlive ?? "none",
+      meta,
+      Body,
+      useSummon,
+      Controller,
+      useIsOpen,
+      useClose,
+      useEmit
+    };
+  };
+}
+
+// src/react/SummonHost.tsx
+import { Activity, useCallback as useCallback3, useEffect as useEffect5, useRef as useRef4, useState as useState3 } from "react";
+import { releaseOverlayInstance } from "@ai-matrx/summon";
+import { registerOverlayMeta } from "@ai-matrx/summon";
+import { closeOverlaysBoundToPage, overlayIdsBoundToPage, selectOpenInstances } from "@ai-matrx/summon";
+import { instanceKey as toInstanceKey2 } from "@ai-matrx/summon";
+import { Fragment, jsx as jsx5 } from "react/jsx-runtime";
+function asRawData(data) {
+  return typeof data === "object" && data !== null && !Array.isArray(data) ? data : null;
+}
+function sameInstances(a, b) {
+  if (a === b) return true;
+  if (a.length !== b.length) return false;
+  for (let i = 0; i < a.length; i += 1) {
+    const x = a[i];
+    const y = b[i];
+    if (!x || !y || x.instanceId !== y.instanceId || x.data !== y.data) return false;
+  }
+  return true;
+}
+var NO_RETAINED = /* @__PURE__ */ new Map();
+function useCloseOnNavigation() {
+  const ports = useSummonPorts();
+  const dispatch = useSummonDispatch();
+  useEffect5(() => {
+    const router = ports.router;
+    let previous = router.pathname();
+    return router.subscribe(() => {
+      const next = router.pathname();
+      if (next === previous) return;
+      previous = next;
+      const overlayIds = overlayIdsBoundToPage();
+      if (overlayIds.length > 0) dispatch(closeOverlaysBoundToPage({ overlayIds }));
+    });
+  }, [ports, dispatch]);
+}
+function InstanceSlot({ definition, instanceId, data, hidden }) {
+  const dispatch = useSummonDispatch();
+  const close = useCallback3(() => dispatchClose(dispatch, definition.id, instanceId), [dispatch, definition.id, instanceId]);
+  const Body = definition.Body;
+  return /* @__PURE__ */ jsx5(Body, { instanceId, instanceKey: toInstanceKey2(definition.id, instanceId), data, hidden, close });
+}
+function DefinitionSlot({ definition }) {
+  const { keepAlive } = useSummonConfig();
+  const dispatch = useSummonDispatch();
+  const open = useSummonSelector((state) => selectOpenInstances(state, definition.id), sameInstances);
+  const keepHidden = definition.keepAlive === "hidden";
+  const [retained, setRetained] = useState3(NO_RETAINED);
+  const [previousOpen, setPreviousOpen] = useState3(open);
+  if (previousOpen !== open) {
+    setPreviousOpen(open);
+    if (keepHidden) {
+      const openIds = new Set(open.map((instance) => instance.instanceId));
+      const next = new Map(retained);
+      for (const instance of previousOpen) {
+        if (!openIds.has(instance.instanceId)) next.set(instance.instanceId, asRawData(instance.data));
+      }
+      for (const id of openIds) next.delete(id);
+      setRetained(next);
+    }
+  }
+  const registered = useRef4(/* @__PURE__ */ new Set());
+  useEffect5(() => {
+    const seen = registered.current;
+    for (const instanceId of retained.keys()) {
+      if (seen.has(instanceId)) continue;
+      seen.add(instanceId);
+      const key = toInstanceKey2(definition.id, instanceId);
+      keepAlive.retain(key, () => {
+        seen.delete(instanceId);
+        releaseOverlayInstance(dispatch, key);
+        setRetained((current) => {
+          if (!current.has(instanceId)) return current;
+          const next = new Map(current);
+          next.delete(instanceId);
+          return next;
+        });
+      });
+    }
+    for (const instanceId of [...seen]) {
+      if (retained.has(instanceId)) continue;
+      seen.delete(instanceId);
+      keepAlive.release(toInstanceKey2(definition.id, instanceId));
+    }
+  }, [retained, keepAlive, definition.id, dispatch]);
+  useEffect5(() => {
+    const seen = registered.current;
+    return () => {
+      for (const instanceId of seen) {
+        const key = toInstanceKey2(definition.id, instanceId);
+        keepAlive.release(key);
+        releaseOverlayInstance(dispatch, key);
+      }
+      seen.clear();
+    };
+  }, [keepAlive, definition.id, dispatch]);
+  if (open.length === 0 && retained.size === 0) return null;
+  const nodes = [];
+  for (const instance of open) {
+    const node = /* @__PURE__ */ jsx5(InstanceSlot, { definition, instanceId: instance.instanceId, data: asRawData(instance.data), hidden: false }, instance.instanceId);
+    nodes.push(
+      keepHidden ? /* @__PURE__ */ jsx5(Activity, { mode: "visible", children: node }, instance.instanceId) : node
+    );
+  }
+  if (keepHidden) {
+    for (const [instanceId, data] of retained) {
+      nodes.push(
+        /* @__PURE__ */ jsx5(Activity, { mode: "hidden", children: /* @__PURE__ */ jsx5(InstanceSlot, { definition, instanceId, data, hidden: true }, instanceId) }, instanceId)
+      );
+    }
+  }
+  return /* @__PURE__ */ jsx5(Fragment, { children: nodes });
+}
+function SummonHost({ definitions }) {
+  const registeredFor = useRef4(null);
+  if (registeredFor.current !== definitions) {
+    registerOverlayMeta(definitions.map((definition) => definition.meta));
+    registeredFor.current = definitions;
+  }
+  useCloseOnNavigation();
+  return /* @__PURE__ */ jsx5(Fragment, { children: definitions.map((definition) => /* @__PURE__ */ jsx5(DefinitionSlot, { definition }, definition.id)) });
+}
+
+// src/react/hooks.ts
+import { useCallback as useCallback4 } from "react";
+import { getOverlayMeta } from "@ai-matrx/summon";
+import { selectIsOverlayOpen as selectIsOverlayOpen2 } from "@ai-matrx/summon";
+import { DEFAULT_INSTANCE_ID as DEFAULT_INSTANCE_ID3 } from "@ai-matrx/summon";
+function useIsOverlayOpen(overlayId, instanceId = DEFAULT_INSTANCE_ID3) {
+  return useSummonSelector((state) => selectIsOverlayOpen2(state, overlayId, instanceId));
+}
+function useOpenOverlay(overlayId) {
+  const dispatch = useSummonDispatch();
+  return useCallback4(
+    (options) => {
+      const multi = getOverlayMeta(overlayId)?.instance === "multi";
+      const instanceId = options?.instanceId ?? (multi ? newInstanceId(overlayId) : DEFAULT_INSTANCE_ID3);
+      dispatchOpen(dispatch, overlayId, instanceId, options?.data ?? null);
+      return { overlayId, instanceId, close: () => dispatchClose(dispatch, overlayId, instanceId) };
+    },
+    [dispatch, overlayId]
+  );
+}
+function useCloseOverlay(overlayId, instanceId = DEFAULT_INSTANCE_ID3) {
+  const dispatch = useSummonDispatch();
+  return useCallback4(() => dispatchClose(dispatch, overlayId, instanceId), [dispatch, overlayId, instanceId]);
+}
+export {
+  CALLBACK_GROUP_KEY,
+  DEFAULT_IMPORT_TIMEOUT_MS,
+  DEFAULT_KEEP_ALIVE_LIMIT,
+  DEFAULT_STALL_WARN_MS,
+  OverlayErrorBoundary,
+  OverlayErrorFallback,
+  OverlayLoadingFallback,
+  SummonHost,
+  SummonProvider,
+  SummonStoreContext,
+  chunkTimeoutError,
+  defineOverlay,
+  normalizeOverlayError,
+  useCloseOnNavigation,
+  useCloseOverlay,
+  useIsOverlayOpen,
+  useOpenOverlay,
+  useOptionalOverlayInstance,
+  useOptionalSummonPorts,
+  useOverlayInstance,
+  useOverlayState,
+  useSummonDispatch,
+  useSummonPorts,
+  useSummonSelector,
+  useSummonStore
+};
+//# sourceMappingURL=react.js.map