agentvfx 0.0.0-stage → 0.3.5

package/skills/agentvfx/scripts/vfx.mjs

@@ -0,0 +1,173 @@
+#!/usr/bin/env node
+// agentvfx (Apache-2.0, see LICENSE). Command-line entry: `vfx.mjs <subcommand> ...`.
+import { spawnSync } from "node:child_process";
+import { existsSync, mkdtempSync, readFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { BlockedError, ChromeSession, findChrome, chromeVersion, stageFlags } from "../engine/node/chrome.mjs";
+import { findFfmpeg, ffmpegVersion } from "../engine/node/encode.mjs";
+import { EXIT } from "../engine/core/constants.mjs";
+import { loadLibrary } from "../engine/core/templates.mjs";
+import { validateScore, validateTemplate } from "../engine/core/validate.mjs";
+import { runJob } from "../engine/node/job.mjs";
+
+const out = (obj) => process.stdout.write(`${JSON.stringify(obj, null, 2)}\n`);
+
+async function doctor() {
+  const report = { ok: false, chrome: null, chromeVersion: null, webgl2: false, renderer: null, extensions: {}, ffmpeg: null, blockers: [] };
+  const ffmpeg = findFfmpeg();
+  report.ffmpeg = ffmpeg ? ffmpegVersion(ffmpeg) : null;
+  if (!report.ffmpeg) report.blockers.push("BLOCKED_NO_FFMPEG_FOR_VIDEO: ffmpeg not found (set FFMPEG_PATH or install ffmpeg)");
+  const chrome = findChrome();
+  if (!chrome) {
+    report.blockers.push("BLOCKED_NO_CHROME: Chrome/Chromium not found (set CHROME_PATH or install Google Chrome)");
+    out(report);
+    return EXIT.BLOCKED_NO_CHROME;
+  }
+  report.chrome = chrome;
+  report.chromeVersion = chromeVersion(chrome);
+  const profileDir = mkdtempSync(path.join(tmpdir(), "agentvfx-doctor-"));
+  let session;
+  try {
+    session = await ChromeSession.launch({ chrome, flags: stageFlags({ width: 1920, height: 1080, rung: "gpu" }), profileDir, routes: () => null });
+    await session.openPage();
+    const probe = await session.evaluate(`(() => {
+      const gl = document.createElement('canvas').getContext('webgl2');
+      if (!gl) return { webgl2: false };
+      const dbg = gl.getExtension('WEBGL_debug_renderer_info');
+      const has = (n) => Boolean(gl.getExtension(n));
+      return {
+        webgl2: true,
+        renderer: dbg ? String(gl.getParameter(dbg.UNMASKED_RENDERER_WEBGL)) : 'unknown',
+        extensions: { EXT_color_buffer_float: has('EXT_color_buffer_float'), OES_texture_float_linear: has('OES_texture_float_linear') },
+        maxTextureSize: gl.getParameter(gl.MAX_TEXTURE_SIZE),
+      };
+    })()`);
+    Object.assign(report, probe);
+  } catch (error) {
+    report.blockers.push(error instanceof BlockedError ? error.message : `BLOCKED_NO_CHROME: ${error.message}`);
+    out(report);
+    return error instanceof BlockedError ? error.code : EXIT.BLOCKED_NO_CHROME;
+  } finally {
+    if (session) await session.close();
+  }
+  if (!report.webgl2) report.blockers.push("BLOCKED_NO_WEBGL2: no WebGL2 context on the GPU rung");
+  else {
+    if (!/ANGLE/u.test(report.renderer ?? "") || /swiftshader/iu.test(report.renderer ?? "")) report.blockers.push(`BLOCKED_NO_WEBGL2: renderer is not a GPU ANGLE backend (${report.renderer})`);
+    for (const [name, ok] of Object.entries(report.extensions)) if (!ok) report.blockers.push(`BLOCKED_NO_WEBGL2: ${name} missing`);
+  }
+  report.ok = report.blockers.length === 0;
+  out(report);
+  if (report.ok) return EXIT.OK;
+  return report.ffmpeg ? EXIT.BLOCKED_NO_WEBGL2 : EXIT.BLOCKED_NO_FFMPEG_FOR_VIDEO;
+}
+
+function list(args) {
+  const lib = loadLibrary({ includeTest: args.includes("--include-test") });
+  const rows = [...lib.values()].map((t) => ({
+    id: t.id, family: t.fx.X_AGENTVFX.family, input: t.fx.X_AGENTVFX.input, flash: t.fx.X_AGENTVFX.flash,
+    presets: Object.keys(t.fx.X_AGENTVFX.presets), description: t.fx.DESCRIPTION,
+  }));
+  if (args.includes("--json")) out(rows);
+  else for (const r of rows) process.stdout.write(`${r.family.padEnd(14)} ${r.id.padEnd(22)} ${r.input.padEnd(10)} ${r.presets.join(", ")}\n`);
+  return EXIT.OK;
+}
+
+function readScore(file) {
+  if (!file || !existsSync(file)) throw new BlockedError(EXIT.USAGE, `score file not found: ${file}`);
+  try {
+    return JSON.parse(readFileSync(file, "utf8"));
+  } catch (error) {
+    throw new BlockedError(EXIT.SCORE_INVALID, `SCORE_INVALID: ${file} is not valid JSON (${error.message})`);
+  }
+}
+
+function validate([file]) {
+  const lib = loadLibrary({ includeTest: true });
+  for (const [id, t] of lib) {
+    const r = validateTemplate(t.fx, id);
+    if (!r.ok) {
+      out({ ok: false, template: id, errors: r.errors });
+      return EXIT.SCORE_INVALID;
+    }
+  }
+  const r = validateScore(readScore(file), lib);
+  out(r.ok ? { ok: true, score: r.value } : { ok: false, errors: r.errors });
+  return r.ok ? EXIT.OK : EXIT.SCORE_INVALID;
+}
+
+function flag(args, name, fallback = null) {
+  const i = args.indexOf(name);
+  return i >= 0 && i + 1 < args.length ? args[i + 1] : fallback;
+}
+
+async function render(args) {
+  const file = args[0];
+  const outDir = flag(args, "--out");
+  if (!file || !outDir) {
+    process.stderr.write("usage: vfx.mjs render <score.json> --out <dir> [--width W --height H] [--no-replay]\n");
+    return EXIT.USAGE;
+  }
+  const lib = loadLibrary({ includeTest: true });
+  const v = validateScore(readScore(file), lib);
+  if (!v.ok) {
+    out({ ok: false, errors: v.errors });
+    return EXIT.SCORE_INVALID;
+  }
+  const width = flag(args, "--width") ? Number(flag(args, "--width")) : undefined;
+  const height = flag(args, "--height") ? Number(flag(args, "--height")) : undefined;
+  const gate = await runJob(v.value, lib, { outDir: path.resolve(outDir), width, height, replay: !args.includes("--no-replay") });
+  out({
+    ok: gate.ok, film: gate.withheld ?? gate.render.film, frames: gate.render.frames, size: `${gate.render.width}x${gate.render.height}`, renderMs: gate.render.renderMs,
+    determinism: gate.determinism.pass ?? "not checked",
+    flash: { exceeds: gate.flash.exceeds, flashesPerSecondMax: gate.flash.flashesPerSecondMax, redFlashes: gate.flash.redFlashes },
+    safetyNotice: gate.safetyNotice?.file ?? null, safeVariant: gate.safeVariant ? { film: gate.safeVariant.withheld ?? gate.safeVariant.film, exceeds: gate.safeVariant.flash.exceeds } : null,
+    stills: { sheet: gate.stills.sheet, strips: gate.stills.strips.map((s) => s.file), poster: gate.stills.poster },
+    credit: gate.credit.text,
+    next: "open stills/sheet.png and every strip with Read before reporting; give the user the credit line from CREDIT.txt",
+  });
+  if (gate.determinism.pass === false) return EXIT.STAGE_NONDETERMINISTIC;
+  return gate.ok ? EXIT.OK : EXIT.GATE_FAIL_QA;
+}
+
+async function analyze(args) {
+  const file = args[0];
+  if (!file) {
+    process.stderr.write("usage: vfx.mjs analyze <audio> [--fps 30] [--out features.json]\n");
+    return EXIT.USAGE;
+  }
+  if (!existsSync(file)) throw new BlockedError(EXIT.BLOCKED_ASSET_MISSING, `BLOCKED_ASSET_MISSING: audio not found: ${file}`);
+  const { analyzeAudio, writeFeatures, summarize } = await import("../engine/node/audio.mjs");
+  const features = await analyzeAudio(file, { fps: Number(flag(args, "--fps", "30")) });
+  const outFile = flag(args, "--out", path.join(path.dirname(file), "features.json"));
+  await writeFeatures(features, outFile);
+  out({ ...summarize(features), features: outFile });
+  return EXIT.OK;
+}
+
+function exportWeb(args) {
+  const script = new URL("./export-web.mjs", import.meta.url).pathname;
+  const r = spawnSync(process.execPath, [script, ...args], { stdio: "inherit" });
+  return r.status ?? 1;
+}
+
+const COMMANDS = { doctor, list, validate, render, analyze, "export-web": exportWeb };
+
+async function main(argv) {
+  const [cmd, ...rest] = argv;
+  const fn = COMMANDS[cmd];
+  if (!fn) {
+    process.stderr.write(`usage: vfx.mjs <${Object.keys(COMMANDS).join("|")}> ...\n`);
+    return EXIT.USAGE;
+  }
+  return fn(rest);
+}
+
+main(process.argv.slice(2)).then((code) => process.exit(code ?? 0), (error) => {
+  if (error instanceof BlockedError) {
+    process.stderr.write(`${error.message}\n`);
+    process.exit(error.code);
+  }
+  process.stderr.write(`${error.stack ?? error}\n`);
+  process.exit(1);
+});

package/skills/agentvfx/templates/_test/feedback-counter/fx.json

@@ -0,0 +1,11 @@
+{
+  "DESCRIPTION": "Test template: a persistent buffer that adds inc per frame; output shows the count in sRGB code values.",
+  "ISFVSN": "2",
+  "CATEGORIES": ["test"],
+  "INPUTS": [{ "NAME": "inc", "TYPE": "float", "MIN": 0, "MAX": 1, "DEFAULT": 0.00392156862745098 }],
+  "PASSES": [{ "TARGET": "acc", "PERSISTENT": true, "FLOAT": true }, {}],
+  "X_AGENTVFX": {
+    "id": "test-feedback-counter", "family": "_test", "input": "generative", "spdx": "Apache-2.0", "flash": "none",
+    "presets": { "one": { "inc": 0.00392156862745098 }, "two": { "inc": 0.00784313725490196 }, "zero": { "inc": 0 } }
+  }
+}

package/skills/agentvfx/templates/_test/feedback-counter/main.frag

@@ -0,0 +1,4 @@
+void main() {
+  float v = texture(acc, vUv).r;
+  fragColor = vec4(srgbToLinear(vec3(v)), 1.0);
+}

package/skills/agentvfx/templates/_test/feedback-counter/pass0.frag

@@ -0,0 +1,4 @@
+void main() {
+  float prev = texture(acc, vUv).r;
+  fragColor = vec4(prev + inc, 0.0, 0.0, 1.0);
+}

package/skills/agentvfx/templates/_test/gradient/fx.json

@@ -0,0 +1,23 @@
+{
+  "DESCRIPTION": "Test template: a moving linear-light gradient. Not listed in the gallery.",
+  "CREDIT": "agentvfx",
+  "ISFVSN": "2",
+  "CATEGORIES": ["test"],
+  "INPUTS": [
+    { "NAME": "speed", "TYPE": "float", "MIN": 0, "MAX": 4, "DEFAULT": 1 },
+    { "NAME": "tint", "TYPE": "color", "DEFAULT": [1, 0.2, 0.6, 1] }
+  ],
+  "X_AGENTVFX": {
+    "id": "test-gradient",
+    "family": "_test",
+    "input": "generative",
+    "spdx": "Apache-2.0",
+    "flash": "none",
+    "presets": {
+      "slow": { "speed": 0.25 },
+      "default": { "speed": 1 },
+      "fast": { "speed": 3, "tint": [0.2, 1, 0.4, 1] }
+    },
+    "credits": []
+  }
+}

package/skills/agentvfx/templates/_test/gradient/main.frag

@@ -0,0 +1,5 @@
+void main() {
+  vec2 uv = isf_FragNormCoord;
+  float x = fract(uv.x + TIME * speed * 0.25);
+  fragColor = vec4(mix(vec3(0.02), tint.rgb, x) * (0.4 + 0.6 * uv.y), 1.0);
+}

package/skills/agentvfx/templates/_test/identity/fx.json

@@ -0,0 +1,10 @@
+{
+  "DESCRIPTION": "Test template: passes inputImage through unchanged (black without input).",
+  "ISFVSN": "2",
+  "CATEGORIES": ["test"],
+  "INPUTS": [{ "NAME": "gain", "TYPE": "float", "MIN": 0, "MAX": 2, "DEFAULT": 1 }],
+  "X_AGENTVFX": {
+    "id": "test-identity", "family": "_test", "input": "either", "spdx": "Apache-2.0", "flash": "none",
+    "presets": { "unity": { "gain": 1 }, "half": { "gain": 0.5 }, "double": { "gain": 2 } }
+  }
+}

package/skills/agentvfx/templates/_test/identity/main.frag

@@ -0,0 +1,4 @@
+void main() {
+  vec4 c = HAS_INPUT ? texture(inputImage, vUv) : vec4(0.0, 0.0, 0.0, 1.0);
+  fragColor = vec4(c.rgb * gain, 1.0);
+}

package/skills/agentvfx/templates/_test/strobe/fx.json

@@ -0,0 +1,14 @@
+{
+  "DESCRIPTION": "Test template: full-frame strobe, on for the first half of each period (rate 0 = always on).",
+  "ISFVSN": "2",
+  "CATEGORIES": ["test"],
+  "INPUTS": [
+    { "NAME": "rate", "TYPE": "float", "MIN": 0, "MAX": 30, "DEFAULT": 12 },
+    { "NAME": "red", "TYPE": "bool", "DEFAULT": false }
+  ],
+  "X_AGENTVFX": {
+    "id": "test-strobe", "family": "_test", "input": "generative", "spdx": "Apache-2.0", "flash": "strobe",
+    "presets": { "hold": { "rate": 0 }, "slow": { "rate": 2 }, "fast": { "rate": 12 } },
+    "safeSubstitute": { "template": "test-identity", "params": { "rate": 1 } }
+  }
+}

package/skills/agentvfx/templates/_test/strobe/main.frag

@@ -0,0 +1,6 @@
+void main() {
+  float phase = fract(TIME * rate + 1e-4);
+  bool on = rate <= 0.0 || phase < 0.5;
+  vec3 c = red ? vec3(1.0, 0.0, 0.0) : vec3(1.0);
+  fragColor = vec4(on ? c : vec3(0.0), 1.0);
+}

package/skills/agentvfx/templates/_test/text-probe/fx.json

@@ -0,0 +1,15 @@
+{
+  "DESCRIPTION": "Test template: shows the engine text mask (R ink white, G box fill grey).",
+  "ISFVSN": "2",
+  "CATEGORIES": ["test"],
+  "INPUTS": [{ "NAME": "gain", "TYPE": "float", "MIN": 0, "MAX": 1, "DEFAULT": 1 }],
+  "X_AGENTVFX": {
+    "id": "test-text-probe", "family": "_test", "input": "generative", "spdx": "Apache-2.0", "flash": "none",
+    "presets": { "a": { "gain": 1 }, "b": { "gain": 0.5 }, "c": { "gain": 0.8 } },
+    "text": [
+      { "key": "title", "default": "TRACK TITLE", "x": 0.06, "y": 0.1, "size": 0.16, "font": "display", "style": "outline", "box": "tab" },
+      { "key": "code", "default": "SIGNAL 0x7G75 ACCEPTED", "x": 0.06, "y": 0.6, "size": 0.07, "font": "mono", "reveal": "decode", "revealStart": 0.2, "revealDur": 1.6 },
+      { "key": "bar", "default": "HEADLINE", "x": 0.94, "y": 0.78, "size": 0.1, "font": "grotesk", "align": "right", "box": "bar" }
+    ]
+  }
+}

package/skills/agentvfx/templates/_test/text-probe/main.frag

@@ -0,0 +1,6 @@
+void main() {
+  vec4 m = HAS_TEXT ? texture(TEXTMASK, vUv) : vec4(0.0);
+  vec3 c = mix(vec3(0.0), vec3(0.25), m.g);
+  c = mix(c, vec3(1.0), m.r);
+  fragColor = vec4(c * gain, 1.0);
+}

package/skills/agentvfx/templates/brutal/NOTES.md

@@ -0,0 +1,14 @@
+# brutal family (neo-brutalist HUD, halftone, boot log)
+
+Templates here are generated: edit `_src/` and run `node templates/brutal/_src/build.mjs`.
+
+- `_src/shared/lib.glsl`: design-unit helpers (1920x1080 layout units, `U` pixels per unit), SDFs, 3x5 digit font, cover-fit media sampling.
+- `_src/shared/screen.glsl`: dot screen, 8x8 Bayer ordered dither, ASCII-cell glyph screen (needs `float lumAt(vec2 p)` from the including shader).
+- `_src/shared/icons.glsl`: procedural outline glyph icons.
+- `_src/<id>/def.mjs`: fx.json (inputs, presets, text items) and demo scores; `_src/<id>/*.src.frag` the passes.
+
+Layout is authored for 16:9. Render with `--width 1920 --height 1080` (footage templates otherwise keep the clip aspect).
+
+- `hud-deck`: media window (rect / rounded / octagon); `deckLayout` 0 = wide window over a bottom desk (labels, waveform, hatched spectrum) with a right rail (contour map, particle box, 16-step beat sequencer, micro code); `deckLayout` 1 = off-centre octagon window with a dial gauge, segment meter, readout column, pad matrix, bar meters, scan ruler, timeline and barcode strip. Text items are gated by layout in the shader (the text layer has no per-preset visibility).
+- `halftone-field`: `screenMode` 0 dots, 1 ordered dither, 2 ASCII cells; `invert` for dark dots on a light field.
+- `boot-log`: generative; `logDone` sets when the log finishes typing and the progress bar fills.

package/skills/agentvfx/templates/brutal/_src/boot-log/def.mjs

@@ -0,0 +1,57 @@
+import { c, f, hex } from "../shared/defs.mjs";
+
+const mono = (key, def, x, y, size, extra = {}) => ({ key, default: def, x, y, size, font: "mono", ...extra });
+
+const INPUTS = [
+  c("fieldColor", hex("#020503")), c("inkColor", hex("#39ff14")), c("hotColor", hex("#d9ffd2")),
+  f("logDone", 1, 3.5, 2.4), f("dustAmount", 0, 1, 0.8), f("streakAmount", 0, 1, 1), f("tearAmount", 0, 1, 0.6),
+  f("scanAmount", 0, 1, 0.35), f("flickerAmount", 0, 0.5, 0.12), f("vignette", 0, 1, 0.45), f("bloomAmount", 0, 2, 0.9),
+  f("letterbox", 0, 120, 46), f("introMs", 0, 3000, 500),
+];
+
+const LOG = [
+  "AGENT//VFX BOOT 0x7G75", "MOUNT /ARCHIVE/COLD-04 ........ OK", "CACHE 4096K PAGES ......... ALIGNED", "RELAY NODE 7G-75 .......... LINKED",
+  "CHECKSUM 91C2 E81B ........ PASS", "LOAD SECTOR 0417 .......... 73%", "DECODE FRAME TABLE ........ OK", "SCAN 0x00F0..0x0FFF ...... CLEAN",
+  "SIGNAL BUS 04 ............. UP", "PHASE LOCK 48.000K ........ HELD", "SEED 0x4A7C ............... SET", "HANDSHAKE ACCEPTED ........ OK", "RUN //",
+].join("\n");
+
+const TEXT = [
+  mono("tagA", "AGENT//VFX // COLD ARCHIVE\nNODE 7G-75   BUILD 0417\nSECTOR 04 / SIGNAL OK", 0.111, 0.066, 0.0135, { lineHeight: 1.45 }),
+  mono("tagB", "BOOT 0x7G75\nREV 04.17.31", 0.9, 0.066, 0.0135, { align: "right", lineHeight: 1.45 }),
+  mono("log", LOG, 0.033, 0.245, 0.0245, { lineHeight: 1.18, reveal: "type", revealStart: 0.2, revealDur: 2.2 }),
+  mono("status", "BOOT SEQUENCE", 0.033, 0.848, 0.0135),
+  { key: "headline", default: "NODE 7G ONLINE", x: 0.033, y: 0.69, size: 0.11, font: "display", style: "fill", reveal: "decode", revealStart: 2.5, revealDur: 0.9 },
+];
+
+const PHOSPHOR = {};
+const ACID = { fieldColor: hex("#c8ff00"), inkColor: hex("#0b0b0c"), hotColor: hex("#0b0b0c"), bloomAmount: 0.35, scanAmount: 0.25, dustAmount: 1, vignette: 0.3 };
+const ULTRA = { fieldColor: hex("#1414ff"), inkColor: hex("#dcd3ff"), hotColor: hex("#ffffff"), bloomAmount: 0.7, vignette: 0.35 };
+const AMBER = { fieldColor: hex("#0a0600"), inkColor: hex("#ffb000"), hotColor: hex("#fff0c8"), bloomAmount: 1.1 };
+
+const fx = {
+  DESCRIPTION: "Boot log: monospace kernel log typing over a field with a dot-matrix emblem, corner + marks, scrolling side readouts, a progress bar and a decode headline; scanlines, slight bloom, flicker and beat tears",
+  CREDIT: "agentvfx",
+  ISFVSN: "2",
+  CATEGORIES: ["brutal", "terminal", "audio"],
+  INPUTS,
+  X_AGENTVFX: {
+    id: "boot-log", family: "brutal", input: "generative", spdx: "Apache-2.0", flash: "possible", fps: 30, palette: false,
+    presets: { phosphor: PHOSPHOR, acid: ACID, ultramarine: ULTRA, amber: AMBER },
+    audioBind: { tearAmount: "beat" },
+    safeSubstitute: { params: { tearAmount: 0, flickerAmount: 0 } },
+    text: TEXT,
+    credits: [
+      "Terminal boot-log grammar (original drawing; no names, marks, fonts or footage from other works)",
+      "3x5 digit font, dot-matrix emblem generator, CRT scanline / flicker / vignette and 8-tap bloom are original",
+    ],
+  },
+};
+
+const MUSIC = "test-media/beat-132.mp3";
+const demo = (seed, labels, startSec) => ({ input: { audio: MUSIC, startSec }, durationSec: 4, seed, labels });
+const demos = {
+  phosphor: demo(61, {}, 2),
+  acid: demo(62, { headline: "DECK 04 LINKED", tagA: "AGENT//VFX // ACID FIELD\nNODE 7G-75   BUILD 0418\nSECTOR 05 / SIGNAL OK" }, 4),
+  ultramarine: demo(63, { headline: "PLATE 77 READY", tagA: "AGENT//VFX // BLUE ARCHIVE\nNODE 3B-31   BUILD 0419\nSECTOR 06 / SIGNAL OK" }, 5),
+};
+export default { fx, demos };

package/skills/agentvfx/templates/brutal/_src/boot-log/main.src.frag

@@ -0,0 +1,129 @@
+// boot-log: monospace boot log typing over a field, dot-matrix emblem, corner + marks, side readouts,
+// progress bar, then a decode headline. Scanlines, slight bloom, phosphor flicker and beat tears.
+//@include lib.glsl
+
+// dot-matrix emblem: a mirrored 13x13 cell pattern that re-rolls on beats, inside a bracket frame
+float emblem(vec2 p, vec2 o, float pitch, float rollSeed) {
+  vec2 q = (p - o) / pitch;
+  vec2 id = floor(q);
+  if (id.x < 0.0 || id.y < 0.0 || id.x > 12.0 || id.y > 12.0) return 0.0;
+  vec2 m = vec2(abs(id.x - 6.0), id.y);
+  float reach = max(abs(id.x - 6.0), abs(id.y - 6.0));
+  float body = step(0.5, hash12(m + vec2(rollSeed * 1.7, 3.0)));
+  float rim = step(0.35, hash12(m + vec2(1.0, rollSeed)));
+  float on = mix(body, rim, step(5.5, reach));
+  on = max(on, step(reach, 1.5) * step(0.4, hash12(m + 9.0)));
+  vec2 f = fract(q) - 0.5;
+  return on * fillAA((length(f) - 0.34) * pitch);
+}
+
+// side readout column: rows of 4-digit codes that scroll and re-roll
+float sideColumn(vec2 p, float x0, float y0, float seed, float cell) {
+  float rowH = 7.4 * cell;
+  float r = floor((p.y - y0) / rowH);
+  if (r < 0.0 || r > 38.0) return 0.0;
+  float scroll = floor(TIME * 6.0 + seed);
+  float v = floor(hash12(vec2(r + scroll, seed)) * 9999.0);
+  vec2 o = snapPx(vec2(x0, y0 + r * rowH));
+  float fade = step(0.18, hash12(vec2(r, seed + 4.0)));
+  return printNum(p - o, v, 4, 0, cell) * fade;
+}
+
+float bloomTaps(vec2 uv, float rad) {
+  float s = 0.0;
+  for (int i = 0; i < 12; i++) {
+    float a = float(i) * 0.5236 + rad;
+    s += texture(TEXTMASK, uv + vec2(cos(a), sin(a)) * rad * U / RENDERSIZE).r;
+  }
+  return s * 0.0833;
+}
+
+void main() {
+  initDesign();
+  float W = designWidth();
+  float pulse = beatPulse(9.0);
+  float beatOn = step(0.3, pulse);
+  vec2 uv = vUv;
+  // beat tear: row blocks slide
+  float row = floor(D.y / 16.0);
+  float f2 = float(FRAMEINDEX / 2);
+  uv.x += beatOn * tearAmount * (hash12(vec2(row, f2)) - 0.5) * 0.06 * step(0.7, hash12(vec2(row, f2 + 5.0)));
+
+  vec4 tm = HAS_TEXT ? texture(TEXTMASK, uv) : vec4(0.0);
+  float bloom = HAS_TEXT ? 0.4 * bloomTaps(uv, 3.0) + 0.35 * bloomTaps(uv, 8.0) + 0.25 * bloomTaps(uv, 16.0) : 0.0;
+  float tInk = tm.r;
+  bool headlineZone = D.y > 740.0 && D.y < 930.0;
+
+  vec3 col = fieldColor.rgb;
+  float ink = 0.0;
+  float dim = 0.0;
+
+  // pixel dust (clustered) and glowing data streaks
+  vec2 dc = floor(D / 8.0);
+  float cluster = smoothstep(0.55, 0.8, fbm(dc * 0.07 + vec2(TIME * 0.05, 0.0), 3));
+  dim = max(dim, cluster * step(0.955, hash12(dc + floor(TIME * 8.0))) * dustAmount);
+  for (int k = 0; k < 3; k++) {
+    float seedK = floor(TIME * 9.0) + float(k) * 13.0;
+    float yS = 240.0 + 640.0 * hash12(vec2(seedK, 1.0));
+    float x0 = W * hash12(vec2(seedK, 2.0));
+    float len = 120.0 + 520.0 * hash12(vec2(seedK, 3.0));
+    float on = step(0.45, hash12(vec2(seedK, 4.0))) * step(x0, D.x) * step(D.x, x0 + len);
+    float core = strokeAA(D.y - yS, 1.6) * on;
+    dim = max(dim, core * streakAmount);
+    col += inkColor.rgb * exp(-abs(D.y - yS) * 0.12) * on * streakAmount * 0.18 * (1.0 + pulse);
+  }
+
+  // emblem + brackets
+  float rv = clamp((TIME * 1000.0 - introMs * 0.2) / 140.0, 0.0, 1.0);
+  float roll = floor(TIME * 2.0) + float(FRAMEINDEX / 8) * beatOn;
+  ink = max(ink, emblem(D, vec2(64.0, 64.0), 10.0, roll) * rv);
+  vec2 ec = vec2(64.0 + 65.0, 64.0 + 65.0);
+  vec2 eq = abs(D - ec) / 74.0;
+  ink = max(ink, strokeAA(sdBox(D - ec, vec2(74.0)), 1.5) * step(0.62, min(eq.x, eq.y)) * rv);
+
+  // corner + marks
+  for (int i = 0; i < 4; i++) {
+    vec2 c = vec2(i % 2 == 0 ? 36.0 : W - 36.0, i < 2 ? 74.0 : 1006.0);
+    ink = max(ink, plusMark(D - c, 10.0));
+  }
+  // side readouts (right and a thin left tick column)
+  float cell = cellPx(2.6);
+  dim = max(dim, sideColumn(D, W - 150.0, 262.0, 3.0, cell) * rv);
+  dim = max(dim, sideColumn(D, W - 90.0, 262.0, 11.0, cell) * rv * 0.7);
+  for (int i = 0; i < 24; i++) {
+    float yT = 262.0 + float(i) * 29.6;
+    dim = max(dim, strokeAA(sdSeg(D, vec2(W - 170.0, yT), vec2(W - 170.0 + (i % 4 == 0 ? 14.0 : 7.0), yT)), 1.2));
+  }
+
+  // progress bar: dot-matrix blocks, completes with the log
+  float prog = clamp((TIME - 0.2) / max(logDone - 0.2, 0.1), 0.0, 1.0);
+  vec2 bo = vec2(64.0, 936.0);
+  vec2 bp = D - bo;
+  float blocks = step(0.0, bp.x) * step(bp.x, 640.0) * step(0.0, bp.y) * step(bp.y, 16.0);
+  float bi = floor(bp.x / 10.0);
+  float full = step(bi, prog * 64.0 - 1.0);
+  float cellIn = step(fract(bp.x / 10.0), 0.78) * step(2.0, bp.y) * step(bp.y, 14.0);
+  ink = max(ink, blocks * cellIn * full);
+  dim = max(dim, blocks * cellIn * (1.0 - full) * 0.6);
+  ink = max(ink, strokeAA(sdBox(bp - vec2(320.0, 8.0), vec2(324.0, 12.0)), 1.3));
+  ink = max(ink, printNum(D - snapPx(vec2(700.0, 936.0)), floor(prog * 100.0), 2, 0, cellPx(3.2)) * 1.0);
+
+  col = mix(col, inkColor.rgb, clamp(dim, 0.0, 1.0) * 0.55);
+  float t = tInk * clamp((TIME * 1000.0 - introMs * 0.05) / 100.0, 0.0, 1.0);
+  vec3 textCol = headlineZone ? hotColor.rgb : inkColor.rgb;
+  col = mix(col, inkColor.rgb, clamp(ink, 0.0, 1.0));
+  col = mix(col, textCol, clamp(t, 0.0, 1.0));
+  col = mix(col, inkColor.rgb, clamp(bloom * bloomAmount, 0.0, 1.0) * (1.0 - t) * 0.6);
+
+  // CRT: scanlines, flicker, vignette, curved letterbox
+  float scan = 1.0 - scanAmount * 0.5 * (1.0 + sin(gl_FragCoord.y * 3.14159));
+  float flick = 1.0 - flickerAmount * hash12(vec2(float(FRAMEINDEX), 3.0)) * (0.4 + pulse);
+  vec2 vq = vUv * 2.0 - 1.0;
+  float vig = 1.0 - vignette * dot(vq * vec2(0.7, 0.9), vq * vec2(0.7, 0.9));
+  col *= scan * flick * vig;
+  float u2 = pow(2.0 * vUv.x - 1.0, 2.0);
+  float edge = letterbox * (1.0 - 0.5 * (1.0 - u2));
+  float yd = min(D.y, 1080.0 - D.y);
+  col = mix(vec3(0.0), col, clamp((yd - edge) * U + 0.5, 0.0, 1.0));
+  fragColor = vec4(col, 1.0);
+}

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

@@ -0,0 +1,33 @@
+// Brutal family build. GLSL has no #include, so each template's shaders are assembled here from
+// _src/shared/*.glsl and its own *.src.glsl parts, and fx.json plus demo scores are written from def.mjs.
+// Run: node templates/brutal/_src/build.mjs   (the "_src" folder is never loaded as a template)
+import { mkdirSync, readFileSync, readdirSync, existsSync, 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, "..");
+
+function include(text, dir) {
+  return text.replace(/^\/\/@include (\S+)\s*$/gmu, (_, name) => {
+    const local = path.join(dir, name);
+    const file = existsSync(local) ? local : path.join(SRC, "shared", name);
+    return include(readFileSync(file, "utf8").trimEnd(), dir);
+  });
+}
+
+for (const id of readdirSync(SRC)) {
+  const dir = path.join(SRC, id);
+  const defFile = path.join(dir, "def.mjs");
+  if (!existsSync(defFile)) continue;
+  const { fx, demos } = (await import(defFile)).default;
+  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"), dir));
+  }
+  for (const [preset, score] of Object.entries(demos)) {
+    writeFileSync(path.join(out, `demo-${preset}.json`), `${JSON.stringify({ version: 1, template: id, preset, ...score, out: `${id}-${preset}` })}\n`);
+  }
+}

package/skills/agentvfx/templates/brutal/_src/halftone-field/def.mjs

@@ -0,0 +1,72 @@
+import { b, c, f, hex, l } from "../shared/defs.mjs";
+
+const mono = (key, def, x, y, extra = {}) => ({ key, default: def, x, y, size: 0.0105, font: "mono", ...extra });
+
+const INPUTS = [
+  c("fieldColor", hex("#1414ff")), c("dotColor", hex("#cbbdff")), c("inkColor", hex("#dcd3ff")), c("textColor", hex("#e8e2ff")),
+  c("barA", hex("#ff6ad5")), c("barB", hex("#00e5ff")),
+  l("screenMode", [0, 1, 2], ["dots", "ordered-dither", "ascii-cells"], 0),
+  f("cell", 4, 28, 10), f("dotAngle", 0, 1.5708, 0.7854), f("dotGain", 0.5, 1.6, 1.12), b("invert", false),
+  f("imgContrast", 0.5, 3, 1.5), f("imgBias", -0.5, 0.5, 0),
+  f("imgX", 0.2, 0.8, 0.5), f("imgY", 0.3, 0.7, 0.5), f("imgW", 0.4, 1, 0.9), f("imgH", 0.4, 1, 0.86),
+  f("frameAmount", 0, 1, 1), b("marks", true), f("barAmount", 0, 1, 1), f("barDensity", 0, 1, 0.55),
+  f("textKnock", 0, 1, 1), f("tearAmount", 0, 1, 0.3), f("kickGain", 0, 1, 0.8), f("reactivity", 0, 2, 1), f("introMs", 0, 3000, 500),
+];
+
+const TEXT = [
+  { key: "headline", default: "PLATE//77", x: 0.052, y: 0.105, size: 0.17, font: "tall", style: "fill", weight: 300, tracking: 0.03 },
+  mono("labelA", "NODE 7G-75 // PLATE 0417", 0.05, 0.022, { reveal: "type", revealStart: 0.3, revealDur: 1.2 }),
+  mono("labelB", "LV//VFX  45DEG  4.0S", 0.95, 0.022, { align: "right" }),
+  mono("labelC", "SCREEN 10PX / MONO / 1-TONE", 0.05, 0.9505),
+  mono("labelD", "FRAME 0417 / 0120", 0.95, 0.9505, { align: "right" }),
+];
+
+const ULTRA = {};
+const INK_BLUE = { fieldColor: hex("#0a0a9e"), dotColor: hex("#c4b5fd"), inkColor: hex("#c4b5fd"), textColor: hex("#d8ccff") };
+const ACID = {
+  fieldColor: hex("#c8ff00"), dotColor: hex("#0b0b0c"), inkColor: hex("#0b0b0c"), textColor: hex("#0b0b0c"), invert: true,
+  barA: hex("#ff2e7e"), barB: hex("#1414ff"), imgContrast: 1.7,
+};
+const ORANGE = {
+  fieldColor: hex("#ff3c00"), dotColor: hex("#0b0b0c"), inkColor: hex("#0b0b0c"), textColor: hex("#0b0b0c"), invert: true,
+  barA: hex("#fff4e0"), barB: hex("#1414ff"), imgContrast: 1.7,
+};
+const PHOSPHOR = {
+  fieldColor: hex("#050805"), dotColor: hex("#39ff14"), inkColor: hex("#39ff14"), textColor: hex("#7dff5c"), dotGain: 1.0,
+};
+const DITHER = { screenMode: 1, cell: 9, imgContrast: 1.7 };
+const ASCII = {
+  fieldColor: hex("#c8ff00"), dotColor: hex("#0b0b0c"), inkColor: hex("#0b0b0c"), textColor: hex("#0b0b0c"), invert: true,
+  barA: hex("#ff2e7e"), barB: hex("#1414ff"), screenMode: 2, cell: 8, imgContrast: 1.8,
+};
+
+const fx = {
+  DESCRIPTION: "Footage as a single-tone dot matrix on a full solid field: dot screen, ordered dither or ASCII cells, hairline frame, pink and cyan micro bars on the image edges and a tall thin headline",
+  CREDIT: "agentvfx",
+  ISFVSN: "2",
+  CATEGORIES: ["brutal", "halftone", "audio"],
+  INPUTS,
+  X_AGENTVFX: {
+    id: "halftone-field", family: "brutal", input: "either", spdx: "Apache-2.0", flash: "possible", fps: 30, palette: false,
+    presets: { ultramarine: ULTRA, "ink-blue": INK_BLUE, acid: ACID, orange: ORANGE, phosphor: PHOSPHOR, dither: DITHER, ascii: ASCII },
+    audioBind: { dotGain: "bass", barAmount: "bands" },
+    safeSubstitute: { params: { tearAmount: 0, kickGain: 0 } },
+    text: TEXT,
+    credits: [
+      "Single-tone halftone / dot-matrix field grammar (original drawing; no images, marks or fonts from other works)",
+      "Dot screen: rotated square lattice, dot area follows tone (classic AM halftone); ordered dither: 8x8 Bayer index matrix (Bryce Bayer, 1973); ASCII cells: original procedural glyphs",
+    ],
+  },
+};
+
+const MUSIC = "test-media/beat-132.mp3";
+const demo = (video, seed, labels, startSec) => ({ input: { video, audio: MUSIC, startSec }, durationSec: 4, seed, labels });
+const demos = {
+  ultramarine: demo("test-media/clip-01.mp4", 51, { headline: "PLATE//77" }, 3),
+  acid: demo("test-media/clip-02.mp4", 52, { headline: "SIGNAL 04", labelA: "NODE 7G-75 // KRAIT 0075" }, 5),
+  orange: demo("test-media/clip-01.mp4", 53, { headline: "HEAT//31", labelA: "NODE 5C-31 // ORANGE 0031" }, 5),
+  phosphor: demo("test-media/clip-02.mp4", 54, { headline: "ECHO/DOT", labelA: "NODE 2P-12 // PHOS 0012" }, 5),
+  dither: demo("test-media/clip-01.mp4", 55, { headline: "BAYER 8", labelC: "SCREEN 9PX / ORDERED / 1-BIT" }, 2),
+  ascii: demo("test-media/clip-02.mp4", 56, { headline: "CELL//08", labelC: "SCREEN 12PX / GLYPH / 6-LEVEL" }, 5),
+};
+export default { fx, demos };