@litfamily/litopencode 1.0.7 → 1.0.9

package/skills/lit-diagram-drawer/scripts/verify-brief.mjs

@@ -0,0 +1,47 @@
+#!/usr/bin/env node
+import fs from 'node:fs';
+import path from 'node:path';
+import { root } from './diagram-metrics.mjs';
+import { checkBrief, readBrief } from './brief-contract.mjs';
+
+const args = process.argv.slice(2);
+function option(name) {
+  const index = args.indexOf(name);
+  return index === -1 ? undefined : args[index + 1];
+}
+
+const briefPath = option('--brief');
+const diagramPath = option('--diagram');
+if (args.includes('--brief') || args.includes('--diagram')) {
+  if (!briefPath || !diagramPath || args.some((arg, index) => ['--brief', '--diagram'].includes(arg) && !args[index + 1])) {
+    console.error('Usage: node scripts/verify-brief.mjs [--brief <brief.md> --diagram <diagram.html>]');
+    process.exit(2);
+  }
+  try {
+    const result = checkBrief(fs.readFileSync(path.resolve(diagramPath), 'utf8'), readBrief(path.resolve(briefPath)));
+    const failed = result.missingNodes?.length || result.missingLabels?.length || result.missingEdges?.length
+      || result.unpairedLabels?.length || result.languageMismatches?.length || result.boundaryMembership?.issues?.length;
+    process.stdout.write(`${JSON.stringify({ mode: 'brief', brief: path.resolve(briefPath), diagram: path.resolve(diagramPath), result }, null, 2)}\n`);
+    if (failed) process.exitCode = 1;
+  } catch (error) {
+    console.error(`BRIEF_VERIFY_ERROR ${error instanceof Error ? error.message : String(error)}`);
+    process.exit(2);
+  }
+} else {
+  const folders = fs.readdirSync(path.join(root, 'examples'), { withFileTypes: true })
+    .filter((entry) => entry.isDirectory()).map((entry) => entry.name).sort();
+  const results = [];
+  for (const folder of folders) {
+    const brief = path.join(root, 'examples', folder, 'brief.md');
+    const after = path.join(root, 'examples', folder, 'after.html');
+    if (!fs.existsSync(brief) || !fs.existsSync(after)) {
+      results.push({ example: folder, missingFiles: [!fs.existsSync(brief) ? 'brief.md' : null, !fs.existsSync(after) ? 'after.html' : null].filter(Boolean) });
+      continue;
+    }
+    results.push({ example: folder, ...checkBrief(fs.readFileSync(after, 'utf8'), readBrief(brief)) });
+  }
+  const failures = results.filter((result) => result.missingFiles || result.missingNodes?.length || result.missingLabels?.length
+    || result.missingEdges?.length || result.unpairedLabels?.length || result.languageMismatches?.length || result.boundaryMembership?.issues?.length);
+  process.stdout.write(`${JSON.stringify({ mode: 'examples', checked: results.length, failures, results }, null, 2)}\n`);
+  if (failures.length) process.exitCode = 1;
+}

package/skills/lit-diagram-drawer/scripts/verify-coverage.mjs

@@ -0,0 +1,56 @@
+#!/usr/bin/env node
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const catalogPath = path.join(root, 'references/type-catalog.json');
+const catalog = JSON.parse(fs.readFileSync(catalogPath, 'utf8'));
+const refs = fs.existsSync(path.join(root, 'references')) ? fs.readdirSync(path.join(root, 'references')) : [];
+const examplesDir = path.join(root, 'assets/examples');
+const exampleFiles = fs.existsSync(examplesDir) ? fs.readdirSync(examplesDir).filter((name) => name.endsWith('.html')) : [];
+const issues = [];
+
+function audit(c, refNames, names) {
+  const problems = [];
+  const ids = c.entries.map((entry) => entry.id);
+  if (c.source?.coreTypeCount !== 41 || c.source?.galleryEntryCount !== 61) problems.push('SOURCE_COUNTS');
+  if (ids.length !== 61) problems.push('ENTRY_COUNT expected=61 actual=' + ids.length);
+  if (new Set(ids).size !== ids.length) problems.push('DUPLICATE_ID');
+  const expected = new Set();
+  const refSet = new Set(refNames);
+  for (const entry of c.entries) {
+    if (!/^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(entry.id)) problems.push('INVALID_ID ' + entry.id);
+    if (entry.reference !== 'type-' + entry.id + '.md') problems.push('BAD_REFERENCE ' + entry.id + ' ' + entry.reference);
+    if (!refSet.has(entry.reference)) problems.push('MISSING_REFERENCE ' + entry.reference);
+    if (JSON.stringify(entry.variants) !== JSON.stringify(['light', 'dark', 'full'])) problems.push('BAD_VARIANTS ' + entry.id);
+    for (const variant of ['light', 'dark', 'full']) expected.add('type-' + entry.id + '-' + variant + '.html');
+  }
+  const actual = new Set(names);
+  for (const name of expected) if (!actual.has(name)) problems.push('MISSING_EXAMPLE ' + name);
+  for (const name of actual) if (!expected.has(name)) problems.push('ORPHAN_EXAMPLE ' + name);
+  if (expected.size !== 183) problems.push('EXPECTED_VARIANT_COUNT ' + expected.size);
+  return problems;
+}
+issues.push(...audit(catalog, refs, exampleFiles));
+if (process.argv.includes('--self-test')) {
+  const clone = JSON.parse(JSON.stringify(catalog));
+  const good = audit(clone, refs, exampleFiles);
+  const duplicate = JSON.parse(JSON.stringify(clone));
+  duplicate.entries[1].id = duplicate.entries[0].id;
+  const duplicateResult = audit(duplicate, refs, exampleFiles);
+  const missing = audit(clone, refs, exampleFiles.filter((name) => name !== 'type-architecture-light.html'));
+  const orphan = audit(clone, refs, [...exampleFiles, 'type-orphan-light.html']);
+  if (good.length || !duplicateResult.some((x) => x.startsWith('DUPLICATE_ID')) || !missing.some((x) => x.startsWith('MISSING_EXAMPLE')) || !orphan.some((x) => x.startsWith('ORPHAN_EXAMPLE'))) {
+    console.error('SELF_TEST_FAIL', { good, duplicateResult, missing, orphan });
+    process.exit(1);
+  }
+  console.log('SELF_TEST_PASS duplicate, missing, and orphan cases fail as expected');
+}
+if (issues.length) {
+  console.error('COVERAGE_FAIL');
+  for (const issue of issues) console.error('- ' + issue);
+  process.exitCode = 1;
+} else {
+  console.log('COVERAGE_PASS core=41 gallery=61 variants=183 references=61');
+}

package/skills/lit-diagram-drawer/scripts/verify-diagram.mjs

@@ -0,0 +1,26 @@
+#!/usr/bin/env node
+import { analyzeFile } from './diagram-metrics.mjs';
+import { visualQuality } from './visual-quality.mjs';
+import { readFileSync } from 'node:fs';
+
+const file=process.argv.slice(2).find((x)=>!x.startsWith('--'));
+if(!file){console.error('Usage: node scripts/verify-diagram.mjs <file.html|file.svg>');process.exit(2);}
+let result;
+try{result=analyzeFile(file);}catch(e){console.error('VERIFY_ERROR '+e.message);process.exit(2);}
+const failures=[];
+if(!result.hasSvg) failures.push('SVG_MISSING');
+if(!result.viewBox||result.viewBox.w<=0||result.viewBox.h<=0) failures.push('VIEWBOX_INVALID');
+if(!result.title||!result.desc||!result.roleImage||!result.ariaLinked) failures.push('A11Y_TITLE_DESC_ROLE_LINK');
+if(result.textCount===0) failures.push('TEXT_MISSING');
+if(result.offCanvas) failures.push('OFF_CANVAS '+result.offCanvas);
+if(result.textOverlaps) failures.push('TEXT_OVERLAP '+result.textOverlaps);
+if(result.objectOverlaps) failures.push('SHAPE_OVERLAP '+result.objectOverlaps);
+if(result.contrastFailures.length) failures.push('CONTRAST '+result.contrastFailures.length);
+if(result.humanizer.summary?.block) failures.push('HUMANIZER_BLOCK '+result.humanizer.summary.block);
+if(result.humanizer.errors?.length) failures.push('HUMANIZER_ERROR');
+if(!result.fontFamilyPresent||!result.localFont||!result.fontFileValid) failures.push('PRETENDARD_FONT_NOT_LOADED_FROM_LOCAL_ASSET');
+if(/<script\b|\bon[a-z]+\s*=|https?:\/\//i.test(result.visibleText)) failures.push('UNSAFE_VISIBLE_TEXT');
+const craft = visualQuality(readFileSync(file, 'utf8'));
+for (const issue of craft.issues.filter((item) => /^(?:CLUSTER_GAP_RATIO|ACCENT_COUNT|LABEL_OVERFLOW)\b/u.test(item))) failures.push(issue);
+if(failures.length){console.error('DIAGRAM_FAIL '+file);for(const f of failures)console.error('- '+f);process.exitCode=1;}
+else console.log('DIAGRAM_PASS '+file+' text='+result.textCount+' overlap=0 contrast=pass humanizer-block=0'+(craft.advisories.length?' advisories='+craft.advisories.join(' | '):''));

package/skills/lit-diagram-drawer/scripts/verify-motion.mjs

@@ -0,0 +1,12 @@
+#!/usr/bin/env node
+import fs from 'node:fs';
+const file=process.argv.slice(2).find((x)=>!x.startsWith('--'));
+if(!file){console.error('Usage: node scripts/verify-motion.mjs <file.html|file.svg>');process.exit(2);}
+const source=fs.readFileSync(file,'utf8');
+const issues=[];
+if(/<animate\b|<set\b/i.test(source)) issues.push('SVG_ANIMATION_NOT_STATIC');
+if(/animation\s*:\s*(?!none\b)[^;}]+/i.test(source)&&!/@media\s*\(prefers-reduced-motion\s*:\s*reduce\)[\s\S]*?animation\s*:\s*none/i.test(source)) issues.push('REDUCED_MOTION_RULE_MISSING');
+if(/autoplay|infinite/i.test(source)) issues.push('UNBOUNDED_MOTION');
+if(/<script\b/i.test(source)&&!/(prefers-reduced-motion|matchMedia)/i.test(source)) issues.push('MOTION_CONTROLLER_REDUCED_MOTION_MISSING');
+if(issues.length){console.error('MOTION_FAIL '+file);for(const issue of issues)console.error('- '+issue);process.exitCode=1;}
+else console.log('MOTION_PASS '+file+' static-first=reduced-motion-ready');

package/skills/lit-diagram-drawer/scripts/verify-type.mjs

@@ -0,0 +1,48 @@
+#!/usr/bin/env node
+import fs from 'node:fs';
+import path from 'node:path';
+import { analyzeFile, root } from './diagram-metrics.mjs';
+import { buildBlockRegistry } from './block-registry.mjs';
+import { sequenceQuality } from './visual-quality.mjs';
+
+const args=process.argv.slice(2);
+const typeArg=args.find((x)=>x.startsWith('--type='));
+const type=typeArg?.slice('--type='.length);
+const file=args.find((x)=>!x.startsWith('--'));
+if(!type||!file){console.error('Usage: node scripts/verify-type.mjs --type=<catalog-id> <file.html|file.svg>');process.exit(2);}
+const catalog=JSON.parse(fs.readFileSync(path.join(root,'references/type-catalog.json'),'utf8'));
+const entry=catalog.entries.find((x)=>x.id===type);
+if(!entry){console.error('TYPE_UNKNOWN '+type);process.exit(2);}
+const source=fs.readFileSync(file,'utf8');
+const result=analyzeFile(file);
+const issues=[];
+if(!source.includes('data-type="'+type+'"')&&!source.includes('id="diagram-'+type+'-')) issues.push('TYPE_ID_MISMATCH');
+if(!fs.existsSync(path.join(root,'references',entry.reference))) issues.push('TYPE_GUIDE_MISSING');
+if(!/data-variant\s*=\s*["'](?:light|dark|full)["']/i.test(source)&&!/id="diagram-[a-z0-9-]+-(?:light|dark|full)"/i.test(source)) issues.push('VARIANT_MISSING');
+if(entry.family==='quantitative'&&result.textCount<3) issues.push('QUANTITATIVE_LABELS_MISSING');
+if(type==='heatmap'&&(source.match(/<rect\b/gi)||[]).length<16) issues.push('HEATMAP_GRID_TOO_SMALL');
+if(type==='treemap'&&(source.match(/<rect\b/gi)||[]).length<6) issues.push('TREEMAP_TILES_TOO_FEW');
+if(type==='sankey'&&!/<path\b[^>]*stroke-width\s*=\s*["'][1-9]/i.test(source)) issues.push('SANKEY_RIBBON_WIDTH_MISSING');
+if(type==='waterfall'&&(source.match(/<rect\b/gi)||[]).length<5) issues.push('WATERFALL_STEPS_TOO_FEW');
+if(type==='beeswarm'&&(source.match(/<circle\b/gi)||[]).length<20) issues.push('BEESWARM_MARKS_TOO_FEW');
+if(type==='bubble'&&(source.match(/<circle\b/gi)||[]).length<6) issues.push('BUBBLE_MARKS_TOO_FEW');
+if(type==='polar'&&!/<polygon\b/i.test(source)) issues.push('POLAR_SHAPE_MISSING');
+if(type==='radar'&&!/<polygon\b/i.test(source)) issues.push('RADAR_SHAPE_MISSING');
+if(type==='sequence'||type==='sequence-oauth')issues.push(...sequenceQuality(source).map((issue)=>'SEQUENCE '+issue));
+if(type==='tree-block-decomposition'){
+  try{
+    const svg=source.match(/<svg\b[^>]*>[\s\S]*?<\/svg>/i)?.[0]||'';
+    const registry=buildBlockRegistry(svg,path.basename(file));
+    const visible=[...svg.matchAll(/<text\b[^>]*>([\s\S]*?)<\/text>/gi)].map((match)=>match[1].replace(/<[^>]*>/g,'').trim());
+    for(const block of registry.blocks){
+      for(const field of ['name','input','output','constraint','assumption','impl']) if(!block[field])issues.push('BLOCK_FIELD_MISSING '+block.id+'.'+field);
+      if(!visible.includes(block.id))issues.push('BLOCK_BADGE_MISSING '+block.id);
+      if(block.name&&!visible.includes(block.name))issues.push('BLOCK_NAME_MISSING '+block.id);
+    }
+  }catch(error){issues.push('BLOCK_REGISTRY_INVALID '+error.message);}
+}
+if(type==='policy-trace-animated'&&!/(rule|policy|allow|deny)/i.test(source)) issues.push('POLICY_TRACE_SEMANTIC_MISSING');
+if(type==='queue-animated'&&!/(queue|buffer|drain|fan-in)/i.test(source)) issues.push('QUEUE_SEMANTIC_MISSING');
+if(type==='paved-road-animated'&&!/(boundary|guardrail|secure|policy)/i.test(source)) issues.push('PAVED_ROAD_SEMANTIC_MISSING');
+if(issues.length){console.error('TYPE_FAIL '+type+' '+file);for(const issue of issues)console.error('- '+issue);process.exitCode=1;}
+else console.log('TYPE_PASS '+type+' family='+entry.family);

package/skills/lit-diagram-drawer/scripts/visual-quality.mjs

@@ -0,0 +1,363 @@
+import { sourceMetrics } from './diagram-metrics.mjs';
+import { readFileSync } from 'node:fs';
+
+const craft = JSON.parse(readFileSync(new URL('./craft-thresholds.json', import.meta.url), 'utf8'));
+
+const MAX_EDGE_LABEL_ANCHOR_DISTANCE=24;
+const BOUNDARY_EDGE_PADDING=4;
+const BOUNDARY_EDGE_MIN_OVERLAP=12;
+const ARROWHEAD_CANVAS_FLOOR=12/1080;
+const ARROWHEAD_STROKE_MULTIPLE=5;
+const ARROWHEAD_TARGET_TOLERANCE=2;
+
+const decode=(s)=>s.replaceAll('&amp;','&').replaceAll('&lt;','<').replaceAll('&gt;','>').replaceAll('&quot;','"').replaceAll('&apos;',"'").replaceAll('&#39;',"'");
+const attributes=(s)=>Object.fromEntries([...s.matchAll(/([\w:-]+)\s*=\s*(?:"([^"]*)"|'([^']*)')/g)].map((m)=>[m[1],decode(m[2]??m[3]??'')]));
+const clean=(s)=>decode(s.replace(/<[^>]*>/g,' ').replace(/\s+/g,' ').trim());
+const widthOf=(text,size)=>[...text].reduce((n,c)=>n+(/\s/.test(c)?.28:/[\u1100-\u11ff\u3130-\u318f\uac00-\ud7af]/.test(c)?.98:/[ilI.,:;!|]/.test(c)?.32:/[MW@#%]/.test(c)?.82:.56),0)*size;
+const contamination=[
+  /\blitfamily\b/i, /\b(?:generator|generated by|template|prototype)\b/i,
+  /\bsource\s*:/i, /\bnotes?\s*:/i, /\bstatic\s+first\b/i,
+  /\baccessible\s+labels\b/i, /\bone\s+accent\b/i, /\bfocal\b/i,
+  /\b(?:light|dark|full)\s*[·|/]\s*static\b/i, /\bdesign\s+rules?\b/i,
+  /^\s*show\b/i,
+];
+
+function visibleSvgText(svg){
+  return [...svg.matchAll(/<text\b([^>]*)>([\s\S]*?)<\/text>/gi)].map((m)=>{
+    const a=attributes(m[1]),label=clean(m[2]),size=Number(a['font-size']||16),textAnchor=a['text-anchor']||'start',anchor={x:Number(a.x||0),y:Number(a.y||0)},w=widthOf(label,size),x=anchor.x-(textAnchor==='middle'?w/2:textAnchor==='end'?w:0),y=anchor.y-size*.82;
+    return {label,size,role:a['data-role']||'',anchor,nodeFor:a['data-node-for']||a['data-node-id']||'',edgeFor:a['data-edge-for']||'',boundaryFor:a['data-boundary-for']||a['data-group-for']||'',x,y,w,h:size*1.22};
+  }).filter((t)=>t.label);
+}
+function svgContent(source){return [...source.matchAll(/<svg\b[^>]*>[\s\S]*?<\/svg>/gi)].map((m)=>m[0]).join('\n');}
+function parseRoutes(svg){
+  const routes=[];
+  for(const m of svg.matchAll(/<(line|path)\b([^>]*)>/gi)){
+    const a=attributes(m[2]); if(!a['data-from']||!a['data-to'])continue;
+    let segments=[];
+    if(m[1].toLowerCase()==='line'){
+      const v=['x1','y1','x2','y2'].map((k)=>Number(a[k])); if(v.every(Number.isFinite))segments=[[v[0],v[1],v[2],v[3]]];
+    }else if(a.d){
+      const parts=a.d.match(/[a-zA-Z]|[-+]?(?:\d*\.\d+|\d+\.?\d*)(?:e[-+]?\d+)?/gi)||[];let i=0,cmd='',x=0,y=0,px=0,py=0;
+      while(i<parts.length){if(/^[a-z]$/i.test(parts[i]))cmd=parts[i++];if(!cmd)break;const rel=cmd===cmd.toLowerCase(),up=cmd.toUpperCase();
+        if(up==='M'||up==='L'){if(i+1>=parts.length||/^[a-z]$/i.test(parts[i])){cmd='';continue;}const nx=Number(parts[i++])+(rel?x:0),ny=Number(parts[i++])+(rel?y:0);if(up==='L')segments.push([x,y,nx,ny]);x=nx;y=ny;}
+        else if(up==='H'){if(i>=parts.length||/^[a-z]$/i.test(parts[i])){cmd='';continue;}const nx=Number(parts[i++])+(rel?x:0);segments.push([x,y,nx,y]);x=nx;}
+        else if(up==='V'){if(i>=parts.length||/^[a-z]$/i.test(parts[i])){cmd='';continue;}const ny=Number(parts[i++])+(rel?y:0);segments.push([x,y,x,ny]);y=ny;}
+        else if(up==='C'){if(i+5>=parts.length||/^[a-z]$/i.test(parts[i])){cmd='';continue;}const p=(n)=>[Number(parts[n])+(rel?x:0),Number(parts[n+1])+(rel?y:0)],start=[x,y],c1=p(i),c2=p(i+2),end=p(i+4);i+=6;let previous=start;for(let step=1;step<=16;step++){const t=step/16,u=1-t,next=[u*u*u*start[0]+3*u*u*t*c1[0]+3*u*t*t*c2[0]+t*t*t*end[0],u*u*u*start[1]+3*u*u*t*c1[1]+3*u*t*t*c2[1]+t*t*t*end[1]];segments.push([previous[0],previous[1],next[0],next[1]]);previous=next;}x=end[0];y=end[1];}
+        else {cmd='';while(i<parts.length&&!/^[a-z]$/i.test(parts[i]))i++;}
+      }
+    }
+    if(segments.length)routes.push({from:a['data-from'],to:a['data-to'],label:a['data-label']||'',segments,markerStart:a['marker-start']||'',markerEnd:a['marker-end']||'',strokeWidth:Number(a['stroke-width']||1)});
+  }
+  return routes;
+}
+function rectangles(svg){
+  const nodes=[];
+  for(const m of svg.matchAll(/<rect\b([^>]*)\/?\s*>/gi)){
+    const a=attributes(m[1]);if(!a['data-node-id'])continue;
+    const box={id:a['data-node-id'],type:a['data-node-type']||'',fill:a.fill||'',outcomes:(a['data-outcomes']||'').split('|').map((value)=>value.trim()).filter(Boolean),x:Number(a.x||0),y:Number(a.y||0),w:Number(a.width||0),h:Number(a.height||0)};
+    if(box.w>0&&box.h>0)nodes.push(box);
+  }
+  return nodes;
+}
+function segmentHitsBox(s,b,pad=0){
+  const [x1,y1,x2,y2]=s,loX=Math.min(x1,x2),hiX=Math.max(x1,x2),loY=Math.min(y1,y2),hiY=Math.max(y1,y2),left=b.x-pad,right=b.x+b.w+pad,top=b.y-pad,bottom=b.y+b.h+pad;
+  if(x1===x2)return x1>=left&&x1<=right&&hiY>=top&&loY<=bottom;
+  if(y1===y2)return y1>=top&&y1<=bottom&&hiX>=left&&loX<=right;
+  const steps=24;for(let i=0;i<=steps;i++){const t=i/steps,x=x1+(x2-x1)*t,y=y1+(y2-y1)*t;if(x>=left&&x<=right&&y>=top&&y<=bottom)return true;}return false;
+}
+function segmentHitsText(s,t,pad=1){
+  const b={x:t.x-pad,y:t.y-pad,w:t.w+pad*2,h:t.h+pad*2};return segmentHitsBox(s,b,0);
+}
+function textOverlapsNode(text,node,pad=1){return text.x<node.x+node.w+pad&&text.x+text.w>node.x-pad&&text.y<node.y+node.h+pad&&text.y+text.h>node.y-pad;}
+function gap(a,b){const dx=Math.max(0,a.x-(b.x+b.w),b.x-(a.x+a.w)),dy=Math.max(0,a.y-(b.y+b.h),b.y-(a.y+a.h));return Math.hypot(dx,dy);}
+
+function accentHue(value){
+  const hex=value.match(/^#([0-9a-f]{6}|[0-9a-f]{3})$/i);if(!hex)return null;
+  const raw=hex[1].length===3?[...hex[1]].map((digit)=>digit+digit).join(''):hex[1];
+  const [r,g,b]=[0,2,4].map((index)=>parseInt(raw.slice(index,index+2),16)/255),hi=Math.max(r,g,b),lo=Math.min(r,g,b),d=hi-lo,l=(hi+lo)/2,s=d/(1-Math.abs(2*l-1))||0;
+  if(s<craft.accentSaturationMin||l<craft.accentLightnessMin||l>craft.accentLightnessMax)return null;
+  const h=d===0?0:hi===r?((g-b)/d)%6:hi===g?(b-r)/d+2:(r-g)/d+4;
+  return (h*60+360)%360;
+}
+
+function officeCraft(texts,nodes,outlines,view){
+  const issues=[],advisories=[];
+  if(outlines.length>=2){
+    const membership=(node)=>outlines.filter((outline)=>node.x+node.w/2>=outline.x&&node.x+node.w/2<=outline.x+outline.w&&node.y+node.h/2>=outline.y&&node.y+node.h/2<=outline.y+outline.h).sort((a,b)=>a.w*a.h-b.w*b.h)[0]?.id||'<outside>';
+    const inside=[],outside=[];
+    for(let i=0;i<nodes.length;i++)for(let j=i+1;j<nodes.length;j++)(membership(nodes[i])===membership(nodes[j])?inside:outside).push(gap(nodes[i],nodes[j]));
+    if(inside.length&&outside.length){const intra=Math.max(...inside),inter=Math.min(...outside);if(intra>0&&inter<craft.groupRatioMin*intra)issues.push('CLUSTER_GAP_RATIO OF-201 '+(inter/intra).toFixed(2)+' minimum='+craft.groupRatioMin);}
+  }
+  const hues=[];
+  for(const node of nodes){
+    if(view&&node.w*node.h>=craft.fullBleedFraction*view.w*view.h)continue;
+    const hue=accentHue(node.fill);if(hue!==null&&!hues.some((other)=>Math.min(Math.abs(hue-other),360-Math.abs(hue-other))<=craft.accentHueBucketDegrees))hues.push(hue);
+  }
+  if(hues.length>=craft.accentHigh)issues.push('ACCENT_COUNT OF-202 '+hues.length+' maximum='+(craft.accentHigh-1));
+  else if(hues.length>=craft.accentMedium)advisories.push('ACCENT_COUNT OF-202 '+hues.length+' preferred<'+craft.accentMedium);
+  for(const text of texts){
+    const label=text.label,latin=[...label].filter((char)=>/[A-Za-z0-9]/.test(char)).length/Math.max(1,[...label].filter((char)=>!(/\s/.test(char))).length);
+    if(latin>=craft.latinFractionMin&&label!==label.toUpperCase()){
+      const words=label.match(/[A-Za-z]+/g)||[],long=words.filter((word)=>word.length>=craft.titleWordMinLetters),capped=long.filter((word)=>/^[A-Z][a-z]+$/.test(word));
+      if(capped.length>=craft.titleWordMinCount&&capped.length/Math.max(1,long.length)>craft.titleWordFractionMin&&/\b(?:Of|And|The|To|For|In)\b/.test(label))advisories.push('LABEL_CASE OF-203 '+label);
+    }
+    const target=text.nodeFor?nodes.find((node)=>node.id===text.nodeFor):text.boundaryFor?outlines.find((outline)=>outline.id===text.boundaryFor||outline.labels.includes(text.boundaryFor)):null;
+    if(target&&text.w>target.w-2*craft.labelInsetPx)issues.push('LABEL_OVERFLOW OF-204 '+label+' width='+text.w.toFixed(1)+'px available='+(target.w-2*craft.labelInsetPx).toFixed(1)+'px');
+  }
+  return {issues,advisories};
+}
+
+function boundaryOutlines(svg){
+  const outlines=[];
+  const add=(a)=>{
+    const markers=['data-trust-boundary','data-boundary','data-boundary-name','data-group-boundary','data-group-name','data-group-label','data-group-id'];
+    const classMarker=/\b(?:boundary|group)(?:[-_][\w-]+)?\b/i.test(a.class||'');
+    if(!markers.some((key)=>Object.hasOwn(a,key))&&!classMarker)return;
+    const labels=[a['data-trust-boundary'],a['data-boundary-name'],a['data-group-boundary'],a['data-group-name'],a['data-group-label']].filter((value)=>value&&value!=='true');
+    const x=Number(a.x||0),y=Number(a.y||0),w=Number(a.width||0),h=Number(a.height||0);
+    if(w>0&&h>0)outlines.push({id:a['data-group-id']||a.id||labels[0]||'outline',labels,x,y,w,h,strokeWidth:Number(a['stroke-width']||1)});
+  };
+  for(const match of svg.matchAll(/<rect\b([^>]*)\/?\s*>/gi))add(attributes(match[1]));
+  for(const match of svg.matchAll(/<g\b([^>]*)>([\s\S]*?)<\/g>/gi)){
+    const group=attributes(match[1]);
+    if(!['data-trust-boundary','data-boundary','data-boundary-name','data-group-boundary','data-group-name','data-group-label','data-group-id'].some((key)=>Object.hasOwn(group,key)))continue;
+    const rect=match[2].match(/<rect\b([^>]*)\/?\s*>/i);
+    if(rect)add({...attributes(rect[1]),...group});
+  }
+  return outlines;
+}
+
+function pointSegmentDistance(point,segment){
+  const [x1,y1,x2,y2]=segment,dx=x2-x1,dy=y2-y1,length=dx*dx+dy*dy;
+  const t=length?Math.max(0,Math.min(1,((point.x-x1)*dx+(point.y-y1)*dy)/length)):0;
+  return Math.hypot(point.x-(x1+t*dx),point.y-(y1+t*dy));
+}
+function routeDistance(point,route){return Math.min(...route.segments.map((segment)=>pointSegmentDistance(point,segment)));}
+function isBoundaryLabel(text,outlines){return text.role==='boundary'||text.boundaryFor||outlines.some((outline)=>outline.labels.includes(text.label)||outline.id===text.boundaryFor);}
+function outlineEdges(outline){return [[outline.x,outline.y,outline.x+outline.w,outline.y],[outline.x+outline.w,outline.y,outline.x+outline.w,outline.y+outline.h],[outline.x+outline.w,outline.y+outline.h,outline.x,outline.y+outline.h],[outline.x,outline.y+outline.h,outline.x,outline.y]];}
+function textHitsOutline(text,outline){return outlineEdges(outline).some((edge)=>segmentHitsText(edge,text,outline.strokeWidth/2+.5));}
+function segmentAlongOutline(segment,outline){
+  const [x1,y1,x2,y2]=segment,loX=Math.min(x1,x2),hiX=Math.max(x1,x2),loY=Math.min(y1,y2),hiY=Math.max(y1,y2),right=outline.x+outline.w,bottom=outline.y+outline.h;
+  if(Math.abs(y1-y2)<=1){const overlap=Math.min(hiX,right)-Math.max(loX,outline.x);return overlap>BOUNDARY_EDGE_MIN_OVERLAP&&(Math.abs(y1-outline.y)<=BOUNDARY_EDGE_PADDING||Math.abs(y1-bottom)<=BOUNDARY_EDGE_PADDING);}
+  if(Math.abs(x1-x2)<=1){const overlap=Math.min(hiY,bottom)-Math.max(loY,outline.y);return overlap>BOUNDARY_EDGE_MIN_OVERLAP&&(Math.abs(x1-outline.x)<=BOUNDARY_EDGE_PADDING||Math.abs(x1-right)<=BOUNDARY_EDGE_PADDING);}
+  return false;
+}
+function markerPathPoints(d){
+  const parts=d.match(/[a-zA-Z]|[-+]?(?:\d*\.\d+|\d+\.?\d*)(?:e[-+]?\d+)?/gi)||[],points=[];let i=0,cmd='',x=0,y=0;
+  while(i<parts.length){if(/^[a-z]$/i.test(parts[i]))cmd=parts[i++];if(!cmd)break;const upper=cmd.toUpperCase(),relative=cmd===cmd.toLowerCase();
+    if(upper==='M'||upper==='L'){if(i+1>=parts.length||/^[a-z]$/i.test(parts[i]))break;let nx=Number(parts[i++]),ny=Number(parts[i++]);if(relative){nx+=x;ny+=y;}x=nx;y=ny;points.push([x,y]);}
+    else if(upper==='H'){if(i>=parts.length||/^[a-z]$/i.test(parts[i]))break;x=Number(parts[i++])+(relative?x:0);points.push([x,y]);}
+    else if(upper==='V'){if(i>=parts.length||/^[a-z]$/i.test(parts[i]))break;y=Number(parts[i++])+(relative?y:0);points.push([x,y]);}
+    else if(upper==='Z')cmd='';
+    else {while(i<parts.length&&!/^[a-z]$/i.test(parts[i]))i++;cmd='';}
+  }
+  return points;
+}
+function markerDefinitions(svg){
+  const markers=new Map();
+  for(const match of svg.matchAll(/<marker\b([^>]*)>([\s\S]*?)<\/marker>/gi)){
+    const a=attributes(match[1]),id=a.id;if(!id)continue;
+    const points=[];
+    for(const shape of match[2].matchAll(/<(path|polygon)\b([^>]*)>/gi)){
+      const attrsForShape=attributes(shape[2]);
+      if(shape[1].toLowerCase()==='polygon'){
+        const values=(attrsForShape.points||'').match(/[-+]?(?:\d*\.\d+|\d+\.?\d*)(?:e[-+]?\d+)?/gi)||[];
+        for(let i=0;i+1<values.length;i+=2)points.push([Number(values[i]),Number(values[i+1])]);
+      }else if(attrsForShape.d){
+        points.push(...markerPathPoints(attrsForShape.d));
+      }
+    }
+    markers.set(id,{refX:Number(a.refX||0),refY:Number(a.refY||0),units:a.markerUnits||'strokeWidth',width:Number(a.markerWidth||0),height:Number(a.markerHeight||0),points,closed:/\bz\b/i.test(match[2])||/<polygon\b/i.test(match[2])});
+  }
+  return markers;
+}
+function markerOverlapsTarget(route,target,markers){
+  const match=route.markerEnd.match(/url\(\s*["']?#([^\s)'"`]+)["']?\s*\)/i),marker=match&&markers.get(match[1]),segment=route.segments.at(-1);
+  if(!segment)return false;
+  const [x1,y1,x2,y2]=segment,length=Math.hypot(x2-x1,y2-y1)||1,ux=(x2-x1)/length,uy=(y2-y1)/length,nx=-uy,ny=ux;
+  if(!marker?.points.length){const reach=route.strokeWidth;return segmentHitsBox([x2+ux*reach,y2+uy*reach,x2+ux*reach,y2+uy*reach],target,-1);}
+  const scale=marker.units==='userSpaceOnUse'?1:route.strokeWidth;
+  const points=marker.points.map(([x,y])=>[x2+ux*(x-marker.refX)*scale+nx*(y-marker.refY)*scale,y2+uy*(x-marker.refX)*scale+ny*(y-marker.refY)*scale]);
+  if(points.some(([x,y])=>x>target.x+1&&x<target.x+target.w-1&&y>target.y+1&&y<target.y+target.h-1))return true;
+  const segments=points.slice(1).map((point,index)=>[points[index][0],points[index][1],point[0],point[1]]);
+  if(marker.closed&&points.length>2)segments.push([points.at(-1)[0],points.at(-1)[1],points[0][0],points[0][1]]);
+  return segments.some((line)=>segmentHitsBox(line,target,-1));
+}
+function markerFor(route,edge,markers){
+  const value=edge==='end'?route.markerEnd:route.markerStart,match=value.match(/url\(\s*["']?#([^\s)'"`]+)["']?\s*\)/i);
+  return match?markers.get(match[1]):null;
+}
+function markerScale(marker,route){return marker.units==='userSpaceOnUse'?1:route.strokeWidth;}
+function markerHeadLength(marker){
+  if(!marker?.points.length)return 0;
+  const xs=marker.points.map(([x])=>x);
+  return Math.max(...xs)-Math.min(...xs);
+}
+function markerTip(route,marker,edge){
+  const segment=edge==='end'?route.segments.at(-1):route.segments[0];
+  if(!segment)return null;
+  const [x1,y1,x2,y2]=segment,dx=x2-x1,dy=y2-y1,length=Math.hypot(dx,dy)||1,ux=dx/length,uy=dy/length;
+  const anchor=edge==='end'?[x2,y2]:[x1,y1],direction=edge==='end'?1:-1;
+  const forward=marker?.points.length?Math.max(...marker.points.map(([x])=>direction*(x-marker.refX)))*markerScale(marker,route):0;
+  return [anchor[0]+direction*ux*forward,anchor[1]+direction*uy*forward];
+}
+function distanceToBoxBoundary(point,box){
+  const [x,y]=point,candidates=[];
+  if(y>=box.y-ARROWHEAD_TARGET_TOLERANCE&&y<=box.y+box.h+ARROWHEAD_TARGET_TOLERANCE)candidates.push(Math.abs(x-box.x),Math.abs(x-(box.x+box.w)));
+  if(x>=box.x-ARROWHEAD_TARGET_TOLERANCE&&x<=box.x+box.w+ARROWHEAD_TARGET_TOLERANCE)candidates.push(Math.abs(y-box.y),Math.abs(y-(box.y+box.h)));
+  if(candidates.length)return Math.min(...candidates);
+  return Math.hypot(Math.max(box.x-x,0,x-(box.x+box.w)),Math.max(box.y-y,0,y-(box.y+box.h)));
+}
+function decisionBranchQuality(nodes,routes){
+  const issues=[];
+  for(const node of nodes.filter((item)=>item.type==='decision')){
+    if(node.outcomes.length<2){issues.push('DECISION_OUTCOMES_MISSING '+node.id+' must name at least two outcomes');continue;}
+    const labels=new Set(routes.filter((route)=>route.from===node.id).map((route)=>route.label).filter(Boolean));
+    for(const outcome of node.outcomes)if(!labels.has(outcome))issues.push('DECISION_OUTCOME_MISSING '+node.id+' '+outcome);
+    for(const label of labels)if(!node.outcomes.includes(label))issues.push('DECISION_OUTCOME_UNDECLARED '+node.id+' '+label);
+  }
+  return issues;
+}
+
+function routeLength(route){return route.segments.reduce((sum,[x1,y1,x2,y2])=>sum+Math.hypot(x2-x1,y2-y1),0);}
+function routeBends(route){
+  const directions=route.segments.map(([x1,y1,x2,y2])=>{const dx=x2-x1,dy=y2-y1,length=Math.hypot(dx,dy);return length?{x:dx/length,y:dy/length}:null;}).filter(Boolean);
+  let bends=0;
+  for(let i=1;i<directions.length;i++)if(directions[i-1].x*directions[i].x+directions[i-1].y*directions[i].y<Math.SQRT1_2)bends++;
+  return bends;
+}
+function routeManhattanDistance(route){
+  const start=route.segments[0]?.slice(0,2),end=route.segments.at(-1)?.slice(2,4);
+  return start&&end?Math.abs(start[0]-end[0])+Math.abs(start[1]-end[1])||null:null;
+}
+function alignedRouteKind(route,nodes){
+  const from=nodes.find((node)=>node.id===route.from),to=nodes.find((node)=>node.id===route.to);
+  if(!from||!to)return null;
+  const sameRow=Math.abs(from.y+from.h/2-(to.y+to.h/2))<=1,sameColumn=Math.abs(from.x+from.w/2-(to.x+to.w/2))<=1;
+  const horizontal=route.segments.every(([x1,y1,x2,y2])=>Math.abs(y1-y2)<=1),vertical=route.segments.every(([x1,y1,x2,y2])=>Math.abs(x1-x2)<=1);
+  if(sameRow&&nodes.every((node)=>node===from||node===to||Math.abs(node.y+node.h/2-(from.y+from.h/2))>1||node.x+node.w/2<=Math.min(from.x+from.w/2,to.x+to.w/2)||node.x+node.w/2>=Math.max(from.x+from.w/2,to.x+to.w/2))&&!horizontal)return 'same-row';
+  if(sameColumn&&nodes.every((node)=>node===from||node===to||Math.abs(node.x+node.w/2-(from.x+from.w/2))>1||node.y+node.h/2<=Math.min(from.y+from.h/2,to.y+to.h/2)||node.y+node.h/2>=Math.max(from.y+from.h/2,to.y+to.h/2))&&!vertical)return 'same-column';
+  return null;
+}
+function routeCrossesBoundary(route,outline){
+  const points=route.segments.flatMap(([x1,y1,x2,y2])=>[[x1,y1],[x2,y2],[(x1+x2)/2,(y1+y2)/2]]);
+  const inside=points.some(([x,y])=>x>outline.x&&x<outline.x+outline.w&&y>outline.y&&y<outline.y+outline.h);
+  const outside=points.some(([x,y])=>x<outline.x||x>outline.x+outline.w||y<outline.y||y>outline.y+outline.h);
+  return inside&&outside;
+}
+function collinearOverlap(a,b){
+  for(const [ax1,ay1,ax2,ay2] of a.segments)for(const [bx1,by1,bx2,by2] of b.segments){
+    if(Math.abs(ay1-ay2)<=.5&&Math.abs(by1-by2)<=.5&&Math.abs(ay1-by1)<12){if(Math.min(Math.max(ax1,ax2),Math.max(bx1,bx2))-Math.max(Math.min(ax1,ax2),Math.min(bx1,bx2))>=12)return true;}
+    if(Math.abs(ax1-ax2)<=.5&&Math.abs(bx1-bx2)<=.5&&Math.abs(ax1-bx1)<12){if(Math.min(Math.max(ay1,ay2),Math.max(by1,by2))-Math.max(Math.min(ay1,ay2),Math.min(by1,by2))>=12)return true;}
+  }
+  return false;
+}
+function segmentIntersectionPoint(a,b){
+  const rx=a[2]-a[0],ry=a[3]-a[1],sx=b[2]-b[0],sy=b[3]-b[1],denominator=rx*sy-ry*sx;
+  if(Math.abs(denominator)<1e-8)return null;
+  const qx=b[0]-a[0],qy=b[1]-a[1],t=(qx*sy-qy*sx)/denominator,u=(qx*ry-qy*rx)/denominator;
+  if(t< -1e-8||t>1+1e-8||u< -1e-8||u>1+1e-8)return null;
+  return [a[0]+t*rx,a[1]+t*ry];
+}
+function routeEndpoints(route){
+  return [{id:route.from,point:route.segments[0].slice(0,2)},{id:route.to,point:route.segments.at(-1).slice(2,4)}];
+}
+function routeCrossingPoints(a,b){
+  const aEnds=routeEndpoints(a),bEnds=routeEndpoints(b),points=[];
+  for(const first of a.segments)for(const second of b.segments){
+    const point=segmentIntersectionPoint(first,second);
+    if(!point)continue;
+    const sharedNodeEndpoint=aEnds.some((left)=>bEnds.some((right)=>left.id===right.id&&Math.hypot(left.point[0]-right.point[0],left.point[1]-right.point[1])<=.5&&Math.hypot(left.point[0]-point[0],left.point[1]-point[1])<=.5));
+    if(sharedNodeEndpoint||points.some((prior)=>Math.hypot(prior[0]-point[0],prior[1]-point[1])<=.5))continue;
+    points.push(point);
+  }
+  return points;
+}
+function sequenceQuality(source,svg=svgContent(source),nodes=rectangles(svg),routes=parseRoutes(svg)){
+  if(!/\bdata-type\s*=\s*["']sequence(?:-oauth)?["']/i.test(source)&&!/\bid\s*=\s*["']diagram-sequence(?:-oauth)?-[^"']+["']/i.test(svg))return [];
+  const lifelines=new Map();
+  for(const match of svg.matchAll(/<line\b([^>]*)>/gi)){
+    const a=attributes(match[1]),name=a['data-lifeline-for'];
+    if(name&&a['stroke-dasharray']&&Number(a.x1)===Number(a.x2)&&Number(a.y2)>Number(a.y1))lifelines.set(name,{x:Number(a.x1),top:Number(a.y1),bottom:Number(a.y2)});
+  }
+  const issues=[],messages=routes.map((route)=>({route,start:route.segments[0].slice(0,2),end:route.segments.at(-1).slice(2,4),y:(route.segments[0][1]+route.segments.at(-1)[3])/2}));
+  const lastMessageY=Math.max(0,...messages.map((message)=>message.y));
+  for(const node of nodes){
+    const line=lifelines.get(node.id);
+    if(!line){issues.push('SEQUENCE_LIFELINE_MISSING '+node.id);continue;}
+    if(Math.abs(line.x-(node.x+node.w/2))>1||Math.abs(line.top-(node.y+node.h))>1)issues.push('SEQUENCE_LIFELINE_ALIGNMENT '+node.id);
+    if(line.bottom+1<lastMessageY)issues.push('SEQUENCE_LIFELINE_SHORT '+node.id+' ends before last message');
+  }
+  let previousY=-Infinity;
+  for(const message of messages){
+    const from=lifelines.get(message.route.from),to=lifelines.get(message.route.to);
+    if(!from||!to)continue;
+    if(Math.abs(message.start[0]-from.x)>1||Math.abs(message.end[0]-to.x)>1)issues.push('SEQUENCE_MESSAGE_OFF_LIFELINE '+message.route.from+'->'+message.route.to);
+    if(message.y<=previousY)issues.push('SEQUENCE_MESSAGE_ORDER '+message.route.from+'->'+message.route.to+' is not top-to-bottom');
+    previousY=message.y;
+  }
+  return issues;
+}
+
+function visualQuality(source,{enforceCanvas=false,scale=null}={}){
+  const svg=svgContent(source),texts=visibleSvgText(svg),nodes=rectangles(svg),routes=parseRoutes(svg),outlines=boundaryOutlines(svg),markers=markerDefinitions(svg),metrics=sourceMetrics(source),issues=[],sequenceDiagram=/\bdata-type\s*=\s*["']sequence(?:-oauth)?["']/i.test(source);
+  const contaminated=texts.filter((t)=>contamination.some((rule)=>rule.test(t.label))).map((t)=>t.label);
+  const office=officeCraft(texts,nodes,outlines,metrics.viewBox);
+  issues.push(...office.issues);
+  if(contaminated.length)issues.push('PROCESS_TEXT '+[...new Set(contaminated)].join(' | '));
+  for(const text of texts.filter((item)=>item.role==='edge'||item.edgeFor)){
+    const matches=routes.filter((route)=>route.from+'|'+route.to===text.edgeFor&&(!route.label||route.label===text.label));
+    if(!text.edgeFor||matches.length!==1){issues.push('EDGE_LABEL_UNBOUND '+(text.edgeFor||text.label));continue;}
+    const own=matches[0],distance=routeDistance(text.anchor,own),nearestOther=Math.min(Infinity,...routes.filter((route)=>route!==own).map((route)=>routeDistance(text.anchor,route)));
+    if(distance>MAX_EDGE_LABEL_ANCHOR_DISTANCE)issues.push('EDGE_LABEL_TOO_FAR '+text.label+' own='+distance.toFixed(1)+'px max='+MAX_EDGE_LABEL_ANCHOR_DISTANCE+'px');
+    if(Number.isFinite(nearestOther)&&distance>=nearestOther)issues.push('EDGE_LABEL_NEAREST_PATH '+text.label+' own='+distance.toFixed(1)+'px other='+nearestOther.toFixed(1)+'px');
+    for(const node of nodes)if(textOverlapsNode(text,node))issues.push('EDGE_LABEL_NODE_COLLISION '+text.label+' overlaps '+node.id);
+  }
+  for(const route of routes){
+    const facing=routeManhattanDistance(route),ratio=facing?routeLength(route)/facing:null,aligned=alignedRouteKind(route,nodes);
+    if(ratio>1.4)issues.push('ROUTE_DETOUR '+route.from+'->'+route.to+' ratio='+ratio.toFixed(2)+' max=1.40');
+    if(aligned)issues.push('ROUTE_ALIGNED_PATH '+route.from+'->'+route.to+' '+aligned+' neighbors require one straight segment');
+    const crossesBoundary=outlines.some((outline)=>routeCrossesBoundary(route,outline)),bendLimit=crossesBoundary?3:2,bends=routeBends(route);
+    if(bends>bendLimit)issues.push('ROUTE_BENDS '+route.from+'->'+route.to+' bends='+bends+' max='+bendLimit);
+    if(route.markerStart&&route.markerEnd)issues.push('ROUTE_OPPOSED_HEADS '+route.from+'->'+route.to);
+    for(const text of texts)for(const segment of route.segments)if(segmentHitsText(segment,text)){issues.push('EDGE_TEXT_COLLISION '+route.from+'->'+route.to+': '+text.label);break;}
+    for(const node of nodes)if(node.id!==route.from&&node.id!==route.to&&route.segments.some((s)=>segmentHitsBox(s,node,8)))issues.push('ROUTE_THROUGH_NODE '+route.from+'->'+route.to+' via '+node.id);
+    for(const outline of outlines)if(route.segments.some((segment)=>segmentAlongOutline(segment,outline))){issues.push('ROUTE_ALONG_BOUNDARY '+route.from+'->'+route.to+' along '+outline.id);break;}
+    const target=nodes.find((node)=>node.id===route.to);
+    for(const edge of ['start','end'])if(edge==='end'?route.markerEnd:route.markerStart){
+      const marker=markerFor(route,edge,markers),minimum=Math.max(ARROWHEAD_STROKE_MULTIPLE*route.strokeWidth,ARROWHEAD_CANVAS_FLOOR*(metrics.viewBox?.w||1080));
+      const length=markerHeadLength(marker)*markerScale(marker||{units:'userSpaceOnUse'},route);
+      if(!marker)issues.push('ARROWHEAD_GEOMETRY_MISSING '+route.from+'->'+route.to+' '+edge);
+      else if(length+0.01<minimum)issues.push('ARROWHEAD_SIZE_FLOOR '+route.from+'->'+route.to+' '+edge+'='+length.toFixed(1)+'px min='+minimum.toFixed(1)+'px (12/1080 canvas, 5x stroke)');
+    }
+    if(route.markerEnd&&target&&!sequenceDiagram){
+      const marker=markerFor(route,'end',markers),tip=markerTip(route,marker,'end');
+      if(tip&&distanceToBoxBoundary(tip,target)>ARROWHEAD_TARGET_TOLERANCE)issues.push('ARROWHEAD_TIP_MISSED_TARGET '+route.from+'->'+route.to+' gap='+distanceToBoxBoundary(tip,target).toFixed(1)+'px max='+ARROWHEAD_TARGET_TOLERANCE+'px');
+    }
+    if(route.markerEnd&&target&&markerOverlapsTarget(route,target,markers))issues.push('ARROWHEAD_TARGET_OVERLAP '+route.from+'->'+route.to+' marker intersects target '+target.id);
+  }
+  issues.push(...decisionBranchQuality(nodes,routes));
+  for(let i=0;i<routes.length;i++)for(let j=i+1;j<routes.length;j++){
+    if(collinearOverlap(routes[i],routes[j]))issues.push('ROUTE_COLLINEAR_OVERLAP '+routes[i].from+'->'+routes[i].to+' / '+routes[j].from+'->'+routes[j].to+' shared within 12px');
+    for(const point of routeCrossingPoints(routes[i],routes[j]))issues.push('ROUTE_CROSSING '+routes[i].from+'->'+routes[i].to+' / '+routes[j].from+'->'+routes[j].to+' at '+point[0].toFixed(1)+','+point[1].toFixed(1));
+  }
+  issues.push(...sequenceQuality(source,svg,nodes,routes));
+  for(const text of texts)for(const outline of outlines)if(textHitsOutline(text,outline)){issues.push('OUTLINE_TEXT_COLLISION '+text.label+' crosses '+outline.id);break;}
+  const boundaryTexts=texts.filter((text)=>isBoundaryLabel(text,outlines));
+  const boundaryContrastFailures=boundaryTexts.filter((text)=>metrics.contrastFailures.some((failure)=>failure.text===text.label));
+  for(const text of boundaryContrastFailures)issues.push('BOUNDARY_CONTRAST_FLOOR '+text.label+' below 4.5:1');
+  for(let i=0;i<nodes.length;i++)for(let j=i+1;j<nodes.length;j++)if(gap(nodes[i],nodes[j])<12)issues.push('NODE_GAP '+nodes[i].id+'/'+nodes[j].id+' below 12px');
+  const fontFailures=[];
+  if(enforceCanvas){
+    const ratio=scale??(metrics.viewBox?Math.min(metrics.viewBox.w/1080,metrics.viewBox.h/640):1);
+    if(!texts.some((t)=>t.role==='title'))issues.push('TITLE_ROLE_MISSING visible title must use data-role="title"');
+    for(const t of texts){const boundary=isBoundaryLabel(t,outlines),minimum=t.role==='title'?28:t.role==='edge'||boundary?13:t.role==='node'?15:0;if(minimum&&t.size+0.01<minimum*ratio){const failure=(boundary?'boundary':t.role)+':'+t.label+'='+t.size+'px (min '+(minimum*ratio).toFixed(1)+'px)';if(boundary)issues.push('BOUNDARY_FONT_FLOOR '+failure);else fontFailures.push(failure);}}
+    if(fontFailures.length)issues.push('FONT_FLOOR '+fontFailures.join(' | '));
+    const points=nodes.flatMap((n)=>[[n.x,n.y],[n.x+n.w,n.y+n.h]]).concat(routes.flatMap((r)=>r.segments.flatMap((s)=>[[s[0],s[1]],[s[2],s[3]]])));
+    const box=points.reduce((b,p)=>({left:Math.min(b.left,p[0]),top:Math.min(b.top,p[1]),right:Math.max(b.right,p[0]),bottom:Math.max(b.bottom,p[1])}),{left:Infinity,top:Infinity,right:-Infinity,bottom:-Infinity});
+    if(nodes.length&&metrics.viewBox){const safeWidth=metrics.viewBox.w*.90,safeHeight=metrics.viewBox.h*.74,width=(box.right-box.left)/safeWidth,height=(box.bottom-box.top)/safeHeight;if(width<.75||height<.54)issues.push('CONTENT_FILL safe-area-width='+width.toFixed(3)+' safe-area-height='+height.toFixed(3)+' minimum=.75/.54');}
+    if(!nodes.length)issues.push('CONTENT_NODES_MISSING');
+  }
+  return {issues,advisories:office.advisories,contaminated,fonts:fontFailures,nodes:nodes.length,edges:routes.length,edgeLabelMaxAnchorDistance:MAX_EDGE_LABEL_ANCHOR_DISTANCE,arrowheadFloor:{canvas:ARROWHEAD_CANVAS_FLOOR,strokeMultiple:ARROWHEAD_STROKE_MULTIPLE,targetTolerance:ARROWHEAD_TARGET_TOLERANCE},boundaryTexts:boundaryTexts.length};
+}
+export { visualQuality, officeCraft, visibleSvgText, parseRoutes, rectangles, boundaryOutlines, sequenceQuality };

package/skills/lit-docx/LICENSE-MIT.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) Woojin Go (wjgoarxiv)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.