@lumy-pack/scene-sieve 0.0.4 → 0.0.6

package/dist/pipeline-worker.mjs

@@ -0,0 +1,1136 @@
+// src/core/pipeline-worker.ts
+import { parentPort, workerData } from "worker_threads";
+
+// src/core/orchestrator.ts
+import { randomUUID } from "crypto";
+
+// src/utils/logger.ts
+import pc from "picocolors";
+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(`${pc.blue("info")} ${message}`);
+  },
+  success(message) {
+    console.log(`
+${pc.green("done")} ${message}`);
+  },
+  warn(message) {
+    console.warn(`${pc.yellow("warn")} ${message}`);
+  },
+  error(message) {
+    console.error(`${pc.red("error")} ${message}`);
+  },
+  debug(message) {
+    if (debugMode) {
+      console.log(`${pc.gray(`[${timestamp()}] debug`)} ${message}`);
+    }
+  }
+};
+
+// src/core/analyzer.ts
+import { createRequire } from "module";
+import sharp from "sharp";
+
+// src/constants.ts
+import { tmpdir } from "os";
+import { join } from "path";
+var APP_NAME = "scene-sieve";
+var DEFAULT_COUNT = 20;
+var DEFAULT_THRESHOLD = 0.5;
+var DEFAULT_FPS = 5;
+var DEFAULT_SCALE = 720;
+var DEFAULT_QUALITY = 80;
+var DEFAULT_MAX_FRAMES = 300;
+var NORMALIZATION_PERCENTILE = 0.9;
+var WORKSPACE_PREFIX = `${APP_NAME}-`;
+var TEMP_BASE_DIR = tmpdir();
+var SUPPORTED_VIDEO_EXTENSIONS = [
+  ".mp4",
+  ".mov",
+  ".avi",
+  ".mkv",
+  ".webm"
+];
+var SUPPORTED_GIF_EXTENSIONS = [".gif"];
+var FRAME_OUTPUT_EXTENSION = ".jpg";
+var FRAME_FILENAME_PATTERN = "frame_%06d.jpg";
+var OPENCV_BATCH_SIZE = 10;
+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.25;
+var PIXELDIFF_GAUSSIAN_KERNEL = 3;
+var PIXELDIFF_BINARY_THRESHOLD = 30;
+var PIXELDIFF_CONTOUR_MIN_AREA = 100;
+var PIXELDIFF_SAMPLE_SPACING = 8;
+function getTempWorkspaceDir(sessionId) {
+  return 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 = createRequire(import.meta.url);
+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 sharp(framePath).resize({ width: scale, withoutEnlargement: true }).grayscale().blur(1).raw().toBuffer({ resolveWithObject: true });
+  return {
+    data: new Uint8Array(data.buffer, data.byteOffset, data.byteLength),
+    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 {
+  constructor(fps = DEFAULT_FPS, iouThreshold = IOU_THRESHOLD, animationThreshold = ANIMATION_FRAME_THRESHOLD) {
+    this.fps = fps;
+    this.iouThreshold = iouThreshold;
+    this.animationThreshold = animationThreshold;
+  }
+  regions = [];
+  extractedAnimations = [];
+  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 > this.iouThreshold && 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 >= this.animationThreshold) {
+          animationIndices.add(bi);
+        }
+      } else {
+        this.regions.push({
+          box,
+          consecutiveCount: 1,
+          firstSeen: pairIndex,
+          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);
+      }
+    }
+    for (let i = 0; i < this.regions.length; i++) {
+      const region = this.regions[i];
+      if (region.weight <= 0.01 && !matched.has(i)) {
+        this.collectAnimation(region);
+      }
+    }
+    this.regions = this.regions.filter(
+      (r, i) => r.weight > 0.01 || matched.has(i)
+    );
+    return animationIndices;
+  }
+  collectAnimation(region) {
+    if (region.consecutiveCount >= this.animationThreshold) {
+      const durationMs = region.consecutiveCount / this.fps * 1e3;
+      this.extractedAnimations.push({
+        type: "loading_spinner",
+        // 기본값으로 loading_spinner 사용
+        boundingBox: region.box,
+        startFrameId: region.firstSeen,
+        endFrameId: region.lastSeen,
+        durationMs
+      });
+    }
+  }
+  flushAndGetAnimations() {
+    for (const region of this.regions) {
+      this.collectAnimation(region);
+    }
+    this.regions = [];
+    return this.extractedAnimations;
+  }
+  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 >= this.animationThreshold) {
+        const iou = computeIoU(box, region.box);
+        if (iou > this.iouThreshold) {
+          maxWeight = Math.max(maxWeight, region.weight);
+        }
+      }
+    }
+    return maxWeight;
+  }
+};
+async function computeAKAZEDiff(cvLib, frame1, frame2) {
+  const cv = cvLib;
+  const mat1 = new cv.Mat(frame1.height, frame1.width, cv.CV_8UC1);
+  mat1.data.set(frame1.data);
+  const mat2 = new cv.Mat(frame2.height, frame2.width, cv.CV_8UC1);
+  mat2.data.set(frame2.data);
+  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 computePixelDiff(cvLib, frame1, frame2) {
+  const cv = cvLib;
+  const mat1 = new cv.Mat(frame1.height, frame1.width, cv.CV_8UC1);
+  const mat2 = new cv.Mat(frame2.height, frame2.width, cv.CV_8UC1);
+  const diff = new cv.Mat();
+  const blurred = new cv.Mat();
+  const binary = new cv.Mat();
+  const contours = new cv.MatVector();
+  const hierarchy = new cv.Mat();
+  try {
+    mat1.data.set(frame1.data);
+    mat2.data.set(frame2.data);
+    cv.absdiff(mat1, mat2, diff);
+    const ksize = new cv.Size(
+      PIXELDIFF_GAUSSIAN_KERNEL,
+      PIXELDIFF_GAUSSIAN_KERNEL
+    );
+    cv.GaussianBlur(diff, blurred, ksize, 0);
+    cv.threshold(
+      blurred,
+      binary,
+      PIXELDIFF_BINARY_THRESHOLD,
+      255,
+      cv.THRESH_BINARY
+    );
+    cv.findContours(
+      binary,
+      contours,
+      hierarchy,
+      cv.RETR_EXTERNAL,
+      cv.CHAIN_APPROX_SIMPLE
+    );
+    const points = [];
+    for (let c = 0; c < contours.size(); c++) {
+      const contour = contours.get(c);
+      const rect = cv.boundingRect(contour);
+      if (rect.width * rect.height < PIXELDIFF_CONTOUR_MIN_AREA) continue;
+      for (let y = rect.y; y < rect.y + rect.height; y += PIXELDIFF_SAMPLE_SPACING) {
+        for (let x = rect.x; x < rect.x + rect.width; x += PIXELDIFF_SAMPLE_SPACING) {
+          points.push({ x, y });
+        }
+      }
+    }
+    return points;
+  } finally {
+    mat1.delete();
+    mat2.delete();
+    diff.delete();
+    blurred.delete();
+    binary.delete();
+    contours.delete();
+    hierarchy.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]
+      );
+      let dbscanResult = dbscan(sNew, imageWidth, imageHeight);
+      let clusters = dbscanResult.boundingBoxes;
+      if (clusters.length === 0) {
+        const pixelDiffPoints = computePixelDiff(
+          cvLib,
+          preprocessed[i],
+          preprocessed[i + 1]
+        );
+        if (pixelDiffPoints.length > 0) {
+          logger.debug(
+            `Edge ${frames[i].id}->${frames[i + 1].id}: pixel-diff fallback (${pixelDiffPoints.length} points)`
+          );
+          dbscanResult = dbscan(
+            pixelDiffPoints,
+            imageWidth,
+            imageHeight,
+            void 0,
+            2
+          );
+          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 { edges: [], animations: [] };
+  logger.debug(
+    `Analyzing ${frames.length} frames in batches of ${OPENCV_BATCH_SIZE}`
+  );
+  const cvLib = await ensureOpenCV();
+  const edges = [];
+  const tracker = new IoUTracker(
+    ctx.options.fps,
+    ctx.options.iouThreshold,
+    ctx.options.animationThreshold
+  );
+  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);
+  }
+  const animations = tracker.flushAndGetAnimations();
+  logger.debug(
+    `Computed ${edges.length} score edges and ${animations.length} animations`
+  );
+  return { edges, animations };
+}
+
+// src/core/extractor.ts
+import { readdir } from "fs/promises";
+import { join as join2 } from "path";
+import { path as ffprobePath } from "@ffprobe-installer/ffprobe";
+import { execa } from "execa";
+import ffmpegPath from "ffmpeg-static";
+
+// src/utils/paths.ts
+import { mkdir, stat } from "fs/promises";
+import { homedir } from "os";
+import { basename, extname, resolve } from "path";
+async function ensureDir(dirPath) {
+  await mkdir(dirPath, { recursive: true });
+}
+async function fileExists(filePath) {
+  try {
+    await stat(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function expandTilde(p) {
+  if (p === "~") return homedir();
+  if (p.startsWith("~/") || p.startsWith("~\\")) {
+    return resolve(homedir(), p.slice(2));
+  }
+  return p;
+}
+function resolveAbsolute(p) {
+  return resolve(expandTilde(p));
+}
+function deriveOutputPath(inputPath) {
+  const dir = resolve(inputPath, "..");
+  const name = basename(inputPath, extname(inputPath));
+  return resolve(dir, `${name}_scenes`);
+}
+function isSupportedFile(filePath, extensions) {
+  return extensions.includes(extname(filePath).toLowerCase());
+}
+
+// src/core/extractor.ts
+async function extractFrames(ctx) {
+  const framesDir = join2(ctx.workspacePath, "frames");
+  const { inputPath, fps, maxFrames, 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);
+  let effectiveFps = fps;
+  const duration = await getVideoDuration(inputPath).catch(() => 0);
+  if (duration > 0) {
+    const fpsCap = maxFrames / duration;
+    effectiveFps = Math.min(fps, fpsCap);
+    effectiveFps = Math.max(0.5, effectiveFps);
+    logger.debug(
+      `Duration: ${duration.toFixed(1)}s, FPS: ${fps} \u2192 effective: ${effectiveFps.toFixed(2)} (maxFrames: ${maxFrames})`
+    );
+  }
+  const frames = await extractByFps(inputPath, framesDir, effectiveFps, scale);
+  ctx.emitProgress(100);
+  logger.debug(`Extracted ${frames.length} frames`);
+  return frames;
+}
+async function extractByFps(inputPath, outputDir, fps, scale) {
+  const outputPattern = join2(outputDir, FRAME_FILENAME_PATTERN);
+  await execa(ffmpegPath, [
+    "-i",
+    inputPath,
+    "-vf",
+    `fps=${fps},scale=-1:${scale}`,
+    "-q:v",
+    "2",
+    outputPattern
+  ]);
+  return buildFrameList(outputDir, inputPath);
+}
+async function getVideoDuration(inputPath) {
+  const { stdout } = await execa(ffprobePath, [
+    "-v",
+    "quiet",
+    "-print_format",
+    "json",
+    "-show_format",
+    inputPath
+  ]);
+  const metadata = JSON.parse(stdout);
+  return parseFloat(metadata.format?.duration ?? "0");
+}
+async function buildFrameList(framesDir, inputPath) {
+  const files = await 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: join2(framesDir, file)
+  }));
+}
+
+// src/core/input-resolver.ts
+import { join as join4 } from "path";
+
+// src/core/workspace.ts
+import { readdir as readdir2, rename, rm, stat as stat2, writeFile } from "fs/promises";
+import { join as join3 } from "path";
+import sharp2 from "sharp";
+async function createWorkspace(sessionId) {
+  const workspacePath = getTempWorkspaceDir(sessionId);
+  await ensureDir(join3(workspacePath, "frames"));
+  await ensureDir(join3(workspacePath, "output"));
+  return workspacePath;
+}
+async function finalizeOutput(ctx, selectedFrames) {
+  const stagingDir = join3(ctx.workspacePath, "output");
+  const outputPath = ctx.options.outputPath;
+  const quality = ctx.options.quality;
+  const outputFiles = [];
+  const framesMetadata = [];
+  const totalFramesCount = ctx.frames.length;
+  const padding = Math.max(4, String(totalFramesCount).length);
+  for (let i = 0; i < selectedFrames.length; i++) {
+    const frame = selectedFrames[i];
+    const fileName = `frame_${String(frame.id + 1).padStart(padding, "0")}.jpg`;
+    const destPath = join3(stagingDir, fileName);
+    await sharp2(frame.extractPath).jpeg({ quality, mozjpeg: true }).toFile(destPath);
+    outputFiles.push(join3(outputPath, fileName));
+    framesMetadata.push({
+      step: i + 1,
+      fileName,
+      frameId: frame.id + 1,
+      timestampMs: Math.round(frame.timestamp * 1e3)
+    });
+  }
+  const metadata = {
+    video: {
+      originalDurationMs: Math.round(
+        (ctx.frames.length > 0 ? ctx.frames[ctx.frames.length - 1].timestamp : 0) * 1e3
+      ),
+      fps: ctx.options.fps,
+      resolution: {
+        width: ctx.options.scale,
+        height: Math.round(ctx.options.scale * 9 / 16)
+      }
+    },
+    frames: framesMetadata,
+    animations: (ctx.animations || []).map((anim) => ({
+      ...anim,
+      startFrameId: anim.startFrameId + 1,
+      endFrameId: anim.endFrameId + 1,
+      durationMs: Math.round(anim.durationMs)
+    }))
+  };
+  const metadataPath = join3(stagingDir, ".metadata.json");
+  await writeFile(metadataPath, JSON.stringify(metadata, null, 2));
+  outputFiles.push(join3(outputPath, ".metadata.json"));
+  await ensureDir(join3(outputPath, ".."));
+  await rm(outputPath, { recursive: true, force: true });
+  await rename(stagingDir, outputPath);
+  return outputFiles;
+}
+async function cleanupWorkspace(workspacePath) {
+  if (!workspacePath) return;
+  try {
+    await rm(workspacePath, { recursive: true, force: true });
+  } catch {
+  }
+}
+var STALE_THRESHOLD_MS = 60 * 60 * 1e3;
+async function writeInputBuffer(buffer, workspacePath) {
+  const inputDir = join3(workspacePath, "input");
+  await ensureDir(inputDir);
+  const tempPath = join3(inputDir, "input.mp4");
+  await writeFile(tempPath, buffer);
+  return tempPath;
+}
+async function writeInputFrames(frames, workspacePath) {
+  const framesDir = join3(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 = join3(framesDir, filename);
+    await writeFile(extractPath, frames[i]);
+    frameNodes.push({ id: i, timestamp: i, extractPath });
+  }
+  return frameNodes;
+}
+async function readFramesAsBuffers(frameNodes, quality) {
+  return Promise.all(
+    frameNodes.map(
+      (f) => sharp2(f.extractPath).jpeg({ quality, mozjpeg: true }).toBuffer()
+    )
+  );
+}
+
+// src/core/input-resolver.ts
+function resolveOptions(options2) {
+  const mode = options2.mode;
+  const inputPath = mode === "file" ? resolveAbsolute(options2.inputPath) : void 0;
+  const outputPath = options2.outputPath ?? (inputPath ? deriveOutputPath(inputPath) : join4(process.cwd(), "scene-sieve-output"));
+  const threshold = options2.threshold ?? DEFAULT_THRESHOLD;
+  if (threshold <= 0 || threshold > 1) {
+    throw new Error(
+      `threshold must be in range (0, 1], received: ${threshold}`
+    );
+  }
+  const pruneMode = "threshold-with-cap";
+  return {
+    mode,
+    inputPath,
+    count: options2.count ?? DEFAULT_COUNT,
+    threshold,
+    pruneMode,
+    outputPath,
+    fps: options2.fps ?? DEFAULT_FPS,
+    maxFrames: options2.maxFrames ?? DEFAULT_MAX_FRAMES,
+    scale: options2.scale ?? DEFAULT_SCALE,
+    quality: options2.quality ?? DEFAULT_QUALITY,
+    iouThreshold: options2.iouThreshold ?? IOU_THRESHOLD,
+    animationThreshold: options2.animationThreshold ?? ANIMATION_FRAME_THRESHOLD,
+    debug: options2.debug ?? false
+  };
+}
+async function resolveInput(options2, workspacePath) {
+  if (options2.mode === "file") {
+    return {
+      frames: [],
+      resolvedInputPath: resolveAbsolute(options2.inputPath)
+    };
+  }
+  if (options2.mode === "buffer") {
+    const resolvedInputPath = await writeInputBuffer(
+      options2.inputBuffer,
+      workspacePath
+    );
+    return { frames: [], resolvedInputPath };
+  }
+  if (options2.mode === "frames") {
+    const frames = await writeInputFrames(options2.inputFrames, workspacePath);
+    return { frames };
+  }
+  throw new Error(`Unsupported input mode: ${options2.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 sorted = [...safeScores].filter((s) => s > 0).sort((a, b) => a - b);
+  if (sorted.length === 0) return safeScores;
+  const pIdx = Math.min(
+    Math.floor(sorted.length * NORMALIZATION_PERCENTILE),
+    sorted.length - 1
+  );
+  const refScore = sorted[pIdx];
+  return safeScores.map((s) => Math.min(s / refScore, 1));
+}
+function suppressConsecutiveRuns(graph, passingIndices, normalizedScores) {
+  const result = /* @__PURE__ */ new Set();
+  let runStart = 0;
+  while (runStart < passingIndices.length) {
+    let runEnd = runStart;
+    while (runEnd + 1 < passingIndices.length && passingIndices[runEnd + 1] === passingIndices[runEnd] + 1) {
+      runEnd++;
+    }
+    const runLen = runEnd - runStart + 1;
+    if (runLen === 1) {
+      result.add(graph[passingIndices[runStart]].targetId);
+    } else {
+      const peaks = [];
+      for (let j = runStart; j <= runEnd; j++) {
+        const idx = passingIndices[j];
+        const score = normalizedScores[idx];
+        const prevScore = j > runStart ? normalizedScores[passingIndices[j - 1]] : -Infinity;
+        const nextScore = j < runEnd ? normalizedScores[passingIndices[j + 1]] : -Infinity;
+        if (score > prevScore && score > nextScore) {
+          peaks.push(idx);
+        }
+      }
+      if (peaks.length > 0) {
+        for (const peakIdx of peaks) {
+          result.add(graph[peakIdx].targetId);
+        }
+      } else {
+        let peakIdx = passingIndices[runStart];
+        for (let j = runStart + 1; j <= runEnd; j++) {
+          const idx = passingIndices[j];
+          if (normalizedScores[idx] > normalizedScores[peakIdx]) {
+            peakIdx = idx;
+          }
+        }
+        result.add(graph[peakIdx].targetId);
+      }
+    }
+    runStart = runEnd + 1;
+  }
+  return result;
+}
+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);
+  const passingIndices = [];
+  for (let i = 0; i < graph.length; i++) {
+    if (normalized[i] >= threshold) {
+      passingIndices.push(i);
+    }
+  }
+  const nmsTargets = suppressConsecutiveRuns(graph, passingIndices, normalized);
+  for (const id of nmsTargets) {
+    surviving.add(id);
+  }
+  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(options2) {
+  const startTime = Date.now();
+  const sessionId = randomUUID();
+  const debug = options2.debug ?? false;
+  if (debug) setDebugMode(true);
+  const resolvedOptions = resolveOptions(options2);
+  const ctx = {
+    options: resolvedOptions,
+    workspacePath: "",
+    frames: [],
+    graph: [],
+    status: "INIT",
+    emitProgress: (percent) => {
+      if (options2.onProgress && ctx.status !== "INIT" && ctx.status !== "SUCCESS" && ctx.status !== "FAILED") {
+        options2.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(
+      options2,
+      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";
+    const { edges, animations } = await analyzeFrames(ctx);
+    ctx.graph = edges;
+    ctx.animations = animations;
+    ctx.status = "PRUNING";
+    const survivingIds = pruneByThresholdWithCap(
+      ctx.graph,
+      ctx.frames,
+      resolvedOptions.threshold,
+      resolvedOptions.count
+    );
+    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,
+      animations: ctx.animations,
+      video: {
+        originalDurationMs: ctx.frames.length / ctx.options.fps * 1e3,
+        fps: ctx.options.fps,
+        resolution: {
+          width: ctx.options.scale,
+          height: Math.round(ctx.options.scale * 9 / 16)
+        }
+      },
+      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}`);
+    }
+  }
+}
+
+// src/core/pipeline-worker.ts
+var options = workerData;
+runPipeline({
+  ...options,
+  onProgress: (phase, percent) => {
+    parentPort?.postMessage({
+      type: "progress",
+      phase,
+      percent
+    });
+  }
+}).then((result) => {
+  parentPort?.postMessage({
+    type: "result",
+    result
+  });
+}).catch((error) => {
+  parentPort?.postMessage({
+    type: "error",
+    message: error instanceof Error ? error.message : String(error)
+  });
+});