effect-motion 0.2.0

package/dist/particles/step.js

@@ -0,0 +1,167 @@
+import * as Prng from "./Prng";
+/**
+ * The per-frame simulation as a PURE fold: `(buffer, dt, births) → buffer`.
+ * No external entropy — the only randomness is each particle's own carried
+ * PRNG state, seeded at birth. `births` is the list of seeds for particles
+ * to birth THIS frame (how many, and their seeds, is decided by the caller
+ * — burst vs. stream — and drawn from the scene's seeded Random there, so
+ * this function stays pure and testable).
+ *
+ * Order per frame: integrate + age live particles, kill expired, then emit
+ * new ones into free slots (overwriting oldest when full).
+ *
+ * DETERMINISM: the draw order at birth is FIXED and part of the contract —
+ * angle, speed, life, size, color, in that sequence. Changing it shifts
+ * seeded output and is a breaking change.
+ */
+const DEG = Math.PI / 180;
+// positive modulo — JS `%` keeps the sign of the dividend, which would let a
+// particle drifting off the left edge land at a negative coordinate
+const mod = (n, m) => ((n % m) + m) % m;
+// sample a uniform range from a particle's own rng, threading state
+const draw = (rng, [min, max]) => Prng.nextBetween(rng, min, max);
+// draw the baseline opacity — LAST in the draw order for both births, so
+// adding it didn't shift earlier draws. Absent `opacity` config → 1 (and no
+// draw is consumed, keeping opacity-less scenes byte-identical).
+const drawOpacity = (rng, config) => config.opacity ? draw(rng, config.opacity) : [rng, 1];
+/** birth one particle from a seed + config (fixed draw order). */
+export const birth = (seed, config) => {
+    let rng = seed;
+    let angle;
+    let speed;
+    let life;
+    let size;
+    let colorPick;
+    [rng, angle] = draw(rng, config.angle);
+    [rng, speed] = draw(rng, config.speed);
+    [rng, life] = draw(rng, config.life);
+    [rng, size] = draw(rng, config.size);
+    [rng, colorPick] = Prng.nextBetween(rng, 0, config.palette.length);
+    let opacity;
+    [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";
+    return {
+        x: config.x,
+        y: config.y,
+        vx: Math.sin(rad) * speed,
+        vy: -Math.cos(rad) * speed,
+        age: 0,
+        life,
+        size,
+        opacity,
+        color,
+        rng,
+        alive: true,
+        wrap: false,
+    };
+};
+/**
+ * Birth a `fill`-mode particle: scattered at a random point in the region
+ * (not at the origin), given a small isotropic drift velocity (not a
+ * launch), and marked to wrap forever instead of aging out. This is what
+ * makes an evenly-spread floating field rather than a fountain. Same fixed
+ * draw order — position x, position y, drift direction, drift speed, size,
+ * color — so seeded output is stable.
+ */
+export const birthFill = (seed, config) => {
+    const w = config.region?.w ?? 0;
+    const h = config.region?.h ?? 0;
+    const drift = config.drift ?? [0, 0];
+    let rng = seed;
+    let px;
+    let py;
+    let dir;
+    let dspeed;
+    let size;
+    let colorPick;
+    [rng, px] = Prng.nextBetween(rng, 0, w);
+    [rng, py] = Prng.nextBetween(rng, 0, h);
+    [rng, dir] = Prng.nextBetween(rng, 0, 360);
+    [rng, dspeed] = draw(rng, drift);
+    [rng, size] = draw(rng, config.size);
+    [rng, colorPick] = Prng.nextBetween(rng, 0, config.palette.length);
+    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";
+    return {
+        // scattered across the region, offset by the field's own origin
+        x: config.x + px,
+        y: config.y + py,
+        vx: Math.cos(rad) * dspeed,
+        vy: Math.sin(rad) * dspeed,
+        age: 0,
+        life: Number.POSITIVE_INFINITY,
+        size,
+        opacity,
+        color,
+        rng,
+        alive: true,
+        wrap: true,
+    };
+};
+/**
+ * Advance the buffer one frame. `dt` is seconds per frame. `seeds` are the
+ * per-particle seeds to birth this frame (already drawn upstream). The
+ * buffer is mutated in place and returned — it is the field's private
+ * representation, owned by one instance, so in-place is safe and flat.
+ * ponytail: array-of-structs, mutated in place. SoA + typed arrays is the
+ * upgrade path if a capacity-target benchmark shows this is the wall.
+ */
+export const step = (buffer, capacity, dt, seeds, config, mode = "emit") => {
+    const spawn = mode === "fill" ? birthFill : birth;
+    // integrate live particles. Emitter particles age and die; fill (wrap)
+    // particles never age and instead wrap around the region's edges, so an
+    // evenly-spread field stays populated forever.
+    const rw = config.region?.w ?? 0;
+    const rh = config.region?.h ?? 0;
+    for (const p of buffer) {
+        if (!p.alive) {
+            continue;
+        }
+        p.vy += config.gravity * dt;
+        p.x += p.vx * dt;
+        p.y += p.vy * dt;
+        if (p.wrap) {
+            // wrap within the region, which sits at the field origin (config.x/y)
+            if (rw > 0) {
+                p.x = config.x + mod(p.x - config.x, rw);
+            }
+            if (rh > 0) {
+                p.y = config.y + mod(p.y - config.y, rh);
+            }
+            continue;
+        }
+        p.age += dt;
+        if (p.age >= p.life) {
+            p.alive = false;
+        }
+    }
+    // emit into free slots; when none, overwrite the oldest live particle
+    for (const seed of seeds) {
+        const fresh = spawn(seed, config);
+        const deadIdx = buffer.findIndex((p) => !p.alive);
+        if (deadIdx !== -1) {
+            buffer[deadIdx] = fresh;
+        }
+        else if (buffer.length < capacity) {
+            buffer.push(fresh);
+        }
+        else {
+            // full and all alive: overwrite the oldest (highest age)
+            let oldest = 0;
+            for (let i = 1; i < buffer.length; i++) {
+                // biome-ignore lint/style/noNonNullAssertion: indices are in range
+                if (buffer[i].age > buffer[oldest].age) {
+                    oldest = i;
+                }
+            }
+            buffer[oldest] = fresh;
+        }
+    }
+    return buffer;
+};
+/** count of currently-live particles */
+export const liveCount = (buffer) => buffer.reduce((n, p) => (p.alive ? n + 1 : n), 0);

package/dist/shapes/Circle.d.ts

@@ -0,0 +1,37 @@
+import * as Entity from "../Entity";
+export declare const Circle: Entity.Entity<"shapes/Circle", import("effect/Schema").Struct<{
+    x: import("effect/Schema").withConstructorDefault<import("effect/Schema").Number>;
+    y: import("effect/Schema").withConstructorDefault<import("effect/Schema").Number>;
+    opacity: import("effect/Schema").withConstructorDefault<import("effect/Schema").Number>;
+    fill: import("effect/Schema").withConstructorDefault<import("effect/Schema").String>;
+    stroke: import("effect/Schema").optionalKey<import("effect/Schema").String>;
+    strokeWidth: import("effect/Schema").optionalKey<import("effect/Schema").Number>;
+    radius: import("effect/Schema").withConstructorDefault<import("effect/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;
+}>;

package/dist/shapes/Circle.js

@@ -0,0 +1,9 @@
+import * as Entity from "../Entity";
+import * as Shape2D from "./Shape2D";
+export const Circle = Entity.make("shapes/Circle", {
+    ...Shape2D.filled,
+    radius: Shape2D.defaultedNumber(10),
+}, {
+    "~position": Shape2D.positionLens(),
+    "~opacity": Shape2D.opacityLens(),
+});

package/dist/shapes/Ellipse.d.ts

@@ -0,0 +1,41 @@
+import * as Entity from "../Entity";
+export declare const Ellipse: Entity.Entity<"shapes/Ellipse", import("effect/Schema").Struct<{
+    x: import("effect/Schema").withConstructorDefault<import("effect/Schema").Number>;
+    y: import("effect/Schema").withConstructorDefault<import("effect/Schema").Number>;
+    opacity: import("effect/Schema").withConstructorDefault<import("effect/Schema").Number>;
+    fill: import("effect/Schema").withConstructorDefault<import("effect/Schema").String>;
+    stroke: import("effect/Schema").optionalKey<import("effect/Schema").String>;
+    strokeWidth: import("effect/Schema").optionalKey<import("effect/Schema").Number>;
+    rx: import("effect/Schema").withConstructorDefault<import("effect/Schema").Number>;
+    ry: import("effect/Schema").withConstructorDefault<import("effect/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 rx: number;
+        readonly ry: 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 rx: number;
+        readonly ry: number;
+    }, number>;
+}, {
+    readonly x?: number;
+    readonly y?: number;
+    readonly opacity?: number;
+    readonly fill?: string;
+    readonly stroke?: string;
+    readonly strokeWidth?: number;
+    readonly rx?: number;
+    readonly ry?: number;
+}>;

package/dist/shapes/Ellipse.js

@@ -0,0 +1,10 @@
+import * as Entity from "../Entity";
+import * as Shape2D from "./Shape2D";
+export const Ellipse = Entity.make("shapes/Ellipse", {
+    ...Shape2D.filled,
+    rx: Shape2D.defaultedNumber(20),
+    ry: Shape2D.defaultedNumber(10),
+}, {
+    "~position": Shape2D.positionLens(),
+    "~opacity": Shape2D.opacityLens(),
+});

package/dist/shapes/Group.d.ts

@@ -0,0 +1,150 @@
+import * as Schema from "effect/Schema";
+import * as Entity from "../Entity";
+export declare const TransformMatrix: 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;
+}>;
+export type TransformMatrix = typeof TransformMatrix.Type;
+export declare const identityTransform: {
+    a: number;
+    b: number;
+    c: number;
+    d: number;
+    e: number;
+    f: number;
+};
+export declare const multiplyTransforms: (left: TransformMatrix, right: TransformMatrix) => TransformMatrix;
+export declare const TransformOperation: Schema.TaggedUnion<{
+    readonly "transform/matrix": Schema.TaggedStruct<"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;
+    }>;
+    readonly "transform/scale": Schema.TaggedStruct<"transform/scale", {
+        readonly x: Schema.Number;
+        readonly y: Schema.Number;
+    }>;
+    readonly "transform/translate": Schema.TaggedStruct<"transform/translate", {
+        readonly x: Schema.Number;
+        readonly y: Schema.Number;
+    }>;
+}>;
+declare const TransformOperations: Schema.$Array<Schema.TaggedUnion<{
+    readonly "transform/matrix": Schema.TaggedStruct<"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;
+    }>;
+    readonly "transform/scale": Schema.TaggedStruct<"transform/scale", {
+        readonly x: Schema.Number;
+        readonly y: Schema.Number;
+    }>;
+    readonly "transform/translate": Schema.TaggedStruct<"transform/translate", {
+        readonly x: Schema.Number;
+        readonly y: Schema.Number;
+    }>;
+}>>;
+export declare const Transform: Schema.decodeTo<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;
+}>, Schema.$Array<Schema.TaggedUnion<{
+    readonly "transform/matrix": Schema.TaggedStruct<"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;
+    }>;
+    readonly "transform/scale": Schema.TaggedStruct<"transform/scale", {
+        readonly x: Schema.Number;
+        readonly y: Schema.Number;
+    }>;
+    readonly "transform/translate": Schema.TaggedStruct<"transform/translate", {
+        readonly x: Schema.Number;
+        readonly y: Schema.Number;
+    }>;
+}>>, never, never>;
+declare const fields: {
+    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 StoredInput = Schema.Struct<typeof fields>["~type.make.in"];
+type GroupInput = Omit<StoredInput, "transform"> & {
+    readonly transform?: typeof TransformOperations.Type;
+};
+export declare const Group: 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>;
+}, GroupInput>;
+/** The group's x/y position composed outside its normalized local transform. */
+export declare const resolvedTransform: (data: {
+    readonly x: number;
+    readonly y: number;
+    readonly transform: TransformMatrix;
+}) => TransformMatrix;
+export declare const isIdentityTransform: (matrix: TransformMatrix) => boolean;
+export {};

package/dist/shapes/Group.js

@@ -0,0 +1,82 @@
+import * as Effect from "effect/Effect";
+import * as Schema from "effect/Schema";
+import * as SchemaGetter from "effect/SchemaGetter";
+import * as Entity from "../Entity";
+import * as Shape2D from "./Shape2D";
+export const TransformMatrix = Schema.Struct({
+    a: Schema.Number,
+    b: Schema.Number,
+    c: Schema.Number,
+    d: Schema.Number,
+    e: Schema.Number,
+    f: Schema.Number,
+});
+export const identityTransform = {
+    a: 1,
+    b: 0,
+    c: 0,
+    d: 1,
+    e: 0,
+    f: 0,
+};
+export const multiplyTransforms = (left, right) => ({
+    a: left.a * right.a + left.c * right.b,
+    b: left.b * right.a + left.d * right.b,
+    c: left.a * right.c + left.c * right.d,
+    d: left.b * right.c + left.d * right.d,
+    e: left.a * right.e + left.c * right.f + left.e,
+    f: left.b * right.e + left.d * right.f + left.f,
+});
+export const TransformOperation = Schema.TaggedUnion({
+    "transform/translate": { x: Schema.Number, y: Schema.Number },
+    "transform/scale": { x: Schema.Number, y: Schema.Number },
+    "transform/matrix": TransformMatrix.fields,
+});
+const TransformOperations = Schema.Array(TransformOperation);
+const operationMatrix = (operation) => TransformOperation.match(operation, {
+    "transform/translate": ({ x, y }) => ({
+        ...identityTransform,
+        e: x,
+        f: y,
+    }),
+    "transform/scale": ({ x, y }) => ({
+        ...identityTransform,
+        a: x,
+        d: y,
+    }),
+    "transform/matrix": ({ a, b, c, d, e, f }) => ({ a, b, c, d, e, f }),
+});
+export const Transform = TransformOperations.pipe(Schema.decodeTo(TransformMatrix, {
+    // Post-multiplication preserves the authored transform-list order.
+    decode: SchemaGetter.transform((operations) => operations.reduce((matrix, operation) => multiplyTransforms(matrix, operationMatrix(operation)), identityTransform)),
+    encode: SchemaGetter.transform((matrix) => [
+        { _tag: "transform/matrix", ...matrix },
+    ]),
+}));
+const fields = {
+    ...Shape2D.position,
+    ...Shape2D.opacity,
+    transform: TransformMatrix.pipe(Schema.withConstructorDefault(Effect.succeed(identityTransform))),
+    children: Schema.Array(Schema.String).pipe(Schema.withConstructorDefault(Effect.sync(() => []))),
+};
+const decodeTransform = Schema.decodeUnknownSync(Transform);
+const normalizeInput = (input) => Array.isArray(input.transform)
+    ? { ...input, transform: decodeTransform(input.transform) }
+    : input;
+// A container: positions and structures its children, paints nothing.
+// Transform operations are normalized once to a target-independent affine
+// matrix; render targets never interpret the operation list.
+const traits = {
+    // moving a group moves the subtree (children keep local coordinates)
+    "~position": Shape2D.positionLens(),
+    "~opacity": Shape2D.opacityLens(),
+};
+export const Group = Entity.make("shapes/Group", fields, traits, { normalize: normalizeInput });
+/** The group's x/y position composed outside its normalized local transform. */
+export const resolvedTransform = (data) => multiplyTransforms({ ...identityTransform, e: data.x, f: data.y }, data.transform);
+export const isIdentityTransform = (matrix) => matrix.a === 1 &&
+    matrix.b === 0 &&
+    matrix.c === 0 &&
+    matrix.d === 1 &&
+    matrix.e === 0 &&
+    matrix.f === 0;

package/dist/shapes/Layer.d.ts

@@ -0,0 +1,9 @@
+import * as Schema from "effect/Schema";
+import * as Entity from "../Entity";
+export declare const Layer: Entity.Entity<"shapes/Layer", Schema.Struct<{
+    depth: Schema.withConstructorDefault<Schema.Number>;
+    children: Schema.withConstructorDefault<Schema.$Array<Schema.String>>;
+}>, {}, {
+    readonly depth?: number;
+    readonly children?: readonly string[];
+}>;

package/dist/shapes/Layer.js

@@ -0,0 +1,23 @@
+import * as Effect from "effect/Effect";
+import * as Schema from "effect/Schema";
+import * as Entity from "../Entity";
+import * as Shape2D from "./Shape2D";
+// A parallax layer: a container that holds children at a camera `depth`, and
+// nothing else. Unlike Group it carries NO position or opacity of its own —
+// `depth` is the only field, so it can never collide with the transform
+// semantics a Group is expected to grow (position now, rotation/scale later),
+// and a future guard can restrict Layers without touching Group.
+//
+// `depth` is the fraction of the camera this layer feels (pan AND zoom): 1 =
+// full camera (default), 0 = pinned to the screen (a HUD), between = parallax.
+// The sink reads it off each top-level layer (see svg/camera.ts).
+//
+// ponytail: a Layer nested inside another Layer is undefined behavior — the
+// point of a dedicated entity is to leave room for a rule here, but the
+// semantics ("a depth inside a depth"?) aren't decided yet, so no guard ships.
+// Add one in Runner.instantiate (dispatch on entity.name === Layer.name) once
+// nesting semantics are settled.
+export const Layer = Entity.make("shapes/Layer", {
+    depth: Shape2D.defaultedNumber(1),
+    children: Schema.Array(Schema.String).pipe(Schema.withConstructorDefault(Effect.sync(() => []))),
+});

package/dist/shapes/Line.d.ts

@@ -0,0 +1,47 @@
+import * as Schema from "effect/Schema";
+import * as Entity from "../Entity";
+declare const fields: {
+    x: Schema.withConstructorDefault<Schema.Number>;
+    y: Schema.withConstructorDefault<Schema.Number>;
+    opacity: Schema.withConstructorDefault<Schema.Number>;
+    x2: Schema.withConstructorDefault<Schema.Number>;
+    y2: Schema.withConstructorDefault<Schema.Number>;
+    stroke: Schema.withConstructorDefault<Schema.String>;
+    strokeWidth: Schema.withConstructorDefault<Schema.Number>;
+};
+type LineData = Schema.Struct<typeof fields>["Type"];
+export declare const Line: Entity.Entity<"shapes/Line", Schema.Struct<{
+    x: Schema.withConstructorDefault<Schema.Number>;
+    y: Schema.withConstructorDefault<Schema.Number>;
+    opacity: Schema.withConstructorDefault<Schema.Number>;
+    x2: Schema.withConstructorDefault<Schema.Number>;
+    y2: Schema.withConstructorDefault<Schema.Number>;
+    stroke: Schema.withConstructorDefault<Schema.String>;
+    strokeWidth: Schema.withConstructorDefault<Schema.Number>;
+}>, {
+    readonly "~position": {
+        get: (data: LineData) => {
+            x: number;
+            y: number;
+        };
+        set: (data: LineData, value: Entity.Position) => LineData;
+    };
+    readonly "~opacity": Entity.TraitLens<Schema.Struct.ReadonlySide<{
+        x: Schema.withConstructorDefault<Schema.Number>;
+        y: Schema.withConstructorDefault<Schema.Number>;
+        opacity: Schema.withConstructorDefault<Schema.Number>;
+        x2: Schema.withConstructorDefault<Schema.Number>;
+        y2: Schema.withConstructorDefault<Schema.Number>;
+        stroke: Schema.withConstructorDefault<Schema.String>;
+        strokeWidth: Schema.withConstructorDefault<Schema.Number>;
+    }, "Type">, number>;
+}, {
+    readonly x?: number;
+    readonly y?: number;
+    readonly opacity?: number;
+    readonly x2?: number;
+    readonly y2?: number;
+    readonly stroke?: string;
+    readonly strokeWidth?: number;
+}>;
+export {};

package/dist/shapes/Line.js

@@ -0,0 +1,30 @@
+import * as Effect from "effect/Effect";
+import * as Schema from "effect/Schema";
+import * as Entity from "../Entity";
+import * as Shape2D from "./Shape2D";
+// No fill — a line is unfillable, so unlike the filled shapes it defaults
+// stroke white / strokeWidth 1: the visible default (see Shape2D.ts).
+// x/y is the start point, x2/y2 the end point.
+const fields = {
+    ...Shape2D.position,
+    x2: Shape2D.defaultedNumber(0),
+    y2: Shape2D.defaultedNumber(0),
+    stroke: Schema.String.pipe(Schema.withConstructorDefault(Effect.succeed("white"))),
+    strokeWidth: Shape2D.defaultedNumber(1),
+    ...Shape2D.opacity,
+};
+export const Line = Entity.make("shapes/Line", fields, {
+    // position moves the WHOLE line: translating x/y alone would stretch
+    // it, so set shifts both endpoints by the delta (get = start point)
+    "~position": {
+        get: (data) => ({ x: data.x, y: data.y }),
+        set: (data, value) => ({
+            ...data,
+            x: value.x,
+            y: value.y,
+            x2: data.x2 + (value.x - data.x),
+            y2: data.y2 + (value.y - data.y),
+        }),
+    },
+    "~opacity": Shape2D.opacityLens(),
+});

package/dist/shapes/Path.d.ts

@@ -0,0 +1,38 @@
+import * as Schema from "effect/Schema";
+import * as Entity from "../Entity";
+export declare const Path: Entity.Entity<"shapes/Path", 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>;
+    d: Schema.String;
+}>, {
+    readonly "~position": Entity.TraitLens<{
+        readonly x: number;
+        readonly y: number;
+        readonly opacity: number;
+        readonly fill: string;
+        readonly stroke?: string;
+        readonly strokeWidth?: number;
+        readonly d: string;
+    }, 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 d: string;
+    }, number>;
+}, {
+    readonly x?: number;
+    readonly y?: number;
+    readonly opacity?: number;
+    readonly fill?: string;
+    readonly stroke?: string;
+    readonly strokeWidth?: number;
+    readonly d: string;
+}>;

package/dist/shapes/Path.js

@@ -0,0 +1,13 @@
+import * as Schema from "effect/Schema";
+import * as Entity from "../Entity";
+import * as Shape2D from "./Shape2D";
+// `d` is required — an empty path can never be visible, so there is no
+// sensible default. x/y offset the whole path (targets translate it),
+// keeping position animatable without rewriting `d`.
+export const Path = Entity.make("shapes/Path", {
+    ...Shape2D.filled,
+    d: Schema.String,
+}, {
+    "~position": Shape2D.positionLens(),
+    "~opacity": Shape2D.opacityLens(),
+});