quoxcli 0.3.1 → 0.5.0

package/vendor/dragonlab/design/lucid/recovery/character.mjs

@@ -0,0 +1,106 @@
+/** Lucid's pure acting layer: clip metadata, deterministic performances, story. */
+import {arrivalPose,ARRIVAL_DURATION,DECK_ARRIVAL_DURATION} from './arrival.mjs';
+import {motionAt} from './motion.mjs';
+import {renderMaster} from './render.mjs';
+const clamp=x=>Math.max(0,Math.min(1,x));
+const ease=x=>{x=clamp(x);return x*x*(3-2*x);};
+export const LUCID_CLIPS=Object.freeze([
+  {id:'attach',title:'I See You',duration:ARRIVAL_DURATION,message:'Hello. I am here.'},
+  {id:'deck-arrival',title:'Lucid Arrives',duration:DECK_ARRIVAL_DURATION,message:'LUCID · Awareness in the present'},
+  {id:'idle',title:'Here and Now',duration:12000,message:'Aware. Attentive. Present.'},
+  {id:'greeting',title:'Hello There',duration:1800,message:'Hello. What shall we look at?'},
+  {id:'curious',title:'A Closer Look',duration:2600,message:'That is interesting…'},
+  {id:'notice',title:'Something Changed',duration:1800,message:'I noticed a change.'},
+  {id:'focus',title:'Hold That Thought',duration:2200,message:'Looking closely.'},
+  {id:'uncertain',title:'Missing Piece',duration:2200,message:'There is a part I cannot see yet.'},
+  {id:'delighted',title:'Oh, There It Is',duration:1800,message:'Oh! There it is.'},
+  {id:'standby',title:'Quiet Company',duration:3000,message:'I am here.'},
+  {id:'sweep',title:'Horizon Sweep',duration:3200,message:'Horizon Sweep · visual demo',power:true},
+  {id:'threadlight',title:'Threadlight',duration:3600,message:'Threadlight · visual demo',power:true},
+  {id:'constellation',title:'Living Constellation',duration:4200,message:'Living Constellation · visual demo',power:true},
+]);
+export const LUCID_STORY=Object.freeze([
+  {scene:'greeting',duration:1800},{scene:'idle',duration:2400},
+  {scene:'curious',duration:2200},{scene:'notice',duration:1500},
+  {scene:'sweep',duration:3200},{scene:'focus',duration:1600},
+  {scene:'threadlight',duration:3600},{scene:'uncertain',duration:1800},
+  {scene:'constellation',duration:4200},{scene:'delighted',duration:1800},
+  {scene:'idle',duration:2000},
+]);
+export const STORY_DURATION=LUCID_STORY.reduce((n,s)=>n+s.duration,0);
+export const LUCID_MANIFEST=Object.freeze({id:'lucid',displayName:'Lucid',
+  role:'Attentive observer of the living present',defaultClip:'idle',
+  clips:LUCID_CLIPS,story:LUCID_STORY,
+  powers:LUCID_CLIPS.filter(c=>c.power).map(c=>({name:c.title,scene:c.id,visualOnly:true})),
+  notes:'SVG recovery rig. White round eyes, black centre pupil. Not yet registered in the shared Character Pack.'});
+
+export function eyePerformance(scene,t){
+  const blink=t%4800;
+  const base={gx:0,gy:0,open:blink>3600&&blink<3800?.12:1};
+  switch(scene){
+    case 'attach':case 'deck-arrival':return {gx:0,gy:0,open:1};
+    case 'idle':return base;
+    case 'greeting':return {gx:0,gy:0,open:t>700&&t<900?.12:1.12};
+    case 'curious':return {gx:-.85*ease(t/650),gy:-.3,open:1.18};
+    case 'notice':return {gx:ease((t-120)/220),gy:-.4,open:1.2};
+    case 'focus':return {gx:.9,gy:0,open:.65};
+    case 'uncertain':return {gx:t<1100?-.7:.65,gy:.45,open:.9};
+    case 'delighted':return {gx:0,gy:0,open:t>1200&&t<1360?.2:1.2};
+    case 'standby':return {...base,open:blink>2500?.2:.85};
+    case 'sweep':return {gx:-1+2*ease(t/2200),gy:-.3,open:1};
+    case 'threadlight':return {gx:.9,gy:-.3,open:1};
+    case 'constellation':return {gx:.8,gy:-.6,open:1.15};
+    default:throw new RangeError('Unknown expression');
+  }
+}
+
+function powerOverlay(frame,scene,t,duration,mono){
+  const rows=frame.length,cols=frame[0].length;
+  const fade=ease(t/450)*(1-ease((t-duration+650)/650));
+  if(fade<.08)return 0;
+  let count=0;
+  const point=(x,y,strong=false)=>{
+    x=Math.round(x);y=Math.round(y);
+    if(x<1||y<1||x>=cols-1||y>=rows-1||frame[y][x].ch!==' ')return;
+    frame[y][x]={ch:strong?'⠿':'⠂',rgb:mono?null:(strong?[232,245,255]:[94,205,230]).map(v=>Math.round(v*fade)),bg:null};count++;
+  };
+  // Deliberately use only the empty sky to the right of the sail.
+  const x0=cols*.74,x1=cols-.06*cols,y0=rows*.10,y1=rows*.43;
+  const nodes=[[x0,y1],[x0+(x1-x0)*.45,y0],[x1,y1*.85]];
+  if(scene==='sweep'){
+    const u=clamp(t/(duration-500));
+    for(let i=0;i<7;i++){const a=-1.2+i*.4;point(x0+u*(x1-x0)+Math.cos(a)*2,y0+(y1-y0)*.5+Math.sin(a)*(y1-y0)*.5,i===3);}
+  }else {
+    const amount=clamp((t-300)/(duration-1100));
+    for(let i=0;i<3;i++)if(amount>(i/5))point(...nodes[i],true);
+    for(let edge=0;edge<(scene==='constellation'?3:2);edge++){
+      const a=nodes[edge],b=nodes[(edge+1)%3];
+      for(let k=1;k<8;k++)if(amount>(edge+k/8)/3)
+        point(a[0]+(b[0]-a[0])*k/8,a[1]+(b[1]-a[1])*k/8);
+    }
+  }
+  return count;
+}
+
+export function renderLucidCharacter(paths,scene='idle',ms=0,options={}){
+  const clip=LUCID_CLIPS.find(c=>c.id===scene);
+  if(!clip)return {ok:false,code:'UNKNOWN_CLIP'};
+  if(!Number.isFinite(ms)||ms<0)return {ok:false,code:'INVALID_TIME'};
+  const arrival=scene==='attach'||scene==='deck-arrival';
+  const time=options.still?0:Math.min(ms,clip.duration);
+  const pose=arrival&&!options.still?arrivalPose(ms,{deck:scene==='deck-arrival'}):null;
+  const idleTime=pose?.phase==='present'?ms-pose.duration:ms;
+  const face=pose?.face??eyePerformance(pose?.phase==='present'?'idle':scene,options.still?0:arrival?idleTime:time);
+  const motionTime=options.motionTime??ms;
+  const motion=options.still?null:pose?.motion??motionAt(motionTime);
+  const result=renderMaster(paths,{...options,face,motion});
+  const effectCells=clip.power?powerOverlay(result.frame,scene,options.still?clip.duration/2:time,clip.duration,options.mono):0;
+  return {...result,ok:true,scene,clip:clip.title,time,duration:clip.duration,face,motion,
+    phase:pose?.phase??scene,caption:clip.message,visualOnly:true,demo:true,effectCells};
+}
+
+export function renderLucidStory(paths,ms,options={}){
+  if(!Number.isFinite(ms)||ms<0)return {ok:false,code:'INVALID_TIME'};
+  let t=options.still?0:options.loop?ms%STORY_DURATION:Math.min(ms,STORY_DURATION-1);
+  for(const beat of LUCID_STORY){if(t<beat.duration)return renderLucidCharacter(paths,beat.scene,t,{...options,motionTime:ms});t-=beat.duration;}
+}

package/vendor/dragonlab/design/lucid/recovery/layout.mjs

@@ -0,0 +1,50 @@
+import {cellsToAnsi} from '../../../vendor/quox-dragon/qart.js';
+
+/** Half-width by half-height, minus margins: below a quarter of the screen. */
+export function artSlot(terminalCols=80,terminalRows=24) {
+  if(![terminalCols,terminalRows].every(n=>Number.isSafeInteger(n)&&n>0))
+    throw new RangeError('Terminal dimensions must be positive integers.');
+  const cols=Math.min(54,Math.floor(terminalCols/2)-1);
+  const rows=Math.min(16,Math.floor(terminalRows/2)-1);
+  return {cols:Math.max(0,cols),rows:Math.max(0,rows),
+    showArt:cols>=28&&rows>=10,terminalCols,terminalRows};
+}
+
+// Terminal cell widths for ordinary message text, including CJK and emoji.
+// Never pass message control sequences through to the terminal.
+export function cleanText(text) {
+  return String(text).replace(/\x1b(?:\[[0-?]*[ -/]*[@-~]|\][^\x07]*(?:\x07|$))/g,'')
+    .replace(/[\x00-\x09\x0b-\x1f\x7f-\x9f]/g,'');
+}
+const segmenter=new Intl.Segmenter(undefined,{granularity:'grapheme'});
+const width=g=>/\p{Extended_Pictographic}|[\u1100-\u115f\u2329\u232a\u2e80-\ua4cf\uac00-\ud7a3\uf900-\ufaff\ufe10-\ufe6f\uff01-\uff60\uffe0-\uffe6]/u.test(g)?2:1;
+export function wrapMessage(text,cols) {
+  if(cols<1)return [];
+  const result=[];
+  for(const paragraph of cleanText(text).split('\n')) {
+    let line='',n=0;
+    for(const {segment} of segmenter.segment(paragraph)) {
+      const w=width(segment);
+      if(n+w>cols){result.push(line.trimEnd());line='';n=0;}
+      if(w>cols)continue;
+      if(!line&&segment===' ')continue;
+      line+=segment;n+=w;
+    }
+    result.push(line.trimEnd());
+  }
+  return result;
+}
+
+export function composeMessage(frame,message,{terminalCols=80}={}) {
+  const margin=1,gap=2,artCols=frame?.[0]?.length??0;
+  const available=terminalCols-margin*2-artCols-gap;
+  if(!frame||available<12) {
+    const text=wrapMessage(message,Math.max(1,terminalCols-margin*2)).map(l=>' '.repeat(Math.min(margin,terminalCols-1))+l);
+    return frame?[...cellsToAnsi(frame).map(l=>' '.repeat(margin)+l),...text]:text;
+  }
+  const text=wrapMessage(message,available),art=cellsToAnsi(frame);
+  // Messages keep all their content and flow below if taller than the art.
+  const offset=text.length<frame.length?Math.floor((frame.length-text.length)/2):0;
+  return Array.from({length:Math.max(frame.length,offset+text.length)},(_,i)=>
+    ' '.repeat(margin)+(art[i]??' '.repeat(artCols))+' '.repeat(gap)+(text[i-offset]??''));
+}

package/vendor/dragonlab/design/lucid/recovery/lucid-master.svg

@@ -0,0 +1,78 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 800 480" role="img" aria-labelledby="title desc">
+  <title id="title">Lucid — the living present</title>
+  <desc id="desc">Full-body vector study: a poised left-facing watcher, swept horns, white eye, tall curved neck, resting haunches, articulated claws, sail wings and a spiral tail. Unapproved art study.</desc>
+  <g id="tail">
+    <path id="tail-mass" fill="#7453ce" d="M480 352 C533 360 569 405 633 405 C692 405 741 375 741 326 C741 298 721 283 701 285 C679 287 666 305 670 324 C673 341 688 348 702 341 C711 336 715 326 710 317 C723 326 719 347 704 354 C682 365 655 349 651 326 C645 293 668 267 700 266 C740 265 762 292 761 326 C759 390 705 431 638 433 C573 435 519 408 475 393 Z"/>
+    <path id="tail-light" fill="#49bdd3" d="M509 384 C565 413 607 428 652 422 C712 415 753 375 752 327 C752 297 731 277 706 278 C733 274 754 293 757 322 C763 378 718 425 655 432 C601 438 552 419 509 397 Z"/>
+    <path id="tail-coil-light" fill="#b09af2" d="M700 275 C673 275 655 297 659 323 C662 345 679 355 696 350 C682 350 669 339 667 323 C664 302 678 284 700 282 Z"/>
+    <path id="tail-tip" fill="#b5a2f7" d="M702 341 C712 337 714 327 710 317 C706 307 698 305 691 310 C697 299 709 301 715 312 C722 325 715 339 702 341 Z"/>
+  </g>
+  <g id="far-wing">
+    <path id="far-sail" fill="#44357c" d="M314 339 C338 265 361 194 409 114 C413 186 444 231 484 249 C424 245 379 281 346 343 Z"/>
+    <path id="far-spar" fill="#9b80e6" d="M314 339 C341 245 371 175 409 114 C388 185 365 254 333 342 Z"/>
+  </g>
+  <g id="far-feet">
+    <path id="far-foreleg" fill="#4b397f" d="M270 330 C285 353 278 385 265 407 L215 418 L199 412 L210 399 L242 392 L245 350 Z"/>
+    <path id="far-hindleg" fill="#514080" d="M472 363 C490 378 488 394 473 410 L418 420 L404 414 L420 399 L450 391 Z"/>
+    <path id="far-claw-1" fill="#b1c9e6" d="M211 402 C201 408 197 417 197 425 L207 418 L219 408 Z"/>
+    <path id="far-claw-2" fill="#b1c9e6" d="M424 404 C414 412 411 420 412 427 L422 419 L434 408 Z"/>
+  </g>
+  <g id="body">
+    <path id="body-mass" fill="#7250bc" d="M239 291 C267 284 296 298 322 319 C359 342 393 319 441 320 C493 320 532 350 554 384 C532 401 490 408 453 402 C421 396 395 390 364 392 C321 402 283 399 252 378 C224 359 219 320 239 291 Z"/>
+    <path id="back-plane" fill="#a184e2" d="M288 311 C333 346 370 319 416 320 C469 310 504 333 530 358 C492 337 464 333 433 340 C389 351 365 359 332 346 Z"/>
+    <path id="haunch" fill="#8563ce" d="M439 344 C477 331 506 352 516 378 C511 395 485 404 456 400 C431 397 413 384 416 367 C418 356 427 349 439 344 Z"/>
+    <path id="haunch-shadow" fill="#4f3b88" d="M454 350 C434 354 427 368 438 380 C451 390 477 389 494 383 C478 399 450 401 433 389 C415 376 427 353 454 350 Z"/>
+  </g>
+  <g id="near-wing">
+    <path id="near-sail" fill="#456cba" d="M299 346 C342 291 371 230 418 170 C453 125 504 90 569 69 C535 106 518 144 516 181 C512 218 533 248 558 265 C519 256 488 259 462 274 C424 297 395 325 361 340 Z"/>
+    <path id="upper-membrane" fill="#618fd0" d="M328 325 C376 252 403 192 450 145 C480 116 514 95 552 82 C500 123 464 170 433 222 C403 269 367 303 328 325 Z"/>
+    <path id="lower-membrane" fill="#408aa9" d="M345 333 C405 299 457 273 514 252 C494 225 493 199 500 170 C457 225 414 285 345 333 Z"/>
+    <path id="wing-leading-edge" fill="#b79af1" d="M295 347 C343 282 367 224 415 165 C457 116 509 86 569 69 C519 93 469 126 428 174 C381 231 357 294 318 345 Z"/>
+    <path id="wing-finger-1" fill="#9fcde7" d="M316 340 C379 298 423 247 458 191 C487 144 521 105 561 75 C521 118 494 155 465 201 C431 258 385 308 330 339 Z"/>
+    <path id="wing-finger-2" fill="#8cc8e0" d="M330 340 C406 316 466 282 549 263 C478 289 420 324 350 342 Z"/>
+    <path id="wing-fold-shadow" fill="#383168" d="M317 343 C364 323 405 296 443 264 C411 303 384 331 360 341 Z"/>
+  </g>
+  <g id="neck">
+    <path id="neck-mass" fill="#7753c5" d="M217 166 C247 181 263 210 266 245 C269 282 254 310 265 339 C273 359 294 372 319 379 C291 397 256 394 229 377 C205 362 199 338 206 309 C214 280 226 256 222 231 C219 210 203 197 188 191 Z"/>
+    <path id="neck-shadow" fill="#4e3a89" d="M223 196 C251 216 257 245 248 274 C234 309 238 340 260 360 C247 355 229 337 230 316 C230 291 244 269 244 244 C244 223 235 209 223 196 Z"/>
+    <path id="throat" fill="#87bfd6" d="M194 189 C214 206 230 221 229 245 C229 272 211 302 212 327 C213 352 226 367 247 378 C227 366 218 345 224 321 C229 301 245 277 245 249 C245 221 230 203 210 190 Z"/>
+    <path id="chest-plane" fill="#91a9df" d="M214 317 C213 341 229 365 254 374 C272 381 289 382 307 378 C292 390 263 389 242 381 C221 372 206 349 208 329 Z"/>
+    <path id="throat-segments" fill="none" stroke="#5263a0" stroke-width="3" d="M218 226 Q229 229 240 225 M227 246 Q235 250 245 247 M224 266 Q234 270 241 269 M217 287 Q226 291 234 292 M212 309 Q220 313 227 313 M213 331 Q221 335 227 333 M220 352 Q230 353 236 350"/>
+  </g>
+  <g id="near-feet">
+    <path id="foreleg" fill="#9273d6" d="M247 337 C261 341 268 354 263 371 C258 385 243 394 225 402 L215 414 L200 414 L194 422 L182 417 L171 422 L161 416 C167 401 184 395 203 388 C218 382 224 371 226 354 Z"/>
+    <path id="foreleg-plane" fill="#b29de9" d="M246 346 C251 362 245 378 227 388 L193 402 L179 414 L169 413 C176 403 188 400 204 392 C227 381 234 368 233 355 Z"/>
+    <path id="hindfoot" fill="#9476d5" d="M472 379 C480 388 477 398 463 403 L430 410 L415 425 L401 423 L395 430 L383 424 L371 429 L362 421 C369 404 386 397 408 395 L432 386 Z"/>
+    <path id="hindfoot-plane" fill="#ae95e1" d="M449 392 L411 403 C392 404 379 414 372 424 L364 420 C372 405 389 400 407 398 Z"/>
+    <path id="fore-claw-1" fill="#d2e3ef" d="M169 412 C159 414 154 426 157 439 C161 429 165 426 175 423 Z"/>
+    <path id="fore-claw-2" fill="#d2e3ef" d="M188 414 C180 420 178 430 181 443 C185 433 189 428 196 425 Z"/>
+    <path id="fore-claw-3" fill="#d2e3ef" d="M209 409 C203 415 201 425 204 436 C208 426 212 422 218 420 Z"/>
+    <path id="hind-claw-1" fill="#c4d9eb" d="M372 420 C362 423 359 434 361 445 C366 436 370 433 378 431 Z"/>
+    <path id="hind-claw-2" fill="#c4d9eb" d="M392 423 C385 429 384 438 387 449 C391 440 395 436 402 433 Z"/>
+    <path id="hind-claw-3" fill="#c4d9eb" d="M413 418 C407 424 406 432 409 442 C414 433 418 430 424 427 Z"/>
+  </g>
+  <g id="horns">
+    <path id="far-horn" fill="#8ba1d7" d="M197 148 C222 114 256 87 302 57 C277 84 254 110 237 133 L218 159 Z"/>
+    <path id="far-horn-tip" fill="#c5dce9" d="M239 112 C259 91 278 75 302 57 C286 74 270 91 256 107 Z"/>
+    <path id="near-horn" fill="#a68be4" d="M165 151 C171 127 190 102 219 78 C239 62 261 45 281 28 C265 53 244 74 226 95 C205 118 196 139 194 157 Z"/>
+    <path id="near-horn-light" fill="#d1daf3" d="M174 143 C181 121 200 99 221 81 C242 63 263 46 281 28 C267 50 243 73 228 90 C204 116 191 138 188 153 Z"/>
+    <path id="horn-root" fill="#8461ce" d="M168 141 L184 129 L204 144 L220 133 L231 153 L214 174 L181 167 Z"/>
+  </g>
+  <g id="head">
+    <path id="head-mass" fill="#8963d4" d="M156.48 146.84 C172.16 130.2 197.92 130.2 218.08 141.72 L243.84 162.2 L227.04 180.12 L236 195.48 L211.36 199.32 C201.28 214.68 182.24 219.8 166.56 213.4 L136.32 212.12 L118.4 223.64 L91.52 219.8 L83.68 209.56 L103.84 185.24 L119.52 162.2 Z"/>
+    <path id="brow-plane" fill="#b797f0" d="M119.52 162.2 C143.04 153.24 158.72 139.16 181.12 139.16 C197.92 137.88 211.36 144.28 222.56 151.96 L204.64 155.8 L181.12 149.4 L158.72 166.04 L131.84 173.72 Z"/>
+    <path id="muzzle-plane" fill="#629fca" d="M103.84 185.24 L126.24 180.12 L137.44 187.8 L124 201.88 L96 209.56 L83.68 209.56 Z"/>
+    <path id="jaw-plane" fill="#b4a2e2" d="M92.64 212.12 L120.64 213.4 L140.8 200.6 L162.08 200.6 C175.52 212.12 193.44 209.56 208 200.6 C195.68 222.36 177.76 226.2 159.84 215.96 L138.56 214.68 L120.64 224.92 L93.76 221.08 Z"/>
+    <path id="cheek-plane" fill="#6846a8" d="M204.64 172.44 L225.92 181.4 L220.32 191.64 L202.4 195.48 L187.84 207 L175.52 200.6 Z"/>
+    <path id="ear-fin" fill="#a184e4" d="M209.12 153.24 C231.52 143 251.68 144.28 269.6 136.6 L247.2 162.2 L227.04 169.88 Z"/>
+    <path id="ear-fold" fill="#4d4286" d="M225.92 157.08 L255.04 145.56 L240.48 159.64 L225.92 164.76 Z"/>
+    <path id="cheek-fin" fill="#6caac9" d="M221.44 181.4 L258.4 185.24 L237.12 195.48 L220.32 192.92 Z"/>
+    <path id="nostril" fill="#24213c" d="M104.96 194.2 Q110.56 187.8 113.92 191.64 Q110.56 198.04 104.96 198.04 Z"/>
+    <path id="mouth-line" fill="none" stroke="#312542" stroke-width="3" d="M96 212.12 Q118.4 218.52 138.56 204.44 Q150.88 200.6 163.2 204.44"/>
+  </g>
+  <g id="eye" data-cell-owner="eye">
+    <path id="eye-socket" fill="#29213d" d="M146 175 C146 158 157 149 178 149 C199 149 211 159 211 176 C211 195 198 205 178 205 C158 205 146 194 146 175 Z"/>
+    <path id="iris" fill="#f2f6ff" d="M149 175 C149 160 160 152 178 152 C196 152 208 161 208 176 C208 192 196 202 178 202 C161 202 149 192 149 175 Z"/>
+    <path id="pupil" fill="#111520" d="M186 177 C186 182 182 185 178 185 C173 185 170 182 170 177 C170 172 173 169 178 169 C182 169 186 172 186 177 Z"/>
+  </g>
+</svg>

package/vendor/dragonlab/design/lucid/recovery/motion.mjs

@@ -0,0 +1,42 @@
+/** Small joint movements over a twelve-second cycle, with deliberate rests. */
+const clamp=x=>Math.max(0,Math.min(1,x));
+const smooth=x=>{x=clamp(x);return x*x*(3-2*x);};
+const pulse=(t,a,b)=>t<=a||t>=b?0:Math.sin(Math.PI*(t-a)/(b-a))**2;
+export const MOTION_PERIOD=12000;
+export function motionAt(ms){
+  if(!Number.isFinite(ms)||ms<0)throw new RangeError('Motion time must be nonnegative.');
+  const t=ms%MOTION_PERIOD;
+  return {
+    tail:pulse(t,600,4200)-.45*pulse(t,4500,6200)+.22*pulse(t,6500,8000),
+    wing:.045*pulse(t,2600,4400)-.010*pulse(t,4400,5100)+.025*pulse(t,9200,10800),
+    farWing:.026*pulse(t,2800,4600)-.006*pulse(t,4600,5300)+.016*pulse(t,9400,11000),
+    neck:.032*pulse(t,1100,4700)-.014*pulse(t,7200,9900),
+    nod:3*pulse(t,1300,4900)+2*pulse(t,7400,10100),
+  };
+}
+const rotate=(x,y,cx,cy,a)=>[
+  cx+(x-cx)*Math.cos(a)-(y-cy)*Math.sin(a),
+  cy+(x-cx)*Math.sin(a)+(y-cy)*Math.cos(a),
+];
+
+/** Deform authored paths together, never append procedural anatomy. */
+export function movePoint(group,x,y,pose){
+  if(!pose)return [x,y];
+  if(group==='tail'){
+    // Root is pinned; only the distal tail and spiral tighten/open/recoil.
+    const w=smooth((x-515)/145),curl=pose.tail*w;
+    const [rx,ry]=rotate(x,y,700,325,curl*.15);
+    const scale=1-.14*curl;
+    return [700+(rx-700)*scale-8*Math.abs(curl),325+(ry-325)*scale-10*curl];
+  }
+  if(group==='near-wing')return rotate(x,y,310,341,pose.wing);
+  if(group==='far-wing')return rotate(x,y,330,340,pose.farWing);
+  if(['neck','head','horns','eye'].includes(group)){
+    // The neck smoothly blends to its anchored chest. Face, eye and horns
+    // share the upper joint transform, so the eye never slides off the head.
+    const w=group==='neck'?smooth((330-y)/130):1;
+    const [rx,ry]=rotate(x,y,235,300,pose.neck*w);
+    return [rx,ry+pose.nod*w];
+  }
+  return [x,y];
+}

package/vendor/dragonlab/design/lucid/recovery/render.mjs

@@ -0,0 +1,121 @@
+/** The SVG is the anatomy source. Q's existing sampler and packer stay intact. */
+import {movePoint} from './motion.mjs';
+import { makeField, fieldToCells } from '../../../vendor/quox-dragon/qart.js';
+import { flattenPath, sampleShape } from '../../stage3/svg-coverage.js';
+
+const CUTOUTS = new Set(['eye-socket', 'pupil', 'nostril', 'mouth-line']);
+const IRIS = new Set(['iris', 'iris-light']);
+const EYE = new Set(['eye-socket','eye-rim','iris','iris-light','pupil','eye-glint','lower-lid']);
+const attr = (tag, key) => tag.match(new RegExp(`(?:^|\\s)${key}="([^"]*)"`))?.[1];
+const rgb = hex => [1,3,5].map(i => parseInt(hex.slice(i,i+2),16));
+
+export function parseMaster(svg) {
+  if (!svg.includes('viewBox="0 0 800 480"')) throw new Error('Expected 800×480 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');
+    const stroke = attr(tag,'stroke'), fill = attr(tag,'fill');
+    if (!id || ids.has(id) || !d) throw new Error('Every path needs a unique id and geometry.');
+    ids.add(id);
+    const colour = stroke || fill;
+    if (!/^#[0-9a-f]{6}$/i.test(colour)) throw new Error(`Unsupported colour: ${id}`);
+    return {id, group:groups.get(id), polygons:flattenPath(d), rgb:rgb(colour), stroke:stroke ? Number(attr(tag,'stroke-width')) : 0};
+  });
+  if (!paths.length || !ids.has('iris') || !ids.has('tail-mass')) throw new Error('Incomplete master.');
+  return paths;
+}
+
+export function renderMaster(paths, {cols=39, rows=11, mono=false, eyes='white', face={}, motion=null}={}) {
+  if (![cols,rows].every(Number.isSafeInteger) || cols<28 || rows<10 || cols>200 || rows>72)
+    throw new RangeError('Full dragon requires 28–200 columns and 10–72 rows.');
+  if (!['white','violet'].includes(eyes)) throw new RangeError('Eyes must be white or violet.');
+  const W=cols*2, H=rows*4, field=makeField(W,H);
+  const colours=new Uint8Array(W*H*3), priorities=new Uint8Array(W*H);
+  const labels=new Array(W*H).fill('');
+  // Fit the authored ink bounds, rather than its generously padded SVG canvas.
+  const points=paths.flatMap(p=>p.polygons.flat());
+  const xs=points.map(p=>p[0]),ys=points.map(p=>p[1]);
+  const left=Math.min(...xs),top=Math.min(...ys);
+  const width=Math.max(...xs)-left,height=Math.max(...ys)-top;
+  const scale=Math.min((W-4)/width,(H-4)/height);
+  const geometry={W,H,scale,ox:(W-width*scale)/2-left*scale,oy:(H-height*scale)/2-top*scale};
+  const gx=face.gx??0,gy=face.gy??0,open=face.open??1;
+  if(![gx,gy,open].every(Number.isFinite)||Math.abs(gx)>1||Math.abs(gy)>1||open<0.1||open>1.25)throw new RangeError('Invalid eye pose.');
+  const coverage=path => {
+    const result=[];
+    let polygons=['iris','pupil'].includes(path.id) ? path.polygons.map(poly=>poly.map(([x,y])=>[x+(path.id==='pupil'?gx*12:0),177+(y-177)*open+(path.id==='pupil'?gy*5*open:0)])) : path.polygons;
+    if(motion)polygons=polygons.map(poly=>poly.map(([x,y])=>movePoint(path.group,x,y,motion)));
+    sampleShape(polygons,{...geometry,stroke:path.stroke},(x,y)=>result.push(y*W+x));
+    // At compact resolution a sub-dot pupil can otherwise disappear as the
+    // head moves between samples. Keep one centre dot inside the eye white.
+    if(path.id==='pupil'&&!result.length&&open>.3){
+      const [cx,cy]=movePoint(path.group,178+gx*12,177+gy*5*open,motion);
+      const px=geometry.ox+cx*scale,py=geometry.oy+cy*scale;
+      let best=-1,distance=Infinity;
+      for(let i=0;i<labels.length;i++)if(labels[i]==='iris'&&field.v[i]){
+        const d=(i%W+.5-px)**2+(Math.floor(i/W)+.5-py)**2;
+        if(d<distance){best=i;distance=d;}
+      }
+      if(best>=0)result.push(best);
+    }
+    return result;
+  };
+  const owned=new Set();
+  const socket=paths.find(p=>p.id==='eye-socket');
+  for (const i of coverage(socket)) owned.add(Math.floor((i%W)/2)+Math.floor(Math.floor(i/W)/4)*cols);
+  for (const path of paths) {
+    if (path.id==='eye-socket') {
+      // Same whole-cell ownership principle as Q's eyes: remove body under
+      // every socket cell before painting the eye; no purple body bleed.
+      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]='';priorities[i]=0;
+        }
+      }
+    }
+    for (const i of coverage(path)) {
+      const erase=CUTOUTS.has(path.id);
+      field.v[i]=erase?0:1;
+      colours.set(IRIS.has(path.id) ? (eyes==='white' ? [242,246,255] : [182,107,255]) : path.id==='eye-rim' ? [242,246,255] : path.rgb,i*3);labels[i]=path.id;
+      priorities[i]=IRIS.has(path.id)?5:EYE.has(path.id)?3:1;
+    }
+  }
+  // Binary coverage means mono and colour produce identical Braille masks.
+  const frame=fieldToCells(field,{color:false,quant:false});
+  let irisCells=0, eyeCutoutDots=0, pupilDots=labels.filter(x=>x==='pupil').length, ink=0;
+  for(let y=0;y<rows;y++)for(let x=0;x<cols;x++) {
+    const cell=frame[y][x];cell.bg=null;
+    let winner=-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] && priorities[i]>rank){winner=i;rank=priorities[i];}
+      if(owned.has(y*cols+x)&&!field.v[i])eyeCutoutDots++;
+    }
+    if(winner>=0) {
+      ink++;
+      if(IRIS.has(labels[winner]))irisCells++;
+      cell.rgb=mono?null:Array.from(colours.slice(winner*3,winner*3+3));
+    }
+  }
+  return {frame,metrics:{cols,rows,ink,irisCells,eyeOwnedCells:owned.size,eyeCutoutDots,pupilDots,scale},geometry};
+}
+
+/** Exact emitted Braille masks, not a font screenshot or a source SVG raster. */
+export function cellsSvg(frame, {label='Lucid · actual emitted dots',dot=4}={}) {
+  const cols=frame[0].length,rows=frame.length,width=cols*dot*2+48,height=rows*dot*4+76;
+  const bits=[[1,8],[2,16],[4,32],[64,128]];
+  let body=`<rect width="100%" height="100%" fill="#080d19"/><text x="24" y="27" fill="#a7b6cc" font-family="monospace" font-size="13">${label.replaceAll('&','&amp;').replaceAll('<','&lt;')}</text>`;
+  for(let y=0;y<rows;y++)for(let x=0;x<cols;x++) {
+    const cell=frame[y][x],mask=cell.ch===' '?0:cell.ch.codePointAt(0)-0x2800;
+    const fill=cell.rgb?`rgb(${cell.rgb.join(',')})`:'#d7e1ef';
+    for(let dy=0;dy<4;dy++)for(let dx=0;dx<2;dx++)if(mask&bits[dy][dx])
+      body+=`<circle cx="${24+(x*2+dx+.5)*dot}" cy="${50+(y*4+dy+.5)*dot}" r="${dot*.39}" fill="${fill}"/>`;
+  }
+  return `<svg xmlns="http://www.w3.org/2000/svg" width="${width}" height="${height}" viewBox="0 0 ${width} ${height}">${body}</svg>\n`;
+}

package/vendor/dragonlab/design/lucid/recovery/review.mjs

@@ -0,0 +1,68 @@
+#!/usr/bin/env node
+import {readFile,writeFile,mkdir} from 'node:fs/promises';
+import {resolve} from 'node:path';
+import {parseMaster,renderMaster,cellsSvg} from './render.mjs';
+import {LUCID_CLIPS,renderLucidCharacter,renderLucidStory,STORY_DURATION} from './character.mjs';
+import {artSlot,composeMessage} from './layout.mjs';
+import {cellsToAnsi} from '../../../vendor/quox-dragon/qart.js';
+
+const args=process.argv.slice(2);
+function option(name,fallback){const i=args.indexOf(name);return i<0?fallback:args[i+1];}
+const allowed=new Set(['--cols','--rows','--mono','--export','--verify','--help','--message','--eyes','--terminal-cols','--terminal-rows','--large','--intro','--scene','--at','--watch','--list','--still','--attach']);
+for(let i=0;i<args.length;i++) {
+  if(!allowed.has(args[i]))throw new Error(`Unknown option: ${args[i]}`);
+  if(['--cols','--rows','--export','--message','--eyes','--terminal-cols','--terminal-rows','--scene','--at'].includes(args[i])) {
+    if(!args[i+1]||args[i+1].startsWith('--'))throw new Error(`Missing value for ${args[i]}`);
+    i++;
+  }
+}
+if(args.includes('--help')) {
+  console.log('Lucid full-body SVG review (Node 20+, no install)\n  node design/lucid/recovery/review.mjs [--message "Your message"] [--eyes white|violet] [--mono]\n  --attach        Arrival followed by quiet idle, requires TTY\n  --still         Freeze the whole character at its scene pose\n  --large         Large still for deck review\n  --intro         Large animated story, requires TTY\n  --watch         Companion-sized story, requires TTY\n  --scene ID --at MS  Inspect one expression/power\n  --list          List clips\n  --export DIR   Write exact-cell SVG/JSON/TXT previews at compact and large sizes\n  --verify       Check deterministic masks, safe margins and white default eyes');
+  process.exit(0);
+}
+if(args.includes('--list')){console.log(LUCID_CLIPS.map(c=>c.id.padEnd(16)+c.title).join('\n'));process.exit(0);}
+const source=await readFile(new URL('./lucid-master.svg',import.meta.url),'utf8');
+const paths=parseMaster(source);
+if(args.includes('--verify')) {
+  const {verify}=await import('./verify.mjs');verify(paths);process.exit(0);
+}
+const destination=option('--export',null);
+if(destination) {
+  await mkdir(resolve(destination),{recursive:true});
+  const metrics=[];
+  for(const [cols,rows] of [[28,10],[36,10],[40,12],[48,14],[88,25]])for(const mono of [false,true]) {
+    const result=renderMaster(paths,{cols,rows,mono}),stem=`lucid-${cols}x${rows}-${mono?'mono':'colour'}`;
+    const label=`LUCID / ${cols}x${rows} / ${mono?'MONO':'COLOUR'} / exact emitted Braille dots`;
+    await writeFile(resolve(destination,stem+'.svg'),cellsSvg(result.frame,{label}));
+    await writeFile(resolve(destination,stem+'.json'),JSON.stringify(result,null,2)+'\n');
+    await writeFile(resolve(destination,stem+'.txt'),cellsToAnsi(result.frame).join('\n')+'\n');
+    metrics.push({...result.metrics,mono});
+  }
+  await writeFile(resolve(destination,'metrics.json'),JSON.stringify(metrics,null,2)+'\n');
+  console.log(`Exported actual cells to ${resolve(destination)}`);
+} else {
+  const terminalCols=Number(option('--terminal-cols',process.stdout.columns||80));
+  const terminalRows=Number(option('--terminal-rows',process.stdout.rows||24));
+  const slot=artSlot(terminalCols,terminalRows);
+  const large=args.includes('--large')||args.includes('--intro');
+  const cols=Number(option('--cols',large?Math.min(120,terminalCols-4):slot.cols)),rows=Number(option('--rows',large?Math.min(36,terminalRows-4):slot.rows));
+  const explicit=large||args.includes('--cols')||args.includes('--rows');
+  if(explicit&&(cols>terminalCols-4||rows>terminalRows-2))
+    throw new Error('Requested art exceeds terminal margins. Widen the terminal or reduce --cols/--rows.');
+  const message=option('--message','LUCID\nAware. Attentive. Present.');
+  if(!slot.showArt&&!explicit) {
+    console.log(composeMessage(null,message,{terminalCols}).join('\n'));
+  } else {
+    const opts={cols,rows,mono:args.includes('--mono'),eyes:option('--eyes','white'),still:args.includes('--still')};
+    const scene=option('--scene',args.includes('--attach')?(large?'deck-arrival':'attach'):'idle'),at=Number(option('--at',0));
+    const result=renderLucidCharacter(paths,scene,at,opts);
+    if(!result.ok)throw new Error(result.code);
+    if(args.includes('--watch')||args.includes('--intro')||args.includes('--attach')){
+      const {watch}=await import('./watch.mjs');
+      await watch(paths,opts,{terminalCols,terminalRows,scene:args.includes('--scene')||args.includes('--attach')?scene:null,arrival:args.includes('--attach'),large,message:args.includes('--message')?message:null});
+    }else{
+      const caption=args.includes('--message')?message:'LUCID\n'+result.caption;
+      console.log((large?[...cellsToAnsi(result.frame),caption]:composeMessage(result.frame,caption,{terminalCols})).join('\n'));
+    }
+  }
+}

package/vendor/dragonlab/design/lucid/recovery/verify.mjs

@@ -0,0 +1,84 @@
+import assert from 'node:assert/strict';
+import {artSlot,composeMessage,wrapMessage,cleanText} from './layout.mjs';
+import {LUCID_CLIPS,renderLucidCharacter,renderLucidStory,STORY_DURATION} from './character.mjs';
+import {motionAt,movePoint,MOTION_PERIOD} from './motion.mjs';
+import {renderMaster} from './render.mjs';
+
+export function verify(paths) {
+  for(const [cols,rows] of [[28,10],[36,10],[40,12],[48,14],[88,25]]) {
+    const colour=renderMaster(paths,{cols,rows}),mono=renderMaster(paths,{cols,rows,mono:true});
+    assert.deepEqual(colour,renderMaster(paths,{cols,rows}),'Deterministic render');
+    assert.deepEqual(colour.frame.map(r=>r.map(c=>c.ch)),mono.frame.map(r=>r.map(c=>c.ch)),'Mono must retain geometry');
+    assert(colour.metrics.irisCells>0,'Actual iris must survive rasterisation');
+    assert(colour.metrics.pupilDots>0,'Round pupil survives');
+    assert(colour.metrics.eyeCutoutDots>0,'Eye needs negative space');
+    assert(colour.frame.flat().some(c=>c.rgb&&c.rgb.every(v=>v>=240)),'Emitted white eye foreground');
+    for(let y=0;y<rows;y++)for(let x=0;x<cols;x++) {
+      const c=colour.frame[y][x];
+      assert(c.bg===null,'Transparent terminal background');
+      assert(c.ch===' '||(c.ch.codePointAt(0)>=0x2800&&c.ch.codePointAt(0)<=0x28ff),'Braille only');
+      const mask=c.ch===' '?0:c.ch.codePointAt(0)-0x2800;
+      if(x===0)assert.equal(mask&71,0,'Left dot margin');
+      if(x===cols-1)assert.equal(mask&184,0,'Right dot margin');
+      if(y===0)assert.equal(mask&9,0,'Top dot margin');
+      if(y===rows-1)assert.equal(mask&192,0,'Bottom dot margin');
+    }
+    console.log(`${cols}x${rows}: ${colour.metrics.ink} ink cells; ${colour.metrics.irisCells} iris cells; verified`);
+  }
+  for(const [w,h] of [[64,24],[80,24],[100,30],[120,40],[52,20],[80,18]]) {
+    const slot=artSlot(w,h);
+    assert(slot.cols*slot.rows<w*h/4,'Art allocation below quarter-screen');
+    const frame=slot.showArt?renderMaster(paths,slot).frame:null;
+    const message='Lucid is watching. A change needs your attention. The rest of your terminal stays available.';
+    const lines=composeMessage(frame,message,{terminalCols:w});
+    assert(lines.every(l=>cleanText(l).length<=w),'No line wrapping beyond viewport');
+    if(frame)assert(lines.length===slot.rows,'Short message fits beside dragon');
+    console.log(`Layout ${w}x${h}: ${slot.showArt?slot.cols+'x'+slot.rows:'text fallback'}`);
+  }
+  assert.equal(cleanText('hello\x1b[2Jworld'),'helloworld');
+  assert(wrapMessage('界界界',4).length===2,'Wide characters respect cells');
+  for(const [cols,rows] of [[31,11],[39,11],[49,14],[88,25],[120,36]]){
+    for(const clip of LUCID_CLIPS){
+      const r=renderLucidCharacter(paths,clip.id,clip.duration/2,{cols,rows});
+      assert(r.ok&&r.frame.length===rows&&r.frame.every(row=>row.length===cols));
+      if(clip.power)assert(r.effectCells>0,'Visible power study');
+    }
+  }
+  assert(renderLucidStory(paths,STORY_DURATION).ok);
+  assert(!renderLucidCharacter(paths,'missing',0).ok);
+  console.log(`${LUCID_CLIPS.length} acting clips verified at companion and intro sizes`);
+  assert.deepEqual(motionAt(0),motionAt(MOTION_PERIOD),'Seamless motion loop');
+  for(const t of [0,1200,2400,3200,5200,9000]){
+    const motion=motionAt(t);
+    for(const group of ['body','near-feet','far-feet'])assert.deepEqual(movePoint(group,300,380,motion),[300,380],'Planted torso and feet');
+    assert.deepEqual(movePoint('head',178,177,motion),movePoint('eye',178,177,motion),'Face stays attached');
+    for(const [cols,rows] of [[28,10],[31,11],[39,11],[49,14],[120,36]]){
+      const r=renderMaster(paths,{cols,rows,motion});
+      assert(r.metrics.pupilDots>0,`Pupil survives motion at ${cols}x${rows}, ${t}`);
+      assert.equal(r.metrics.scale,renderMaster(paths,{cols,rows}).metrics.scale,'No camera breathing');
+    }
+  }
+  for(const scene of ['attach','deck-arrival']){
+    const duration=scene==='attach'?3200:4400;
+    for(const [cols,rows] of [[31,11],[49,14],[120,36],[200,72]]){
+      const end=renderLucidCharacter(paths,scene,duration,{cols,rows});
+      assert.deepEqual(end.frame,renderLucidCharacter(paths,'idle',0,{cols,rows}).frame,'Exact idle handoff');
+      for(const t of [0,500,1000,1700,2400,3100]){
+        const r=renderLucidCharacter(paths,scene,t,{cols,rows});
+        assert(r.metrics.pupilDots>0,'Arrival pupil');
+        for(let y=0;y<rows;y++)for(let x=0;x<cols;x++){
+          const mask=r.frame[y][x].ch===' '?0:r.frame[y][x].ch.codePointAt(0)-0x2800;
+          if(x===0)assert.equal(mask&71,0);if(x===cols-1)assert.equal(mask&184,0);
+          if(y===0)assert.equal(mask&9,0);if(y===rows-1)assert.equal(mask&192,0);
+        }
+      }
+    }
+  }
+  for(const c of LUCID_CLIPS)assert.deepEqual(
+    renderLucidCharacter(paths,c.id,0,{still:true}).frame,
+    renderLucidCharacter(paths,c.id,c.duration*.7,{still:true}).frame,'Still freezes '+c.id);
+  assert.deepEqual(renderLucidStory(paths,0,{still:true}).frame,renderLucidStory(paths,11000,{still:true}).frame,'Still story');
+  console.log('Arrival bounds, pupils, idle handoff and complete still mode verified');
+  console.log('Quiet motion: loop, planted feet, attached eye and compact pupils verified');
+  console.log('Technical checks passed. Artistic acceptance remains a human judgment.');
+}

package/vendor/dragonlab/design/lucid/recovery/watch.mjs

@@ -0,0 +1,56 @@
+import {performance} from 'node:perf_hooks';
+import {LUCID_CLIPS,renderLucidCharacter,renderLucidStory,STORY_DURATION} from './character.mjs';
+import {composeMessage} from './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?LUCID_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?renderLucidCharacter(paths,scene,t,options):renderLucidStory(paths,t,options);
+    if(!r?.ok)throw new Error(r?.code??'Invalid story frame');
+    const caption=message??'LUCID · '+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/12);
+    await done;
+  }catch(e){cleanup(e);await done;}
+}