foster-ts-shapes 0.1.0

package/dist/types.d.ts

@@ -0,0 +1,121 @@
+export interface VariationFields {
+    distort?: number;
+    sizeVariance?: number;
+    clamp?: {
+        width: number;
+        height: number;
+    };
+}
+export interface ColorStop {
+    offset: number;
+    color: string;
+    opacity?: number;
+}
+export interface LinearGradient {
+    type: "linear";
+    x1?: number;
+    y1?: number;
+    x2?: number;
+    y2?: number;
+    stops: ColorStop[];
+}
+export interface RadialGradient {
+    type: "radial";
+    cx?: number;
+    cy?: number;
+    r?: number;
+    stops: ColorStop[];
+}
+export type Gradient = LinearGradient | RadialGradient;
+export interface StylingFields {
+    fill?: string;
+    stroke?: string;
+    strokeWidth?: number;
+    opacity?: number;
+    fillGradient?: Gradient;
+    strokeGradient?: Gradient;
+}
+export interface BezierFields {
+    bezier?: number;
+    bezierDirection?: "out" | "in";
+}
+export interface LayerFields {
+    layer?: number;
+}
+export interface MaskFields {
+    mask?: MaskShape | MaskShape[];
+}
+export type MaskShape = Shape;
+export interface GeneratorInput {
+    seed: number;
+    canvas: Canvas;
+    shapes: Shape[];
+    outputMode?: "semantic" | "path";
+}
+export interface Canvas {
+    width: number;
+    height: number;
+}
+export interface ShapeBase extends VariationFields, StylingFields, BezierFields, LayerFields, MaskFields {
+    type: string;
+    x: number;
+    y: number;
+    rotation?: number;
+}
+export interface SquareShape extends ShapeBase {
+    type: "square";
+    size: number;
+}
+export interface RectangleShape extends ShapeBase {
+    type: "rectangle";
+    width: number;
+    height: number;
+}
+export interface CircleShape extends ShapeBase {
+    type: "circle";
+    size: number;
+}
+export interface TriangleShape extends ShapeBase {
+    type: "triangle";
+    size: number;
+}
+export interface TrapezoidShape extends ShapeBase {
+    type: "trapezoid";
+    topWidth: number;
+    bottomWidth: number;
+    height: number;
+}
+export interface OctagonShape extends ShapeBase {
+    type: "octagon";
+    size: number;
+}
+export interface PolygonShape extends ShapeBase {
+    type: "polygon";
+    sides: number;
+    size: number;
+}
+export interface OvalShape extends ShapeBase {
+    type: "oval";
+    width: number;
+    height: number;
+}
+export interface BlobShape extends ShapeBase {
+    type: "blob";
+    size: number;
+    points?: number;
+}
+export type Shape = SquareShape | RectangleShape | CircleShape | TriangleShape | TrapezoidShape | OctagonShape | PolygonShape | OvalShape | BlobShape;
+export interface GeneratorOutput {
+    svg: string;
+    metadata: {
+        shapeCount: number;
+    };
+}
+export interface ShapeElement {
+    tag: "rect" | "circle" | "polygon" | "path" | "ellipse";
+    attrs: Record<string, string | number>;
+    id: string;
+    rotation?: number;
+    cx: number;
+    cy: number;
+}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/dist/validate.d.ts

@@ -0,0 +1,2 @@
+import type { GeneratorInput } from "./types.js";
+export declare function validate(input: GeneratorInput): void;

package/dist/validate.js

@@ -0,0 +1,266 @@
+const SUPPORTED_TYPES = [
+    "square", "rectangle", "circle", "triangle",
+    "trapezoid", "octagon", "polygon", "oval", "blob",
+];
+function checkFinite(value, path) {
+    if (typeof value !== "number")
+        return;
+    if (Number.isNaN(value)) {
+        throw new Error(`Invalid numeric value in ${path}: NaN`);
+    }
+    if (!Number.isFinite(value)) {
+        throw new Error(`Invalid numeric value in ${path}: ${value}`);
+    }
+}
+function isPositiveFinite(value, path) {
+    checkFinite(value, path);
+    if (value <= 0) {
+        throw new Error(`${path} must be positive, got ${value}`);
+    }
+}
+function validateGradient(gradient, fieldName) {
+    const g = gradient;
+    if (g.type !== "linear" && g.type !== "radial") {
+        throw new Error(`gradient type must be 'linear' or 'radial'`);
+    }
+    if (!Array.isArray(g.stops) || g.stops.length === 0) {
+        throw new Error(`${fieldName}.stops must have at least one stop`);
+    }
+    for (const stop of g.stops) {
+        if (typeof stop.offset !== "number" || !Number.isFinite(stop.offset) || stop.offset < 0 || stop.offset > 1) {
+            throw new Error(`gradient stop offset must be a number between 0 and 1`);
+        }
+        if (typeof stop.color !== "string") {
+            throw new Error(`gradient stop color must be a string`);
+        }
+        if (stop.opacity !== undefined) {
+            if (typeof stop.opacity !== "number" || !Number.isFinite(stop.opacity) || stop.opacity < 0 || stop.opacity > 1) {
+                throw new Error(`gradient stop opacity must be a number between 0 and 1`);
+            }
+        }
+    }
+    if (g.type === "linear") {
+        const lg = g;
+        for (const val of [lg.x1, lg.y1, lg.x2, lg.y2]) {
+            if (val !== undefined && (typeof val !== "number" || !Number.isFinite(val))) {
+                throw new Error(`gradient coordinate must be a finite number`);
+            }
+        }
+    }
+    else {
+        const rg = g;
+        for (const val of [rg.cx, rg.cy]) {
+            if (val !== undefined && (typeof val !== "number" || !Number.isFinite(val))) {
+                throw new Error(`gradient coordinate must be a finite number`);
+            }
+        }
+        if (rg.r !== undefined) {
+            if (typeof rg.r !== "number" || !Number.isFinite(rg.r) || rg.r <= 0) {
+                throw new Error(`gradient r must be a positive finite number`);
+            }
+        }
+    }
+}
+function validateShape(shape, index) {
+    const prefix = `shapes[${index}]`;
+    // Type check
+    if (!SUPPORTED_TYPES.includes(shape.type)) {
+        throw new Error(`Invalid shape type "${shape.type}" in ${prefix}. Must be one of: ${SUPPORTED_TYPES.join(", ")}`);
+    }
+    // x and y required
+    if (shape.x === undefined || shape.x === null) {
+        throw new Error(`Missing required field ${prefix}.x`);
+    }
+    if (shape.y === undefined || shape.y === null) {
+        throw new Error(`Missing required field ${prefix}.y`);
+    }
+    // Numeric safety on x, y, rotation
+    checkFinite(shape.x, `${prefix}.x`);
+    checkFinite(shape.y, `${prefix}.y`);
+    if (shape.rotation !== undefined) {
+        checkFinite(shape.rotation, `${prefix}.rotation`);
+    }
+    // Opacity validation (Stage 3)
+    if (shape.opacity !== undefined) {
+        checkFinite(shape.opacity, `${prefix}.opacity`);
+        if (shape.opacity < 0 || shape.opacity > 1) {
+            throw new Error(`opacity must be a number between 0 and 1`);
+        }
+    }
+    // strokeWidth validation (Stage 3)
+    if (shape.strokeWidth !== undefined) {
+        if (typeof shape.strokeWidth !== "number" || !Number.isFinite(shape.strokeWidth) || shape.strokeWidth <= 0) {
+            throw new Error(`strokeWidth must be a positive finite number`);
+        }
+    }
+    // bezier/bezierDirection validation (Stage 3)
+    if (shape.bezier !== undefined) {
+        checkFinite(shape.bezier, `${prefix}.bezier`);
+        if (shape.bezier < 0 || shape.bezier > 1) {
+            throw new Error(`bezier must be a number between 0 and 1`);
+        }
+    }
+    if (shape.bezierDirection !== undefined) {
+        if (shape.bezierDirection !== "out" && shape.bezierDirection !== "in") {
+            throw new Error(`bezierDirection must be "out" or "in"`);
+        }
+    }
+    // Gradient validation (Stage 3)
+    if (shape.fillGradient !== undefined)
+        validateGradient(shape.fillGradient, "fillGradient");
+    if (shape.strokeGradient !== undefined)
+        validateGradient(shape.strokeGradient, "strokeGradient");
+    // Layer validation (Stage 4)
+    if (shape.layer !== undefined && !Number.isFinite(shape.layer)) {
+        throw new Error(`layer must be a finite number`);
+    }
+    // Mask validation (Stage 4) — each MaskShape is validated as a full shape
+    // mask/layer on the MaskShapes are not present after canonicalize, so no special handling needed
+    if (shape.mask !== undefined) {
+        const maskArr = Array.isArray(shape.mask) ? shape.mask : [shape.mask];
+        for (let mi = 0; mi < maskArr.length; mi++) {
+            validateShape(maskArr[mi], index);
+        }
+    }
+    // Variation field validation (optional on all shape types)
+    if (shape.distort !== undefined) {
+        checkFinite(shape.distort, `${prefix}.distort`);
+        if (shape.distort < 0 || shape.distort > 1) {
+            throw new Error(`distort must be a number between 0 and 1`);
+        }
+    }
+    if (shape.sizeVariance !== undefined) {
+        checkFinite(shape.sizeVariance, `${prefix}.sizeVariance`);
+        if (shape.sizeVariance < 0 || shape.sizeVariance > 1) {
+            throw new Error(`sizeVariance must be a number between 0 and 1`);
+        }
+    }
+    if (shape.clamp !== undefined) {
+        const w = shape.clamp.width;
+        const h = shape.clamp.height;
+        if (typeof w !== "number" || !Number.isFinite(w) || w <= 0) {
+            throw new Error(`clamp.width must be a positive finite number`);
+        }
+        if (typeof h !== "number" || !Number.isFinite(h) || h <= 0) {
+            throw new Error(`clamp.height must be a positive finite number`);
+        }
+    }
+    // Per-type validation
+    switch (shape.type) {
+        case "square": {
+            if (shape.size === undefined || shape.size === null) {
+                throw new Error(`Missing required field ${prefix}.size for square`);
+            }
+            isPositiveFinite(shape.size, `${prefix}.size`);
+            break;
+        }
+        case "circle": {
+            if (shape.size === undefined || shape.size === null) {
+                throw new Error(`Missing required field ${prefix}.size for circle`);
+            }
+            isPositiveFinite(shape.size, `${prefix}.size`);
+            break;
+        }
+        case "triangle": {
+            if (shape.size === undefined || shape.size === null) {
+                throw new Error(`Missing required field ${prefix}.size for triangle`);
+            }
+            isPositiveFinite(shape.size, `${prefix}.size`);
+            break;
+        }
+        case "rectangle": {
+            if (shape.width === undefined || shape.width === null) {
+                throw new Error(`Missing required field ${prefix}.width for rectangle`);
+            }
+            if (shape.height === undefined || shape.height === null) {
+                throw new Error(`Missing required field ${prefix}.height for rectangle`);
+            }
+            isPositiveFinite(shape.width, `${prefix}.width`);
+            isPositiveFinite(shape.height, `${prefix}.height`);
+            break;
+        }
+        case "trapezoid": {
+            if (shape.topWidth === undefined || shape.topWidth === null) {
+                throw new Error(`Missing required field ${prefix}.topWidth for trapezoid`);
+            }
+            if (shape.bottomWidth === undefined || shape.bottomWidth === null) {
+                throw new Error(`Missing required field ${prefix}.bottomWidth for trapezoid`);
+            }
+            if (shape.height === undefined || shape.height === null) {
+                throw new Error(`Missing required field ${prefix}.height for trapezoid`);
+            }
+            isPositiveFinite(shape.topWidth, `${prefix}.topWidth`);
+            isPositiveFinite(shape.bottomWidth, `${prefix}.bottomWidth`);
+            isPositiveFinite(shape.height, `${prefix}.height`);
+            break;
+        }
+        case "octagon": {
+            if (shape.size === undefined || shape.size === null) {
+                throw new Error(`Missing required field ${prefix}.size for octagon`);
+            }
+            isPositiveFinite(shape.size, `${prefix}.size`);
+            break;
+        }
+        case "polygon": {
+            if (shape.sides === undefined || shape.sides === null) {
+                throw new Error(`Missing required field ${prefix}.sides for polygon`);
+            }
+            if (shape.size === undefined || shape.size === null) {
+                throw new Error(`Missing required field ${prefix}.size for polygon`);
+            }
+            checkFinite(shape.sides, `${prefix}.sides`);
+            if (!Number.isInteger(shape.sides) || shape.sides < 3) {
+                throw new Error(`${prefix}.sides must be an integer >= 3, got ${shape.sides}`);
+            }
+            isPositiveFinite(shape.size, `${prefix}.size`);
+            break;
+        }
+        case "oval": {
+            if (shape.width === undefined || shape.width === null) {
+                throw new Error(`Missing required field ${prefix}.width for oval`);
+            }
+            if (shape.height === undefined || shape.height === null) {
+                throw new Error(`Missing required field ${prefix}.height for oval`);
+            }
+            isPositiveFinite(shape.width, `${prefix}.width`);
+            isPositiveFinite(shape.height, `${prefix}.height`);
+            break;
+        }
+        case "blob": {
+            if (shape.size === undefined || shape.size === null) {
+                throw new Error(`Missing required field ${prefix}.size for blob`);
+            }
+            isPositiveFinite(shape.size, `${prefix}.size`);
+            if (shape.points !== undefined) {
+                checkFinite(shape.points, `${prefix}.points`);
+                if (!Number.isInteger(shape.points) || shape.points < 3) {
+                    throw new Error(`${prefix}.points must be an integer >= 3, got ${shape.points}`);
+                }
+            }
+            break;
+        }
+    }
+}
+export function validate(input) {
+    // seed required
+    if (input.seed === undefined || input.seed === null) {
+        throw new Error("Missing required field: seed");
+    }
+    checkFinite(input.seed, "seed");
+    // canvas validation
+    if (!input.canvas) {
+        throw new Error("Missing required field: canvas");
+    }
+    checkFinite(input.canvas.width, "canvas.width");
+    checkFinite(input.canvas.height, "canvas.height");
+    if (input.canvas.width <= 0) {
+        throw new Error(`canvas.width must be > 0, got ${input.canvas.width}`);
+    }
+    if (input.canvas.height <= 0) {
+        throw new Error(`canvas.height must be > 0, got ${input.canvas.height}`);
+    }
+    // shapes validation
+    for (let i = 0; i < input.shapes.length; i++) {
+        validateShape(input.shapes[i], i);
+    }
+}

package/dist/variation.d.ts

@@ -0,0 +1,11 @@
+import type { Shape } from "./types.js";
+export declare function charSizeOf(shape: Shape): number;
+export declare function extractVertices(shape: Shape, generatorSeed: number, shapeIndex: number): [number, number][];
+export declare function applyDistort(vertices: [number, number][], charSize: number, distort: number, prng: () => number): [number, number][];
+export declare function applyClamp(vertices: [number, number][], cx: number, cy: number, clampWidth: number, clampHeight: number): [number, number][];
+export declare function verticesToPath(vertices: [number, number][], bezier?: number, direction?: "out" | "in"): string;
+export declare function applySizeVariance(shape: Shape, prng: () => number): Shape;
+export declare function renderVaried(shape: Shape, varPrng: () => number, generatorSeed: number, shapeIndex: number, bezier?: number, bezierDirection?: "out" | "in"): {
+    tag: "path";
+    attrs: Record<string, string | number>;
+};

package/dist/variation.js

@@ -0,0 +1,244 @@
+import { fmt } from "./fmt.js";
+import { createPrng, blobSeed } from "./prng.js";
+// ---------------------------------------------------------------------------
+// charSizeOf — characteristic half-size used as distortion magnitude basis
+// ---------------------------------------------------------------------------
+export function charSizeOf(shape) {
+    switch (shape.type) {
+        case "square": return shape.size / 2;
+        case "circle": return shape.size / 2;
+        case "triangle": return shape.size / 2;
+        case "octagon": return shape.size / 2;
+        case "polygon": return shape.size / 2;
+        case "blob": return shape.size / 2;
+        case "rectangle": return Math.min(shape.width, shape.height) / 2;
+        case "oval": return Math.min(shape.width, shape.height) / 2;
+        case "trapezoid": return Math.min(shape.topWidth, shape.bottomWidth, shape.height) / 2;
+        default: return 1;
+    }
+}
+// ---------------------------------------------------------------------------
+// extractVertices — get [x, y] vertex list from a shape
+// For circle/oval: samples 16 points around the perimeter.
+// For blob: re-derives N control points using blobSeed PRNG.
+// ---------------------------------------------------------------------------
+export function extractVertices(shape, generatorSeed, shapeIndex) {
+    const { x, y } = shape;
+    switch (shape.type) {
+        case "square": {
+            const h = shape.size / 2;
+            return [[x - h, y - h], [x + h, y - h], [x + h, y + h], [x - h, y + h]];
+        }
+        case "rectangle": {
+            const hw = shape.width / 2, hh = shape.height / 2;
+            return [[x - hw, y - hh], [x + hw, y - hh], [x + hw, y + hh], [x - hw, y + hh]];
+        }
+        case "circle": {
+            const r = shape.size / 2;
+            const pts = [];
+            for (let k = 0; k < 16; k++) {
+                const angle = (k * Math.PI * 2) / 16;
+                pts.push([x + r * Math.cos(angle), y + r * Math.sin(angle)]);
+            }
+            return pts;
+        }
+        case "triangle": {
+            const h = shape.size * Math.sqrt(3) / 2;
+            return [
+                [x, y - (2 * h) / 3],
+                [x - shape.size / 2, y + h / 3],
+                [x + shape.size / 2, y + h / 3],
+            ];
+        }
+        case "trapezoid": {
+            const htw = shape.topWidth / 2, hbw = shape.bottomWidth / 2, hh = shape.height / 2;
+            return [
+                [x - htw, y - hh],
+                [x + htw, y - hh],
+                [x + hbw, y + hh],
+                [x - hbw, y + hh],
+            ];
+        }
+        case "octagon": {
+            const pts = [];
+            for (let k = 0; k < 8; k++) {
+                const angle = k * Math.PI / 4 - Math.PI / 2;
+                pts.push([x + shape.size * Math.cos(angle), y + shape.size * Math.sin(angle)]);
+            }
+            return pts;
+        }
+        case "polygon": {
+            const pts = [];
+            for (let k = 0; k < shape.sides; k++) {
+                const angle = (k * Math.PI * 2) / shape.sides - Math.PI / 2;
+                pts.push([x + shape.size * Math.cos(angle), y + shape.size * Math.sin(angle)]);
+            }
+            return pts;
+        }
+        case "oval": {
+            const rx = shape.width / 2, ry = shape.height / 2;
+            const pts = [];
+            for (let k = 0; k < 16; k++) {
+                const angle = (k * Math.PI * 2) / 16;
+                pts.push([x + rx * Math.cos(angle), y + ry * Math.sin(angle)]);
+            }
+            return pts;
+        }
+        case "blob": {
+            const n = shape.points ?? 6;
+            const prng = createPrng(blobSeed(generatorSeed, shapeIndex));
+            const pts = [];
+            for (let k = 0; k < n; k++) {
+                const angle = (k * Math.PI * 2) / n;
+                const radius = shape.size * (0.6 + 0.4 * prng());
+                pts.push([x + radius * Math.cos(angle), y + radius * Math.sin(angle)]);
+            }
+            return pts;
+        }
+        default:
+            return [];
+    }
+}
+// ---------------------------------------------------------------------------
+// applyDistort — perturb each vertex by ±(charSize * distort)
+// Consumes 2 prng() draws per vertex (dx, dy).
+// ---------------------------------------------------------------------------
+export function applyDistort(vertices, charSize, distort, prng) {
+    const mag = charSize * distort;
+    return vertices.map(([vx, vy]) => [
+        vx + (prng() * 2 - 1) * mag,
+        vy + (prng() * 2 - 1) * mag,
+    ]);
+}
+// ---------------------------------------------------------------------------
+// applyClamp — constrain vertices to bounding box [cx±w/2, cy±h/2]
+// ---------------------------------------------------------------------------
+export function applyClamp(vertices, cx, cy, clampWidth, clampHeight) {
+    const xMin = cx - clampWidth / 2, xMax = cx + clampWidth / 2;
+    const yMin = cy - clampHeight / 2, yMax = cy + clampHeight / 2;
+    return vertices.map(([vx, vy]) => [
+        Math.max(xMin, Math.min(xMax, vx)),
+        Math.max(yMin, Math.min(yMax, vy)),
+    ]);
+}
+// ---------------------------------------------------------------------------
+// verticesToPath — build path from vertices with optional bezier corner rounding.
+// When bezier = 0 or absent: straight-line path M x0 y0 L x1 y1 ... Z (unchanged).
+// When bezier > 0: quadratic bezier Q curves at each corner.
+//   Handle length: t = bezier × 0.45 (max 45% of min adjacent segment — prevents overlap).
+//   For each vertex v[i] with prev and next:
+//     P1 = v[i] + t*(prev - v[i])   (approach point on incoming edge)
+//     P2 = v[i] + t*(next - v[i])   (departure point on outgoing edge)
+//     "out" (convex): ctrl = v[i]
+//     "in"  (concave): ctrl = P1 + P2 - v[i]  (reflection through midpoint)
+//   Path: M P1[0] Q ctrl[0] P2[0] L P1[1] Q ctrl[1] P2[1] ... Z
+// ---------------------------------------------------------------------------
+export function verticesToPath(vertices, bezier, direction) {
+    const N = vertices.length;
+    if (!bezier || bezier <= 0 || N < 2) {
+        const [first, ...rest] = vertices;
+        const lines = rest.map(([vx, vy]) => `L ${fmt(vx)} ${fmt(vy)}`);
+        return `M ${fmt(first[0])} ${fmt(first[1])} ${lines.join(" ")} Z`;
+    }
+    const t = bezier * 0.45;
+    const dir = direction ?? "out";
+    const parts = [];
+    for (let i = 0; i < N; i++) {
+        const [vx, vy] = vertices[i];
+        const [px, py] = vertices[(i - 1 + N) % N];
+        const [nx, ny] = vertices[(i + 1) % N];
+        // Approach point (t-fraction from v toward prev)
+        const p1x = vx + t * (px - vx);
+        const p1y = vy + t * (py - vy);
+        // Departure point (t-fraction from v toward next)
+        const p2x = vx + t * (nx - vx);
+        const p2y = vy + t * (ny - vy);
+        // Control point
+        let cx, cy;
+        if (dir === "out") {
+            cx = vx;
+            cy = vy;
+        }
+        else {
+            // Reflect v through midpoint(P1, P2)
+            cx = p1x + p2x - vx;
+            cy = p1y + p2y - vy;
+        }
+        if (i === 0) {
+            parts.push(`M ${fmt(p1x)} ${fmt(p1y)}`);
+        }
+        else {
+            parts.push(`L ${fmt(p1x)} ${fmt(p1y)}`);
+        }
+        parts.push(`Q ${fmt(cx)} ${fmt(cy)} ${fmt(p2x)} ${fmt(p2y)}`);
+    }
+    parts.push("Z");
+    return parts.join(" ");
+}
+// ---------------------------------------------------------------------------
+// blobVariedPath — Catmull-Rom → cubic Bézier through perturbed control points
+// ---------------------------------------------------------------------------
+function blobVariedPath(pts) {
+    const n = pts.length;
+    const p = (i) => pts[((i % n) + n) % n];
+    const segments = [];
+    for (let i = 0; i < n; i++) {
+        const [p0x, p0y] = p(i);
+        const [p1x, p1y] = p(i + 1);
+        const [pm1x, pm1y] = p(i - 1);
+        const [p2x, p2y] = p(i + 2);
+        const cp1x = p0x + (p1x - pm1x) / 6;
+        const cp1y = p0y + (p1y - pm1y) / 6;
+        const cp2x = p1x - (p2x - p0x) / 6;
+        const cp2y = p1y - (p2y - p0y) / 6;
+        segments.push(`C ${fmt(cp1x)} ${fmt(cp1y)} ${fmt(cp2x)} ${fmt(cp2y)} ${fmt(p1x)} ${fmt(p1y)}`);
+    }
+    const [startX, startY] = pts[0];
+    return `M ${fmt(startX)} ${fmt(startY)} ${segments.join(" ")} Z`;
+}
+// ---------------------------------------------------------------------------
+// applySizeVariance — scale all size dimensions; consumes exactly one prng() draw.
+// Returns a new shape object with scaled dimensions; all other fields unchanged.
+// ---------------------------------------------------------------------------
+export function applySizeVariance(shape, prng) {
+    const sv = shape.sizeVariance ?? 0;
+    if (sv === 0)
+        return shape;
+    const f = 1 + (prng() * 2 - 1) * sv;
+    const scale = (dim) => Math.max(1, dim * f);
+    switch (shape.type) {
+        case "square": return { ...shape, size: scale(shape.size) };
+        case "circle": return { ...shape, size: scale(shape.size) };
+        case "triangle": return { ...shape, size: scale(shape.size) };
+        case "octagon": return { ...shape, size: scale(shape.size) };
+        case "polygon": return { ...shape, size: scale(shape.size) };
+        case "blob": return { ...shape, size: scale(shape.size) };
+        case "rectangle": return { ...shape, width: scale(shape.width), height: scale(shape.height) };
+        case "oval": return { ...shape, width: scale(shape.width), height: scale(shape.height) };
+        case "trapezoid": return {
+            ...shape,
+            topWidth: scale(shape.topWidth),
+            bottomWidth: scale(shape.bottomWidth),
+            height: scale(shape.height),
+        };
+        default: return shape;
+    }
+}
+// ---------------------------------------------------------------------------
+// renderVaried — full distortion pipeline (sizeVariance assumed already applied).
+// extractVertices → applyDistort → applyClamp (if shape.clamp) → path
+// Always returns tag: "path".
+// ---------------------------------------------------------------------------
+export function renderVaried(shape, varPrng, generatorSeed, shapeIndex, bezier, bezierDirection) {
+    const dt = shape.distort ?? 0;
+    const cs = charSizeOf(shape);
+    let vertices = extractVertices(shape, generatorSeed, shapeIndex);
+    vertices = applyDistort(vertices, cs, dt, varPrng);
+    if (shape.clamp) {
+        vertices = applyClamp(vertices, shape.x, shape.y, shape.clamp.width, shape.clamp.height);
+    }
+    const d = shape.type === "blob"
+        ? blobVariedPath(vertices)
+        : verticesToPath(vertices, bezier, bezierDirection);
+    return { tag: "path", attrs: { d } };
+}

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "foster-ts-shapes",
+  "version": "0.1.0",
+  "description": "Deterministic SVG shape generation library",
+  "license": "MIT",
+  "author": "VisualFinesse",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/VisualFinesse/ShapeGenerator"
+  },
+  "keywords": [
+    "svg",
+    "shapes",
+    "generator",
+    "deterministic"
+  ],
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "test": "vitest run",
+    "lint": "tsc --noEmit",
+    "prepublishOnly": "npm run build"
+  },
+  "devDependencies": {
+    "@types/node": "^25.3.3",
+    "typescript": "^5.4.0",
+    "vitest": "^1.6.0"
+  }
+}