@bash-app/bash-common 30.347.0 → 30.355.0

package/src/__tests__/eventTimezoneIana.test.ts

@@ -0,0 +1,387 @@
+import {
+  getIanaTimezoneFromCoordinates,
+  getIanaTimezoneFromUsStateCode,
+  inferEventTimezoneIana,
+  isValidIanaTimezone,
+  resolveEventTimezoneIanaForDisplay,
+} from "../utils/eventTimezoneIana";
+
+describe("eventTimezoneIana", () => {
+  describe("isValidIanaTimezone", () => {
+    describe("valid IANA timezones", () => {
+      it("accepts US mainland timezones", () => {
+        expect(isValidIanaTimezone("America/New_York")).toBe(true);
+        expect(isValidIanaTimezone("America/Chicago")).toBe(true);
+        expect(isValidIanaTimezone("America/Denver")).toBe(true);
+        expect(isValidIanaTimezone("America/Los_Angeles")).toBe(true);
+      });
+
+      it("accepts US special zones", () => {
+        expect(isValidIanaTimezone("America/Phoenix")).toBe(true); // Arizona (no DST)
+        expect(isValidIanaTimezone("America/Anchorage")).toBe(true); // Alaska
+        expect(isValidIanaTimezone("Pacific/Honolulu")).toBe(true); // Hawaii
+        expect(isValidIanaTimezone("America/Indiana/Indianapolis")).toBe(true);
+      });
+
+      it("accepts European timezones", () => {
+        expect(isValidIanaTimezone("Europe/London")).toBe(true);
+        expect(isValidIanaTimezone("Europe/Paris")).toBe(true);
+        expect(isValidIanaTimezone("Europe/Berlin")).toBe(true);
+        expect(isValidIanaTimezone("Europe/Rome")).toBe(true);
+        expect(isValidIanaTimezone("Europe/Madrid")).toBe(true);
+      });
+
+      it("accepts Asian timezones", () => {
+        expect(isValidIanaTimezone("Asia/Tokyo")).toBe(true);
+        expect(isValidIanaTimezone("Asia/Shanghai")).toBe(true);
+        expect(isValidIanaTimezone("Asia/Singapore")).toBe(true);
+        expect(isValidIanaTimezone("Asia/Dubai")).toBe(true);
+        expect(isValidIanaTimezone("Asia/Kolkata")).toBe(true);
+      });
+
+      it("accepts other major timezones", () => {
+        expect(isValidIanaTimezone("Australia/Sydney")).toBe(true);
+        expect(isValidIanaTimezone("America/Sao_Paulo")).toBe(true);
+        expect(isValidIanaTimezone("Africa/Johannesburg")).toBe(true);
+        expect(isValidIanaTimezone("UTC")).toBe(true);
+      });
+
+      it("accepts case variations (Intl is case-insensitive)", () => {
+        expect(isValidIanaTimezone("America/New_York")).toBe(true);
+        // Intl.DateTimeFormat is case-insensitive (unlike Luxon)
+        expect(isValidIanaTimezone("america/new_york")).toBe(true);
+        expect(isValidIanaTimezone("AMERICA/NEW_YORK")).toBe(true);
+      });
+    });
+
+    describe("invalid timezones", () => {
+      it("rejects timezone abbreviations (ambiguous, not IANA standard)", () => {
+        // These are explicitly rejected because they're ambiguous:
+        // EST could be US Eastern or Australian Eastern, etc.
+        expect(isValidIanaTimezone("EST")).toBe(false);
+        expect(isValidIanaTimezone("PST")).toBe(false);
+        expect(isValidIanaTimezone("CST")).toBe(false);
+        expect(isValidIanaTimezone("MST")).toBe(false);
+        expect(isValidIanaTimezone("EDT")).toBe(false);
+        expect(isValidIanaTimezone("PDT")).toBe(false);
+        expect(isValidIanaTimezone("AEST")).toBe(false);
+        expect(isValidIanaTimezone("JST")).toBe(false);
+      });
+
+      it("rejects made-up timezone names", () => {
+        expect(isValidIanaTimezone("Invalid/Zone")).toBe(false);
+        expect(isValidIanaTimezone("America/FakeCity")).toBe(false);
+        expect(isValidIanaTimezone("Not_A_Timezone")).toBe(false);
+        expect(isValidIanaTimezone("Random/Gibberish")).toBe(false);
+      });
+
+      it("rejects empty or whitespace strings", () => {
+        expect(isValidIanaTimezone("")).toBe(false);
+        expect(isValidIanaTimezone("   ")).toBe(false);
+        expect(isValidIanaTimezone("\t")).toBe(false);
+        expect(isValidIanaTimezone("\n")).toBe(false);
+      });
+
+      it("rejects null and undefined", () => {
+        expect(isValidIanaTimezone(null)).toBe(false);
+        expect(isValidIanaTimezone(undefined)).toBe(false);
+      });
+
+      it("rejects numeric GMT offsets", () => {
+        expect(isValidIanaTimezone("GMT+5")).toBe(false);
+        expect(isValidIanaTimezone("UTC-8")).toBe(false);
+        expect(isValidIanaTimezone("+05:00")).toBe(false);
+      });
+    });
+
+    describe("whitespace handling", () => {
+      it("trims leading/trailing whitespace", () => {
+        expect(isValidIanaTimezone(" America/New_York ")).toBe(true);
+        expect(isValidIanaTimezone("\tEurope/London\n")).toBe(true);
+      });
+
+      it("rejects zones with internal spaces", () => {
+        expect(isValidIanaTimezone("America/ New_York")).toBe(false);
+        expect(isValidIanaTimezone("America /New_York")).toBe(false);
+      });
+    });
+  });
+
+  describe("getIanaTimezoneFromUsStateCode", () => {
+    it("maps standard US state codes", () => {
+      expect(getIanaTimezoneFromUsStateCode("CA", "US")).toBe(
+        "America/Los_Angeles"
+      );
+      expect(getIanaTimezoneFromUsStateCode("NY", "US")).toBe(
+        "America/New_York"
+      );
+      expect(getIanaTimezoneFromUsStateCode("TX", "US")).toBe(
+        "America/Chicago"
+      );
+      expect(getIanaTimezoneFromUsStateCode("UT", "US")).toBe("America/Denver");
+    });
+
+    it("maps special zones", () => {
+      expect(getIanaTimezoneFromUsStateCode("AZ", "US")).toBe(
+        "America/Phoenix"
+      );
+      expect(getIanaTimezoneFromUsStateCode("AK", "US")).toBe(
+        "America/Anchorage"
+      );
+      expect(getIanaTimezoneFromUsStateCode("HI", "US")).toBe(
+        "Pacific/Honolulu"
+      );
+      expect(getIanaTimezoneFromUsStateCode("IN", "US")).toBe(
+        "America/Indiana/Indianapolis"
+      );
+    });
+
+    it("handles DC", () => {
+      expect(getIanaTimezoneFromUsStateCode("DC", "US")).toBe(
+        "America/New_York"
+      );
+    });
+
+    it("is case-insensitive for state codes", () => {
+      expect(getIanaTimezoneFromUsStateCode("ca", "US")).toBe(
+        "America/Los_Angeles"
+      );
+      expect(getIanaTimezoneFromUsStateCode("ny", "US")).toBe(
+        "America/New_York"
+      );
+    });
+
+    it("assumes US when country is null/undefined", () => {
+      expect(getIanaTimezoneFromUsStateCode("CA", null)).toBe(
+        "America/Los_Angeles"
+      );
+      expect(getIanaTimezoneFromUsStateCode("NY", undefined)).toBe(
+        "America/New_York"
+      );
+    });
+
+    it("accepts USA/United States variations", () => {
+      expect(getIanaTimezoneFromUsStateCode("CA", "USA")).toBe(
+        "America/Los_Angeles"
+      );
+      expect(getIanaTimezoneFromUsStateCode("NY", "United States")).toBe(
+        "America/New_York"
+      );
+      expect(
+        getIanaTimezoneFromUsStateCode("TX", "United States of America")
+      ).toBe("America/Chicago");
+    });
+
+    it("returns null for non-US countries", () => {
+      expect(getIanaTimezoneFromUsStateCode("CA", "Canada")).toBeNull();
+      expect(getIanaTimezoneFromUsStateCode("NY", "Mexico")).toBeNull();
+    });
+
+    it("returns null for invalid state codes", () => {
+      expect(getIanaTimezoneFromUsStateCode("XX", "US")).toBeNull();
+      expect(getIanaTimezoneFromUsStateCode("ZZZ", "US")).toBeNull();
+      expect(getIanaTimezoneFromUsStateCode("California", "US")).toBeNull(); // Full name, not code
+    });
+
+    it("returns null for null/undefined/empty state", () => {
+      expect(getIanaTimezoneFromUsStateCode(null, "US")).toBeNull();
+      expect(getIanaTimezoneFromUsStateCode(undefined, "US")).toBeNull();
+      expect(getIanaTimezoneFromUsStateCode("", "US")).toBeNull();
+      expect(getIanaTimezoneFromUsStateCode("  ", "US")).toBeNull();
+    });
+  });
+
+  describe("getIanaTimezoneFromCoordinates", () => {
+    describe("US regions", () => {
+      it("resolves Eastern Time", () => {
+        // New York City
+        expect(getIanaTimezoneFromCoordinates(40.7128, -74.006)).toBe(
+          "America/New_York"
+        );
+        // Miami
+        expect(getIanaTimezoneFromCoordinates(25.7617, -80.1918)).toBe(
+          "America/New_York"
+        );
+      });
+
+      it("resolves Central Time", () => {
+        // Chicago
+        expect(getIanaTimezoneFromCoordinates(41.8781, -87.6298)).toBe(
+          "America/Chicago"
+        );
+        // Houston
+        expect(getIanaTimezoneFromCoordinates(29.7604, -95.3698)).toBe(
+          "America/Chicago"
+        );
+      });
+
+      it("resolves Mountain Time", () => {
+        // Denver
+        expect(getIanaTimezoneFromCoordinates(39.7392, -104.9903)).toBe(
+          "America/Denver"
+        );
+        // Salt Lake City
+        expect(getIanaTimezoneFromCoordinates(40.7608, -111.891)).toBe(
+          "America/Denver"
+        );
+      });
+
+      it("resolves Pacific Time", () => {
+        // Los Angeles
+        expect(getIanaTimezoneFromCoordinates(34.0522, -118.2437)).toBe(
+          "America/Los_Angeles"
+        );
+        // Seattle
+        expect(getIanaTimezoneFromCoordinates(47.6062, -122.3321)).toBe(
+          "America/Los_Angeles"
+        );
+      });
+
+      it("resolves special zones", () => {
+        // Phoenix (Arizona - no DST)
+        expect(getIanaTimezoneFromCoordinates(33.4484, -112.074)).toBe(
+          "America/Phoenix"
+        );
+        // Anchorage (Alaska)
+        expect(getIanaTimezoneFromCoordinates(61.2181, -149.9003)).toBe(
+          "America/Anchorage"
+        );
+        // Honolulu (Hawaii)
+        expect(getIanaTimezoneFromCoordinates(21.3099, -157.8581)).toBe(
+          "Pacific/Honolulu"
+        );
+      });
+    });
+
+    describe("international regions", () => {
+      it("resolves European zones", () => {
+        // London
+        expect(getIanaTimezoneFromCoordinates(51.5074, -0.1278)).toBe(
+          "Europe/London"
+        );
+        // Paris
+        expect(getIanaTimezoneFromCoordinates(48.8566, 2.3522)).toBe(
+          "Europe/Paris"
+        );
+      });
+
+      it("resolves Asian zones", () => {
+        // Tokyo
+        expect(getIanaTimezoneFromCoordinates(35.6762, 139.6503)).toBe(
+          "Asia/Tokyo"
+        );
+      });
+    });
+
+    it("returns null for missing coordinates", () => {
+      expect(getIanaTimezoneFromCoordinates(null, -74.006)).toBeNull();
+      expect(getIanaTimezoneFromCoordinates(40.7128, null)).toBeNull();
+      expect(getIanaTimezoneFromCoordinates(null, null)).toBeNull();
+      expect(getIanaTimezoneFromCoordinates(undefined, undefined)).toBeNull();
+    });
+
+    it("returns null for coordinates with no regional match", () => {
+      // Middle of the South Atlantic Ocean - truly remote
+      expect(getIanaTimezoneFromCoordinates(-30, -30)).toBeNull();
+      // Far southern ocean between Africa and Antarctica
+      expect(getIanaTimezoneFromCoordinates(-60, 40)).toBeNull();
+    });
+  });
+
+  describe("inferEventTimezoneIana", () => {
+    it("prefers coordinates over state code", () => {
+      // LA coords but NY state - coords should win
+      const result = inferEventTimezoneIana({
+        latitude: 34.0522,
+        longitude: -118.2437,
+        state: "NY",
+        country: "US",
+      });
+      expect(result).toBe("America/Los_Angeles");
+    });
+
+    it("falls back to state code when coordinates missing", () => {
+      const result = inferEventTimezoneIana({
+        state: "TX",
+        country: "US",
+      });
+      expect(result).toBe("America/Chicago");
+    });
+
+    it("falls back to location string hints", () => {
+      const result = inferEventTimezoneIana({
+        location: "Denver, CO",
+      });
+      expect(result).toBe("America/Denver");
+    });
+
+    it("returns UTC when nothing matches", () => {
+      const result = inferEventTimezoneIana({
+        city: "Unknown",
+        state: "XX",
+        country: "Unknown",
+      });
+      expect(result).toBe("UTC");
+    });
+
+    it("handles empty args", () => {
+      const result = inferEventTimezoneIana({});
+      expect(result).toBe("UTC");
+    });
+  });
+
+  describe("resolveEventTimezoneIanaForDisplay", () => {
+    it("prefers inferred timezone over stored", () => {
+      // NYC coords with wrong stored timezone
+      const result = resolveEventTimezoneIanaForDisplay({
+        latitude: 40.7128,
+        longitude: -74.006,
+        timezone: "America/Los_Angeles", // wrong
+      });
+      expect(result).toBe("America/New_York");
+    });
+
+    it("uses stored timezone when inference returns UTC", () => {
+      const result = resolveEventTimezoneIanaForDisplay({
+        timezone: "Europe/London",
+        city: "Unknown",
+        state: "XX",
+      });
+      expect(result).toBe("Europe/London");
+    });
+
+    it("validates stored timezone before using it", () => {
+      const result = resolveEventTimezoneIanaForDisplay({
+        timezone: "Invalid/Zone",
+      });
+      expect(result).toBe("UTC");
+    });
+
+    it("rejects timezone abbreviations in stored field", () => {
+      const result = resolveEventTimezoneIanaForDisplay({
+        timezone: "EST",
+      });
+      expect(result).toBe("UTC");
+    });
+
+    it("returns UTC when everything fails", () => {
+      const result = resolveEventTimezoneIanaForDisplay({
+        timezone: null,
+        city: "Unknown",
+      });
+      expect(result).toBe("UTC");
+    });
+
+    it("handles BashCard typical inputs", () => {
+      // Typical event with coords and timezone
+      const result = resolveEventTimezoneIanaForDisplay({
+        latitude: 40.7608,
+        longitude: -111.891,
+        timezone: "America/Denver",
+        city: "Salt Lake City",
+        state: "UT",
+      });
+      expect(result).toBe("America/Denver");
+    });
+  });
+});

package/src/extendedSchemas.ts

@@ -208,6 +208,9 @@ export const FRONT_END_USER_DATA_TO_SELECT = {
   /** BashPoints loyalty (API may omit when viewing someone else’s profile). */
   bashPointsBalance: true,
   bashPointsEarnedLifetime: true,
+  /** Home hero “Stuff the horn” best clear (ms; lower is better). */
+  hornClearBestMs: true,
+  hornClearBestAt: true,
   /** Host reputation fields */
   hostRating: true,
   totalRatings: true,

package/src/index.ts

@@ -401,6 +401,7 @@ export * from "./utils/sortUtils.js";
 export * from "./utils/stringUtils.js";
 export * from "./utils/ticketListUtils.js";
 export * from "./utils/urlUtils.js";
+export * from "./utils/moodTrackUtils.js";
 export * from "./utils/userPromoCodeUtils.js";
 export * from "./utils/userSubscriptionUtils.js";
 export * from "./utils/blog/blogDbUtils.js";

package/src/utils/__tests__/moodTrackUtils.test.ts

@@ -0,0 +1,46 @@
+import {
+  isMoodTrackUrlAllowed,
+  normalizeMoodTrackUrl,
+  parseMoodTrackUrl,
+} from "../moodTrackUtils";
+
+describe("moodTrackUtils", () => {
+  it("parses YouTube Music watch URLs into youtube embeds", () => {
+    const parsed = parseMoodTrackUrl(
+      "https://music.youtube.com/watch?v=dQw4w9WgXcQ"
+    );
+    expect(parsed?.provider).toBe("youtubeMusic");
+    expect(parsed?.embedUrl).toContain("youtube.com/embed/dQw4w9WgXcQ");
+  });
+
+  it("parses Spotify track URLs", () => {
+    const parsed = parseMoodTrackUrl(
+      "https://open.spotify.com/track/11dFghVXANMlKmJXsNCbNl"
+    );
+    expect(parsed?.provider).toBe("spotify");
+    expect(parsed?.embedUrl).toBe(
+      "https://open.spotify.com/embed/track/11dFghVXANMlKmJXsNCbNl"
+    );
+  });
+
+  it("parses Apple Music and SoundCloud", () => {
+    expect(
+      parseMoodTrackUrl(
+        "https://music.apple.com/us/album/example/123?i=456"
+      )?.provider
+    ).toBe("appleMusic");
+    expect(
+      parseMoodTrackUrl("https://soundcloud.com/artist/track")?.provider
+    ).toBe("soundcloud");
+  });
+
+  it("normalizes empty to null and rejects unsupported hosts", () => {
+    expect(normalizeMoodTrackUrl("  ")).toBeNull();
+    expect(normalizeMoodTrackUrl(null)).toBeNull();
+    expect(() => normalizeMoodTrackUrl("https://example.com/song")).toThrow(
+      /YouTube Music/
+    );
+    expect(isMoodTrackUrlAllowed("")).toBe(true);
+    expect(isMoodTrackUrlAllowed("https://evil.example/x")).toBe(false);
+  });
+});

package/src/utils/eventTimezoneIana.ts

@@ -1,5 +1,3 @@
-import { DateTime } from "luxon";
-
 /** Primary IANA zone for each US state + DC (contiguous conventions; AZ/HI/AK use canonical zones). */
 const US_STATE_CODE_TO_IANA: Record<string, string> = {
   AL: "America/Chicago",
@@ -84,7 +82,20 @@ export function getIanaTimezoneFromUsStateCode(
 export function isValidIanaTimezone(timezone: string | null | undefined): boolean {
   const t = timezone?.trim();
   if (!t) return false;
-  return DateTime.now().setZone(t).isValid;
+  
+  // Reject ambiguous abbreviations (EST, PST, CST, etc.) - not IANA standard.
+  // These are ambiguous: EST could be US Eastern or Australian Eastern, etc.
+  // IANA zones follow "Region/City" format or special cases like "UTC".
+  const looksLikeAbbreviation = /^[A-Z]{2,5}T?$/.test(t);
+  if (looksLikeAbbreviation && t !== "UTC") return false;
+  
+  // Intl throws RangeError for unknown IANA ids — no luxon needed.
+  try {
+    Intl.DateTimeFormat(undefined, { timeZone: t });
+    return true;
+  } catch {
+    return false;
+  }
 }
 
 /**

package/src/utils/index.ts

@@ -12,6 +12,7 @@ export * from './entityUtils.js';
 export * from './generalDateTimeUtils.js';
 export * from './luxonUtils.js';
 export * from './mathUtils.js';
+export * from './moodTrackUtils.js';
 export * from './objUtils.js';
 export * from './paymentUtils.js';
 export * from './promoCodesUtils.js';

package/src/utils/moodTrackUtils.ts

@@ -0,0 +1,190 @@
+/**
+ * Bash mood track — optional soundtrack URL on a bash.
+ * Preferred: YouTube Music. Also: Spotify, Apple Music, SoundCloud.
+ * Guests tap to play; never autoplay.
+ */
+
+export type MoodTrackProvider =
+  | "youtubeMusic"
+  | "spotify"
+  | "appleMusic"
+  | "soundcloud";
+
+export type MoodTrackEmbed = {
+  provider: MoodTrackProvider;
+  /** Original pasted URL (normalized). */
+  url: string;
+  /** iframe src when the provider supports embed; null → link-out only. */
+  embedUrl: string | null;
+  label: string;
+};
+
+const YOUTUBE_HOSTS = new Set([
+  "music.youtube.com",
+  "www.youtube.com",
+  "youtube.com",
+  "youtu.be",
+  "m.youtube.com",
+]);
+
+const SPOTIFY_HOSTS = new Set(["open.spotify.com", "spotify.com"]);
+const APPLE_HOSTS = new Set(["music.apple.com", "itunes.apple.com"]);
+const SOUNDCLOUD_HOSTS = new Set(["soundcloud.com", "www.soundcloud.com", "m.soundcloud.com"]);
+
+function hostnameOf(raw: string): string | null {
+  try {
+    return new URL(raw).hostname.toLowerCase();
+  } catch {
+    return null;
+  }
+}
+
+function ensureHttps(raw: string): string | null {
+  const trimmed = raw.trim();
+  if (!trimmed) return null;
+  const withScheme = /^https?:\/\//i.test(trimmed)
+    ? trimmed
+    : `https://${trimmed}`;
+  try {
+    const u = new URL(withScheme);
+    if (u.protocol !== "http:" && u.protocol !== "https:") return null;
+    return u.toString();
+  } catch {
+    return null;
+  }
+}
+
+function youtubeVideoId(url: URL): string | null {
+  if (url.hostname === "youtu.be") {
+    const id = url.pathname.replace(/^\//, "").split("/")[0];
+    return id || null;
+  }
+  const v = url.searchParams.get("v");
+  if (v) return v;
+  const parts = url.pathname.split("/").filter(Boolean);
+  const watchIdx = parts.indexOf("watch");
+  if (watchIdx >= 0 && parts[watchIdx + 1]) return parts[watchIdx + 1];
+  const embedIdx = parts.indexOf("embed");
+  if (embedIdx >= 0 && parts[embedIdx + 1]) return parts[embedIdx + 1];
+  const shortsIdx = parts.indexOf("shorts");
+  if (shortsIdx >= 0 && parts[shortsIdx + 1]) return parts[shortsIdx + 1];
+  return null;
+}
+
+function youtubePlaylistId(url: URL): string | null {
+  return url.searchParams.get("list");
+}
+
+function spotifyEmbedPath(url: URL): string | null {
+  // /track/id | /album/id | /playlist/id | /episode/id
+  const m = url.pathname.match(
+    /^\/(track|album|playlist|episode|show)\/([a-zA-Z0-9]+)/
+  );
+  if (!m) return null;
+  return `/${m[1]}/${m[2]}`;
+}
+
+function appleEmbedPath(url: URL): string | null {
+  // music.apple.com/{country}/album/... or /song/...
+  if (!url.pathname || url.pathname === "/") return null;
+  return url.pathname + url.search;
+}
+
+/**
+ * Normalize + validate a mood track URL for storage.
+ * Empty / whitespace → null. Unsupported host → throws with a host-facing message.
+ */
+export function normalizeMoodTrackUrl(
+  raw: string | null | undefined
+): string | null {
+  if (raw == null) return null;
+  const trimmed = raw.trim();
+  if (!trimmed) return null;
+  const parsed = parseMoodTrackUrl(trimmed);
+  if (!parsed) {
+    throw new Error(
+      "Use a YouTube Music, Spotify, Apple Music, or SoundCloud link."
+    );
+  }
+  return parsed.url;
+}
+
+/** Parse a mood URL into an embed plan (or null if unsupported). */
+export function parseMoodTrackUrl(
+  raw: string | null | undefined
+): MoodTrackEmbed | null {
+  const https = ensureHttps(raw ?? "");
+  if (!https) return null;
+  let url: URL;
+  try {
+    url = new URL(https);
+  } catch {
+    return null;
+  }
+  const host = hostnameOf(https);
+  if (!host) return null;
+
+  if (YOUTUBE_HOSTS.has(host)) {
+    const videoId = youtubeVideoId(url);
+    const listId = youtubePlaylistId(url);
+    if (videoId) {
+      const embed = new URL(`https://www.youtube.com/embed/${videoId}`);
+      embed.searchParams.set("playsinline", "1");
+      embed.searchParams.set("rel", "0");
+      if (listId) embed.searchParams.set("list", listId);
+      return {
+        provider: "youtubeMusic",
+        url: https,
+        embedUrl: embed.toString(),
+        label: "YouTube Music",
+      };
+    }
+    if (listId) {
+      return {
+        provider: "youtubeMusic",
+        url: https,
+        embedUrl: `https://www.youtube.com/embed/videoseries?list=${encodeURIComponent(listId)}`,
+        label: "YouTube Music",
+      };
+    }
+    return null;
+  }
+
+  if (SPOTIFY_HOSTS.has(host)) {
+    const path = spotifyEmbedPath(url);
+    if (!path) return null;
+    return {
+      provider: "spotify",
+      url: https,
+      embedUrl: `https://open.spotify.com/embed${path}`,
+      label: "Spotify",
+    };
+  }
+
+  if (APPLE_HOSTS.has(host)) {
+    const path = appleEmbedPath(url);
+    if (!path) return null;
+    return {
+      provider: "appleMusic",
+      url: https,
+      embedUrl: `https://embed.music.apple.com${path}`,
+      label: "Apple Music",
+    };
+  }
+
+  if (SOUNDCLOUD_HOSTS.has(host)) {
+    return {
+      provider: "soundcloud",
+      url: https,
+      embedUrl: `https://w.soundcloud.com/player/?url=${encodeURIComponent(https)}&auto_play=false&hide_related=true&show_comments=false&visual=false`,
+      label: "SoundCloud",
+    };
+  }
+
+  return null;
+}
+
+export function isMoodTrackUrlAllowed(raw: string | null | undefined): boolean {
+  if (raw == null || !String(raw).trim()) return true;
+  return parseMoodTrackUrl(raw) != null;
+}