hyperframes 0.8.45 → 0.8.47

package/dist/fontLocalizeCli.js

@@ -56326,37 +56326,80 @@ function finiteOr(value, fallback) {
 }
 function resolveMotionBlurPlan(options) {
   if (!options) return null;
-  const samplesPerFrame = Math.min(
+  const fixedSamplesPerFrame = options.samplesPerFrame === void 0 ? null : Math.min(
     MAX_SAMPLES_PER_FRAME,
     Math.max(1, Math.round(finiteOr(options.samplesPerFrame, DEFAULT_SAMPLES_PER_FRAME)))
   );
   const shutterAngle = finiteOr(options.shutterAngle, DEFAULT_SHUTTER_ANGLE);
   const shutterPhase = finiteOr(options.shutterPhase, DEFAULT_SHUTTER_PHASE);
   const blend = options.blend === "linear" ? "linear" : "srgb";
-  const windowStartFrames = shutterPhase / 360;
-  const shutterFrames = shutterAngle / 360;
-  const sampleTickOffsets = [];
+  return {
+    blend,
+    subFrameDivisions: SUB_FRAME_DIVISIONS,
+    windowStartFrames: shutterPhase / 360,
+    shutterFrames: shutterAngle / 360,
+    fixedSamplesPerFrame
+  };
+}
+function sampleTickOffsets(plan2, samplesPerFrame) {
+  const offsets = [];
   for (let k = 0; k < samplesPerFrame; k++) {
-    const offsetFrames = windowStartFrames + (k + 0.5) / samplesPerFrame * shutterFrames;
-    sampleTickOffsets.push(Math.round(offsetFrames * SUB_FRAME_DIVISIONS));
+    const offsetFrames = plan2.windowStartFrames + (k + 0.5) / samplesPerFrame * plan2.shutterFrames;
+    offsets.push(Math.round(offsetFrames * plan2.subFrameDivisions));
   }
-  return { blend, subFrameDivisions: SUB_FRAME_DIVISIONS, sampleTickOffsets };
+  return offsets;
 }
-function motionBlurSampleTimes(plan2, frameIndex, fps) {
+function motionBlurSampleTimes(plan2, frameIndex, fps, samplesPerFrame) {
   const grid = fps * plan2.subFrameDivisions;
   const frameTicks = frameIndex * plan2.subFrameDivisions;
-  return plan2.sampleTickOffsets.map((offset2) => Math.max(0, frameTicks + offset2) / grid);
+  return sampleTickOffsets(plan2, samplesPerFrame).map(
+    (offset2) => Math.max(0, frameTicks + offset2) / grid
+  );
 }
-function motionBlurWindowIsStatic(plan2, frameIndex, staticFrames) {
-  const first = Math.floor(
-    frameIndex - 1 + Math.min(...plan2.sampleTickOffsets) / plan2.subFrameDivisions
+function motionBlurProbeTimes(plan2, frameIndex, fps) {
+  const grid = fps * plan2.subFrameDivisions;
+  const frameTicks = frameIndex * plan2.subFrameDivisions;
+  const startTick = Math.round(plan2.windowStartFrames * plan2.subFrameDivisions);
+  const endTick = Math.round(
+    (plan2.windowStartFrames + plan2.shutterFrames) * plan2.subFrameDivisions
   );
-  const last = Math.floor(frameIndex + Math.max(...plan2.sampleTickOffsets) / plan2.subFrameDivisions) + 1;
+  return {
+    windowStart: Math.max(0, frameTicks + startTick) / grid,
+    windowEnd: Math.max(0, frameTicks + endTick) / grid
+  };
+}
+function motionBlurWindowIsStatic(plan2, frameIndex, staticFrames) {
+  const worstCaseSamples = plan2.fixedSamplesPerFrame ?? MAX_SAMPLES_PER_FRAME;
+  const inset = plan2.shutterFrames / (2 * worstCaseSamples);
+  const minOffsetFrames = plan2.windowStartFrames + inset;
+  const maxOffsetFrames = plan2.windowStartFrames + plan2.shutterFrames - inset;
+  const first = Math.floor(frameIndex - 1 + Math.min(0, minOffsetFrames));
+  const last = Math.floor(frameIndex + Math.max(0, maxOffsetFrames)) + 1;
   for (let frame = first; frame <= last; frame++) {
     if (!staticFrames.has(frame)) return false;
   }
   return true;
 }
+function adaptiveSampleCount(diff) {
+  for (const step of ADAPTIVE_SAMPLE_STEPS) {
+    if (diff <= step.maxDiff) return step.samples;
+  }
+  return MAX_SAMPLES_PER_FRAME;
+}
+function probeDiffMagnitude(a, b) {
+  const decodedA = decodePng(a);
+  const decodedB = decodePng(b);
+  if (decodedA.width !== decodedB.width || decodedA.height !== decodedB.height) {
+    throw new Error(
+      `probeDiffMagnitude: sample geometry mismatch (${decodedA.width}x${decodedA.height} vs ${decodedB.width}x${decodedB.height})`
+    );
+  }
+  let sum = 0;
+  for (let i = 0; i < decodedA.data.length; i++) {
+    sum += Math.abs(decodedA.data[i] - decodedB.data[i]);
+  }
+  return sum / decodedA.data.length;
+}
 function linearToByte(value) {
   const c = value <= 31308e-7 ? value * 12.92 : 1.055 * Math.pow(value, 1 / 2.4) - 0.055;
   return clampByte(c * 255);
@@ -56364,7 +56407,7 @@ function linearToByte(value) {
 function clampByte(value) {
   return Math.min(255, Math.max(0, Math.round(value)));
 }
-var MAX_SAMPLES_PER_FRAME, DEFAULT_SAMPLES_PER_FRAME, DEFAULT_SHUTTER_ANGLE, DEFAULT_SHUTTER_PHASE, SUB_FRAME_DIVISIONS, SRGB_TO_LINEAR, SRGB_PASSTHROUGH, MotionBlurAccumulator;
+var MAX_SAMPLES_PER_FRAME, DEFAULT_SAMPLES_PER_FRAME, DEFAULT_SHUTTER_ANGLE, DEFAULT_SHUTTER_PHASE, SUB_FRAME_DIVISIONS, ADAPTIVE_SAMPLE_STEPS, SPATIAL_TWEEN_PROPERTIES, SRGB_TO_LINEAR, SRGB_PASSTHROUGH, MotionBlurAccumulator;
 var init_motionBlur = __esm({
   "../engine/src/services/motionBlur.ts"() {
     "use strict";
@@ -56374,6 +56417,42 @@ var init_motionBlur = __esm({
     DEFAULT_SHUTTER_ANGLE = 180;
     DEFAULT_SHUTTER_PHASE = -90;
     SUB_FRAME_DIVISIONS = 4096;
+    ADAPTIVE_SAMPLE_STEPS = [
+      { maxDiff: 3, samples: DEFAULT_SAMPLES_PER_FRAME },
+      { maxDiff: 6, samples: 32 },
+      { maxDiff: Infinity, samples: MAX_SAMPLES_PER_FRAME }
+    ];
+    SPATIAL_TWEEN_PROPERTIES = [
+      "x",
+      "y",
+      "z",
+      "xPercent",
+      "yPercent",
+      "rotation",
+      "rotate",
+      "rotationX",
+      "rotationY",
+      "rotationZ",
+      "scale",
+      "scaleX",
+      "scaleY",
+      "scaleZ",
+      "skewX",
+      "skewY",
+      "perspective",
+      "transformPerspective",
+      "top",
+      "left",
+      "right",
+      "bottom",
+      "width",
+      "height",
+      "translate",
+      "translateX",
+      "translateY",
+      "translateZ",
+      "transform"
+    ];
     SRGB_TO_LINEAR = (() => {
       const lut = new Float64Array(256);
       for (let i = 0; i < 256; i++) lut[i] = srgbByteToLinear(i);
@@ -59995,7 +60074,13 @@ function isStaticDedupFrameAnalysisSafe(totalFrames) {
   return Number.isFinite(totalFrames) && Number.isSafeInteger(totalFrames) && totalFrames > 0 && totalFrames <= MAX_STATIC_DEDUP_ANALYSIS_FRAMES;
 }
 async function computeStaticFrameSet(page, fps) {
-  const result = await page.evaluate(() => {
+  const result = await page.evaluate((spatialProps) => {
+    const SPATIAL_PROPS = new Set(spatialProps);
+    function isSpatial(vars) {
+      if (!vars) return false;
+      for (const key2 of Object.keys(vars)) if (SPATIAL_PROPS.has(key2)) return true;
+      return false;
+    }
     const intervals2 = [];
     let tweenCount2 = 0;
     let hasTimelineCall2 = false;
@@ -60003,7 +60088,7 @@ async function computeStaticFrameSet(page, fps) {
       if (typeof tl.getChildren !== "function") return;
       if (typeof tl.vars?.onUpdate === "function") {
         const total = typeof tl.totalDuration === "function" ? tl.totalDuration() : 0;
-        if (total > 0) intervals2.push({ start: offset2, end: offset2 + total });
+        if (total > 0) intervals2.push({ start: offset2, end: offset2 + total, spatial: true });
       }
       for (const child of tl.getChildren(false, true, true)) {
         const start = offset2 + (typeof child.startTime === "function" ? child.startTime() : 0);
@@ -60011,14 +60096,14 @@ async function computeStaticFrameSet(page, fps) {
         const total = typeof child.totalDuration === "function" ? child.totalDuration() : single;
         if (typeof child.getChildren === "function") {
           if (total > single + 1e-6) {
-            intervals2.push({ start, end: start + total });
+            intervals2.push({ start, end: start + total, spatial: true });
             walk(child, start);
           } else {
             walk(child, start);
           }
         } else {
           tweenCount2++;
-          intervals2.push({ start, end: start + total });
+          intervals2.push({ start, end: start + total, spatial: isSpatial(child.vars) });
           if (total <= 1e-6 && (typeof child.vars?.onComplete === "function" || typeof child.vars?.onReverseComplete === "function")) {
             hasTimelineCall2 = true;
           }
@@ -60059,7 +60144,7 @@ async function computeStaticFrameSet(page, fps) {
       hasUnresolvableClipStart: hasUnresolvableClipStart2,
       hasTimelineCall: hasTimelineCall2
     };
-  });
+  }, SPATIAL_TWEEN_PROPERTIES);
   const {
     intervals,
     tweenCount,
@@ -60075,6 +60160,7 @@ async function computeStaticFrameSet(page, fps) {
     return {
       totalFrames,
       staticFrameSet: /* @__PURE__ */ new Set(),
+      nonSpatialOnlyFrameSet: /* @__PURE__ */ new Set(),
       hasVideo,
       hasCanvas,
       hasNonGsapAnim,
@@ -60084,10 +60170,14 @@ async function computeStaticFrameSet(page, fps) {
     };
   }
   const animated = /* @__PURE__ */ new Set();
-  for (const { start, end } of intervals) {
+  const spatialFrameSet = /* @__PURE__ */ new Set();
+  for (const { start, end, spatial } of intervals) {
     const lo = Math.max(0, Math.floor(start * fps));
     const hi = Math.min(totalFrames - 1, Math.ceil(end * fps));
-    for (let f = lo; f <= hi; f++) animated.add(f);
+    for (let f = lo; f <= hi; f++) {
+      animated.add(f);
+      if (spatial) spatialFrameSet.add(f);
+    }
   }
   for (const f of await computeClipBoundaryFrames(page, fps)) animated.add(f);
   const reasons = [];
@@ -60105,9 +60195,14 @@ async function computeStaticFrameSet(page, fps) {
       if (!animated.has(f) && !animated.has(f - 1)) staticFrameSet.add(f);
     }
   }
+  const nonSpatialOnlyFrameSet = /* @__PURE__ */ new Set();
+  if (eligible) {
+    for (const f of animated) if (!spatialFrameSet.has(f)) nonSpatialOnlyFrameSet.add(f);
+  }
   return {
     totalFrames,
     staticFrameSet,
+    nonSpatialOnlyFrameSet,
     hasVideo,
     hasCanvas,
     hasNonGsapAnim,
@@ -60317,6 +60412,11 @@ async function verifyStaticFramesSafe(session, page, staticFrames, fps, sampleCo
   }
 }
 async function armStaticDedup(session, page, logInitPhase) {
+  let sharedStaticFrameStats;
+  if (session.options.motionBlur && session.options.motionBlur.samplesPerFrame === void 0 && !session.motionBlurNonSpatialFrames) {
+    sharedStaticFrameStats = await computeStaticFrameSet(page, fpsToNumber(session.options.fps));
+    session.motionBlurNonSpatialFrames = sharedStaticFrameStats.nonSpatialOnlyFrameSet;
+  }
   if (session.staticFrames || session.staticDedupSkipReason) return;
   session.staticDedupEnabled = session.config?.staticFrameDedup !== false;
   if (!session.staticDedupEnabled) return;
@@ -60341,7 +60441,7 @@ async function armStaticDedup(session, page, logInitPhase) {
     return;
   }
   const fps = fpsToNumber(session.options.fps);
-  const stats = await computeStaticFrameSet(page, fps);
+  const stats = sharedStaticFrameStats ?? await computeStaticFrameSet(page, fps);
   if (!stats.eligible || stats.staticFrameSet.size === 0) {
     session.staticDedupSkipReason = "ineligible";
     logInitPhase(`static-frame dedup: disabled (${stats.reason})`);
@@ -60587,6 +60687,25 @@ function finalizeSessionInit(session) {
   session.motionBlur = resolveSessionMotionBlur(session);
   session.isInitialized = true;
 }
+async function resolveAdaptiveSampleCount(session, frameIndex, absFrameIndex, plan2, fps, sampleSeek) {
+  if (session.motionBlurNonSpatialFrames?.has(absFrameIndex)) {
+    return {
+      samplesPerFrame: DEFAULT_SAMPLES_PER_FRAME,
+      seekMs: 0,
+      beforeCaptureMs: 0,
+      screenshotMs: 0
+    };
+  }
+  const { windowStart, windowEnd } = motionBlurProbeTimes(plan2, absFrameIndex, fps);
+  const probeA = await captureFrameSurface(session, frameIndex, windowStart, sampleSeek);
+  const probeB = await captureFrameSurface(session, frameIndex, windowEnd, sampleSeek);
+  return {
+    samplesPerFrame: adaptiveSampleCount(probeDiffMagnitude(probeA.buffer, probeB.buffer)),
+    seekMs: probeA.seekMs + probeB.seekMs,
+    beforeCaptureMs: probeA.beforeCaptureMs + probeB.beforeCaptureMs,
+    screenshotMs: probeA.screenshotMs + probeB.screenshotMs
+  };
+}
 async function captureAccumulatedFrame(session, frameIndex, absFrameIndex, plan2) {
   const fps = fpsToNumber(session.options.fps);
   const frameTime = quantizeSeekTime(absFrameIndex / fps, fps);
@@ -60597,8 +60716,23 @@ async function captureAccumulatedFrame(session, frameIndex, absFrameIndex, plan2
     suppressEvents: true,
     subFrameDivisions: plan2.subFrameDivisions
   };
+  let samplesPerFrame = plan2.fixedSamplesPerFrame;
+  if (samplesPerFrame === null) {
+    const chosen = await resolveAdaptiveSampleCount(
+      session,
+      frameIndex,
+      absFrameIndex,
+      plan2,
+      fps,
+      sampleSeek
+    );
+    samplesPerFrame = chosen.samplesPerFrame;
+    totals.seekMs += chosen.seekMs;
+    totals.beforeCaptureMs += chosen.beforeCaptureMs;
+    totals.screenshotMs += chosen.screenshotMs;
+  }
   const accumulator = new MotionBlurAccumulator(plan2.blend);
-  for (const sampleTime of motionBlurSampleTimes(plan2, absFrameIndex, fps)) {
+  for (const sampleTime of motionBlurSampleTimes(plan2, absFrameIndex, fps, samplesPerFrame)) {
     const sample = await captureFrameSurface(session, frameIndex, sampleTime, sampleSeek);
     totals.seekMs += sample.seekMs;
     totals.beforeCaptureMs += sample.beforeCaptureMs;
@@ -100520,8 +100654,8 @@ async function runFontLocalize(io, localize) {
 }
 
 // src/version.ts
-var VERSION = true ? "0.8.45" : "0.0.0-dev";
-var PRODUCER_VERSION = true ? "0.8.45" : "0.0.0-dev";
+var VERSION = true ? "0.8.47" : "0.0.0-dev";
+var PRODUCER_VERSION = true ? "0.8.47" : "0.0.0-dev";
 
 // src/fontLocalizeCli.ts
 async function readStdin() {