@q9labsai/chalk-react-native 4.1.12 → 4.1.14

package/src/telemetry.test.ts

@@ -1,143 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-import { createTelemetry, getNativeJourneyContext, registerNativeJourneyContext, syncTransportCloseDiagnostic, type RtcPeerConnection, type TelemetryJourney } from "./telemetry";
-
-describe("createTelemetry", () => {
-  it("bounds Sync transport close diagnostics without recording raw reasons", () => {
-    expect(syncTransportCloseDiagnostic({ code: 1008, reason: "invalid token" })).toEqual({
-      category: "network",
-      code: "sync_websocket_closed_1008_invalid_token",
-      phase: "signaling",
-      state: "failed",
-    });
-    expect(syncTransportCloseDiagnostic({ code: 1008, reason: "secret detail" }).code).toBe("sync_websocket_closed_1008_other");
-    expect(syncTransportCloseDiagnostic({ code: 1000, reason: "" }).state).toBe("observed");
-  });
-
-  it("propagates one journey through API and sync transport configuration", () => {
-    const journey = createJourney();
-    const telemetry = createTelemetry(journey);
-
-    expect(telemetry.connection).toEqual({
-      apiHeaders: journey.headers,
-      context: journey.context,
-      syncCorrelation: {
-        journey_id: journey.context.journeyId,
-        traceparent: journey.context.traceparent,
-        tracestate: journey.context.tracestate,
-      },
-    });
-
-    telemetry.recordSyncFrame({ direction: "client_to_server", frameType: "space.join" });
-    expect(journey.recordSyncFrame).toHaveBeenCalledWith({ direction: "client_to_server", frameType: "space.join" });
-  });
-
-  it("records production whiteboard metrics without forwarding renderer attributes", () => {
-    const journey = createJourney();
-    const telemetry = createTelemetry(journey);
-
-    telemetry.recordWhiteboardMetric({
-      name: "whiteboard.renderer.termination",
-      value: 1,
-      attributes: { renderer_generation: "private-cardinality-value" },
-    });
-
-    expect(journey.recordDiagnostic).toHaveBeenCalledWith({
-      category: "whiteboard_renderer",
-      code: "whiteboard.renderer.termination",
-      metricValue: 1,
-      phase: "media",
-      state: "failed",
-    });
-  });
-
-  it("keeps the native client journey seam private and exact-client scoped", () => {
-    const journey = createJourney();
-    const telemetry = createTelemetry(journey);
-    const client = {};
-    registerNativeJourneyContext(client, journey, telemetry);
-
-    expect(getNativeJourneyContext(client)).toMatchObject({
-      journeyId: journey.context.journeyId,
-      traceparent: journey.context.traceparent,
-      tracestate: journey.context.tracestate,
-    });
-    getNativeJourneyContext(client)?.recordWhiteboardMetric({ name: "whiteboard.renderer.ready", value: 1 });
-    expect(journey.recordDiagnostic).toHaveBeenCalledWith({
-      category: "whiteboard_renderer",
-      code: "whiteboard.renderer.ready",
-      metricValue: 1,
-      phase: "media",
-      state: "observed",
-    });
-    expect(getNativeJourneyContext({})).toBeUndefined();
-  });
-
-  it("records aggregate RTC summaries from native peer-connection stats", async () => {
-    const journey = createJourney();
-    const telemetry = createTelemetry(journey);
-    const peerConnection = createPeerConnection();
-    const stop = telemetry.observePeerConnection(peerConnection);
-
-    peerConnection.connectionState = "connected";
-    peerConnection.emit("connectionstatechange");
-
-    await vi.waitFor(() => expect(journey.recordRtcSummary).toHaveBeenCalled());
-    expect(journey.recordRtcSummary).toHaveBeenLastCalledWith({ connectionState: "connected", iceConnectionState: "completed", signalingState: "stable" }, [
-      { type: "inbound-rtp", bytesReceived: 1200, packetsLost: 2 },
-      { type: "candidate-pair", roundTripTime: 0.03 },
-    ]);
-
-    stop();
-    peerConnection.emit("iceconnectionstatechange");
-    expect(journey.recordRtcSummary).toHaveBeenCalledTimes(2);
-  });
-});
-
-function createJourney(): TelemetryJourney & {
-  recordDiagnostic: ReturnType<typeof vi.fn>;
-  recordRtcSummary: ReturnType<typeof vi.fn>;
-  recordSyncFrame: ReturnType<typeof vi.fn>;
-} {
-  return {
-    context: {
-      journeyId: "00000000-0000-4000-8000-000000000001",
-      rootJourneyId: "00000000-0000-4000-8000-000000000001",
-      traceparent: "00-4bf92f3577b34da6a3ce929d0e0e4736-00f067aa0ba902b7-01",
-      tracestate: "chalk=mobile",
-    },
-    headers: {
-      "x-chalk-journey-id": "00000000-0000-4000-8000-000000000001",
-      traceparent: "00-4bf92f3577b34da6a3ce929d0e0e4736-00f067aa0ba902b7-01",
-    },
-    recordDiagnostic: vi.fn(),
-    recordRtcSummary: vi.fn(),
-    recordSyncFrame: vi.fn(),
-  };
-}
-
-function createPeerConnection(): RtcPeerConnection & { emit(event: "connectionstatechange" | "iceconnectionstatechange" | "signalingstatechange"): void; connectionState: string } {
-  const listeners = new Map<string, Set<() => void>>();
-
-  return {
-    connectionState: "connecting",
-    iceConnectionState: "completed",
-    signalingState: "stable",
-    addEventListener(event, listener) {
-      const eventListeners = listeners.get(event) ?? new Set();
-      eventListeners.add(listener);
-      listeners.set(event, eventListeners);
-    },
-    removeEventListener(event, listener) {
-      listeners.get(event)?.delete(listener);
-    },
-    async getStats() {
-      return new Map([
-        ["inbound", { type: "inbound-rtp", bytesReceived: 1200, packetsLost: 2 }],
-        ["pair", { type: "candidate-pair", roundTripTime: 0.03 }],
-      ]);
-    },
-    emit(event) {
-      for (const listener of listeners.get(event) ?? []) listener();
-    },
-  };
-}

package/src/test-support/test-renderer.test.ts

@@ -1,9 +0,0 @@
-import { describe, expect, it } from "vitest";
-
-import { renderHook } from "./test-renderer";
-
-describe("test renderer", () => {
-  it("loads the workspace renderHook harness", () => {
-    expect(renderHook).toBeTypeOf("function");
-  });
-});

package/src/test-support/test-renderer.ts

@@ -1,28 +0,0 @@
-/// <reference types="node" />
-
-import { createRequire } from "node:module";
-import { join } from "node:path";
-import type { ComponentType, ReactNode } from "react";
-
-type RenderHookOptions<Props> = {
-  readonly initialProps?: Props;
-  readonly wrapper?: ComponentType<{ readonly children?: ReactNode }>;
-};
-
-type RenderHookResult<Result, Props> = {
-  readonly result: { readonly current: Result };
-  readonly rerender: (props?: Props) => void;
-  readonly unmount: () => void;
-};
-
-type RenderHook = <Result, Props = undefined>(callback: (props: Props) => Result, options?: RenderHookOptions<Props>) => RenderHookResult<Result, Props>;
-type Act = (callback: () => void | Promise<void>) => void | Promise<void>;
-type WaitFor = (callback: () => void | Promise<void>) => Promise<void>;
-
-const testingLibrary = createRequire(import.meta.url)(join(process.cwd(), "../react/node_modules", "@" + "testing-library", "react")) as {
-  readonly act: Act;
-  readonly renderHook: RenderHook;
-  readonly waitFor: WaitFor;
-};
-
-export const { act, renderHook, waitFor } = testingLibrary;

package/src/ui/appearance.test.ts

@@ -1,61 +0,0 @@
-import { describe, expect, it } from "vitest";
-
-import { THEME_PALETTES as REACT_THEME_PALETTES, THEME_TEXTURES as REACT_THEME_TEXTURES } from "../../../react/src/components/theme";
-
-import { getThemeMode, isDarkThemePalette, resolveNativeAppearance, THEME_PALETTES, THEME_TEXTURES } from "./appearance";
-
-describe("React Native appearance catalog", () => {
-  it("keeps palette and texture metadata in parity with React", () => {
-    expect(THEME_PALETTES.map(({ value, label, family, mode, swatch }) => ({ value, label, family, mode, swatch }))).toEqual(REACT_THEME_PALETTES);
-    expect(THEME_TEXTURES.map(({ value, label, description }) => ({ value, label, description }))).toEqual(REACT_THEME_TEXTURES);
-    expect(THEME_PALETTES).toHaveLength(16);
-    expect(THEME_PALETTES.filter((palette) => palette.mode === "light")).toHaveLength(8);
-    expect(THEME_PALETTES.filter((palette) => palette.mode === "dark")).toHaveLength(8);
-    expect(THEME_TEXTURES.map((texture) => texture.value)).toEqual(["none", "paper", "slate"]);
-  });
-
-  it("carries every CSS appearance token as a native value", () => {
-    for (const palette of THEME_PALETTES) {
-      expect(palette.tokens.canvas).toMatch(/^#[0-9a-f]{6}$/);
-      expect(palette.tokens.tileColorStrength).toBeGreaterThan(0);
-      expect(palette.tokens.tileColorStrength).toBeLessThanOrEqual(1);
-      expect(palette.tokens.shadows.xs.offset.width).toBe(0);
-      expect(palette.tokens.shadows.sm.radius).toBeGreaterThanOrEqual(0);
-      expect(palette.tokens.shadows.control.elevation).toBeGreaterThanOrEqual(0);
-    }
-
-    expect(THEME_PALETTES[0].tokens).toMatchObject({ canvas: "#f7f6f2", panel: "#ffffff", controlPrimary: "#202329", input: "#fbfaf7" });
-    expect(THEME_PALETTES.find((palette) => palette.value === "warm-porcelain")?.tokens).toMatchObject({ canvas: "#f2ebe2", stage: "#eee4dc", controlPrimary: "#51443c" });
-    expect(THEME_PALETTES.find((palette) => palette.value === "cosmic-chalk")?.tokens).toMatchObject({
-      canvas: "#080f20",
-      chrome: "#10182b",
-      panel: "#10182b",
-      stage: "#0b1427",
-      text: "#f4ecd7",
-      textMuted: "#aeb8c9",
-      controlActiveLine: "#8fdcff",
-      controlPrimary: "#8fdcff",
-      messageLocalText: "#080f20",
-    });
-    expect(THEME_PALETTES.find((palette) => palette.value === "oled-signal")?.tokens).toMatchObject({ canvas: "#000000", stage: "#000000", shadows: { xs: { opacity: 0 }, sm: { opacity: 0 } } });
-  });
-
-  it("resolves mode and native texture primitives independently", () => {
-    expect(isDarkThemePalette("warm-charcoal")).toBe(true);
-    expect(isDarkThemePalette("warm-porcelain")).toBe(false);
-    expect(getThemeMode("prism-nocturne")).toBe("dark");
-    expect(getThemeMode("prism-daylight")).toBe("light");
-
-    expect(resolveNativeAppearance()).toMatchObject({ palette: "light", mode: "light", texture: "none", textureDescriptor: { kind: "none", opacity: 0, tileSize: null } });
-
-    const lightSlate = resolveNativeAppearance({ palette: "warm-porcelain", texture: "slate" });
-    expect(lightSlate.mode).toBe("light");
-    expect(lightSlate.tokens.canvas).toBe("#f2ebe2");
-    expect(lightSlate.textureDescriptor).toMatchObject({ kind: "slate", blendMode: "multiply", opacity: 0.16, lines: { color: "#0c0e12", opacity: 0.022 } });
-
-    const darkSlate = resolveNativeAppearance({ palette: "oled-signal", texture: "slate" });
-    expect(darkSlate.mode).toBe("dark");
-    expect(darkSlate.tokens.canvas).toBe("#000000");
-    expect(darkSlate.textureDescriptor).toMatchObject({ kind: "slate", blendMode: "soft-light", opacity: 0.2, lines: { color: "#ffffff", opacity: 0.018 } });
-  });
-});

package/src/ui/native-appearance-context.controlled.test.tsx

@@ -1,41 +0,0 @@
-// @vitest-environment happy-dom
-
-import type { ReactNode } from "react";
-import { describe, expect, it, vi } from "vitest";
-
-import { act, renderHook } from "../test-support/test-renderer";
-
-vi.mock("react-native", () => ({
-  StyleSheet: { absoluteFill: {}, create: (styles: unknown) => styles },
-  View: ({ children }: { readonly children?: ReactNode }) => children,
-}));
-
-import { NativeAppearanceProvider, useNativeAppearance } from "./native-appearance-context";
-
-describe("NativeAppearanceProvider controlled initial appearance", () => {
-  it("updates palette and texture without replacing its child", () => {
-    let initialAppearance = { palette: "light" as const, texture: "none" as const };
-    const wrapper = ({ children }: { readonly children?: ReactNode }): React.JSX.Element => <NativeAppearanceProvider initialAppearance={initialAppearance}>{children}</NativeAppearanceProvider>;
-    const { result, rerender } = renderHook(() => useNativeAppearance(), { wrapper });
-
-    expect(result.current.appearance.palette).toBe("light");
-    expect(result.current.appearance.texture).toBe("none");
-
-    initialAppearance = { palette: "warm-porcelain", texture: "paper" };
-    rerender();
-
-    expect(result.current.appearance.palette).toBe("warm-porcelain");
-    expect(result.current.appearance.texture).toBe("paper");
-  });
-
-  it("updates appearance when controls change", () => {
-    const wrapper = ({ children }: { readonly children?: ReactNode }): React.JSX.Element => <NativeAppearanceProvider>{children}</NativeAppearanceProvider>;
-    const { result } = renderHook(() => useNativeAppearance(), { wrapper });
-
-    act(() => result.current.setPalette("warm-porcelain"));
-    act(() => result.current.setTexture("paper"));
-
-    expect(result.current.appearance.palette).toBe("warm-porcelain");
-    expect(result.current.appearance.texture).toBe("paper");
-  });
-});

package/src/ui/native-appearance-context.test.tsx

@@ -1,14 +0,0 @@
-import { readFileSync } from "node:fs";
-import { describe, expect, it } from "vitest";
-
-const source = readFileSync(new URL("./native-appearance-context.tsx", import.meta.url), "utf8");
-
-describe("NativeAppearanceProvider", () => {
-  it("resolves local selections and renders inert textures", () => {
-    expect(source).toContain("resolveNativeAppearance(selection)");
-    expect(source).toContain("setPalette:");
-    expect(source).toContain("setTexture:");
-    expect(source).toContain('pointerEvents="none"');
-    expect(source).toContain("must be used inside NativeAppearanceProvider");
-  });
-});

package/src/ui/native-theme.test.ts

@@ -1,34 +0,0 @@
-import { describe, expect, it } from "vitest";
-
-import { resolveNativeAppearance } from "./appearance";
-import { resolveNativeTheme } from "./native-theme";
-
-describe("resolveNativeTheme", () => {
-  it("resolves the public color scheme, accent, and token overrides into semantic colors", () => {
-    const theme = resolveNativeTheme({
-      colorScheme: "light",
-      accent: "#7c3aed",
-      tokens: { canvas: "#fefce8", text: "#1c1917" },
-    });
-
-    expect(theme.colorScheme).toBe("light");
-    expect(theme.colors).toMatchObject({
-      background: "#fefce8",
-      foreground: "#1c1917",
-      primary: "#7c3aed",
-      ring: "#7c3aed",
-      stageBackground: "#e2e8f0",
-    });
-  });
-
-  it("projects the selected native palette into rendered theme colors", () => {
-    const appearance = resolveNativeAppearance({ palette: "warm-porcelain", texture: "paper" });
-    const theme = resolveNativeTheme(undefined, appearance);
-
-    expect(theme.colorScheme).toBe("light");
-    expect(theme.colors.background).toBe(appearance.tokens.canvas);
-    expect(theme.colors.foreground).toBe(appearance.tokens.text);
-    expect(theme.colors.stageBackground).toBe(appearance.tokens.stage);
-    expect(theme.colors.primary).toBe(appearance.tokens.controlPrimary);
-  });
-});

package/src/ui/native-theme.test.tsx

@@ -1,14 +0,0 @@
-import { describe, expect, it } from "vitest";
-
-import { resolveNativeTheme } from "./native-theme";
-
-describe("resolveNativeTheme", () => {
-  it("uses dark defaults while allowing semantic token overrides", () => {
-    const theme = resolveNativeTheme({ tokens: { focus: "#f59e0b", positive: "#15803d" } });
-
-    expect(theme.colorScheme).toBe("dark");
-    expect(theme.colors.darkCanvas).toBe("#0a0a0b");
-    expect(theme.colors.ring).toBe("#f59e0b");
-    expect(theme.colors.success).toBe("#15803d");
-  });
-});

package/src/ui/participant-avatar.test.ts

@@ -1,29 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { getParticipantAvatarRecipe, getParticipantColor, getParticipantInitials, PARTICIPANT_AVATAR_PALETTE } from "./participant-avatar";
-
-describe("participant identity colors", () => {
-  it("chooses one approved flat identity color deterministically", () => {
-    const first = getParticipantColor("Avery Chen");
-    const second = getParticipantColor("Avery Chen");
-
-    expect(first).toEqual(second);
-    expect(PARTICIPANT_AVATAR_PALETTE.map(({ primary }) => primary)).toContain(first.primary);
-    expect(first.gradientEnd).toBe(first.primary);
-  });
-
-  it("keeps avatar recipes flat for compatibility consumers", () => {
-    const recipe = getParticipantAvatarRecipe("Avery Chen");
-
-    expect(recipe.gradientStops).toEqual([
-      { color: recipe.colors.primary, offset: "0%" },
-      { color: recipe.colors.primary, offset: "100%" },
-    ]);
-    expect(recipe.facehashColors).toEqual([recipe.colors.primary, recipe.colors.primary, recipe.colors.primary]);
-  });
-
-  it("returns one or two initials without making identity noun assumptions", () => {
-    expect(getParticipantInitials("Avery Chen")).toBe("AC");
-    expect(getParticipantInitials("Avery")).toBe("A");
-    expect(getParticipantInitials()).toBe("?");
-  });
-});

package/src/ui/theme-tokens.test.ts

@@ -1,14 +0,0 @@
-import { describe, expect, it } from "vitest";
-
-import { DEFAULT_CHALK_THEME_TOKENS, LIGHT_CHALK_THEME_TOKENS } from "./theme-tokens";
-
-describe("Chalk theme tokens", () => {
-  it("keeps dark and light themes on the same semantic token contract", () => {
-    const tokenNames = ["canvas", "chrome", "surface", "stage", "text", "mutedText", "line", "accent", "accentText", "positive", "danger", "dangerSurface", "focus", "shadow"];
-
-    expect(Object.keys(DEFAULT_CHALK_THEME_TOKENS)).toEqual(tokenNames);
-    expect(Object.keys(LIGHT_CHALK_THEME_TOKENS)).toEqual(tokenNames);
-    expect(DEFAULT_CHALK_THEME_TOKENS.canvas).not.toBe(LIGHT_CHALK_THEME_TOKENS.canvas);
-    expect(DEFAULT_CHALK_THEME_TOKENS.accent).not.toBe(LIGHT_CHALK_THEME_TOKENS.accent);
-  });
-});

package/src/ui/theme.test.ts

@@ -1,36 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { createNativeTheme, Theme } from "./theme";
-
-describe("native theme aliases", () => {
-  it("keeps progressive surfaces on the active token set", () => {
-    expect(Theme.colors.paper).toBe(Theme.colors.background);
-    expect(Theme.colors.ink).toBe(Theme.colors.foreground);
-    expect(Theme.colors.lineStrong).toBe(Theme.colors.border);
-    expect(Theme.colors.chalkGreen).toBe(Theme.colors.success);
-  });
-
-  it("resolves the same aliases for light mode", () => {
-    const light = createNativeTheme(
-      {
-        canvas: "#f8fafc",
-        chrome: "#ffffff",
-        surface: "#f1f5f9",
-        stage: "#e2e8f0",
-        text: "#0f172a",
-        mutedText: "#475569",
-        line: "#cbd5e1",
-        accent: "#0f766e",
-        accentText: "#ffffff",
-        positive: "#15803d",
-        danger: "#b91c1c",
-        dangerSurface: "#fee2e2",
-        focus: "#0f766e",
-        shadow: "#0f172a",
-      },
-      "light",
-    );
-    expect(light.colors.paper).toBe(light.colors.background);
-    expect(light.colors.ink).toBe(light.colors.foreground);
-    expect(light.colors.primary).toBe("#0f766e");
-  });
-});

package/src/utils/build-chalk-invite-link.test.ts

@@ -1,12 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { buildChalkInviteLink } from "./build-chalk-invite-link";
-
-describe("buildChalkInviteLink", () => {
-  it("builds a canonical Space invite link with the public host", () => {
-    expect(buildChalkInviteLink("design-lab", "cspi1.key.payload.signature")).toBe("https://chalkmeet.com/space/design-lab#spaceInviteToken=cspi1.key.payload.signature");
-  });
-
-  it("normalizes trailing slashes on custom origins", () => {
-    expect(buildChalkInviteLink("design-lab", "cspi1.key.payload.signature", "https://chalk.q9labs.ai/")).toBe("https://chalk.q9labs.ai/space/design-lab#spaceInviteToken=cspi1.key.payload.signature");
-  });
-});

package/src/utils/ios-simulator.test.ts

@@ -1,96 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from "vitest";
-
-const nativeModules = {
-  ChalkRuntimeInfo: { isSimulator: true },
-  WebRTCModule: {
-    receiverGetCapabilities: vi.fn(() => {
-      throw new Error("native receiver call should be bypassed on simulator");
-    }),
-    senderGetCapabilities: vi.fn(() => {
-      throw new Error("native sender call should be bypassed on simulator");
-    }),
-  },
-};
-
-const mockedMediaDevices = {
-  enumerateDevices: vi.fn(async () => {
-    throw new Error("mediaDevices.enumerateDevices should be bypassed on simulator");
-  }),
-};
-
-vi.mock("react-native", () => ({
-  NativeModules: nativeModules,
-  Platform: { OS: "ios" },
-}));
-
-describe("ensureIosSimulatorWebRtcSafety", () => {
-  beforeEach(() => {
-    vi.resetModules();
-    nativeModules.ChalkRuntimeInfo.isSimulator = true;
-    nativeModules.WebRTCModule.receiverGetCapabilities = vi.fn(() => {
-      throw new Error("native receiver call should be bypassed on simulator");
-    });
-    nativeModules.WebRTCModule.senderGetCapabilities = vi.fn(() => {
-      throw new Error("native sender call should be bypassed on simulator");
-    });
-    delete (globalThis as Record<string, unknown>).RTCRtpReceiver;
-    delete (globalThis as Record<string, unknown>).RTCRtpSender;
-    mockedMediaDevices.enumerateDevices = vi.fn(async () => {
-      throw new Error("mediaDevices.enumerateDevices should be bypassed on simulator");
-    });
-  });
-
-  it("patches native capability lookups on the iOS simulator", async () => {
-    const { ensureIosSimulatorWebRtcSafety } = await import("./ios-simulator");
-
-    ensureIosSimulatorWebRtcSafety();
-
-    expect(nativeModules.WebRTCModule.receiverGetCapabilities("video")).toEqual({
-      codecs: [],
-      headerExtensions: [],
-    });
-    expect(nativeModules.WebRTCModule.senderGetCapabilities("audio")).toEqual({
-      codecs: [],
-      headerExtensions: [],
-    });
-  });
-
-  it("patches exported RTCRtp capability helpers when available", async () => {
-    const { ensureIosSimulatorWebRtcSafety } = await import("./ios-simulator");
-
-    const receiver = {
-      getCapabilities: vi.fn(() => {
-        throw new Error("receiver helper should be patched");
-      }),
-    };
-    const sender = {
-      getCapabilities: vi.fn(() => {
-        throw new Error("sender helper should be patched");
-      }),
-    };
-
-    ensureIosSimulatorWebRtcSafety({
-      RTCRtpReceiver: receiver,
-      RTCRtpSender: sender,
-    });
-
-    expect(receiver.getCapabilities("video")).toEqual({
-      codecs: [],
-      headerExtensions: [],
-    });
-    expect(sender.getCapabilities("audio")).toEqual({
-      codecs: [],
-      headerExtensions: [],
-    });
-  });
-
-  it("patches media device enumeration on the iOS simulator", async () => {
-    const { ensureIosSimulatorWebRtcSafety } = await import("./ios-simulator");
-
-    ensureIosSimulatorWebRtcSafety({
-      mediaDevices: mockedMediaDevices,
-    });
-
-    await expect(mockedMediaDevices.enumerateDevices()).resolves.toEqual([]);
-  });
-});