@litfamily/litopencode 1.0.7 → 1.0.9

package/skills/lit-diagram-drawer/scripts/capability-probe.mjs

@@ -0,0 +1,132 @@
+#!/usr/bin/env node
+import { createHash } from 'node:crypto';
+import { spawnSync } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+let browserTools;
+try { browserTools = await import('../../browser-drive/scripts/capability-probe.mjs'); } catch { browserTools = undefined; }
+
+const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const minimum = [0, 38, 1];
+
+function versionParts(value) {
+  const match = /^agent-browser ((?:0|[1-9]\d*)\.(?:0|[1-9]\d*)\.(?:0|[1-9]\d*))$/u.exec(value ?? '');
+  return match?.[1].split('.').map(Number) ?? null;
+}
+
+function meetsMinimum(parts) {
+  if (!parts) return false;
+  for (let index = 0; index < minimum.length; index += 1) {
+    if (parts[index] !== minimum[index]) return parts[index] > minimum[index];
+  }
+  return true;
+}
+
+function run(command, args) {
+  return browserTools?.runCommandSync?.(command, args, { encoding: 'utf8', timeout: 15_000, maxBuffer: 64 * 1024 })
+    ?? spawnSync(command, args, { encoding: 'utf8', timeout: 15_000, maxBuffer: 64 * 1024 });
+}
+
+function isRegularFile(file) {
+  try { return fs.lstatSync(file).isFile(); } catch { return false; }
+}
+
+function probeWriteAccess(requestedDirectory = process.cwd()) {
+  const target = path.resolve(requestedDirectory);
+  let directory = target;
+  try {
+    while (!fs.existsSync(directory) && path.dirname(directory) !== directory) directory = path.dirname(directory);
+    if (!fs.statSync(directory).isDirectory()) throw new Error('nearest existing path is not a directory');
+    const probe = fs.mkdtempSync(path.join(directory, '.lit-diagram-write-check-'));
+    try { fs.writeFileSync(path.join(probe, 'probe.tmp'), '', { flag: 'wx' }); }
+    finally { fs.rmSync(probe, { recursive: true, force: true }); }
+    return { status: 'pass', detail: directory === target ? `write access verified for ${target}` : `write access verified at nearest existing parent ${directory}` };
+  } catch (error) {
+    return { status: 'fail', detail: `write access unavailable for ${target}: ${error.message}` };
+  }
+}
+
+export function runDiagramCommand(command, args, options = {}) {
+  return browserTools?.runCommandSync?.(command, args, options)
+    ?? spawnSync(command, args, { encoding: 'utf8', timeout: 30_000, maxBuffer: 2 * 1024 * 1024, ...options });
+}
+
+export function inspectDiagramCapabilities({ writeDirectory = process.cwd() } = {}) {
+  const checks = [];
+  const driver = browserTools?.probeBrowserDriver?.() ?? { status: 'unavailable', version: null, command: null, detail: 'browser-drive capability probe is unavailable' };
+  const driverParts = versionParts(driver.version);
+  const driverReady = driver.status === 'available' && meetsMinimum(driverParts);
+  const driverDetail = !driverReady && driver.status === 'available' && driverParts && !meetsMinimum(driverParts)
+    ? `agent-browser ${driver.version} is older than required floor 0.38.1`
+    : driver.detail;
+  checks.push({
+    id: 'agent-browser',
+    status: driverReady ? 'pass' : 'fail',
+    version: driver.version,
+    detail: driverReady ? `verified floor 0.38.1 met by ${driver.version}` : driverDetail
+  });
+
+  let browserReady = false;
+  let browserDetail = 'agent-browser is unavailable';
+  if (driverReady && driver.command) {
+    const result = run(driver.command, ['doctor', '--json']);
+    let output;
+    try { output = JSON.parse(result?.stdout ?? ''); } catch { output = null; }
+    const chrome = output?.checks?.find((check) => check.id === 'chrome.installed')?.message ?? '';
+    browserReady = result?.status === 0 && output?.success === true && /\b154\./u.test(chrome);
+    browserDetail = browserReady ? 'Chrome for Testing 154 is available' : 'Chrome for Testing 154 is missing or unverified';
+  }
+  checks.push({ id: 'chrome-for-testing', status: browserReady ? 'pass' : 'fail', detail: browserDetail });
+
+  const font = path.join(root, 'assets/fonts/PretendardVariable.woff2');
+  const provenanceFile = path.join(root, 'assets/fonts/provenance.json');
+  let fontValid = false;
+  let licenseValid = false;
+  try {
+    const provenance = JSON.parse(fs.readFileSync(provenanceFile, 'utf8'));
+    for (const [file, assign] of [['PretendardVariable.woff2', (valid) => { fontValid = valid; }], ['OFL.txt', (valid) => { licenseValid = valid; }]]) {
+      const record = provenance.files?.find((item) => item.file === file);
+      const bytes = fs.readFileSync(path.join(root, 'assets/fonts', file));
+      assign(typeof record?.sha256 === 'string' && record.bytes === bytes.length
+        && createHash('sha256').update(bytes).digest('hex') === record.sha256);
+    }
+  } catch {
+    fontValid = false;
+    licenseValid = false;
+  }
+  checks.push({ id: 'pretendard-font', status: fontValid ? 'pass' : 'fail', detail: fontValid ? 'font matches bundled provenance' : 'font or provenance is missing or altered' });
+  checks.push({
+    id: 'pretendard-license',
+    status: licenseValid ? 'pass' : 'fail',
+    detail: licenseValid ? 'OFL file matches bundled provenance' : 'OFL file or provenance is missing, altered, or mismatched'
+  });
+
+  const detector = path.resolve(root, '../lit-humanizer/scripts/detect.mjs');
+  const rules = path.resolve(root, '../lit-humanizer/rules.json');
+  const detectorReady = isRegularFile(detector) && isRegularFile(rules);
+  checks.push({ id: 'lit-humanizer-detector', status: detectorReady ? 'pass' : 'fail', detail: detectorReady ? 'local detector and rule set are present' : 'local detector or rule set is missing' });
+
+  const renderer = run('rsvg-convert', ['--version']);
+  checks.push({
+    id: 'rsvg-convert',
+    status: renderer?.status === 0 ? 'pass' : 'optional-missing',
+    detail: (renderer?.stdout || renderer?.stderr || 'not found').trim().slice(0, 200)
+  });
+
+  const writeAccess = probeWriteAccess(writeDirectory);
+  checks.push({ id: 'write-access', ...writeAccess });
+
+  return {
+    ready: driverReady && browserReady && fontValid && licenseValid && detectorReady && writeAccess.status === 'pass',
+    driverCommand: driverReady ? driver.command : undefined,
+    checks
+  };
+}
+
+if (process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url)) {
+  const report = inspectDiagramCapabilities();
+  process.stdout.write(`${JSON.stringify(report, null, 2)}\n`);
+  if (!report.ready) process.exitCode = 1;
+}

package/skills/lit-diagram-drawer/scripts/check-visible-text.mjs

@@ -0,0 +1,15 @@
+#!/usr/bin/env node
+import { analyzeFile } from './diagram-metrics.mjs';
+const files=process.argv.slice(2).filter((x)=>!x.startsWith('--'));
+if(!files.length){console.error('Usage: node scripts/check-visible-text.mjs <file...>');process.exit(2);}
+let failed=false;
+for(const file of files){
+  try{
+    const result=analyzeFile(file);
+    const block=result.humanizer.summary?.block||0;
+    const errors=result.humanizer.errors?.length||0;
+    console.log(JSON.stringify({file,block,warn:result.humanizer.summary?.warn||0,errors,findings:result.humanizer.findings||[]}));
+    if(block||errors) failed=true;
+  }catch(e){console.error(file+': '+e.message);failed=true;}
+}
+if(failed)process.exitCode=1;

package/skills/lit-diagram-drawer/scripts/craft-thresholds.json

@@ -0,0 +1,15 @@
+{
+  "groupRatioMin": 2,
+  "accentLightnessMin": 0.12,
+  "accentLightnessMax": 0.93,
+  "accentSaturationMin": 0.12,
+  "accentHueBucketDegrees": 20,
+  "accentMedium": 3,
+  "accentHigh": 4,
+  "fullBleedFraction": 0.92,
+  "latinFractionMin": 0.8,
+  "titleWordFractionMin": 0.6,
+  "titleWordMinLetters": 4,
+  "titleWordMinCount": 2,
+  "labelInsetPx": 2
+}

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

@@ -0,0 +1,216 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { spawnSync } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+import { fontReferencePortable } from './renderer-safety.mjs';
+
+const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const humanizer = path.resolve(root, '../lit-humanizer/scripts/detect.mjs');
+const decode = (s) => s.replaceAll('&amp;', '&').replaceAll('&lt;', '<').replaceAll('&gt;', '>').replaceAll('&quot;', '"').replaceAll('&apos;', "'").replaceAll('&#39;', "'");
+const attrs = (s) => Object.fromEntries([...s.matchAll(/([\w:-]+)\s*=\s*("([^"]*)"|' + "'([^']*)'" + ')/g)].map((m) => [m[1], decode(m[3] ?? m[4] ?? '')]));
+const strip = (s) => decode(s.replace(/<[^>]*>/g, ' ').replace(/\s+/g, ' ').trim());
+const escText = (s) => s.replace(/<style\b[^>]*>[\s\S]*?<\/style>/gi, ' ').replace(/<script\b[^>]*>[\s\S]*?<\/script>/gi, ' ').replace(/<head\b[^>]*>[\s\S]*?<\/head>/gi, ' ');
+function glyphWidth(text, fontSize) {
+  let units = 0;
+  for (const ch of text) {
+    if (/\s/.test(ch)) units += 0.28;
+    else if (/[\u1100-\u11ff\u3130-\u318f\uac00-\ud7af]/.test(ch)) units += 0.98;
+    else if (/[ilI.,:;!|]/.test(ch)) units += 0.32;
+    else if (/[MW@#%]/.test(ch)) units += 0.82;
+    else units += 0.56;
+  }
+  return units * fontSize;
+}
+function boxesFromSvg(svg) {
+  const boxes = [];
+  const texts = [];
+  for (const m of svg.matchAll(/<rect\b([^>]*)\/?\s*>/gi)) {
+    const a = attrs(m[1]);
+    const x = Number(a.x || 0), y = Number(a.y || 0), w = Number(a.width || 0), h = Number(a.height || 0);
+    if (w > 2 && h > 2) boxes.push({ kind: 'rect', x, y, w, h, fill: a.fill || '' });
+  }
+  for (const m of svg.matchAll(/<circle\b([^>]*)\/?\s*>/gi)) {
+    const a = attrs(m[1]), r = Number(a.r || 0), cx = Number(a.cx || 0), cy = Number(a.cy || 0);
+    if (r > 0) boxes.push({ kind: 'circle', x: cx-r, y: cy-r, w: 2*r, h: 2*r });
+  }
+  for (const m of svg.matchAll(/<text\b([^>]*)>([\s\S]*?)<\/text>/gi)) {
+    const a = attrs(m[1]);
+    const label = strip(m[2]);
+    if (!label) continue;
+    const size = Number(a['font-size'] || 16);
+    const width = glyphWidth(label, size);
+    const anchor = a['text-anchor'] || 'start';
+    const x = Number(a.x || 0) - (anchor === 'middle' ? width/2 : anchor === 'end' ? width : 0);
+    const y = Number(a.y || 0) - size*0.82;
+    texts.push({ kind:'text', label, x, y, w:width, h:size*1.22, fill:a.fill || '#000000', fontSize:size });
+  }
+  return { boxes, texts };
+}
+function intersects(a,b) {
+  return a.x < b.x + b.w - 1 && a.x + a.w > b.x + 1 && a.y < b.y + b.h - 1 && a.y + a.h > b.y + 1;
+}
+function contains(a,b) {
+  return a.x <= b.x+1 && a.y <= b.y+1 && a.x+a.w >= b.x+b.w-1 && a.y+a.h >= b.y+b.h-1;
+}
+function contrastRatio(fg, bg) {
+  const hex = (s) => {
+    if (!/^#[0-9a-f]{3}([0-9a-f]{3})?$/i.test(s)) return null;
+    let v=s.slice(1); if(v.length===3) v=[...v].map((x)=>x+x).join('');
+    return [0,2,4].map((i)=>parseInt(v.slice(i,i+2),16)/255).map((x)=>x<=0.04045?x/12.92:((x+0.055)/1.055)**2.4);
+  };
+  const f=hex(fg), b=hex(bg);
+  if(!f||!b) return null;
+  const lum=(v)=>0.2126*v[0]+0.7152*v[1]+0.0722*v[2];
+  const l1=lum(f), l2=lum(b);
+  return (Math.max(l1,l2)+0.05)/(Math.min(l1,l2)+0.05);
+}
+function lineCrossings(svg) {
+  const routes=[];
+  for(const m of svg.matchAll(/<line\b([^>]*)\/?\s*>/gi)) {
+    const a=attrs(m[1]);
+    if(a['data-lifeline-for'])continue;
+    const values=['x1','y1','x2','y2'].map((k)=>Number(a[k]));
+    if(values.every(Number.isFinite)) routes.push([[values[0],values[1],values[2],values[3]]]);
+  }
+  const tokens=(d)=>d.match(/[-+]?(?:\d*\.\d+|\d+\.?\d*)(?:e[-+]?\d+)?|[a-zA-Z]/gi)||[];
+  const pathSegments=(d)=>{
+    const parts=tokens(d),segments=[];let i=0,cmd='',x=0,y=0,sx=0,sy=0;
+    const number=()=>Number(parts[i++]);
+    const point=(relative)=>{const px=number(),py=number();return relative?[x+px,y+py]:[px,py];};
+    while(i<parts.length){
+      if(/^[a-z]$/i.test(parts[i]))cmd=parts[i++];
+      if(!cmd)break;
+      const relative=cmd===cmd.toLowerCase(),upper=cmd.toUpperCase();
+      if(upper==='Z'){if(x!==sx||y!==sy)segments.push([x,y,sx,sy]);x=sx;y=sy;cmd='';continue;}
+      if(upper==='M'||upper==='L'){
+        if(i+1>=parts.length||/^[a-z]$/i.test(parts[i])){cmd='';continue;}
+        const [nx,ny]=point(relative);
+        if(upper==='M'){x=nx;y=ny;sx=x;sy=y;cmd=relative?'l':'L';}
+        else {segments.push([x,y,nx,ny]);x=nx;y=ny;}
+      }else if(upper==='H'){
+        if(i>=parts.length||/^[a-z]$/i.test(parts[i])){cmd='';continue;}
+        const nx=number()+(relative?x:0);segments.push([x,y,nx,y]);x=nx;
+      }else if(upper==='V'){
+        if(i>=parts.length||/^[a-z]$/i.test(parts[i])){cmd='';continue;}
+        const ny=number()+(relative?y:0);segments.push([x,y,x,ny]);y=ny;
+      }else if(upper==='C'){
+        if(i+5>=parts.length||/^[a-z]$/i.test(parts[i])){cmd='';continue;}
+        const c1=point(relative),c2=point(relative),end=point(relative),start=[x,y];let previous=start;
+        for(let step=1;step<=12;step++){
+          const t=step/12,u=1-t;
+          const 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{
+        while(i<parts.length&&!/^[a-z]$/i.test(parts[i]))i++;
+        cmd='';
+      }
+    }
+    return segments;
+  };
+  const pathsOnly=svg.replace(/<defs\b[^>]*>[\s\S]*?<\/defs>/gi,'');
+  for(const m of pathsOnly.matchAll(/<path\b([^>]*)>/gi)){
+    const a=attrs(m[1]);
+    if(!a.d||(!a['marker-end']&&!a['marker-start']&&a.fill!=='none'))continue;
+    const segments=pathSegments(a.d);
+    if(segments.length)routes.push(segments);
+  }
+  let count=0;
+  const orient=(a,b,c)=>(b[0]-a[0])*(c[1]-a[1])-(b[1]-a[1])*(c[0]-a[0]);
+  for(let i=0;i<routes.length;i++) for(let j=i+1;j<routes.length;j++) {
+    let crossing=false;
+    for(const first of routes[i]) for(const second of routes[j]){
+      const a=[first[0],first[1]],b=[first[2],first[3]],c=[second[0],second[1]],d=[second[2],second[3]];
+      const shared=[a,b].some(p=>[c,d].some(q=>Math.abs(p[0]-q[0])<2&&Math.abs(p[1]-q[1])<2));
+      if(!shared&&orient(a,b,c)*orient(a,b,d)<0&&orient(c,d,a)*orient(c,d,b)<0){crossing=true;break;}
+    }
+    if(crossing)count++;
+  }
+  return count;
+}
+function sourceMetrics(source, sourcePath='<stdin>') {
+  const svgMatches=[...source.matchAll(/<svg\b([^>]*)>([\s\S]*?)<\/svg>/gi)];
+  const svg=svgMatches.map((m)=>m[0]).join('\n');
+  const svgAttrs=svgMatches[0] ? attrs(svgMatches[0][1]) : {};
+  const viewBox=(svgAttrs.viewBox||'').trim().split(/[\s,]+/).map(Number);
+  const view=viewBox.length===4 ? {x:viewBox[0],y:viewBox[1],w:viewBox[2],h:viewBox[3]} : null;
+  const {boxes,texts}=boxesFromSvg(svg);
+  const overflow=[];
+  if(view) {
+    for(const b of [...boxes,...texts]) if(b.x<view.x-1||b.y<view.y-1||b.x+b.w>view.x+view.w+1||b.y+b.h>view.y+view.h+1) overflow.push(b.label||b.kind);
+  }
+  let textOverlaps=0;
+  for(let i=0;i<texts.length;i++) for(let j=i+1;j<texts.length;j++) if(intersects(texts[i],texts[j])) textOverlaps++;
+  let objectOverlaps=0;
+  const visibleBoxes=boxes.filter((b)=>!(view && b.w>=view.w-2 && b.h>=view.h-2));
+  for(let i=0;i<visibleBoxes.length;i++) for(let j=i+1;j<visibleBoxes.length;j++) {
+    const a=visibleBoxes[i],b=visibleBoxes[j];
+    const vennPair=/diagram-venn-(?:light|dark|full)/.test(svgAttrs.id||'')&&a.kind==='circle'&&b.kind==='circle';
+    if(!vennPair&&intersects(a,b)&&!contains(a,b)&&!contains(b,a)) objectOverlaps++;
+  }
+  const paper=([...svg.matchAll(/<rect\b([^>]*)\/?\s*>/gi)].map((m)=>{
+    const a=attrs(m[1]);
+    const fill=a.fill||'#ffffff';
+    const x=Number(a.x||0),y=Number(a.y||0),w=Number(a.width||0),h=Number(a.height||0);
+    return {fill,area:w*h,visible:fill.toLowerCase()!=='none'&&fill.toLowerCase()!=='transparent',canvas:!!view&&x<=view.x+1&&y<=view.y+1&&w>=view.w-2&&h>=view.h-2};
+  }).filter((rect)=>rect.visible).sort((a,b)=>Number(b.canvas)-Number(a.canvas)||b.area-a.area)[0]?.fill)||'#ffffff';
+  const contrastFailures=[];
+  for(const t of texts) {
+    const ratio=contrastRatio(t.fill,paper);
+    if(ratio!==null && ratio<4.5) contrastFailures.push({text:t.label,ratio:Number(ratio.toFixed(2))});
+  }
+  const fills=new Set([...svg.matchAll(/\b(?:fill|stroke)\s*=\s*["'](#[0-9a-f]{3,8})["']/gi)].map((m)=>m[1].toLowerCase()));
+  const textContent=[...svg.matchAll(/<(?:text|title|desc)\b[^>]*>([\s\S]*?)<\/(?:text|title|desc)>/gi)].map((m)=>strip(m[1])).filter(Boolean).join('\n');
+  const documentText=escText(source).replace(/<svg\b[^>]*>[\s\S]*?<\/svg>/gi,' ').replace(/<[^>]*>/g,' ');
+  const htmlText=strip(documentText);
+  const visibleText=[textContent,htmlText].filter(Boolean).join('\n');
+  const fontFamilyPresent=/Pretendard/i.test(svg) && /Pretendard/i.test(source);
+  const fontUrls=[...source.matchAll(/@font-face\b[\s\S]{0,250}?url\(\s*["']?([^"')]+)["']?\)/gi)].map((match)=>decode(match[1].trim()));
+  const localFont=fontUrls.some((url)=>/^data:font\//i.test(url)||(!/^https?:\/\//i.test(url)&&/\.(?:woff2?|ttf|otf)(?:[?#].*)?$/i.test(url)));
+  const bundledFont=path.join(root,'assets/fonts/PretendardVariable.woff2');
+  const fontFileValid=fontUrls.some((url)=>fontReferencePortable(url,sourcePath,bundledFont));
+  const radiusLarge=[...svg.matchAll(/<rect\b([^>]*)\/?\s*>/gi)].filter((m)=>Number(attrs(m[1]).rx||0)>8).length;
+  const hasShadow=/\bbox-shadow\s*:|filter\s*=\s*["']url\(#/i.test(source);
+  return {
+    source:sourcePath,
+    hasSvg:svgMatches.length>0,
+    viewBox:view,
+    title: /<title\b[^>]*>[\s\S]*?<\/title>/i.test(svg),
+    desc: /<desc\b[^>]*>[\s\S]*?<\/desc>/i.test(svg),
+    roleImage:/\brole\s*=\s*["']img["']/i.test(svg),
+    ariaLinked:!!svgAttrs['aria-labelledby'],
+    textCount:texts.length,
+    textOverlaps,
+    objectOverlaps,
+    offCanvas:overflow.length,
+    offCanvasLabels:overflow.slice(0,12),
+    arrowCrossings:lineCrossings(svg),
+    contrastFailures,
+    colors:fills.size,
+    largeRadius:radiusLarge,
+    hasShadow,
+    fontFamilyPresent,
+    localFont,
+    fontFileValid,
+    visibleText,
+    type:svgAttrs.id||'',
+    sourceBytes:Buffer.byteLength(source)
+  };
+}
+function detectorFindings(visibleText) {
+  const result=spawnSync(process.execPath,[humanizer,'--json','-'],{input:visibleText,encoding:'utf8',maxBuffer:1024*1024});
+  if(result.error) throw result.error;
+  let parsed;
+  try { parsed=JSON.parse(result.stdout); } catch { throw new Error('Humanizer returned invalid JSON: '+result.stdout+' '+result.stderr); }
+  return {exitCode:result.status,summary:parsed.summary||{},findings:parsed.findings||[],errors:parsed.errors||[]};
+}
+function analyzeSource(source, sourcePath) {
+  const metrics=sourceMetrics(source,sourcePath);
+  const humanizer=detectorFindings(metrics.visibleText);
+  return {...metrics,humanizer};
+}
+function analyzeFile(file) {
+  return analyzeSource(fs.readFileSync(file,'utf8'),file);
+}
+export { root, analyzeFile, analyzeSource, sourceMetrics, detectorFindings, contrastRatio };

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

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+import { inspectDiagramCapabilities } from './capability-probe.mjs';
+
+const outputIndex = process.argv.indexOf('--out');
+const writeDirectory = outputIndex >= 0 && process.argv[outputIndex + 1] ? process.argv[outputIndex + 1] : process.cwd();
+const report = inspectDiagramCapabilities({ writeDirectory });
+process.stdout.write(`${JSON.stringify({ ready: report.ready, checks: report.checks }, null, 2)}\n`);
+if (!report.ready) process.exitCode = 1;

package/skills/lit-diagram-drawer/scripts/drawio-extract.mjs

@@ -0,0 +1,214 @@
+#!/usr/bin/env node
+import path from 'node:path';
+import { inflateRawSync, inflateSync } from 'node:zlib';
+import { pathToFileURL } from 'node:url';
+import { cleanLabel, cli, digest, MAX_NODES, MAX_RELATIONSHIPS, parseAttributes, readBounded, reject, safeId, validateInertXml } from './import-shared.mjs';
+
+const MAX_INPUT = 16 * 1024 * 1024;
+const MAX_DECODED = 32 * 1024 * 1024;
+const MAX_PAGES = 1_024;
+const PNG_MAGIC = Buffer.from([137, 80, 78, 71, 13, 10, 26, 10]);
+const crcTable = Uint32Array.from({ length: 256 }, (_, n) => {
+  let value = n;
+  for (let bit = 0; bit < 8; bit += 1) value = value & 1 ? 0xedb88320 ^ (value >>> 1) : value >>> 1;
+  return value >>> 0;
+});
+
+function crc32(data) {
+  let crc = 0xffffffff;
+  for (const byte of data) crc = crcTable[(crc ^ byte) & 0xff] ^ (crc >>> 8);
+  return (crc ^ 0xffffffff) >>> 0;
+}
+
+function inflate(data, raw) {
+  try {
+    const result = raw ? inflateRawSync(data, { maxOutputLength: MAX_DECODED + 1 }) : inflateSync(data, { maxOutputLength: MAX_DECODED + 1 });
+    if (result.length > MAX_DECODED) reject('embedded draw.io page exceeds the 32 MiB decoded limit');
+    return result;
+  } catch { reject('embedded draw.io page has invalid or oversized compression'); }
+}
+
+function decodePage(payload) {
+  const compact = payload.replace(/\s+/gu, '');
+  if (!/^[A-Za-z0-9+/]*={0,2}$/u.test(compact) || compact.length % 4 === 1) reject('compressed draw.io page is not valid base64');
+  const decoded = inflate(Buffer.from(compact, 'base64'), true);
+  try { return decodeURIComponent(new TextDecoder('utf-8', { fatal: true }).decode(decoded)); }
+  catch { reject('compressed draw.io page is malformed or not UTF-8'); }
+}
+
+function pngText(data) {
+  let offset = PNG_MAGIC.length;
+  while (offset + 12 <= data.length) {
+    const length = data.readUInt32BE(offset);
+    const type = data.toString('ascii', offset + 4, offset + 8);
+    const end = offset + 8 + length;
+    if (end + 4 > data.length) reject('PNG has a truncated metadata chunk');
+    const payload = data.subarray(offset + 8, end);
+    const crcInput = data.subarray(offset + 4, end);
+    if (crc32(crcInput) !== data.readUInt32BE(end)) reject('PNG metadata chunk has an invalid CRC');
+    offset = end + 4;
+    if (['tEXt', 'zTXt', 'iTXt'].includes(type)) {
+      const split = payload.indexOf(0);
+      if (split < 0 || payload.toString('latin1', 0, split).toLowerCase() !== 'mxfile') continue;
+      const rest = payload.subarray(split + 1);
+      let value;
+      if (type === 'tEXt') value = rest.toString('latin1');
+      else if (type === 'zTXt') {
+        if (rest[0] !== 0) reject('PNG mxfile text uses an unsupported compression method');
+        value = inflate(rest.subarray(1), false).toString('utf8');
+      } else {
+        if (rest.length < 4 || rest[1] !== 0) reject('PNG mxfile international text is malformed');
+        const fields = rest.subarray(2).toString('binary').split('\0', 2);
+        const textOffset = 2 + Buffer.byteLength(fields[0] ?? '', 'binary') + 1 + Buffer.byteLength(fields[1] ?? '', 'binary') + 1;
+        const body = rest.subarray(textOffset);
+        value = (rest[0] === 1 ? inflate(body, false) : body).toString('utf8');
+      }
+      if (Buffer.byteLength(value, 'utf8') > MAX_DECODED) reject('embedded draw.io payload exceeds the decoded size limit');
+      try { return decodeURIComponent(value); } catch { return value; }
+    }
+    if (type === 'IEND') break;
+  }
+  reject('PNG has no embedded mxfile diagram');
+}
+
+function sourceXml(data, file) {
+  if (data.subarray(0, PNG_MAGIC.length).equals(PNG_MAGIC)) return pngText(data);
+  let source;
+  try { source = new TextDecoder('utf-8', { fatal: true }).decode(data).replace(/^\uFEFF/u, '').trim(); }
+  catch { reject('input is not valid UTF-8 draw.io XML'); }
+  if (path.extname(file).toLowerCase() === '.svg' || /^<svg\b/iu.test(source)) {
+    validateInertXml(source);
+    const metadata = /<metadata\b([^>]*)>/iu.exec(source);
+    const content = metadata && parseAttributes(metadata[1]).content;
+    if (!content || !/(?:<mxfile\b|<mxGraphModel\b)/iu.test(content)) reject('SVG has no embedded draw.io diagram');
+    source = content;
+  }
+  if (!source.startsWith('<')) reject('unsupported form; provide draw.io XML or an SVG/PNG with embedded mxfile data');
+  validateInertXml(source);
+  return source;
+}
+
+function pagesFrom(source, pageIndex = 0) {
+  if (!Number.isInteger(pageIndex) || pageIndex < 0) reject('page index is out of range');
+  const root = /^\s*<([\w:.-]+)/u.exec(source)?.[1]?.split(':').at(-1)?.toLowerCase();
+  if (root === 'mxgraphmodel') {
+    if (pageIndex !== 0) reject('page index is out of range (file contains 1 page)');
+    return { name: '', xml: source };
+  }
+  if (root !== 'mxfile') reject('unsupported XML root; expected mxfile or mxGraphModel');
+  let count = 0;
+  let selected;
+  for (const match of source.matchAll(/<diagram\b([^>]*)>([\s\S]*?)<\/diagram\s*>/giu)) {
+    if (count >= MAX_PAGES) reject(`draw.io file exceeds the ${MAX_PAGES} page limit`);
+    const attributes = parseAttributes(match[1]);
+    if (count === pageIndex) {
+      const body = match[2].trim();
+      const xml = /<mxGraphModel\b/iu.test(body) ? body : decodePage(body);
+      validateInertXml(xml);
+      if (!/<mxGraphModel\b/iu.test(xml)) reject('draw.io page does not contain mxGraphModel');
+      selected = { name: attributes.name ?? '', xml };
+    }
+    count += 1;
+  }
+  if (!count) reject('draw.io file contains no pages');
+  if (!selected) reject(`page index is out of range (file contains ${count} page(s))`);
+  return selected;
+}
+
+function cellsFrom(xml) {
+  const cells = [];
+  const covered = [];
+  const wrappers = /<(?:object|UserObject)\b([^>]*)>([\s\S]*?)<\/(?:object|UserObject)\s*>/giu;
+  for (const wrapper of xml.matchAll(wrappers)) {
+    const cell = /<mxCell\b([^>]*)\/?\s*>/iu.exec(wrapper[2]);
+    if (cell) cells.push({ ...parseAttributes(wrapper[1]), ...parseAttributes(cell[1]) });
+    covered.push([wrapper.index, wrapper.index + wrapper[0].length]);
+  }
+  for (const match of xml.matchAll(/<mxCell\b([^>]*)\/?\s*>/giu)) {
+    if (!covered.some(([start, end]) => match.index >= start && match.index < end)) cells.push(parseAttributes(match[1]));
+  }
+  for (const match of xml.matchAll(/<mxGeometry\b([^>]*)\/?\s*>/giu)) {
+    const geometry = parseAttributes(match[1]);
+    for (const key of ['x', 'y', 'width', 'height']) {
+      if (geometry[key] === undefined) continue;
+      const value = Number(geometry[key]);
+      if (!Number.isFinite(value) || Math.abs(value) > 10_000_000) reject(`geometry field ${key} is outside the supported range`);
+    }
+  }
+  return cells;
+}
+
+function shapeOf(style = '') {
+  const raw = /(?:^|;)shape=([^;]+)/iu.exec(style)?.[1]?.toLowerCase() ?? 'rect';
+  if (/rhombus|diamond/u.test(raw)) return 'diamond';
+  if (/ellipse|actor/u.test(raw)) return 'ellipse';
+  if (/cylinder|database/u.test(raw)) return 'cylinder';
+  if (/swimlane/u.test(raw)) return 'container';
+  if (/text/u.test(raw)) return 'text';
+  if (/group/u.test(raw)) return 'group';
+  if (/table/u.test(raw)) return 'table';
+  if (/hexagon/u.test(raw)) return 'hexagon';
+  if (/cloud/u.test(raw)) return 'cloud';
+  if (/parallelogram/u.test(raw)) return 'parallelogram';
+  if (/document/u.test(raw)) return 'document';
+  if (/image/u.test(raw)) return 'image';
+  return 'rectangle';
+}
+
+function extract(file, pageIndex = 0) {
+  const data = readBounded(file, MAX_INPUT);
+  const page = pagesFrom(sourceXml(data, file), pageIndex);
+  const cells = cellsFrom(page.xml);
+  if (cells.length > MAX_NODES + MAX_RELATIONSHIPS) reject('diagram exceeds the 7,000 cell limit');
+  const ids = new Map();
+  const used = new Set();
+  for (const cell of cells) {
+    if (cell.id === undefined || ids.has(cell.id)) reject('diagram contains duplicate or missing element ids');
+    ids.set(cell.id, safeId(cell.id, used));
+  }
+  const vertices = cells.filter((cell) => cell.vertex === '1');
+  const edges = cells.filter((cell) => cell.edge === '1');
+  if (vertices.length > MAX_NODES || edges.length > MAX_RELATIONSHIPS) reject('diagram exceeds the node or relationship limit');
+  const vertexIds = new Set(vertices.map((cell) => cell.id));
+  const children = new Map();
+  for (const cell of vertices) if (vertexIds.has(cell.parent)) children.set(cell.parent, [...(children.get(cell.parent) ?? []), cell.id]);
+  const discarded = { styles: 0, links: 0, urls: 0, assets: 0, unsupportedElements: 0, danglingRelationships: 0 };
+  const title = cleanLabel(page.name || path.basename(file, path.extname(file)) || 'Imported diagram');
+  discarded.urls += title.urls;
+  const nodes = vertices.map((cell) => {
+    const label = cleanLabel(cell.value ?? cell.label ?? '');
+    discarded.urls += label.urls;
+    const shape = shapeOf(cell.style ?? '');
+    discarded.styles += Number(Boolean(cell.style));
+    discarded.links += Number(Boolean(cell.link || cell.href));
+    discarded.assets += Number(shape === 'image' || /(?:^|;)image=/iu.test(cell.style ?? ''));
+    const group = Boolean(children.get(cell.id)?.length) || shape === 'container' || shape === 'group';
+    return { id: ids.get(cell.id), label: label.text, kind: group ? 'container' : 'component', shape: group ? 'container' : shape, ...(vertexIds.has(cell.parent) ? { parentId: ids.get(cell.parent) } : {}) };
+  });
+  const groups = vertices.filter((cell) => children.has(cell.id)).map((cell) => ({ id: ids.get(cell.id), label: nodes.find((node) => node.id === ids.get(cell.id))?.label || 'Group', nodeIds: children.get(cell.id).map((id) => ids.get(id)) }));
+  const relationships = [];
+  for (const edge of edges) {
+    if (!vertexIds.has(edge.source) || !vertexIds.has(edge.target)) { discarded.danglingRelationships += 1; continue; }
+    const label = cleanLabel(edge.value ?? '');
+    discarded.urls += label.urls;
+    discarded.styles += Number(Boolean(edge.style));
+    discarded.links += Number(Boolean(edge.link || edge.href));
+    const style = edge.style ?? '';
+    const start = /(?:^|;)startArrow=(?!none(?:;|$))/iu.test(style);
+    const end = /(?:^|;)endArrow=(?!none(?:;|$))/iu.test(style);
+    const direction = start && end ? 'both' : start ? 'reverse' : end ? 'forward' : 'none';
+    relationships.push({ from: ids.get(edge.source), to: ids.get(edge.target), label: label.text, kind: direction === 'none' ? 'association' : 'flow', direction });
+  }
+  return { schemaVersion: 1, sourceFormat: 'drawio', sourceDigest: digest(data), title: title.text || 'Imported diagram', suggestedType: groups.length ? 'architecture' : relationships.length ? 'flowchart' : 'architecture', nodes, relationships, groups, discarded, warnings: ['Source coordinates and styling are omitted; imported labels are inert data.'] };
+}
+
+function main() {
+  const args = process.argv.slice(2);
+  const file = args.find((arg) => !arg.startsWith('--'));
+  const index = args.indexOf('--page');
+  const page = index < 0 ? 0 : Number(args[index + 1]);
+  if (!file || (index >= 0 && (!args[index + 1] || !Number.isInteger(page)))) reject('Usage: node scripts/drawio-extract.mjs <file.drawio|file.svg|file.png> [--page 0]');
+  return extract(file, page);
+}
+
+if (process.argv[1] && pathToFileURL(path.resolve(process.argv[1])).href === import.meta.url) process.exitCode = cli(main, 'drawio-extract');