@kolkrabbi/kol-growth 0.3.0 → 0.4.0

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # @kolkrabbi/kol-growth
 
+## 0.4.0 — 2026-10-31
+
+- **The line cools instead of freezing** (GrowthLineIntro, kol-fxr plan 45). With `settle` > 0 every node carries a heat 1 → 0 that fades by 1/settle a step; its motion, a split beside it, `poke`, or a warm neighbour pressing a fifth into its gap (less 0.15 a hop) raise it. Force and growth scale with heat, the last quarter tapers, the step is halved (it overshot every step), so nothing stops mid-move — 0.3.0's step-count freeze left a rubber-string rim and a hard stop. New fields: `heat`, `hot` (nodes still warm), `full`, `id` (stable node ids).
+- **Front growth** — while settling, each open-front edge splits with chance `growth`/100 a step, so the rim advances at a steady pace; splits end at the cap or when the front leaves the frame. `growth` now means a percentage for settling sims (fxr's home uses 2.5); `settle` 0 is unchanged.
+- **Soft pointer** — settling, a hover reaches 0.24 of the short side with a bell falloff `(1 − d²/r²)²`, capped under a third of `minGap` a frame.
+- **`draw({ wave })`** — `{ a, k, p }` displaces the drawn line by two crossed sines; the sim is untouched.
+- `orbCanvas(aspect, W)` · `pathCanvas(d, aspect, fit, W)` take an optional width (default 400). kol-fxr's `engine.js`, carried verbatim.
+
 ## 0.3.0 — 2026-10-30
 
 - **`settle` — the line rests** (kol-fxr plan 44 6.1 — user: *"it doesnt need to be so active when nothing is happening, its just the mouse interaction and the growth edges that are subject to constant change"*). 0.2.0 still jittered: a packed line never comes to rest (strands two nodes apart push along it), and growth split edges anywhere, so every split shoved the whole line. With `settle` > 0 a node with packed neighbours (14+ strands within 1.5 gaps) freezes after `settle` steps, growth splits only the front, and `poke` re-heats what it touches. Measured on a 1440×900 orb: 98% of the line moving every step → 8–13% while growing, 3% when grown, ~10× cheaper a step. Default 0 = 0.2.0's behaviour.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kolkrabbi/kol-growth",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "description": "The growing line engine, differential growth into shapes",
   "license": "MIT",
   "type": "module",

package/src/engine.js

@@ -13,15 +13,29 @@
 // sits still, not this jittering"*). By default the line is held 2 units inside the frame — the effect and the generator
 // draw on framed paper. `bleed` lets it run that far past every edge instead, and a node outside the frame FREEZES: no
 // force, no split, no merge, no growth. The wall the line piled into is gone; what leaves the frame sits still.
-// THE LINE RESTS (plan 44 6.1, user 2026-10-30: *"it doesnt need to be so active when nothing is happening, its just the
-// mouse interaction and the growth edges that are subject to constant change"*). A packed line never comes to rest on
-// its own — strands two nodes apart push along it, so it always wants to lengthen. With `settle` > 0 a node COOLS: off
-// the front (FRONT, below) it freezes after `settle` steps; on the front it stays live; the pointer (`poke`) re-heats
-// what it touches. Growth splits only the front — so only the growing front and the pointer move.
+//
+// THE LINE SETTLES (plan 45 W1, user 2026-10-30: *"it still jitters to helll at the edges, its like a rubber string...
+// until a timer is done thhen its just dead. AND the mouse is like just vibratiing EVERYTHING"*). Plan 44's version froze
+// nodes by flag and kept a "front" live forever — on a finished orb the whole rim was front: it sprang while growing, every
+// mouse move woke the whole rim, and the only stop was a hard cap flag. With `settle` > 0 every node carries a HEAT, 1 → 0:
+// it fades by 1/settle a step; its own motion, a split beside it, the pointer (`poke`), or a warm neighbour pressing a
+// fifth into its gap raise it. A cold node takes no force and is not resampled; a node's last quarter of heat tapers its
+// motion out instead of stopping it; growth eases to nothing over the last 15 % before the cap and ends there, and a
+// split's sideways nudge is capped at 0.15 · minGap so the wide-gapped rim is not kicked. Nothing is live forever, nothing
+// snaps: the line goes still as its heat fades (`hot` counts the nodes still warm). `settle` 0 is the framed, always-live
+// engine the effect and the generator draw with — unchanged.
 
 export const SIM_W = 1000
-/* fewer close strands than this, and a node is on the growing front */
+/* heat below this is cold: no force, no resample, no growth, and it does not count as hot */
+const COLD = 0.02
+/* fewer strands than this within 1.5 gaps, and a node is on the open front (measured: front ~10, packed interior ~20) */
 const FRONT = 14
+/* THE STEP IS HALVED when settling (plan 45 1.1, measured 2026-10-31): the relaxation as written overshoots — every node
+ * reversed direction EVERY step (direction correlation −1.00 over the whole line, 0.9 px in the tight gaps, 2.5 px at
+ * the rim), a two-step oscillation that never dies and was every jitter the user saw, the mouse's included. Half the
+ * move lands on the balance point instead of past it. The framed engine (settle 0) keeps its full step — the effect and
+ * the generator are drawn with it, and their look is not this plan's to change */
+const GAIN = 0.5
 
 /* density from any canvas: 1 − luma, on a grid `cols` wide, lightly blurred so the spacing changes smoothly */
 export function densityFrom(canvas, cols = 160, invert = false) {
@@ -50,7 +64,12 @@ export class Growth {
     this.rand = rand
     this.cap = cap
     this.minGap = 5; this.maxGap = 22; this.contrast = 1.4; this.growth = 4; this.bleed = 0; this.settle = 0
-    this.x = []; this.y = []; this.r = []
+    this.x = []; this.y = []; this.heat = []
+    /* settling: a stable id per node, kept through splits and merges, so a node can be followed frame to frame */
+    this.id = []; this.nid = 0
+    /* nodes still warm (settle > 0) — the loop can sleep at 0 */
+    this.hot = 0
+    this.acc = 0; this.full = false
   }
 
   setParams({ minGap, maxGap, contrast, growth, cap, bleed, settle }) {
@@ -83,7 +102,8 @@ export class Growth {
       const a = (i / n) * Math.PI * 2
       this.x.push(cx + Math.cos(a) * r); this.y.push(cy + Math.sin(a) * r)
     }
-    this.r = new Array(n).fill(0)
+    this.heat = new Array(n).fill(1); this.hot = n; this.acc = 0; this.full = false
+    this.id = Array.from({ length: n }, (_, i) => i); this.nid = n
   }
 
   dens(x, y) {
@@ -104,21 +124,26 @@ export class Growth {
     let n = x.length
     if (n < 3) return
     const R = this.maxGap, b = this.bleed
+    const S = this.settle, K = S > 0 ? 1 - 1 / S : 1
+    const heat = S > 0 ? (this.heat.length === n ? this.heat : (this.heat = new Array(n).fill(1))) : null
     /* spatial hash on the largest gap, over the frame and its bleed */
     const cols = Math.ceil((w + 2 * b) / R) + 1, rows = Math.ceil((h + 2 * b) / R) + 1
     const head = new Int32Array(cols * rows).fill(-1)
     const next = new Int32Array(n)
     const cell = (px, py) => Math.min(rows - 1, Math.max(0, Math.floor((py + b) / R))) * cols + Math.min(cols - 1, Math.max(0, Math.floor((px + b) / R)))
-    /* 1 = off the frame (for good), 2 = cooled (the pointer re-heats it) */
-    const rest = this.r.length === n ? this.r : (this.r = new Array(n).fill(0)), S = this.settle
-    const frozen = new Uint8Array(n)
-    for (let i = 0; i < n; i++) frozen[i] = this.out(x[i], y[i]) ? 1 : S > 0 && rest[i] >= S ? 2 : 0
+    /* a node takes force when it is on the frame and (settling) warm */
+    const live = new Uint8Array(n)
+    for (let i = 0; i < n; i++) live[i] = this.out(x[i], y[i]) || (heat && heat[i] <= COLD) ? 0 : 1
     for (let i = 0; i < n; i++) { const c = cell(x[i], y[i]); next[i] = head[c]; head[c] = i }
     const gaps = new Float32Array(n)
     for (let i = 0; i < n; i++) gaps[i] = this.gap(x[i], y[i])
-    const fx = new Float32Array(n), fy = new Float32Array(n), crowd = new Uint8Array(n)
+    const fx = new Float32Array(n), fy = new Float32Array(n)
+    /* a warm node pressing into a neighbour's gap wakes it, by how far it presses (settling only) */
+    const wake = heat ? new Float32Array(n) : null
+    /* settling: strands within 1.5 gaps of each node — the open front has few, the packed interior ~20 */
+    const crowd = heat ? new Uint8Array(n) : null
     for (let i = 0; i < n; i++) {
-      if (frozen[i]) continue
+      if (!live[i]) continue
       const ip = (i - 1 + n) % n, inx = (i + 1) % n
       /* smooth: toward the neighbours' midpoint */
       fx[i] += ((x[ip] + x[inx]) / 2 - x[i]) * 0.35
@@ -137,88 +162,135 @@ export class Growth {
             const dx = x[i] - x[j], dy = y[i] - y[j]
             const g = (gi + gaps[j]) / 2
             const d2 = dx * dx + dy * dy
-            /* a strand of line within 1.5 gaps — packed; the front has none on its open side */
-            if (d2 < 2.25 * g * g && crowd[i] < 255) crowd[i]++
+            if (crowd && d2 < 2.25 * g * g && crowd[i] < 255) crowd[i]++
             if (d2 >= g * g || d2 === 0) continue
             const d = Math.sqrt(d2)
             const push = ((g - d) / g) * 0.5
             fx[i] += (dx / d) * push * g * 0.5
             fy[i] += (dy / d) * push * g * 0.5
+            /* a press of a fifth of the gap or more carries heat across, less 0.15 a hop — so a push dies out within six
+             * strands instead of travelling the packed line as a pressure wave (the mouse moved nodes 511 px away, 2026-10-31) */
+            if (wake) { const v = Math.min(heat[i] - 0.15, heat[i] * ((g - d) / g - 0.2) / 0.8); if (v > 0.1 && v > wake[j]) wake[j] = v }
           }
         }
       }
     }
     const m = b > 0 ? -b : 2
     for (let i = 0; i < n; i++) {
-      if (frozen[i]) continue
-      const lim = gaps[i] * 0.25
-      const mx = Math.max(-lim, Math.min(lim, fx[i])), my = Math.max(-lim, Math.min(lim, fy[i]))
+      if (!live[i]) continue
+      /* full force while warm; the last quarter of a node's heat tapers its motion out, so nothing stops mid-move */
+      const lim = gaps[i] * 0.25, k = heat ? Math.min(1, heat[i] * 4) * GAIN : 1
+      const mx = Math.max(-lim, Math.min(lim, fx[i])) * k, my = Math.max(-lim, Math.min(lim, fy[i])) * k
       x[i] = Math.min(w - m, Math.max(m, x[i] + mx))
       y[i] = Math.min(h - m, Math.max(m, y[i] + my))
-      rest[i] = crowd[i] < FRONT ? 0 : rest[i] + 1
+      /* a node that still moves a tenth of its gap a step is still hot — heat is recent motion */
+      if (heat) { const v = Math.min(1, Math.hypot(mx, my) / (0.1 * gaps[i])); if (v > wake[i]) wake[i] = v }
     }
+    if (heat) for (let i = 0; i < n; i++) { const v = heat[i] * K; heat[i] = wake[i] > v ? wake[i] : v }
     /* resample: split long edges, merge short ones, then grow */
-    const nx = [], ny = [], nr = [], nc = []
+    const nx = [], ny = [], nh = [], ni = [], nc = []
+    const id = heat ? (this.id.length === n ? this.id : (this.id = Array.from({ length: n }, () => this.nid++))) : null
     let budget = this.cap - n
     for (let i = 0; i < n; i++) {
       const j = (i + 1) % n
       const g = this.gap(x[i], y[i])
       const dx = x[j] - x[i], dy = y[j] - y[i]
       const len = Math.hypot(dx, dy)
-      /* an edge with a frozen end keeps its nodes as they are */
-      if (frozen[i] || frozen[j]) { nx.push(x[i]); ny.push(y[i]); nr.push(rest[i]); nc.push(255); continue }
-      if (len < g * 0.2 && n > 8) continue
-      nx.push(x[i]); ny.push(y[i]); nr.push(rest[i]); nc.push(crowd[i])
-      if (len > g * 0.5 && budget > 0) { nx.push(x[i] + dx / 2); ny.push(y[i] + dy / 2); nr.push(0); nc.push(crowd[i]); budget-- }
+      /* an edge with a frozen or cold end keeps its nodes as they are */
+      if (!live[i] || !live[j]) { nx.push(x[i]); ny.push(y[i]); if (heat) { nh.push(heat[i]); ni.push(id[i]); nc.push(255) } continue }
+      /* settling, a merge must not leave an edge long enough to split again — a merge/split loop at one spot was the
+       * last thing moving on a finished line (10 nodes, 1.5 px, forever; measured 2026-10-31) */
+      if (len < g * 0.2 && n > 8 && (!heat || Math.hypot(x[j] - x[(i - 1 + n) % n], y[j] - y[(i - 1 + n) % n]) < g * 0.45)) continue
+      nx.push(x[i]); ny.push(y[i]); if (heat) { nh.push(heat[i]); ni.push(id[i]); nc.push(crowd[i]) }
+      if (len > g * 0.5 && budget > 0) { nx.push(x[i] + dx / 2); ny.push(y[i] + dy / 2); if (heat) { nh.push(Math.max(heat[i], heat[j])); ni.push(this.nid++); nc.push(crowd[i]) } budget-- }
     }
-    /* WHERE IT GROWS: anywhere (the default), or — resting on — only the FRONT: active edges with room around them (fewer
-     * than FRONT strands within 1.5 gaps; measured, the front holds ~10, the packed interior ~20). Grown anywhere, every
-     * split shoves the whole line and nothing ever rests */
-    const front = []
-    if (S > 0) for (let i = 0; i < nx.length; i++) {
-      const j = (i + 1) % nx.length
-      if (nr[i] < S && nr[j] < S && nc[i] < FRONT && nc[j] < FRONT && !this.out(nx[i], ny[i]) && !this.out(nx[j], ny[j])) front.push(i)
+    if (!heat) {
+      for (let k = 0; k < this.growth && nx.length < this.cap; k++) {
+        const i = Math.floor(this.rand() * nx.length), j = (i + 1) % nx.length
+        if (this.out(nx[i], ny[i]) || this.out(nx[j], ny[j])) continue
+        /* a split nudged sideways starts a new fold */
+        const dx = nx[j] - nx[i], dy = ny[j] - ny[i]
+        const s = (this.rand() - 0.5) * 0.6
+        nx.splice(i + 1, 0, nx[i] + dx / 2 - dy * s)
+        ny.splice(i + 1, 0, ny[i] + dy / 2 + dx * s)
+      }
+      this.x = nx; this.y = ny
+      return
     }
-    for (let k = 0; k < this.growth && nx.length < this.cap; k++) {
-      if (S > 0 && !front.length) break
-      /* ponytail: front indices drift by the splits made before them this step — a neighbouring edge, harmless */
-      let i = S > 0 ? front[Math.floor(this.rand() * front.length)] : Math.floor(this.rand() * nx.length)
-      i = Math.min(i, nx.length - 1)
-      const j = (i + 1) % nx.length
-      if (S === 0 && (this.out(nx[i], ny[i]) || this.out(nx[j], ny[j]))) continue
-      /* a split nudged sideways starts a new fold */
-      const dx = nx[j] - nx[i], dy = ny[j] - ny[i]
-      const s = (this.rand() - 0.5) * 0.6
-      nx.splice(i + 1, 0, nx[i] + dx / 2 - dy * s)
-      ny.splice(i + 1, 0, ny[i] + dy / 2 + dx * s)
-      nr.splice(i + 1, 0, 0); nc.splice(i + 1, 0, nc[i])
+    /* SETTLING GROWTH — the differential-growth rule (plan 45, user 2026-10-31: *"the growth starts well but plateaus early
+     * at a small size … then 4 minutes later it reaches the edges"*): every edge on the open FRONT (both ends warm, fewer than
+     * FRONT strands within 1.5 gaps) splits with chance `growth`/100 a step. Random splits anywhere wasted most of the budget
+     * on the cooled interior, where nothing can move — the rim crawled and the nodes ran out before the edges. The front's
+     * length grows with the line, so the rim advances at a steady pace instead of stalling. Once the cap is reached the
+     * splits stop for good (merges may drop the count under it; refilling it forever was the churn). The sideways nudge is
+     * capped so a wide-gapped edge (the rim) is not kicked */
+    if (nx.length >= this.cap) this.full = true
+    if (!this.full) {
+      const p = this.growth / 100, kick = 0.15 * this.minGap
+      const front = []; let open = 0
+      for (let i = 0; i < nx.length; i++) {
+        const j = (i + 1) % nx.length
+        if (nh[i] > COLD && nh[j] > COLD && nc[i] < FRONT && nc[j] < FRONT && !this.out(nx[i], ny[i]) && !this.out(nx[j], ny[j])) { open++; if (this.rand() < p) front.push(i) }
+      }
+      /* the front has run off the frame: the line has filled what it can reach — done, cap or not */
+      if (open === 0 && nx.length > 200) this.full = true
+      /* back to front, so an insert never shifts an index still to come */
+      for (let q = front.length - 1; q >= 0 && nx.length < this.cap; q--) {
+        const i = front[q], j = (i + 1) % nx.length
+        const dx = nx[j] - nx[i], dy = ny[j] - ny[i]
+        let s = (this.rand() - 0.5) * 0.6
+        const len = Math.hypot(dx, dy) || 1
+        if (Math.abs(s) * len > kick) s = Math.sign(s) * kick / len
+        nx.splice(i + 1, 0, nx[i] + dx / 2 - dy * s)
+        ny.splice(i + 1, 0, ny[i] + dy / 2 + dx * s)
+        nh.splice(i + 1, 0, 1); nh[i] = 1; nh[(i + 2) % nh.length] = 1; ni.splice(i + 1, 0, this.nid++); nc.splice(i + 1, 0, nc[i])
+      }
     }
-    this.x = nx; this.y = ny; this.r = nr; this.c = nc
+    let hot = 0
+    for (let i = 0; i < nh.length; i++) if (nh[i] > COLD) hot++
+    this.x = nx; this.y = ny; this.heat = nh; this.hot = hot; this.id = ni
   }
 
   /* THE POINTER AS A FORCE (sim units) — penrose/common.js's verbs on this line: a move pushes the nodes out of a ring
    * around (px, py), a press blasts (3× reach, 6× strength, capped at 3% of the frame a step so it reads as a shove, not
-   * a teleport). The line's own smoothing and spacing refold the crater; `amount` 0 turns it off. */
+   * a teleport). The line's own smoothing and spacing refold the crater; `amount` 0 turns it off. Settling, a push is
+   * capped under half the tightest gap, so it can never carry a node across a strand, and it heats what it moves. */
   poke(px, py, down = false, amount = 1) {
     if (!amount) return
     const { x, y, w, h } = this, s = Math.min(w, h), m = this.bleed > 0 ? -this.bleed : 2
-    const reach = s * 0.08 * (down ? 3 : 1), r2 = reach * reach
-    const strength = Math.min(s * 0.03, s * 0.006 * amount * (down ? 6 : 1))
+    const heat = this.settle > 0 && this.heat.length === x.length ? this.heat : null
+    /* settling, a hover reaches as far as a press, three times the old brush, and fades out soft (plan 45 1.4, user
+     * 2026-10-31: *"the mouse radius is so small it should be bigger and more blurry"*) */
+    const reach = s * (heat && !down ? 0.24 : 0.08) * (down ? 3 : 1), r2 = reach * reach
+    let strength = Math.min(s * 0.03, s * 0.006 * amount * (down ? 6 : 1))
+    /* settling, a hover is a nudge (under a third of the tightest gap a frame, user 2026-10-31: *"mouse hover applies too much
+     * affect?"*) — at half a gap it crammed strands into each other; a press may shove up to half a gap */
+    if (heat) strength = Math.min(strength, (down ? 0.45 : 0.3) * this.minGap)
+    let hot = this.hot
     for (let i = 0; i < x.length; i++) {
       const dx = x[i] - px, dy = y[i] - py, d2 = dx * dx + dy * dy
       if (d2 >= r2 || d2 < 1e-6 || this.out(x[i], y[i])) continue
-      const d = Math.sqrt(d2), f = (1 - d / reach) * strength
+      /* settling, the falloff is a bell — (1 − d²/r²)², no edge at the rim — instead of the linear cone */
+      const d = Math.sqrt(d2), q = 1 - d2 / r2, fall = heat ? q * q : 1 - d / reach, f = fall * strength
       x[i] = Math.min(w - m, Math.max(m, x[i] + (dx / d) * f))
       y[i] = Math.min(h - m, Math.max(m, y[i] + (dy / d) * f))
-      if (this.r.length === x.length) this.r[i] = 0
+      if (heat) { const v = fall; if (v > heat[i]) { if (heat[i] <= COLD && v > COLD) hot++; heat[i] = v } }
     }
+    this.hot = hot
   }
 
   /* the one path, scaled onto a w × h frame */
-  draw(ctx, fw, fh, { ink = '#111', paper = null, width = 1.2 } = {}) {
+  draw(ctx, fw, fh, { ink = '#111', paper = null, width = 1.2, wave = null } = {}) {
     if (paper) { ctx.fillStyle = paper; ctx.fillRect(0, 0, fw, fh) }
-    const { x, y } = this
+    let { x, y } = this
     const n = x.length
+    /* a slow wave (plan 45 4.3): the drawn line is displaced by two crossed sines — `a` px, `k` rad/px, phase `p` — and
+     * the sim itself never moves, so a resting line still drifts at no cost to the step */
+    if (wave && n) {
+      const { a, k, p } = wave, wx = new Float32Array(n), wy = new Float32Array(n)
+      for (let i = 0; i < n; i++) { wx[i] = x[i] + a * Math.sin(k * y[i] + p); wy[i] = y[i] + a * Math.sin(k * x[i] + p * 1.3 + 1) }
+      x = wx; y = wy
+    }
     if (n < 3) return
     const sx = fw / this.w, sy = fh / this.h
     ctx.beginPath()

package/src/selftest.mjs

@@ -17,18 +17,19 @@ const before = a.x.slice()
 a.poke(a.x[0], a.y[0] + 1, true)
 assert.notDeepEqual(a.x, before, 'poke moves the line')
 assert.match(a.pathD(400, 300), /^M.*Z$/, 'one closed path')
-/* resting (`settle`): the packed interior cools and stops — once grown, a step moves only the front */
+/* settling (`settle`): every node's heat fades — a grown line goes cold and a step then moves nothing; a poke re-heats it */
 const r = new Growth({ w: 400, h: 300, rand: mulberry32(5), cap: 1500 })
-r.setParams({ minGap: 6, maxGap: 24, contrast: 1.4, growth: 8, bleed: 30, settle: 40 })
+r.setParams({ minGap: 6, maxGap: 24, contrast: 1.4, growth: 2.5, bleed: 30, settle: 40 })
 r.seed()
-for (let i = 0; i < 3000 && r.x.length < r.cap; i++) r.step()
-for (let i = 0; i < 60; i++) r.step()
-const rx = r.x.slice(), ry = r.y.slice(), rn = r.x.length
+for (let i = 0; i < 20000 && (!r.full || r.hot > 0); i++) r.step()
+assert.ok(r.full && r.hot === 0, `a grown line goes cold (full ${r.full}, hot ${r.hot})`)
+const rx = r.x.slice(), ids = r.id.slice()
 r.step()
-if (r.x.length === rn) {
-  const still = rx.filter((v, i) => v === r.x[i] && ry[i] === r.y[i]).length
-  assert.ok(still / rn > 0.8, `a grown line rests (${still}/${rn} still)`)
-}
+assert.deepEqual(r.x, rx, 'a cold line does not move')
+r.poke(r.x[0], r.y[0] + 1)
+assert.ok(r.hot > 0, 'a poke re-heats it')
+for (let i = 0; i < 20000 && r.hot > 0; i++) r.step()
+assert.ok(r.hot === 0 && r.id.filter((v) => ids.includes(v)).length > ids.length * 0.9, 'it cools again and keeps its nodes')
 /* with a bleed the line may leave the frame, and stays inside the bled frame */
 const c = new Growth({ w: 200, h: 150, rand: mulberry32(3), cap: 900 })
 c.setParams({ minGap: 6, maxGap: 24, contrast: 1.4, growth: 8, bleed: 30 })

package/src/shapes.js

@@ -2,8 +2,8 @@
 // The one DOM in this engine (as `densityFrom` itself): a shape is a canvas, so these run in a browser.
 
 /* the built-in orb, kol-fxr's `sourceCanvas('orb')` carried verbatim: a radial gradient, black at the centre */
-export function orbCanvas(aspect) {
-  const W = 400, H = Math.max(1, Math.round(W / aspect))
+export function orbCanvas(aspect, W = 400) {
+  const H = Math.max(1, Math.round(W / aspect))
   const c = document.createElement('canvas')
   c.width = W; c.height = H
   const g = c.getContext('2d')
@@ -17,8 +17,8 @@ export function orbCanvas(aspect) {
 
 /* any SVG path `d`, filled solid black on white, centred and scaled to `fit` of the frame — kol-fxr's `vectorCanvas`
  * for a bare path: synchronous (no image decode), the bounds measured by the browser's own SVG `getBBox` */
-export function pathCanvas(d, aspect, fit = 0.6) {
-  const W = 400, H = Math.max(1, Math.round(W / aspect))
+export function pathCanvas(d, aspect, fit = 0.6, W = 400) {
+  const H = Math.max(1, Math.round(W / aspect))
   const c = document.createElement('canvas')
   c.width = W; c.height = H
   const g = c.getContext('2d')