quoxcli 0.3.1 → 0.5.0

package/vendor/dragonlab/design/stage3/sentinel-warden-eyes.js

@@ -0,0 +1,95 @@
+/**
+ * Sentinel-specific "Warden V" face rig.
+ *
+ * Resting eyes continue to use the EXACT canonical Q eyeCells().
+ * During action, dot whites turn into rounded triangular shields whose TOP
+ * EDGES descend toward the bridge. No floating shocked / raised eyebrows.
+ *
+ * Deliberately preserves qeyes' most important rule: an eye owns WHOLE
+ * terminal cells, including its dark pupil and empty eyelid cut-outs.
+ * Sentinel additions remain pure functions of time / geometry; no globals.
+ */
+import {eyeCells,EYE_WHITE} from '../../vendor/quox-dragon/qeyes.js';
+
+const BR=[[1,8],[2,16],[4,32],[64,128]];
+const clamp=(n,a=0,b=1)=>Math.max(a,Math.min(b,n));
+
+export function renderWardenEyes(geo,variant,{
+  intensity=0, leftIntensity=null,rightIntensity=null,
+  gx=0,gy=.25,open=1, mono=false
+}={}){
+  const {cols,rows,Hq}=geo;
+  const valid=Number.isFinite(Hq)&&Hq>0&&
+    Number.isSafeInteger(cols)&&Number.isSafeInteger(rows)&&cols>0&&rows>0;
+  if(!valid)throw new RangeError('Invalid Sentinel eye geometry.');
+  const severity=clamp(Number.isFinite(intensity)?intensity:0);
+  if(severity===0&&leftIntensity==null&&rightIntensity==null){
+    // The familiar resting Sentinel look is real Quox art, unchanged.
+    const original=eyeCells(geo,{open:clamp(open),gx,gy},variant);
+    return original.map(row=>row.map(cell=>cell?
+      {ch:cell.ch,rgb:mono?null:cell.rgb,bg:null}:null));
+  }
+  const W=cols*2,H=rows*4;
+  const axis=2*Math.round((geo.ox+.41*Hq)/2);
+  const sep=2*Math.ceil(variant.sep*Hq/2);
+  const R=variant.r*Hq,cy=(geo.oy??0)+variant.y*Hq;
+  const lit=new Uint8Array(W*H),foot=new Uint8Array(cols*rows);
+  let visible=0;
+  const eyes=[
+    {side:-1,cx:axis-sep,level:clamp(leftIntensity??severity)},
+    {side:1,cx:axis+sep,level:clamp(rightIntensity??severity)}
+  ];
+  for(const {side,cx,level} of eyes){
+    const rx=R*variant.ox,ry=R*variant.oy;
+    const lean=level*0.72; // angled down *toward the bridge*
+    const lo=Math.floor(cx-rx-2),hi=Math.ceil(cx+rx+2);
+    const ty=Math.max(0,Math.floor(cy-ry-2)),by=Math.min(H-1,Math.ceil(cy+ry+2));
+    const pupilRadius=Math.max(1.1,R*variant.pupil*(1-level*.24));
+    const pupilX=cx+clamp(gx,-1,1)*Math.max(0,rx-pupilRadius-1)*.48;
+    const pupilY=cy+clamp(gy,-1,1)*Math.max(0,ry-pupilRadius-1)*.48+level*ry*.18;
+    for(let y=ty;y<=by;y++)for(let x=Math.max(0,lo);x<=Math.min(W-1,hi);x++){
+      const u=(x+.5-cx)/rx;
+      if(Math.abs(u)>1)continue;
+      const v=Math.sqrt(Math.max(0,1-u*u));
+      const inner=-side*u; // LEFT inner edge is right, RIGHT inner edge is left
+      const top=cy-ry*v+lean*ry*(.18+.42*clamp((inner+1)/2));
+      const bottom=cy+ry*v*(1-level*.14);
+      const yy=y+.5;
+      const inRoundEye=yy>=top-1.2&&yy<=bottom+1.1;
+      if(inRoundEye)foot[Math.floor(y/4)*cols+Math.floor(x/2)]=1;
+      if(yy<top||yy>bottom||clamp(open)<.12)continue;
+      // Keep an upper bright ridge, even for the severest glare.
+      const ridge=yy-top<1.15;
+      const dist=Math.hypot((x+.5-pupilX), (yy-pupilY));
+      const pupil=!ridge&&dist<pupilRadius;
+      const shine=pupil&&
+        Math.abs(x+.5-(pupilX-pupilRadius*.30))<.9&&
+        Math.abs(yy-(pupilY-pupilRadius*.40))<.9&&
+        pupilRadius>2.7;
+      if(!pupil||shine){
+        lit[y*W+x]=1;visible++;
+      }
+    }
+    // Cell-level margin: no solid blue body allowed to flood an eye's edge.
+    // The body is allowed around the two eyes but never inside either one.
+    for(let r=Math.max(0,Math.floor((cy-ry-2)/4));r<=Math.min(rows-1,Math.ceil((cy+ry+2)/4));r++)
+      for(let c=Math.max(0,Math.floor((cx-rx-2)/2));c<=Math.min(cols-1,Math.ceil((cx+rx+2)/2));c++){
+        const x=c*2+1,y=r*4+2;
+        if(((x-cx)/(rx+1.0))**2+((y-cy)/(ry+1.0))**2<=1)
+          foot[r*cols+c]=1;
+      }
+  }
+  const output=[];
+  for(let row=0;row<rows;row++){
+    const cells=[];
+    for(let col=0;col<cols;col++){
+      let bits=0;
+      for(let dy=0;dy<4;dy++)for(let dx=0;dx<2;dx++)
+        if(lit[(row*4+dy)*W+col*2+dx])bits|=BR[dy][dx];
+      cells.push(bits?{ch:String.fromCodePoint(0x2800+bits),rgb:mono?null:EYE_WHITE,bg:null}:
+        foot[row*cols+col]?{ch:' ',rgb:null,bg:null}:null);
+    }
+    output.push(cells);
+  }
+  return output;
+}

package/vendor/dragonlab/design/stage3/svg-coverage.js

@@ -0,0 +1,148 @@
+/**
+ * Tiny, deterministic absolute SVG path parser and 2x2-coverage shape helper.
+ * Only M/L/H/V/C/Q/Z are accepted; unsupported commands fail closed.
+ * No DOM, browser APIs, canvas dependency, third-party SVG parser or I/O.
+ *
+ * Unlike naive point-stamping, all fills are tested at sub-dot offsets identical
+ * to Quox's 2x2 vector->Braille rasterisation in qart.js and qdragon.js.
+ */
+const TOKEN=/[MLHVCQZ]|[-+]?(?:\d*\.\d+|\d+\.?)(?:e[-+]?\d+)?/g;
+const CMD=/^[MLHVCQZ]$/;
+const PTS=[0.25,0.75];
+
+export function flattenPath(source){
+  if(typeof source!=='string'||source.length>24000)
+    throw new TypeError('A path must be a short SVG path string.');
+  const tokens=source.match(TOKEN)||[];
+  // Reject SVG commands we have not deliberately implemented, including
+  // arc and relative-path syntax. Silently skipping them corrupts the art.
+  if(source.replace(TOKEN,'').replace(/[\s,]/g,'')!=='')
+    throw new RangeError('Unsupported SVG path command or syntax.');
+  if(!tokens.length||tokens[0]!=='M')throw new RangeError('Path must start with absolute M.');
+  const polygons=[];let poly=[],point=[0,0],start=[0,0],i=0,cmd=null,loops=0;
+  const take=()=>{
+    const v=tokens[i++];
+    if(v===undefined||CMD.test(v))throw new RangeError('Invalid SVG numeric argument.');
+    const n=Number(v);if(!Number.isFinite(n))throw new RangeError('Invalid SVG numeric coordinate.');
+    return n;
+  };
+  const push=(p)=>{point=p;poly.push(p);};
+  while(i<tokens.length){
+    if(++loops>20000)throw new RangeError('SVG path command limit reached.');
+    if(CMD.test(tokens[i]))cmd=tokens[i++];
+    if(!cmd)throw new RangeError('Unexpected coordinate before command.');
+    if(cmd==='M'){
+      if(poly.length>2)polygons.push(poly);
+      poly=[];start=[take(),take()];push(start);cmd='L';continue;
+    }
+    if(cmd==='L'){push([take(),take()]);continue;}
+    if(cmd==='H'){push([take(),point[1]]);continue;}
+    if(cmd==='V'){push([point[0],take()]);continue;}
+    if(cmd==='Q'){
+      const a=point,b=[take(),take()],c=[take(),take()];
+      const n=24;
+      for(let j=1;j<=n;j++){
+        const u=j/n,v=1-u;
+        push([v*v*a[0]+2*v*u*b[0]+u*u*c[0],
+          v*v*a[1]+2*v*u*b[1]+u*u*c[1]]);
+      }
+      continue;
+    }
+    if(cmd==='C'){
+      const a=point,b=[take(),take()],c=[take(),take()],d=[take(),take()];
+      const n=36;
+      for(let j=1;j<=n;j++){
+        const u=j/n,v=1-u;
+        push([v*v*v*a[0]+3*v*v*u*b[0]+3*v*u*u*c[0]+u*u*u*d[0],
+          v*v*v*a[1]+3*v*v*u*b[1]+3*v*u*u*c[1]+u*u*u*d[1]]);
+      }
+      continue;
+    }
+    if(cmd==='Z'){
+      if(poly.length>=3)polygons.push(poly);
+      poly=[];point=start;cmd=null;continue;
+    }
+    throw new RangeError('SVG command not supported: '+cmd);
+  }
+  if(poly.length>=2)polygons.push(poly);
+  if(!polygons.length)throw new RangeError('SVG path has no drawable coordinates.');
+  return polygons;
+}
+
+export function inside(polygons,x,y){
+  let yes=false;
+  for(const poly of polygons){
+    for(let i=0,j=poly.length-1;i<poly.length;j=i++){
+      const [ax,ay]=poly[i],[bx,by]=poly[j];
+      if((ay>y)!==(by>y)&&x<(bx-ax)*(y-ay)/(by-ay)+ax)yes=!yes;
+    }
+  }
+  return yes;
+}
+
+function segmentDistSq(px,py,ax,ay,bx,by){
+  const dx=bx-ax,dy=by-ay,dd=dx*dx+dy*dy;
+  const t=dd?Math.max(0,Math.min(1,((px-ax)*dx+(py-ay)*dy)/dd)):0;
+  const a=px-(ax+dx*t),b=py-(ay+dy*t);
+  return a*a+b*b;
+}
+export function nearStroke(polygons,x,y,width){
+  const radius=width*.5,limit=radius*radius;
+  for(const poly of polygons)
+    for(let i=1;i<poly.length;i++)
+      if(segmentDistSq(x,y,...poly[i-1],...poly[i])<=limit)return true;
+  return false;
+}
+
+/**
+ * Callback receives target dot x/y only if >=2 of the same four supersamples
+ * that the production Q uses lie within the source-space predicate.
+ */
+export function sampleShape(polygons,{W,H,scale,ox,oy,stroke=0},put){
+  const points=polygons.flat();
+  const xx=points.map(p=>p[0]),yy=points.map(p=>p[1]);
+  const guard=stroke?stroke*.5+1:1;
+  const x0=Math.max(1,Math.floor(ox+(Math.min(...xx)-guard)*scale)-1);
+  const x1=Math.min(W-2,Math.ceil(ox+(Math.max(...xx)+guard)*scale)+1);
+  const y0=Math.max(1,Math.floor(oy+(Math.min(...yy)-guard)*scale)-1);
+  const y1=Math.min(H-2,Math.ceil(oy+(Math.max(...yy)+guard)*scale)+1);
+  if(stroke){
+    // Short brows and mouth outlines still use the straightforward
+    // segment-distance test, which is exact for these narrow contours.
+    for(let y=y0;y<=y1;y++)for(let x=x0;x<=x1;x++){
+      let n=0;
+      for(const sy of PTS)for(const sx of PTS)
+        if(nearStroke(polygons,(x+sx-ox)/scale,(y+sy-oy)/scale,stroke))n++;
+      if(n>=2)put(x,y);
+    }
+    return;
+  }
+  // Scanline fill: EXACTLY the same even/odd polygon rule and four sample
+  // locations, but calculate intersections once per sub-dot row instead of
+  // walking hundreds of SVG edges for every single dot. This dramatically
+  // reduces cold-frame latency while preserving the original Q 2x2 coverage.
+  const width=x1-x0+1,counts=new Uint8Array(width*(y1-y0+1));
+  const edges=[];
+  for(const poly of polygons)for(let i=0,j=poly.length-1;i<poly.length;j=i++){
+    const [ax,ay]=poly[j],[bx,by]=poly[i];
+    if(ay===by)continue;
+    edges.push([ax,ay,(bx-ax)/(by-ay),Math.min(ay,by),Math.max(ay,by)]);
+  }
+  for(let y=y0;y<=y1;y++)for(const sy of PTS){
+    const ys=(y+sy-oy)/scale;
+    const crosses=[];
+    for(const [ax,ay,slope,lo,hi] of edges)
+      if(ys>=lo&&ys<hi)crosses.push(ox+(ax+(ys-ay)*slope)*scale);
+    crosses.sort((a,b)=>a-b);
+    for(let i=0;i+1<crosses.length;i+=2){
+      const a=crosses[i],b=crosses[i+1];
+      for(const sx of PTS){
+        const start=Math.max(x0,Math.ceil(a-sx));
+        const end=Math.min(x1,Math.ceil(b-sx)-1);
+        for(let x=start;x<=end;x++)counts[(y-y0)*width+x-x0]++;
+      }
+    }
+  }
+  for(let y=y0;y<=y1;y++)for(let x=x0;x<=x1;x++)
+    if(counts[(y-y0)*width+x-x0]>=2)put(x,y);
+}

package/vendor/dragonlab/design/vulcan/v1/character.mjs

@@ -0,0 +1,34 @@
+import {renderSvgRig} from '../../../factory/svg-rig.mjs';
+export const VULCAN_CLIPS=Object.freeze([{id:'idle',title:'Banked Furnace',duration:6000},{id:'fire',title:'Fire and Brimstone',duration:6000}]);
+export const STORY_DURATION=12000;
+export function poseRig(rig,scene,ms){
+ const t=ms%6000,heat=(1-Math.cos(t/6000*Math.PI*2))/2;
+ const paths=rig.paths.map(p=>({...p,rgb:p.id.includes('lava')||p.id.includes('heat')||p.id.includes('crack')||p.id==='hot-billet'||p.id==='hammer-seam'?[255,Math.round(100+95*heat),Math.round(25+30*heat)]:p.rgb}));
+ // Fixed camera includes the complete mouth-to-forge flame envelope.
+ if(scene==='fire'){
+  const power=Math.sin(Math.PI*t/6000)**2;
+  if(power>.02){
+   const flame=(id,rgb,points)=>({id,group:'fire',rgb,stroke:0,erase:false,polygons:[points]});
+   // Authored muzzle already faces right/down toward the workpiece.
+   const tip=[468+153*power,194+113*power],cx=468+87*power,cy=194+57*power;
+   paths.push(flame('fire-outer',[255,85,20],[[458,187],[cx,cy-23*power],[tip[0]-9*power,tip[1]-34*power],tip,[tip[0]-45*power,tip[1]-12*power],[cx-13*power,cy+19*power],[458,201]]));
+   paths.push(flame('fire-heart',[255,220,92],[[458,192],[cx,cy-5*power],[tip[0]-8*power,tip[1]-6*power],[cx-5*power,cy+7*power],[458,198]]));
+   for(let i=0;i<4;i++){
+    const phase=(t/1100+i/4)%1,x=595+(i-1.5)*18+phase*12,y=304-phase*64;
+    const s=2+2*power;paths.push(flame('brimstone-'+i,[255,211,67],[[x,y-s],[x+s,y],[x,y+s],[x-s,y]]));
+   }
+  }
+ }
+ return {...rig,paths};
+}
+export function renderVulcan(rig,scene='idle',ms=0,options={}){
+ if(!VULCAN_CLIPS.some(c=>c.id===scene))return {ok:false,code:'UNKNOWN_CLIP'};
+ if(!Number.isFinite(ms)||ms<0)return {ok:false,code:'INVALID_TIME'};
+ const r=renderSvgRig(poseRig(rig,scene,options.still?3000:ms),options);
+ return {...r,scene,clip:scene,caption:scene==='fire'?'Fire and brimstone.':'The furnace waits.'};
+}
+export function renderStory(rig,ms,options={}){
+ if(!Number.isFinite(ms)||ms<0)return {ok:false,code:'INVALID_TIME'};
+ const t=options.still?9000:ms%STORY_DURATION;
+ return renderVulcan(rig,t<6000?'idle':'fire',t%6000,options);
+}

package/vendor/dragonlab/design/vulcan/v1/vulcan-master.svg

@@ -0,0 +1,57 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 800 480">
+<title>Vulcan — basalt dragon at the brimstone forge</title>
+<g id="tail">
+<path id="tail-rock" fill="#706a71" d="M 297 331 C 212 319 191 391 110 380 L 57 345 L 75 398 Q 167 450 290 398 Z"/>
+<path id="tail-lava" fill="none" stroke="#ff801f" stroke-width="9" d="M 283 365 L 228 363 L 191 399 L 120 398 L 79 375"/>
+<path id="tail-spines" fill="#c1a68c" d="M 80 362 L 53 317 L 112 376 L 121 347 L 152 382 L 176 355 L 190 381 L 214 333 L 234 356 Z"/>
+</g>
+<g id="wings">
+<path id="far-wing" fill="#504953" d="M 366 287 L 349 126 L 293 65 L 300 162 L 241 129 L 278 219 L 252 239 Z"/>
+<path id="near-wing" fill="#7e7273" d="M 302 307 L 231 186 L 146 130 L 159 213 L 112 192 L 154 265 L 123 284 L 229 316 Z"/>
+<path id="wing-lava" fill="none" stroke="#ff8b27" stroke-width="9" d="M 302 307 L 231 186 L 146 130 M 231 186 L 190 255 L 123 284 M 366 287 L 349 126 L 293 65"/>
+</g>
+<g id="body">
+<path id="body-rock" fill="#8b7d78" d="M 290 205 L 367 188 L 433 250 L 452 345 L 416 408 L 291 409 L 255 359 L 263 278 Z"/>
+<path id="shoulder-plate" fill="#b4a08a" d="M 291 214 L 332 190 L 361 222 L 346 259 L 301 266 L 276 240 Z"/>
+<path id="belly-core" fill="#ff6820" d="M 352 255 L 403 268 L 420 329 L 394 381 L 346 366 L 321 312 Z"/>
+<path id="belly-plates" fill="none" stroke="#554953" stroke-width="15" d="M 336 280 L 405 295 M 329 310 L 418 326 M 339 341 L 408 352"/>
+<path id="rock-feet" fill="#a28b7a" d="M 292 345 L 329 365 L 321 410 L 341 430 L 266 430 L 252 410 L 261 370 Z M 397 365 L 434 356 L 453 407 L 476 428 L 390 430 L 378 411 Z"/>
+<path id="claws" fill="#f3dfb0" d="M 268 413 L 255 433 L 282 430 L 290 410 L 287 431 L 309 430 L 315 414 L 321 432 L 343 429 M 398 412 L 386 433 L 409 430 L 420 411 L 419 432 L 442 431 L 447 414 L 454 432 L 479 430"/>
+<path id="body-cracks" fill="none" stroke="#ffbc37" stroke-width="7" d="M 281 269 L 298 300 L 279 327 L 297 345 M 421 271 L 435 305 L 420 329 M 282 379 L 296 397 L 286 414"/>
+</g>
+<g id="neck">
+<path id="neck-rock" fill="#99857a" d="M 338 163 L 397 162 L 430 257 L 375 280 L 327 232 Z"/>
+<path id="neck-lava" fill="none" stroke="#ff9c2f" stroke-width="10" d="M 371 187 L 362 222 L 388 246"/>
+</g>
+<g id="head">
+<path id="horn-far" fill="#d3ba91" d="M 330 131 L 311 89 L 326 33 L 341 92 L 357 115 Z"/>
+<path id="horn-near" fill="#e4c798" d="M 387 119 L 401 65 L 439 34 L 423 90 L 420 138 Z"/>
+<path id="head-rock" fill="#a99786" d="M 325 110 L 370 93 L 414 113 L 443 148 L 429 201 L 385 224 L 339 203 L 312 157 Z"/>
+<path id="crown-plates" fill="#6d6063" d="M 328 112 L 347 83 L 365 110 L 382 77 L 400 112 L 418 94 L 422 134 L 382 123 Z"/>
+<path id="face-cracks" fill="none" stroke="#ffbc37" stroke-width="7" d="M 371 109 L 367 131 L 380 143 M 335 172 L 348 192 L 372 202"/>
+<path id="muzzle" fill="#bf9c7f" d="M 406 156 L 448 158 L 469 177 L 461 198 L 423 211 L 394 193 Z"/>
+<path id="furnace-mouth" fill="#080d19" d="M 419 183 L 464 183 L 458 199 L 423 206 L 410 197 Z"/>
+<path id="mouth-heat" fill="#ff8c22" d="M 423 191 L 459 189 L 452 196 L 427 201 Z"/>
+<path id="nose" fill="#080d19" d="M 448 166 L 458 174 L 446 176 Z"/>
+<path id="brow" fill="none" stroke="#e3c49b" stroke-width="8" d="M 330 140 L 354 135 M 374 137 L 406 143"/>
+</g>
+<g id="tools">
+<path id="hammer-handle" fill="none" stroke="#d5aa77" stroke-width="17" d="M 461 296 L 533 140"/>
+<path id="hammer-head" fill="#9b9290" d="M 493 86 L 565 110 L 580 151 L 559 176 L 485 150 L 474 112 Z"/>
+<path id="hammer-face" fill="#dbb885" d="M 565 110 L 580 151 L 559 176 L 549 135 Z"/>
+<path id="hammer-seam" fill="none" stroke="#ffaf2b" stroke-width="8" d="M 495 102 L 518 121 L 509 142 L 545 157"/>
+<path id="arm" fill="#b59b80" d="M 410 247 L 438 241 L 455 267 L 478 253 L 495 264 L 493 288 L 455 309 L 431 293 Z"/>
+<path id="grip" fill="none" stroke="#554953" stroke-width="5" d="M 471 261 L 488 271 M 466 273 L 485 282"/>
+<path id="anvil" fill="#9a98a4" d="M 519 321 L 690 321 L 737 339 L 682 356 L 654 356 L 638 385 L 649 404 L 680 418 L 680 433 L 549 433 L 549 419 L 580 405 L 591 385 L 575 358 L 544 355 Z"/>
+<path id="anvil-top" fill="none" stroke="#f0d8b2" stroke-width="9" d="M 521 322 L 688 322 L 733 338"/>
+<path id="hot-billet" fill="#ffac2d" d="M 567 307 L 638 307 L 648 319 L 563 319 Z"/>
+</g>
+<g id="eyes">
+<path id="far-eye-socket" fill="#080d19" d="M 325 146 Q 342 133 358 148 L 360 175 Q 342 188 326 173 Z"/>
+<path id="far-eye-white" fill="#ffffff" d="M 331 149 Q 343 141 353 151 L 353 169 Q 342 179 332 169 Z"/>
+<path id="far-pupil" fill="#080d19" d="M 343 160 C 343 152 351 152 351 160 C 351 168 343 168 343 160 Z"/>
+<path id="near-eye-socket" fill="#080d19" d="M 369 145 Q 391 132 412 151 L 413 178 Q 389 193 370 177 Z"/>
+<path id="near-eye-white" fill="#ffffff" d="M 376 149 Q 392 141 406 154 L 406 172 Q 391 183 377 172 Z"/>
+<path id="near-pupil" fill="#080d19" d="M 391 162 C 391 152 401 152 401 162 C 401 172 391 172 391 162 Z"/>
+</g>
+</svg>

package/vendor/dragonlab/design/vulcan/v2/character.mjs

@@ -0,0 +1,39 @@
+import {renderSvgRig} from '../../../factory/svg-rig.mjs';
+import {renderVulcan as previous,poseRig as heatRig,VULCAN_CLIPS as previousClips} from '../v1/character.mjs';
+export const VULCAN_CLIPS=Object.freeze([...previousClips,{id:'forge',title:'The Brimstone Forge',duration:9000}]);
+export const STORY_DURATION=9000;
+const ease=x=>{x=Math.max(0,Math.min(1,x));return x*x*(3-2*x);};
+export function hammerAngle(t){
+ if(t<3000)return 0;
+ if(t<3800)return -.15*ease((t-3000)/800);
+ if(t<4200)return -.15+1.23*((t-3800)/400)**2;
+ if(t<4480)return 1.08-.22*ease((t-4200)/280);
+ if(t<4900)return .86+.09*ease((t-4480)/420);
+ if(t<7000)return .95*(1-ease((t-4900)/2100));
+ return 0;
+}
+export function poseRig(rig,ms){
+ const t=ms%9000;
+ const posed=heatRig(rig,t<3000?'fire':'idle',t<3000?t*2:0);
+ const a=hammerAngle(t),c=Math.cos(a),s=Math.sin(a);
+ const turn=([x,y])=>[478+(x-478)*c-(y-275)*s,275+(x-478)*s+(y-275)*c];
+ const moving=new Set(['hammer-handle','hammer-head','hammer-face','hammer-seam','grip']);
+ const paths=posed.paths.map(p=>moving.has(p.id)?{...p,polygons:p.polygons.map(poly=>poly.map(turn))}:p);
+ const delta=t-4200;
+ if(delta>=0&&delta<1000){
+  const u=delta/1000;
+  for(let i=0;i<9;i++){
+   const vx=(i-4)*25,vy=-85-12*(i%3),x=625+vx*u,y=307+vy*u+72*u*u,r=3.5*(1-u)+.5;
+   paths.push({id:'strike-spark-'+i,group:'sparks',stroke:0,erase:false,rgb:i%2?[255,233,143]:[255,154,34],polygons:[[[x-r,y],[x,y-r*1.8],[x+r,y],[x,y+r*1.8]]]});
+  }
+ }
+ return {...posed,paths};
+}
+export function renderVulcan(rig,scene='idle',ms=0,options={}){
+ if(scene!=='forge')return previous(rig,scene,ms,options);
+ if(!Number.isFinite(ms)||ms<0)return {ok:false,code:'INVALID_TIME'};
+ const t=options.still?4350:ms%9000;
+ const caption=t<3000?'Heat the iron.':t<4200?'Raise the hammer.':t<4900?'Fire. Iron. Impact.':t<7000?'Let the sparks settle.':'Ready for the next forging.';
+ return {...renderSvgRig(poseRig(rig,t),options),clip:scene,scene,caption};
+}
+export const renderStory=(rig,ms,options={})=>renderVulcan(rig,'forge',ms,options);

package/vendor/dragonlab/design/vulcan/v3/character.mjs

@@ -0,0 +1,41 @@
+import {renderSvgRig} from '../../../factory/svg-rig.mjs';
+import {poseRig as thermalPose} from '../v1/character.mjs';
+import {poseRig as forgePose,renderVulcan as previous,VULCAN_CLIPS as oldClips} from '../v2/character.mjs';
+export const VULCAN_CLIPS=Object.freeze([{id:'attach',title:'The Smith Arrives',duration:3600},...oldClips.map(c=>c.id==='idle'?{...c,duration:12000}:c)]);
+export const STORY_DURATION=15600;
+const pulse=(t,start,end)=>t<=start||t>=end?0:Math.sin(Math.PI*(t-start)/(end-start))**2;
+export function poseRig(rig,scene,ms){
+ const t=scene==='forge'?ms%9000:scene==='idle'?ms%12000:ms;
+ let base=scene==='forge'?forgePose(rig,t):thermalPose(rig,scene==='fire'?'fire':'idle',scene==='attach'?0:t);
+ // Keep mouth and target locked while emitting fire. Move only after it dies down.
+ const nod=scene==='attach'?pulse(t,300,1900):scene==='forge'?pulse(t,3800,4900):scene==='idle'?.22*pulse(t,2200,5200):0;
+ const follow=scene==='attach'?pulse(t,900,3200):scene==='forge'?pulse(t,4200,6800):scene==='idle'?.35*pulse(t,3100,7800):0;
+ const salute=scene==='attach'?-.13*pulse(t,1100,2900):0,c=Math.cos(salute),s=Math.sin(salute);
+ const tools=new Set(['hammer-handle','hammer-head','hammer-face','hammer-seam','grip']);
+ const paths=base.paths.map(p=>({...p,polygons:p.polygons.map(poly=>poly.map(([x,y])=>{
+  if(p.group==='head'||p.group==='eyes')return [x+4*nod,y+10*nod];
+  if(p.group==='neck'){const w=Math.max(0,Math.min(1,(270-y)/65));return [x+4*nod*w,y+10*nod*w];}
+  if(p.group==='wings'){const w=Math.max(0,Math.min(1,(310-y)/170));return [x+7*follow*w,y+5*follow*w];}
+  if(p.group==='tail'){const w=Math.max(0,Math.min(1,(270-x)/190));return [x,y-9*follow*w*w];}
+  if(tools.has(p.id)&&salute)return [478+(x-478)*c-(y-275)*s,275+(x-478)*s+(y-275)*c];
+  return [x,y];
+ }))}));
+ const byId=new Map(paths.map(p=>[p.id,p]));
+ const eyes=rig.eyes.map(e=>({...e,socket:byId.get(e.socket.id),white:byId.get(e.white.id),pupil:byId.get(e.pupil.id)}));
+ return {...base,paths,eyes};
+}
+export function renderVulcan(rig,scene='idle',ms=0,options={}){
+ if(!VULCAN_CLIPS.some(c=>c.id===scene))return {ok:false,code:'UNKNOWN_CLIP'};
+ if(!Number.isFinite(ms)||ms<0)return {ok:false,code:'INVALID_TIME'};
+ if(scene==='attach'&&ms>=3600&&!options.still)return renderVulcan(rig,'idle',ms-3600,options);
+ const t=options.still?({attach:1400,idle:4000,forge:4350,fire:3000}[scene]):ms;
+ const caption=scene==='attach'?'A nod from the forge.':scene==='idle'?'The furnace waits.':previous(rig,scene,t,options).caption;
+ return {...renderSvgRig(poseRig(rig,scene,t),options),clip:scene,scene,caption};
+}
+export function renderStory(rig,ms,options={}){
+ if(!Number.isFinite(ms)||ms<0)return {ok:false,code:'INVALID_TIME'};
+ if(options.still)return renderVulcan(rig,'forge',4350,options);
+ if(ms<3600)return renderVulcan(rig,'attach',ms,options);
+ if(ms<12600)return renderVulcan(rig,'forge',ms-3600,options);
+ return renderVulcan(rig,'idle',ms-12600,options);
+}

package/vendor/dragonlab/design/vulcan/v3/review.mjs

@@ -0,0 +1,35 @@
+#!/usr/bin/env node
+import fs from 'node:fs/promises';
+import {parseSvgRig} from '../../../factory/svg-rig.mjs';
+import {renderVulcan,VULCAN_CLIPS} from './character.mjs';
+import {artSlot,composeMessage} from '../../lucid/recovery/layout.mjs';
+import {cellsToAnsi} from '../../../vendor/quox-dragon/qart.js';
+const args=process.argv.slice(2),values=new Set(['--cols','--rows','--terminal-cols','--terminal-rows','--message','--scene','--at']);
+for(let i=0;i<args.length;i++){
+ if(values.has(args[i])){if(!args[i+1]||args[i+1].startsWith('--'))throw Error('Missing option value');i++;}
+ else if(!['--large','--mono','--help','--watch','--attach','--intro','--still','--list'].includes(args[i]))throw Error('Unknown option: '+args[i]);
+}
+const value=(name,fallback)=>args.includes(name)?args[args.indexOf(name)+1]:fallback;
+if(args.includes('--help')){console.log('Vulcan V3 forge studio. --watch --attach --intro --still --scene ID --at MS --list --large --mono --message TEXT --cols N --rows N --terminal-cols N --terminal-rows N');process.exit(0);}
+if(args.includes('--list')){console.log(VULCAN_CLIPS.map(c=>c.id+' · '+c.title).join('\n'));process.exit(0);}
+const w=Number(value('--terminal-cols',process.stdout.columns||80)),h=Number(value('--terminal-rows',process.stdout.rows||24));
+if(!Number.isSafeInteger(w)||!Number.isSafeInteger(h)||w<1||h<1)throw Error('Invalid terminal size');
+const slot=artSlot(w,h),large=args.includes('--large')||args.includes('--intro'),explicit=large||args.includes('--cols')||args.includes('--rows');
+const cols=Number(value('--cols',large?Math.min(120,w-4):Math.min(39,slot.cols))),rows=Number(value('--rows',large?Math.min(36,h-4):Math.min(11,slot.rows)));
+const message=value('--message','VULCAN\nThe furnace waits.');
+if(!slot.showArt&&!explicit){console.log(composeMessage(null,message,{terminalCols:w}).join('\n'));}
+else{
+ if(cols>w-4||rows>h-2)throw Error('Requested art exceeds terminal margins');
+ const rig=parseSvgRig(await fs.readFile(new URL('../v1/vulcan-master.svg',import.meta.url),'utf8'));
+ const opts={cols,rows,mono:args.includes('--mono'),still:args.includes('--still'),deck:large};
+ const scene=value('--scene',args.includes('--attach')?'attach':'idle');
+ const r=renderVulcan(rig,scene,Number(value('--at',0)),opts);
+ if(!r.ok)throw Error(r.code);
+ if(args.includes('--watch')||args.includes('--attach')||args.includes('--intro')){
+  const {watch}=await import('./watch.mjs');
+  await watch(rig,opts,{terminalCols:w,terminalRows:h,large,scene:args.includes('--scene')||args.includes('--attach')?scene:null,arrival:args.includes('--attach'),message:args.includes('--message')?message:null});
+ }else{
+ const shownMessage=args.includes('--message')?message:'VULCAN\n'+r.caption;
+ console.log((large?[...cellsToAnsi(r.frame),...composeMessage(null,shownMessage,{terminalCols:w})]:composeMessage(r.frame,shownMessage,{terminalCols:w})).join('\n'));
+}
+}

package/vendor/dragonlab/design/vulcan/v3/watch.mjs

@@ -0,0 +1,56 @@
+import {performance} from 'node:perf_hooks';
+import {VULCAN_CLIPS,renderVulcan,renderStory,STORY_DURATION} from './character.mjs';
+import {composeMessage} from '../../lucid/recovery/layout.mjs';
+import {cellsToAnsi} from '../../../vendor/quox-dragon/qart.js';
+
+/** One bounded performance. No alternate screen or full-screen clearing. */
+export async function watch(paths,options,config){
+  if(!process.stdout.isTTY||!process.stdin.isTTY)throw new Error('--watch/--intro needs an interactive terminal. Use --scene and --at for snapshots.');
+  const {terminalCols,terminalRows,scene,large,message}=config;
+  const clip=scene?VULCAN_CLIPS.find(c=>c.id===scene):null;
+  const duration=(clip?.duration??STORY_DURATION)+(config.arrival?6000:0);
+  const realCols=process.stdout.columns,realRows=process.stdout.rows;
+  const start=performance.now();
+  const render=t=>{
+    const r=scene?renderVulcan(paths,scene,t,options):renderStory(paths,t,options);
+    if(!r?.ok)throw new Error(r?.code??'Invalid story frame');
+    const caption=message??'VULCAN · '+r.clip+'\n'+r.caption;
+    return large?[...cellsToAnsi(r.frame),...caption.split('\n')]:composeMessage(r.frame,caption,{terminalCols});
+  };
+  // Reserve enough lines for captions too; keep within the real terminal.
+  const height=options.rows+3;
+  if(height>=terminalRows)throw new Error('Animation needs room for its caption; reduce --rows.');
+  let ended=false,drawn=false,timer,resolveDone,rejectDone;
+  const wasRaw=Boolean(process.stdin.isRaw);
+  const done=new Promise((resolve,reject)=>{resolveDone=resolve;rejectDone=reject;});
+  const cleanup=(error)=>{
+    if(ended)return;ended=true;clearInterval(timer);
+    process.stdin.off('data',key);process.stdout.off('resize',resized);
+    process.off('SIGINT',sigint);process.off('SIGTERM',sigterm);
+    process.stdin.setRawMode(wasRaw);process.stdin.pause();
+    if(drawn)process.stdout.write(`\x1b[${height}B\r`);
+    process.stdout.write('\x1b[0m\x1b[?25h');
+    error?rejectDone(error):resolveDone();
+  };
+  const key=data=>{if(data.includes(3)||data.toString().includes('q'))cleanup();};
+  const sigint=()=>cleanup(),sigterm=()=>cleanup();
+  const resized=()=>cleanup(new Error('Terminal resized; rerun for the new art slot.'));
+  try{
+    process.stdin.setRawMode(true);process.stdin.resume();process.stdin.on('data',key);
+    process.stdout.on('resize',resized);process.on('SIGINT',sigint);process.on('SIGTERM',sigterm);
+    process.stdout.write('\x1b[?25l');
+    // Allocate the block once; each frame replaces only these lines.
+    process.stdout.write('\n'.repeat(height)+`\x1b[${height}A`);drawn=true;
+    const tick=()=>{
+      try{
+        if(process.stdout.columns!==realCols||process.stdout.rows!==realRows)return resized();
+        const t=Math.min(performance.now()-start,duration-1),lines=render(t);
+        if(lines.length>height)throw new Error('Message exceeds the animation block; use a shorter message or a static preview.');
+        process.stdout.write(Array.from({length:height},(_,i)=>'\r\x1b[2K'+(lines[i]??'')+'\n').join('')+`\x1b[${height}A`);
+        if(performance.now()-start>=duration)cleanup();
+      }catch(e){cleanup(e);}
+    };
+    tick();if(!ended)timer=setInterval(tick,1000/6);
+    await done;
+  }catch(e){cleanup(e);await done;}
+}

package/vendor/dragonlab/factory/svg-rig-contour.mjs

@@ -0,0 +1,64 @@
+/** Shared authored SVG → original Q cells, supporting independently owned eyes. */
+import {flattenPath,sampleShape} from '../design/stage3/svg-coverage.js';
+import {makeField,fieldToCells} from '../vendor/quox-dragon/qart.js';
+const attr=(s,k)=>s.match(new RegExp(`(?:^|\\s)${k}="([^"]*)"`))?.[1];
+export function parseSvgRig(svg){
+ if(!svg.includes('viewBox="0 0 800 480"'))throw Error('Expected authored 800x480 master');
+ const ids=new Set(),groups=new Map(),stack=[];
+ for(const [tag]of svg.matchAll(/<g\s[^>]*>|<\/g>|<path\s[^>]*\/>/g)){
+  if(tag.startsWith('<g '))stack.push(attr(tag,'id'));else if(tag==='</g>')stack.pop();else groups.set(attr(tag,'id'),stack.at(-1));
+ }
+ const paths=[...svg.matchAll(/<path\s[^>]*\/>/g)].map(([tag])=>{
+  const id=attr(tag,'id'),d=attr(tag,'d'),stroke=attr(tag,'stroke'),fill=attr(tag,'fill');
+  if(!id||ids.has(id)||!d)throw Error('Every path requires unique id and geometry');ids.add(id);
+  const colour=stroke||fill;if(!/^#[0-9a-f]{6}$/i.test(colour))throw Error('Explicit hex colour required');
+  const width=stroke?Number(attr(tag,'stroke-width')):0;
+  if(!Number.isFinite(width)||width<0||width>30)throw Error('Invalid stroke width');
+  return {id,group:groups.get(id),polygons:flattenPath(d),rgb:[1,3,5].map(i=>parseInt(colour.slice(i,i+2),16)),stroke:width,erase:colour==='#080d19'};
+ });
+ const eyes=paths.filter(p=>p.id.endsWith('-eye-socket')).map(p=>{
+  const name=p.id.slice(0,-11),white=paths.find(p=>p.id===name+'-eye-white'),pupil=paths.find(p=>p.id===name+'-pupil');
+  if(!white||!pupil)throw Error('Every eye needs white and pupil');return {name,socket:p,white,pupil};
+ });
+ if(!paths.length||!eyes.length)throw Error('Missing anatomy or eyes');
+ const points=paths.flatMap(p=>p.polygons.flat());
+ const x=points.map(p=>p[0]),y=points.map(p=>p[1]);
+ return {paths,eyes,bounds:{left:Math.min(...x),top:Math.min(...y),right:Math.max(...x),bottom:Math.max(...y)}};
+}
+export function renderSvgRig(rig,{cols=39,rows=11,mono=false}={}){
+ if(!Number.isSafeInteger(cols)||!Number.isSafeInteger(rows)||cols<28||rows<10||cols>200||rows>72)throw RangeError('Art needs 28–200 columns and 10–72 rows');
+ if(typeof mono!=='boolean')throw TypeError('mono must be boolean');
+ const W=cols*2,H=rows*4,{left,top,right,bottom}=rig.bounds;
+ const scale=Math.min((W-4)/(right-left),(H-4)/(bottom-top));
+ const geometry={W,H,scale,ox:(W-(right-left)*scale)/2-left*scale,oy:(H-(bottom-top)*scale)/2-top*scale};
+ const field=makeField(W,H),labels=new Array(W*H).fill(''),colour=new Array(W*H).fill(null);
+ const coverage=p=>{const indices=[];sampleShape(p.polygons,{...geometry,stroke:p.stroke},(x,y)=>indices.push(y*W+x));return indices;};
+ const eyeIds=new Set(rig.eyes.flatMap(e=>[e.socket.id,e.white.id,e.pupil.id]));
+ function paint(p){for(const i of coverage(p)){field.v[i]=p.erase?0:1;labels[i]=p.id;colour[i]=p.rgb;}}
+ for(const p of rig.paths)if(!eyeIds.has(p.id))paint(p);
+ // Track eye cells for diagnostics; carve only the curved socket coverage.
+ const owned=new Set();
+ for(const e of rig.eyes)for(const i of coverage(e.socket))owned.add(Math.floor(i%W/2)+Math.floor(Math.floor(i/W)/4)*cols);
+ // Preserve facial dots outside each authored socket. Cell colour still prioritizes eye white.
+ for(const e of rig.eyes)paint(e.socket);
+ const pupilDots={};
+ for(const e of rig.eyes){
+  paint(e.white);let dots=coverage(e.pupil);
+  if(!dots.length){
+   // Optical correction is local to THIS eye; no Lucid-specific coordinates.
+   const points=e.pupil.polygons.flat(),cx=points.reduce((n,p)=>n+p[0],0)/points.length,cy=points.reduce((n,p)=>n+p[1],0)/points.length;
+   let best=-1,d=Infinity;
+   for(let i=0;i<labels.length;i++)if(labels[i]===e.white.id&&field.v[i]){const q=(i%W+.5-(geometry.ox+cx*scale))**2+(Math.floor(i/W)+.5-(geometry.oy+cy*scale))**2;if(q<d){best=i;d=q;}}
+   if(best>=0)dots=[best];
+  }
+  for(const i of dots){field.v[i]=0;labels[i]=e.pupil.id;colour[i]=null;}
+  pupilDots[e.name]=dots.length;
+ }
+ const frame=fieldToCells(field,{color:false,quant:false});let ink=0;
+ for(let y=0;y<rows;y++)for(let x=0;x<cols;x++){
+  const c=frame[y][x];c.bg=null;c.rgb=null;let chosen=-1,rank=-1;
+  for(let dy=0;dy<4;dy++)for(let dx=0;dx<2;dx++){const i=(y*4+dy)*W+x*2+dx;if(!field.v[i])continue;const r=labels[i].endsWith('-eye-white')?2:1;if(r>rank){rank=r;chosen=i;}}
+  if(chosen>=0){ink++;if(!mono)c.rgb=[...colour[chosen]];}
+ }
+ return {ok:true,frame,geometry,metrics:{cols,rows,ink,pupilDots,eyeOwnedCells:owned.size},visualOnly:true,demo:true};
+}

package/vendor/dragonlab/factory/svg-rig.mjs

@@ -0,0 +1,63 @@
+/** Shared authored SVG → original Q cells, supporting independently owned eyes. */
+import {flattenPath,sampleShape} from '../design/stage3/svg-coverage.js';
+import {makeField,fieldToCells} from '../vendor/quox-dragon/qart.js';
+const attr=(s,k)=>s.match(new RegExp(`(?:^|\\s)${k}="([^"]*)"`))?.[1];
+export function parseSvgRig(svg){
+ if(!svg.includes('viewBox="0 0 800 480"'))throw Error('Expected authored 800x480 master');
+ const ids=new Set(),groups=new Map(),stack=[];
+ for(const [tag]of svg.matchAll(/<g\s[^>]*>|<\/g>|<path\s[^>]*\/>/g)){
+  if(tag.startsWith('<g '))stack.push(attr(tag,'id'));else if(tag==='</g>')stack.pop();else groups.set(attr(tag,'id'),stack.at(-1));
+ }
+ const paths=[...svg.matchAll(/<path\s[^>]*\/>/g)].map(([tag])=>{
+  const id=attr(tag,'id'),d=attr(tag,'d'),stroke=attr(tag,'stroke'),fill=attr(tag,'fill');
+  if(!id||ids.has(id)||!d)throw Error('Every path requires unique id and geometry');ids.add(id);
+  const colour=stroke||fill;if(!/^#[0-9a-f]{6}$/i.test(colour))throw Error('Explicit hex colour required');
+  const width=stroke?Number(attr(tag,'stroke-width')):0;
+  if(!Number.isFinite(width)||width<0||width>30)throw Error('Invalid stroke width');
+  return {id,group:groups.get(id),polygons:flattenPath(d),rgb:[1,3,5].map(i=>parseInt(colour.slice(i,i+2),16)),stroke:width,erase:colour==='#080d19'};
+ });
+ const eyes=paths.filter(p=>p.id.endsWith('-eye-socket')).map(p=>{
+  const name=p.id.slice(0,-11),white=paths.find(p=>p.id===name+'-eye-white'),pupil=paths.find(p=>p.id===name+'-pupil');
+  if(!white||!pupil)throw Error('Every eye needs white and pupil');return {name,socket:p,white,pupil};
+ });
+ if(!paths.length||!eyes.length)throw Error('Missing anatomy or eyes');
+ const points=paths.flatMap(p=>p.polygons.flat());
+ const x=points.map(p=>p[0]),y=points.map(p=>p[1]);
+ return {paths,eyes,bounds:{left:Math.min(...x),top:Math.min(...y),right:Math.max(...x),bottom:Math.max(...y)}};
+}
+export function renderSvgRig(rig,{cols=39,rows=11,mono=false}={}){
+ if(!Number.isSafeInteger(cols)||!Number.isSafeInteger(rows)||cols<28||rows<10||cols>200||rows>72)throw RangeError('Art needs 28–200 columns and 10–72 rows');
+ if(typeof mono!=='boolean')throw TypeError('mono must be boolean');
+ const W=cols*2,H=rows*4,{left,top,right,bottom}=rig.bounds;
+ const scale=Math.min((W-4)/(right-left),(H-4)/(bottom-top));
+ const geometry={W,H,scale,ox:(W-(right-left)*scale)/2-left*scale,oy:(H-(bottom-top)*scale)/2-top*scale};
+ const field=makeField(W,H),labels=new Array(W*H).fill(''),colour=new Array(W*H).fill(null);
+ const coverage=p=>{const indices=[];sampleShape(p.polygons,{...geometry,stroke:p.stroke},(x,y)=>indices.push(y*W+x));return indices;};
+ const eyeIds=new Set(rig.eyes.flatMap(e=>[e.socket.id,e.white.id,e.pupil.id]));
+ function paint(p){for(const i of coverage(p)){field.v[i]=p.erase?0:1;labels[i]=p.id;colour[i]=p.rgb;}}
+ for(const p of rig.paths)if(!eyeIds.has(p.id))paint(p);
+ // Clear all eye-owned cells FIRST, so the far eye cannot erase the near eye.
+ const owned=new Set();
+ for(const e of rig.eyes)for(const i of coverage(e.socket))owned.add(Math.floor(i%W/2)+Math.floor(Math.floor(i/W)/4)*cols);
+ for(const cell of owned){const x=cell%cols*2,y=Math.floor(cell/cols)*4;for(let dy=0;dy<4;dy++)for(let dx=0;dx<2;dx++){const i=(y+dy)*W+x+dx;field.v[i]=0;labels[i]='';colour[i]=null;}}
+ const pupilDots={};
+ for(const e of rig.eyes){
+  paint(e.white);let dots=coverage(e.pupil);
+  if(!dots.length){
+   // Optical correction is local to THIS eye; no Lucid-specific coordinates.
+   const points=e.pupil.polygons.flat(),cx=points.reduce((n,p)=>n+p[0],0)/points.length,cy=points.reduce((n,p)=>n+p[1],0)/points.length;
+   let best=-1,d=Infinity;
+   for(let i=0;i<labels.length;i++)if(labels[i]===e.white.id&&field.v[i]){const q=(i%W+.5-(geometry.ox+cx*scale))**2+(Math.floor(i/W)+.5-(geometry.oy+cy*scale))**2;if(q<d){best=i;d=q;}}
+   if(best>=0)dots=[best];
+  }
+  for(const i of dots){field.v[i]=0;labels[i]=e.pupil.id;colour[i]=null;}
+  pupilDots[e.name]=dots.length;
+ }
+ const frame=fieldToCells(field,{color:false,quant:false});let ink=0;
+ for(let y=0;y<rows;y++)for(let x=0;x<cols;x++){
+  const c=frame[y][x];c.bg=null;c.rgb=null;let chosen=-1,rank=-1;
+  for(let dy=0;dy<4;dy++)for(let dx=0;dx<2;dx++){const i=(y*4+dy)*W+x*2+dx;if(!field.v[i])continue;const r=labels[i].endsWith('-eye-white')?2:1;if(r>rank){rank=r;chosen=i;}}
+  if(chosen>=0){ink++;if(!mono)c.rgb=[...colour[chosen]];}
+ }
+ return {ok:true,frame,geometry,metrics:{cols,rows,ink,pupilDots,eyeOwnedCells:owned.size},visualOnly:true,demo:true};
+}