@oxyhq/bloom 0.66.0 → 0.68.0

package/src/__tests__/Dialog.web.test.tsx

@@ -77,8 +77,11 @@ describe('Dialog.web keyframe self-injection', () => {
     const css = styleEl?.textContent ?? '';
     expect(css).toContain('@keyframes bloomDialogZoomFadeIn');
     expect(css).toContain('@keyframes bloomDialogZoomFadeOut');
-    expect(css).toContain('@keyframes bloomDialogFadeIn');
-    expect(css).toContain('@keyframes bloomDialogFadeOut');
+    // The backdrop's own fade is NOT a keyframe: it rides a shared value, so
+    // the dim can never be driven past its own opacity (see the black-flash
+    // regression below).
+    expect(css).not.toContain('@keyframes bloomDialogFadeIn');
+    expect(css).not.toContain('@keyframes bloomDialogFadeOut');
 
     // Opening the dialog (the path that actually plays the animation) must not
     // duplicate the stylesheet.

package/src/__tests__/backdrop-fade-form.test.ts

@@ -0,0 +1,91 @@
+// The black flash every centered dialog opened with.
+//
+// The backdrop's fade used to be a CSS `@keyframes opacity: 0 → 1` handed to
+// BOTH of `Backdrop`'s layers through `layerStyle`. A running CSS animation
+// outranks inline styles in the cascade, so on the DIM layer — whose inline
+// opacity IS the dim (0.28) — those keyframes drove opacity all the way to 1,
+// i.e. opaque BLACK, for the length of the animation, then dropped it back to
+// 0.28 the instant it ended. Nothing errored, and a screenshot taken after the
+// 150ms looked perfect; it only ever showed as a flicker behind an opening
+// dialog. A CSS *transition* is fine and is what the side-sheet path uses: it
+// interpolates the inline value instead of overriding it.
+//
+// This is a SOURCE gate on purpose. The DOM cannot answer the question in
+// jest: the layers are a mocked `BlurView` and a mocked reanimated
+// `Animated.View`, so neither the inline style nor a react-native-web class
+// ever reaches jsdom — a DOM-level assertion here passes just as happily with
+// the bug in place (it did, which is why this file looks like this).
+
+import { readdirSync, readFileSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+
+const SRC = join(__dirname, '..');
+
+function sourceFiles(dir: string, out: string[] = []): string[] {
+  for (const entry of readdirSync(dir)) {
+    if (entry === '__tests__' || entry === 'node_modules') continue;
+    const full = join(dir, entry);
+    if (statSync(full).isDirectory()) {
+      sourceFiles(full, out);
+    } else if (/\.tsx?$/.test(entry)) {
+      out.push(full);
+    }
+  }
+  return out;
+}
+
+/** `layerStyle={X}` → the source text X actually resolves to. */
+function resolveLayerStyles(source: string): string[] {
+  const out: string[] = [];
+  for (const match of source.matchAll(/layerStyle=\{([^}]*(?:\}[^}]*)?)\}/g)) {
+    const expression = match[1] ?? '';
+    out.push(expression);
+    // An identifier (`layerStyle={BACKDROP_FADE_IN}`) has to be followed home:
+    // the animation lived in the constant, not at the call site.
+    for (const identifier of expression.matchAll(/\b([A-Za-z_$][\w$]*)\b/g)) {
+      const declaration = new RegExp(
+        `const ${identifier[1]}[^=]*=\\s*([\\s\\S]{0,400}?);\\n`,
+      ).exec(source);
+      if (declaration?.[1]) out.push(declaration[1]);
+    }
+  }
+  return out;
+}
+
+describe('backdrop fade form', () => {
+  const files = sourceFiles(SRC);
+
+  it('scans the whole source tree', () => {
+    expect(files.length).toBeGreaterThan(200);
+  });
+
+  it('never drives the backdrop layers with a CSS animation', () => {
+    const offenders: string[] = [];
+    let layerStyles = 0;
+
+    for (const file of files) {
+      const source = readFileSync(file, 'utf8');
+      for (const style of resolveLayerStyles(source)) {
+        layerStyles += 1;
+        if (/\banimation\b/.test(style)) {
+          offenders.push(`${file.slice(SRC.length + 1)}  ${style.replace(/\s+/g, ' ').slice(0, 80)}`);
+        }
+      }
+    }
+
+    // Vacuity floor: the side-sheet's transition is a real `layerStyle` and must
+    // be found, or the scan resolved nothing and this passes for free.
+    expect(layerStyles).toBeGreaterThan(0);
+    expect(offenders).toEqual([]);
+  });
+
+  // The other half of the contract: the fade is multiplied INTO each layer's own
+  // opacity, so a fully-arrived backdrop is still only `dimOpacity` dark.
+  it('multiplies the fade into the dim opacity', () => {
+    const overlay = readFileSync(join(SRC, 'overlay', 'index.tsx'), 'utf8');
+
+    expect(overlay).toMatch(
+      /const dimFade[\s\S]{0,200}?progress\.value[\s\S]{0,80}?\* dimOpacity/,
+    );
+  });
+});

package/src/__tests__/exports-map-contract.test.ts

@@ -0,0 +1,112 @@
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+
+/**
+ * The `react-native` export condition must stay SPLIT into `types` + `default`.
+ *
+ * Metro compiles Bloom from source, so `default` points at `src/`. TypeScript
+ * honours `react-native` as well (expo/tsconfig.base sets
+ * `customConditions: ["react-native"]`), and if the condition were a bare
+ * string every native-targeted consumer would type-check Bloom's own `.tsx`
+ * files — pulling `react-dom` (from the web forks) and optional peers like
+ * `expo-haptics` / `@react-native-community/netinfo` into a program that never
+ * declared them. Measured against a consumer fixture with no
+ * `@types/react-dom`, the string form produces TS7016 on
+ * `src/portal/index.web.tsx`, TS2307 on `src/hooks/useHaptics.tsx` and
+ * `src/connection-status/index.tsx`, plus a nativewind TS2769 on
+ * `src/dialog/DialogHeader.tsx`. `skipLibCheck` cannot suppress any of them —
+ * a `.tsx` is not a declaration file.
+ *
+ * Splitting the condition means tsc asks for `types` and gets the built
+ * declarations, while Metro (which never requests `types`) still falls through
+ * to `default` and bundles source. Verified end to end with a real
+ * `expo export --platform ios`.
+ *
+ * `package.json#exports` is generated by `scripts/generate-platform-exports.mjs`
+ * — fix a failure there, never by hand-editing `package.json`.
+ */
+
+type ExportEntry = Record<string, unknown>;
+
+// Read rather than `import` the manifest: tsconfig pins `rootDir` to `src`, so
+// a JSON import from outside it would drag package.json into the build program.
+const PKG_PATH = join(__dirname, '..', '..', 'package.json');
+const pkg = JSON.parse(readFileSync(PKG_PATH, 'utf8')) as {
+  exports: Record<string, ExportEntry | string>;
+};
+const exportsMap = pkg.exports;
+
+/** Non-subpath entries that are legitimately plain strings (static assets). */
+const STRING_ENTRIES = ['./design-tokens/theme.css', './package.json'];
+
+/**
+ * Vacuity floor. `SUBPATHS` in the generator is 86 entries today; a traversal
+ * bug that silently found none must not read as a pass.
+ */
+const MIN_SUBPATHS = 80;
+
+const subpathEntries = Object.entries(exportsMap).filter(
+  (entry): entry is [string, ExportEntry] => typeof entry[1] !== 'string',
+);
+
+describe('package.json#exports — react-native condition', () => {
+  it(`declares at least ${MIN_SUBPATHS} conditional subpaths`, () => {
+    expect(subpathEntries.length).toBeGreaterThanOrEqual(MIN_SUBPATHS);
+  });
+
+  it('exposes only the known static assets as string exports', () => {
+    const strings = Object.entries(exportsMap)
+      .filter(([, value]) => typeof value === 'string')
+      .map(([name]) => name);
+    expect(strings.sort()).toEqual([...STRING_ENTRIES].sort());
+  });
+
+  it('splits every react-native condition into types + default, in that order', () => {
+    const offenders: string[] = [];
+    for (const [name, entry] of subpathEntries) {
+      const condition = entry['react-native'];
+      if (typeof condition !== 'object' || condition === null) {
+        offenders.push(`${name}: react-native is ${JSON.stringify(condition)}, expected an object`);
+        continue;
+      }
+      const keys = Object.keys(condition);
+      if (keys.join(',') !== 'types,default') {
+        offenders.push(`${name}: react-native keys are [${keys.join(', ')}], expected [types, default]`);
+      }
+    }
+    expect(offenders).toEqual([]);
+  });
+
+  it('points react-native.default at src and react-native.types at the built declarations', () => {
+    const offenders: string[] = [];
+    for (const [name, entry] of subpathEntries) {
+      const condition = entry['react-native'];
+      if (typeof condition !== 'object' || condition === null) continue;
+      const { types, default: def } = condition as { types?: unknown; default?: unknown };
+
+      if (typeof def !== 'string' || !def.startsWith('./src/')) {
+        offenders.push(`${name}: react-native.default is ${JSON.stringify(def)}, expected a ./src/ path`);
+      }
+      if (typeof types !== 'string' || !types.startsWith('./lib/typescript/')) {
+        offenders.push(
+          `${name}: react-native.types is ${JSON.stringify(types)}, expected a ./lib/typescript/ path`,
+        );
+      }
+    }
+    expect(offenders).toEqual([]);
+  });
+
+  it('resolves react-native.types to the same declarations as the import condition', () => {
+    const offenders: string[] = [];
+    for (const [name, entry] of subpathEntries) {
+      const condition = entry['react-native'] as { types?: unknown } | undefined;
+      const importCondition = entry.import as { types?: unknown } | undefined;
+      if (condition?.types !== importCondition?.types) {
+        offenders.push(
+          `${name}: react-native.types (${String(condition?.types)}) !== import.types (${String(importCondition?.types)})`,
+        );
+      }
+    }
+    expect(offenders).toEqual([]);
+  });
+});

package/src/__tests__/toast-single-outlet-guard.test.tsx

@@ -0,0 +1,176 @@
+import React from 'react';
+import { render } from '@testing-library/react-native';
+
+import { ToastOutlet } from '../toast';
+import { resetSingleOutletGuardForTests } from '../toast/use-single-outlet-guard';
+
+/**
+ * THE DUPLICATE-OUTLET GUARD.
+ *
+ * `Toaster` subscribes to the module-level `toastStore`, so two mounted outlets
+ * render two copies of every row — measured 1→1, 2→2, 3→3 in Mention, and 1→2→1
+ * in Alia with the second outlet gated on a query param inside ONE bundle so both
+ * arms came from identical bytes. The copies overlap almost exactly (bare outlets
+ * take identical defaults and land pixel-identical), so nothing but a row count
+ * reveals it — hence a warning.
+ *
+ * Every test here mounts outlets and fires NO toast: a second outlet duplicates
+ * rows from the moment it mounts, so the warning must not wait for one. An idle
+ * `Toaster` renders null, which is why these need no theme provider or portal.
+ *
+ * The guard's module state outlives a render tree, so `beforeEach` resets it.
+ * Without that, the first test to latch the warning would leave every later test
+ * asserting "did not warn" against a guard that can no longer fire — green
+ * whatever the implementation does. That vacuity is the specific failure mode
+ * this suite is mutation-tested against; see the per-test mutation notes.
+ */
+describe('duplicate toast outlet guard', () => {
+  let warn: jest.SpyInstance<void, Parameters<typeof console.warn>>;
+
+  beforeEach(() => {
+    resetSingleOutletGuardForTests();
+    // `__mocks__/setup.ts` already silences console.warn; this re-spies so the
+    // calls are recorded and stay scoped to one test.
+    warn = jest.spyOn(console, 'warn').mockImplementation(() => {});
+  });
+
+  afterEach(() => {
+    warn.mockRestore();
+  });
+
+  const bloomWarnings = () =>
+    warn.mock.calls.filter(
+      (call) => typeof call[0] === 'string' && call[0].startsWith('[Bloom] Toaster:'),
+    );
+
+  /** Mutation: `mountedOutlets > 1` → `>= 1` warns here. */
+  it('stays silent for a single outlet', () => {
+    render(<ToastOutlet />);
+
+    expect(bloomWarnings()).toHaveLength(0);
+  });
+
+  it('warns exactly once when a second outlet mounts', () => {
+    render(
+      <>
+        <ToastOutlet />
+        <ToastOutlet />
+      </>,
+    );
+
+    expect(bloomWarnings()).toHaveLength(1);
+  });
+
+  it('names the cause rather than just the symptom', () => {
+    render(
+      <>
+        <ToastOutlet />
+        <ToastOutlet />
+      </>,
+    );
+
+    // The consumer's tree is the only place this is fixable, and the overwhelming
+    // cause is an app mounting its own outlet beside OxyProvider's.
+    expect(bloomWarnings()[0]?.[0]).toContain('OxyProvider');
+  });
+
+  /** Mutation: drop the `hasWarned` latch and this warns twice. */
+  it('warns once, not once per extra outlet, when a third mounts', () => {
+    render(
+      <>
+        <ToastOutlet />
+        <ToastOutlet />
+        <ToastOutlet />
+      </>,
+    );
+
+    expect(bloomWarnings()).toHaveLength(1);
+  });
+
+  /**
+   * Mutation: drop the unmount decrement and the second mount reads a count of 2
+   * and warns. This is the counter-never-resets failure mode.
+   */
+  it('does not warn across an unmount / remount cycle', () => {
+    render(<ToastOutlet />).unmount();
+    render(<ToastOutlet />);
+
+    expect(bloomWarnings()).toHaveLength(0);
+  });
+
+  /** Three cycles: a counter that leaks by one per mount crosses the threshold. */
+  it('does not warn across repeated remounts', () => {
+    render(<ToastOutlet />).unmount();
+    render(<ToastOutlet />).unmount();
+    render(<ToastOutlet />);
+
+    expect(bloomWarnings()).toHaveLength(0);
+  });
+
+  /**
+   * A route change or provider reshuffle that moves the outlet: React runs the
+   * outgoing tree's cleanups before the incoming tree's setups, so the count dips
+   * to 0 and back to 1 rather than reaching 2.
+   */
+  it('does not warn when one outlet replaces another', () => {
+    const first = render(<ToastOutlet />);
+    const second = render(<ToastOutlet />);
+    first.unmount();
+    second.unmount();
+    render(<ToastOutlet />);
+
+    // Two were genuinely co-mounted in the middle, so one warning is correct...
+    expect(bloomWarnings()).toHaveLength(1);
+  });
+
+  /**
+   * StrictMode is the dominant dev environment and it replays effects
+   * (setup → cleanup → setup), so without the latch a real duplicate would warn
+   * TWICE and a well-behaved single outlet could warn at all. Verified against
+   * this renderer: it does double-invoke, so neither case below is vacuous.
+   */
+  describe('under StrictMode double-invoked effects', () => {
+    it('still stays silent for a single outlet', () => {
+      render(
+        <React.StrictMode>
+          <ToastOutlet />
+        </React.StrictMode>,
+      );
+
+      expect(bloomWarnings()).toHaveLength(0);
+    });
+
+    it('still warns exactly once for a duplicate', () => {
+      render(
+        <React.StrictMode>
+          <ToastOutlet />
+          <ToastOutlet />
+        </React.StrictMode>,
+      );
+
+      expect(bloomWarnings()).toHaveLength(1);
+    });
+  });
+
+  /**
+   * Mutation: drop the `process.env.NODE_ENV` gate and this warns. Bundlers fold
+   * the branch statically, so production ships neither the counter nor the
+   * message — the guard must not change production behaviour at all.
+   */
+  it('does not warn in production', () => {
+    const previous = process.env.NODE_ENV;
+    process.env.NODE_ENV = 'production';
+    try {
+      render(
+        <>
+          <ToastOutlet />
+          <ToastOutlet />
+        </>,
+      );
+    } finally {
+      process.env.NODE_ENV = previous;
+    }
+
+    expect(bloomWarnings()).toHaveLength(0);
+  });
+});

package/src/dialog/Dialog.web.tsx

@@ -16,7 +16,11 @@ import {
   type StyleProp,
   type ViewStyle,
 } from 'react-native';
-import Animated from 'react-native-reanimated';
+import Animated, {
+  Easing,
+  useSharedValue,
+  withTiming,
+} from 'react-native-reanimated';
 import { RemoveScrollBar } from 'react-remove-scroll-bar';
 
 import { Backdrop, OverlayRoot } from '../overlay';
@@ -72,10 +76,11 @@ const ZOOM_FADE_IN: WebCssStyle = {
 const ZOOM_FADE_OUT: WebCssStyle = {
   animation: `bloomDialogZoomFadeOut ease-in ${FADE_OUT_DURATION}ms forwards`,
 };
-const BACKDROP_FADE_IN: WebCssStyle = { animation: 'bloomDialogFadeIn ease-out 0.15s' };
-const BACKDROP_FADE_OUT: WebCssStyle = {
-  animation: `bloomDialogFadeOut ease-in ${FADE_OUT_DURATION}ms forwards`,
-};
+/**
+ * Backdrop fade-in duration (ms). The card's zoom-fade is longer; the dim
+ * arriving first is what makes the card read as landing ON something.
+ */
+const BACKDROP_FADE_IN_DURATION = 150;
 
 const stopPropagation = (e: { stopPropagation: () => void }) => e.stopPropagation();
 
@@ -279,6 +284,27 @@ function CenterOrSideDialog({
     return () => clearTimeout(timer);
   }, [isClosing, exitDuration]);
 
+  // The backdrop's fade rides a shared value, NOT a CSS `@keyframes opacity
+  // 0 → 1` handed to the layers. A running CSS animation outranks inline styles
+  // in the cascade, so those keyframes drove the DIM layer — whose inline
+  // opacity IS the dim (0.28) — all the way to 1, i.e. opaque black, and then
+  // dropped it back to 0.28 the instant the animation ended. That is the black
+  // flash every centered dialog opened with. `progress` is multiplied INTO each
+  // layer's own opacity by `Backdrop`, so the dim can only ever reach its own
+  // value. (The side-sheet path was never affected: it animates with a CSS
+  // *transition*, which interpolates the inline value instead of overriding it.)
+  const backdropFade = useSharedValue(0);
+
+  useEffect(() => {
+    if (!isOpen) {
+      backdropFade.value = 0;
+      return;
+    }
+    backdropFade.value = isClosing
+      ? withTiming(0, { duration: FADE_OUT_DURATION, easing: Easing.in(Easing.ease) })
+      : withTiming(1, { duration: BACKDROP_FADE_IN_DURATION, easing: Easing.out(Easing.ease) });
+  }, [backdropFade, isOpen, isClosing]);
+
   // Escape-to-close while open. The listener is intentionally scoped to the
   // open lifetime so stacked dialogs don't fight for the keydown — the
   // top-most one wins via document-level event order. Escape honors
@@ -328,7 +354,7 @@ function CenterOrSideDialog({
               // The fade rides on the LAYERS, never on the press target: an
               // opacity animation on the blur's ancestor composites the group in
               // isolation and leaves `backdrop-filter` nothing to sample.
-              layerStyle={isClosing ? BACKDROP_FADE_OUT : BACKDROP_FADE_IN}
+              progress={backdropFade}
               style={{
                 position: WEB_POSITION_FIXED,
                 zIndex: dialogZIndex.backdrop,
@@ -877,8 +903,6 @@ const sheetStyles: Record<'root' | 'backdrop' | 'panel', ViewStyle> = {
  * injection is guarded by a unique style id.
  *
  * ```css
- * @keyframes bloomDialogFadeIn { from { opacity: 0; } to { opacity: 1; } }
- * @keyframes bloomDialogFadeOut { from { opacity: 1; } to { opacity: 0; } }
  * @keyframes bloomDialogZoomFadeIn { from { opacity: 0; transform: scale(0.95); } to { opacity: 1; transform: scale(1); } }
  * @keyframes bloomDialogZoomFadeOut { from { opacity: 1; transform: scale(1); } to { opacity: 0; transform: scale(0.95); } }
  * ```
@@ -888,8 +912,6 @@ const sheetStyles: Record<'root' | 'backdrop' | 'panel', ViewStyle> = {
  * `bottom` placement uses bloom's `BottomSheet` (reanimated) and needs none.
  */
 export const BLOOM_DIALOG_CSS = `
-@keyframes bloomDialogFadeIn { from { opacity: 0; } to { opacity: 1; } }
-@keyframes bloomDialogFadeOut { from { opacity: 1; } to { opacity: 0; } }
 @keyframes bloomDialogZoomFadeIn { from { opacity: 0; transform: scale(0.95); } to { opacity: 1; transform: scale(1); } }
 @keyframes bloomDialogZoomFadeOut { from { opacity: 1; transform: scale(1); } to { opacity: 0; transform: scale(0.95); } }
 `;

package/src/toast/Toaster.tsx

@@ -30,6 +30,7 @@ import type {
   ToastProps,
 } from './types';
 import { useAppStateChange } from './use-app-state';
+import { useSingleOutletGuard } from './use-single-outlet-guard';
 
 const ALL_POSITIONS: ToastPosition[] = [
   'top-center',
@@ -79,6 +80,11 @@ export const Toaster: React.FC<ToasterProps> = ({
   style,
   styles: styleOverrides,
 }) => {
+  // Before any early return, and independent of whether a toast is up: a second
+  // outlet duplicates every row from the moment it mounts, not from the first
+  // toast, so the warning must not wait for one.
+  useSingleOutletGuard();
+
   const { toasts, shouldShowOverlay, toastHeights, isExpanded } =
     React.useSyncExternalStore(
       toastStore.subscribe,

package/src/toast/use-single-outlet-guard.ts

@@ -0,0 +1,72 @@
+/**
+ * Bloom-original — the dev-only guard against a SECOND toast outlet.
+ *
+ * Every `Toaster` subscribes to the ONE module-level `toastStore`, which has no
+ * notion of an owning outlet, so N mounted outlets each render the full row set:
+ * a toast appears N times. Nothing in the engine can dedupe that — the outlets
+ * are legitimate, independent subscribers — so the contract is "mount exactly
+ * one" and this is what enforces it.
+ *
+ * WHY A WARNING IS WORTH ITS WEIGHT: the copies are not visually separated, so
+ * the defect does not look like duplication. Two bare outlets take identical
+ * defaults and land pixel-identical; two outlets whose `offset` differs by a
+ * point land 1px apart. Only counting the rendered rows reveals it, which is not
+ * something anyone thinks to do — the reports this guard comes from all read as
+ * "the toast looks wrong", never as "there are two of them". Stacking is on by
+ * default, so a duplicate outlet now doubles the rows INSIDE a stack.
+ *
+ * The counter is decremented on unmount, so a remount, a route change that moves
+ * the outlet, Fast Refresh and React's StrictMode double-invoke (setup, cleanup,
+ * setup) all pass through a count of 1 and stay silent. The latch keeps the
+ * warning to exactly one per module lifetime rather than one per extra outlet,
+ * and — because StrictMode replays the setups — one per app, not two.
+ *
+ * Gated on `process.env.NODE_ENV`, the same mechanism as
+ * `content-panel/nesting-context.ts`: Metro and Vite/Rolldown both fold it
+ * statically, so production keeps the counter, the branch and the message out of
+ * the bundle entirely. Deliberately NOT `__DEV__`, which is a Metro global that a
+ * plain web bundler does not define. It only ever warns — a duplicate outlet
+ * renders a redundant toast, it does not break the app, so it must never throw.
+ */
+import * as React from 'react';
+
+let mountedOutlets = 0;
+let hasWarned = false;
+
+export function useSingleOutletGuard(): void {
+  React.useEffect(() => {
+    if (process.env.NODE_ENV === 'production') {
+      return;
+    }
+
+    mountedOutlets += 1;
+    if (mountedOutlets > 1 && !hasWarned) {
+      hasWarned = true;
+      // Internal Bloom diagnostic: the consumer's tree is the only place this
+      // can be fixed, so it names the usual cause rather than just the symptom.
+      // eslint-disable-next-line no-console
+      console.warn(
+        `[Bloom] Toaster: ${mountedOutlets} toast outlets are mounted, so every ` +
+          'toast renders once per outlet. The copies overlap almost exactly, so ' +
+          'this reads as a rendering glitch rather than as duplicate rows. Mount ' +
+          "exactly one: @oxyhq/services' OxyProvider already renders a " +
+          'ToastOutlet, so an app that uses it must not render its own.',
+      );
+    }
+
+    return () => {
+      mountedOutlets -= 1;
+    };
+  }, []);
+}
+
+/**
+ * Test-only reset: both the counter and the one-shot latch are module state that
+ * outlives a render tree, so without this the first suite to mount two outlets
+ * would latch the warning and leave every later suite asserting against a guard
+ * that can no longer fire — passing whatever the implementation did.
+ */
+export function resetSingleOutletGuardForTests(): void {
+  mountedOutlets = 0;
+  hasWarned = false;
+}