effect-motion 0.4.0 → 0.6.0

package/package.json

@@ -1,61 +1,59 @@
 {
-  "name": "effect-motion",
-  "version": "0.4.0",
-  "description": "Deterministic, frame-exact motion graphics in code, composed with Effect",
-  "type": "module",
-  "license": "MIT",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/julia-script/effect-motion.git",
-    "directory": "packages/motion"
-  },
-  "homepage": "https://github.com/julia-script/effect-motion#readme",
-  "bugs": "https://github.com/julia-script/effect-motion/issues",
-  "keywords": [
-    "effect",
-    "motion",
-    "animation",
-    "motion-graphics",
-    "svg",
-    "deterministic"
-  ],
-  "exports": {
-    ".": {
-      "types": "./dist/index.d.ts",
-      "default": "./dist/index.js"
-    },
-    "./*": {
-      "types": "./dist/*.d.ts",
-      "default": "./dist/*.js"
-    }
-  },
-  "files": [
-    "dist"
-  ],
-  "publishConfig": {
-    "access": "public"
-  },
-  "peerDependencies": {
-    "effect": ">=4.0.0-beta.98"
-  },
-  "devDependencies": {
-    "@types/chroma-js": "^3.1.2",
-    "@types/node": "^26.1.1",
-    "effect": "4.0.0-beta.98",
-    "happy-dom": "^20.10.6",
-    "tsx": "^4.23.0",
-    "typescript": "^7.0.2",
-    "vitest": "^4.1.10"
-  },
-  "dependencies": {
-    "@effect/platform-node": "4.0.0-beta.98",
-    "chroma-js": "^3.2.0",
-    "@effect-motion/thorvg": "^0.2.0"
-  },
-  "scripts": {
-    "build": "tsc -p tsconfig.build.json",
-    "dev": "tsc -p tsconfig.build.json --watch --preserveWatchOutput",
-    "test": "vitest run",
-    "check": "tsc --noEmit"
-  }
-}
+	"name": "effect-motion",
+	"version": "0.6.0",
+	"description": "Deterministic, frame-exact motion graphics in code, composed with Effect",
+	"type": "module",
+	"license": "MIT",
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/julia-script/effect-motion.git",
+		"directory": "packages/motion"
+	},
+	"homepage": "https://github.com/julia-script/effect-motion#readme",
+	"bugs": "https://github.com/julia-script/effect-motion/issues",
+	"keywords": [
+		"effect",
+		"motion",
+		"animation",
+		"motion-graphics",
+		"svg",
+		"deterministic"
+	],
+	"exports": {
+		".": {
+			"types": "./dist/index.d.ts",
+			"default": "./dist/index.js"
+		},
+		"./*": {
+			"types": "./dist/*.d.ts",
+			"default": "./dist/*.js"
+		}
+	},
+	"files": [
+		"dist"
+	],
+	"scripts": {
+		"build": "tsc -p tsconfig.build.json",
+		"dev": "tsc -p tsconfig.build.json --watch --preserveWatchOutput",
+		"test": "vitest run",
+		"check": "tsc --noEmit"
+	},
+	"publishConfig": {
+		"access": "public"
+	},
+	"peerDependencies": {
+		"effect": ">=4.0.0-rc.115"
+	},
+	"devDependencies": {
+		"@types/chroma-js": "^3.1.2",
+		"@types/node": "^26.1.1",
+		"effect": "4.0.0-rc.115",
+		"happy-dom": "^20.10.6",
+		"tsx": "^4.23.0",
+		"typescript": "^7.0.2",
+		"vitest": "^4.1.10"
+	},
+	"dependencies": {
+		"chroma-js": "^3.2.0"
+	}
+}

package/dist/CameraHelpers.d.ts

@@ -1,70 +0,0 @@
-import * as Duration from "effect/Duration";
-import * as Effect from "effect/Effect";
-import type { Camera } from "./Camera.js";
-import * as Entity from "./Entity.js";
-import * as Instance from "./Instance.js";
-import * as Runner from "./Runner.js";
-import * as Timing from "./Timing.js";
-export type { CameraState } from "./Camera.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`.
- */
-export { Camera, identity } from "./Camera.js";
-type AnyInstance = Instance.Instance<any, any, any>;
-/**
- * A helper target: an Instance (position read live each frame), an Effect
- * resolving to one (resolved once at helper start, then read live), or a
- * plain position (inherently fixed — the no-entity escape hatch).
- */
-export type CameraTarget = AnyInstance | Effect.Effect<AnyInstance, never, Runner.Runner> | Partial<Entity.Position>;
-type CamData = (typeof Camera)["data"];
-type CamTraits = (typeof Camera)["traits"];
-type CamOrEffect<E = never, R = Runner.Runner> = Instance.InstanceOrEffect<"Camera", CamData, CamTraits, E, R>;
-type CamInstance = Instance.Instance<"Camera", CamData, CamTraits>;
-type CamEffect = Effect.Effect<CamInstance, never, Runner.Runner>;
-/**
- * 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 declare const lookAt: ((target: CameraTarget, duration?: Duration.Input, timing?: Timing.TimingInput, offset?: Partial<Entity.Position>) => (cam: CamOrEffect) => CamEffect) & ((cam: CamOrEffect, target: CameraTarget, duration?: Duration.Input, timing?: Timing.TimingInput, offset?: Partial<Entity.Position>) => CamEffect);
-/**
- * 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 declare const follow: ((target: CameraTarget, duration: Duration.Input, offset?: Partial<Entity.Position>) => (cam: CamOrEffect) => CamEffect) & ((cam: CamOrEffect, target: CameraTarget, duration: Duration.Input, offset?: Partial<Entity.Position>) => CamEffect);
-/**
- * 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 declare const orbitTo: ((azimuth: number, duration: Duration.Input, timing?: Timing.TimingInput) => (cam: CamOrEffect) => CamEffect) & ((cam: CamOrEffect, azimuth: number, duration: Duration.Input, timing?: Timing.TimingInput) => CamEffect);
-/** Like `orbitTo`, but from an explicit start azimuth. */
-export declare const orbit: ((from: number, to: number, duration: Duration.Input, timing?: Timing.TimingInput) => (cam: CamOrEffect) => CamEffect) & ((cam: CamOrEffect, from: number, to: number, duration: Duration.Input, timing?: Timing.TimingInput) => CamEffect);
-/**
- * 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 declare const dollyTo: ((distance: number, duration: Duration.Input, timing?: Timing.TimingInput) => (cam: CamOrEffect) => CamEffect) & ((cam: CamOrEffect, distance: number, duration: Duration.Input, timing?: Timing.TimingInput) => CamEffect);
-/** Like `dollyTo`, but from an explicit start distance. */
-export declare const dolly: ((from: number, to: number, duration: Duration.Input, timing?: Timing.TimingInput) => (cam: CamOrEffect) => CamEffect) & ((cam: CamOrEffect, from: number, to: number, duration: Duration.Input, timing?: Timing.TimingInput) => CamEffect);

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>;