@ai-matrx/summon 0.0.0 → 0.1.1

package/dist/react.cjs

@@ -0,0 +1,738 @@
+"use client";
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/react.ts
+var react_exports = {};
+__export(react_exports, {
+  CALLBACK_GROUP_KEY: () => CALLBACK_GROUP_KEY,
+  DEFAULT_IMPORT_TIMEOUT_MS: () => DEFAULT_IMPORT_TIMEOUT_MS,
+  DEFAULT_KEEP_ALIVE_LIMIT: () => DEFAULT_KEEP_ALIVE_LIMIT,
+  DEFAULT_STALL_WARN_MS: () => DEFAULT_STALL_WARN_MS,
+  OverlayErrorBoundary: () => OverlayErrorBoundary,
+  OverlayErrorFallback: () => OverlayErrorFallback,
+  OverlayLoadingFallback: () => OverlayLoadingFallback,
+  SummonHost: () => SummonHost,
+  SummonProvider: () => SummonProvider,
+  SummonStoreContext: () => SummonStoreContext,
+  chunkTimeoutError: () => chunkTimeoutError,
+  defineOverlay: () => defineOverlay,
+  normalizeOverlayError: () => normalizeOverlayError,
+  useCloseOnNavigation: () => useCloseOnNavigation,
+  useCloseOverlay: () => useCloseOverlay,
+  useIsOverlayOpen: () => useIsOverlayOpen,
+  useOpenOverlay: () => useOpenOverlay,
+  useOptionalOverlayInstance: () => useOptionalOverlayInstance,
+  useOptionalSummonPorts: () => useOptionalSummonPorts,
+  useOptionalSummonStore: () => useOptionalSummonStore,
+  useOverlayInstance: () => useOverlayInstance,
+  useOverlayState: () => useOverlayState,
+  useSummonDispatch: () => useSummonDispatch,
+  useSummonPorts: () => useSummonPorts,
+  useSummonSelector: () => useSummonSelector,
+  useSummonStore: () => useSummonStore
+});
+module.exports = __toCommonJS(react_exports);
+
+// src/react/SummonProvider.tsx
+var import_react5 = require("react");
+var import_react_redux2 = require("react-redux");
+var import_summon2 = require("@ai-matrx/summon");
+var import_summon3 = require("@ai-matrx/summon");
+
+// src/react/context.ts
+var import_react = require("react");
+var SummonStoreContext = (0, import_react.createContext)(null);
+SummonStoreContext.displayName = "SummonStoreContext";
+var SummonPortsContext = (0, import_react.createContext)(null);
+SummonPortsContext.displayName = "SummonPortsContext";
+var SummonConfigContext = (0, import_react.createContext)(null);
+SummonConfigContext.displayName = "SummonConfigContext";
+
+// src/react/fallbacks.tsx
+var import_react3 = require("react");
+var import_design_system = require("@ai-matrx/design-system");
+
+// src/react/storeHooks.ts
+var import_react2 = require("react");
+var import_react_redux = require("react-redux");
+var import_summon = require("@ai-matrx/summon");
+var useSummonSelector = (0, import_react_redux.createSelectorHook)(SummonStoreContext).withTypes();
+var useSummonDispatch = (0, import_react_redux.createDispatchHook)(SummonStoreContext).withTypes();
+var useSummonStore = (0, import_react_redux.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 = (0, import_react2.useContext)(SummonPortsContext);
+  if (!ports) throw new Error(MISSING_PROVIDER);
+  return ports;
+}
+function useOptionalSummonPorts() {
+  return (0, import_react2.useContext)(SummonPortsContext) ?? import_summon.DEFAULT_PORTS;
+}
+function useOptionalSummonStore() {
+  const context = (0, import_react2.useContext)(SummonStoreContext);
+  return context ? context.store : null;
+}
+function useSummonConfig() {
+  const config = (0, import_react2.useContext)(SummonConfigContext);
+  if (!config) throw new Error(MISSING_PROVIDER);
+  return config;
+}
+
+// src/react/fallbacks.tsx
+var import_jsx_runtime = require("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();
+  (0, import_react3.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__ */ (0, import_jsx_runtime.jsx)("div", { className: "pointer-events-none fixed inset-0 z-[2147483000] flex items-center justify-center p-4", children: /* @__PURE__ */ (0, import_jsx_runtime.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__ */ (0, import_jsx_runtime.jsx)("span", { "aria-hidden": true, className: "size-4 animate-spin rounded-full border-2 border-border border-t-primary" }),
+        /* @__PURE__ */ (0, import_jsx_runtime.jsx)("span", { children: "Loading\u2026" })
+      ]
+    }
+  ) });
+}
+function OverlayErrorFallback({ label, error, retry, close, extras }) {
+  const e = normalizeOverlayError(error);
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { className: "pointer-events-none fixed inset-0 z-[2147483001] flex items-center justify-center p-4", children: /* @__PURE__ */ (0, import_jsx_runtime.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__ */ (0, import_jsx_runtime.jsxs)("div", { className: "border-b border-border px-5 py-4", children: [
+          /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("h2", { className: "text-sm font-semibold text-foreground", children: [
+            label,
+            " failed to load"
+          ] }),
+          /* @__PURE__ */ (0, import_jsx_runtime.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__ */ (0, import_jsx_runtime.jsx)("div", { className: "min-h-0 flex-1 overflow-auto px-5 py-4", children: /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("div", { className: "rounded-lg bg-muted px-3 py-2 font-mono text-xs text-foreground", children: [
+          /* @__PURE__ */ (0, import_jsx_runtime.jsx)("span", { className: "text-destructive", children: e.name }),
+          ": ",
+          e.message
+        ] }) }),
+        /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("div", { className: "flex items-center justify-between gap-2 border-t border-border px-5 py-3", children: [
+          /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { children: extras }),
+          /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("div", { className: "flex items-center gap-2", children: [
+            /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_design_system.Button, { variant: "ghost", size: "sm", onClick: close, children: "Close" }),
+            /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_design_system.Button, { variant: "primary", size: "sm", onClick: retry, children: "Try again" }),
+            /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+              import_design_system.Button,
+              {
+                variant: "outline",
+                size: "sm",
+                onClick: () => {
+                  if (typeof window !== "undefined") window.location.reload();
+                },
+                children: "Reload page"
+              }
+            )
+          ] })
+        ] })
+      ]
+    }
+  ) });
+}
+
+// src/react/keepAlive.ts
+var KeepAliveRegistry = class {
+  order = [];
+  evictors = /* @__PURE__ */ new Map();
+  limit;
+  constructor(limit) {
+    this.limit = limit;
+  }
+  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
+var import_react4 = require("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 {
+  entries = /* @__PURE__ */ new Map();
+  options;
+  constructor(options) {
+    this.options = options;
+  }
+  create(key, loader, attempt) {
+    const Component2 = (0, import_react4.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
+var import_jsx_runtime2 = require("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 = (0, import_react5.useMemo)(() => (0, import_summon2.resolvePorts)(ports), [ports]);
+  const [privateStore] = (0, import_react5.useState)(() => store ? null : (0, import_summon3.createSummonStore)({ ports: resolvedPorts }));
+  const activeStore = store ?? privateStore;
+  const timeoutRef = (0, import_react5.useRef)(importTimeoutMs);
+  timeoutRef.current = importTimeoutMs;
+  const [keepAlive] = (0, import_react5.useState)(() => new KeepAliveRegistry(keepAliveLimit));
+  const [loaders] = (0, import_react5.useState)(() => new LoaderCache({ timeoutMs: () => timeoutRef.current }));
+  (0, import_react5.useEffect)(() => keepAlive.setLimit(keepAliveLimit), [keepAlive, keepAliveLimit]);
+  const loading = fallbacks?.loading ?? OverlayLoadingFallback;
+  const error = fallbacks?.error ?? OverlayErrorFallback;
+  const config = (0, import_react5.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__ */ (0, import_jsx_runtime2.jsx)(import_react_redux2.Provider, { store: activeStore, context: SummonStoreContext, children: /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(SummonPortsContext.Provider, { value: resolvedPorts, children: /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(SummonConfigContext.Provider, { value: config, children }) }) });
+}
+
+// src/react/defineOverlay.tsx
+var import_react9 = require("react");
+var import_summon7 = require("@ai-matrx/summon");
+var import_summon8 = require("@ai-matrx/summon");
+
+// src/react/dispatchers.ts
+var import_summon4 = require("@ai-matrx/summon");
+var import_summon5 = require("@ai-matrx/summon");
+function newInstanceId(overlayId) {
+  return `${overlayId}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+}
+function dispatchOpen(dispatch, overlayId, instanceId, data) {
+  dispatch(
+    (0, import_summon4.openOverlay)({
+      overlayId,
+      instanceId,
+      data: data ?? null
+    })
+  );
+}
+function dispatchClose(dispatch, overlayId, instanceId = import_summon5.DEFAULT_INSTANCE_ID) {
+  dispatch((0, import_summon4.closeOverlay)({ overlayId, instanceId }));
+}
+
+// src/react/events.ts
+var import_handles = require("@ai-matrx/summon/handles");
+function openOverlayEventChannel(owner, getHandlers) {
+  const channel = (0, import_handles.createEventChannel)({ owner });
+  channel.subscribe((message) => {
+    const handlers = getHandlers();
+    handlers?.[message.type]?.(message.payload);
+  });
+  return channel.id;
+}
+function emitOverlayEvent(channelId, type, payload) {
+  (0, import_handles.getEventChannel)(channelId)?.emit({ type, payload });
+}
+
+// src/react/instanceBody.tsx
+var import_react8 = require("react");
+
+// src/react/OverlayErrorBoundary.tsx
+var import_react6 = require("react");
+var import_jsx_runtime3 = require("react/jsx-runtime");
+var CLEAR = { error: null, hasError: false, componentStack: null };
+var OverlayErrorBoundary = class extends import_react6.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__ */ (0, import_jsx_runtime3.jsx)(
+      Fallback,
+      {
+        overlayId,
+        instanceId,
+        label,
+        error,
+        componentStack,
+        retry: this.retry,
+        close: onClose,
+        extras: renderedExtras
+      }
+    );
+  }
+};
+
+// src/react/instance.tsx
+var import_react7 = require("react");
+var import_summon6 = require("@ai-matrx/summon");
+var OverlayInstanceContext = (0, import_react7.createContext)(null);
+OverlayInstanceContext.displayName = "OverlayInstanceContext";
+function useOverlayInstance() {
+  const value = (0, import_react7.useContext)(OverlayInstanceContext);
+  if (!value) {
+    throw new Error("[summon] useOverlayInstance() was called outside a rendered overlay.");
+  }
+  return value;
+}
+function useOptionalOverlayInstance() {
+  return (0, import_react7.useContext)(OverlayInstanceContext);
+}
+function useOverlayState(name, initial) {
+  const { instanceKey } = useOverlayInstance();
+  const dispatch = useSummonDispatch();
+  const store = useSummonStore();
+  const stored = useSummonSelector((state) => (0, import_summon6.selectOverlayStateValue)(state, instanceKey, name));
+  const value = stored === void 0 ? initial : stored;
+  const setValue = (0, import_react7.useCallback)(
+    (next) => {
+      const current = (0, import_summon6.selectOverlayStateValue)(store.getState(), instanceKey, name);
+      const previous = current === void 0 ? initial : current;
+      const resolved = typeof next === "function" ? next(previous) : next;
+      dispatch((0, import_summon6.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
+var import_jsx_runtime4 = require("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__ */ (0, import_jsx_runtime4.jsx)(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 = (0, import_react8.useRef)(0);
+    const parsed = (0, import_react8.useMemo)(() => parse(data), [data]);
+    const refused = refusable && parsed === null;
+    (0, import_react8.useEffect)(() => {
+      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 = (0, import_react8.useMemo)(
+      () => ({ 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__ */ (0, import_jsx_runtime4.jsx)(
+      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__ */ (0, import_jsx_runtime4.jsx)(import_react8.Suspense, { fallback: /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(config.loadingFallback, { overlayId, label }), children: /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(
+          LazyRender,
+          {
+            overlayId,
+            instanceId,
+            data: parsed,
+            hidden,
+            close,
+            render,
+            attemptRef
+          }
+        ) })
+      }
+    );
+    return /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(OverlayInstanceContext.Provider, { value: instance, children: config.renderWrapper ? config.renderWrapper(body, context) : body });
+  }
+  OverlayInstanceBody.displayName = `Overlay(${overlayId})`;
+  return (0, import_react8.memo)(OverlayInstanceBody);
+}
+
+// src/react/defineOverlay.tsx
+var CALLBACK_GROUP_KEY = "callbackGroupId";
+function openWith(dispatch, id, multi, options) {
+  const instanceId = options?.instanceId ?? (multi ? newInstanceId(id) : import_summon7.DEFAULT_INSTANCE_ID);
+  const key = (0, import_summon7.instanceKey)(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 (0, import_react9.useCallback)((options) => openWith(dispatch, id, multi, options), [dispatch]);
+    }
+    function useIsOpen(instanceId = import_summon7.DEFAULT_INSTANCE_ID) {
+      return useSummonSelector((state) => (0, import_summon8.selectIsOverlayOpen)(state, id, instanceId));
+    }
+    function useClose() {
+      const dispatch = useSummonDispatch();
+      return (0, import_react9.useCallback)((instanceId) => dispatchClose(dispatch, id, instanceId ?? import_summon7.DEFAULT_INSTANCE_ID), [dispatch]);
+    }
+    function useEmit() {
+      const instance = useOptionalOverlayInstance();
+      const channelId = instance?.overlayId === id ? instance.rawData?.[CALLBACK_GROUP_KEY] : void 0;
+      return (0, import_react9.useCallback)(
+        (event, payload) => {
+          if (typeof channelId === "string") emitOverlayEvent(channelId, event, payload);
+        },
+        [channelId]
+      );
+    }
+    function Controller(props) {
+      const dispatch = useSummonDispatch();
+      const [ownInstanceId] = (0, import_react9.useState)(() => multi ? newInstanceId(id) : import_summon7.DEFAULT_INSTANCE_ID);
+      const instanceId = props.instanceId ?? ownInstanceId;
+      const handlersRef = (0, import_react9.useRef)(props.handlers);
+      handlersRef.current = props.handlers;
+      const hasHandlers = props.handlers !== void 0;
+      const data = (0, import_react9.useMemo)(() => {
+        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 = (0, import_react9.useRef)(data);
+      dataRef.current = data;
+      (0, import_react9.useEffect)(() => {
+        const key = (0, import_summon7.instanceKey)(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
+var import_react10 = require("react");
+var import_summon9 = require("@ai-matrx/summon");
+var import_summon10 = require("@ai-matrx/summon");
+var import_summon11 = require("@ai-matrx/summon");
+var import_summon12 = require("@ai-matrx/summon");
+var import_jsx_runtime5 = require("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();
+  (0, import_react10.useEffect)(() => {
+    const router = ports.router;
+    let previous = router.pathname();
+    return router.subscribe(() => {
+      const next = router.pathname();
+      if (next === previous) return;
+      previous = next;
+      const overlayIds = (0, import_summon11.overlayIdsBoundToPage)();
+      if (overlayIds.length > 0) dispatch((0, import_summon11.closeOverlaysBoundToPage)({ overlayIds }));
+    });
+  }, [ports, dispatch]);
+}
+var InstanceSlot = (0, import_react10.memo)(function InstanceSlot2({ definition, instanceId, data, hidden }) {
+  const dispatch = useSummonDispatch();
+  const close = (0, import_react10.useCallback)(() => dispatchClose(dispatch, definition.id, instanceId), [dispatch, definition.id, instanceId]);
+  const Body = definition.Body;
+  return /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(Body, { instanceId, instanceKey: (0, import_summon12.instanceKey)(definition.id, instanceId), data, hidden, close });
+});
+var DefinitionSlot = (0, import_react10.memo)(function DefinitionSlot2({ definition }) {
+  const { keepAlive } = useSummonConfig();
+  const dispatch = useSummonDispatch();
+  const open = useSummonSelector((state) => (0, import_summon11.selectOpenInstances)(state, definition.id), sameInstances);
+  const keepHidden = definition.keepAlive === "hidden";
+  const [retained, setRetained] = (0, import_react10.useState)(NO_RETAINED);
+  const [previousOpen, setPreviousOpen] = (0, import_react10.useState)(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 = (0, import_react10.useRef)(/* @__PURE__ */ new Set());
+  (0, import_react10.useEffect)(() => {
+    const seen = registered.current;
+    for (const instanceId of retained.keys()) {
+      if (seen.has(instanceId)) continue;
+      seen.add(instanceId);
+      const key = (0, import_summon12.instanceKey)(definition.id, instanceId);
+      keepAlive.retain(key, () => {
+        seen.delete(instanceId);
+        (0, import_summon9.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((0, import_summon12.instanceKey)(definition.id, instanceId));
+    }
+  }, [retained, keepAlive, definition.id, dispatch]);
+  (0, import_react10.useEffect)(() => {
+    const seen = registered.current;
+    return () => {
+      for (const instanceId of seen) {
+        const key = (0, import_summon12.instanceKey)(definition.id, instanceId);
+        keepAlive.release(key);
+        (0, import_summon9.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__ */ (0, import_jsx_runtime5.jsx)(InstanceSlot, { definition, instanceId: instance.instanceId, data: asRawData(instance.data), hidden: false }, instance.instanceId);
+    nodes.push(
+      keepHidden ? /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(import_react10.Activity, { mode: "visible", children: node }, instance.instanceId) : node
+    );
+  }
+  if (keepHidden) {
+    for (const [instanceId, data] of retained) {
+      nodes.push(
+        /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(import_react10.Activity, { mode: "hidden", children: /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(InstanceSlot, { definition, instanceId, data, hidden: true }, instanceId) }, instanceId)
+      );
+    }
+  }
+  return /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(import_jsx_runtime5.Fragment, { children: nodes });
+});
+function SummonHost({ definitions }) {
+  const registeredFor = (0, import_react10.useRef)(null);
+  if (registeredFor.current !== definitions) {
+    (0, import_summon10.registerOverlayMeta)(definitions.map((definition) => definition.meta));
+    registeredFor.current = definitions;
+  }
+  useCloseOnNavigation();
+  return /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(import_jsx_runtime5.Fragment, { children: definitions.map((definition) => /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(DefinitionSlot, { definition }, definition.id)) });
+}
+
+// src/react/hooks.ts
+var import_react11 = require("react");
+var import_summon13 = require("@ai-matrx/summon");
+var import_summon14 = require("@ai-matrx/summon");
+var import_summon15 = require("@ai-matrx/summon");
+function useIsOverlayOpen(overlayId, instanceId = import_summon15.DEFAULT_INSTANCE_ID) {
+  return useSummonSelector((state) => (0, import_summon14.selectIsOverlayOpen)(state, overlayId, instanceId));
+}
+function useOpenOverlay(overlayId) {
+  const dispatch = useSummonDispatch();
+  return (0, import_react11.useCallback)(
+    (options) => {
+      const multi = (0, import_summon13.getOverlayMeta)(overlayId)?.instance === "multi";
+      const instanceId = options?.instanceId ?? (multi ? newInstanceId(overlayId) : import_summon15.DEFAULT_INSTANCE_ID);
+      dispatchOpen(dispatch, overlayId, instanceId, options?.data ?? null);
+      return { overlayId, instanceId, close: () => dispatchClose(dispatch, overlayId, instanceId) };
+    },
+    [dispatch, overlayId]
+  );
+}
+function useCloseOverlay(overlayId, instanceId = import_summon15.DEFAULT_INSTANCE_ID) {
+  const dispatch = useSummonDispatch();
+  return (0, import_react11.useCallback)(() => dispatchClose(dispatch, overlayId, instanceId), [dispatch, overlayId, instanceId]);
+}
+//# sourceMappingURL=react.cjs.map