effect-motion 0.4.0 → 0.6.0

package/dist/Renderer.js

@@ -1,508 +0,0 @@
-import * as Tvg from "@effect-motion/thorvg";
-import * as Effect from "effect/Effect";
-import * as CameraMod from "./Camera.js";
-import * as Color from "./Color.js";
-import * as Projection from "./Projection.js";
-import { circleOfConfusion, quantizeSigma } from "./render/dof.js";
-import { builtinPaints } from "./render/shapes.js";
-import * as Group from "./shapes/Group.js";
-import { Hud } from "./shapes/Hud.js";
-// in frame data, a `children: string[]` field means child instance ids
-const childIdsOf = (data) => {
-    const children = data?.children;
-    return Array.isArray(children) ? children : [];
-};
-/**
- * Split a Path's command list into world-space subpaths: `M` starts one,
- * `L` extends it, `Z` closes it. Command points are LOCAL to the path's
- * anchor; `z` absent means 0. An `L` directly after a `Z` starts a new open
- * subpath from the closed subpath's start point (SVG semantics).
- */
-const pathSubpaths = (commands, anchor) => {
-    const subpaths = [];
-    let current = [];
-    let lastMove = anchor;
-    const world = (p) => ({
-        x: anchor.x + p.x,
-        y: anchor.y + p.y,
-        z: anchor.z + (p.z ?? 0),
-    });
-    const flush = (closed) => {
-        if (current.length >= 2) {
-            subpaths.push({ points: current, closed });
-        }
-        current = [];
-    };
-    for (const command of commands) {
-        switch (command._tag) {
-            case "M": {
-                flush(false);
-                lastMove = world(command);
-                current = [lastMove];
-                break;
-            }
-            case "L": {
-                if (current.length === 0) {
-                    current.push(lastMove);
-                }
-                current.push(world(command));
-                break;
-            }
-            case "Z": {
-                flush(true);
-                break;
-            }
-        }
-    }
-    flush(false);
-    return subpaths;
-};
-// a hidden instance ($visible false) and its subtree are skipped entirely
-const isVisible = (frame, id) => frame.instances[id]?.$visible !== false;
-/**
- * Fold a frame onto the shared ThorVG canvas + scene: flatten the instance
- * tree to a depth-sorted draw list, project each paintable through the
- * frame's camera, and paint far→near. The pipeline (flatten, world-offset
- * composition, projection, quad, stable-id depth sort, visibility skip,
- * cycle/duplicate defects) is target-agnostic; only the per-entity paint is
- * ThorVG-specific.
- */
-const renderToCanvas = (frame, canvas, scene, 
-// blur sigmas are canvas-pixel amounts; the scene is authored in logical
-// units, so depth-of-field scales them by the device-pixel ratio
-dpr = 1) => Effect.gen(function* () {
-    const origin = {
-        x: frame.width / 2,
-        y: frame.height / 2,
-    };
-    // the effective view: a camera with a point of interest auto-orients
-    // toward it here (explicit Euler composes after — see resolveCamera);
-    // the frame's camera data is never mutated
-    const camera = Projection.resolveCamera(frame.camera, origin);
-    // HUD subtrees project through the identity camera: camera-independent
-    // placement, and structurally exempt from depth of field (aperture 0)
-    const identityCamera = CameraMod.identity(frame.width);
-    const visited = new Set();
-    const paintables = [];
-    // Flatten the tree to a draw list. A container (a node with a
-    // `children` field) is NOT a paint-order boundary: its position
-    // composes into its children's world coordinates, and each child is
-    // emitted into the same flat list. `offset` is the accumulated world
-    // translation from ancestor containers. `hud` marks an ancestor Hud:
-    // the subtree projects through the identity camera and paints in the
-    // top tier. `inWorldContainer` marks any ordinary container above —
-    // a Hud there would compose world offsets into screen coordinates,
-    // which is incoherent and dies loudly.
-    const flatten = (id, offset, hud, inWorldContainer, 
-    // where this node's paintables land: the top-level list, or an
-    // enclosing sub-composition's own sub-list
-    sink) => Effect.gen(function* () {
-        if (visited.has(id)) {
-            return yield* Effect.die(new Error(`Renderer: instance "${id}" is referenced more than once (duplicate parent or cycle)`));
-        }
-        visited.add(id);
-        const entry = frame.instances[id];
-        if (entry === undefined) {
-            return yield* Effect.die(new Error(`Renderer: unknown instance id "${id}"`));
-        }
-        const isHud = entry.entity.name === Hud.name;
-        if (isHud && inWorldContainer) {
-            return yield* Effect.die(new Error(`Renderer: Hud "${id}" is nested inside world content — a Hud must be a top-level child of the root (or of another Hud)`));
-        }
-        const subtreeHud = hud || isHud;
-        const effectiveCamera = subtreeHud ? identityCamera : camera;
-        const data = entry.data;
-        // world anchor = ancestor offset + this node's own position
-        const world = {
-            x: offset.x + (data.x ?? 0),
-            y: offset.y + (data.y ?? 0),
-            z: offset.z + (data.z ?? 0),
-        };
-        const childIds = childIdsOf(entry.data).filter((childId) => isVisible(frame, childId));
-        // a SIZED container is a sub-composition (Scene.play's mount
-        // group, or any Group given bounds): its subtree collects into
-        // its own unit at the group's depth — clipped, backed, and
-        // transformed as one layer, AE-precomp-style
-        const isComp = Array.isArray(entry.data.children) &&
-            typeof data.width === "number" &&
-            typeof data.height === "number";
-        if (isComp) {
-            const proj = Projection.project(effectiveCamera, world, origin);
-            const subs = [];
-            yield* Effect.all(childIds.map((childId) => flatten(childId, world, subtreeHud, inWorldContainer || !subtreeHud, subs)));
-            const groupData = entry.data;
-            sink.push({
-                id,
-                entry,
-                projection: {
-                    screen: Projection.billboardAffine(proj, {
-                        x: data.x ?? 0,
-                        y: data.y ?? 0,
-                    }),
-                    depth: proj.depth,
-                    scale: proj.scale,
-                },
-                hud: subtreeHud,
-                comp: {
-                    width: data.width,
-                    height: data.height,
-                    ...(groupData.backgroundColor !== undefined
-                        ? { backgroundColor: groupData.backgroundColor }
-                        : {}),
-                    opacity: groupData.opacity ?? 1,
-                    transform: groupData.transform ?? Group.identityTransform,
-                    anchor: { x: proj.x, y: proj.y },
-                    subs,
-                },
-            });
-            return;
-        }
-        if (childIds.length > 0) {
-            // a pure container: contribute position, recurse, paint
-            // nothing itself (the root, Groups, Huds). ponytail: only
-            // translation composes down — a Group's 2D affine transform
-            // is not yet threaded into child world coords.
-            yield* Effect.all(childIds.map((childId) => flatten(childId, world, subtreeHud, inWorldContainer || !subtreeHud, sink)));
-            return;
-        }
-        // a skeletal path leaf (Path): every command point is an
-        // independent world point (anchor + local), projected per point
-        // with per-subpath near-plane clipping — the paint fn emits the
-        // exact screen subpaths. ponytail: no viewport clip yet — ThorVG
-        // stroke cost scales with the path's full extent, offscreen
-        // included; upgrade is per-span clipSegmentToRect with the same
-        // splitting the near clip uses.
-        if (Array.isArray(data.commands)) {
-            const projected = Projection.projectPath(effectiveCamera, pathSubpaths(data.commands, world), origin);
-            if (projected === undefined) {
-                // entirely behind the near plane — cull
-                return;
-            }
-            // anchor the billboard affine on the first visible point, as
-            // the segment branch does — path paints ignore it (their
-            // geometry is already screen-space) but the field stays coherent
-            const first = projected.subpaths[0]?.points[0] ?? origin;
-            sink.push({
-                id,
-                entry,
-                projection: {
-                    screen: Projection.billboardAffine({
-                        x: first.x,
-                        y: first.y,
-                        depth: projected.depth,
-                        scale: projected.scale,
-                    }, { x: data.x ?? 0, y: data.y ?? 0 }),
-                    depth: projected.depth,
-                    scale: projected.scale,
-                    subpaths: projected.subpaths,
-                },
-                hud: subtreeHud,
-            });
-            return;
-        }
-        // a skeletal leaf (Line): both endpoints are independent world
-        // points — project the pair per point (near-plane-clipped) and
-        // hand the exact screen segment to the paint fn. Unconditional
-        // for any x2/y2 leaf: the identity invariant makes the flat
-        // case pixel-identical to the old billboard path.
-        if (typeof data.x2 === "number" && typeof data.y2 === "number") {
-            const seg = Projection.projectSegment(effectiveCamera, world, {
-                x: offset.x + data.x2,
-                y: offset.y + data.y2,
-                z: offset.z + (data.z2 ?? 0),
-            }, origin);
-            if (seg === undefined) {
-                // entirely behind the near plane — cull
-                return;
-            }
-            // clip to the viewport before painting: ThorVG stroke cost
-            // scales with the path's full extent, offscreen included.
-            // The margin covers the scaled stroke (caps/joins) so the
-            // visible pixels are untouched by the clip.
-            const strokeMargin = (entry.data.strokeWidth ?? 1) *
-                seg.scale +
-                1;
-            const clipped = Projection.clipSegmentToRect(seg.a, seg.b, { x: -strokeMargin, y: -strokeMargin }, {
-                x: frame.width + strokeMargin,
-                y: frame.height + strokeMargin,
-            });
-            if (clipped === undefined) {
-                // entirely offscreen — cull
-                return;
-            }
-            // ponytail: one depth/scale for the whole segment (its
-            // visible midpoint) — a depth-spanning line blurs and sorts
-            // as one unit, the same ceiling as a tilted plane's quad.
-            // Upgrade: split the segment where its (linear) view depth
-            // crosses DoF bucket boundaries → gradient blur along the
-            // line plus per-piece sort keys.
-            sink.push({
-                id,
-                entry,
-                projection: {
-                    screen: Projection.billboardAffine({ x: seg.a.x, y: seg.a.y, depth: seg.depth, scale: seg.scale }, { x: data.x ?? 0, y: data.y ?? 0 }),
-                    depth: seg.depth,
-                    scale: seg.scale,
-                    segment: clipped,
-                },
-                hud: subtreeHud,
-            });
-            return;
-        }
-        // a leaf paintable: project its world anchor for placement +
-        // depth, but anchor the billboard affine on the shape's own
-        // LOCAL coordinates — the shape paints at local (data.x/y), so
-        // the transform maps local → screen. The composed ancestor
-        // offset lives in the transform's translation.
-        const proj = Projection.project(effectiveCamera, world, origin);
-        // A rectangular plane with any nonzero rotation tilts: project
-        // its four corners so the paint fn can emit an exact path. The
-        // pivot is the plane's world anchor, so rotation spins it in
-        // place. Billboards (no rotation, or non-rect shapes) skip this.
-        const rotX = data.rotX ?? 0;
-        const rotY = data.rotY ?? 0;
-        const rotZ = data.rotZ ?? 0;
-        const tilted = (rotX !== 0 || rotY !== 0 || rotZ !== 0) &&
-            data.width !== undefined &&
-            data.height !== undefined;
-        const quad = tilted
-            ? Projection.projectPlane(effectiveCamera, Projection.planeCorners({
-                x: data.x ?? 0,
-                y: data.y ?? 0,
-                width: data.width,
-                height: data.height,
-            }, { rotX, rotY, rotZ }, world), origin)
-            : undefined;
-        if (quad !== undefined && quad.length < 3) {
-            // the tilted plane is entirely behind the near plane — cull
-            return;
-        }
-        sink.push({
-            id,
-            entry,
-            projection: {
-                screen: Projection.billboardAffine(proj, {
-                    x: data.x ?? 0,
-                    y: data.y ?? 0,
-                }),
-                depth: proj.depth,
-                scale: proj.scale,
-                ...(quad !== undefined ? { quad } : {}),
-            },
-            hud: subtreeHud,
-        });
-    });
-    const rootEntry = frame.instances[frame.root];
-    if (rootEntry === undefined) {
-        return yield* Effect.die(new Error(`Renderer: missing root instance "${frame.root}"`));
-    }
-    visited.add(frame.root);
-    yield* Effect.all(childIdsOf(rootEntry.data)
-        .filter((childId) => isVisible(frame, childId))
-        .map((childId) => flatten(childId, { x: 0, y: 0, z: 0 }, false, false, paintables)));
-    // painter's order: two tiers — world content by depth (farthest
-    // first), then HUD content by depth among itself, each with a stable
-    // id tie-break so equal-depth paintables paint deterministically.
-    // ponytail: naive O(n log n) per frame — swap for a spatial structure
-    // only if a scene with thousands of objects proves it.
-    const byPaintOrder = (a, b) => (a.hud ? 1 : 0) - (b.hud ? 1 : 0) ||
-        b.projection.depth - a.projection.depth ||
-        (a.id < b.id ? -1 : a.id > b.id ? 1 : 0);
-    paintables.sort(byPaintOrder);
-    const meta = {
-        frameRate: frame.frameRate,
-        width: frame.width,
-        height: frame.height,
-        backgroundColor: frame.backgroundColor,
-        camera: frame.camera,
-    };
-    // Depth of field (camera-depth-of-field D3): with aperture > 0,
-    // contiguous depth-sorted runs sharing a quantized blur sigma paint
-    // into nested scenes that get a gaussian-blur effect; sharp runs paint
-    // into the root as always, so aperture 0 (the default) takes the
-    // unchanged single-scene path. Buckets are added to the root at run
-    // boundaries, preserving painter's order exactly. Sigma is scaled by
-    // dpr because the blur operates in canvas pixels while the scene is
-    // authored in logical units.
-    const aperture = frame.camera.aperture;
-    let bucketScene = scene;
-    let bucketSigma = 0;
-    const closeBucket = Effect.gen(function* () {
-        if (bucketSigma > 0) {
-            // direction 0 = both axes, border 0 = duplicate, quality 75
-            // (upstream default) — verified in the scene-blur spike
-            yield* Tvg.Scene.addGaussianBlur(bucketScene, bucketSigma * dpr, 0, 0, 75);
-            yield* Tvg.Scene.add(scene, bucketScene);
-        }
-    });
-    // paint one paintable into `target`: a leaf via its entity's paint fn,
-    // a sub-composition as one clipped nested scene (below)
-    const paintOne = (p, target) => Effect.gen(function* () {
-        if (p.comp !== undefined) {
-            return yield* paintComp(p, p.comp, target);
-        }
-        // the concrete paint fn for this entity name; the map is exhaustive
-        // over Entities by construction (PaintFunctions<Entities>). The
-        // specific member depends on the instance's entity, known only at
-        // runtime — hence the cast to the erased paint-fn type.
-        const paint = builtinPaints[p.entry.entity.name];
-        if (paint === undefined) {
-            return yield* Effect.die(new Error(`Renderer: no paint function for entity "${p.entry.entity.name}"`));
-        }
-        yield* paint({
-            entity: p.entry.entity,
-            id: p.id,
-            data: p.entry.data,
-            projection: p.projection,
-            canvas,
-            scene: target,
-            meta,
-        });
-    });
-    // A sub-composition paints as ONE layer: inner scene clipped to the
-    // bounds (background rect first, then the subtree in painter's order),
-    // outer scene carrying the group's transform and opacity — the clip
-    // lives inside, so the bounds move/scale WITH the unit, as an AE
-    // precomp layer's frame does.
-    const paintComp = (p, comp, target) => Effect.gen(function* () {
-        const scale = p.projection.scale;
-        // bounds start at the group's anchor: a comp's local space is
-        // top-left-anchored like every shape (world = screen at rest)
-        const w = comp.width * scale;
-        const h = comp.height * scale;
-        const x = comp.anchor.x;
-        const y = comp.anchor.y;
-        const outer = yield* Tvg.Scene.make();
-        const clipShape = yield* Tvg.Shape.make();
-        yield* Tvg.Shape.appendRect(clipShape, x, y, w, h);
-        yield* Tvg.Paint.clip(outer, clipShape);
-        if (comp.backgroundColor !== undefined) {
-            const { r, g, b, a } = Color.bytes(comp.backgroundColor);
-            if (a > 0) {
-                const bg = yield* Tvg.Shape.make();
-                yield* Tvg.Shape.appendRect(bg, x, y, w, h);
-                yield* Tvg.Shape.setFillColor(bg, r, g, b, a);
-                yield* Tvg.Scene.add(outer, bg);
-            }
-        }
-        // ponytail: the unit's content paints sharp — depth of field
-        // treats the comp as one layer at its anchor depth (like a
-        // tilted plane's quad); bucket inside the unit if a deep comp
-        // ever needs per-child blur.
-        for (const sub of [...comp.subs].sort(byPaintOrder)) {
-            if (sub.projection.scale <= 0 && sub.projection.quad === undefined) {
-                continue;
-            }
-            yield* paintOne(sub, outer);
-        }
-        if (!Group.isIdentityTransform(comp.transform)) {
-            // the group's local matrix conjugated into screen space about
-            // the BOUNDS CENTER (AE scales a precomp layer about its
-            // anchor, default the layer center):
-            // screen = T(c)·S(scale)·M·S(1/scale)·T(-c), c = bounds center
-            const cx = x + w / 2;
-            const cy = y + h / 2;
-            const t = (e, f) => ({
-                a: 1,
-                b: 0,
-                c: 0,
-                d: 1,
-                e,
-                f,
-            });
-            const s = (k) => ({
-                a: k,
-                b: 0,
-                c: 0,
-                d: k,
-                e: 0,
-                f: 0,
-            });
-            const m = [
-                t(cx, cy),
-                s(scale),
-                comp.transform,
-                s(1 / scale),
-                t(-cx, -cy),
-            ].reduce(Group.multiplyTransforms);
-            yield* Tvg.Paint.setTransform(outer, m);
-        }
-        if (comp.opacity < 1) {
-            yield* Tvg.Paint.setOpacity(outer, Math.round(Math.max(0, Math.min(1, comp.opacity)) * 255));
-        }
-        yield* Tvg.Scene.add(target, outer);
-    });
-    // paint far→near. A paintable whose anchor is behind the camera
-    // (scale <= 0) is culled here so paint functions never see an invalid
-    // placement — EXCEPT a tilted plane carrying a quad: its polygon is
-    // already near-plane-clipped, and it can be visible (near part in
-    // front) while its anchor corner is behind.
-    for (const p of paintables) {
-        const { projection, hud } = p;
-        if (projection.scale <= 0 && projection.quad === undefined) {
-            continue;
-        }
-        // HUD content is structurally sharp: its effective camera is the
-        // identity camera (aperture 0), so it never enters a blur bucket
-        const sigma = aperture > 0 && !hud
-            ? quantizeSigma(circleOfConfusion(projection.depth, frame.camera))
-            : 0;
-        if (sigma !== bucketSigma) {
-            yield* closeBucket;
-            bucketScene = sigma === 0 ? scene : yield* Tvg.Scene.make();
-            bucketSigma = sigma;
-        }
-        yield* paintOne(p, bucketScene);
-    }
-    yield* closeBucket;
-});
-/**
- * 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 const render = (frame, options) => Effect.gen(function* () {
-    const logicalWidth = frame.width;
-    const logicalHeight = frame.height;
-    const dpr = options?.dpr ?? 1;
-    const width = Math.round(logicalWidth * dpr);
-    const height = Math.round(logicalHeight * dpr);
-    const canvas = yield* Tvg.Session.canvasSized(width, height);
-    const scene = yield* Tvg.Scene.make();
-    // background as a filled rect covering the viewport (mirrors the SVG
-    // sink's background rect; survives into the raster buffer)
-    const bg = yield* Tvg.Shape.make();
-    yield* Tvg.Shape.appendRect(bg, 0, 0, logicalWidth, logicalHeight);
-    const { r, g, b, a } = Color.bytes(frame.backgroundColor);
-    yield* Tvg.Shape.setFillColor(bg, r, g, b, a);
-    yield* Tvg.Scene.add(scene, bg);
-    yield* renderToCanvas(frame, canvas, scene, dpr);
-    // scale the whole subtree to physical pixels; children keep their own
-    // logical affines (parent transforms compose in the scene graph)
-    if (dpr !== 1) {
-        yield* Tvg.Paint.scale(scene, dpr);
-    }
-    yield* Tvg.Canvas.add(canvas, scene);
-    yield* Tvg.Canvas.update(canvas);
-    // clear the target buffer: with a transparent background nothing else
-    // overwrites the previous frame's (or uninitialized) pixels
-    yield* Tvg.Canvas.draw(canvas, true);
-    yield* Tvg.Canvas.sync(canvas);
-    const buffer = yield* Tvg.Canvas.render(canvas);
-    return {
-        rgba: new Uint8Array(buffer),
-        width,
-        height,
-        logicalWidth,
-        logicalHeight,
-    };
-});

package/dist/Shapes.d.ts

@@ -1,11 +0,0 @@
-export { Circle } from "./shapes/Circle.js";
-export { Ellipse } from "./shapes/Ellipse.js";
-export * from "./shapes/Group.js";
-export { Hud } from "./shapes/Hud.js";
-export { Image } from "./shapes/Image.js";
-export { Line } from "./shapes/Line.js";
-export { Path } from "./shapes/Path.js";
-export { Rect } from "./shapes/Rect.js";
-export * as Shape2D from "./shapes/Shape2D.js";
-export { Square } from "./shapes/Square.js";
-export { Text } from "./shapes/Text.js";

package/dist/Shapes.js

@@ -1,11 +0,0 @@
-export { Circle } from "./shapes/Circle.js";
-export { Ellipse } from "./shapes/Ellipse.js";
-export * from "./shapes/Group.js";
-export { Hud } from "./shapes/Hud.js";
-export { Image } from "./shapes/Image.js";
-export { Line } from "./shapes/Line.js";
-export { Path } from "./shapes/Path.js";
-export { Rect } from "./shapes/Rect.js";
-export * as Shape2D from "./shapes/Shape2D.js";
-export { Square } from "./shapes/Square.js";
-export { Text } from "./shapes/Text.js";

package/dist/demo.d.ts

@@ -1,3 +0,0 @@
-import * as Scene from "./Scene.js";
-export declare const scene: Scene.Scene<never, import("./Runner.js").Runner>;
-export declare const staggered: Scene.Scene<never, import("./Runner.js").Runner>;

package/dist/demo.js

@@ -1,71 +0,0 @@
-import { NodeServices } from "@effect/platform-node";
-import { Session } from "@effect-motion/thorvg";
-import { EngineNode } from "@effect-motion/thorvg/node";
-import { Effect, Layer, Schedule, Stream } from "effect";
-import * as Color from "./Color.js";
-import * as Motion from "./Motion.js";
-import * as Physics from "./Physics.js";
-import * as PngExporter from "./PngExporter.js";
-import * as Renderer from "./Renderer.js";
-import * as Scene from "./Scene.js";
-import * as Shapes from "./Shapes.js";
-// the demo's comp config — the old runner defaults, now explicit on the scene
-const demoComp = {
-    width: 500,
-    height: 300,
-    backgroundColor: Color.rgba(22, 22, 29),
-};
-// children live in the group's local coordinates: one motion moves them all
-export const scene = Scene.make(function* () {
-    const duo = yield* Scene.instantiate(Shapes.Group, {
-        x: 70,
-        y: 200,
-        children: [
-            Scene.instantiate(Shapes.Circle, {
-                x: 0,
-                y: 0,
-                radius: 14,
-                fill: Color.hex("#e53170"),
-            }),
-            Scene.instantiate(Shapes.Square, {
-                x: 20,
-                y: -16,
-                size: 28,
-                fill: Color.hex("#a786df"),
-            }),
-        ],
-    });
-    yield* Motion.wait("1.5 seconds");
-    yield* duo.pipe(Motion.moveTo({ x: 380 }, "1.5 seconds", "easeInOutCubic"), Motion.moveTo({ x: 70 }, "1.5 seconds", "easeInOutCubic"), Motion.wait("1.5 seconds"), Physics.springTo({ y: 80 }, "jump"), Motion.fadeTo(0.15, "1 second"));
-}, demoComp);
-// schedule-driven composition: a background pulse loops for the scene's
-// duration while three staggered dots define its actual length
-export const staggered = Scene.make(function* () {
-    const stage = yield* Scene.instantiate(Shapes.Group, { x: 70, y: 150 });
-    yield* Scene.background(Scene.repeat(stage.pipe(Motion.moveTo({ y: 130 }, "500 millis", "easeInOutCubic"), Motion.moveTo({ y: 150 }, "500 millis", "easeInOutCubic")), Schedule.forever));
-    const dot = (x) => Effect.gen(function* () {
-        const circle = yield* Scene.instantiate(Shapes.Circle, {
-            x,
-            y: 0,
-            radius: 10,
-            fill: Color.hex("#e53170"),
-        });
-        // reparent the freshly-born dot from root into the stage group
-        yield* Scene.appendChild(stage, circle);
-        yield* Motion.tweenTo(circle, { x: x + 300 }, "1 second", "easeInOutCubic");
-    });
-    yield* Scene.stagger([dot(0), dot(25), dot(50)], Schedule.spaced("250 millis"));
-}, demoComp);
-// render the middle frame of the duo scene to a PNG through the single ThorVG
-// renderer (Node adapter) — the end-to-end path: Scene.stream → renderToPng.
-const movie = Effect.gen(function* () {
-    const frames = yield* Scene.stream(scene).pipe(Stream.runCollect);
-    const list = [...frames];
-    const mid = list[Math.floor(list.length / 2)];
-    const framebuffer = yield* Renderer.render(mid);
-    const _png = yield* PngExporter.toBuffer(framebuffer);
-    yield* PngExporter.toFile(framebuffer, "output.png");
-});
-Effect.runPromise(movie.pipe(Effect.scoped, Effect.provide(Layer.provideMerge(
-// a demo scene with declared assets would add fonts/images maps here
-Session.layer({ width: 500, height: 300 }), EngineNode.layer("sw"))), Effect.provide(NodeServices.layer)));

package/dist/render/dof.d.ts

@@ -1,27 +0,0 @@
-import type * as Projection from "../Projection.js";
-/**
- * Depth-of-field circle of confusion (design D2 of camera-depth-of-field):
- * how much gaussian blur a paintable at `depth` receives under `camera`.
- * Pure arithmetic on frame data — deterministic by construction.
- */
-/** defensive ceiling: no author intends a 100px blur; huge sigmas are bugs */
-export declare const MAX_SIGMA = 64;
-/** quantization step (px): paintables within a step share one blur pass */
-export declare const SIGMA_STEP = 0.5;
-/** below this, blur is visually nil — treat as sharp (no blur pass at all) */
-export declare const SHARP_THRESHOLD = 0.25;
-/**
- * Blur sigma for a paintable at view-space `depth`: zero at the focus plane,
- * growing with distance from it, scaled by aperture and focal length (longer
- * lens = shallower field). AE-flavored, not thin-lens-accurate — the contract
- * is the shape of the curve, not the constants.
- */
-export declare const circleOfConfusion: (depth: number, camera: Projection.CameraView) => number;
-/**
- * Quantize a sigma so contiguous depth-sorted runs share blur passes: 0 for
- * visually-sharp values, otherwise the nearest step (never above the ceiling).
- * ponytail: 0.5px steps keep pass counts low and banding invisible; the
- * upgrade path is per-paintable exact sigma (one blur pass each) if a smooth
- * depth gradient ever shows stepping.
- */
-export declare const quantizeSigma: (sigma: number) => number;

package/dist/render/dof.js

@@ -1,37 +0,0 @@
-/**
- * Depth-of-field circle of confusion (design D2 of camera-depth-of-field):
- * how much gaussian blur a paintable at `depth` receives under `camera`.
- * Pure arithmetic on frame data — deterministic by construction.
- */
-/** defensive ceiling: no author intends a 100px blur; huge sigmas are bugs */
-export const MAX_SIGMA = 64;
-/** quantization step (px): paintables within a step share one blur pass */
-export const SIGMA_STEP = 0.5;
-/** below this, blur is visually nil — treat as sharp (no blur pass at all) */
-export const SHARP_THRESHOLD = 0.25;
-/**
- * Blur sigma for a paintable at view-space `depth`: zero at the focus plane,
- * growing with distance from it, scaled by aperture and focal length (longer
- * lens = shallower field). AE-flavored, not thin-lens-accurate — the contract
- * is the shape of the curve, not the constants.
- */
-export const circleOfConfusion = (depth, camera) => {
-    if (camera.aperture <= 0 || depth <= 0 || camera.focusDistance <= 0) {
-        return 0;
-    }
-    const sigma = (camera.aperture *
-        camera.focalLength *
-        Math.abs(depth - camera.focusDistance)) /
-        (depth * camera.focusDistance);
-    return Math.min(sigma, MAX_SIGMA);
-};
-/**
- * Quantize a sigma so contiguous depth-sorted runs share blur passes: 0 for
- * visually-sharp values, otherwise the nearest step (never above the ceiling).
- * ponytail: 0.5px steps keep pass counts low and banding invisible; the
- * upgrade path is per-paintable exact sigma (one blur pass each) if a smooth
- * depth gradient ever shows stepping.
- */
-export const quantizeSigma = (sigma) => sigma < SHARP_THRESHOLD
-    ? 0
-    : Math.min(Math.round(sigma / SIGMA_STEP) * SIGMA_STEP, MAX_SIGMA);