effect-motion 0.4.0 → 0.5.0

package/dist/CameraHelpers.js

@@ -1,239 +0,0 @@
-import * as Duration from "effect/Duration";
-import * as Effect from "effect/Effect";
-import { dual } from "effect/Function";
-import * as Entity from "./Entity.js";
-import * as Instance from "./Instance.js";
-import * as Motion from "./Motion.js";
-import * as Runner from "./Runner.js";
-import * as Scene from "./Scene.js";
-import * as Time from "./Time.js";
-import * as Timing from "./Timing.js";
-/**
- * The public Camera surface: the entity/identity from Camera.js plus the
- * directing helpers. This module (not Camera.ts) is what index exports as
- * the `Camera` namespace — Runner/Renderer import the schema file
- * directly, so helpers can depend on Motion/Scene without an import
- * cycle.
- *
- * Naming rule (recorded in the camera-poi-helpers change): verbs that
- * name their target (`lookAt`, `follow`) have no base/To pair — an
- * optional duration selects instant vs eased. Value-animating helpers
- * (`orbit`/`orbitTo`, `dolly`/`dollyTo`) keep the pair, exactly like
- * `move`/`moveTo`.
- */
-// explicit named re-exports (not `export *`) so the public Camera surface
-// is enumerable at a glance: the entity + identity from the schema module,
-// plus the helpers below
-export { Camera, identity } from "./Camera.js";
-// a target argument (vs a duration/timing in the same slot): instances,
-// effects, or a position-like object — Durations are objects too, so
-// exclude them explicitly
-const isTargetArg = (v) => Instance.isInstance(v) ||
-    Effect.isEffect(v) ||
-    (typeof v === "object" &&
-        v !== null &&
-        !Duration.isDuration(v) &&
-        ("x" in v || "y" in v || "z" in v));
-// data-first iff the first arg is an instance AND the second is a target —
-// plain firstArgIsInstance would misread `cam.pipe`-less pipeable calls
-// whose TARGET is an instance (`lookAt(hero, "1 second")`)
-const dataFirst = (args) => Instance.isInstance(args[0]) && isTargetArg(args[1]);
-/**
- * Resolve a target once (Effects yield their Instance), returning a
- * per-frame position reader with the offset folded in: live for
- * instances, fixed for plain positions.
- */
-const targetReader = Effect.fnUntraced(function* (target, offset) {
-    const ox = offset?.x ?? 0;
-    const oy = offset?.y ?? 0;
-    const oz = offset?.z ?? 0;
-    if (Instance.isInstance(target) || Effect.isEffect(target)) {
-        const instance = yield* Instance.flatten(target);
-        const lens = Entity.traitOrDie(instance.entity, "~position");
-        return Scene.data(instance).pipe(Effect.map((data) => {
-            const p = lens.get(data);
-            return { x: p.x + ox, y: p.y + oy, z: p.z + oz };
-        }));
-    }
-    // AnyInstance's `any` params defeat narrowing — the guards above
-    // returned for instances/effects, so this is a plain position
-    const point = target;
-    const fixed = {
-        x: (point.x ?? 0) + ox,
-        y: (point.y ?? 0) + oy,
-        z: (point.z ?? 0) + oz,
-    };
-    return Effect.succeed(fixed);
-});
-const setPoi = (data, p) => Object.assign({}, data, { poiX: p.x, poiY: p.y, poiZ: p.z });
-// the camera's WORLD position: x/y are pan-from-viewport-center
-const worldPosition = Effect.fnUntraced(function* (cam) {
-    const { comp } = yield* Runner.Runner;
-    const data = (yield* Scene.data(cam));
-    return {
-        x: comp.width / 2 + data.x,
-        y: comp.height / 2 + data.y,
-        z: data.z ?? 0,
-    };
-});
-const lookAtImpl = Effect.fnUntraced(function* (camOrEffect, target, duration, timing, offset) {
-    const cam = yield* Instance.flatten(camOrEffect);
-    const read = yield* targetReader(target, offset);
-    if (duration === undefined) {
-        const p = yield* read;
-        yield* Scene.update(cam, (d) => setPoi(d, p));
-        return cam;
-    }
-    // eased re-aim: a RETARGETED tween — each frame interpolates from the
-    // start POI toward the target's CURRENT position, converging exactly
-    // onto a moving target at t = 1 (a plain-Position target degenerates to
-    // a fixed tween). Effectful per-frame read, so this runs its own loop
-    // rather than Motion.drive (whose callback is pure).
-    const runner = yield* Runner.Runner;
-    const timingFn = Timing.resolve(timing ?? "linear");
-    const data = (yield* Scene.data(cam));
-    let start;
-    if (data.poiX !== undefined &&
-        data.poiY !== undefined &&
-        data.poiZ !== undefined) {
-        start = { x: data.poiX, y: data.poiY, z: data.poiZ };
-    }
-    else {
-        // no POI yet: seed on the camera's UNAIMED axis (straight down world
-        // -z) at the target's distance. resolveCamera derives zero aim for
-        // that point, so the explicit Euler alone carries the view — engaging
-        // POI mode is snap-free for ANY current orientation, and the tween
-        // takes over from there.
-        const world = yield* worldPosition(cam);
-        const first = yield* read;
-        const distance = Math.hypot(first.x - world.x, first.y - world.y, first.z - world.z);
-        start = { x: world.x, y: world.y, z: world.z - distance };
-    }
-    const frames = Math.max(1, Time.toFrames(duration, runner.settings.frameRate));
-    for (let i = 1; i <= frames; i++) {
-        const t = timingFn(i / frames);
-        const p = yield* read;
-        yield* Scene.update(cam, (d) => setPoi(d, {
-            x: start.x + (p.x - start.x) * t,
-            y: start.y + (p.y - start.y) * t,
-            z: start.z + (p.z - start.z) * t,
-        }));
-        yield* Scene.tick;
-    }
-    return cam;
-});
-/**
- * Aim the camera at a target. No duration: set the point of interest this
- * frame. With a duration: eased re-aim as a retargeted tween (lands
- * exactly on a moving target, no terminal snap). `offset` shifts the aim
- * relative to the target ("slightly above their head"). Dual:
- * `lookAt(cam, target, ...)` or `cam.pipe(lookAt(target, ...))`.
- */
-export const lookAt = dual(dataFirst, lookAtImpl);
-/**
- * Track a target for the duration: the point of interest is a hard
- * per-frame copy of the target position (+offset). A plain animator — it
- * pipes, `Scene.all`s, staggers, repeats. No timing input (lag is
- * expressed by springing the POI instead). Ordering practice: within a
- * tick, branches run in fork order — a follow forked before its target's
- * animator reads the previous frame's position, a deterministic one-frame
- * trail. Dual like `lookAt`.
- */
-export const follow = dual(dataFirst, Effect.fnUntraced(function* (camOrEffect, target, duration, offset) {
-    const cam = yield* Instance.flatten(camOrEffect);
-    const read = yield* targetReader(target, offset);
-    const runner = yield* Runner.Runner;
-    const frames = Math.max(1, Time.toFrames(duration, runner.settings.frameRate));
-    for (let i = 1; i <= frames; i++) {
-        const p = yield* read;
-        yield* Scene.update(cam, (d) => setPoi(d, p));
-        yield* Scene.tick;
-    }
-    return cam;
-}));
-// orbit/dolly are defined relative to the POI — die loudly without one
-const poiOrDie = (data) => {
-    if (data.poiX === undefined ||
-        data.poiY === undefined ||
-        data.poiZ === undefined) {
-        throw new Error("Camera: orbit/dolly need a point of interest — set one first (Camera.lookAt(target))");
-    }
-    return { x: data.poiX, y: data.poiY, z: data.poiZ };
-};
-const orbitImpl = Effect.fnUntraced(function* (camOrEffect, from, to, duration, timing) {
-    const cam = yield* Instance.flatten(camOrEffect);
-    const { comp } = yield* Runner.Runner;
-    const origin = { x: comp.width / 2, y: comp.height / 2 };
-    const startData = (yield* Scene.data(cam));
-    const poi = poiOrDie(startData);
-    const world = {
-        x: origin.x + startData.x,
-        z: startData.z ?? 0,
-    };
-    // azimuth 0 = directly +z of the POI (the resting side); radius = the
-    // current horizontal distance, preserved through the arc; height too
-    const radius = Math.hypot(world.x - poi.x, world.z - poi.z);
-    const startAzimuth = from ?? Math.atan2(world.x - poi.x, world.z - poi.z);
-    return yield* Motion.drive(cam, duration, timing ?? "linear", (t, d) => {
-        const data = d;
-        // POI read from live data: orbiting a moving POI stays centered on it
-        const p = poiOrDie(data);
-        const angle = startAzimuth + (to - startAzimuth) * t;
-        return Object.assign({}, d, {
-            x: p.x + radius * Math.sin(angle) - origin.x,
-            z: p.z + radius * Math.cos(angle),
-        });
-    });
-});
-/**
- * Turntable the camera to an absolute azimuth around its point of
- * interest (angle about the world-Y axis through the POI; 0 = directly +z
- * of it). Position travels the arc — orientation comes entirely from the
- * POI, so there is no orientation math to get wrong. Radius and height
- * are preserved. Dies loudly without a POI. Dual like `moveTo`.
- */
-export const orbitTo = dual((args) => Instance.isInstance(args[0]), ((cam, azimuth, duration, timing) => orbitImpl(cam, undefined, azimuth, duration, timing)));
-/** Like `orbitTo`, but from an explicit start azimuth. */
-export const orbit = dual((args) => Instance.isInstance(args[0]), orbitImpl);
-const dollyImpl = Effect.fnUntraced(function* (camOrEffect, from, to, duration, timing) {
-    const cam = yield* Instance.flatten(camOrEffect);
-    const { comp } = yield* Runner.Runner;
-    const origin = { x: comp.width / 2, y: comp.height / 2 };
-    const startData = (yield* Scene.data(cam));
-    const poi = poiOrDie(startData);
-    const world = {
-        x: origin.x + startData.x,
-        y: origin.y + startData.y,
-        z: startData.z ?? 0,
-    };
-    const startDistance = Math.hypot(world.x - poi.x, world.y - poi.y, world.z - poi.z);
-    // the fixed unit direction POI → camera; a zero distance has no
-    // direction to dolly along
-    if (startDistance === 0) {
-        throw new Error("Camera: dolly from distance 0 — the camera sits ON its point of interest, so there is no view axis to move along");
-    }
-    const u = {
-        x: (world.x - poi.x) / startDistance,
-        y: (world.y - poi.y) / startDistance,
-        z: (world.z - poi.z) / startDistance,
-    };
-    const d0 = from ?? startDistance;
-    return yield* Motion.drive(cam, duration, timing ?? "linear", (t, d) => {
-        const data = d;
-        const p = poiOrDie(data);
-        const dist = d0 + (to - d0) * t;
-        return Object.assign({}, d, {
-            x: p.x + u.x * dist - origin.x,
-            y: p.y + u.y * dist - origin.y,
-            z: p.z + u.z * dist,
-        });
-    });
-});
-/**
- * Move the camera along its view axis to an absolute distance from the
- * point of interest (in: toward it, out: away), aim unchanged. Dies
- * loudly without a POI. Dual like `moveTo`.
- */
-export const dollyTo = dual((args) => Instance.isInstance(args[0]), ((cam, distance, duration, timing) => dollyImpl(cam, undefined, distance, duration, timing)));
-/** Like `dollyTo`, but from an explicit start distance. */
-export const dolly = dual((args) => Instance.isInstance(args[0]), dollyImpl);

package/dist/CanvasExporter.d.ts

@@ -1,12 +0,0 @@
-import * as Effect from "effect/Effect";
-import { EffectMotionError } from "./EffectMotionError.js";
-import type * as Renderer from "./Renderer.js";
-/**
- * Blit a framebuffer onto a DOM canvas. The canvas buffer takes the
- * framebuffer's PHYSICAL size (logical × dpr); CSS display size is left to
- * the caller — the intrinsic aspect ratio is preserved by the attributes, so
- * responsive styling (`width: 100%`) or a fixed `fb.logicalWidth`px both
- * work. Writing CSS here would clobber caller styling (e.g. React inline
- * styles are not re-applied on rerender).
- */
-export declare const toCanvas: (fb: Renderer.Framebuffer, target: "string" | HTMLCanvasElement) => Effect.Effect<undefined, EffectMotionError, never>;

package/dist/CanvasExporter.js

@@ -1,40 +0,0 @@
-import * as Effect from "effect/Effect";
-import { EffectMotionError } from "./EffectMotionError.js";
-const resolveCanvas = Effect.fnUntraced(function* (target) {
-    if (typeof target === "string") {
-        if (typeof document === "undefined") {
-            return yield* Effect.fail(EffectMotionError.of("'document' is not available in the current environment"));
-        }
-        const maybeCanvas = document.querySelector(target);
-        if (maybeCanvas === null) {
-            return yield* Effect.fail(EffectMotionError.of(`Could not find canvas with selector '${target}'`));
-        }
-        if (!(maybeCanvas instanceof HTMLCanvasElement)) {
-            return yield* Effect.fail(EffectMotionError.of(`Could not find canvas with selector '${target}'`));
-        }
-        return maybeCanvas;
-    }
-    if (!(target instanceof HTMLCanvasElement)) {
-        return yield* Effect.fail(EffectMotionError.of(`'target' is not a HTMLCanvasElement`));
-    }
-    return target;
-});
-/**
- * Blit a framebuffer onto a DOM canvas. The canvas buffer takes the
- * framebuffer's PHYSICAL size (logical × dpr); CSS display size is left to
- * the caller — the intrinsic aspect ratio is preserved by the attributes, so
- * responsive styling (`width: 100%`) or a fixed `fb.logicalWidth`px both
- * work. Writing CSS here would clobber caller styling (e.g. React inline
- * styles are not re-applied on rerender).
- */
-export const toCanvas = Effect.fnUntraced(function* (fb, target) {
-    const canvas = yield* resolveCanvas(target);
-    canvas.width = fb.width;
-    canvas.height = fb.height;
-    const ctx = canvas.getContext("2d");
-    if (ctx === null) {
-        return yield* Effect.fail(EffectMotionError.of("Could not get a 2D context from the canvas"));
-    }
-    const clamped = Uint8ClampedArray.from(fb.rgba);
-    ctx.putImageData(new ImageData(clamped, fb.width, fb.height), 0, 0);
-});

package/dist/Fonts.d.ts

@@ -1,41 +0,0 @@
-import * as Context from "effect/Context";
-/**
- * One loadable font face. `family` is the name text entities reference in
- * `fontFamily`; `src` carries per-environment sources — browsers load
- * `url`, offline rasterizers read `path`. Consumers skip sources they
- * can't use. `weight`/`style` are browser variant-matching descriptors;
- * file-based rasterizers read them from the font file itself. Declare one
- * entry per face (e.g. Inter 400 and Inter 700 are two entries).
- */
-export interface FontResource {
-    readonly family: string;
-    readonly src: {
-        readonly url?: string;
-        readonly path?: string;
-    };
-    /** CSS font-weight (e.g. 400, 700) */
-    readonly weight?: number;
-    readonly style?: "normal" | "italic";
-}
-/**
- * Scene annotation key declaring the fonts a scene's text depends on:
- * `scene.annotate(Fonts.Fonts, [...])`. The runtime never reads it — the
- * engine cannot measure text, so fonts cannot affect frame data. Consumers
- * (the player, export tools) read it to prepare their environment before
- * rendering.
- */
-export declare const Fonts: Context.Reference<readonly FontResource[]>;
-/** A scene's declared fonts — empty for scenes never annotated. */
-export declare const get: (scene: {
-    readonly annotations: Context.Context<never>;
-}) => ReadonlyArray<FontResource>;
-/**
- * A scene's declared fonts as a `family -> url` map for the ThorVG engine's
- * `fonts` option. Only entries with a `src.url` are included — the ThorVG
- * renderer fetches fonts by URL (no filesystem), so `path`-only entries are
- * skipped. Merge this over the engine default so declared families load and a
- * `sans-serif` entry can override the default sans.
- */
-export declare const urlMap: (scene: {
-    readonly annotations: Context.Context<never>;
-}) => Record<string, string>;

package/dist/Fonts.js

@@ -1,27 +0,0 @@
-import * as Context from "effect/Context";
-/**
- * Scene annotation key declaring the fonts a scene's text depends on:
- * `scene.annotate(Fonts.Fonts, [...])`. The runtime never reads it — the
- * engine cannot measure text, so fonts cannot affect frame data. Consumers
- * (the player, export tools) read it to prepare their environment before
- * rendering.
- */
-export const Fonts = Context.Reference("motion/Fonts", { defaultValue: () => [] });
-/** A scene's declared fonts — empty for scenes never annotated. */
-export const get = (scene) => Context.get(scene.annotations, Fonts);
-/**
- * A scene's declared fonts as a `family -> url` map for the ThorVG engine's
- * `fonts` option. Only entries with a `src.url` are included — the ThorVG
- * renderer fetches fonts by URL (no filesystem), so `path`-only entries are
- * skipped. Merge this over the engine default so declared families load and a
- * `sans-serif` entry can override the default sans.
- */
-export const urlMap = (scene) => {
-    const out = {};
-    for (const font of get(scene)) {
-        if (font.src.url !== undefined) {
-            out[font.family] = font.src.url;
-        }
-    }
-    return out;
-};

package/dist/Images.d.ts

@@ -1,33 +0,0 @@
-import * as Context from "effect/Context";
-/**
- * One loadable image asset. `name` is what `Shapes.Image` entities reference
- * in their `image` field; `src` carries per-environment sources — browsers
- * load `url`, file-based tooling may read `path` (reserved; url-only today,
- * same contract as fonts). Consumers skip sources they can't use.
- */
-export interface ImageResource {
-    readonly name: string;
-    readonly src: {
-        readonly url?: string;
-        readonly path?: string;
-    };
-}
-/**
- * Scene annotation key declaring the images a scene's Image entities depend
- * on: `scene.annotate(Images.Images, [...])`. The runtime never reads it —
- * decoded pixels cannot affect frame data. Consumers (the player, export
- * tools) read it to load assets into their render session before playback.
- */
-export declare const Images: Context.Reference<readonly ImageResource[]>;
-/** A scene's declared images — empty for scenes never annotated. */
-export declare const get: (scene: {
-    readonly annotations: Context.Context<never>;
-}) => ReadonlyArray<ImageResource>;
-/**
- * A scene's declared images as a `name -> url` map for the render session's
- * `images` option. Only entries with a `src.url` are included — loading is
- * fetch-by-URL (no filesystem), so `path`-only entries are skipped.
- */
-export declare const urlMap: (scene: {
-    readonly annotations: Context.Context<never>;
-}) => Record<string, string>;

package/dist/Images.js

@@ -1,24 +0,0 @@
-import * as Context from "effect/Context";
-/**
- * Scene annotation key declaring the images a scene's Image entities depend
- * on: `scene.annotate(Images.Images, [...])`. The runtime never reads it —
- * decoded pixels cannot affect frame data. Consumers (the player, export
- * tools) read it to load assets into their render session before playback.
- */
-export const Images = Context.Reference("motion/Images", { defaultValue: () => [] });
-/** A scene's declared images — empty for scenes never annotated. */
-export const get = (scene) => Context.get(scene.annotations, Images);
-/**
- * A scene's declared images as a `name -> url` map for the render session's
- * `images` option. Only entries with a `src.url` are included — loading is
- * fetch-by-URL (no filesystem), so `path`-only entries are skipped.
- */
-export const urlMap = (scene) => {
-    const out = {};
-    for (const image of get(scene)) {
-        if (image.src.url !== undefined) {
-            out[image.name] = image.src.url;
-        }
-    }
-    return out;
-};

package/dist/PngExporter.d.ts

@@ -1,6 +0,0 @@
-import * as Effect from "effect/Effect";
-import { FileSystem } from "effect/FileSystem";
-import { EffectMotionError } from "./EffectMotionError.js";
-import type * as Renderer from "./Renderer.js";
-export declare const toBuffer: (fb: Renderer.Framebuffer) => Effect.Effect<Uint8Array<ArrayBuffer>, EffectMotionError, never>;
-export declare const toFile: (fb: Renderer.Framebuffer, outPath: string) => Effect.Effect<void, EffectMotionError | import("effect/PlatformError").PlatformError, FileSystem>;

package/dist/PngExporter.js

@@ -1,85 +0,0 @@
-import { deflateSync } from "node:zlib";
-import * as Effect from "effect/Effect";
-import { FileSystem } from "effect/FileSystem";
-import { EffectMotionError } from "./EffectMotionError.js";
-const SIGNATURE = new Uint8Array([137, 80, 78, 71, 13, 10, 26, 10]);
-const crcTable = (() => {
-    const t = new Uint32Array(256);
-    for (let n = 0; n < 256; n++) {
-        let c = n;
-        for (let k = 0; k < 8; k++) {
-            c = c & 1 ? 0xedb88320 ^ (c >>> 1) : c >>> 1;
-        }
-        t[n] = c >>> 0;
-    }
-    return t;
-})();
-const crc32 = (bytes) => {
-    let c = 0xffffffff;
-    for (let i = 0; i < bytes.length; i++) {
-        c = crcTable[(c ^ bytes[i]) & 0xff] ^ (c >>> 8);
-    }
-    return (c ^ 0xffffffff) >>> 0;
-};
-const chunk = (type, data) => {
-    const typeBytes = new Uint8Array([
-        type.charCodeAt(0),
-        type.charCodeAt(1),
-        type.charCodeAt(2),
-        type.charCodeAt(3),
-    ]);
-    const body = new Uint8Array(typeBytes.length + data.length);
-    body.set(typeBytes, 0);
-    body.set(data, typeBytes.length);
-    const out = new Uint8Array(4 + body.length + 4);
-    const view = new DataView(out.buffer);
-    view.setUint32(0, data.length, false);
-    out.set(body, 4);
-    view.setUint32(4 + body.length, crc32(body), false);
-    return out;
-};
-/** Encode a raw RGBA8888 buffer (`width * height * 4` bytes) as a PNG. */
-const encodePng = Effect.fnUntraced(function* (rgba, width, height) {
-    if (rgba.length !== width * height * 4) {
-        return yield* Effect.fail(EffectMotionError.of(`Could not encode PNG: buffer is ${rgba.length} bytes, expected ${width * height * 4} (${width}x${height} RGBA)`));
-    }
-    // prepend a filter byte (0 = none) to each scanline
-    const stride = width * 4;
-    const raw = new Uint8Array((stride + 1) * height);
-    for (let y = 0; y < height; y++) {
-        raw[y * (stride + 1)] = 0;
-        raw.set(rgba.subarray(y * stride, y * stride + stride), y * (stride + 1) + 1);
-    }
-    const ihdr = new Uint8Array(13);
-    const ihdrView = new DataView(ihdr.buffer);
-    ihdrView.setUint32(0, width, false);
-    ihdrView.setUint32(4, height, false);
-    ihdr[8] = 8; // bit depth
-    ihdr[9] = 6; // color type: RGBA
-    // [10] compression, [11] filter, [12] interlace all 0
-    const idat = new Uint8Array(deflateSync(raw));
-    const chunks = [
-        SIGNATURE,
-        chunk("IHDR", ihdr),
-        chunk("IDAT", idat),
-        chunk("IEND", new Uint8Array(0)),
-    ];
-    const total = chunks.reduce((n, c) => n + c.length, 0);
-    const png = new Uint8Array(total);
-    let offset = 0;
-    for (const c of chunks) {
-        png.set(c, offset);
-        offset += c.length;
-    }
-    return png;
-});
-export const toBuffer = (fb) => {
-    return encodePng(fb.rgba, fb.width, fb.height);
-};
-export const toFile = (fb, outPath) => {
-    return Effect.gen(function* () {
-        const fs = yield* FileSystem;
-        const png = yield* toBuffer(fb);
-        yield* fs.writeFile(outPath, png);
-    });
-};

package/dist/Renderer.d.ts

@@ -1,118 +0,0 @@
-import type { OwnedPaint, RenderSession, ThorvgException, ThorvgWasm } from "@effect-motion/thorvg";
-import * as Tvg from "@effect-motion/thorvg";
-import type { Canvas } from "@effect-motion/thorvg/Canvas";
-import * as Effect from "effect/Effect";
-import type * as Scope from "effect/Scope";
-import * as Color from "./Color.js";
-import type * as Entity from "./Entity.js";
-import * as Projection from "./Projection.js";
-import type { Frame } from "./Scene.js";
-/**
- * The projection handed to each paint function — how the camera places a
- * paintable this frame. `screen` is the projected billboard placement (an
- * affine the paint fn applies via `setTransform`); `depth` is the view-space
- * sort key; `scale` is the perspective scale (<= 0 means the anchor is behind
- * the camera — cull, unless a `quad` or `segment` is present). `quad`, when
- * present, is the projected, near-plane-clipped screen polygon of a tilted
- * plane (3–5 vertices — see Projection.projectPlane); a shape that can tilt
- * paints an exact path from these instead of applying the billboard affine.
- * `segment`, when present, is the exact projected screen endpoints of a
- * skeletal shape (Line) — each endpoint carries its own world depth, so the
- * pair is projected per point (see Projection.projectSegment) and the paint
- * fn draws it directly, skipping the billboard affine. `subpaths`, when
- * present, is the projected screen geometry of a skeletal path (Path): every
- * command point projected individually and near-plane-clipped per subpath
- * (see Projection.projectPath) — the paint fn emits it directly at screen
- * coordinates.
- */
-export interface PaintProjection {
-    readonly screen: Projection.Affine;
-    readonly depth: number;
-    readonly scale: number;
-    readonly quad?: ReadonlyArray<Projection.Vec2>;
-    readonly segment?: readonly [Projection.Vec2, Projection.Vec2];
-    readonly subpaths?: Projection.ProjectedPath["subpaths"];
-}
-/** The frame's render metadata, handed to paint functions. */
-export interface FrameMeta {
-    readonly frameRate: number;
-    readonly width: number;
-    readonly height: number;
-    readonly backgroundColor: Color.Color;
-    /**
-     * the active camera's view — world position `{x, y, z}`, Euler
-     * orientation `{rotX, rotY, rotZ}`, and `focalLength` (FOV). The renderer
-     * projects every instance through it. The resting camera (see
-     * Camera.identity) reproduces plain-2D placement for z=0 content.
-     */
-    readonly camera: {
-        readonly x: number;
-        readonly y: number;
-        readonly z: number;
-        readonly rotX: number;
-        readonly rotY: number;
-        readonly rotZ: number;
-        readonly focalLength: number;
-    };
-}
-/**
- * Paints one entity instance onto the shared ThorVG scene. It issues ThorVG
- * C-API calls (make a shape, append geometry, style it, apply the projection,
- * add it to `scene`) — there is no intermediate description value. A container
- * (Group / root) paints nothing itself; its position has already composed into
- * its children's world coordinates by the time this is called.
- */
-export type PaintFunction<Ent extends Entity.AnyEntity> = (payload: {
-    readonly entity: Ent;
-    readonly id: string;
-    readonly data: Ent["data"]["Type"];
-    readonly projection: PaintProjection;
-    readonly canvas: Canvas;
-    readonly scene: OwnedPaint;
-    readonly meta: FrameMeta;
-}) => Effect.Effect<void, ThorvgException, ThorvgWasm | RenderSession | Scope.Scope>;
-/**
- * A registry of paint functions keyed by entity name. `PaintFunctions<E>` is
- * the exhaustive map over an entity union — a built-in with no paint function
- * is a type error at the render call, not a runtime surprise (the old
- * "coverage manifest" guarantee, kept without a Context registry).
- */
-export type PaintFunctions<Entities extends Entity.AnyEntity> = {
-    readonly [K in Entities as K["name"]]: PaintFunction<K>;
-};
-/** RGBA8888 framebuffer plus its dimensions, straight from the SW canvas. */
-export interface Framebuffer {
-    readonly rgba: Uint8Array;
-    /** physical pixel size of the rgba buffer (logical size × dpr) */
-    readonly width: number;
-    readonly height: number;
-    /**
-     * logical scene size — the resolution the buffer should be displayed at
-     * (CSS pixels). Equals width/height when rendered at dpr 1.
-     */
-    readonly logicalWidth: number;
-    readonly logicalHeight: number;
-}
-/**
- * Render one frame to an RGBA framebuffer, shared by both output adapters.
- *
- * Uses the RenderSession's canvas (resized in place to the frame's physical
- * size, cleared of the previous frame), adds a root scene, folds the frame
- * onto it via `Renderer.render`, then update/draw/sync and reads the SW
- * framebuffer. The scene and every painted shape are scoped per frame; the
- * canvas belongs to the session (a player mount, an export run) and is
- * deleted when the session closes.
- *
- * The background is painted as a filled rect (not a canvas clear color) so it
- * survives into the buffer the same way the SVG sink emitted a background
- * rect.
- */
-export declare const render: (frame: Frame, options?: {
-    /**
-     * device-pixel-ratio multiplier for high-dpi displays. The buffer is
-     * rasterized at `logical × dpr` while paint functions keep working in
-     * logical scene coordinates (the root scene is scaled). Callers display
-     * the buffer at the logical size. Default 1 (node/export paths).
-     */
-    readonly dpr?: number;
-}) => Effect.Effect<Framebuffer, ThorvgException, Tvg.ThorvgWasm | Tvg.RenderSession | Scope.Scope>;