effect-motion 0.2.0 → 0.3.1

package/dist/shapes/Image.js

@@ -0,0 +1,28 @@
+import * as Schema from "effect/Schema";
+import * as Entity from "../Entity.js";
+import * as Shape2D from "./Shape2D.js";
+/**
+ * A raster/vector image leaf. `image` names an asset declared via the
+ * `Images` annotation; the render session decodes it once and every frame
+ * reuses the decoded picture. An undeclared or failed asset paints nothing
+ * (soft skip — the rest of the frame renders).
+ *
+ * `width`/`height` are optional and undefaulted: set BOTH to draw at that
+ * size (numeric, so they tween); leave both absent to draw at the source's
+ * natural size. A lone dimension is ignored (natural size used) — aspect
+ * math would need the natural size, which frame data never sees.
+ *
+ * Billboard only: no orientation fields. ponytail: tilting an image needs a
+ * projective setTransform (full 3×3, we hardcode the bottom row) mapping the
+ * projected quad; add when a scene needs a tilted image.
+ */
+export const Image = Entity.make("shapes/Image", {
+    ...Shape2D.position,
+    image: Schema.String,
+    width: Schema.optionalKey(Schema.Number),
+    height: Schema.optionalKey(Schema.Number),
+    ...Shape2D.opacity,
+}, {
+    "~position": Shape2D.positionLens(),
+    "~opacity": Shape2D.opacityLens(),
+});

package/dist/shapes/Line.d.ts

@@ -1,47 +1,47 @@
 import * as Schema from "effect/Schema";
-import * as Entity from "../Entity";
+import * as Color from "../Color.js";
+import * as Entity from "../Entity.js";
 declare const fields: {
     x: Schema.withConstructorDefault<Schema.Number>;
     y: Schema.withConstructorDefault<Schema.Number>;
+    z: Schema.withConstructorDefault<Schema.Number>;
     opacity: Schema.withConstructorDefault<Schema.Number>;
     x2: Schema.withConstructorDefault<Schema.Number>;
     y2: Schema.withConstructorDefault<Schema.Number>;
-    stroke: Schema.withConstructorDefault<Schema.String>;
+    z2: Schema.withConstructorDefault<Schema.Number>;
+    stroke: Schema.withConstructorDefault<typeof Color.Color>;
     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>;
+    z: Schema.withConstructorDefault<Schema.Number>;
     opacity: Schema.withConstructorDefault<Schema.Number>;
     x2: Schema.withConstructorDefault<Schema.Number>;
     y2: Schema.withConstructorDefault<Schema.Number>;
-    stroke: Schema.withConstructorDefault<Schema.String>;
+    z2: Schema.withConstructorDefault<Schema.Number>;
+    stroke: Schema.withConstructorDefault<typeof Color.Color>;
     strokeWidth: Schema.withConstructorDefault<Schema.Number>;
 }>, {
     readonly "~position": {
         get: (data: LineData) => {
             x: number;
             y: number;
+            z: 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>;
+        z: Schema.withConstructorDefault<Schema.Number>;
         opacity: Schema.withConstructorDefault<Schema.Number>;
         x2: Schema.withConstructorDefault<Schema.Number>;
         y2: Schema.withConstructorDefault<Schema.Number>;
-        stroke: Schema.withConstructorDefault<Schema.String>;
+        z2: Schema.withConstructorDefault<Schema.Number>;
+        stroke: Schema.withConstructorDefault<typeof Color.Color>;
         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

@@ -1,29 +1,34 @@
 import * as Effect from "effect/Effect";
 import * as Schema from "effect/Schema";
-import * as Entity from "../Entity";
-import * as Shape2D from "./Shape2D";
+import * as Color from "../Color.js";
+import * as Entity from "../Entity.js";
+import * as Shape2D from "./Shape2D.js";
 // 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.
+// x/y/z is the start point, x2/y2/z2 the end point — a Line is skeletal:
+// each endpoint is an independent 3D world point (no orientation fields).
 const fields = {
     ...Shape2D.position,
     x2: Shape2D.defaultedNumber(0),
     y2: Shape2D.defaultedNumber(0),
-    stroke: Schema.String.pipe(Schema.withConstructorDefault(Effect.succeed("white"))),
+    z2: Shape2D.defaultedNumber(0),
+    stroke: Color.Color.pipe(Schema.withConstructorDefault(Effect.succeed(Color.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
+    // position moves the WHOLE line: translating x/y/z alone would stretch
     // it, so set shifts both endpoints by the delta (get = start point)
     "~position": {
-        get: (data) => ({ x: data.x, y: data.y }),
+        get: (data) => ({ x: data.x, y: data.y, z: data.z }),
         set: (data, value) => ({
             ...data,
             x: value.x,
             y: value.y,
+            z: value.z,
             x2: data.x2 + (value.x - data.x),
             y2: data.y2 + (value.y - data.y),
+            z2: data.z2 + (value.z - data.z),
         }),
     },
     "~opacity": Shape2D.opacityLens(),

package/dist/shapes/Path.d.ts

@@ -1,38 +1,107 @@
 import * as Schema from "effect/Schema";
-import * as Entity from "../Entity";
+import * as Entity from "../Entity.js";
+export declare const PathCommand: Schema.TaggedUnion<{
+    readonly L: Schema.TaggedStruct<"L", {
+        x: Schema.Number;
+        y: Schema.Number;
+        z: Schema.optionalKey<Schema.Number>;
+    }>;
+    readonly M: Schema.TaggedStruct<"M", {
+        x: Schema.Number;
+        y: Schema.Number;
+        z: Schema.optionalKey<Schema.Number>;
+    }>;
+    readonly Z: Schema.TaggedStruct<"Z", {}>;
+}>;
+export type PathCommand = typeof PathCommand.Type;
 export declare const Path: Entity.Entity<"shapes/Path", Schema.Struct<{
     x: Schema.withConstructorDefault<Schema.Number>;
     y: Schema.withConstructorDefault<Schema.Number>;
+    z: Schema.withConstructorDefault<Schema.Number>;
     opacity: Schema.withConstructorDefault<Schema.Number>;
-    fill: Schema.withConstructorDefault<Schema.String>;
-    stroke: Schema.optionalKey<Schema.String>;
+    fill: Schema.withConstructorDefault<typeof import("../Color.js").Color>;
+    stroke: Schema.optionalKey<typeof import("../Color.js").Color>;
     strokeWidth: Schema.optionalKey<Schema.Number>;
-    d: Schema.String;
+    commands: Schema.NonEmptyArray<Schema.TaggedUnion<{
+        readonly L: Schema.TaggedStruct<"L", {
+            x: Schema.Number;
+            y: Schema.Number;
+            z: Schema.optionalKey<Schema.Number>;
+        }>;
+        readonly M: Schema.TaggedStruct<"M", {
+            x: Schema.Number;
+            y: Schema.Number;
+            z: Schema.optionalKey<Schema.Number>;
+        }>;
+        readonly Z: Schema.TaggedStruct<"Z", {}>;
+    }>>;
 }>, {
     readonly "~position": Entity.TraitLens<{
         readonly x: number;
         readonly y: number;
+        readonly z: number;
         readonly opacity: number;
-        readonly fill: string;
-        readonly stroke?: string;
+        readonly fill: import("../Color.js").Color;
+        readonly stroke?: import("../Color.js").Color;
         readonly strokeWidth?: number;
-        readonly d: string;
+        readonly commands: readonly [Schema.Struct.ReadonlySide<{
+            readonly _tag: Schema.tag<"Z">;
+        }, "Type"> | {
+            readonly _tag: "L";
+            readonly x: number;
+            readonly y: number;
+            readonly z?: number;
+        } | {
+            readonly _tag: "M";
+            readonly x: number;
+            readonly y: number;
+            readonly z?: number;
+        }, ...(Schema.Struct.ReadonlySide<{
+            readonly _tag: Schema.tag<"Z">;
+        }, "Type"> | {
+            readonly _tag: "L";
+            readonly x: number;
+            readonly y: number;
+            readonly z?: number;
+        } | {
+            readonly _tag: "M";
+            readonly x: number;
+            readonly y: number;
+            readonly z?: number;
+        })[]];
     }, Entity.Position>;
     readonly "~opacity": Entity.TraitLens<{
         readonly x: number;
         readonly y: number;
+        readonly z: number;
         readonly opacity: number;
-        readonly fill: string;
-        readonly stroke?: string;
+        readonly fill: import("../Color.js").Color;
+        readonly stroke?: import("../Color.js").Color;
         readonly strokeWidth?: number;
-        readonly d: string;
+        readonly commands: readonly [Schema.Struct.ReadonlySide<{
+            readonly _tag: Schema.tag<"Z">;
+        }, "Type"> | {
+            readonly _tag: "L";
+            readonly x: number;
+            readonly y: number;
+            readonly z?: number;
+        } | {
+            readonly _tag: "M";
+            readonly x: number;
+            readonly y: number;
+            readonly z?: number;
+        }, ...(Schema.Struct.ReadonlySide<{
+            readonly _tag: Schema.tag<"Z">;
+        }, "Type"> | {
+            readonly _tag: "L";
+            readonly x: number;
+            readonly y: number;
+            readonly z?: number;
+        } | {
+            readonly _tag: "M";
+            readonly x: number;
+            readonly y: number;
+            readonly z?: number;
+        })[]];
     }, 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

@@ -1,12 +1,31 @@
 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`.
+import * as Entity from "../Entity.js";
+import * as Shape2D from "./Shape2D.js";
+// A command point, LOCAL to the path's anchor (x/y/z). `z` is optionalKey
+// (absent = 0, coalesced at render): nested constructor defaults would not
+// fire through the entity struct's `make`, so absence is the default.
+const point = {
+    x: Schema.Number,
+    y: Schema.Number,
+    z: Schema.optionalKey(Schema.Number),
+};
+// The command vocabulary: M (move to) starts a subpath, L (line to) extends
+// it, Z closes it. Straight polylines only — curves/arcs arrive in a later
+// iteration via deterministic flattening.
+export const PathCommand = Schema.TaggedUnion({
+    M: point,
+    L: point,
+    Z: {},
+});
+// `commands` is required — an empty path can never be visible, so there is
+// no sensible default. Points are local to the anchor: the ~position trait
+// moves the anchor and never rewrites the array. The first command must be
+// M (every subpath needs a start point) — a loud failure at instantiation.
 export const Path = Entity.make("shapes/Path", {
     ...Shape2D.filled,
-    d: Schema.String,
+    commands: Schema.NonEmptyArray(PathCommand).check(Schema.makeFilter((commands) => commands[0]._tag === "M"
+        ? undefined
+        : { path: [0], issue: "the first path command must be M" })),
 }, {
     "~position": Shape2D.positionLens(),
     "~opacity": Shape2D.opacityLens(),

package/dist/shapes/Rect.d.ts

@@ -1,41 +1,51 @@
-import * as Entity from "../Entity";
-export declare const Rect: Entity.Entity<"shapes/Rect", 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>;
-    width: import("effect/Schema").withConstructorDefault<import("effect/Schema").Number>;
-    height: import("effect/Schema").withConstructorDefault<import("effect/Schema").Number>;
+import * as Schema from "effect/Schema";
+import * as Entity from "../Entity.js";
+export declare const Rect: Entity.Entity<"shapes/Rect", Schema.Struct<{
+    x: Schema.withConstructorDefault<Schema.Number>;
+    y: Schema.withConstructorDefault<Schema.Number>;
+    z: Schema.withConstructorDefault<Schema.Number>;
+    rotX: Schema.withConstructorDefault<Schema.Number>;
+    rotY: Schema.withConstructorDefault<Schema.Number>;
+    rotZ: Schema.withConstructorDefault<Schema.Number>;
+    opacity: Schema.withConstructorDefault<Schema.Number>;
+    fill: Schema.withConstructorDefault<typeof import("../Color.js").Color>;
+    stroke: Schema.optionalKey<typeof import("../Color.js").Color>;
+    strokeWidth: Schema.optionalKey<Schema.Number>;
+    width: Schema.withConstructorDefault<Schema.Number>;
+    height: Schema.withConstructorDefault<Schema.Number>;
+    rx: Schema.optionalKey<Schema.Number>;
+    ry: Schema.optionalKey<Schema.Number>;
 }>, {
     readonly "~position": Entity.TraitLens<{
         readonly x: number;
         readonly y: number;
+        readonly z: number;
+        readonly rotX: number;
+        readonly rotY: number;
+        readonly rotZ: number;
         readonly opacity: number;
-        readonly fill: string;
-        readonly stroke?: string;
+        readonly fill: import("../Color.js").Color;
+        readonly stroke?: import("../Color.js").Color;
         readonly strokeWidth?: number;
         readonly width: number;
         readonly height: number;
+        readonly rx?: number;
+        readonly ry?: number;
     }, Entity.Position>;
     readonly "~opacity": Entity.TraitLens<{
         readonly x: number;
         readonly y: number;
+        readonly z: number;
+        readonly rotX: number;
+        readonly rotY: number;
+        readonly rotZ: number;
         readonly opacity: number;
-        readonly fill: string;
-        readonly stroke?: string;
+        readonly fill: import("../Color.js").Color;
+        readonly stroke?: import("../Color.js").Color;
         readonly strokeWidth?: number;
         readonly width: number;
         readonly height: 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 width?: number;
-    readonly height?: number;
 }>;

package/dist/shapes/Rect.js

@@ -1,9 +1,21 @@
-import * as Entity from "../Entity";
-import * as Shape2D from "./Shape2D";
+import * as Schema from "effect/Schema";
+import * as Entity from "../Entity.js";
+import * as Shape2D from "./Shape2D.js";
+// A Rect is the canonical 2.5D plane: give it Euler orientation so it can
+// tilt in 3D (lie flat as a floor, tilt as a wall). All-zero rotation (the
+// default) keeps it a camera-facing billboard. The renderer projects its
+// four corners when tilted (see Renderer flatten + Projection.planeCorners).
+//
+// `rx`/`ry` round the corners (SVG semantics: a lone radius applies to both
+// axes); numeric, so they tween. A TILTED rect ignores them — the tilt path
+// paints an exact projected polygon, which can't express rounding.
 export const Rect = Entity.make("shapes/Rect", {
     ...Shape2D.filled,
+    ...Shape2D.orientation,
     width: Shape2D.defaultedNumber(100),
     height: Shape2D.defaultedNumber(100),
+    rx: Schema.optionalKey(Schema.Number),
+    ry: Schema.optionalKey(Schema.Number),
 }, {
     "~position": Shape2D.positionLens(),
     "~opacity": Shape2D.opacityLens(),

package/dist/shapes/Shape2D.d.ts

@@ -1,5 +1,6 @@
 import * as Schema from "effect/Schema";
-import type * as Entity from "../Entity";
+import * as Color from "../Color.js";
+import type * as Entity from "../Entity.js";
 /**
  * The portable styling prop set shared by built-in shapes — deliberately
  * limited to what any plausible render target (SVG, canvas, Lottie) can
@@ -16,6 +17,12 @@ export declare const defaultedNumber: (value: number) => Schema.withConstructorD
 export declare const position: {
     x: Schema.withConstructorDefault<Schema.Number>;
     y: Schema.withConstructorDefault<Schema.Number>;
+    z: Schema.withConstructorDefault<Schema.Number>;
+};
+export declare const orientation: {
+    rotX: Schema.withConstructorDefault<Schema.Number>;
+    rotY: Schema.withConstructorDefault<Schema.Number>;
+    rotZ: Schema.withConstructorDefault<Schema.Number>;
 };
 export declare const opacity: {
     opacity: Schema.withConstructorDefault<Schema.Number>;
@@ -24,15 +31,17 @@ export declare const opacity: {
 export declare const filled: {
     x: Schema.withConstructorDefault<Schema.Number>;
     y: Schema.withConstructorDefault<Schema.Number>;
+    z: Schema.withConstructorDefault<Schema.Number>;
     opacity: Schema.withConstructorDefault<Schema.Number>;
-    fill: Schema.withConstructorDefault<Schema.String>;
-    stroke: Schema.optionalKey<Schema.String>;
+    fill: Schema.withConstructorDefault<typeof Color.Color>;
+    stroke: Schema.optionalKey<typeof Color.Color>;
     strokeWidth: Schema.optionalKey<Schema.Number>;
 };
-/** standard x/y position lens for shapes whose position IS x/y */
+/** standard x/y/z position lens for shapes whose position IS x/y/z */
 export declare const positionLens: <Data extends {
     x: number;
     y: number;
+    z: number;
 }>() => Entity.TraitLens<Data, Entity.Position>;
 /** standard opacity lens */
 export declare const opacityLens: <Data extends {

package/dist/shapes/Shape2D.js

@@ -1,5 +1,6 @@
 import * as Effect from "effect/Effect";
 import * as Schema from "effect/Schema";
+import * as Color from "../Color.js";
 /**
  * The portable styling prop set shared by built-in shapes — deliberately
  * limited to what any plausible render target (SVG, canvas, Lottie) can
@@ -13,9 +14,19 @@ import * as Schema from "effect/Schema";
  * emitted with placeholder values.
  */
 export const defaultedNumber = (value) => Schema.Number.pipe(Schema.withConstructorDefault(Effect.succeed(value)));
+// z is depth (0 = the screen plane); a default-constructed shape sits at
+// z=0 and projects to plain-2D coordinates under the resting camera.
 export const position = {
     x: defaultedNumber(0),
     y: defaultedNumber(0),
+    z: defaultedNumber(0),
+};
+// Euler orientation for a shape's plane. All-zero (the default) is a
+// billboard facing the camera; non-zero tilts the plane in 3D.
+export const orientation = {
+    rotX: defaultedNumber(0),
+    rotY: defaultedNumber(0),
+    rotZ: defaultedNumber(0),
 };
 export const opacity = {
     opacity: defaultedNumber(1),
@@ -23,16 +34,16 @@ export const opacity = {
 /** Common fields for fillable shapes. */
 export const filled = {
     ...position,
-    fill: Schema.String.pipe(Schema.withConstructorDefault(Effect.succeed("white"))),
-    stroke: Schema.optionalKey(Schema.String),
+    fill: Color.Color.pipe(Schema.withConstructorDefault(Effect.succeed(Color.white))),
+    stroke: Schema.optionalKey(Color.Color),
     strokeWidth: Schema.optionalKey(Schema.Number),
     ...opacity,
 };
-/** standard x/y position lens for shapes whose position IS x/y */
+/** standard x/y/z position lens for shapes whose position IS x/y/z */
 export const positionLens = () => ({
-    get: (data) => ({ x: data.x, y: data.y }),
+    get: (data) => ({ x: data.x, y: data.y, z: data.z }),
     // spread of a generic yields Data & {...}; assignable back to Data
-    set: (data, value) => ({ ...data, x: value.x, y: value.y }),
+    set: (data, value) => ({ ...data, x: value.x, y: value.y, z: value.z }),
 });
 /** standard opacity lens */
 export const opacityLens = () => ({

package/dist/shapes/Shapes.d.ts

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

package/dist/shapes/Shapes.js

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

package/dist/shapes/Square.d.ts

@@ -1,37 +1,32 @@
-import * as Entity from "../Entity";
+import * as Entity from "../Entity.js";
 export declare const Square: Entity.Entity<"shapes/Square", import("effect/Schema").Struct<{
     x: import("effect/Schema").withConstructorDefault<import("effect/Schema").Number>;
     y: import("effect/Schema").withConstructorDefault<import("effect/Schema").Number>;
+    z: 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>;
+    fill: import("effect/Schema").withConstructorDefault<typeof import("../Color.js").Color>;
+    stroke: import("effect/Schema").optionalKey<typeof import("../Color.js").Color>;
     strokeWidth: import("effect/Schema").optionalKey<import("effect/Schema").Number>;
     size: import("effect/Schema").withConstructorDefault<import("effect/Schema").Number>;
 }>, {
     readonly "~position": Entity.TraitLens<{
         readonly x: number;
         readonly y: number;
+        readonly z: number;
         readonly opacity: number;
-        readonly fill: string;
-        readonly stroke?: string;
+        readonly fill: import("../Color.js").Color;
+        readonly stroke?: import("../Color.js").Color;
         readonly strokeWidth?: number;
         readonly size: number;
     }, Entity.Position>;
     readonly "~opacity": Entity.TraitLens<{
         readonly x: number;
         readonly y: number;
+        readonly z: number;
         readonly opacity: number;
-        readonly fill: string;
-        readonly stroke?: string;
+        readonly fill: import("../Color.js").Color;
+        readonly stroke?: import("../Color.js").Color;
         readonly strokeWidth?: number;
         readonly size: number;
     }, number>;
-}, {
-    readonly x?: number;
-    readonly y?: number;
-    readonly opacity?: number;
-    readonly fill?: string;
-    readonly stroke?: string;
-    readonly strokeWidth?: number;
-    readonly size?: number;
 }>;

package/dist/shapes/Square.js

@@ -1,5 +1,5 @@
-import * as Entity from "../Entity";
-import * as Shape2D from "./Shape2D";
+import * as Entity from "../Entity.js";
+import * as Shape2D from "./Shape2D.js";
 // its own entity, not Rect sugar: the schema IS the width === height
 // constraint, which a Rect can't enforce through updates
 export const Square = Entity.make("shapes/Square", {

package/dist/shapes/Text.d.ts

@@ -1,5 +1,5 @@
 import * as Schema from "effect/Schema";
-import * as Entity from "../Entity";
+import * as Entity from "../Entity.js";
 /**
  * A plain-string text leaf. `text` is required. The engine cannot measure
  * text, so alignment is delegated to SVG via `textAnchor` / `baseline`.
@@ -9,9 +9,10 @@ import * as Entity from "../Entity";
 export declare const Text: Entity.Entity<"shapes/Text", Schema.Struct<{
     x: Schema.withConstructorDefault<Schema.Number>;
     y: Schema.withConstructorDefault<Schema.Number>;
+    z: Schema.withConstructorDefault<Schema.Number>;
     opacity: Schema.withConstructorDefault<Schema.Number>;
-    fill: Schema.withConstructorDefault<Schema.String>;
-    stroke: Schema.optionalKey<Schema.String>;
+    fill: Schema.withConstructorDefault<typeof import("../Color.js").Color>;
+    stroke: Schema.optionalKey<typeof import("../Color.js").Color>;
     strokeWidth: Schema.optionalKey<Schema.Number>;
     text: Schema.String;
     fontSize: Schema.withConstructorDefault<Schema.Number>;
@@ -22,9 +23,10 @@ export declare const Text: Entity.Entity<"shapes/Text", Schema.Struct<{
     readonly "~position": Entity.TraitLens<{
         readonly x: number;
         readonly y: number;
+        readonly z: number;
         readonly opacity: number;
-        readonly fill: string;
-        readonly stroke?: string;
+        readonly fill: import("../Color.js").Color;
+        readonly stroke?: import("../Color.js").Color;
         readonly strokeWidth?: number;
         readonly text: string;
         readonly fontSize: number;
@@ -35,9 +37,10 @@ export declare const Text: Entity.Entity<"shapes/Text", Schema.Struct<{
     readonly "~opacity": Entity.TraitLens<{
         readonly x: number;
         readonly y: number;
+        readonly z: number;
         readonly opacity: number;
-        readonly fill: string;
-        readonly stroke?: string;
+        readonly fill: import("../Color.js").Color;
+        readonly stroke?: import("../Color.js").Color;
         readonly strokeWidth?: number;
         readonly text: string;
         readonly fontSize: number;
@@ -45,16 +48,4 @@ export declare const Text: Entity.Entity<"shapes/Text", Schema.Struct<{
         readonly textAnchor?: "end" | "middle" | "start";
         readonly baseline?: "auto" | "hanging" | "middle";
     }, number>;
-}, {
-    readonly x?: number;
-    readonly y?: number;
-    readonly opacity?: number;
-    readonly fill?: string;
-    readonly stroke?: string;
-    readonly strokeWidth?: number;
-    readonly text: string;
-    readonly fontSize?: number;
-    readonly fontFamily?: string;
-    readonly textAnchor?: "end" | "middle" | "start";
-    readonly baseline?: "auto" | "hanging" | "middle";
 }>;

package/dist/shapes/Text.js

@@ -1,7 +1,7 @@
 import * as Effect from "effect/Effect";
 import * as Schema from "effect/Schema";
-import * as Entity from "../Entity";
-import * as Shape2D from "./Shape2D";
+import * as Entity from "../Entity.js";
+import * as Shape2D from "./Shape2D.js";
 /**
  * A plain-string text leaf. `text` is required. The engine cannot measure
  * text, so alignment is delegated to SVG via `textAnchor` / `baseline`.