effect-motion 0.2.0 → 0.3.0

package/dist/Scene.d.ts

@@ -7,31 +7,24 @@ import type * as Schedule from "effect/Schedule";
 import type * as Schema from "effect/Schema";
 import type * as Scope from "effect/Scope";
 import * as Stream from "effect/Stream";
-import type * as Entity from "./Entity";
-import type * as Instance from "./Instance";
-import * as Phaser from "./Phaser";
-import * as Runner from "./Runner";
+import type * as Camera from "./Camera.js";
+import type * as Color from "./Color.js";
+import type * as Entity from "./Entity.js";
+import type * as Instance from "./Instance.js";
+import * as Phaser from "./Phaser.js";
+import * as Runner from "./Runner.js";
 export declare const TypeId: "~motion/Scene";
-export interface Scene<E, R, Entities> {
+export interface Scene<E = never, R = never> {
     readonly [TypeId]: typeof TypeId;
     readonly runner: Effect.Effect<void, E, R | Scope.Scope>;
-    readonly "~entities": Entities;
     /** tooling-facing metadata; never read by the runtime */
     readonly annotations: Context.Context<never>;
-    annotate<I, S>(key: Context.Key<I, S>, value: S): Scene<E, R, Entities>;
-    annotateMerge(context: Context.Context<never>): Scene<E, R, Entities>;
+    annotate<I, S>(key: Context.Key<I, S>, value: S): Scene<E, R>;
+    annotateMerge(context: Context.Context<never>): Scene<E, R>;
 }
-type MakeEffect<Eff extends Effect.Effect<any, any, any>, AEff> = Effect.Effect<AEff, [
-    Eff
-] extends [never] ? never : [Eff] extends [Effect.Effect<infer _A, infer E, infer _R>] ? E : never, [
-    Eff
-] extends [never] ? never : [Eff] extends [Effect.Effect<infer _A, infer _E, infer R>] ? R : never>;
-export declare const make: <const Eff extends Effect.Effect<any, any, any>, AEff>(f: () => Generator<Eff, void, never>) => MakeEffect<Eff, AEff> extends Effect.Effect<AEff, infer E, infer R> ? Scene<E, Exclude<R, {
-    readonly [Entity.TypeId]: typeof Entity.TypeId;
-}> | Scope.Scope, Extract<R, {
-    readonly [Entity.TypeId]: typeof Entity.TypeId;
-}>> : never;
-export declare const instantiate: <Name extends string, Data extends Schema.Top, Traits extends Partial<Entity.EntityTraits<Data["Type"]>>, MakeInput>(entity: Entity.Entity<Name, Data, Traits, MakeInput>, props: Runner.InstantiateProps<MakeInput>) => Effect.Effect<Instance.Instance<Name, Data, Traits>, unknown, Entity.Entity<Name, Data, Traits, MakeInput> | Runner.Runner>;
+export type AnyScene = Scene<never, never>;
+export declare const make: <const Eff extends Effect.Effect<any, any, any>, const AEff>(f: () => Generator<Eff, AEff, never>) => Scene<[Eff] extends [never] ? never : [Eff] extends [Effect.Effect<infer _A, infer E, infer _R>] ? E : never, [Eff] extends [never] ? never : [Eff] extends [Effect.Effect<infer _A, infer _E, infer R>] ? R : never>;
+export declare const instantiate: <Name extends string, Data extends Schema.Top, Traits extends Partial<Entity.EntityTraits<Data["Type"]>>>(entity: Entity.Entity<Name, Data, Traits>, props: Runner.InstantiateProps<Data["~type.make.in"]>) => Effect.Effect<Instance.Instance<Name, Data, Traits>, never, Runner.Runner>;
 export declare const tick: Effect.Effect<void, never, Runner.Runner>;
 /**
  * Hold the scene for `duration` of scene time (frames at the runner's
@@ -52,7 +45,7 @@ export interface FrameEntry<Entity extends Entity.AnyEntity> {
 export type EntriesFromEntities<Entities> = Entities extends Entity.AnyEntity ? {
     [K in Entities as K["name"]]: FrameEntry<K>;
 }[Entities["name"]] : never;
-export interface Frame<Entities extends Entity.AnyEntity> {
+export interface Frame<Entities extends Entity.AnyEntity = Entity.AnyEntity> {
     instances: Record<string, EntriesFromEntities<Entities>>;
     /** id of the root group (conventionally "root"); never rendered itself */
     root: string;
@@ -60,25 +53,21 @@ export interface Frame<Entities extends Entity.AnyEntity> {
     frameRate: number;
     width: number;
     height: number;
-    backgroundColor: string;
-    /** the active camera's view; identity `{0,0,1}` when unused */
-    camera: {
-        x: number;
-        y: number;
-        zoom: number;
-    };
+    backgroundColor: Color.Color;
+    /** the active camera's view; Camera.IDENTITY when unused */
+    camera: Camera.CameraState;
 }
-export declare const step: <E, R, Entities extends Entity.AnyEntity>(runningScene: RunningScene<E, R, Entities>) => Effect.Effect<Frame<Entities> | null, E, never>;
-interface RunningScene<E, R, Entities> {
+export declare const step: <E, R>(runningScene: RunningScene<E, R>) => Effect.Effect<Frame<Entity.AnyEntity> | null, E, never>;
+export interface RunningScene<E, R> {
     readonly runner: Runner.Runner["Service"];
-    readonly scene: Scene<E, R, Entities>;
+    readonly scene: Scene<E, R>;
     readonly fiber: Fiber.Fiber<void, E>;
     readonly done: boolean;
     /** frames delivered so far — mutated by `step` for the maxFrames cap */
     framesDelivered: number;
 }
-export declare const run: <E, R, Entities>(scene: Scene<E, R, Entities>, settings?: Partial<Runner.Settings>) => Effect.Effect<RunningScene<E, R, Entities>, never, Exclude<Exclude<Exclude<Exclude<R, Scope.Scope>, never>, Phaser.Phaser>, Runner.Runner>>;
-export declare const stream: <E, R, Entities extends Entity.AnyEntity>(scene: Scene<E, R, Entities>, settings?: Partial<Runner.Settings>) => Stream.Stream<Frame<Entities>, Exclude<E, Cause.Done<any>>, Exclude<Exclude<Exclude<Exclude<Exclude<R, Scope.Scope>, never>, Phaser.Phaser>, Runner.Runner>, Scope.Scope>>;
+export declare const run: <E, R>(scene: Scene<E, R>, settings?: Partial<Runner.Settings>) => Effect.Effect<RunningScene<E, R>, never, Scope.Scope | Exclude<Exclude<Exclude<Exclude<R, Scope.Scope>, never>, Phaser.Phaser>, Runner.Runner>>;
+export declare const stream: <E = never, R = never>(scene: Scene<E, R>, settings?: Partial<Runner.Settings>) => Stream.Stream<Frame<Entity.AnyEntity>, Exclude<E, Cause.Done<any>>, Exclude<Exclude<Exclude<Exclude<Exclude<R, Scope.Scope>, never>, Phaser.Phaser>, Runner.Runner>, Scope.Scope>>;
 type Updater<Data> = Data | ((data: Data) => Data);
 export declare const data: <Name extends string, Data extends Schema.Top>(instance: Instance.Instance<Name, Data>) => Effect.Effect<Data["Type"] & ({} | undefined), never, Runner.Runner>;
 export declare const update: <Name extends string, Data extends Schema.Top>(instance: Instance.Instance<Name, Data>, props: Updater<Data["Type"]>) => Effect.Effect<void | false, never, Runner.Runner>;
@@ -95,41 +84,81 @@ export declare const settings: () => Effect.Effect<{
     frameRate: number;
     width: number;
     height: number;
-    backgroundColor: string;
+    backgroundColor: Color.Color;
     seed: Runner.Seed;
     maxFrames: number;
 }, never, Runner.Runner>;
 /**
  * The active camera instance — an ordinary instance carrying `~position`
- * (x/y pan) and a `zoom` field, so the existing animators drive it:
- * `Scene.make(function* () { const cam = yield* Scene.camera; yield*
- * cam.pipe(Motion.moveTo({ x: 400 })) })`. A default identity camera is
- * always present; animate it directly, or `Scene.setCamera` to swap in
- * another instance. The camera is never drawn.
+ * (world x/y/z), Euler orientation (`rotX`/`rotY`/`rotZ`), and
+ * `focalLength` (perspective strength — see Projection.defaultFocalLength),
+ * so the existing animators drive it: `Scene.make(function* () { const cam
+ * = yield* Scene.camera; yield* cam.pipe(Motion.moveTo({ z: -400 })) })`.
+ * A default resting camera is always present (width-relative 50mm-equivalent
+ * focal length, projecting z=0 content to plain-2D placement); animate it
+ * directly, or `Scene.setCamera` to swap in another instance. The camera is
+ * never drawn.
  */
 export declare const camera: Effect.Effect<Instance.Instance<"Camera", Schema.Struct<{
     x: Schema.withConstructorDefault<Schema.Number>;
     y: Schema.withConstructorDefault<Schema.Number>;
-    zoom: Schema.withConstructorDefault<Schema.Number>;
+    z: Schema.withConstructorDefault<Schema.Number>;
+    rotX: Schema.withConstructorDefault<Schema.Number>;
+    rotY: Schema.withConstructorDefault<Schema.Number>;
+    rotZ: Schema.withConstructorDefault<Schema.Number>;
+    focalLength: Schema.withConstructorDefault<Schema.Number>;
+    focusDistance: Schema.withConstructorDefault<Schema.Number>;
+    aperture: Schema.withConstructorDefault<Schema.Number>;
+    poiX: Schema.optionalKey<Schema.Number>;
+    poiY: Schema.optionalKey<Schema.Number>;
+    poiZ: Schema.optionalKey<Schema.Number>;
 }>, {
     readonly "~position": {
-        get: (data: Schema.Struct.ReadonlySide<{
-            x: Schema.withConstructorDefault<Schema.Number>;
-            y: Schema.withConstructorDefault<Schema.Number>;
-            zoom: Schema.withConstructorDefault<Schema.Number>;
-        }, "Type">) => {
+        get: (data: {
+            readonly x: number;
+            readonly y: number;
+            readonly z: number;
+            readonly rotX: number;
+            readonly rotY: number;
+            readonly rotZ: number;
+            readonly focalLength: number;
+            readonly focusDistance: number;
+            readonly aperture: number;
+            readonly poiX?: number;
+            readonly poiY?: number;
+            readonly poiZ?: number;
+        }) => {
             x: number;
             y: number;
+            z: number;
+        };
+        set: (data: {
+            readonly x: number;
+            readonly y: number;
+            readonly z: number;
+            readonly rotX: number;
+            readonly rotY: number;
+            readonly rotZ: number;
+            readonly focalLength: number;
+            readonly focusDistance: number;
+            readonly aperture: number;
+            readonly poiX?: number;
+            readonly poiY?: number;
+            readonly poiZ?: number;
+        }, value: Entity.Position) => {
+            readonly x: number;
+            readonly y: number;
+            readonly z: number;
+            readonly rotX: number;
+            readonly rotY: number;
+            readonly rotZ: number;
+            readonly focalLength: number;
+            readonly focusDistance: number;
+            readonly aperture: number;
+            readonly poiX?: number;
+            readonly poiY?: number;
+            readonly poiZ?: number;
         };
-        set: (data: Schema.Struct.ReadonlySide<{
-            x: Schema.withConstructorDefault<Schema.Number>;
-            y: Schema.withConstructorDefault<Schema.Number>;
-            zoom: Schema.withConstructorDefault<Schema.Number>;
-        }, "Type">, value: Entity.Position) => Schema.Struct.ReadonlySide<{
-            x: Schema.withConstructorDefault<Schema.Number>;
-            y: Schema.withConstructorDefault<Schema.Number>;
-            zoom: Schema.withConstructorDefault<Schema.Number>;
-        }, "Type">;
     };
 }>, never, Runner.Runner>;
 /** Swap the active camera to `instance`; its live data becomes the view. */
@@ -142,7 +171,7 @@ export declare const setCamera: (instance: Instance.Instance) => Effect.Effect<v
  * the rest of the scene stays live while you wait. `fiber` is the
  * branch's physical execution — interrupt it to bound a tail.
  */
-export interface BranchHandle<A = unknown, E = unknown> {
+export interface BranchHandle<A = unknown, E = never> {
     readonly finished: Effect.Effect<void, never, Runner.Runner>;
     readonly fiber: Fiber.Fiber<A, E>;
 }
@@ -178,7 +207,7 @@ export declare const repeat: <A, E, R, Output, ScheduleE, ScheduleR>(effect: Eff
  * instead. Forks are supervised by the fiber that spawned them: a fork
  * made inside another fork is interrupted when its spawner completes.
  */
-export declare const fork: <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<BranchHandle<A, E>, never, Runner.Runner | Exclude<Exclude<R, never>, Phaser.Phaser>>;
+export declare const fork: <A, E = never, R = never>(effect: Effect.Effect<A, E, R>) => Effect.Effect<BranchHandle<A, E>, never, Runner.Runner | Exclude<Exclude<R, never>, Phaser.Phaser>>;
 /**
  * Like {@link fork}, but the fiber is INTERRUPTED at scene end instead
  * of awaited — for indefinite work (`Scene.repeat(…, Schedule.forever)`)
@@ -186,7 +215,7 @@ export declare const fork: <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.E
  * alive. "Scene end" includes the fork drain: backgrounds keep animating
  * while awaited forks finish, and are stopped after the last one.
  */
-export declare const background: <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<BranchHandle<A, E>, never, Runner.Runner | Exclude<Exclude<R, never>, Phaser.Phaser>>;
+export declare const background: <A, E = never, R = never>(effect: Effect.Effect<A, E, R>) => Effect.Effect<BranchHandle<A, E>, never, Runner.Runner | Exclude<Exclude<R, never>, Phaser.Phaser>>;
 export interface PlayOptions {
     /** group to mount the scene's instances under (default: the root) */
     readonly parent?: Runner.GroupInstance;
@@ -202,14 +231,14 @@ export interface PlayOptions {
  * like a fork — `yield* handle.finished` for sequential nesting, or
  * don't await for concurrent scenes.
  */
-export declare const play: <E, R, Entities>(scene: Scene<E, R, Entities>, options?: PlayOptions) => Effect.Effect<BranchHandle<void, E>, never, Runner.Runner | Exclude<R, Scope.Scope>>;
+export declare const play: <E, R>(scene: Scene<E, R>, options?: PlayOptions) => Effect.Effect<BranchHandle<void, E>, never, Runner.Runner | Exclude<R, Scope.Scope>>;
 /**
  * Run effects in lockstep parallel, sharing frame phases — the public
  * counterpart to the low-level `Phaser.all`. Takes no schedule: pacing a
  * list sequentially belongs to {@link chain}, overlapping staggered
  * starts to {@link stagger}.
  */
-export declare const all: typeof Phaser.all;
+export declare const all: <Eff extends Effect.Effect<any, any, any>>(effects: Iterable<Eff>) => Effect.Effect<void, Eff extends Effect.Effect<any, infer E, any> ? E : never, Runner.Runner | Exclude<Eff extends Effect.Effect<any, any, infer R> ? R : never, Phaser.Phaser>>;
 /**
  * Run items one at a time, in order — items NEVER overlap, mirroring
  * Effect's guarantee for scheduled effects. The first item runs
@@ -237,5 +266,5 @@ export declare const chain: <Eff extends Effect.Effect<any, any, any>, ScheduleE
  */
 export declare const stagger: <Eff extends Effect.Effect<any, any, any>, ScheduleE = never, ScheduleR = never>(effects: Iterable<Eff>, schedule: Schedule.Schedule<unknown, void, ScheduleE, ScheduleR>) => Effect.Effect<{
     released: number;
-}, (Eff extends Effect.Effect<any, infer E, any> ? E : never) | ScheduleE, (Eff extends Effect.Effect<any, any, infer R> ? R : never) | Phaser.Phaser | Runner.Runner | ScheduleR>;
+}, (Eff extends Effect.Effect<any, infer E, any> ? E : never) | ScheduleE, (Eff extends Effect.Effect<any, any, infer R> ? R : never) | Runner.Runner | ScheduleR>;
 export {};

package/dist/Scene.js

@@ -5,9 +5,9 @@ import * as Exit from "effect/Exit";
 import * as Fiber from "effect/Fiber";
 import * as Random from "effect/Random";
 import * as Stream from "effect/Stream";
-import * as Phaser from "./Phaser";
-import * as Runner from "./Runner";
-import * as Time from "./Time";
+import * as Phaser from "./Phaser.js";
+import * as Runner from "./Runner.js";
+import * as Time from "./Time.js";
 export const TypeId = "~motion/Scene";
 export const make = (f) => {
     return makeScene(Effect.scoped(Effect.gen(f)), Context.empty());
@@ -126,13 +126,13 @@ export const run = (scene, settings = {}) => Effect.gen(function* () {
             // interrupt can cut this fiber before failCause runs,
             // and the root branch records like any other branch
             onFailure: (cause) => Effect.sync(() => runner.recordFailure(cause)).pipe(Effect.andThen(releaseRoot), Effect.andThen(Fiber.interruptAll([...runner.forks, ...runner.backgrounds].map((b) => b.fiber))), Effect.andThen(Effect.failCause(cause))),
-        }))).pipe(Effect.ensuring(releaseRoot), Effect.provideService(CurrentBranch, rootBranch), 
+        }))).pipe(Effect.ensuring(releaseRoot), Effect.provideService(currentBranch(), rootBranch), 
         // success, failure, or interrupt: the scene is over either way
         Effect.ensuring(Effect.sync(() => {
             done = true;
         })), Effect.provide(Layer.succeed(Phaser.Phaser, runner.phaser)), Effect.provide(Layer.succeed(Runner.Runner, runner)), 
         // seeded pseudo-randomness, scoped to the scene fiber
-        Random.withSeed(runner.settings.seed), Effect.forkChild);
+        Random.withSeed(runner.settings.seed), Effect.forkScoped);
     }));
     const runningScene = {
         runner,
@@ -191,11 +191,14 @@ export const settings = Effect.fnUntraced(function* () {
 });
 /**
  * The active camera instance — an ordinary instance carrying `~position`
- * (x/y pan) and a `zoom` field, so the existing animators drive it:
- * `Scene.make(function* () { const cam = yield* Scene.camera; yield*
- * cam.pipe(Motion.moveTo({ x: 400 })) })`. A default identity camera is
- * always present; animate it directly, or `Scene.setCamera` to swap in
- * another instance. The camera is never drawn.
+ * (world x/y/z), Euler orientation (`rotX`/`rotY`/`rotZ`), and
+ * `focalLength` (perspective strength — see Projection.defaultFocalLength),
+ * so the existing animators drive it: `Scene.make(function* () { const cam
+ * = yield* Scene.camera; yield* cam.pipe(Motion.moveTo({ z: -400 })) })`.
+ * A default resting camera is always present (width-relative 50mm-equivalent
+ * focal length, projecting z=0 content to plain-2D placement); animate it
+ * directly, or `Scene.setCamera` to swap in another instance. The camera is
+ * never drawn.
  */
 export const camera = Effect.gen(function* () {
     const runner = yield* Runner.Runner;
@@ -207,7 +210,9 @@ export const setCamera = (instance) => Effect.gen(function* () {
     runner.setCamera(instance);
 });
 /** the innermost enclosing branch; null = outside any running scene */
-const CurrentBranch = Context.Reference("motion/Scene/CurrentBranch", { defaultValue: () => null });
+const currentBranch = () => Context.Reference("motion/Scene/CurrentBranch", {
+    defaultValue: () => null,
+});
 const makeBranch = (runner, kind) => {
     const latch = Latch.makeUnsafe();
     let finished = false;
@@ -247,7 +252,7 @@ const makeBranch = (runner, kind) => {
  * reported — by then nothing is listening.
  */
 export const finish = Effect.gen(function* () {
-    const branch = yield* CurrentBranch;
+    const branch = yield* currentBranch();
     if (branch === null) {
         return yield* Effect.die(new Error("Scene.finish called outside a running scene"));
     }
@@ -270,7 +275,7 @@ const forkBranch = (runner, effect, kind) => Effect.gen(function* () {
             runner.recordFailure(exit.cause);
         }
         branch.finishUnsafe();
-    })), Effect.provideService(CurrentBranch, branch)));
+    })), Effect.provideService(currentBranch(), branch)));
     branch.entry.fiber = fiber;
     if (kind === "fork" && !branch.isFinished()) {
         runner.forks.add(branch.entry);
@@ -373,7 +378,11 @@ export const play = (scene, options) => Effect.gen(function* () {
  * list sequentially belongs to {@link chain}, overlapping staggered
  * starts to {@link stagger}.
  */
-export const all = (effects) => Phaser.all(effects);
+export const all = Effect.fnUntraced(function* (effects) {
+    const runner = yield* Runner.Runner;
+    // runner.phaser
+    return yield* Phaser.all(effects).pipe(Effect.provideService(Phaser.Phaser, runner.phaser));
+});
 /**
  * Run items one at a time, in order — items NEVER overlap, mirroring
  * Effect's guarantee for scheduled effects. The first item runs
@@ -449,6 +458,6 @@ export const stagger = (effects, schedule) => Effect.gen(function* () {
         // biome-ignore lint/style/noNonNullAssertion: same length as releaseFrames
         yield* list[i];
     }));
-    yield* Phaser.all(branches);
+    yield* Phaser.all(branches).pipe(Effect.provideService(Phaser.Phaser, runner.phaser));
     return { released: releaseFrames.length };
 });

package/dist/Shapes.d.ts

@@ -0,0 +1,11 @@
+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

@@ -0,0 +1,11 @@
+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,186 +1,3 @@
-import * as Schema from "effect/Schema";
-import * as Entity from "./Entity";
-import * as Scene from "./Scene";
-export declare const scene: Scene.Scene<unknown, import("./Runner").Runner | import("effect/Scope").Scope, Entity.Entity<"shapes/Group", Schema.Struct<{
-    x: Schema.withConstructorDefault<Schema.Number>;
-    y: Schema.withConstructorDefault<Schema.Number>;
-    opacity: Schema.withConstructorDefault<Schema.Number>;
-    transform: Schema.withConstructorDefault<Schema.Struct<{
-        readonly a: Schema.Number;
-        readonly b: Schema.Number;
-        readonly c: Schema.Number;
-        readonly d: Schema.Number;
-        readonly e: Schema.Number;
-        readonly f: Schema.Number;
-    }>>;
-    children: Schema.withConstructorDefault<Schema.$Array<Schema.String>>;
-}>, {
-    "~position": Entity.TraitLens<Schema.Struct.ReadonlySide<{
-        x: Schema.withConstructorDefault<Schema.Number>;
-        y: Schema.withConstructorDefault<Schema.Number>;
-        opacity: Schema.withConstructorDefault<Schema.Number>;
-        transform: Schema.withConstructorDefault<Schema.Struct<{
-            readonly a: Schema.Number;
-            readonly b: Schema.Number;
-            readonly c: Schema.Number;
-            readonly d: Schema.Number;
-            readonly e: Schema.Number;
-            readonly f: Schema.Number;
-        }>>;
-        children: Schema.withConstructorDefault<Schema.$Array<Schema.String>>;
-    }, "Type">, Entity.Position>;
-    "~opacity": Entity.TraitLens<Schema.Struct.ReadonlySide<{
-        x: Schema.withConstructorDefault<Schema.Number>;
-        y: Schema.withConstructorDefault<Schema.Number>;
-        opacity: Schema.withConstructorDefault<Schema.Number>;
-        transform: Schema.withConstructorDefault<Schema.Struct<{
-            readonly a: Schema.Number;
-            readonly b: Schema.Number;
-            readonly c: Schema.Number;
-            readonly d: Schema.Number;
-            readonly e: Schema.Number;
-            readonly f: Schema.Number;
-        }>>;
-        children: Schema.withConstructorDefault<Schema.$Array<Schema.String>>;
-    }, "Type">, number>;
-}, Omit<{
-    readonly x?: number;
-    readonly y?: number;
-    readonly opacity?: number;
-    readonly transform?: Schema.Struct.ReadonlyMakeIn<{
-        readonly a: Schema.Number;
-        readonly b: Schema.Number;
-        readonly c: Schema.Number;
-        readonly d: Schema.Number;
-        readonly e: Schema.Number;
-        readonly f: Schema.Number;
-    }>;
-    readonly children?: readonly string[];
-}, "transform"> & {
-    readonly transform?: readonly (Schema.Struct.ReadonlySide<{
-        readonly _tag: Schema.tag<"transform/matrix">;
-        readonly a: Schema.Number;
-        readonly b: Schema.Number;
-        readonly c: Schema.Number;
-        readonly d: Schema.Number;
-        readonly e: Schema.Number;
-        readonly f: Schema.Number;
-    }, "Type"> | Schema.Struct.ReadonlySide<{
-        readonly _tag: Schema.tag<"transform/scale">;
-        readonly x: Schema.Number;
-        readonly y: Schema.Number;
-    }, "Type"> | Schema.Struct.ReadonlySide<{
-        readonly _tag: Schema.tag<"transform/translate">;
-        readonly x: Schema.Number;
-        readonly y: Schema.Number;
-    }, "Type">)[];
-}>>;
-export declare const staggered: Scene.Scene<unknown, import("./Phaser").Phaser | import("./Runner").Runner | import("effect/Scope").Scope, Entity.Entity<"shapes/Circle", Schema.Struct<{
-    x: Schema.withConstructorDefault<Schema.Number>;
-    y: Schema.withConstructorDefault<Schema.Number>;
-    opacity: Schema.withConstructorDefault<Schema.Number>;
-    fill: Schema.withConstructorDefault<Schema.String>;
-    stroke: Schema.optionalKey<Schema.String>;
-    strokeWidth: Schema.optionalKey<Schema.Number>;
-    radius: Schema.withConstructorDefault<Schema.Number>;
-}>, {
-    readonly "~position": Entity.TraitLens<{
-        readonly x: number;
-        readonly y: number;
-        readonly opacity: number;
-        readonly fill: string;
-        readonly stroke?: string;
-        readonly strokeWidth?: number;
-        readonly radius: number;
-    }, Entity.Position>;
-    readonly "~opacity": Entity.TraitLens<{
-        readonly x: number;
-        readonly y: number;
-        readonly opacity: number;
-        readonly fill: string;
-        readonly stroke?: string;
-        readonly strokeWidth?: number;
-        readonly radius: number;
-    }, number>;
-}, {
-    readonly x?: number;
-    readonly y?: number;
-    readonly opacity?: number;
-    readonly fill?: string;
-    readonly stroke?: string;
-    readonly strokeWidth?: number;
-    readonly radius?: number;
-}> | Entity.Entity<"shapes/Group", Schema.Struct<{
-    x: Schema.withConstructorDefault<Schema.Number>;
-    y: Schema.withConstructorDefault<Schema.Number>;
-    opacity: Schema.withConstructorDefault<Schema.Number>;
-    transform: Schema.withConstructorDefault<Schema.Struct<{
-        readonly a: Schema.Number;
-        readonly b: Schema.Number;
-        readonly c: Schema.Number;
-        readonly d: Schema.Number;
-        readonly e: Schema.Number;
-        readonly f: Schema.Number;
-    }>>;
-    children: Schema.withConstructorDefault<Schema.$Array<Schema.String>>;
-}>, {
-    "~position": Entity.TraitLens<Schema.Struct.ReadonlySide<{
-        x: Schema.withConstructorDefault<Schema.Number>;
-        y: Schema.withConstructorDefault<Schema.Number>;
-        opacity: Schema.withConstructorDefault<Schema.Number>;
-        transform: Schema.withConstructorDefault<Schema.Struct<{
-            readonly a: Schema.Number;
-            readonly b: Schema.Number;
-            readonly c: Schema.Number;
-            readonly d: Schema.Number;
-            readonly e: Schema.Number;
-            readonly f: Schema.Number;
-        }>>;
-        children: Schema.withConstructorDefault<Schema.$Array<Schema.String>>;
-    }, "Type">, Entity.Position>;
-    "~opacity": Entity.TraitLens<Schema.Struct.ReadonlySide<{
-        x: Schema.withConstructorDefault<Schema.Number>;
-        y: Schema.withConstructorDefault<Schema.Number>;
-        opacity: Schema.withConstructorDefault<Schema.Number>;
-        transform: Schema.withConstructorDefault<Schema.Struct<{
-            readonly a: Schema.Number;
-            readonly b: Schema.Number;
-            readonly c: Schema.Number;
-            readonly d: Schema.Number;
-            readonly e: Schema.Number;
-            readonly f: Schema.Number;
-        }>>;
-        children: Schema.withConstructorDefault<Schema.$Array<Schema.String>>;
-    }, "Type">, number>;
-}, Omit<{
-    readonly x?: number;
-    readonly y?: number;
-    readonly opacity?: number;
-    readonly transform?: Schema.Struct.ReadonlyMakeIn<{
-        readonly a: Schema.Number;
-        readonly b: Schema.Number;
-        readonly c: Schema.Number;
-        readonly d: Schema.Number;
-        readonly e: Schema.Number;
-        readonly f: Schema.Number;
-    }>;
-    readonly children?: readonly string[];
-}, "transform"> & {
-    readonly transform?: readonly (Schema.Struct.ReadonlySide<{
-        readonly _tag: Schema.tag<"transform/matrix">;
-        readonly a: Schema.Number;
-        readonly b: Schema.Number;
-        readonly c: Schema.Number;
-        readonly d: Schema.Number;
-        readonly e: Schema.Number;
-        readonly f: Schema.Number;
-    }, "Type"> | Schema.Struct.ReadonlySide<{
-        readonly _tag: Schema.tag<"transform/scale">;
-        readonly x: Schema.Number;
-        readonly y: Schema.Number;
-    }, "Type"> | Schema.Struct.ReadonlySide<{
-        readonly _tag: Schema.tag<"transform/translate">;
-        readonly x: Schema.Number;
-        readonly y: Schema.Number;
-    }, "Type">)[];
-}>>;
+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,9 +1,14 @@
+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 { Svg } from ".";
-import * as Motion from "./Motion";
-import * as Physics from "./Physics";
-import * as Scene from "./Scene";
-import * as Shapes from "./shapes";
+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";
 // 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, {
@@ -14,35 +19,19 @@ export const scene = Scene.make(function* () {
                 x: 0,
                 y: 0,
                 radius: 14,
-                fill: "#e53170",
+                fill: Color.hex("#e53170"),
             }),
             Scene.instantiate(Shapes.Square, {
                 x: 20,
                 y: -16,
                 size: 28,
-                fill: "#a786df",
+                fill: Color.hex("#a786df"),
             }),
         ],
     });
-    const moveA = Motion.moveTo({ x: 380 }, "1.5 seconds", "easeInOutCubic");
-    const moveB = Motion.moveTo({ x: 70 }, "1.5 seconds", "easeInOutCubic");
     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"));
 });
-// const program = Effect.gen(function* () {
-// 	const renderer = yield* Svg.SvgRenderer.Context;
-// 	const sceneResult = yield* Scene.stream(scene, {
-// 	}).pipe(
-// 		Stream.runCollect,
-// 		Effect.provide(renderer)
-// 	)
-// 	console.log(sceneResult);
-// 	//  renderer.render(scene, {
-// 	// 	width: 500,
-// 	// 	height: 300,
-// 	// });
-// }).pipe(Effect.provide(shapesLayer));
-// Effect.runPromise(program);
 // 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* () {
@@ -53,7 +42,7 @@ export const staggered = Scene.make(function* () {
             x,
             y: 0,
             radius: 10,
-            fill: "#e53170",
+            fill: Color.hex("#e53170"),
         });
         // reparent the freshly-born dot from root into the stage group
         yield* Scene.appendChild(stage, circle);
@@ -61,16 +50,16 @@ export const staggered = Scene.make(function* () {
     });
     yield* Scene.stagger([dot(0), dot(25), dot(50)], Schedule.spaced("250 millis"));
 });
+// 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 svgRenderer = yield* Svg.SvgRenderer.Context;
-    // const frames = yield* Scene.stream(scene).pipe(Stream.runCollect);
-    // let n = 0;
-    // for (const frame of frames) {
-    // 	console.log(`\x1b[36mframe ${n++}\x1b[0m`);
-    // 	console.log(yield* svgRenderer.render(frame, { width: 500, height: 300 }));
-    // }
-    const frames = yield* Scene.stream(staggered).pipe(Stream.runCollect);
-    console.log(`staggered scene: ${[...frames].length} frames`);
+    const frames = yield* Scene.stream(scene, { width: 500, height: 300 }).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");
 });
-const layers = Svg.layer.pipe(Layer.provideMerge(Svg.shapesLayer));
-Effect.runPromise(movie.pipe(Effect.provide(layers)));
+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)));