@q9labsai/chalk-react-native 4.1.12 → 4.1.13

package/src/hooks/space-hooks.test.ts

@@ -1,76 +0,0 @@
-import type { SpaceClient, SpaceSnapshot } from "@q9labsai/chalk-client";
-import { beforeEach, describe, expect, it, vi } from "vitest";
-
-const state = vi.hoisted(() => ({ client: null as SpaceClient | null }));
-
-vi.mock("../context/space-client-context", () => ({
-  useSpaceClient: () => {
-    if (!state.client) throw new Error("missing client");
-    return state.client;
-  },
-}));
-
-vi.mock("react", async (importOriginal) => {
-  const react = await importOriginal<typeof import("react")>();
-  return {
-    ...react,
-    useCallback: <T>(callback: T) => callback,
-    useSyncExternalStore: (_subscribe: unknown, getSnapshot: () => unknown) => getSnapshot(),
-  };
-});
-
-import { useCan, useChat, useConnection, useMedia, useParticipants, useReactions, useSelf, useWhiteboard } from "./space-hooks";
-
-describe("SpaceSnapshot hooks", () => {
-  beforeEach(() => {
-    state.client = client(snapshot());
-  });
-
-  it("returns the exact stable slices from SpaceSnapshot", () => {
-    const current = state.client!.getSnapshot();
-
-    expect(useConnection()).toBe(current.connection);
-    expect(useSelf()).toBe(current.self);
-    expect(useParticipants()).toBe(current.participants);
-    expect(useMedia()).toBe(current.media);
-    expect(useChat()).toBe(current.chat);
-    expect(useReactions()).toBe(current.reactions);
-    expect(useWhiteboard()).toBe(current.whiteboard);
-  });
-
-  it("derives capabilities from the self slice", () => {
-    expect(useCan("sendChat")).toBe(true);
-    expect(useCan("endEpisode")).toBe(false);
-  });
-});
-
-function client(current: SpaceSnapshot): SpaceClient {
-  return {
-    getSnapshot: () => current,
-    subscribe: () => () => undefined,
-  } as SpaceClient;
-}
-
-function snapshot(): SpaceSnapshot {
-  const capabilities = ["sendChat"] as const;
-  return {
-    connection: { status: "live", episode: null, lastError: null },
-    self: { participantId: "participant-1", displayName: "Ada", role: "collaborator", capabilities, handRaised: false, can: (capability) => capabilities.includes(capability as (typeof capabilities)[number]) },
-    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/hooks/useLayout.test.ts

@@ -1,16 +0,0 @@
-// @vitest-environment happy-dom
-
-import { describe, expect, it } from "vitest";
-
-import { act, renderHook } from "../test-support/test-renderer";
-import { useLayout } from "./useLayout";
-
-describe("useLayout", () => {
-  it("synchronizes a controlled layout without replacing the hook", () => {
-    const { result, rerender } = renderHook(({ layout }) => useLayout({ layout }), { initialProps: { layout: "grid" as const } });
-
-    expect(result.current.layout).toBe("grid");
-    act(() => rerender({ layout: "presentation" }));
-    expect(result.current.layout).toBe("presentation");
-  });
-});

package/src/invites.test.ts

@@ -1,51 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { getClipboardInviteSuggestion, parseSpaceInviteLink } from "./invites";
-
-describe("parseSpaceInviteLink", () => {
-  const inviteToken = "cspi1.key.payload.signature";
-
-  it("accepts Chalk https invite links", () => {
-    expect(parseSpaceInviteLink(`https://chalk.q9labs.ai/space/design-lab#spaceInviteToken=${inviteToken}`)).toEqual({ slug: "design-lab", spaceInviteToken: inviteToken });
-  });
-
-  it("accepts bare Chalk hostnames", () => {
-    expect(parseSpaceInviteLink(`chalkmeet.com/space/design-lab#spaceInviteToken=${inviteToken}`)).toEqual({ slug: "design-lab", spaceInviteToken: inviteToken });
-  });
-
-  it("accepts native Chalk deep links with the canonical path", () => {
-    expect(parseSpaceInviteLink(`chalk://space/design-lab#spaceInviteToken=${inviteToken}`)).toEqual({ slug: "design-lab", spaceInviteToken: inviteToken });
-    expect(parseSpaceInviteLink(`ai.q9labs.chalk.mobile://space/design-lab#spaceInviteToken=${inviteToken}`)).toEqual({ slug: "design-lab", spaceInviteToken: inviteToken });
-  });
-
-  it("accepts loopback HTTP invite links for local development", () => {
-    expect(parseSpaceInviteLink(`http://127.0.0.1:3070/space/design-lab#spaceInviteToken=${inviteToken}`)).toEqual({ slug: "design-lab", spaceInviteToken: inviteToken });
-    expect(parseSpaceInviteLink(`http://localhost:3070/space/design-lab#spaceInviteToken=${inviteToken}`)).toEqual({ slug: "design-lab", spaceInviteToken: inviteToken });
-  });
-
-  it("rejects legacy paths, missing slugs, and invalid tokens", () => {
-    expect(parseSpaceInviteLink(`https://chalk.q9labs.ai/legacy/${inviteToken}`)).toBeNull();
-    expect(parseSpaceInviteLink(`https://chalk.q9labs.ai/space#spaceInviteToken=${inviteToken}`)).toBeNull();
-    expect(parseSpaceInviteLink("https://chalk.q9labs.ai/space/design-lab#invite=legacy")).toBeNull();
-    expect(parseSpaceInviteLink("https://attacker.test/space/design-lab#spaceInviteToken=cspi1.key.payload.signature")).toBeNull();
-    expect(parseSpaceInviteLink(`http://chalkmeet.com/space/design-lab#spaceInviteToken=${inviteToken}`)).toBeNull();
-    expect(parseSpaceInviteLink(`http://192.168.1.10/space/design-lab#spaceInviteToken=${inviteToken}`)).toBeNull();
-    expect(parseSpaceInviteLink("https://chalk.q9labs.ai/space/design-lab#spaceInviteToken=ABC123")).toBeNull();
-    expect(parseSpaceInviteLink(`https://chalk.q9labs.ai/space/design-lab#spaceInviteToken=${`cspi1.${"k".repeat(170)}.${"p".repeat(170)}.${"s".repeat(170)}`}`)).toBeNull();
-  });
-});
-
-describe("getClipboardInviteSuggestion", () => {
-  const inviteLink = "https://chalkmeet.com/space/design-lab#spaceInviteToken=cspi1.key.payload.signature";
-
-  it("returns a copied Chalk invite link when it differs from the current input", () => {
-    expect(getClipboardInviteSuggestion(inviteLink, "")).toBe(inviteLink);
-  });
-
-  it("hides the suggestion when the input already matches the clipboard", () => {
-    expect(getClipboardInviteSuggestion(inviteLink, inviteLink)).toBeNull();
-  });
-
-  it("ignores non-invite clipboard values", () => {
-    expect(getClipboardInviteSuggestion("ABC123", "")).toBeNull();
-  });
-});

package/src/public-surface.test.ts

@@ -1,26 +0,0 @@
-import type { ClientEventMap } from "@q9labsai/chalk-client";
-import type { ThemeAppearance as ReactThemeAppearance, ThemePalette as ReactThemePalette, ThemeTexture as ReactThemeTexture } from "../../react/src/components/theme";
-import type { ChalkProps, ChalkThemeTokens, SpaceLayout } from "./components/Chalk";
-import type { EntranceProps, EntranceSettings } from "./components/Entrance";
-import type { ThemeAppearance, ThemePalette, ThemeTexture } from "./ui/appearance";
-import { expectTypeOf, test } from "vitest";
-
-test("the turnkey and entrance props use the ratified names", () => {
-  expectTypeOf<ChalkProps>().toMatchTypeOf<{
-    readonly entrance?: boolean;
-    readonly defaults?: { readonly microphone?: boolean; readonly camera?: boolean };
-    readonly features?: object;
-    readonly layout?: SpaceLayout;
-    readonly onOpenDiagnostics?: () => void;
-  }>();
-  expectTypeOf<EntranceProps>().toMatchTypeOf<{
-    readonly defaults?: { readonly microphone?: boolean; readonly camera?: boolean };
-    readonly onCancel?: () => void;
-  }>();
-  expectTypeOf<EntranceSettings>().toEqualTypeOf<{ readonly displayName: string; readonly microphone: boolean; readonly camera: boolean }>();
-  expectTypeOf<NonNullable<ChalkProps["onError"]>>().toEqualTypeOf<(event: ClientEventMap["error"]) => void>();
-  expectTypeOf<keyof ChalkThemeTokens>().toEqualTypeOf<"canvas" | "chrome" | "surface" | "stage" | "text" | "mutedText" | "line" | "accent" | "accentText" | "positive" | "danger" | "dangerSurface" | "focus" | "shadow">();
-  expectTypeOf<ThemePalette>().toEqualTypeOf<ReactThemePalette>();
-  expectTypeOf<ThemeTexture>().toEqualTypeOf<ReactThemeTexture>();
-  expectTypeOf<ThemeAppearance>().toEqualTypeOf<ReactThemeAppearance>();
-});

package/src/runtime.test.ts

@@ -1,83 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-import { canUseLocalHostBootstrap, getMetroHostFromScriptUrl, isConfiguredLocalApiUrl, isDeviceLocalUrl, resolveAppRuntimeUrl, resolveDeviceLocalUrl, shouldAutoReadClipboard } from "./runtime";
-
-vi.mock("react-native", () => ({
-  NativeModules: { SourceCode: { scriptURL: null } },
-  Platform: {
-    OS: "ios",
-    Version: "17.0",
-    constants: { reactNativeVersion: { major: 0, minor: 83, patch: 2 } },
-  },
-}));
-
-describe("mobile runtime helpers", () => {
-  it("extracts the Metro host from a device script URL", () => {
-    expect(getMetroHostFromScriptUrl("http://192.168.18.245:8081/index.bundle?platform=android")).toBe("192.168.18.245");
-    expect(getMetroHostFromScriptUrl(null)).toBeNull();
-  });
-
-  it("rewrites localhost URLs to the Metro host for device builds", () => {
-    const scriptUrl = "http://192.168.18.245:8081/index.bundle?platform=android";
-
-    expect(resolveDeviceLocalUrl("http://localhost:8080", scriptUrl)).toBe("http://192.168.18.245:8080");
-    expect(resolveDeviceLocalUrl("ws://127.0.0.1:8080/ws", scriptUrl)).toBe("ws://192.168.18.245:8080/ws");
-    expect(resolveDeviceLocalUrl("https://chalk-api.q9labs.ai", scriptUrl)).toBe("https://chalk-api.q9labs.ai");
-  });
-
-  it("falls back to production URLs when release builds still carry localhost env values", () => {
-    expect(resolveDeviceLocalUrl("http://localhost:8080", null, "https://chalk-api.q9labs.ai")).toBe("https://chalk-api.q9labs.ai");
-    expect(resolveDeviceLocalUrl("ws://127.0.0.1:8080/ws", undefined, "wss://chalk-ws.q9labs.ai/ws")).toBe("wss://chalk-ws.q9labs.ai/ws");
-  });
-
-  it("preserves localhost URLs when the dev bundle is also served from localhost", () => {
-    const scriptUrl = "http://localhost:8081/index.bundle?platform=ios";
-
-    expect(resolveDeviceLocalUrl("http://localhost:8080", scriptUrl, "https://chalk-api.q9labs.ai")).toBe("http://localhost:8080");
-    expect(resolveDeviceLocalUrl("ws://127.0.0.1:8080/ws", scriptUrl, "wss://chalk-ws.q9labs.ai/ws")).toBe("ws://127.0.0.1:8080/ws");
-  });
-
-  it("hard-forces production URLs when release builds disallow device-local hosts", () => {
-    expect(
-      resolveAppRuntimeUrl({
-        configuredUrl: "http://localhost:8080",
-        scriptUrl: "file:///android_asset/index.android.bundle",
-        fallbackUrl: "https://chalk-api.q9labs.ai",
-        allowDeviceLocal: false,
-      }),
-    ).toBe("https://chalk-api.q9labs.ai");
-
-    expect(
-      resolveAppRuntimeUrl({
-        configuredUrl: "ws://localhost:8080/ws",
-        scriptUrl: "file:///android_asset/index.android.bundle",
-        fallbackUrl: "wss://chalk-ws.q9labs.ai/ws",
-        allowDeviceLocal: false,
-      }),
-    ).toBe("wss://chalk-ws.q9labs.ai/ws");
-  });
-
-  it("detects local device URLs", () => {
-    expect(isDeviceLocalUrl("http://localhost:8080")).toBe(true);
-    expect(isDeviceLocalUrl("ws://127.0.0.1:8080/ws")).toBe(true);
-    expect(isDeviceLocalUrl("https://chalk-api.q9labs.ai")).toBe(false);
-  });
-
-  it("detects configured local api urls even outside dev mode", () => {
-    expect(isConfiguredLocalApiUrl("http://localhost:8080")).toBe(true);
-    expect(isConfiguredLocalApiUrl(" ws://127.0.0.1:8080/ws ")).toBe(true);
-    expect(isConfiguredLocalApiUrl("https://chalk-api.q9labs.ai")).toBe(false);
-    expect(isConfiguredLocalApiUrl(undefined)).toBe(false);
-  });
-
-  it("only allows host bootstrap for resolved local runtime urls", () => {
-    expect(canUseLocalHostBootstrap("http://localhost:8080", true)).toBe(true);
-    expect(canUseLocalHostBootstrap("https://chalk-api.q9labs.ai", true)).toBe(false);
-    expect(canUseLocalHostBootstrap("http://localhost:8080", false)).toBe(false);
-  });
-
-  it("skips eager clipboard reads on the iOS simulator", () => {
-    expect(shouldAutoReadClipboard({ platform: "ios", isSimulator: true })).toBe(false);
-    expect(shouldAutoReadClipboard({ platform: "ios", isSimulator: false })).toBe(true);
-    expect(shouldAutoReadClipboard({ platform: "android", isSimulator: false })).toBe(true);
-  });
-});

package/src/space-client/cloudflare-rtk-native.test.ts

@@ -1,118 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from "vitest";
-
-const initialize = vi.hoisted(() => vi.fn());
-
-vi.mock("@cloudflare/realtimekit-react-native", () => ({ default: { init: initialize } }));
-
-import { createNativeRealtimeKitClient } from "./cloudflare-rtk-native";
-
-describe("native RealtimeKit adapter", () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-  });
-
-  it("initializes, joins, leaves, and projects native participants", async () => {
-    const selfOn = vi.fn();
-    const selfOff = vi.fn();
-    const joinedOn = vi.fn();
-    const joinedOff = vi.fn();
-    const joinRoom = vi.fn().mockResolvedValue(undefined);
-    const leaveRoom = vi.fn().mockResolvedValue(undefined);
-    const audioTrack = { kind: "audio" };
-    const videoTrack = { kind: "video" };
-    const participant = {
-      id: "native-participant",
-      userId: "user",
-      customParticipantId: "custom-participant",
-      audioEnabled: true,
-      videoEnabled: false,
-      screenShareEnabled: false,
-      audioTrack,
-      videoTrack: null,
-      screenShareTracks: {},
-    };
-    const nativeClient = {
-      joinRoom,
-      leaveRoom,
-      self: {
-        peerId: "peer",
-        audioEnabled: true,
-        videoEnabled: false,
-        screenShareEnabled: false,
-        audioTrack,
-        videoTrack,
-        screenShareTracks: {},
-        enableAudio: vi.fn().mockResolvedValue(undefined),
-        enableVideo: vi.fn().mockResolvedValue(undefined),
-        enableScreenShare: vi.fn().mockResolvedValue(undefined),
-        disableAudio: vi.fn().mockResolvedValue(undefined),
-        disableVideo: vi.fn().mockResolvedValue(undefined),
-        disableScreenShare: vi.fn().mockResolvedValue(undefined),
-        on: selfOn,
-        off: selfOff,
-      },
-      participants: {
-        joined: {
-          toArray: vi.fn(() => [participant]),
-          on: joinedOn,
-          off: joinedOff,
-        },
-      },
-    };
-    initialize.mockResolvedValue(nativeClient);
-
-    const onError = vi.fn();
-    const connection = await createNativeRealtimeKitClient({ authToken: "rtk-token", onError });
-    await connection.join();
-    await connection.leave();
-
-    expect(initialize).toHaveBeenCalledWith({ authToken: "rtk-token", defaults: { audio: false, video: false }, onError });
-    expect(joinRoom).toHaveBeenCalledOnce();
-    expect(leaveRoom).toHaveBeenCalledOnce();
-    expect(connection.self.peerId).toBe("peer");
-    expect(connection.self.audioTrack).toBe(audioTrack);
-    expect(connection.participants.joined.list()).toEqual([expect.objectContaining({ id: "native-participant", customParticipantId: "custom-participant", audioTrack })]);
-  });
-
-  it("bridges lifecycle event subscriptions and removes them", async () => {
-    const selfOn = vi.fn();
-    const selfOff = vi.fn();
-    const joinedOn = vi.fn();
-    const joinedOff = vi.fn();
-    initialize.mockResolvedValue({
-      joinRoom: vi.fn(),
-      leaveRoom: vi.fn(),
-      self: {
-        peerId: "peer",
-        audioEnabled: false,
-        videoEnabled: false,
-        screenShareEnabled: false,
-        audioTrack: null,
-        videoTrack: null,
-        screenShareTracks: {},
-        enableAudio: vi.fn(),
-        enableVideo: vi.fn(),
-        enableScreenShare: vi.fn(),
-        disableAudio: vi.fn(),
-        disableVideo: vi.fn(),
-        disableScreenShare: vi.fn(),
-        on: selfOn,
-        off: selfOff,
-      },
-      participants: { joined: { toArray: vi.fn(() => []), on: joinedOn, off: joinedOff } },
-    });
-
-    const connection = await createNativeRealtimeKitClient({ authToken: "rtk-token", onError: vi.fn() });
-    const listener = vi.fn();
-    const unsubscribeAudio = connection.self.onAudioUpdate(listener);
-    const unsubscribeJoined = connection.participants.joined.onJoined(listener);
-
-    unsubscribeAudio();
-    unsubscribeJoined();
-
-    expect(selfOn).toHaveBeenCalledWith("audioUpdate", listener);
-    expect(selfOff).toHaveBeenCalledWith("audioUpdate", listener);
-    expect(joinedOn).toHaveBeenCalledWith("participantJoined", expect.any(Function));
-    expect(joinedOff).toHaveBeenCalledWith("participantJoined", expect.any(Function));
-  });
-});

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

@@ -1,300 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from "vitest";
-
-const createSpaceClientForPlatform = vi.hoisted(() => vi.fn());
-const addAppStateListener = vi.hoisted(() => vi.fn());
-const createV1SyncClient = vi.hoisted(() => vi.fn());
-const createCloudflareSFUHTTPTransport = vi.hoisted(() => vi.fn(() => ({})));
-const CloudflareRTKClient = vi.hoisted(() =>
-  vi.fn(
-    class MockCloudflareRTKClient {
-      setLocalPublicationTarget = vi.fn();
-      observeLocalPublications = vi.fn();
-      observeRemotePublications = vi.fn();
-      start = vi.fn();
-      stop = vi.fn();
-      restart = vi.fn();
-      prepareLocalTrack = vi.fn();
-      clearPreparedLocalTrack = vi.fn();
-      getSnapshot = vi.fn();
-      subscribe = vi.fn();
-    },
-  ),
-);
-const CloudflareSFUClient = vi.hoisted(() =>
-  vi.fn(
-    class MockCloudflareSFUClient {
-      setLocalPublicationTarget = vi.fn();
-      observeLocalPublications = vi.fn();
-      observeRemotePublications = vi.fn();
-      start = vi.fn();
-      stop = vi.fn();
-      restart = vi.fn();
-      prepareLocalTrack = vi.fn();
-      clearPreparedLocalTrack = vi.fn();
-      getSnapshot = vi.fn();
-      subscribe = vi.fn();
-    },
-  ),
-);
-
-vi.mock("@q9labsai/chalk-client", () => ({
-  AsyncStorageV1PendingTargetStore: vi.fn(),
-  CloudflareRTKClient,
-  CloudflareSFUClient,
-  createChalkChatFileHttpTransport: vi.fn(),
-  createChalkWhiteboardV1Client: vi.fn(),
-  createChalkWhiteboardV1FileHttpTransport: vi.fn(),
-  createCloudflareSFUHTTPTransport,
-  createReactNativeSyncLifecycle: vi.fn(() => ({})),
-  createReactNativeWebSocketFactory: vi.fn(() => ({})),
-  createV1SyncClient,
-}));
-vi.mock("@q9labsai/chalk-client/effect", () => ({ createSpaceClientForPlatform }));
-vi.mock("@cloudflare/react-native-webrtc", () => ({
-  RTCPeerConnection: vi.fn(),
-  mediaDevices: {
-    getDisplayMedia: vi.fn(),
-    getUserMedia: vi.fn(),
-  },
-}));
-vi.mock("react-native", () => ({
-  AppState: {
-    addEventListener: addAppStateListener,
-    currentState: "active",
-  },
-}));
-
-import { createNativeSpaceClient } from "./create-native-space-client";
-
-describe("native client creation", () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-    createSpaceClientForPlatform.mockReturnValue(spaceClient());
-    addAppStateListener.mockReturnValue({ remove: vi.fn() });
-  });
-
-  it("allows multiple native WebSocket attempts before Sync startup expires", () => {
-    createNativeSpaceClient(options());
-
-    expect(createSpaceClientForPlatform.mock.calls[0]?.[1]).toEqual(expect.objectContaining({ syncStartupTimeoutMs: 30_000 }));
-  });
-
-  it("preserves an explicit consumer Sync startup budget", () => {
-    createNativeSpaceClient({ ...options(), syncStartupTimeoutMs: 45_000 });
-
-    expect(createSpaceClientForPlatform.mock.calls[0]?.[1]).toEqual(expect.objectContaining({ syncStartupTimeoutMs: 45_000 }));
-  });
-
-  it("derives the canonical Sync origin from the default API origin", () => {
-    createNativeSpaceClient({ ...options(), baseUrl: undefined, syncUrl: undefined });
-
-    expect(createSpaceClientForPlatform.mock.calls[0]?.[1]).toEqual(expect.objectContaining({ apiBaseUrl: "https://api.chalkmeet.com", syncUrl: "wss://sync.chalkmeet.com/v1/sync" }));
-  });
-
-  it("selects the native RealtimeKit adapter for RTK access grants", () => {
-    createNativeSpaceClient(options());
-    const platform = createSpaceClientForPlatform.mock.calls[0]?.[1] as {
-      readonly dependencies: { readonly createMediaClient: (input: unknown) => unknown };
-    };
-
-    platform.dependencies.createMediaClient({
-      access: {
-        subject: { tenantId: "tenant", spaceId: "space", episodeId: "episode", participantId: "participant", participantGeneration: 1 },
-        media: { provider: "cloudflare_rtk", clientPayload: { providerSubject: "provider-subject", token: "rtk-token" } },
-      },
-      credential: vi.fn(),
-      onFailure: vi.fn(),
-      onScreenEnded: vi.fn(),
-    });
-
-    expect(CloudflareRTKClient).toHaveBeenCalledWith(expect.objectContaining({ authToken: "rtk-token", participantId: "participant", clientFactory: expect.any(Function) }));
-    expect(createCloudflareSFUHTTPTransport).not.toHaveBeenCalled();
-  });
-
-  it("passes the closed access callback to the client", () => {
-    const getAccess = vi.fn();
-    createNativeSpaceClient({ ...options(), getAccess });
-
-    expect(createSpaceClientForPlatform.mock.calls[0]?.[0]).toEqual(expect.objectContaining({ getAccess }));
-  });
-
-  it("forwards Space join spans into the correlated diagnostic timeline", () => {
-    const journey = {
-      context: { journeyId: "journey", rootJourneyId: "journey", traceparent: "00-11111111111111111111111111111111-2222222222222222-01" },
-      headers: {},
-      recordDiagnostic: vi.fn(),
-      recordRtcSummary: vi.fn(),
-      recordSyncFrame: vi.fn(),
-    };
-
-    createNativeSpaceClient({ ...options(), telemetry: journey });
-    const platform = createSpaceClientForPlatform.mock.calls[0]?.[1] as { readonly onConnectionDiagnostic: (event: unknown) => void };
-    platform.onConnectionDiagnostic({
-      event: "space_join_span",
-      state: "live",
-      epoch: 2,
-      step: "start_media",
-      spanId: "space-join-span-2",
-      parentSpanId: "space-join-span-1",
-      outcome: "succeeded",
-      durationMs: 12,
-      code: "media_start_failed",
-    });
-
-    expect(journey.recordDiagnostic).toHaveBeenCalledWith({
-      category: "connection",
-      code: "space.join.start_media.succeeded",
-      phase: "media",
-      state: "succeeded",
-      metricValue: 12,
-      attributes: {
-        span_id: "space-join-span-2",
-        parent_span_id: "space-join-span-1",
-        step: "start_media",
-        outcome: "succeeded",
-        epoch: 2,
-        failure_code: "media_start_failed",
-      },
-    });
-  });
-
-  it("passes telemetry context into the production Sync constructor", () => {
-    const journey = {
-      context: {
-        journeyId: "journey",
-        rootJourneyId: "journey",
-        traceparent: "00-11111111111111111111111111111111-2222222222222222-01",
-        tracestate: "chalk=native",
-      },
-      headers: {},
-      recordDiagnostic: vi.fn(),
-      recordRtcSummary: vi.fn(),
-      recordSyncFrame: vi.fn(),
-    };
-
-    createNativeSpaceClient({ ...options(), telemetry: journey });
-    const platform = createSpaceClientForPlatform.mock.calls[0]?.[1] as {
-      readonly telemetry: typeof journey.context;
-      readonly dependencies: { readonly createSyncClient: (input: unknown) => unknown };
-    };
-    expect(platform.telemetry).toEqual(journey.context);
-    platform.dependencies.createSyncClient({
-      access: { subject: { tenantId: "tenant", episodeId: "episode", participantId: "participant" } },
-      token: async () => "token",
-      media: {},
-      telemetry: platform.telemetry,
-    });
-
-    expect(createV1SyncClient).toHaveBeenCalledWith(expect.objectContaining({ telemetry: journey.context }));
-  });
-
-  it("revalidates access when the app returns to the foreground", () => {
-    createNativeSpaceClient(options());
-    const platform = createSpaceClientForPlatform.mock.calls[0]?.[1] as {
-      readonly dependencies: { readonly subscribeForeground: (listener: () => void) => () => void };
-    };
-
-    const refresh = vi.fn();
-    const unsubscribe = platform.dependencies.subscribeForeground(refresh);
-    const stateListener = addAppStateListener.mock.calls[0]?.[1] as (state: string) => void;
-
-    stateListener("background");
-    expect(refresh).not.toHaveBeenCalled();
-    stateListener("active");
-    expect(refresh).toHaveBeenCalledOnce();
-
-    unsubscribe();
-    expect(addAppStateListener.mock.results[0]?.value.remove).toHaveBeenCalledOnce();
-  });
-
-  it("bridges verified media credentials to telemetry and clears them at terminal teardown", async () => {
-    const client = spaceClient();
-    createSpaceClientForPlatform.mockReturnValue(client);
-    const setAuthenticatedTelemetryHeaders = vi.fn();
-    const journey = {
-      context: { journeyId: "journey", rootJourneyId: "journey", traceparent: "00-11111111111111111111111111111111-2222222222222222-01" },
-      headers: { "x-chalk-journey-id": "journey" },
-      recordDiagnostic: vi.fn(),
-      recordRtcSummary: vi.fn(),
-      recordSyncFrame: vi.fn(),
-      setAuthenticatedTelemetryHeaders,
-    };
-    createNativeSpaceClient({ ...options(), telemetry: journey });
-    const platform = createSpaceClientForPlatform.mock.calls[0]?.[1] as {
-      readonly dependencies: { readonly createMediaClient: (input: unknown) => unknown };
-    };
-    const credential = vi.fn().mockResolvedValueOnce("media-one").mockResolvedValueOnce("media-two").mockResolvedValueOnce("media-three");
-    platform.dependencies.createMediaClient({
-      access: { subject: { tenantId: "tenant", episodeId: "episode", participantId: "participant" }, media: { clientPayload: {} } },
-      credential,
-      onFailure: vi.fn(),
-      onScreenEnded: vi.fn(),
-    });
-
-    const transport = createCloudflareSFUHTTPTransport.mock.calls.at(-1)?.[0] as { readonly credential: () => Promise<string> };
-    await expect(transport.credential()).resolves.toBe("media-one");
-    await expect(transport.credential()).resolves.toBe("media-two");
-    expect(setAuthenticatedTelemetryHeaders).toHaveBeenNthCalledWith(1, { Authorization: "Bearer media-one" });
-    expect(setAuthenticatedTelemetryHeaders).toHaveBeenNthCalledWith(2, { Authorization: "Bearer media-two" });
-    expect(journey.recordDiagnostic).not.toHaveBeenCalledWith(expect.objectContaining({ attributes: expect.stringContaining("media-") }));
-    expect(JSON.stringify(journey.recordDiagnostic.mock.calls)).not.toContain("media-one");
-
-    client.setStatus("left");
-    expect(setAuthenticatedTelemetryHeaders).toHaveBeenLastCalledWith(undefined);
-    await expect(transport.credential()).resolves.toBe("media-three");
-    client.dispose();
-    expect(setAuthenticatedTelemetryHeaders).toHaveBeenLastCalledWith(undefined);
-    expect(credential).toHaveBeenCalledTimes(3);
-  });
-});
-
-function options() {
-  return {
-    space: "native-space",
-    getAccess: vi.fn(),
-    baseUrl: "https://api.chalk.test",
-    syncUrl: "wss://sync.chalk.test/v1/sync",
-  };
-}
-
-function spaceClient() {
-  const snapshot = {
-    connection: { status: "idle", 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: "unavailable", track: null },
-        camera: { source: "camera", state: "unavailable", track: null },
-        screen: { source: "screen", state: "unavailable", track: null },
-      },
-      remote: [],
-      screenShare: { source: "screen", state: "unavailable", 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 } },
-  } as const;
-  let currentSnapshot = snapshot;
-  const listeners = new Set<() => void>();
-  return {
-    media: {},
-    chat: { files: {} },
-    participants: {},
-    reactions: {},
-    whiteboard: { transport: () => null },
-    getSnapshot: () => currentSnapshot,
-    subscribe: (listener: () => void) => {
-      listeners.add(listener);
-      return () => listeners.delete(listener);
-    },
-    setStatus: (status: "idle" | "failed" | "left") => {
-      currentSnapshot = { ...currentSnapshot, connection: { ...currentSnapshot.connection, status } };
-      listeners.forEach((listener) => listener());
-    },
-    dispose: vi.fn(),
-  };
-}