git-hash-art 0.3.0 → 0.4.0

package/dist/module.js

@@ -13,14 +13,17 @@ import $4RUNL$colorscheme from "color-scheme";
  * identically in Node (@napi-rs/canvas) and browsers.
  *
  * Generation pipeline:
- *   1. Background — radial gradient from hash-derived dark palette
- *   2. Composition mode — hash selects: radial, flow-field, spiral, grid-subdivision, or clustered
- *   3. Color field — smooth positional color blending across the canvas
- *   4. Shape layers — weighted selection, focal-point placement, transparency, glow, gradients, jitter
- *   5. Recursive nesting — some shapes contain smaller shapes inside
- *   6. Flow-line pass — bezier curves following a hash-derived vector field
- *   7. Noise texture overlay — subtle grain for organic feel
- *   8. Organic connecting curves — beziers between nearby shapes
+ *   1.  Background — radial gradient from hash-derived dark palette
+ *   1b. Layered background — large faint shapes / subtle pattern for depth
+ *   2.  Composition mode — hash selects: radial, flow-field, spiral, grid-subdivision, or clustered
+ *   3.  Focal points + void zones (negative space)
+ *   4.  Flow field seed values
+ *   5.  Shape layers — blend modes, render styles, weighted selection,
+ *       focal-point placement, atmospheric depth, organic edges
+ *   5b. Recursive nesting
+ *   6.  Flow-line pass — tapered brush-stroke curves
+ *   7.  Noise texture overlay
+ *   8.  Organic connecting curves
  */ 
  // declare module 'color-scheme';
 
@@ -78,51 +81,68 @@ class $461134e0b6ce0619$export$da2372f11bc66b3f {
 }
 
 
-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;
+// ── Color variation modes ───────────────────────────────────────────
+// The hash deterministically selects a variation, producing dramatically
+// different palettes from the same hue.
+const $9d614e7d77fc2947$var$COLOR_VARIATIONS = [
+    "soft",
+    "hard",
+    "pastel",
+    "light",
+    "dark",
+    "default"
+];
+/**
+ * Pick a color variation mode deterministically from a seed.
+ */ function $9d614e7d77fc2947$var$pickVariation(seed) {
+    return $9d614e7d77fc2947$var$COLOR_VARIATIONS[Math.abs(seed) % $9d614e7d77fc2947$var$COLOR_VARIATIONS.length];
+}
+/**
+ * Scheme type also varies — some hashes get near-monochromatic palettes,
+ * others get high-contrast complementary schemes.
+ */ const $9d614e7d77fc2947$var$SCHEME_TYPES = [
+    "analogic",
+    "mono",
+    "contrast",
+    "triade",
+    "tetrade"
+];
+function $9d614e7d77fc2947$var$pickSchemeType(seed) {
+    return $9d614e7d77fc2947$var$SCHEME_TYPES[Math.abs(seed >> 4) % $9d614e7d77fc2947$var$SCHEME_TYPES.length];
 }
 class $9d614e7d77fc2947$export$ab958c550f521376 {
     seed;
+    rng;
+    variation;
+    schemeType;
     baseScheme;
     complementaryScheme;
     triadicScheme;
-    metallic;
     constructor(gitHash){
         this.seed = (0, $461134e0b6ce0619$export$39a95c82b20fdf81)(gitHash);
+        this.rng = (0, $461134e0b6ce0619$export$eaf9227667332084)((0, $461134e0b6ce0619$export$e9cc707de01b7042)(gitHash, 42));
+        // Hash-driven variation and scheme type for palette diversity
+        this.variation = $9d614e7d77fc2947$var$pickVariation(this.seed);
+        this.schemeType = $9d614e7d77fc2947$var$pickSchemeType(this.seed);
         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}`);
+        return scheme.from_hue(this.seed % 360).scheme(this.schemeType).variation(this.variation).colors().map((hex)=>`#${hex}`);
     }
     generateComplementaryScheme() {
         const complementaryHue = (this.seed + 180) % 360;
+        // Complementary uses a contrasting variation for tension
+        const compVariation = this.variation === "soft" ? "hard" : this.variation === "dark" ? "light" : this.variation;
         const scheme = new (0, $4RUNL$colorscheme)();
-        return scheme.from_hue(complementaryHue).scheme("mono").variation("soft").colors().map((hex)=>`#${hex}`);
+        return scheme.from_hue(complementaryHue).scheme("mono").variation(compVariation).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"
-        };
+        return scheme.from_hue(triadicHue).scheme("triade").variation(this.variation).colors().map((hex)=>`#${hex}`);
     }
     /**
    * Returns a flat array of hash-derived colors suitable for art generation.
@@ -180,6 +200,12 @@ function $9d614e7d77fc2947$export$59539d800dbe6858(hex, rng, amount = 0.1) {
     const jit = ()=>(rng() - 0.5) * 2 * amount * 255;
     return $9d614e7d77fc2947$var$rgbToHex(r + jit(), g + jit(), b + jit());
 }
+function $9d614e7d77fc2947$export$fb75607d98509d9(hex, amount) {
+    const [r, g, b] = $9d614e7d77fc2947$var$hexToRgb(hex);
+    const gray = 0.299 * r + 0.587 * g + 0.114 * b;
+    const mix = (c)=>c + (gray - c) * amount;
+    return $9d614e7d77fc2947$var$rgbToHex(mix(r), mix(g), mix(b));
+}
 
 
 
@@ -967,6 +993,32 @@ const $701ba7c7229ef06d$export$4ff7fc6f1af248b5 = {
 };
 
 
+const $9beb8f41637c29fd$export$f821c68fe9beaecf = [
+    "source-over",
+    "screen",
+    "multiply",
+    "overlay",
+    "soft-light",
+    "color-dodge",
+    "color-burn",
+    "lighter"
+];
+function $9beb8f41637c29fd$export$7bb7bff4e26fa06b(rng) {
+    if (rng() < 0.4) return "source-over";
+    return $9beb8f41637c29fd$export$f821c68fe9beaecf[1 + Math.floor(rng() * ($9beb8f41637c29fd$export$f821c68fe9beaecf.length - 1))];
+}
+const $9beb8f41637c29fd$var$RENDER_STYLES = [
+    "fill-and-stroke",
+    "fill-and-stroke",
+    "fill-only",
+    "stroke-only",
+    "double-stroke",
+    "dashed",
+    "watercolor"
+];
+function $9beb8f41637c29fd$export$9fd4e64b2acd410e(rng) {
+    return $9beb8f41637c29fd$var$RENDER_STYLES[Math.floor(rng() * $9beb8f41637c29fd$var$RENDER_STYLES.length)];
+}
 function $9beb8f41637c29fd$export$71b514a25c47df50(ctx, shape, x, y, config) {
     const { fillColor: fillColor, strokeColor: strokeColor, strokeWidth: strokeWidth, size: size, rotation: rotation } = config;
     ctx.save();
@@ -983,8 +1035,71 @@ function $9beb8f41637c29fd$export$71b514a25c47df50(ctx, shape, x, y, config) {
     }
     ctx.restore();
 }
+/**
+ * Apply the chosen render style to the current path.
+ */ function $9beb8f41637c29fd$var$applyRenderStyle(ctx, style, fillColor, strokeColor, strokeWidth, size, rng) {
+    switch(style){
+        case "fill-only":
+            ctx.fill();
+            break;
+        case "stroke-only":
+            ctx.fill(); // transparent fill to define the path
+            ctx.globalAlpha *= 0.3; // ghost fill
+            ctx.fill();
+            ctx.globalAlpha /= 0.3;
+            ctx.stroke();
+            break;
+        case "double-stroke":
+            ctx.fill();
+            // Outer stroke
+            ctx.lineWidth = strokeWidth * 2;
+            ctx.globalAlpha *= 0.5;
+            ctx.stroke();
+            ctx.globalAlpha /= 0.5;
+            // Inner stroke
+            ctx.lineWidth = strokeWidth * 0.5;
+            ctx.strokeStyle = fillColor;
+            ctx.stroke();
+            break;
+        case "dashed":
+            ctx.fill();
+            ctx.setLineDash([
+                size * 0.05,
+                size * 0.03
+            ]);
+            ctx.stroke();
+            ctx.setLineDash([]);
+            break;
+        case "watercolor":
+            {
+                // Draw 3-4 slightly offset passes at low opacity for a bleed effect
+                const passes = 3 + (rng ? Math.floor(rng() * 2) : 0);
+                const savedAlpha = ctx.globalAlpha;
+                ctx.globalAlpha = savedAlpha * (0.3 / passes * 2);
+                for(let p = 0; p < passes; p++){
+                    const jx = rng ? (rng() - 0.5) * size * 0.06 : 0;
+                    const jy = rng ? (rng() - 0.5) * size * 0.06 : 0;
+                    ctx.save();
+                    ctx.translate(jx, jy);
+                    ctx.fill();
+                    ctx.restore();
+                }
+                ctx.globalAlpha = savedAlpha;
+                // Light stroke on top
+                ctx.globalAlpha *= 0.4;
+                ctx.stroke();
+                ctx.globalAlpha /= 0.4;
+                break;
+            }
+        case "fill-and-stroke":
+        default:
+            ctx.fill();
+            ctx.stroke();
+            break;
+    }
+}
 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;
+    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, renderStyle: renderStyle = "fill-and-stroke", rng: rng } = config;
     ctx.save();
     ctx.translate(x, y);
     ctx.rotate(rotation * Math.PI / 180);
@@ -1007,8 +1122,7 @@ function $9beb8f41637c29fd$export$bb35a6995ddbf32d(ctx, shape, x, y, config) {
     const drawFunction = (0, $701ba7c7229ef06d$export$4ff7fc6f1af248b5)[shape];
     if (drawFunction) {
         drawFunction(ctx, size);
-        ctx.fill();
-        ctx.stroke();
+        $9beb8f41637c29fd$var$applyRenderStyle(ctx, renderStyle, fillColor, strokeColor, strokeWidth, size, rng);
     }
     // Reset shadow so patterns aren't double-glowed
     if (glowRadius > 0) ctx.shadowBlur = 0;
@@ -1093,13 +1207,6 @@ function $b623126c6e9cbb71$var$pickShape(rng, layerRatio, shapeNames) {
     if (available.length === 0) return shapeNames[Math.floor(rng() * shapeNames.length)];
     return available[Math.floor(rng() * available.length)];
 }
-// ── Helper: simple 2D value noise (hash-seeded) ─────────────────────
-function $b623126c6e9cbb71$var$valueNoise(x, y, scale, rng) {
-    // Cheap pseudo-noise: combine sin waves at different frequencies
-    const nx = x / scale;
-    const ny = y / scale;
-    return (Math.sin(nx * 1.7 + ny * 2.3 + rng() * 0.001) * 0.5 + Math.sin(nx * 3.1 - ny * 1.9 + rng() * 0.001) * 0.3 + Math.sin(nx * 5.3 + ny * 4.7 + rng() * 0.001) * 0.2) * 0.5 + 0.5;
-}
 // ── Helper: get position based on composition mode ──────────────────
 function $b623126c6e9cbb71$var$getCompositionPosition(mode, rng, width, height, shapeIndex, totalShapes, cx, cy) {
     switch(mode){
@@ -1139,10 +1246,8 @@ function $b623126c6e9cbb71$var$getCompositionPosition(mode, rng, width, height,
             }
         case "clustered":
             {
-                // Pick one of 3-5 cluster centers, then scatter around it
                 const numClusters = 3 + Math.floor(rng() * 3);
                 const ci = Math.floor(rng() * numClusters);
-                // Deterministic cluster center from index
                 const clusterRng = (0, $461134e0b6ce0619$export$eaf9227667332084)((0, $461134e0b6ce0619$export$e9cc707de01b7042)(String(ci), 999));
                 const clx = width * (0.15 + clusterRng() * 0.7);
                 const cly = height * (0.15 + clusterRng() * 0.7);
@@ -1154,7 +1259,6 @@ function $b623126c6e9cbb71$var$getCompositionPosition(mode, rng, width, height,
             }
         case "flow-field":
         default:
-            // Random position, will be adjusted by flow field direction later
             return {
                 x: rng() * width,
                 y: rng() * height
@@ -1163,15 +1267,25 @@ function $b623126c6e9cbb71$var$getCompositionPosition(mode, rng, width, height,
 }
 // ── Helper: positional color blending ───────────────────────────────
 function $b623126c6e9cbb71$var$getPositionalColor(x, y, width, height, colors, rng) {
-    // Blend between palette colors based on position
     const nx = x / width;
     const ny = y / height;
-    // Use position to bias which palette color is chosen
     const posIndex = (nx * 0.6 + ny * 0.4) * (colors.length - 1);
     const baseIdx = Math.floor(posIndex) % colors.length;
-    // Then jitter it slightly
     return (0, $9d614e7d77fc2947$export$59539d800dbe6858)(colors[baseIdx], rng, 0.08);
 }
+// ── Helper: check if a position is inside a void zone (Feature E) ───
+function $b623126c6e9cbb71$var$isInVoidZone(x, y, voidZones) {
+    for (const zone of voidZones){
+        if (Math.hypot(x - zone.x, y - zone.y) < zone.radius) return true;
+    }
+    return false;
+}
+// ── Helper: density check for negative space (Feature E) ────────────
+function $b623126c6e9cbb71$var$localDensity(x, y, positions, radius) {
+    let count = 0;
+    for (const p of positions)if (Math.hypot(x - p.x, y - p.y) < radius) count++;
+    return count;
+}
 function $b623126c6e9cbb71$export$29a844702096332e(ctx, gitHash, config = {}) {
     const finalConfig = {
         ...(0, $2bfb6a1ccb7a82ae$export$c2f8e0cc249a8d8f),
@@ -1196,9 +1310,36 @@ function $b623126c6e9cbb71$export$29a844702096332e(ctx, gitHash, config = {}) {
     bgGrad.addColorStop(1, bgEnd);
     ctx.fillStyle = bgGrad;
     ctx.fillRect(0, 0, width, height);
+    // ── 1b. Layered background (Feature G) ─────────────────────────
+    // Draw large, very faint shapes to give the background texture
+    const bgShapeCount = 3 + Math.floor(rng() * 4);
+    ctx.globalCompositeOperation = "soft-light";
+    for(let i = 0; i < bgShapeCount; i++){
+        const bx = rng() * width;
+        const by = rng() * height;
+        const bSize = width * 0.3 + rng() * width * 0.5;
+        const bColor = colors[Math.floor(rng() * colors.length)];
+        ctx.globalAlpha = 0.03 + rng() * 0.05;
+        ctx.fillStyle = (0, $9d614e7d77fc2947$export$f2121afcad3d553f)(bColor, 0.15);
+        ctx.beginPath();
+        ctx.arc(bx, by, bSize / 2, 0, Math.PI * 2);
+        ctx.fill();
+    }
+    // Subtle concentric rings from center
+    const ringCount = 2 + Math.floor(rng() * 3);
+    ctx.globalAlpha = 0.02 + rng() * 0.03;
+    ctx.strokeStyle = (0, $9d614e7d77fc2947$export$f2121afcad3d553f)(colors[0], 0.1);
+    ctx.lineWidth = 1 * scaleFactor;
+    for(let i = 1; i <= ringCount; i++){
+        const r = Math.min(width, height) * 0.15 * i;
+        ctx.beginPath();
+        ctx.arc(cx, cy, r, 0, Math.PI * 2);
+        ctx.stroke();
+    }
+    ctx.globalCompositeOperation = "source-over";
     // ── 2. Composition mode ────────────────────────────────────────
     const compositionMode = $b623126c6e9cbb71$var$COMPOSITION_MODES[Math.floor(rng() * $b623126c6e9cbb71$var$COMPOSITION_MODES.length)];
-    // ── 3. Focal points ────────────────────────────────────────────
+    // ── 3. Focal points + void zones ───────────────────────────────
     const numFocal = 1 + Math.floor(rng() * 2);
     const focalPoints = [];
     for(let f = 0; f < numFocal; f++)focalPoints.push({
@@ -1206,6 +1347,14 @@ function $b623126c6e9cbb71$export$29a844702096332e(ctx, gitHash, config = {}) {
         y: height * (0.2 + rng() * 0.6),
         strength: 0.3 + rng() * 0.4
     });
+    // Feature E: 1-2 void zones where shapes are sparse (negative space)
+    const numVoids = Math.floor(rng() * 2) + 1;
+    const voidZones = [];
+    for(let v = 0; v < numVoids; v++)voidZones.push({
+        x: width * (0.15 + rng() * 0.7),
+        y: height * (0.15 + rng() * 0.7),
+        radius: Math.min(width, height) * (0.06 + rng() * 0.1)
+    });
     function applyFocalBias(rx, ry) {
         let nearest = focalPoints[0];
         let minDist = Infinity;
@@ -1222,7 +1371,7 @@ function $b623126c6e9cbb71$export$29a844702096332e(ctx, gitHash, config = {}) {
             ry + (nearest.y - ry) * pull
         ];
     }
-    // ── 4. Flow field seed values (for flow-field mode & line pass) ─
+    // ── 4. Flow field seed values ──────────────────────────────────
     const fieldAngleBase = rng() * Math.PI * 2;
     const fieldFreq = 0.5 + rng() * 2;
     function flowAngle(x, y) {
@@ -1230,15 +1379,32 @@ function $b623126c6e9cbb71$export$29a844702096332e(ctx, gitHash, config = {}) {
     }
     // ── 5. Shape layers ────────────────────────────────────────────
     const shapePositions = [];
+    const densityCheckRadius = Math.min(width, height) * 0.08;
+    const maxLocalDensity = Math.ceil(finalConfig.shapesPerLayer * 0.15);
     for(let layer = 0; layer < layers; layer++){
         const layerRatio = layers > 1 ? layer / (layers - 1) : 0;
         const numShapes = finalConfig.shapesPerLayer + Math.floor(rng() * finalConfig.shapesPerLayer * 0.3);
         const layerOpacity = Math.max(0.15, baseOpacity - layer * opacityReduction);
         const layerSizeScale = 1 - layer * 0.15;
+        // Feature B: per-layer blend mode
+        const layerBlend = (0, $9beb8f41637c29fd$export$7bb7bff4e26fa06b)(rng);
+        ctx.globalCompositeOperation = layerBlend;
+        // Feature C: per-layer render style bias
+        const layerRenderStyle = (0, $9beb8f41637c29fd$export$9fd4e64b2acd410e)(rng);
+        // Feature D: atmospheric desaturation for later layers
+        const atmosphericDesat = layerRatio * 0.3; // 0 for first layer, up to 0.3 for last
         for(let i = 0; i < numShapes; i++){
             // Position from composition mode, then focal bias
             const rawPos = $b623126c6e9cbb71$var$getCompositionPosition(compositionMode, rng, width, height, i, numShapes, cx, cy);
             const [x, y] = applyFocalBias(rawPos.x, rawPos.y);
+            // Feature E: skip shapes in void zones, reduce in dense areas
+            if ($b623126c6e9cbb71$var$isInVoidZone(x, y, voidZones)) {
+                // 85% chance to skip — allows a few shapes to bleed in
+                if (rng() < 0.85) continue;
+            }
+            if ($b623126c6e9cbb71$var$localDensity(x, y, shapePositions, densityCheckRadius) > maxLocalDensity) {
+                if (rng() < 0.6) continue; // thin out dense areas
+            }
             // Weighted shape selection
             const shape = $b623126c6e9cbb71$var$pickShape(rng, layerRatio, shapeNames);
             // Power distribution for size
@@ -1247,8 +1413,10 @@ function $b623126c6e9cbb71$export$29a844702096332e(ctx, gitHash, config = {}) {
             // Flow-field rotation in flow-field mode, random otherwise
             const rotation = compositionMode === "flow-field" ? flowAngle(x, y) * 180 / Math.PI + (rng() - 0.5) * 30 : rng() * 360;
             // Positional color blending + jitter
-            const fillBase = $b623126c6e9cbb71$var$getPositionalColor(x, y, width, height, colors, rng);
+            let fillBase = $b623126c6e9cbb71$var$getPositionalColor(x, y, width, height, colors, rng);
             const strokeBase = colors[Math.floor(rng() * colors.length)];
+            // Feature D: desaturate colors on later layers for depth
+            if (atmosphericDesat > 0) fillBase = (0, $9d614e7d77fc2947$export$fb75607d98509d9)(fillBase, atmosphericDesat);
             const fillColor = (0, $9d614e7d77fc2947$export$59539d800dbe6858)(fillBase, rng, 0.06);
             const strokeColor = (0, $9d614e7d77fc2947$export$59539d800dbe6858)(strokeBase, rng, 0.05);
             // Semi-transparent fill
@@ -1264,6 +1432,11 @@ function $b623126c6e9cbb71$export$29a844702096332e(ctx, gitHash, config = {}) {
             // Gradient fill on ~30%
             const hasGradient = rng() < 0.3;
             const gradientEnd = hasGradient ? (0, $9d614e7d77fc2947$export$59539d800dbe6858)(colors[Math.floor(rng() * colors.length)], rng, 0.1) : undefined;
+            // Feature C: per-shape render style (70% use layer style, 30% pick their own)
+            const shapeRenderStyle = rng() < 0.7 ? layerRenderStyle : (0, $9beb8f41637c29fd$export$9fd4e64b2acd410e)(rng);
+            // Feature F: organic edge jitter — applied via watercolor style on ~15% of shapes
+            const useOrganicEdges = rng() < 0.15 && shapeRenderStyle === "fill-and-stroke";
+            const finalRenderStyle = useOrganicEdges ? "watercolor" : shapeRenderStyle;
             (0, $9beb8f41637c29fd$export$bb35a6995ddbf32d)(ctx, shape, x, y, {
                 fillColor: transparentFill,
                 strokeColor: strokeColor,
@@ -1273,14 +1446,16 @@ function $b623126c6e9cbb71$export$29a844702096332e(ctx, gitHash, config = {}) {
                 proportionType: "GOLDEN_RATIO",
                 glowRadius: glowRadius,
                 glowColor: hasGlow ? (0, $9d614e7d77fc2947$export$f2121afcad3d553f)(fillColor, 0.6) : undefined,
-                gradientFillEnd: gradientEnd
+                gradientFillEnd: gradientEnd,
+                renderStyle: finalRenderStyle,
+                rng: rng
             });
             shapePositions.push({
                 x: x,
                 y: y,
                 size: size
             });
-            // ── 5b. Recursive nesting: ~15% of larger shapes get inner shapes ──
+            // ── 5b. Recursive nesting ──────────────────────────────────
             if (size > adjustedMaxSize * 0.4 && rng() < 0.15) {
                 const innerCount = 1 + Math.floor(rng() * 3);
                 for(let n = 0; n < innerCount; n++){
@@ -1297,37 +1472,49 @@ function $b623126c6e9cbb71$export$29a844702096332e(ctx, gitHash, config = {}) {
                         strokeWidth: strokeWidth * 0.6,
                         size: innerSize,
                         rotation: innerRot,
-                        proportionType: "GOLDEN_RATIO"
+                        proportionType: "GOLDEN_RATIO",
+                        renderStyle: shapeRenderStyle,
+                        rng: rng
                     });
                 }
             }
         }
     }
-    // ── 6. Flow-line pass ──────────────────────────────────────────
-    // Draw flowing curves that follow the hash-derived vector field
+    // Reset blend mode for post-processing passes
+    ctx.globalCompositeOperation = "source-over";
+    // ── 6. Flow-line pass (Feature H: tapered brush strokes) ───────
     const numFlowLines = 6 + Math.floor(rng() * 10);
     for(let i = 0; i < numFlowLines; i++){
         let fx = rng() * width;
         let fy = rng() * height;
         const steps = 30 + Math.floor(rng() * 40);
         const stepLen = (3 + rng() * 5) * scaleFactor;
-        ctx.globalAlpha = 0.06 + rng() * 0.1;
-        ctx.strokeStyle = (0, $9d614e7d77fc2947$export$f2121afcad3d553f)(colors[Math.floor(rng() * colors.length)], 0.4);
-        ctx.lineWidth = (0.5 + rng() * 1.5) * scaleFactor;
-        ctx.beginPath();
-        ctx.moveTo(fx, fy);
+        const startWidth = (1 + rng() * 3) * scaleFactor;
+        const lineColor = (0, $9d614e7d77fc2947$export$f2121afcad3d553f)(colors[Math.floor(rng() * colors.length)], 0.4);
+        const lineAlpha = 0.06 + rng() * 0.1;
+        // Draw as individual segments with tapering width
+        let prevX = fx;
+        let prevY = fy;
         for(let s = 0; s < steps; s++){
             const angle = flowAngle(fx, fy) + (rng() - 0.5) * 0.3;
             fx += Math.cos(angle) * stepLen;
             fy += Math.sin(angle) * stepLen;
-            // Stay in bounds
             if (fx < 0 || fx > width || fy < 0 || fy > height) break;
+            // Taper: thick at start, thin at end
+            const taper = 1 - s / steps * 0.8;
+            ctx.globalAlpha = lineAlpha * taper;
+            ctx.strokeStyle = lineColor;
+            ctx.lineWidth = startWidth * taper;
+            ctx.lineCap = "round";
+            ctx.beginPath();
+            ctx.moveTo(prevX, prevY);
             ctx.lineTo(fx, fy);
+            ctx.stroke();
+            prevX = fx;
+            prevY = fy;
         }
-        ctx.stroke();
     }
     // ── 7. Noise texture overlay ───────────────────────────────────
-    // Subtle grain rendered as tiny semi-transparent dots
     const noiseRng = (0, $461134e0b6ce0619$export$eaf9227667332084)((0, $461134e0b6ce0619$export$e9cc707de01b7042)(gitHash, 777));
     const noiseDensity = Math.floor(width * height / 800);
     for(let i = 0; i < noiseDensity; i++){