@opengeni/react 6.5.2-canary.41607687019001 → 6.7.0

package/dist/chunk-I7ITSXSJ.js

@@ -0,0 +1,603 @@
+"use client";
+import {
+  useEmbeddedRealtimeSession
+} from "./chunk-TVQCDDSZ.js";
+import {
+  useOpenGeniText
+} from "./chunk-7T2ZE3VT.js";
+
+// src/realtime/session-realtime.ts
+import {
+  hasStoredSessionRealtimeOwnerProof,
+  isSessionRealtimeModel,
+  projectSessionRealtimeLifecycle
+} from "@opengeni/sdk/realtime";
+import { useCallback, useEffect, useMemo, useRef, useState, useSyncExternalStore } from "react";
+function abortError(message) {
+  if (typeof DOMException !== "undefined") return new DOMException(message, "AbortError");
+  const error = new Error(message);
+  error.name = "AbortError";
+  return error;
+}
+var CODEX_LIVE_MODEL = (t) => ({
+  id: "gpt-live-1-boulder-alpha",
+  label: t("realtime.sessionRealtime.codexLive"),
+  provider: "Connected Codex",
+  description: t("realtime.sessionRealtime.deepSessionIntegration"),
+  available: false,
+  unavailableReason: t("realtime.sessionRealtime.connectCodexToUseThis"),
+  recommended: false
+});
+var REALTIME_MODEL_STORAGE_PREFIX = "opengeni:realtime-model";
+var REALTIME_LANGUAGE_STORAGE_KEY = "opengeni:realtime-language";
+var REALTIME_MODEL_CATALOG_CACHE_TTL_MS = 6e4;
+var REALTIME_MODEL_CATALOG_CACHE_MAX_WORKSPACES = 64;
+var realtimeLanguageListeners = /* @__PURE__ */ new Set();
+var realtimeLanguageMemory = null;
+function readRealtimeLanguagePreference() {
+  if (typeof localStorage === "undefined") return realtimeLanguageMemory;
+  try {
+    return localStorage.getItem(REALTIME_LANGUAGE_STORAGE_KEY) ?? null;
+  } catch {
+    return realtimeLanguageMemory;
+  }
+}
+function subscribeRealtimeLanguagePreference(listener) {
+  realtimeLanguageListeners.add(listener);
+  return () => realtimeLanguageListeners.delete(listener);
+}
+function useRealtimeLanguagePreference() {
+  const language = useSyncExternalStore(
+    subscribeRealtimeLanguagePreference,
+    readRealtimeLanguagePreference,
+    () => null
+  );
+  const setLanguage = useCallback((next) => {
+    realtimeLanguageMemory = next;
+    if (typeof localStorage !== "undefined") {
+      try {
+        if (next === null) localStorage.removeItem(REALTIME_LANGUAGE_STORAGE_KEY);
+        else localStorage.setItem(REALTIME_LANGUAGE_STORAGE_KEY, next);
+      } catch {
+      }
+    }
+    for (const listener of realtimeLanguageListeners) listener();
+  }, []);
+  return { language, setLanguage };
+}
+function realtimeAppLanguage(locale) {
+  if (locale) return locale;
+  return typeof navigator === "undefined" ? void 0 : navigator.language || void 0;
+}
+function realtimeConversationLanguage(model, preference, locale) {
+  if (!model?.languages?.length) return void 0;
+  return preference ?? realtimeAppLanguage(locale);
+}
+var realtimeModelCatalogCache = /* @__PURE__ */ new WeakMap();
+function realtimeModelFallback(t, codexConnected) {
+  return [
+    {
+      ...CODEX_LIVE_MODEL(t),
+      available: codexConnected,
+      unavailableReason: codexConnected ? null : CODEX_LIVE_MODEL(t).unavailableReason
+    }
+  ];
+}
+function realtimeModelCatalogCacheFor(client) {
+  const existing = realtimeModelCatalogCache.get(client);
+  if (existing) return existing;
+  const created = /* @__PURE__ */ new Map();
+  realtimeModelCatalogCache.set(client, created);
+  return created;
+}
+function readCachedRealtimeModelCatalog(client, workspaceId, now = Date.now()) {
+  const cache = realtimeModelCatalogCache.get(client);
+  const entry = cache?.get(workspaceId);
+  if (!entry || entry.state === "loading") return null;
+  if (entry.expiresAt > now) return entry.models;
+  cache?.delete(workspaceId);
+  return null;
+}
+function pruneRealtimeModelCatalogCache(cache, now) {
+  for (const [workspaceId, entry] of cache) {
+    if (entry.state === "ready" && entry.expiresAt <= now) cache.delete(workspaceId);
+  }
+  while (cache.size >= REALTIME_MODEL_CATALOG_CACHE_MAX_WORKSPACES) {
+    const oldestWorkspaceId = cache.keys().next().value;
+    if (oldestWorkspaceId === void 0) return;
+    cache.delete(oldestWorkspaceId);
+  }
+}
+function loadRealtimeModelCatalog(client, workspaceId, signal) {
+  const load = client.getWorkspaceRealtimeModelCatalog;
+  if (!load) return null;
+  if (signal?.aborted) {
+    return Promise.reject(signal.reason ?? abortError("Request aborted"));
+  }
+  const now = Date.now();
+  const cache = realtimeModelCatalogCacheFor(client);
+  const entry = cache.get(workspaceId);
+  if (entry?.state === "loading" && !entry.controller.signal.aborted) {
+    return consumeRealtimeModelCatalog(entry, signal);
+  }
+  if (entry?.state === "ready" && entry.expiresAt > now) return Promise.resolve(entry.models);
+  if (entry) cache.delete(workspaceId);
+  pruneRealtimeModelCatalogCache(cache, now);
+  const controller = new AbortController();
+  const promise = load.call(client, workspaceId, { signal: controller.signal }).then((response) => response.models.map(toRealtimeModelOption)).then((models) => {
+    const current = cache.get(workspaceId);
+    if (current?.state === "loading" && current.promise === promise) {
+      cache.delete(workspaceId);
+      cache.set(workspaceId, {
+        state: "ready",
+        models,
+        expiresAt: Date.now() + REALTIME_MODEL_CATALOG_CACHE_TTL_MS
+      });
+    }
+    return models;
+  }).catch((error) => {
+    const current = cache.get(workspaceId);
+    if (current?.state === "loading" && current.promise === promise) cache.delete(workspaceId);
+    throw error;
+  });
+  const loading = {
+    state: "loading",
+    promise,
+    controller,
+    consumers: 0
+  };
+  cache.set(workspaceId, loading);
+  return consumeRealtimeModelCatalog(loading, signal);
+}
+function consumeRealtimeModelCatalog(entry, signal) {
+  entry.consumers += 1;
+  return new Promise((resolve, reject) => {
+    let released = false;
+    const release = (abandoned) => {
+      if (released) return;
+      released = true;
+      entry.consumers = Math.max(0, entry.consumers - 1);
+      if (abandoned && entry.consumers === 0) {
+        entry.controller.abort(signal?.reason ?? abortError("Request abandoned"));
+      }
+    };
+    const onAbort = () => {
+      release(true);
+      reject(signal?.reason ?? abortError("Request aborted"));
+    };
+    signal?.addEventListener("abort", onAbort, { once: true });
+    void entry.promise.then(resolve, reject).finally(() => {
+      signal?.removeEventListener("abort", onAbort);
+      release(false);
+    });
+  });
+}
+var prestartedSessionRealtime = /* @__PURE__ */ new Map();
+var abandonedSessionRealtime = /* @__PURE__ */ new Map();
+function prestartKey(workspaceId, sessionId) {
+  return `${workspaceId}\0${sessionId}`;
+}
+function prestartSessionRealtime(input) {
+  const key = prestartKey(input.workspaceId, input.sessionId);
+  const existing = prestartedSessionRealtime.get(key);
+  if (existing?.model === input.model) return abandonPrestarted(key, existing);
+  if (existing) abandonPrestarted(key, existing)();
+  const modelContext = { current: void 0 };
+  const language = { current: () => input.language };
+  const voiceSettings = {
+    current: () => input.voiceSettings
+  };
+  const controller = (abandonedSessionRealtime.get(key) ?? Promise.resolve()).then(() => import("@opengeni/sdk/realtime")).then(({ createSessionRealtimeController }) => {
+    const created = (input.controllerFactory ?? createSessionRealtimeController)({
+      client: input.client,
+      workspaceId: input.workspaceId,
+      sessionId: input.sessionId,
+      // The adopting view's audio element does not exist yet; a detached
+      // element plays the same way.
+      ...typeof Audio === "undefined" ? {} : { remoteAudio: new Audio() },
+      model: input.model,
+      getModelContext: () => modelContext.current?.(),
+      getLanguage: () => language.current(),
+      getVoiceSettings: () => voiceSettings.current()
+    });
+    void created.start().catch(() => void 0);
+    return created;
+  });
+  const entry = {
+    model: input.model,
+    controller,
+    modelContext,
+    language,
+    voiceSettings
+  };
+  prestartedSessionRealtime.set(key, entry);
+  controller.catch(() => {
+    if (prestartedSessionRealtime.get(key) === entry) prestartedSessionRealtime.delete(key);
+  });
+  return abandonPrestarted(key, entry);
+}
+function abandonPrestarted(key, entry) {
+  return () => {
+    if (prestartedSessionRealtime.get(key) !== entry) return;
+    prestartedSessionRealtime.delete(key);
+    const ended = entry.controller.then(
+      (abandoned) => abandoned.stop().catch(() => void 0).finally(() => abandoned.close()),
+      () => void 0
+    );
+    abandonedSessionRealtime.set(key, ended);
+    void ended.finally(() => {
+      if (abandonedSessionRealtime.get(key) === ended) abandonedSessionRealtime.delete(key);
+    });
+  };
+}
+function codexRealtimeAdmissionAllowed(t, input) {
+  return codexRealtimeAdmissionBlocker(t, input) === null;
+}
+function codexRealtimeAdmissionBlocker(t, input) {
+  if (input.sessionStatus === "cancelled")
+    return t("realtime.sessionRealtime.thisSessionWasCancelled");
+  if (input.controlState !== "active")
+    return t("realtime.sessionRealtime.resumeThisSessionBeforeStarting");
+  if (input.settlement !== null) return t("realtime.sessionRealtime.waitForTheCurrentSession");
+  if (!input.codexConnected) return t("realtime.sessionRealtime.connectCodexToUseThis2");
+  if (input.lifecycleActive) return t("realtime.sessionRealtime.voiceIsAlreadyActiveFor");
+  return null;
+}
+function useSessionRealtime(options) {
+  const t = useOpenGeniText();
+  const { client, workspaceId } = useEmbeddedRealtimeSession({
+    client: options.client,
+    workspaceId: options.workspaceId
+  });
+  const model = options.model ?? CODEX_LIVE_MODEL(t).id;
+  const audioRef = useRef(null);
+  const controllerRef = useRef(null);
+  const controllerModelRef = useRef(null);
+  const modelContextProviderRef = useRef(options.getModelContext);
+  modelContextProviderRef.current = options.getModelContext;
+  const languageRef = useRef(options.language);
+  languageRef.current = options.language;
+  const voiceSettingsRef = useRef(options.voiceSettings);
+  voiceSettingsRef.current = options.voiceSettings;
+  const [snapshot, setSnapshot] = useState(() => ({
+    status: hasStoredSessionRealtimeOwnerProof({
+      workspaceId,
+      sessionId: options.sessionId,
+      model
+    }) ? "recovering" : "idle",
+    realtimeId: null,
+    mode: null,
+    bridge: null,
+    microphone: "inactive",
+    inputMuted: false,
+    audibleOutput: "inactive",
+    outputMuted: false,
+    connectionGeneration: 0,
+    reconnectAttempt: 0,
+    diagnostic: null,
+    error: null
+  }));
+  const lifecycle = useMemo(
+    () => projectSessionRealtimeLifecycle(options.events),
+    [options.events]
+  );
+  const lifecycleRef = useRef(lifecycle);
+  const eventsReadyRef = useRef(options.eventsReady);
+  lifecycleRef.current = lifecycle;
+  eventsReadyRef.current = options.eventsReady;
+  const lifecycleActive = sessionRealtimeLifecycleIsActive(lifecycle);
+  const [prestarted, setPrestarted] = useState(false);
+  useEffect(() => {
+    let disposed = false;
+    let controller = null;
+    let unsubscribe = null;
+    const key = prestartKey(workspaceId, options.sessionId);
+    const adopted = prestartedSessionRealtime.get(key);
+    if (adopted && adopted.model !== model) return;
+    if (adopted) {
+      prestartedSessionRealtime.delete(key);
+      adopted.modelContext.current = () => modelContextProviderRef.current?.();
+      adopted.language.current = () => languageRef.current;
+      adopted.voiceSettings.current = () => voiceSettingsRef.current;
+    }
+    const pending = adopted ? adopted.controller : import("@opengeni/sdk/realtime").then(({ createSessionRealtimeController }) => {
+      if (disposed) return null;
+      const controllerFactory = options.controllerFactory ?? createSessionRealtimeController;
+      return controllerFactory({
+        client,
+        workspaceId,
+        sessionId: options.sessionId,
+        ...audioRef.current ? { remoteAudio: audioRef.current } : {},
+        model,
+        getModelContext: () => modelContextProviderRef.current?.(),
+        getLanguage: () => languageRef.current,
+        getVoiceSettings: () => voiceSettingsRef.current
+      });
+    });
+    void pending.then((created) => {
+      if (!created) return;
+      if (disposed) {
+        created.close();
+        return;
+      }
+      controller = created;
+      controllerRef.current = controller;
+      controllerModelRef.current = model;
+      setPrestarted(adopted !== void 0);
+      unsubscribe = controller.subscribe(setSnapshot);
+      if (eventsReadyRef.current) {
+        void controller.observeLifecycle(lifecycleRef.current).catch(() => void 0);
+      }
+    }).catch((error) => {
+      if (disposed) return;
+      setSnapshot({
+        status: "error",
+        realtimeId: null,
+        mode: null,
+        bridge: null,
+        microphone: "inactive",
+        inputMuted: false,
+        audibleOutput: "inactive",
+        outputMuted: false,
+        connectionGeneration: 0,
+        reconnectAttempt: 0,
+        diagnostic: {
+          kind: "negotiation_failure",
+          message: error instanceof Error ? error.message : t("realtime.sessionRealtime.codexRealtimeControllerFailedTo"),
+          recoverable: false,
+          connectionGeneration: 0,
+          attempt: 0
+        },
+        error: error instanceof Error ? error.message : t("realtime.sessionRealtime.codexRealtimeControllerFailedTo")
+      });
+    });
+    return () => {
+      disposed = true;
+      unsubscribe?.();
+      controller?.close();
+      if (controllerRef.current === controller) {
+        controllerRef.current = null;
+        controllerModelRef.current = null;
+      }
+    };
+  }, [client, model, options.controllerFactory, options.sessionId, workspaceId, t]);
+  useEffect(() => {
+    if (!options.eventsReady) return;
+    void controllerRef.current?.observeLifecycle(lifecycle).catch(() => void 0);
+  }, [lifecycle, options.eventsReady]);
+  const delegationOutcomeSequence = useMemo(
+    () => latestDelegationOutcomeSequence(options.events),
+    [options.events]
+  );
+  const flushedOutcomeSequenceRef = useRef(delegationOutcomeSequence);
+  useEffect(() => {
+    if (delegationOutcomeSequence <= flushedOutcomeSequenceRef.current) return;
+    flushedOutcomeSequenceRef.current = delegationOutcomeSequence;
+    void controllerRef.current?.flush().catch(() => void 0);
+  }, [delegationOutcomeSequence]);
+  const start = useCallback(async () => {
+    const controller = controllerRef.current;
+    if (!controller || controllerModelRef.current !== model) {
+      throw new Error(t("realtime.sessionRealtime.theSelectedVoiceModelIs"));
+    }
+    await controller.start();
+  }, [model, t]);
+  const stop = useCallback(async () => {
+    await controllerRef.current?.stop();
+  }, []);
+  const retry = useCallback(async () => {
+    await controllerRef.current?.retry();
+  }, []);
+  const retryAudibleOutput = useCallback(async () => {
+    await controllerRef.current?.retryAudibleOutput();
+  }, []);
+  const setInputMuted = useCallback((muted) => {
+    controllerRef.current?.setInputMuted(muted);
+  }, []);
+  const setOutputMuted = useCallback((muted) => {
+    controllerRef.current?.setOutputMuted(muted);
+  }, []);
+  const admissionInput = {
+    sessionStatus: options.sessionStatus,
+    controlState: options.effectiveControl.state,
+    settlement: options.effectiveControl.settlement,
+    codexConnected: options.modelAvailable ?? options.codexConnected,
+    lifecycleActive
+  };
+  const admissionBlocker = options.modelAvailable === false ? options.modelUnavailableReason ?? t("realtime.sessionRealtime.thisVoiceModelIsUnavailable") : codexRealtimeAdmissionBlocker(t, admissionInput);
+  const canStart = controllerRef.current !== null && controllerModelRef.current === model && ["idle", "error"].includes(snapshot.status) && admissionBlocker === null;
+  return {
+    snapshot,
+    lifecycleActive,
+    /** The current call was started before this view mounted and adopted here. */
+    prestarted,
+    canStart,
+    admissionBlocker,
+    codexConnected: options.codexConnected,
+    audioRef,
+    start,
+    stop,
+    retry,
+    retryAudibleOutput,
+    setInputMuted,
+    setOutputMuted
+  };
+}
+var DELEGATION_OUTCOME_EVENT_TYPES = /* @__PURE__ */ new Set([
+  "agent.message.completed",
+  "turn.completed",
+  "turn.failed",
+  "turn.cancelled",
+  "turn.superseded"
+]);
+function latestDelegationOutcomeSequence(events) {
+  for (let index = events.length - 1; index >= 0; index -= 1) {
+    const event = events[index];
+    if (DELEGATION_OUTCOME_EVENT_TYPES.has(event.type)) return event.sequence;
+  }
+  return 0;
+}
+function sessionRealtimeLifecycleIsActive(lifecycle) {
+  if (lifecycle?.state !== "active") return false;
+  const leaseExpiresAt = Date.parse(lifecycle.leaseExpiresAt);
+  return !Number.isFinite(leaseExpiresAt) || leaseExpiresAt > Date.now();
+}
+function fallbackRealtimeModelId(t, models) {
+  return models.find((model) => model.available)?.id ?? models.find((model) => model.unavailableCode)?.id ?? CODEX_LIVE_MODEL(t).id;
+}
+function startingRealtimeModelId(t, models, picked) {
+  const usable = (id) => models.some((model) => model.id === id && model.available);
+  if (picked && usable(picked)) return picked;
+  const chosen = models.find((model) => model.workspaceDefault) ?? models.find((model) => model.organizationDefault);
+  if (chosen?.available) return chosen.id;
+  if (!picked && usable(CODEX_LIVE_MODEL(t).id)) return CODEX_LIVE_MODEL(t).id;
+  return fallbackRealtimeModelId(t, models);
+}
+function useRealtimeModelSelection(options) {
+  const t = useOpenGeniText();
+  const { client, workspaceId } = useEmbeddedRealtimeSession({
+    client: options.client,
+    workspaceId: options.workspaceId
+  });
+  const activeModel = options.activeModel;
+  const initialCachedCatalog = readCachedRealtimeModelCatalog(client, workspaceId);
+  const [catalog, setCatalog] = useState(
+    () => initialCachedCatalog ?? realtimeModelFallback(t, options.codexConnected)
+  );
+  const catalogScopeRef = useRef({
+    client,
+    workspaceId,
+    source: initialCachedCatalog ? "cache" : "fallback"
+  });
+  const [fallbackFinal, setFallbackFinal] = useState(null);
+  const pickedRef = useRef(null);
+  const activeModelRef = useRef(activeModel ?? null);
+  const [selectedModelId, setSelectedModelId] = useState(() => {
+    const picked = readRealtimeModelPreference(workspaceId);
+    if (!initialCachedCatalog) return picked ?? CODEX_LIVE_MODEL(t).id;
+    return startingRealtimeModelId(t, initialCachedCatalog, picked);
+  });
+  useEffect(() => {
+    activeModelRef.current = activeModel ?? null;
+  }, [activeModel]);
+  useEffect(() => {
+    let disposed = false;
+    const requestAbort = new AbortController();
+    const applyCatalog = (models) => {
+      catalogScopeRef.current = { client, workspaceId, source: "cache" };
+      setCatalog(models);
+      if (activeModelRef.current) {
+        setSelectedModelId(activeModelRef.current);
+        return;
+      }
+      const picked = readRealtimeModelPreference(workspaceId) ?? (pickedRef.current?.workspaceId === workspaceId ? pickedRef.current.model : null);
+      setSelectedModelId(startingRealtimeModelId(t, models, picked));
+    };
+    const cached = readCachedRealtimeModelCatalog(client, workspaceId);
+    if (cached) {
+      const scope2 = catalogScopeRef.current;
+      if (scope2.client !== client || scope2.workspaceId !== workspaceId || scope2.source !== "cache") {
+        applyCatalog(cached);
+      }
+      return;
+    }
+    const loading = loadRealtimeModelCatalog(client, workspaceId, requestAbort.signal);
+    if (!loading) {
+      setFallbackFinal({ client, workspaceId, failed: false });
+      return;
+    }
+    void loading.then((models) => {
+      if (disposed) return;
+      applyCatalog(models);
+    }).catch(() => {
+      if (!disposed) setFallbackFinal({ client, workspaceId, failed: true });
+    });
+    return () => {
+      disposed = true;
+      requestAbort.abort();
+    };
+  }, [client, workspaceId, t]);
+  useEffect(() => {
+    if (activeModel) setSelectedModelId(activeModel);
+  }, [activeModel]);
+  const selectedModel = catalog.find((model) => model.id === selectedModelId) ?? {
+    ...CODEX_LIVE_MODEL(t),
+    available: options.codexConnected,
+    unavailableReason: options.codexConnected ? null : CODEX_LIVE_MODEL(t).unavailableReason
+  };
+  const selectModel = useCallback(
+    (value) => {
+      const model = catalog.find((candidate) => candidate.id === value);
+      if (!model || !model.available || activeModel) return;
+      setSelectedModelId(model.id);
+      pickedRef.current = { workspaceId, model: model.id };
+      writeRealtimeModelPreference(workspaceId, model.id);
+    },
+    [activeModel, catalog, workspaceId]
+  );
+  const { language: languagePreference } = useRealtimeLanguagePreference();
+  const languageFor = useCallback(
+    (modelId) => realtimeConversationLanguage(
+      catalog.find((model) => model.id === modelId),
+      null,
+      t.locale
+    ),
+    [catalog, t.locale]
+  );
+  const voiceSettingsFor = useCallback(
+    (modelId, base) => {
+      const picked = languagePreference !== null && catalog.find((model) => model.id === modelId)?.languages?.length ? languagePreference : null;
+      if (picked === null) return base;
+      return { ...base, language: picked };
+    },
+    [catalog, languagePreference]
+  );
+  const scope = catalogScopeRef.current;
+  const realCatalog = scope.source === "cache" && scope.client === client && scope.workspaceId === workspaceId;
+  const fallbackIsFinal = fallbackFinal?.client === client && fallbackFinal.workspaceId === workspaceId;
+  const catalogReady = realCatalog || fallbackIsFinal;
+  const loadState = realCatalog ? "ready" : !fallbackIsFinal ? "loading" : fallbackFinal?.failed ? "failed" : "ready";
+  return {
+    models: catalog,
+    selectedModel,
+    selectModel,
+    catalogReady,
+    loadState,
+    languageFor,
+    voiceSettingsFor
+  };
+}
+function toRealtimeModelOption(model) {
+  return { ...model };
+}
+function readRealtimeModelPreference(workspaceId) {
+  if (typeof localStorage === "undefined") return null;
+  try {
+    const value = localStorage.getItem(`${REALTIME_MODEL_STORAGE_PREFIX}:${workspaceId}`);
+    return isSessionRealtimeModel(value) ? value : null;
+  } catch {
+    return null;
+  }
+}
+function writeRealtimeModelPreference(workspaceId, model) {
+  if (typeof localStorage === "undefined") return;
+  try {
+    localStorage.setItem(`${REALTIME_MODEL_STORAGE_PREFIX}:${workspaceId}`, model);
+  } catch {
+  }
+}
+
+export {
+  CODEX_LIVE_MODEL,
+  useRealtimeLanguagePreference,
+  realtimeAppLanguage,
+  realtimeConversationLanguage,
+  loadRealtimeModelCatalog,
+  prestartSessionRealtime,
+  codexRealtimeAdmissionAllowed,
+  codexRealtimeAdmissionBlocker,
+  useSessionRealtime,
+  sessionRealtimeLifecycleIsActive,
+  useRealtimeModelSelection
+};
+//# sourceMappingURL=chunk-I7ITSXSJ.js.map