@q9labsai/chalk-react-native 4.1.11 → 4.1.13

package/src/components/native-space-view/useSpaceViewDerived.test.ts

@@ -1,58 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-
-const viewport = vi.hoisted(() => ({ width: 500 }));
-const defaultViewportWidth = 500;
-
-vi.mock("react", () => ({
-  useMemo: <T>(factory: () => T) => factory(),
-}));
-vi.mock("react-native", () => ({
-  useWindowDimensions: () => ({ width: viewport.width, height: 800 }),
-}));
-
-import { useSpaceViewDerived } from "./useSpaceViewDerived";
-
-describe("useSpaceViewDerived", () => {
-  beforeEach(() => {
-    viewport.width = defaultViewportWidth;
-  });
-
-  afterEach(() => {
-    viewport.width = defaultViewportWidth;
-  });
-
-  it("marks compact whiteboard layouts and keeps the local participant first", () => {
-    const local = { id: "local", screenShareTrack: null };
-    const remote = { id: "remote", screenShareTrack: null };
-
-    const derived = useSpaceViewDerived({
-      participants: [remote] as never,
-      localParticipant: local as never,
-      screenShare: { isActive: false, isLocalSharing: false, sharerParticipantId: null, videoTrack: null },
-      isWhiteboardOpen: true,
-    });
-
-    expect(derived.isCompactViewport).toBe(true);
-    expect(derived.primaryContent).toBe("whiteboard");
-    expect(derived.allParticipants.map((participant) => participant.id)).toEqual(["local", "remote"]);
-  });
-
-  it("uses the wide viewport to expose an active remote screen share", () => {
-    viewport.width = 1024;
-    const local = { id: "local", screenShareTrack: null };
-    const remote = { id: "remote", screenShareTrack: null };
-    const track = { readyState: "live" } as never;
-
-    const derived = useSpaceViewDerived({
-      participants: [remote] as never,
-      localParticipant: local as never,
-      screenShare: { isActive: true, isLocalSharing: false, sharerParticipantId: "remote", videoTrack: track },
-      isWhiteboardOpen: false,
-    });
-
-    expect(derived.isCompactViewport).toBe(false);
-    expect(derived.primaryContent).toBe("screen-share");
-    expect(derived.screenSharer).toBe(remote);
-    expect(derived.screenShareTrack).toBe(track);
-  });
-});

package/src/components/native-space-view/useSpaceViewPanels.controlled.test.ts

@@ -1,40 +0,0 @@
-// @vitest-environment happy-dom
-
-import { describe, expect, it, vi } from "vitest";
-
-import { act, renderHook } from "../../test-support/test-renderer";
-
-const alert = vi.hoisted(() => ({ alert: vi.fn() }));
-
-vi.mock("react-native", () => ({ Alert: alert, Share: { share: vi.fn(async () => undefined) } }));
-
-import { useSpaceViewPanels } from "./useSpaceViewPanels";
-
-describe("controlled Space view fixture state", () => {
-  it("updates production panel and whiteboard state without remounting the hook", () => {
-    const base = {
-      canWhiteboard: true,
-      canDraw: true,
-      canClear: false,
-      canEndEpisode: false,
-      transport: null,
-      onLeave: vi.fn(),
-      onEndEpisode: undefined,
-      run: vi.fn(async (action: () => void | Promise<void>) => {
-        await action();
-      }),
-    };
-    const { result, rerender } = renderHook(({ state }) => useSpaceViewPanels({ ...base, controlledState: state }), { initialProps: { state: { layout: "grid" as const, panel: null, settingsOpen: false, whiteboardOpen: false } } });
-
-    expect(result.current.layout.layout).toBe("grid");
-    expect(result.current.panel).toBeNull();
-    expect(result.current.whiteboard.isOpen).toBe(false);
-
-    act(() => rerender({ state: { layout: "presentation", panel: "participants", settingsOpen: true, whiteboardOpen: true } }));
-
-    expect(result.current.layout.layout).toBe("presentation");
-    expect(result.current.panel).toBe("participants");
-    expect(result.current.settingsOpen).toBe(true);
-    expect(result.current.whiteboard.isOpen).toBe(true);
-  });
-});

package/src/components/native-space-view/useSpaceViewPanels.test.ts

@@ -1,73 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-
-const alert = vi.hoisted(() => ({ alert: vi.fn() }));
-
-vi.mock("react", () => ({
-  useCallback: <T>(callback: T) => callback,
-  useEffect: () => undefined,
-  useMemo: <T>(factory: () => T) => factory(),
-  useRef: <T>(current: T) => ({ current }),
-  useState: <T>(initial: T): readonly [T, (next: T) => void] => [initial, vi.fn()],
-}));
-vi.mock("react-native", () => ({ Alert: alert, Share: { share: vi.fn(async () => undefined) } }));
-vi.mock("../../hooks/useLayout", () => ({
-  useLayout: () => ({ layout: "grid", isMobileView: true, isFullscreen: false, setLayout: vi.fn(), toggleLayout: vi.fn(), toggleFullscreen: vi.fn(async () => undefined) }),
-}));
-
-import { useSpaceViewPanels } from "./useSpaceViewPanels";
-
-describe("useSpaceViewPanels", () => {
-  it("composes layout, panel state, whiteboard state, and leave actions", () => {
-    const panels = useSpaceViewPanels({
-      spaceName: "Space",
-      inviteLink: "https://example.test/space",
-      canWhiteboard: true,
-      canDraw: true,
-      canClear: false,
-      canEndEpisode: true,
-      transport: null,
-      onLeave: vi.fn(),
-      onEndEpisode: vi.fn(),
-      run: vi.fn(async (action) => {
-        await action();
-      }),
-    });
-
-    expect(panels).toMatchObject({ layout: { layout: "grid" }, panel: null, formattedDuration: "0:00", whiteboard: { isOpen: false, canDraw: true } });
-    expect(panels.whiteboard.journeyId).toMatch(/^native-whiteboard-|^[0-9a-f-]{36}$/u);
-    expect(panels.whiteboard.onMetric).toBeUndefined();
-    panels.openPanel("participants");
-    expect(panels.openPanel).toBeTypeOf("function");
-    panels.handleLeave();
-    expect(alert.alert).toHaveBeenCalledWith("Leave Space?", "Choose how you want to leave.", expect.any(Array));
-  });
-
-  it("forwards registered W3C journey context to the whiteboard surface", () => {
-    const onMetric = vi.fn();
-    const panels = useSpaceViewPanels({
-      canWhiteboard: true,
-      canDraw: true,
-      canClear: false,
-      canEndEpisode: false,
-      transport: null,
-      onLeave: vi.fn(),
-      onEndEpisode: undefined,
-      run: vi.fn(async (action) => {
-        await action();
-      }),
-      journeyContext: {
-        journeyId: "00000000-0000-4000-8000-000000000001",
-        traceparent: "00-4bf92f3577b34da6a3ce929d0e0e4736-00f067aa0ba902b7-01",
-        tracestate: "chalk=mobile",
-        recordWhiteboardMetric: onMetric,
-      },
-    });
-
-    expect(panels.whiteboard).toMatchObject({
-      journeyId: "00000000-0000-4000-8000-000000000001",
-      traceparent: "00-4bf92f3577b34da6a3ce929d0e0e4736-00f067aa0ba902b7-01",
-      tracestate: "chalk=mobile",
-      onMetric,
-    });
-  });
-});

package/src/components/space-lifecycle.test.ts

@@ -1,19 +0,0 @@
-import { readFileSync } from "node:fs";
-import { fileURLToPath } from "node:url";
-import ts from "typescript";
-import { describe, expect, it } from "vitest";
-
-describe("SpaceLifecyclePhase", () => {
-  it("keeps the exported source contract on the canonical native phases", () => {
-    const sourcePath = fileURLToPath(new URL("./space-lifecycle.ts", import.meta.url));
-    const sourceFile = ts.createSourceFile("space-lifecycle.ts", readFileSync(sourcePath, "utf8"), ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
-    const declaration = sourceFile.statements.find((statement): statement is ts.TypeAliasDeclaration => ts.isTypeAliasDeclaration(statement) && statement.name.text === "SpaceLifecyclePhase");
-
-    expect(declaration).toBeDefined();
-    if (!declaration || !ts.isUnionTypeNode(declaration.type)) throw new Error("SpaceLifecyclePhase must remain an exported string union.");
-
-    expect(declaration.modifiers?.some((modifier) => modifier.kind === ts.SyntaxKind.ExportKeyword)).toBe(true);
-    const phases = declaration.type.types.map((member) => (ts.isLiteralTypeNode(member) && ts.isStringLiteral(member.literal) ? member.literal.text : "<invalid>"));
-    expect(phases).toEqual(["entrance", "joining", "live", "left"]);
-  });
-});

package/src/context/space-client-context.test.tsx

@@ -1,10 +0,0 @@
-import { describe, expect, it } from "vitest";
-
-import { ChalkProvider, useSpaceClient } from "./space-client-context";
-
-describe("ChalkProvider", () => {
-  it("provides the canonical SpaceClient context entry", () => {
-    expect(ChalkProvider).toBeTypeOf("function");
-    expect(useSpaceClient).toBeTypeOf("function");
-  });
-});

package/src/diagnostics.test.ts

@@ -1,29 +0,0 @@
-import { beforeEach, describe, expect, it } from "vitest";
-
-import { buildDevDiagnosticsCopyText, classifyTarget, getDevDiagnosticsState, recordDiagnosticsFailure, resetDevDiagnosticsState, setDevDiagnosticsEnvironment } from "./diagnostics";
-
-describe("native diagnostics", () => {
-  beforeEach(resetDevDiagnosticsState);
-
-  it("does not retain caller credentials", () => {
-    expect(buildDevDiagnosticsCopyText()).not.toContain("inviteToken");
-  });
-
-  it("uses the public-invite API as the single environment boundary", () => {
-    setDevDiagnosticsEnvironment({
-      apiBaseURL: "http://localhost:8787",
-    });
-    expect(getDevDiagnosticsState().environment.target).toBe("local");
-    expect(classifyTarget("https://api.chalkmeet.com")).toBe("production");
-  });
-
-  it("records failures without legacy auth or transport state", () => {
-    recordDiagnosticsFailure("connection-join", "Sync unavailable");
-    expect(getDevDiagnosticsState().lastFailure).toMatchObject({
-      source: "connection-join",
-      message: "Sync unavailable",
-    });
-    expect(buildDevDiagnosticsCopyText()).not.toContain("apiKey");
-    expect(buildDevDiagnosticsCopyText()).not.toContain("RealtimeKit");
-  });
-});

package/src/hooks/entrance-preview-store.test.ts

@@ -1,79 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-import type { NativeMediaStream, NativeMediaStreamTrack } from "../media/native-webrtc";
-import { createEntrancePreviewStore } from "./entrance-preview-store";
-
-function createStream(withVideoTrack: boolean): { stream: NativeMediaStream; wasStopped: () => boolean } {
-  let stopped = false;
-  const track: NativeMediaStreamTrack = {
-    id: "camera-track",
-    kind: "video",
-    enabled: true,
-    muted: false,
-    readyState: "live",
-    stop: () => {
-      stopped = true;
-    },
-  };
-  const stream: NativeMediaStream = {
-    toURL: () => "camera-stream",
-    getTracks: () => (withVideoTrack ? [track] : []),
-    getVideoTracks: () => (withVideoTrack ? [track] : []),
-    getAudioTracks: () => [],
-  };
-
-  return { stream, wasStopped: () => stopped };
-}
-
-describe("createEntrancePreviewStore", () => {
-  it("starts the camera on subscription and stops it on cleanup", async () => {
-    const camera = createStream(true);
-    const getUserMedia = vi.fn(async () => camera.stream);
-    const store = createEntrancePreviewStore({
-      enabled: true,
-      simulatorVideoDisabled: false,
-      simulatorVideoMessage: "simulator",
-      getUserMedia,
-    });
-
-    const unsubscribe = store.subscribe(() => {});
-    await Promise.resolve();
-
-    expect(getUserMedia).toHaveBeenCalledWith({ audio: false, video: { facingMode: "user" } });
-    expect(store.getSnapshot()).toEqual({ previewStream: camera.stream, previewError: null });
-
-    unsubscribe();
-    expect(camera.wasStopped()).toBe(true);
-  });
-
-  it("reports simulator video as unavailable without opening the camera", () => {
-    const getUserMedia = vi.fn(async () => createStream(true).stream);
-    const store = createEntrancePreviewStore({
-      enabled: true,
-      simulatorVideoDisabled: true,
-      simulatorVideoMessage: "Video is unavailable in the iOS simulator",
-      getUserMedia,
-    });
-
-    const unsubscribe = store.subscribe(() => {});
-
-    expect(store.getSnapshot()).toEqual({ previewStream: null, previewError: "Video is unavailable in the iOS simulator" });
-    expect(getUserMedia).not.toHaveBeenCalled();
-    unsubscribe();
-  });
-
-  it("keeps the preview disabled when Entrance disables preview", () => {
-    const getUserMedia = vi.fn(async () => createStream(true).stream);
-    const store = createEntrancePreviewStore({
-      enabled: false,
-      simulatorVideoDisabled: false,
-      simulatorVideoMessage: "simulator",
-      getUserMedia,
-    });
-
-    const unsubscribe = store.subscribe(() => {});
-
-    expect(store.getSnapshot()).toEqual({ previewStream: null, previewError: null });
-    expect(getUserMedia).not.toHaveBeenCalled();
-    unsubscribe();
-  });
-});

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);
-  });
-});