@erinjs/core 1.0.0 → 1.2.4

package/core/packages/util/src/emojiShortcodes.test.ts

@@ -1,41 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { getUnicodeFromShortcode, UNICODE_EMOJI_SHORTCODES } from './emojiShortcodes.js';
-
-describe('getUnicodeFromShortcode', () => {
-  it('resolves :heart: to unicode', () => {
-    const r = getUnicodeFromShortcode('heart');
-    expect(r).toBeDefined();
-    expect(typeof r).toBe('string');
-    expect(r!.length).toBeGreaterThan(0);
-  });
-
-  it('is case-insensitive', () => {
-    const a = getUnicodeFromShortcode('heart');
-    const b = getUnicodeFromShortcode('HEART');
-    const c = getUnicodeFromShortcode('Heart');
-    expect(a).toBe(b);
-    expect(b).toBe(c);
-  });
-
-  it('trims whitespace', () => {
-    const r = getUnicodeFromShortcode('  heart  ');
-    expect(r).toBe(UNICODE_EMOJI_SHORTCODES['heart']);
-  });
-
-  it('returns undefined for empty or invalid', () => {
-    expect(getUnicodeFromShortcode('')).toBeUndefined();
-    expect(getUnicodeFromShortcode('   ')).toBeUndefined();
-    expect(getUnicodeFromShortcode('nonexistent_emoji_xyz')).toBeUndefined();
-  });
-
-  it('returns undefined for null/undefined input', () => {
-    expect(getUnicodeFromShortcode(null as unknown as string)).toBeUndefined();
-    expect(getUnicodeFromShortcode(undefined as unknown as string)).toBeUndefined();
-  });
-
-  it('resolves common shortcodes', () => {
-    expect(getUnicodeFromShortcode('thumbsup')).toBeDefined();
-    expect(getUnicodeFromShortcode('smile')).toBeDefined();
-    expect(getUnicodeFromShortcode('fire')).toBeDefined();
-  });
-});

package/core/packages/util/src/emojiShortcodes.ts

@@ -1,22 +0,0 @@
-/**
- * Maps Unicode emoji shortcodes (:name:) to their Unicode characters.
- * Used to resolve shortcodes like :arrow_backward: and :flag_ad: for message.react()
- * without requiring guild context. Custom emojis use guild lookup; known Unicode shortcodes
- * resolve here so they work in DMs and guild channels alike.
- *
- * Data is generated from Discord's emoji data (anyascii/discord-emojis).
- * Run: pnpm exec tsx scripts/generate-emoji-shortcodes.ts
- */
-import { UNICODE_EMOJI_SHORTCODES as SHORTCODES } from './emojiShortcodes.generated.js';
-
-export const UNICODE_EMOJI_SHORTCODES = SHORTCODES;
-
-/**
- * Get the Unicode character for a known shortcode name.
- * Case-insensitive. Returns undefined if the shortcode is not in the map.
- */
-export function getUnicodeFromShortcode(name: string): string | undefined {
-  if (!name || typeof name !== 'string') return undefined;
-  const key = name.toLowerCase().trim();
-  return UNICODE_EMOJI_SHORTCODES[key];
-}

package/core/packages/util/src/formatters.test.ts

@@ -1,65 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { formatColor, escapeMarkdown, formatTimestamp, truncate } from './formatters.js';
-
-describe('formatColor', () => {
-  it('formats color as hex', () => {
-    expect(formatColor(0xff0000)).toBe('#ff0000');
-    expect(formatColor(0)).toBe('#000000');
-    expect(formatColor(0xffffff)).toBe('#ffffff');
-  });
-});
-
-describe('escapeMarkdown', () => {
-  it('escapes markdown characters', () => {
-    expect(escapeMarkdown('*bold*')).toBe('\\*bold\\*');
-    expect(escapeMarkdown('_italic_')).toBe('\\_italic\\_');
-  });
-});
-
-describe('formatTimestamp', () => {
-  it('formats timestamp', () => {
-    const ts = 1609459200000; // 2021-01-01 00:00:00 UTC
-    expect(formatTimestamp(ts)).toBe('<t:1609459200>');
-    expect(formatTimestamp(ts, 'R')).toBe('<t:1609459200:R>');
-  });
-});
-
-describe('truncate', () => {
-  it('returns unchanged if under limit', () => {
-    expect(truncate('hello', 10)).toBe('hello');
-  });
-
-  it('truncates with suffix', () => {
-    expect(truncate('hello world', 8)).toBe('hello...');
-  });
-
-  it('uses custom suffix', () => {
-    expect(truncate('hello world', 9, '..')).toBe('hello w..');
-  });
-
-  it('handles exact length', () => {
-    expect(truncate('hello', 5)).toBe('hello');
-  });
-
-  it('handles length smaller than suffix', () => {
-    expect(truncate('hi', 1, '...')).toBe('...');
-  });
-});
-
-describe('escapeMarkdown edge cases', () => {
-  it('escapes backtick', () => {
-    expect(escapeMarkdown('`code`')).toBe('\\`code\\`');
-  });
-  it('escapes pipe', () => {
-    expect(escapeMarkdown('a|b')).toBe('a\\|b');
-  });
-  it('escapes tilde', () => {
-    expect(escapeMarkdown('~strikethrough~')).toBe('\\~strikethrough\\~');
-  });
-});
-
-describe('formatColor edge cases', () => {
-  it('pads short hex', () => {
-    expect(formatColor(0x000001)).toBe('#000001');
-  });
-});

package/core/packages/util/src/formatters.ts

@@ -1,35 +0,0 @@
-/**
- * Format a number as a hex color string.
- */
-export function formatColor(color: number): string {
-  const hex = color.toString(16).padStart(6, '0');
-  return `#${hex}`;
-}
-
-/**
- * Escape markdown formatting characters in a string.
- */
-export function escapeMarkdown(text: string): string {
-  return text.replace(/([\\*_`~|])/g, '\\$1');
-}
-
-/**
- * Format a Unix timestamp for Fluxer/Discord style timestamps.
- * @param timestamp - Unix timestamp in seconds
- * @param style - t, T, d, D, f, F, R, etc.
- */
-export function formatTimestamp(
-  timestamp: number,
-  style?: 't' | 'T' | 'd' | 'D' | 'f' | 'F' | 'R',
-): string {
-  const suffix = style ? `:${style}` : '';
-  return `<t:${Math.floor(timestamp / 1000)}${suffix}>`;
-}
-
-/**
- * Truncate a string to a maximum length with an optional suffix.
- */
-export function truncate(str: string, maxLength: number, suffix = '...'): string {
-  if (str.length <= maxLength) return str;
-  return str.slice(0, maxLength - suffix.length) + suffix;
-}

package/core/packages/util/src/index.ts

@@ -1,34 +0,0 @@
-export { BitField, type BitFieldResolvable } from './BitField.js';
-export { SnowflakeUtil, FLUXER_EPOCH } from './SnowflakeUtil.js';
-export {
-  PermissionsBitField,
-  PermissionFlags,
-  ALL_PERMISSIONS_BIGINT,
-  resolvePermissionsToBitfield,
-  type PermissionString,
-  type PermissionResolvable,
-} from './PermissionsBitField.js';
-export {
-  MessageFlagsBitField,
-  MessageFlagsBits,
-  type MessageFlagsString,
-  type MessageFlagsResolvable,
-} from './MessageFlagsBitField.js';
-export {
-  UserFlagsBitField,
-  UserFlagsBits,
-  type UserFlagsString,
-  type UserFlagsResolvable,
-} from './UserFlagsBitField.js';
-export { formatColor, escapeMarkdown, formatTimestamp, truncate } from './formatters.js';
-export {
-  resolveColor,
-  parseEmoji,
-  formatEmoji,
-  parseUserMention,
-  parseRoleMention,
-  parsePrefixCommand,
-} from './resolvers.js';
-export { getUnicodeFromShortcode } from './emojiShortcodes.js';
-export { resolveTenorToImageUrl, type TenorMediaResult } from './tenorUtils.js';
-export { emitDeprecationWarning } from './deprecation.js';

package/core/packages/util/src/resolvers.test.ts

@@ -1,198 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import {
-  parseEmoji,
-  formatEmoji,
-  parseUserMention,
-  parseRoleMention,
-  parsePrefixCommand,
-  resolveColor,
-} from './resolvers.js';
-
-describe('parseEmoji', () => {
-  it('returns null for null/undefined/non-string', () => {
-    expect(parseEmoji(null as unknown as string)).toBeNull();
-    expect(parseEmoji(undefined as unknown as string)).toBeNull();
-    expect(parseEmoji(123 as unknown as string)).toBeNull();
-  });
-
-  it('returns null for empty or whitespace-only string', () => {
-    expect(parseEmoji('')).toBeNull();
-    expect(parseEmoji('   ')).toBeNull();
-  });
-
-  it('parses <:name:id> mention format', () => {
-    const r = parseEmoji('<:custom:123456789012345678>');
-    expect(r).toEqual({ id: '123456789012345678', name: 'custom', animated: false });
-  });
-
-  it('parses <a:name:id> animated mention format', () => {
-    const r = parseEmoji('<a:wiggle:987654321098765432>');
-    expect(r).toEqual({ id: '987654321098765432', name: 'wiggle', animated: true });
-  });
-
-  it('parses name:id API format', () => {
-    const r = parseEmoji('CustomEmoji:123456789012345678');
-    expect(r).toEqual({ id: '123456789012345678', name: 'CustomEmoji' });
-  });
-
-  it('parses :name: shortcode format (unicode or guild lookup)', () => {
-    const r = parseEmoji(':heart:');
-    expect(r).toEqual({ id: null, name: 'heart' });
-  });
-
-  it('parses :name: with surrounding whitespace', () => {
-    const r = parseEmoji('  :heart:  ');
-    expect(r).toEqual({ id: null, name: 'heart' });
-  });
-
-  it('returns plain unicode as name when no pattern matches', () => {
-    const r = parseEmoji('❤️');
-    expect(r).toEqual({ id: null, name: '❤️' });
-  });
-
-  it('rejects name:id with short id (less than 17 digits)', () => {
-    const r = parseEmoji('emoji:123456');
-    expect(r?.id).toBeNull();
-    expect(r?.name).toBe('emoji:123456'); // falls through to plain
-  });
-});
-
-describe('formatEmoji', () => {
-  it('formats custom emoji as name:id', () => {
-    expect(formatEmoji({ id: '123456789012345678', name: 'custom' })).toBe(
-      ':custom:123456789012345678',
-    );
-  });
-
-  it('formats animated custom emoji with a prefix', () => {
-    expect(formatEmoji({ id: '123456789012345678', name: 'wiggle', animated: true })).toBe(
-      'a:wiggle:123456789012345678',
-    );
-  });
-
-  it('encodes unicode emoji for API (id null)', () => {
-    const r = formatEmoji({ id: null, name: '❤' });
-    expect(r).toBe(encodeURIComponent('❤'));
-  });
-});
-
-describe('parseUserMention', () => {
-  it('extracts user ID from <@id> mention', () => {
-    expect(parseUserMention('<@123456789012345678>')).toBe('123456789012345678');
-  });
-
-  it('extracts user ID from <@!id> mention', () => {
-    expect(parseUserMention('<@!123456789012345678>')).toBe('123456789012345678');
-  });
-
-  it('returns raw snowflake when valid 17–19 digits', () => {
-    expect(parseUserMention('123456789012345678')).toBe('123456789012345678');
-  });
-
-  it('returns null for invalid formats', () => {
-    expect(parseUserMention('<@&123>')).toBeNull();
-    expect(parseUserMention('invalid')).toBeNull();
-    expect(parseUserMention('')).toBeNull();
-  });
-
-  it('trims whitespace', () => {
-    expect(parseUserMention('  <@!123456789012345678>  ')).toBe('123456789012345678');
-  });
-});
-
-describe('parsePrefixCommand', () => {
-  it('parses command with no args', () => {
-    expect(parsePrefixCommand('!ping', '!')).toEqual({ command: 'ping', args: [] });
-  });
-
-  it('parses command with args', () => {
-    expect(parsePrefixCommand('!hello world', '!')).toEqual({ command: 'hello', args: ['world'] });
-    expect(parsePrefixCommand('!ban 123 reason here', '!')).toEqual({
-      command: 'ban',
-      args: ['123', 'reason', 'here'],
-    });
-  });
-
-  it('returns null when content does not start with prefix', () => {
-    expect(parsePrefixCommand('hello', '!')).toBeNull();
-  });
-
-  it('returns null for prefix only with no command', () => {
-    expect(parsePrefixCommand('!', '!')).toBeNull();
-    expect(parsePrefixCommand('!  ', '!')).toBeNull();
-  });
-
-  it('handles multiple spaces between args', () => {
-    expect(parsePrefixCommand('!cmd   a   b', '!')).toEqual({
-      command: 'cmd',
-      args: ['a', 'b'],
-    });
-  });
-
-  it('lowercases command', () => {
-    expect(parsePrefixCommand('!PING', '!')).toEqual({ command: 'ping', args: [] });
-  });
-
-  it('returns null for null or non-string content', () => {
-    expect(parsePrefixCommand(null as unknown as string, '!')).toBeNull();
-    expect(parsePrefixCommand(123 as unknown as string, '!')).toBeNull();
-  });
-});
-
-describe('parseRoleMention', () => {
-  it('extracts role ID from valid mention', () => {
-    expect(parseRoleMention('<@&123456789012345678>')).toBe('123456789012345678');
-  });
-
-  it('returns null for invalid formats', () => {
-    expect(parseRoleMention('<@123>')).toBeNull();
-    expect(parseRoleMention('@&123')).toBeNull();
-    expect(parseRoleMention('')).toBeNull();
-    expect(parseRoleMention('  ')).toBeNull();
-  });
-
-  it('returns null for null or non-string', () => {
-    expect(parseRoleMention(null as unknown as string)).toBeNull();
-    expect(parseRoleMention(undefined as unknown as string)).toBeNull();
-    expect(parseRoleMention(123 as unknown as string)).toBeNull();
-  });
-
-  it('trims whitespace', () => {
-    expect(parseRoleMention('  <@&123456789012345678>  ')).toBe('123456789012345678');
-  });
-});
-
-describe('resolveColor', () => {
-  it('accepts valid number 0-16777215', () => {
-    expect(resolveColor(0)).toBe(0);
-    expect(resolveColor(0xff0000)).toBe(0xff0000);
-    expect(resolveColor(0xffffff)).toBe(0xffffff);
-  });
-
-  it('throws for number out of range', () => {
-    expect(() => resolveColor(-1)).toThrow(RangeError);
-    expect(() => resolveColor(0x1000000)).toThrow(RangeError);
-  });
-
-  it('parses hex string', () => {
-    expect(resolveColor('#ff0000')).toBe(0xff0000);
-    expect(resolveColor('#FFFFFF')).toBe(0xffffff);
-    expect(resolveColor('000000')).toBe(0);
-  });
-
-  it('throws for invalid hex', () => {
-    expect(() => resolveColor('#gggggg')).toThrow(RangeError);
-    expect(() => resolveColor('#fff')).toThrow(RangeError);
-  });
-
-  it('parses RGB array', () => {
-    expect(resolveColor([255, 0, 0])).toBe(0xff0000);
-    expect(resolveColor([0, 0, 0])).toBe(0);
-    expect(resolveColor([255, 255, 255])).toBe(0xffffff);
-  });
-
-  it('throws for non-color types', () => {
-    expect(() => resolveColor({} as unknown as number)).toThrow(TypeError);
-    expect(() => resolveColor(true as unknown as number)).toThrow(TypeError);
-  });
-});

package/core/packages/util/src/resolvers.ts

@@ -1,127 +0,0 @@
-/**
- * Resolve a color from various input types to a number (0-16777215).
- */
-export function resolveColor(color: number | string | [number, number, number]): number {
-  if (typeof color === 'number') {
-    if (color < 0 || color > 0xffffff) throw new RangeError('Color must be between 0 and 16777215');
-    return color;
-  }
-  if (Array.isArray(color)) {
-    const [r, g, b] = color;
-    return (r! << 16) | (g! << 8) | b!;
-  }
-  if (typeof color === 'string') {
-    const hex = color.replace(/^#/, '');
-    if (!/^[0-9a-fA-F]{6}$/.test(hex)) throw new RangeError('Invalid hex color');
-    return parseInt(hex, 16);
-  }
-  throw new TypeError('Color must be a number, hex string, or RGB array');
-}
-
-/**
- * Parse an emoji string into id and name.
- * Supports: <a?:name:id> (mention), :name: (colons), name:id (API format), unicode.
- */
-export function parseEmoji(
-  emoji: string,
-): { id: string | null; name: string; animated?: boolean } | null {
-  if (emoji == null || typeof emoji !== 'string') return null;
-  const trimmed = emoji.trim();
-  if (trimmed.length === 0) return null;
-  // <a?:name:id> mention format
-  const mention = /^<(a?):(\w+):(\d+)>$/;
-  const mentionMatch = trimmed.match(mention);
-  if (mentionMatch) {
-    return {
-      id: mentionMatch[3],
-      name: mentionMatch[2],
-      animated: mentionMatch[1] === 'a',
-    };
-  }
-  // name:id API format (custom emoji)
-  const nameId = /^(\w+):(\d{17,19})$/;
-  const nameIdMatch = trimmed.match(nameId);
-  if (nameIdMatch) {
-    return { id: nameIdMatch[2], name: nameIdMatch[1] };
-  }
-  // :name: format (colons, no id - needs guild lookup)
-  const colons = /^:(\w+):$/;
-  const colonsMatch = trimmed.match(colons);
-  if (colonsMatch) {
-    return { id: null, name: colonsMatch[1] };
-  }
-  // Plain name (possibly unicode) - id null
-  return { id: null, name: trimmed };
-}
-
-/**
- * Parse a user mention string or raw snowflake and extract the user ID.
- * Supports: <@123456789012345678>, <@!123456789012345678>, or raw 17–19 digit snowflake.
- * @param arg - String that may contain a user mention or raw user ID
- * @returns The user ID if valid, otherwise null
- * @example
- * parseUserMention('<@!123456789012345678>'); // '123456789012345678'
- * parseUserMention('<@123456789012345678>');  // '123456789012345678'
- * parseUserMention('123456789012345678');     // '123456789012345678'
- */
-export function parseUserMention(arg: string): string | null {
-  if (arg == null || typeof arg !== 'string') return null;
-  const trimmed = arg.trim();
-  if (trimmed.length === 0) return null;
-  const mentionMatch = trimmed.match(/^<@!?(\d{17,19})>$/);
-  if (mentionMatch) return mentionMatch[1];
-  if (/^\d{17,19}$/.test(trimmed)) return trimmed;
-  return null;
-}
-
-/**
- * Parse prefix command content into command name and args.
- * Returns null if content does not start with the prefix.
- * @param content - Raw message content
- * @param prefix - Command prefix (e.g. '!')
- * @returns { command, args } or null
- * @example
- * parsePrefixCommand('!ping', '!');      // { command: 'ping', args: [] }
- * parsePrefixCommand('!hello world', '!'); // { command: 'hello', args: ['world'] }
- */
-export function parsePrefixCommand(
-  content: string,
-  prefix: string,
-): { command: string; args: string[] } | null {
-  if (content == null || typeof content !== 'string') return null;
-  const trimmed = content.trim();
-  if (!trimmed.startsWith(prefix)) return null;
-  const rest = trimmed.slice(prefix.length).trim();
-  if (rest.length === 0) return null;
-  const parts = rest.split(/\s+/);
-  const command = parts[0]?.toLowerCase() ?? '';
-  const args = parts.slice(1);
-  return { command, args };
-}
-
-/**
- * Parse a role mention string (e.g. <@&123456>) and extract the role ID.
- * @param arg - String that may contain a role mention
- * @returns The role ID if valid mention, otherwise null
- */
-export function parseRoleMention(arg: string): string | null {
-  if (arg == null || typeof arg !== 'string') return null;
-  const match = arg.trim().match(/^<@&(\d{17,19})>$/);
-  return match?.[1] ?? null;
-}
-
-/**
- * Convert emoji to the format used in API (for reactions etc).
- * Custom: "name:id", Unicode: "unicode"
- */
-export function formatEmoji(emoji: {
-  id: string | null;
-  name: string;
-  animated?: boolean;
-}): string {
-  if (emoji.id) {
-    const prefix = emoji.animated ? 'a' : '';
-    return `${prefix}:${emoji.name}:${emoji.id}`;
-  }
-  return encodeURIComponent(emoji.name);
-}

package/core/packages/util/src/tenorUtils.test.ts

@@ -1,75 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import { resolveTenorToImageUrl } from './tenorUtils.js';
-
-describe('resolveTenorToImageUrl', () => {
-  beforeEach(() => {
-    vi.stubGlobal(
-      'fetch',
-      vi.fn((url: string) => {
-        if (url.includes('tenor.com/view')) {
-          const html = `<html><script class="dynamic" type="application/ld+json">
-            {"@type":"VideoObject","contentUrl":"https://media.tenor.com/abc123/stressed.gif","thumbnailUrl":"https://media.tenor.com/abc123/stressed.png"}
-          </script></html>`;
-          return Promise.resolve({
-            ok: true,
-            text: () => Promise.resolve(html),
-          } as Response);
-        }
-        if (url.includes('oembed')) {
-          return Promise.resolve({
-            ok: true,
-            json: () =>
-              Promise.resolve({
-                thumbnail_url: 'https://media.tenor.com/xyz/stressed.png',
-              }),
-          } as Response);
-        }
-        return Promise.reject(new Error('Unexpected URL'));
-      }),
-    );
-  });
-
-  afterEach(() => {
-    vi.unstubAllGlobals();
-  });
-
-  it('returns null for empty or non-tenor URL', async () => {
-    expect(await resolveTenorToImageUrl('')).toBeNull();
-    expect(await resolveTenorToImageUrl('https://example.com')).toBeNull();
-    expect(await resolveTenorToImageUrl('https://giphy.com/view/123')).toBeNull();
-  });
-
-  it('resolves GIF URL from tenor view page JSON-LD', async () => {
-    const result = await resolveTenorToImageUrl(
-      'https://tenor.com/view/stressed-gif-7048057395502071840',
-    );
-    expect(result).not.toBeNull();
-    expect(result!.url).toContain('.gif');
-    expect(result!.url).toContain('media.tenor.com');
-  });
-
-  it('falls back to oEmbed when page fetch fails', async () => {
-    vi.stubGlobal(
-      'fetch',
-      vi.fn((url: string) => {
-        if (url.includes('tenor.com/view')) {
-          return Promise.resolve({ ok: false });
-        }
-        if (url.includes('oembed')) {
-          return Promise.resolve({
-            ok: true,
-            json: () =>
-              Promise.resolve({
-                thumbnail_url: 'https://media.tenor.com/fallback/image.png',
-              }),
-          } as Response);
-        }
-        return Promise.reject(new Error('Unexpected'));
-      }),
-    );
-    const result = await resolveTenorToImageUrl('https://tenor.com/view/test-123');
-    expect(result).not.toBeNull();
-    expect(result!.url).toContain('media.tenor.com');
-    expect(result!.url).toContain('.gif');
-  });
-});

package/core/packages/util/src/tenorUtils.ts

@@ -1,86 +0,0 @@
-import { EmbedMediaFlags } from '@erinjs/types';
-
-/** Result for embed media: url and optional flags. */
-export interface TenorMediaResult {
-  url: string;
-  flags?: number;
-}
-
-/**
- * Resolve a Tenor view URL to a direct GIF URL for use in embeds.
- * Embeds require GIF format (not MP4). Fetches the Tenor page for JSON-LD
- * or oEmbed, then derives the GIF URL from the media.tenor.com path.
- *
- * @param tenorViewUrl - Tenor view URL (e.g. https://tenor.com/view/stressed-gif-7048057395502071840)
- * @returns { url, flags? } for setImage/setThumbnail, or null if resolution fails
- * @example
- * const media = await resolveTenorToImageUrl('https://tenor.com/view/stressed-gif-7048057395502071840');
- * if (media) embed.setImage(media);
- */
-export async function resolveTenorToImageUrl(
-  tenorViewUrl: string,
-): Promise<TenorMediaResult | null> {
-  if (!tenorViewUrl || !tenorViewUrl.includes('tenor.com')) return null;
-
-  // Try page HTML + JSON-LD first
-  try {
-    const pageRes = await fetch(tenorViewUrl, {
-      signal: AbortSignal.timeout(5000),
-      headers: { 'User-Agent': 'Mozilla/5.0 (compatible; FluxerSDK/1.0)' },
-    });
-    if (!pageRes.ok) throw new Error('Page fetch failed');
-    const html = await pageRes.text();
-    const jsonLd = extractTenorJsonLd(html);
-    const gifUrl = extractGifUrlFromJsonLd(jsonLd);
-    if (gifUrl) {
-      return { url: gifUrl, flags: EmbedMediaFlags.IS_ANIMATED };
-    }
-  } catch {
-    // Fall through to oEmbed
-  }
-
-  // Fallback: oEmbed thumbnail, derive GIF URL (media.tenor.com/ID/name.png -> name.gif)
-  try {
-    const oembedUrl = `https://tenor.com/oembed?url=${encodeURIComponent(tenorViewUrl)}`;
-    const res = await fetch(oembedUrl, { signal: AbortSignal.timeout(5000) });
-    if (!res.ok) return null;
-    const data = (await res.json()) as { thumbnail_url?: string };
-    const gifUrl = deriveGifFromThumbnail(data.thumbnail_url);
-    return gifUrl ? { url: gifUrl, flags: EmbedMediaFlags.IS_ANIMATED } : null;
-  } catch {
-    return null;
-  }
-}
-
-/** Extract GIF URL from JSON-LD. Prefers .gif URLs; derives from thumbnail path if needed. */
-function extractGifUrlFromJsonLd(jsonLd: Record<string, unknown> | null): string | null {
-  if (!jsonLd) return null;
-  const image = jsonLd.image as Record<string, string> | undefined;
-  const video = jsonLd.video as Record<string, string> | undefined;
-  const thumbnailUrl = image?.thumbnailUrl ?? image?.url;
-  const contentUrl = image?.contentUrl ?? video?.contentUrl;
-  if (contentUrl && /\.gif($|\?)/i.test(contentUrl)) return contentUrl;
-  if (thumbnailUrl) return deriveGifFromThumbnail(thumbnailUrl);
-  return null;
-}
-
-/** Derive GIF URL from media.tenor.com thumbnail (.png -> .gif). */
-function deriveGifFromThumbnail(thumbUrl: string | undefined): string | null {
-  if (!thumbUrl || !thumbUrl.includes('media.tenor.com')) return null;
-  const gifUrl = thumbUrl.replace(/\.(png|jpg|jpeg|webp)(\?|$)/i, '.gif$2');
-  return gifUrl !== thumbUrl ? gifUrl : null;
-}
-
-function extractTenorJsonLd(html: string): Record<string, unknown> | null {
-  const re =
-    /<script[^>]*class="dynamic"[^>]*type="application\/ld\+json"[^>]*>([\s\S]*?)<\/script>/i;
-  const alt =
-    /<script[^>]*type="application\/ld\+json"[^>]*class="dynamic"[^>]*>([\s\S]*?)<\/script>/i;
-  const match = html.match(re) ?? html.match(alt);
-  if (!match?.[1]) return null;
-  try {
-    return JSON.parse(match[1].trim()) as Record<string, unknown>;
-  } catch {
-    return null;
-  }
-}