git-hash-art 0.0.4 → 0.2.0

package/dist/module.js

@@ -1,34 +1,198 @@
-import {createCanvas as $hgUW1$createCanvas} from "canvas";
-import $hgUW1$fs from "fs";
-import $hgUW1$path from "path";
-import $hgUW1$colorscheme from "color-scheme";
-
+import {createCanvas as $4RUNL$createCanvas} from "@napi-rs/canvas";
+import {existsSync as $4RUNL$existsSync, mkdirSync as $4RUNL$mkdirSync, writeFileSync as $4RUNL$writeFileSync} from "fs";
+import {join as $4RUNL$join} from "path";
+import $4RUNL$colorscheme from "color-scheme";
 
 
 
 
+/**
+ * Pure rendering logic — environment-agnostic.
+ *
+ * This module only uses the standard CanvasRenderingContext2D API,
+ * so it works identically in Node (@napi-rs/canvas) and browsers
+ * (HTMLCanvasElement).
+ */ 
  // declare module 'color-scheme';
 
 
-const $44f5b87a40c9680b$export$8daab6f91f7ff730 = (ctx, size)=>{
+function $461134e0b6ce0619$export$39a95c82b20fdf81(gitHash) {
+    return parseInt(gitHash.slice(0, 8), 16);
+}
+function $461134e0b6ce0619$export$eaf9227667332084(seed) {
+    let s = seed | 0;
+    return ()=>{
+        s = s + 0x6d2b79f5 | 0;
+        let t = Math.imul(s ^ s >>> 15, 1 | s);
+        t = t + Math.imul(t ^ t >>> 7, 61 | t) ^ t;
+        return ((t ^ t >>> 14) >>> 0) / 4294967296;
+    };
+}
+function $461134e0b6ce0619$export$e9cc707de01b7042(hash, offset = 0) {
+    let h = 0;
+    for(let i = 0; i < hash.length; i++)h = Math.imul(31, h) + hash.charCodeAt(i) | 0;
+    return h + offset | 0;
+}
+function $461134e0b6ce0619$export$6b193cae730c547a(hash, index, min, max) {
+    const rng = $461134e0b6ce0619$export$eaf9227667332084($461134e0b6ce0619$export$e9cc707de01b7042(hash, index));
+    return min + rng() * (max - min);
+}
+const $461134e0b6ce0619$export$bb9e4790bc99ae59 = {
+    GOLDEN_RATIO: 1.618034,
+    SQUARE_ROOT_2: Math.sqrt(2),
+    SQUARE_ROOT_3: Math.sqrt(3),
+    SQUARE_ROOT_5: Math.sqrt(5),
+    PI: Math.PI,
+    PHI: (1 + Math.sqrt(5)) / 2
+};
+class $461134e0b6ce0619$export$da2372f11bc66b3f {
+    static getProportionalSize(baseSize, proportion) {
+        return baseSize * proportion;
+    }
+    static centerPattern(ctx, width, height) {
+        ctx.translate(width / 2, height / 2);
+    }
+    // Combines sacred geometry patterns with proper proportions
+    static layerPatterns(ctx, patterns, config) {
+        const { baseSize: baseSize, baseOpacity: baseOpacity = 0.6, opacityReduction: opacityReduction = 0.1, rotationOffset: rotationOffset = 0, proportionType: proportionType = "GOLDEN_RATIO" } = config;
+        patterns.forEach((pattern, index)=>{
+            const size = this.getProportionalSize(baseSize, Math.pow($461134e0b6ce0619$export$bb9e4790bc99ae59[proportionType], index));
+            const opacity = Math.max(0.1, baseOpacity - index * opacityReduction);
+            const rotation = rotationOffset * index;
+            ctx.save();
+            ctx.globalAlpha = opacity;
+            ctx.rotate(rotation * Math.PI / 180);
+            shapes[pattern.type](ctx, size, pattern.config);
+            ctx.restore();
+        });
+    }
+}
+
+
+function $9d614e7d77fc2947$export$f116a24fd288e742(gitHash) {
+    const seed = (0, $461134e0b6ce0619$export$39a95c82b20fdf81)(gitHash);
+    const scheme = new (0, $4RUNL$colorscheme)();
+    scheme.from_hue(seed % 360).scheme("analogic").variation("soft");
+    let colors = scheme.colors().map((hex)=>`#${hex}`);
+    const contrastingHue = (seed + 180) % 360;
+    const contrastingScheme = new (0, $4RUNL$colorscheme)();
+    contrastingScheme.from_hue(contrastingHue).scheme("mono").variation("soft");
+    colors.push(`#${contrastingScheme.colors()[0]}`);
+    return colors;
+}
+class $9d614e7d77fc2947$export$ab958c550f521376 {
+    seed;
+    baseScheme;
+    complementaryScheme;
+    triadicScheme;
+    metallic;
+    constructor(gitHash){
+        this.seed = (0, $461134e0b6ce0619$export$39a95c82b20fdf81)(gitHash);
+        this.baseScheme = this.generateBaseScheme();
+        this.complementaryScheme = this.generateComplementaryScheme();
+        this.triadicScheme = this.generateTriadicScheme();
+        this.metallic = this.generateMetallicColors();
+    }
+    generateBaseScheme() {
+        const scheme = new (0, $4RUNL$colorscheme)();
+        return scheme.from_hue(this.seed % 360).scheme("analogic").variation("soft").colors().map((hex)=>`#${hex}`);
+    }
+    generateComplementaryScheme() {
+        const complementaryHue = (this.seed + 180) % 360;
+        const scheme = new (0, $4RUNL$colorscheme)();
+        return scheme.from_hue(complementaryHue).scheme("mono").variation("soft").colors().map((hex)=>`#${hex}`);
+    }
+    generateTriadicScheme() {
+        const triadicHue = (this.seed + 120) % 360;
+        const scheme = new (0, $4RUNL$colorscheme)();
+        return scheme.from_hue(triadicHue).scheme("triade").variation("soft").colors().map((hex)=>`#${hex}`);
+    }
+    generateMetallicColors() {
+        return {
+            gold: "#FFD700",
+            silver: "#C0C0C0",
+            copper: "#B87333",
+            bronze: "#CD7F32"
+        };
+    }
+    /**
+   * Returns a flat array of hash-derived colors suitable for art generation.
+   * Combines base analogic, complementary, and triadic schemes for variety
+   * while maintaining color harmony.
+   */ getColors() {
+        // Deduplicate and return a rich palette
+        const all = [
+            ...this.baseScheme.slice(0, 4),
+            ...this.complementaryScheme.slice(0, 2),
+            ...this.triadicScheme.slice(0, 2)
+        ];
+        return [
+            ...new Set(all)
+        ];
+    }
+    /**
+   * Returns two background colors derived from the hash — darker variants
+   * of the base scheme for gradient backgrounds.
+   */ getBackgroundColors() {
+        return [
+            this.darken(this.baseScheme[0], 0.65),
+            this.darken(this.baseScheme[1], 0.55)
+        ];
+    }
+    /**
+   * Simple hex color darkening by a factor (0 = black, 1 = unchanged).
+   */ darken(hex, factor) {
+        const c = hex.replace("#", "");
+        const r = Math.round(parseInt(c.substring(0, 2), 16) * factor);
+        const g = Math.round(parseInt(c.substring(2, 4), 16) * factor);
+        const b = Math.round(parseInt(c.substring(4, 6), 16) * factor);
+        return `#${r.toString(16).padStart(2, "0")}${g.toString(16).padStart(2, "0")}${b.toString(16).padStart(2, "0")}`;
+    }
+}
+// ── Standalone color utilities ──────────────────────────────────────
+/** Parse a hex color (#RRGGBB) into [r, g, b] 0-255. */ function $9d614e7d77fc2947$var$hexToRgb(hex) {
+    const c = hex.replace("#", "");
+    return [
+        parseInt(c.substring(0, 2), 16),
+        parseInt(c.substring(2, 4), 16),
+        parseInt(c.substring(4, 6), 16)
+    ];
+}
+/** Format [r, g, b] back to #RRGGBB. */ function $9d614e7d77fc2947$var$rgbToHex(r, g, b) {
+    const clamp = (v)=>Math.max(0, Math.min(255, Math.round(v)));
+    return `#${clamp(r).toString(16).padStart(2, "0")}${clamp(g).toString(16).padStart(2, "0")}${clamp(b).toString(16).padStart(2, "0")}`;
+}
+function $9d614e7d77fc2947$export$f2121afcad3d553f(hex, alpha) {
+    const [r, g, b] = $9d614e7d77fc2947$var$hexToRgb(hex);
+    return `rgba(${r},${g},${b},${alpha.toFixed(3)})`;
+}
+function $9d614e7d77fc2947$export$59539d800dbe6858(hex, rng, amount = 0.1) {
+    const [r, g, b] = $9d614e7d77fc2947$var$hexToRgb(hex);
+    const jit = ()=>(rng() - 0.5) * 2 * amount * 255;
+    return $9d614e7d77fc2947$var$rgbToHex(r + jit(), g + jit(), b + jit());
+}
+
+
+
+const $f225038c018b3815$export$8daab6f91f7ff730 = (ctx, size)=>{
     ctx.beginPath();
     ctx.arc(0, 0, size / 2, 0, Math.PI * 2);
 };
-const $44f5b87a40c9680b$export$9340b6a85ea854b9 = (ctx, size)=>{
+const $f225038c018b3815$export$9340b6a85ea854b9 = (ctx, size)=>{
     ctx.beginPath();
     ctx.rect(-size / 2, -size / 2, size, size);
 };
-const $44f5b87a40c9680b$export$e6b70c7883316010 = (ctx, size)=>{
+const $f225038c018b3815$export$e6b70c7883316010 = (ctx, size)=>{
     ctx.beginPath();
     ctx.moveTo(0, -size / 2);
     ctx.lineTo(-size / 2, size / 2);
     ctx.lineTo(size / 2, size / 2);
     ctx.closePath();
 };
-const $44f5b87a40c9680b$export$252d2895fb67397b = (ctx, size)=>{
+const $f225038c018b3815$export$252d2895fb67397b = (ctx, size)=>{
     ctx.beginPath();
     for(let i = 0; i < 6; i++){
-        const angle = Math.PI / 8 * i;
+        const angle = Math.PI * 2 / 6 * i;
         const x = size / 2 * Math.cos(angle);
         const y = size / 2 * Math.sin(angle);
         if (i === 0) ctx.moveTo(x, y);
@@ -36,7 +200,7 @@ const $44f5b87a40c9680b$export$252d2895fb67397b = (ctx, size)=>{
     }
     ctx.closePath();
 };
-const $44f5b87a40c9680b$export$ca57b923902a3c0 = (ctx, size)=>{
+const $f225038c018b3815$export$ca57b923902a3c0 = (ctx, size)=>{
     ctx.beginPath();
     for(let i = 0; i < 10; i++){
         const angle = Math.PI / 5 + Math.PI / 5 * i * 3;
@@ -48,7 +212,7 @@ const $44f5b87a40c9680b$export$ca57b923902a3c0 = (ctx, size)=>{
     }
     ctx.closePath();
 };
-const $44f5b87a40c9680b$export$cf8f2f05ac4f561f = (ctx, size)=>{
+const $f225038c018b3815$export$cf8f2f05ac4f561f = (ctx, size)=>{
     ctx.beginPath();
     for(let i = 0; i < 10; i++){
         const angle = Math.PI / 30 + Math.PI / 30 * i * 8;
@@ -60,13 +224,13 @@ const $44f5b87a40c9680b$export$cf8f2f05ac4f561f = (ctx, size)=>{
     }
     ctx.closePath();
 };
-const $44f5b87a40c9680b$export$1ed0c0bc398b6246 = (ctx, size)=>{
+const $f225038c018b3815$export$1ed0c0bc398b6246 = (ctx, size)=>{
     ctx.beginPath();
     ctx.moveTo(0, size / 4);
     ctx.quadraticCurveTo(size / 2, size / 4, 0, -size / 4);
     ctx.quadraticCurveTo(-size / 2, size / 4, 0, size / 4);
 };
-const $44f5b87a40c9680b$export$57ec12daf141ce6 = (ctx, size)=>{
+const $f225038c018b3815$export$57ec12daf141ce6 = (ctx, size)=>{
     ctx.beginPath();
     ctx.moveTo(0, -size / 2);
     ctx.lineTo(size / 2, 0);
@@ -74,7 +238,7 @@ const $44f5b87a40c9680b$export$57ec12daf141ce6 = (ctx, size)=>{
     ctx.lineTo(-size / 2, 0);
     ctx.closePath();
 };
-const $44f5b87a40c9680b$export$39f25a4fc5491539 = (ctx, size)=>{
+const $f225038c018b3815$export$39f25a4fc5491539 = (ctx, size)=>{
     ctx.beginPath();
     ctx.moveTo(-size / 2, -size / 2);
     ctx.lineTo(size / 2, -size / 2);
@@ -82,21 +246,21 @@ const $44f5b87a40c9680b$export$39f25a4fc5491539 = (ctx, size)=>{
     ctx.lineTo(-size / 2, size / 2);
     ctx.closePath();
 };
-const $44f5b87a40c9680b$export$492753207a5258e1 = {
-    circle: $44f5b87a40c9680b$export$8daab6f91f7ff730,
-    square: $44f5b87a40c9680b$export$9340b6a85ea854b9,
-    triangle: $44f5b87a40c9680b$export$e6b70c7883316010,
-    hexagon: $44f5b87a40c9680b$export$252d2895fb67397b,
-    star: $44f5b87a40c9680b$export$ca57b923902a3c0,
-    "jacked-star": $44f5b87a40c9680b$export$cf8f2f05ac4f561f,
-    heart: $44f5b87a40c9680b$export$1ed0c0bc398b6246,
-    diamond: $44f5b87a40c9680b$export$57ec12daf141ce6,
-    cube: $44f5b87a40c9680b$export$39f25a4fc5491539
+const $f225038c018b3815$export$492753207a5258e1 = {
+    circle: $f225038c018b3815$export$8daab6f91f7ff730,
+    square: $f225038c018b3815$export$9340b6a85ea854b9,
+    triangle: $f225038c018b3815$export$e6b70c7883316010,
+    hexagon: $f225038c018b3815$export$252d2895fb67397b,
+    star: $f225038c018b3815$export$ca57b923902a3c0,
+    "jacked-star": $f225038c018b3815$export$cf8f2f05ac4f561f,
+    heart: $f225038c018b3815$export$1ed0c0bc398b6246,
+    diamond: $f225038c018b3815$export$57ec12daf141ce6,
+    cube: $f225038c018b3815$export$39f25a4fc5491539
 };
 
 
 // Define interfaces for our configurations
-const $e0ea14d2e2f06463$export$9265403940be6b4 = {
+const $4e82a5352fbc7b27$export$9265403940be6b4 = {
     // Standard sizes with different hashes
     react: {
         hash: "46192e59d42f741c761cbea79462a8b3815dd905",
@@ -186,7 +350,7 @@ const $e0ea14d2e2f06463$export$9265403940be6b4 = {
         maxShapeSize: 250
     }
 };
-const $e0ea14d2e2f06463$export$3572305709b6b48c = {
+const $4e82a5352fbc7b27$export$3572305709b6b48c = {
     strokeStyle: "#000000",
     fillStyle: "transparent",
     lineWidth: 1,
@@ -194,12 +358,12 @@ const $e0ea14d2e2f06463$export$3572305709b6b48c = {
     iterations: 1,
     animate: false
 };
-const $e0ea14d2e2f06463$export$a4ca1369b6d2c19e = {
+const $4e82a5352fbc7b27$export$a4ca1369b6d2c19e = {
     BASIC: "basic",
     DETAILED: "detailed",
     ANIMATED: "animated"
 };
-const $e0ea14d2e2f06463$export$bb9e4790bc99ae59 = {
+const $4e82a5352fbc7b27$export$bb9e4790bc99ae59 = {
     GOLDEN_RATIO: 1.618034,
     SQUARE_ROOT_2: Math.sqrt(2),
     SQUARE_ROOT_3: Math.sqrt(3),
@@ -207,7 +371,7 @@ const $e0ea14d2e2f06463$export$bb9e4790bc99ae59 = {
     PI: Math.PI,
     PHI: (1 + Math.sqrt(5)) / 2
 };
-const $e0ea14d2e2f06463$export$c36defeab44ba3b3 = {
+const $4e82a5352fbc7b27$export$c36defeab44ba3b3 = {
     flowerOfLifeMandala: (size)=>[
             // { type: "flowerOfLife", config: { size } },
             {
@@ -264,25 +428,25 @@ const $e0ea14d2e2f06463$export$c36defeab44ba3b3 = {
 };
 
 
-const $ce2c52df8af02e62$export$e6bfdeff8bfc94f9 = (degrees)=>degrees * Math.PI / 180;
-const $ce2c52df8af02e62$export$e46c5570db033611 = (ctx, size, config)=>{
+const $79312e33271883e9$export$e6bfdeff8bfc94f9 = (degrees)=>degrees * Math.PI / 180;
+const $79312e33271883e9$export$e46c5570db033611 = (ctx, size, config)=>{
     ctx.save();
     ctx.translate(0, 0);
-    if (config.rotation) ctx.rotate($ce2c52df8af02e62$export$e6bfdeff8bfc94f9(config.rotation));
+    if (config.rotation) ctx.rotate($79312e33271883e9$export$e6bfdeff8bfc94f9(config.rotation));
     ctx.lineWidth = config.lineWidth;
     ctx.strokeStyle = config.strokeStyle;
     ctx.fillStyle = config.fillStyle;
 };
-const $ce2c52df8af02e62$export$68ae68d395d27fd1 = (ctx)=>{
+const $79312e33271883e9$export$68ae68d395d27fd1 = (ctx)=>{
     ctx.restore();
 };
-const $ce2c52df8af02e62$export$70ba51ca253810ef = (type)=>({
+const $79312e33271883e9$export$70ba51ca253810ef = (type)=>({
         enabled: false,
         duration: 1000,
         easing: "linear",
         type: type
     });
-const $ce2c52df8af02e62$export$5627764dc1e1d74a = (cx, cy, radius, segments)=>{
+const $79312e33271883e9$export$5627764dc1e1d74a = (cx, cy, radius, segments)=>{
     const points = [];
     for(let i = 0; i < segments; i++){
         const angle = i / segments * Math.PI * 2;
@@ -295,7 +459,7 @@ const $ce2c52df8af02e62$export$5627764dc1e1d74a = (cx, cy, radius, segments)=>{
 };
 
 
-const $f0f1a7293548e501$export$90cc629a1c6121c7 = {
+const $8bde0a7ee87832b5$export$90cc629a1c6121c7 = {
     platonic: {
         tetrahedron: {
             vertices: 4,
@@ -327,16 +491,18 @@ const $f0f1a7293548e501$export$90cc629a1c6121c7 = {
         ratio: 1.618034
     }
 };
-const $f0f1a7293548e501$export$4721fcae39954914 = (ctx, size, config = {})=>{
+const $8bde0a7ee87832b5$export$4721fcae39954914 = (ctx, size, config = {})=>{
     const finalConfig = {
-        ...(0, $e0ea14d2e2f06463$export$3572305709b6b48c),
+        ...(0, $4e82a5352fbc7b27$export$3572305709b6b48c),
         ...config
     };
-    (0, $ce2c52df8af02e62$export$e46c5570db033611)(ctx, size, finalConfig);
-    const { vertices: vertices } = $f0f1a7293548e501$export$90cc629a1c6121c7.platonic[config.type];
+    (0, $79312e33271883e9$export$e46c5570db033611)(ctx, size, finalConfig);
+    const solidType = config.type;
+    const solidConfig = $8bde0a7ee87832b5$export$90cc629a1c6121c7.platonic[solidType] ?? $8bde0a7ee87832b5$export$90cc629a1c6121c7.platonic.icosahedron;
+    const { vertices: vertices } = solidConfig;
     const radius = size / 2;
     // Calculate vertices based on platonic solid type
-    const points = (0, $ce2c52df8af02e62$export$5627764dc1e1d74a)(0, 0, radius, vertices);
+    const points = (0, $79312e33271883e9$export$5627764dc1e1d74a)(0, 0, radius, vertices);
     ctx.beginPath();
     // Draw edges between vertices
     points.forEach((p1, i)=>{
@@ -347,15 +513,15 @@ const $f0f1a7293548e501$export$4721fcae39954914 = (ctx, size, config = {})=>{
     });
     if (finalConfig.fillStyle !== "transparent") ctx.fill();
     ctx.stroke();
-    (0, $ce2c52df8af02e62$export$68ae68d395d27fd1)(ctx);
+    (0, $79312e33271883e9$export$68ae68d395d27fd1)(ctx);
 };
-const $f0f1a7293548e501$export$4091fa94ab006097 = (ctx, size, config = {})=>{
+const $8bde0a7ee87832b5$export$4091fa94ab006097 = (ctx, size, config = {})=>{
     const finalConfig = {
-        ...(0, $e0ea14d2e2f06463$export$3572305709b6b48c),
-        ...$f0f1a7293548e501$export$90cc629a1c6121c7.fibonacci,
+        ...(0, $4e82a5352fbc7b27$export$3572305709b6b48c),
+        ...$8bde0a7ee87832b5$export$90cc629a1c6121c7.fibonacci,
         ...config
     };
-    (0, $ce2c52df8af02e62$export$e46c5570db033611)(ctx, size, finalConfig);
+    (0, $79312e33271883e9$export$e46c5570db033611)(ctx, size, finalConfig);
     let current = 1;
     let previous = 1;
     let scale = size / Math.pow(finalConfig.growthFactor, finalConfig.iterations);
@@ -374,14 +540,14 @@ const $f0f1a7293548e501$export$4091fa94ab006097 = (ctx, size, config = {})=>{
         ctx.rotate(Math.PI / 2);
     }
     ctx.stroke();
-    (0, $ce2c52df8af02e62$export$68ae68d395d27fd1)(ctx);
+    (0, $79312e33271883e9$export$68ae68d395d27fd1)(ctx);
 };
-const $f0f1a7293548e501$export$c9043b89bcb14ed9 = (ctx, size, config = {})=>{
+const $8bde0a7ee87832b5$export$c9043b89bcb14ed9 = (ctx, size, config = {})=>{
     const finalConfig = {
-        ...(0, $e0ea14d2e2f06463$export$3572305709b6b48c),
+        ...(0, $4e82a5352fbc7b27$export$3572305709b6b48c),
         ...config
     };
-    (0, $ce2c52df8af02e62$export$e46c5570db033611)(ctx, size, finalConfig);
+    (0, $79312e33271883e9$export$e46c5570db033611)(ctx, size, finalConfig);
     const gridSize = 8;
     const unit = size / gridSize;
     ctx.beginPath();
@@ -402,14 +568,14 @@ const $f0f1a7293548e501$export$c9043b89bcb14ed9 = (ctx, size, config = {})=>{
         }
     }
     ctx.stroke();
-    (0, $ce2c52df8af02e62$export$68ae68d395d27fd1)(ctx);
+    (0, $79312e33271883e9$export$68ae68d395d27fd1)(ctx);
 };
-const $f0f1a7293548e501$export$16ea6f9310920305 = (ctx, size, config = {})=>{
+const $8bde0a7ee87832b5$export$16ea6f9310920305 = (ctx, size, config = {})=>{
     const finalConfig = {
-        ...(0, $e0ea14d2e2f06463$export$3572305709b6b48c),
+        ...(0, $4e82a5352fbc7b27$export$3572305709b6b48c),
         ...config
     };
-    (0, $ce2c52df8af02e62$export$e46c5570db033611)(ctx, size, finalConfig);
+    (0, $79312e33271883e9$export$e46c5570db033611)(ctx, size, finalConfig);
     const gridSize = 4;
     const unit = size / gridSize;
     const drawKnotSegment = (x, y, type)=>{
@@ -432,19 +598,19 @@ const $f0f1a7293548e501$export$16ea6f9310920305 = (ctx, size, config = {})=>{
         const y = (j - gridSize / 2) * unit;
         drawKnotSegment(x, y, (i + j) % 2 === 0 ? "over" : "under");
     }
-    (0, $ce2c52df8af02e62$export$68ae68d395d27fd1)(ctx);
+    (0, $79312e33271883e9$export$68ae68d395d27fd1)(ctx);
 };
-const $f0f1a7293548e501$export$661ad3ddfb8912ed = (ctx, size, config = {})=>{
+const $8bde0a7ee87832b5$export$661ad3ddfb8912ed = (ctx, size, config = {})=>{
     const finalConfig = {
-        ...(0, $e0ea14d2e2f06463$export$3572305709b6b48c),
+        ...(0, $4e82a5352fbc7b27$export$3572305709b6b48c),
         ...config
     };
-    (0, $ce2c52df8af02e62$export$e46c5570db033611)(ctx, size, finalConfig);
+    (0, $79312e33271883e9$export$e46c5570db033611)(ctx, size, finalConfig);
     const radius = size / 2;
     // Draw two intersecting tetrahedra
     ctx.beginPath();
     // First tetrahedron
-    const points1 = (0, $ce2c52df8af02e62$export$5627764dc1e1d74a)(0, 0, radius, 3);
+    const points1 = (0, $79312e33271883e9$export$5627764dc1e1d74a)(0, 0, radius, 3);
     points1.forEach((p1, i)=>{
         points1.slice(i + 1).forEach((p2)=>{
             ctx.moveTo(p1.x, p1.y);
@@ -453,7 +619,7 @@ const $f0f1a7293548e501$export$661ad3ddfb8912ed = (ctx, size, config = {})=>{
     });
     // Second tetrahedron (rotated)
     ctx.rotate(Math.PI / 6);
-    const points2 = (0, $ce2c52df8af02e62$export$5627764dc1e1d74a)(0, 0, radius, 3);
+    const points2 = (0, $79312e33271883e9$export$5627764dc1e1d74a)(0, 0, radius, 3);
     points2.forEach((p1, i)=>{
         points2.slice(i + 1).forEach((p2)=>{
             ctx.moveTo(p1.x, p1.y);
@@ -462,14 +628,14 @@ const $f0f1a7293548e501$export$661ad3ddfb8912ed = (ctx, size, config = {})=>{
     });
     if (finalConfig.fillStyle !== "transparent") ctx.fill();
     ctx.stroke();
-    (0, $ce2c52df8af02e62$export$68ae68d395d27fd1)(ctx);
+    (0, $79312e33271883e9$export$68ae68d395d27fd1)(ctx);
 };
-const $f0f1a7293548e501$export$97222779ddee1bfe = (ctx, size, config = {})=>{
+const $8bde0a7ee87832b5$export$97222779ddee1bfe = (ctx, size, config = {})=>{
     const finalConfig = {
-        ...(0, $e0ea14d2e2f06463$export$3572305709b6b48c),
+        ...(0, $4e82a5352fbc7b27$export$3572305709b6b48c),
         ...config
     };
-    (0, $ce2c52df8af02e62$export$e46c5570db033611)(ctx, size, finalConfig);
+    (0, $79312e33271883e9$export$e46c5570db033611)(ctx, size, finalConfig);
     const numCircles = 8;
     const numPoints = 16;
     const radius = size / 2;
@@ -487,15 +653,15 @@ const $f0f1a7293548e501$export$97222779ddee1bfe = (ctx, size, config = {})=>{
         }
     }
     ctx.stroke();
-    (0, $ce2c52df8af02e62$export$68ae68d395d27fd1)(ctx);
+    (0, $79312e33271883e9$export$68ae68d395d27fd1)(ctx);
 };
-const $f0f1a7293548e501$export$4fab07e71ae4aeeb = (ctx, size, config = {})=>{
+const $8bde0a7ee87832b5$export$4fab07e71ae4aeeb = (ctx, size, config = {})=>{
     const finalConfig = {
-        ...(0, $e0ea14d2e2f06463$export$3572305709b6b48c),
+        ...(0, $4e82a5352fbc7b27$export$3572305709b6b48c),
         ...config,
         iterations: 5
     };
-    (0, $ce2c52df8af02e62$export$e46c5570db033611)(ctx, size, finalConfig);
+    (0, $79312e33271883e9$export$e46c5570db033611)(ctx, size, finalConfig);
     const drawBranch = (x, y, length, angle, depth)=>{
         if (depth === 0) return;
         const endX = x + length * Math.cos(angle);
@@ -508,21 +674,21 @@ const $f0f1a7293548e501$export$4fab07e71ae4aeeb = (ctx, size, config = {})=>{
         drawBranch(endX, endY, length * 0.7, angle + Math.PI / 6, depth - 1);
     };
     drawBranch(0, size / 2, size / 4, -Math.PI / 2, finalConfig.iterations);
-    (0, $ce2c52df8af02e62$export$68ae68d395d27fd1)(ctx);
+    (0, $79312e33271883e9$export$68ae68d395d27fd1)(ctx);
 };
-const $f0f1a7293548e501$export$dbe318a13ce51887 = {
-    platonicSolid: $f0f1a7293548e501$export$4721fcae39954914,
-    fibonacciSpiral: $f0f1a7293548e501$export$4091fa94ab006097,
-    islamicPattern: $f0f1a7293548e501$export$c9043b89bcb14ed9,
-    celticKnot: $f0f1a7293548e501$export$16ea6f9310920305,
-    merkaba: $f0f1a7293548e501$export$661ad3ddfb8912ed,
-    mandala: $f0f1a7293548e501$export$97222779ddee1bfe,
-    fractal: $f0f1a7293548e501$export$4fab07e71ae4aeeb
+const $8bde0a7ee87832b5$export$dbe318a13ce51887 = {
+    platonicSolid: $8bde0a7ee87832b5$export$4721fcae39954914,
+    fibonacciSpiral: $8bde0a7ee87832b5$export$4091fa94ab006097,
+    islamicPattern: $8bde0a7ee87832b5$export$c9043b89bcb14ed9,
+    celticKnot: $8bde0a7ee87832b5$export$16ea6f9310920305,
+    merkaba: $8bde0a7ee87832b5$export$661ad3ddfb8912ed,
+    mandala: $8bde0a7ee87832b5$export$97222779ddee1bfe,
+    fractal: $8bde0a7ee87832b5$export$4fab07e71ae4aeeb
 };
 
 
 
-const $77711f013715e6da$export$3bac12a72d9de58c = (ctx, size)=>{
+const $d63629e16208c310$export$3bac12a72d9de58c = (ctx, size)=>{
     const radius = size / 6;
     const centers = [
         {
@@ -560,7 +726,7 @@ const $77711f013715e6da$export$3bac12a72d9de58c = (ctx, size)=>{
         ctx.arc(center.x, center.y, radius, 0, Math.PI * 2);
     });
 };
-const $77711f013715e6da$export$639bf214428ceec2 = (ctx, size)=>{
+const $d63629e16208c310$export$639bf214428ceec2 = (ctx, size)=>{
     const radius = size / 12;
     const spacing = radius * 2.5;
     // Sephirot positions (traditional layout)
@@ -621,7 +787,7 @@ const $77711f013715e6da$export$639bf214428ceec2 = (ctx, size)=>{
         });
     });
 };
-const $77711f013715e6da$export$de26673ceb3e04eb = (ctx, size)=>{
+const $d63629e16208c310$export$de26673ceb3e04eb = (ctx, size)=>{
     const radius = size / 3;
     // Create 13 points - one center and 12 vertices of an icosahedron
     // const phi = (1 + Math.sqrt(5)) / 2; // Golden ratio
@@ -630,8 +796,8 @@ const $77711f013715e6da$export$de26673ceb3e04eb = (ctx, size)=>{
             x: 0,
             y: 0
         },
-        ...(0, $ce2c52df8af02e62$export$5627764dc1e1d74a)(0, 0, radius, 6),
-        ...(0, $ce2c52df8af02e62$export$5627764dc1e1d74a)(0, 0, radius * 1.5, 6)
+        ...(0, $79312e33271883e9$export$5627764dc1e1d74a)(0, 0, radius, 6),
+        ...(0, $79312e33271883e9$export$5627764dc1e1d74a)(0, 0, radius * 1.5, 6)
     ];
     ctx.beginPath();
     // Draw all connecting lines
@@ -642,7 +808,7 @@ const $77711f013715e6da$export$de26673ceb3e04eb = (ctx, size)=>{
         });
     });
 };
-const $77711f013715e6da$export$f743702d1590aefb = (ctx, size)=>{
+const $d63629e16208c310$export$f743702d1590aefb = (ctx, size)=>{
     const radius = size / 2;
     ctx.beginPath();
     // Draw outer triangles
@@ -671,7 +837,7 @@ const $77711f013715e6da$export$f743702d1590aefb = (ctx, size)=>{
         ctx.lineTo(0, 0);
     }
 };
-const $77711f013715e6da$export$980631444e370ab0 = (ctx, size)=>{
+const $d63629e16208c310$export$980631444e370ab0 = (ctx, size)=>{
     const radius = size / 6;
     const centers = [
         {
@@ -709,13 +875,13 @@ const $77711f013715e6da$export$980631444e370ab0 = (ctx, size)=>{
         ctx.arc(center.x, center.y, radius, 0, Math.PI * 2);
     });
 };
-const $77711f013715e6da$export$eeae7765f05012e2 = (ctx, size)=>{
+const $d63629e16208c310$export$eeae7765f05012e2 = (ctx, size)=>{
     const radius = size / 4;
     ctx.beginPath();
     ctx.arc(-radius / 2, 0, radius, 0, Math.PI * 2);
     ctx.arc(radius / 2, 0, radius, 0, Math.PI * 2);
 };
-const $77711f013715e6da$export$3355220a8108efc3 = (ctx, size)=>{
+const $d63629e16208c310$export$3355220a8108efc3 = (ctx, size)=>{
     const outerRadius = size / 2;
     const innerRadius = size / 4;
     const steps = 36;
@@ -735,7 +901,7 @@ const $77711f013715e6da$export$3355220a8108efc3 = (ctx, size)=>{
         }
     }
 };
-const $77711f013715e6da$export$31e39e0544d9b1e8 = (ctx, size)=>{
+const $d63629e16208c310$export$31e39e0544d9b1e8 = (ctx, size)=>{
     const radius = size / 8;
     const centers = [
         {
@@ -773,140 +939,26 @@ const $77711f013715e6da$export$31e39e0544d9b1e8 = (ctx, size)=>{
         ctx.arc(center.x, center.y, radius, 0, Math.PI * 2);
     });
 };
-const $77711f013715e6da$export$c2fc138f94dd4b2a = {
-    flowerOfLife: $77711f013715e6da$export$3bac12a72d9de58c,
-    treeOfLife: $77711f013715e6da$export$639bf214428ceec2,
-    metatronsCube: $77711f013715e6da$export$de26673ceb3e04eb,
-    sriYantra: $77711f013715e6da$export$f743702d1590aefb,
-    seedOfLife: $77711f013715e6da$export$980631444e370ab0,
-    vesicaPiscis: $77711f013715e6da$export$eeae7765f05012e2,
-    torus: $77711f013715e6da$export$3355220a8108efc3,
-    eggOfLife: $77711f013715e6da$export$31e39e0544d9b1e8
+const $d63629e16208c310$export$c2fc138f94dd4b2a = {
+    flowerOfLife: $d63629e16208c310$export$3bac12a72d9de58c,
+    treeOfLife: $d63629e16208c310$export$639bf214428ceec2,
+    metatronsCube: $d63629e16208c310$export$de26673ceb3e04eb,
+    sriYantra: $d63629e16208c310$export$f743702d1590aefb,
+    seedOfLife: $d63629e16208c310$export$980631444e370ab0,
+    vesicaPiscis: $d63629e16208c310$export$eeae7765f05012e2,
+    torus: $d63629e16208c310$export$3355220a8108efc3,
+    eggOfLife: $d63629e16208c310$export$31e39e0544d9b1e8
 };
 
 
-const $e41b41d8dcf837ad$export$4ff7fc6f1af248b5 = {
-    ...(0, $44f5b87a40c9680b$export$492753207a5258e1),
-    ...(0, $f0f1a7293548e501$export$dbe318a13ce51887),
-    ...(0, $77711f013715e6da$export$c2fc138f94dd4b2a)
-};
-
-
-function $616009579e3d72c5$export$39a95c82b20fdf81(gitHash) {
-    return parseInt(gitHash.slice(0, 8), 16);
-}
-function $616009579e3d72c5$export$6b193cae730c547a(hash, index, min, max) {
-    const hexPair = hash.substr(index * 2 % hash.length, 2);
-    const decimal = parseInt(hexPair, 16);
-    return min + decimal / 255 * (max - min);
-}
-const $616009579e3d72c5$export$bb9e4790bc99ae59 = {
-    GOLDEN_RATIO: 1.618034,
-    SQUARE_ROOT_2: Math.sqrt(2),
-    SQUARE_ROOT_3: Math.sqrt(3),
-    SQUARE_ROOT_5: Math.sqrt(5),
-    PI: Math.PI,
-    PHI: (1 + Math.sqrt(5)) / 2
+const $701ba7c7229ef06d$export$4ff7fc6f1af248b5 = {
+    ...(0, $f225038c018b3815$export$492753207a5258e1),
+    ...(0, $8bde0a7ee87832b5$export$dbe318a13ce51887),
+    ...(0, $d63629e16208c310$export$c2fc138f94dd4b2a)
 };
-class $616009579e3d72c5$export$da2372f11bc66b3f {
-    static getProportionalSize(baseSize, proportion) {
-        return baseSize * proportion;
-    }
-    static centerPattern(ctx, width, height) {
-        ctx.translate(width / 2, height / 2);
-    }
-    // Combines sacred geometry patterns with proper proportions
-    static layerPatterns(ctx, patterns, config) {
-        const { baseSize: baseSize, baseOpacity: baseOpacity = 0.6, opacityReduction: opacityReduction = 0.1, rotationOffset: rotationOffset = 0, proportionType: proportionType = "GOLDEN_RATIO" } = config;
-        patterns.forEach((pattern, index)=>{
-            const size = this.getProportionalSize(baseSize, Math.pow($616009579e3d72c5$export$bb9e4790bc99ae59[proportionType], index));
-            const opacity = Math.max(0.1, baseOpacity - index * opacityReduction);
-            const rotation = rotationOffset * index;
-            ctx.save();
-            ctx.globalAlpha = opacity;
-            ctx.rotate(rotation * Math.PI / 180);
-            (0, $e41b41d8dcf837ad$export$4ff7fc6f1af248b5)[pattern.type](ctx, size, pattern.config);
-            ctx.restore();
-        });
-    }
-}
 
 
-function $b5a262d09b87e373$export$f116a24fd288e742(gitHash) {
-    const seed = (0, $616009579e3d72c5$export$39a95c82b20fdf81)(gitHash);
-    const scheme = new (0, $hgUW1$colorscheme)();
-    scheme.from_hue(seed % 360).scheme("analogic").variation("soft");
-    let colors = scheme.colors().map((hex)=>`#${hex}`);
-    const contrastingHue = (seed + 180) % 360;
-    const contrastingScheme = new (0, $hgUW1$colorscheme)();
-    contrastingScheme.from_hue(contrastingHue).scheme("mono").variation("soft");
-    colors.push(`#${contrastingScheme.colors()[0]}`);
-    return colors;
-}
-class $b5a262d09b87e373$export$ab958c550f521376 {
-    constructor(gitHash){
-        this.seed = this.gitHashToSeed(gitHash);
-        this.baseScheme = this.generateBaseScheme();
-        this.complementaryScheme = this.generateComplementaryScheme();
-        this.metallic = this.generateMetallicColors();
-    }
-    gitHashToSeed(hash) {
-        return parseInt(hash.slice(0, 8), 16);
-    }
-    generateBaseScheme() {
-        const scheme = new (0, $hgUW1$colorscheme)();
-        scheme;
-        return scheme.from_hue(this.seed % 360).scheme("analogic").variation("soft").colors().map((hex)=>`#${hex}`);
-    }
-    generateComplementaryScheme() {
-        const complementaryHue = (this.seed + 180) % 360;
-        const scheme = new (0, $hgUW1$colorscheme)();
-        return scheme.from_hue(complementaryHue).scheme("mono").variation("soft").colors().map((hex)=>`#${hex}`);
-    }
-    generateMetallicColors() {
-        return {
-            gold: "#FFD700",
-            silver: "#C0C0C0",
-            copper: "#B87333",
-            bronze: "#CD7F32"
-        };
-    }
-    getColorPalette(type = "sacred") {
-        switch(type){
-            case "sacred":
-                return {
-                    primary: this.baseScheme[0],
-                    secondary: this.baseScheme[1],
-                    accent: this.complementaryScheme[0],
-                    metallic: this.metallic.gold
-                };
-            case "elemental":
-                return {
-                    earth: this.baseScheme[0],
-                    water: this.baseScheme[1],
-                    air: this.baseScheme[2],
-                    fire: this.complementaryScheme[0]
-                };
-            case "chakra":
-                return {
-                    root: "#FF0000",
-                    sacral: "#FF7F00",
-                    solar: "#FFFF00",
-                    heart: "#00FF00",
-                    throat: "#0000FF",
-                    third_eye: "#4B0082",
-                    crown: "#8F00FF"
-                };
-            default:
-                return this.baseScheme;
-        }
-    }
-}
-
-
-
-
-function $e0f99502ff383dd8$export$71b514a25c47df50(ctx, shape, x, y, config) {
+function $9beb8f41637c29fd$export$71b514a25c47df50(ctx, shape, x, y, config) {
     const { fillColor: fillColor, strokeColor: strokeColor, strokeWidth: strokeWidth, size: size, rotation: rotation } = config;
     ctx.save();
     ctx.translate(x, y);
@@ -914,32 +966,50 @@ function $e0f99502ff383dd8$export$71b514a25c47df50(ctx, shape, x, y, config) {
     ctx.fillStyle = fillColor;
     ctx.strokeStyle = strokeColor;
     ctx.lineWidth = strokeWidth;
-    const drawFunction = (0, $e41b41d8dcf837ad$export$4ff7fc6f1af248b5)[shape];
-    if (drawFunction) drawFunction(ctx, size);
-    ctx.fill();
-    ctx.stroke();
+    const drawFunction = (0, $701ba7c7229ef06d$export$4ff7fc6f1af248b5)[shape];
+    if (drawFunction) {
+        drawFunction(ctx, size);
+        ctx.fill();
+        ctx.stroke();
+    }
     ctx.restore();
 }
-function $e0f99502ff383dd8$export$bb35a6995ddbf32d(ctx, shape, x, y, config) {
-    const { fillColor: fillColor, strokeColor: strokeColor, strokeWidth: strokeWidth, size: size, rotation: rotation, patterns: patterns = [], proportionType: proportionType = "GOLDEN_RATIO", baseOpacity: baseOpacity = 0.6, opacityReduction: opacityReduction = 0.1 } = config;
+function $9beb8f41637c29fd$export$bb35a6995ddbf32d(ctx, shape, x, y, config) {
+    const { fillColor: fillColor, strokeColor: strokeColor, strokeWidth: strokeWidth, size: size, rotation: rotation, patterns: patterns = [], proportionType: proportionType = "GOLDEN_RATIO", baseOpacity: baseOpacity = 0.6, opacityReduction: opacityReduction = 0.1, glowRadius: glowRadius = 0, glowColor: glowColor, gradientFillEnd: gradientFillEnd } = config;
     ctx.save();
     ctx.translate(x, y);
     ctx.rotate(rotation * Math.PI / 180);
-    // Draw base shape
-    ctx.fillStyle = fillColor;
+    // Glow / shadow effect
+    if (glowRadius > 0) {
+        ctx.shadowBlur = glowRadius;
+        ctx.shadowColor = glowColor || fillColor;
+        ctx.shadowOffsetX = 0;
+        ctx.shadowOffsetY = 0;
+    }
+    // Gradient fill or flat fill
+    if (gradientFillEnd) {
+        const grad = ctx.createRadialGradient(0, 0, 0, 0, 0, size / 2);
+        grad.addColorStop(0, fillColor);
+        grad.addColorStop(1, gradientFillEnd);
+        ctx.fillStyle = grad;
+    } else ctx.fillStyle = fillColor;
     ctx.strokeStyle = strokeColor;
     ctx.lineWidth = strokeWidth;
-    const drawFunction = (0, $e41b41d8dcf837ad$export$4ff7fc6f1af248b5)[shape];
-    if (drawFunction) drawFunction(ctx, size);
+    const drawFunction = (0, $701ba7c7229ef06d$export$4ff7fc6f1af248b5)[shape];
+    if (drawFunction) {
+        drawFunction(ctx, size);
+        ctx.fill();
+        ctx.stroke();
+    }
+    // Reset shadow so patterns aren't double-glowed
+    if (glowRadius > 0) ctx.shadowBlur = 0;
     // Layer additional patterns if specified
-    if (patterns.length > 0) (0, $616009579e3d72c5$export$da2372f11bc66b3f).layerPatterns(ctx, patterns, {
+    if (patterns.length > 0) (0, $461134e0b6ce0619$export$da2372f11bc66b3f).layerPatterns(ctx, patterns, {
         baseSize: size,
         baseOpacity: baseOpacity,
         opacityReduction: opacityReduction,
         proportionType: proportionType
     });
-    ctx.fill();
-    ctx.stroke();
     ctx.restore();
 }
 
@@ -947,133 +1017,154 @@ function $e0f99502ff383dd8$export$bb35a6995ddbf32d(ctx, shape, x, y, config) {
 
 
 /**
- * Generate an abstract art image from a git hash with custom configuration
- * @param {string} gitHash - The git hash to use as a seed
- * @param {ArtConfig} [config={}] - Configuration options
- * @returns {Buffer} PNG buffer of the generated image
- */ function $149c1bd638913645$export$491525bf12232411(gitHash, config = {}) {
-    // Default configuration
-    const defaultConfig = {
-        width: 2048,
-        height: 2048,
-        gridSize: 12,
-        layers: 2,
-        minShapeSize: 20,
-        maxShapeSize: 600,
-        baseOpacity: 0.8,
-        opacityReduction: 0.4,
-        shapesPerLayer: 0
-    };
-    // Merge provided config with defaults
+ * Configuration options for image generation.
+ */ const $2bfb6a1ccb7a82ae$export$c2f8e0cc249a8d8f = {
+    width: 2048,
+    height: 2048,
+    gridSize: 5,
+    layers: 4,
+    minShapeSize: 30,
+    maxShapeSize: 400,
+    baseOpacity: 0.7,
+    opacityReduction: 0.12,
+    shapesPerLayer: 0
+};
+
+
+function $b623126c6e9cbb71$export$29a844702096332e(ctx, gitHash, config = {}) {
     const finalConfig = {
-        ...defaultConfig,
+        ...(0, $2bfb6a1ccb7a82ae$export$c2f8e0cc249a8d8f),
         ...config
     };
     const { width: width, height: height, gridSize: gridSize, layers: layers, minShapeSize: minShapeSize, maxShapeSize: maxShapeSize, baseOpacity: baseOpacity, opacityReduction: opacityReduction } = finalConfig;
-    // Calculate shapes per layer based on grid size if not provided
     finalConfig.shapesPerLayer = finalConfig.shapesPerLayer || Math.floor(gridSize * gridSize * 1.5);
-    const canvas = (0, $hgUW1$createCanvas)(width, height);
-    const ctx = canvas.getContext("2d");
-    const colorScheme = new (0, $b5a262d09b87e373$export$ab958c550f521376)(gitHash);
-    const colors = colorScheme.getColorPalette("chakra");
-    // Create a gradient background
-    const gradient = ctx.createLinearGradient(0, 0, width, height);
-    gradient.addColorStop(0, colorScheme.baseScheme[0]);
-    gradient.addColorStop(1, colorScheme.baseScheme[1]);
+    // --- Color scheme derived from hash ---
+    const colorScheme = new (0, $9d614e7d77fc2947$export$ab958c550f521376)(gitHash);
+    const colors = colorScheme.getColors();
+    const [bgStart, bgEnd] = colorScheme.getBackgroundColors();
+    // --- Radial gradient background for depth ---
+    const cx = width / 2;
+    const cy = height / 2;
+    const bgRadius = Math.hypot(cx, cy);
+    const gradient = ctx.createRadialGradient(cx, cy, 0, cx, cy, bgRadius);
+    gradient.addColorStop(0, bgStart);
+    gradient.addColorStop(1, bgEnd);
     ctx.fillStyle = gradient;
     ctx.fillRect(0, 0, width, height);
-    const shapeNames = Object.keys((0, $e41b41d8dcf837ad$export$4ff7fc6f1af248b5));
-    const cellWidth = width / gridSize;
-    const cellHeight = height / gridSize;
-    // Scale shape sizes based on canvas dimensions
+    const shapeNames = Object.keys((0, $701ba7c7229ef06d$export$4ff7fc6f1af248b5));
     const scaleFactor = Math.min(width, height) / 1024;
     const adjustedMinSize = minShapeSize * scaleFactor;
     const adjustedMaxSize = maxShapeSize * scaleFactor;
+    // One master RNG seeded from the full hash — all randomness flows from here
+    const rng = (0, $461134e0b6ce0619$export$eaf9227667332084)((0, $461134e0b6ce0619$export$e9cc707de01b7042)(gitHash));
+    // Track shape positions for organic connecting curves later
+    const shapePositions = [];
     for(let layer = 0; layer < layers; layer++){
-        const numShapes = finalConfig.shapesPerLayer + Math.floor((0, $616009579e3d72c5$export$6b193cae730c547a)(gitHash, layer, 0, finalConfig.shapesPerLayer / 2));
-        const layerOpacity = baseOpacity - layer * opacityReduction;
+        const numShapes = finalConfig.shapesPerLayer + Math.floor(rng() * finalConfig.shapesPerLayer * 0.3);
+        // Layer opacity decays gently so all layers remain visible
+        const layerOpacity = Math.max(0.15, baseOpacity - layer * opacityReduction);
+        // Later layers use smaller shapes for depth
+        const layerSizeScale = 1 - layer * 0.15;
         for(let i = 0; i < numShapes; i++){
-            const gridX = Math.floor(i / gridSize);
-            const gridY = i % gridSize;
-            const cellOffsetX = (0, $616009579e3d72c5$export$6b193cae730c547a)(gitHash, layer * numShapes + i * 2, 0, cellWidth);
-            const cellOffsetY = (0, $616009579e3d72c5$export$6b193cae730c547a)(gitHash, layer * numShapes + i * 2 + 1, 0, cellHeight);
-            const x = gridX * cellWidth + cellOffsetX;
-            const y = gridY * cellHeight + cellOffsetY;
-            const shape = shapeNames[Math.floor((0, $616009579e3d72c5$export$6b193cae730c547a)(gitHash, layer * numShapes + i * 3, 0, shapeNames.length))];
-            const size = adjustedMinSize + (0, $616009579e3d72c5$export$6b193cae730c547a)(gitHash, layer * numShapes + i * 4, 0, adjustedMaxSize - adjustedMinSize);
-            const rotation = (0, $616009579e3d72c5$export$6b193cae730c547a)(gitHash, layer * numShapes + i * 5, 0, 360);
-            const fillColorIndex = Math.floor((0, $616009579e3d72c5$export$6b193cae730c547a)(gitHash, layer * numShapes + i * 6, 0, Object.keys(colors).length));
-            const strokeColorIndex = Math.floor((0, $616009579e3d72c5$export$6b193cae730c547a)(gitHash, layer * numShapes + i * 7, 0, Object.keys(colors).length));
-            ctx.globalAlpha = layerOpacity;
-            // drawShape(
-            //   ctx,
-            //   shape,
-            //   x,
-            //   y,
-            //   colors[fillColorIndex],
-            //   colors[strokeColorIndex],
-            //   2 * scaleFactor,
-            //   size,
-            //   rotation
-            // );
-            (0, $e0f99502ff383dd8$export$bb35a6995ddbf32d)(ctx, shape, x, y, {
-                fillColor: Object.values(colors)[fillColorIndex],
-                strokeColor: Object.values(colors)[strokeColorIndex],
-                strokeWidth: 1.5 * scaleFactor,
+            const x = rng() * width;
+            const y = rng() * height;
+            const shapeIdx = Math.floor(rng() * shapeNames.length);
+            const shape = shapeNames[shapeIdx];
+            // Shape size follows a power distribution — many small, few large
+            const sizeT = Math.pow(rng(), 1.8);
+            const size = (adjustedMinSize + sizeT * (adjustedMaxSize - adjustedMinSize)) * layerSizeScale;
+            const rotation = rng() * 360;
+            const fillColor = colors[Math.floor(rng() * colors.length)];
+            const strokeColor = colors[Math.floor(rng() * colors.length)];
+            const strokeWidth = (0.5 + rng() * 2.0) * scaleFactor;
+            ctx.globalAlpha = layerOpacity * (0.5 + rng() * 0.5);
+            (0, $9beb8f41637c29fd$export$bb35a6995ddbf32d)(ctx, shape, x, y, {
+                fillColor: fillColor,
+                strokeColor: strokeColor,
+                strokeWidth: strokeWidth,
                 size: size,
                 rotation: rotation,
-                // Optionally add pattern combinations
-                // patterns:
-                //   Math.random() > 0.7 ? PatternPresets.cosmicTree(size) : [],
                 proportionType: "GOLDEN_RATIO"
             });
+            shapePositions.push({
+                x: x,
+                y: y
+            });
         }
-        // Add connecting lines scaled to canvas size
-        ctx.globalAlpha = 0.2;
-        ctx.strokeStyle = Object.values(colors)[Object.keys(colors).length - 1];
-        ctx.lineWidth = 1 * scaleFactor;
-        const numLines = Math.floor(15 * (width * height) / 1048576);
-        for(let i = 0; i < numLines; i++){
-            const x1 = (0, $616009579e3d72c5$export$6b193cae730c547a)(gitHash, i * 4, 0, width);
-            const y1 = (0, $616009579e3d72c5$export$6b193cae730c547a)(gitHash, i * 4 + 1, 0, height);
-            const x2 = (0, $616009579e3d72c5$export$6b193cae730c547a)(gitHash, i * 4 + 2, 0, width);
-            const y2 = (0, $616009579e3d72c5$export$6b193cae730c547a)(gitHash, i * 4 + 3, 0, height);
+    }
+    // --- Organic connecting curves between nearby shapes ---
+    if (shapePositions.length > 1) {
+        const numCurves = Math.floor(8 * (width * height) / 1048576);
+        ctx.lineWidth = 0.8 * scaleFactor;
+        for(let i = 0; i < numCurves; i++){
+            const idxA = Math.floor(rng() * shapePositions.length);
+            const offset = 1 + Math.floor(rng() * Math.min(5, shapePositions.length - 1));
+            const idxB = (idxA + offset) % shapePositions.length;
+            const a = shapePositions[idxA];
+            const b = shapePositions[idxB];
+            const mx = (a.x + b.x) / 2;
+            const my = (a.y + b.y) / 2;
+            const dx = b.x - a.x;
+            const dy = b.y - a.y;
+            const dist = Math.hypot(dx, dy);
+            const bulge = (rng() - 0.5) * dist * 0.4;
+            const cpx = mx + -dy / (dist || 1) * bulge;
+            const cpy = my + dx / (dist || 1) * bulge;
+            ctx.globalAlpha = 0.08 + rng() * 0.12;
+            ctx.strokeStyle = colors[Math.floor(rng() * colors.length)];
             ctx.beginPath();
-            ctx.moveTo(x1, y1);
-            ctx.lineTo(x2, y2);
+            ctx.moveTo(a.x, a.y);
+            ctx.quadraticCurveTo(cpx, cpy, b.x, b.y);
             ctx.stroke();
         }
     }
+    ctx.globalAlpha = 1;
+}
+
+
+
+
+/**
+ * Generate an abstract art PNG buffer from a git hash (Node.js only).
+ *
+ * Uses @napi-rs/canvas under the hood to create an off-screen canvas,
+ * renders the hash-derived art, and returns the result as a PNG Buffer.
+ *
+ * @param gitHash - Hex hash string used as the deterministic seed
+ * @param config  - Partial generation config (merged with defaults)
+ * @returns PNG buffer of the generated image
+ */ function $054ab01bb585d84a$export$491525bf12232411(gitHash, config = {}) {
+    const finalConfig = {
+        ...(0, $2bfb6a1ccb7a82ae$export$c2f8e0cc249a8d8f),
+        ...config
+    };
+    const { width: width, height: height } = finalConfig;
+    const canvas = (0, $4RUNL$createCanvas)(width, height);
+    const ctx = canvas.getContext("2d");
+    (0, $b623126c6e9cbb71$export$29a844702096332e)(ctx, gitHash, finalConfig);
     return canvas.toBuffer("image/png");
 }
 /**
- * Save the generated image to a file
- * @param {Buffer} imageBuffer - The PNG buffer of the generated image
- * @param {string} outputDir - The directory to save the image
- * @param {string} gitHash - The git hash used to generate the image
- * @param {string} [label=''] - Label for the output file
- * @param {number} width - The width of the generated image
- * @param {number} height - The height of the generated image
- * @returns {string} Path to the saved image
- */ function $149c1bd638913645$export$ea0bbc160a51089a(imageBuffer, outputDir, gitHash, label = "", width, height) {
-    if (!(0, $hgUW1$fs).existsSync(outputDir)) (0, $hgUW1$fs).mkdirSync(outputDir, {
+ * Save the generated image to a file (Node.js only).
+ *
+ * @param imageBuffer - The PNG buffer of the generated image
+ * @param outputDir   - The directory to save the image
+ * @param gitHash     - The git hash used to generate the image
+ * @param label       - Optional label for the output filename
+ * @param width       - The width of the generated image
+ * @param height      - The height of the generated image
+ * @returns Path to the saved image
+ */ function $054ab01bb585d84a$export$ea0bbc160a51089a(imageBuffer, outputDir, gitHash, label = "", width, height) {
+    if (!$4RUNL$existsSync(outputDir)) $4RUNL$mkdirSync(outputDir, {
         recursive: true
     });
     const filename = label ? `${label}-${width}x${height}-${gitHash.slice(0, 8)}.png` : `${gitHash.slice(0, 8)}-${width}x${height}.png`;
-    const outputPath = (0, $hgUW1$path).join(outputDir, filename);
-    (0, $hgUW1$fs).writeFileSync(outputPath, imageBuffer);
+    const outputPath = $4RUNL$join(outputDir, filename);
+    $4RUNL$writeFileSync(outputPath, imageBuffer);
     console.log(`Generated: ${outputPath}`);
     return outputPath;
 }
- // Usage example:
- /*
-import { generateImageFromHash, saveImageToFile } from 'git-hash-art';
 
-const gitHash = '1234567890abcdef1234567890abcdef12345678';
-const imageBuffer = generateImageFromHash(gitHash, { width: 1024, height: 1024 });
-const savedImagePath = saveImageToFile(imageBuffer, './output', gitHash, 'example', 1024, 1024);
-console.log(`Image saved to: ${savedImagePath}`);
-*/ 
 
-export {$149c1bd638913645$export$491525bf12232411 as generateImageFromHash, $149c1bd638913645$export$ea0bbc160a51089a as saveImageToFile};
+export {$054ab01bb585d84a$export$491525bf12232411 as generateImageFromHash, $054ab01bb585d84a$export$ea0bbc160a51089a as saveImageToFile, $b623126c6e9cbb71$export$29a844702096332e as renderHashArt, $4e82a5352fbc7b27$export$9265403940be6b4 as PRESETS, $2bfb6a1ccb7a82ae$export$c2f8e0cc249a8d8f as DEFAULT_CONFIG};
 //# sourceMappingURL=module.js.map