@q9labsai/chalk-react-native 4.0.0

package/dist/chunk-F3NPRVHO.js

@@ -0,0 +1,121 @@
+// src/runtime.ts
+import { NativeModules, Platform } from "react-native";
+var LOCAL_HOSTNAMES = /* @__PURE__ */ new Set(["localhost", "127.0.0.1", "0.0.0.0"]);
+function shouldAutoReadClipboard({ platform, isSimulator }) {
+  return !(platform === "ios" && isSimulator);
+}
+function getReactNativeScriptUrl() {
+  return NativeModules.SourceCode?.scriptURL ?? NativeModules.SourceCode?.getConstants?.().scriptURL ?? null;
+}
+function getMetroHostFromScriptUrl(scriptUrl) {
+  if (!scriptUrl) {
+    return null;
+  }
+  try {
+    const parsed = new URL(scriptUrl);
+    return parsed.hostname || null;
+  } catch {
+    return null;
+  }
+}
+function stripTrailingSlash(url) {
+  return url.endsWith("/") ? url.slice(0, -1) : url;
+}
+function isDeviceLocalHostname(hostname) {
+  return LOCAL_HOSTNAMES.has(hostname);
+}
+function isDeviceLocalUrl(url) {
+  try {
+    return isDeviceLocalHostname(new URL(url).hostname);
+  } catch {
+    return false;
+  }
+}
+function isConfiguredLocalApiUrl(configuredUrl) {
+  const candidate = configuredUrl?.trim();
+  return !!candidate && isDeviceLocalUrl(candidate);
+}
+function canUseLocalHostBootstrap(apiUrl, allowDeviceLocal) {
+  return allowDeviceLocal && isDeviceLocalUrl(apiUrl);
+}
+function resolveDeviceLocalUrl(url, scriptUrl, fallbackUrl) {
+  try {
+    const parsed = new URL(url);
+    if (!isDeviceLocalHostname(parsed.hostname)) {
+      return stripTrailingSlash(url);
+    }
+    const metroHost = getMetroHostFromScriptUrl(scriptUrl);
+    if (!metroHost) {
+      if (fallbackUrl) {
+        return stripTrailingSlash(fallbackUrl);
+      }
+      return stripTrailingSlash(url);
+    }
+    if (isDeviceLocalHostname(metroHost)) {
+      return stripTrailingSlash(url);
+    }
+    parsed.hostname = metroHost;
+    return stripTrailingSlash(parsed.toString());
+  } catch {
+    return stripTrailingSlash(url);
+  }
+}
+function resolveAppRuntimeUrl({ configuredUrl, scriptUrl, fallbackUrl, allowDeviceLocal }) {
+  const candidate = configuredUrl?.trim();
+  if (!candidate) {
+    return stripTrailingSlash(fallbackUrl);
+  }
+  if (!allowDeviceLocal && isDeviceLocalUrl(candidate)) {
+    return stripTrailingSlash(fallbackUrl);
+  }
+  return resolveDeviceLocalUrl(candidate, scriptUrl, fallbackUrl);
+}
+function getReactNativeVersionString() {
+  const version = Platform.constants?.reactNativeVersion;
+  if (!version) {
+    return null;
+  }
+  const major = typeof version.major === "number" ? version.major : null;
+  const minor = typeof version.minor === "number" ? version.minor : null;
+  const patch = typeof version.patch === "number" ? version.patch : null;
+  if (major === null || minor === null || patch === null) {
+    return null;
+  }
+  return `${major}.${minor}.${patch}`;
+}
+function isHermesEnabled() {
+  return "HermesInternal" in globalThis;
+}
+var readPlatformString = (value) => typeof value === "string" && value.length > 0 ? value : null;
+function getDeviceInfo({ appVersion = null, scriptUrl = getReactNativeScriptUrl() } = {}) {
+  const constants = Platform.constants ?? {};
+  return {
+    appVersion,
+    platform: Platform.OS,
+    osVersion: String(Platform.Version),
+    reactNativeVersion: getReactNativeVersionString(),
+    brand: readPlatformString(constants.Brand),
+    manufacturer: readPlatformString(constants.Manufacturer),
+    model: readPlatformString(constants.Model),
+    systemName: readPlatformString(constants.systemName),
+    interfaceIdiom: readPlatformString(constants.interfaceIdiom),
+    hermesEnabled: isHermesEnabled(),
+    scriptUrl
+  };
+}
+
+export {
+  shouldAutoReadClipboard,
+  getReactNativeScriptUrl,
+  getMetroHostFromScriptUrl,
+  stripTrailingSlash,
+  isDeviceLocalHostname,
+  isDeviceLocalUrl,
+  isConfiguredLocalApiUrl,
+  canUseLocalHostBootstrap,
+  resolveDeviceLocalUrl,
+  resolveAppRuntimeUrl,
+  getReactNativeVersionString,
+  isHermesEnabled,
+  getDeviceInfo
+};

package/dist/chunk-HXYIJ75K.js

@@ -0,0 +1,394 @@
+// src/space-client/create-native-space-client.ts
+import {
+  AsyncStorageV1PendingTargetStore,
+  CloudflareSFUClient,
+  createChalkChatFileHttpTransport,
+  createChalkWhiteboardV1Client,
+  createChalkWhiteboardV1FileHttpTransport,
+  createCloudflareSFUHTTPTransport,
+  createReactNativeSyncLifecycle,
+  createReactNativeWebSocketFactory,
+  createV1SyncClient
+} from "@q9labsai/chalk-client";
+import { createSpaceClientForPlatform } from "@q9labsai/chalk-client/effect";
+import { RTCPeerConnection, mediaDevices } from "@cloudflare/react-native-webrtc";
+import { AppState } from "react-native";
+
+// src/telemetry.ts
+import { syncTelemetryCorrelation } from "@q9labsai/chalk-client/telemetry";
+var rtcStateEvents = ["connectionstatechange", "iceconnectionstatechange", "signalingstatechange"];
+var nativeJourneyContexts = /* @__PURE__ */ new WeakMap();
+async function authenticatedNativeCredential(credential, journey) {
+  const value = await credential();
+  try {
+    journey?.setAuthenticatedTelemetryHeaders?.({ Authorization: `Bearer ${value}` });
+  } catch {
+  }
+  return value;
+}
+function bindNativeAuthenticatedTelemetry(client, journey) {
+  const setHeaders = journey?.setAuthenticatedTelemetryHeaders;
+  if (!setHeaders) return;
+  const clear = () => {
+    try {
+      setHeaders(void 0);
+    } catch {
+    }
+  };
+  const onSnapshot = () => {
+    const status = client.getSnapshot().connection.status;
+    if (status === "idle" || status === "failed" || status === "left") clear();
+  };
+  const unsubscribe = client.subscribe(onSnapshot);
+  let disposed = false;
+  const originalDispose = client.dispose;
+  client.dispose = () => {
+    if (disposed) return;
+    disposed = true;
+    clear();
+    unsubscribe();
+    originalDispose();
+  };
+}
+function registerNativeJourneyContext(client, journey, telemetry) {
+  if (!journey || !telemetry) return;
+  nativeJourneyContexts.set(client, {
+    journeyId: journey.context.journeyId,
+    traceparent: journey.context.traceparent,
+    ...journey.context.tracestate ? { tracestate: journey.context.tracestate } : {},
+    recordWhiteboardMetric: telemetry.recordWhiteboardMetric
+  });
+}
+function getNativeJourneyContext(client) {
+  return nativeJourneyContexts.get(client);
+}
+function createTelemetry(journey) {
+  const connection = {
+    apiHeaders: journey.headers,
+    context: journey.context,
+    syncCorrelation: syncTelemetryCorrelation(journey.context)
+  };
+  return {
+    connection,
+    observePeerConnection(peerConnection) {
+      return observeNativeRtc(peerConnection, journey);
+    },
+    recordSyncFrame(observation) {
+      journey.recordSyncFrame(observation);
+    },
+    recordWhiteboardMetric(metric) {
+      journey.recordDiagnostic({
+        category: "whiteboard_renderer",
+        code: metric.name,
+        metricValue: metric.value,
+        phase: "media",
+        state: isFailedWhiteboardMetric(metric.name) ? "failed" : "observed"
+      });
+    }
+  };
+}
+function syncTransportCloseDiagnostic(event) {
+  const code = typeof event.code === "number" ? event.code : null;
+  const reason = typeof event.reason === "string" ? event.reason : "";
+  return {
+    category: "network",
+    code: code === null ? "sync_websocket_closed_unknown" : `sync_websocket_closed_${code}_${syncCloseReason(reason)}`,
+    phase: "signaling",
+    state: code === 1e3 ? "observed" : "failed"
+  };
+}
+function syncCloseReason(reason) {
+  switch (reason) {
+    case "authentication failed":
+    case "heartbeat timeout":
+    case "hello timeout":
+    case "invalid token":
+    case "policy violation":
+    case "space actions unsupported":
+    case "text frames only":
+    case "transport error":
+      return reason.replaceAll(" ", "_");
+    default:
+      return reason ? "other" : "none";
+  }
+}
+function isFailedWhiteboardMetric(name) {
+  return name.endsWith(".failure") || name.endsWith(".termination");
+}
+function observeNativeRtc(peerConnection, journey) {
+  let disposed = false;
+  const dispose = () => {
+    if (disposed) return;
+    disposed = true;
+    for (const event of rtcStateEvents) peerConnection.removeEventListener(event, capture);
+  };
+  const capture = () => {
+    void peerConnection.getStats().then((stats) => journey.recordRtcSummary(rtcConnectionState(peerConnection), rtcStats(stats))).catch(() => void 0);
+    if (peerConnection.connectionState === "closed") dispose();
+  };
+  for (const event of rtcStateEvents) peerConnection.addEventListener(event, capture);
+  capture();
+  return dispose;
+}
+function rtcConnectionState(peerConnection) {
+  return {
+    connectionState: peerConnection.connectionState,
+    iceConnectionState: peerConnection.iceConnectionState,
+    signalingState: peerConnection.signalingState
+  };
+}
+function rtcStats(stats) {
+  if (Array.isArray(stats)) return stats.filter(isRtcStatsLike);
+  if (isIterable(stats)) return Array.from(stats, statsValue).filter(isRtcStatsLike);
+  if (hasForEach(stats)) return forEachStats(stats);
+  if (isObject(stats)) return Object.values(stats).filter(isRtcStatsLike);
+  return [];
+}
+function isIterable(value) {
+  return isObject(value) && Symbol.iterator in value;
+}
+function hasForEach(value) {
+  return isObject(value) && "forEach" in value && typeof value.forEach === "function";
+}
+function forEachStats(stats) {
+  const entries = [];
+  stats.forEach((entry) => {
+    if (isRtcStatsLike(entry)) entries.push(entry);
+  });
+  return entries;
+}
+function statsValue(entry) {
+  return Array.isArray(entry) ? entry[1] : entry;
+}
+function isRtcStatsLike(value) {
+  return isObject(value) && typeof value.type === "string";
+}
+function isObject(value) {
+  return typeof value === "object" && value !== null;
+}
+
+// src/space-client/create-native-space-client.ts
+function createNativeSpaceClient(options) {
+  const { storage, telemetry: journey } = options;
+  const apiBaseURL = options.baseUrl ?? "https://api.chalkmeet.com";
+  const syncURL = options.syncUrl ?? defaultSyncURL(apiBaseURL);
+  const telemetry = journey ? createTelemetry(journey) : void 0;
+  const fetch = telemetryFetch(journey);
+  const lifecycle = createReactNativeSyncLifecycle({ appState: AppState });
+  const webSocket = createReactNativeWebSocketFactory(nativeWebSocketConstructor(journey));
+  const dependencies = {
+    clock: {
+      now: () => Date.now(),
+      setTimeout: (callback, milliseconds) => globalThis.setTimeout(callback, milliseconds),
+      clearTimeout: (handle) => globalThis.clearTimeout(handle)
+    },
+    mediaDevices: {
+      getUserMedia: async (constraints) => await mediaDevices.getUserMedia(constraints),
+      getDisplayMedia: async () => await mediaDevices.getDisplayMedia()
+    },
+    createMediaClient: (input) => createMediaClient(apiBaseURL, input, fetch, telemetry?.observePeerConnection, journey),
+    createSyncClient: (input) => createSyncClient(syncURL, input, lifecycle, webSocket, storage),
+    createChatFileTransport: (input) => createChatFileTransport(apiBaseURL, input, fetch),
+    createWhiteboardClient: options.whiteboardURL === null ? void 0 : (input) => createWhiteboardClient(apiBaseURL, options.whiteboardURL ?? whiteboardURL(syncURL), input, fetch, lifecycle, webSocket),
+    subscribeForeground: (listener) => {
+      const subscription = AppState.addEventListener("change", (state) => {
+        if (state === "active") listener();
+      });
+      return () => subscription.remove();
+    }
+  };
+  const client = createSpaceClientForPlatform(
+    { space: options.space, getAccess: options.getAccess, baseUrl: apiBaseURL },
+    {
+      apiBaseUrl: apiBaseURL,
+      syncUrl: syncURL,
+      whiteboardUrl: options.whiteboardURL,
+      telemetry: journey?.context,
+      dependencies,
+      fetch,
+      syncStartupTimeoutMs: options.syncStartupTimeoutMs ?? 3e4,
+      initialMicrophoneEnabled: options.microphone,
+      initialCameraEnabled: options.camera,
+      onConnectionDiagnostic: (event) => journey?.recordDiagnostic(connectionDiagnostic(event))
+    }
+  );
+  bindNativeAuthenticatedTelemetry(client, journey);
+  registerNativeJourneyContext(client, journey, telemetry);
+  return client;
+}
+function connectionDiagnostic(event) {
+  if (event.event === "space_join_span" && event.step && event.spanId && event.outcome) {
+    return {
+      category: "connection",
+      code: `space.join.${event.step}.${event.outcome}`,
+      phase: joinTracePhase(event.step),
+      state: event.outcome === "succeeded" ? "succeeded" : event.outcome === "failed" ? "failed" : "observed",
+      ...event.durationMs === void 0 ? {} : { metricValue: event.durationMs },
+      attributes: {
+        span_id: event.spanId,
+        ...event.parentSpanId ? { parent_span_id: event.parentSpanId } : {},
+        step: event.step,
+        outcome: event.outcome,
+        epoch: event.epoch,
+        ...event.code ? { failure_code: event.code } : {}
+      }
+    };
+  }
+  return {
+    category: "connection",
+    code: event.event,
+    phase: event.state === "joining" ? "signaling" : event.state === "leaving" || event.state === "left" ? "terminal" : "recovery",
+    state: event.event.endsWith("_failed") || event.event.endsWith("_exhausted") ? "failed" : "observed"
+  };
+}
+function joinTracePhase(step) {
+  switch (step) {
+    case "acquire_initial_media":
+    case "create_media_client":
+    case "start_media":
+      return "media";
+    default:
+      return "signaling";
+  }
+}
+function createMediaClient(apiBaseURL, input, fetch, observePeerConnection, journey) {
+  const { subject } = input.access;
+  return new CloudflareSFUClient({
+    bootstrap: input.access.media.clientPayload,
+    participantId: subject.participantId,
+    transport: createCloudflareSFUHTTPTransport({
+      apiBaseURL,
+      credential: () => authenticatedNativeCredential(input.credential, journey),
+      tenantId: subject.tenantId,
+      spaceId: subject.spaceId,
+      episodeId: subject.episodeId,
+      participantId: subject.participantId,
+      fetch
+    }),
+    peerConnectionFactory: (configuration) => {
+      const connection = new RTCPeerConnection(configuration);
+      observePeerConnection?.(connection);
+      return connection;
+    },
+    onError: input.onFailure,
+    onScreenEnded: input.onScreenEnded
+  });
+}
+function createSyncClient(syncURL, input, lifecycle, webSocket, storage) {
+  const subject = input.access.subject;
+  const scope = `${subject.tenantId}:${subject.episodeId}:${subject.participantId}`;
+  return createV1SyncClient({
+    url: syncURL,
+    token: input.token,
+    mediaPlane: input.media,
+    lifecycle,
+    webSocket,
+    telemetry: input.telemetry,
+    ...storage ? { pendingStore: new AsyncStorageV1PendingTargetStore({ scope, storage }) } : {}
+  });
+}
+function createChatFileTransport(apiBaseURL, input, fetch) {
+  return createChalkChatFileHttpTransport({ baseUrl: apiBaseURL, token: input.token, fetch });
+}
+function createWhiteboardClient(apiBaseURL, url, input, fetch, lifecycle, webSocket) {
+  let sceneId = null;
+  const files = createChalkWhiteboardV1FileHttpTransport({
+    baseUrl: apiBaseURL,
+    token: input.token,
+    sceneId: () => {
+      if (sceneId === null) throw new TypeError("Whiteboard scene is not ready");
+      return sceneId;
+    },
+    fetch
+  });
+  return createChalkWhiteboardV1Client({
+    url,
+    token: input.token,
+    files,
+    lifecycle,
+    webSocket,
+    onSummary: (summary) => {
+      sceneId = summary.sceneId;
+      input.onSummary(summary);
+    }
+  });
+}
+function telemetryFetch(journey) {
+  if (!journey) return globalThis.fetch;
+  return (input, init) => {
+    const headers = new Headers(init?.headers);
+    for (const [name, value] of Object.entries(journey.headers)) headers.set(name, value);
+    return globalThis.fetch(input, { ...init, headers });
+  };
+}
+function nativeWebSocketConstructor(journey) {
+  const RuntimeWebSocket = globalThis.WebSocket;
+  return class ChalkNativeWebSocket {
+    onopen = null;
+    onmessage = null;
+    onclose = null;
+    onerror = null;
+    #socket;
+    constructor(url) {
+      this.#socket = new RuntimeWebSocket(url, void 0, journey ? { headers: journey.headers } : void 0);
+      this.#socket.onopen = (event) => this.onopen?.(event);
+      this.#socket.onmessage = (event) => {
+        recordSyncFrame(journey, "server_to_client", event.data);
+        this.onmessage?.(event);
+      };
+      this.#socket.onclose = (event) => {
+        recordSyncTransportClose(journey, event);
+        this.onclose?.(event);
+      };
+      this.#socket.onerror = (event) => {
+        journey?.recordDiagnostic({ category: "network", code: "sync_websocket_error", phase: "signaling", state: "failed" });
+        this.onerror?.(event);
+      };
+    }
+    send(data) {
+      recordSyncFrame(journey, "client_to_server", data);
+      this.#socket.send(data);
+    }
+    close(code, reason) {
+      this.#socket.close(code, reason);
+    }
+  };
+}
+function recordSyncTransportClose(journey, event) {
+  if (!journey) return;
+  journey.recordDiagnostic(syncTransportCloseDiagnostic(event));
+}
+function recordSyncFrame(journey, direction, data) {
+  if (!journey) return;
+  let frameType = "binary";
+  if (typeof data === "string") {
+    try {
+      const frame = JSON.parse(data);
+      frameType = typeof frame.type === "string" ? frame.type : "unknown";
+    } catch {
+      frameType = "invalid_json";
+    }
+  }
+  journey.recordSyncFrame({ direction, frameType });
+}
+function whiteboardURL(syncURL) {
+  const url = new URL(syncURL);
+  url.pathname = "/v1/whiteboard";
+  url.search = "";
+  url.hash = "";
+  return url.toString();
+}
+function defaultSyncURL(apiBaseURL) {
+  const url = new URL(apiBaseURL);
+  url.protocol = url.protocol === "https:" ? "wss:" : "ws:";
+  if (url.hostname.startsWith("api.")) url.hostname = `sync.${url.hostname.slice(4)}`;
+  url.pathname = "/v1/sync";
+  url.search = "";
+  url.hash = "";
+  return url.toString();
+}
+
+export {
+  getNativeJourneyContext,
+  createNativeSpaceClient
+};