hyperframes 0.8.142 → 0.8.143

package/dist/{chunk-IDX52YJN.js → chunk-33RZPZ4K.js}

@@ -26,7 +26,7 @@ import {
   renderFrameIdForRenderId,
   resolveAuthoredTimingWindow,
   toFps
-} from "./chunk-YFT3BL7N.js";
+} from "./chunk-4M4EC7JX.js";
 import {
   AUDIO_GROUP_RENDER_ID_ATTR,
   COLOR_GRADING_SOURCE_HIDDEN_ATTR,
@@ -55,7 +55,7 @@ import {
   shiftRateLane,
   sourceTimeAt,
   timeAtSourceTime
-} from "./chunk-J4UX3RS3.js";
+} from "./chunk-6TPZSTCL.js";
 import {
   clampAudioGain,
   isAudibleVideoElement
@@ -70,7 +70,7 @@ import {
 import {
   isWithinProjectRoot,
   resolveProjectRelativeSrc
-} from "./chunk-JFKL3WAE.js";
+} from "./chunk-IWFLMU2N.js";
 import {
   FFMPEG_PATH_ENV,
   FFPROBE_PATH_ENV,
@@ -79,10 +79,10 @@ import {
 import {
   parseNumeric,
   parseStartExpression
-} from "./chunk-TQFG7HTI.js";
+} from "./chunk-3RM2ETQT.js";
 import {
   parseHTML
-} from "./chunk-GK4AIFIH.js";
+} from "./chunk-SDYDNHEE.js";
 
 // ../engine/src/config.ts
 import { tmpdir } from "os";
@@ -553,6 +553,10 @@ function applyConcreteGpuScreenshotClamp(currentForceScreenshot, resolvedGpuMode
   });
 }
 
+// ../engine/src/utils/sdrCaptureColor.ts
+var SDR_RGB_TO_BT709_FILTER = "scale=out_color_matrix=bt709:out_range=tv:flags=neighbor";
+var SDR_CAPTURE_TO_BT709_FILTER = `scale=in_color_matrix=bt601:in_range=pc:flags=neighbor,format=gbrp,${SDR_RGB_TO_BT709_FILTER}`;
+
 // ../engine/src/services/browserManager.ts
 import { execSync } from "child_process";
 import { existsSync, readdirSync } from "fs";
@@ -1959,7 +1963,7 @@ function parseObjectPositionAxis(value, axis) {
   if (lower === "center" || lower === "") return 0.5;
   if (lower.endsWith("%")) {
     const pct = parseFloat(lower) / 100;
-    return Number.isFinite(pct) ? Math.max(0, Math.min(1, pct)) : 0.5;
+    return Number.isFinite(pct) ? pct : 0.5;
   }
   if (axis === "x" || axis === "y") return 0.5;
   return 0.5;
@@ -7006,7 +7010,7 @@ async function captureFramesBatchPipelined(session, frameIndices, times) {
   return results;
 }
 async function discardWarmupCapture(session, frameIndex = 0, time = 0, innerCapture = captureFrameCore) {
-  const perfBefore = { ...session.capturePerf };
+  const perfBefore = { ...session.capturePerf, frameMs: [...session.capturePerf.frameMs] };
   const hasDamageBefore = session.beginFrameHasDamageCount;
   const noDamageBefore = session.beginFrameNoDamageCount;
   const dedupCountBefore = session.staticDedupCount;
@@ -7661,10 +7665,6 @@ function withEvenDimensionPad(vfChain, pixelFormat, width, height) {
   return vfChain ? `${vfChain},${EVEN_DIMENSION_PAD}` : EVEN_DIMENSION_PAD;
 }
 
-// ../engine/src/utils/sdrCaptureColor.ts
-var SDR_RGB_TO_BT709_FILTER = "scale=out_color_matrix=bt709:out_range=tv:flags=neighbor";
-var SDR_CAPTURE_TO_BT709_FILTER = `scale=in_color_matrix=bt601:in_range=pc:flags=neighbor,format=gbrp,${SDR_RGB_TO_BT709_FILTER}`;
-
 // ../engine/src/utils/runFfmpeg.ts
 import { spawn as spawn2 } from "child_process";
 var FFMPEG_SIGTERM_EXIT_LINE = /^Exiting normally, received signal 15\.?\r?$/m;
@@ -7944,6 +7944,22 @@ function mediaFileIdentity(filePath) {
     return null;
   }
 }
+function readMetadataCache(cache, key, identity) {
+  const cached = cache.get(key);
+  return cached?.identity === identity ? cached.promise : void 0;
+}
+function writeMetadataCache(cache, key, identity, promise) {
+  const entry = { identity, promise };
+  cache.set(key, entry);
+  void promise.then(
+    () => {
+      if (identity === null && cache.get(key) === entry) cache.delete(key);
+    },
+    () => {
+      if (cache.get(key) === entry) cache.delete(key);
+    }
+  );
+}
 async function probeMediaOutput(filePath, signal) {
   let cache = mediaProbeOutputCache;
   if (signal) {
@@ -8126,7 +8142,8 @@ function parseFrameRate(frameRateStr) {
   return rounded > 0 ? rounded : 0.01;
 }
 async function extractMediaMetadata(filePath) {
-  const cached = videoMetadataCache.get(filePath);
+  const identity = mediaFileIdentity(filePath);
+  const cached = readMetadataCache(videoMetadataCache, filePath, identity);
   if (cached) return cached;
   const probePromise = (async () => {
     let stillImageMetaMemo;
@@ -8210,12 +8227,7 @@ async function extractMediaMetadata(filePath) {
       frames
     };
   })();
-  videoMetadataCache.set(filePath, probePromise);
-  probePromise.catch(() => {
-    if (videoMetadataCache.get(filePath) === probePromise) {
-      videoMetadataCache.delete(filePath);
-    }
-  });
+  writeMetadataCache(videoMetadataCache, filePath, identity, probePromise);
   return probePromise;
 }
 function resolveStreamWindow(filePath, metadata) {
@@ -8231,12 +8243,13 @@ async function extractFinalVideoFrameTimestamp(filePath, metadata, signal) {
     videoStreamDurationSeconds: videoDurationSeconds,
     cacheKey
   } = resolveStreamWindow(filePath, metadata);
+  const identity = mediaFileIdentity(filePath);
   let probeCache = finalVideoFrameTimestampCache;
   if (signal) {
     probeCache = finalVideoFrameTimestampSignalCaches.get(signal) ?? /* @__PURE__ */ new Map();
     finalVideoFrameTimestampSignalCaches.set(signal, probeCache);
   }
-  const cached = probeCache.get(cacheKey);
+  const cached = readMetadataCache(probeCache, cacheKey, identity);
   if (cached) return cached;
   const probePromise = (async () => {
     if (!(videoDurationSeconds > 0) || !Number.isFinite(videoDurationSeconds)) {
@@ -8271,17 +8284,13 @@ async function extractFinalVideoFrameTimestamp(filePath, metadata, signal) {
     }
     return Math.min(Math.max(timestamp - videoStreamStartSeconds, 0), videoDurationSeconds);
   })();
-  probeCache.set(cacheKey, probePromise);
-  probePromise.catch(() => {
-    if (probeCache.get(cacheKey) === probePromise) {
-      probeCache.delete(cacheKey);
-    }
-  });
+  writeMetadataCache(probeCache, cacheKey, identity, probePromise);
   return probePromise;
 }
 var extractVideoMetadata = extractMediaMetadata;
 async function extractAudioMetadata(filePath, options) {
-  const cached = options?.signal ? void 0 : audioMetadataCache.get(filePath);
+  const identity = mediaFileIdentity(filePath);
+  const cached = options?.signal ? void 0 : readMetadataCache(audioMetadataCache, filePath, identity);
   if (cached) return cached;
   const probePromise = (async () => {
     const output = await probeMediaOutput(filePath, options?.signal);
@@ -8326,12 +8335,7 @@ async function extractAudioMetadata(filePath, options) {
     };
   })();
   if (options?.signal) return probePromise;
-  audioMetadataCache.set(filePath, probePromise);
-  probePromise.catch(() => {
-    if (audioMetadataCache.get(filePath) === probePromise) {
-      audioMetadataCache.delete(filePath);
-    }
-  });
+  writeMetadataCache(audioMetadataCache, filePath, identity, probePromise);
   return probePromise;
 }
 var keyframeCache = /* @__PURE__ */ new Map();
@@ -9608,6 +9612,7 @@ function isMemberGroupHidden(groupsById, el) {
 // ../engine/src/services/videoFrameExtractor.ts
 import { copyFileSync as copyFileSync2, existsSync as existsSync8, linkSync as linkSync2, mkdirSync as mkdirSync6, rmSync as rmSync4 } from "fs";
 import { join as join10 } from "path";
+import { cpus } from "os";
 
 // ../engine/src/services/referenceResolver.ts
 function findReferenceTargetEl(doc, refId) {
@@ -10782,7 +10787,7 @@ function extractedFrameIndex(file, format) {
   }
   return ordinal - 1;
 }
-function framePathsFromDirectory(outputDir, format) {
+function framePathsFromDirectory(outputDir, format, allowGaps = false) {
   const suffix = `.${format}`;
   const indexed = /* @__PURE__ */ new Map();
   for (const file of readdirSync4(outputDir)) {
@@ -10795,6 +10800,7 @@ function framePathsFromDirectory(outputDir, format) {
     }
     indexed.set(index, join8(outputDir, file));
   }
+  if (allowGaps) return new Map([...indexed].sort(([a], [b]) => a - b));
   const ordered = /* @__PURE__ */ new Map();
   for (let index = 0; index < indexed.size; index += 1) {
     const path = indexed.get(index);
@@ -11465,6 +11471,69 @@ function restoreSourceColourFilter(metadata) {
   ].filter(([, value]) => value && value !== "unknown" && value !== "reserved");
   return tags.length > 0 ? [`setparams=${tags.map(([key, value]) => `${key}=${value}`).join(":")}`] : [];
 }
+var EXTRACTION_SEGMENT_SECONDS = 120;
+function splitFrameRanges(ranges, segmentFrames) {
+  const segments = [];
+  for (const range of ranges) {
+    for (let offset = 0; offset < range.frames; offset += segmentFrames) {
+      segments.push({
+        firstFrame: range.firstFrame + offset,
+        frames: Math.min(segmentFrames, range.frames - offset)
+      });
+    }
+  }
+  return segments;
+}
+async function runSegmentedExtraction(job) {
+  const { decodeArgs, filterAndEncodeArgs, videoPath, startTime, fps, segments } = job;
+  const segmentCount = segments.length;
+  const failed = new AbortController();
+  const signal = job.runOptions.signal ? AbortSignal.any([job.runOptions.signal, failed.signal]) : failed.signal;
+  const results = [];
+  let next = 0;
+  const worker = async () => {
+    while (next < segmentCount && !signal.aborted) {
+      const index = next++;
+      const { firstFrame, frames } = segments[index];
+      const result = await runFfmpeg(
+        [
+          ...decodeArgs,
+          "-noaccurate_seek",
+          "-ss",
+          String(startTime + firstFrame / fps),
+          "-i",
+          videoPath,
+          // Read one frame past the segment and keep exactly its own frames.
+          "-t",
+          String((frames + 1) / fps),
+          "-frames:v",
+          String(frames),
+          "-start_number",
+          String(firstFrame + 1),
+          ...filterAndEncodeArgs
+        ],
+        { ...job.runOptions, signal }
+      );
+      results[index] = result;
+      if (!result.success) failed.abort();
+    }
+  };
+  const workers = Math.min(segmentCount, Math.max(1, Math.floor(cpus().length / 2)));
+  await Promise.all(Array.from({ length: workers }, worker));
+  const ran = results.filter(Boolean);
+  const failure = ran.find((r) => !r.success && r.terminationReason !== "abort") ?? ran.find((r) => !r.success);
+  if (failure) return failure;
+  if (ran.length < segmentCount) {
+    return {
+      success: false,
+      exitCode: null,
+      stderr: "",
+      durationMs: 0,
+      terminationReason: "abort"
+    };
+  }
+  return ran[ran.length - 1];
+}
 async function extractVideoFramesRange(videoPath, videoId, startTime, duration, options, signal, config, outputDirOverride) {
   const ffmpegProcessTimeout = config?.ffmpegProcessTimeout ?? DEFAULT_CONFIG.ffmpegProcessTimeout;
   const { outputDir, quality = 95 } = options;
@@ -11504,6 +11573,9 @@ async function extractVideoFramesRange(videoPath, videoId, startTime, duration,
   const toneMappedToSdr = options.toneMapHdrToSdr === true && isHdr && await toneMapsWithZscale();
   const decodeWithVideoToolbox = isHdr && isMacOS && !toneMappedToSdr;
   const sampleCfrAtOutputFps = !options.finalFrameOnly && !metadata.isVFR;
+  if (options.frameRanges && !sampleCfrAtOutputFps) {
+    throw new Error("frameRanges extraction needs a constant-frame-rate source");
+  }
   const args = [];
   if (decodeWithVideoToolbox) {
     args.push("-hwaccel", "videotoolbox");
@@ -11511,6 +11583,7 @@ async function extractVideoFramesRange(videoPath, videoId, startTime, duration,
   if (codecMayHaveAlpha(metadata.videoCodec)) {
     args.push("-c:v", decoderForCodec(metadata.videoCodec));
   }
+  const decodeArgs = [...args];
   if (options.finalFrameOnly) {
     args.push("-i", videoPath, "-ss", String(startTime), "-frames:v", "1");
   } else {
@@ -11566,8 +11639,21 @@ async function extractVideoFramesRange(videoPath, videoId, startTime, duration,
       runOptions
     );
   } else {
-    if (vfFilters.length > 0) args.push("-vf", vfFilters.join(","));
-    processResult = await runFfmpeg([...args, ...encodeArgs], runOptions);
+    const filterArgs = vfFilters.length > 0 ? ["-vf", vfFilters.join(",")] : [];
+    const segmentFrames = Math.round(EXTRACTION_SEGMENT_SECONDS * fps);
+    const totalFrames = extractionFrameCountForDuration(duration, normalizedFps, false);
+    processResult = sampleCfrAtOutputFps && (options.frameRanges || totalFrames > segmentFrames) ? await runSegmentedExtraction({
+      decodeArgs,
+      filterAndEncodeArgs: [...filterArgs, ...encodeArgs],
+      videoPath,
+      startTime,
+      fps,
+      segments: splitFrameRanges(
+        options.frameRanges ?? [{ firstFrame: 0, frames: totalFrames }],
+        segmentFrames
+      ),
+      runOptions
+    }) : await runFfmpeg([...args, ...filterArgs, ...encodeArgs], runOptions);
   }
   if (processResult.failureReason === "external_interruption") {
     throw new VideoSourceExtractionError(
@@ -11606,7 +11692,7 @@ async function extractVideoFramesRange(videoPath, videoId, startTime, duration,
       diagnostic
     );
   }
-  const framePaths = framePathsFromDirectory(videoOutputDir, format);
+  const framePaths = framePathsFromDirectory(videoOutputDir, format, !!options.frameRanges);
   if (framePaths.size === 0 && duration > 0) {
     throw new VideoSourceExtractionError(
       "zero_output",
@@ -11615,7 +11701,7 @@ async function extractVideoFramesRange(videoPath, videoId, startTime, duration,
       `FFmpeg exited successfully but produced no frames (start=${startTime}, duration=${duration})`
     );
   }
-  if (framePaths.size > 0 && duration > 0 && !options.finalFrameOnly) {
+  if (framePaths.size > 0 && duration > 0 && !options.finalFrameOnly && !options.frameRanges) {
     const expectedAtFps = extractionFrameCountForDuration(duration, normalizedFps, metadata.isVFR);
     if (expectedAtFps > 0 && framePaths.size <= expectedAtFps * 0.6) {
       const correctedDuration = startTime + framePaths.size / fps;
@@ -12298,6 +12384,57 @@ async function extractAllVideoFrames(videos, baseDir, options, signal, config, c
     }
     return rehydratePublishedCache(work, cacheTarget);
   }
+  async function deferExtraction(work) {
+    if (work.finalFrameOnly || work.metadata.isVFR || work.sdrToHdrTransfer !== void 0 || work.hdrToSdrTransformKey !== void 0) {
+      return null;
+    }
+    const expectedFrames = extractionFrameCountForDuration(
+      work.videoDuration,
+      configuredFps,
+      false
+    );
+    const tailFrames = Math.min(expectedFrames, Math.ceil(fps));
+    if (expectedFrames <= tailFrames) return null;
+    const probeDir = join10(options.outputDir, `${work.video.id}.tail-probe`);
+    try {
+      const tail = await extractVideoFramesRange(
+        work.videoPath,
+        work.video.id,
+        work.extractionMediaStart,
+        work.videoDuration,
+        {
+          ...scopedExtractionOptions(work),
+          frameRanges: [{ firstFrame: expectedFrames - tailFrames, frames: tailFrames }]
+        },
+        signal,
+        config,
+        probeDir
+      );
+      const totalFrames = expectedFrames - tailFrames + tail.totalFrames;
+      if (totalFrames <= expectedFrames * 0.6) return null;
+      const outputDir = join10(options.outputDir, work.video.id);
+      mkdirSync6(outputDir, { recursive: true });
+      return {
+        videoId: work.video.id,
+        srcPath: work.videoPath,
+        outputDir,
+        framePattern: `${FRAME_FILENAME_PREFIX}%05d.${work.format}`,
+        fps,
+        totalFrames,
+        metadata: work.metadata,
+        framePaths: /* @__PURE__ */ new Map(),
+        deferredRange: {
+          startTime: work.extractionMediaStart,
+          durationSeconds: work.videoDuration,
+          format: work.format
+        }
+      };
+    } catch {
+      return null;
+    } finally {
+      rmSync4(probeDir, { recursive: true, force: true });
+    }
+  }
   async function executeDirectMiss(miss, maxTransientRetries = options.maxTransientRetries ?? 0) {
     try {
       return { result: await extractDirectMiss(miss, maxTransientRetries) };
@@ -12422,8 +12559,17 @@ async function extractAllVideoFrames(videos, baseDir, options, signal, config, c
     }
   }
   const uniqueOutcomes = /* @__PURE__ */ new Map();
+  if (options.deferRangeExtraction) {
+    const works = [...uniqueWorks.values()];
+    const deferred = await Promise.all(works.map(deferExtraction));
+    works.forEach((work, i) => {
+      const result = deferred[i];
+      if (result) uniqueOutcomes.set(work.dedupeKey, { result });
+    });
+  }
   const cacheMisses = [];
   for (const work of uniqueWorks.values()) {
+    if (uniqueOutcomes.has(work.dedupeKey)) continue;
     const lookup = lookupCacheFor(work);
     if ("work" in lookup) {
       cacheMisses.push(lookup);
@@ -12479,7 +12625,7 @@ async function extractAllVideoFrames(videos, baseDir, options, signal, config, c
       errors.push(item.error);
     } else if ("result" in item) {
       extracted.push(item.result);
-      totalFramesExtracted += item.result.totalFrames;
+      if (!item.result.deferredRange) totalFramesExtracted += item.result.totalFrames;
     }
   }
   const sweepDue = breakdown.cacheMisses > 0 || cacheRootDir !== void 0 && gcSweepDue(cacheRootDir, GC_STALENESS_MS);
@@ -14716,7 +14862,7 @@ async function processCompositionAudio(elements, baseDir, workDir, outputPath, t
 }
 
 // ../engine/src/services/parallelCoordinator.ts
-import { cpus, freemem } from "os";
+import { cpus as cpus2, freemem } from "os";
 import { existsSync as existsSync11, mkdirSync as mkdirSync8, readdirSync as readdirSync6 } from "fs";
 import { copyFile, readFile as readFile2, rename } from "fs/promises";
 import { join as join15 } from "path";
@@ -14831,7 +14977,7 @@ var MIN_WORKERS = 1;
 var MAX_WORKER_DIAGNOSTIC_LINES = 8;
 var ABSOLUTE_MAX_WORKERS = 24;
 function defaultSafeMaxWorkers() {
-  return Math.max(6, Math.min(16, Math.floor(cpus().length / 8)));
+  return Math.max(6, Math.min(16, Math.floor(cpus2().length / 8)));
 }
 var MIN_FRAMES_PER_WORKER = 30;
 function shouldDisableBrowserPoolForParallelWorker({
@@ -14876,7 +15022,7 @@ function formatWorkerFailure(result) {
   return `${base}; diagnostics: ${diagnostics}`;
 }
 function computeWorkerSizing(totalFrames, requested, config) {
-  const cpuCount = cpus().length;
+  const cpuCount = cpus2().length;
   const totalMemoryMb = getSystemTotalMb();
   const heapLimitMb = Math.round(getHeapStatistics().heap_size_limit / (1024 * 1024));
   const heapBasedWorkers = Math.max(
@@ -15434,7 +15580,7 @@ async function mergeWorkerFrames(workDir, tasks, outputDir) {
 }
 function getSystemResources() {
   return {
-    cpuCores: cpus().length,
+    cpuCores: cpus2().length,
     totalMemoryMB: getSystemTotalMb(),
     freeMemoryMB: Math.round(freemem() / (1024 * 1024)),
     recommendedWorkers: calculateOptimalWorkers(1e3)
@@ -15909,6 +16055,7 @@ export {
   resolveConfig,
   shouldClampToScreenshotForConcreteGpu,
   applyConcreteGpuScreenshotClamp,
+  SDR_RGB_TO_BT709_FILTER,
   BrowserLeasePool,
   setHostHandlesSigint,
   resolveHeadlessShellPath,

package/dist/{chunk-JU6Y5TTZ.js → chunk-3NE7ZYU2.js}

@@ -7,10 +7,10 @@ var __dirname = __hf_dirname(__filename);
 import {
   parseFeedbackRating,
   trackRenderFeedback
-} from "./chunk-XGMNQQTJ.js";
+} from "./chunk-QFN7NVWM.js";
 import {
   shouldTrack
-} from "./chunk-LBKDQKWV.js";
+} from "./chunk-OSSHSIMD.js";
 import {
   detectAgentRuntime
 } from "./chunk-GQJZORQP.js";

package/dist/{chunk-TQFG7HTI.js → chunk-3RM2ETQT.js}

@@ -287,157 +287,6 @@ function writeClipTiming(attributes, update) {
   return readClipTiming(attributes);
 }
 
-// ../parsers/dist/mediaDuration.js
-var COMPOSITION_ATTRIBUTES2 = Object.freeze({
-  start: "data-start",
-  duration: "data-duration",
-  trackIndex: "data-track-index",
-  derivedEnd: "data-end",
-  legacyTrack: "data-layer"
-});
-var CANONICAL_AUTHORED_TIMING_ATTRIBUTES2 = Object.freeze([
-  COMPOSITION_ATTRIBUTES2.start,
-  COMPOSITION_ATTRIBUTES2.duration,
-  COMPOSITION_ATTRIBUTES2.trackIndex
-]);
-var DERIVED_TIMING_ATTRIBUTES2 = Object.freeze([
-  COMPOSITION_ATTRIBUTES2.derivedEnd
-]);
-var LEGACY_TIMING_ATTRIBUTES2 = Object.freeze([
-  COMPOSITION_ATTRIBUTES2.derivedEnd,
-  COMPOSITION_ATTRIBUTES2.legacyTrack
-]);
-function parseNumeric2(value) {
-  if (value == null || value.trim() === "") return null;
-  const parsed = Number(value);
-  return Number.isFinite(parsed) ? parsed : null;
-}
-var nonNegative = (raw) => {
-  const value = parseNumeric2(raw);
-  return value !== null && value >= 0 ? value : null;
-};
-function readMediaOffsetSeconds(getAttr) {
-  return nonNegative(getAttr("data-playback-start")) ?? nonNegative(getAttr("data-media-start")) ?? 0;
-}
-var MIN_PLAYBACK_RATE = 0.1;
-var MAX_PLAYBACK_RATE = 10;
-function clampPlaybackRate(raw) {
-  return Number.isFinite(raw) && raw > 0 ? Math.max(MIN_PLAYBACK_RATE, Math.min(MAX_PLAYBACK_RATE, raw)) : 1;
-}
-function readPlaybackRate(getAttr, fallback = 1) {
-  const authored = Number.parseFloat(getAttr("data-playback-rate") ?? "");
-  return clampPlaybackRate(Number.isFinite(authored) && authored > 0 ? authored : fallback);
-}
-function readDataDurationSeconds(getAttr) {
-  const duration = parseNumeric2(getAttr("data-duration"));
-  return duration !== null && duration > 0 ? duration : null;
-}
-function readAuthoredDurationSeconds(getAttr, startSeconds) {
-  const duration = readDataDurationSeconds(getAttr);
-  if (duration !== null) return duration;
-  const end = parseNumeric2(getAttr("data-end"));
-  return end !== null ? end - startSeconds : null;
-}
-var DEFAULT_IMAGE_TIMELINE_DURATION_SECONDS = 3;
-function resolveNaturalDurationSeconds(sourceDurationSeconds, mediaStartSeconds, playbackRate) {
-  if (!Number.isFinite(sourceDurationSeconds)) return null;
-  const remaining = Math.max(0, sourceDurationSeconds - mediaStartSeconds);
-  return remaining / clampPlaybackRate(playbackRate);
-}
-function resolveMediaDuration(input) {
-  const { tag, authoredDurationSeconds, sourceDurationSeconds, mediaStartSeconds, playbackRate } = input;
-  if (authoredDurationSeconds !== null && authoredDurationSeconds > 0) {
-    return { seconds: authoredDurationSeconds, source: "authored" };
-  }
-  if (tag === "img") {
-    return { seconds: DEFAULT_IMAGE_TIMELINE_DURATION_SECONDS, source: "default" };
-  }
-  if (sourceDurationSeconds === null) {
-    return { seconds: null, source: "pending", reason: "source duration not yet probed" };
-  }
-  const seconds = resolveNaturalDurationSeconds(
-    sourceDurationSeconds,
-    mediaStartSeconds,
-    playbackRate
-  );
-  if (seconds === null) {
-    return { seconds: null, source: "pending", reason: "source reported a non-finite duration" };
-  }
-  return { seconds, source: "media" };
-}
-
-// ../parsers/dist/assets.js
-import { isAbsolute, relative, resolve } from "path";
-import { posix } from "path";
-var CSS_URL_RE = /\burl\(\s*(["']?)([^)"'\s](?:[^)"']*[^)"'\s])?)\1\s*\)/g;
-var PATH_ATTRS = ["src", "href"];
-function isNonRelativeUrl(val) {
-  return !val || val.startsWith("http://") || val.startsWith("https://") || val.startsWith("//") || val.startsWith("data:") || val.startsWith("#") || val.startsWith("/");
-}
-function isPathInside(childPath, parentPath) {
-  const absChild = resolve(childPath);
-  const absParent = resolve(parentPath);
-  if (absChild === absParent) return true;
-  const rel = relative(absParent, absChild);
-  return rel !== "" && !rel.startsWith("..") && !isAbsolute(rel);
-}
-var { join, resolve: resolve2, dirname } = posix;
-var isAbsoluteOrSpecial = isNonRelativeUrl;
-function needsRewrite(val) {
-  return val.startsWith("../") || val === "..";
-}
-function splitPathSuffix(value) {
-  const marker = value.search(/[?#]/);
-  return marker === -1 ? [value, ""] : [value.slice(0, marker), value.slice(marker)];
-}
-function rewriteAssetPath(compSrcPath, relativePath, assetExists) {
-  if (isAbsoluteOrSpecial(relativePath)) return relativePath;
-  const compDir = dirname(compSrcPath);
-  if (!compDir || compDir === ".") return relativePath;
-  if (!needsRewrite(relativePath)) {
-    if (!assetExists) return relativePath;
-    const [filePart, suffix] = splitPathSuffix(relativePath);
-    if (!filePart) return relativePath;
-    const sibling = resolve2("/", join(compDir, filePart)).slice(1);
-    return assetExists(sibling) ? sibling + suffix : relativePath;
-  }
-  const resolved = join(compDir, relativePath);
-  const normalized = resolve2("/", resolved).slice(1);
-  return normalized;
-}
-function rewriteAssetPaths(elements, compSrcPath, getAttr, setAttr, assetExists) {
-  for (const el of elements) {
-    for (const attr of PATH_ATTRS) {
-      const val = (getAttr(el, attr) || "").trim();
-      const rewritten = rewriteAssetPath(compSrcPath, val, assetExists);
-      if (rewritten !== val) {
-        setAttr(el, attr, rewritten);
-      }
-    }
-  }
-}
-function rewriteInlineStyleAssetUrls(elements, compSrcPath, getStyle, setStyle, assetExists) {
-  const compDir = dirname(compSrcPath);
-  if (!compDir || compDir === ".") return;
-  for (const el of elements) {
-    const style = getStyle(el);
-    if (!style) continue;
-    const rewritten = rewriteCssAssetUrls(style, compSrcPath, assetExists);
-    if (rewritten !== style) {
-      setStyle(el, rewritten);
-    }
-  }
-}
-function rewriteCssAssetUrls(cssText, compSrcPath, assetExists) {
-  if (!cssText) return cssText;
-  return cssText.replace(CSS_URL_RE, (full, quote, rawUrl) => {
-    const urlValue = (rawUrl || "").trim();
-    const rewritten = rewriteAssetPath(compSrcPath, urlValue, assetExists);
-    if (rewritten === urlValue) return full;
-    return `url(${quote || ""}${rewritten}${quote || ""})`;
-  });
-}
-
 // ../parsers/dist/subCompositionValidity.js
 function resolveSubCompositionContent(html, document) {
   const template = document.querySelector("template");
@@ -987,23 +836,6 @@ export {
   parseStartExpression,
   readClipTiming,
   writeClipTiming,
-  readMediaOffsetSeconds,
-  MIN_PLAYBACK_RATE,
-  MAX_PLAYBACK_RATE,
-  clampPlaybackRate,
-  readPlaybackRate,
-  readDataDurationSeconds,
-  readAuthoredDurationSeconds,
-  resolveNaturalDurationSeconds,
-  resolveMediaDuration,
-  CSS_URL_RE,
-  PATH_ATTRS,
-  isNonRelativeUrl,
-  isPathInside,
-  rewriteAssetPath,
-  rewriteAssetPaths,
-  rewriteInlineStyleAssetUrls,
-  rewriteCssAssetUrls,
   resolveSubCompositionContent,
   checkSubCompositionUsability,
   COLOR_GRADING_CONTRACT_VERSION,

package/dist/{chunk-PFCFR3KZ.js → chunk-442JNXRM.js}

@@ -6,7 +6,7 @@ var __filename = __hf_fileURLToPath(import.meta.url);
 var __dirname = __hf_dirname(__filename);
 import {
   DOMParser
-} from "./chunk-GK4AIFIH.js";
+} from "./chunk-SDYDNHEE.js";
 
 // src/utils/dom.ts
 function ensureDOMParser() {