@slithy/prim-lib 0.4.1 → 0.5.0

package/README.md

@@ -17,9 +17,52 @@ Reconstructs an image by iteratively placing geometric shapes. Each step evaluat
 
 ### Shapes
 
-- **`Shape`** — abstract base
+Fixed shapes (class constructors, pass directly in `shapeTypes`):
+
 - **`Triangle`**, **`Rectangle`**, **`Ellipse`**, **`Circle`**, **`Square`**, **`Hexagon`**, **`Glyph`**, **`Debug`**
 
+Configurable shapes (factory functions that return a constructor):
+
+- **`makeNGon(opts)`** — N-sided polygon; supports regular and irregular modes
+- **`makeRect(opts)`** — axis-aligned or rotatable rectangle with independent width/height control
+
+```ts
+shapeTypes: [Triangle, makeNGon({ sides: 6, regular: true }), makeRect({ aspectRatio: 1.78 })]
+```
+
+### Factory options
+
+**`NGonOptions`**
+
+```ts
+interface NGonOptions {
+  sides: number               // number of vertices (≥ 3, required)
+  regular?: boolean           // true = equidistant vertices (default: true)
+  rotatable?: boolean         // regular only: random rotation each instance (default: true)
+  startAngle?: number         // regular, non-rotatable only: fixed orientation in radians
+                              // default: -π/2 (top vertex pointing up)
+  noise?: number              // regular only: 0–1 vertex jitter (default: 0)
+  convex?: boolean            // irregular only: apply convex hull (default: false)
+  sizeRange?: [number, number] // vertex radius range in compute-space px (default: [1, 20])
+                               // regular: radius from center; irregular: scatter radius from first point
+  mutationScale?: number      // max mutation step size in px (default: 20)
+}
+```
+
+**`RectOptions`**
+
+```ts
+interface RectOptions {
+  widthRange?: [number, number]   // half-width range in compute-space px (default: [5, 40])
+  heightRange?: [number, number]  // half-height range in compute-space px (default: [5, 40])
+                                  // ignored when aspectRatio is set
+  aspectRatio?: number            // width ÷ height; locks proportions, derives hh from hw
+                                  // e.g. 1.78 for 16:9, 1.33 for 4:3, 1.0 for square
+  rotatable?: boolean             // random rotation per instance (default: false)
+  mutationScale?: number          // max mutation step size in px (default: 20)
+}
+```
+
 ### Types
 
 **`Cfg`** — runtime config (all fields required):
@@ -56,11 +99,13 @@ interface Cfg {
 type StepData =
   | { t: 't';  a: number; c: RGB; pts: [number, number][] }       // Triangle
   | { t: 'r';  a: number; c: RGB; pts: [number, number][] }       // Rectangle
+  | { t: 'p';  a: number; c: RGB; pts: [number, number][] }       // makeNGon (regular and irregular)
   | { t: 'e';  a: number; c: RGB; cx: number; cy: number; rx: number; ry: number } // Ellipse
   | { t: 'c';  a: number; c: RGB; cx: number; cy: number; r: number }              // Circle
   | { t: 's';  a: number; c: RGB; cx: number; cy: number; r: number }              // Square
   | { t: 'h';  a: number; c: RGB; cx: number; cy: number; r: number; angle: number } // Hexagon
   | { t: 'sm'; a: number; c: RGB; cx: number; cy: number; fs: number; text: string } // Glyph
+  | { t: 'rc'; a: number; c: RGB; cx: number; cy: number; hw: number; hh: number; angle: number } // makeRect
 ```
 
 **`SerializedOutput`** — compact, storage-ready representation of a completed run:
@@ -112,7 +157,7 @@ interface ReplayResult {
 - **Architecture split** — the original is a single-layer library. Here, `prim-lib` is the pure algorithm (no knowledge of how images arrive or where results go), and `prim-interface` is the adapter that wires it to the browser
 - **`PreCfg` / `Cfg` distinction** — `Canvas.original()` accepts `PreCfg` (optional `width`/`height`) and resolves to a fully-populated `Cfg`, making the config lifecycle explicit in the types
 - **Serialization** — `StepData` / `SerializedOutput` allow completed runs to be stored compactly and replayed via `replayOutput()` without re-running the optimizer
-- **Additional shapes** — `Circle`, `Square`, `Hexagon`, and `Glyph` are not in the original; `Circle` is a uniform-radius variant of `Ellipse`
+- **Additional shapes** — `Circle`, `Square`, `Hexagon`, and `Glyph` are not in the original; `Circle` is a uniform-radius variant of `Ellipse`; `makeNGon` and `makeRect` are configurable factory shapes also not in the original
 - **Shape weighting** — `shapeWeights` allows biased shape selection with a guaranteed distribution: the optimizer pre-allocates exact per-shape step counts (largest-remainder rounding) and shuffles them, so the final mix always matches the requested weights
 
 ## Architecture notes
@@ -122,3 +167,4 @@ interface ReplayResult {
 - When `shapeWeights` is provided (same length as `shapeTypes`), `Optimizer` builds a step plan at construction time: each shape type is allocated an exact number of slots proportional to its weight (using largest-remainder rounding), then the plan is Fisher-Yates shuffled. This guarantees the final shape distribution matches the weights, rather than just biasing random selection
 - `PreCfg` exists to bridge the gap between call time (dimensions unknown) and runtime (dimensions set by `Canvas.original()` or `Canvas.fromBitmap()`)
 - `Canvas.svgRoot()` is a static helper shared by `Canvas.empty()` and `replayOutput()` to create the SVG root with clip path and background fill; it uses DOM APIs and is main-thread only
+- Factory shapes (`makeNGon`, `makeRect`) capture their options in a closure and return an inner class. The class carries a static `_shapeSpec` property (`{ f: string, o: opts }`) used by `runWorker` to serialize and reconstruct the factory call inside the worker

package/dist/index.d.ts

@@ -68,6 +68,11 @@ type StepData = {
     a: number;
     c: RGB;
     pts: [number, number][];
+} | {
+    t: 'p';
+    a: number;
+    c: RGB;
+    pts: [number, number][];
 } | {
     t: 'e';
     a: number;
@@ -106,6 +111,15 @@ type StepData = {
     cy: number;
     fs: number;
     text: string;
+} | {
+    t: 'rc';
+    a: number;
+    c: RGB;
+    cx: number;
+    cy: number;
+    hw: number;
+    hh: number;
+    angle: number;
 };
 interface SerializedOutput {
     v: 1;
@@ -280,6 +294,25 @@ declare class Hexagon extends Shape {
     toData(a: number, c: RGB): StepData;
     mutate(_cfg?: Partial<Cfg>): ShapeInterface;
 }
+interface NGonOptions {
+    sides: number;
+    regular?: boolean;
+    rotatable?: boolean;
+    startAngle?: number;
+    convex?: boolean;
+    noise?: number;
+    sizeRange?: [number, number];
+    mutationScale?: number;
+}
+declare function makeNGon(opts: NGonOptions): new (w: number, h: number) => ShapeInterface;
+interface RectOptions {
+    widthRange?: [number, number];
+    heightRange?: [number, number];
+    aspectRatio?: number;
+    rotatable?: boolean;
+    mutationScale?: number;
+}
+declare function makeRect(opts?: Partial<RectOptions>): new (w: number, h: number) => ShapeInterface;
 declare class Debug extends Shape {
     constructor(w: number, h: number);
     render(ctx: CanvasRenderingContext2D): void;
@@ -308,4 +341,4 @@ interface ReplayResult {
 }
 declare function replayOutput(data: SerializedOutput): ReplayResult;
 
-export { type Bbox, Canvas, type Cfg, Circle, type Ctx2D, Debug, Ellipse, Glyph, Hexagon, type ImageDataLike, Optimizer, type Point, type PreCfg, type RGB, Rectangle, type ReplayResult, SVGNS, type SerializedOutput, Shape, type ShapeImageData, type ShapeInterface, Square, State, Step, type StepData, Triangle, clamp, clampColor, computeColorAndDifferenceChange, difference, differenceToDistance, distanceToDifference, getFill, parseColor, renderStepToCtx, replayOutput, stepDataToSVGElement, stepPerf };
+export { type Bbox, Canvas, type Cfg, Circle, type Ctx2D, Debug, Ellipse, Glyph, Hexagon, type ImageDataLike, type NGonOptions, Optimizer, type Point, type PreCfg, type RGB, type RectOptions, Rectangle, type ReplayResult, SVGNS, type SerializedOutput, Shape, type ShapeImageData, type ShapeInterface, Square, State, Step, type StepData, Triangle, clamp, clampColor, computeColorAndDifferenceChange, difference, differenceToDistance, distanceToDifference, getFill, makeNGon, makeRect, parseColor, renderStepToCtx, replayOutput, stepDataToSVGElement, stepPerf };

package/dist/index.js

@@ -915,6 +915,337 @@ var Hexagon = class _Hexagon extends Shape {
     return clone.computeBbox();
   }
 };
+function convexHull(pts) {
+  if (pts.length <= 3) return [...pts];
+  const sorted = [...pts].sort((a, b) => a[0] !== b[0] ? a[0] - b[0] : a[1] - b[1]);
+  function cross(O, A, B) {
+    return (A[0] - O[0]) * (B[1] - O[1]) - (A[1] - O[1]) * (B[0] - O[0]);
+  }
+  __name(cross, "cross");
+  const lower = [];
+  for (const p of sorted) {
+    while (lower.length >= 2 && cross(lower[lower.length - 2], lower[lower.length - 1], p) <= 0) lower.pop();
+    lower.push(p);
+  }
+  const upper = [];
+  for (let i = sorted.length - 1; i >= 0; i--) {
+    const p = sorted[i];
+    while (upper.length >= 2 && cross(upper[upper.length - 2], upper[upper.length - 1], p) <= 0) upper.pop();
+    upper.push(p);
+  }
+  lower.pop();
+  upper.pop();
+  const hull = [...lower, ...upper];
+  return hull.length >= 3 ? hull : [...pts];
+}
+__name(convexHull, "convexHull");
+function makeNGon(opts) {
+  const sides = opts.sides;
+  const regular = opts.regular ?? true;
+  const rotatable = opts.rotatable ?? true;
+  const noise = opts.noise ?? 0;
+  const convex = opts.convex ?? false;
+  const sizeRange = opts.sizeRange ?? [1, 20];
+  const mutationScale = opts.mutationScale ?? 20;
+  const defaultAngle = rotatable ? 0 : -(Math.PI / 2);
+  const startAngle = opts.startAngle ?? defaultAngle;
+  if (sides < 3) throw new RangeError("makeNGon requires at least 3 sides");
+  if (regular) {
+    class NGonRegular extends Shape {
+      static {
+        __name(this, "NGonRegular");
+      }
+      static _ngonOpts = { sides, regular: true, rotatable, noise, sizeRange, mutationScale, startAngle };
+      center;
+      r;
+      angle;
+      noises;
+      _cachedPoints;
+      constructor(w, h) {
+        super(w, h);
+        this.center = Shape.randomPoint(w, h);
+        this.r = Math.max(1, sizeRange[0] + ~~(Math.random() * (sizeRange[1] - sizeRange[0])));
+        this.angle = rotatable ? Math.random() * (2 * Math.PI / sides) : startAngle;
+        this.noises = Array.from({ length: sides }, () => Math.random());
+        this._cachedPoints = null;
+        this.computeBbox();
+      }
+      _points() {
+        if (!this._cachedPoints) {
+          this._cachedPoints = Array.from({ length: sides }, (_, i) => {
+            const a = this.angle + i * 2 * Math.PI / sides;
+            const ri = Math.max(1, ~~(this.r * (1 + (this.noises[i] - 0.5) * noise)));
+            return [
+              ~~(this.center[0] + ri * Math.cos(a)),
+              ~~(this.center[1] + ri * Math.sin(a))
+            ];
+          });
+        }
+        return this._cachedPoints;
+      }
+      computeBbox() {
+        this._cachedPoints = null;
+        const pts = this._points();
+        let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
+        for (const [x, y] of pts) {
+          if (x < minX) minX = x;
+          if (y < minY) minY = y;
+          if (x > maxX) maxX = x;
+          if (y > maxY) maxY = y;
+        }
+        this.bbox = {
+          left: minX,
+          top: minY,
+          width: maxX - minX || 1,
+          height: maxY - minY || 1
+        };
+        return this;
+      }
+      render(ctx) {
+        const pts = this._points();
+        ctx.beginPath();
+        pts.forEach(([x, y], i) => i ? ctx.lineTo(x, y) : ctx.moveTo(x, y));
+        ctx.closePath();
+        ctx.fill();
+      }
+      toSVG() {
+        const node = document.createElementNS(SVGNS, "polygon");
+        node.setAttribute("points", this._points().map((p) => p.join(",")).join(" "));
+        return node;
+      }
+      toData(a, c) {
+        return { t: "p", a, c, pts: this._points().map(([x, y]) => [x, y]) };
+      }
+      mutate(_cfg) {
+        const clone = new NGonRegular(0, 0);
+        clone.center = [this.center[0], this.center[1]];
+        clone.r = this.r;
+        clone.angle = this.angle;
+        clone.noises = [...this.noises];
+        const mutCount = 2 + (rotatable ? 1 : 0) + (noise > 0 ? 1 : 0);
+        switch (Math.floor(Math.random() * mutCount)) {
+          case 0: {
+            const a = Math.random() * 2 * Math.PI;
+            const d = Math.random() * mutationScale;
+            clone.center[0] += ~~(d * Math.cos(a));
+            clone.center[1] += ~~(d * Math.sin(a));
+            break;
+          }
+          case 1:
+            clone.r += (Math.random() - 0.5) * mutationScale;
+            clone.r = Math.max(1, ~~clone.r);
+            break;
+          case 2:
+            if (rotatable) {
+              clone.angle += (Math.random() - 0.5) * (2 * Math.PI / sides);
+            } else {
+              const ni = Math.floor(Math.random() * sides);
+              clone.noises[ni] = Math.random();
+            }
+            break;
+          case 3: {
+            const ni = Math.floor(Math.random() * sides);
+            clone.noises[ni] = Math.random();
+            break;
+          }
+        }
+        return clone.computeBbox();
+      }
+    }
+    return NGonRegular;
+  } else {
+    class NGonIrregular extends Shape {
+      static {
+        __name(this, "NGonIrregular");
+      }
+      static _ngonOpts = { sides, regular: false, convex, sizeRange, mutationScale };
+      points;
+      constructor(w, h) {
+        super(w, h);
+        const first = Shape.randomPoint(w, h);
+        this.points = [first];
+        for (let i = 1; i < sides; i++) {
+          const angle = Math.random() * 2 * Math.PI;
+          const radius = sizeRange[0] + Math.random() * (sizeRange[1] - sizeRange[0]);
+          this.points.push([
+            first[0] + ~~(radius * Math.cos(angle)),
+            first[1] + ~~(radius * Math.sin(angle))
+          ]);
+        }
+        if (convex) this.points = convexHull(this.points);
+        this.computeBbox();
+      }
+      computeBbox() {
+        let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
+        for (const [x, y] of this.points) {
+          if (x < minX) minX = x;
+          if (y < minY) minY = y;
+          if (x > maxX) maxX = x;
+          if (y > maxY) maxY = y;
+        }
+        this.bbox = {
+          left: minX,
+          top: minY,
+          width: maxX - minX || 1,
+          height: maxY - minY || 1
+        };
+        return this;
+      }
+      render(ctx) {
+        ctx.beginPath();
+        this.points.forEach(([x, y], i) => i ? ctx.lineTo(x, y) : ctx.moveTo(x, y));
+        ctx.closePath();
+        ctx.fill();
+      }
+      toSVG() {
+        const path = document.createElementNS(SVGNS, "path");
+        const d = this.points.map(([x, y], i) => `${i ? "L" : "M"}${x},${y}`).join("") + "Z";
+        path.setAttribute("d", d);
+        return path;
+      }
+      toData(a, c) {
+        return { t: "p", a, c, pts: this.points.map(([x, y]) => [x, y]) };
+      }
+      mutate(_cfg) {
+        const clone = new NGonIrregular(0, 0);
+        clone.points = this.points.map(([x, y]) => [x, y]);
+        const index = Math.floor(Math.random() * clone.points.length);
+        const point = clone.points[index];
+        const angle = Math.random() * 2 * Math.PI;
+        const radius = Math.random() * mutationScale;
+        point[0] += ~~(radius * Math.cos(angle));
+        point[1] += ~~(radius * Math.sin(angle));
+        if (convex) clone.points = convexHull(clone.points);
+        return clone.computeBbox();
+      }
+    }
+    return NGonIrregular;
+  }
+}
+__name(makeNGon, "makeNGon");
+function makeRect(opts) {
+  const widthRange = opts?.widthRange ?? [5, 40];
+  const heightRange = opts?.heightRange ?? [5, 40];
+  const aspectRatio = opts?.aspectRatio;
+  const rotatable = opts?.rotatable ?? false;
+  const mutationScale = opts?.mutationScale ?? 20;
+  class Rect extends Shape {
+    static {
+      __name(this, "Rect");
+    }
+    static _rectOpts = { widthRange, heightRange, aspectRatio, rotatable, mutationScale };
+    static _shapeSpec = { f: "rect" };
+    center;
+    hw;
+    hh;
+    angle;
+    constructor(w, h) {
+      super(w, h);
+      this.center = Shape.randomPoint(w, h);
+      this.hw = widthRange[0] + ~~(Math.random() * (widthRange[1] - widthRange[0]));
+      if (aspectRatio !== void 0) {
+        this.hh = Math.max(1, Math.round(this.hw / aspectRatio));
+      } else {
+        this.hh = heightRange[0] + ~~(Math.random() * (heightRange[1] - heightRange[0]));
+      }
+      this.angle = rotatable ? Math.random() * Math.PI : 0;
+      this.computeBbox();
+    }
+    computeBbox() {
+      const cos = Math.abs(Math.cos(this.angle));
+      const sin = Math.abs(Math.sin(this.angle));
+      const w = ~~(this.hw * cos + this.hh * sin);
+      const h = ~~(this.hw * sin + this.hh * cos);
+      this.bbox = {
+        left: this.center[0] - w,
+        top: this.center[1] - h,
+        width: 2 * w || 1,
+        height: 2 * h || 1
+      };
+      return this;
+    }
+    render(ctx) {
+      const cos = Math.cos(this.angle);
+      const sin = Math.sin(this.angle);
+      const corners = [
+        [this.center[0] - this.hw * cos + this.hh * sin, this.center[1] - this.hw * sin - this.hh * cos],
+        [this.center[0] + this.hw * cos + this.hh * sin, this.center[1] + this.hw * sin - this.hh * cos],
+        [this.center[0] + this.hw * cos - this.hh * sin, this.center[1] + this.hw * sin + this.hh * cos],
+        [this.center[0] - this.hw * cos - this.hh * sin, this.center[1] - this.hw * sin + this.hh * cos]
+      ];
+      ctx.beginPath();
+      corners.forEach(([x, y], i) => i ? ctx.lineTo(~~x, ~~y) : ctx.moveTo(~~x, ~~y));
+      ctx.closePath();
+      ctx.fill();
+    }
+    toSVG() {
+      const cos = Math.cos(this.angle);
+      const sin = Math.sin(this.angle);
+      const corners = [
+        [this.center[0] - this.hw * cos + this.hh * sin, this.center[1] - this.hw * sin - this.hh * cos],
+        [this.center[0] + this.hw * cos + this.hh * sin, this.center[1] + this.hw * sin - this.hh * cos],
+        [this.center[0] + this.hw * cos - this.hh * sin, this.center[1] + this.hw * sin + this.hh * cos],
+        [this.center[0] - this.hw * cos - this.hh * sin, this.center[1] - this.hw * sin + this.hh * cos]
+      ];
+      const node = document.createElementNS(SVGNS, "polygon");
+      node.setAttribute("points", corners.map((p) => p.join(",")).join(" "));
+      return node;
+    }
+    toData(a, c) {
+      return {
+        t: "rc",
+        a,
+        c,
+        cx: this.center[0],
+        cy: this.center[1],
+        hw: this.hw,
+        hh: this.hh,
+        angle: this.angle
+      };
+    }
+    mutate(_cfg) {
+      const clone = new Rect(0, 0);
+      clone.center = [this.center[0], this.center[1]];
+      clone.hw = this.hw;
+      clone.hh = this.hh;
+      clone.angle = this.angle;
+      const mutCount = 2 + (rotatable ? 1 : 0) + (aspectRatio === void 0 ? 1 : 0);
+      switch (Math.floor(Math.random() * mutCount)) {
+        case 0: {
+          const a = Math.random() * 2 * Math.PI;
+          const d = Math.random() * mutationScale;
+          clone.center[0] += ~~(d * Math.cos(a));
+          clone.center[1] += ~~(d * Math.sin(a));
+          break;
+        }
+        case 1:
+          clone.hw += (Math.random() - 0.5) * mutationScale;
+          clone.hw = Math.max(1, ~~clone.hw);
+          if (aspectRatio !== void 0) {
+            clone.hh = Math.max(1, Math.round(clone.hw / aspectRatio));
+          }
+          break;
+        case 2:
+          if (rotatable) {
+            clone.angle += (Math.random() - 0.5) * Math.PI / 4;
+          } else if (aspectRatio === void 0) {
+            clone.hh += (Math.random() - 0.5) * mutationScale;
+            clone.hh = Math.max(1, ~~clone.hh);
+          }
+          break;
+        case 3:
+          if (aspectRatio === void 0) {
+            clone.hh += (Math.random() - 0.5) * mutationScale;
+            clone.hh = Math.max(1, ~~clone.hh);
+          }
+          break;
+      }
+      return clone.computeBbox();
+    }
+  }
+  return Rect;
+}
+__name(makeRect, "makeRect");
 var Debug = class extends Shape {
   static {
     __name(this, "Debug");
@@ -1064,7 +1395,8 @@ function renderStepToCtx(data, ctx) {
   ctx.fillStyle = rgbString(data.c);
   switch (data.t) {
     case "t":
-    case "r": {
+    case "r":
+    case "p": {
       ctx.beginPath();
       data.pts.forEach(([x, y], i) => i ? ctx.lineTo(x, y) : ctx.moveTo(x, y));
       ctx.closePath();
@@ -1102,6 +1434,19 @@ function renderStepToCtx(data, ctx) {
       ctx.fillText(data.text, data.cx, data.cy);
       break;
     }
+    case "rc": {
+      const { cx, cy, hw, hh, angle } = data;
+      const cos = Math.cos(angle);
+      const sin = Math.sin(angle);
+      ctx.beginPath();
+      ctx.moveTo(cx - hw * cos + hh * sin, cy - hw * sin - hh * cos);
+      ctx.lineTo(cx + hw * cos + hh * sin, cy + hw * sin - hh * cos);
+      ctx.lineTo(cx + hw * cos - hh * sin, cy + hw * sin + hh * cos);
+      ctx.lineTo(cx - hw * cos - hh * sin, cy - hw * sin + hh * cos);
+      ctx.closePath();
+      ctx.fill();
+      break;
+    }
   }
 }
 __name(renderStepToCtx, "renderStepToCtx");
@@ -1111,7 +1456,8 @@ function stepDataToSVGElement(data) {
   let node;
   switch (data.t) {
     case "t":
-    case "r": {
+    case "r":
+    case "p": {
       node = document.createElementNS(SVGNS, "path");
       const d = data.pts.map(([x, y], i) => `${i ? "L" : "M"}${x},${y}`).join("") + "Z";
       node.setAttribute("d", d);
@@ -1157,6 +1503,21 @@ function stepDataToSVGElement(data) {
       node.setAttribute("y", String(data.cy));
       break;
     }
+    case "rc": {
+      const { cx, cy, hw, hh, angle } = data;
+      const cos = Math.cos(angle);
+      const sin = Math.sin(angle);
+      const fmt = /* @__PURE__ */ __name((n) => n.toFixed(2), "fmt");
+      const pts = [
+        [cx - hw * cos + hh * sin, cy - hw * sin - hh * cos],
+        [cx + hw * cos + hh * sin, cy + hw * sin - hh * cos],
+        [cx + hw * cos - hh * sin, cy + hw * sin + hh * cos],
+        [cx - hw * cos - hh * sin, cy - hw * sin + hh * cos]
+      ];
+      node = document.createElementNS(SVGNS, "polygon");
+      node.setAttribute("points", pts.map(([x, y]) => `${fmt(x)},${fmt(y)}`).join(" "));
+      break;
+    }
   }
   node.setAttribute("fill", color);
   node.setAttribute("fill-opacity", opacity);
@@ -1203,6 +1564,8 @@ export {
   differenceToDistance,
   distanceToDifference,
   getFill,
+  makeNGon,
+  makeRect,
   parseColor,
   renderStepToCtx,
   replayOutput,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@slithy/prim-lib",
-  "version": "0.4.1",
+  "version": "0.5.0",
   "description": "Core engine for primitive-based image reconstruction.",
   "type": "module",
   "exports": {
@@ -19,8 +19,8 @@
     "tsup": "^8",
     "typescript": "^5",
     "vitest": "^4.1.2",
-    "@slithy/tsconfig": "0.0.0",
-    "@slithy/eslint-config": "0.0.0"
+    "@slithy/eslint-config": "0.0.0",
+    "@slithy/tsconfig": "0.0.0"
   },
   "author": {
     "name": "Matthew Campagna",