@lumy-pack/scene-sieve 0.0.8 → 0.0.10

package/dist/pipeline-worker.mjs

@@ -2,7 +2,7 @@
 import { parentPort, workerData } from "worker_threads";
 
 // src/core/orchestrator.ts
-import { randomUUID } from "crypto";
+import { randomUUID as randomUUID2 } from "crypto";
 
 // src/utils/logger.ts
 import pc from "picocolors";
@@ -67,6 +67,8 @@ var PIXELDIFF_GAUSSIAN_KERNEL = 3;
 var PIXELDIFF_BINARY_THRESHOLD = 30;
 var PIXELDIFF_CONTOUR_MIN_AREA = 100;
 var PIXELDIFF_SAMPLE_SPACING = 8;
+var DEFAULT_MAX_SEGMENT_DURATION = 300;
+var DEFAULT_SEGMENT_CONCURRENCY = 2;
 function getTempWorkspaceDir(sessionId) {
   return join(TEMP_BASE_DIR, `${WORKSPACE_PREFIX}${sessionId}`);
 }
@@ -659,6 +661,23 @@ async function buildFrameList(framesDir, duration) {
     extractPath: join2(framesDir, file)
   }));
 }
+async function extractFramesForRange(inputPath, outputDir, fps, scale, startTime, duration) {
+  const outputPattern = join2(outputDir, FRAME_FILENAME_PATTERN);
+  await execa(ffmpegPath, [
+    "-ss",
+    String(startTime),
+    "-i",
+    inputPath,
+    "-t",
+    String(duration),
+    "-vf",
+    `fps=${fps},scale=-1:${scale}`,
+    "-q:v",
+    "2",
+    outputPattern
+  ]);
+  return buildFrameList(outputDir, duration);
+}
 
 // src/core/input-resolver.ts
 import { join as join4 } from "path";
@@ -721,6 +740,15 @@ async function finalizeOutput(ctx, selectedFrames) {
   await rename(stagingDir, outputPath);
   return outputFiles;
 }
+async function createSegmentWorkspace(parentWorkspacePath, segmentIndex) {
+  const segmentPath = join3(
+    parentWorkspacePath,
+    "segments",
+    String(segmentIndex)
+  );
+  await ensureDir(join3(segmentPath, "frames"));
+  return segmentPath;
+}
 async function cleanupWorkspace(workspacePath) {
   if (!workspacePath) return;
   try {
@@ -781,7 +809,9 @@ function resolveOptions(options2) {
     quality: options2.quality ?? DEFAULT_QUALITY,
     iouThreshold: options2.iouThreshold ?? IOU_THRESHOLD,
     animationThreshold: options2.animationThreshold ?? ANIMATION_FRAME_THRESHOLD,
-    debug: options2.debug ?? false
+    debug: options2.debug ?? false,
+    maxSegmentDuration: options2.maxSegmentDuration ?? DEFAULT_MAX_SEGMENT_DURATION,
+    concurrency: options2.concurrency ?? DEFAULT_SEGMENT_CONCURRENCY
   };
 }
 async function resolveInput(options2, workspacePath) {
@@ -1033,13 +1063,361 @@ function pruneByThresholdWithCap(graph, frames, threshold, maxCount) {
   return pruneTo(syntheticEdges, survivingFrames, maxCount);
 }
 
+// src/core/segmenter.ts
+import { randomUUID } from "crypto";
+import { join as join5 } from "path";
+
+// src/utils/concurrency.ts
+function concurrencyLimit(limit) {
+  limit = Math.max(1, limit);
+  let active = 0;
+  const queue = [];
+  return async (fn) => {
+    while (active >= limit) {
+      await new Promise((resolve2) => queue.push(resolve2));
+    }
+    active++;
+    try {
+      return await fn();
+    } finally {
+      active--;
+      queue.shift()?.();
+    }
+  };
+}
+
+// src/core/segmenter.ts
+function shouldSegment(resolvedOptions, originalOptions) {
+  if (resolvedOptions.mode === "frames") return false;
+  if (originalOptions.mode === "file") {
+    if (originalOptions.inputPath.toLowerCase().endsWith(".gif")) return false;
+  }
+  return true;
+}
+function computeSegmentPlan(totalDuration, maxSegmentDuration, maxFrames, fps) {
+  const effectiveFps = Math.max(0.5, Math.min(fps, maxFrames / totalDuration));
+  if (totalDuration <= maxSegmentDuration) {
+    return [
+      {
+        index: 0,
+        startTime: 0,
+        endTime: totalDuration,
+        duration: totalDuration,
+        allocatedFrames: Math.min(
+          Math.ceil(effectiveFps * totalDuration),
+          maxFrames
+        ),
+        effectiveFps,
+        overlapBefore: 0,
+        overlapAfter: 0,
+        extractStartTime: 0,
+        extractDuration: totalDuration
+      }
+    ];
+  }
+  const segmentCount = Math.ceil(totalDuration / maxSegmentDuration);
+  const overlapTime = 1 / effectiveFps;
+  const segments = [];
+  for (let i = 0; i < segmentCount; i++) {
+    const startTime = i * maxSegmentDuration;
+    const endTime = Math.min((i + 1) * maxSegmentDuration, totalDuration);
+    const duration = endTime - startTime;
+    const overlapBefore = i > 0 ? 1 : 0;
+    const overlapAfter = i < segmentCount - 1 ? 1 : 0;
+    const extractStartTime = Math.max(
+      0,
+      startTime - overlapBefore * overlapTime
+    );
+    const extractEndTime = Math.min(
+      totalDuration,
+      endTime + overlapAfter * overlapTime
+    );
+    const extractDuration = extractEndTime - extractStartTime;
+    segments.push({
+      index: i,
+      startTime,
+      endTime,
+      duration,
+      allocatedFrames: Math.ceil(effectiveFps * duration),
+      effectiveFps,
+      overlapBefore,
+      overlapAfter,
+      extractStartTime,
+      extractDuration
+    });
+  }
+  const totalAllocated = segments.reduce(
+    (sum, s) => sum + s.allocatedFrames,
+    0
+  );
+  if (totalAllocated > maxFrames) {
+    segments[segments.length - 1].allocatedFrames -= totalAllocated - maxFrames;
+  }
+  return segments;
+}
+function collectAllFrames(segmentResults) {
+  const allFrames = [];
+  for (const result of segmentResults) {
+    for (const frame of result.frames) {
+      allFrames.push({
+        frame: {
+          ...frame,
+          // Use extractStartTime for timestamp correction (Section 18 note 1)
+          timestamp: frame.timestamp + result.segment.extractStartTime
+        },
+        segmentIndex: result.segment.index,
+        localId: frame.id
+      });
+    }
+  }
+  return allFrames;
+}
+function deduplicateFrames(frames, effectiveFps) {
+  frames.sort((a, b) => a.frame.timestamp - b.frame.timestamp);
+  const dupThreshold = 1 / (effectiveFps * 2);
+  const unique = [];
+  for (const entry of frames) {
+    if (unique.length > 0) {
+      const last = unique[unique.length - 1];
+      if (Math.abs(entry.frame.timestamp - last.frame.timestamp) < dupThreshold) {
+        continue;
+      }
+    }
+    unique.push(entry);
+  }
+  return unique;
+}
+function remapFrameIds(uniqueFrames) {
+  const globalIdMap = /* @__PURE__ */ new Map();
+  const frames = uniqueFrames.map((entry, globalId) => {
+    globalIdMap.set(`${entry.segmentIndex}:${entry.localId}`, globalId);
+    return {
+      id: globalId,
+      timestamp: entry.frame.timestamp,
+      extractPath: entry.frame.extractPath
+    };
+  });
+  return { frames, globalIdMap };
+}
+function remapEdges(segmentResults, globalIdMap) {
+  const edges = [];
+  const edgeMap = /* @__PURE__ */ new Map();
+  for (const result of segmentResults) {
+    for (const edge of result.edges) {
+      const newSourceId = globalIdMap.get(`${result.segment.index}:${edge.sourceId}`);
+      const newTargetId = globalIdMap.get(`${result.segment.index}:${edge.targetId}`);
+      if (newSourceId === void 0 || newTargetId === void 0) continue;
+      const edgeKey = `${newSourceId}-${newTargetId}`;
+      const existingIdx = edgeMap.get(edgeKey);
+      if (existingIdx !== void 0) {
+        if (edges[existingIdx].score < edge.score) {
+          edges[existingIdx] = { sourceId: newSourceId, targetId: newTargetId, score: edge.score };
+        }
+      } else {
+        edgeMap.set(edgeKey, edges.length);
+        edges.push({ sourceId: newSourceId, targetId: newTargetId, score: edge.score });
+      }
+    }
+  }
+  return edges;
+}
+function remapAnimations(segmentResults, globalIdMap) {
+  const animations = [];
+  for (const result of segmentResults) {
+    for (const anim of result.animations) {
+      const newStartId = globalIdMap.get(`${result.segment.index}:${anim.startFrameId}`);
+      const newEndId = globalIdMap.get(`${result.segment.index}:${anim.endFrameId}`);
+      if (newStartId === void 0 || newEndId === void 0) continue;
+      animations.push({ ...anim, startFrameId: newStartId, endFrameId: newEndId });
+    }
+  }
+  return animations;
+}
+function mergeSegmentFrames(segmentResults) {
+  if (segmentResults.length === 0) {
+    return { frames: [], edges: [], animations: [] };
+  }
+  const effectiveFps = segmentResults[0].segment.effectiveFps;
+  const allFrames = collectAllFrames(segmentResults);
+  const uniqueFrames = deduplicateFrames(allFrames, effectiveFps);
+  const { frames, globalIdMap } = remapFrameIds(uniqueFrames);
+  const edges = remapEdges(segmentResults, globalIdMap);
+  const animations = remapAnimations(segmentResults, globalIdMap);
+  return { frames, edges, animations };
+}
+function buildSegmentContext(segment, frames, segmentWorkspacePath, resolvedOptions, onProgress) {
+  return {
+    options: {
+      ...resolvedOptions,
+      fps: segment.effectiveFps,
+      maxFrames: segment.allocatedFrames
+    },
+    workspacePath: segmentWorkspacePath,
+    frames,
+    graph: [],
+    status: "ANALYZING",
+    emitProgress: onProgress
+  };
+}
+async function processSegment(inputPath, segment, workspacePath, resolvedOptions, onProgress) {
+  const framesDir = join5(workspacePath, "frames");
+  const frames = await extractFramesForRange(
+    inputPath,
+    framesDir,
+    segment.effectiveFps,
+    resolvedOptions.scale,
+    segment.extractStartTime,
+    segment.extractDuration
+  );
+  if (frames.length < 2) {
+    return { segment, frames, edges: [], animations: [] };
+  }
+  const ctx = buildSegmentContext(
+    segment,
+    frames,
+    workspacePath,
+    resolvedOptions,
+    onProgress
+  );
+  const { edges, animations } = await analyzeFrames(ctx);
+  return { segment, frames, edges, animations };
+}
+async function runSegmentedPipeline(options2, resolvedOptions) {
+  const pipelineStart = Date.now();
+  const sessionId = randomUUID();
+  let mainWorkspace = "";
+  try {
+    mainWorkspace = await createWorkspace(sessionId);
+    logger.debug(`Segmented pipeline: workspace at ${mainWorkspace}`);
+    const { resolvedInputPath } = await resolveInput(options2, mainWorkspace);
+    const inputPath = resolvedInputPath ?? resolvedOptions.inputPath;
+    if (!inputPath) {
+      throw new Error("No input path available for segmented pipeline");
+    }
+    const metadata = await getVideoMetadata(inputPath);
+    const totalDuration = parseFloat(metadata.format?.duration ?? "0");
+    if (totalDuration <= 0) {
+      throw new Error(`Invalid video duration: ${totalDuration}`);
+    }
+    logger.debug(`Video duration: ${totalDuration}s`);
+    const segments = computeSegmentPlan(
+      totalDuration,
+      resolvedOptions.maxSegmentDuration,
+      resolvedOptions.maxFrames,
+      resolvedOptions.fps
+    );
+    logger.debug(`Segment plan: ${segments.length} segments`);
+    const limit = concurrencyLimit(resolvedOptions.concurrency);
+    const segmentProgresses = new Array(segments.length).fill(0);
+    const weights = segments.map((s) => s.duration / totalDuration);
+    const emitOverallProgress = (phase) => {
+      if (!options2.onProgress) return;
+      const overall = weights.reduce(
+        (sum, w, i) => sum + w * (segmentProgresses[i] ?? 0),
+        0
+      );
+      options2.onProgress(phase, Math.min(100, overall));
+    };
+    options2.onProgress?.("EXTRACTING", 0);
+    const results = await Promise.all(
+      segments.map(
+        (segment) => limit(async () => {
+          const segWorkspace = await createSegmentWorkspace(
+            mainWorkspace,
+            segment.index
+          );
+          const result = await processSegment(
+            inputPath,
+            segment,
+            segWorkspace,
+            resolvedOptions,
+            (percent) => {
+              segmentProgresses[segment.index] = percent;
+              emitOverallProgress("ANALYZING");
+            }
+          );
+          return result;
+        })
+      )
+    );
+    options2.onProgress?.("ANALYZING", 100);
+    const { frames, edges, animations } = mergeSegmentFrames(results);
+    logger.debug(
+      `Merged: ${frames.length} frames, ${edges.length} edges, ${animations.length} animations`
+    );
+    options2.onProgress?.("PRUNING", 0);
+    const survivingIds = pruneByThresholdWithCap(
+      edges,
+      frames,
+      resolvedOptions.threshold,
+      resolvedOptions.count
+    );
+    const prunedFrames = frames.filter((f) => survivingIds.has(f.id));
+    options2.onProgress?.("PRUNING", 100);
+    options2.onProgress?.("FINALIZING", 0);
+    const ctx = {
+      options: resolvedOptions,
+      workspacePath: mainWorkspace,
+      frames,
+      graph: edges,
+      animations,
+      status: "FINALIZING",
+      emitProgress: (percent) => options2.onProgress?.("FINALIZING", percent)
+    };
+    let outputFiles = [];
+    let outputBuffers;
+    if (resolvedOptions.mode === "buffer" || resolvedOptions.mode === "frames") {
+      outputBuffers = await readFramesAsBuffers(
+        prunedFrames,
+        resolvedOptions.quality
+      );
+    } else {
+      outputFiles = await finalizeOutput(ctx, prunedFrames);
+    }
+    options2.onProgress?.("FINALIZING", 100);
+    logger.success(
+      `Segmented pipeline: ${prunedFrames.length} scenes from ${frames.length} frames (${segments.length} segments)`
+    );
+    return {
+      success: true,
+      originalFramesCount: frames.length,
+      prunedFramesCount: prunedFrames.length,
+      outputFiles,
+      outputBuffers,
+      animations,
+      video: {
+        originalDurationMs: totalDuration * 1e3,
+        fps: resolvedOptions.fps,
+        resolution: {
+          width: resolvedOptions.scale,
+          height: Math.round(resolvedOptions.scale * 9 / 16)
+        }
+      },
+      executionTimeMs: Date.now() - pipelineStart
+    };
+  } catch (error) {
+    const err = error instanceof Error ? error : new Error(String(error));
+    logger.error(`Segmented pipeline failed: ${err.message}`);
+    throw err;
+  } finally {
+    if (!resolvedOptions.debug) {
+      await cleanupWorkspace(mainWorkspace);
+    } else {
+      logger.debug(`Debug mode: workspace preserved at ${mainWorkspace}`);
+    }
+  }
+}
+
 // 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);
+  if (shouldSegment(resolvedOptions, options2)) {
+    return runSegmentedPipeline(options2, resolvedOptions);
+  }
+  const startTime = Date.now();
+  const sessionId = randomUUID2();
   const ctx = {
     options: resolvedOptions,
     workspacePath: "",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lumy-pack/scene-sieve",
-  "version": "0.0.8",
+  "version": "0.0.10",
   "description": "CLI tool for extracting key frames from video and GIF files",
   "keywords": [
     "cli",
@@ -33,7 +33,7 @@
   "main": "dist/index.cjs",
   "module": "dist/index.mjs",
   "types": "dist/index.d.ts",
-  "bin": "./dist/cli.mjs",
+  "bin": "dist/cli.mjs",
   "files": [
     "dist",
     "!dist/tsconfig.tsbuildinfo"
@@ -55,6 +55,7 @@
   },
   "dependencies": {
     "@ffprobe-installer/ffprobe": "^1.4.1",
+    "@lumy-pack/shared": "0.0.1",
     "@techstark/opencv-js": "4.12.0-release.1",
     "commander": "^12.1.0",
     "execa": "^9.5.0",

package/dist/cli.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/commands/Sieve.d.ts

@@ -1,15 +0,0 @@
-import React from 'react';
-export interface SieveViewProps {
-    input: string;
-    count?: number;
-    threshold?: number;
-    output?: string;
-    fps: number;
-    maxFrames: number;
-    scale: number;
-    quality: number;
-    iouThreshold?: number;
-    animationThreshold?: number;
-    debug: boolean;
-}
-export declare const SieveView: React.FC<SieveViewProps>;

package/dist/components/PhaseStep.d.ts

@@ -1,14 +0,0 @@
-import React from 'react';
-export type PhaseStatus = 'pending' | 'running' | 'done' | 'failed';
-export interface PhaseState {
-    label: string;
-    status: PhaseStatus;
-    hasProgress: boolean;
-    percent: number;
-    durationMs?: number;
-}
-interface PhaseStepProps {
-    phase: PhaseState;
-}
-export declare const PhaseStep: React.FC<PhaseStepProps>;
-export {};

package/dist/components/ProgressBar.d.ts

@@ -1,7 +0,0 @@
-import React from 'react';
-interface ProgressBarProps {
-    percent: number;
-    width?: number;
-}
-export declare const ProgressBar: React.FC<ProgressBarProps>;
-export {};

package/dist/constants.d.ts

@@ -1,30 +0,0 @@
-export declare const APP_NAME = "scene-sieve";
-export declare const DEFAULT_COUNT = 20;
-export declare const DEFAULT_THRESHOLD = 0.5;
-export declare const DEFAULT_FPS = 5;
-export declare const DEFAULT_SCALE = 720;
-export declare const DEFAULT_QUALITY = 80;
-export declare const DEFAULT_MAX_FRAMES = 300;
-export declare const NORMALIZATION_MIN_PERCENTILE = 0.1;
-export declare const NORMALIZATION_MAX_PERCENTILE = 0.9;
-export declare const NORMALIZATION_LOGISTIC_K = 3;
-export declare const NORMALIZATION_ALPHA = 0.4;
-export declare const NORMALIZATION_MAD_COEFFICIENT = 1.4826;
-export declare const NORMALIZATION_MIN_SAMPLE_SIZE = 10;
-export declare const WORKSPACE_PREFIX = "scene-sieve-";
-export declare const TEMP_BASE_DIR: string;
-export declare const FRAME_OUTPUT_EXTENSION = ".jpg";
-export declare const FRAME_FILENAME_PATTERN = "frame_%06d.jpg";
-export declare const OPENCV_BATCH_SIZE = 10;
-export declare const MIN_IFRAME_COUNT = 3;
-export declare const DBSCAN_ALPHA = 0.03;
-export declare const DBSCAN_MIN_PTS = 4;
-export declare const IOU_THRESHOLD = 0.9;
-export declare const DECAY_LAMBDA = 0.95;
-export declare const ANIMATION_FRAME_THRESHOLD = 5;
-export declare const MATCH_DISTANCE_THRESHOLD = 0.25;
-export declare const PIXELDIFF_GAUSSIAN_KERNEL = 3;
-export declare const PIXELDIFF_BINARY_THRESHOLD = 30;
-export declare const PIXELDIFF_CONTOUR_MIN_AREA = 100;
-export declare const PIXELDIFF_SAMPLE_SPACING = 8;
-export declare function getTempWorkspaceDir(sessionId: string): string;

package/dist/core/analyzer.d.ts

@@ -1,62 +0,0 @@
-import type { AnalysisResult, AnimationMetadata, BoundingBox, ProcessContext } from '../types/index.js';
-import type { Point2D } from './dbscan.js';
-type CvLib = typeof import('@techstark/opencv-js');
-export declare function preprocessFrame(framePath: string, scale: number): Promise<{
-    data: Uint8Array;
-    width: number;
-    height: number;
-}>;
-export declare function computeIoU(a: BoundingBox, b: BoundingBox): number;
-export declare class IoUTracker {
-    private fps;
-    private iouThreshold;
-    private animationThreshold;
-    private regions;
-    private extractedAnimations;
-    constructor(fps?: number, iouThreshold?: number, animationThreshold?: number);
-    update(boxes: BoundingBox[], pairIndex: number): Set<number>;
-    private collectAnimation;
-    flushAndGetAnimations(): AnimationMetadata[];
-    getAnimationWeight(boxIndex: number, boxes: BoundingBox[]): number;
-}
-export interface AKAZEResult {
-    sNew: Point2D[];
-    sLoss: Point2D[];
-}
-/**
- * Pixel-level difference fallback for AKAZE blind spots.
- *
- * When AKAZE produces sparse results (typical for UI screen recordings
- * where form fields, dropdowns, or overlays change), this function
- * detects changed regions via cv.absdiff and generates synthetic
- * Point2D[] that feed into the existing DBSCAN → IoU → G(t) pipeline.
- *
- * Algorithm:
- * 1. absdiff(frame1, frame2) → grayscale difference
- * 2. GaussianBlur → reduce JPEG compression noise
- * 3. threshold → binary mask of significant changes
- * 4. findContours → bounding rects of changed regions
- * 5. Grid sampling within each bounding rect → Point2D[]
- */
-export declare function computePixelDiff(cvLib: CvLib, frame1: {
-    data: Uint8Array;
-    width: number;
-    height: number;
-}, frame2: {
-    data: Uint8Array;
-    width: number;
-    height: number;
-}): Point2D[];
-export declare function computeInformationGain(clusters: BoundingBox[], clusterPoints: number[], imageArea: number, animationIndices: Set<number>, animationWeights: number[]): number;
-/**
- * Analyze adjacent frame pairs to compute information gain scores (G(t)).
- * Processes frames in batches for memory efficiency.
- *
- * Pipeline:
- * 1. AKAZE Feature Set Difference
- * 2. DBSCAN Spatial Clustering
- * 3. Spatio-temporal IoU Tracking
- * 4. G(t) Information Gain Scoring
- */
-export declare function analyzeFrames(ctx: ProcessContext): Promise<AnalysisResult>;
-export {};

package/dist/core/dbscan.d.ts

@@ -1,10 +0,0 @@
-import type { DBSCANResult } from '../types/index.js';
-export interface Point2D {
-    x: number;
-    y: number;
-}
-/**
- * DBSCAN clustering with resolution-independent eps.
- * eps = alpha * sqrt(width^2 + height^2)
- */
-export declare function dbscan(points: Point2D[], imageWidth: number, imageHeight: number, alpha?: number, minPts?: number): DBSCANResult;

package/dist/core/extractor.d.ts

@@ -1,7 +0,0 @@
-import type { FrameNode, ProcessContext } from '../types/index.js';
-/**
- * Extract frames from video/GIF using FFmpeg.
- * Always uses FPS-based extraction. For long videos, FPS is automatically
- * reduced to stay within maxFrames budget.
- */
-export declare function extractFrames(ctx: ProcessContext): Promise<FrameNode[]>;

package/dist/core/index.d.ts

@@ -1,8 +0,0 @@
-export { runPipeline } from './orchestrator.js';
-export { analyzeFrames, computeIoU, computeInformationGain, } from './analyzer.js';
-export { extractFrames } from './extractor.js';
-export { pruneTo, pruneByThreshold, pruneByThresholdWithCap, suppressConsecutiveRuns, } from './pruner.js';
-export { dbscan } from './dbscan.js';
-export type { Point2D } from './dbscan.js';
-export { resolveInput, resolveOptions } from './input-resolver.js';
-export { createWorkspace, cleanupWorkspace, finalizeOutput, readFramesAsBuffers, writeInputBuffer, writeInputFrames, } from './workspace.js';

package/dist/core/input-resolver.d.ts

@@ -1,13 +0,0 @@
-import type { FrameNode, ResolvedOptions, SieveOptions } from '../types/index.js';
-export declare function resolveOptions(options: SieveOptions): ResolvedOptions;
-/**
- * Resolve the input source to a list of FrameNode[].
- *
- * - 'file'   mode: validate file exists and delegate to extractor (caller's responsibility)
- * - 'buffer' mode: write buffer as temp video file, return path via FrameNode trick (empty list)
- * - 'frames' mode: write frame buffers as JPGs, return FrameNode[]
- */
-export declare function resolveInput(options: SieveOptions, workspacePath: string): Promise<{
-    frames: FrameNode[];
-    resolvedInputPath?: string;
-}>;

package/dist/core/orchestrator.d.ts

@@ -1,2 +0,0 @@
-import type { SieveOptions, SieveResult } from '../types/index.js';
-export declare function runPipeline(options: SieveOptions): Promise<SieveResult>;

package/dist/core/pipeline-worker.d.ts

@@ -1 +0,0 @@
-export {};