@q9labsai/chalk-react-native 4.1.11 → 4.1.13

package/src/components/native-space-view/SpaceTopBar.android.tsx

@@ -3,6 +3,7 @@ import { HugeiconsIcon } from "@hugeicons/react-native";
 import { Image, Platform, StyleSheet, Text, View } from "react-native";
 import { Theme } from "../../ui/theme";
 import { useNativeTheme } from "../../ui/native-theme";
+import { Logo } from "../logo/Logo";
 
 export interface SpaceTopBarProps {
   spaceName: string;
@@ -16,7 +17,7 @@ export function SpaceTopBarAndroid({ spaceName, participantCount, formattedDurat
   return (
     <View style={[styles.topBar, { backgroundColor: theme.colors.darkCanvas, borderColor: theme.colors.border }]}>
       <View style={styles.topBarLeft}>
-        {logoUrl ? <Image accessibilityLabel="Chalk" source={{ uri: logoUrl }} style={styles.logo} /> : null}
+        {logoUrl ? <Image accessibilityLabel="Chalk" source={{ uri: logoUrl }} style={styles.logo} /> : <Logo height={24} variant="mark" />}
         <View style={[styles.connectionDot, { backgroundColor: theme.colors.success }]} />
         <Text style={[styles.topBarSpaceName, { color: theme.colors.foreground }]} numberOfLines={1}>
           {spaceName}

package/src/index.ts

@@ -2,6 +2,8 @@ export { Chalk } from "./components/Chalk";
 export type { ChalkFeatures, ChalkProps, ChalkTheme, ChalkThemeTokens, SpaceLayout } from "./components/Chalk";
 export { Entrance } from "./components/Entrance";
 export type { EntranceProps, EntranceSettings } from "./components/Entrance";
+export { Logo } from "./components/logo/Logo";
+export type { LogoMotion, LogoProps, LogoVariant } from "./components/logo/Logo";
 export { ChalkProvider, useSpaceClient } from "./context/space-client-context";
 export type { ChalkProviderProps } from "./context/space-client-context";
 export { useCan, useChat, useConnection, useMedia, useParticipants, useReactions, useSelf, useWhiteboard } from "./hooks/space-hooks";

package/src/space-client/create-native-space-client.ts

@@ -144,6 +144,7 @@ function createMediaClient(apiBaseURL: string, input: MediaFactoryInput, fetch:
     });
     return createRTKConnectionMediaClient(client);
   }
+  const replaceMediaConnection = input.replaceMediaConnection;
   const client = new CloudflareSFUClient({
     bootstrap: input.access.media.clientPayload,
     participantId: subject.participantId,
@@ -156,6 +157,13 @@ function createMediaClient(apiBaseURL: string, input: MediaFactoryInput, fetch:
       participantId: subject.participantId,
       fetch,
     }),
+    replaceMediaConnection: replaceMediaConnection
+      ? async () => {
+          const replacement = await replaceMediaConnection();
+          if (replacement.provider !== "cloudflare_sfu") throw new TypeError("The Cloudflare SFU adapter requires a Cloudflare SFU access grant");
+          return replacement.clientPayload;
+        }
+      : undefined,
     peerConnectionFactory: (configuration) => {
       const connection = new RTCPeerConnection(configuration);
       observePeerConnection?.(connection as unknown as RtcPeerConnection);

package/dist/components/LogoElements.d.ts

@@ -1,6 +0,0 @@
-interface LogoElementsProps {
-    size?: number;
-}
-export declare function LogoElements({ size }: LogoElementsProps): React.JSX.Element;
-export {};
-//# sourceMappingURL=LogoElements.d.ts.map

package/dist/components/LogoElements.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"LogoElements.d.ts","sourceRoot":"","sources":["../../src/components/LogoElements.tsx"],"names":[],"mappings":"AASA,UAAU,iBAAiB;IACzB,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED,wBAAgB,YAAY,CAAC,EAAE,IAAS,EAAE,EAAE,iBAAiB,GAAG,KAAK,CAAC,GAAG,CAAC,OAAO,CAyGhF"}

package/dist/test-support/test-renderer.d.ts

@@ -1,20 +0,0 @@
-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>;
-export declare const act: Act, renderHook: RenderHook, waitFor: WaitFor;
-export {};
-//# sourceMappingURL=test-renderer.d.ts.map

package/dist/test-support/test-renderer.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"test-renderer.d.ts","sourceRoot":"","sources":["../../src/test-support/test-renderer.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,aAAa,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AAEtD,KAAK,iBAAiB,CAAC,KAAK,IAAI;IAC9B,QAAQ,CAAC,YAAY,CAAC,EAAE,KAAK,CAAC;IAC9B,QAAQ,CAAC,OAAO,CAAC,EAAE,aAAa,CAAC;QAAE,QAAQ,CAAC,QAAQ,CAAC,EAAE,SAAS,CAAA;KAAE,CAAC,CAAC;CACrE,CAAC;AAEF,KAAK,gBAAgB,CAAC,MAAM,EAAE,KAAK,IAAI;IACrC,QAAQ,CAAC,MAAM,EAAE;QAAE,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;KAAE,CAAC;IAC9C,QAAQ,CAAC,QAAQ,EAAE,CAAC,KAAK,CAAC,EAAE,KAAK,KAAK,IAAI,CAAC;IAC3C,QAAQ,CAAC,OAAO,EAAE,MAAM,IAAI,CAAC;CAC9B,CAAC;AAEF,KAAK,UAAU,GAAG,CAAC,MAAM,EAAE,KAAK,GAAG,SAAS,EAAE,QAAQ,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,MAAM,EAAE,OAAO,CAAC,EAAE,iBAAiB,CAAC,KAAK,CAAC,KAAK,gBAAgB,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;AACzJ,KAAK,GAAG,GAAG,CAAC,QAAQ,EAAE,MAAM,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;AAC1E,KAAK,OAAO,GAAG,CAAC,QAAQ,EAAE,MAAM,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;AAQvE,eAAO,MAAQ,GAAG,OAAE,UAAU,cAAE,OAAO,SAAmB,CAAC"}

package/src/android/connection-service.test.ts

@@ -1,114 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from "vitest";
-
-const nativeModule = {
-  addListener: vi.fn(),
-  endCall: vi.fn(async () => true),
-  isSupported: vi.fn(async () => true),
-  registerPhoneAccount: vi.fn(async () => true),
-  removeListeners: vi.fn(),
-  setActive: vi.fn(async () => true),
-  startCall: vi.fn(async () => true),
-};
-
-const subscriptions = new Map<string, (payload: unknown) => void>();
-const platform = { OS: "android" };
-
-class MockNativeEventEmitter {
-  addListener(eventName: string, listener: (payload: unknown) => void) {
-    subscriptions.set(eventName, listener);
-    return {
-      remove: () => {
-        subscriptions.delete(eventName);
-      },
-    };
-  }
-}
-
-vi.mock("react-native", () => ({
-  NativeEventEmitter: MockNativeEventEmitter,
-  NativeModules: {
-    ChalkAndroidConnectionService: nativeModule,
-  },
-  Platform: platform,
-}));
-
-describe("android connection service bridge", () => {
-  beforeEach(() => {
-    vi.resetModules();
-    vi.clearAllMocks();
-    subscriptions.clear();
-    platform.OS = "android";
-  });
-
-  it("no-ops when Android native support is unavailable", async () => {
-    platform.OS = "ios";
-
-    const { addAndroidConnectionServiceListener, ensureAndroidConnectionServiceRegistered, endAndroidConnectionServiceCall, isAndroidConnectionServiceSupported, setAndroidConnectionServiceActive, startAndroidConnectionServiceCall } = await import("./connection-service");
-
-    expect(await isAndroidConnectionServiceSupported()).toBe(false);
-    expect(await ensureAndroidConnectionServiceRegistered()).toBe(false);
-    expect(
-      await startAndroidConnectionServiceCall({
-        callId: "space-1:1",
-        displayName: "Host",
-        spaceId: "space-1",
-        spaceName: "Daily Standup",
-      }),
-    ).toBe(false);
-    expect(await setAndroidConnectionServiceActive("space-1:1")).toBe(false);
-    expect(await endAndroidConnectionServiceCall("space-1:1")).toBe(false);
-
-    const unsubscribe = addAndroidConnectionServiceListener(() => {
-      throw new Error("listener should not be called on iOS");
-    });
-    unsubscribe();
-
-    expect(nativeModule.isSupported).not.toHaveBeenCalled();
-    expect(nativeModule.registerPhoneAccount).not.toHaveBeenCalled();
-    expect(nativeModule.startCall).not.toHaveBeenCalled();
-    expect(nativeModule.setActive).not.toHaveBeenCalled();
-    expect(nativeModule.endCall).not.toHaveBeenCalled();
-  });
-
-  it("passes through Android native module calls and emits disconnect events", async () => {
-    const { addAndroidConnectionServiceListener, ensureAndroidConnectionServiceRegistered, endAndroidConnectionServiceCall, isAndroidConnectionServiceSupported, setAndroidConnectionServiceActive, startAndroidConnectionServiceCall } = await import("./connection-service");
-
-    expect(await isAndroidConnectionServiceSupported()).toBe(true);
-    expect(await ensureAndroidConnectionServiceRegistered()).toBe(true);
-    expect(
-      await startAndroidConnectionServiceCall({
-        callId: "space-1:2",
-        displayName: "Guest",
-        hasVideo: false,
-        spaceId: "space-1",
-        spaceName: "Board Review",
-      }),
-    ).toBe(true);
-    expect(await setAndroidConnectionServiceActive("space-1:2")).toBe(true);
-    expect(await endAndroidConnectionServiceCall("space-1:2", { reason: "remote", label: "Space ended" })).toBe(true);
-
-    const listener = vi.fn();
-    const unsubscribe = addAndroidConnectionServiceListener(listener);
-    const disconnectPayload = {
-      callId: "space-1:2",
-      reason: "local",
-      type: "disconnect",
-    };
-
-    subscriptions.get("ChalkAndroidConnectionServiceEvent")?.(disconnectPayload);
-    unsubscribe();
-
-    expect(nativeModule.isSupported).toHaveBeenCalledTimes(1);
-    expect(nativeModule.registerPhoneAccount).toHaveBeenCalledTimes(1);
-    expect(nativeModule.startCall).toHaveBeenCalledWith({
-      callId: "space-1:2",
-      displayName: "Guest",
-      hasVideo: false,
-      spaceId: "space-1",
-      spaceName: "Board Review",
-    });
-    expect(nativeModule.setActive).toHaveBeenCalledWith("space-1:2");
-    expect(nativeModule.endCall).toHaveBeenCalledWith("space-1:2", "remote", "Space ended");
-    expect(listener).toHaveBeenCalledWith(disconnectPayload);
-  });
-});

package/src/callkit/resolve-space-callkit-options.test.ts

@@ -1,68 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { resolveSpaceCallKitOptions } from "./resolve-space-callkit-options";
-
-describe("resolveSpaceCallKitOptions", () => {
-  it("returns null when CallKit is disabled", () => {
-    expect(
-      resolveSpaceCallKitOptions({
-        callKit: false,
-        hasVideo: true,
-        spaceId: "space-123",
-        spaceName: "Design Review",
-      }),
-    ).toBeNull();
-  });
-
-  it("fills sensible defaults for enabled Spaces", () => {
-    expect(
-      resolveSpaceCallKitOptions({
-        callKit: true,
-        hasVideo: true,
-        spaceId: "space-123",
-        spaceName: "Design Review",
-      }),
-    ).toEqual({
-      appName: "Chalk",
-      displayName: "Design Review",
-      handle: "space-123",
-      handleType: "generic",
-      hasVideo: true,
-      includesCallsInRecents: false,
-      maximumCallGroups: 1,
-      maximumCallsPerCallGroup: 1,
-      iconTemplateImageName: undefined,
-      ringtoneSound: undefined,
-    });
-  });
-
-  it("prefers explicit overrides from the caller", () => {
-    expect(
-      resolveSpaceCallKitOptions({
-        callKit: {
-          appName: "Chalk Meet",
-          displayName: "Board Space",
-          handle: "board-space",
-          handleType: "emailAddress",
-          hasVideo: false,
-          includesCallsInRecents: true,
-          maximumCallGroups: 2,
-          maximumCallsPerCallGroup: 3,
-          ringtoneSound: "ring.caf",
-        },
-        hasVideo: true,
-        spaceId: "space-123",
-      }),
-    ).toEqual({
-      appName: "Chalk Meet",
-      displayName: "Board Space",
-      handle: "board-space",
-      handleType: "emailAddress",
-      hasVideo: false,
-      includesCallsInRecents: true,
-      maximumCallGroups: 2,
-      maximumCallsPerCallGroup: 3,
-      iconTemplateImageName: undefined,
-      ringtoneSound: "ring.caf",
-    });
-  });
-});

package/src/client.test.ts

@@ -1,12 +0,0 @@
-import type { GetAccess, SpaceClient } from "@q9labsai/chalk-client";
-import { expectTypeOf, test } from "vitest";
-
-import type { NativeSpaceClientOptions } from "./client";
-
-test("the native client subpath exposes the advanced-construction contract", () => {
-  expectTypeOf<NativeSpaceClientOptions>().toMatchTypeOf<{
-    readonly space: string;
-    readonly getAccess: GetAccess;
-  }>();
-  expectTypeOf<typeof import("./client").createNativeSpaceClient>().returns.toEqualTypeOf<SpaceClient>();
-});

package/src/clipboard.test.ts

@@ -1,79 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-import { createClipboardTextStore } from "./clipboard-store";
-
-vi.mock("react-native", () => ({
-  AppState: { addEventListener: vi.fn(() => ({ remove: vi.fn() })) },
-  NativeModules: { ChalkRuntimeInfo: { isSimulator: false } },
-  Platform: { OS: "ios" },
-}));
-
-describe("clipboard invite suggestion hook", () => {
-  it("exposes the extracted clipboard suggestion hook", async () => {
-    const { useClipboardInviteSuggestion } = await import("./clipboard");
-
-    expect(typeof useClipboardInviteSuggestion).toBe("function");
-  });
-});
-
-describe("createClipboardTextStore", () => {
-  it("refreshes on subscription and active app-state events, then stops after unsubscribe", async () => {
-    let appStateListener: ((nextState: string) => void) | undefined;
-    const removeAppStateListener = vi.fn();
-    const clipboard = {
-      hasStringAsync: vi.fn().mockResolvedValue(true),
-      getStringAsync: vi.fn().mockResolvedValue("chalk invite"),
-    };
-    const store = createClipboardTextStore({
-      clipboard,
-      shouldReadClipboard: true,
-      subscribeToAppState: (listener) => {
-        appStateListener = listener;
-        return { remove: removeAppStateListener };
-      },
-    });
-    const listener = vi.fn();
-
-    const unsubscribe = store.subscribe(listener);
-    await Promise.resolve();
-    await Promise.resolve();
-
-    expect(store.getSnapshot()).toBe("chalk invite");
-    expect(listener).toHaveBeenCalledOnce();
-
-    appStateListener?.("active");
-    await Promise.resolve();
-    await Promise.resolve();
-
-    expect(clipboard.hasStringAsync).toHaveBeenCalledTimes(2);
-
-    unsubscribe();
-    expect(removeAppStateListener).toHaveBeenCalledOnce();
-    appStateListener?.("active");
-    await Promise.resolve();
-    await Promise.resolve();
-
-    expect(clipboard.hasStringAsync).toHaveBeenCalledTimes(2);
-  });
-
-  it("does not read the clipboard when the platform policy disables automatic reads", async () => {
-    const clipboard = {
-      hasStringAsync: vi.fn(),
-      getStringAsync: vi.fn(),
-    };
-    const subscribeToAppState = vi.fn();
-    const store = createClipboardTextStore({
-      clipboard,
-      shouldReadClipboard: false,
-      subscribeToAppState,
-    });
-
-    const unsubscribe = store.subscribe(vi.fn());
-    await Promise.resolve();
-
-    expect(store.getSnapshot()).toBeNull();
-    expect(clipboard.hasStringAsync).not.toHaveBeenCalled();
-    expect(subscribeToAppState).not.toHaveBeenCalled();
-
-    unsubscribe();
-  });
-});

package/src/components/Chalk.test.tsx

@@ -1,223 +0,0 @@
-// @vitest-environment happy-dom
-import type { SpaceClient, SpaceSnapshot } from "@q9labsai/chalk-client";
-import { createRequire } from "node:module";
-import { join } from "node:path";
-import type { ReactNode } from "react";
-import { afterEach, describe, expect, it, vi } from "vitest";
-
-const testingLibrary = createRequire(import.meta.url)(join(process.cwd(), "../react/node_modules", "@testing-library/react")) as {
-  readonly act: (callback: () => void | Promise<void>) => void | Promise<void>;
-  readonly cleanup: () => void;
-  readonly render: (element: ReactNode) => { readonly container: HTMLElement; readonly unmount: () => void; readonly rerender: (element: ReactNode) => void };
-};
-const { act, cleanup, render } = testingLibrary;
-
-const nativeClientFactory = vi.hoisted(() => vi.fn());
-const spaceViewSpy = vi.hoisted(() => vi.fn(() => <div data-testid="space" />));
-
-vi.mock("react-native", () => ({
-  StyleSheet: { create: <T,>(styles: T) => styles },
-  View: ({ children }: { readonly children?: ReactNode }) => children,
-  Text: ({ children }: { readonly children?: ReactNode }) => children,
-  Pressable: ({ children }: { readonly children?: ReactNode }) => children,
-}));
-vi.mock("../space-client/create-native-space-client", () => ({ createNativeSpaceClient: nativeClientFactory }));
-vi.mock("./SpaceView", () => ({ SpaceView: spaceViewSpy }));
-vi.mock("./Entrance", () => ({ Entrance: () => <div data-testid="entrance" /> }));
-
-import { Chalk } from "./Chalk";
-
-afterEach(() => {
-  cleanup();
-  nativeClientFactory.mockReset();
-  spaceViewSpy.mockClear();
-});
-
-describe("Chalk", () => {
-  it("fires joined and left only for the specified connection transitions", () => {
-    const client = createClient("joining");
-    const onJoined = vi.fn();
-    const onLeft = vi.fn();
-    render(<Chalk client={client.client} entrance={false} onJoined={onJoined} onLeft={onLeft} />);
-
-    act(() => client.setStatus("live"));
-    act(() => client.setStatus("reconnecting"));
-    act(() => client.setStatus("live"));
-    act(() => client.setStatus("left"));
-
-    expect(onJoined).toHaveBeenCalledTimes(1);
-    expect(onLeft).toHaveBeenCalledTimes(1);
-  });
-
-  it("does not fire joined for an already-live supplied client", () => {
-    const client = createClient("live");
-    const onJoined = vi.fn();
-    render(<Chalk client={client.client} entrance={false} onJoined={onJoined} />);
-
-    expect(onJoined).not.toHaveBeenCalled();
-  });
-
-  it("forwards the optional diagnostics action to the live Space", () => {
-    const client = createClient("live");
-    const onOpenDiagnostics = vi.fn();
-    render(<Chalk client={client.client} onOpenDiagnostics={onOpenDiagnostics} />);
-
-    expect(spaceViewSpy).toHaveBeenCalledWith(expect.objectContaining({ onOpenDiagnostics }), undefined);
-  });
-
-  it("forwards canonical client events and cleans their subscriptions up", () => {
-    const client = createClient("live");
-    const handlers = new Map<string, (event: unknown) => void>();
-    const unsubscribe = vi.fn();
-    const eventClient = client.client as { on: (event: string, handler: unknown) => () => void };
-    eventClient.on = vi.fn((event, handler) => {
-      handlers.set(event, handler as (event: unknown) => void);
-      return unsubscribe;
-    });
-    const onError = vi.fn();
-    const view = render(<Chalk client={client.client} onEpisodeEnded={vi.fn()} onError={onError} onParticipantJoined={vi.fn()} onParticipantLeft={vi.fn()} onScreenShareStarted={vi.fn()} onScreenShareStopped={vi.fn()} />);
-
-    const error = { error: { code: "client.internal_error", message: "test", recoverable: true } };
-    handlers.get("error")?.(error);
-    expect(onError).toHaveBeenCalledWith(error);
-
-    view.unmount();
-    expect(unsubscribe).toHaveBeenCalledTimes(6);
-  });
-
-  it("leaves an owned client before disposing it on unmount", async () => {
-    const client = createClient("joining");
-    let resolveLeave: (() => void) | undefined;
-    client.client.leave = vi.fn(
-      () =>
-        new Promise<void>((resolve) => {
-          resolveLeave = resolve;
-        }),
-    );
-    nativeClientFactory.mockReturnValue(client.client);
-
-    const view = render(<Chalk entrance={false} getAccess={vi.fn()} space="space-1" />);
-    view.unmount();
-
-    expect(client.client.leave).toHaveBeenCalledTimes(1);
-    expect(client.client.dispose).not.toHaveBeenCalled();
-    await act(async () => resolveLeave?.());
-    expect(client.client.dispose).toHaveBeenCalledTimes(1);
-  });
-
-  it("keeps an owned SpaceClient when getAccess changes identity and uses the latest callback", async () => {
-    const client = createClient("idle");
-    const firstAccess = vi.fn(async () => ({ token: "first" }));
-    const latestAccess = vi.fn(async () => ({ token: "latest" }));
-    nativeClientFactory.mockReturnValue(client.client);
-
-    const view = render(<Chalk entrance getAccess={firstAccess} space="space-1" />);
-    view.rerender(<Chalk entrance getAccess={latestAccess} space="space-1" />);
-
-    expect(nativeClientFactory).toHaveBeenCalledTimes(1);
-    const access = nativeClientFactory.mock.calls[0]?.[0].getAccess as (input: unknown) => Promise<unknown>;
-    await expect(access({})).resolves.toEqual({ token: "latest" });
-    expect(firstAccess).not.toHaveBeenCalled();
-    expect(latestAccess).toHaveBeenCalledTimes(1);
-  });
-
-  it("omits an absent display name when joining without Entrance", async () => {
-    const client = createClient("idle");
-    render(<Chalk client={client.client} entrance={false} />);
-
-    await act(async () => undefined);
-    expect(client.client.join).toHaveBeenCalledWith({ microphone: true, camera: true });
-  });
-
-  it("retries automatic join when an owned client is replaced for a new Space", async () => {
-    const first = createClient("idle");
-    const replacement = createClient("idle");
-    nativeClientFactory.mockReturnValueOnce(first.client).mockReturnValueOnce(replacement.client);
-
-    const view = render(<Chalk entrance={false} getAccess={vi.fn()} space="space-1" />);
-    await act(async () => undefined);
-    expect(first.client.join).toHaveBeenCalledWith({ microphone: true, camera: true });
-
-    view.rerender(<Chalk entrance={false} getAccess={vi.fn()} space="space-2" />);
-    await act(async () => undefined);
-
-    expect(nativeClientFactory).toHaveBeenCalledTimes(2);
-    expect(replacement.client.join).toHaveBeenCalledWith({ microphone: true, camera: true });
-  });
-
-  it("treats a replacement client's initial failure as an Entrance failure", () => {
-    const first = createClient("live");
-    const replacement = createClient("failed");
-    nativeClientFactory.mockReturnValueOnce(first.client).mockReturnValueOnce(replacement.client);
-
-    const view = render(<Chalk entrance getAccess={vi.fn()} space="space-1" />);
-    view.rerender(<Chalk entrance getAccess={vi.fn()} space="space-2" />);
-
-    expect(view.container.querySelector('[data-testid="entrance"]')).not.toBeNull();
-  });
-
-  it("keeps the active Space visible during reconnecting and never after left", () => {
-    const client = createClient("live");
-    const view = render(<Chalk client={client.client} />);
-
-    expect(view.container.querySelector('[data-testid="space"]')).not.toBeNull();
-    act(() => client.setStatus("reconnecting"));
-    expect(view.container.querySelector('[data-testid="space"]')).not.toBeNull();
-    act(() => client.setStatus("left"));
-    expect(view.container.querySelector('[data-testid="space"]')).toBeNull();
-    expect(view.container.textContent).toContain("You have left this Space.");
-  });
-});
-
-function createClient(status: SpaceSnapshot["connection"]["status"]): { readonly client: SpaceClient; readonly setStatus: (nextStatus: SpaceSnapshot["connection"]["status"]) => void } {
-  let snapshot = createSnapshot(status);
-  const listeners = new Set<() => void>();
-  const client = {
-    getSnapshot: () => snapshot,
-    subscribe: (listener: () => void) => {
-      listeners.add(listener);
-      return () => listeners.delete(listener);
-    },
-    on: vi.fn(() => () => undefined),
-    join: vi.fn(async () => undefined),
-    leave: vi.fn(async () => undefined),
-    dispose: vi.fn(),
-    endEpisode: vi.fn(async () => undefined),
-    media: {},
-    chat: {},
-    participants: {},
-    reactions: {},
-    whiteboard: {},
-  } as unknown as SpaceClient;
-  return {
-    client,
-    setStatus(nextStatus) {
-      snapshot = { ...snapshot, connection: { ...snapshot.connection, status: nextStatus } };
-      listeners.forEach((listener) => listener());
-    },
-  };
-}
-
-function createSnapshot(status: SpaceSnapshot["connection"]["status"]): SpaceSnapshot {
-  const capabilities = [] as const;
-  return {
-    connection: { status, episode: null, lastError: null },
-    self: { participantId: null, displayName: null, role: null, capabilities, handRaised: false, can: () => false },
-    participants: { roster: [], admissionQueue: [] },
-    media: {
-      devices: { microphones: [], cameras: [], speakers: [] },
-      selection: { microphone: null, camera: null, speaker: null },
-      local: {
-        microphone: { source: "microphone", state: "disabled", track: null },
-        camera: { source: "camera", state: "disabled", track: null },
-        screen: { source: "screen", state: "disabled", track: null },
-      },
-      remote: [],
-      screenShare: { source: "screen", state: "disabled", track: null },
-      incomingRequests: [],
-    },
-    chat: { status: "idle", messages: [], pendingSends: [], readReceipts: [], unreadCount: 0, pagination: { cursor: null, hasOlder: false, historyTruncated: false }, lastError: null },
-    reactions: { active: [] },
-    whiteboard: { open: false, engine: { status: "unsubscribed", sceneId: null, revision: null, presenting: false, error: null } },
-  };
-}

package/src/components/EmbeddedWhiteboard.test.tsx

@@ -1,92 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-
-const nativeTheme = vi.hoisted(() => ({
-  colorScheme: "light" as const,
-  colors: {
-    dangerSurfaceOverlay94: "#danger",
-    info: "#info",
-    lightMutedText: "#muted",
-    lightSubtleText: "#subtle",
-    lightSurface: "#surface",
-    lightText: "#text",
-    onDark: "#on-dark",
-  },
-}));
-const controllerOptions = vi.hoisted(() => [] as unknown[]);
-
-vi.mock("react", () => ({
-  useCallback: <T,>(callback: T) => callback,
-  useEffect: (effect: () => void) => effect(),
-  useMemo: <T,>(factory: () => T) => factory(),
-  useRef: <T,>(current: T) => ({ current }),
-  useState: <T,>(initial: T | (() => T)): readonly [T, () => void] => [typeof initial === "function" ? (initial as () => T)() : initial, () => undefined],
-}));
-vi.mock("@q9labsai/chalk-whiteboard/embedded", () => ({
-  ChalkWhiteboardController: class {
-    constructor(options: unknown) {
-      controllerOptions.push(options);
-    }
-
-    rendererReloaded(): void {}
-
-    setCapabilities(): void {}
-
-    setViewport(): void {}
-
-    start(): void {}
-
-    stop(): void {}
-  },
-}));
-vi.mock("react-native", () => ({
-  ActivityIndicator: "ActivityIndicator",
-  Pressable: "Pressable",
-  StyleSheet: { create: <Styles,>(styles: Styles) => styles },
-  Text: "Text",
-  View: "View",
-  useWindowDimensions: () => ({ width: 320, height: 640, scale: 2 }),
-}));
-vi.mock("react-native-webview", () => ({ default: "WebView" }));
-vi.mock("../ui/native-theme", () => ({ useNativeTheme: () => nativeTheme }));
-vi.mock("../whiteboard/embedded-whiteboard-assets", () => ({
-  isEmbeddedWhiteboardNavigationAllowed: () => true,
-  rendererURLWithContext: (url: string) => url,
-  resolveEmbeddedWhiteboardRendererURL: async () => "file:///android_asset/chalk-whiteboard/index.html",
-}));
-
-import type { ChalkEmbeddedWhiteboardTransport } from "@q9labsai/chalk-whiteboard/embedded";
-import { EmbeddedWhiteboard, embeddedWhiteboardWebViewSecurityPolicy } from "./EmbeddedWhiteboard";
-
-describe("EmbeddedWhiteboard WebView policy", () => {
-  it("keeps the offline renderer isolated from files, networks, storage, and cookies", () => {
-    expect(embeddedWhiteboardWebViewSecurityPolicy).toEqual({
-      allowFileAccess: true,
-      allowFileAccessFromFileURLs: false,
-      allowUniversalAccessFromFileURLs: false,
-      cacheEnabled: false,
-      domStorageEnabled: false,
-      javaScriptCanOpenWindowsAutomatically: false,
-      javaScriptEnabled: true,
-      mixedContentMode: "never",
-      setSupportMultipleWindows: false,
-      sharedCookiesEnabled: false,
-      thirdPartyCookiesEnabled: false,
-    });
-  });
-
-  it("uses the active NativeTheme colors throughout its loading surface", () => {
-    controllerOptions.length = 0;
-    const rendered = EmbeddedWhiteboard({
-      canClear: false,
-      canDraw: true,
-      journeyId: "journey-test",
-      transport: {} as ChalkEmbeddedWhiteboardTransport,
-    });
-    const children = rendered.props.children as readonly [{ readonly props: { readonly color: string } }, { readonly props: { readonly style: readonly unknown[] } }];
-
-    expect(rendered.props.style).toContainEqual({ backgroundColor: "#surface" });
-    expect(children[0]?.props.color).toBe("#info");
-    expect(children[1]?.props.style).toContainEqual({ color: "#muted" });
-    expect(controllerOptions[0]).toMatchObject({ theme: "light" });
-  });
-});