@effect-motion/export 0.4.0 → 0.5.0

package/dist/Video.d.ts

@@ -1,16 +1,21 @@
-import { type ThorvgException } from "@effect-motion/thorvg";
+import type { ThreeException } from "@effect-motion/three";
 import * as Effect from "effect/Effect";
 import type * as Scope from "effect/Scope";
 import type { ChildProcessSpawner } from "effect/unstable/process";
-import { Scene } from "effect-motion";
+import type { EffectMotionError } from "effect-motion";
+import { type Resource, Scene } from "effect-motion";
 import * as Ffmpeg from "./Ffmpeg.js";
 type SceneRunner = typeof Scene.tick extends Effect.Effect<unknown, unknown, infer RR> ? RR : never;
 type SceneInternalR = SceneRunner | Scope.Scope;
 /**
  * The one-call export path: a scene becomes a video file. Composes the whole
- * pipeline — `Scene.stream` → ThorVG PNG renderer → ffmpeg — reading the
- * framerate and dimensions from the scene's own frame metadata. The ThorVG
- * engine is acquired internally (Node SW layer), so callers wire nothing.
+ * pipeline — `Scene.stream` → three GPU renderer (Dawn) → PNG → ffmpeg —
+ * reading the framerate and dimensions from the scene's own frame metadata.
+ * The renderer is acquired internally, so callers wire nothing.
+ *
+ * ponytail: frames rasterize serially (sync → render → readback per frame);
+ * readback being async allows pipelining ahead of the encoder if it ever
+ * becomes the bottleneck.
  */
 /**
  * Playback settings honored by the export path — a subset of the runner's
@@ -39,7 +44,7 @@ export interface VideoOptions {
     /** Extra ffmpeg arguments, appended before the output path. */
     readonly extraArgs?: ReadonlyArray<string>;
     /**
-     * Supersampling factor: frames are rasterized at scene dimensions × dpr
+     * Supersampling factor: frames are rendered at scene dimensions × dpr
      * (the video's pixel size) while the scene keeps its authored logical
      * coordinates and framing. Defaults to 1.
      */
@@ -52,7 +57,8 @@ export interface VideoOptions {
  *
  * Fails with {@link Ffmpeg.EncodeError} on odd output dimensions (invalid for
  * `yuv420p`) — before any ffmpeg process is spawned — or on an ffmpeg failure;
- * a ThorVG render failure surfaces as `ThorvgException`.
+ * a GPU render failure surfaces as `ThreeException`; a failed resource
+ * (font layout, image decode) as `EffectMotionError`.
  */
-export declare const render: <E = never>(scene: Scene.Scene<E, SceneInternalR>, outPath: string, options?: VideoOptions) => Effect.Effect<void, E | Ffmpeg.EncodeError | ThorvgException, ChildProcessSpawner.ChildProcessSpawner>;
+export declare const render: <E = never, LoaderR = never>(scene: Scene.Scene<E, SceneInternalR | LoaderR>, outPath: string, options?: VideoOptions) => Effect.Effect<void, E | Ffmpeg.EncodeError | ThreeException | EffectMotionError, ChildProcessSpawner.ChildProcessSpawner | Resource.ExtractLoaders<LoaderR>>;
 export {};

package/dist/Video.js

@@ -1,33 +1,16 @@
-import { Font, Session } from "@effect-motion/thorvg";
-import { EngineNode } from "@effect-motion/thorvg/node";
+import * as NodeRenderer from "@effect-motion/renderer/node";
 import * as Effect from "effect/Effect";
-import * as Layer from "effect/Layer";
 import * as Sink from "effect/Sink";
 import * as Stream from "effect/Stream";
-import { Fonts, Renderer, Scene } from "effect-motion";
-import * as PngExporter from "effect-motion/PngExporter";
+import { Scene } from "effect-motion";
 import * as Ffmpeg from "./Ffmpeg.js";
-// The ThorVG engine (global font registry) plus a render session (the canvas
-// Renderer.render draws each frame onto). The session canvas is resized per
-// frame, so the seed size only has to be valid — the scene's own comp
-// dimensions (the canvas is resized to each frame's size regardless).
-const fontedLayer = (scene) => {
-    const fonts = {
-        "sans-serif": Font.DEFAULT_FONT_URL,
-        ...Fonts.urlMap(scene),
-    };
-    return Layer.provideMerge(Session.layer({
-        width: scene.width,
-        height: scene.height,
-        fonts,
-    }), EngineNode.layer("sw", fonts));
-};
 /**
  * Render a scene to a video file at `outPath`.
  *
  * Fails with {@link Ffmpeg.EncodeError} on odd output dimensions (invalid for
  * `yuv420p`) — before any ffmpeg process is spawned — or on an ffmpeg failure;
- * a ThorVG render failure surfaces as `ThorvgException`.
+ * a GPU render failure surfaces as `ThreeException`; a failed resource
+ * (font layout, image decode) as `EffectMotionError`.
  */
 export const render = (scene, outPath, options = {}) => Effect.scoped(Effect.gen(function* () {
     let frames = Scene.stream(scene, options.settings ?? {});
@@ -55,19 +38,28 @@ export const render = (scene, outPath, options = {}) => Effect.scoped(Effect.gen
             cause: meta,
         });
     }
+    // one renderer for the whole export, sized from the first frame's
+    // metadata, released with this scope
+    const renderer = yield* NodeRenderer.make({
+        width: meta.width,
+        height: meta.height,
+        pixelRatio: dpr,
+    });
     const allFrames = Stream.concat(Stream.make(meta), rest);
-    // each frame is rasterized to a framebuffer by the ThorVG renderer
-    // then PNG-encoded. Rasterization is serial: Renderer.render mutates
-    // one shared RenderSession canvas per frame (resize/clear/draw/read),
-    // so concurrent renders would clobber each other's pixels.
-    const pngStream = Stream.mapEffect(allFrames, (frame) => Renderer.render(frame, { dpr }).pipe(Effect.flatMap(PngExporter.toBuffer)));
+    // serial by construction: syncFrame mutates one retained scene, so
+    // concurrent renders would clobber each other's state
+    const pngStream = Stream.mapEffect(allFrames, (frame) => NodeRenderer.renderToPng(renderer, frame));
+    // writing a file implies its directory: create the output's parent
+    // so render programs carry no mkdir boilerplate (Node-only module,
+    // no new requirement)
+    yield* Effect.promise(async () => {
+        const { mkdir } = await import("node:fs/promises");
+        const { dirname } = await import("node:path");
+        await mkdir(dirname(outPath), { recursive: true });
+    });
     yield* Ffmpeg.encode(pngStream, outPath, {
         frameRate: meta.frameRate,
         binary: options.binary,
         extraArgs: options.extraArgs,
     });
-})).pipe(
-// the scene's declared url fonts, merged over the default sans, so text
-// in a declared family renders (design D3); path-only entries skipped.
-// Fonts go to both the engine (global registry) and the render session.
-Effect.provide(fontedLayer(scene)));
+}));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@effect-motion/export",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "description": "Node-only export tools for effect-motion: render scenes to PNG frames (ThorVG) and encode to video (ffmpeg)",
   "type": "module",
   "license": "MIT",
@@ -34,8 +34,9 @@
   },
   "dependencies": {
     "ffmpeg-static": "^5.3.0",
-    "@effect-motion/thorvg": "^0.2.0",
-    "effect-motion": "^0.4.0"
+    "@effect-motion/renderer": "^0.5.0",
+    "@effect-motion/three": "^0.5.0",
+    "effect-motion": "^0.5.0"
   },
   "peerDependencies": {
     "effect": ">=4.0.0-beta.98"