@pictor-sdk/video-android 0.1.5 → 0.2.0

package/android/src/main/java/dev/pictor/video/CompositionSpike.kt

@@ -212,6 +212,9 @@ internal object CompositionSpike {
         private set
 
     @Volatile var readinessTimeouts = 0L
+
+    /** How many resumes had to be re-primed because no frame could satisfy them. */
+    @Volatile var primedResumes = 0L
         private set
 
     /** How long a hold may wait before it is reported as a failure. */
@@ -408,19 +411,24 @@ internal object CompositionSpike {
         */
         if (seamHoldTargetUs >= 0) return pts >= seamHoldTargetUs
 
-        return pts >= epochTargetUs - FRAME_MATCH_BACK_US &&
-            pts <= epochTargetUs + FRAME_MATCH_AHEAD_US
+        return ResumeReadiness.matches(pts, epochTargetUs)
     }
 
     /**
-     * How far a frame may sit from the epoch's target and still be its first.
+     * The newest frame the pipeline actually has, or null if there is none.
      *
-     * Backwards by about a frame, because a seek lands on the preceding
-     * keyframe-derived sample; forwards by a second, because the first frame
-     * after a seek into a long GOP can legitimately be later than asked for.
+     * The same three checks the gate makes before it will look at a timestamp:
+     * latched rather than merely offered, pixels and timestamp from the same
+     * frame, and a usable project time. A caller deciding where to re-prime has
+     * to be reading the same frame the gate will be judging.
      */
-    private const val FRAME_MATCH_BACK_US = 40_000L
-    private const val FRAME_MATCH_AHEAD_US = 1_000_000L
+    private fun latchedFramePtsUs(): Long? {
+        val frame = FrameClock.latestSample() ?: return null
+        if (frame[FrameClock.Field.CONSUMED_NS] <= 0L) return null
+        if (frame[FrameClock.Field.ASSOCIATION] != 1L) return null
+        val pts = frame[FrameClock.Field.PTS_US]
+        return if (pts < 0L) null else pts
+    }
 
     /** Retained evidence, so an excursion can be looked at rather than inferred. */
     private const val RING = 8192
@@ -660,6 +668,7 @@ internal object CompositionSpike {
             .put("releases", releases)
             .put("readinessTimeouts", readinessTimeouts)
             .put("readinessFailure", readinessFailure ?: JSONObject.NULL)
+            .put("primedResumes", primedResumes)
             /*
               Hold durations, listed rather than summarised.
 
@@ -912,7 +921,38 @@ internal object CompositionSpike {
     fun play(): String = onPlayer {
         intentPlaying = true
         // Resume targets where the transport already is.
-        armRelease(it.currentPosition * 1000)
+        val clockUs = it.currentPosition * 1000
+        /*
+          Unless nothing can show that position.
+
+          Coming back from the background the renderer has stopped latching
+          while the transport kept counting, so the newest frame can sit a
+          frame or two behind the clock — past the gate's backward tolerance.
+          Arming there asks for a frame the decoder will never produce while it
+          is paused, and a seek to the position it already reports need not
+          produce one either, so the hold times out and every later press of
+          play repeats the same impossible wait.
+
+          Re-primed instead of relaxed: playback seeks to the timestamp of the
+          frame on screen, which is a real position and a different one, so the
+          decoder emits for it and the gate releases on a frame made for this
+          epoch. See `ResumeReadiness`.
+        */
+        val primeUs =
+            if (seamHoldTargetUs >= 0) null
+            else ResumeReadiness.primeTargetUs(clockUs, latchedFramePtsUs())
+        if (primeUs == null) {
+            armRelease(clockUs)
+            return@onPlayer
+        }
+        // A new epoch, for the same reason a seek opens one: what is in flight
+        // describes the position being left, not the one being asked for.
+        epoch += 1
+        epochAtNs = System.nanoTime()
+        FrameClock.bump()
+        primedResumes += 1
+        armRelease(primeUs)
+        it.seekTo(primeUs / 1000)
     }
 
     fun pause(): String = onPlayer {

package/android/src/main/java/dev/pictor/video/ExportGate.kt

@@ -1598,6 +1598,123 @@ internal class ExportGate(private val context: Context) {
         }
     }
 
+    /**
+     * Export a single still photograph with animated overlays.
+     *
+     * The still is encoded directly from the PNG through the same image path
+     * `runStill` proves, and the overlays are the same compiled scene program a
+     * video project uses. There is no audio and no mux: a photo story gets a
+     * silent MP4 whose duration is the story duration.
+     *
+     * Publication is the same staged rename as `runProject`, because the failure
+     * that matters is identical — a half-written file replacing a good one.
+     */
+    fun runPhotoProject(
+        pngBytes: ByteArray,
+        programJson: String,
+        overlaysJson: String,
+        durationUs: Long,
+        timeoutSeconds: Long = 180,
+        destinationJson: String = "",
+    ): Outcome {
+        val target = if (destinationJson.isEmpty()) null else GateDestination.parse(destinationJson)
+        if (target != null) {
+            GateDestination.validate(target)?.let {
+                refusals.incrementAndGet()
+                return failed(it, 0, Thread.currentThread().name)
+            }
+        }
+        if (durationUs <= 0) {
+            refusals.incrementAndGet()
+            return failed("photo duration must be positive", 0, Thread.currentThread().name)
+        }
+        val (compiled, invalid) = SceneProgramNative.parse(programJson)
+        if (compiled == null) {
+            refusals.incrementAndGet()
+            return failed("program rejected: " + (invalid?.reason ?: "unknown"), 0, Thread.currentThread().name)
+        }
+        val (resources, badResource) = OverlayResources.parse(context, overlaysJson)
+        if (resources == null) {
+            refusals.incrementAndGet()
+            return failed(
+                "overlay resources rejected: " + (badResource?.reason ?: "unknown"),
+                0, Thread.currentThread().name,
+            )
+        }
+        for (id in compiled.requiredResourceIds()) {
+            if (!resources.entries.containsKey(id)) {
+                refusals.incrementAndGet()
+                return failed(
+                    "overlay resource '" + id + "' is referenced by the program but not supplied",
+                    0, Thread.currentThread().name,
+                )
+            }
+        }
+        val still = File.createTempFile(TEMP_PREFIX + "photo-", ".png", context.cacheDir)
+        synchronized(created) { tempFilesCreated.incrementAndGet(); created.add(still) }
+        var videoUri: String? = null
+        try {
+            still.writeBytes(pngBytes)
+            val video = runSequence(
+                listOf(still.absolutePath), timeoutSeconds, compiled,
+                withSkia = true, stillDurationUs = durationUs, overlays = resources,
+            )
+            if (!video.ok) return video
+            videoUri = video.uri
+            if (target == null) return video.copy(hasAudio = false)
+            if (cancelled) {
+                return failed("cancelled during publishing", 0, Thread.currentThread().name)
+            }
+            val output = File(video.uri)
+            val sweptStaging = GateDestination.sweepStaging(target)
+            val staging = GateDestination.stagingFor(target, System.nanoTime())
+            synchronized(created) { tempFilesCreated.incrementAndGet(); created.add(staging) }
+            val stageError = GateDestination.stage(
+                output, staging, keepGoing = { !cancelled },
+                beatEpoch = ExportHeartbeat.currentEpoch(),
+            )
+            if (stageError != null) {
+                releaseTemp(staging)
+                return failed(
+                    if (stageError == "cancelled") "cancelled during publishing" else stageError,
+                    0, Thread.currentThread().name,
+                )
+            }
+            val stagedProbe = GateDestination.probe(staging.absolutePath)
+            if (!stagedProbe.optBoolean("readable", false)) {
+                releaseTemp(staging)
+                return failed(
+                    "the staged file could not be read back: " + stagedProbe.optString("error", "no video track"),
+                    0, Thread.currentThread().name,
+                )
+            }
+            GateDestination.publish(staging, target)?.let {
+                releaseTemp(staging)
+                return failed(it, 0, Thread.currentThread().name)
+            }
+            synchronized(created) {
+                if (created.remove(staging)) tempFilesReleased.incrementAndGet()
+            }
+            return video.copy(
+                uri = target.path,
+                fileBytes = File(target.path).length(),
+                hasAudio = false,
+                boundary = if (sweptStaging > 0) "sweptStaging=" + sweptStaging else video.boundary,
+            )
+        } finally {
+            releaseTemp(still)
+            /*
+              A temporary belongs to the caller.
+
+              The adapter probes the returned uri before it reports success, so
+              releasing it here deletes the file out from under that probe —
+              which is exactly an unopenable "success". Only a published file
+              leaves a temp of ours to clean up.
+            */
+            if (target != null) videoUri?.let { releaseTemp(File(it)) }
+        }
+    }
+
     /**
      * One audio-only pass over the whole timeline.
      *

package/android/src/main/java/dev/pictor/video/PictorVideoModule.kt

@@ -369,6 +369,50 @@ class PictorVideoModule(reactContext: ReactApplicationContext) :
         return GateFrames.framePng(reactApplicationContext, uri, timeUs.toLong())
     }
 
+    /**
+     * Export a photo story: one still, animated overlays, no audio.
+     *
+     * The base is PNG bytes because a photo story has no video source. Animated
+     * overlays are the same resource list the video exporter prepares, so the
+     * still path cannot drift into a second renderer.
+     */
+    @androidx.media3.common.util.UnstableApi
+    override fun exportRunPhotoProjectAsync(
+        jobId: String,
+        pngPath: String,
+        programJson: String,
+        overlaysJson: String,
+        durationUs: Double,
+        timeoutSeconds: Double,
+        destinationJson: String,
+        promise: com.facebook.react.bridge.Promise,
+    ) {
+        val running = gate ?: ExportGate(reactApplicationContext).also { gate = it }
+        if (!running.beginJob(jobId)) {
+            promise.resolve(
+                org.json.JSONObject().put("ok", false)
+                    .put("error", "an export is already running").toString(),
+            )
+            return
+        }
+        exportExecutor.execute {
+            val outcome = try {
+                val bytes = java.io.File(pngPath).readBytes()
+                val result = running.runPhotoProject(
+                    bytes, programJson, overlaysJson, durationUs.toLong(),
+                    timeoutSeconds.toLong(), destinationJson,
+                )
+                report(result, running)
+            } catch (e: Throwable) {
+                org.json.JSONObject().put("ok", false)
+                    .put("error", e.javaClass.simpleName + ": " + e.message).toString()
+            } finally {
+                running.endJob()
+            }
+            promise.resolve(outcome)
+        }
+    }
+
     /**
      * Run an export off the bridge, so it can be cancelled while it runs.
      *

package/android/src/main/java/dev/pictor/video/ResumeReadiness.kt

@@ -0,0 +1,82 @@
+package dev.pictor.video
+
+/**
+ * Where a resume may be released, and where it has to be re-primed first.
+ *
+ * The readiness gate releases the transport only on a frame that shows the
+ * epoch's position. That is the right rule, and it is kept exactly: this is the
+ * arithmetic behind it, pulled out so it can be reasoned about and tested
+ * without a player.
+ *
+ * ## The failure it exists for
+ *
+ * A resume's target is the transport clock, and the clock can sit ahead of the
+ * newest frame that exists. When the app goes to the background the renderer
+ * stops latching before the transport stops counting, so the last frame on
+ * screen ends up a frame or two behind the position the player reports. Arming
+ * on the clock then asks for a frame that nothing will produce — the decoder is
+ * paused, and Media3 need not emit anything for a seek to the position it is
+ * already at — so the gate waits out its three seconds and the transport is
+ * left stopped. Pressing play again re-arms the same impossible wait.
+ *
+ * Measured on a Pixel 7, opening the system document picker from "Add music":
+ * targets 46,667 us and 53,334 us ahead of the newest frame against a 40,000 us
+ * backward tolerance, wedging two runs in five. The runs that recovered had
+ * gaps inside the tolerance.
+ *
+ * ## What is done about it
+ *
+ * Re-prime, rather than relax. When no frame can satisfy the hold, playback
+ * seeks to the timestamp of the frame already on screen — a real position that
+ * differs from the clock, so the decoder emits for it — and the gate then
+ * releases on a frame produced for this epoch. The tolerances are untouched,
+ * nothing starts on an unverified frame, and the distance moved is whatever the
+ * renderer fell behind rather than a nudge chosen to clear the comparison.
+ */
+internal object ResumeReadiness {
+
+    /**
+     * How far a frame may sit from the epoch's target and still be its first.
+     *
+     * Backwards by about a frame, because a seek lands on the preceding
+     * keyframe-derived sample; forwards by a second, because the first frame
+     * after a seek into a long GOP can legitimately be later than asked for.
+     */
+    const val FRAME_MATCH_BACK_US = 40_000L
+    const val FRAME_MATCH_AHEAD_US = 1_000_000L
+
+    /** Whether a frame at [framePtsUs] shows the position [targetUs] asks for. */
+    fun matches(framePtsUs: Long, targetUs: Long): Boolean =
+        framePtsUs >= targetUs - FRAME_MATCH_BACK_US &&
+            framePtsUs <= targetUs + FRAME_MATCH_AHEAD_US
+
+    /**
+     * The position a stalled resume has to re-prime at, or null to wait as usual.
+     *
+     * [framePtsUs] is the newest latched, associated frame of the current
+     * generation, or null when there is none — after a seek, for instance, where
+     * `FrameClock.bump` has cleared it and the seek's own frame is on its way.
+     * With nothing latched there is nothing to re-prime at and nothing to
+     * conclude, so the ordinary wait applies.
+     *
+     * Returns null when the gate can already be satisfied, so an ordinary start
+     * or seek is completely unaffected: this only fires where playback would
+     * otherwise wait for a frame that cannot arrive.
+     *
+     * A frame further behind than [FRAME_MATCH_AHEAD_US] is not treated as the
+     * current picture at all. That is a stalled pipeline rather than a renderer
+     * that stopped a couple of frames early, and seeking a second backwards to
+     * meet it would be starting playback somewhere nobody asked for. It is left
+     * to time out and be reported, which is what that timeout is for.
+     */
+    fun primeTargetUs(clockUs: Long, framePtsUs: Long?): Long? {
+        if (framePtsUs == null) return null
+        if (matches(framePtsUs, clockUs)) return null
+        // Ahead of the clock is not this problem: a frame in front of the target
+        // is already covered by the forward tolerance, and seeking back to it
+        // would move playback the wrong way.
+        if (framePtsUs > clockUs) return null
+        if (framePtsUs < clockUs - FRAME_MATCH_AHEAD_US) return null
+        return framePtsUs
+    }
+}

package/dist/index.d.mts

@@ -1026,6 +1026,19 @@ interface CompositionPlaybackState {
     width: number;
     height: number;
     error: string | null;
+    /**
+     * Why the transport refused to start, or null.
+     *
+     * Playback is released on a frame that shows the position asked for, and if
+     * no such frame arrives the hold times out and the transport stays stopped
+     * rather than starting on an unverified picture. That used to be invisible:
+     * the control stayed enabled, the press was accepted, and nothing happened,
+     * with no way for a host to tell that apart from a person who had not pressed
+     * it yet. Pressing play again clears it and tries afresh.
+     *
+     * @experimental
+     */
+    readinessFailure: string | null;
 }
 /** @experimental */
 type CompositionPlayback = Omit<Media3Playback, 'state'> & {
@@ -1305,6 +1318,18 @@ interface Media3ExporterOptions {
      * @experimental
      */
     videoSpeedVia?: 'cadence' | 'media3';
+    /**
+     * Render one photo clip to the PNG a photo-story export encodes.
+     *
+     * A photo project has no video source for the base frame, so the host renders
+     * it through the same document renderer the preview uses and returns a local
+     * PNG path. Without this a photo project is refused exactly as before.
+     *
+     * Only a project consisting of exactly one photo is accepted: a sequence of
+     * stills is a slideshow with its own timeline rules, and silently treating it
+     * as one long still would be a different composition.
+     */
+    renderPhotoBase?(source: MediaSource, clipId: string): Promise<string>;
 }
 /** Why an export will not start. @experimental */
 declare class VideoExportRejected extends Error {
@@ -2501,6 +2526,16 @@ interface CompositionSpikeState {
     releases?: number;
     readinessTimeouts?: number;
     readinessFailure?: string | null;
+    /**
+     * How many resumes had to be re-primed because no frame could satisfy them.
+     *
+     * A resume whose target sits past the newest frame cannot be released on
+     * anything that exists, so playback seeks to the frame on screen to make the
+     * decoder produce one. Counted because it is a recovery, not a normal path:
+     * a number that climbs steadily is the renderer falling behind the transport
+     * more often than it should.
+     */
+    primedResumes?: number;
     /** How long the last hold lasted before playback was released. */
     holdMs?: number;
     /**

package/dist/index.d.ts

@@ -1026,6 +1026,19 @@ interface CompositionPlaybackState {
     width: number;
     height: number;
     error: string | null;
+    /**
+     * Why the transport refused to start, or null.
+     *
+     * Playback is released on a frame that shows the position asked for, and if
+     * no such frame arrives the hold times out and the transport stays stopped
+     * rather than starting on an unverified picture. That used to be invisible:
+     * the control stayed enabled, the press was accepted, and nothing happened,
+     * with no way for a host to tell that apart from a person who had not pressed
+     * it yet. Pressing play again clears it and tries afresh.
+     *
+     * @experimental
+     */
+    readinessFailure: string | null;
 }
 /** @experimental */
 type CompositionPlayback = Omit<Media3Playback, 'state'> & {
@@ -1305,6 +1318,18 @@ interface Media3ExporterOptions {
      * @experimental
      */
     videoSpeedVia?: 'cadence' | 'media3';
+    /**
+     * Render one photo clip to the PNG a photo-story export encodes.
+     *
+     * A photo project has no video source for the base frame, so the host renders
+     * it through the same document renderer the preview uses and returns a local
+     * PNG path. Without this a photo project is refused exactly as before.
+     *
+     * Only a project consisting of exactly one photo is accepted: a sequence of
+     * stills is a slideshow with its own timeline rules, and silently treating it
+     * as one long still would be a different composition.
+     */
+    renderPhotoBase?(source: MediaSource, clipId: string): Promise<string>;
 }
 /** Why an export will not start. @experimental */
 declare class VideoExportRejected extends Error {
@@ -2501,6 +2526,16 @@ interface CompositionSpikeState {
     releases?: number;
     readinessTimeouts?: number;
     readinessFailure?: string | null;
+    /**
+     * How many resumes had to be re-primed because no frame could satisfy them.
+     *
+     * A resume whose target sits past the newest frame cannot be released on
+     * anything that exists, so playback seeks to the frame on screen to make the
+     * decoder produce one. Counted because it is a recovery, not a normal path:
+     * a number that climbs steadily is the renderer falling behind the transport
+     * more often than it should.
+     */
+    primedResumes?: number;
     /** How long the last hold lasted before playback was released. */
     holdMs?: number;
     /**

package/dist/index.js

@@ -884,7 +884,8 @@ function composedState(snapshot) {
         */
     width: 0,
     height: 0,
-    error: snapshot.error ?? null
+    error: snapshot.error ?? null,
+    readinessFailure: snapshot.readinessFailure ?? null
   };
 }
 function useCompositionPlayback(options) {
@@ -1824,11 +1825,26 @@ var VideoExportRejected = class extends Error {
   }
 };
 var DEFAULT_FPS = 30;
-function describeUnsupported(project, spec) {
+function animatedSchedulesFor(project) {
+  const schedules = {};
+  for (const overlay of project.overlays) {
+    if (overlay.type !== "sticker") continue;
+    const data = overlay.data;
+    if (data && data.animation) schedules[overlay.id] = data.animation;
+  }
+  return schedules;
+}
+function describeUnsupported(project, spec, options) {
   const reasons = [];
   for (const clip of project.clips) {
     if (clip.kind === "photo") {
-      reasons.push(`clip '${clip.id}' is a photo, which this exporter does not encode yet`);
+      if (!options.renderPhotoBase) {
+        reasons.push(`clip '${clip.id}' is a photo, and no photo renderer was supplied`);
+      } else if (project.clips.length !== 1) {
+        reasons.push(
+          `clip '${clip.id}' is a photo in a project of ${project.clips.length} clips; only a single-photo story is supported`
+        );
+      }
       continue;
     }
   }
@@ -1860,11 +1876,107 @@ function createMedia3VideoExporter(options) {
         if (issues.length > 0) {
           throw new VideoExportRejected(issues.map((issue) => issue.message));
         }
-        const unsupported = describeUnsupported(project, spec);
+        const unsupported = describeUnsupported(project, spec, options);
         if (unsupported.length > 0) throw new VideoExportRejected(unsupported);
         const decision = resolveDestination(spec.destination);
         if (decision.destination === null) throw new VideoExportRejected(decision.reasons);
         const destination = decision.destination;
+        const photoOnly = project.clips.length === 1 && project.clips[0].kind === "photo";
+        if (photoOnly) {
+          const clip = project.clips[0];
+          if (!options.renderPhotoBase) {
+            throw new VideoExportRejected([`clip '${clip.id}' is a photo, and no photo renderer was supplied`]);
+          }
+          const pngPath = await options.renderPhotoBase(clip.source, clip.id);
+          job.checkpoint("resolving");
+          const photoProgram = (0, import_video_core6.compileVideoSceneProgram)(project, {
+            animatedSchedules: animatedSchedulesFor(project)
+          });
+          if (photoProgram.segments.length === 0) {
+            throw new VideoExportRejected(["the compiled program has no segments"]);
+          }
+          const named2 = /* @__PURE__ */ new Set();
+          for (const segment of photoProgram.segments) {
+            for (const command of segment.commands) {
+              if (command.op === "overlay") named2.add(command.overlayId);
+            }
+          }
+          const overlayPlan2 = options.prepareOverlays ? options.prepareOverlays(photoProgram, project.size, 1) : {
+            resources: [],
+            pending: [],
+            invalid: [...named2].map((overlayId) => ({
+              overlayId,
+              kind: "unknown",
+              reason: "no prepareOverlays was supplied, so this overlay has no portable form"
+            }))
+          };
+          const stagedNow2 = overlayPlan2.resources.map((resource) => resource.file);
+          if (overlayPlan2.pending.length > 0) {
+            options.releaseResources?.(stagedNow2);
+            throw new VideoExportRejected(
+              overlayPlan2.pending.map(
+                (id) => `overlay '${id}' is still preparing; export would omit it`
+              )
+            );
+          }
+          if (overlayPlan2.invalid.length > 0) {
+            options.releaseResources?.(stagedNow2);
+            throw new VideoExportRejected(
+              overlayPlan2.invalid.map(
+                (bad) => `overlay '${bad.overlayId}' (${bad.kind}): ${bad.reason}`
+              )
+            );
+          }
+          job.checkpoint("overlays");
+          let outcome2;
+          try {
+            outcome2 = JSON.parse(
+              await nativeModule().exportRunPhotoProjectAsync(
+                job.id,
+                pngPath,
+                JSON.stringify({
+                  version: import_video_core6.VIDEO_SCENE_PROGRAM_VERSION,
+                  projectSize: { width: project.size.width, height: project.size.height },
+                  durationUs: photoProgram.durationUs,
+                  segments: photoProgram.segments
+                }),
+                JSON.stringify(overlayPlan2.resources),
+                (0, import_video_core6.projectDuration)(project),
+                180,
+                destination.kind === "file" ? JSON.stringify({
+                  kind: "file",
+                  path: destination.path,
+                  overwrite: destination.overwrite
+                }) : ""
+              )
+            );
+          } finally {
+            options.releaseResources?.(stagedNow2);
+          }
+          if (!outcome2.ok) {
+            const error = outcome2.error || "the export failed";
+            if (isRefusal(error)) throw new VideoExportRejected([error]);
+            throw new import_video_core6.VideoExportFailed(job.id, "encoding", error);
+          }
+          const probe2 = JSON.parse(nativeModule().exportProbeOutput(outcome2.uri));
+          if (!probe2.readable) {
+            throw new import_video_core6.VideoExportFailed(
+              job.id,
+              "publishing",
+              `${describeTarget(outcome2.uri)} could not be read back: ${probe2.error ?? "no video track"}`
+            );
+          }
+          if (destination.kind === "file") return { kind: "file", uri: outcome2.uri };
+          const temporaryUri2 = outcome2.uri;
+          return {
+            kind: "temporary",
+            uri: temporaryUri2,
+            release: async () => {
+              await Promise.resolve();
+              nativeModule().exportReleaseTemporaryOutput(temporaryUri2);
+            }
+          };
+        }
         const playable = project.clips.filter((clip) => (0, import_video_core6.isPlayableWindow)(clip));
         if (playable.length === 0) throw new VideoExportRejected(["the project has no playable clips"]);
         if (!((0, import_video_core6.projectDuration)(project) > 0)) {
@@ -1891,7 +2003,9 @@ function createMedia3VideoExporter(options) {
           targetFps: fps
         }));
         const plan = (0, import_video_core6.planClipShards)(requests, fps);
-        const program = (0, import_video_core6.compileVideoSceneProgram)(project);
+        const program = (0, import_video_core6.compileVideoSceneProgram)(project, {
+          animatedSchedules: animatedSchedulesFor(project)
+        });
         if (program.segments.length === 0) {
           throw new VideoExportRejected(["the compiled program has no segments"]);
         }