@q9labsai/chalk-react-native 4.1.11 → 4.1.13

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

package/src/telemetry.test.ts

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

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

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

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

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

package/src/ui/appearance.test.ts

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