@stacksjs/stx 0.2.95 → 0.2.97

package/dist/media/video/processor/streaming.js

@@ -1,2 +1,197 @@
-// @bun
-import{Aj as a,Bj as b,Cj as c}from"../../../chunk-rtr974rc.js";import"../../../chunk-jpndqst5.js";import"../../../chunk-xv34zbp4.js";export{b as generateHLSManifest,c as generateDASHManifest,a as DEFAULT_STREAMING_QUALITIES};
+import { resolve, basename, extname, join } from "node:path";
+import { mkdir, writeFile } from "node:fs/promises";
+import { hashFile, fileExists } from "../../shared/hash.js";
+async function getTsVideos() {
+  try {
+    return await import("ts-videos");
+  } catch {
+    return null;
+  }
+}
+export const DEFAULT_STREAMING_QUALITIES = [
+  { label: "1080p", width: 1920, height: 1080, bitrate: 5000000, audioBitrate: 192000 },
+  { label: "720p", width: 1280, height: 720, bitrate: 2500000, audioBitrate: 128000 },
+  { label: "480p", width: 854, height: 480, bitrate: 1e6, audioBitrate: 96000 },
+  { label: "360p", width: 640, height: 360, bitrate: 600000, audioBitrate: 64000 }
+];
+export async function generateHLSManifest(src, qualities, outputDir, baseUrl, options) {
+  const tsVideos = await getTsVideos();
+  if (!tsVideos) {
+    console.warn("[stx-media] ts-videos not installed, cannot generate HLS manifest");
+    return null;
+  }
+  try {
+    const srcPath = resolve(src);
+    if (!await fileExists(srcPath))
+      return null;
+    const srcHash = await hashFile(srcPath), srcBasename = basename(src, extname(src)), hlsDir = join(outputDir, `${srcBasename}-${srcHash}-hls`);
+    await mkdir(hlsDir, { recursive: !0 });
+    const effectiveQualities = qualities.length > 0 ? qualities : DEFAULT_STREAMING_QUALITIES, segmentDuration = options?.segmentDuration || 6, duration = (await new tsVideos.Input(srcPath).getInfo()).duration || 0, playlists = [];
+    let totalSegments = 0;
+    for (const quality of effectiveQualities) {
+      const qualityDir = join(hlsDir, quality.label);
+      await mkdir(qualityDir, { recursive: !0 });
+      const playlistFilename = `${quality.label}.m3u8`, playlistPath = join(qualityDir, playlistFilename);
+      try {
+        const result = await tsVideos.generateHLS(srcPath, {
+          outputDir: qualityDir,
+          segmentDuration,
+          width: quality.width,
+          height: quality.height,
+          videoBitrate: quality.bitrate,
+          audioBitrate: quality.audioBitrate,
+          playlistName: quality.label
+        });
+        if (result) {
+          playlists.push({
+            quality,
+            url: `${baseUrl}/${srcBasename}-${srcHash}-hls/${quality.label}/${playlistFilename}`,
+            path: playlistPath
+          });
+          totalSegments += result.segmentCount || Math.ceil(duration / segmentDuration);
+        }
+      } catch (error) {
+        console.warn(`[stx-media] Failed to generate HLS for ${quality.label}: ${error}`);
+      }
+    }
+    if (playlists.length === 0)
+      return null;
+    const masterPlaylistPath = join(hlsDir, "master.m3u8"), masterPlaylist = generateMasterPlaylist(playlists, baseUrl, srcBasename, srcHash);
+    await writeFile(masterPlaylistPath, masterPlaylist);
+    return {
+      manifestUrl: `${baseUrl}/${srcBasename}-${srcHash}-hls/master.m3u8`,
+      manifestPath: masterPlaylistPath,
+      playlists,
+      segmentCount: totalSegments,
+      duration
+    };
+  } catch (error) {
+    console.warn(`[stx-media] Failed to generate HLS manifest: ${error}`);
+    return null;
+  }
+}
+function generateMasterPlaylist(playlists, baseUrl, srcBasename, srcHash) {
+  const lines = ["#EXTM3U", "#EXT-X-VERSION:3"];
+  for (const playlist of playlists) {
+    const { quality } = playlist, bandwidth = quality.bitrate + (quality.audioBitrate || 128000), resolution = `${quality.width}x${quality.height || Math.round(quality.width * 9 / 16)}`;
+    lines.push(`#EXT-X-STREAM-INF:BANDWIDTH=${bandwidth},RESOLUTION=${resolution},NAME="${quality.label}"`, `${quality.label}/${quality.label}.m3u8`);
+  }
+  return lines.join(`
+`);
+}
+export async function generateDASHManifest(src, qualities, outputDir, baseUrl, options) {
+  const tsVideos = await getTsVideos();
+  if (!tsVideos) {
+    console.warn("[stx-media] ts-videos not installed, cannot generate DASH manifest");
+    return null;
+  }
+  try {
+    const srcPath = resolve(src);
+    if (!await fileExists(srcPath))
+      return null;
+    const srcHash = await hashFile(srcPath), srcBasename = basename(src, extname(src)), dashDir = join(outputDir, `${srcBasename}-${srcHash}-dash`);
+    await mkdir(dashDir, { recursive: !0 });
+    const effectiveQualities = qualities.length > 0 ? qualities : DEFAULT_STREAMING_QUALITIES, segmentDuration = options?.segmentDuration || 4, minBufferTime = options?.minBufferTime || 2, duration = (await new tsVideos.Input(srcPath).getInfo()).duration || 0, videoRepresentations = [], audioRepresentations = [];
+    for (const quality of effectiveQualities) {
+      const qualityDir = join(dashDir, quality.label);
+      await mkdir(qualityDir, { recursive: !0 });
+      try {
+        if (await tsVideos.generateDASH(srcPath, {
+          outputDir: qualityDir,
+          segmentDuration,
+          width: quality.width,
+          height: quality.height,
+          videoBitrate: quality.bitrate,
+          audioBitrate: quality.audioBitrate
+        })) {
+          videoRepresentations.push({
+            bandwidth: quality.bitrate,
+            width: quality.width,
+            height: quality.height || Math.round(quality.width * 9 / 16),
+            url: `${baseUrl}/${srcBasename}-${srcHash}-dash/${quality.label}/video`
+          });
+          if (quality.audioBitrate)
+            audioRepresentations.push({
+              bandwidth: quality.audioBitrate,
+              url: `${baseUrl}/${srcBasename}-${srcHash}-dash/${quality.label}/audio`
+            });
+        }
+      } catch (error) {
+        console.warn(`[stx-media] Failed to generate DASH for ${quality.label}: ${error}`);
+      }
+    }
+    if (videoRepresentations.length === 0)
+      return null;
+    const mpdPath = join(dashDir, "manifest.mpd"), mpd = generateMPD(videoRepresentations, audioRepresentations, duration, segmentDuration, minBufferTime);
+    await writeFile(mpdPath, mpd);
+    const adaptationSets = [
+      { type: "video", representations: videoRepresentations }
+    ];
+    if (audioRepresentations.length > 0)
+      adaptationSets.push({ type: "audio", representations: audioRepresentations });
+    return {
+      manifestUrl: `${baseUrl}/${srcBasename}-${srcHash}-dash/manifest.mpd`,
+      manifestPath: mpdPath,
+      adaptationSets,
+      duration
+    };
+  } catch (error) {
+    console.warn(`[stx-media] Failed to generate DASH manifest: ${error}`);
+    return null;
+  }
+}
+function generateMPD(videoReps, audioReps, duration, segmentDuration, minBufferTime) {
+  const durationISO = formatISODuration(duration), minBufferISO = formatISODuration(minBufferTime);
+  let mpd = `<?xml version="1.0" encoding="UTF-8"?>
+<MPD xmlns="urn:mpeg:dash:schema:mpd:2011"
+     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+     xsi:schemaLocation="urn:mpeg:dash:schema:mpd:2011 DASH-MPD.xsd"
+     type="static"
+     mediaPresentationDuration="${durationISO}"
+     minBufferTime="${minBufferISO}"
+     profiles="urn:mpeg:dash:profile:isoff-on-demand:2011">
+  <Period>
+    <AdaptationSet mimeType="video/mp4" codecs="avc1.64001f" segmentAlignment="true" startWithSAP="1">
+`;
+  for (let i = 0;i < videoReps.length; i++) {
+    const rep = videoReps[i];
+    mpd += `      <Representation id="video${i}" bandwidth="${rep.bandwidth}" width="${rep.width}" height="${rep.height}">
+        <BaseURL>${rep.url}/</BaseURL>
+        <SegmentBase indexRange="0-999">
+          <Initialization range="0-999"/>
+        </SegmentBase>
+      </Representation>
+`;
+  }
+  mpd += `    </AdaptationSet>
+`;
+  if (audioReps.length > 0) {
+    mpd += `    <AdaptationSet mimeType="audio/mp4" codecs="mp4a.40.2" segmentAlignment="true" startWithSAP="1">
+`;
+    for (let i = 0;i < audioReps.length; i++) {
+      const rep = audioReps[i];
+      mpd += `      <Representation id="audio${i}" bandwidth="${rep.bandwidth}">
+        <BaseURL>${rep.url}/</BaseURL>
+        <SegmentBase indexRange="0-999">
+          <Initialization range="0-999"/>
+        </SegmentBase>
+      </Representation>
+`;
+    }
+    mpd += `    </AdaptationSet>
+`;
+  }
+  mpd += `  </Period>
+</MPD>`;
+  return mpd;
+}
+function formatISODuration(seconds) {
+  const hours = Math.floor(seconds / 3600), minutes = Math.floor(seconds % 3600 / 60), secs = Math.floor(seconds % 60);
+  let duration = "PT";
+  if (hours > 0)
+    duration += `${hours}H`;
+  if (minutes > 0)
+    duration += `${minutes}M`;
+  duration += `${secs}S`;
+  return duration;
+}

package/dist/media/video/processor/thumbnail.js

@@ -1,2 +1,134 @@
-// @bun
-import{Dj as a,Ej as b,Fj as c}from"../../../chunk-j8tn8enq.js";import"../../../chunk-jpndqst5.js";import"../../../chunk-xv34zbp4.js";export{b as generateThumbnails,c as generateSpriteSheet,a as generatePoster};
+import { resolve, basename, extname, join } from "node:path";
+import { mkdir } from "node:fs/promises";
+import { hashFile, fileExists } from "../../shared/hash.js";
+async function getTsVideos() {
+  try {
+    return await import("ts-videos");
+  } catch {
+    return null;
+  }
+}
+export async function generatePoster(src, options, outputDir, baseUrl) {
+  const tsVideos = await getTsVideos();
+  if (!tsVideos) {
+    console.warn("[stx-media] ts-videos not installed, cannot generate poster");
+    return null;
+  }
+  try {
+    const srcPath = resolve(src);
+    if (!await fileExists(srcPath))
+      return null;
+    await mkdir(outputDir, { recursive: !0 });
+    const srcHash = await hashFile(srcPath), srcBasename = basename(src, extname(src)), format = options.format || "webp", timestamp = options.timestamp || 0, outputFilename = `${srcBasename}-poster-${srcHash}.${format}`, outputPath = join(outputDir, outputFilename), result = await tsVideos.extractThumbnails(srcPath, {
+      timestamps: [timestamp],
+      width: options.width || 1280,
+      height: options.height,
+      format,
+      quality: options.quality || 85,
+      outputDir,
+      outputPattern: outputFilename.replace(`.${format}`, "")
+    });
+    if (result && result.length > 0) {
+      const thumb = result[0];
+      return {
+        path: outputPath,
+        url: `${baseUrl}/${outputFilename}`,
+        width: thumb.width || options.width || 1280,
+        height: thumb.height || 720,
+        timestamp,
+        size: thumb.size || 0
+      };
+    }
+    return null;
+  } catch (error) {
+    console.warn(`[stx-media] Failed to generate poster: ${error}`);
+    return null;
+  }
+}
+export async function generateThumbnails(src, options, outputDir, baseUrl) {
+  const tsVideos = await getTsVideos();
+  if (!tsVideos)
+    return [];
+  try {
+    const srcPath = resolve(src);
+    if (!await fileExists(srcPath))
+      return [];
+    await mkdir(outputDir, { recursive: !0 });
+    const srcHash = await hashFile(srcPath), srcBasename = basename(src, extname(src)), format = options.format || "webp", duration = (await new tsVideos.Input(srcPath).getInfo()).duration || 60, count = options.count || 10, interval = options.interval || duration / count, timestamps = [];
+    for (let i = 0;i < count && i * interval < duration; i++)
+      timestamps.push(i * interval);
+    const result = await tsVideos.extractThumbnails(srcPath, {
+      timestamps,
+      width: options.width || 320,
+      format,
+      quality: options.quality || 80,
+      outputDir,
+      outputPattern: `${srcBasename}-thumb-${srcHash}`
+    });
+    if (result && result.length > 0)
+      return result.map((thumb, index) => ({
+        path: thumb.path || join(outputDir, `${srcBasename}-thumb-${srcHash}-${index}.${format}`),
+        url: `${baseUrl}/${srcBasename}-thumb-${srcHash}-${index}.${format}`,
+        width: thumb.width || options.width || 320,
+        height: thumb.height || 180,
+        timestamp: timestamps[index],
+        size: thumb.size || 0
+      }));
+    return [];
+  } catch (error) {
+    console.warn(`[stx-media] Failed to generate thumbnails: ${error}`);
+    return [];
+  }
+}
+export async function generateSpriteSheet(src, options, outputDir, baseUrl) {
+  const tsVideos = await getTsVideos();
+  if (!tsVideos) {
+    console.warn("[stx-media] ts-videos not installed, cannot generate sprite sheet");
+    return null;
+  }
+  try {
+    const srcPath = resolve(src);
+    if (!await fileExists(srcPath))
+      return null;
+    await mkdir(outputDir, { recursive: !0 });
+    const srcHash = await hashFile(srcPath), srcBasename = basename(src, extname(src)), duration = (await new tsVideos.Input(srcPath).getInfo()).duration || 60, columns = options.columns || 10, interval = options.interval || 5, thumbnailWidth = options.thumbnailWidth || 160, thumbnailHeight = options.thumbnailHeight || 90, format = options.format || "jpeg", totalFrames = Math.ceil(duration / interval), rows = Math.ceil(totalFrames / columns), outputFilename = `${srcBasename}-sprite-${srcHash}.${format}`, outputPath = join(outputDir, outputFilename), timestamps = [];
+    for (let i = 0;i < totalFrames; i++)
+      timestamps.push(i * interval);
+    const thumbnails = await tsVideos.extractThumbnails(srcPath, {
+      timestamps,
+      width: thumbnailWidth,
+      height: thumbnailHeight,
+      format,
+      quality: options.quality || 70,
+      outputDir: join(outputDir, ".temp")
+    });
+    if (!thumbnails || thumbnails.length === 0)
+      return null;
+    try {
+      const tsImages = await import("ts-images"), spriteWidth = columns * thumbnailWidth, spriteHeight = rows * thumbnailHeight, sprite = await tsImages.createSprite({
+        images: thumbnails.map((t) => t.path),
+        columns,
+        padding: 0,
+        outputPath,
+        format,
+        quality: options.quality || 70
+      });
+      return {
+        url: `${baseUrl}/${outputFilename}`,
+        path: outputPath,
+        columns,
+        rows,
+        thumbnailWidth,
+        thumbnailHeight,
+        interval,
+        totalFrames
+      };
+    } catch {
+      console.warn("[stx-media] ts-images not installed, sprite sheet generation skipped");
+      return null;
+    }
+  } catch (error) {
+    console.warn(`[stx-media] Failed to generate sprite sheet: ${error}`);
+    return null;
+  }
+}

package/dist/media/video/processor/transcoder.js

@@ -1,2 +1,283 @@
-// @bun
-import{yj as a,zj as b}from"../../../chunk-4x7kae4j.js";import"../../../chunk-rtr974rc.js";import"../../../chunk-j8tn8enq.js";import"../../../chunk-pcntd9h4.js";import"../../../chunk-ckxjqqn9.js";import"../../../chunk-jpndqst5.js";import"../../../chunk-xv34zbp4.js";export{b as processVideo,a as analyzeVideo};
+import { resolve, basename, extname, join } from "node:path";
+import { mkdir } from "node:fs/promises";
+import { hashFile, fileExists } from "../../shared/hash.js";
+import { getCachedVideoResult, setCachedVideoResult } from "./cache.js";
+import { generatePoster, generateThumbnails } from "./thumbnail.js";
+import { generateHLSManifest, generateDASHManifest } from "./streaming.js";
+async function getTsVideos() {
+  try {
+    return await import("ts-videos");
+  } catch {
+    return null;
+  }
+}
+function getQualityBitrate(preset) {
+  switch (preset) {
+    case "very-low":
+      return 500000;
+    case "low":
+      return 1e6;
+    case "medium":
+      return 2500000;
+    case "high":
+      return 5000000;
+    case "very-high":
+      return 1e7;
+    case "lossless":
+      return 0;
+    default:
+      return 2500000;
+  }
+}
+function getPlatformSettings(platform) {
+  switch (platform) {
+    case "youtube":
+      return {
+        codec: "h264",
+        maxWidth: 1920,
+        maxHeight: 1080,
+        frameRate: 30,
+        audioCodec: "aac",
+        audioBitrate: 128000
+      };
+    case "twitter":
+      return {
+        codec: "h264",
+        maxWidth: 1280,
+        maxHeight: 720,
+        frameRate: 30,
+        bitrate: 5000000,
+        audioCodec: "aac",
+        audioBitrate: 128000
+      };
+    case "instagram-feed":
+      return {
+        codec: "h264",
+        maxWidth: 1080,
+        maxHeight: 1080,
+        frameRate: 30,
+        bitrate: 3500000,
+        audioCodec: "aac",
+        audioBitrate: 128000
+      };
+    case "instagram-story":
+    case "instagram-reels":
+      return {
+        codec: "h264",
+        maxWidth: 1080,
+        maxHeight: 1920,
+        frameRate: 30,
+        bitrate: 3500000,
+        audioCodec: "aac",
+        audioBitrate: 128000
+      };
+    case "tiktok":
+      return {
+        codec: "h264",
+        maxWidth: 1080,
+        maxHeight: 1920,
+        frameRate: 30,
+        bitrate: 4000000,
+        audioCodec: "aac",
+        audioBitrate: 128000
+      };
+    case "discord":
+      return {
+        codec: "h264",
+        maxWidth: 1920,
+        maxHeight: 1080,
+        frameRate: 60,
+        bitrate: 8000000,
+        audioCodec: "aac",
+        audioBitrate: 192000
+      };
+    case "linkedin":
+      return {
+        codec: "h264",
+        maxWidth: 1920,
+        maxHeight: 1080,
+        frameRate: 30,
+        bitrate: 5000000,
+        audioCodec: "aac",
+        audioBitrate: 128000
+      };
+    case "facebook":
+      return {
+        codec: "h264",
+        maxWidth: 1280,
+        maxHeight: 720,
+        frameRate: 30,
+        bitrate: 4000000,
+        audioCodec: "aac",
+        audioBitrate: 128000
+      };
+    case "web-progressive":
+      return {
+        codec: "h264",
+        maxWidth: 1920,
+        maxHeight: 1080,
+        frameRate: 30,
+        audioCodec: "aac",
+        audioBitrate: 128000,
+        twoPass: !0
+      };
+    case "web-streaming":
+      return {
+        codec: "h264",
+        maxWidth: 1920,
+        maxHeight: 1080,
+        frameRate: 30,
+        audioCodec: "aac",
+        audioBitrate: 128000
+      };
+    default:
+      return {};
+  }
+}
+export async function analyzeVideo(src) {
+  const tsVideos = await getTsVideos();
+  if (!tsVideos)
+    return null;
+  try {
+    const srcPath = resolve(src), info = await new tsVideos.Input(srcPath).getInfo();
+    return {
+      duration: info.duration || 0,
+      width: info.width || 0,
+      height: info.height || 0,
+      frameRate: info.frameRate || 0,
+      bitrate: info.bitrate || 0,
+      codec: info.videoCodec || "",
+      audioCodec: info.audioCodec
+    };
+  } catch (error) {
+    console.warn(`[stx-media] Failed to analyze video: ${error}`);
+    return null;
+  }
+}
+export async function processVideo(src, options, config, onProgress) {
+  const tsVideos = await getTsVideos();
+  if (!tsVideos) {
+    console.warn("[stx-media] ts-videos not installed, skipping processing");
+    return { src, processed: !1 };
+  }
+  const cached = await getCachedVideoResult(src, options, config);
+  if (cached)
+    return cached;
+  try {
+    const srcPath = resolve(src);
+    if (!await fileExists(srcPath))
+      return { src, processed: !1, errors: [`Source file not found: ${src}`] };
+    const outputDir = config.outputDir || "dist/videos", baseUrl = config.baseUrl || "/videos";
+    await mkdir(outputDir, { recursive: !0 });
+    const srcHash = await hashFile(srcPath), srcBasename = basename(src, extname(src)), result = {
+      src,
+      processed: !0,
+      hash: srcHash
+    };
+    onProgress?.({ percentage: 5, stage: "analyzing" });
+    result.metadata = await analyzeVideo(srcPath) || void 0;
+    const qualitySettings = {};
+    if (options.quality)
+      qualitySettings.bitrate = getQualityBitrate(options.quality);
+    if (options.platform)
+      Object.assign(qualitySettings, getPlatformSettings(options.platform));
+    if (options.transcode)
+      Object.assign(qualitySettings, options.transcode);
+    if (Object.keys(qualitySettings).length > 0 || options.process) {
+      onProgress?.({ percentage: 10, stage: "transcoding" });
+      const outputFilename = `${srcBasename}-${srcHash}.mp4`, outputPath = join(outputDir, outputFilename);
+      try {
+        const transcodeResult = await transcodeVideo(srcPath, outputPath, qualitySettings, tsVideos, (p) => onProgress?.({ percentage: 10 + p * 0.5, stage: "transcoding" }));
+        if (transcodeResult)
+          result.transcoded = {
+            path: outputPath,
+            url: `${baseUrl}/${outputFilename}`,
+            duration: transcodeResult.duration,
+            size: transcodeResult.size,
+            video: {
+              codec: qualitySettings.codec || "h264",
+              width: transcodeResult.width,
+              height: transcodeResult.height,
+              bitrate: transcodeResult.bitrate,
+              frameRate: transcodeResult.frameRate
+            },
+            audio: transcodeResult.audioCodec ? {
+              codec: qualitySettings.audioCodec || "aac",
+              bitrate: qualitySettings.audioBitrate || 128000,
+              sampleRate: qualitySettings.sampleRate || 48000,
+              channels: qualitySettings.channels || 2
+            } : void 0
+          };
+      } catch (error) {
+        result.errors = result.errors || [];
+        result.errors.push(`Transcoding failed: ${error}`);
+      }
+    }
+    if (options.generatePoster) {
+      onProgress?.({ percentage: 65, stage: "generating-poster" });
+      const posterOpts = typeof options.generatePoster === "object" ? options.generatePoster : { timestamp: 0 }, poster = await generatePoster(srcPath, posterOpts, outputDir, baseUrl);
+      if (poster)
+        result.poster = poster;
+    }
+    if (config.thumbnails?.enabled) {
+      onProgress?.({ percentage: 70, stage: "generating-thumbnails" });
+      const thumbnails = await generateThumbnails(srcPath, config.thumbnails, outputDir, baseUrl);
+      if (thumbnails.length > 0)
+        result.thumbnails = thumbnails;
+    }
+    if (options.streaming) {
+      onProgress?.({ percentage: 80, stage: "generating-manifests" });
+      const streamConfig = typeof options.streaming === "object" ? options.streaming : config.streaming || { format: "hls" };
+      if (streamConfig.format === "hls" || streamConfig.format === void 0) {
+        const hls = await generateHLSManifest(srcPath, streamConfig.qualities || config.streaming?.defaultQualities || [], outputDir, baseUrl);
+        if (hls)
+          result.streaming = { ...result.streaming, hls };
+      }
+      if (streamConfig.format === "dash") {
+        const dash = await generateDASHManifest(srcPath, streamConfig.qualities || config.streaming?.defaultQualities || [], outputDir, baseUrl);
+        if (dash)
+          result.streaming = { ...result.streaming, dash };
+      }
+    }
+    if (options.spriteSheet)
+      onProgress?.({ percentage: 90, stage: "generating-sprite-sheet" });
+    onProgress?.({ percentage: 100, stage: "complete" });
+    await setCachedVideoResult(src, options, result, config);
+    return result;
+  } catch (error) {
+    return {
+      src,
+      processed: !1,
+      errors: [`Processing failed: ${error}`]
+    };
+  }
+}
+async function transcodeVideo(input, output, config, tsVideos, onProgress) {
+  try {
+    const result = await new tsVideos.Conversion(input, output, {
+      videoCodec: config.codec,
+      videoBitrate: config.bitrate,
+      width: config.maxWidth,
+      height: config.maxHeight,
+      frameRate: config.frameRate,
+      audioCodec: config.audioCodec,
+      audioBitrate: config.audioBitrate,
+      sampleRate: config.sampleRate,
+      channels: config.channels
+    }).run((progress) => {
+      onProgress?.(progress.percentage / 100);
+    });
+    return {
+      duration: result.duration || 0,
+      size: result.size || 0,
+      width: result.width || config.maxWidth || 0,
+      height: result.height || config.maxHeight || 0,
+      bitrate: result.bitrate || config.bitrate || 0,
+      frameRate: result.frameRate || config.frameRate || 30,
+      audioCodec: result.audioCodec
+    };
+  } catch (error) {
+    console.error(`[stx-media] Transcoding failed: ${error}`);
+    return null;
+  }
+}

package/dist/method-spoofing.js

@@ -1,2 +1,17 @@
-// @bun
-import{fu as a,gu as b,hu as c}from"./chunk-07y6m5xx.js";import"./chunk-xv34zbp4.js";export{b as processMethodDirectives,a as methodField,c as getOriginalMethod};
+const METHOD_FIELD_NAME = "_method";
+export function methodField(method, fieldName = METHOD_FIELD_NAME) {
+  const upperMethod = method.toUpperCase();
+  if (upperMethod === "GET" || upperMethod === "POST")
+    return "";
+  return `<input type="hidden" name="${fieldName}" value="${upperMethod}">`;
+}
+export function processMethodDirectives(template) {
+  return template.replace(/@method\(\s*(['"])([^'"]+)\1\s*(?:,\s*(['"])([^'"]+)\3\s*)?\)/g, (_, outerQuote, method, innerQuote, fieldName) => {
+    return methodField(method, fieldName || METHOD_FIELD_NAME);
+  });
+}
+export function getOriginalMethod(body, methodField = METHOD_FIELD_NAME) {
+  if (body && typeof body[methodField] === "string")
+    return body[methodField].toUpperCase();
+  return null;
+}

package/dist/middleware.js

@@ -1,2 +1,40 @@
-// @bun
-import{xs as a,ys as b,zs as c}from"./chunk-1xz0w746.js";import"./chunk-m8448qby.js";import"./chunk-kx6eb6ma.js";import"./chunk-g1vt329s.js";import"./chunk-7074g241.js";import"./chunk-9cf97f9p.js";import"./chunk-6djzdes9.js";import"./chunk-v7f8jj15.js";import"./chunk-keawsbpn.js";import"./chunk-8b3z0zd5.js";import"./chunk-hbgxbgam.js";import"./chunk-ejh8fyak.js";import"./chunk-krqn0ddk.js";import"./chunk-y1k17c8b.js";import"./chunk-2j21d3ka.js";import"./chunk-frg705zq.js";import"./chunk-hjm2xab3.js";import"./chunk-07y6m5xx.js";import"./chunk-wazkqv7n.js";import"./chunk-x05nxhyv.js";import"./chunk-31dr4bys.js";import"./chunk-mgj88zeq.js";import"./chunk-m167kjhv.js";import"./chunk-3a4qsygv.js";import"./chunk-dqn9gyhb.js";import"./chunk-988dw6q3.js";import"./chunk-8qc1bsym.js";import"./chunk-xyg1r5w0.js";import"./chunk-7gd339hd.js";import"./chunk-4deg33rw.js";import"./chunk-pa9zb7ty.js";import"./chunk-a2g2qb2y.js";import"./chunk-h5jxydqq.js";import"./chunk-nhv099jv.js";import"./chunk-shv88d2d.js";import"./chunk-0dx4q6yq.js";import"./chunk-ek2w6zvy.js";import"./chunk-9wmq2272.js";import"./chunk-7dkz6z2s.js";import"./chunk-9ecv8aqj.js";import"./chunk-bdk6g1vj.js";import"./chunk-xqq1vxb6.js";import"./chunk-amaa1bev.js";import"./chunk-r5m9xtm7.js";import"./chunk-bs3gmfxz.js";import"./chunk-1zgsgk4b.js";import"./chunk-2jxbwnkz.js";import"./chunk-zen6ax1y.js";import"./chunk-yb1t2h8h.js";import"./chunk-fjk3x41y.js";import"./chunk-5shey2e4.js";import"./chunk-27zsyhrd.js";import"./chunk-7ed3tean.js";import"./chunk-8vtm0m84.js";import"./chunk-tzwtg722.js";import"./chunk-ah88wzbg.js";import"./chunk-v8j49spx.js";import"./chunk-tg2f1mzq.js";import"./chunk-n9dhs1dw.js";import"./chunk-rwrv9wbf.js";import"./chunk-wg9k6h8w.js";import"./chunk-9jtj77jx.js";import"./chunk-qygvvygy.js";import"./chunk-gz5fmp3q.js";import"./chunk-vjbefncc.js";import"./chunk-8xj7c3mf.js";import"./chunk-qvrbjpdc.js";import"./chunk-w3b6m427.js";import"./chunk-rz2ec6g7.js";import"./chunk-35faj94w.js";import"./chunk-djddhmcc.js";import"./chunk-knm8a8yx.js";import"./chunk-xv34zbp4.js";export{b as runPreProcessingMiddleware,c as runPostProcessingMiddleware,a as processMiddleware};
+import { escapeHtml } from "./expressions.js";
+import { createDetailedErrorMessage } from "./utils.js";
+export async function processMiddleware(template, context, filePath, options, timing) {
+  if (!options.middleware || options.middleware.length === 0)
+    return template;
+  let output = template;
+  const middlewareToRun = options.middleware.filter((m) => m.timing === timing);
+  if (middlewareToRun.length === 0)
+    return output;
+  for (const middleware of middlewareToRun) {
+    if (!middleware.name || typeof middleware.handler !== "function") {
+      if (options.debug)
+        console.warn("Invalid middleware:", middleware);
+      continue;
+    }
+    try {
+      const result = await middleware.handler(output, context, filePath, options);
+      if (typeof result === "string")
+        output = result;
+      else if (options.debug)
+        console.warn(`Middleware ${middleware.name} did not return a string`);
+    } catch (error) {
+      if (options.debug)
+        console.error(`Error in middleware ${middleware.name}:`, error);
+      if (options.debug) {
+        const errorMessage = createDetailedErrorMessage("Middleware", `Error in middleware '${middleware.name}': ${error instanceof Error ? error.message : String(error)}`, filePath, template);
+        output = output.replace(/<body[^>]*>/, `$&
+<div style="color:red;background:#ffeeee;padding:10px;border:1px solid #ff0000;margin:10px 0;font-family:monospace;white-space:pre-wrap;">${escapeHtml(errorMessage)}</div>
+`);
+      }
+    }
+  }
+  return output;
+}
+export async function runPreProcessingMiddleware(template, context, filePath, options) {
+  return processMiddleware(template, context, filePath, options, "before");
+}
+export async function runPostProcessingMiddleware(template, context, filePath, options) {
+  return processMiddleware(template, context, filePath, options, "after");
+}