@q9labsai/chalk-react-native 4.1.12 → 4.1.14

package/src/components/native-space-view/SpaceWhiteboardSurface.test.tsx

@@ -1,85 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-
-const nativeTheme = vi.hoisted(() => ({ colorScheme: "light" as "light" | "dark" }));
-
-vi.mock("react", () => ({
-  useCallback: <T,>(callback: T) => callback,
-}));
-vi.mock("react-native", () => ({
-  StyleSheet: { create: <Styles,>(styles: Styles) => styles },
-}));
-vi.mock("../../ui/native-theme", () => ({
-  useNativeTheme: () => nativeTheme,
-}));
-vi.mock("../EmbeddedWhiteboard", () => ({
-  EmbeddedWhiteboard: "EmbeddedWhiteboard",
-}));
-
-import type { SpaceWhiteboardState } from "./useSpaceViewPanels";
-import { forwardNativeSpaceWhiteboardFailure, forwardNativeSpaceWhiteboardMetric, shouldRenderNativeSpaceWhiteboard, SpaceWhiteboardSurface } from "./SpaceWhiteboardSurface";
-
-describe("SpaceWhiteboardSurface", () => {
-  it("renders only for an open canonical whiteboard transport", () => {
-    expect(shouldRenderNativeSpaceWhiteboard(controller({ isOpen: false, transport: null }))).toBe(false);
-    expect(shouldRenderNativeSpaceWhiteboard(controller({ isOpen: true, transport: null }))).toBe(false);
-    expect(
-      shouldRenderNativeSpaceWhiteboard(
-        controller({
-          isOpen: true,
-          transport: {} as NonNullable<SpaceWhiteboardState["transport"]>,
-        }),
-      ),
-    ).toBe(true);
-  });
-
-  it("forwards renderer metrics in production runtimes", () => {
-    const onMetric = vi.fn();
-    const metric = { name: "whiteboard.frame.delay_ms", value: 17 };
-
-    forwardNativeSpaceWhiteboardMetric(metric, onMetric);
-
-    expect(onMetric).toHaveBeenCalledWith(metric);
-  });
-
-  it("forwards renderer failures without relying on development logging", () => {
-    const onMetric = vi.fn();
-    forwardNativeSpaceWhiteboardFailure({ code: "renderer_load_failed", recoverable: true }, onMetric);
-    expect(onMetric).toHaveBeenCalledWith({
-      name: "whiteboard.renderer.failure",
-      value: 1,
-      attributes: { code: "renderer_load_failed", recoverable: true },
-    });
-
-    const element = SpaceWhiteboardSurface({ whiteboard: controller({ isOpen: true, transport: {} as NonNullable<SpaceWhiteboardState["transport"]>, onMetric }) });
-    element?.props.onError({ code: "renderer_stopped", message: "renderer stopped", recoverable: true });
-    expect(onMetric).toHaveBeenCalledTimes(2);
-  });
-
-  it("passes the active NativeTheme color scheme to the embedded renderer", () => {
-    nativeTheme.colorScheme = "light";
-    const lightElement = SpaceWhiteboardSurface({ whiteboard: controller({ isOpen: true, transport: {} as NonNullable<SpaceWhiteboardState["transport"]> }) });
-    expect(lightElement).toMatchObject({ props: { theme: "light" } });
-
-    nativeTheme.colorScheme = "dark";
-    const darkElement = SpaceWhiteboardSurface({ whiteboard: controller({ isOpen: true, transport: {} as NonNullable<SpaceWhiteboardState["transport"]> }) });
-    expect(darkElement).toMatchObject({ props: { theme: "dark" } });
-  });
-});
-
-function controller(overrides: Partial<SpaceWhiteboardState>): SpaceWhiteboardState {
-  return {
-    isOpen: false,
-    canDraw: false,
-    canClear: false,
-    elements: [],
-    openParticipants: [],
-    transport: null,
-    journeyId: "journey-test",
-    open: vi.fn(),
-    close: vi.fn(),
-    toggle: vi.fn(),
-    requestSync: vi.fn(),
-    clear: vi.fn(),
-    ...overrides,
-  };
-}

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

@@ -1,31 +0,0 @@
-import { describe, expect, it } from "vitest";
-
-import { buildSpaceViewDiagnosticsSnapshot } from "./diagnostics";
-
-describe("buildSpaceViewDiagnosticsSnapshot", () => {
-  it("surfaces canonical feature and moderation availability", () => {
-    const snapshot = buildSpaceViewDiagnosticsSnapshot({
-      featureFlags: {
-        chat: true,
-        participants: true,
-        screenShare: false,
-        reactions: true,
-        handRaise: true,
-        whiteboard: true,
-      },
-      canEndEpisode: false,
-      participantCount: 2,
-      raisedHandCount: 0,
-      unreadChatCount: 0,
-      isScreenShareActive: false,
-      isLocalScreenSharing: false,
-      screenShareSharerParticipantId: null,
-    });
-
-    expect(snapshot.actionAvailability.screenShare).toMatchObject({
-      enabled: false,
-      reason: "feature-disabled",
-    });
-    expect(snapshot.actionAvailability.moderation.reason).toBe("capability-unavailable");
-  });
-});

package/src/components/native-space-view/format-space-duration.test.ts

@@ -1,13 +0,0 @@
-import { describe, expect, it } from "vitest";
-
-import { formatSpaceDuration } from "./format-space-duration";
-
-describe("formatSpaceDuration", () => {
-  it.each([
-    [0, "0:00"],
-    [59, "0:59"],
-    [125, "2:05"],
-  ])("formats %s elapsed seconds", (secondsElapsed, expected) => {
-    expect(formatSpaceDuration(secondsElapsed)).toBe(expected);
-  });
-});

package/src/components/native-space-view/native-space-grid-keys.test.ts

@@ -1,11 +0,0 @@
-import { describe, expect, it } from "vitest";
-
-import { nativeSpaceGridKey } from "./native-space-grid-keys";
-
-describe("nativeSpaceGridKey", () => {
-  it("changes when the ordered participant ids change and identifies an empty page", () => {
-    expect(nativeSpaceGridKey("page", [{ id: "participant-a" }, { id: "participant-b" }] as never)).toBe("page-participant-a|participant-b");
-    expect(nativeSpaceGridKey("page", [{ id: "participant-b" }, { id: "participant-a" }] as never)).toBe("page-participant-b|participant-a");
-    expect(nativeSpaceGridKey("page", [])).toBe("page-empty");
-  });
-});

package/src/components/native-space-view/native-space-page-store.test.ts

@@ -1,23 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-import { createSpacePageStore } from "./native-space-page-store";
-
-describe("createSpacePageStore", () => {
-  it("keeps a non-negative page and notifies subscribers when it changes", () => {
-    const store = createSpacePageStore();
-    const listener = vi.fn();
-    const unsubscribe = store.subscribe(listener);
-
-    store.setPage(2);
-    store.setPage(2);
-    store.clampToPageCount(1);
-
-    expect(store.getSnapshot()).toBe(0);
-    expect(listener).toHaveBeenCalledTimes(2);
-
-    unsubscribe();
-    store.setPage(3);
-
-    expect(store.getSnapshot()).toBe(3);
-    expect(listener).toHaveBeenCalledTimes(2);
-  });
-});

package/src/components/native-space-view/space-chat-attachments.test.ts

@@ -1,33 +0,0 @@
-import { CHALK_CHAT_ATTACHMENT_LIMITS } from "@q9labsai/chalk-client";
-import { describe, expect, it, vi } from "vitest";
-
-import { normalizeChatFileDrafts, uploadAndSendNativeChatAttachments } from "./space-chat-attachments";
-
-describe("native Space chat attachments", () => {
-  it("accepts lazy file readers and enforces the client bounds", () => {
-    const result = normalizeChatFileDrafts([
-      { name: "note.txt", type: "text/plain", size: 5, arrayBuffer: async () => new TextEncoder().encode("hello").buffer },
-      { fileName: "image.png", mimeType: "image/png", bytes: new Uint8Array([1, 2]).buffer },
-    ]);
-
-    expect(result.error).toBeNull();
-    expect(result.files.map((file) => file.fileName)).toEqual(["note.txt", "image.png"]);
-  });
-
-  it("rejects unsupported types and excess staged files before upload", () => {
-    expect(normalizeChatFileDrafts([{ name: "script.js", type: "application/javascript", size: 1, arrayBuffer: async () => new ArrayBuffer(1) }])).toMatchObject({ files: [], error: "This file type is not supported in Space chat." });
-    const files = Array.from({ length: CHALK_CHAT_ATTACHMENT_LIMITS.maximumPerMessage + 1 }, (_, index) => ({ name: `note-${index}.txt`, type: "text/plain", size: 1, arrayBuffer: async () => new ArrayBuffer(1) }));
-    expect(normalizeChatFileDrafts(files)).toMatchObject({ files: [], error: `You can attach up to ${CHALK_CHAT_ATTACHMENT_LIMITS.maximumPerMessage} files per message.` });
-  });
-
-  it("uploads every staged file before sending an attachment-only message", async () => {
-    const files = normalizeChatFileDrafts([{ name: "note.txt", type: "text/plain", size: 1, arrayBuffer: async () => new ArrayBuffer(1) }]).files;
-    const upload = vi.fn(async () => ({ attachmentId: "note.txt", fileName: "note.txt", mimeType: "text/plain" as const, byteLength: 1 }));
-    const send = vi.fn(async () => undefined);
-
-    await uploadAndSendNativeChatAttachments(files, "", upload, send);
-
-    expect(upload).toHaveBeenCalledOnce();
-    expect(send).toHaveBeenCalledWith({ text: "", attachments: [{ attachmentId: "note.txt", fileName: "note.txt", mimeType: "text/plain", byteLength: 1 }] });
-  });
-});

package/src/components/native-space-view/space-progressive-surface-helpers.test.ts

@@ -1,24 +0,0 @@
-import { describe, expect, it } from "vitest";
-
-import { buildParticipantActionDescriptors, formatChatTimestamp } from "./space-progressive-surface-helpers";
-
-describe("space progressive surface helpers", () => {
-  it("only exposes capability-backed Participant actions", () => {
-    const actions = buildParticipantActionDescriptors({
-      canMuteParticipants: true,
-      canRequestMedia: false,
-      canStopParticipantCamera: false,
-      canStopParticipantScreenShare: false,
-      canRemoveParticipants: true,
-    });
-
-    expect(actions.map((action) => action.label)).toEqual(["Mute microphone", "Remove Participant"]);
-    expect(actions.at(-1)?.destructive).toBe(true);
-  });
-
-  it("formats valid chat timestamps and ignores empty metadata", () => {
-    expect(formatChatTimestamp(0)).toBe("");
-    expect(formatChatTimestamp(Number.NaN)).toBe("");
-    expect(formatChatTimestamp(Date.UTC(2026, 7, 4, 12, 34))).toMatch(/\d{1,2}:34/);
-  });
-});

package/src/components/native-space-view/useSpaceViewController.contract.test.ts

@@ -1,10 +0,0 @@
-import { describe, expect, it } from "vitest";
-
-import type { SpaceViewControllerContractCheck } from "./useSpaceViewController.contract";
-
-describe("useSpaceViewController contract", () => {
-  it("keeps the bidirectional return-shape assertion compiled", () => {
-    const contractCheck: SpaceViewControllerContractCheck = true;
-    expect(contractCheck).toBe(true);
-  });
-});

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

@@ -1,106 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-
-const directClient = vi.hoisted(() => ({
-  chat: { files: { url: vi.fn(() => "https://example.test/file") }, loadOlder: vi.fn(async () => ({ status: "loaded" })), markRead: vi.fn(async () => null), send: vi.fn(async () => ({})) },
-  media: {
-    acceptRequest: vi.fn(async () => undefined),
-    declineRequest: vi.fn(async () => undefined),
-    setCameraEnabled: vi.fn(async () => undefined),
-    setMicrophoneEnabled: vi.fn(async () => undefined),
-    setScreenShareEnabled: vi.fn(async () => undefined),
-  },
-  participants: {
-    admit: vi.fn(async () => undefined),
-    assignRole: vi.fn(async () => undefined),
-    deny: vi.fn(async () => undefined),
-    lowerHand: vi.fn(async () => undefined),
-    mute: vi.fn(async () => undefined),
-    raiseHand: vi.fn(async () => undefined),
-    remove: vi.fn(async () => undefined),
-    renameSelf: vi.fn(async () => undefined),
-    requestMedia: vi.fn(async () => ({ status: "delivered" })),
-    stopScreenShare: vi.fn(async () => undefined),
-    stopVideo: vi.fn(async () => undefined),
-  },
-  reactions: { send: vi.fn(async () => ({})) },
-  whiteboard: { transport: vi.fn(() => null) },
-}));
-
-vi.mock("react", () => ({
-  useCallback: <T>(callback: T) => callback,
-  useEffect: () => undefined,
-  useMemo: <T>(factory: () => T) => factory(),
-  useState: <T>(initial: T): readonly [T, (next: T) => void] => [initial, vi.fn()],
-}));
-vi.mock("react-native", () => ({ Alert: { alert: vi.fn() }, Linking: { openURL: vi.fn(async () => undefined) } }));
-vi.mock("../../context/space-client-context", () => ({ useSpaceClient: () => directClient }));
-vi.mock("../../hooks/space-hooks", () => ({
-  useSelf: () => ({ participantId: "self", displayName: "Taylor", handRaised: false, can: (capability: string) => capability !== "endEpisode" }),
-  useParticipants: () => ({
-    roster: [
-      {
-        participantId: "self",
-        displayName: "Taylor",
-        role: "collaborator",
-        eligibleRoles: [],
-        capabilities: [],
-        handRaised: false,
-        media: { microphone: "active", camera: "active", screenShare: "inactive" },
-        presence: { state: "connected", speaking: false, activeSpeaker: false },
-      },
-    ],
-    admissionQueue: [],
-  }),
-  useMedia: () => ({
-    local: {
-      microphone: { state: "enabled", track: null },
-      camera: { state: "enabled", track: null },
-      screen: { state: "disabled", track: null },
-    },
-    screenShare: { state: "disabled", track: null },
-    remote: [],
-    incomingRequests: [],
-  }),
-  useChat: () => ({ status: "ready", messages: [], pendingSends: [], readReceipts: [], unreadCount: 0, pagination: { cursor: null, hasOlder: false, historyTruncated: false } }),
-  useReactions: () => ({ active: [] }),
-  useWhiteboard: () => ({ engine: { status: "ready", sceneId: null, revision: null, error: null } }),
-}));
-vi.mock("../../utils/ios-simulator", () => ({ isIosSimulator: () => false }));
-vi.mock("./useSpaceViewPanels", () => ({
-  useSpaceViewPanels: () => ({
-    layout: { layout: "grid" },
-    panel: null,
-    secondsElapsed: 5,
-    formattedDuration: "0:05",
-    actionsOpen: false,
-    reactionPickerOpen: false,
-    whiteboard: { isOpen: false, canDraw: true, canClear: false, elements: [], openParticipants: [], transport: null },
-    handleLeave: vi.fn(),
-    openPanel: vi.fn(),
-    closePanel: vi.fn(),
-    handleInviteParticipants: vi.fn(),
-  }),
-}));
-vi.mock("./useSpaceViewDerived", () => ({ useSpaceViewDerived: () => ({ isStageMode: false, gridPages: [], allParticipants: [] }) }));
-
-import { useSpaceViewController } from "./useSpaceViewController";
-
-describe("useSpaceViewController", () => {
-  it("binds native Space actions directly to the canonical SpaceClient", async () => {
-    const controller = useSpaceViewController({ spaceName: "Design review", onLeave: vi.fn() });
-
-    expect(controller.participants.localParticipant?.displayName).toBe("Taylor");
-    expect(controller.chat.isEnabled).toBe(true);
-    expect(controller.canSettings).toBe(true);
-    expect(controller.canInvite).toBe(false);
-    controller.toggleAudio();
-    controller.sendReaction("🎉");
-    controller.requestStartParticipantCamera("participant-2");
-
-    await vi.waitFor(() => {
-      expect(directClient.media.setMicrophoneEnabled).toHaveBeenCalledWith(false);
-      expect(directClient.reactions.send).toHaveBeenCalledWith("🎉");
-      expect(directClient.participants.requestMedia).toHaveBeenCalledWith("participant-2", "camera");
-    });
-  });
-});

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