@xhub-short/adapters 0.1.0-beta.0

package/dist/index.js

@@ -0,0 +1,3238 @@
+// src/data/mock.ts
+var MOCK_VIDEOS = [
+  // ═══════════════════════════════════════════════════════════════════════════
+  // HLS Videos (for testing hls.js integration)
+  // ═══════════════════════════════════════════════════════════════════════════
+  {
+    id: "video-1",
+    source: {
+      url: "https://peertube.teknix.services/static/streaming-playlists/hls/dd8de71d-0b75-4677-a1a2-6f60e673bee4/465faffa-6d08-4f34-ae40-691cc904ce7b-master.m3u8",
+      type: "hls"
+    },
+    poster: "https://images.unsplash.com/photo-1536240478700-b869070f9279?w=400&h=600&fit=crop",
+    duration: 634,
+    title: "HLS Test Stream - Big Buck Bunny",
+    author: {
+      id: "author-1",
+      name: "Mux Test Streams",
+      avatar: "https://i.pravatar.cc/150?u=author1",
+      isVerified: true
+    },
+    stats: {
+      views: 1234567,
+      likes: 98765,
+      comments: 4321,
+      shares: 876
+    },
+    isLiked: false,
+    isFollowing: false,
+    createdAt: "2024-01-15T10:30:00Z",
+    hashtags: ["hls", "streaming", "test"]
+  },
+  {
+    id: "video-2",
+    source: {
+      url: "https://devstreaming-cdn.apple.com/videos/streaming/examples/img_bipbop_adv_example_fmp4/master.m3u8",
+      type: "hls"
+    },
+    poster: "https://images.unsplash.com/photo-1478737270239-2f02b77fc618?w=400&h=600&fit=crop",
+    duration: 120,
+    title: "Apple HLS Sample - Advanced Stream",
+    author: {
+      id: "author-2",
+      name: "Apple Developer",
+      avatar: "https://i.pravatar.cc/150?u=author2",
+      isVerified: true
+    },
+    stats: {
+      views: 876543,
+      likes: 54321,
+      comments: 2109,
+      shares: 543
+    },
+    isLiked: true,
+    isFollowing: true,
+    createdAt: "2024-01-14T15:45:00Z",
+    hashtags: ["apple", "hls", "fmp4"]
+  },
+  // ═══════════════════════════════════════════════════════════════════════════
+  // MP4 Videos
+  // ═══════════════════════════════════════════════════════════════════════════
+  {
+    id: "video-3",
+    source: {
+      url: "https://peertube.teknix.services/static/streaming-playlists/hls/ea58b245-b3bf-4958-b2f0-b31f8113d142/83f1bb91-e76a-4dcd-8034-2ec37cb70ead-master.m3u8",
+      type: "hls"
+    },
+    poster: "https://storage.googleapis.com/gtv-videos-bucket/sample/images/ForBiggerBlazes.jpg",
+    duration: 15,
+    title: "For Bigger Blazes (MP4)",
+    author: {
+      id: "author-3",
+      name: "Google Chrome",
+      avatar: "https://i.pravatar.cc/150?u=author3",
+      isVerified: true
+    },
+    stats: {
+      views: 543210,
+      likes: 32109,
+      comments: 1543,
+      shares: 321
+    },
+    isLiked: false,
+    isFollowing: false,
+    createdAt: "2024-01-13T09:20:00Z",
+    hashtags: ["chrome", "blazes"]
+  },
+  {
+    id: "video-4",
+    source: {
+      url: "https://storage.googleapis.com/gtv-videos-bucket/sample/ForBiggerEscapes.mp4",
+      type: "mp4"
+    },
+    poster: "https://storage.googleapis.com/gtv-videos-bucket/sample/images/ForBiggerEscapes.jpg",
+    duration: 15,
+    title: "For Bigger Escapes",
+    author: {
+      id: "author-3",
+      name: "Google Chrome",
+      avatar: "https://i.pravatar.cc/150?u=author3",
+      isVerified: true
+    },
+    stats: {
+      views: 432109,
+      likes: 21098,
+      comments: 987,
+      shares: 210
+    },
+    isLiked: false,
+    isFollowing: false,
+    createdAt: "2024-01-12T14:10:00Z",
+    hashtags: ["chrome", "escapes"]
+  },
+  {
+    id: "video-5",
+    source: {
+      url: "https://peertube.teknix.services/static/streaming-playlists/hls/003a41a3-25c1-419b-9548-7a1597adc85f/9cc93564-c9c9-4107-ae12-cd22d0db8046-master.m3u8",
+      type: "hls"
+    },
+    poster: "https://storage.googleapis.com/gtv-videos-bucket/sample/images/ForBiggerFun.jpg",
+    duration: 60,
+    title: "For Bigger Fun",
+    author: {
+      id: "author-3",
+      name: "Google Chrome",
+      avatar: "https://i.pravatar.cc/150?u=author3",
+      isVerified: true
+    },
+    stats: {
+      views: 321098,
+      likes: 10987,
+      comments: 654,
+      shares: 109
+    },
+    isLiked: true,
+    isFollowing: false,
+    createdAt: "2024-01-11T11:05:00Z",
+    hashtags: ["chrome", "fun"]
+  },
+  {
+    id: "video-6",
+    source: {
+      url: "https://storage.googleapis.com/gtv-videos-bucket/sample/ForBiggerJoyrides.mp4",
+      type: "mp4"
+    },
+    poster: "https://storage.googleapis.com/gtv-videos-bucket/sample/images/ForBiggerJoyrides.jpg",
+    duration: 15,
+    title: "For Bigger Joyrides",
+    author: {
+      id: "author-4",
+      name: "GoPro Adventures",
+      avatar: "https://i.pravatar.cc/150?u=author4",
+      isVerified: true
+    },
+    stats: {
+      views: 892345,
+      likes: 67890,
+      comments: 3456,
+      shares: 789
+    },
+    isLiked: false,
+    isFollowing: true,
+    createdAt: "2024-01-10T16:45:00Z",
+    hashtags: ["adventure", "joyride", "travel"]
+  },
+  {
+    id: "video-7",
+    source: {
+      url: "https://storage.googleapis.com/gtv-videos-bucket/sample/ForBiggerMeltdowns.mp4",
+      type: "mp4"
+    },
+    poster: "https://storage.googleapis.com/gtv-videos-bucket/sample/images/ForBiggerMeltdowns.jpg",
+    duration: 15,
+    title: "For Bigger Meltdowns",
+    author: {
+      id: "author-5",
+      name: "Ice Cream Factory",
+      avatar: "https://i.pravatar.cc/150?u=author5",
+      isVerified: false
+    },
+    stats: {
+      views: 234567,
+      likes: 12345,
+      comments: 567,
+      shares: 123
+    },
+    isLiked: true,
+    isFollowing: false,
+    createdAt: "2024-01-09T12:30:00Z",
+    hashtags: ["satisfying", "icecream", "asmr"]
+  },
+  {
+    id: "video-8",
+    source: {
+      url: "https://storage.googleapis.com/gtv-videos-bucket/sample/Sintel.mp4",
+      type: "mp4"
+    },
+    poster: "https://storage.googleapis.com/gtv-videos-bucket/sample/images/Sintel.jpg",
+    duration: 888,
+    title: "Sintel - Epic Fantasy Short Film",
+    author: {
+      id: "author-1",
+      name: "Blender Foundation",
+      avatar: "https://i.pravatar.cc/150?u=author1",
+      isVerified: true
+    },
+    stats: {
+      views: 2567890,
+      likes: 189012,
+      comments: 8901,
+      shares: 2345
+    },
+    isLiked: false,
+    isFollowing: false,
+    createdAt: "2024-01-08T09:15:00Z",
+    hashtags: ["fantasy", "animation", "sintel", "blender"]
+  },
+  {
+    id: "video-9",
+    source: {
+      url: "https://storage.googleapis.com/gtv-videos-bucket/sample/SubaruOutbackOnStreetAndDirt.mp4",
+      type: "mp4"
+    },
+    poster: "https://storage.googleapis.com/gtv-videos-bucket/sample/images/SubaruOutbackOnStreetAndDirt.jpg",
+    duration: 596,
+    title: "Subaru Outback - Street & Dirt",
+    author: {
+      id: "author-6",
+      name: "Car Reviews Daily",
+      avatar: "https://i.pravatar.cc/150?u=author6",
+      isVerified: true
+    },
+    stats: {
+      views: 456789,
+      likes: 34567,
+      comments: 1234,
+      shares: 456
+    },
+    isLiked: false,
+    isFollowing: true,
+    createdAt: "2024-01-07T14:20:00Z",
+    hashtags: ["cars", "subaru", "offroad", "review"]
+  },
+  {
+    id: "video-10",
+    source: {
+      url: "https://storage.googleapis.com/gtv-videos-bucket/sample/TearsOfSteel.mp4",
+      type: "mp4"
+    },
+    poster: "https://storage.googleapis.com/gtv-videos-bucket/sample/images/TearsOfSteel.jpg",
+    duration: 734,
+    title: "Tears of Steel - Sci-Fi Drama",
+    author: {
+      id: "author-1",
+      name: "Blender Foundation",
+      avatar: "https://i.pravatar.cc/150?u=author1",
+      isVerified: true
+    },
+    stats: {
+      views: 1876543,
+      likes: 145678,
+      comments: 6789,
+      shares: 1890
+    },
+    isLiked: true,
+    isFollowing: false,
+    createdAt: "2024-01-06T11:10:00Z",
+    hashtags: ["scifi", "drama", "blender", "vfx"]
+  },
+  {
+    id: "video-11",
+    source: {
+      url: "https://storage.googleapis.com/gtv-videos-bucket/sample/VolkswagenGTIReview.mp4",
+      type: "mp4"
+    },
+    poster: "https://storage.googleapis.com/gtv-videos-bucket/sample/images/VolkswagenGTIReview.jpg",
+    duration: 596,
+    title: "VW GTI Review - Hot Hatch King",
+    author: {
+      id: "author-6",
+      name: "Car Reviews Daily",
+      avatar: "https://i.pravatar.cc/150?u=author6",
+      isVerified: true
+    },
+    stats: {
+      views: 567890,
+      likes: 45678,
+      comments: 2345,
+      shares: 567
+    },
+    isLiked: false,
+    isFollowing: true,
+    createdAt: "2024-01-05T17:35:00Z",
+    hashtags: ["cars", "vw", "gti", "hothatch"]
+  },
+  {
+    id: "video-12",
+    source: {
+      url: "https://storage.googleapis.com/gtv-videos-bucket/sample/WeAreGoingOnBullrun.mp4",
+      type: "mp4"
+    },
+    poster: "https://storage.googleapis.com/gtv-videos-bucket/sample/images/WeAreGoingOnBullrun.jpg",
+    duration: 596,
+    title: "We Are Going On Bullrun! \u{1F3CE}\uFE0F",
+    author: {
+      id: "author-7",
+      name: "Rally Life",
+      avatar: "https://i.pravatar.cc/150?u=author7",
+      isVerified: false
+    },
+    stats: {
+      views: 345678,
+      likes: 23456,
+      comments: 890,
+      shares: 234
+    },
+    isLiked: true,
+    isFollowing: false,
+    createdAt: "2024-01-04T08:50:00Z",
+    hashtags: ["rally", "racing", "bullrun", "supercars"]
+  },
+  {
+    id: "video-13",
+    source: {
+      url: "https://storage.googleapis.com/gtv-videos-bucket/sample/WhatCarCanYouGetForAGrand.mp4",
+      type: "mp4"
+    },
+    poster: "https://storage.googleapis.com/gtv-videos-bucket/sample/images/WhatCarCanYouGetForAGrand.jpg",
+    duration: 596,
+    title: "What Car Can You Get For $1000?",
+    author: {
+      id: "author-8",
+      name: "Budget Car Tips",
+      avatar: "https://i.pravatar.cc/150?u=author8",
+      isVerified: false
+    },
+    stats: {
+      views: 789012,
+      likes: 56789,
+      comments: 3456,
+      shares: 890
+    },
+    isLiked: false,
+    isFollowing: false,
+    createdAt: "2024-01-03T13:25:00Z",
+    hashtags: ["budget", "usedcars", "tips", "bargain"]
+  },
+  {
+    id: "video-14",
+    source: {
+      url: "https://storage.googleapis.com/gtv-videos-bucket/sample/BigBuckBunny.mp4",
+      type: "mp4"
+    },
+    poster: "https://storage.googleapis.com/gtv-videos-bucket/sample/images/BigBuckBunny.jpg",
+    duration: 596,
+    title: "Behind The Scenes: Big Buck Bunny",
+    author: {
+      id: "author-9",
+      name: "3D Animation Pro",
+      avatar: "https://i.pravatar.cc/150?u=author9",
+      isVerified: true
+    },
+    stats: {
+      views: 456123,
+      likes: 34512,
+      comments: 1567,
+      shares: 412
+    },
+    isLiked: false,
+    isFollowing: true,
+    createdAt: "2024-01-02T10:40:00Z",
+    hashtags: ["bts", "animation", "3d", "making"]
+  },
+  {
+    id: "video-15",
+    source: {
+      url: "https://storage.googleapis.com/gtv-videos-bucket/sample/ElephantsDream.mp4",
+      type: "mp4"
+    },
+    poster: "https://storage.googleapis.com/gtv-videos-bucket/sample/images/ElephantsDream.jpg",
+    duration: 653,
+    title: "Making of Elephant's Dream",
+    author: {
+      id: "author-9",
+      name: "3D Animation Pro",
+      avatar: "https://i.pravatar.cc/150?u=author9",
+      isVerified: true
+    },
+    stats: {
+      views: 234890,
+      likes: 19876,
+      comments: 876,
+      shares: 234
+    },
+    isLiked: true,
+    isFollowing: true,
+    createdAt: "2024-01-01T15:15:00Z",
+    hashtags: ["tutorial", "animation", "blender", "makingof"]
+  },
+  {
+    id: "video-16",
+    source: {
+      url: "https://storage.googleapis.com/gtv-videos-bucket/sample/Sintel.mp4",
+      type: "mp4"
+    },
+    poster: "https://storage.googleapis.com/gtv-videos-bucket/sample/images/Sintel.jpg",
+    duration: 888,
+    title: "Sintel Character Design Breakdown",
+    author: {
+      id: "author-10",
+      name: "Character Artist Hub",
+      avatar: "https://i.pravatar.cc/150?u=author10",
+      isVerified: true
+    },
+    stats: {
+      views: 678901,
+      likes: 45678,
+      comments: 2134,
+      shares: 567
+    },
+    isLiked: false,
+    isFollowing: false,
+    createdAt: "2023-12-31T18:00:00Z",
+    hashtags: ["characterdesign", "sintel", "tutorial", "art"]
+  },
+  {
+    id: "video-17",
+    source: {
+      url: "https://storage.googleapis.com/gtv-videos-bucket/sample/TearsOfSteel.mp4",
+      type: "mp4"
+    },
+    poster: "https://storage.googleapis.com/gtv-videos-bucket/sample/images/TearsOfSteel.jpg",
+    duration: 734,
+    title: "VFX Breakdown: Tears of Steel",
+    author: {
+      id: "author-11",
+      name: "VFX Masters",
+      avatar: "https://i.pravatar.cc/150?u=author11",
+      isVerified: true
+    },
+    stats: {
+      views: 890123,
+      likes: 67890,
+      comments: 3456,
+      shares: 789
+    },
+    isLiked: true,
+    isFollowing: true,
+    createdAt: "2023-12-30T09:30:00Z",
+    hashtags: ["vfx", "breakdown", "compositing", "cgi"]
+  },
+  {
+    id: "video-18",
+    source: {
+      url: "https://storage.googleapis.com/gtv-videos-bucket/sample/ForBiggerJoyrides.mp4",
+      type: "mp4"
+    },
+    poster: "https://storage.googleapis.com/gtv-videos-bucket/sample/images/ForBiggerJoyrides.jpg",
+    duration: 15,
+    title: "POV: Ultimate Road Trip \u{1F304}",
+    author: {
+      id: "author-12",
+      name: "Travel Vlogger",
+      avatar: "https://i.pravatar.cc/150?u=author12",
+      isVerified: false
+    },
+    stats: {
+      views: 123456,
+      likes: 9876,
+      comments: 432,
+      shares: 123
+    },
+    isLiked: false,
+    isFollowing: false,
+    createdAt: "2023-12-29T14:45:00Z",
+    hashtags: ["pov", "roadtrip", "travel", "wanderlust"]
+  },
+  {
+    id: "video-19",
+    source: {
+      url: "https://storage.googleapis.com/gtv-videos-bucket/sample/ForBiggerBlazes.mp4",
+      type: "mp4"
+    },
+    poster: "https://storage.googleapis.com/gtv-videos-bucket/sample/images/ForBiggerBlazes.jpg",
+    duration: 15,
+    title: "Satisfying Fire Compilation \u{1F525}",
+    author: {
+      id: "author-13",
+      name: "Oddly Satisfying",
+      avatar: "https://i.pravatar.cc/150?u=author13",
+      isVerified: true
+    },
+    stats: {
+      views: 567890,
+      likes: 45678,
+      comments: 1234,
+      shares: 456
+    },
+    isLiked: true,
+    isFollowing: false,
+    createdAt: "2023-12-28T11:20:00Z",
+    hashtags: ["satisfying", "fire", "asmr", "relaxing"]
+  },
+  {
+    id: "video-20",
+    source: {
+      url: "https://storage.googleapis.com/gtv-videos-bucket/sample/ForBiggerMeltdowns.mp4",
+      type: "mp4"
+    },
+    poster: "https://storage.googleapis.com/gtv-videos-bucket/sample/images/ForBiggerMeltdowns.jpg",
+    duration: 15,
+    title: "Chocolate Factory Tour \u{1F36B}",
+    author: {
+      id: "author-14",
+      name: "Food Explorer",
+      avatar: "https://i.pravatar.cc/150?u=author14",
+      isVerified: false
+    },
+    stats: {
+      views: 345678,
+      likes: 23456,
+      comments: 876,
+      shares: 234
+    },
+    isLiked: false,
+    isFollowing: true,
+    createdAt: "2023-12-27T16:55:00Z",
+    hashtags: ["food", "chocolate", "factory", "tour"]
+  }
+];
+var MockDataAdapter = class {
+  constructor(options = {}) {
+    this.videos = options.videos ?? MOCK_VIDEOS;
+    this.pageSize = options.pageSize ?? 3;
+    this.delay = options.delay ?? 300;
+  }
+  /**
+   * Fetch a page of mock videos
+   */
+  async fetchFeed(cursor) {
+    await this.simulateDelay();
+    const offset = cursor ? Number.parseInt(cursor, 10) : 0;
+    const start = offset;
+    const end = start + this.pageSize;
+    const items = this.videos.slice(start, end);
+    const hasMore = end < this.videos.length;
+    const nextCursor = hasMore ? String(end) : null;
+    return {
+      items,
+      nextCursor,
+      hasMore
+    };
+  }
+  /**
+   * Get a single video by ID
+   */
+  async getVideoDetail(id) {
+    await this.simulateDelay();
+    const video = this.videos.find((v) => v.id === id);
+    if (!video) {
+      throw new Error(`Video not found: ${id}`);
+    }
+    return video;
+  }
+  /**
+   * Prefetch videos (no-op for mock)
+   */
+  async prefetch(_ids) {
+  }
+  /**
+   * Simulate network delay
+   */
+  async simulateDelay() {
+    if (this.delay > 0) {
+      await new Promise((resolve) => setTimeout(resolve, this.delay));
+    }
+  }
+};
+
+// src/logger/mock.ts
+var LOG_LEVEL_PRIORITY = {
+  debug: 0,
+  info: 1,
+  warn: 2,
+  error: 3
+};
+var MockLoggerAdapter = class {
+  constructor(options = {}) {
+    this.buffer = [];
+    this.maxSize = options.bufferSize ?? 50;
+    this.minLevel = options.minLevel ?? "debug";
+    this.consoleOutput = options.consoleOutput ?? false;
+  }
+  /**
+   * Log a single entry to the circular buffer
+   *
+   * @param entry - Log entry to record
+   */
+  log(entry) {
+    if (LOG_LEVEL_PRIORITY[entry.level] < LOG_LEVEL_PRIORITY[this.minLevel]) {
+      return;
+    }
+    this.buffer.push(entry);
+    if (this.buffer.length > this.maxSize) {
+      this.buffer.shift();
+    }
+    if (this.consoleOutput) {
+      this.outputToConsole(entry);
+    }
+  }
+  /**
+   * Flush log entries (called on error for context)
+   *
+   * @param entries - Array of log entries to flush
+   */
+  flush(entries) {
+    if (this.consoleOutput) {
+      for (const entry of entries) {
+        this.outputToConsole(entry);
+      }
+    }
+  }
+  /**
+   * Log debug message
+   *
+   * @param message - Debug message
+   * @param context - Optional context data
+   */
+  debug(message, context) {
+    this.log({
+      level: "debug",
+      message,
+      timestamp: Date.now(),
+      context
+    });
+  }
+  /**
+   * Log info message
+   *
+   * @param message - Info message
+   * @param context - Optional context data
+   */
+  info(message, context) {
+    this.log({
+      level: "info",
+      message,
+      timestamp: Date.now(),
+      context
+    });
+  }
+  /**
+   * Log warning message
+   *
+   * @param message - Warning message
+   * @param context - Optional context data
+   */
+  warn(message, context) {
+    this.log({
+      level: "warn",
+      message,
+      timestamp: Date.now(),
+      context
+    });
+  }
+  /**
+   * Log error message
+   *
+   * @param message - Error message
+   * @param error - Optional Error object
+   * @param context - Optional context data
+   */
+  error(message, error, context) {
+    this.log({
+      level: "error",
+      message,
+      timestamp: Date.now(),
+      context,
+      stack: error?.stack
+    });
+  }
+  // ═══════════════════════════════════════════════════════════════
+  // TESTING HELPERS (not part of ILogger interface)
+  // ═══════════════════════════════════════════════════════════════
+  /**
+   * Get current buffer contents (for testing)
+   *
+   * @returns Copy of current log buffer
+   */
+  getBuffer() {
+    return [...this.buffer];
+  }
+  /**
+   * Get buffer size (for testing)
+   *
+   * @returns Number of entries in buffer
+   */
+  getBufferSize() {
+    return this.buffer.length;
+  }
+  /**
+   * Clear the buffer (for testing)
+   */
+  clearBuffer() {
+    this.buffer = [];
+  }
+  /**
+   * Get entries by level (for testing)
+   *
+   * @param level - Log level to filter by
+   * @returns Entries matching the level
+   */
+  getEntriesByLevel(level) {
+    return this.buffer.filter((entry) => entry.level === level);
+  }
+  /**
+   * Force flush and return buffer contents
+   *
+   * @returns All entries in buffer before clearing
+   */
+  forceFlush() {
+    const entries = [...this.buffer];
+    this.flush(entries);
+    this.buffer = [];
+    return entries;
+  }
+  /**
+   * Output entry to console (when consoleOutput is enabled)
+   */
+  outputToConsole(entry) {
+    const timestamp = new Date(entry.timestamp).toISOString();
+    const prefix = `[${timestamp}] [${entry.level.toUpperCase()}]`;
+    switch (entry.level) {
+      case "debug":
+        console.debug(prefix, entry.message, entry.context ?? "");
+        break;
+      case "info":
+        console.info(prefix, entry.message, entry.context ?? "");
+        break;
+      case "warn":
+        console.warn(prefix, entry.message, entry.context ?? "");
+        break;
+      case "error":
+        console.error(prefix, entry.message, entry.context ?? "", entry.stack ?? "");
+        break;
+    }
+  }
+};
+
+// src/storage/mock.ts
+var MockStorageAdapter = class {
+  constructor(options = {}) {
+    this.store = /* @__PURE__ */ new Map();
+    this.delay = options.delay ?? 0;
+    this.errorRate = options.errorRate ?? 0;
+    this.simulateQuotaError = options.simulateQuotaError ?? false;
+    if (options.initialData) {
+      for (const [key, value] of Object.entries(options.initialData)) {
+        this.store.set(key, JSON.stringify(value));
+      }
+    }
+  }
+  /**
+   * Get a value from storage
+   *
+   * @param key - Storage key
+   * @returns Promise resolving to the stored value or null if not found
+   */
+  async get(key) {
+    await this.simulateDelay();
+    this.maybeThrowError();
+    const value = this.store.get(key);
+    if (value === void 0) {
+      return null;
+    }
+    try {
+      return JSON.parse(value);
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Set a value in storage
+   *
+   * @param key - Storage key
+   * @param value - Value to store (will be serialized)
+   * @throws DOMException if simulateQuotaError is enabled
+   */
+  async set(key, value) {
+    await this.simulateDelay();
+    this.maybeThrowError();
+    if (this.simulateQuotaError) {
+      throw new DOMException("QuotaExceededError", "QuotaExceededError");
+    }
+    this.store.set(key, JSON.stringify(value));
+  }
+  /**
+   * Remove a value from storage
+   *
+   * @param key - Storage key to remove
+   */
+  async remove(key) {
+    await this.simulateDelay();
+    this.maybeThrowError();
+    this.store.delete(key);
+  }
+  /**
+   * Clear all SDK-related storage
+   */
+  async clear() {
+    await this.simulateDelay();
+    this.maybeThrowError();
+    this.store.clear();
+  }
+  /**
+   * Get all keys in storage
+   *
+   * @returns Promise resolving to array of storage keys
+   */
+  async keys() {
+    await this.simulateDelay();
+    this.maybeThrowError();
+    return Array.from(this.store.keys());
+  }
+  // ═══════════════════════════════════════════════════════════════
+  // TESTING HELPERS (not part of IStorage interface)
+  // ═══════════════════════════════════════════════════════════════
+  /**
+   * Get storage size (for testing)
+   *
+   * @returns Number of entries in storage
+   */
+  getSize() {
+    return this.store.size;
+  }
+  /**
+   * Check if key exists (for testing)
+   *
+   * @param key - Storage key to check
+   * @returns Whether key exists
+   */
+  has(key) {
+    return this.store.has(key);
+  }
+  /**
+   * Get raw storage Map (for testing)
+   *
+   * @returns Copy of internal storage map
+   */
+  getRawStore() {
+    return new Map(this.store);
+  }
+  /**
+   * Simulate network/processing delay
+   */
+  async simulateDelay() {
+    if (this.delay > 0) {
+      await new Promise((resolve) => setTimeout(resolve, this.delay));
+    }
+  }
+  /**
+   * Maybe throw error based on error rate
+   */
+  maybeThrowError() {
+    if (this.errorRate > 0 && Math.random() < this.errorRate) {
+      throw new Error("Storage operation failed");
+    }
+  }
+};
+var SESSION_SNAPSHOT_KEY = "sv-session-snapshot";
+var MockSessionStorageAdapter = class extends MockStorageAdapter {
+  constructor(options = {}) {
+    super(options);
+    this.maxSnapshotAge = options.maxSnapshotAge ?? 24 * 60 * 60 * 1e3;
+  }
+  /**
+   * Save session snapshot for state restoration
+   *
+   * @param snapshot - Session state to persist
+   */
+  async saveSnapshot(snapshot) {
+    await this.set(SESSION_SNAPSHOT_KEY, snapshot);
+  }
+  /**
+   * Load the most recent session snapshot
+   *
+   * @returns Promise resolving to snapshot or null if none exists
+   */
+  async loadSnapshot() {
+    const snapshot = await this.get(SESSION_SNAPSHOT_KEY);
+    if (!snapshot) {
+      return null;
+    }
+    const age = Date.now() - snapshot.savedAt;
+    if (age > this.maxSnapshotAge) {
+      await this.clearSnapshot();
+      return null;
+    }
+    return snapshot;
+  }
+  /**
+   * Clear session snapshot
+   */
+  async clearSnapshot() {
+    await this.remove(SESSION_SNAPSHOT_KEY);
+  }
+  // ═══════════════════════════════════════════════════════════════
+  // TESTING HELPERS
+  // ═══════════════════════════════════════════════════════════════
+  /**
+   * Check if snapshot exists (for testing)
+   *
+   * @returns Whether snapshot exists
+   */
+  hasSnapshot() {
+    return this.has(SESSION_SNAPSHOT_KEY);
+  }
+  /**
+   * Get snapshot age in ms (for testing)
+   *
+   * @returns Age in ms or null if no snapshot
+   */
+  async getSnapshotAge() {
+    const snapshot = await this.get(SESSION_SNAPSHOT_KEY);
+    if (!snapshot) {
+      return null;
+    }
+    return Date.now() - snapshot.savedAt;
+  }
+};
+
+// src/interaction/mock.ts
+var commentIdCounter = 0;
+var MockInteractionAdapter = class {
+  constructor(options = {}) {
+    this.likedVideos = /* @__PURE__ */ new Set();
+    this.followedAuthors = /* @__PURE__ */ new Set();
+    this.likedComments = /* @__PURE__ */ new Set();
+    this.comments = /* @__PURE__ */ new Map();
+    this.delay = options.delay ?? 0;
+    this.errorRate = options.errorRate ?? 0;
+    this.failLike = options.failLike ?? false;
+    this.failUnlike = options.failUnlike ?? false;
+    this.failFollow = options.failFollow ?? false;
+    this.failUnfollow = options.failUnfollow ?? false;
+    this.failComment = options.failComment ?? false;
+    this.failDeleteComment = options.failDeleteComment ?? false;
+    if (options.initialLikedVideos) {
+      for (const id of options.initialLikedVideos) {
+        this.likedVideos.add(id);
+      }
+    }
+    if (options.initialFollowedAuthors) {
+      for (const id of options.initialFollowedAuthors) {
+        this.followedAuthors.add(id);
+      }
+    }
+    if (options.initialLikedComments) {
+      for (const id of options.initialLikedComments) {
+        this.likedComments.add(id);
+      }
+    }
+  }
+  /**
+   * Like a video
+   *
+   * @param videoId - ID of the video to like
+   * @throws Error if failLike is enabled or random error occurs
+   */
+  async like(videoId) {
+    await this.simulateDelay();
+    this.maybeThrowError();
+    if (this.failLike) {
+      throw new Error("Like failed - server error");
+    }
+    this.likedVideos.add(videoId);
+  }
+  /**
+   * Remove like from a video
+   *
+   * @param videoId - ID of the video to unlike
+   * @throws Error if failUnlike is enabled or random error occurs
+   */
+  async unlike(videoId) {
+    await this.simulateDelay();
+    this.maybeThrowError();
+    if (this.failUnlike) {
+      throw new Error("Unlike failed - server error");
+    }
+    this.likedVideos.delete(videoId);
+  }
+  /**
+   * Follow a video author
+   *
+   * @param authorId - ID of the author to follow
+   * @throws Error if failFollow is enabled or random error occurs
+   */
+  async follow(authorId) {
+    await this.simulateDelay();
+    this.maybeThrowError();
+    if (this.failFollow) {
+      throw new Error("Follow failed - server error");
+    }
+    this.followedAuthors.add(authorId);
+  }
+  /**
+   * Unfollow a video author
+   *
+   * @param authorId - ID of the author to unfollow
+   * @throws Error if failUnfollow is enabled or random error occurs
+   */
+  async unfollow(authorId) {
+    await this.simulateDelay();
+    this.maybeThrowError();
+    if (this.failUnfollow) {
+      throw new Error("Unfollow failed - server error");
+    }
+    this.followedAuthors.delete(authorId);
+  }
+  /**
+   * Post a comment on a video
+   *
+   * @param _videoId - ID of the video to comment on (unused in mock)
+   * @param text - Comment text content
+   * @returns Promise resolving to the created comment
+   * @throws Error if failComment is enabled or random error occurs
+   */
+  async comment(_videoId, text) {
+    await this.simulateDelay();
+    this.maybeThrowError();
+    if (this.failComment) {
+      throw new Error("Comment failed - server error");
+    }
+    const newComment = {
+      id: `comment-${++commentIdCounter}`,
+      text,
+      author: {
+        id: "mock-user",
+        name: "Mock User",
+        avatar: "https://i.pravatar.cc/150?u=mock",
+        isVerified: false
+      },
+      likes: 0,
+      isLiked: false,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      replyCount: 0
+    };
+    this.comments.set(newComment.id, newComment);
+    return newComment;
+  }
+  /**
+   * Delete a comment
+   *
+   * @param commentId - ID of the comment to delete
+   * @throws Error if comment not found, failDeleteComment is enabled, or random error occurs
+   */
+  async deleteComment(commentId) {
+    await this.simulateDelay();
+    this.maybeThrowError();
+    if (this.failDeleteComment) {
+      throw new Error("Delete comment failed - server error");
+    }
+    if (!this.comments.has(commentId)) {
+      throw new Error(`Comment not found: ${commentId}`);
+    }
+    this.comments.delete(commentId);
+    this.likedComments.delete(commentId);
+  }
+  /**
+   * Like a comment
+   *
+   * @param commentId - ID of the comment to like
+   */
+  async likeComment(commentId) {
+    await this.simulateDelay();
+    this.maybeThrowError();
+    this.likedComments.add(commentId);
+    const comment = this.comments.get(commentId);
+    if (comment) {
+      comment.isLiked = true;
+      comment.likes += 1;
+    }
+  }
+  /**
+   * Unlike a comment
+   *
+   * @param commentId - ID of the comment to unlike
+   */
+  async unlikeComment(commentId) {
+    await this.simulateDelay();
+    this.maybeThrowError();
+    this.likedComments.delete(commentId);
+    const comment = this.comments.get(commentId);
+    if (comment?.isLiked) {
+      comment.isLiked = false;
+      comment.likes = Math.max(0, comment.likes - 1);
+    }
+  }
+  /**
+   * Share a video (tracking only)
+   *
+   * @param _videoId - ID of the video being shared
+   * @param _platform - Optional platform identifier
+   */
+  async share(_videoId, _platform) {
+    await this.simulateDelay();
+    this.maybeThrowError();
+  }
+  /**
+   * Report a video
+   *
+   * @param _videoId - ID of the video to report
+   * @param _reason - Report reason code
+   * @param _description - Optional additional description
+   */
+  async report(_videoId, _reason, _description) {
+    await this.simulateDelay();
+    this.maybeThrowError();
+  }
+  // ═══════════════════════════════════════════════════════════════
+  // TESTING HELPERS (not part of IInteraction interface)
+  // ═══════════════════════════════════════════════════════════════
+  /**
+   * Check if video is liked (for testing)
+   *
+   * @param videoId - Video ID to check
+   * @returns Whether video is liked
+   */
+  isVideoLiked(videoId) {
+    return this.likedVideos.has(videoId);
+  }
+  /**
+   * Check if author is followed (for testing)
+   *
+   * @param authorId - Author ID to check
+   * @returns Whether author is followed
+   */
+  isAuthorFollowed(authorId) {
+    return this.followedAuthors.has(authorId);
+  }
+  /**
+   * Check if comment is liked (for testing)
+   *
+   * @param commentId - Comment ID to check
+   * @returns Whether comment is liked
+   */
+  isCommentLiked(commentId) {
+    return this.likedComments.has(commentId);
+  }
+  /**
+   * Get all liked video IDs (for testing)
+   *
+   * @returns Array of liked video IDs
+   */
+  getLikedVideos() {
+    return Array.from(this.likedVideos);
+  }
+  /**
+   * Get all followed author IDs (for testing)
+   *
+   * @returns Array of followed author IDs
+   */
+  getFollowedAuthors() {
+    return Array.from(this.followedAuthors);
+  }
+  /**
+   * Get all comments (for testing)
+   *
+   * @returns Map of comment ID to Comment
+   */
+  getComments() {
+    return new Map(this.comments);
+  }
+  /**
+   * Get a specific comment (for testing)
+   *
+   * @param commentId - Comment ID
+   * @returns Comment or undefined
+   */
+  getComment(commentId) {
+    return this.comments.get(commentId);
+  }
+  /**
+   * Reset all state (for testing)
+   */
+  reset() {
+    this.likedVideos.clear();
+    this.followedAuthors.clear();
+    this.likedComments.clear();
+    this.comments.clear();
+  }
+  /**
+   * Simulate network/processing delay
+   */
+  async simulateDelay() {
+    if (this.delay > 0) {
+      await new Promise((resolve) => setTimeout(resolve, this.delay));
+    }
+  }
+  /**
+   * Maybe throw error based on error rate
+   */
+  maybeThrowError() {
+    if (this.errorRate > 0 && Math.random() < this.errorRate) {
+      throw new Error("Interaction failed - random error");
+    }
+  }
+};
+
+// src/analytics/mock.ts
+var MockAnalyticsAdapter = class {
+  constructor(options = {}) {
+    this.eventQueue = [];
+    this.flushedEvents = [];
+    this.userId = null;
+    this.userProperties = {};
+    this.batchSize = options.batchSize ?? 10;
+    this.autoFlush = options.autoFlush ?? false;
+    this.flushDelay = options.flushDelay ?? 0;
+    this.errorRate = options.errorRate ?? 0;
+  }
+  /**
+   * Track an analytics event
+   *
+   * @param event - Event to track
+   */
+  track(event) {
+    this.eventQueue.push(event);
+    if (this.autoFlush && this.eventQueue.length >= this.batchSize) {
+      this.flush().catch(() => {
+      });
+    }
+  }
+  /**
+   * Flush queued events immediately
+   *
+   * @returns Promise that resolves when flush is complete
+   */
+  async flush() {
+    if (this.eventQueue.length === 0) {
+      return;
+    }
+    if (this.flushDelay > 0) {
+      await new Promise((resolve) => setTimeout(resolve, this.flushDelay));
+    }
+    if (this.errorRate > 0 && Math.random() < this.errorRate) {
+      return;
+    }
+    const events = [...this.eventQueue];
+    this.flushedEvents.push(events);
+    this.eventQueue = [];
+  }
+  /**
+   * Track video view duration
+   *
+   * @param videoId - ID of the video
+   * @param duration - Watch duration in seconds
+   * @param totalDuration - Total video duration in seconds
+   */
+  trackViewDuration(videoId, duration, totalDuration) {
+    this.track({
+      type: "video_view",
+      videoId,
+      timestamp: Date.now(),
+      data: {
+        duration,
+        totalDuration,
+        percentage: totalDuration > 0 ? duration / totalDuration * 100 : 0
+      }
+    });
+  }
+  /**
+   * Track video completion
+   *
+   * @param videoId - ID of the video
+   * @param watchTime - Total time watched in seconds
+   * @param loops - Number of times video looped
+   */
+  trackCompletion(videoId, watchTime, loops) {
+    this.track({
+      type: "video_complete",
+      videoId,
+      timestamp: Date.now(),
+      data: {
+        watchTime,
+        loops
+      }
+    });
+  }
+  /**
+   * Set user context for analytics
+   *
+   * @param userId - Optional user ID (null for anonymous)
+   * @param properties - Optional user properties
+   */
+  setUser(userId, properties) {
+    this.userId = userId;
+    this.userProperties = properties ?? {};
+  }
+  /**
+   * Get current queue size
+   *
+   * @returns Number of events in queue
+   */
+  getQueueSize() {
+    return this.eventQueue.length;
+  }
+  // ═══════════════════════════════════════════════════════════════
+  // TESTING HELPERS (not part of IAnalytics interface)
+  // ═══════════════════════════════════════════════════════════════
+  /**
+   * Get all tracked events (current queue)
+   *
+   * @returns Copy of current event queue
+   */
+  getTrackedEvents() {
+    return [...this.eventQueue];
+  }
+  /**
+   * Get all flushed event batches
+   *
+   * @returns Array of flushed event batches
+   */
+  getFlushedBatches() {
+    return [...this.flushedEvents];
+  }
+  /**
+   * Get total flushed events count
+   *
+   * @returns Total number of flushed events
+   */
+  getTotalFlushedCount() {
+    return this.flushedEvents.reduce((sum, batch) => sum + batch.length, 0);
+  }
+  /**
+   * Get events by type (from current queue)
+   *
+   * @param type - Event type to filter by
+   * @returns Events matching the type
+   */
+  getEventsByType(type) {
+    return this.eventQueue.filter((event) => event.type === type);
+  }
+  /**
+   * Get events for a specific video (from current queue)
+   *
+   * @param videoId - Video ID to filter by
+   * @returns Events for the video
+   */
+  getEventsByVideoId(videoId) {
+    return this.eventQueue.filter((event) => event.videoId === videoId);
+  }
+  /**
+   * Get current user context
+   *
+   * @returns User ID and properties
+   */
+  getUserContext() {
+    return {
+      userId: this.userId,
+      properties: { ...this.userProperties }
+    };
+  }
+  /**
+   * Check if specific event type was tracked
+   *
+   * @param type - Event type to check
+   * @returns Whether event type was tracked
+   */
+  hasTracked(type) {
+    return this.eventQueue.some((event) => event.type === type);
+  }
+  /**
+   * Get last tracked event
+   *
+   * @returns Last event or undefined
+   */
+  getLastEvent() {
+    return this.eventQueue[this.eventQueue.length - 1];
+  }
+  /**
+   * Reset all state
+   */
+  reset() {
+    this.eventQueue = [];
+    this.flushedEvents = [];
+    this.userId = null;
+    this.userProperties = {};
+  }
+  /**
+   * Clear only the event queue (keep flushed history)
+   */
+  clearQueue() {
+    this.eventQueue = [];
+  }
+};
+
+// src/network/mock.ts
+var MockNetworkAdapter = class {
+  constructor(options = {}) {
+    this.listeners = /* @__PURE__ */ new Set();
+    this.currentType = options.initialType ?? "wifi";
+    this.downlink = options.initialDownlink ?? 10;
+    this.rtt = options.initialRtt ?? 50;
+    this.metered = options.isMetered ?? false;
+    this.online = options.isOnline ?? true;
+  }
+  async getNetworkType() {
+    return this.currentType;
+  }
+  async getNetworkQuality() {
+    return {
+      type: this.currentType,
+      downlink: this.downlink,
+      rtt: this.rtt,
+      isMetered: this.metered
+    };
+  }
+  onNetworkChange(callback) {
+    this.listeners.add(callback);
+    return () => {
+      this.listeners.delete(callback);
+    };
+  }
+  async isOnline() {
+    return this.online;
+  }
+  // ═══════════════════════════════════════════════════════════════
+  // MOCK CONTROL METHODS (for testing)
+  // ═══════════════════════════════════════════════════════════════
+  /**
+   * Set network type and notify listeners
+   */
+  setNetworkType(type) {
+    if (this.currentType !== type) {
+      this.currentType = type;
+      this.notifyListeners();
+    }
+  }
+  /**
+   * Set downlink speed in Mbps
+   */
+  setDownlink(mbps) {
+    this.downlink = mbps;
+  }
+  /**
+   * Set RTT in milliseconds
+   */
+  setRtt(ms) {
+    this.rtt = ms;
+  }
+  /**
+   * Set metered status (e.g., cellular data)
+   */
+  setMetered(metered) {
+    this.metered = metered;
+  }
+  /**
+   * Set online/offline status
+   */
+  setOnline(online) {
+    this.online = online;
+    if (!online) {
+      this.currentType = "offline";
+      this.notifyListeners();
+    }
+  }
+  /**
+   * Simulate network change sequence for testing
+   */
+  async simulateNetworkChanges(sequence, delayMs = 100) {
+    for (const type of sequence) {
+      await new Promise((resolve) => setTimeout(resolve, delayMs));
+      this.setNetworkType(type);
+    }
+  }
+  /**
+   * Reset to default state
+   */
+  reset() {
+    this.currentType = "wifi";
+    this.downlink = 10;
+    this.rtt = 50;
+    this.metered = false;
+    this.online = true;
+    this.listeners.clear();
+  }
+  notifyListeners() {
+    for (const listener of this.listeners) {
+      listener(this.currentType);
+    }
+  }
+};
+
+// src/video-loader/mock.ts
+var MockVideoLoader = class {
+  constructor(options = {}) {
+    this.preloads = /* @__PURE__ */ new Map();
+    this.preloadDelayMs = options.preloadDelayMs ?? 100;
+    this.shouldSucceed = options.shouldSucceed ?? true;
+    this.errorMessage = options.errorMessage ?? "Mock preload failed";
+    this.bytesPerPreload = options.bytesPerPreload ?? 5e5;
+  }
+  // ═══════════════════════════════════════════════════════════════
+  // IVideoLoader Implementation
+  // ═══════════════════════════════════════════════════════════════
+  async preload(_videoId, _source, _config) {
+    const abortController = new AbortController();
+    this.preloads.set(_videoId, {
+      status: "loading",
+      loadedBytes: 0,
+      abortController
+    });
+    try {
+      await new Promise((resolve, reject) => {
+        const timeoutId = setTimeout(resolve, this.preloadDelayMs);
+        abortController.signal.addEventListener("abort", () => {
+          clearTimeout(timeoutId);
+          reject(new Error("Preload cancelled"));
+        });
+      });
+      if (abortController.signal.aborted) {
+        return {
+          videoId: _videoId,
+          status: "idle",
+          loadedBytes: 0
+        };
+      }
+      if (this.shouldSucceed) {
+        this.preloads.set(_videoId, {
+          status: "ready",
+          loadedBytes: this.bytesPerPreload
+        });
+        return {
+          videoId: _videoId,
+          status: "ready",
+          loadedBytes: this.bytesPerPreload
+        };
+      }
+      const error = new Error(this.errorMessage);
+      this.preloads.set(_videoId, {
+        status: "error",
+        loadedBytes: 0,
+        error
+      });
+      return {
+        videoId: _videoId,
+        status: "error",
+        error
+      };
+    } catch (e) {
+      if (e instanceof Error && e.message === "Preload cancelled") {
+        this.preloads.set(_videoId, {
+          status: "idle",
+          loadedBytes: 0
+        });
+        return {
+          videoId: _videoId,
+          status: "idle",
+          loadedBytes: 0
+        };
+      }
+      throw e;
+    }
+  }
+  cancelPreload(videoId) {
+    const state = this.preloads.get(videoId);
+    if (state?.abortController) {
+      state.abortController.abort();
+    }
+    this.preloads.set(videoId, {
+      status: "idle",
+      loadedBytes: 0
+    });
+  }
+  isPreloaded(videoId) {
+    return this.preloads.get(videoId)?.status === "ready";
+  }
+  getPreloadStatus(videoId) {
+    return this.preloads.get(videoId)?.status ?? "idle";
+  }
+  clearPreload(videoId) {
+    this.preloads.delete(videoId);
+  }
+  clearAll() {
+    this.preloads.clear();
+  }
+  getTotalPreloadedBytes() {
+    let total = 0;
+    for (const state of this.preloads.values()) {
+      if (state.status === "ready") {
+        total += state.loadedBytes;
+      }
+    }
+    return total;
+  }
+  // ═══════════════════════════════════════════════════════════════
+  // MOCK CONTROL METHODS (for testing)
+  // ═══════════════════════════════════════════════════════════════
+  /**
+   * Set whether preloads should succeed
+   */
+  setShouldSucceed(shouldSucceed) {
+    this.shouldSucceed = shouldSucceed;
+  }
+  /**
+   * Set preload delay in milliseconds
+   */
+  setPreloadDelay(ms) {
+    this.preloadDelayMs = ms;
+  }
+  /**
+   * Set error message for failed preloads
+   */
+  setErrorMessage(message) {
+    this.errorMessage = message;
+  }
+  /**
+   * Get all tracked preloads (for testing assertions)
+   */
+  getPreloads() {
+    return new Map(this.preloads);
+  }
+  /**
+   * Reset all state
+   */
+  reset() {
+    this.preloads.clear();
+    this.shouldSucceed = true;
+    this.preloadDelayMs = 100;
+    this.bytesPerPreload = 5e5;
+    this.errorMessage = "Mock preload failed";
+  }
+};
+var MockPosterLoader = class {
+  constructor(preloadDelayMs = 50) {
+    this.posterCache = /* @__PURE__ */ new Set();
+    this.preloadDelayMs = preloadDelayMs;
+  }
+  async preload(url) {
+    await new Promise((resolve) => setTimeout(resolve, this.preloadDelayMs));
+    this.posterCache.add(url);
+  }
+  isCached(url) {
+    return this.posterCache.has(url);
+  }
+  clearCache() {
+    this.posterCache.clear();
+  }
+  /**
+   * Set preload delay in milliseconds
+   */
+  setPreloadDelay(ms) {
+    this.preloadDelayMs = ms;
+  }
+  /**
+   * Reset all state
+   */
+  reset() {
+    this.posterCache.clear();
+    this.preloadDelayMs = 50;
+  }
+};
+
+// src/preset/adapters/RESTAnalyticsAdapter.ts
+var DEFAULT_BATCH_SIZE = 10;
+var DEFAULT_FLUSH_INTERVAL = 3e4;
+var RESTAnalyticsAdapter = class {
+  constructor(config) {
+    // Event queue
+    this.queue = [];
+    // Flush interval timer
+    this.flushTimer = null;
+    // User context
+    this.userId = null;
+    this.userProperties = {};
+    this.httpClient = config.httpClient;
+    this.endpoint = config.endpoints.batch;
+    this.batchSize = config.batchSize ?? DEFAULT_BATCH_SIZE;
+    this.logger = config.logger;
+    const interval = config.flushInterval ?? DEFAULT_FLUSH_INTERVAL;
+    this.flushTimer = setInterval(() => this.flush(), interval);
+  }
+  /**
+   * Track an analytics event
+   * Fire-and-forget - doesn't throw
+   */
+  track(event) {
+    try {
+      const enrichedEvent = {
+        ...event,
+        userId: this.userId,
+        userProperties: this.userProperties
+      };
+      this.queue.push(enrichedEvent);
+      if (this.queue.length >= this.batchSize) {
+        this.flush().catch(() => {
+        });
+      }
+    } catch (error) {
+      this.logger?.warn("[RESTAnalyticsAdapter] Failed to track event", { error });
+    }
+  }
+  /**
+   * Flush queued events
+   */
+  async flush() {
+    if (this.queue.length === 0) {
+      return;
+    }
+    const events = [...this.queue];
+    this.queue = [];
+    try {
+      if (this.trySendBeacon(events)) {
+        this.logger?.debug("[RESTAnalyticsAdapter] Events sent via sendBeacon", {
+          count: events.length
+        });
+        return;
+      }
+      await this.httpClient.request({
+        method: "POST",
+        path: this.endpoint,
+        body: { events }
+      });
+      this.logger?.debug("[RESTAnalyticsAdapter] Events sent via HTTP", {
+        count: events.length
+      });
+    } catch (error) {
+      if (this.queue.length < this.batchSize * 3) {
+        this.queue = [...events, ...this.queue];
+      }
+      this.logger?.warn("[RESTAnalyticsAdapter] Failed to flush events", { error });
+    }
+  }
+  /**
+   * Track video view duration (heartbeat)
+   */
+  trackViewDuration(videoId, duration, totalDuration) {
+    this.track({
+      type: "video_view",
+      videoId,
+      timestamp: Date.now(),
+      data: {
+        watchTime: duration,
+        totalDuration,
+        percentage: totalDuration > 0 ? Math.round(duration / totalDuration * 100) : 0
+      }
+    });
+  }
+  /**
+   * Track video completion
+   */
+  trackCompletion(videoId, watchTime, loops) {
+    this.track({
+      type: "video_complete",
+      videoId,
+      timestamp: Date.now(),
+      data: {
+        watchTime,
+        loops
+      }
+    });
+  }
+  /**
+   * Set user context
+   */
+  setUser(userId, properties) {
+    this.userId = userId;
+    this.userProperties = properties ?? {};
+  }
+  /**
+   * Get current queue size (for debugging)
+   */
+  getQueueSize() {
+    return this.queue.length;
+  }
+  /**
+   * Cleanup - stop flush interval
+   */
+  destroy() {
+    if (this.flushTimer) {
+      clearInterval(this.flushTimer);
+      this.flushTimer = null;
+    }
+    this.flush().catch(() => {
+    });
+  }
+  /**
+   * Try to send via sendBeacon (for reliability on page unload)
+   */
+  trySendBeacon(events) {
+    if (typeof navigator === "undefined" || !navigator.sendBeacon) {
+      return false;
+    }
+    try {
+      const url = this.buildFullUrl();
+      const data = JSON.stringify({ events });
+      const blob = new Blob([data], { type: "application/json" });
+      return navigator.sendBeacon(url, blob);
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Build full URL for sendBeacon
+   */
+  buildFullUrl() {
+    return this.endpoint.startsWith("http") ? this.endpoint : `${window.location.origin}${this.endpoint}`;
+  }
+};
+function createNoOpAnalyticsAdapter() {
+  return {
+    track: () => {
+    },
+    flush: async () => {
+    },
+    trackViewDuration: () => {
+    },
+    trackCompletion: () => {
+    },
+    setUser: () => {
+    },
+    getQueueSize: () => 0
+  };
+}
+
+// src/preset/adapters/RESTDataAdapter.ts
+var RESTDataAdapter = class {
+  constructor(config) {
+    this.httpClient = config.httpClient;
+    this.endpoints = config.endpoints;
+    this.transforms = config.transforms;
+    this.pagination = config.pagination ?? { cursor: "cursor", limit: "limit" };
+    this.logger = config.logger;
+  }
+  /**
+   * Fetch feed with pagination
+   */
+  async fetchFeed(cursor) {
+    try {
+      const params = {
+        [this.pagination.cursor]: cursor ?? null,
+        [this.pagination.limit]: 10
+      };
+      const response = await this.httpClient.request({
+        method: "GET",
+        path: this.endpoints.list,
+        params
+      });
+      const feedData = this.transforms.feedResponse(response);
+      const items = feedData.items.map((item) => {
+        try {
+          return this.transforms.videoItem(item);
+        } catch (error) {
+          this.logger?.error("[RESTDataAdapter] Failed to transform video item", error);
+          return this.createFallbackVideoItem(item);
+        }
+      });
+      return {
+        items,
+        nextCursor: feedData.nextCursor,
+        hasMore: feedData.hasMore
+      };
+    } catch (error) {
+      this.logger?.error("[RESTDataAdapter] fetchFeed failed", error);
+      throw error;
+    }
+  }
+  /**
+   * Get video detail by ID
+   */
+  async getVideoDetail(id) {
+    try {
+      const response = await this.httpClient.request({
+        method: "GET",
+        path: this.endpoints.detail,
+        pathParams: { id }
+      });
+      const videoData = this.unwrapResponse(response);
+      return this.transforms.videoItem(videoData);
+    } catch (error) {
+      this.logger?.error("[RESTDataAdapter] getVideoDetail failed", error);
+      throw error;
+    }
+  }
+  /**
+   * Optional: Prefetch videos
+   * This is a no-op by default, can be overridden if API supports batch fetch
+   */
+  async prefetch(ids) {
+    this.logger?.debug("[RESTDataAdapter] prefetch called", { ids });
+  }
+  /**
+   * Unwrap response if wrapped in data/result field
+   */
+  unwrapResponse(response) {
+    if (!response || typeof response !== "object") {
+      return response;
+    }
+    const obj = response;
+    if (obj.data !== void 0) return obj.data;
+    if (obj.result !== void 0) return obj.result;
+    if (obj.video !== void 0) return obj.video;
+    if (obj.item !== void 0) return obj.item;
+    return response;
+  }
+  /**
+   * Create fallback video item when transform fails
+   */
+  createFallbackVideoItem(data) {
+    const obj = data ?? {};
+    return {
+      id: String(obj.id ?? obj.video_id ?? `fallback-${Date.now()}`),
+      source: {
+        url: String(obj.video_url ?? obj.url ?? ""),
+        type: "mp4"
+      },
+      duration: 0,
+      author: {
+        id: "unknown",
+        name: "Unknown"
+      },
+      stats: {
+        views: 0,
+        likes: 0,
+        comments: 0,
+        shares: 0
+      },
+      isLiked: false,
+      isFollowing: false,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+};
+
+// src/preset/adapters/RESTInteractionAdapter.ts
+var RESTInteractionAdapter = class {
+  constructor(config) {
+    this.httpClient = config.httpClient;
+    this.endpoints = config.endpoints;
+    this.logger = config.logger;
+  }
+  /**
+   * Like a video
+   */
+  async like(videoId) {
+    try {
+      await this.httpClient.request({
+        method: "POST",
+        path: this.endpoints.like,
+        pathParams: { id: videoId }
+      });
+    } catch (error) {
+      this.logger?.error("[RESTInteractionAdapter] like failed", error);
+      throw error;
+    }
+  }
+  /**
+   * Unlike a video
+   */
+  async unlike(videoId) {
+    try {
+      await this.httpClient.request({
+        method: "DELETE",
+        path: this.endpoints.unlike,
+        pathParams: { id: videoId }
+      });
+    } catch (error) {
+      this.logger?.error("[RESTInteractionAdapter] unlike failed", error);
+      throw error;
+    }
+  }
+  /**
+   * Follow an author
+   */
+  async follow(authorId) {
+    try {
+      await this.httpClient.request({
+        method: "POST",
+        path: this.endpoints.follow,
+        pathParams: { id: authorId }
+      });
+    } catch (error) {
+      this.logger?.error("[RESTInteractionAdapter] follow failed", error);
+      throw error;
+    }
+  }
+  /**
+   * Unfollow an author
+   */
+  async unfollow(authorId) {
+    try {
+      await this.httpClient.request({
+        method: "DELETE",
+        path: this.endpoints.unfollow,
+        pathParams: { id: authorId }
+      });
+    } catch (error) {
+      this.logger?.error("[RESTInteractionAdapter] unfollow failed", error);
+      throw error;
+    }
+  }
+  /**
+   * Post a comment
+   */
+  async comment(videoId, text) {
+    try {
+      const response = await this.httpClient.request({
+        method: "POST",
+        path: this.endpoints.comment,
+        pathParams: { id: videoId },
+        body: { text }
+      });
+      return this.transformComment(response);
+    } catch (error) {
+      this.logger?.error("[RESTInteractionAdapter] comment failed", error);
+      throw error;
+    }
+  }
+  /**
+   * Delete a comment
+   */
+  async deleteComment(commentId) {
+    try {
+      await this.httpClient.request({
+        method: "DELETE",
+        path: this.endpoints.deleteComment,
+        pathParams: { id: commentId }
+      });
+    } catch (error) {
+      this.logger?.error("[RESTInteractionAdapter] deleteComment failed", error);
+      throw error;
+    }
+  }
+  /**
+   * Like a comment
+   */
+  async likeComment(commentId) {
+    this.logger?.debug("[RESTInteractionAdapter] likeComment not implemented", { commentId });
+  }
+  /**
+   * Unlike a comment
+   */
+  async unlikeComment(commentId) {
+    this.logger?.debug("[RESTInteractionAdapter] unlikeComment not implemented", { commentId });
+  }
+  /**
+   * Share a video (optional tracking)
+   */
+  async share(videoId, platform) {
+    if (!this.endpoints.share) {
+      this.logger?.debug("[RESTInteractionAdapter] share endpoint not configured");
+      return;
+    }
+    try {
+      await this.httpClient.request({
+        method: "POST",
+        path: this.endpoints.share,
+        pathParams: { id: videoId },
+        body: platform ? { platform } : void 0
+      });
+    } catch (error) {
+      this.logger?.warn("[RESTInteractionAdapter] share tracking failed", { error });
+    }
+  }
+  /**
+   * Transform API comment response to Comment type
+   */
+  transformComment(response) {
+    const obj = this.unwrapResponse(response);
+    const user = obj.user ?? {};
+    const author = obj.author ?? {};
+    return {
+      id: String(obj.id ?? obj.comment_id ?? ""),
+      text: String(obj.text ?? obj.content ?? obj.body ?? ""),
+      author: {
+        id: String(user.id ?? author.id ?? obj.user_id ?? ""),
+        name: String(user.display_name ?? user.name ?? author.name ?? "Unknown"),
+        avatar: user.avatar ?? author.avatar
+      },
+      likes: Number(obj.like_count ?? obj.likes ?? 0),
+      isLiked: Boolean(obj.is_liked ?? obj.liked ?? false),
+      createdAt: String(obj.created_at ?? obj.createdAt ?? (/* @__PURE__ */ new Date()).toISOString()),
+      replyCount: Number(obj.reply_count ?? obj.replies ?? 0)
+    };
+  }
+  /**
+   * Unwrap response if wrapped
+   */
+  unwrapResponse(response) {
+    if (!response || typeof response !== "object") return response;
+    const obj = response;
+    if (obj.data !== void 0) return obj.data;
+    if (obj.comment !== void 0) return obj.comment;
+    if (obj.result !== void 0) return obj.result;
+    return response;
+  }
+};
+
+// src/preset/types.ts
+var DEFAULT_RETRY_CONFIG = {
+  maxRetries: 3,
+  retryDelay: 1e3,
+  retryOn: [408, 429, 500, 502, 503, 504],
+  exponentialBackoff: true
+};
+var DEFAULT_REQUEST_CONFIG = {
+  defaultParams: {},
+  timeout: 1e4,
+  retry: DEFAULT_RETRY_CONFIG,
+  pagination: {
+    cursor: "cursor",
+    limit: "limit"
+  }
+};
+
+// src/preset/http/client.ts
+var RetryableError = class extends Error {
+  constructor(status, message) {
+    super(message);
+    this.status = status;
+    this.name = "RetryableError";
+  }
+};
+var HttpError = class extends Error {
+  constructor(status, message, body) {
+    super(message);
+    this.status = status;
+    this.body = body;
+    this.name = "HttpError";
+  }
+};
+var HttpClient = class {
+  constructor(config) {
+    // Token refresh deduplication
+    this.isRefreshing = false;
+    this.refreshPromise = null;
+    this.config = config;
+    const mergedRetry = {
+      maxRetries: config.request?.retry?.maxRetries ?? DEFAULT_RETRY_CONFIG.maxRetries,
+      retryDelay: config.request?.retry?.retryDelay ?? DEFAULT_RETRY_CONFIG.retryDelay,
+      retryOn: config.request?.retry?.retryOn ?? DEFAULT_RETRY_CONFIG.retryOn,
+      exponentialBackoff: config.request?.retry?.exponentialBackoff ?? DEFAULT_RETRY_CONFIG.exponentialBackoff
+    };
+    this.requestConfig = {
+      defaultParams: config.request?.defaultParams ?? DEFAULT_REQUEST_CONFIG.defaultParams,
+      timeout: config.request?.timeout ?? DEFAULT_REQUEST_CONFIG.timeout,
+      retry: mergedRetry,
+      pagination: {
+        cursor: config.request?.pagination?.cursor ?? DEFAULT_REQUEST_CONFIG.pagination.cursor,
+        limit: config.request?.pagination?.limit ?? DEFAULT_REQUEST_CONFIG.pagination.limit
+      }
+    };
+    this.retryConfig = mergedRetry;
+  }
+  /**
+   * Make HTTP request with auth and retry
+   */
+  async request(options) {
+    const { method, path, params, body, pathParams } = options;
+    let url = this.buildUrl(path, pathParams);
+    if (params) {
+      url = this.appendQueryParams(url, params);
+    }
+    const headers = await this.buildHeaders();
+    return this.executeWithRetry({ url, method, headers, body });
+  }
+  /**
+   * Build full URL from path and path params
+   */
+  buildUrl(path, pathParams) {
+    let finalPath = path;
+    if (pathParams) {
+      for (const [key, value] of Object.entries(pathParams)) {
+        finalPath = finalPath.replace(`:${key}`, encodeURIComponent(value));
+      }
+    }
+    return `${this.config.baseUrl}${finalPath}`;
+  }
+  /**
+   * Append query params to URL
+   */
+  appendQueryParams(url, params) {
+    const searchParams = new URLSearchParams();
+    for (const [key, value] of Object.entries(this.requestConfig.defaultParams)) {
+      searchParams.set(key, value);
+    }
+    for (const [key, value] of Object.entries(params)) {
+      if (value != null) {
+        searchParams.set(key, String(value));
+      }
+    }
+    const queryString = searchParams.toString();
+    return queryString ? `${url}?${queryString}` : url;
+  }
+  /**
+   * Build headers with auth token
+   */
+  async buildHeaders() {
+    const headers = {
+      "Content-Type": "application/json",
+      Accept: "application/json",
+      ...this.config.auth.headers
+    };
+    const token = await this.config.auth.getAccessToken();
+    if (token) {
+      const headerName = this.config.auth.tokenHeader ?? "Authorization";
+      const prefix = this.config.auth.tokenPrefix ?? "Bearer";
+      headers[headerName] = prefix ? `${prefix} ${token}` : token;
+    }
+    return headers;
+  }
+  /**
+   * Execute request with retry logic
+   */
+  async executeWithRetry(request) {
+    let lastError = null;
+    for (let attempt = 0; attempt <= this.retryConfig.maxRetries; attempt++) {
+      try {
+        const response = await this.doFetch(request);
+        return await this.handleResponse(response, request);
+      } catch (error) {
+        lastError = error;
+        if (this.shouldRetry(error, attempt)) {
+          await this.waitBeforeRetry(attempt, request.url, error);
+          continue;
+        }
+        throw error;
+      }
+    }
+    throw lastError ?? new Error("Request failed");
+  }
+  /**
+   * Handle response status and parse result
+   */
+  async handleResponse(response, request) {
+    if (response.status === 401) {
+      return this.handleUnauthorized(request);
+    }
+    if (this.retryConfig.retryOn.includes(response.status)) {
+      const errorText = await response.text();
+      throw new RetryableError(response.status, errorText);
+    }
+    if (!response.ok) {
+      const errorBody = await this.safeParseJson(response);
+      throw new HttpError(
+        response.status,
+        `Request failed with status ${response.status}`,
+        errorBody
+      );
+    }
+    return this.parseResponse(response);
+  }
+  /**
+   * Handle 401 unauthorized - attempt token refresh
+   */
+  async handleUnauthorized(request) {
+    const newToken = await this.refreshTokenIfNeeded();
+    if (newToken) {
+      this.updateAuthHeader(request.headers, newToken);
+      const retryResponse = await this.doFetch(request);
+      return this.parseResponse(retryResponse);
+    }
+    this.config.auth.onAuthError?.({ status: 401, message: "Authentication failed" });
+    throw new HttpError(401, "Authentication failed");
+  }
+  /**
+   * Update auth header with new token
+   */
+  updateAuthHeader(headers, token) {
+    const headerName = this.config.auth.tokenHeader ?? "Authorization";
+    const prefix = this.config.auth.tokenPrefix ?? "Bearer";
+    headers[headerName] = prefix ? `${prefix} ${token}` : token;
+  }
+  /**
+   * Check if error should trigger retry
+   */
+  shouldRetry(error, attempt) {
+    return error instanceof RetryableError && attempt < this.retryConfig.maxRetries;
+  }
+  /**
+   * Wait before retry with backoff
+   */
+  async waitBeforeRetry(attempt, url, error) {
+    const delay = this.retryConfig.exponentialBackoff ? this.retryConfig.retryDelay * 2 ** attempt : this.retryConfig.retryDelay;
+    this.config.logger?.warn(
+      `[HttpClient] Retrying (${attempt + 1}/${this.retryConfig.maxRetries}) after ${delay}ms`,
+      { url, status: error.status }
+    );
+    await this.sleep(delay);
+  }
+  /**
+   * Execute fetch with timeout
+   */
+  async doFetch(request) {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.requestConfig.timeout);
+    try {
+      return await fetch(request.url, {
+        method: request.method,
+        headers: request.headers,
+        body: request.body ? JSON.stringify(request.body) : void 0,
+        signal: controller.signal
+      });
+    } catch (error) {
+      if (error instanceof Error && error.name === "AbortError") {
+        throw new HttpError(408, "Request timeout");
+      }
+      throw error;
+    } finally {
+      clearTimeout(timeoutId);
+    }
+  }
+  /**
+   * Parse response JSON
+   */
+  async parseResponse(response) {
+    const text = await response.text();
+    if (!text) {
+      return {};
+    }
+    try {
+      return JSON.parse(text);
+    } catch {
+      return { data: text };
+    }
+  }
+  /**
+   * Safely parse JSON from response
+   */
+  async safeParseJson(response) {
+    try {
+      return await response.json();
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Refresh token with deduplication
+   */
+  async refreshTokenIfNeeded() {
+    if (!this.config.auth.refreshToken) {
+      return null;
+    }
+    if (this.isRefreshing && this.refreshPromise) {
+      return this.refreshPromise;
+    }
+    this.isRefreshing = true;
+    this.refreshPromise = this.config.auth.refreshToken().finally(() => {
+      this.isRefreshing = false;
+      this.refreshPromise = null;
+    });
+    try {
+      return await this.refreshPromise;
+    } catch (error) {
+      this.config.logger?.error("[HttpClient] Token refresh failed", error);
+      return null;
+    }
+  }
+  /**
+   * Sleep utility
+   */
+  sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+};
+
+// src/preset/transforms/defaults.ts
+function getNestedValue(obj, path) {
+  if (!obj || typeof obj !== "object") return void 0;
+  const keys = path.split(".");
+  let current = obj;
+  for (const key of keys) {
+    if (current === null || current === void 0) return void 0;
+    if (typeof current !== "object") return void 0;
+    current = current[key];
+  }
+  return current;
+}
+function tryFields(obj, ...paths) {
+  for (const path of paths) {
+    const value = getNestedValue(obj, path);
+    if (value !== void 0 && value !== null) {
+      return value;
+    }
+  }
+  return void 0;
+}
+function toSafeString(value, fallback = "") {
+  if (value === null || value === void 0) return fallback ?? "";
+  return String(value);
+}
+function toStringOrNull(value) {
+  if (value === null || value === void 0 || value === "") return null;
+  return String(value);
+}
+function toNumber(value, fallback = 0) {
+  if (value === null || value === void 0) return fallback;
+  const num = Number(value);
+  return Number.isNaN(num) ? fallback : num;
+}
+function toBoolean(value, fallback = false) {
+  if (value === null || value === void 0) return fallback;
+  if (typeof value === "boolean") return value;
+  if (typeof value === "string") {
+    return value.toLowerCase() === "true" || value === "1";
+  }
+  return Boolean(value);
+}
+function defaultSourceTransform(data) {
+  const obj = data;
+  const url = toSafeString(
+    tryFields(obj, "video_url", "url", "source_url", "playback_url", "stream_url"),
+    ""
+  );
+  const typeRaw = toSafeString(
+    tryFields(obj, "video_type", "type", "source_type", "format"),
+    "mp4"
+  );
+  const type = typeRaw.toLowerCase().includes("hls") ? "hls" : "mp4";
+  return { url, type };
+}
+function defaultAuthorTransform(data) {
+  const obj = data;
+  const authorObj = tryFields(obj, "user", "author", "creator", "owner") ?? obj;
+  const author = authorObj;
+  return {
+    id: toSafeString(tryFields(author, "id", "user_id", "author_id"), ""),
+    name: toSafeString(
+      tryFields(author, "display_name", "name", "username", "nickname"),
+      "Unknown"
+    ),
+    avatar: toSafeString(
+      tryFields(author, "avatar", "avatar_url", "profile_picture", "photo"),
+      void 0
+    ),
+    isVerified: toBoolean(tryFields(author, "is_verified", "verified"), false)
+  };
+}
+function defaultStatsTransform(data) {
+  const obj = data;
+  const statsObj = tryFields(obj, "stats", "statistics", "metrics") ?? obj;
+  const stats = statsObj;
+  return {
+    views: toNumber(tryFields(stats, "view_count", "views", "play_count"), 0),
+    likes: toNumber(tryFields(stats, "like_count", "likes", "digg_count"), 0),
+    comments: toNumber(tryFields(stats, "comment_count", "comments"), 0),
+    shares: toNumber(tryFields(stats, "share_count", "shares"), 0)
+  };
+}
+function defaultVideoItemTransform(apiResponse, fieldMap, logger) {
+  const obj = apiResponse;
+  const getMapped = (sdkField, ...fallbacks) => {
+    if (fieldMap?.[sdkField]) {
+      const mapped = getNestedValue(obj, fieldMap[sdkField]);
+      if (mapped !== void 0) return mapped;
+    }
+    return tryFields(obj, ...fallbacks);
+  };
+  const id = toSafeString(getMapped("id", "id", "video_id", "_id"), "");
+  const sourceUrl = toSafeString(
+    getMapped("source.url", "video_url", "url", "source_url", "playback_url"),
+    ""
+  );
+  if (!id) {
+    logger?.warn("[Transform] Missing required field: id", { data: obj });
+  }
+  if (!sourceUrl) {
+    logger?.warn("[Transform] Missing required field: source.url", { data: obj });
+  }
+  const source = defaultSourceTransform(obj);
+  const author = defaultAuthorTransform(obj);
+  const stats = defaultStatsTransform(obj);
+  const videoItem = {
+    id,
+    source,
+    poster: toSafeString(
+      getMapped("poster", "thumbnail_url", "poster", "thumbnail", "cover", "cover_url"),
+      void 0
+    ),
+    duration: toNumber(
+      getMapped("duration", "duration", "duration_seconds", "length", "video_duration"),
+      0
+    ),
+    title: toSafeString(getMapped("title", "title", "description", "caption", "text"), void 0),
+    author,
+    stats,
+    isLiked: toBoolean(getMapped("isLiked", "is_liked", "liked", "user_liked", "has_liked"), false),
+    isFollowing: toBoolean(
+      getMapped("isFollowing", "is_following", "following", "user_following"),
+      false
+    ),
+    createdAt: toSafeString(
+      getMapped("createdAt", "created_at", "createdAt", "create_time", "timestamp"),
+      (/* @__PURE__ */ new Date()).toISOString()
+    ),
+    hashtags: getMapped("hashtags", "hashtags", "tags", "hash_tags") ?? []
+  };
+  return videoItem;
+}
+function defaultFeedResponseTransform(apiResponse, fieldMap, logger) {
+  const obj = apiResponse;
+  const itemsPath = fieldMap?.items;
+  let items;
+  if (itemsPath) {
+    items = getNestedValue(obj, itemsPath) ?? [];
+  } else {
+    items = tryFields(obj, "data", "items", "videos", "results", "list") ?? [];
+  }
+  if (!Array.isArray(items)) {
+    logger?.warn("[Transform] Feed items is not an array", { data: obj });
+    items = [];
+  }
+  const cursorPath = fieldMap?.nextCursor;
+  let nextCursor;
+  if (cursorPath) {
+    nextCursor = toStringOrNull(getNestedValue(obj, cursorPath));
+  } else {
+    nextCursor = toStringOrNull(
+      tryFields(
+        obj,
+        "next_cursor",
+        "nextCursor",
+        "cursor",
+        "next_page",
+        "pagination.next",
+        "meta.next_cursor"
+      )
+    );
+  }
+  const hasMorePath = fieldMap?.hasMore;
+  let hasMore;
+  if (hasMorePath) {
+    hasMore = toBoolean(getNestedValue(obj, hasMorePath), false);
+  } else {
+    const hasMoreValue = tryFields(
+      obj,
+      "has_more",
+      "hasMore",
+      "has_next",
+      "hasNext",
+      "pagination.has_more",
+      "meta.has_more"
+    );
+    if (hasMoreValue !== void 0) {
+      hasMore = toBoolean(hasMoreValue, false);
+    } else {
+      hasMore = nextCursor !== null;
+    }
+  }
+  return { items, nextCursor, hasMore };
+}
+function createTransforms(config, logger) {
+  return {
+    videoItem: config?.videoItem ? config.videoItem : (data) => defaultVideoItemTransform(data, config?.fieldMap?.video, logger),
+    feedResponse: config?.feedResponse ? config.feedResponse : (data) => defaultFeedResponseTransform(data, config?.fieldMap?.feed, logger)
+  };
+}
+
+// src/preset/createRESTAdapters.ts
+function validateConfig(config) {
+  if (!config.baseUrl) {
+    throw new Error("[createRESTAdapters] baseUrl is required");
+  }
+  if (!config.auth?.getAccessToken) {
+    throw new Error("[createRESTAdapters] auth.getAccessToken is required");
+  }
+  if (!config.endpoints?.feed?.list) {
+    throw new Error("[createRESTAdapters] endpoints.feed.list is required");
+  }
+  if (!config.endpoints?.feed?.detail) {
+    throw new Error("[createRESTAdapters] endpoints.feed.detail is required");
+  }
+  const requiredInteractionEndpoints = [
+    "like",
+    "unlike",
+    "follow",
+    "unfollow",
+    "comment",
+    "deleteComment"
+  ];
+  for (const endpoint of requiredInteractionEndpoints) {
+    if (!config.endpoints.interaction?.[endpoint]) {
+      throw new Error(`[createRESTAdapters] endpoints.interaction.${endpoint} is required`);
+    }
+  }
+}
+function createRESTAdapters(config) {
+  validateConfig(config);
+  const { baseUrl, auth, endpoints, transforms, request, logger } = config;
+  const httpClient = new HttpClient({
+    baseUrl,
+    auth,
+    request,
+    logger
+  });
+  const resolvedTransforms = createTransforms(transforms, logger);
+  const dataSource = new RESTDataAdapter({
+    httpClient,
+    endpoints: endpoints.feed,
+    transforms: resolvedTransforms,
+    pagination: request?.pagination,
+    logger
+  });
+  const interaction = new RESTInteractionAdapter({
+    httpClient,
+    endpoints: endpoints.interaction,
+    logger
+  });
+  const analytics = endpoints.analytics ? new RESTAnalyticsAdapter({
+    httpClient,
+    endpoints: endpoints.analytics,
+    logger
+  }) : createNoOpAnalyticsAdapter();
+  return {
+    dataSource,
+    interaction,
+    analytics
+  };
+}
+
+// src/preset/adapters/BrowserVideoLoader.ts
+var DEFAULT_CONFIG = {
+  defaultMaxBytes: 512 * 1024,
+  // 512KB
+  defaultTimeout: 1e4,
+  useCache: true,
+  cacheName: "sv-video-cache"
+};
+var BrowserVideoLoader = class {
+  constructor(config = {}) {
+    this.preloads = /* @__PURE__ */ new Map();
+    this.cache = null;
+    this.logger = config.logger;
+    this.config = {
+      defaultMaxBytes: config.defaultMaxBytes ?? DEFAULT_CONFIG.defaultMaxBytes,
+      defaultTimeout: config.defaultTimeout ?? DEFAULT_CONFIG.defaultTimeout,
+      useCache: config.useCache ?? DEFAULT_CONFIG.useCache,
+      cacheName: config.cacheName ?? DEFAULT_CONFIG.cacheName
+    };
+    this.initCache();
+  }
+  /**
+   * Initialize Cache API
+   */
+  async initCache() {
+    if (!this.config.useCache) return;
+    try {
+      if ("caches" in window) {
+        this.cache = await caches.open(this.config.cacheName);
+        this.logger?.debug("[BrowserVideoLoader] Cache initialized");
+      }
+    } catch (error) {
+      this.logger?.warn("[BrowserVideoLoader] Cache API not available", { error });
+    }
+  }
+  /**
+   * Preload video source
+   */
+  async preload(videoId, source, config) {
+    const existing = this.preloads.get(videoId);
+    if (existing?.status === "ready") {
+      return {
+        videoId,
+        status: "ready",
+        loadedBytes: existing.loadedBytes
+      };
+    }
+    if (existing?.status === "loading") {
+      this.logger?.debug("[BrowserVideoLoader] Already loading", { videoId });
+      return { videoId, status: "loading" };
+    }
+    const abortController = new AbortController();
+    const timeout = config?.timeout ?? this.config.defaultTimeout;
+    const maxBytes = config?.maxBytes ?? this.config.defaultMaxBytes;
+    this.preloads.set(videoId, {
+      status: "loading",
+      loadedBytes: 0,
+      abortController
+    });
+    const timeoutId = setTimeout(() => {
+      abortController.abort();
+    }, timeout);
+    try {
+      let loadedBytes;
+      if (source.type === "hls") {
+        loadedBytes = await this.preloadHLS(source.url, abortController.signal);
+      } else {
+        loadedBytes = await this.preloadMP4(source.url, maxBytes, abortController.signal);
+      }
+      clearTimeout(timeoutId);
+      this.preloads.set(videoId, {
+        status: "ready",
+        loadedBytes
+      });
+      this.logger?.debug("[BrowserVideoLoader] Preload complete", {
+        videoId,
+        loadedBytes,
+        type: source.type
+      });
+      return {
+        videoId,
+        status: "ready",
+        loadedBytes
+      };
+    } catch (error) {
+      clearTimeout(timeoutId);
+      const err = error instanceof Error ? error : new Error(String(error));
+      if (err.name !== "AbortError") {
+        this.logger?.warn("[BrowserVideoLoader] Preload failed", { videoId, error: err.message });
+      }
+      this.preloads.set(videoId, {
+        status: err.name === "AbortError" ? "idle" : "error",
+        loadedBytes: 0,
+        error: err
+      });
+      return {
+        videoId,
+        status: err.name === "AbortError" ? "idle" : "error",
+        error: err
+      };
+    }
+  }
+  /**
+   * Preload MP4 video using Range request
+   */
+  async preloadMP4(url, maxBytes, signal) {
+    const response = await fetch(url, {
+      method: "GET",
+      headers: {
+        Range: `bytes=0-${maxBytes - 1}`
+      },
+      signal
+    });
+    if (!response.ok && response.status !== 206) {
+      throw new Error(`HTTP error: ${response.status}`);
+    }
+    const buffer = await response.arrayBuffer();
+    if (this.cache && buffer.byteLength > 0) {
+      try {
+        const cacheResponse = new Response(buffer, {
+          headers: {
+            "Content-Type": "video/mp4",
+            "Content-Length": String(buffer.byteLength)
+          }
+        });
+        await this.cache.put(url, cacheResponse);
+      } catch {
+      }
+    }
+    return buffer.byteLength;
+  }
+  /**
+   * Preload HLS - fetch manifest only
+   * Full segment preload requires hls.js which is optional
+   */
+  async preloadHLS(url, signal) {
+    const response = await fetch(url, { signal });
+    if (!response.ok) {
+      throw new Error(`HTTP error: ${response.status}`);
+    }
+    const text = await response.text();
+    if (this.cache) {
+      try {
+        const cacheResponse = new Response(text, {
+          headers: {
+            "Content-Type": "application/vnd.apple.mpegurl"
+          }
+        });
+        await this.cache.put(url, cacheResponse);
+      } catch {
+      }
+    }
+    return text.length;
+  }
+  /**
+   * Cancel preload
+   */
+  cancelPreload(videoId) {
+    const state = this.preloads.get(videoId);
+    if (state?.abortController) {
+      state.abortController.abort();
+    }
+    this.preloads.set(videoId, {
+      status: "idle",
+      loadedBytes: 0
+    });
+    this.logger?.debug("[BrowserVideoLoader] Cancelled preload", { videoId });
+  }
+  /**
+   * Check if video is preloaded
+   */
+  isPreloaded(videoId) {
+    return this.preloads.get(videoId)?.status === "ready";
+  }
+  /**
+   * Get preload status
+   */
+  getPreloadStatus(videoId) {
+    return this.preloads.get(videoId)?.status ?? "idle";
+  }
+  /**
+   * Clear preloaded data for a video
+   */
+  clearPreload(videoId) {
+    this.preloads.delete(videoId);
+  }
+  /**
+   * Clear all preloaded data
+   */
+  clearAll() {
+    for (const [, state] of this.preloads) {
+      if (state.abortController) {
+        state.abortController.abort();
+      }
+    }
+    this.preloads.clear();
+    if (this.cache) {
+      caches.delete(this.config.cacheName).catch(() => {
+      });
+    }
+    this.logger?.debug("[BrowserVideoLoader] Cleared all preloads");
+  }
+  /**
+   * Get total preloaded bytes
+   */
+  getTotalPreloadedBytes() {
+    let total = 0;
+    for (const state of this.preloads.values()) {
+      if (state.status === "ready") {
+        total += state.loadedBytes;
+      }
+    }
+    return total;
+  }
+};
+var BrowserPosterLoader = class {
+  constructor(config) {
+    this.cache = /* @__PURE__ */ new Set();
+    this.pending = /* @__PURE__ */ new Map();
+    this.logger = config?.logger;
+    this.timeout = config?.timeout ?? 1e4;
+  }
+  /**
+   * Preload a poster image
+   */
+  async preload(url) {
+    if (this.cache.has(url)) {
+      return;
+    }
+    const pending = this.pending.get(url);
+    if (pending) {
+      return pending;
+    }
+    const promise = new Promise((resolve, reject) => {
+      const img = new Image();
+      const timeoutId = setTimeout(() => {
+        img.src = "";
+        reject(new Error("Poster preload timeout"));
+      }, this.timeout);
+      img.onload = () => {
+        clearTimeout(timeoutId);
+        this.cache.add(url);
+        this.pending.delete(url);
+        this.logger?.debug("[BrowserPosterLoader] Preloaded", { url });
+        resolve();
+      };
+      img.onerror = () => {
+        clearTimeout(timeoutId);
+        this.pending.delete(url);
+        this.logger?.warn("[BrowserPosterLoader] Failed to preload", { url });
+        reject(new Error(`Failed to load image: ${url}`));
+      };
+      img.src = url;
+    });
+    this.pending.set(url, promise);
+    try {
+      await promise;
+    } catch {
+    }
+  }
+  /**
+   * Check if poster is cached
+   */
+  isCached(url) {
+    return this.cache.has(url);
+  }
+  /**
+   * Clear poster cache
+   */
+  clearCache() {
+    this.cache.clear();
+    this.pending.clear();
+    this.logger?.debug("[BrowserPosterLoader] Cache cleared");
+  }
+};
+function createBrowserVideoLoader(config) {
+  return new BrowserVideoLoader(config);
+}
+function createBrowserPosterLoader(config) {
+  return new BrowserPosterLoader(config);
+}
+
+// src/preset/adapters/LocalStorageAdapter.ts
+var DEFAULT_CONFIG2 = {
+  prefix: "sv-",
+  maxSnapshotAge: 24 * 60 * 60 * 1e3
+  // 24 hours
+};
+var SESSION_SNAPSHOT_KEY2 = "session-snapshot";
+var LocalStorageAdapter = class {
+  constructor(config = {}) {
+    this.prefix = config.prefix ?? DEFAULT_CONFIG2.prefix;
+    this.logger = config.logger;
+  }
+  /**
+   * Build namespaced key
+   */
+  buildKey(key) {
+    return `${this.prefix}${key}`;
+  }
+  /**
+   * Get a value from localStorage
+   */
+  async get(key) {
+    try {
+      const fullKey = this.buildKey(key);
+      const value = localStorage.getItem(fullKey);
+      if (value === null) {
+        return null;
+      }
+      return JSON.parse(value);
+    } catch (error) {
+      this.logger?.warn("[LocalStorageAdapter] Failed to get/parse value", { key, error });
+      return null;
+    }
+  }
+  /**
+   * Set a value in localStorage
+   */
+  async set(key, value) {
+    try {
+      const fullKey = this.buildKey(key);
+      localStorage.setItem(fullKey, JSON.stringify(value));
+    } catch (error) {
+      if (error instanceof DOMException && error.name === "QuotaExceededError") {
+        this.logger?.warn("[LocalStorageAdapter] Storage quota exceeded, clearing old data");
+        await this.clearOldEntries();
+        try {
+          const fullKey = this.buildKey(key);
+          localStorage.setItem(fullKey, JSON.stringify(value));
+        } catch {
+          this.logger?.error(
+            "[LocalStorageAdapter] Still over quota after cleanup",
+            error
+          );
+          throw error;
+        }
+      } else {
+        throw error;
+      }
+    }
+  }
+  /**
+   * Remove a value from localStorage
+   */
+  async remove(key) {
+    const fullKey = this.buildKey(key);
+    localStorage.removeItem(fullKey);
+  }
+  /**
+   * Clear all SDK-namespaced keys
+   */
+  async clear() {
+    const keysToRemove = [];
+    for (let i = 0; i < localStorage.length; i++) {
+      const key = localStorage.key(i);
+      if (key?.startsWith(this.prefix)) {
+        keysToRemove.push(key);
+      }
+    }
+    for (const key of keysToRemove) {
+      localStorage.removeItem(key);
+    }
+    this.logger?.debug("[LocalStorageAdapter] Cleared all SDK keys", {
+      count: keysToRemove.length
+    });
+  }
+  /**
+   * Get all SDK-namespaced keys
+   */
+  async keys() {
+    const sdkKeys = [];
+    for (let i = 0; i < localStorage.length; i++) {
+      const key = localStorage.key(i);
+      if (key?.startsWith(this.prefix)) {
+        sdkKeys.push(key.slice(this.prefix.length));
+      }
+    }
+    return sdkKeys;
+  }
+  /**
+   * Clear old entries when quota exceeded (simple LRU-like behavior)
+   */
+  async clearOldEntries() {
+    const allKeys = await this.keys();
+    const keysToRemove = allKeys.slice(0, Math.ceil(allKeys.length / 2));
+    for (const key of keysToRemove) {
+      await this.remove(key);
+    }
+    this.logger?.debug("[LocalStorageAdapter] Cleared old entries", { count: keysToRemove.length });
+  }
+};
+var LocalSessionStorageAdapter = class extends LocalStorageAdapter {
+  constructor(config = {}) {
+    super(config);
+    this.maxSnapshotAge = config.maxSnapshotAge ?? DEFAULT_CONFIG2.maxSnapshotAge;
+  }
+  /**
+   * Save session snapshot
+   */
+  async saveSnapshot(snapshot) {
+    await this.set(SESSION_SNAPSHOT_KEY2, snapshot);
+    this.logger?.debug("[LocalSessionStorageAdapter] Saved snapshot", {
+      index: snapshot.focusedIndex,
+      cursor: snapshot.cursor
+    });
+  }
+  /**
+   * Load session snapshot (returns null if stale)
+   */
+  async loadSnapshot() {
+    const snapshot = await this.get(SESSION_SNAPSHOT_KEY2);
+    if (!snapshot) {
+      return null;
+    }
+    const age = Date.now() - snapshot.savedAt;
+    if (age > this.maxSnapshotAge) {
+      this.logger?.debug("[LocalSessionStorageAdapter] Snapshot is stale, clearing", {
+        age,
+        maxAge: this.maxSnapshotAge
+      });
+      await this.clearSnapshot();
+      return null;
+    }
+    this.logger?.debug("[LocalSessionStorageAdapter] Loaded snapshot", {
+      index: snapshot.focusedIndex,
+      age
+    });
+    return snapshot;
+  }
+  /**
+   * Clear session snapshot
+   */
+  async clearSnapshot() {
+    await this.remove(SESSION_SNAPSHOT_KEY2);
+    this.logger?.debug("[LocalSessionStorageAdapter] Cleared snapshot");
+  }
+};
+function createLocalStorageAdapter(config) {
+  return new LocalStorageAdapter(config);
+}
+function createSessionStorageAdapter(config) {
+  return new LocalSessionStorageAdapter(config);
+}
+
+// src/preset/adapters/WebNetworkAdapter.ts
+function mapEffectiveType(effectiveType) {
+  switch (effectiveType) {
+    case "4g":
+      return "4g";
+    case "3g":
+      return "3g";
+    case "2g":
+    case "slow-2g":
+      return "slow";
+    default:
+      return "wifi";
+  }
+}
+function mapConnectionType(type, effectiveType) {
+  if (type === "none") return "offline";
+  if (type === "wifi" || type === "ethernet") return "wifi";
+  if (type === "cellular") {
+    return mapEffectiveType(effectiveType);
+  }
+  return mapEffectiveType(effectiveType);
+}
+var WebNetworkAdapter = class {
+  constructor(config = {}) {
+    this.listeners = /* @__PURE__ */ new Set();
+    this.connection = null;
+    this.logger = config.logger;
+    this.fallbackType = config.fallbackType ?? "wifi";
+    this.fallbackDownlink = config.fallbackDownlink ?? 10;
+    const nav = navigator;
+    this.connection = nav.connection ?? nav.mozConnection ?? nav.webkitConnection ?? null;
+    this.boundOnlineHandler = this.handleOnline.bind(this);
+    this.boundOfflineHandler = this.handleOffline.bind(this);
+    this.boundChangeHandler = this.handleConnectionChange.bind(this);
+    this.setupListeners();
+    this.logger?.debug("[WebNetworkAdapter] Initialized", {
+      hasConnectionAPI: !!this.connection
+    });
+  }
+  /**
+   * Get current network type
+   */
+  async getNetworkType() {
+    if (!navigator.onLine) {
+      return "offline";
+    }
+    if (!this.connection) {
+      return this.fallbackType;
+    }
+    return mapConnectionType(this.connection.type, this.connection.effectiveType);
+  }
+  /**
+   * Get detailed network quality
+   */
+  async getNetworkQuality() {
+    const type = await this.getNetworkType();
+    if (!this.connection) {
+      return {
+        type,
+        downlink: this.fallbackDownlink,
+        rtt: void 0,
+        isMetered: false
+      };
+    }
+    return {
+      type,
+      downlink: this.connection.downlink,
+      rtt: this.connection.rtt,
+      isMetered: this.connection.saveData ?? this.connection.type === "cellular"
+    };
+  }
+  /**
+   * Subscribe to network changes
+   */
+  onNetworkChange(callback) {
+    this.listeners.add(callback);
+    return () => {
+      this.listeners.delete(callback);
+    };
+  }
+  /**
+   * Check if currently online
+   */
+  async isOnline() {
+    return navigator.onLine;
+  }
+  /**
+   * Cleanup listeners
+   */
+  destroy() {
+    window.removeEventListener("online", this.boundOnlineHandler);
+    window.removeEventListener("offline", this.boundOfflineHandler);
+    if (this.connection) {
+      this.connection.removeEventListener("change", this.boundChangeHandler);
+    }
+    this.listeners.clear();
+    this.logger?.debug("[WebNetworkAdapter] Destroyed");
+  }
+  // ═══════════════════════════════════════════════════════════════
+  // PRIVATE METHODS
+  // ═══════════════════════════════════════════════════════════════
+  setupListeners() {
+    window.addEventListener("online", this.boundOnlineHandler);
+    window.addEventListener("offline", this.boundOfflineHandler);
+    if (this.connection) {
+      this.connection.addEventListener("change", this.boundChangeHandler);
+    }
+  }
+  handleOnline() {
+    this.logger?.debug("[WebNetworkAdapter] Online");
+    this.notifyListeners();
+  }
+  handleOffline() {
+    this.logger?.debug("[WebNetworkAdapter] Offline");
+    this.notifyListeners();
+  }
+  handleConnectionChange() {
+    this.logger?.debug("[WebNetworkAdapter] Connection changed", {
+      type: this.connection?.type,
+      effectiveType: this.connection?.effectiveType
+    });
+    this.notifyListeners();
+  }
+  async notifyListeners() {
+    const type = await this.getNetworkType();
+    for (const listener of this.listeners) {
+      try {
+        listener(type);
+      } catch (error) {
+        this.logger?.error("[WebNetworkAdapter] Listener error", error);
+      }
+    }
+  }
+};
+function createWebNetworkAdapter(config) {
+  return new WebNetworkAdapter(config);
+}
+
+// src/preset/createBrowserAdapters.ts
+function createBrowserAdapters(config) {
+  const restAdapters = createRESTAdapters(config);
+  const storage = new LocalSessionStorageAdapter({
+    ...config.storage,
+    logger: config.logger
+  });
+  const network = new WebNetworkAdapter({
+    ...config.network,
+    logger: config.logger
+  });
+  const videoLoader = new BrowserVideoLoader({
+    ...config.videoLoader,
+    logger: config.logger
+  });
+  const posterLoader = new BrowserPosterLoader({
+    logger: config.logger,
+    timeout: config.posterTimeout
+  });
+  config.logger?.info("[createBrowserAdapters] Created all adapters", {
+    baseUrl: config.baseUrl,
+    hasAnalytics: !!config.endpoints.analytics
+  });
+  return {
+    dataSource: restAdapters.dataSource,
+    interaction: restAdapters.interaction,
+    analytics: restAdapters.analytics,
+    storage,
+    network,
+    videoLoader,
+    posterLoader,
+    logger: config.logger
+  };
+}
+
+export { BrowserPosterLoader, BrowserVideoLoader, DEFAULT_REQUEST_CONFIG, DEFAULT_RETRY_CONFIG, HttpClient, HttpError, LocalSessionStorageAdapter, LocalStorageAdapter, MockAnalyticsAdapter, MockDataAdapter, MockInteractionAdapter, MockLoggerAdapter, MockNetworkAdapter, MockPosterLoader, MockSessionStorageAdapter, MockStorageAdapter, MockVideoLoader, RESTAnalyticsAdapter, RESTDataAdapter, RESTInteractionAdapter, WebNetworkAdapter, createBrowserAdapters, createBrowserPosterLoader, createBrowserVideoLoader, createLocalStorageAdapter, createNoOpAnalyticsAdapter, createRESTAdapters, createSessionStorageAdapter, createTransforms, createWebNetworkAdapter, defaultFeedResponseTransform, defaultVideoItemTransform };