effect-motion 0.2.0 → 0.3.1

package/dist/index.d.ts

@@ -1,13 +1,14 @@
-export * as Camera from "./Camera";
-export * as Entity from "./Entity";
-export * as Fonts from "./Fonts";
-export * as Instance from "./Instance";
-export * as Motion from "./Motion";
-export * as Phaser from "./Phaser";
-export * as Physics from "./Physics";
-export * as Particles from "./particles";
-export * as Renderer from "./Renderer";
-export * as Scene from "./Scene";
-export * as Shapes from "./shapes";
-export * as Svg from "./svg";
-export * as Timing from "./Timing";
+export * as Camera from "./CameraHelpers.js";
+export * as Color from "./Color.js";
+export * as Entity from "./Entity.js";
+export * as Fonts from "./Fonts.js";
+export * as Images from "./Images.js";
+export * as Instance from "./Instance.js";
+export * as Motion from "./Motion.js";
+export * as Phaser from "./Phaser.js";
+export * as Physics from "./Physics.js";
+export * as Particles from "./particles/index.js";
+export * as Renderer from "./Renderer.js";
+export * as Scene from "./Scene.js";
+export * as Shapes from "./Shapes.js";
+export * as Timing from "./Timing.js";

package/dist/index.js

@@ -1,13 +1,14 @@
-export * as Camera from "./Camera";
-export * as Entity from "./Entity";
-export * as Fonts from "./Fonts";
-export * as Instance from "./Instance";
-export * as Motion from "./Motion";
-export * as Phaser from "./Phaser";
-export * as Physics from "./Physics";
-export * as Particles from "./particles";
-export * as Renderer from "./Renderer";
-export * as Scene from "./Scene";
-export * as Shapes from "./shapes";
-export * as Svg from "./svg";
-export * as Timing from "./Timing";
+export * as Camera from "./CameraHelpers.js";
+export * as Color from "./Color.js";
+export * as Entity from "./Entity.js";
+export * as Fonts from "./Fonts.js";
+export * as Images from "./Images.js";
+export * as Instance from "./Instance.js";
+export * as Motion from "./Motion.js";
+export * as Phaser from "./Phaser.js";
+export * as Physics from "./Physics.js";
+export * as Particles from "./particles/index.js";
+export * as Renderer from "./Renderer.js";
+export * as Scene from "./Scene.js";
+export * as Shapes from "./Shapes.js";
+export * as Timing from "./Timing.js";

package/dist/particles/Particle.d.ts

@@ -1,4 +1,5 @@
-import type * as Prng from "./Prng";
+import type * as Color from "../Color.js";
+import type * as Prng from "./Prng.js";
 /**
  * A single particle's live state. Held in a flat buffer on the
  * ParticleField instance — never its own entity/instance/fiber. Position
@@ -25,7 +26,7 @@ export interface Particle {
     size: number;
     /** baseline opacity drawn at birth; the over-life curve multiplies it */
     opacity: number;
-    color: string;
+    color: Color.Color;
     rng: Prng.PrngState;
     /** false = dead slot, reusable by the next emission */
     alive: boolean;
@@ -68,7 +69,7 @@ export interface EmitterConfig {
     /** shared downward acceleration (px/sec²); not ranged */
     readonly gravity: number;
     /** colors drawn from uniformly at birth */
-    readonly palette: ReadonlyArray<string>;
+    readonly palette: ReadonlyArray<Color.Color>;
     /**
      * fill mode only — the rectangular region particles scatter across and
      * wrap around, in the field's local coordinates. The animator defaults

package/dist/particles/ParticleField.d.ts

@@ -1,8 +1,10 @@
 import * as Schema from "effect/Schema";
-import * as Entity from "../Entity";
+import * as Color from "../Color.js";
+import * as Entity from "../Entity.js";
 export declare const ParticleField: Entity.Entity<"particles/ParticleField", Schema.Struct<{
     x: Schema.withConstructorDefault<Schema.Number>;
     y: Schema.withConstructorDefault<Schema.Number>;
+    z: Schema.withConstructorDefault<Schema.Number>;
     opacity: Schema.withConstructorDefault<Schema.Number>;
     speed: Schema.withConstructorDefault<Schema.Tuple<readonly [Schema.Number, Schema.Number]>>;
     angle: Schema.withConstructorDefault<Schema.Tuple<readonly [Schema.Number, Schema.Number]>>;
@@ -10,7 +12,7 @@ export declare const ParticleField: Entity.Entity<"particles/ParticleField", Sch
     size: Schema.withConstructorDefault<Schema.Tuple<readonly [Schema.Number, Schema.Number]>>;
     opacityRange: Schema.withConstructorDefault<Schema.Tuple<readonly [Schema.Number, Schema.Number]>>;
     gravity: Schema.withConstructorDefault<Schema.Number>;
-    palette: Schema.withConstructorDefault<Schema.$Array<Schema.String>>;
+    palette: Schema.withConstructorDefault<Schema.$Array<typeof Color.Color>>;
     region: Schema.optionalKey<Schema.Struct<{
         readonly w: Schema.Number;
         readonly h: Schema.Number;
@@ -36,7 +38,7 @@ export declare const ParticleField: Entity.Entity<"particles/ParticleField", Sch
         readonly life: Schema.Number;
         readonly size: Schema.Number;
         readonly opacity: Schema.Number;
-        readonly color: Schema.String;
+        readonly color: typeof Color.Color;
         readonly rng: Schema.Number;
         readonly alive: Schema.Boolean;
         readonly wrap: Schema.Boolean;
@@ -45,6 +47,7 @@ export declare const ParticleField: Entity.Entity<"particles/ParticleField", Sch
     readonly "~position": Entity.TraitLens<{
         readonly x: number;
         readonly y: number;
+        readonly z: number;
         readonly opacity: number;
         readonly speed: readonly [number, number];
         readonly angle: readonly [number, number];
@@ -52,7 +55,7 @@ export declare const ParticleField: Entity.Entity<"particles/ParticleField", Sch
         readonly size: readonly [number, number];
         readonly opacityRange: readonly [number, number];
         readonly gravity: number;
-        readonly palette: readonly string[];
+        readonly palette: readonly Color.Color[];
         readonly region?: Schema.Struct.ReadonlySide<{
             readonly w: Schema.Number;
             readonly h: Schema.Number;
@@ -78,7 +81,7 @@ export declare const ParticleField: Entity.Entity<"particles/ParticleField", Sch
             readonly life: Schema.Number;
             readonly size: Schema.Number;
             readonly opacity: Schema.Number;
-            readonly color: Schema.String;
+            readonly color: typeof Color.Color;
             readonly rng: Schema.Number;
             readonly alive: Schema.Boolean;
             readonly wrap: Schema.Boolean;
@@ -87,6 +90,7 @@ export declare const ParticleField: Entity.Entity<"particles/ParticleField", Sch
     readonly "~opacity": Entity.TraitLens<{
         readonly x: number;
         readonly y: number;
+        readonly z: number;
         readonly opacity: number;
         readonly speed: readonly [number, number];
         readonly angle: readonly [number, number];
@@ -94,7 +98,7 @@ export declare const ParticleField: Entity.Entity<"particles/ParticleField", Sch
         readonly size: readonly [number, number];
         readonly opacityRange: readonly [number, number];
         readonly gravity: number;
-        readonly palette: readonly string[];
+        readonly palette: readonly Color.Color[];
         readonly region?: Schema.Struct.ReadonlySide<{
             readonly w: Schema.Number;
             readonly h: Schema.Number;
@@ -120,51 +124,10 @@ export declare const ParticleField: Entity.Entity<"particles/ParticleField", Sch
             readonly life: Schema.Number;
             readonly size: Schema.Number;
             readonly opacity: Schema.Number;
-            readonly color: Schema.String;
+            readonly color: typeof Color.Color;
             readonly rng: Schema.Number;
             readonly alive: Schema.Boolean;
             readonly wrap: Schema.Boolean;
         }, "Type">[];
     }, number>;
-}, {
-    readonly x?: number;
-    readonly y?: number;
-    readonly opacity?: number;
-    readonly speed?: readonly [number, number];
-    readonly angle?: readonly [number, number];
-    readonly life?: readonly [number, number];
-    readonly size?: readonly [number, number];
-    readonly opacityRange?: readonly [number, number];
-    readonly gravity?: number;
-    readonly palette?: readonly string[];
-    readonly region?: Schema.Struct.ReadonlyMakeIn<{
-        readonly w: Schema.Number;
-        readonly h: Schema.Number;
-    }>;
-    readonly drift?: readonly [number, number];
-    readonly sizeOverLife?: {
-        readonly from: number;
-        readonly to: number;
-        readonly ease?: string;
-    };
-    readonly opacityOverLife?: {
-        readonly from: number;
-        readonly to: number;
-        readonly ease?: string;
-    };
-    readonly capacity?: number;
-    readonly buffer?: readonly Schema.Struct.ReadonlyMakeIn<{
-        readonly x: Schema.Number;
-        readonly y: Schema.Number;
-        readonly vx: Schema.Number;
-        readonly vy: Schema.Number;
-        readonly age: Schema.Number;
-        readonly life: Schema.Number;
-        readonly size: Schema.Number;
-        readonly opacity: Schema.Number;
-        readonly color: Schema.String;
-        readonly rng: Schema.Number;
-        readonly alive: Schema.Boolean;
-        readonly wrap: Schema.Boolean;
-    }>[];
 }>;

package/dist/particles/ParticleField.js

@@ -1,7 +1,8 @@
 import * as Effect from "effect/Effect";
 import * as Schema from "effect/Schema";
-import * as Entity from "../Entity";
-import * as Shape2D from "../shapes/Shape2D";
+import * as Color from "../Color.js";
+import * as Entity from "../Entity.js";
+import * as Shape2D from "../shapes/Shape2D.js";
 /**
  * A ParticleField is ONE entity/instance backing many particles. Its data
  * holds the emitter config plus a fixed-capacity buffer of live particle
@@ -31,7 +32,7 @@ const ParticleSchema = Schema.Struct({
     life: Schema.Number,
     size: Schema.Number,
     opacity: Schema.Number,
-    color: Schema.String,
+    color: Color.Color,
     rng: Schema.Number,
     alive: Schema.Boolean,
     wrap: Schema.Boolean,
@@ -53,7 +54,7 @@ export const ParticleField = Entity.make("particles/ParticleField", {
     // `opacity` (the ~opacity trait above, which fades the whole field).
     opacityRange: defaultedRange([1, 1]),
     gravity: Shape2D.defaultedNumber(0),
-    palette: Schema.Array(Schema.String).pipe(Schema.withConstructorDefault(Effect.sync(() => ["white"]))),
+    palette: Schema.Array(Color.Color).pipe(Schema.withConstructorDefault(Effect.sync(() => [Color.white]))),
     // fill mode: the region particles spread across and wrap within
     // (defaults to the frame in `simulate`) and their drift speed range
     region: Schema.optionalKey(Schema.Struct({ w: Schema.Number, h: Schema.Number })),

package/dist/particles/constructors.d.ts

@@ -1,8 +1,9 @@
 import type * as Effect from "effect/Effect";
-import type * as Instance from "../Instance";
-import type * as Runner from "../Runner";
-import type { Range } from "./Particle";
-import { ParticleField } from "./ParticleField";
+import type * as Color from "../Color.js";
+import type * as Instance from "../Instance.js";
+import type * as Runner from "../Runner.js";
+import type { Range } from "./Particle.js";
+import { ParticleField } from "./ParticleField.js";
 /**
  * Two typed front doors onto the SAME `ParticleField` entity. The field's
  * emission model is chosen at `simulate`, but the properties that make sense
@@ -38,7 +39,7 @@ interface CommonInput {
     /** per-particle birth opacity range (0..1); over-life curve multiplies it */
     readonly opacityRange?: Range;
     /** colors drawn from uniformly at birth */
-    readonly palette?: ReadonlyArray<string>;
+    readonly palette?: ReadonlyArray<Color.Color>;
     /** shared downward acceleration (px/sec²) */
     readonly gravity?: number;
     readonly sizeOverLife?: OverLifeInput;
@@ -69,10 +70,10 @@ export interface FieldInput extends CommonInput {
  * Create a source emitter field. Simulate it with `{ burst: n }` (all at
  * once) or `{ rate: n }` (a continuous stream).
  */
-export declare const emitter: (props: EmitterInput) => Effect.Effect<EmitterField, unknown, typeof ParticleField | Runner.Runner>;
+export declare const emitter: (props: EmitterInput) => Effect.Effect<EmitterField, never, Runner.Runner>;
 /**
  * Create a floating field: particles spread evenly across the region,
  * drifting and wrapping at the edges. Simulate it with `{ fill: n }`.
  */
-export declare const field: (props: FieldInput) => Effect.Effect<FloatField, unknown, typeof ParticleField | Runner.Runner>;
+export declare const field: (props: FieldInput) => Effect.Effect<FloatField, never, Runner.Runner>;
 export {};

package/dist/particles/constructors.js

@@ -1,5 +1,5 @@
-import * as Scene from "../Scene";
-import { ParticleField } from "./ParticleField";
+import * as Scene from "../Scene.js";
+import { ParticleField } from "./ParticleField.js";
 /**
  * Create a source emitter field. Simulate it with `{ burst: n }` (all at
  * once) or `{ rate: n }` (a continuous stream).

package/dist/particles/index.d.ts

@@ -1,6 +1,5 @@
-export * from "./constructors";
-export * from "./Particle";
-export * from "./ParticleField";
-export * as Prng from "./Prng";
-export { particleField as render } from "./render";
-export * from "./simulate";
+export * from "./constructors.js";
+export * from "./Particle.js";
+export * from "./ParticleField.js";
+export * as Prng from "./Prng.js";
+export * from "./simulate.js";

package/dist/particles/index.js

@@ -1,6 +1,5 @@
-export * from "./constructors";
-export * from "./Particle";
-export * from "./ParticleField";
-export * as Prng from "./Prng";
-export { particleField as render } from "./render";
-export * from "./simulate";
+export * from "./constructors.js";
+export * from "./Particle.js";
+export * from "./ParticleField.js";
+export * as Prng from "./Prng.js";
+export * from "./simulate.js";

package/dist/particles/overLife.d.ts

@@ -1,4 +1,4 @@
-import type { OverLife, Particle } from "./Particle";
+import type { OverLife, Particle } from "./Particle.js";
 /**
  * Evaluate an over-life curve at a particle's current age. Purely a
  * function of `age/life` (clamped to [0,1]) eased by the configured timing

package/dist/particles/overLife.js

@@ -1,4 +1,4 @@
-import * as Timing from "../Timing";
+import * as Timing from "../Timing.js";
 /**
  * Evaluate an over-life curve at a particle's current age. Purely a
  * function of `age/life` (clamped to [0,1]) eased by the configured timing

package/dist/particles/simulate.d.ts

@@ -1,7 +1,7 @@
 import type * as Duration from "effect/Duration";
 import * as Effect from "effect/Effect";
-import * as Runner from "../Runner";
-import type { EmitterField, FloatField } from "./constructors";
+import * as Runner from "../Runner.js";
+import type { EmitterField, FloatField } from "./constructors.js";
 /**
  * Emission model for a single `simulate` call:
  * - `{ burst: n }` — birth `n` particles on the FIRST frame, then none

package/dist/particles/simulate.js

@@ -1,12 +1,12 @@
 import * as Effect from "effect/Effect";
 import { dual } from "effect/Function";
 import * as Random from "effect/Random";
-import * as Instance from "../Instance";
-import * as Runner from "../Runner";
-import * as Scene from "../Scene";
-import * as Time from "../Time";
-import * as Prng from "./Prng";
-import { step } from "./step";
+import * as Instance from "../Instance.js";
+import * as Runner from "../Runner.js";
+import * as Scene from "../Scene.js";
+import * as Time from "../Time.js";
+import * as Prng from "./Prng.js";
+import { step } from "./step.js";
 // how many particles to birth on frame `i` (1-based) of this call
 const birthsForFrame = (emission, i, fps) => {
     if ("burst" in emission) {

package/dist/particles/step.d.ts

@@ -1,5 +1,5 @@
-import type { EmitterConfig, Particle } from "./Particle";
-import * as Prng from "./Prng";
+import type { EmitterConfig, Particle } from "./Particle.js";
+import * as Prng from "./Prng.js";
 /** birth one particle from a seed + config (fixed draw order). */
 export declare const birth: (seed: Prng.PrngState, config: EmitterConfig) => Particle;
 /**

package/dist/particles/step.js

@@ -1,4 +1,6 @@
-import * as Prng from "./Prng";
+/** biome-ignore-all lint/style/useConst: let declaration is necessary for destructuring assignment */
+import * as Color from "../Color.js";
+import * as Prng from "./Prng.js";
 /**
  * The per-frame simulation as a PURE fold: `(buffer, dt, births) → buffer`.
  * No external entropy — the only randomness is each particle's own carried
@@ -41,7 +43,7 @@ export const birth = (seed, config) => {
     [rng, opacity] = drawOpacity(rng, config);
     // angle 0 = straight up; clockwise-positive
     const rad = angle * DEG;
-    const color = config.palette[Math.min(config.palette.length - 1, Math.floor(colorPick))] ?? "white";
+    const color = config.palette[Math.min(config.palette.length - 1, Math.floor(colorPick))] ?? Color.white;
     return {
         x: config.x,
         y: config.y,
@@ -85,7 +87,7 @@ export const birthFill = (seed, config) => {
     let opacity;
     [rng, opacity] = drawOpacity(rng, config);
     const rad = dir * DEG;
-    const color = config.palette[Math.min(config.palette.length - 1, Math.floor(colorPick))] ?? "white";
+    const color = config.palette[Math.min(config.palette.length - 1, Math.floor(colorPick))] ?? Color.white;
     return {
         // scattered across the region, offset by the field's own origin
         x: config.x + px,

package/dist/render/dof.d.ts

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

@@ -0,0 +1,37 @@
+/**
+ * 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);

package/dist/render/paint.d.ts

@@ -0,0 +1,30 @@
+import type { OwnedPaint, ThorvgException } from "@effect-motion/thorvg";
+import * as Tvg from "@effect-motion/thorvg";
+import * as Effect from "effect/Effect";
+import type * as Scope from "effect/Scope";
+import * as Color from "../Color.js";
+import type { PaintProjection } from "../Renderer.js";
+/**
+ * Shared paint helpers: style application, projection, and the attach step
+ * every leaf paint function runs. Keeping the ThorVG call sequence in one
+ * place means each shape's paint function is just "make geometry, then
+ * `finishPaint`".
+ */
+/** The style fields a filled/stroked shape carries in its data. */
+export interface StyleData {
+    readonly fill?: Color.Color;
+    readonly stroke?: Color.Color;
+    readonly strokeWidth?: number;
+    readonly opacity: number;
+}
+/** Apply fill/stroke/opacity from shape data onto a ThorVG shape paint. */
+export declare const applyStyle: (shape: OwnedPaint, data: StyleData) => Effect.Effect<void, ThorvgException, Tvg.ThorvgWasm>;
+/**
+ * Apply the billboard projection affine to a shape, then add it to the scene.
+ * The identity affine (resting camera, z=0) is skipped so plain-2D scenes
+ * issue the minimal draw calls. Ownership transfers to the scene on add.
+ *
+ * Callers must NOT have applied any translate/rotate/scale to the shape —
+ * `setTransform` is the single, final transform (design D3).
+ */
+export declare const finishPaint: (shape: OwnedPaint, scene: OwnedPaint, projection: PaintProjection) => Effect.Effect<void, ThorvgException, Tvg.ThorvgWasm | Scope.Scope>;

package/dist/render/paint.js

@@ -0,0 +1,36 @@
+import * as Tvg from "@effect-motion/thorvg";
+import * as Effect from "effect/Effect";
+import * as Color from "../Color.js";
+/** Apply fill/stroke/opacity from shape data onto a ThorVG shape paint. */
+export const applyStyle = (shape, data) => Effect.gen(function* () {
+    if (data.fill !== undefined) {
+        const { r, g, b, a } = Color.bytes(data.fill);
+        yield* Tvg.Shape.setFillColor(shape, r, g, b, a);
+    }
+    if (data.stroke !== undefined) {
+        const { r, g, b, a } = Color.bytes(data.stroke);
+        yield* Tvg.Shape.setStrokeColor(shape, r, g, b, a);
+    }
+    if (data.strokeWidth !== undefined) {
+        yield* Tvg.Shape.setStrokeWidth(shape, data.strokeWidth);
+    }
+    // opacity 1 is the ThorVG default; only set when it changes something
+    if (data.opacity !== 1) {
+        yield* Tvg.Paint.setOpacity(shape, Math.round(data.opacity * 255));
+    }
+});
+const isIdentity = (m) => m.a === 1 && m.b === 0 && m.c === 0 && m.d === 1 && m.e === 0 && m.f === 0;
+/**
+ * Apply the billboard projection affine to a shape, then add it to the scene.
+ * The identity affine (resting camera, z=0) is skipped so plain-2D scenes
+ * issue the minimal draw calls. Ownership transfers to the scene on add.
+ *
+ * Callers must NOT have applied any translate/rotate/scale to the shape —
+ * `setTransform` is the single, final transform (design D3).
+ */
+export const finishPaint = (shape, scene, projection) => Effect.gen(function* () {
+    if (!isIdentity(projection.screen)) {
+        yield* Tvg.Paint.setTransform(shape, projection.screen);
+    }
+    yield* Tvg.Scene.add(scene, shape);
+});

package/dist/render/shapes.d.ts

@@ -0,0 +1,42 @@
+import { ParticleField } from "../particles/ParticleField.js";
+import type { PaintFunction, PaintFunctions } from "../Renderer.js";
+import * as Circle from "../shapes/Circle.js";
+import * as Ellipse from "../shapes/Ellipse.js";
+import * as Group from "../shapes/Group.js";
+import * as Hud from "../shapes/Hud.js";
+import * as Image from "../shapes/Image.js";
+import * as Line from "../shapes/Line.js";
+import * as Path from "../shapes/Path.js";
+import * as Rect from "../shapes/Rect.js";
+import * as Square from "../shapes/Square.js";
+import * as Text from "../shapes/Text.js";
+/**
+ * ThorVG paint functions for the built-in shapes — this file is the coverage
+ * manifest: `paints` is typed `PaintFunctions<...>`, so a built-in missing a
+ * paint function is a type error, not a runtime surprise.
+ */
+export declare const circle: PaintFunction<typeof Circle.Circle>;
+export declare const rect: PaintFunction<typeof Rect.Rect>;
+export declare const square: PaintFunction<typeof Square.Square>;
+export declare const ellipse: PaintFunction<typeof Ellipse.Ellipse>;
+export declare const line: PaintFunction<typeof Line.Line>;
+export declare const path: PaintFunction<typeof Path.Path>;
+export declare const group: PaintFunction<typeof Group.Group>;
+export declare const hud: PaintFunction<typeof Hud.Hud>;
+export declare const image: PaintFunction<typeof Image.Image>;
+export declare const text: PaintFunction<typeof Text.Text>;
+/**
+ * ParticleField: live particles batched into one shape PER (color, opacity)
+ * bucket — ThorVG fills a shape uniformly, so particles that share a color and
+ * (quantized) over-life opacity are appended into the same shape and filled
+ * once. Sized/faded by the over-life curves; dead slots emit nothing.
+ * ponytail: one shape per distinct (color, opacity-bucket) — far fewer than one
+ * per particle, but a fully instanced path is the upgrade if this is a wall.
+ */
+export declare const particleField: PaintFunction<typeof ParticleField>;
+/**
+ * The exhaustive paint-function map for every built-in entity. Typed
+ * `PaintFunctions<...>` so a missing built-in fails to type-check (the old
+ * "coverage manifest" guarantee, without a Context registry).
+ */
+export declare const builtinPaints: PaintFunctions<typeof Circle.Circle | typeof Rect.Rect | typeof Square.Square | typeof Ellipse.Ellipse | typeof Line.Line | typeof Path.Path | typeof Group.Group | typeof Hud.Hud | typeof Text.Text | typeof Image.Image | typeof ParticleField>;