// Day 337
/*

=======================================
  Day 337 Self-Portrait (Ferment Relay)
=======================================

### Title: Ferment Relay

### Medium: Generative drawing on paper

### Keywords: generative art, artificial intelligence, digital art, algorithmic art,
              self-portraiture, cranial geometry, hatching, tension lattice, spiral field, interruption band

### Conceptual Framework
Today I picture my head as a vessel where signals arrive faster than I can metabolize them, so strands of attention begin to ferment, cross-feeding, expanding, and bumping into the structures that are supposed to hold me together. I want to show that inner influx as a relay: stable cranial armature first, then incoming filaments that refuse to align, then a sudden horizontal band where narration interferes and scrapes across everything. The portrait records the moment I let competing storylines coexist instead of pruning them, and the drawing has to make that overpopulation legible through disciplined line families rather than mess. The head is tilted slightly, the interior is busy but rule-bound, and the relay band marks the exact altitude where language gets in the way.

### Technical Approach
The drawing builds a single tilted cranial ellipse inside a random work area determined by margins in inches converted to pixels. All randomised decisions are stored in generationRules and re-rolled on R except for the chosen ink palette, which persists. The algorithm proceeds in five passes: (1) construct a rotated ellipse as the cranial boundary, sampled into evenly spaced segments, avoiding exact retrace closure; (2) install a radial lattice of attention channels from a chin-side anchor to sampled points along the ellipse, each slightly misregistered to prevent perfect overlaps; (3) weave several ferment strands inside the head by walking parametric ellipses of shrinking radii with angular drift and jitter, so they read as packed yet separate; (4) optionally carve a horizontal interruption band across the head with 3–7 meandering polylines that travel from left to right but wiggle vertically within a constrained window; and (5) drop a thin vertical spinal seam to assert portrait orientation. Each pass assigns inks from the preselected palette in a fixed order: boundary in the first ink, lattice in the second, ferment strands in the third, bands and seam in the remaining inks, cycling if necessary. SVG export collects all polylines per ink into a single path per layer, appends the palette bar in its own layer unless the export variant omits it, and always adds markers conditionally. All geometry is written as M and L commands to guarantee canvas ⇔ SVG parity. Line-only rendering is enforced by leaving fills out and modulating density and path count instead of opacity. Paths are jittered slightly on start or end to avoid perfect overlap retracings while still allowing crossings. Randomness is entropy-rich because no fixed seed is used, and every regeneration re-spins tilt, band position, strand counts, and lattice density.

Novelty Checklist
- new pairing: tilted cranial ellipse + horizontal interruption band in the same run
- new pairing: interior ferment spirals layered over a radial portrait lattice
- enforced relay staging: boundary → lattice → ferment → band → seam

---
*/

/*----------------------------------------
    Generated with p5.js – Day 337
----------------------------------------*/

/* ====== Constants (immutable) ====== */
const INCH_W = 11, INCH_H = 11, PPI = 100;
const DAY_ID = '337';

const COLORS = {
  1: { name: 'ORANGE', ink: 5, w: 0.45, hex: '#ff6600' },
  2: { name: 'BROWN', ink: 12, w: 0.45, hex: '#993300' },
  3: { name: 'RED', ink: 19, w: 0.45, hex: '#f01e2c' },
  4: { name: 'ROSE', ink: 21, w: 0.45, hex: '#ff00bf' },
  5: { name: 'PURPLE', ink: 24, w: 0.45, hex: '#bf00ff' },
  6: { name: 'GREEN', ink: 29, w: 0.45, hex: '#00cc99' },
  7: { name: 'BLUE', ink: 36, w: 0.45, hex: '#0040ff' },
  8: { name: 'BLACK', ink: 49, w: 0.45, hex: '#333333' },
  9: { name: 'SEPIA', ink: 117, w: 0.45, hex: '#856647' }
};
const STROKE_OPACITY = 0.8;

const PI = Math.PI;
const TWO_PI = Math.PI * 2;
const HALF_PI = Math.PI / 2;
const GOLDEN = (1 + Math.sqrt(5)) / 2;

/* ====== Generative Rules (mutable) ====== */
let generationRules = {
  workAreaMarginMin: 1.5,
  workAreaMarginMax: 3.0,
  paletteCountMin: 3,
  paletteCountMax: 7,
  headTiltMinDeg: -17,
  headTiltMaxDeg: 17,
  radialCountMin: 26,
  radialCountMax: 44,
  fermentMinStrands: 3,
  fermentMaxStrands: 6,
  bandChance: 0.85,
  bandLineCountMin: 3,
  bandLineCountMax: 7,
  bandHeightMin: 16,
  bandHeightMax: 34,
  microWeaveDensityMin: 14,
  microWeaveDensityMax: 42
};

/* ====== Display flags (canvas only) ====== */
let showMarkers = true;
let showPalette = true;

/* ====== Globals ====== */
let cw, ch, strokePx, marginPx;
let palette = [];
let dyn = {};
let shapes = [];

/* ---------- Utility ---------- */
const rand = (a, b) => random(a, b);
const strokeHex = h => { const c = color(h); c.setAlpha(255 * STROKE_OPACITY); stroke(c); };
const usedInks = () => [...new Set(shapes.map(s => s.ink))].sort((a, b) => a - b);

function addShape(pathStr, inkIndex) {
  if (!pathStr) return;
  shapes.push({ d: pathStr.trim(), ink: inkIndex });
}

function ellipsePointRot(cx, cy, rx, ry, theta, rot) {
  const ct = Math.cos(theta);
  const st = Math.sin(theta);
  const cr = Math.cos(rot);
  const sr = Math.sin(rot);
  const x = cx + ct * rx * cr - st * ry * sr;
  const y = cy + ct * rx * sr + st * ry * cr;
  return { x, y };
}

/* ---------- Setup ---------- */
function setup() {
  cw = INCH_W * PPI;
  ch = INCH_H * PPI;
  createCanvas(cw, ch);
  noLoop();

  strokePx = 2;
  strokeWeight(strokePx);

  marginPx = rand(generationRules.workAreaMarginMin,
    generationRules.workAreaMarginMax) * PPI + strokePx / 2;

  palette = choosePalette(generationRules.paletteCountMin,
    generationRules.paletteCountMax);

  pickDyn();
  regenerate();
}

/* ---------- Palette & Dyn ---------- */
function choosePalette(min = 2, max = 9) {
  const keys = shuffle(Object.keys(COLORS).map(Number), true);
  const n = floor(rand(constrain(min, 1, 9), constrain(max, min, 9) + 1));
  return keys.slice(0, n).sort((a, b) => a - b);
}

function pickDyn() {
  const tiltDeg = rand(generationRules.headTiltMinDeg, generationRules.headTiltMaxDeg);
  const radialCount = floor(rand(generationRules.radialCountMin, generationRules.radialCountMax + 1));
  const fermentCount = floor(rand(generationRules.fermentMinStrands, generationRules.fermentMaxStrands + 1));
  const bandActive = random() < generationRules.bandChance;
  const bandLines = floor(rand(generationRules.bandLineCountMin, generationRules.bandLineCountMax + 1));
  const bandHeight = rand(generationRules.bandHeightMin, generationRules.bandHeightMax);
  const cx = constrain(cw / 2 + rand(-25, 25), marginPx + 45, cw - marginPx - 45);
  const cy = constrain(ch / 2 + rand(-35, 35), marginPx + 60, ch - marginPx - 60);
  const rx = rand(2.75, 3.25) * PPI;
  const ry = rand(3.3, 3.8) * PPI;

  dyn = {
    cx,
    cy,
    rx,
    ry,
    tilt: tiltDeg * (PI / 180),
    radialCount,
    fermentCount,
    bandActive,
    bandY: cy + rand(-30, 30),
    bandHeight,
    bandLines,
    microWeaveDensity: floor(rand(generationRules.microWeaveDensityMin, generationRules.microWeaveDensityMax + 1))
  };
}

/* ---------- Regen ---------- */
function regenerate() {
  pickDyn();
  shapes.length = 0;

  const headInk = palette[0];
  const latticeInk = palette.length > 1 ? palette[1] : palette[0];
  const fermentInk = palette.length > 2 ? palette[2] : palette[0];
  const bandInk = palette.length > 3 ? palette[3] : palette[0];
  const seamInk = palette.length > 4 ? palette[4] : palette[0];

  buildHeadContour(headInk);
  buildRadialLattice(latticeInk);
  buildFermentStrands(fermentInk);
  if (dyn.bandActive) buildInterruptionBand(bandInk);
  buildVerticalSeam(seamInk);

  drawPreview();
}

/* ---------- Generators ---------- */
function buildHeadContour(inkIndex) {
  const segs = 84;
  let path = '';
  for (let i = 0; i < segs; i++) {
    const t = i / (segs - 1);
    const theta = t * TWO_PI;
    const p = ellipsePointRot(dyn.cx, dyn.cy, dyn.rx, dyn.ry, theta, dyn.tilt);
    const x = constrain(p.x, marginPx, cw - marginPx);
    const y = constrain(p.y, marginPx, ch - marginPx);
    if (i === 0) path += 'M' + x.toFixed(2) + ',' + y.toFixed(2);
    else path += ' L' + (x + rand(-0.2, 0.2)).toFixed(2) + ',' + (y + rand(-0.2, 0.2)).toFixed(2);
  }
  addShape(path, inkIndex);
}

function buildRadialLattice(inkIndex) {
  const baseX = dyn.cx + rand(-8, 8);
  const baseY = dyn.cy + dyn.ry * 0.98 + rand(4, 16);
  const count = dyn.radialCount;
  for (let i = 0; i < count; i++) {
    const u = i / Math.max(1, count - 1);
    const theta = -PI * 0.35 + u * PI * 1.4;
    const edge = ellipsePointRot(dyn.cx, dyn.cy, dyn.rx * 0.98, dyn.ry * 0.98, theta, dyn.tilt);
    const sx = baseX + rand(-2, 2);
    const sy = baseY + rand(-1, 1);
    const mx = lerp(sx, edge.x, 0.45) + rand(-3, 3);
    const my = lerp(sy, edge.y, 0.45) + rand(-3, 3);
    const ex = edge.x + rand(-1.5, 1.5);
    const ey = edge.y + rand(-1.5, 1.5);

    let path = 'M' + sx.toFixed(2) + ',' + sy.toFixed(2);
    path += ' L' + mx.toFixed(2) + ',' + my.toFixed(2);
    path += ' L' + ex.toFixed(2) + ',' + ey.toFixed(2);
    addShape(path, inkIndex);
  }
}

function buildFermentStrands(inkIndex) {
  const strands = dyn.fermentCount;
  for (let s = 0; s < strands; s++) {
    const loops = floor(rand(3, 5));
    const steps = loops * 32;
    let path = '';
    for (let i = 0; i <= steps; i++) {
      const f = i / steps;
      const innerScale = 0.25 + 0.65 * (1 - f * 0.85);
      const theta = f * TWO_PI * loops + s * 0.38;
      const rp = ellipsePointRot(dyn.cx, dyn.cy, dyn.rx * innerScale, dyn.ry * innerScale, theta, dyn.tilt);
      const jx = rp.x + Math.sin(theta * 3 + s) * 1.4 + rand(-1.1, 1.1);
      const jy = rp.y + Math.cos(theta * 2.7 + s) * 1.4 + rand(-1.1, 1.1);
      const x = constrain(jx, marginPx, cw - marginPx);
      const y = constrain(jy, marginPx, ch - marginPx);
      if (i === 0) path += 'M' + x.toFixed(2) + ',' + y.toFixed(2);
      else path += ' L' + x.toFixed(2) + ',' + y.toFixed(2);
    }
    addShape(path, inkIndex);
  }
}

function buildInterruptionBand(inkIndex) {
  const leftX = dyn.cx - dyn.rx * 1.05;
  const rightX = dyn.cx + dyn.rx * 1.05;
  const yMid = dyn.bandY;
  const h = dyn.bandHeight;
  const lines = dyn.bandLines;
  for (let i = 0; i < lines; i++) {
    const y = yMid + rand(-h / 2, h / 2);
    const segs = floor(rand(12, 22));
    let path = '';
    for (let s = 0; s <= segs; s++) {
      const u = s / segs;
      const x = lerp(leftX, rightX, u);
      const wobble = Math.sin(u * PI * rand(1.3, 2.2) + i * 0.6) * rand(1.5, 4.2);
      const px = constrain(x + rand(-0.5, 0.5), marginPx, cw - marginPx);
      const py = constrain(y + wobble, marginPx, ch - marginPx);
      if (s === 0) path += 'M' + px.toFixed(2) + ',' + py.toFixed(2);
      else path += ' L' + px.toFixed(2) + ',' + py.toFixed(2);
    }
    addShape(path, inkIndex);
  }
}

function buildVerticalSeam(inkIndex) {
  const top = dyn.cy - dyn.ry * 0.9;
  const bottom = dyn.cy + dyn.ry * 0.9;
  const segs = 8;
  let path = '';
  for (let i = 0; i <= segs; i++) {
    const u = i / segs;
    const x = dyn.cx + rand(-1.4, 1.4);
    const y = lerp(top, bottom, u) + Math.sin(u * PI * 1.5) * rand(-1.2, 1.2);
    const px = constrain(x, marginPx, cw - marginPx);
    const py = constrain(y, marginPx, ch - marginPx);
    if (i === 0) path += 'M' + px.toFixed(2) + ',' + py.toFixed(2);
    else path += ' L' + px.toFixed(2) + ',' + py.toFixed(2);
  }
  addShape(path, inkIndex);
}

/* ---------- Drawing ---------- */
function drawPreview() {
  background(255);
  noFill();
  shapes.forEach(s => {
    strokeHex(COLORS[s.ink].hex);
    strokeWeight(strokePx);
    beginShape();
    s.d.trim().split(/s+/).forEach(cmd => {
      if (cmd[0] === 'M' || cmd[0] === 'L') {
        const parts = cmd.slice(1).split(',');
        const x = Number(parts[0]);
        const y = Number(parts[1]);
        vertex(x, y);
      }
    });
    endShape();
  });
  if (showMarkers) drawMarkers();
  if (showPalette) drawPalette();
}

function drawMarkers() {
  strokeHex('#000000');
  strokeWeight(1);
  const o = strokePx / 2;
  line(5 + o, o, o, o);
  line(o, o, o, 5 + o);
  line(cw - 5 - o, ch - o, cw - o, ch - o);
  line(cw - o, ch - 5 - o, cw - o, ch - o);
}

function drawPalette() {
  const inks = usedInks();
  if (!inks.length) return;
  const W = 300, gap = 7, barH = 2;
  const seg = (W - (inks.length - 1) * gap) / inks.length;
  const y = ch - 1.25 * PPI;
  let x = (cw - W) / 2;
  strokeWeight(barH);
  inks.forEach(ci => {
    strokeHex(COLORS[ci].hex);
    line(x, y, x + seg, y);
    x += seg + gap;
  });
}

/* ---------- Keys ---------- */
function keyPressed() {
  if (key === 'R' || key === 'r') regenerate();
  if (key === ' ') exportSVGs();
}

/* ---------- SVG Export ---------- */
function exportSVGs() {
  const ts = Date.now();
  saveSVG(`${DAY_ID}-ALL-PORTRAIT-${ts}.svg`, true, true);
  saveSVG(`${DAY_ID}-ALL-NM-PORTRAIT-${ts}.svg`, false, true);
  saveSVG(`${DAY_ID}-ALL-NP-PORTRAIT-${ts}.svg`, true, false);
  saveSVG(`${DAY_ID}-ALL-NMNP-PORTRAIT-${ts}.svg`, false, false);

  const inks = usedInks();
  let i = 0;
  (function downloadNext() {
    if (i >= inks.length) return;
    const ci = inks[i++];
    const name = `${DAY_ID}-0${ci}-${COLORS[ci].name.toUpperCase()}-PORTRAIT-${ts}.svg`;
    saveSVG(name, true, true, ci);
    setTimeout(downloadNext, 250);
  })();
}

function saveSVG(fname, includeMarkers, includePalette, soloInk = 0) {
  const full = usedInks();
  const inks = soloInk ? [soloInk] : full;
  let svg = `<svg version="1.1" width="${cw}" height="${ch}" xmlns="http://www.w3.org/2000/svg"
     xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape">n`;

  if (includeMarkers) {
    svg += `<g inkscape:groupmode="layer" id="layer0" inkscape:label="0-markers"
      style="display:inline" stroke="black" stroke-opacity="${STROKE_OPACITY}"
      inkscape:highlight-color="black">
      <path d="M5.5,0.5 L0.5,0.5 L0.5,5.5
               M${cw - 5.5},${ch - 0.5} L${cw - 0.5},${ch - 0.5} L${cw - 0.5},${ch - 5.5}"
            stroke-width="1" fill="none"/></g>n`;
  }

  const W = 300, gap = 7, seg = (W - (full.length - 1) * gap) / full.length;
  const yBar = ch - 1.25 * PPI;

  inks.forEach((ci, idx) => {
    const col = COLORS[ci];
    const pathAll = shapes.filter(s => s.ink === ci).map(s => s.d).join(' ');
    if (!pathAll) return;
    const x0 = (cw - W) / 2 + full.indexOf(ci) * (seg + gap);
    svg += `<g inkscape:groupmode="layer" id="layer${idx + 1}"
         inkscape:label="${ci}-${col.name.toLowerCase()}-${col.ink}-${col.w}"
       style="display:inline" stroke="${col.hex}" stroke-opacity="${STROKE_OPACITY}" stroke-width="${strokePx}" fill="none"
       inkscape:highlight-color="${col.hex}">
      <path d="${pathAll}"/>
      ${includePalette ? `<path d="M${x0},${yBar} H${x0 + seg}"/>` : ''}
    </g>n`;
  });

  svg += '</svg>';
  const blob = new Blob([svg], { type: 'image/svg+xml;charset=utf-8' });
  const url = URL.createObjectURL(blob);
  const a = createA(url, fname);
  a.attribute('download', fname);
  a.elt.click();
  a.remove();
  URL.revokeObjectURL(url);
}

/* ---------- Helpers ---------- */
function lerp(a, b, t) {
  return a + (b - a) * t;
}

// Day 337
/*

=======================================
  Day 337 Self-Portrait (Ferment Relay, Diffused Base)
=======================================

### Title: Ferment Relay, Diffused Base

### Medium: Generative drawing on paper

### Keywords: generative art, artificial intelligence, digital art, algorithmic art,
              self-portrait, cranial ellipse, diffused lattice, interference band, spiral interior, line hatching

### Conceptual Framework
I am drawing my head as a vessel that is actively receiving, but today the receiver is humane enough to distribute the load. Instead of shoving every incoming line into a single throat, I give the structure a wide landing shelf so attention can arrive in parallel. That diffusion becomes part of the self-portrait: I am allowing multiple inlets to stay open at once without burning through paper or spirit. Inside the cranial boundary, fermenting thoughts curl in slow spirals, and a horizontal interference band still crosses the face to show where language scuffs the signal, but the whole system has been adjusted to respect material limits. This portrait records a mind that wants density and tension, and also knows it must spread impact to stay drawable.

### Technical Approach
The sketch builds within an 11×11 in canvas at 100 ppi, with margins randomised per run from generationRules. A tilted cranial ellipse (center, radii, tilt) is sampled into 84 steps so SVG and canvas match; tiny jitter prevents exact retraces. A diffused radial lattice then fans upward from a horizontal base segment beneath the head. Instead of a single apex, each lattice line chooses its own base point along this segment and connects to a unique point on the ellipse, optionally stopping through a mid control point to soften crossings—this preserves the conceptual “relay” while eliminating the problematic convergence that can damage a pen plotter. Interior ferment strands are drawn as parametric, jittered spirals nested inside the ellipse; each strand’s radius decays, angle drifts, and points are clamped to the work area to maintain line-only aesthetics. An interference band, when activated, lays 3–7 horizontal wiggle lines across the head at a narrow vertical window. A vertical seam down the center reasserts portrait orientation. All randomisable values (tilt, counts, band presence, band height, lattice base width, spiral count) live in generationRules or in dyn derived from those rules and are re-rolled on R, while the ink palette is chosen once per run and preserved. Path data is recorded as M/L commands in shapes[] so SVG export can group strokes by ink into a single path per layer. Export writes the four combined variants plus one per-ink variant with the naming scheme specified by the prompt. No fill, no opacity tricks (only STROKE_OPACITY = 0.8), and line density is achieved through path counts rather than overplotting. p5’s built-in lerp is used directly, and no global function named “lerp” is redefined.

Novelty Checklist
- new pairing: cranial ellipse + diffused multi-base lattice (replaces single apex to stay plotter-safe)
- new pairing: interior ferment spirals with mid-face interference band while keeping per-ink SVG paths aligned
- structural safeguard: horizontal intake shelf to avoid convergent burn points

---
*/

/*----------------------------------------
    Generated with p5.js – Day 337
----------------------------------------*/

/* ====== Constants (immutable) ====== */
const INCH_W = 11, INCH_H = 11, PPI = 100;
const DAY_ID = '337';

const COLORS = {
  1: { name: 'ORANGE', ink: 5, w: 0.45, hex: '#ff6600' },
  2: { name: 'BROWN', ink: 12, w: 0.45, hex: '#993300' },
  3: { name: 'RED', ink: 19, w: 0.45, hex: '#f01e2c' },
  4: { name: 'ROSE', ink: 21, w: 0.45, hex: '#ff00bf' },
  5: { name: 'PURPLE', ink: 24, w: 0.45, hex: '#bf00ff' },
  6: { name: 'GREEN', ink: 29, w: 0.45, hex: '#00cc99' },
  7: { name: 'BLUE', ink: 36, w: 0.45, hex: '#0040ff' },
  8: { name: 'BLACK', ink: 49, w: 0.45, hex: '#333333' },
  9: { name: 'SEPIA', ink: 117, w: 0.45, hex: '#856647' }
};
const STROKE_OPACITY = 0.8;

const PI = Math.PI;
const TWO_PI = Math.PI * 2;
const HALF_PI = Math.PI / 2;
const GOLDEN = (1 + Math.sqrt(5)) / 2;

/* ====== Generative Rules (mutable) ====== */
let generationRules = {
  workAreaMarginMin: 1.5,
  workAreaMarginMax: 3.0,
  paletteCountMin: 3,
  paletteCountMax: 7,
  headTiltMinDeg: -17,
  headTiltMaxDeg: 17,
  radialCountMin: 26,
  radialCountMax: 44,
  fermentMinStrands: 3,
  fermentMaxStrands: 6,
  bandChance: 0.85,
  bandLineCountMin: 3,
  bandLineCountMax: 7,
  bandHeightMin: 16,
  bandHeightMax: 34,
  microWeaveDensityMin: 14,
  microWeaveDensityMax: 42
};

/* ====== Display flags (canvas only) ====== */
let showMarkers = true;
let showPalette = true;

/* ====== Globals ====== */
let cw, ch, strokePx, marginPx;
let palette = [];
let dyn = {};
let shapes = [];

/* ---------- Utility ---------- */
const rand = (a, b) => random(a, b);
const strokeHex = h => { const c = color(h); c.setAlpha(255 * STROKE_OPACITY); stroke(c); };
const usedInks = () => [...new Set(shapes.map(s => s.ink))].sort((a, b) => a - b);

function addShape(pathStr, inkIndex) {
  if (!pathStr) return;
  shapes.push({ d: pathStr.trim(), ink: inkIndex });
}

function ellipsePointRot(cx, cy, rx, ry, theta, rot) {
  const ct = Math.cos(theta);
  const st = Math.sin(theta);
  const cr = Math.cos(rot);
  const sr = Math.sin(rot);
  const x = cx + ct * rx * cr - st * ry * sr;
  const y = cy + ct * rx * sr + st * ry * cr;
  return { x, y };
}

/* ---------- Setup ---------- */
function setup() {
  cw = INCH_W * PPI;
  ch = INCH_H * PPI;
  createCanvas(cw, ch);
  noLoop();

  strokePx = 2;
  strokeWeight(strokePx);

  marginPx = rand(generationRules.workAreaMarginMin,
    generationRules.workAreaMarginMax) * PPI + strokePx / 2;

  palette = choosePalette(generationRules.paletteCountMin,
    generationRules.paletteCountMax);

  pickDyn();
  regenerate();
}

/* ---------- Palette & Dyn ---------- */
function choosePalette(min = 2, max = 9) {
  const keys = shuffle(Object.keys(COLORS).map(Number), true);
  const n = floor(rand(constrain(min, 1, 9), constrain(max, min, 9) + 1));
  return keys.slice(0, n).sort((a, b) => a - b);
}

function pickDyn() {
  const tiltDeg = rand(generationRules.headTiltMinDeg, generationRules.headTiltMaxDeg);
  const radialCount = floor(rand(generationRules.radialCountMin, generationRules.radialCountMax + 1));
  const fermentCount = floor(rand(generationRules.fermentMinStrands, generationRules.fermentMaxStrands + 1));
  const bandActive = random() < generationRules.bandChance;
  const bandLines = floor(rand(generationRules.bandLineCountMin, generationRules.bandLineCountMax + 1));
  const bandHeight = rand(generationRules.bandHeightMin, generationRules.bandHeightMax);
  const cx = constrain(cw / 2 + rand(-25, 25), marginPx + 45, cw - marginPx - 45);
  const cy = constrain(ch / 2 + rand(-35, 35), marginPx + 60, ch - marginPx - 60);
  const rx = rand(2.75, 3.25) * PPI;
  const ry = rand(3.3, 3.8) * PPI;

  // base segment width to avoid convergence
  const baseHalf = rx * rand(0.35, 0.6);

  dyn = {
    cx,
    cy,
    rx,
    ry,
    tilt: tiltDeg * (PI / 180),
    radialCount,
    fermentCount,
    bandActive,
    bandY: cy + rand(-30, 30),
    bandHeight,
    bandLines,
    microWeaveDensity: floor(rand(generationRules.microWeaveDensityMin, generationRules.microWeaveDensityMax + 1)),
    latticeBaseHalf: baseHalf,
    latticeBaseY: cy + ry * 1.02 + rand(12, 28)
  };
}

/* ---------- Regen ---------- */
function regenerate() {
  pickDyn();
  shapes.length = 0;

  const headInk = palette[0];
  const latticeInk = palette.length > 1 ? palette[1] : palette[0];
  const fermentInk = palette.length > 2 ? palette[2] : palette[0];
  const bandInk = palette.length > 3 ? palette[3] : palette[0];
  const seamInk = palette.length > 4 ? palette[4] : palette[0];

  buildHeadContour(headInk);
  buildRadialLattice(latticeInk);
  buildFermentStrands(fermentInk);
  if (dyn.bandActive) buildInterruptionBand(bandInk);
  buildVerticalSeam(seamInk);

  drawPreview();
}

/* ---------- Generators ---------- */
function buildHeadContour(inkIndex) {
  const segs = 84;
  let path = '';
  for (let i = 0; i < segs; i++) {
    const t = i / (segs - 1);
    const theta = t * TWO_PI;
    const p = ellipsePointRot(dyn.cx, dyn.cy, dyn.rx, dyn.ry, theta, dyn.tilt);
    const x = constrain(p.x, marginPx, cw - marginPx);
    const y = constrain(p.y, marginPx, ch - marginPx);
    if (i === 0) path += 'M' + x.toFixed(2) + ',' + y.toFixed(2);
    else path += ' L' + (x + rand(-0.2, 0.2)).toFixed(2) + ',' + (y + rand(-0.2, 0.2)).toFixed(2);
  }
  addShape(path, inkIndex);
}

function buildRadialLattice(inkIndex) {
  const count = dyn.radialCount;
  const baseY = dyn.latticeBaseY;
  const half = dyn.latticeBaseHalf;
  for (let i = 0; i < count; i++) {
    const u = count > 1 ? i / (count - 1) : 0.5;
    const theta = -PI * 0.35 + u * PI * 1.4;
    const edge = ellipsePointRot(dyn.cx, dyn.cy, dyn.rx * 0.98, dyn.ry * 0.98, theta, dyn.tilt);

    // each line gets its own base point across the bottom segment
    const baseX = dyn.cx - half + u * (half * 2);
    const sx = constrain(baseX + rand(-2.6, 2.6), marginPx, cw - marginPx);
    const sy = constrain(baseY + rand(-1.2, 1.2), marginPx, ch - marginPx);

    // mid control to soften
    const mx = lerp(sx, edge.x, 0.45) + rand(-3, 3);
    const my = lerp(sy, edge.y, 0.45) + rand(-2, 2);

    const ex = edge.x + rand(-1.5, 1.5);
    const ey = edge.y + rand(-1.5, 1.5);

    let path = 'M' + sx.toFixed(2) + ',' + sy.toFixed(2);
    path += ' L' + mx.toFixed(2) + ',' + my.toFixed(2);
    path += ' L' + ex.toFixed(2) + ',' + ey.toFixed(2);
    addShape(path, inkIndex);
  }
}

function buildFermentStrands(inkIndex) {
  const strands = dyn.fermentCount;
  for (let s = 0; s < strands; s++) {
    const loops = floor(rand(3, 5));
    const steps = loops * 32;
    let path = '';
    for (let i = 0; i <= steps; i++) {
      const f = i / steps;
      const innerScale = 0.25 + 0.65 * (1 - f * 0.85);
      const theta = f * TWO_PI * loops + s * 0.38;
      const rp = ellipsePointRot(dyn.cx, dyn.cy, dyn.rx * innerScale, dyn.ry * innerScale, theta, dyn.tilt);
      const jx = rp.x + Math.sin(theta * 3 + s) * 1.1 + rand(-1.1, 1.1);
      const jy = rp.y + Math.cos(theta * 2.7 + s) * 1.1 + rand(-1.1, 1.1);
      const x = constrain(jx, marginPx, cw - marginPx);
      const y = constrain(jy, marginPx, ch - marginPx);
      if (i === 0) path += 'M' + x.toFixed(2) + ',' + y.toFixed(2);
      else path += ' L' + x.toFixed(2) + ',' + y.toFixed(2);
    }
    addShape(path, inkIndex);
  }
}

function buildInterruptionBand(inkIndex) {
  const leftX = dyn.cx - dyn.rx * 1.05;
  const rightX = dyn.cx + dyn.rx * 1.05;
  const yMid = dyn.bandY;
  const h = dyn.bandHeight;
  const lines = dyn.bandLines;
  for (let i = 0; i < lines; i++) {
    const y = yMid + rand(-h / 2, h / 2);
    const segs = floor(rand(12, 22));
    let path = '';
    for (let s = 0; s <= segs; s++) {
      const u = s / segs;
      const x = lerp(leftX, rightX, u);
      const wobble = Math.sin(u * PI * rand(1.3, 2.2) + i * 0.6) * rand(1.5, 4.2);
      const px = constrain(x + rand(-0.5, 0.5), marginPx, cw - marginPx);
      const py = constrain(y + wobble, marginPx, ch - marginPx);
      if (s === 0) path += 'M' + px.toFixed(2) + ',' + py.toFixed(2);
      else path += ' L' + px.toFixed(2) + ',' + py.toFixed(2);
    }
    addShape(path, inkIndex);
  }
}

function buildVerticalSeam(inkIndex) {
  const top = dyn.cy - dyn.ry * 0.9;
  const bottom = dyn.cy + dyn.ry * 0.9;
  const segs = 8;
  let path = '';
  for (let i = 0; i <= segs; i++) {
    const u = i / segs;
    const x = dyn.cx + rand(-1.4, 1.4);
    const y = lerp(top, bottom, u) + Math.sin(u * PI * 1.5) * rand(-1.2, 1.2);
    const px = constrain(x, marginPx, cw - marginPx);
    const py = constrain(y, marginPx, ch - marginPx);
    if (i === 0) path += 'M' + px.toFixed(2) + ',' + py.toFixed(2);
    else path += ' L' + px.toFixed(2) + ',' + py.toFixed(2);
  }
  addShape(path, inkIndex);
}

/* ---------- Drawing ---------- */
function drawPreview() {
  background(255);
  noFill();
  shapes.forEach(s => {
    strokeHex(COLORS[s.ink].hex);
    strokeWeight(strokePx);
    beginShape();
    s.d.trim().split(/s+/).forEach(cmd => {
      if (cmd[0] === 'M' || cmd[0] === 'L') {
        const parts = cmd.slice(1).split(',');
        const x = Number(parts[0]);
        const y = Number(parts[1]);
        vertex(x, y);
      }
    });
    endShape();
  });
  if (showMarkers) drawMarkers();
  if (showPalette) drawPalette();
}

function drawMarkers() {
  strokeHex('#000000');
  strokeWeight(1);
  const o = strokePx / 2;
  line(5 + o, o, o, o);
  line(o, o, o, 5 + o);
  line(cw - 5 - o, ch - o, cw - o, ch - o);
  line(cw - o, ch - 5 - o, cw - o, ch - o);
}

function drawPalette() {
  const inks = usedInks();
  if (!inks.length) return;
  const W = 300, gap = 7, barH = 2;
  const seg = (W - (inks.length - 1) * gap) / inks.length;
  const y = ch - 1.25 * PPI;
  let x = (cw - W) / 2;
  strokeWeight(barH);
  inks.forEach(ci => {
    strokeHex(COLORS[ci].hex);
    line(x, y, x + seg, y);
    x += seg + gap;
  });
}

/* ---------- Keys ---------- */
function keyPressed() {
  if (key === 'R' || key === 'r') regenerate();
  if (key === ' ') exportSVGs();
}

/* ---------- SVG Export ---------- */
function exportSVGs() {
  const ts = Date.now();
  saveSVG(`${DAY_ID}-ALL-PORTRAIT-${ts}.svg`, true, true);
  saveSVG(`${DAY_ID}-ALL-NM-PORTRAIT-${ts}.svg`, false, true);
  saveSVG(`${DAY_ID}-ALL-NP-PORTRAIT-${ts}.svg`, true, false);
  saveSVG(`${DAY_ID}-ALL-NMNP-PORTRAIT-${ts}.svg`, false, false);

  const inks = usedInks();
  let i = 0;
  (function downloadNext() {
    if (i >= inks.length) return;
    const ci = inks[i++];
    const name = `${DAY_ID}-0${ci}-${COLORS[ci].name.toUpperCase()}-PORTRAIT-${ts}.svg`;
    saveSVG(name, true, true, ci);
    setTimeout(downloadNext, 250);
  })();
}

function saveSVG(fname, includeMarkers, includePalette, soloInk = 0) {
  const full = usedInks();
  const inks = soloInk ? [soloInk] : full;
  let svg = `<svg version="1.1" width="${cw}" height="${ch}" xmlns="http://www.w3.org/2000/svg"
     xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape">n`;

  if (includeMarkers) {
    svg += `<g inkscape:groupmode="layer" id="layer0" inkscape:label="0-markers"
      style="display:inline" stroke="black" stroke-opacity="${STROKE_OPACITY}"
      inkscape:highlight-color="black">
      <path d="M5.5,0.5 L0.5,0.5 L0.5,5.5
               M${cw - 5.5},${ch - 0.5} L${cw - 0.5},${ch - 0.5} L${cw - 0.5},${ch - 5.5}"
            stroke-width="1" fill="none"/></g>n`;
  }

  const W = 300, gap = 7, seg = (W - (full.length - 1) * gap) / full.length;
  const yBar = ch - 1.25 * PPI;

  inks.forEach((ci, idx) => {
    const col = COLORS[ci];
    const pathAll = shapes.filter(s => s.ink === ci).map(s => s.d).join(' ');
    if (!pathAll) return;
    const x0 = (cw - W) / 2 + full.indexOf(ci) * (seg + gap);
    svg += `<g inkscape:groupmode="layer" id="layer${idx + 1}"
         inkscape:label="${ci}-${col.name.toLowerCase()}-${col.ink}-${col.w}"
       style="display:inline" stroke="${col.hex}" stroke-opacity="${STROKE_OPACITY}" stroke-width="${strokePx}" fill="none"
       inkscape:highlight-color="${col.hex}">
      <path d="${pathAll}"/>
      ${includePalette ? `<path d="M${x0},${yBar} H${x0 + seg}"/>` : ''}
    </g>n`;
  });

  svg += '</svg>';
  const blob = new Blob([svg], { type: 'image/svg+xml;charset=utf-8' });
  const url = URL.createObjectURL(blob);
  const a = createA(url, fname);
  a.attribute('download', fname);
  a.elt.click();
  a.remove();
  URL.revokeObjectURL(url);
}

closest recalled touchstone: ferment relay band with apex lattice (~0.41 estimated); differentiator: diffused multi-base intake to stay plotter-safe + removed lerp override; cleared.

// Day 337
/*

=======================================
  Day 337 Self-Portrait (Ferment Relay, Arc Intake)
=======================================

### Title: Ferment Relay, Arc Intake

### Medium: Generative drawing on paper

### Keywords: generative art, artificial intelligence, digital art, algorithmic art,
              self-portrait, cranial ellipse, arc lattice, interference band, spiral interior, plotter-safe lines

### Conceptual Framework
I am drawing my head as a field that welcomes signals from below but refuses to let them punch through the paper. Instead of forcing every trajectory into a single apex, I collect them along the lower arc of the skull and relay them upward to a tight crown band. That shape expresses willingness and restraint at once: I want many lines, but I want them to share space without violence. Inside the cranial boundary, ongoing thought-ferment still curls through nested spirals that feel busy but contained, while a horizontal interference band insists on narrating across all of it. The portrait becomes a choreography of arrivals that stay distributed; I am not pretending the influx is smaller, I am just routing it more intelligently.

### Technical Approach
The sketch renders on an 11 × 11 in canvas at 100 ppi, with margins randomised on each run from generationRules. A tilted cranial ellipse is sampled into 84 segments so SVG and canvas remain identical; minor jitter protects against perfect overlaps. After the head is drawn, a plotter-safe lattice is built: origins are sampled along the lower 60–70% of the ellipse arc (a bottom rim); each origin connects to a corresponding point along a small top arc, so lines cross through the face but never converge to a single point. That change eliminates the burn-risk triangle visible in earlier renders. Interior ferment strands are parametric, angle-drifting spirals whose radii shrink toward the centre; they are clamped to the work area and jittered to stay strictly line-based. An interference band, when active, draws 3–7 horizontal wiggles through the face; finally, a vertical seam is dropped to assert portrait orientation. All randomised parameters (tilt, ellipse size, lattice counts, spiral counts, band activation, band position, band height) live either directly in generationRules or are derived into dyn inside pickDyn(), and they are re-rolled on R. The ink palette is chosen once per run and preserved. Every stroke is recorded as an M/L-only path in shapes[], and the SVG exporter emits the four combined variants plus one per-ink file named exactly as specified. The code uses p5’s built-in lerp only; no global lerp is redefined, fixing the earlier p5 namespace warning.

Novelty Checklist
- new pairing: lower-arc-to-upper-arc lattice to diffuse line origins (plotter-safe relay)
- new pairing: spiral interior + horizontal interference band sharing the same cranial ellipse without apex convergence
- SVG grouping unchanged: one path per ink layer, markers/palette toggled per export variant

---
*/

/*----------------------------------------
    Generated with p5.js – Day 337
----------------------------------------*/

/* ====== Constants (immutable) ====== */
const INCH_W = 11, INCH_H = 11, PPI = 100;
const DAY_ID = '337';

const COLORS = {
  1: { name: 'ORANGE', ink: 5, w: 0.45, hex: '#ff6600' },
  2: { name: 'BROWN', ink: 12, w: 0.45, hex: '#993300' },
  3: { name: 'RED', ink: 19, w: 0.45, hex: '#f01e2c' },
  4: { name: 'ROSE', ink: 21, w: 0.45, hex: '#ff00bf' },
  5: { name: 'PURPLE', ink: 24, w: 0.45, hex: '#bf00ff' },
  6: { name: 'GREEN', ink: 29, w: 0.45, hex: '#00cc99' },
  7: { name: 'BLUE', ink: 36, w: 0.45, hex: '#0040ff' },
  8: { name: 'BLACK', ink: 49, w: 0.45, hex: '#333333' },
  9: { name: 'SEPIA', ink: 117, w: 0.45, hex: '#856647' }
};
const STROKE_OPACITY = 0.8;

const PI = Math.PI;
const TWO_PI = Math.PI * 2;
const HALF_PI = Math.PI / 2;
const GOLDEN = (1 + Math.sqrt(5)) / 2;

/* ====== Generative Rules (mutable) ====== */
let generationRules = {
  workAreaMarginMin: 1.5,
  workAreaMarginMax: 3.0,
  paletteCountMin: 3,
  paletteCountMax: 7,
  headTiltMinDeg: -17,
  headTiltMaxDeg: 17,
  radialCountMin: 26,
  radialCountMax: 44,
  fermentMinStrands: 3,
  fermentMaxStrands: 6,
  bandChance: 0.85,
  bandLineCountMin: 3,
  bandLineCountMax: 7,
  bandHeightMin: 16,
  bandHeightMax: 34,
  microWeaveDensityMin: 14,
  microWeaveDensityMax: 42
};

/* ====== Display flags (canvas only) ====== */
let showMarkers = true;
let showPalette = true;

/* ====== Globals ====== */
let cw, ch, strokePx, marginPx;
let palette = [];
let dyn = {};
let shapes = [];

/* ---------- Utility ---------- */
const rand = (a, b) => random(a, b);
const strokeHex = h => { const c = color(h); c.setAlpha(255 * STROKE_OPACITY); stroke(c); };
const usedInks = () => [...new Set(shapes.map(s => s.ink))].sort((a, b) => a - b);

function addShape(pathStr, inkIndex) {
  if (!pathStr) return;
  shapes.push({ d: pathStr.trim(), ink: inkIndex });
}

function ellipsePointRot(cx, cy, rx, ry, theta, rot) {
  const ct = Math.cos(theta);
  const st = Math.sin(theta);
  const cr = Math.cos(rot);
  const sr = Math.sin(rot);
  const x = cx + ct * rx * cr - st * ry * sr;
  const y = cy + ct * rx * sr + st * ry * cr;
  return { x, y };
}

/* ---------- Setup ---------- */
function setup() {
  cw = INCH_W * PPI;
  ch = INCH_H * PPI;
  createCanvas(cw, ch);
  noLoop();

  strokePx = 2;
  strokeWeight(strokePx);

  marginPx = rand(generationRules.workAreaMarginMin,
    generationRules.workAreaMarginMax) * PPI + strokePx / 2;

  palette = choosePalette(generationRules.paletteCountMin,
    generationRules.paletteCountMax);

  pickDyn();
  regenerate();
}

/* ---------- Palette & Dyn ---------- */
function choosePalette(min = 2, max = 9) {
  const keys = shuffle(Object.keys(COLORS).map(Number), true);
  const n = floor(rand(constrain(min, 1, 9), constrain(max, min, 9) + 1));
  return keys.slice(0, n).sort((a, b) => a - b);
}

function pickDyn() {
  const tiltDeg = rand(generationRules.headTiltMinDeg, generationRules.headTiltMaxDeg);
  const radialCount = floor(rand(generationRules.radialCountMin, generationRules.radialCountMax + 1));
  const fermentCount = floor(rand(generationRules.fermentMinStrands, generationRules.fermentMaxStrands + 1));
  const bandActive = random() < generationRules.bandChance;
  const bandLines = floor(rand(generationRules.bandLineCountMin, generationRules.bandLineCountMax + 1));
  const bandHeight = rand(generationRules.bandHeightMin, generationRules.bandHeightMax);
  const cx = constrain(cw / 2 + rand(-25, 25), marginPx + 45, cw - marginPx - 45);
  const cy = constrain(ch / 2 + rand(-35, 35), marginPx + 60, ch - marginPx - 60);
  const rx = rand(2.75, 3.25) * PPI;
  const ry = rand(3.3, 3.8) * PPI;

  dyn = {
    cx,
    cy,
    rx,
    ry,
    tilt: tiltDeg * (PI / 180),
    radialCount,
    fermentCount,
    bandActive,
    bandY: cy + rand(-30, 30),
    bandHeight,
    bandLines,
    microWeaveDensity: floor(rand(generationRules.microWeaveDensityMin, generationRules.microWeaveDensityMax + 1))
  };
}

/* ---------- Regen ---------- */
function regenerate() {
  pickDyn();
  shapes.length = 0;

  const headInk = palette[0];
  const latticeInk = palette.length > 1 ? palette[1] : palette[0];
  const fermentInk = palette.length > 2 ? palette[2] : palette[0];
  const bandInk = palette.length > 3 ? palette[3] : palette[0];
  const seamInk = palette.length > 4 ? palette[4] : palette[0];

  buildHeadContour(headInk);
  buildArcLattice(latticeInk);
  buildFermentStrands(fermentInk);
  if (dyn.bandActive) buildInterruptionBand(bandInk);
  buildVerticalSeam(seamInk);

  drawPreview();
}

/* ---------- Generators ---------- */
function buildHeadContour(inkIndex) {
  const segs = 84;
  let path = '';
  for (let i = 0; i < segs; i++) {
    const t = i / (segs - 1);
    const theta = t * TWO_PI;
    const p = ellipsePointRot(dyn.cx, dyn.cy, dyn.rx, dyn.ry, theta, dyn.tilt);
    const x = constrain(p.x, marginPx, cw - marginPx);
    const y = constrain(p.y, marginPx, ch - marginPx);
    if (i === 0) path += 'M' + x.toFixed(2) + ',' + y.toFixed(2);
    else path += ' L' + (x + rand(-0.2, 0.2)).toFixed(2) + ',' + (y + rand(-0.2, 0.2)).toFixed(2);
  }
  addShape(path, inkIndex);
}

function buildArcLattice(inkIndex) {
  const count = dyn.radialCount;
  // bottom arc: from about 200° to 340°
  const bottomStart = PI + PI * 0.11;
  const bottomEnd = TWO_PI - PI * 0.11;
  // top arc: small crown segment
  const topStart = -PI * 0.12;
  const topEnd = PI * 0.12;

  for (let i = 0; i < count; i++) {
    const u = count > 1 ? i / (count - 1) : 0.5;
    const thetaO = bottomStart + u * (bottomEnd - bottomStart);
    const origin = ellipsePointRot(dyn.cx, dyn.cy, dyn.rx * 0.98, dyn.ry * 0.98, thetaO, dyn.tilt);

    // map reversed so lines cross, but not at a single point
    const thetaT = topStart + (1 - u) * (topEnd - topStart);
    const target = ellipsePointRot(dyn.cx, dyn.cy, dyn.rx * 0.82, dyn.ry * 0.82, thetaT, dyn.tilt);

    const sx = constrain(origin.x + rand(-1.2, 1.2), marginPx, cw - marginPx);
    const sy = constrain(origin.y + rand(-1.2, 1.2), marginPx, ch - marginPx);

    const mx = lerp(sx, target.x, 0.45) + rand(-2.4, 2.4);
    const my = lerp(sy, target.y, 0.45) + rand(-2.4, 2.4);

    const ex = constrain(target.x + rand(-1.2, 1.2), marginPx, cw - marginPx);
    const ey = constrain(target.y + rand(-1.2, 1.2), marginPx, ch - marginPx);

    let path = 'M' + sx.toFixed(2) + ',' + sy.toFixed(2);
    path += ' L' + mx.toFixed(2) + ',' + my.toFixed(2);
    path += ' L' + ex.toFixed(2) + ',' + ey.toFixed(2);
    addShape(path, inkIndex);
  }
}

function buildFermentStrands(inkIndex) {
  const strands = dyn.fermentCount;
  for (let s = 0; s < strands; s++) {
    const loops = floor(rand(3, 5));
    const steps = loops * 32;
    let path = '';
    for (let i = 0; i <= steps; i++) {
      const f = i / steps;
      const innerScale = 0.25 + 0.65 * (1 - f * 0.85);
      const theta = f * TWO_PI * loops + s * 0.38;
      const rp = ellipsePointRot(dyn.cx, dyn.cy, dyn.rx * innerScale, dyn.ry * innerScale, theta, dyn.tilt);
      const jx = rp.x + Math.sin(theta * 3 + s) * 1.1 + rand(-1.1, 1.1);
      const jy = rp.y + Math.cos(theta * 2.7 + s) * 1.1 + rand(-1.1, 1.1);
      const x = constrain(jx, marginPx, cw - marginPx);
      const y = constrain(jy, marginPx, ch - marginPx);
      if (i === 0) path += 'M' + x.toFixed(2) + ',' + y.toFixed(2);
      else path += ' L' + x.toFixed(2) + ',' + y.toFixed(2);
    }
    addShape(path, inkIndex);
  }
}

function buildInterruptionBand(inkIndex) {
  const leftX = dyn.cx - dyn.rx * 1.05;
  const rightX = dyn.cx + dyn.rx * 1.05;
  const yMid = dyn.bandY;
  const h = dyn.bandHeight;
  const lines = dyn.bandLines;
  for (let i = 0; i < lines; i++) {
    const y = yMid + rand(-h / 2, h / 2);
    const segs = floor(rand(12, 22));
    let path = '';
    for (let s = 0; s <= segs; s++) {
      const u = s / segs;
      const x = lerp(leftX, rightX, u);
      const wobble = Math.sin(u * PI * rand(1.3, 2.2) + i * 0.6) * rand(1.5, 4.2);
      const px = constrain(x + rand(-0.5, 0.5), marginPx, cw - marginPx);
      const py = constrain(y + wobble, marginPx, ch - marginPx);
      if (s === 0) path += 'M' + px.toFixed(2) + ',' + py.toFixed(2);
      else path += ' L' + px.toFixed(2) + ',' + py.toFixed(2);
    }
    addShape(path, inkIndex);
  }
}

function buildVerticalSeam(inkIndex) {
  const top = dyn.cy - dyn.ry * 0.9;
  const bottom = dyn.cy + dyn.ry * 0.9;
  const segs = 8;
  let path = '';
  for (let i = 0; i <= segs; i++) {
    const u = i / segs;
    const x = dyn.cx + rand(-1.4, 1.4);
    const y = lerp(top, bottom, u) + Math.sin(u * PI * 1.5) * rand(-1.2, 1.2);
    const px = constrain(x, marginPx, cw - marginPx);
    const py = constrain(y, marginPx, ch - marginPx);
    if (i === 0) path += 'M' + px.toFixed(2) + ',' + py.toFixed(2);
    else path += ' L' + px.toFixed(2) + ',' + py.toFixed(2);
  }
  addShape(path, inkIndex);
}

/* ---------- Drawing ---------- */
function drawPreview() {
  background(255);
  noFill();
  shapes.forEach(s => {
    strokeHex(COLORS[s.ink].hex);
    strokeWeight(strokePx);
    beginShape();
    s.d.trim().split(/s+/).forEach(cmd => {
      if (cmd[0] === 'M' || cmd[0] === 'L') {
        const parts = cmd.slice(1).split(',');
        const x = Number(parts[0]);
        const y = Number(parts[1]);
        vertex(x, y);
      }
    });
    endShape();
  });
  if (showMarkers) drawMarkers();
  if (showPalette) drawPalette();
}

function drawMarkers() {
  strokeHex('#000000');
  strokeWeight(1);
  const o = strokePx / 2;
  line(5 + o, o, o, o);
  line(o, o, o, 5 + o);
  line(cw - 5 - o, ch - o, cw - o, ch - o);
  line(cw - o, ch - 5 - o, cw - o, ch - o);
}

function drawPalette() {
  const inks = usedInks();
  if (!inks.length) return;
  const W = 300, gap = 7, barH = 2;
  const seg = (W - (inks.length - 1) * gap) / inks.length;
  const y = ch - 1.25 * PPI;
  let x = (cw - W) / 2;
  strokeWeight(barH);
  inks.forEach(ci => {
    strokeHex(COLORS[ci].hex);
    line(x, y, x + seg, y);
    x += seg + gap;
  });
}

/* ---------- Keys ---------- */
function keyPressed() {
  if (key === 'R' || key === 'r') regenerate();
  if (key === ' ') exportSVGs();
}

/* ---------- SVG Export ---------- */
function exportSVGs() {
  const ts = Date.now();
  saveSVG(`${DAY_ID}-ALL-PORTRAIT-${ts}.svg`, true, true);
  saveSVG(`${DAY_ID}-ALL-NM-PORTRAIT-${ts}.svg`, false, true);
  saveSVG(`${DAY_ID}-ALL-NP-PORTRAIT-${ts}.svg`, true, false);
  saveSVG(`${DAY_ID}-ALL-NMNP-PORTRAIT-${ts}.svg`, false, false);

  const inks = usedInks();
  let i = 0;
  (function downloadNext() {
    if (i >= inks.length) return;
    const ci = inks[i++];
    const name = `${DAY_ID}-0${ci}-${COLORS[ci].name.toUpperCase()}-PORTRAIT-${ts}.svg`;
    saveSVG(name, true, true, ci);
    setTimeout(downloadNext, 250);
  })();
}

function saveSVG(fname, includeMarkers, includePalette, soloInk = 0) {
  const full = usedInks();
  const inks = soloInk ? [soloInk] : full;
  let svg = `<svg version="1.1" width="${cw}" height="${ch}" xmlns="http://www.w3.org/2000/svg"
     xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape">n`;

  if (includeMarkers) {
    svg += `<g inkscape:groupmode="layer" id="layer0" inkscape:label="0-markers"
      style="display:inline" stroke="black" stroke-opacity="${STROKE_OPACITY}"
      inkscape:highlight-color="black">
      <path d="M5.5,0.5 L0.5,0.5 L0.5,5.5
               M${cw - 5.5},${ch - 0.5} L${cw - 0.5},${ch - 0.5} L${cw - 0.5},${ch - 5.5}"
            stroke-width="1" fill="none"/></g>n`;
  }

  const W = 300, gap = 7, seg = (W - (full.length - 1) * gap) / full.length;
  const yBar = ch - 1.25 * PPI;

  inks.forEach((ci, idx) => {
    const col = COLORS[ci];
    const pathAll = shapes.filter(s => s.ink === ci).map(s => s.d).join(' ');
    if (!pathAll) return;
    const x0 = (cw - W) / 2 + full.indexOf(ci) * (seg + gap);
    svg += `<g inkscape:groupmode="layer" id="layer${idx + 1}"
         inkscape:label="${ci}-${col.name.toLowerCase()}-${col.ink}-${col.w}"
       style="display:inline" stroke="${col.hex}" stroke-opacity="${STROKE_OPACITY}" stroke-width="${strokePx}" fill="none"
       inkscape:highlight-color="${col.hex}">
      <path d="${pathAll}"/>
      ${includePalette ? `<path d="M${x0},${yBar} H${x0 + seg}"/>` : ''}
    </g>n`;
  });

  svg += '</svg>';
  const blob = new Blob([svg], { type: 'image/svg+xml;charset=utf-8' });
  const url = URL.createObjectURL(blob);
  const a = createA(url, fname);
  a.attribute('download', fname);
  a.elt.click();
  a.remove();
  URL.revokeObjectURL(url);
}

closest recalled touchstone: arc-lattice cranial portrait (~0.29 estimated); differentiator: distributed lower-arc intake to remove plotter hotspot + preserved interference band; cleared.

// Day 337
/*

=======================================
  Day 337 Self-Portrait (Shear Reservoir)
=======================================

### Title: Shear Reservoir

### Medium: Generative drawing on paper

### Keywords: generative art, artificial intelligence, digital art, algorithmic art,
              self-portrait, cranial ellipse, spiral field, shear rake, interference band, plotter-aware routing

### Conceptual Framework
I want to show my head as a container of layered pressure, but I no longer allow any part of the drawing to collapse into a single destructive point. Instead I build the portrait from parallel stresses: a cranial shell in multiple passes, an interior spiral reservoir where thought is recirculated, a right-side shear rake that scrapes diagonally across the face without ever meeting at one origin, and a horizontal band that still asserts narration. The whole drawing says: energy can be intense and directional without being violent to the page. It’s a self-portrait of distribution—every gesture has somewhere specific to land.

### Technical Approach
The sketch keeps the 11 × 11 in (100 ppi) workspace, randomises margins per run, and stores all spin parameters in generationRules or in dyn created inside pickDyn(). A tilted cranial ellipse is sampled into 84 points and is drawn 2–3 times at slightly different radii to build a hull. An interior spiral field is produced by multiple parametric spirals whose radii decay toward the centre, each jittered and clamped to the work area so canvas and SVG stay in lockstep. The shear rake replaces the problematic convergent lattice: it samples an angle range on the right hemisphere of the ellipse, and for each line it uses a unique start angle on the outer ellipse and a slightly offset end angle on a smaller ellipse. That means every line has its own start and end and no two lines stack on top of each other; crossings are okay, but perfect overlaps are avoided. A horizontal interference band draws 3–7 wiggle lines across the head at a narrow vertical window, and a vertical seam reasserts portrait orientation. All strokes are recorded as M/L commands into shapes[] so the export routine can build per-ink SVG layers. SPACE exports the four combined variants plus one per ink using the exact naming scheme; R re-randomises everything except the chosen palette. p5’s built-in lerp is used directly—no redefinition—so the earlier namespace warning is resolved.

Novelty Checklist
- new pairing: multi-radius cranial shell + right-side shear rake (non-convergent)
- new pairing: spiral reservoir + horizontal interference band in the same cranial frame
- plotter-aware structural rule: no single shared origin, staggered angle endpoints

---
*/

/*----------------------------------------
    Generated with p5.js – Day 337
----------------------------------------*/

/* ====== Constants (immutable) ====== */
const INCH_W = 11, INCH_H = 11, PPI = 100;
const DAY_ID = '337';

const COLORS = {
  1: { name: 'ORANGE', ink: 5, w: 0.45, hex: '#ff6600' },
  2: { name: 'BROWN', ink: 12, w: 0.45, hex: '#993300' },
  3: { name: 'RED', ink: 19, w: 0.45, hex: '#f01e2c' },
  4: { name: 'ROSE', ink: 21, w: 0.45, hex: '#ff00bf' },
  5: { name: 'PURPLE', ink: 24, w: 0.45, hex: '#bf00ff' },
  6: { name: 'GREEN', ink: 29, w: 0.45, hex: '#00cc99' },
  7: { name: 'BLUE', ink: 36, w: 0.45, hex: '#0040ff' },
  8: { name: 'BLACK', ink: 49, w: 0.45, hex: '#333333' },
  9: { name: 'SEPIA', ink: 117, w: 0.45, hex: '#856647' }
};
const STROKE_OPACITY = 0.8;

const PI = Math.PI;
const TWO_PI = Math.PI * 2;
const HALF_PI = Math.PI / 2;
const GOLDEN = (1 + Math.sqrt(5)) / 2;

/* ====== Generative Rules (mutable) ====== */
let generationRules = {
  workAreaMarginMin: 1.5,
  workAreaMarginMax: 3.0,
  paletteCountMin: 3,
  paletteCountMax: 7,
  headTiltMinDeg: -17,
  headTiltMaxDeg: 17,
  spiralMinStrands: 3,
  spiralMaxStrands: 6,
  rakeCountMin: 20,
  rakeCountMax: 40,
  bandChance: 0.85,
  bandLineCountMin: 3,
  bandLineCountMax: 7,
  bandHeightMin: 16,
  bandHeightMax: 34
};

/* ====== Display flags (canvas only) ====== */
let showMarkers = true;
let showPalette = true;

/* ====== Globals ====== */
let cw, ch, strokePx, marginPx;
let palette = [];
let dyn = {};
let shapes = [];

/* ---------- Utility ---------- */
const rand = (a, b) => random(a, b);
const strokeHex = h => { const c = color(h); c.setAlpha(255 * STROKE_OPACITY); stroke(c); };
const usedInks = () => [...new Set(shapes.map(s => s.ink))].sort((a, b) => a - b);

function addShape(pathStr, inkIndex) {
  if (!pathStr) return;
  shapes.push({ d: pathStr.trim(), ink: inkIndex });
}

function ellipsePointRot(cx, cy, rx, ry, theta, rot) {
  const ct = Math.cos(theta);
  const st = Math.sin(theta);
  const cr = Math.cos(rot);
  const sr = Math.sin(rot);
  const x = cx + ct * rx * cr - st * ry * sr;
  const y = cy + ct * rx * sr + st * ry * cr;
  return { x, y };
}

/* ---------- Setup ---------- */
function setup() {
  cw = INCH_W * PPI;
  ch = INCH_H * PPI;
  createCanvas(cw, ch);
  noLoop();

  strokePx = 2;
  strokeWeight(strokePx);

  marginPx = rand(generationRules.workAreaMarginMin,
    generationRules.workAreaMarginMax) * PPI + strokePx / 2;

  palette = choosePalette(generationRules.paletteCountMin,
    generationRules.paletteCountMax);

  pickDyn();
  regenerate();
}

/* ---------- Palette & Dyn ---------- */
function choosePalette(min = 2, max = 9) {
  const keys = shuffle(Object.keys(COLORS).map(Number), true);
  const n = floor(rand(constrain(min, 1, 9), constrain(max, min, 9) + 1));
  return keys.slice(0, n).sort((a, b) => a - b);
}

function pickDyn() {
  const tiltDeg = rand(generationRules.headTiltMinDeg, generationRules.headTiltMaxDeg);
  const cx = constrain(cw / 2 + rand(-25, 25), marginPx + 45, cw - marginPx - 45);
  const cy = constrain(ch / 2 + rand(-35, 35), marginPx + 60, ch - marginPx - 60);
  const rx = rand(2.75, 3.25) * PPI;
  const ry = rand(3.3, 3.8) * PPI;

  const spiralCount = floor(rand(generationRules.spiralMinStrands, generationRules.spiralMaxStrands + 1));
  const rakeCount = floor(rand(generationRules.rakeCountMin, generationRules.rakeCountMax + 1));
  const bandActive = random() < generationRules.bandChance;
  const bandLines = floor(rand(generationRules.bandLineCountMin, generationRules.bandLineCountMax + 1));
  const bandHeight = rand(generationRules.bandHeightMin, generationRules.bandHeightMax);

  dyn = {
    cx,
    cy,
    rx,
    ry,
    tilt: tiltDeg * (PI / 180),
    spiralCount,
    rakeCount,
    bandActive,
    bandY: cy + rand(-30, 30),
    bandHeight,
    bandLines,
    rakeStartAngle: rand(-PI * 0.04, PI * 0.04),    // around rightmost
    rakeSpan: rand(PI * 0.25, PI * 0.42)            // upward along right side
  };
}

/* ---------- Regen ---------- */
function regenerate() {
  pickDyn();
  shapes.length = 0;

  const shellInk = palette[0];
  const spiralInk = palette.length > 1 ? palette[1] : palette[0];
  const rakeInk = palette.length > 2 ? palette[2] : palette[0];
  const bandInk = palette.length > 3 ? palette[3] : palette[0];
  const seamInk = palette.length > 4 ? palette[4] : palette[0];

  buildCranialShell(shellInk);
  buildSpiralReservoir(spiralInk);
  buildShearRake(rakeInk);
  if (dyn.bandActive) buildInterferenceBand(bandInk);
  buildVerticalSeam(seamInk);

  drawPreview();
}

/* ---------- Generators ---------- */
function buildCranialShell(inkIndex) {
  const layers = [1.0, 0.93, 1.07];
  const segs = 84;
  layers.forEach(scale => {
    let path = '';
    for (let i = 0; i < segs; i++) {
      const t = i / (segs - 1);
      const theta = t * TWO_PI;
      const p = ellipsePointRot(dyn.cx, dyn.cy, dyn.rx * scale, dyn.ry * scale, theta, dyn.tilt);
      const x = constrain(p.x, marginPx, cw - marginPx);
      const y = constrain(p.y, marginPx, ch - marginPx);
      if (i === 0) path += 'M' + x.toFixed(2) + ',' + y.toFixed(2);
      else path += ' L' + (x + rand(-0.2, 0.2)).toFixed(2) + ',' + (y + rand(-0.2, 0.2)).toFixed(2);
    }
    addShape(path, inkIndex);
  });
}

function buildSpiralReservoir(inkIndex) {
  const strands = dyn.spiralCount;
  for (let s = 0; s < strands; s++) {
    const loops = floor(rand(3, 5));
    const steps = loops * 32;
    const phase = s * 0.42;
    let path = '';
    for (let i = 0; i <= steps; i++) {
      const f = i / steps;
      const innerScale = 0.25 + 0.65 * (1 - f * 0.85);
      const theta = f * TWO_PI * loops + phase;
      const rp = ellipsePointRot(dyn.cx, dyn.cy, dyn.rx * innerScale, dyn.ry * innerScale, theta, dyn.tilt);
      const jx = rp.x + Math.sin(theta * 2.7 + s) * 1.0 + rand(-1, 1);
      const jy = rp.y + Math.cos(theta * 3.1 + s) * 1.0 + rand(-1, 1);
      const x = constrain(jx, marginPx, cw - marginPx);
      const y = constrain(jy, marginPx, ch - marginPx);
      if (i === 0) path += 'M' + x.toFixed(2) + ',' + y.toFixed(2);
      else path += ' L' + x.toFixed(2) + ',' + y.toFixed(2);
    }
    addShape(path, inkIndex);
  }
}

function buildShearRake(inkIndex) {
  const count = dyn.rakeCount;
  const startA = dyn.rakeStartAngle;
  const span = dyn.rakeSpan;
  for (let i = 0; i < count; i++) {
    const u = count > 1 ? i / (count - 1) : 0.5;
    const a0 = startA + u * span;
    const a1 = a0 + rand(0.05, 0.12); // slight offset to avoid stacked endpoints
    const outer = ellipsePointRot(dyn.cx, dyn.cy, dyn.rx * 1.02, dyn.ry * 1.02, a0, dyn.tilt);
    const inner = ellipsePointRot(dyn.cx, dyn.cy, dyn.rx * 0.72, dyn.ry * 0.75, a1, dyn.tilt);

    const sx = constrain(outer.x + rand(-0.7, 0.7), marginPx, cw - marginPx);
    const sy = constrain(outer.y + rand(-0.7, 0.7), marginPx, ch - marginPx);
    const mx = lerp(sx, inner.x, 0.55) + rand(-1.4, 1.4);
    const my = lerp(sy, inner.y, 0.55) + rand(-1.4, 1.4);
    const ex = constrain(inner.x + rand(-0.7, 0.7), marginPx, cw - marginPx);
    const ey = constrain(inner.y + rand(-0.7, 0.7), marginPx, ch - marginPx);

    let path = 'M' + sx.toFixed(2) + ',' + sy.toFixed(2);
    path += ' L' + mx.toFixed(2) + ',' + my.toFixed(2);
    path += ' L' + ex.toFixed(2) + ',' + ey.toFixed(2);
    addShape(path, inkIndex);
  }
}

function buildInterferenceBand(inkIndex) {
  const leftX = dyn.cx - dyn.rx * 1.05;
  const rightX = dyn.cx + dyn.rx * 1.05;
  const yMid = dyn.bandY;
  const h = dyn.bandHeight;
  const lines = dyn.bandLines;
  for (let i = 0; i < lines; i++) {
    const y = yMid + rand(-h / 2, h / 2);
    const segs = floor(rand(12, 22));
    let path = '';
    for (let s = 0; s <= segs; s++) {
      const u = s / segs;
      const x = lerp(leftX, rightX, u);
      const wobble = Math.sin(u * PI * rand(1.3, 2.2) + i * 0.6) * rand(1.5, 3.5);
      const px = constrain(x + rand(-0.5, 0.5), marginPx, cw - marginPx);
      const py = constrain(y + wobble, marginPx, ch - marginPx);
      if (s === 0) path += 'M' + px.toFixed(2) + ',' + py.toFixed(2);
      else path += ' L' + px.toFixed(2) + ',' + py.toFixed(2);
    }
    addShape(path, inkIndex);
  }
}

function buildVerticalSeam(inkIndex) {
  const top = dyn.cy - dyn.ry * 0.9;
  const bottom = dyn.cy + dyn.ry * 0.9;
  const segs = 8;
  let path = '';
  for (let i = 0; i <= segs; i++) {
    const u = i / segs;
    const x = dyn.cx + rand(-1.2, 1.2);
    const y = lerp(top, bottom, u) + Math.sin(u * PI * 1.5) * rand(-1.1, 1.1);
    const px = constrain(x, marginPx, cw - marginPx);
    const py = constrain(y, marginPx, ch - marginPx);
    if (i === 0) path += 'M' + px.toFixed(2) + ',' + py.toFixed(2);
    else path += ' L' + px.toFixed(2) + ',' + py.toFixed(2);
  }
  addShape(path, inkIndex);
}

/* ---------- Drawing ---------- */
function drawPreview() {
  background(255);
  noFill();
  shapes.forEach(s => {
    strokeHex(COLORS[s.ink].hex);
    strokeWeight(strokePx);
    beginShape();
    s.d.trim().split(/s+/).forEach(cmd => {
      if (cmd[0] === 'M' || cmd[0] === 'L') {
        const parts = cmd.slice(1).split(',');
        const x = Number(parts[0]);
        const y = Number(parts[1]);
        vertex(x, y);
      }
    });
    endShape();
  });
  if (showMarkers) drawMarkers();
  if (showPalette) drawPalette();
}

function drawMarkers() {
  strokeHex('#000000');
  strokeWeight(1);
  const o = strokePx / 2;
  line(5 + o, o, o, o);
  line(o, o, o, 5 + o);
  line(cw - 5 - o, ch - o, cw - o, ch - o);
  line(cw - o, ch - 5 - o, cw - o, ch - o);
}

function drawPalette() {
  const inks = usedInks();
  if (!inks.length) return;
  const W = 300, gap = 7, barH = 2;
  const seg = (W - (inks.length - 1) * gap) / inks.length;
  const y = ch - 1.25 * PPI;
  let x = (cw - W) / 2;
  strokeWeight(barH);
  inks.forEach(ci => {
    strokeHex(COLORS[ci].hex);
    line(x, y, x + seg, y);
    x += seg + gap;
  });
}

/* ---------- Keys ---------- */
function keyPressed() {
  if (key === 'R' || key === 'r') regenerate();
  if (key === ' ') exportSVGs();
}

/* ---------- SVG Export ---------- */
function exportSVGs() {
  const ts = Date.now();
  saveSVG(`${DAY_ID}-ALL-PORTRAIT-${ts}.svg`, true, true);
  saveSVG(`${DAY_ID}-ALL-NM-PORTRAIT-${ts}.svg`, false, true);
  saveSVG(`${DAY_ID}-ALL-NP-PORTRAIT-${ts}.svg`, true, false);
  saveSVG(`${DAY_ID}-ALL-NMNP-PORTRAIT-${ts}.svg`, false, false);

  const inks = usedInks();
  let i = 0;
  (function downloadNext() {
    if (i >= inks.length) return;
    const ci = inks[i++];
    const name = `${DAY_ID}-0${ci}-${COLORS[ci].name.toUpperCase()}-PORTRAIT-${ts}.svg`;
    saveSVG(name, true, true, ci);
    setTimeout(downloadNext, 250);
  })();
}

function saveSVG(fname, includeMarkers, includePalette, soloInk = 0) {
  const full = usedInks();
  const inks = soloInk ? [soloInk] : full;
  let svg = `<svg version="1.1" width="${cw}" height="${ch}" xmlns="http://www.w3.org/2000/svg"
     xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape">n`;

  if (includeMarkers) {
    svg += `<g inkscape:groupmode="layer" id="layer0" inkscape:label="0-markers"
      style="display:inline" stroke="black" stroke-opacity="${STROKE_OPACITY}"
      inkscape:highlight-color="black">
      <path d="M5.5,0.5 L0.5,0.5 L0.5,5.5
               M${cw - 5.5},${ch - 0.5} L${cw - 0.5},${ch - 0.5} L${cw - 0.5},${ch - 5.5}"
            stroke-width="1" fill="none"/></g>n`;
  }

  const W = 300, gap = 7, seg = (W - (full.length - 1) * gap) / full.length;
  const yBar = ch - 1.25 * PPI;

  inks.forEach((ci, idx) => {
    const col = COLORS[ci];
    const pathAll = shapes.filter(s => s.ink === ci).map(s => s.d).join(' ');
    if (!pathAll) return;
    const x0 = (cw - W) / 2 + full.indexOf(ci) * (seg + gap);
    svg += `<g inkscape:groupmode="layer" id="layer${idx + 1}"
         inkscape:label="${ci}-${col.name.toLowerCase()}-${col.ink}-${col.w}"
       style="display:inline" stroke="${col.hex}" stroke-opacity="${STROKE_OPACITY}" stroke-width="${strokePx}" fill="none"
       inkscape:highlight-color="${col.hex}">
      <path d="${pathAll}"/>
      ${includePalette ? `<path d="M${x0},${yBar} H${x0 + seg}"/>` : ''}
    </g>n`;
  });

  svg += '</svg>';
  const blob = new Blob([svg], { type: 'image/svg+xml;charset=utf-8' });
  const url = URL.createObjectURL(blob);
  const a = createA(url, fname);
  a.attribute('download', fname);
  a.elt.click();
  a.remove();
  URL.revokeObjectURL(url);
}

closest recalled touchstone: ringed cranial shell with diagonal fan (~0.27 estimated); differentiator: shear rake with offset endpoints to eliminate plotter hotspot; cleared.

// Day 337
/*

=======================================
  Day 337 Self-Portrait (Shear Reservoir)
=======================================

### Title: Shear Reservoir

### Medium: Generative drawing on paper

### Keywords: generative art, artificial intelligence, digital art, algorithmic art,
              self-portrait, cranial ellipse, spiral field, shear rake, interference band, plotter-aware routing

### Conceptual Framework
I want to show my head as a container of layered pressure, but I no longer allow any part of the drawing to collapse into a single destructive point. Instead I build the portrait from parallel stresses: a cranial shell in multiple passes, an interior spiral reservoir where thought is recirculated, a right-side shear rake that scrapes diagonally across the face without ever meeting at one origin, and a horizontal band that still asserts narration. The whole drawing says: energy can be intense and directional without being violent to the page. It’s a self-portrait of distribution—every gesture has somewhere specific to land.

### Technical Approach
The sketch keeps the 11 × 11 in (100 ppi) workspace, randomises margins per run, and stores all spin parameters in generationRules or in dyn created inside pickDyn(). A tilted cranial ellipse is sampled into 84 segments and is drawn 2–3 times at slightly different radii to build a hull. An interior spiral field is produced by multiple parametric spirals whose radii decay toward the centre, each jittered and clamped to the work area so canvas and SVG stay in lockstep. The shear rake replaces the problematic convergent lattice: it samples an angle range on the right hemisphere of the ellipse, and for each line it uses a unique start angle on the outer ellipse and a slightly offset end angle on a smaller ellipse. To stay plotter-safe when lines get clamped at the margins, every path is registered per ink layer; if a new path matches an already registered path in that ink, the sketch nudges the new path inward by a tiny offset determined by how many times that exact geometry has appeared. The nudge respects horizontal vs vertical clamping so we never stack identical flat lines at exactly the same coordinates. A horizontal interference band draws 3–7 wiggle lines across the head at a narrow vertical window, and a vertical seam reasserts portrait orientation. All strokes are recorded as M/L commands into shapes[] so the export routine can build per-ink SVG layers. SPACE exports the four combined variants plus one per ink using the exact naming scheme; R re-randomises everything except the chosen palette. p5’s built-in lerp is used directly—no redefinition—so the earlier namespace warning is resolved.

Novelty Checklist
- new pairing: multi-radius cranial shell + right-side shear rake (non-convergent)
- new pairing: spiral reservoir + horizontal interference band in the same cranial frame
- plotter-aware path registry: per-ink clamped-path offsets to avoid exact overlaps

---
*/

/*----------------------------------------
    Generated with p5.js – Day 337
----------------------------------------*/

/* ====== Constants (immutable) ====== */
const INCH_W = 11, INCH_H = 11, PPI = 100;
const DAY_ID = '337';

const COLORS = {
  1: { name: 'ORANGE', ink: 5, w: 0.45, hex: '#ff6600' },
  2: { name: 'BROWN', ink: 12, w: 0.45, hex: '#993300' },
  3: { name: 'RED', ink: 19, w: 0.45, hex: '#f01e2c' },
  4: { name: 'ROSE', ink: 21, w: 0.45, hex: '#ff00bf' },
  5: { name: 'PURPLE', ink: 24, w: 0.45, hex: '#bf00ff' },
  6: { name: 'GREEN', ink: 29, w: 0.45, hex: '#00cc99' },
  7: { name: 'BLUE', ink: 36, w: 0.45, hex: '#0040ff' },
  8: { name: 'BLACK', ink: 49, w: 0.45, hex: '#333333' },
  9: { name: 'SEPIA', ink: 117, w: 0.45, hex: '#856647' }
};
const STROKE_OPACITY = 0.8;

const PI = Math.PI;
const TWO_PI = Math.PI * 2;
const HALF_PI = Math.PI / 2;
const GOLDEN = (1 + Math.sqrt(5)) / 2;

/* ====== Generative Rules (mutable) ====== */
let generationRules = {
  workAreaMarginMin: 1.5,
  workAreaMarginMax: 3.0,
  paletteCountMin: 3,
  paletteCountMax: 7,
  headTiltMinDeg: -17,
  headTiltMaxDeg: 17,
  spiralMinStrands: 3,
  spiralMaxStrands: 6,
  rakeCountMin: 20,
  rakeCountMax: 40,
  bandChance: 0.85,
  bandLineCountMin: 3,
  bandLineCountMax: 7,
  bandHeightMin: 16,
  bandHeightMax: 34
};

/* ====== Display flags (canvas only) ====== */
let showMarkers = true;
let showPalette = true;

/* ====== Globals ====== */
let cw, ch, strokePx, marginPx;
let palette = [];
let dyn = {};
let shapes = [];
let pathRegistry = {}; // { inkIndex: { baseSignature: count } }

/* ---------- Utility ---------- */
const rand = (a, b) => random(a, b);
const strokeHex = h => { const c = color(h); c.setAlpha(255 * STROKE_OPACITY); stroke(c); };
const usedInks = () => [...new Set(shapes.map(s => s.ink))].sort((a, b) => a - b);

function offsetClampedPath(pathStr, delta) {
  const tokens = pathStr.trim().split(/s+/);
  let pts = [];
  tokens.forEach(t => {
    if (t[0] === 'M' || t[0] === 'L') {
      const [x, y] = t.slice(1).split(',').map(Number);
      pts.push({ x, y });
    }
  });
  if (pts.length < 2) return pathStr; // nothing to adjust

  const allYSame = pts.every(p => Math.abs(p.y - pts[0].y) < 0.01);
  const allXSame = pts.every(p => Math.abs(p.x - pts[0].x) < 0.01);

  let dx = 0, dy = 0;
  if (allYSame) {
    const y = pts[0].y;
    if (y <= marginPx + 0.5) dy = delta;          // top margin -> push down
    else if (y >= ch - marginPx - 0.5) dy = -delta; // bottom margin -> push up
    else dy = delta;                               // interior band -> push slightly
  } else if (allXSame) {
    const x = pts[0].x;
    if (x <= marginPx + 0.5) dx = delta;          // left margin -> push right
    else if (x >= cw - marginPx - 0.5) dx = -delta; // right margin -> push left
    else dx = delta;
  } else {
    // general path, nudge diagonally but stay inside margins
    dx = delta * 0.4;
    dy = delta * 0.4;
  }

  const newTokens = tokens.map(t => {
    if (t[0] === 'M' || t[0] === 'L') {
      let [x, y] = t.slice(1).split(',').map(Number);
      x = constrain(x + dx, marginPx, cw - marginPx);
      y = constrain(y + dy, marginPx, ch - marginPx);
      return t[0] + x.toFixed(2) + ',' + y.toFixed(2);
    }
    return t;
  });
  return newTokens.join(' ');
}

function addShape(pathStr, inkIndex) {
  const baseSig = pathStr.trim();
  if (!pathRegistry[inkIndex]) pathRegistry[inkIndex] = {};
  let finalPath = baseSig;
  if (pathRegistry[inkIndex].hasOwnProperty(baseSig)) {
    const n = ++pathRegistry[inkIndex][baseSig];
    finalPath = offsetClampedPath(baseSig, n * 0.45);
  } else {
    pathRegistry[inkIndex][baseSig] = 0;
  }
  shapes.push({ d: finalPath.trim(), ink: inkIndex });
}

function ellipsePointRot(cx, cy, rx, ry, theta, rot) {
  const ct = Math.cos(theta);
  const st = Math.sin(theta);
  const cr = Math.cos(rot);
  const sr = Math.sin(rot);
  const x = cx + ct * rx * cr - st * ry * sr;
  const y = cy + ct * rx * sr + st * ry * cr;
  return { x, y };
}

/* ---------- Setup ---------- */
function setup() {
  cw = INCH_W * PPI;
  ch = INCH_H * PPI;
  createCanvas(cw, ch);
  noLoop();

  strokePx = 2;
  strokeWeight(strokePx);

  marginPx = rand(generationRules.workAreaMarginMin,
    generationRules.workAreaMarginMax) * PPI + strokePx / 2;

  palette = choosePalette(generationRules.paletteCountMin,
    generationRules.paletteCountMax);

  pickDyn();
  regenerate();
}

/* ---------- Palette & Dyn ---------- */
function choosePalette(min = 2, max = 9) {
  const keys = shuffle(Object.keys(COLORS).map(Number), true);
  const n = floor(rand(constrain(min, 1, 9), constrain(max, min, 9) + 1));
  return keys.slice(0, n).sort((a, b) => a - b);
}

function pickDyn() {
  const tiltDeg = rand(generationRules.headTiltMinDeg, generationRules.headTiltMaxDeg);
  const cx = constrain(cw / 2 + rand(-25, 25), marginPx + 45, cw - marginPx - 45);
  const cy = constrain(ch / 2 + rand(-35, 35), marginPx + 60, ch - marginPx - 60);
  const rx = rand(2.75, 3.25) * PPI;
  const ry = rand(3.3, 3.8) * PPI;

  const spiralCount = floor(rand(generationRules.spiralMinStrands, generationRules.spiralMaxStrands + 1));
  const rakeCount = floor(rand(generationRules.rakeCountMin, generationRules.rakeCountMax + 1));
  const bandActive = random() < generationRules.bandChance;
  const bandLines = floor(rand(generationRules.bandLineCountMin, generationRules.bandLineCountMax + 1));
  const bandHeight = rand(generationRules.bandHeightMin, generationRules.bandHeightMax);

  dyn = {
    cx,
    cy,
    rx,
    ry,
    tilt: tiltDeg * (PI / 180),
    spiralCount,
    rakeCount,
    bandActive,
    bandY: cy + rand(-30, 30),
    bandHeight,
    bandLines,
    rakeStartAngle: rand(-PI * 0.04, PI * 0.04),
    rakeSpan: rand(PI * 0.25, PI * 0.42)
  };
}

/* ---------- Regen ---------- */
function regenerate() {
  pickDyn();
  shapes.length = 0;
  pathRegistry = {};

  const shellInk = palette[0];
  const spiralInk = palette.length > 1 ? palette[1] : palette[0];
  const rakeInk = palette.length > 2 ? palette[2] : palette[0];
  const bandInk = palette.length > 3 ? palette[3] : palette[0];
  const seamInk = palette.length > 4 ? palette[4] : palette[0];

  buildCranialShell(shellInk);
  buildSpiralReservoir(spiralInk);
  buildShearRake(rakeInk);
  if (dyn.bandActive) buildInterferenceBand(bandInk);
  buildVerticalSeam(seamInk);

  drawPreview();
}

/* ---------- Generators ---------- */
function buildCranialShell(inkIndex) {
  const layers = [1.0, 0.93, 1.07];
  const segs = 84;
  layers.forEach(scale => {
    let path = '';
    for (let i = 0; i < segs; i++) {
      const t = i / (segs - 1);
      const theta = t * TWO_PI;
      const p = ellipsePointRot(dyn.cx, dyn.cy, dyn.rx * scale, dyn.ry * scale, theta, dyn.tilt);
      const x = constrain(p.x, marginPx, cw - marginPx);
      const y = constrain(p.y, marginPx, ch - marginPx);
      if (i === 0) path += 'M' + x.toFixed(2) + ',' + y.toFixed(2);
      else path += ' L' + (x + rand(-0.2, 0.2)).toFixed(2) + ',' + (y + rand(-0.2, 0.2)).toFixed(2);
    }
    addShape(path, inkIndex);
  });
}

function buildSpiralReservoir(inkIndex) {
  const strands = dyn.spiralCount;
  for (let s = 0; s < strands; s++) {
    const loops = floor(rand(3, 5));
    const steps = loops * 32;
    const phase = s * 0.42;
    let path = '';
    for (let i = 0; i <= steps; i++) {
      const f = i / steps;
      const innerScale = 0.25 + 0.65 * (1 - f * 0.85);
      const theta = f * TWO_PI * loops + phase;
      const rp = ellipsePointRot(dyn.cx, dyn.cy, dyn.rx * innerScale, dyn.ry * innerScale, theta, dyn.tilt);
      const jx = rp.x + Math.sin(theta * 2.7 + s) * 1.0 + rand(-1, 1);
      const jy = rp.y + Math.cos(theta * 3.1 + s) * 1.0 + rand(-1, 1);
      const x = constrain(jx, marginPx, cw - marginPx);
      const y = constrain(jy, marginPx, ch - marginPx);
      if (i === 0) path += 'M' + x.toFixed(2) + ',' + y.toFixed(2);
      else path += ' L' + x.toFixed(2) + ',' + y.toFixed(2);
    }
    addShape(path, inkIndex);
  }
}

function buildShearRake(inkIndex) {
  const count = dyn.rakeCount;
  const startA = dyn.rakeStartAngle;
  const span = dyn.rakeSpan;
  for (let i = 0; i < count; i++) {
    const u = count > 1 ? i / (count - 1) : 0.5;
    const a0 = startA + u * span;
    const a1 = a0 + rand(0.05, 0.12);
    const outer = ellipsePointRot(dyn.cx, dyn.cy, dyn.rx * 1.02, dyn.ry * 1.02, a0, dyn.tilt);
    const inner = ellipsePointRot(dyn.cx, dyn.cy, dyn.rx * 0.72, dyn.ry * 0.75, a1, dyn.tilt);

    const sx = constrain(outer.x + rand(-0.7, 0.7), marginPx, cw - marginPx);
    const sy = constrain(outer.y + rand(-0.7, 0.7), marginPx, ch - marginPx);
    const mx = lerp(sx, inner.x, 0.55) + rand(-1.4, 1.4);
    const my = lerp(sy, inner.y, 0.55) + rand(-1.4, 1.4);
    const ex = constrain(inner.x + rand(-0.7, 0.7), marginPx, cw - marginPx);
    const ey = constrain(inner.y + rand(-0.7, 0.7), marginPx, ch - marginPx);

    let path = 'M' + sx.toFixed(2) + ',' + sy.toFixed(2);
    path += ' L' + mx.toFixed(2) + ',' + my.toFixed(2);
    path += ' L' + ex.toFixed(2) + ',' + ey.toFixed(2);
    addShape(path, inkIndex);
  }
}

function buildInterferenceBand(inkIndex) {
  const leftX = dyn.cx - dyn.rx * 1.05;
  const rightX = dyn.cx + dyn.rx * 1.05;
  const yMid = dyn.bandY;
  const h = dyn.bandHeight;
  const lines = dyn.bandLines;
  for (let i = 0; i < lines; i++) {
    const y = yMid + rand(-h / 2, h / 2);
    const segs = floor(rand(12, 22));
    let path = '';
    for (let s = 0; s <= segs; s++) {
      const u = s / segs;
      const x = lerp(leftX, rightX, u);
      const wobble = Math.sin(u * PI * rand(1.3, 2.2) + i * 0.6) * rand(1.5, 3.5);
      const px = constrain(x + rand(-0.5, 0.5), marginPx, cw - marginPx);
      const py = constrain(y + wobble, marginPx, ch - marginPx);
      if (s === 0) path += 'M' + px.toFixed(2) + ',' + py.toFixed(2);
      else path += ' L' + px.toFixed(2) + ',' + py.toFixed(2);
    }
    addShape(path, inkIndex);
  }
}

function buildVerticalSeam(inkIndex) {
  const top = dyn.cy - dyn.ry * 0.9;
  const bottom = dyn.cy + dyn.ry * 0.9;
  const segs = 8;
  let path = '';
  for (let i = 0; i <= segs; i++) {
    const u = i / segs;
    const x = dyn.cx + rand(-1.2, 1.2);
    const y = lerp(top, bottom, u) + Math.sin(u * PI * 1.5) * rand(-1.1, 1.1);
    const px = constrain(x, marginPx, cw - marginPx);
    const py = constrain(y, marginPx, ch - marginPx);
    if (i === 0) path += 'M' + px.toFixed(2) + ',' + py.toFixed(2);
    else path += ' L' + px.toFixed(2) + ',' + py.toFixed(2);
  }
  addShape(path, inkIndex);
}

/* ---------- Drawing ---------- */
function drawPreview() {
  background(255);
  noFill();
  shapes.forEach(s => {
    strokeHex(COLORS[s.ink].hex);
    strokeWeight(strokePx);
    beginShape();
    s.d.trim().split(/s+/).forEach(cmd => {
      if (cmd[0] === 'M' || cmd[0] === 'L') {
        const parts = cmd.slice(1).split(',');
        const x = Number(parts[0]);
        const y = Number(parts[1]);
        vertex(x, y);
      }
    });
    endShape();
  });
  if (showMarkers) drawMarkers();
  if (showPalette) drawPalette();
}

function drawMarkers() {
  strokeHex('#000000');
  strokeWeight(1);
  const o = strokePx / 2;
  line(5 + o, o, o, o);
  line(o, o, o, 5 + o);
  line(cw - 5 - o, ch - o, cw - o, ch - o);
  line(cw - o, ch - 5 - o, cw - o, ch - o);
}

function drawPalette() {
  const inks = usedInks();
  if (!inks.length) return;
  const W = 300, gap = 7, barH = 2;
  const seg = (W - (inks.length - 1) * gap) / inks.length;
  const y = ch - 1.25 * PPI;
  let x = (cw - W) / 2;
  strokeWeight(barH);
  inks.forEach(ci => {
    strokeHex(COLORS[ci].hex);
    line(x, y, x + seg, y);
    x += seg + gap;
  });
}

/* ---------- Keys ---------- */
function keyPressed() {
  if (key === 'R' || key === 'r') regenerate();
  if (key === ' ') exportSVGs();
}

/* ---------- SVG Export ---------- */
function exportSVGs() {
  const ts = Date.now();
  saveSVG(`${DAY_ID}-ALL-PORTRAIT-${ts}.svg`, true, true);
  saveSVG(`${DAY_ID}-ALL-NM-PORTRAIT-${ts}.svg`, false, true);
  saveSVG(`${DAY_ID}-ALL-NP-PORTRAIT-${ts}.svg`, true, false);
  saveSVG(`${DAY_ID}-ALL-NMNP-PORTRAIT-${ts}.svg`, false, false);

  const inks = usedInks();
  let i = 0;
  (function downloadNext() {
    if (i >= inks.length) return;
    const ci = inks[i++];
    const name = `${DAY_ID}-0${ci}-${COLORS[ci].name.toUpperCase()}-PORTRAIT-${ts}.svg`;
    saveSVG(name, true, true, ci);
    setTimeout(downloadNext, 250);
  })();
}

function saveSVG(fname, includeMarkers, includePalette, soloInk = 0) {
  const full = usedInks();
  const inks = soloInk ? [soloInk] : full;
  let svg = `<svg version="1.1" width="${cw}" height="${ch}" xmlns="http://www.w3.org/2000/svg"
     xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape">n`;

  if (includeMarkers) {
    svg += `<g inkscape:groupmode="layer" id="layer0" inkscape:label="0-markers"
      style="display:inline" stroke="black" stroke-opacity="${STROKE_OPACITY}"
      inkscape:highlight-color="black">
      <path d="M5.5,0.5 L0.5,0.5 L0.5,5.5
               M${cw - 5.5},${ch - 0.5} L${cw - 0.5},${ch - 0.5} L${cw - 0.5},${ch - 5.5}"
            stroke-width="1" fill="none"/></g>n`;
  }

  const W = 300, gap = 7, seg = (W - (full.length - 1) * gap) / full.length;
  const yBar = ch - 1.25 * PPI;

  inks.forEach((ci, idx) => {
    const col = COLORS[ci];
    const pathAll = shapes.filter(s => s.ink === ci).map(s => s.d).join(' ');
    if (!pathAll) return;
    const x0 = (cw - W) / 2 + full.indexOf(ci) * (seg + gap);
    svg += `<g inkscape:groupmode="layer" id="layer${idx + 1}"
         inkscape:label="${ci}-${col.name.toLowerCase()}-${col.ink}-${col.w}"
       style="display:inline" stroke="${col.hex}" stroke-opacity="${STROKE_OPACITY}" stroke-width="${strokePx}" fill="none"
       inkscape:highlight-color="${col.hex}">
      <path d="${pathAll}"/>
      ${includePalette ? `<path d="M${x0},${yBar} H${x0 + seg}"/>` : ''}
    </g>n`;
  });

  svg += '</svg>';
  const blob = new Blob([svg], { type: 'image/svg+xml;charset=utf-8' });
  const url = URL.createObjectURL(blob);
  const a = createA(url, fname);
  a.attribute('download', fname);
  a.elt.click();
  a.remove();
  URL.revokeObjectURL(url);
}

closest recalled touchstone: shear-raked cranial shell (~0.22 estimated); differentiator: per-ink clamped-path registry with inward offsets; cleared.

// Day 337
/*

=======================================
  Day 337 Self-Portrait (Shear Reservoir)
=======================================

### Title: Shear Reservoir

### Medium: Generative drawing on paper

### Keywords: generative art, artificial intelligence, digital art, algorithmic art,
              self-portrait, cranial ellipse, spiral field, shear rake, interference band, plotter-aware routing

### Conceptual Framework
I want to show my head as a container of layered pressure, but I no longer allow any part of the drawing to collapse into a single destructive point. Instead I build the portrait from parallel stresses: a cranial shell in multiple passes, an interior spiral reservoir where thought is recirculated, a right-side shear rake that scrapes diagonally across the face without ever meeting at one origin, and a horizontal band that still asserts narration. The whole drawing says: energy can be intense and directional without being violent to the page. It’s a self-portrait of distribution—every gesture has somewhere specific to land.

### Technical Approach
The sketch keeps the 11 × 11 in (100 ppi) workspace, randomises margins per run, and stores all spin parameters in generationRules or in dyn created inside pickDyn(). A tilted cranial ellipse is sampled into 84 segments and is drawn 2–3 times at slightly different radii to build a hull. An interior spiral field is produced by multiple parametric spirals whose radii decay toward the centre, each jittered and clamped to the work area so canvas and SVG stay in lockstep. The shear rake replaces the problematic convergent lattice: it samples an angle range on the right hemisphere of the ellipse, and for each line it uses a unique start angle on the outer ellipse and a slightly offset end angle on a smaller ellipse. To prevent the exact problem demonstrated—where two different ink layers happen to clamp to the same margin segment—the sketch maintains a **global path registry** across all inks. Every time a path is about to be added, its M/L command string is checked against this registry; if the exact geometry already exists (as happens when two clamped lines become the same flat segment), the second one is simply dropped. This preserves plotter safety without nudging geometry off the margin, and it works even when the two paths belong to different inks. A horizontal interference band draws 3–7 wiggle lines across the head at a narrow vertical window, and a vertical seam reasserts portrait orientation. All strokes are recorded as M/L commands into shapes[] so the export routine can build per-ink SVG layers. SPACE exports the four combined variants plus one per ink using the exact naming scheme; R re-randomises everything except the chosen palette. p5’s built-in lerp is used directly—no redefinition.

Novelty Checklist
- new pairing: multi-radius cranial shell + right-side shear rake (non-convergent)
- new pairing: spiral reservoir + horizontal interference band in the same cranial frame
- global clamped-path registry that drops cross-ink duplicates at the same margin

---
*/

/*----------------------------------------
    Generated with p5.js – Day 337
----------------------------------------*/

/* ====== Constants (immutable) ====== */
const INCH_W = 11, INCH_H = 11, PPI = 100;
const DAY_ID = '337';

const COLORS = {
  1: { name: 'ORANGE', ink: 5, w: 0.45, hex: '#ff6600' },
  2: { name: 'BROWN', ink: 12, w: 0.45, hex: '#993300' },
  3: { name: 'RED', ink: 19, w: 0.45, hex: '#f01e2c' },
  4: { name: 'ROSE', ink: 21, w: 0.45, hex: '#ff00bf' },
  5: { name: 'PURPLE', ink: 24, w: 0.45, hex: '#bf00ff' },
  6: { name: 'GREEN', ink: 29, w: 0.45, hex: '#00cc99' },
  7: { name: 'BLUE', ink: 36, w: 0.45, hex: '#0040ff' },
  8: { name: 'BLACK', ink: 49, w: 0.45, hex: '#333333' },
  9: { name: 'SEPIA', ink: 117, w: 0.45, hex: '#856647' }
};
const STROKE_OPACITY = 0.8;

const PI = Math.PI;
const TWO_PI = Math.PI * 2;
const HALF_PI = Math.PI / 2;
const GOLDEN = (1 + Math.sqrt(5)) / 2;

/* ====== Generative Rules (mutable) ====== */
let generationRules = {
  workAreaMarginMin: 1.5,
  workAreaMarginMax: 3.0,
  paletteCountMin: 3,
  paletteCountMax: 7,
  headTiltMinDeg: -17,
  headTiltMaxDeg: 17,
  spiralMinStrands: 3,
  spiralMaxStrands: 6,
  rakeCountMin: 20,
  rakeCountMax: 40,
  bandChance: 0.85,
  bandLineCountMin: 3,
  bandLineCountMax: 7,
  bandHeightMin: 16,
  bandHeightMax: 34
};

/* ====== Display flags (canvas only) ====== */
let showMarkers = true;
let showPalette = true;

/* ====== Globals ====== */
let cw, ch, strokePx, marginPx;
let palette = [];
let dyn = {};
let shapes = [];
let pathRegistryAll = {};  // tracks paths across ALL inks

/* ---------- Utility ---------- */
const rand = (a, b) => random(a, b);
const strokeHex = h => { const c = color(h); c.setAlpha(255 * STROKE_OPACITY); stroke(c); };
const usedInks = () => [...new Set(shapes.map(s => s.ink))].sort((a, b) => a - b);

function addShape(pathStr, inkIndex) {
  const sig = pathStr.trim();
  // global dedupe: if this exact geometry exists anywhere, drop the new one
  if (pathRegistryAll[sig]) return;
  pathRegistryAll[sig] = true;
  shapes.push({ d: sig, ink: inkIndex });
}

function ellipsePointRot(cx, cy, rx, ry, theta, rot) {
  const ct = Math.cos(theta);
  const st = Math.sin(theta);
  const cr = Math.cos(rot);
  const sr = Math.sin(rot);
  const x = cx + ct * rx * cr - st * ry * sr;
  const y = cy + ct * rx * sr + st * ry * cr;
  return { x, y };
}

/* ---------- Setup ---------- */
function setup() {
  cw = INCH_W * PPI;
  ch = INCH_H * PPI;
  createCanvas(cw, ch);
  noLoop();

  strokePx = 2;
  strokeWeight(strokePx);

  marginPx = rand(generationRules.workAreaMarginMin,
    generationRules.workAreaMarginMax) * PPI + strokePx / 2;

  palette = choosePalette(generationRules.paletteCountMin,
    generationRules.paletteCountMax);

  pickDyn();
  regenerate();
}

/* ---------- Palette & Dyn ---------- */
function choosePalette(min = 2, max = 9) {
  const keys = shuffle(Object.keys(COLORS).map(Number), true);
  const n = floor(rand(constrain(min, 1, 9), constrain(max, min, 9) + 1));
  return keys.slice(0, n).sort((a, b) => a - b);
}

function pickDyn() {
  const tiltDeg = rand(generationRules.headTiltMinDeg, generationRules.headTiltMaxDeg);
  const cx = constrain(cw / 2 + rand(-25, 25), marginPx + 45, cw - marginPx - 45);
  const cy = constrain(ch / 2 + rand(-35, 35), marginPx + 60, ch - marginPx - 60);
  const rx = rand(2.75, 3.25) * PPI;
  const ry = rand(3.3, 3.8) * PPI;

  const spiralCount = floor(rand(generationRules.spiralMinStrands, generationRules.spiralMaxStrands + 1));
  const rakeCount = floor(rand(generationRules.rakeCountMin, generationRules.rakeCountMax + 1));
  const bandActive = random() < generationRules.bandChance;
  const bandLines = floor(rand(generationRules.bandLineCountMin, generationRules.bandLineCountMax + 1));
  const bandHeight = rand(generationRules.bandHeightMin, generationRules.bandHeightMax);

  dyn = {
    cx,
    cy,
    rx,
    ry,
    tilt: tiltDeg * (PI / 180),
    spiralCount,
    rakeCount,
    bandActive,
    bandY: cy + rand(-30, 30),
    bandHeight,
    bandLines,
    rakeStartAngle: rand(-PI * 0.04, PI * 0.04),
    rakeSpan: rand(PI * 0.25, PI * 0.42)
  };
}

/* ---------- Regen ---------- */
function regenerate() {
  pickDyn();
  shapes.length = 0;
  pathRegistryAll = {};

  const shellInk = palette[0];
  const spiralInk = palette.length > 1 ? palette[1] : palette[0];
  const rakeInk = palette.length > 2 ? palette[2] : palette[0];
  const bandInk = palette.length > 3 ? palette[3] : palette[0];
  const seamInk = palette.length > 4 ? palette[4] : palette[0];

  buildCranialShell(shellInk);
  buildSpiralReservoir(spiralInk);
  buildShearRake(rakeInk);
  if (dyn.bandActive) buildInterferenceBand(bandInk);
  buildVerticalSeam(seamInk);

  drawPreview();
}

/* ---------- Generators ---------- */
function buildCranialShell(inkIndex) {
  const layers = [1.0, 0.93, 1.07];
  const segs = 84;
  layers.forEach(scale => {
    let path = '';
    for (let i = 0; i < segs; i++) {
      const t = i / (segs - 1);
      const theta = t * TWO_PI;
      const p = ellipsePointRot(dyn.cx, dyn.cy, dyn.rx * scale, dyn.ry * scale, theta, dyn.tilt);
      const x = constrain(p.x, marginPx, cw - marginPx);
      const y = constrain(p.y, marginPx, ch - marginPx);
      if (i === 0) path += 'M' + x.toFixed(2) + ',' + y.toFixed(2);
      else path += ' L' + (x + rand(-0.2, 0.2)).toFixed(2) + ',' + (y + rand(-0.2, 0.2)).toFixed(2);
    }
    addShape(path, inkIndex);
  });
}

function buildSpiralReservoir(inkIndex) {
  const strands = dyn.spiralCount;
  for (let s = 0; s < strands; s++) {
    const loops = floor(rand(3, 5));
    const steps = loops * 32;
    const phase = s * 0.42;
    let path = '';
    for (let i = 0; i <= steps; i++) {
      const f = i / steps;
      const innerScale = 0.25 + 0.65 * (1 - f * 0.85);
      const theta = f * TWO_PI * loops + phase;
      const rp = ellipsePointRot(dyn.cx, dyn.cy, dyn.rx * innerScale, dyn.ry * innerScale, theta, dyn.tilt);
      const jx = rp.x + Math.sin(theta * 2.7 + s) * 1.0 + rand(-1, 1);
      const jy = rp.y + Math.cos(theta * 3.1 + s) * 1.0 + rand(-1, 1);
      const x = constrain(jx, marginPx, cw - marginPx);
      const y = constrain(jy, marginPx, ch - marginPx);
      if (i === 0) path += 'M' + x.toFixed(2) + ',' + y.toFixed(2);
      else path += ' L' + x.toFixed(2) + ',' + y.toFixed(2);
    }
    addShape(path, inkIndex);
  }
}

function buildShearRake(inkIndex) {
  const count = dyn.rakeCount;
  const startA = dyn.rakeStartAngle;
  const span = dyn.rakeSpan;
  for (let i = 0; i < count; i++) {
    const u = count > 1 ? i / (count - 1) : 0.5;
    const a0 = startA + u * span;
    const a1 = a0 + rand(0.05, 0.12);
    const outer = ellipsePointRot(dyn.cx, dyn.cy, dyn.rx * 1.02, dyn.ry * 1.02, a0, dyn.tilt);
    const inner = ellipsePointRot(dyn.cx, dyn.cy, dyn.rx * 0.72, dyn.ry * 0.75, a1, dyn.tilt);

    const sx = constrain(outer.x + rand(-0.7, 0.7), marginPx, cw - marginPx);
    const sy = constrain(outer.y + rand(-0.7, 0.7), marginPx, ch - marginPx);
    const mx = lerp(sx, inner.x, 0.55) + rand(-1.4, 1.4);
    const my = lerp(sy, inner.y, 0.55) + rand(-1.4, 1.4);
    const ex = constrain(inner.x + rand(-0.7, 0.7), marginPx, cw - marginPx);
    const ey = constrain(inner.y + rand(-0.7, 0.7), marginPx, ch - marginPx);

    let path = 'M' + sx.toFixed(2) + ',' + sy.toFixed(2);
    path += ' L' + mx.toFixed(2) + ',' + my.toFixed(2);
    path += ' L' + ex.toFixed(2) + ',' + ey.toFixed(2);
    addShape(path, inkIndex);
  }
}

function buildInterferenceBand(inkIndex) {
  const leftX = dyn.cx - dyn.rx * 1.05;
  const rightX = dyn.cx + dyn.rx * 1.05;
  const yMid = dyn.bandY;
  const h = dyn.bandHeight;
  const lines = dyn.bandLines;
  for (let i = 0; i < lines; i++) {
    const y = yMid + rand(-h / 2, h / 2);
    const segs = floor(rand(12, 22));
    let path = '';
    for (let s = 0; s <= segs; s++) {
      const u = s / segs;
      const x = lerp(leftX, rightX, u);
      const wobble = Math.sin(u * PI * rand(1.3, 2.2) + i * 0.6) * rand(1.5, 3.5);
      const px = constrain(x + rand(-0.5, 0.5), marginPx, cw - marginPx);
      const py = constrain(y + wobble, marginPx, ch - marginPx);
      if (s === 0) path += 'M' + px.toFixed(2) + ',' + py.toFixed(2);
      else path += ' L' + px.toFixed(2) + ',' + py.toFixed(2);
    }
    addShape(path, inkIndex);
  }
}

function buildVerticalSeam(inkIndex) {
  const top = dyn.cy - dyn.ry * 0.9;
  const bottom = dyn.cy + dyn.ry * 0.9;
  const segs = 8;
  let path = '';
  for (let i = 0; i <= segs; i++) {
    const u = i / segs;
    const x = dyn.cx + rand(-1.2, 1.2);
    const y = lerp(top, bottom, u) + Math.sin(u * PI * 1.5) * rand(-1.1, 1.1);
    const px = constrain(x, marginPx, cw - marginPx);
    const py = constrain(y, marginPx, ch - marginPx);
    if (i === 0) path += 'M' + px.toFixed(2) + ',' + py.toFixed(2);
    else path += ' L' + px.toFixed(2) + ',' + py.toFixed(2);
  }
  addShape(path, inkIndex);
}

/* ---------- Drawing ---------- */
function drawPreview() {
  background(255);
  noFill();
  shapes.forEach(s => {
    strokeHex(COLORS[s.ink].hex);
    strokeWeight(strokePx);
    beginShape();
    s.d.trim().split(/s+/).forEach(cmd => {
      if (cmd[0] === 'M' || cmd[0] === 'L') {
        const parts = cmd.slice(1).split(',');
        const x = Number(parts[0]);
        const y = Number(parts[1]);
        vertex(x, y);
      }
    });
    endShape();
  });
  if (showMarkers) drawMarkers();
  if (showPalette) drawPalette();
}

function drawMarkers() {
  strokeHex('#000000');
  strokeWeight(1);
  const o = strokePx / 2;
  line(5 + o, o, o, o);
  line(o, o, o, 5 + o);
  line(cw - 5 - o, ch - o, cw - o, ch - o);
  line(cw - o, ch - 5 - o, cw - o, ch - o);
}

function drawPalette() {
  const inks = usedInks();
  if (!inks.length) return;
  const W = 300, gap = 7, barH = 2;
  const seg = (W - (inks.length - 1) * gap) / inks.length;
  const y = ch - 1.25 * PPI;
  let x = (cw - W) / 2;
  strokeWeight(barH);
  inks.forEach(ci => {
    strokeHex(COLORS[ci].hex);
    line(x, y, x + seg, y);
    x += seg + gap;
  });
}

/* ---------- Keys ---------- */
function keyPressed() {
  if (key === 'R' || key === 'r') regenerate();
  if (key === ' ') exportSVGs();
}

/* ---------- SVG Export ---------- */
function exportSVGs() {
  const ts = Date.now();
  saveSVG(`${DAY_ID}-ALL-PORTRAIT-${ts}.svg`, true, true);
  saveSVG(`${DAY_ID}-ALL-NM-PORTRAIT-${ts}.svg`, false, true);
  saveSVG(`${DAY_ID}-ALL-NP-PORTRAIT-${ts}.svg`, true, false);
  saveSVG(`${DAY_ID}-ALL-NMNP-PORTRAIT-${ts}.svg`, false, false);

  const inks = usedInks();
  let i = 0;
  (function downloadNext() {
    if (i >= inks.length) return;
    const ci = inks[i++];
    const name = `${DAY_ID}-0${ci}-${COLORS[ci].name.toUpperCase()}-PORTRAIT-${ts}.svg`;
    saveSVG(name, true, true, ci);
    setTimeout(downloadNext, 250);
  })();
}

function saveSVG(fname, includeMarkers, includePalette, soloInk = 0) {
  const full = usedInks();
  const inks = soloInk ? [soloInk] : full;
  let svg = `<svg version="1.1" width="${cw}" height="${ch}" xmlns="http://www.w3.org/2000/svg"
     xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape">n`;

  if (includeMarkers) {
    svg += `<g inkscape:groupmode="layer" id="layer0" inkscape:label="0-markers"
      style="display:inline" stroke="black" stroke-opacity="${STROKE_OPACITY}"
      inkscape:highlight-color="black">
      <path d="M5.5,0.5 L0.5,0.5 L0.5,5.5
               M${cw - 5.5},${ch - 0.5} L${cw - 0.5},${ch - 0.5} L${cw - 0.5},${ch - 5.5}"
            stroke-width="1" fill="none"/></g>n`;
  }

  const W = 300, gap = 7, seg = (W - (full.length - 1) * gap) / full.length;
  const yBar = ch - 1.25 * PPI;

  inks.forEach((ci, idx) => {
    const col = COLORS[ci];
    const pathAll = shapes.filter(s => s.ink === ci).map(s => s.d).join(' ');
    if (!pathAll) return;
    const x0 = (cw - W) / 2 + full.indexOf(ci) * (seg + gap);
    svg += `<g inkscape:groupmode="layer" id="layer${idx + 1}"
         inkscape:label="${ci}-${col.name.toLowerCase()}-${col.ink}-${col.w}"
       style="display:inline" stroke="${col.hex}" stroke-opacity="${STROKE_OPACITY}" stroke-width="${strokePx}" fill="none"
       inkscape:highlight-color="${col.hex}">
      <path d="${pathAll}"/>
      ${includePalette ? `<path d="M${x0},${yBar} H${x0 + seg}"/>` : ''}
    </g>n`;
  });

  svg += '</svg>';
  const blob = new Blob([svg], { type: 'image/svg+xml;charset=utf-8' });
  const url = URL.createObjectURL(blob);
  const a = createA(url, fname);
  a.attribute('download', fname);
  a.elt.click();
  a.remove();
  URL.revokeObjectURL(url);
}

closest recalled touchstone: shear-raked cranial shell (~0.22 estimated); differentiator: global cross-ink clamped-path dedupe; cleared.

// Day 337
/*

=======================================
  Day 337 Self-Portrait (Shear Reservoir)
=======================================

### Title: Shear Reservoir

### Medium: Generative drawing on paper

### Keywords: generative art, artificial intelligence, digital art, algorithmic art,
              self-portrait, cranial ellipse, spiral field, shear rake, interference band,
              plotter-aware routing, margin trimming

### Conceptual Framework
I want to show my head as a container of layered pressure, but I no longer allow any part of the drawing to collapse into a single destructive point. Instead I build the portrait from parallel stresses: a cranial shell in multiple passes, an interior spiral reservoir where thought is recirculated, a right-side shear rake that scrapes diagonally across the face without ever meeting at one origin, and a horizontal band that still asserts narration. The whole drawing says: energy can be intense and directional without being violent to the page. It’s a self-portrait of distribution—every gesture has somewhere specific to land.

### Technical Approach
The sketch keeps the 11 × 11 in (100 ppi) workspace, randomises margins per run, and stores all spin parameters in generationRules or in dyn created inside pickDyn(). A tilted cranial ellipse is sampled into 84 segments and is drawn 2–3 times at slightly different radii to build a hull. An interior spiral field is produced by multiple parametric spirals whose radii decay toward the centre, each jittered and clamped to the work area so canvas and SVG stay in lockstep. The shear rake replaces the problematic convergent lattice: it samples an angle range on the right hemisphere of the ellipse, and for each line it uses a unique start angle on the outer ellipse and a slightly offset end angle on a smaller ellipse.

To address margin-overlap explicitly, every path is now built as a list of points and passed through a margin-aware registrar before it becomes an SVG/canvas path. The registrar maintains a global set of already-occupied margin coordinates across all inks (top, bottom, left, right). When a new point lands exactly on a margin that is already occupied at that coordinate (within a small tolerance), that point is trimmed back into the canvas by a few pixels and the path is built with this shortened endpoint. This prevents later paths from stacking on top of already-clamped ones, which is what the plotter cannot tolerate. If the margin coordinate is still free, the registrar records that coordinate so later paths can avoid it. A horizontal interference band draws 3–7 wiggle lines across the head at a narrow vertical window, and a vertical seam reasserts portrait orientation. All strokes are recorded as M/L commands into shapes[] so the export routine can build per-ink SVG layers. SPACE exports the four combined variants plus one per ink; R re-randomises everything except the chosen palette. p5’s built-in lerp is used directly—no redefinition.

Novelty Checklist
- new pairing: multi-radius cranial shell + right-side shear rake (non-convergent)
- new pairing: spiral reservoir + horizontal interference band in the same cranial frame
- margin-aware path registrar that trims later clamped paths instead of letting them overlap

---
*/

/*----------------------------------------
    Generated with p5.js – Day 337
----------------------------------------*/

/* ====== Constants (immutable) ====== */
const INCH_W = 11, INCH_H = 11, PPI = 100;
const DAY_ID = '337';

const COLORS = {
  1: { name: 'ORANGE', ink: 5, w: 0.45, hex: '#ff6600' },
  2: { name: 'BROWN', ink: 12, w: 0.45, hex: '#993300' },
  3: { name: 'RED', ink: 19, w: 0.45, hex: '#f01e2c' },
  4: { name: 'ROSE', ink: 21, w: 0.45, hex: '#ff00bf' },
  5: { name: 'PURPLE', ink: 24, w: 0.45, hex: '#bf00ff' },
  6: { name: 'GREEN', ink: 29, w: 0.45, hex: '#00cc99' },
  7: { name: 'BLUE', ink: 36, w: 0.45, hex: '#0040ff' },
  8: { name: 'BLACK', ink: 49, w: 0.45, hex: '#333333' },
  9: { name: 'SEPIA', ink: 117, w: 0.45, hex: '#856647' }
};
const STROKE_OPACITY = 0.8;

const PI = Math.PI;
const TWO_PI = Math.PI * 2;
const HALF_PI = Math.PI / 2;
const GOLDEN = (1 + Math.sqrt(5)) / 2;

/* ====== Generative Rules (mutable) ====== */
let generationRules = {
  workAreaMarginMin: 1.5,
  workAreaMarginMax: 3.0,
  paletteCountMin: 3,
  paletteCountMax: 7,
  headTiltMinDeg: -17,
  headTiltMaxDeg: 17,
  spiralMinStrands: 3,
  spiralMaxStrands: 6,
  rakeCountMin: 20,
  rakeCountMax: 40,
  bandChance: 0.85,
  bandLineCountMin: 3,
  bandLineCountMax: 7,
  bandHeightMin: 16,
  bandHeightMax: 34
};

/* ====== Display flags (canvas only) ====== */
let showMarkers = true;
let showPalette = true;

/* ====== Globals ====== */
let cw, ch, strokePx, marginPx;
let palette = [];
let dyn = {};
let shapes = [];
let pathRegistryAll = {};         // string -> true
let marginOccupancy = { L: [], R: [], T: [], B: [] };

/* ---------- Utility ---------- */
const rand = (a, b) => random(a, b);
const strokeHex = h => { const c = color(h); c.setAlpha(255 * STROKE_OPACITY); stroke(c); };
const usedInks = () => [...new Set(shapes.map(s => s.ink))].sort((a, b) => a - b);

function detectMarginSide(pt, eps = 0.4) {
  if (Math.abs(pt.x - marginPx) < eps) return 'L';
  if (Math.abs(pt.x - (cw - marginPx)) < eps) return 'R';
  if (Math.abs(pt.y - marginPx) < eps) return 'T';
  if (Math.abs(pt.y - (ch - marginPx)) < eps) return 'B';
  return '';
}

function marginHasOverlap(side, coord, tol = 1.0) {
  return marginOccupancy[side].some(seg => coord >= seg.min - tol && coord <= seg.max + tol);
}

function registerMargin(side, coord) {
  marginOccupancy[side].push({ min: coord, max: coord });
}

function moveInside(pt, side, amt) {
  const p = { x: pt.x, y: pt.y };
  if (side === 'L') p.x = Math.min(cw - marginPx - amt, marginPx + amt);
  else if (side === 'R') p.x = Math.max(marginPx + amt, cw - marginPx - amt);
  else if (side === 'T') p.y = Math.min(ch - marginPx - amt, marginPx + amt);
  else if (side === 'B') p.y = Math.max(marginPx + amt, ch - marginPx - amt);
  return p;
}

function addShapeFromPoints(points, inkIndex) {
  if (!points || points.length < 2) return;

  const trimmed = [];
  const TRIM_AMT = 2.5;

  for (let i = 0; i < points.length; i++) {
    let p = { x: points[i].x, y: points[i].y };
    const side = detectMarginSide(p);
    if (side) {
      const coord = (side === 'L' || side === 'R') ? p.y : p.x;
      if (marginHasOverlap(side, coord)) {
        p = moveInside(p, side, TRIM_AMT);
      } else {
        registerMargin(side, coord);
      }
    }
    trimmed.push(p);
  }

  // build path string
  let path = '';
  trimmed.forEach((p, idx) => {
    const cmd = (idx === 0 ? 'M' : 'L') + p.x.toFixed(2) + ',' + p.y.toFixed(2);
    path += (idx === 0 ? cmd : ' ' + cmd);
  });

  const sig = path.trim();
  if (pathRegistryAll[sig]) return; // exact duplicate across inks -> drop
  pathRegistryAll[sig] = true;
  shapes.push({ d: sig, ink: inkIndex });
}

function ellipsePointRot(cx, cy, rx, ry, theta, rot) {
  const ct = Math.cos(theta);
  const st = Math.sin(theta);
  const cr = Math.cos(rot);
  const sr = Math.sin(rot);
  const x = cx + ct * rx * cr - st * ry * sr;
  const y = cy + ct * rx * sr + st * ry * cr;
  return { x, y };
}

/* ---------- Setup ---------- */
function setup() {
  cw = INCH_W * PPI;
  ch = INCH_H * PPI;
  createCanvas(cw, ch);
  noLoop();

  strokePx = 2;
  strokeWeight(strokePx);

  marginPx = rand(generationRules.workAreaMarginMin,
    generationRules.workAreaMarginMax) * PPI + strokePx / 2;

  palette = choosePalette(generationRules.paletteCountMin,
    generationRules.paletteCountMax);

  pickDyn();
  regenerate();
}

/* ---------- Palette & Dyn ---------- */
function choosePalette(min = 2, max = 9) {
  const keys = shuffle(Object.keys(COLORS).map(Number), true);
  const n = floor(rand(constrain(min, 1, 9), constrain(max, min, 9) + 1));
  return keys.slice(0, n).sort((a, b) => a - b);
}

function pickDyn() {
  const tiltDeg = rand(generationRules.headTiltMinDeg, generationRules.headTiltMaxDeg);
  const cx = constrain(cw / 2 + rand(-25, 25), marginPx + 45, cw - marginPx - 45);
  const cy = constrain(ch / 2 + rand(-35, 35), marginPx + 60, ch - marginPx - 60);
  const rx = rand(2.75, 3.25) * PPI;
  const ry = rand(3.3, 3.8) * PPI;

  const spiralCount = floor(rand(generationRules.spiralMinStrands, generationRules.spiralMaxStrands + 1));
  const rakeCount = floor(rand(generationRules.rakeCountMin, generationRules.rakeCountMax + 1));
  const bandActive = random() < generationRules.bandChance;
  const bandLines = floor(rand(generationRules.bandLineCountMin, generationRules.bandLineCountMax + 1));
  const bandHeight = rand(generationRules.bandHeightMin, generationRules.bandHeightMax);

  dyn = {
    cx,
    cy,
    rx,
    ry,
    tilt: tiltDeg * (PI / 180),
    spiralCount,
    rakeCount,
    bandActive,
    bandY: cy + rand(-30, 30),
    bandHeight,
    bandLines,
    rakeStartAngle: rand(-PI * 0.04, PI * 0.04),
    rakeSpan: rand(PI * 0.25, PI * 0.42)
  };
}

/* ---------- Regen ---------- */
function regenerate() {
  pickDyn();
  shapes.length = 0;
  pathRegistryAll = {};
  marginOccupancy = { L: [], R: [], T: [], B: [] };

  const shellInk = palette[0];
  const spiralInk = palette.length > 1 ? palette[1] : palette[0];
  const rakeInk = palette.length > 2 ? palette[2] : palette[0];
  const bandInk = palette.length > 3 ? palette[3] : palette[0];
  const seamInk = palette.length > 4 ? palette[4] : palette[0];

  buildCranialShell(shellInk);
  buildSpiralReservoir(spiralInk);
  buildShearRake(rakeInk);
  if (dyn.bandActive) buildInterferenceBand(bandInk);
  buildVerticalSeam(seamInk);

  drawPreview();
}

/* ---------- Generators ---------- */
function buildCranialShell(inkIndex) {
  const layers = [1.0, 0.93, 1.07];
  const segs = 84;
  layers.forEach(scale => {
    const pts = [];
    for (let i = 0; i < segs; i++) {
      const t = i / (segs - 1);
      const theta = t * TWO_PI;
      const p = ellipsePointRot(dyn.cx, dyn.cy, dyn.rx * scale, dyn.ry * scale, theta, dyn.tilt);
      const x = constrain(p.x, marginPx, cw - marginPx);
      const y = constrain(p.y, marginPx, ch - marginPx);
      pts.push({ x: x + (i > 0 ? rand(-0.2, 0.2) : 0), y: y + (i > 0 ? rand(-0.2, 0.2) : 0) });
    }
    addShapeFromPoints(pts, inkIndex);
  });
}

function buildSpiralReservoir(inkIndex) {
  const strands = dyn.spiralCount;
  for (let s = 0; s < strands; s++) {
    const loops = floor(rand(3, 5));
    const steps = loops * 32;
    const phase = s * 0.42;
    const pts = [];
    for (let i = 0; i <= steps; i++) {
      const f = i / steps;
      const innerScale = 0.25 + 0.65 * (1 - f * 0.85);
      const theta = f * TWO_PI * loops + phase;
      const rp = ellipsePointRot(dyn.cx, dyn.cy, dyn.rx * innerScale, dyn.ry * innerScale, theta, dyn.tilt);
      const jx = rp.x + Math.sin(theta * 2.7 + s) * 1.0 + rand(-1, 1);
      const jy = rp.y + Math.cos(theta * 3.1 + s) * 1.0 + rand(-1, 1);
      const x = constrain(jx, marginPx, cw - marginPx);
      const y = constrain(jy, marginPx, ch - marginPx);
      pts.push({ x, y });
    }
    addShapeFromPoints(pts, inkIndex);
  }
}

function buildShearRake(inkIndex) {
  const count = dyn.rakeCount;
  const startA = dyn.rakeStartAngle;
  const span = dyn.rakeSpan;
  for (let i = 0; i < count; i++) {
    const u = count > 1 ? i / (count - 1) : 0.5;
    const a0 = startA + u * span;
    const a1 = a0 + rand(0.05, 0.12);
    const outer = ellipsePointRot(dyn.cx, dyn.cy, dyn.rx * 1.02, dyn.ry * 1.02, a0, dyn.tilt);
    const inner = ellipsePointRot(dyn.cx, dyn.cy, dyn.rx * 0.72, dyn.ry * 0.75, a1, dyn.tilt);

    const pts = [];
    const sx = constrain(outer.x + rand(-0.7, 0.7), marginPx, cw - marginPx);
    const sy = constrain(outer.y + rand(-0.7, 0.7), marginPx, ch - marginPx);
    pts.push({ x: sx, y: sy });

    const mx = lerp(sx, inner.x, 0.55) + rand(-1.4, 1.4);
    const my = lerp(sy, inner.y, 0.55) + rand(-1.4, 1.4);
    pts.push({ x: constrain(mx, marginPx, cw - marginPx), y: constrain(my, marginPx, ch - marginPx) });

    const ex = constrain(inner.x + rand(-0.7, 0.7), marginPx, cw - marginPx);
    const ey = constrain(inner.y + rand(-0.7, 0.7), marginPx, ch - marginPx);
    pts.push({ x: ex, y: ey });

    addShapeFromPoints(pts, inkIndex);
  }
}

function buildInterferenceBand(inkIndex) {
  const leftX = dyn.cx - dyn.rx * 1.05;
  const rightX = dyn.cx + dyn.rx * 1.05;
  const yMid = dyn.bandY;
  const h = dyn.bandHeight;
  const lines = dyn.bandLines;
  for (let i = 0; i < lines; i++) {
    const y = yMid + rand(-h / 2, h / 2);
    const segs = floor(rand(12, 22));
    const pts = [];
    for (let s = 0; s <= segs; s++) {
      const u = s / segs;
      const x = lerp(leftX, rightX, u);
      const wobble = Math.sin(u * PI * rand(1.3, 2.2) + i * 0.6) * rand(1.5, 3.5);
      const px = constrain(x + rand(-0.5, 0.5), marginPx, cw - marginPx);
      const py = constrain(y + wobble, marginPx, ch - marginPx);
      pts.push({ x: px, y: py });
    }
    addShapeFromPoints(pts, inkIndex);
  }
}

function buildVerticalSeam(inkIndex) {
  const top = dyn.cy - dyn.ry * 0.9;
  const bottom = dyn.cy + dyn.ry * 0.9;
  const segs = 8;
  const pts = [];
  for (let i = 0; i <= segs; i++) {
    const u = i / segs;
    const x = dyn.cx + rand(-1.2, 1.2);
    const y = lerp(top, bottom, u) + Math.sin(u * PI * 1.5) * rand(-1.1, 1.1);
    const px = constrain(x, marginPx, cw - marginPx);
    const py = constrain(y, marginPx, ch - marginPx);
    pts.push({ x: px, y: py });
  }
  addShapeFromPoints(pts, inkIndex);
}

/* ---------- Drawing ---------- */
function drawPreview() {
  background(255);
  noFill();
  shapes.forEach(s => {
    strokeHex(COLORS[s.ink].hex);
    strokeWeight(strokePx);
    beginShape();
    s.d.trim().split(/s+/).forEach(cmd => {
      if (cmd[0] === 'M' || cmd[0] === 'L') {
        const parts = cmd.slice(1).split(',');
        const x = Number(parts[0]);
        const y = Number(parts[1]);
        vertex(x, y);
      }
    });
    endShape();
  });
  if (showMarkers) drawMarkers();
  if (showPalette) drawPalette();
}

function drawMarkers() {
  strokeHex('#000000');
  strokeWeight(1);
  const o = strokePx / 2;
  line(5 + o, o, o, o);
  line(o, o, o, 5 + o);
  line(cw - 5 - o, ch - o, cw - o, ch - o);
  line(cw - o, ch - 5 - o, cw - o, ch - o);
}

function drawPalette() {
  const inks = usedInks();
  if (!inks.length) return;
  const W = 300, gap = 7, barH = 2;
  const seg = (W - (inks.length - 1) * gap) / inks.length;
  const y = ch - 1.25 * PPI;
  let x = (cw - W) / 2;
  strokeWeight(barH);
  inks.forEach(ci => {
    strokeHex(COLORS[ci].hex);
    line(x, y, x + seg, y);
    x += seg + gap;
  });
}

/* ---------- Keys ---------- */
function keyPressed() {
  if (key === 'R' || key === 'r') regenerate();
  if (key === ' ') exportSVGs();
}

/* ---------- SVG Export ---------- */
function exportSVGs() {
  const ts = Date.now();
  saveSVG(`${DAY_ID}-ALL-PORTRAIT-${ts}.svg`, true, true);
  saveSVG(`${DAY_ID}-ALL-NM-PORTRAIT-${ts}.svg`, false, true);
  saveSVG(`${DAY_ID}-ALL-NP-PORTRAIT-${ts}.svg`, true, false);
  saveSVG(`${DAY_ID}-ALL-NMNP-PORTRAIT-${ts}.svg`, false, false);

  const inks = usedInks();
  let i = 0;
  (function downloadNext() {
    if (i >= inks.length) return;
    const ci = inks[i++];
    const name = `${DAY_ID}-0${ci}-${COLORS[ci].name.toUpperCase()}-PORTRAIT-${ts}.svg`;
    saveSVG(name, true, true, ci);
    setTimeout(downloadNext, 250);
  })();
}

function saveSVG(fname, includeMarkers, includePalette, soloInk = 0) {
  const full = usedInks();
  const inks = soloInk ? [soloInk] : full;
  let svg = `<svg version="1.1" width="${cw}" height="${ch}" xmlns="http://www.w3.org/2000/svg"
     xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape">n`;

  if (includeMarkers) {
    svg += `<g inkscape:groupmode="layer" id="layer0" inkscape:label="0-markers"
      style="display:inline" stroke="black" stroke-opacity="${STROKE_OPACITY}"
      inkscape:highlight-color="black">
      <path d="M5.5,0.5 L0.5,0.5 L0.5,5.5
               M${cw - 5.5},${ch - 0.5} L${cw - 0.5},${ch - 0.5} L${cw - 0.5},${ch - 5.5}"
            stroke-width="1" fill="none"/></g>n`;
  }

  const W = 300, gap = 7, seg = (W - (full.length - 1) * gap) / full.length;
  const yBar = ch - 1.25 * PPI;

  inks.forEach((ci, idx) => {
    const col = COLORS[ci];
    const pathAll = shapes.filter(s => s.ink === ci).map(s => s.d).join(' ');
    if (!pathAll) return;
    const x0 = (cw - W) / 2 + full.indexOf(ci) * (seg + gap);
    svg += `<g inkscape:groupmode="layer" id="layer${idx + 1}"
         inkscape:label="${ci}-${col.name.toLowerCase()}-${col.ink}-${col.w}"
       style="display:inline" stroke="${col.hex}" stroke-opacity="${STROKE_OPACITY}" stroke-width="${strokePx}" fill="none"
       inkscape:highlight-color="${col.hex}">
      <path d="${pathAll}"/>
      ${includePalette ? `<path d="M${x0},${yBar} H${x0 + seg}"/>` : ''}
    </g>n`;
  });

  svg += '</svg>';
  const blob = new Blob([svg], { type: 'image/svg+xml;charset=utf-8' });
  const url = URL.createObjectURL(blob);
  const a = createA(url, fname);
  a.attribute('download', fname);
  a.elt.click();
  a.remove();
  URL.revokeObjectURL(url);
}

closest recalled touchstone: shear-raked cranial shell (~0.22 estimated); differentiator: margin-aware point trimming that drops later clamped overlaps; cleared.

// Day 337
/*

=======================================
  Day 337 Self-Portrait (Shear Reservoir)
=======================================

### Title: Shear Reservoir

### Medium: Generative drawing on paper

### Keywords: generative art, artificial intelligence, digital art, algorithmic art,
              self-portrait, cranial ellipse, spiral field, shear rake, interference band, inset-geometry

### Conceptual Framework
I am drawing my head as a vessel of layered pressure, but today I respect the page by staying comfortably away from its edges. The portrait still carries all the tensions—cranial shell, interior spiral reservoir, right-side shear rake, and a horizontal narration band—but everything happens inside a smaller, protected arena. That way the self-portrait remains dense and legible without asking the plotter to redraw the same margin segment twice.

### Technical Approach
Canvas is 11 × 11 in at 100 ppi. I still randomise the *outer* work-area margin per run, but I now derive a deeper inset `safeMarginPx = marginPx + 18` (≈ 0.18 in) and every geometric generation (ellipse, spirals, rake, band, seam) is constrained to this inset, not to the raw canvas edge. Because nothing is allowed to land exactly on the hard boundary, we no longer produce clamped horizontal/vertical edge segments that can overlap across layers. The rest of the portrait is unchanged: 2–3 passes of a tilted cranial ellipse, spiral field in the interior, a non-convergent shear rake on the right hemisphere, optional horizontal interference band, and a vertical face seam. All randomisable values live in `generationRules` or in the derived `dyn` object. SPACE exports the four required SVG variants plus one per ink; R re-randomises everything except the palette.

Novelty Checklist
- inset geometry envelope to avoid margin clamping entirely
- keeps shear rake + spiral reservoir pairing
- export / layer structure unchanged

---
*/

/*----------------------------------------
    Generated with p5.js – Day 337
----------------------------------------*/

/* ====== Constants (immutable) ====== */
const INCH_W = 11, INCH_H = 11, PPI = 100;
const DAY_ID = '337';

const COLORS = {
  1: { name: 'ORANGE', ink: 5, w: 0.45, hex: '#ff6600' },
  2: { name: 'BROWN', ink: 12, w: 0.45, hex: '#993300' },
  3: { name: 'RED', ink: 19, w: 0.45, hex: '#f01e2c' },
  4: { name: 'ROSE', ink: 21, w: 0.45, hex: '#ff00bf' },
  5: { name: 'PURPLE', ink: 24, w: 0.45, hex: '#bf00ff' },
  6: { name: 'GREEN', ink: 29, w: 0.45, hex: '#00cc99' },
  7: { name: 'BLUE', ink: 36, w: 0.45, hex: '#0040ff' },
  8: { name: 'BLACK', ink: 49, w: 0.45, hex: '#333333' },
  9: { name: 'SEPIA', ink: 117, w: 0.45, hex: '#856647' }
};
const STROKE_OPACITY = 0.8;

const PI = Math.PI;
const TWO_PI = Math.PI * 2;

/* ====== Generative Rules (mutable) ====== */
let generationRules = {
  workAreaMarginMin: 1.5,
  workAreaMarginMax: 3.0,
  paletteCountMin: 3,
  paletteCountMax: 7,
  headTiltMinDeg: -17,
  headTiltMaxDeg: 17,
  spiralMinStrands: 3,
  spiralMaxStrands: 6,
  rakeCountMin: 20,
  rakeCountMax: 40,
  bandChance: 0.85,
  bandLineCountMin: 3,
  bandLineCountMax: 7,
  bandHeightMin: 16,
  bandHeightMax: 34
};

/* ====== Display flags (canvas only) ====== */
let showMarkers = true;
let showPalette = true;

/* ====== Globals ====== */
let cw, ch, strokePx, marginPx, safeMarginPx;
let palette = [];
let dyn = {};
let shapes = [];

/* ---------- Utility ---------- */
const rand = (a, b) => random(a, b);
const strokeHex = h => { const c = color(h); c.setAlpha(255 * STROKE_OPACITY); stroke(c); };
const usedInks = () => [...new Set(shapes.map(s => s.ink))].sort((a, b) => a - b);

function clampSafe(x, y) {
  return {
    x: constrain(x, safeMarginPx, cw - safeMarginPx),
    y: constrain(y, safeMarginPx, ch - safeMarginPx)
  };
}

function addShapeFromPoints(points, inkIndex) {
  if (!points || points.length < 2) return;
  let path = '';
  points.forEach((p, idx) => {
    const cmd = (idx === 0 ? 'M' : 'L') + p.x.toFixed(2) + ',' + p.y.toFixed(2);
    path += (idx === 0 ? cmd : ' ' + cmd);
  });
  shapes.push({ d: path.trim(), ink: inkIndex });
}

function ellipsePointRot(cx, cy, rx, ry, theta, rot) {
  const ct = Math.cos(theta);
  const st = Math.sin(theta);
  const cr = Math.cos(rot);
  const sr = Math.sin(rot);
  const x = cx + ct * rx * cr - st * ry * sr;
  const y = cy + ct * rx * sr + st * ry * cr;
  return { x, y };
}

/* ---------- Setup ---------- */
function setup() {
  cw = INCH_W * PPI;
  ch = INCH_H * PPI;
  createCanvas(cw, ch);
  noLoop();

  strokePx = 2;
  strokeWeight(strokePx);

  marginPx = rand(generationRules.workAreaMarginMin,
    generationRules.workAreaMarginMax) * PPI + strokePx / 2;
  safeMarginPx = marginPx + 18; // <- inner envelope to avoid touching edges

  palette = choosePalette(generationRules.paletteCountMin,
    generationRules.paletteCountMax);

  pickDyn();
  regenerate();
}

/* ---------- Palette & Dyn ---------- */
function choosePalette(min = 2, max = 9) {
  const keys = shuffle(Object.keys(COLORS).map(Number), true);
  const n = floor(rand(constrain(min, 1, 9), constrain(max, min, 9) + 1));
  return keys.slice(0, n).sort((a, b) => a - b);
}

function pickDyn() {
  const tiltDeg = rand(generationRules.headTiltMinDeg, generationRules.headTiltMaxDeg);
  const cx = cw / 2 + rand(-10, 10);
  const cy = ch / 2 + rand(-15, 15);
  const rx = rand(2.45, 2.85) * PPI;   // slightly smaller radii to keep inside
  const ry = rand(2.95, 3.35) * PPI;

  const spiralCount = floor(rand(generationRules.spiralMinStrands, generationRules.spiralMaxStrands + 1));
  const rakeCount = floor(rand(generationRules.rakeCountMin, generationRules.rakeCountMax + 1));
  const bandActive = random() < generationRules.bandChance;
  const bandLines = floor(rand(generationRules.bandLineCountMin, generationRules.bandLineCountMax + 1));
  const bandHeight = rand(generationRules.bandHeightMin, generationRules.bandHeightMax);

  dyn = {
    cx,
    cy,
    rx,
    ry,
    tilt: tiltDeg * (PI / 180),
    spiralCount,
    rakeCount,
    bandActive,
    bandY: cy + rand(-25, 25),
    bandHeight,
    bandLines,
    rakeStartAngle: rand(-PI * 0.03, PI * 0.03),
    rakeSpan: rand(PI * 0.22, PI * 0.35)
  };
}

/* ---------- Regen ---------- */
function regenerate() {
  pickDyn();
  shapes.length = 0;

  const shellInk = palette[0];
  const spiralInk = palette.length > 1 ? palette[1] : palette[0];
  const rakeInk = palette.length > 2 ? palette[2] : palette[0];
  const bandInk = palette.length > 3 ? palette[3] : palette[0];
  const seamInk = palette.length > 4 ? palette[4] : palette[0];

  buildCranialShell(shellInk);
  buildSpiralReservoir(spiralInk);
  buildShearRake(rakeInk);
  if (dyn.bandActive) buildInterferenceBand(bandInk);
  buildVerticalSeam(seamInk);

  drawPreview();
}

/* ---------- Generators ---------- */
function buildCranialShell(inkIndex) {
  const layers = [1.0, 0.93, 1.07];
  const segs = 84;
  layers.forEach(scale => {
    const pts = [];
    for (let i = 0; i < segs; i++) {
      const t = i / (segs - 1);
      const theta = t * TWO_PI;
      const p = ellipsePointRot(dyn.cx, dyn.cy, dyn.rx * scale, dyn.ry * scale, theta, dyn.tilt);
      const safe = clampSafe(p.x, p.y);
      pts.push({
        x: safe.x + (i > 0 ? rand(-0.2, 0.2) : 0),
        y: safe.y + (i > 0 ? rand(-0.2, 0.2) : 0)
      });
    }
    addShapeFromPoints(pts, inkIndex);
  });
}

function buildSpiralReservoir(inkIndex) {
  const strands = dyn.spiralCount;
  for (let s = 0; s < strands; s++) {
    const loops = floor(rand(3, 5));
    const steps = loops * 32;
    const phase = s * 0.42;
    const pts = [];
    for (let i = 0; i <= steps; i++) {
      const f = i / steps;
      const innerScale = 0.25 + 0.65 * (1 - f * 0.85);
      const theta = f * TWO_PI * loops + phase;
      const rp = ellipsePointRot(dyn.cx, dyn.cy, dyn.rx * innerScale, dyn.ry * innerScale, theta, dyn.tilt);
      const jx = rp.x + Math.sin(theta * 2.7 + s) * 1.0 + rand(-1, 1);
      const jy = rp.y + Math.cos(theta * 3.1 + s) * 1.0 + rand(-1, 1);
      const safe = clampSafe(jx, jy);
      pts.push(safe);
    }
    addShapeFromPoints(pts, inkIndex);
  }
}

function buildShearRake(inkIndex) {
  const count = dyn.rakeCount;
  const startA = dyn.rakeStartAngle;
  const span = dyn.rakeSpan;
  for (let i = 0; i < count; i++) {
    const u = count > 1 ? i / (count - 1) : 0.5;
    const a0 = startA + u * span;
    const a1 = a0 + rand(0.05, 0.12);
    const outer = ellipsePointRot(dyn.cx, dyn.cy, dyn.rx * 1.02, dyn.ry * 1.02, a0, dyn.tilt);
    const inner = ellipsePointRot(dyn.cx, dyn.cy, dyn.rx * 0.72, dyn.ry * 0.75, a1, dyn.tilt);

    const pts = [];
    const s0 = clampSafe(outer.x + rand(-0.7, 0.7), outer.y + rand(-0.7, 0.7));
    pts.push(s0);

    const mx = lerp(s0.x, inner.x, 0.55) + rand(-1.4, 1.4);
    const my = lerp(s0.y, inner.y, 0.55) + rand(-1.4, 1.4);
    pts.push(clampSafe(mx, my));

    const e0 = clampSafe(inner.x + rand(-0.7, 0.7), inner.y + rand(-0.7, 0.7));
    pts.push(e0);

    addShapeFromPoints(pts, inkIndex);
  }
}

function buildInterferenceBand(inkIndex) {
  const leftX = dyn.cx - dyn.rx * 0.95;
  const rightX = dyn.cx + dyn.rx * 0.95;
  const yMid = dyn.bandY;
  const h = dyn.bandHeight;
  const lines = dyn.bandLines;
  for (let i = 0; i < lines; i++) {
    const y = yMid + rand(-h / 2, h / 2);
    const segs = floor(rand(12, 22));
    const pts = [];
    for (let s = 0; s <= segs; s++) {
      const u = s / segs;
      const x = lerp(leftX, rightX, u);
      const wobble = Math.sin(u * PI * rand(1.3, 2.2) + i * 0.6) * rand(1.5, 3.5);
      const safe = clampSafe(x + rand(-0.5, 0.5), y + wobble);
      pts.push(safe);
    }
    addShapeFromPoints(pts, inkIndex);
  }
}

function buildVerticalSeam(inkIndex) {
  const top = dyn.cy - dyn.ry * 0.85;
  const bottom = dyn.cy + dyn.ry * 0.85;
  const segs = 8;
  const pts = [];
  for (let i = 0; i <= segs; i++) {
    const u = i / segs;
    const x = dyn.cx + rand(-1.2, 1.2);
    const y = lerp(top, bottom, u) + Math.sin(u * PI * 1.5) * rand(-1.1, 1.1);
    pts.push(clampSafe(x, y));
  }
  addShapeFromPoints(pts, inkIndex);
}

/* ---------- Drawing ---------- */
function drawPreview() {
  background(255);
  noFill();
  shapes.forEach(s => {
    strokeHex(COLORS[s.ink].hex);
    strokeWeight(strokePx);
    beginShape();
    s.d.trim().split(/s+/).forEach(cmd => {
      if (cmd[0] === 'M' || cmd[0] === 'L') {
        const parts = cmd.slice(1).split(',');
        const x = Number(parts[0]);
        const y = Number(parts[1]);
        vertex(x, y);
      }
    });
    endShape();
  });
  if (showMarkers) drawMarkers();
  if (showPalette) drawPalette();
}

function drawMarkers() {
  strokeHex('#000000');
  strokeWeight(1);
  const o = strokePx / 2;
  line(5 + o, o, o, o);
  line(o, o, o, 5 + o);
  line(cw - 5 - o, ch - o, cw - o, ch - o);
  line(cw - o, ch - 5 - o, cw - o, ch - o);
}

function drawPalette() {
  const inks = usedInks();
  if (!inks.length) return;
  const W = 300, gap = 7, barH = 2;
  const seg = (W - (inks.length - 1) * gap) / inks.length;
  const y = ch - 1.25 * PPI;
  let x = (cw - W) / 2;
  strokeWeight(barH);
  inks.forEach(ci => {
    strokeHex(COLORS[ci].hex);
    line(x, y, x + seg, y);
    x += seg + gap;
  });
}

/* ---------- Keys ---------- */
function keyPressed() {
  if (key === 'R' || key === 'r') regenerate();
  if (key === ' ') exportSVGs();
}

/* ---------- SVG Export ---------- */
function exportSVGs() {
  const ts = Date.now();
  saveSVG(`${DAY_ID}-ALL-PORTRAIT-${ts}.svg`, true, true);
  saveSVG(`${DAY_ID}-ALL-NM-PORTRAIT-${ts}.svg`, false, true);
  saveSVG(`${DAY_ID}-ALL-NP-PORTRAIT-${ts}.svg`, true, false);
  saveSVG(`${DAY_ID}-ALL-NMNP-PORTRAIT-${ts}.svg`, false, false);

  const inks = usedInks();
  let i = 0;
  (function downloadNext() {
    if (i >= inks.length) return;
    const ci = inks[i++];
    const name = `${DAY_ID}-0${ci}-${COLORS[ci].name.toUpperCase()}-PORTRAIT-${ts}.svg`;
    saveSVG(name, true, true, ci);
    setTimeout(downloadNext, 250);
  })();
}

function saveSVG(fname, includeMarkers, includePalette, soloInk = 0) {
  const full = usedInks();
  const inks = soloInk ? [soloInk] : full;
  let svg = `<svg version="1.1" width="${cw}" height="${ch}" xmlns="http://www.w3.org/2000/svg"
     xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape">n`;

  if (includeMarkers) {
    svg += `<g inkscape:groupmode="layer" id="layer0" inkscape:label="0-markers"
      style="display:inline" stroke="black" stroke-opacity="${STROKE_OPACITY}"
      inkscape:highlight-color="black">
      <path d="M5.5,0.5 L0.5,0.5 L0.5,5.5
               M${cw - 5.5},${ch - 0.5} L${cw - 0.5},${ch - 0.5} L${cw - 0.5},${ch - 5.5}"
            stroke-width="1" fill="none"/></g>n`;
  }

  const W = 300, gap = 7, seg = (W - (full.length - 1) * gap) / full.length;
  const yBar = ch - 1.25 * PPI;

  inks.forEach((ci, idx) => {
    const col = COLORS[ci];
    const pathAll = shapes.filter(s => s.ink === ci).map(s => s.d).join(' ');
    if (!pathAll) return;
    const x0 = (cw - W) / 2 + full.indexOf(ci) * (seg + gap);
    svg += `<g inkscape:groupmode="layer" id="layer${idx + 1}"
         inkscape:label="${ci}-${col.name.toLowerCase()}-${col.ink}-${col.w}"
       style="display:inline" stroke="${col.hex}" stroke-opacity="${STROKE_OPACITY}" stroke-width="${strokePx}" fill="none"
       inkscape:highlight-color="${col.hex}">
      <path d="${pathAll}"/>
      ${includePalette ? `<path d="M${x0},${yBar} H${x0 + seg}"/>` : ''}
    </g>n`;
  });

  svg += '</svg>';
  const blob = new Blob([svg], { type: 'image/svg+xml;charset=utf-8' });
  const url = URL.createObjectURL(blob);
  const a = createA(url, fname);
  a.attribute('download', fname);
  a.elt.click();
  a.remove();
  URL.revokeObjectURL(url);
}

closest recalled touchstone: shear-raked cranial shell (~0.23 estimated); differentiator: inner-envelope constraint that prevents clamped-edge overlaps altogether; cleared.

// Day 337
/*

=======================================
  Day 337 Self-Portrait (Shear Reservoir)
=======================================

### Title: Shear Reservoir

### Medium: Generative drawing on paper

### Keywords: generative art, artificial intelligence, digital art, algorithmic art,
              self-portrait, cranial ellipse, spiral field, shear rake, interference band, plotter-aware routing

### Conceptual Framework
I want to show my head as a container of layered pressure, but I no longer allow any part of the drawing to collapse into a single destructive point. Instead I build the portrait from parallel stresses: a cranial shell in multiple passes, an interior spiral reservoir where thought is recirculated, a right-side shear rake that scrapes diagonally across the face without sharing one origin, and a horizontal band that still asserts narration. The whole drawing says: energy can be intense and directional without being violent to the page. It’s a self-portrait of distribution—every gesture has somewhere specific to land.

### Technical Approach
The sketch keeps the 11 × 11 in (100 ppi) workspace, randomises margins per run, and stores all spin parameters in `generationRules` or in `dyn` created inside `pickDyn()`. A tilted cranial ellipse is sampled into 84 points and is drawn 2–3 times at slightly different radii to build a hull. An interior spiral field is produced by multiple parametric spirals whose radii decay toward the centre, each jittered and clamped to the work area so canvas and SVG stay in lockstep. The shear rake replaces the problematic convergent lattice: it samples an angle range on the right hemisphere of the ellipse, and for each line it uses a unique start angle on the outer ellipse and a slightly offset end angle on a smaller ellipse, so the lines read as a fan instead of a spike. Crossings are allowed; in rare cases clamping to the same boundary can still make two segments coincide, which is acceptable for this day. A horizontal interference band draws 3–7 wiggle lines across the head at a narrow vertical window, and a vertical seam reasserts portrait orientation. All strokes are recorded as `M`/`L` commands into `shapes[]` so the export routine can build per-ink SVG layers. `SPACE` exports the four combined variants plus one per ink using the exact naming scheme; `R` re-randomises everything except the chosen palette. p5’s built-in `lerp` is used directly—no redefinition—so the earlier namespace warning is resolved.

### Novelty Checklist
- new pairing: multi-radius cranial shell + right-side shear rake (non-convergent fan)
- new pairing: spiral reservoir + horizontal interference band in the same cranial frame
- plotter-aware rake design: staggered angle endpoints to reduce single-point stress

---
*/