@lumy-pack/scene-sieve 0.0.1

package/dist/index.cjs

@@ -0,0 +1,936 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  extractScenes: () => runPipeline
+});
+module.exports = __toCommonJS(src_exports);
+
+// ../../node_modules/tsup/assets/cjs_shims.js
+var getImportMetaUrl = () => typeof document === "undefined" ? new URL(`file:${__filename}`).href : document.currentScript && document.currentScript.tagName.toUpperCase() === "SCRIPT" ? document.currentScript.src : new URL("main.js", document.baseURI).href;
+var importMetaUrl = /* @__PURE__ */ getImportMetaUrl();
+
+// src/core/orchestrator.ts
+var import_node_crypto = require("crypto");
+
+// src/utils/logger.ts
+var import_picocolors = __toESM(require("picocolors"), 1);
+var debugMode = false;
+function setDebugMode(enabled) {
+  debugMode = enabled;
+}
+function timestamp() {
+  return (/* @__PURE__ */ new Date()).toLocaleTimeString("en-US", { hour12: false });
+}
+var logger = {
+  info(message) {
+    console.log(`${import_picocolors.default.blue("info")} ${message}`);
+  },
+  success(message) {
+    console.log(`${import_picocolors.default.green("done")} ${message}`);
+  },
+  warn(message) {
+    console.warn(`${import_picocolors.default.yellow("warn")} ${message}`);
+  },
+  error(message) {
+    console.error(`${import_picocolors.default.red("error")} ${message}`);
+  },
+  debug(message) {
+    if (debugMode) {
+      console.log(`${import_picocolors.default.gray(`[${timestamp()}] debug`)} ${message}`);
+    }
+  }
+};
+
+// src/core/analyzer.ts
+var import_node_module = require("module");
+var import_sharp = __toESM(require("sharp"), 1);
+
+// src/constants.ts
+var import_node_os = require("os");
+var import_node_path = require("path");
+var APP_NAME = "scene-sieve";
+var DEFAULT_COUNT = 5;
+var DEFAULT_FPS = 5;
+var DEFAULT_SCALE = 720;
+var DEFAULT_QUALITY = 80;
+var WORKSPACE_PREFIX = `${APP_NAME}-`;
+var TEMP_BASE_DIR = (0, import_node_os.tmpdir)();
+var SUPPORTED_VIDEO_EXTENSIONS = [
+  ".mp4",
+  ".mov",
+  ".avi",
+  ".mkv",
+  ".webm"
+];
+var SUPPORTED_GIF_EXTENSIONS = [".gif"];
+var FRAME_OUTPUT_EXTENSION = ".jpg";
+var OPENCV_BATCH_SIZE = 10;
+var MIN_IFRAME_COUNT = 3;
+var DBSCAN_ALPHA = 0.03;
+var DBSCAN_MIN_PTS = 4;
+var IOU_THRESHOLD = 0.9;
+var DECAY_LAMBDA = 0.95;
+var ANIMATION_FRAME_THRESHOLD = 5;
+var MATCH_DISTANCE_THRESHOLD = 0.75;
+function getTempWorkspaceDir(sessionId) {
+  return (0, import_node_path.join)(TEMP_BASE_DIR, `${WORKSPACE_PREFIX}${sessionId}`);
+}
+
+// src/core/dbscan.ts
+var UNVISITED = -2;
+var NOISE = -1;
+function dbscan(points, imageWidth, imageHeight, alpha, minPts) {
+  if (points.length === 0) {
+    return { labels: [], boundingBoxes: [] };
+  }
+  const eps = (alpha ?? DBSCAN_ALPHA) * Math.sqrt(imageWidth ** 2 + imageHeight ** 2);
+  const epsSquared = eps * eps;
+  const minPoints = minPts ?? DBSCAN_MIN_PTS;
+  const labels = new Array(points.length).fill(UNVISITED);
+  let clusterId = 0;
+  for (let i = 0; i < points.length; i++) {
+    if (labels[i] !== UNVISITED) continue;
+    const neighbors = findNeighbors(points, i, epsSquared);
+    if (neighbors.length < minPoints) {
+      labels[i] = NOISE;
+      continue;
+    }
+    labels[i] = clusterId;
+    const seeds = [...neighbors];
+    const seedSet = new Set(seeds);
+    for (let si = 0; si < seeds.length; si++) {
+      const q = seeds[si];
+      if (labels[q] === NOISE) {
+        labels[q] = clusterId;
+      }
+      if (labels[q] !== UNVISITED) continue;
+      labels[q] = clusterId;
+      const qNeighbors = findNeighbors(points, q, epsSquared);
+      if (qNeighbors.length >= minPoints) {
+        for (const n of qNeighbors) {
+          if (!seedSet.has(n)) {
+            seedSet.add(n);
+            seeds.push(n);
+          }
+        }
+      }
+    }
+    clusterId++;
+  }
+  const boundingBoxes = [];
+  for (let c = 0; c < clusterId; c++) {
+    let minX = Infinity;
+    let minY = Infinity;
+    let maxX = -Infinity;
+    let maxY = -Infinity;
+    for (let i = 0; i < points.length; i++) {
+      if (labels[i] !== c) continue;
+      const p = points[i];
+      if (p.x < minX) minX = p.x;
+      if (p.y < minY) minY = p.y;
+      if (p.x > maxX) maxX = p.x;
+      if (p.y > maxY) maxY = p.y;
+    }
+    boundingBoxes.push({
+      x: minX,
+      y: minY,
+      width: maxX - minX,
+      height: maxY - minY
+    });
+  }
+  return { labels, boundingBoxes };
+}
+function findNeighbors(points, idx, epsSquared) {
+  const p = points[idx];
+  const neighbors = [];
+  for (let i = 0; i < points.length; i++) {
+    if (i === idx) continue;
+    const q = points[i];
+    const distSq = (p.x - q.x) ** 2 + (p.y - q.y) ** 2;
+    if (distSq <= epsSquared) {
+      neighbors.push(i);
+    }
+  }
+  return neighbors;
+}
+
+// src/core/analyzer.ts
+var OPENCV_INIT_TIMEOUT_MS = 3e4;
+var require2 = (0, import_node_module.createRequire)(importMetaUrl);
+var cvReady = null;
+async function ensureOpenCV() {
+  if (!cvReady) {
+    cvReady = (async () => {
+      const cvObj = require2("@techstark/opencv-js");
+      delete cvObj.then;
+      if (cvObj.Mat) return cvObj;
+      return new Promise((resolve2, reject) => {
+        const timeout = setTimeout(() => {
+          reject(new Error("OpenCV WASM initialization timed out after 30s"));
+        }, OPENCV_INIT_TIMEOUT_MS);
+        cvObj.onRuntimeInitialized = () => {
+          clearTimeout(timeout);
+          resolve2(cvObj);
+        };
+      });
+    })();
+  }
+  return cvReady;
+}
+async function preprocessFrame(framePath, scale) {
+  const { data, info } = await (0, import_sharp.default)(framePath).resize({ width: scale, withoutEnlargement: true }).grayscale().blur(1).raw().toBuffer({ resolveWithObject: true });
+  return {
+    data: new Uint8Array(data.buffer),
+    width: info.width,
+    height: info.height
+  };
+}
+function computeIoU(a, b) {
+  const ix1 = Math.max(a.x, b.x);
+  const iy1 = Math.max(a.y, b.y);
+  const ix2 = Math.min(a.x + a.width, b.x + b.width);
+  const iy2 = Math.min(a.y + a.height, b.y + b.height);
+  const iw = Math.max(0, ix2 - ix1);
+  const ih = Math.max(0, iy2 - iy1);
+  const intersection = iw * ih;
+  if (intersection === 0) return 0;
+  const aArea = a.width * a.height;
+  const bArea = b.width * b.height;
+  const union = aArea + bArea - intersection;
+  return union === 0 ? 0 : intersection / union;
+}
+var IoUTracker = class {
+  regions = [];
+  update(boxes, pairIndex) {
+    const animationIndices = /* @__PURE__ */ new Set();
+    const matched = /* @__PURE__ */ new Set();
+    for (let bi = 0; bi < boxes.length; bi++) {
+      const box = boxes[bi];
+      let bestIoU = 0;
+      let bestRegionIdx = -1;
+      for (let ri = 0; ri < this.regions.length; ri++) {
+        if (matched.has(ri)) continue;
+        const iou = computeIoU(box, this.regions[ri].box);
+        if (iou > bestIoU) {
+          bestIoU = iou;
+          bestRegionIdx = ri;
+        }
+      }
+      if (bestIoU > IOU_THRESHOLD && bestRegionIdx !== -1) {
+        const region = this.regions[bestRegionIdx];
+        const gap = pairIndex - region.lastSeen;
+        region.box = box;
+        region.consecutiveCount++;
+        region.lastSeen = pairIndex;
+        region.weight *= Math.pow(DECAY_LAMBDA, gap);
+        matched.add(bestRegionIdx);
+        if (region.consecutiveCount >= ANIMATION_FRAME_THRESHOLD) {
+          animationIndices.add(bi);
+        }
+      } else {
+        this.regions.push({
+          box,
+          consecutiveCount: 1,
+          lastSeen: pairIndex,
+          weight: 1
+        });
+      }
+    }
+    for (let ri = 0; ri < this.regions.length; ri++) {
+      if (!matched.has(ri)) {
+        const gap = pairIndex - this.regions[ri].lastSeen;
+        this.regions[ri].weight *= Math.pow(DECAY_LAMBDA, gap);
+      }
+    }
+    this.regions = this.regions.filter((r) => r.weight > 0.01);
+    return animationIndices;
+  }
+  getAnimationWeight(boxIndex, boxes) {
+    if (boxIndex >= boxes.length) return 0;
+    const box = boxes[boxIndex];
+    let maxWeight = 0;
+    for (const region of this.regions) {
+      if (region.consecutiveCount >= ANIMATION_FRAME_THRESHOLD) {
+        const iou = computeIoU(box, region.box);
+        if (iou > IOU_THRESHOLD) {
+          maxWeight = Math.max(maxWeight, region.weight);
+        }
+      }
+    }
+    return maxWeight;
+  }
+};
+async function computeAKAZEDiff(cvLib, frame1, frame2) {
+  const mat1 = cvLib.matFromImageData({
+    data: frame1.data,
+    width: frame1.width,
+    height: frame1.height
+  });
+  const mat2 = cvLib.matFromImageData({
+    data: frame2.data,
+    width: frame2.width,
+    height: frame2.height
+  });
+  const kp1 = new cvLib.KeyPointVector();
+  const kp2 = new cvLib.KeyPointVector();
+  const desc1 = new cvLib.Mat();
+  const desc2 = new cvLib.Mat();
+  const mask1 = new cvLib.Mat();
+  const mask2 = new cvLib.Mat();
+  const akaze = new cvLib.AKAZE();
+  let matches = null;
+  try {
+    akaze.detectAndCompute(mat1, mask1, kp1, desc1);
+    akaze.detectAndCompute(mat2, mask2, kp2, desc2);
+    const matchedKp1Indices = /* @__PURE__ */ new Set();
+    const matchedKp2Indices = /* @__PURE__ */ new Set();
+    if (desc1.rows > 0 && desc2.rows > 0) {
+      const matcher = new cvLib.BFMatcher(cvLib.NORM_HAMMING, false);
+      try {
+        matches = new cvLib.DMatchVectorVector();
+        matcher.knnMatch(desc1, desc2, matches, 2);
+        for (let i = 0; i < matches.size(); i++) {
+          const pair = matches.get(i);
+          if (pair.size() < 2) continue;
+          const m0 = pair.get(0);
+          const m1 = pair.get(1);
+          if (m0.distance < MATCH_DISTANCE_THRESHOLD * m1.distance) {
+            matchedKp1Indices.add(m0.queryIdx);
+            matchedKp2Indices.add(m0.trainIdx);
+          }
+        }
+      } finally {
+        matcher.delete();
+      }
+    }
+    const sNew = [];
+    for (let i = 0; i < kp2.size(); i++) {
+      if (!matchedKp2Indices.has(i)) {
+        const pt = kp2.get(i).pt;
+        sNew.push({ x: pt.x, y: pt.y });
+      }
+    }
+    const sLoss = [];
+    for (let i = 0; i < kp1.size(); i++) {
+      if (!matchedKp1Indices.has(i)) {
+        const pt = kp1.get(i).pt;
+        sLoss.push({ x: pt.x, y: pt.y });
+      }
+    }
+    return { sNew, sLoss };
+  } finally {
+    mat1.delete();
+    mat2.delete();
+    kp1.delete();
+    kp2.delete();
+    desc1.delete();
+    desc2.delete();
+    mask1.delete();
+    mask2.delete();
+    akaze.delete();
+    if (matches) matches.delete();
+  }
+}
+function computeInformationGain(clusters, clusterPoints, imageArea, animationIndices, animationWeights) {
+  if (clusters.length === 0) return 0;
+  let gain = 0;
+  for (let i = 0; i < clusters.length; i++) {
+    const box = clusters[i];
+    const clusterArea = box.width * box.height;
+    if (clusterArea <= 0) continue;
+    const normalizedArea = clusterArea / imageArea;
+    const featureDensity = clusterPoints[i] / clusterArea;
+    let contribution = normalizedArea * featureDensity;
+    if (animationIndices.has(i)) {
+      const animWeight = animationWeights[i] ?? 0;
+      contribution *= 1 - animWeight;
+    }
+    gain += contribution;
+  }
+  return gain;
+}
+async function analyzeBatch(cvLib, frames, scale, tracker, pairOffset) {
+  const edges = [];
+  const preprocessed = await Promise.all(
+    frames.map((f) => preprocessFrame(f.extractPath, scale))
+  );
+  const imageWidth = preprocessed[0]?.width ?? scale;
+  const imageHeight = preprocessed[0]?.height ?? Math.round(scale * 9 / 16);
+  const imageArea = imageWidth * imageHeight;
+  for (let i = 0; i < frames.length - 1; i++) {
+    const pairIndex = pairOffset + i;
+    try {
+      const { sNew } = await computeAKAZEDiff(
+        cvLib,
+        preprocessed[i],
+        preprocessed[i + 1]
+      );
+      const dbscanResult = dbscan(sNew, imageWidth, imageHeight);
+      const clusters = dbscanResult.boundingBoxes;
+      const clusterPointCounts = new Array(clusters.length).fill(0);
+      for (const label of dbscanResult.labels) {
+        if (label >= 0) {
+          clusterPointCounts[label]++;
+        }
+      }
+      const animationIndices = tracker.update(clusters, pairIndex);
+      const animationWeights = clusters.map(
+        (_, ci) => animationIndices.has(ci) ? tracker.getAnimationWeight(ci, clusters) : 0
+      );
+      const score = computeInformationGain(
+        clusters,
+        clusterPointCounts,
+        imageArea,
+        animationIndices,
+        animationWeights
+      );
+      logger.debug(`Edge ${frames[i].id}->${frames[i + 1].id} G(t)=${score.toFixed(6)}`);
+      edges.push({
+        sourceId: frames[i].id,
+        targetId: frames[i + 1].id,
+        score
+      });
+    } catch (err) {
+      logger.debug(`Frame pair analysis failed: ${String(err)}`);
+      edges.push({
+        sourceId: frames[i].id,
+        targetId: frames[i + 1].id,
+        score: 0
+      });
+    }
+  }
+  return edges;
+}
+async function analyzeFrames(ctx) {
+  const { frames } = ctx;
+  if (frames.length < 2) return [];
+  logger.debug(
+    `Analyzing ${frames.length} frames in batches of ${OPENCV_BATCH_SIZE}`
+  );
+  const cvLib = await ensureOpenCV();
+  const edges = [];
+  const tracker = new IoUTracker();
+  const scale = ctx.options.scale;
+  for (let i = 0; i < frames.length - 1; i += OPENCV_BATCH_SIZE) {
+    const batchEnd = Math.min(i + OPENCV_BATCH_SIZE + 1, frames.length);
+    const batch = frames.slice(i, batchEnd);
+    const batchEdges = await analyzeBatch(cvLib, batch, scale, tracker, i);
+    edges.push(...batchEdges);
+    const progress = Math.min(
+      100,
+      (i + OPENCV_BATCH_SIZE) / (frames.length - 1) * 100
+    );
+    ctx.emitProgress(progress);
+  }
+  logger.debug(`Computed ${edges.length} score edges`);
+  return edges;
+}
+
+// src/core/extractor.ts
+var import_promises2 = require("fs/promises");
+var import_node_path3 = require("path");
+var import_fluent_ffmpeg = __toESM(require("fluent-ffmpeg"), 1);
+var import_ffmpeg_static = __toESM(require("ffmpeg-static"), 1);
+var import_ffprobe = require("@ffprobe-installer/ffprobe");
+
+// src/utils/paths.ts
+var import_promises = require("fs/promises");
+var import_node_path2 = require("path");
+async function ensureDir(dirPath) {
+  await (0, import_promises.mkdir)(dirPath, { recursive: true });
+}
+async function fileExists(filePath) {
+  try {
+    await (0, import_promises.stat)(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function deriveOutputPath(inputPath) {
+  const dir = (0, import_node_path2.resolve)(inputPath, "..");
+  const name = (0, import_node_path2.basename)(inputPath, (0, import_node_path2.extname)(inputPath));
+  return (0, import_node_path2.resolve)(dir, `${name}_scenes`);
+}
+function isSupportedFile(filePath, extensions) {
+  return extensions.includes((0, import_node_path2.extname)(filePath).toLowerCase());
+}
+
+// src/core/extractor.ts
+if (import_ffmpeg_static.default) import_fluent_ffmpeg.default.setFfmpegPath(import_ffmpeg_static.default);
+import_fluent_ffmpeg.default.setFfprobePath(import_ffprobe.path);
+async function extractFrames(ctx) {
+  const framesDir = (0, import_node_path3.join)(ctx.workspacePath, "frames");
+  const { inputPath, fps, scale } = ctx.options;
+  if (!inputPath) {
+    throw new Error("inputPath is required for frame extraction");
+  }
+  const exists = await fileExists(inputPath);
+  if (!exists) {
+    throw new Error(`Input file not found: ${inputPath}`);
+  }
+  const allExtensions = [...SUPPORTED_VIDEO_EXTENSIONS, ...SUPPORTED_GIF_EXTENSIONS];
+  if (!isSupportedFile(inputPath, allExtensions)) {
+    throw new Error(`Unsupported file format: ${inputPath}`);
+  }
+  logger.debug(`Extracting frames from: ${inputPath}`);
+  await ensureDir(framesDir);
+  const isGif = isSupportedFile(inputPath, SUPPORTED_GIF_EXTENSIONS);
+  let frames;
+  if (isGif) {
+    logger.debug("GIF detected \u2014 using FPS extraction");
+    frames = await extractByFps(inputPath, framesDir, fps, scale);
+  } else {
+    frames = await extractIFrames(inputPath, framesDir, scale);
+    if (frames.length < MIN_IFRAME_COUNT) {
+      logger.debug(
+        `Insufficient I-frames (${frames.length}), falling back to FPS mode`
+      );
+      frames = await extractByFps(inputPath, framesDir, fps, scale);
+    }
+  }
+  ctx.emitProgress(100);
+  logger.debug(`Extracted ${frames.length} frames`);
+  return frames;
+}
+async function extractIFrames(inputPath, outputDir, scale) {
+  const outputPattern = (0, import_node_path3.join)(outputDir, "frame_%06d.jpg");
+  await new Promise((resolve2, reject) => {
+    (0, import_fluent_ffmpeg.default)(inputPath).outputOptions([
+      `-vf select='eq(pict_type,I)',scale=-1:${scale}`,
+      "-vsync vfr",
+      "-q:v 2"
+    ]).output(outputPattern).on("end", () => resolve2()).on("error", (err) => reject(err)).run();
+  });
+  return buildFrameList(outputDir, inputPath);
+}
+async function extractByFps(inputPath, outputDir, fps, scale) {
+  const outputPattern = (0, import_node_path3.join)(outputDir, "frame_%06d.jpg");
+  await new Promise((resolve2, reject) => {
+    (0, import_fluent_ffmpeg.default)(inputPath).outputOptions([
+      `-vf fps=${fps},scale=-1:${scale}`,
+      "-q:v 2"
+    ]).output(outputPattern).on("end", () => resolve2()).on("error", (err) => reject(err)).run();
+  });
+  return buildFrameList(outputDir, inputPath);
+}
+async function getVideoDuration(inputPath) {
+  return new Promise((resolve2, reject) => {
+    import_fluent_ffmpeg.default.ffprobe(inputPath, (err, metadata) => {
+      if (err) {
+        reject(err);
+        return;
+      }
+      resolve2(metadata.format.duration ?? 0);
+    });
+  });
+}
+async function buildFrameList(framesDir, inputPath) {
+  const files = await (0, import_promises2.readdir)(framesDir);
+  const jpgFiles = files.filter((f) => f.endsWith(".jpg")).sort();
+  if (jpgFiles.length === 0) {
+    return [];
+  }
+  let duration = 0;
+  try {
+    duration = await getVideoDuration(inputPath);
+  } catch {
+    logger.debug("Could not determine video duration; using frame index for timestamps");
+  }
+  return jpgFiles.map((file, index) => ({
+    id: index,
+    timestamp: duration > 0 && jpgFiles.length > 1 ? duration * index / (jpgFiles.length - 1) : index,
+    extractPath: (0, import_node_path3.join)(framesDir, file)
+  }));
+}
+
+// src/core/input-resolver.ts
+var import_node_path5 = require("path");
+
+// src/core/workspace.ts
+var import_promises3 = require("fs/promises");
+var import_node_path4 = require("path");
+var import_sharp2 = __toESM(require("sharp"), 1);
+async function createWorkspace(sessionId) {
+  const workspacePath = getTempWorkspaceDir(sessionId);
+  await ensureDir((0, import_node_path4.join)(workspacePath, "frames"));
+  await ensureDir((0, import_node_path4.join)(workspacePath, "output"));
+  return workspacePath;
+}
+async function finalizeOutput(ctx, selectedFrames) {
+  const stagingDir = (0, import_node_path4.join)(ctx.workspacePath, "output");
+  const outputPath = ctx.options.outputPath;
+  const quality = ctx.options.quality;
+  const outputFiles = [];
+  for (let i = 0; i < selectedFrames.length; i++) {
+    const frame = selectedFrames[i];
+    const destName = `scene_${String(i + 1).padStart(3, "0")}.jpg`;
+    const destPath = (0, import_node_path4.join)(stagingDir, destName);
+    await (0, import_sharp2.default)(frame.extractPath).jpeg({ quality, mozjpeg: true }).toFile(destPath);
+    outputFiles.push((0, import_node_path4.join)(outputPath, destName));
+  }
+  await ensureDir((0, import_node_path4.join)(outputPath, ".."));
+  await (0, import_promises3.rename)(stagingDir, outputPath);
+  return outputFiles;
+}
+async function cleanupWorkspace(workspacePath) {
+  if (!workspacePath) return;
+  try {
+    await (0, import_promises3.rm)(workspacePath, { recursive: true, force: true });
+  } catch {
+  }
+}
+async function writeInputBuffer(buffer, workspacePath) {
+  const inputDir = (0, import_node_path4.join)(workspacePath, "input");
+  await ensureDir(inputDir);
+  const tempPath = (0, import_node_path4.join)(inputDir, "input.mp4");
+  await (0, import_promises3.writeFile)(tempPath, buffer);
+  return tempPath;
+}
+async function writeInputFrames(frames, workspacePath) {
+  const framesDir = (0, import_node_path4.join)(workspacePath, "frames");
+  await ensureDir(framesDir);
+  const frameNodes = [];
+  for (let i = 0; i < frames.length; i++) {
+    const filename = `frame_${String(i).padStart(6, "0")}${FRAME_OUTPUT_EXTENSION}`;
+    const extractPath = (0, import_node_path4.join)(framesDir, filename);
+    await (0, import_promises3.writeFile)(extractPath, frames[i]);
+    frameNodes.push({ id: i, timestamp: i, extractPath });
+  }
+  return frameNodes;
+}
+async function readFramesAsBuffers(frameNodes, quality) {
+  return Promise.all(
+    frameNodes.map(
+      (f) => (0, import_sharp2.default)(f.extractPath).jpeg({ quality, mozjpeg: true }).toBuffer()
+    )
+  );
+}
+
+// src/core/input-resolver.ts
+function resolveOptions(options) {
+  const mode = options.mode;
+  const inputPath = mode === "file" ? options.inputPath : void 0;
+  const outputPath = options.outputPath ?? (inputPath ? deriveOutputPath(inputPath) : (0, import_node_path5.join)(process.cwd(), "scene-sieve-output"));
+  const threshold = options.threshold;
+  if (threshold !== void 0 && (threshold <= 0 || threshold > 1)) {
+    throw new Error(
+      `threshold must be in range (0, 1], received: ${threshold}`
+    );
+  }
+  const hasThreshold = threshold !== void 0;
+  const hasExplicitCount = options.count !== void 0;
+  const pruneMode = hasThreshold && hasExplicitCount ? "threshold-with-cap" : hasThreshold ? "threshold" : "count";
+  return {
+    mode,
+    inputPath,
+    count: options.count ?? DEFAULT_COUNT,
+    threshold,
+    pruneMode,
+    outputPath,
+    fps: options.fps ?? DEFAULT_FPS,
+    scale: options.scale ?? DEFAULT_SCALE,
+    quality: options.quality ?? DEFAULT_QUALITY,
+    debug: options.debug ?? false
+  };
+}
+async function resolveInput(options, workspacePath) {
+  if (options.mode === "file") {
+    return { frames: [], resolvedInputPath: options.inputPath };
+  }
+  if (options.mode === "buffer") {
+    const resolvedInputPath = await writeInputBuffer(options.inputBuffer, workspacePath);
+    return { frames: [], resolvedInputPath };
+  }
+  if (options.mode === "frames") {
+    const frames = await writeInputFrames(options.inputFrames, workspacePath);
+    return { frames };
+  }
+  throw new Error(`Unsupported input mode: ${options.mode}`);
+}
+
+// src/utils/min-heap.ts
+var MinHeap = class {
+  h = [];
+  get size() {
+    return this.h.length;
+  }
+  push(entry) {
+    this.h.push(entry);
+    this.siftUp(this.h.length - 1);
+  }
+  pop() {
+    const n = this.h.length;
+    if (n === 0) return void 0;
+    const top = this.h[0];
+    const last = this.h.pop();
+    if (n > 1) {
+      this.h[0] = last;
+      this.siftDown(0);
+    }
+    return top;
+  }
+  siftUp(i) {
+    while (i > 0) {
+      const p = i - 1 >> 1;
+      if (this.h[p].score <= this.h[i].score) break;
+      [this.h[p], this.h[i]] = [this.h[i], this.h[p]];
+      i = p;
+    }
+  }
+  siftDown(i) {
+    const n = this.h.length;
+    for (; ; ) {
+      let m = i;
+      const l = 2 * i + 1;
+      const r = 2 * i + 2;
+      if (l < n && this.h[l].score < this.h[m].score) m = l;
+      if (r < n && this.h[r].score < this.h[m].score) m = r;
+      if (m === i) break;
+      [this.h[m], this.h[i]] = [this.h[i], this.h[m]];
+      i = m;
+    }
+  }
+};
+
+// src/core/pruner.ts
+function pruneTo(graph, frames, targetCount) {
+  if (frames.length <= targetCount) {
+    return new Set(frames.map((f) => f.id));
+  }
+  const prev = /* @__PURE__ */ new Map();
+  const next = /* @__PURE__ */ new Map();
+  for (let i = 0; i < frames.length; i++) {
+    if (i > 0) prev.set(frames[i].id, frames[i - 1].id);
+    if (i < frames.length - 1) next.set(frames[i].id, frames[i + 1].id);
+  }
+  const edgeScore = /* @__PURE__ */ new Map();
+  const heap = new MinHeap();
+  for (const edge of graph) {
+    edgeScore.set(`${edge.sourceId}:${edge.targetId}`, edge.score);
+    heap.push({ score: edge.score, srcId: edge.sourceId, tgtId: edge.targetId });
+  }
+  const surviving = new Set(frames.map((f) => f.id));
+  const firstId = frames[0].id;
+  const lastId = frames[frames.length - 1].id;
+  while (surviving.size > targetCount && heap.size > 0) {
+    const entry = heap.pop();
+    if (!surviving.has(entry.srcId) || !surviving.has(entry.tgtId)) continue;
+    const key = `${entry.srcId}:${entry.tgtId}`;
+    if (edgeScore.get(key) !== entry.score) continue;
+    if (entry.tgtId === firstId || entry.tgtId === lastId) continue;
+    surviving.delete(entry.tgtId);
+    edgeScore.delete(key);
+    const tgtNext = next.get(entry.tgtId);
+    if (tgtNext !== void 0) {
+      const rightKey = `${entry.tgtId}:${tgtNext}`;
+      const rightScore = edgeScore.get(rightKey) ?? 0;
+      edgeScore.delete(rightKey);
+      const newScore = Math.max(entry.score, rightScore);
+      edgeScore.set(`${entry.srcId}:${tgtNext}`, newScore);
+      heap.push({ score: newScore, srcId: entry.srcId, tgtId: tgtNext });
+      next.set(entry.srcId, tgtNext);
+      prev.set(tgtNext, entry.srcId);
+    } else {
+      next.delete(entry.srcId);
+    }
+    prev.delete(entry.tgtId);
+    next.delete(entry.tgtId);
+  }
+  return surviving;
+}
+function normalizeScores(graph) {
+  if (graph.length === 0) return [];
+  const safeScores = graph.map(
+    (e) => Number.isFinite(e.score) && e.score > 0 ? e.score : 0
+  );
+  const maxScore = Math.max(...safeScores);
+  if (maxScore === 0) return safeScores;
+  return safeScores.map((s) => s / maxScore);
+}
+function pruneByThreshold(graph, frames, threshold) {
+  if (frames.length === 0) return /* @__PURE__ */ new Set();
+  const surviving = /* @__PURE__ */ new Set();
+  surviving.add(frames[0].id);
+  surviving.add(frames[frames.length - 1].id);
+  const normalized = normalizeScores(graph);
+  for (let i = 0; i < graph.length; i++) {
+    if (normalized[i] >= threshold) {
+      surviving.add(graph[i].targetId);
+    }
+  }
+  return surviving;
+}
+function pruneByThresholdWithCap(graph, frames, threshold, maxCount) {
+  const thresholdSurvivors = pruneByThreshold(graph, frames, threshold);
+  if (thresholdSurvivors.size <= maxCount) {
+    return thresholdSurvivors;
+  }
+  const survivingFrames = frames.filter((f) => thresholdSurvivors.has(f.id));
+  const idToOrigIdx = /* @__PURE__ */ new Map();
+  for (let i = 0; i < frames.length; i++) {
+    idToOrigIdx.set(frames[i].id, i);
+  }
+  const edgeLookup = /* @__PURE__ */ new Map();
+  for (const e of graph) {
+    edgeLookup.set(`${e.sourceId}:${e.targetId}`, e.score);
+  }
+  const syntheticEdges = [];
+  for (let i = 0; i < survivingFrames.length - 1; i++) {
+    const srcSurvivor = survivingFrames[i];
+    const tgtSurvivor = survivingFrames[i + 1];
+    const srcOrigIdx = idToOrigIdx.get(srcSurvivor.id);
+    const tgtOrigIdx = idToOrigIdx.get(tgtSurvivor.id);
+    let minScore = Infinity;
+    for (let j = srcOrigIdx; j < tgtOrigIdx; j++) {
+      const fromId = frames[j].id;
+      const toId = frames[j + 1].id;
+      const score = edgeLookup.get(`${fromId}:${toId}`) ?? 0;
+      if (score < minScore) {
+        minScore = score;
+      }
+    }
+    syntheticEdges.push({
+      sourceId: srcSurvivor.id,
+      targetId: tgtSurvivor.id,
+      score: minScore === Infinity ? 0 : minScore
+    });
+  }
+  return pruneTo(syntheticEdges, survivingFrames, maxCount);
+}
+
+// src/core/orchestrator.ts
+async function runPipeline(options) {
+  const startTime = Date.now();
+  const sessionId = (0, import_node_crypto.randomUUID)();
+  const debug = options.debug ?? false;
+  if (debug) setDebugMode(true);
+  const resolvedOptions = resolveOptions(options);
+  const ctx = {
+    options: resolvedOptions,
+    workspacePath: "",
+    frames: [],
+    graph: [],
+    status: "INIT",
+    emitProgress: (percent) => {
+      if (options.onProgress && ctx.status !== "INIT" && ctx.status !== "SUCCESS" && ctx.status !== "FAILED") {
+        options.onProgress(ctx.status, percent);
+      }
+    }
+  };
+  try {
+    ctx.workspacePath = await createWorkspace(sessionId);
+    logger.debug(`Workspace created: ${ctx.workspacePath}`);
+    ctx.status = "EXTRACTING";
+    const { frames: resolvedFrames, resolvedInputPath } = await resolveInput(
+      options,
+      ctx.workspacePath
+    );
+    if (resolvedOptions.mode === "frames") {
+      ctx.frames = resolvedFrames;
+    } else {
+      const extractCtx = {
+        ...ctx,
+        options: {
+          ...resolvedOptions,
+          inputPath: resolvedInputPath
+        }
+      };
+      ctx.frames = await extractFrames(extractCtx);
+    }
+    ctx.emitProgress(100);
+    ctx.status = "ANALYZING";
+    ctx.graph = await analyzeFrames(ctx);
+    ctx.status = "PRUNING";
+    let survivingIds;
+    switch (resolvedOptions.pruneMode) {
+      case "threshold-with-cap":
+        survivingIds = pruneByThresholdWithCap(
+          ctx.graph,
+          ctx.frames,
+          resolvedOptions.threshold,
+          resolvedOptions.count
+        );
+        break;
+      case "threshold":
+        survivingIds = pruneByThreshold(
+          ctx.graph,
+          ctx.frames,
+          resolvedOptions.threshold
+        );
+        break;
+      case "count":
+      default:
+        survivingIds = pruneTo(ctx.graph, ctx.frames, resolvedOptions.count);
+        break;
+    }
+    const prunedFrames = ctx.frames.filter((f) => survivingIds.has(f.id));
+    ctx.emitProgress(100);
+    ctx.status = "FINALIZING";
+    let outputFiles = [];
+    let outputBuffers;
+    if (resolvedOptions.mode === "buffer" || resolvedOptions.mode === "frames") {
+      outputBuffers = await readFramesAsBuffers(prunedFrames, resolvedOptions.quality);
+      ctx.emitProgress(100);
+    } else {
+      outputFiles = await finalizeOutput(ctx, prunedFrames);
+      ctx.emitProgress(100);
+    }
+    ctx.status = "SUCCESS";
+    logger.success(
+      `Extracted ${prunedFrames.length} scenes from ${ctx.frames.length} frames`
+    );
+    return {
+      success: true,
+      originalFramesCount: ctx.frames.length,
+      prunedFramesCount: prunedFrames.length,
+      outputFiles,
+      outputBuffers,
+      executionTimeMs: Date.now() - startTime
+    };
+  } catch (error) {
+    ctx.status = "FAILED";
+    ctx.error = error instanceof Error ? error : new Error(String(error));
+    logger.error(`Pipeline failed: ${ctx.error.message}`);
+    throw ctx.error;
+  } finally {
+    if (!resolvedOptions.debug) {
+      await cleanupWorkspace(ctx.workspacePath);
+    } else {
+      logger.debug(`Debug mode: workspace preserved at ${ctx.workspacePath}`);
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  extractScenes
+});