agentvfx 0.0.0-stage → 0.3.4

package/skills/agentvfx/templates/spectrum/_src/bars-mirror/main.src.frag

@@ -0,0 +1,72 @@
+// bars-mirror main: the full-frame FIELD version. One saturated field colour (acid lime / ultramarine /
+// signal orange / phosphor green on black) with black or white ink: a four-way mirrored spectrum of tiny
+// hairline bars growing up and down from a centre slit (low frequencies meet in the middle), tip dots,
+// a dashed centre axis with a tick ruler and numerals, an inset frame with corner brackets and + marks,
+// and engine-text labels. mirrorMode 0 = four-way, 1 = full-width mirrored top / bottom, 2 = centre-out
+// growing up from the floor. A strong onset (hitFlux) swaps field and ink for ~3 frames: the hard cut.
+//@include stage.glsl
+//@include hud.glsl
+
+vec4 barAt(int i) { return texelFetch(barState, ivec2(clamp(i, 0, bandCount - 1), 0), 0); }
+
+void main() {
+  vec2 res = RENDERSIZE;
+  float U = hudU();
+  vec4 clk = texelFetch(barState, ivec2(0, 1), 0);
+  vec2 sp = vUv * res;
+  vec2 uv = stageUv(clk, vUv);
+  vec2 px = uv * res;
+  float n = float(bandCount);
+  float cx = res.x * 0.5;
+  float halfW = res.x * 0.42;
+  float pitch = mirrorMode == 1 ? res.x * 0.84 / n : halfW / n;
+  float coordX = mirrorMode == 1 ? px.x - res.x * 0.08 : abs(px.x - cx) - centreGap * res.x;
+  float fi = floor(coordX / pitch);
+  int i = int(clamp(fi, 0.0, n - 1.0));
+  float span = introSpan();
+  bool inSpan = fi >= 0.0 && fi < n && abs(uv.x - 0.5) * 2.0 < span * 0.86 + 0.001;
+  float lx = coordX - (fi + 0.5) * pitch;
+  float hwBar = max(hudW() * 0.5, pitch * thickness * 0.5);
+  float baseY = mirrorMode == 2 ? 0.1 * res.y : 0.5 * res.y;
+  float dy = mirrorMode == 2 ? px.y - baseY : abs(px.y - baseY) - 1.5 * U;
+  float extent = res.y * (mirrorMode == 2 ? 0.74 : 0.36) * maxHeight * introK();
+  vec4 bar = barAt(i);
+  float hj = bar.r * extent + floorHeight * U;
+  float body = inSpan ? cov(abs(lx) - hwBar) * step(-0.5, dy) * cov(dy - hj) : 0.0;
+  float tipY = hj + 3.5 * U;
+  float tip = inSpan && tipDots ? cov(length(vec2(lx, dy - tipY)) - 1.5 * U) * step(0.012, bar.r) : 0.0;
+  float capY = bar.g * extent + 6.0 * U;
+  float cap = inSpan && bar.g * extent > hj + 8.0 * U ? cov(abs(dy - capY) - 0.7 * U) * cov(abs(lx) - hwBar * 1.8) : 0.0;
+
+  float axis = mirrorMode == 2 ? 0.0 : hair(px.y - baseY) * dashes(px.x, 10.0, 0.5) * step(abs(uv.x - 0.5) * 2.0, span * 0.92);
+  float tickX = abs(fract(coordX / (pitch * 4.0) + 0.5) - 0.5) * pitch * 4.0;
+  float tl = (mod(fi, 16.0) < 0.5 ? 14.0 : 6.0) * U;
+  float rd = mirrorMode == 2 ? 14.0 * U - px.y : abs(px.y - baseY) - extent * 1.06 - 6.0 * U;
+  float rtick = inSpan && rd > 0.0 && rd < tl && tickX < hudW() * 0.6 ? 1.0 : 0.0;
+
+  float rowsG = 0.0;
+  for (int r = 1; r <= 3; r++) {
+    float yr = baseY + float(r) * extent / 3.0;
+    float yr2 = baseY - float(r) * extent / 3.0;
+    rowsG = max(rowsG, max(hair(px.y - yr), mirrorMode == 2 ? 0.0 : hair(px.y - yr2)));
+  }
+  rowsG *= dashes(px.x, 8.0, 0.25) * step(abs(uv.x - 0.5) * 2.0, span * 0.92) * 0.55;
+
+  vec2 flo = vec2(0.035 * res.x, 0.05 * res.y);
+  vec2 fhi = vec2(0.965 * res.x, 0.95 * res.y);
+  float frame = boxLine(sp, flo, fhi) * 0.8 + brackets(sp, flo - 8.0 * U, fhi + 8.0 * U, 26.0 * U);
+  vec2 qc = abs(sp - res * 0.5);
+  float plus = max(hair(qc.y) * step(qc.x, 12.0 * U), hair(qc.x) * step(qc.y, 12.0 * U));
+
+  float m = max(max(body, tip), max(cap, max(axis * 0.9, rtick * 0.9)));
+  m = max(m, rowsG * gridAmount);
+  m = max(m, max(frame * gridAmount, plus * float(marks)));
+  m = max(m, textInk());
+  vec3 gnd = stageBackground(vUv, inkColor.rgb, kickEnv(clk));
+  float hit = step(0.5, hitEnv(clk, max(flashDecayMs * 0.001, 0.001))) * step(0.5, clk.x) * invertHit;
+  vec3 ink = inkColor.rgb;
+  vec3 straight = mix(gnd, mix(ink, accentAt((fi + 0.5) / n), min(cap + tip, 1.0)), m);
+  vec3 swapped = mix(ink, gnd, m);
+  vec3 col = mix(straight, swapped, hit);
+  fragColor = vec4(stageFinish(col, vUv), 1.0);
+}

package/skills/agentvfx/templates/spectrum/_src/bars-mirror/pass0.src.frag

@@ -0,0 +1,2 @@
+// bars-mirror pass 0: pro-motion bar state (see the shared block below), persistent in barState.
+//@include bars-pass.glsl

package/skills/agentvfx/templates/spectrum/_src/bass-circle/fx.src.json

@@ -0,0 +1,56 @@
+{
+  "DESCRIPTION": "Thin-line bracketed bass instrument: up to eight nested hairline outlines (delayed, exponent-stepped) around a halftone emblem disc, hatch fill, tick ring and corner brackets",
+  "CREDIT": "agentvfx",
+  "ISFVSN": "2",
+  "CATEGORIES": ["spectrum", "audio", "hud"],
+  "INPUTS": [
+    { "NAME": "bandCount", "TYPE": "long", "MIN": 8, "MAX": 64, "DEFAULT": 26 },
+    { "NAME": "layerCount", "TYPE": "long", "MIN": 1, "MAX": 8, "DEFAULT": 8 },
+    { "NAME": "layerDelay", "TYPE": "long", "MIN": 1, "MAX": 3, "DEFAULT": 2 },
+    { "NAME": "emblemRadius", "TYPE": "float", "MIN": 0.06, "MAX": 0.3, "DEFAULT": 0.15 },
+    { "NAME": "emblemBounce", "TYPE": "float", "MIN": 0, "MAX": 0.5, "DEFAULT": 0.1 },
+    { "NAME": "emblemShake", "TYPE": "float", "MIN": 0, "MAX": 24, "DEFAULT": 0 },
+    { "NAME": "maxRadius", "TYPE": "float", "MIN": 0.05, "MAX": 0.45, "DEFAULT": 0.15 },
+    { "NAME": "bandGap", "TYPE": "float", "MIN": 0, "MAX": 0.03, "DEFAULT": 0.009 },
+    { "NAME": "hatchAmount", "TYPE": "float", "MIN": 0, "MAX": 1, "DEFAULT": 0.55 },
+    { "NAME": "spin", "TYPE": "float", "MIN": -3, "MAX": 3, "DEFAULT": 0.1 },
+    { "NAME": "snapDeg", "TYPE": "float", "MIN": 0, "MAX": 90, "DEFAULT": 10 },
+    { "NAME": "coneAmount", "TYPE": "float", "MIN": 0, "MAX": 1, "DEFAULT": 0.8 },
+    { "NAME": "coneCount", "TYPE": "long", "MIN": 0, "MAX": 160, "DEFAULT": 90 },
+    { "NAME": "coneSpeed", "TYPE": "float", "MIN": 0.05, "MAX": 2, "DEFAULT": 0.25 }
+  ],
+  "use": ["pro", "stage", "hud"],
+  "defaults": { "startFreq": 30, "endFreq": 300, "freqCurve": 1, "floorLevel": 0.34, "ceilLevel": 0.6, "expLow": 1.5, "expHigh": 1.5, "headBars": 0, "monsterSmooth": 1.2, "attackMs": 10, "releaseMs": 110, "bassHold": 0, "kickBass": 1.4, "glowRadius": 0.02 },
+  "PASSES": [
+    { "TARGET": "barState", "PERSISTENT": true, "FLOAT": true },
+    {}
+  ],
+  "X_AGENTVFX": {
+    "id": "bass-circle",
+    "family": "spectrum",
+    "input": "either",
+    "spdx": "LicenseRef-agentvfx",
+    "flash": "none",
+    "fps": 30,
+    "palette": true,
+    "presets": {
+      "bracket-black": {},
+      "bracket-ultramarine": { "$field": "ultramarine" },
+      "bracket-orange": { "$field": "orange", "layerCount": 6 },
+      "bracket-acid": { "$field": "acid", "hatchAmount": 0.8 },
+      "rainbow-glow": { "colorMode": 1, "glow": 1.6, "lineWidth": 2.6, "hatchAmount": 0.2 }
+    },
+    "audioBind": { "emblemBounce": "bass" },
+    "safeSubstitute": { "params": { "kickZoom": 0, "shake": 0, "emblemShake": 0, "snapDeg": 0 } },
+    "text": [
+      { "key": "title", "default": "BASS 30-300HZ", "x": 0.03, "y": 0.06, "size": 0.07, "font": "display", "style": "outline", "box": "tab" },
+      { "key": "node", "default": "NODE 7G-75", "x": 0.97, "y": 0.045, "size": 0.085, "font": "tall", "align": "right" },
+      { "key": "log", "default": "KICK GATE 1.4\nLAYERS 8  DELAY 2F\nCACHE OK", "x": 0.03, "y": 0.8, "size": 0.017, "font": "mono", "reveal": "type", "revealStart": 0.2, "revealDur": 1.5 },
+      { "key": "num", "default": "KX  7G2  R4  D9\n41A TQP  118  3", "x": 0.97, "y": 0.9, "size": 0.016, "font": "mono", "align": "right" }
+    ],
+    "credits": [
+      "Thin-line bracketed radial instrument: original drawing, no marks, fonts or text from other works",
+      "Layer delays, exponents and smoothing margins follow the parameters published in the open caseif/js.nation recreation (MIT; values described, no code used)"
+    ]
+  }
+}

package/skills/agentvfx/templates/spectrum/_src/bass-circle/main.src.frag

@@ -0,0 +1,136 @@
+// bass-circle main: a thin-line bracketed bass instrument. Only the bass band (startFreq..endFreq, 30..300
+// Hz by default) is analysed, so the shape moves on real kicks only. Up to eight nested hairline outlines
+// are drawn: outline s shows the bass spectrum delayed by s * layerDelay frames, raised to its own exponent
+// [1, 1.12, 1.14, 1.30, 1.33, 1.36, 1.50, 1.52] and smoothed with a triangular kernel of its own width
+// [0, 2, 2, 3, 3, 3, 5, 5]; radii are kept nested (bandGap) and older outlines are dimmer. The shape is
+// mirrored left / right about an axis that snaps on every kick. Between the inner disc and the newest
+// outline a radial dash hatch (hatchAmount) fills the shape. The centre disc is a hairline circle holding
+// the input as a one-tone halftone (or, without footage, a ring + cross mark) that bounces and shakes with
+// the bass. Around it: a square bracket frame that breathes with the kick, + marks at the cardinal points,
+// a tick ring and a ring of fine dots (the particle cone as one-pixel dots streaming outward).
+//@include stage.glsl
+//@include hud.glsl
+const float TAU = 6.28318530718;
+const float EXP[8] = float[8](1.0, 1.12, 1.14, 1.30, 1.33, 1.36, 1.50, 1.52);
+
+float histAt(int i, int d) { return texelFetch(barState, ivec2(clamp(i, 0, bandCount - 1), d == 0 ? 0 : 3 + d), 0).r; }
+
+float sampleAt(float fx, int d) {
+  float x = clamp(fx, 0.0, float(bandCount - 1));
+  int i0 = int(floor(x));
+  float t = x - float(i0);
+  return mix(histAt(i0, d), histAt(i0 + 1, d), t * t * (3.0 - 2.0 * t));
+}
+
+float layerHeight(float fx, int d, int mg) {
+  float s = 0.0;
+  float ws = 0.0;
+  for (int k = -5; k <= 5; k++) {
+    if (abs(k) > mg) { continue; }
+    float w = float(mg + 1 - abs(k));
+    s += w * sampleAt(fx + float(k), d);
+    ws += w;
+  }
+  return s / ws;
+}
+
+void main() {
+  vec2 res = RENDERSIZE;
+  float U = hudU();
+  float px1 = 1.0 / res.y;
+  float u1 = 1.0 / 1080.0;
+  vec4 clk = texelFetch(barState, ivec2(0, 1), 0);
+  vec2 sp = vUv * res;
+  vec2 uv = stageUv(clk, vUv);
+  float ke = kickEnv(clk);
+  float since = stageSince(clk.z, clk.w);
+  vec2 p = (uv * res - res * 0.5) * px1;
+  vec2 sh = (hash22(vec2(clk.z, 9.1)) - 0.5) * 2.0 * emblemShake * ke * u1;
+  vec2 pe = p - sh;
+  float r = length(p);
+  float rot = TIME * spin + (clk.z > 0.5 ? radians(snapDeg) * (clk.z - exp(-since / 0.07)) : 0.0);
+  float a = atan(p.x, p.y) - rot;
+  a = mod(a + 3.14159265, TAU) - 3.14159265;
+  float fm = abs(a) / 3.14159265 * float(bandCount - 1);
+  float grow = introK();
+  float Re = emblemRadius * (1.0 + emblemBounce * ke) * (0.3 + 0.7 * introSpan());
+  float R0 = Re * 1.06 + 0.006;
+  float wU = hudW() * px1;
+
+  float radii[8];
+  float prevR = R0;
+  for (int s = 0; s < 8; s++) {
+    if (s >= layerCount) { break; }
+    int mg = s == 0 ? 0 : (s < 3 ? 2 : (s < 6 ? 3 : 5));
+    float A = layerHeight(fm, s * layerDelay, mg);
+    float rs = R0 + max(maxRadius * pow(A, EXP[s]), 0.0) * grow;
+    rs = max(rs, prevR + (s == 0 ? 0.0 : bandGap * grow));
+    radii[s] = rs;
+    prevR = rs;
+  }
+  float outlines = 0.0;
+  for (int s = 7; s >= 0; s--) {
+    if (s >= layerCount) { continue; }
+    float al = s == 0 ? 1.0 : max(0.62 - 0.08 * float(s), 0.18);
+    outlines = max(outlines, hair((r - radii[s]) / px1) * al);
+  }
+  float newest = radii[0];
+  float hatch = step(R0, r) * step(r, newest) * step(0.5, fract(a / TAU * 180.0 * (1.0 + 0.0))) * step(0.5, fract(r / (7.0 * u1))) * hatchAmount;
+
+  float de = length(pe) - Re;
+  float disc = hair(de / px1);
+  float emblem;
+  if (HAS_INPUT) {
+    float c = cos(rot * 0.5);
+    float sn = sin(rot * 0.5);
+    vec2 q = vec2(0.5) + (mat2(c, -sn, sn, c) * pe / Re) * 0.275 * vec2(res.y / res.x, 1.0);
+    float cell = max(halftoneSize * 0.7 * U, 2.0);
+    vec2 g = (q * res) / cell;
+    vec2 fr = fract(g) - 0.5;
+    float L = luma(texture(inputImage, (floor(g) + 0.5) * cell / res).rgb);
+    emblem = cov((length(fr) - 0.6 * sqrt(clamp(L * 1.2, 0.0, 1.0))) * cell) * step(de, 0.0);
+  } else {
+    float lr = length(pe) / Re;
+    float ca = cos(rot);
+    float sa = sin(rot);
+    vec2 qq = mat2(ca, -sa, sa, ca) * pe / Re;
+    float crossA = max(hair(qq.y * Re / px1) * step(abs(qq.x), 0.5), hair(qq.x * Re / px1) * step(abs(qq.y), 0.5));
+    emblem = max(hair((lr - 0.6) * Re / px1) * 0.8, crossA) * step(de, 0.0);
+  }
+
+  float half0 = 0.44 * (1.0 + 0.03 * ke);
+  vec2 flo = res * 0.5 - half0 * res.y;
+  vec2 fhi = res * 0.5 + half0 * res.y;
+  float brk = brackets(sp, flo, fhi, 34.0 * U) * gridAmount;
+  float plus = 0.0;
+  for (int c = 0; c < 4; c++) {
+    vec2 dir = c == 0 ? vec2(1.0, 0.0) : (c == 1 ? vec2(-1.0, 0.0) : (c == 2 ? vec2(0.0, 1.0) : vec2(0.0, -1.0)));
+    plus = max(plus, plusAt(sp, res * 0.5 + dir * (half0 + 0.025) * res.y, 7.0 * U));
+  }
+  float tickCnt = 90.0;
+  float tkd = abs(fract(a / TAU * tickCnt) - 0.5) * (TAU * 0.46 / tickCnt);
+  float ticks = step(abs(r - 0.46), 0.007 * (mod(floor(a / TAU * tickCnt), 5.0) < 0.5 ? 1.5 : 1.0)) * cov((tkd - wU * 0.5) / px1) * gridAmount;
+  float outerDash = hair((r - 0.43) / px1) * dashes(a * 0.43 / px1, 8.0, 0.4) * gridAmount;
+
+  float cone = 0.0;
+  for (int k = 0; k < 160; k++) {
+    if (k >= coneCount) { break; }
+    vec3 h = vec3(hash12(vec2(float(k), 1.7)), hash12(vec2(float(k), 4.3)), hash12(vec2(float(k), 8.9)));
+    float z = fract(TIME * coneSpeed * (1.0 + 0.8 * ke) * (0.5 + h.y) + h.z);
+    vec2 pos = vec2(cos(h.x * TAU), sin(h.x * TAU)) * (prevR + 0.02 + z * z * 0.5);
+    cone = max(cone, cov((length(p - pos) - (0.7 + 1.6 * z) * u1) / px1) * smoothstep(0.0, 0.1, z) * smoothstep(1.0, 0.7, z));
+  }
+
+  float mk = max(max(outlines, hatch), max(disc, emblem));
+  mk = max(mk, max(brk, max(plus * float(marks), max(ticks * 0.8, outerDash * 0.6))));
+  mk = max(mk, cone * coneAmount);
+  mk = max(mk, textInk());
+  vec3 ink = inkColor.rgb;
+  vec3 gnd = stageBackground(vUv, ink, ke);
+  vec3 col = mix(gnd, ink, mk);
+  float hot = hair((r - radii[0]) / px1);
+  vec3 acc = colorMode == 1 ? paletteCycle(clamp(a / TAU + 0.5, 0.0, 1.0) + paletteShift) : accentColor.rgb;
+  col = mix(col, acc, hot * 0.9);
+  col += acc * exp(-max(r - prevR, 0.0) / max(glowRadius, px1)) * glow * 0.3 * step(R0, r);
+  fragColor = vec4(stageFinish(col, vUv), 1.0);
+}

package/skills/agentvfx/templates/spectrum/_src/bass-circle/pass0.src.frag

@@ -0,0 +1,2 @@
+// bass-circle pass 0: bass-band pro-motion bars plus a shift register of past bar rows (one delayed copy per layer).
+//@include bars-pass.glsl

package/skills/agentvfx/templates/spectrum/_src/build.mjs

@@ -0,0 +1,68 @@
+// Spectrum family build: templates share one GLSL "pro motion" stage and one "label stage" (camera,
+// background, particle field, finish), and GLSL has no #include, so the sources live in _src/ and
+// this script writes the standalone template folders. Run: node templates/spectrum/_src/build.mjs
+// (the folder name starts with "_", so the template loader never treats _src as a template).
+import { mkdirSync, readFileSync, readdirSync, writeFileSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const SRC = path.dirname(fileURLToPath(import.meta.url));
+const OUT = path.resolve(SRC, "..");
+const f = (NAME, MIN, MAX, DEFAULT) => ({ NAME, TYPE: "float", MIN, MAX, DEFAULT });
+
+/** Pro motion stage: bin mapping, peak-preserving smoothing, per-bar exponent, head margin, attack / release, caps. */
+const PRO = [
+  f("startFreq", 10, 2000, 40), f("endFreq", 100, 20000, 14000), f("freqCurve", 1, 4, 2.2),
+  f("floorLevel", 0, 0.6, 0.2), f("ceilLevel", 0.2, 1, 0.62), f("expLow", 0.5, 8, 2.1), f("expHigh", 0.5, 8, 1.3),
+  f("monsterSmooth", 1.05, 3, 1.55), f("headBars", 0, 0.4, 0.12), f("headMin", 0, 1, 0.7), f("tilt", 0, 0.1, 0.02),
+  f("attackMs", 1, 300, 14), f("releaseMs", 20, 1500, 150), f("bassHold", 0, 3, 0.8),
+  f("capGravity", 0.1, 8, 2.2), f("capHoldMs", 0, 600, 90),
+];
+/** Stage: kick zoom, shake, background mode, flecks, vignette, grain, intro, hit thresholds. */
+const STAGE = [
+  f("kickZoom", 0, 0.15, 0), f("kickDecayMs", 30, 600, 120), f("kickBass", 0, 6, 1.6), f("shake", 0, 24, 0),
+  { NAME: "bgMode", TYPE: "long", MIN: 0, MAX: 2, VALUES: [0, 1, 2], LABELS: ["flat", "blurred-footage", "halftone-footage"], DEFAULT: 2 },
+  f("bgDim", 0, 1, 0.16), f("halftoneSize", 3, 24, 7), f("fieldAmount", 0, 1, 0), f("fieldSpeed", 0, 4, 1),
+  f("vignette", 0, 1, 0), f("grain", 0, 0.12, 0.02), f("introMs", 0, 2000, 500), f("hitFlux", 0, 2, 0.9),
+];
+/** HUD ground / ink / accent, hairline width, optional palette accent and glow. */
+const HUD = [
+  { NAME: "groundColor", TYPE: "color", DEFAULT: [0.043, 0.043, 0.047, 1] },
+  { NAME: "inkColor", TYPE: "color", DEFAULT: [0.914, 0.914, 0.894, 1] },
+  { NAME: "accentColor", TYPE: "color", DEFAULT: [0.784, 1, 0, 1] },
+  f("lineWidth", 0.8, 4, 1.5), f("gridAmount", 0, 1, 1),
+  { NAME: "colorMode", TYPE: "long", MIN: 0, MAX: 1, VALUES: [0, 1], LABELS: ["accent", "palette-by-frequency"], DEFAULT: 0 },
+  f("paletteShift", 0, 1, 0), f("glow", 0, 3, 0), f("glowRadius", 0.002, 0.1, 0.012),
+  { NAME: "marks", TYPE: "bool", DEFAULT: true },
+];
+
+const SHARED = { pro: PRO, stage: STAGE, hud: HUD };
+/** Full-frame field looks, merged into any preset that names one with "$field". */
+const dark = [0.04, 0.04, 0.04, 1];
+const FIELDS = {
+  acid: { groundColor: [0.784, 1, 0, 1], inkColor: dark, accentColor: dark },
+  ultramarine: { groundColor: [0.078, 0.078, 1, 1], inkColor: [0.95, 0.95, 0.92, 1], accentColor: [1, 1, 1, 1] },
+  orange: { groundColor: [1, 0.235, 0, 1], inkColor: dark, accentColor: dark },
+  phosphor: { groundColor: [0.02, 0.03, 0.02, 1], inkColor: [0.224, 1, 0.078, 1], accentColor: [0.224, 1, 0.078, 1] },
+};
+const resolvePresets = (presets) => Object.fromEntries(Object.entries(presets).map(([name, { $field, ...rest }]) => [name, $field ? { ...FIELDS[$field], ...rest } : rest]));
+const include = (text) => text.replace(/^\/\/@include (\S+)\s*$/gmu, (_, name) => include(readFileSync(path.join(SRC, "shared", name), "utf8").trimEnd()));
+
+for (const id of readdirSync(SRC)) {
+  const dir = path.join(SRC, id);
+  let src;
+  try {
+    src = JSON.parse(readFileSync(path.join(dir, "fx.src.json"), "utf8"));
+  } catch {
+    continue;
+  }
+  const { use = [], defaults = {}, ...fx } = src;
+  fx.INPUTS = [...fx.INPUTS, ...use.flatMap((k) => SHARED[k])].map((input) => (input.NAME in defaults ? { ...input, DEFAULT: defaults[input.NAME] } : input));
+  fx.X_AGENTVFX.presets = resolvePresets(fx.X_AGENTVFX.presets);
+  const out = path.join(OUT, id);
+  mkdirSync(out, { recursive: true });
+  writeFileSync(path.join(out, "fx.json"), `${JSON.stringify(fx, null, 2)}\n`);
+  for (const file of readdirSync(dir).filter((n) => n.endsWith(".src.frag"))) {
+    writeFileSync(path.join(out, file.replace(".src.frag", ".frag")), include(readFileSync(path.join(dir, file), "utf8")));
+  }
+}

package/skills/agentvfx/templates/spectrum/_src/label-bars/fx.src.json

@@ -0,0 +1,54 @@
+{
+  "DESCRIPTION": "Deck layout: outlined tab-box labels, icon row and starburst on the left, a framed panel of 63 hairline bars on a ruler baseline, tall title, halftone footage backdrop",
+  "CREDIT": "agentvfx",
+  "ISFVSN": "2",
+  "CATEGORIES": ["spectrum", "audio", "hud"],
+  "INPUTS": [
+    { "NAME": "bandCount", "TYPE": "long", "MIN": 16, "MAX": 96, "DEFAULT": 63 },
+    { "NAME": "maxHeight", "TYPE": "float", "MIN": 0.1, "MAX": 1, "DEFAULT": 1 },
+    { "NAME": "thickness", "TYPE": "float", "MIN": 0.05, "MAX": 1, "DEFAULT": 0.34 },
+    { "NAME": "floorHeight", "TYPE": "float", "MIN": 0, "MAX": 10, "DEFAULT": 2 }
+  ],
+  "use": ["pro", "stage", "hud"],
+  "defaults": { "freqCurve": 2.5, "expLow": 2.4, "expHigh": 1.4, "monsterSmooth": 1.5, "releaseMs": 170, "bgDim": 0.2, "halftoneSize": 8 },
+  "PASSES": [
+    { "TARGET": "barState", "PERSISTENT": true, "FLOAT": true },
+    {}
+  ],
+  "X_AGENTVFX": {
+    "id": "label-bars",
+    "family": "spectrum",
+    "input": "either",
+    "spdx": "LicenseRef-agentvfx",
+    "flash": "none",
+    "fps": 30,
+    "palette": true,
+    "presets": {
+      "deck-black": {},
+      "deck-ultramarine": { "$field": "ultramarine", "thickness": 0.45 },
+      "deck-acid": { "$field": "acid" },
+      "deck-orange": { "$field": "orange", "bandCount": 48 },
+      "rainbow-glow": { "colorMode": 1, "glow": 1.2, "lineWidth": 2.4 }
+    },
+    "audioBind": { "thickness": "bass" },
+    "safeSubstitute": { "params": { "kickZoom": 0, "shake": 0 } },
+    "text": [
+      { "key": "artist", "default": "AGENT//VFX", "x": 0.03, "y": 0.07, "size": 0.062, "font": "display", "style": "outline", "box": "tab" },
+      { "key": "track", "default": "SIGNAL 04", "x": 0.03, "y": 0.21, "size": 0.062, "font": "display", "style": "outline", "box": "tab" },
+      { "key": "title", "default": "NODE 7G-75", "x": 0.97, "y": 0.04, "size": 0.085, "font": "tall", "align": "right" },
+      { "key": "n0", "default": "0", "x": 0.269, "y": 0.83, "size": 0.015, "font": "mono", "align": "center" },
+      { "key": "n1", "default": "8", "x": 0.354, "y": 0.83, "size": 0.015, "font": "mono", "align": "center" },
+      { "key": "n2", "default": "16", "x": 0.44, "y": 0.83, "size": 0.015, "font": "mono", "align": "center" },
+      { "key": "n3", "default": "24", "x": 0.525, "y": 0.83, "size": 0.015, "font": "mono", "align": "center" },
+      { "key": "n4", "default": "32", "x": 0.61, "y": 0.83, "size": 0.015, "font": "mono", "align": "center" },
+      { "key": "n5", "default": "40", "x": 0.695, "y": 0.83, "size": 0.015, "font": "mono", "align": "center" },
+      { "key": "n6", "default": "48", "x": 0.781, "y": 0.83, "size": 0.015, "font": "mono", "align": "center" },
+      { "key": "n7", "default": "56", "x": 0.866, "y": 0.83, "size": 0.015, "font": "mono", "align": "center" },
+      { "key": "log", "default": "KX  7G2  R4  D9  41A  TQP  118\nBARS 63  20-12000HZ  CACHE OK", "x": 0.03, "y": 0.9, "size": 0.015, "font": "mono", "reveal": "type", "revealStart": 0.3, "revealDur": 1.6 }
+    ],
+    "credits": [
+      "Index-card outlined labels, level meter and framed instrument panels: original drawing, no marks, fonts or text from other works",
+      "Power-curve bin mapping (exponent 2.5), peak-preserving neighbour smoothing, per-bar exponent ramp and head margin as described for the open caseif/vis.js recreation (MIT; algorithm described, no code used)"
+    ]
+  }
+}

package/skills/agentvfx/templates/spectrum/_src/label-bars/main.src.frag

@@ -0,0 +1,102 @@
+// label-bars main: the deck layout. A left column of outlined tab-box labels (artist, track, from the text
+// layer; font display, style outline, box tab) over a four-cell level meter and a small
+// starburst; a framed main panel holding 63 thin bars on a ruler baseline (major tick every 8 bars with
+// numerals) with tip dots; a tall title top-right. The media window of the deck is the stage background:
+// footage as one-tone halftone dots (bgMode 2) when there is an input. A strong onset thickens the bars
+// and the emblem starburst for ~3 frames; a kick zooms the panel (both optional). All ink is hairline; a
+// field colour (groundColor / inkColor presets) turns the whole deck acid, ultramarine or orange.
+//@include stage.glsl
+//@include hud.glsl
+
+vec4 barAt(int i) { return texelFetch(barState, ivec2(clamp(i, 0, bandCount - 1), 0), 0); }
+
+float starburst(vec2 p, float R, float spokes, float wpx) {
+  float r = length(p);
+  float a = atan(p.y, p.x);
+  float k = abs(fract(a / 6.2831853 * spokes) - 0.5) * 6.2831853 / spokes * r;
+  return cov(k - wpx * 0.5) * step(R * 0.18, r) * step(r, R) + cov(r - R * 0.1);
+}
+
+void main() {
+  vec2 res = RENDERSIZE;
+  float U = hudU();
+  vec4 clk = texelFetch(barState, ivec2(0, 1), 0);
+  vec2 sp = vUv * res;
+  vec2 px = stageUv(clk, vUv) * res;
+  vec2 lo = vec2(0.24 * res.x, 0.12 * res.y);
+  vec2 hi = vec2(0.97 * res.x, 0.78 * res.y);
+  float W = hi.x - lo.x;
+  float H = hi.y - lo.y;
+  float n = float(bandCount);
+  float span = introSpan();
+  float pitch = W * 0.92 / n;
+  float x0 = lo.x + W * 0.04;
+  float baseY = lo.y + 0.12 * H;
+  float extent = 0.8 * H * maxHeight * introK();
+  float hitOn = step(0.5, hitEnv(clk, 0.1)) * step(0.5, clk.x);
+
+  float fi = floor((px.x - x0) / pitch);
+  int i = int(clamp(fi, 0.0, n - 1.0));
+  float bc = x0 + (fi + 0.5) * pitch;
+  bool inSpan = fi >= 0.0 && fi < n && abs(px.x / res.x - 0.5) * 2.0 < span * 0.95 + 0.001;
+  vec4 bar = barAt(i);
+  float hw = max(hudW() * 0.5, pitch * thickness * 0.5 * (1.0 + 0.5 * hitOn));
+  float hP = bar.r * extent + floorHeight * U;
+  float dy = px.y - baseY;
+  float body = inSpan ? cov(abs(px.x - bc) - hw) * step(-0.5, dy) * cov(dy - hP) : 0.0;
+  float tip = inSpan ? cov(length(vec2(px.x - bc, dy - hP - 4.0 * U)) - 1.5 * U) * step(0.012, bar.r) : 0.0;
+  float cap = inSpan && bar.g * extent > hP + 8.0 * U ? cov(abs(dy - bar.g * extent - 6.0 * U) - 0.7 * U) * cov(abs(px.x - bc) - hw * 1.5) : 0.0;
+
+  float baseLine = hair(dy) * step(x0, px.x) * step(px.x, x0 + pitch * n) * span;
+  float tickX = abs(fract((px.x - x0) / pitch + 0.5) - 0.5) * pitch;
+  float td = baseY - px.y;
+  float major = mod(fi, 8.0) < 0.5 ? 1.0 : 0.0;
+  float tick = inSpan && td > 3.0 * U && td < (3.0 + (major > 0.5 ? 14.0 : 6.0)) * U && tickX < hudW() * 0.5 ? 1.0 : 0.0;
+  float gridH = 0.0;
+  for (int r = 1; r <= 4; r++) {
+    gridH = max(gridH, hair(px.y - (baseY + float(r) * extent / 4.0)));
+  }
+  gridH *= dashes(px.x, 8.0, 0.25) * inRect(px, vec2(x0, lo.y), vec2(x0 + pitch * n, hi.y)) * 0.45 * gridAmount;
+
+  float frame = boxLine(sp, lo, hi) * gridAmount;
+  float brk = brackets(sp, lo - 10.0 * U, hi + 10.0 * U, 24.0 * U) * gridAmount;
+
+  // left column furniture: a four-cell level meter (low, low-mid, high-mid, high bands) and a framed sub-panel
+  float icons = 0.0;
+  for (int k = 0; k < 4; k++) {
+    vec2 lo2 = vec2((0.03 + 0.04 * float(k)) * res.x, 0.62 * res.y);
+    vec2 hi2 = lo2 + vec2(0.032 * res.x, 0.04 * res.y);
+    float lvl = clamp(barAt(4 + k * 14).r, 0.0, 1.0);
+    float fillTop = hi2.y - lvl * (hi2.y - lo2.y);
+    icons = max(icons, max(boxLine(sp, lo2, hi2), inRect(sp, vec2(lo2.x + 3.0 * U, fillTop), hi2 - 3.0 * U)));
+  }
+  vec2 slo = vec2(0.03 * res.x, 0.4 * res.y);
+  vec2 shi = vec2(0.19 * res.x, 0.58 * res.y);
+  float sub = boxLine(sp, slo, shi) * gridAmount;
+  float subTicks = 0.0;
+  for (int r = 0; r < 12; r++) {
+    float yr = slo.y + (float(r) + 0.5) * (shi.y - slo.y) / 12.0;
+    float ln = (2.0 + 6.0 * hash12(vec2(float(r), 3.0))) * 0.012 * res.x * (0.4 + 0.6 * barAt(r * 5).r);
+    subTicks = max(subTicks, hair(sp.y - yr) * step(slo.x + 6.0 * U, sp.x) * step(sp.x, slo.x + 6.0 * U + ln));
+  }
+  vec2 eblo = vec2(0.03 * res.x, 0.12 * res.y);
+  vec2 ebhi = vec2(0.19 * res.x, 0.12 * res.y + 0.16 * res.x);
+  float emblem = max(boxLine(sp, eblo, ebhi) * gridAmount, starburst(sp - (eblo + ebhi) * 0.5, 0.07 * res.x, 32.0, hudW() * (1.0 + hitOn)));
+  float plus = 0.0;
+  for (int c = 0; c < 4; c++) {
+    vec2 centre = vec2((c & 1) == 0 ? 0.015 * res.x : 0.985 * res.x, (c & 2) == 0 ? 0.04 * res.y : 0.96 * res.y);
+    plus = max(plus, plusAt(sp, centre, 7.0 * U));
+  }
+
+  float mk = max(max(body, tip), max(cap, max(baseLine * 0.9, tick * 0.9)));
+  mk = max(mk, max(gridH, max(frame, brk)));
+  mk = max(mk, max(icons * gridAmount, max(sub, subTicks * 0.8)));
+  mk = max(mk, max(emblem, plus * float(marks)));
+  vec3 ink = inkColor.rgb;
+  vec3 gnd = stageBackground(vUv, ink, kickEnv(clk));
+  vec3 acc = accentAt((fi + 0.5) / n);
+  vec3 col = mix(gnd, ink, mk);
+  col = mix(col, acc, min(tip + cap, 1.0));
+  col = mix(col, ink, textInk());
+  fragColor = vec4(stageFinish(col, vUv), 1.0);
+}

package/skills/agentvfx/templates/spectrum/_src/label-bars/pass0.src.frag

@@ -0,0 +1,2 @@
+// label-bars pass 0: pro-motion bar state (63 bars by default), persistent in barState.
+//@include bars-pass.glsl

package/skills/agentvfx/templates/spectrum/_src/shared/bars-fn.glsl

@@ -0,0 +1,64 @@
+// ---- pro motion stage: spectrum -> bar values (shared by the spectrum family) ----
+// Bin mapping: bar i covers startFreq + (endFreq - startFreq) * (i / n)^freqCurve, a power curve that
+// gives the lows more bars (common bar visualisers use exponent 2.5). Each bar takes the
+// maximum of four taps of the 512-bin audioFFT texture (bin s is centred near 29.3 + 46.875 * s Hz).
+// The dB tilt (+tilt per octave above 200 Hz) offsets the 1/f slope of music. The value is windowed
+// by floorLevel / ceilLevel, raised to a per-bar exponent (expLow for the lows ramping to expHigh for
+// the highs, so quiet bars collapse and loud peaks pop), and the first headBars of the bars are weighted
+// down to headMin so the sub-bass edge does not dominate. Peak-preserving neighbour smoothing keeps
+// local maxima and lets each bar lift its neighbours by value / monsterSmooth^distance.
+float specAt(float hz) {
+  float s = (hz - 29.3) / 46.875;
+  return texture(audioFFT, vec2(clamp((s + 0.5) / 512.0, 0.0, 1.0), 0.5)).r;
+}
+
+float binValue(int i, int n) {
+  float t0 = float(i) / float(n);
+  float f0 = startFreq + (endFreq - startFreq) * pow(t0, freqCurve);
+  float f1 = startFreq + (endFreq - startFreq) * pow(float(i + 1) / float(n), freqCurve);
+  float v = 0.0;
+  for (int k = 0; k < 4; k++) {
+    float fq = mix(f0, f1, (float(k) + 0.5) / 4.0);
+    float a = specAt(fq);
+    v = max(v, a > 0.001 ? a + tilt * log2(max(fq, 20.0) / 200.0) : 0.0);
+  }
+  float x = clamp((v - floorLevel) / max(ceilLevel - floorLevel, 0.01), 0.0, 1.0);
+  x = pow(x, mix(expHigh, expLow, 1.0 - t0 * t0));
+  float hb = headBars * float(n);
+  return hb > 0.5 && float(i) < hb ? x * mix(headMin, 1.0, float(i) / hb) : x;
+}
+
+float smoothedBar(int i, int n) {
+  float v = binValue(i, n);
+  for (int d = 1; d <= 6; d++) {
+    float w = 1.0 / pow(monsterSmooth, float(d));
+    if (i - d >= 0) { v = max(v, binValue(i - d, n) * w); }
+    if (i + d < n) { v = max(v, binValue(i + d, n) * w); }
+  }
+  return v;
+}
+
+// state texel of bar i: r = height, g = cap, b = cap fall speed, a = cap hold timer
+vec4 barStep(vec4 prev, int i, int n) {
+  float t0 = float(i) / float(n);
+  float raw = smoothedBar(i, n);
+  float rel = releaseMs * (1.0 + bassHold * (1.0 - t0));
+  float k = 1.0 - exp(-TIMEDELTA / max((raw > prev.r ? attackMs : rel) * 0.001, 0.0005));
+  float h = prev.r + (raw - prev.r) * k;
+  float cap = prev.g;
+  float vel = prev.b;
+  float hold = prev.a;
+  if (h >= cap) {
+    cap = h;
+    vel = 0.0;
+    hold = capHoldMs * 0.001;
+  } else if (hold > 0.0) {
+    hold -= TIMEDELTA;
+  } else {
+    vel += capGravity * TIMEDELTA;
+    cap = max(h, cap - vel * TIMEDELTA);
+  }
+  return vec4(h, cap, vel, hold);
+}
+
+//@include clock.glsl

package/skills/agentvfx/templates/spectrum/_src/shared/bars-pass.glsl

@@ -0,0 +1,22 @@
+//@include bars-fn.glsl
+
+// state pass: bars in row 0 of barState, clock in texel (0, 1), history rows 4..27 where row 3 + d
+// holds the bars as they were d frames ago (a shift register: each row copies the row below it from the
+// previous frame), so templates can draw delayed echoes.
+void main() {
+  ivec2 px = ivec2(gl_FragCoord.xy);
+  vec4 prev = texelFetch(barState, px, 0);
+  if (px.y == 0 && px.x < bandCount) {
+    fragColor = barStep(prev, px.x, bandCount);
+    return;
+  }
+  if (px.y == 1 && px.x == 0) {
+    fragColor = clockStep(prev);
+    return;
+  }
+  if (px.y >= 4 && px.y <= 27 && px.x < bandCount) {
+    fragColor = texelFetch(barState, ivec2(px.x, px.y == 4 ? 0 : px.y - 1), 0);
+    return;
+  }
+  fragColor = vec4(0.0);
+}

package/skills/agentvfx/templates/spectrum/_src/shared/clock.glsl

@@ -0,0 +1,7 @@
+// clock texel: (hit count, last hit frame, kick count, last kick frame). A hit is an onset whose spectral
+// flux reaches hitFlux; a kick is an onset whose bass ratio reaches kickBass.
+vec4 clockStep(vec4 ev) {
+  if (AUDIO_ONSET > 0.5 && AUDIO_FLUX >= hitFlux) { ev.x += 1.0; ev.y = float(FRAMEINDEX); }
+  if (AUDIO_ONSET > 0.5 && AUDIO_BASS >= kickBass) { ev.z += 1.0; ev.w = float(FRAMEINDEX); }
+  return ev;
+}