@avgz/react-contract-renderer 0.1.0

package/dist/index.cjs

@@ -0,0 +1,1010 @@
+"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/index.ts
+var index_exports = {};
+__export(index_exports, {
+  RenderSession: () => RenderSession,
+  Subject: () => Subject,
+  cleanup: () => cleanup,
+  getComponentRenderer: () => getComponentRenderer
+});
+module.exports = __toCommonJS(index_exports);
+var import_react2 = require("react");
+
+// src/mount.ts
+var React = __toESM(require("react"), 1);
+
+// src/adapters/dom.ts
+function selectDOMReactVersion(version3) {
+  const match = /^(17|18|19)\.(\d+)\.(\d+)$/.exec(version3);
+  const major = Number(match?.[1]);
+  const minor = Number(match?.[2]);
+  const patch = Number(match?.[3]);
+  if (major === 17 && minor === 0 && patch === 2) return 17;
+  if (major === 18 && (minor === 2 || minor === 3)) return 18;
+  if (major === 19 && minor >= 0 && minor <= 3) return 19;
+  throw new Error(
+    `Unsupported React version ${version3}. Mount supports stable React 17.0.2, 18.2\u201318.3, and 19.0\u201319.3.`
+  );
+}
+function record(value) {
+  return typeof value === "object" && value !== null ? value : null;
+}
+function currentFiber(publicRoot) {
+  const root = record(publicRoot);
+  if (root === null)
+    throw new Error(
+      "Unsupported React DOM internals: expected a mounted root."
+    );
+  const internalRoot = record(root["_internalRoot"]);
+  if (internalRoot === null)
+    throw new Error("Unsupported React DOM internals: expected a FiberRoot.");
+  const current = record(internalRoot["current"]);
+  if (current === null || current["tag"] !== 3) {
+    throw new Error(
+      "Unsupported React DOM internals: expected FiberRoot.current."
+    );
+  }
+  return current;
+}
+function skipped(fiber, version3) {
+  if (fiber.tag === 4 || fiber.tag === 18) return true;
+  const offscreen = version3 === 17 ? 23 : 22;
+  const legacyHidden = version3 === 17 ? 24 : 23;
+  return (fiber.tag === offscreen || fiber.tag === legacyHidden) && fiber.memoizedState !== null;
+}
+function isHost(fiber, version3) {
+  return fiber.tag === 5 || version3 === 19 && (fiber.tag === 26 || fiber.tag === 27);
+}
+function exposedType(fiber, version3) {
+  if (isHost(fiber, version3)) return fiber.type;
+  switch (fiber.tag) {
+    case 0:
+    // Function.
+    case 1:
+      return fiber.type;
+    case 11:
+    // ForwardRef.
+    case 14:
+      return fiber.type;
+    case 15:
+      return fiber.elementType;
+    default:
+      return null;
+  }
+}
+function hostElement(fiber) {
+  const node = record(fiber.stateNode);
+  return node?.["nodeType"] === 1 ? fiber.stateNode : null;
+}
+function firstDOM(fiber, version3) {
+  if (skipped(fiber, version3)) return null;
+  if (isHost(fiber, version3)) return hostElement(fiber);
+  for (let { child } = fiber; child !== null; child = child.sibling) {
+    const element = firstDOM(child, version3);
+    if (element !== null) return element;
+  }
+  return null;
+}
+function committedText(fiber, version3) {
+  if (skipped(fiber, version3)) return "";
+  if (fiber.tag === 6) {
+    const node = record(fiber.stateNode);
+    return typeof node?.["nodeValue"] === "string" ? node["nodeValue"] : "";
+  }
+  if (isHost(fiber, version3) && fiber.child === null)
+    return hostElement(fiber)?.textContent ?? "";
+  let text = "";
+  for (let { child } = fiber; child !== null; child = child.sibling) {
+    text += committedText(child, version3);
+  }
+  return text;
+}
+var CommittedNode = class {
+  constructor(fiber, type, version3) {
+    this.fiber = fiber;
+    this.type = type;
+    this.version = version3;
+  }
+  get props() {
+    return record(this.fiber.memoizedProps) ?? {};
+  }
+  get children() {
+    const children = [];
+    appendChildren(this.fiber.child, this.version, children);
+    return children;
+  }
+  get text() {
+    return committedText(this.fiber, this.version);
+  }
+  get dom() {
+    return firstDOM(this.fiber, this.version);
+  }
+};
+function appendChildren(first, version3, output) {
+  for (let fiber = first; fiber !== null; fiber = fiber.sibling) {
+    if (skipped(fiber, version3)) continue;
+    const type = exposedType(fiber, version3);
+    if (type === null) appendChildren(fiber.child, version3, output);
+    else output.push(new CommittedNode(fiber, type, version3));
+  }
+}
+function findBoundary(first, boundary, version3) {
+  for (let fiber = first; fiber !== null; fiber = fiber.sibling) {
+    if (skipped(fiber, version3)) continue;
+    if (fiber.elementType === boundary || fiber.type === boundary) return fiber;
+    const found = findBoundary(fiber.child, boundary, version3);
+    if (found !== null) return found;
+  }
+  return null;
+}
+function inspectDOMRoot(version3, container, publicRoot, boundary) {
+  const root = version3 === 17 ? record(container)?.["_reactRootContainer"] : publicRoot;
+  const current = currentFiber(root);
+  const targetBoundary = findBoundary(current.child, boundary, version3);
+  if (targetBoundary === null) return null;
+  return new CommittedNode(targetBoundary, boundary, version3);
+}
+
+// src/internal.ts
+var actScopes = 0;
+var previousActEnvironment;
+function enterActEnvironment() {
+  if (actScopes === 0) {
+    previousActEnvironment = Object.getOwnPropertyDescriptor(
+      globalThis,
+      "IS_REACT_ACT_ENVIRONMENT"
+    );
+    Object.defineProperty(globalThis, "IS_REACT_ACT_ENVIRONMENT", {
+      configurable: true,
+      enumerable: true,
+      writable: true,
+      value: true
+    });
+  }
+  actScopes += 1;
+}
+function leaveActEnvironment() {
+  actScopes -= 1;
+  if (actScopes !== 0) return;
+  if (previousActEnvironment === void 0) {
+    Reflect.deleteProperty(globalThis, "IS_REACT_ACT_ENVIRONMENT");
+  } else {
+    Object.defineProperty(
+      globalThis,
+      "IS_REACT_ACT_ENVIRONMENT",
+      previousActEnvironment
+    );
+  }
+  previousActEnvironment = void 0;
+}
+function wrap(element, wrappers, create) {
+  let result = element;
+  for (let index = wrappers.length - 1; index >= 0; index -= 1) {
+    const wrapper = wrappers[index];
+    if (wrapper !== void 0) result = create(wrapper, { children: result });
+  }
+  return result;
+}
+
+// src/mount.ts
+var cachedRuntime;
+function loadRuntime() {
+  const version3 = selectDOMReactVersion(React.version);
+  const reactRuntime = React;
+  const utilities = typeof reactRuntime["act"] === "function" ? reactRuntime : require("react-dom/test-utils");
+  const actCandidate = utilities["act"];
+  if (typeof actCandidate !== "function")
+    throw new Error(
+      "This React build does not provide act(). Use a development React build for testing."
+    );
+  const reactAct = actCandidate;
+  const legacy = version3 === 17 ? require("react-dom") : null;
+  const concurrent = version3 === 17 ? null : require("react-dom");
+  const domVersion = legacy?.version ?? concurrent?.version;
+  if (domVersion !== React.version) {
+    throw new Error(
+      `React and React DOM versions must match; received React ${React.version} and React DOM ${String(domVersion)}.`
+    );
+  }
+  const client = version3 === 17 ? null : require("react-dom/client");
+  return { version: version3, reactAct, legacy, concurrent, client };
+}
+function createMountDriver(options) {
+  if (typeof document === "undefined" || document.body === null) {
+    throw new Error(
+      "mount() requires a DOM document with a body. Configure jsdom before mounting."
+    );
+  }
+  const { version: version3, reactAct, legacy, client } = cachedRuntime ??= loadRuntime();
+  const container = document.createElement("div");
+  let root = null;
+  let unmounted = false;
+  let currentProps = options.props;
+  let currentWrappers = options.wrappers;
+  let { initialElement } = options;
+  const pendingErrors = [];
+  function throwPendingErrors() {
+    if (pendingErrors.length === 0) return;
+    if (pendingErrors.length === 1) throw pendingErrors.shift();
+    const errors = pendingErrors.splice(0);
+    throw new AggregateError(errors, "Multiple uncaught React errors.");
+  }
+  function sync(callback) {
+    enterActEnvironment();
+    try {
+      reactAct(callback);
+      throwPendingErrors();
+    } finally {
+      leaveActEnvironment();
+    }
+  }
+  const driver = {
+    mode: "mount",
+    inspect() {
+      throwPendingErrors();
+      return unmounted ? null : inspectDOMRoot(version3, container, root, options.component);
+    },
+    render(props, wrappers) {
+      if (unmounted) throw new Error("Cannot render an unmounted subject.");
+      currentProps = props;
+      currentWrappers = wrappers;
+      const target = initialElement ?? React.createElement(options.component, props);
+      initialElement = void 0;
+      const element = wrap(
+        target,
+        wrappers,
+        (type, providerProps) => React.createElement(type, providerProps)
+      );
+      sync(() => {
+        if (legacy !== null) legacy.render(element, container);
+        else if (root !== null) root.render(element);
+        else throw new Error("React DOM root was not initialized.");
+      });
+    },
+    flush() {
+      if (!unmounted) driver.render(currentProps, currentWrappers);
+    },
+    async act(callback) {
+      if (unmounted) throw new Error("Cannot act on an unmounted subject.");
+      enterActEnvironment();
+      try {
+        await reactAct(async () => {
+          await callback();
+        });
+        throwPendingErrors();
+      } finally {
+        leaveActEnvironment();
+      }
+    },
+    unmount() {
+      if (unmounted) return;
+      unmounted = true;
+      try {
+        sync(() => {
+          if (legacy !== null) legacy.unmountComponentAtNode(container);
+          else root?.unmount();
+        });
+      } finally {
+        root = null;
+        container.remove();
+      }
+    }
+  };
+  document.body.appendChild(container);
+  try {
+    if (client !== null) {
+      root = version3 === 19 ? client.createRoot(container, {
+        onUncaughtError: (error) => {
+          pendingErrors.push(error);
+        }
+      }) : client.createRoot(container);
+    }
+    driver.render(options.props, options.wrappers);
+  } catch (error) {
+    try {
+      driver.unmount();
+    } catch (cleanupError) {
+      throw new AggregateError(
+        [error, cleanupError],
+        "Mount failed and React cleanup also failed."
+      );
+    }
+    throw error;
+  }
+  return driver;
+}
+
+// src/shallow.ts
+var React3 = __toESM(require("react"), 1);
+
+// src/adapters/reconciler.ts
+var React2 = __toESM(require("react"), 1);
+var noop = () => {
+};
+var emptyContext = Object.freeze({});
+var instance;
+var cachedAct;
+function reactVersion() {
+  const match = /^(17|18|19)\.(\d+)\.(\d+)$/.exec(React2.version);
+  const major = Number(match?.[1]);
+  const minor = Number(match?.[2]);
+  if (!match || major === 17 && minor !== 0 || major === 18 && (minor < 2 || minor > 3) || major === 19 && minor > 3) {
+    throw new Error(
+      `Unsupported React ${React2.version}; tested adapters cover 17.0.2, 18.2\u201318.3, and 19.0\u201319.3 stable releases.`
+    );
+  }
+  return { major, minor };
+}
+function loadFactory(major, minor) {
+  switch (major) {
+    case 17:
+      return require("./adapters/react17.cjs");
+    case 18:
+      return require("./adapters/react18.cjs");
+    case 19:
+      switch (minor) {
+        case 0:
+          return require("./adapters/react19_0.cjs");
+        case 1:
+          return require("./adapters/react19_1.cjs");
+        case 2:
+          return require("./adapters/react19_2.cjs");
+        case 3:
+          return require("./adapters/react19_3.cjs");
+      }
+  }
+  throw new Error(`No reconciler adapter for React ${React2.version}`);
+}
+function remove(parent, child) {
+  const index = parent.children.indexOf(child);
+  if (index >= 0) parent.children.splice(index, 1);
+}
+function append(parent, child) {
+  remove(parent, child);
+  parent.children.push(child);
+}
+function insert(parent, child, before) {
+  remove(parent, child);
+  const index = parent.children.indexOf(before);
+  if (index < 0)
+    throw new Error("Invalid insertion point in shallow host tree");
+  parent.children.splice(index, 0, child);
+}
+function getReconciler() {
+  if (instance) return instance;
+  const { major, minor } = reactVersion();
+  let priority = 0;
+  const config = {
+    rendererVersion: "0.1.0",
+    rendererPackageName: "@avgz/react-contract-renderer",
+    isPrimaryRenderer: false,
+    supportsMutation: true,
+    supportsPersistence: false,
+    supportsHydration: false,
+    supportsMicrotasks: true,
+    supportsResources: false,
+    supportsSingletons: false,
+    supportsTestSelectors: false,
+    getRootHostContext: () => emptyContext,
+    getChildHostContext: () => emptyContext,
+    getPublicInstance: (node) => node,
+    prepareForCommit: () => null,
+    resetAfterCommit: noop,
+    createInstance: (type, props) => ({
+      type,
+      props,
+      children: [],
+      hidden: false
+    }),
+    createTextInstance: (text) => ({
+      type: "#text",
+      props: { text },
+      children: [],
+      hidden: false
+    }),
+    appendInitialChild: append,
+    appendChild: append,
+    appendChildToContainer: append,
+    insertBefore: insert,
+    insertInContainerBefore: insert,
+    removeChild: remove,
+    removeChildFromContainer: remove,
+    clearContainer: (container) => {
+      container.children.length = 0;
+    },
+    finalizeInitialChildren: () => false,
+    shouldSetTextContent: () => false,
+    prepareUpdate: () => true,
+    commitUpdate: major >= 19 ? (node, _type, _old, props) => {
+      node.props = props;
+    } : (node, _payload, _type, _old, props) => {
+      node.props = props;
+    },
+    commitTextUpdate: (node, _old, text) => {
+      node.props = { text };
+    },
+    resetTextContent: (node) => {
+      node.children.length = 0;
+    },
+    hideInstance: (node) => {
+      node.hidden = true;
+    },
+    unhideInstance: (node) => {
+      node.hidden = false;
+    },
+    hideTextInstance: (node) => {
+      node.hidden = true;
+    },
+    unhideTextInstance: (node) => {
+      node.hidden = false;
+    },
+    detachDeletedInstance: (node) => {
+      node.children.length = 0;
+    },
+    preparePortalMount: noop,
+    now: () => performance.now(),
+    scheduleTimeout: setTimeout,
+    cancelTimeout: clearTimeout,
+    noTimeout: -1,
+    scheduleMicrotask: queueMicrotask,
+    getCurrentEventPriority: () => 16,
+    getCurrentUpdatePriority: () => priority,
+    setCurrentUpdatePriority: (next) => {
+      priority = next;
+    },
+    resolveUpdatePriority: () => priority || 32,
+    shouldAttemptEagerTransition: () => false,
+    trackSchedulerEvent: noop,
+    resolveEventType: () => null,
+    resolveEventTimeStamp: () => -1.1,
+    maySuspendCommit: () => false,
+    maySuspendCommitOnUpdate: () => false,
+    maySuspendCommitInSyncRender: () => false,
+    preloadInstance: () => true,
+    NotPendingTransition: null,
+    HostTransitionContext: React2.createContext(null)
+  };
+  instance = loadFactory(major, minor)(config);
+  return instance;
+}
+function actFunction() {
+  if (cachedAct) return cachedAct;
+  const react = React2;
+  if (react.act) cachedAct = react.act;
+  else if (reactVersion().major === 18) {
+    const utilities = require("react-dom/test-utils");
+    cachedAct = utilities.act;
+  }
+  return cachedAct;
+}
+function createShallowRoot() {
+  const reconciler = getReconciler();
+  const { major } = reactVersion();
+  const container = {
+    type: "#root",
+    props: {},
+    children: [],
+    hidden: false
+  };
+  let failure;
+  const onError = (error) => {
+    failure = { error };
+  };
+  const root = major === 17 ? reconciler.createContainer(container, 0, false, null) : major === 18 ? reconciler.createContainer(
+    container,
+    1,
+    null,
+    false,
+    null,
+    "",
+    onError,
+    null
+  ) : reconciler.createContainer(
+    container,
+    1,
+    null,
+    false,
+    null,
+    "",
+    onError,
+    onError,
+    onError,
+    noop
+  );
+  const checkError = () => {
+    if (failure) {
+      const { error } = failure;
+      failure = void 0;
+      throw error;
+    }
+  };
+  const flushSync = reconciler.flushSync ?? reconciler.flushSyncFromReconciler;
+  if (!flushSync)
+    throw new Error(
+      `React ${React2.version} reconciler has no synchronous flush API`
+    );
+  const drain = () => {
+    let passes = 0;
+    do {
+      flushSync(noop);
+      checkError();
+      if (++passes > 100)
+        throw new Error("Shallow effects did not settle after 100 flushes");
+    } while (reconciler.flushPassiveEffects());
+    checkError();
+  };
+  const sync = (callback) => {
+    const act = actFunction();
+    if (act) {
+      enterActEnvironment();
+      try {
+        void act(() => {
+          callback();
+          drain();
+        });
+      } finally {
+        leaveActEnvironment();
+      }
+    } else {
+      callback();
+      drain();
+    }
+    checkError();
+  };
+  return {
+    container,
+    render(element) {
+      sync(
+        () => flushSync(() => {
+          (reconciler.updateContainerSync ?? reconciler.updateContainer)(
+            element,
+            root,
+            null,
+            null
+          );
+        })
+      );
+    },
+    flush() {
+      sync(noop);
+    },
+    async act(callback) {
+      const act = actFunction();
+      if (act) {
+        enterActEnvironment();
+        try {
+          await act(async () => {
+            await callback();
+            drain();
+          });
+        } finally {
+          leaveActEnvironment();
+        }
+      } else {
+        await callback();
+        drain();
+      }
+      checkError();
+    }
+  };
+}
+
+// src/shallow.ts
+var outputType = "contract-renderer-output";
+var wrappedTypes = /* @__PURE__ */ new WeakMap();
+var noChildren = Object.freeze([]);
+function capture(value, props) {
+  return React3.createElement(outputType, { value, input: props });
+}
+function instrument(type) {
+  if (typeof type === "string") {
+    return (props) => capture(props["children"], props);
+  }
+  const existing = wrappedTypes.get(type);
+  if (existing) return existing;
+  let result;
+  if (typeof type === "function") {
+    if (type.prototype && "isReactComponent" in type.prototype) {
+      const Base = type;
+      result = class ContractTarget extends Base {
+        render() {
+          return capture(super.render(), this.props);
+        }
+      };
+    } else {
+      const render = type;
+      result = (props) => capture(render(props), props);
+      if ("defaultProps" in type)
+        Object.assign(result, { defaultProps: type.defaultProps });
+    }
+  } else {
+    const exotic = type;
+    switch (exotic.$$typeof) {
+      case Symbol.for("react.memo"): {
+        if (!exotic.type) throw new TypeError("Invalid memo component");
+        const child = instrument(exotic.type);
+        result = React3.memo(child, exotic.compare);
+        break;
+      }
+      case Symbol.for("react.forward_ref"): {
+        const { render } = exotic;
+        if (!render) throw new TypeError("Invalid forwardRef component");
+        result = React3.forwardRef(
+          (props, ref) => capture(render(props, ref), props)
+        );
+        break;
+      }
+      case Symbol.for("react.lazy"): {
+        const initialize = exotic._init;
+        if (!initialize) throw new TypeError("Invalid lazy component");
+        result = (props) => React3.createElement(instrument(initialize(exotic._payload)), props);
+        break;
+      }
+      default:
+        throw new TypeError(
+          "Shallow rendering requires a component function, class, memo, forwardRef, lazy component, or host tag"
+        );
+    }
+  }
+  wrappedTypes.set(type, result);
+  return result;
+}
+function outputNode(node) {
+  if (node.hidden) return void 0;
+  if (node.type === outputType) return node;
+  for (const child of node.children) {
+    const found = outputNode(child);
+    if (found) return found;
+  }
+  return void 0;
+}
+function inspectChildren(value) {
+  const children = [];
+  let text = "";
+  React3.Children.forEach(value, (child) => {
+    if (typeof child === "string" || typeof child === "number" || typeof child === "bigint") {
+      text += String(child);
+    } else if (React3.isValidElement(child)) {
+      const { type } = child;
+      if (type === React3.Fragment) {
+        const inner = inspectChildren(child.props["children"]);
+        children.push(...inner.children);
+        text += inner.text;
+      } else {
+        const inner = typeof type === "string" ? inspectChildren(child.props["children"]) : { children: noChildren, text: "" };
+        children.push({
+          type,
+          props: child.props,
+          children: inner.children,
+          text: inner.text,
+          dom: null
+        });
+        text += inner.text;
+      }
+    }
+  });
+  return { children, text };
+}
+function createShallowDriver(options) {
+  const root = createShallowRoot();
+  const Target = instrument(options.component);
+  let disposed = false;
+  let currentProps = options.props;
+  let currentWrappers = options.wrappers;
+  const driver = {
+    mode: "shallow",
+    inspect() {
+      if (disposed) return null;
+      const node = outputNode(root.container);
+      if (!node) return null;
+      const children = inspectChildren(node.props["value"]);
+      return {
+        type: options.component,
+        props: node.props["input"],
+        children: children.children,
+        text: children.text,
+        dom: null
+      };
+    },
+    render(props, wrappers) {
+      if (disposed) throw new Error("Cannot render an unmounted subject");
+      currentProps = props;
+      currentWrappers = wrappers;
+      const target = React3.createElement(Target, props);
+      root.render(wrap(target, wrappers, React3.createElement));
+    },
+    flush() {
+      if (disposed) throw new Error("Cannot flush an unmounted subject");
+      driver.render(currentProps, currentWrappers);
+    },
+    async act(callback) {
+      if (disposed) throw new Error("Cannot update an unmounted subject");
+      await root.act(callback);
+    },
+    unmount() {
+      if (disposed) return;
+      disposed = true;
+      root.render(null);
+    }
+  };
+  try {
+    driver.render(options.props, options.wrappers);
+  } catch (error) {
+    driver.unmount();
+    throw error;
+  }
+  return driver;
+}
+
+// src/subject.ts
+var import_react = require("react");
+function validateType(type) {
+  if (typeof type === "string") {
+    if (!/^[a-zA-Z][a-zA-Z0-9:_-]*$/.test(type)) {
+      throw new TypeError(
+        "Subject queries accept an intrinsic tag name, not a CSS selector."
+      );
+    }
+    return;
+  }
+  if (typeof type === "function") return;
+  const marker = typeof type === "object" && type !== null && "$$typeof" in type ? type.$$typeof : type;
+  if (typeof marker === "symbol") {
+    const name = Symbol.keyFor(marker);
+    if (name === "react.memo" || name === "react.forward_ref" || name === "react.lazy" || name === "react.context" || name === "react.provider" || name === "react.consumer" || name === "react.fragment" || name === "react.strict_mode" || name === "react.profiler" || name === "react.suspense" || name === "react.suspense_list" || name === "react.activity")
+      return;
+  }
+  throw new TypeError(
+    "Subject queries require a React component identity or an intrinsic tag name."
+  );
+}
+function collectMatches(node, type, matches) {
+  if (node.type === type) matches.push(node);
+  for (const child of node.children) collectMatches(child, type, matches);
+}
+var Subject = class _Subject {
+  /** @internal */
+  constructor(source, mode) {
+    this.source = source;
+    this.mode = mode;
+  }
+  /** Match a component identity or host tag, including this node; inspection rejects multiple matches. */
+  find(type) {
+    validateType(type);
+    this.resolve();
+    return new _Subject(() => this.search(type), this.mode);
+  }
+  /** Return live selections by match index. Re-query after insertion/reordering to obtain a new list. */
+  findAll(type) {
+    validateType(type);
+    return this.search(type).map(
+      (_, index) => new _Subject(() => {
+        const node = this.search(type)[index];
+        return node === void 0 ? [] : [node];
+      }, this.mode)
+    );
+  }
+  /** Report whether exactly one matching node exists in the current render. */
+  exists() {
+    return this.resolve() !== void 0;
+  }
+  /** Return every prop from the selected component or host node. */
+  props() {
+    return this.requireNode().props;
+  }
+  /** Return one typed prop from the selected component or host node. */
+  prop(key) {
+    return this.props()[key];
+  }
+  /** Return the selected node's string className, if it has one. */
+  className() {
+    const value = this.requireNode().props["className"];
+    if (value === void 0) return void 0;
+    if (typeof value !== "string") {
+      throw new TypeError(
+        "The selected node has a className prop that is not a string."
+      );
+    }
+    return value;
+  }
+  /** Return the selected component identity or intrinsic host tag. */
+  type() {
+    return this.requireNode().type;
+  }
+  /** Recreate the selected node as a React element with its current props. */
+  element() {
+    const node = this.requireNode();
+    return (0, import_react.createElement)(node.type, node.props);
+  }
+  /** Return all text content beneath the selected node. */
+  text() {
+    return this.requireNode().text;
+  }
+  /**
+   * Mount only: return the first host element represented by the selected
+   * contract.
+   */
+  getDOMNode() {
+    const node = this.requireNode();
+    if (this.mode === "shallow") {
+      throw new Error(
+        "getDOMNode() is unavailable for shallow rendering; use mount() instead."
+      );
+    }
+    if (node.dom === null) {
+      throw new Error("The selected node has no associated host DOM element.");
+    }
+    return node.dom;
+  }
+  resolve() {
+    const nodes = this.source();
+    if (nodes.length > 1) {
+      throw new Error(
+        `Subject selection is ambiguous: found ${nodes.length} nodes. Use findAll() to select multiple nodes.`
+      );
+    }
+    return nodes[0];
+  }
+  requireNode() {
+    const node = this.resolve();
+    if (node === void 0) {
+      throw new Error(
+        "Subject selection is empty: no matching node exists in the current render."
+      );
+    }
+    return node;
+  }
+  search(type) {
+    const node = this.resolve();
+    if (node === void 0) return [];
+    const matches = [];
+    collectMatches(node, type, matches);
+    return matches;
+  }
+};
+
+// src/index.ts
+var mounted = /* @__PURE__ */ new Set();
+var RenderSession = class {
+  /**
+   * @internal
+   * Constructed by {@link getComponentRenderer}.
+   */
+  constructor(component, props, factory, initialElement) {
+    this.component = component;
+    this.props = props;
+    this.factory = factory;
+    this.initialElement = initialElement;
+  }
+  driver;
+  wrappers = [];
+  disposed = false;
+  selection;
+  /**
+   * Configure providers before first observation. Providers nest in argument
+   * order, so the first provider is outermost.
+   */
+  with(...providers) {
+    if (this.disposed) throw new Error("Cannot configure an unmounted subject");
+    if (this.driver)
+      throw new Error(
+        "Call .with(...) before observing or updating the subject"
+      );
+    this.wrappers = [...this.wrappers, ...providers];
+    return this;
+  }
+  /** Inspect the current render through live, typed contract queries. */
+  get subject() {
+    const driver = this.initialize();
+    this.selection ??= new Subject(() => {
+      const node = driver.inspect();
+      return node ? [node] : [];
+    }, driver.mode);
+    return this.selection;
+  }
+  /** Merge props into the current render while preserving component state. */
+  rerender(overrides) {
+    const driver = this.initialize();
+    this.props = { ...this.props, ...overrides };
+    driver.render(this.props, this.wrappers);
+  }
+  /** Flush already scheduled synchronous work; use {@link act} for asynchronous work. */
+  flush() {
+    this.initialize().flush();
+  }
+  /** Await React work scheduled by the callback. Await the component request or timer inside the callback. */
+  async act(callback) {
+    await this.initialize().act(callback);
+  }
+  /** Unmount the render. Calling this more than once is safe. */
+  unmount() {
+    if (this.disposed) return;
+    this.disposed = true;
+    mounted.delete(this);
+    this.driver?.unmount();
+  }
+  initialize() {
+    if (this.disposed)
+      throw new Error("Cannot use an unmounted render session");
+    if (!this.driver) {
+      this.driver = this.factory({
+        component: this.component,
+        props: this.props,
+        wrappers: this.wrappers,
+        initialElement: this.initialElement
+      });
+      mounted.add(this);
+    }
+    return this.driver;
+  }
+};
+function getComponentRenderer(component, defaultProps) {
+  const defaults = { ...defaultProps };
+  let defaultElement;
+  return {
+    shallow(overrides) {
+      return new RenderSession(
+        component,
+        overrides === void 0 ? defaults : { ...defaults, ...overrides },
+        createShallowDriver
+      );
+    },
+    mount(overrides) {
+      const props = overrides === void 0 ? defaults : { ...defaults, ...overrides };
+      const element = overrides === void 0 ? defaultElement ??= (0, import_react2.createElement)(component, defaults) : (0, import_react2.createElement)(component, props);
+      return new RenderSession(component, props, createMountDriver, element);
+    }
+  };
+}
+function cleanup() {
+  const errors = [];
+  for (const session of mounted) {
+    try {
+      session.unmount();
+    } catch (error) {
+      errors.push(error);
+    }
+  }
+  if (errors.length === 1) throw errors[0];
+  if (errors.length > 1)
+    throw new AggregateError(
+      errors,
+      "Multiple render sessions failed to clean up"
+    );
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  RenderSession,
+  Subject,
+  cleanup,
+  getComponentRenderer
+});
+//# sourceMappingURL=index.cjs.map