@kano/stem-daw 0.1.0

package/dist/chunk-56PWIP7O.js

@@ -0,0 +1,1029 @@
+import { AEV3Config, extractBareSessionStationId, resolveSingleBeatsAndKeysWithBeatsLink, replaceMp4ForLocalUse, calculateTempoOrigSzFromBeatDownBeat, calculateQuantisedTrackActualDurationFromBeatGrid, getFullDurationFromBeatsLinkSegmentInfo, getDurationFromBeatsLinkUpToLastDownbeat0, resolveMultipleBeatsAndKeysWithBeatsLink } from './chunk-TBXCZFAY.js';
+
+// src/services/dropped-mix-ids.ts
+var NEXT_MIX_ID_DROPPED_ON_RESOLVING_NEXT_MIX = [];
+
+// src/services/fetchMix.tsx
+var TRACK_CREATOR_ENDPOINT = `${import.meta.env?.VITE_KB_STEMIFY_API_URL || "https://api.stemplayer.com"}/track-creator`;
+var LOGIN_LINK = `${import.meta.env?.VITE_KB_STEMIFY_API_URL || "https://api.stemplayer.com"}/accounts/user/login`;
+var APPLY_BEAT_GRID_SMOOTHING = true;
+var FETCH_MIX_CONSOLE_TIME = "";
+var TRACK_ITEM_FRAGMENT = `fragment TrackItem on Track {
+  artistDisplayName
+  colors
+  name
+  trackId
+  trackMixType
+  trackStatus
+  isClaimed
+  duration
+  artwork: image
+  artworkGlowColor
+  url: url(codec: aac, container: mp4, profile: raw)
+  stems {
+    aac: url(codec: aac)
+    hls: url(codec: hls)
+    wav: url(codec: wav)
+    mp3: url(codec: mp3)
+    stemId
+    stemPosition
+  }
+}`;
+var MIX_ITEM_FRAGMENT = `fragment MixItem on Mix {
+  mixId
+  name
+  colors
+  mixPosition
+  tracks {
+    ...TrackItem
+  }
+  popularSelectedStems {
+    vocals
+    other
+    drums
+    bass
+  }
+}`;
+var _FM_log = (...data) => {
+  return;
+};
+var _FM_log_table = (...data) => {
+  return;
+};
+var login = async () => {
+  const loginUrl = LOGIN_LINK;
+  try {
+    const cachedToken = localStorage.getItem("accessToken");
+    const tokenExpiry = localStorage.getItem("tokenExpiry");
+    if (cachedToken && tokenExpiry && (/* @__PURE__ */ new Date()).getTime() < parseInt(tokenExpiry, 10)) {
+      const cachedTokenObj = JSON.parse(cachedToken);
+      _FM_log("Using cached access token:", cachedTokenObj.accessToken.value);
+      return cachedTokenObj.accessToken.value;
+    }
+    let loginPayload;
+    try {
+      const username = import.meta.env?.VITE_STEM_API_USERNAME;
+      const password = import.meta.env?.VITE_STEM_API_PASSWORD;
+      if (!username || !password) {
+        throw new Error("Username or password not found in environment variables");
+      }
+      loginPayload = {
+        email: username,
+        password
+      };
+    } catch (error) {
+      _FM_log(error);
+      throw new Error("Username or password not found");
+    }
+    _FM_log("Starting login request...");
+    const loginResponse = await fetch(loginUrl, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(loginPayload)
+    });
+    if (!loginResponse.ok) {
+      throw new Error("Login failed");
+    }
+    const loginData = await loginResponse.json();
+    const accessTokenObj = loginData.data;
+    const expiryTime = (/* @__PURE__ */ new Date()).getTime() + 20 * 60 * 1e3;
+    _FM_log("Login successful. Access token:", accessTokenObj.accessToken.value);
+    localStorage.setItem("accessToken", JSON.stringify(accessTokenObj));
+    localStorage.setItem("tokenExpiry", expiryTime.toString());
+    return accessTokenObj.accessToken.value;
+  } catch (error) {
+    console.error("Error during login or fetching mix data:", error.message);
+    return null;
+  }
+};
+var getMixMetadata = async (authToken, mixId, stationId, smoothBeats = APPLY_BEAT_GRID_SMOOTHING, abortController) => {
+  const query = `query GetMix($id: ID!) {
+  mix(id: $id) {
+    ...MixItem
+  }
+}
+
+${TRACK_ITEM_FRAGMENT}
+
+${MIX_ITEM_FRAGMENT}`;
+  const variables = { "id": mixId };
+  const queryParams = new URLSearchParams({
+    query: query.trim(),
+    variables: JSON.stringify(variables),
+    operationName: "GetMix"
+  });
+  const url = `${TRACK_CREATOR_ENDPOINT}/graphql?${queryParams.toString()}`;
+  const headers = {
+    Authorization: `Bearer ${authToken}`
+  };
+  try {
+    const response = await fetch(url, {
+      method: "GET",
+      headers,
+      signal: abortController?.signal
+    });
+    const responseData = await response.json();
+    if (response.ok) {
+      _FM_log("Successfully fetched the mix details.");
+      _FM_log(responseData);
+      if (!responseData?.data?.mix) {
+        console.error("Mix not found or returned null for this ID");
+        return null;
+      }
+      responseData.data.mix.remixes = [];
+      const trackIds = responseData.data.mix.tracks.map((t) => {
+        return { id: t.trackId, url: t.url };
+      });
+      const trackIds2 = responseData.data.mix.remixes?.length > 0 ? responseData.data.mix.remixes[0].tracksmap((t) => {
+        return { id: t.trackId, url: t.url };
+      }) : [];
+      const tracks = removeDuplicatesById([...trackIds, ...trackIds2]);
+      const trackBeatsCollection2 = await resolveMultipleBeatsAndKeysWithBeatsLink(tracks, authToken, smoothBeats, window.$currentBeatGridVersion);
+      responseData.data.mix.tracks.map((t) => {
+        const m_t = t;
+        if (trackBeatsCollection2.data[t.trackId]) {
+          replaceMp4Url(m_t);
+          addBeatsRelatedParam(m_t, trackBeatsCollection2.data[t.trackId]);
+          m_t.__falseTrack = false;
+          m_t.__durationForValidation1 = getFullDurationFromBeatsLinkSegmentInfo(m_t.segmentInfo);
+          m_t.__durationForValidation2 = getDurationFromBeatsLinkUpToLastDownbeat0(-1, m_t.beats);
+        } else {
+          m_t.__falseTrack = true;
+          m_t.__durationForValidation1 = 0;
+          m_t.__durationForValidation2 = 0;
+        }
+        return m_t;
+      });
+      return responseData;
+    } else {
+      console.error(`Failed to fetch mix details. ${FETCH_MIX_CONSOLE_TIME}`);
+      return null;
+    }
+  } catch (e) {
+    console.timeEnd(FETCH_MIX_CONSOLE_TIME);
+    console.error(`Error during mix detail retrieval: ${e}`);
+    return null;
+  }
+};
+var getNextMixMetadata = async (authToken, mixId, stationId, direction, currentMixPosition = -1, smoothBeats = APPLY_BEAT_GRID_SMOOTHING, abortController) => {
+  const query = `query MixesToPlay($id: [ID]!, $first: Int, $afterId: ID, $sort: Sort) {
+  stations(ids: $id) {
+    stationId
+    lastModified
+    mixCount
+    mixes(first: $first, afterId: $afterId, sort: $sort) {
+        ...MixItem
+        mixPosition
+    }
+  }
+}
+
+${TRACK_ITEM_FRAGMENT}
+
+${MIX_ITEM_FRAGMENT}`;
+  const queryArtist = `query MixesToPlay($id: [ID]!, $first: Int, $afterId: ID) {
+  stations: libraryArtists(ids: $id) {
+    artist {
+        artistId
+        stationId: artistId
+    }
+    lastModified
+    mixCount
+    mixes(first: $first, afterId: $afterId) {
+        ...MixItem
+        mixPosition
+    }
+  }
+}
+
+${TRACK_ITEM_FRAGMENT}
+
+${MIX_ITEM_FRAGMENT}`;
+  const variables = { "afterId": mixId, "id": [stationId], "first": 3, "sort": direction === "nextMixId" ? "asc" : "desc" };
+  const queryParams = new URLSearchParams({
+    query: isStationIdLibraryArtistStation(stationId) ? queryArtist.trim() : query.trim(),
+    variables: JSON.stringify(variables),
+    operationName: "MixesToPlay"
+  });
+  const url = `${TRACK_CREATOR_ENDPOINT}/graphql?${queryParams.toString()}`;
+  const headers = {
+    Authorization: `Bearer ${authToken}`
+  };
+  FETCH_MIX_CONSOLE_TIME = `Getting mix details... ${stationId}/${mixId}`;
+  try {
+    const response = await fetch(url, {
+      method: "GET",
+      headers,
+      signal: abortController?.signal
+    });
+    const responseData = await response.json();
+    _FM_log("%cnext mix json", "color: magenta", responseData);
+    if (response.ok || responseData.data?.stations?.[0]?.mixes && responseData.data?.stations?.[0]?.mixes?.length === 0) {
+      _FM_log("Successfully fetched the mix details.");
+      _FM_log(responseData);
+      responseData.data?.stations?.[0]?.mixes.forEach((m) => m.remixes = []);
+      const trackIds = responseData.data?.stations?.[0]?.mixes.map((m) => m.tracks.map((t) => {
+        return { id: t.trackId, url: t.url };
+      }));
+      const tracks = removeDuplicatesById([...trackIds].flat(Infinity));
+      const trackBeatsCollection2 = await resolveMultipleBeatsAndKeysWithBeatsLink(tracks, authToken, smoothBeats, window.$currentBeatGridVersion);
+      responseData.data?.stations?.[0]?.mixes.forEach((m) => m.tracks.map((t) => {
+        const m_t = t;
+        if (trackBeatsCollection2.data[t.trackId]) {
+          replaceMp4Url(m_t);
+          addBeatsRelatedParam(m_t, trackBeatsCollection2.data[t.trackId]);
+          m_t.__falseTrack = false;
+          m_t.__durationForValidation1 = getFullDurationFromBeatsLinkSegmentInfo(m_t.segmentInfo);
+          m_t.__durationForValidation2 = getDurationFromBeatsLinkUpToLastDownbeat0(-1, m_t.beats);
+        } else {
+          m_t.__falseTrack = true;
+          m_t.__durationForValidation1 = 0;
+          m_t.__durationForValidation2 = 0;
+        }
+        return m_t;
+      }));
+      if (!responseData.data?.stations?.[0]?.stationId) {
+        if (responseData.data?.stations?.[0]?.artist?.stationId) {
+          responseData.data.stations[0].stationId = responseData.data?.stations?.[0]?.artist?.stationId;
+        } else {
+          responseData.data.stations[0].stationId = "";
+        }
+      }
+      const stationMixCount = responseData.data?.stations?.[0]?.mixCount || 0;
+      const mixesLength = responseData.data?.stations?.[0]?.mixes?.length;
+      _FM_log_table({
+        id: "autoplay",
+        stationId,
+        mixId,
+        currentMixPosition,
+        stationMixCount,
+        mixesLength,
+        "isNaN(currentMixPosition*1)": isNaN(currentMixPosition * 1)
+      });
+      if (responseData.data?.stations?.[0]?.mixes?.length === 0 || NEXT_MIX_ID_DROPPED_ON_RESOLVING_NEXT_MIX.includes(responseData.data?.stations?.[0]?.mixes?.[0]?.mixId)) {
+        if (isNaN(currentMixPosition * 1)) {
+          return getFirstOrLastMixMetadata(authToken, stationId, direction, smoothBeats);
+        } else {
+          if (currentMixPosition + 1 < stationMixCount) {
+            return getMixesAfterNMetadata(authToken, stationId, direction, currentMixPosition + 1, smoothBeats);
+          } else {
+            return getFirstOrLastMixMetadata(authToken, stationId, direction, smoothBeats);
+          }
+        }
+      }
+      return responseData;
+    } else {
+      console.error(`Failed to fetch mix details. ${FETCH_MIX_CONSOLE_TIME}`);
+      return null;
+    }
+  } catch (e) {
+    console.error(`Error during mix detail retrieval: ${e}`);
+    return null;
+  }
+};
+var getFirstOrLastMixMetadata = async (authToken, stationId, direction, smoothBeats = APPLY_BEAT_GRID_SMOOTHING, abortController) => {
+  return getMixesAfterNMetadata(authToken, stationId, direction, 0, smoothBeats, abortController);
+};
+var getMixesAfterNMetadata = async (authToken, stationId, direction, mixPosition = 0, smoothBeats = APPLY_BEAT_GRID_SMOOTHING, abortController) => {
+  const query = `query MixesToPlay($id: [ID]!, $first: Int, $after: Int, $sort: Sort) {
+  stations(ids: $id) {
+    stationId
+    lastModified
+    mixCount
+    mixes(first: $first, after: $after, sort: $sort) {
+        ...MixItem
+        mixPosition
+    }
+  }
+}
+
+${TRACK_ITEM_FRAGMENT}
+
+${MIX_ITEM_FRAGMENT}`;
+  const queryArtist = `query MixesToPlay($id: [ID]!, $first: Int, $after: Int) {
+  stations: libraryArtists(ids: $id) {
+    artist {
+        artistId
+        stationId: artistId
+    }
+    lastModified
+    mixCount
+    mixes(first: $first, after: $after) {
+        ...MixItem
+        mixPosition
+    }
+  }
+}
+
+${TRACK_ITEM_FRAGMENT}
+
+${MIX_ITEM_FRAGMENT}`;
+  const variables = { "after": mixPosition, "id": [stationId], "first": 3, "sort": direction === "nextMixId" ? "asc" : "desc" };
+  const queryParams = new URLSearchParams({
+    query: isStationIdLibraryArtistStation(stationId) ? queryArtist.trim() : query.trim(),
+    variables: JSON.stringify(variables),
+    operationName: "MixesToPlay"
+  });
+  const url = `${TRACK_CREATOR_ENDPOINT}/graphql?${queryParams.toString()}`;
+  const headers = {
+    Authorization: `Bearer ${authToken}`
+  };
+  FETCH_MIX_CONSOLE_TIME = `Getting mix details... ${stationId}/first_item}`;
+  try {
+    const response = await fetch(url, {
+      method: "GET",
+      headers,
+      signal: abortController?.signal
+    });
+    const responseData = await response.json();
+    _FM_log("%cnext mix json", "color: magenta", responseData);
+    if (response.ok || responseData.data?.stations?.[0]?.mixes && responseData.data?.stations?.[0]?.mixes?.length === 0) {
+      _FM_log("Successfully fetched the mix details.");
+      _FM_log(responseData);
+      responseData.data?.stations?.[0]?.mixes.forEach((m) => m.remixes = []);
+      const trackIds = responseData.data?.stations?.[0]?.mixes.map((m) => m.tracks.map((t) => {
+        return { id: t.trackId, url: t.url };
+      }));
+      const tracks = removeDuplicatesById([...trackIds].flat(Infinity));
+      const trackBeatsCollection2 = await resolveMultipleBeatsAndKeysWithBeatsLink(tracks, authToken, smoothBeats, window.$currentBeatGridVersion);
+      responseData.data?.stations?.[0]?.mixes.forEach((m) => m.tracks.map((t) => {
+        const m_t = t;
+        if (trackBeatsCollection2.data[t.trackId]) {
+          replaceMp4Url(m_t);
+          addBeatsRelatedParam(m_t, trackBeatsCollection2.data[t.trackId]);
+          m_t.__falseTrack = false;
+          m_t.__durationForValidation1 = getFullDurationFromBeatsLinkSegmentInfo(m_t.segmentInfo);
+          m_t.__durationForValidation2 = getDurationFromBeatsLinkUpToLastDownbeat0(-1, m_t.beats);
+        } else {
+          m_t.__falseTrack = true;
+          m_t.__durationForValidation1 = 0;
+          m_t.__durationForValidation2 = 0;
+        }
+        return m_t;
+      }));
+      if (!responseData.data?.stations?.[0]?.stationId) {
+        if (responseData.data?.stations?.[0]?.artist?.stationId) {
+          responseData.data.stations[0].stationId = responseData.data?.stations?.[0]?.artist?.stationId;
+        } else {
+          responseData.data.stations[0].stationId = "";
+        }
+      }
+      return responseData;
+    } else {
+      console.error(`Failed to fetch mix details. ${FETCH_MIX_CONSOLE_TIME}`);
+      return null;
+    }
+  } catch (e) {
+    console.timeEnd(FETCH_MIX_CONSOLE_TIME);
+    console.error(`Error during mix detail retrieval: ${e}`);
+    return null;
+  }
+};
+var extractMixIdVer2 = (url) => {
+  const pattern = /^https?:\/\/[^/]+\/(?:set|artist)\/([^/]+)\/mix\/([^/?#]+)(?:\/|$|\?)/i;
+  const match = url.match(pattern);
+  if (match) {
+    const mixValue = match[2];
+    return mixValue;
+  }
+};
+var extractStationIdVer2 = (url) => {
+  const pattern = /^https?:\/\/[^/]+\/(?:set|artist)\/([^/]+)\/mix\/([^/?#]+)(?:\/|$|\?)/i;
+  const match = url.match(pattern);
+  if (match) {
+    const mixValue = match[1];
+    return mixValue;
+  }
+};
+var fetchMixDataWithSharedURL = async (url, smoothBeats = APPLY_BEAT_GRID_SMOOTHING, abortController) => {
+  if (!url) {
+    return;
+  }
+  const mixId = extractMixIdVer2(url);
+  const stationId = extractStationIdVer2(url);
+  if (mixId) {
+    const token = await login();
+    AEV3Config.getInstance().setAccessToken(token);
+    if (token) {
+      const fetchedData = await getMixMetadata(token, mixId, stationId, smoothBeats, abortController);
+      if (fetchedData) {
+        return JSON.stringify(fetchedData);
+      } else {
+        console.error("Failed to fetch mix data");
+      }
+    }
+  } else {
+    console.error("Invalid URL or mixId not found");
+  }
+};
+var removeDuplicatesById = (arr) => {
+  const seen = /* @__PURE__ */ new Set();
+  return arr.filter((item) => {
+    if (seen.has(item.id)) {
+      return false;
+    }
+    seen.add(item.id);
+    return true;
+  });
+};
+var isStationIdLibraryArtistStation = (stationId) => {
+  return stationId?.includes("00000014-");
+};
+var replaceMp4Url = (m_t) => {
+  const mp4 = m_t.url;
+  m_t.url = replaceMp4ForLocalUse(mp4);
+};
+var addBeatsRelatedParam = (m_t, beats) => {
+  m_t.beats = beats.beats;
+  m_t.tempoOrigSz = calculateTempoOrigSzFromBeatDownBeat(m_t.beats.map((b) => b.timestamp));
+  m_t.duration = calculateQuantisedTrackActualDurationFromBeatGrid(-1, m_t.beats);
+  m_t.indices = beats.indices;
+  m_t.segmentInfo = beats.segmentInfo;
+  m_t.key = beats.key;
+  m_t.tonality = beats.tonality;
+  m_t.beatSource = beats.beatSource;
+  return m_t;
+};
+
+// src/daw/services/track-search-api.ts
+var API_BASE = import.meta.env?.VITE_KB_STEMIFY_API_URL || "https://api.stemplayer.com";
+var GQL_URL = `${API_BASE}/track-creator/graphql`;
+var FEAT_API_URL = import.meta.env?.VITE_FEAT_API_URL || "https://173i5juztg.execute-api.us-west-2.amazonaws.com";
+var SIMILARITY_MODES = [
+  { id: "feature", label: "Audio DNA", description: "Audio fingerprint / text similarity" },
+  { id: "remix", label: "Remix Match", description: "Server-side key/BPM/feature matching" }
+];
+var CAMELOT_MAP = {
+  "A:minor": "8A",
+  "A:major": "11B",
+  "A#:minor": "3A",
+  "A#:major": "6B",
+  "B:minor": "10A",
+  "B:major": "1B",
+  "C:minor": "5A",
+  "C:major": "8B",
+  "C#:minor": "12A",
+  "C#:major": "3B",
+  "D:minor": "7A",
+  "D:major": "10B",
+  "D#:minor": "2A",
+  "D#:major": "5B",
+  "E:minor": "9A",
+  "E:major": "12B",
+  "F:minor": "4A",
+  "F:major": "7B",
+  "F#:minor": "11A",
+  "F#:major": "2B",
+  "G:minor": "6A",
+  "G:major": "9B",
+  "G#:minor": "1A",
+  "G#:major": "4B"
+};
+function getCamelotTag(key, tonality) {
+  return CAMELOT_MAP[`${key}:${tonality}`] || `${key}${tonality === "minor" ? "m" : ""}`;
+}
+function parseCamelot(tag) {
+  const m = tag.match(/^(\d+)([AB])$/);
+  if (!m) return null;
+  return { num: parseInt(m[1], 10), letter: m[2] };
+}
+function scoreKeyCompatibility(refKey, refTonality, trackKey, trackTonality) {
+  const refTag = getCamelotTag(refKey, refTonality);
+  const trkTag = getCamelotTag(trackKey, trackTonality);
+  if (refTag === trkTag) return 1;
+  const ref = parseCamelot(refTag);
+  const trk = parseCamelot(trkTag);
+  if (!ref || !trk) return 0;
+  const numDist = Math.min(
+    Math.abs(ref.num - trk.num),
+    12 - Math.abs(ref.num - trk.num)
+  );
+  if (numDist === 0 && ref.letter !== trk.letter) return 0.9;
+  if (numDist === 1 && ref.letter === trk.letter) return 0.85;
+  if (numDist === 1 && ref.letter !== trk.letter) return 0.7;
+  if (numDist === 2 && ref.letter === trk.letter) return 0.5;
+  return Math.max(0, 0.4 - numDist * 0.05);
+}
+function scoreBpmCompatibility(refBpm, trackBpm) {
+  const candidates = [trackBpm, trackBpm * 2, trackBpm / 2];
+  let bestPct = Infinity;
+  let bestLabel = "1x";
+  for (const bpm of candidates) {
+    const pct = Math.abs(bpm - refBpm) / refBpm;
+    if (pct < bestPct) {
+      bestPct = pct;
+      bestLabel = bpm === trackBpm ? "1x" : bpm > trackBpm ? "2x" : "\xBDx";
+    }
+  }
+  const score = Math.max(0, 1 - bestPct / 0.15);
+  return { score, ratio: bestLabel };
+}
+function computeCompatibility(ref, track) {
+  const keyScore = scoreKeyCompatibility(ref.key, ref.tonality, track.key, track.tonality);
+  const { score: bpmScore, ratio } = scoreBpmCompatibility(ref.bpm, track.bpm);
+  const bpmPct = Math.round((1 - Math.abs(ref.bpm - track.bpm) / ref.bpm) * 100);
+  const overall = keyScore * 0.5 + bpmScore * 0.5;
+  return {
+    bpmPct,
+    keyScore: Math.round(keyScore * 100),
+    overall: Math.round(overall * 100),
+    camelotTag: getCamelotTag(track.key, track.tonality),
+    bpmLabel: `${Math.round(track.bpm)} ${ratio !== "1x" ? `(${ratio})` : ""}`.trim()
+  };
+}
+var beatsCache = /* @__PURE__ */ new Map();
+async function fetchBeatsRaw(trackId) {
+  const cached = beatsCache.get(trackId);
+  if (cached) return cached;
+  try {
+    const token = await getToken();
+    const url = `${API_BASE}/track-creator/tracks/${trackId}/beats?min_bars=16`;
+    const res = await fetch(url, {
+      headers: { Authorization: `Bearer ${token}` }
+    });
+    if (!res.ok) return null;
+    const json = await res.json();
+    const d = json?.data;
+    if (!d?.bpm || !d?.key) return null;
+    const segments = Array.isArray(d.segmentInfo) ? d.segmentInfo : [];
+    const durationSec = typeof d.duration === "number" ? d.duration : segments.length > 0 ? segments[segments.length - 1][1] : null;
+    const record = {
+      info: { bpm: d.bpm, key: d.key, tonality: d.tonality || "minor" },
+      segmentInfo: segments,
+      durationSec
+    };
+    beatsCache.set(trackId, record);
+    return record;
+  } catch {
+    return null;
+  }
+}
+async function fetchTrackMusicalInfo(trackId) {
+  const record = await fetchBeatsRaw(trackId);
+  return record ? record.info : null;
+}
+async function fetchTrackSegmentInfo(trackId) {
+  const record = await fetchBeatsRaw(trackId);
+  if (!record) return null;
+  return { segmentInfo: record.segmentInfo, durationSec: record.durationSec };
+}
+async function getToken() {
+  const token = await login();
+  if (!token) throw new Error("Authentication failed \u2014 check .env credentials");
+  AEV3Config.getInstance().setAccessToken(token);
+  return token;
+}
+var MIX_URL_PATTERN = /^https?:\/\/[^/]+\/(?:set|artist)\/([^/]+)\/mix\/([^/?#]+)/i;
+var SESSION_TRACK_URL_PATTERN = /^https?:\/\/[^/]+\/session\/([^/]+)\/track\/([^/?#]+)/i;
+function isMixUrl(input) {
+  return MIX_URL_PATTERN.test(input.trim());
+}
+function isSessionTrackUrl(input) {
+  const t = input.trim();
+  return SESSION_TRACK_URL_PATTERN.test(t) || extractBareSessionStationId(t) !== null;
+}
+function isStemUrl(input) {
+  const trimmed = input.trim();
+  return MIX_URL_PATTERN.test(trimmed) || SESSION_TRACK_URL_PATTERN.test(trimmed) || extractBareSessionStationId(trimmed) !== null;
+}
+var MIX_TRACK_FRAGMENT = `fragment TrackItem on Track {
+  trackId
+  name
+  artistDisplayName
+  artwork: image
+  artworkGlowColor
+  url: url(codec: aac, container: mp4, profile: raw)
+}`;
+var MIX_QUERY = `query GetMix($id: ID!) {
+  mix(id: $id) {
+    mixId
+    name
+    tracks { ...TrackItem }
+  }
+}
+${MIX_TRACK_FRAGMENT}`;
+async function fetchTracksFromMixUrl(url) {
+  const mixId = extractMixIdVer2(url);
+  if (!mixId) throw new Error("Could not extract mix ID from URL");
+  const token = await getToken();
+  const params = new URLSearchParams({
+    query: MIX_QUERY.trim(),
+    variables: JSON.stringify({ id: mixId }),
+    operationName: "GetMix"
+  });
+  const res = await fetch(`${GQL_URL}?${params}`, {
+    headers: { Authorization: `Bearer ${token}` }
+  });
+  if (!res.ok) throw new Error(`Mix fetch failed (${res.status})`);
+  const json = await res.json();
+  const tracks = json?.data?.mix?.tracks;
+  if (!Array.isArray(tracks) || tracks.length === 0) {
+    throw new Error("Mix contains no tracks");
+  }
+  return tracks.map((t) => ({
+    id: t.trackId,
+    title: t.name || "Untitled",
+    artist: t.artistDisplayName || "Unknown",
+    artwork: t.artwork || null,
+    artworkGlowColor: t.artworkGlowColor || null,
+    type: "MixTrack"
+  }));
+}
+async function fetchTracksFromSessionUrl(url) {
+  const { fetchStationTrackDataWithSharedURL } = await import('./fetchStationTracks-SKFT4V3U.js');
+  const jsonString = await fetchStationTrackDataWithSharedURL(url);
+  if (!jsonString) throw new Error("Could not fetch station track data from session URL");
+  const stObj = JSON.parse(jsonString);
+  const currentTracks = stObj?.data?.stations?.[0]?.currentTrack ?? [];
+  const nextTracks = stObj?.data?.stations?.[0]?.nextTracks ?? [];
+  const allEntries = [...currentTracks, ...nextTracks];
+  if (allEntries.length === 0) throw new Error("No tracks found for this session link");
+  return allEntries.filter((e) => e?.track && !e.track.__falseTrack).map((e) => ({
+    id: e.track.trackId,
+    title: e.track.name || "Untitled",
+    artist: e.track.artistDisplayName || "Unknown",
+    artwork: e.track.artwork || e.track.image || null,
+    artworkGlowColor: e.track.artworkGlowColor || null,
+    type: "StationTrack"
+  }));
+}
+var SEARCH_QUERY = `
+query SearchTracks($name: String, $first: Int, $after: Int) {
+  searchItems(filter: { name: $name, searchMode: all }, first: $first, after: $after) {
+    tracks {
+      ... on Track {
+        title: name
+        id: trackId
+        artist: artistDisplayName
+        artwork: image
+        artworkGlowColor: artworkHighlightColor
+        type: __typename
+      }
+      ... on ExternalSearchTrack {
+        title: name
+        id: trackId
+        artist: artistDisplayName
+        artwork: image
+        artworkGlowColor
+        type: __typename
+      }
+    }
+  }
+}`;
+async function searchTracks(query, limit = 20, offset = 0) {
+  const token = await getToken();
+  const params = new URLSearchParams({
+    query: SEARCH_QUERY.trim(),
+    variables: JSON.stringify({ name: query, first: limit, after: offset }),
+    operationName: "SearchTracks"
+  });
+  const res = await fetch(`${GQL_URL}?${params}`, {
+    headers: { Authorization: `Bearer ${token}` }
+  });
+  if (!res.ok) throw new Error(`Search failed (${res.status})`);
+  const json = await res.json();
+  const tracks = json?.data?.searchItems?.tracks ?? [];
+  return tracks.map((t) => ({
+    id: t.id,
+    title: t.title || "Untitled",
+    artist: t.artist || "Unknown",
+    artwork: t.artwork || null,
+    artworkGlowColor: t.artworkGlowColor || null,
+    type: t.type || "Track"
+  }));
+}
+var TRACK_PREVIEW_QUERY = `
+query GetTrackPreview($id: ID!) {
+  track(id: $id) {
+    trackId
+    duration
+    url: url(codec: aac, container: mp4, profile: raw)
+  }
+}`;
+var previewSourcesCache = /* @__PURE__ */ new Map();
+async function fetchTrackPreviewSources(trackId) {
+  const cached = previewSourcesCache.get(trackId);
+  if (cached) return cached;
+  try {
+    const token = await getToken();
+    const params = new URLSearchParams({
+      query: TRACK_PREVIEW_QUERY.trim(),
+      variables: JSON.stringify({ id: trackId }),
+      operationName: "GetTrackPreview"
+    });
+    const res = await fetch(`${GQL_URL}?${params}`, {
+      headers: { Authorization: `Bearer ${token}` }
+    });
+    if (!res.ok) return null;
+    const json = await res.json();
+    const t = json?.data?.track;
+    if (!t) return null;
+    const record = {
+      durationSec: typeof t.duration === "number" ? t.duration : null,
+      mp4Url: typeof t.url === "string" ? t.url : null
+    };
+    previewSourcesCache.set(trackId, record);
+    return record;
+  } catch {
+    return null;
+  }
+}
+var TRACK_QUERY = `
+query GetTrack($id: ID!) {
+  track(id: $id) {
+    trackId
+    name
+    artistDisplayName
+    artwork: image
+    artworkGlowColor: artworkHighlightColor
+    duration
+    url: url(codec: aac, container: mp4, profile: raw)
+    colors
+    trackMixType
+    trackStatus
+    isClaimed
+    stems {
+      aac: url(codec: aac)
+      hls: url(codec: hls)
+      wav: url(codec: wav)
+      mp3: url(codec: mp3)
+      stemId
+      stemPosition
+    }
+  }
+}`;
+async function fetchTrackForDAW(trackId) {
+  const token = await getToken();
+  const params = new URLSearchParams({
+    query: TRACK_QUERY.trim(),
+    variables: JSON.stringify({ id: trackId }),
+    operationName: "GetTrack"
+  });
+  const res = await fetch(`${GQL_URL}?${params}`, {
+    headers: { Authorization: `Bearer ${token}` }
+  });
+  if (!res.ok) throw new Error(`Track fetch failed (${res.status})`);
+  const json = await res.json();
+  const t = json?.data?.track;
+  if (!t) throw new Error("Track not found");
+  const beatsResolved = await resolveSingleBeatsAndKeysWithBeatsLink(
+    trackId,
+    token,
+    true,
+    // smooth beats
+    null,
+    // beatVersion — always server default, never the debug global
+    t.url
+  );
+  const beats = beatsResolved.data[trackId];
+  if (!beats) throw new Error(`Beat analysis unavailable for track ${trackId}`);
+  const track = t;
+  track.trackDisplayName = t.name;
+  const mp4Url = t.url;
+  if (!mp4Url) {
+    throw new Error(`Track ${trackId} has no MP4 URL`);
+  }
+  track.url = replaceMp4ForLocalUse(mp4Url) ?? mp4Url;
+  track.trackMixType = track.trackMixType || "seed";
+  track.color1Hex = t.colors?.[0] || t.artworkGlowColor || "";
+  track.color2Hex = t.colors?.[1] || "";
+  track.webMixChunkUrl = "";
+  track.webMixChunkCount = 0;
+  track.switchInTimes = [];
+  track.beats = beats.beats;
+  track.tempoOrigSz = calculateTempoOrigSzFromBeatDownBeat(track.beats.map((b) => b.timestamp));
+  track.duration = calculateQuantisedTrackActualDurationFromBeatGrid(-1, track.beats);
+  track.indices = beats.indices;
+  track.segmentInfo = beats.segmentInfo;
+  track.key = beats.key;
+  track.tonality = beats.tonality;
+  track.beatSource = beats.beatSource;
+  track.__falseTrack = false;
+  track.__durationForValidation1 = getFullDurationFromBeatsLinkSegmentInfo(track.segmentInfo);
+  track.__durationForValidation2 = getDurationFromBeatsLinkUpToLastDownbeat0(-1, track.beats);
+  return track;
+}
+function parseFeatureResults(data) {
+  if (!Array.isArray(data)) return [];
+  return data.filter((t) => t.uuid || t.id).map((t) => ({
+    id: t.uuid || t.id,
+    title: t.title || "Untitled",
+    artist: t.artist || "Unknown",
+    artwork: t.artwork || null,
+    artworkGlowColor: null,
+    type: "SimilarTrack"
+  }));
+}
+async function fetchFeaturesByQuery(query, limit) {
+  const body = new FormData();
+  body.append("query", query);
+  body.append("num_results", String(limit));
+  body.append("include_pca", "true");
+  const res = await fetch(`${FEAT_API_URL}/searchfeatures`, {
+    method: "POST",
+    body
+  });
+  if (!res.ok) return [];
+  return parseFeatureResults(await res.json());
+}
+async function fetchFeaturesByUUID(uuid, limit) {
+  const body = new FormData();
+  body.append("uuid", uuid);
+  body.append("num_results", String(limit));
+  body.append("include_pca", "true");
+  const res = await fetch(`${FEAT_API_URL}/searchfeatures`, {
+    method: "POST",
+    body
+  });
+  if (!res.ok) return [];
+  return parseFeatureResults(await res.json());
+}
+async function fetchSimilarTracksByFeature(trackId, limit = 12) {
+  try {
+    const uuidResults = await fetchFeaturesByUUID(trackId, limit);
+    if (uuidResults.length > 0) return uuidResults;
+    const { tracks: sessionTracks } = (await import('./store/daw-session-store.js')).useDAWSessionStore.getState();
+    const sessionTrack = sessionTracks.find(
+      (t) => (t.trackData?.trackId || t.id) === trackId
+    );
+    if (sessionTrack) {
+      const parts = [sessionTrack.displayName, sessionTrack.artistName].filter(Boolean);
+      if (parts.length > 0) {
+        return await fetchFeaturesByQuery(parts.join(" "), limit);
+      }
+    }
+    return [];
+  } catch (err) {
+    console.error("[fetchSimilarTracksByFeature]", err);
+    return [];
+  }
+}
+var STRICT_POOL_BBOX = {
+  maxSemitoneDiff: 1,
+  maxBarSizePctDiff: 8,
+  allowOppositeTonality: false
+};
+var SIMILAR_TRACKS_QUERY = `
+query SimilarTracks(
+    $trackId: ID!,
+    $first: Int,
+    $after: Int,
+    $excludeTrackIds: [ID],
+    $strategy: SimilarTracksStrategy,
+    $ranking: SimilarTracksRankingInput
+) {
+  similarTracks(
+    trackId: $trackId,
+    first: $first,
+    after: $after,
+    excludeTrackIds: $excludeTrackIds,
+    strategy: $strategy,
+    ranking: $ranking
+  ) {
+    trackId
+    name
+    artistDisplayName
+    colors
+    trackStatus
+    duration
+    isClaimed
+    artwork: image
+    artworkGlowColor
+  }
+}`;
+function parseSimilarTracksResults(json) {
+  const tracks = json?.data?.similarTracks ?? [];
+  return tracks.filter((t) => t.trackId).map((t) => ({
+    id: t.trackId,
+    title: t.name || "Untitled",
+    artist: t.artistDisplayName || "Unknown",
+    artwork: t.artwork || null,
+    artworkGlowColor: t.artworkGlowColor || null,
+    type: "RemixMatch"
+  }));
+}
+function buildRankingInput(ranking, strategy) {
+  const out = {};
+  if (ranking) {
+    if (ranking.collaborativeStrength !== void 0) {
+      out.collaborativeStrength = ranking.collaborativeStrength;
+    }
+    if (ranking.genreWeight !== void 0) {
+      out.genreWeight = ranking.genreWeight;
+    }
+    if (ranking.prioritizeUserLikes !== void 0) {
+      out.prioritizeUserLikes = ranking.prioritizeUserLikes;
+    }
+  }
+  if (strategy === "embedding_rank_with_bbox") {
+    Object.assign(out, STRICT_POOL_BBOX);
+  }
+  return Object.keys(out).length > 0 ? out : void 0;
+}
+async function fetchSimilarTracksByRemix(trackId, limit = 12, excludeTrackIds, offset = 0, args) {
+  try {
+    const token = await getToken();
+    const variables = {
+      trackId,
+      first: limit,
+      after: offset
+    };
+    if (excludeTrackIds?.length) {
+      variables.excludeTrackIds = excludeTrackIds;
+    }
+    if (args?.strategy) {
+      variables.strategy = args.strategy;
+    }
+    const ranking = buildRankingInput(args?.ranking, args?.strategy);
+    if (ranking) {
+      variables.ranking = ranking;
+    }
+    const params = new URLSearchParams({
+      query: SIMILAR_TRACKS_QUERY.trim(),
+      variables: JSON.stringify(variables),
+      operationName: "SimilarTracks"
+    });
+    const res = await fetch(`${GQL_URL}?${params}`, {
+      headers: { Authorization: `Bearer ${token}` }
+    });
+    if (!res.ok) {
+      console.warn(`[fetchSimilarTracksByRemix] similarTracks returned ${res.status}`);
+      return [];
+    }
+    return parseSimilarTracksResults(await res.json());
+  } catch (err) {
+    console.error("[fetchSimilarTracksByRemix]", err);
+    return [];
+  }
+}
+async function fetchSimilarTracksFromStation(mixUrl, limit = 8) {
+  const stationId = extractStationIdVer2(mixUrl);
+  const mixId = extractMixIdVer2(mixUrl);
+  if (!stationId || !mixId) return [];
+  const token = await login();
+  if (!token) return [];
+  const seen = /* @__PURE__ */ new Set();
+  const results = [];
+  const addTracksFromMixes = (mixes) => {
+    if (!mixes) return;
+    for (const mix of mixes) {
+      const tracks = mix?.tracks ?? [];
+      for (const t of tracks) {
+        if (t?.trackId && !seen.has(t.trackId) && !t.__falseTrack) {
+          seen.add(t.trackId);
+          results.push({
+            id: t.trackId,
+            title: t.name || t.trackDisplayName || "Untitled",
+            artist: t.artistDisplayName || "Unknown",
+            artwork: t.artwork || t.image || null,
+            artworkGlowColor: t.artworkGlowColor || null,
+            type: t.trackMixType || "Track"
+          });
+          if (results.length >= limit) return;
+        }
+      }
+    }
+  };
+  try {
+    const nextData = await getNextMixMetadata(
+      token,
+      mixId,
+      stationId,
+      "nextMixId",
+      -1,
+      true
+    );
+    addTracksFromMixes(nextData?.data?.stations?.[0]?.mixes);
+    if (results.length < limit) {
+      const prevData = await getNextMixMetadata(
+        token,
+        mixId,
+        stationId,
+        "prevMixId",
+        -1,
+        true
+      );
+      addTracksFromMixes(prevData?.data?.stations?.[0]?.mixes);
+    }
+    if (results.length < limit) {
+      const fallbackData = await getMixesAfterNMetadata(
+        token,
+        stationId,
+        "nextMixId",
+        0,
+        true
+      );
+      addTracksFromMixes(fallbackData?.data?.stations?.[0]?.mixes);
+    }
+    return results.slice(0, limit);
+  } catch (err) {
+    console.error("[fetchSimilarTracksFromStation]", err);
+    return [];
+  }
+}
+
+export { SIMILARITY_MODES, computeCompatibility, fetchMixDataWithSharedURL, fetchSimilarTracksByFeature, fetchSimilarTracksByRemix, fetchSimilarTracksFromStation, fetchTrackForDAW, fetchTrackMusicalInfo, fetchTrackPreviewSources, fetchTrackSegmentInfo, fetchTracksFromMixUrl, fetchTracksFromSessionUrl, getCamelotTag, isMixUrl, isSessionTrackUrl, isStemUrl, login, searchTracks };
+//# sourceMappingURL=chunk-56PWIP7O.js.map
+//# sourceMappingURL=chunk-56PWIP7O.js.map