@effect-motion/export 0.2.0 → 0.3.0

package/dist/Video.d.ts

@@ -1,16 +1,16 @@
+import { type ThorvgException } from "@effect-motion/thorvg";
 import * as Effect from "effect/Effect";
 import type * as Scope from "effect/Scope";
 import type { ChildProcessSpawner } from "effect/unstable/process";
-import { type Entity, Scene } from "effect-motion";
-import * as Ffmpeg from "./Ffmpeg";
-import * as Resvg from "./Resvg";
+import { 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` → SVG string sink → resvg → ffmpeg — reading the
- * framerate and dimensions from the scene's own frame metadata and feeding
- * declared fonts to the rasterizer.
+ * 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.
  */
 /**
  * Scene settings honored by the export path — a subset of the runner's
@@ -39,8 +39,12 @@ export interface VideoOptions {
     readonly binary?: string;
     /** Extra ffmpeg arguments, appended before the output path. */
     readonly extraArgs?: ReadonlyArray<string>;
-    /** How many frames to rasterize concurrently (order preserved). Default 4. */
-    readonly concurrency?: number;
+    /**
+     * Supersampling factor: frames are rasterized at scene dimensions × dpr
+     * (the video's pixel size) while the scene keeps its authored logical
+     * coordinates and framing. Defaults to 1.
+     */
+    readonly dpr?: number;
     /** Scene framerate/dimensions/maxFrames for this export. */
     readonly settings?: VideoSceneSettings;
 }
@@ -48,7 +52,8 @@ export interface VideoOptions {
  * 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.
+ * `yuv420p`) — before any ffmpeg process is spawned — or on an ffmpeg failure;
+ * a ThorVG render failure surfaces as `ThorvgException`.
  */
-export declare const render: <E, R, Entities extends Entity.AnyEntity>(scene: Scene.Scene<E, R, Entities>, outPath: string, options?: VideoOptions) => Effect.Effect<void, E | Ffmpeg.EncodeError | Resvg.RasterizeError, Exclude<R, Scope.Scope | SceneInternalR> | ChildProcessSpawner.ChildProcessSpawner>;
+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 {};

package/dist/Video.js

@@ -1,24 +1,35 @@
-import { Layer } from "effect";
+import { Font, Session } from "@effect-motion/thorvg";
+import { EngineNode } from "@effect-motion/thorvg/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 { Scene, Svg } from "effect-motion";
-import * as Ffmpeg from "./Ffmpeg";
-import { resvgOptions } from "./Fonts";
-import * as Resvg from "./Resvg";
-// SVG string sink + built-in shape renderers, provided internally so callers
-// don't wire renderers for the export path
-const renderLayer = Svg.layer.pipe(Layer.provideMerge(Svg.shapesLayer));
+import { Fonts, Renderer, Scene } from "effect-motion";
+import * as PngExporter from "effect-motion/PngExporter";
+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 settings dimensions when
+// given, else a 1×1 placeholder the first frame's resize corrects.
+const fontedLayer = (scene, settings) => {
+    const fonts = {
+        "sans-serif": Font.DEFAULT_FONT_URL,
+        ...Fonts.urlMap(scene),
+    };
+    return Layer.provideMerge(Session.layer({
+        width: settings?.width ?? 1,
+        height: settings?.height ?? 1,
+        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.
+ * `yuv420p`) — before any ffmpeg process is spawned — or on an ffmpeg failure;
+ * a ThorVG render failure surfaces as `ThorvgException`.
  */
 export const render = (scene, outPath, options = {}) => Effect.scoped(Effect.gen(function* () {
-    const renderer = yield* Svg.SvgRenderer.Context;
-    const fontOpts = resvgOptions(scene);
-    const concurrency = options.concurrency ?? 4;
     let frames = Scene.stream(scene, options.settings ?? {});
     if (options.frames !== undefined) {
         frames = Stream.take(frames, options.frames);
@@ -30,24 +41,33 @@ export const render = (scene, outPath, options = {}) => Effect.scoped(Effect.gen
         return; // empty scene: nothing to encode
     }
     const meta = first.value;
-    if (meta.width % 2 !== 0 || meta.height % 2 !== 0) {
-        const odd = meta.width % 2 !== 0
-            ? `width ${meta.width}`
-            : `height ${meta.height}`;
+    // the encoded pixel size is the logical scene size × dpr; that is
+    // what yuv420p needs even, not the logical size
+    const dpr = options.dpr ?? 1;
+    const outWidth = Math.round(meta.width * dpr);
+    const outHeight = Math.round(meta.height * dpr);
+    if (outWidth % 2 !== 0 || outHeight % 2 !== 0) {
+        const odd = outWidth % 2 !== 0 ? `width ${outWidth}` : `height ${outHeight}`;
         return yield* new Ffmpeg.EncodeError({
             message: `Video dimensions must be even for yuv420p, got ${odd}. ` +
-                `Use even scene dimensions, or pass extraArgs with a scale filter.`,
+                `Use even scene dimensions (× dpr), or pass extraArgs with a scale filter.`,
             stderr: "",
             cause: meta,
         });
     }
     const allFrames = Stream.concat(Stream.make(meta), rest);
-    const pngStream = Stream.mapEffect(allFrames, (frame) => renderer
-        .render(frame, {})
-        .pipe(Effect.flatMap((svg) => Resvg.rasterize(svg, fontOpts))), { concurrency });
+    // 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)));
     yield* Ffmpeg.encode(pngStream, outPath, {
         frameRate: meta.frameRate,
         binary: options.binary,
         extraArgs: options.extraArgs,
     });
-})).pipe(Effect.provide(renderLayer));
+})).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, options.settings)));

package/dist/index.d.ts

@@ -1,7 +1,4 @@
-export * as Ffmpeg from "./Ffmpeg";
-export { EncodeError, type EncodeOptions } from "./Ffmpeg";
-export * as Fonts from "./Fonts";
-export * as Resvg from "./Resvg";
-export { RasterizeError, type ResvgRenderOptions } from "./Resvg";
-export type { VideoOptions } from "./Video";
-export * as Video from "./Video";
+export * as Ffmpeg from "./Ffmpeg.js";
+export { EncodeError, type EncodeOptions } from "./Ffmpeg.js";
+export type { VideoOptions } from "./Video.js";
+export * as Video from "./Video.js";

package/dist/index.js

@@ -1,6 +1,3 @@
-export * as Ffmpeg from "./Ffmpeg";
-export { EncodeError } from "./Ffmpeg";
-export * as Fonts from "./Fonts";
-export * as Resvg from "./Resvg";
-export { RasterizeError } from "./Resvg";
-export * as Video from "./Video";
+export * as Ffmpeg from "./Ffmpeg.js";
+export { EncodeError } from "./Ffmpeg.js";
+export * as Video from "./Video.js";

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@effect-motion/export",
-  "version": "0.2.0",
-  "description": "Node-only export tools for effect-motion: rasterize SVG frames to PNG via resvg",
+  "version": "0.3.0",
+  "description": "Node-only export tools for effect-motion: render scenes to PNG frames (ThorVG) and encode to video (ffmpeg)",
   "type": "module",
   "license": "MIT",
   "repository": {
@@ -15,7 +15,7 @@
     "effect",
     "motion",
     "export",
-    "svg",
+    "thorvg",
     "png",
     "ffmpeg",
     "video"
@@ -33,17 +33,17 @@
     "access": "public"
   },
   "dependencies": {
-    "@resvg/resvg-js": "^2.6.2",
     "ffmpeg-static": "^5.3.0",
-    "effect-motion": "^0.2.0"
+    "@effect-motion/thorvg": "^0.1.0",
+    "effect-motion": "^0.3.0"
   },
   "peerDependencies": {
-    "effect": ">=4.0.0-beta.94"
+    "effect": ">=4.0.0-beta.98"
   },
   "devDependencies": {
-    "@effect/platform-node": "4.0.0-beta.94",
+    "@effect/platform-node": "4.0.0-beta.98",
     "@types/node": "^26.1.1",
-    "effect": "4.0.0-beta.94",
+    "effect": "4.0.0-beta.98",
     "typescript": "^7.0.2",
     "vitest": "^4.1.10"
   },

package/dist/Fonts.d.ts

@@ -1,12 +0,0 @@
-import type { ResvgRenderOptions } from "@resvg/resvg-js";
-import type * as Context from "effect/Context";
-/**
- * Map a scene's declared fonts (the `Fonts` annotation) to resvg font
- * options: every entry with a `src.path` becomes a `fontFiles` entry.
- * Url-only entries are a browser concern and are skipped. System fonts
- * stay loaded (resvg's default) — declared fonts ADD faces; pass
- * `loadSystemFonts: false` yourself for fully self-contained output.
- */
-export declare const resvgOptions: (scene: {
-    readonly annotations: Context.Context<never>;
-}) => ResvgRenderOptions;

package/dist/Fonts.js

@@ -1,12 +0,0 @@
-import { Fonts } from "effect-motion";
-/**
- * Map a scene's declared fonts (the `Fonts` annotation) to resvg font
- * options: every entry with a `src.path` becomes a `fontFiles` entry.
- * Url-only entries are a browser concern and are skipped. System fonts
- * stay loaded (resvg's default) — declared fonts ADD faces; pass
- * `loadSystemFonts: false` yourself for fully self-contained output.
- */
-export const resvgOptions = (scene) => {
-    const fontFiles = Fonts.get(scene).flatMap((font) => font.src.path === undefined ? [] : [font.src.path]);
-    return fontFiles.length === 0 ? {} : { font: { fontFiles } };
-};

package/dist/Resvg.d.ts

@@ -1,27 +0,0 @@
-import { type ResvgRenderOptions } from "@resvg/resvg-js";
-import * as Effect from "effect/Effect";
-import * as FileSystem from "effect/FileSystem";
-import type * as PlatformError from "effect/PlatformError";
-/**
- * Thin Effect wrappers over resvg. Rasterization is an export tool, not a
- * renderer: it consumes the SVG document strings the string sink produces
- * (or any other SVG) and yields PNG bytes.
- */
-/** resvg's own options, untranslated — font config and fitTo live here */
-export type { ResvgRenderOptions } from "@resvg/resvg-js";
-declare const RasterizeError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
-    readonly _tag: "RasterizeError";
-} & Readonly<A>;
-/** A failure raised by resvg while parsing or rendering an SVG document. */
-export declare class RasterizeError extends RasterizeError_base<{
-    readonly cause: unknown;
-}> {
-}
-/**
- * Rasterize an SVG document string to PNG bytes. Output dimensions come
- * from the document itself; the string sink stamps the frame's
- * width/height on the root.
- */
-export declare const rasterize: (svg: string, options?: ResvgRenderOptions) => Effect.Effect<Uint8Array, RasterizeError>;
-/** `rasterize`, then persist through the FileSystem service. */
-export declare const rasterizeToFile: (svg: string, path: string, options?: ResvgRenderOptions) => Effect.Effect<void, RasterizeError | PlatformError.PlatformError, FileSystem.FileSystem>;

package/dist/Resvg.js

@@ -1,22 +0,0 @@
-import { Resvg as ResvgJs } from "@resvg/resvg-js";
-import * as Data from "effect/Data";
-import * as Effect from "effect/Effect";
-import * as FileSystem from "effect/FileSystem";
-/** A failure raised by resvg while parsing or rendering an SVG document. */
-export class RasterizeError extends Data.TaggedError("RasterizeError") {
-}
-/**
- * Rasterize an SVG document string to PNG bytes. Output dimensions come
- * from the document itself; the string sink stamps the frame's
- * width/height on the root.
- */
-export const rasterize = (svg, options) => Effect.try({
-    try: () => new Uint8Array(new ResvgJs(svg, options ?? null).render().asPng()),
-    catch: (cause) => new RasterizeError({ cause }),
-});
-/** `rasterize`, then persist through the FileSystem service. */
-export const rasterizeToFile = (svg, path, options) => Effect.gen(function* () {
-    const bytes = yield* rasterize(svg, options);
-    const fs = yield* FileSystem.FileSystem;
-    yield* fs.writeFile(path, bytes);
-});