@@ -48,24 +48,25 @@ export const asBlocks = (content) =>
 function parse(text, { mono = false, muted = false } = {}) {
   return String(text ?? '').split('\n').map((line) => {
     const words = [];
-    for (const part of line.split(/(\*\*[^*]+\*\*|`[^`]+`)/)) {
+    for (const part of line.trim().split(/(\*\*[^*]+\*\*|`[^`]+`)/)) {
       if (!part) continue;
       const bold = part.startsWith('**') && part.endsWith('**') && part.length > 4;
       const code = part.startsWith('`') && part.endsWith('`') && part.length > 2;
       const inner = bold ? part.slice(2, -2) : code ? part.slice(1, -1) : part;
-      words.push({ t: inner, bold, code: code || mono, muted, noBreak: muted });
+      words.push({ t: inner.replace(/\s+/g, ' '), bold, code: code || mono, muted, noBreak: muted }); // runs of spaces read as one, like before
     }
     return words;
   });
 }
 
 const wordW = (w, size, S, bold) => measureText(w.t, size, w.code ? MONO_CHAR : S.charWidth, w.bold || bold);
+const SPACE = (size, S) => size * S.charWidth * 0.9;
 
 // Wrap styled runs without inventing whitespace at their boundaries.
 function wrapRich(text, room, size, S, bold = false, extra = []) {
   const paras = typeof text === 'string' || text == null ? parse(text) : text;
   if (extra.length) paras[paras.length - 1] = [...paras[paras.length - 1], { t: ' ' }, ...extra];
-  return paras.flatMap((runs) => wrapRuns(runs, room, (r) => wordW(r, size, S, bold)));
+  return paras.flatMap((runs) => wrapRuns(runs, room, (r) => (r.t === ' ' ? SPACE(size, S) : wordW(r, size, S, bold))));
 }
 
 function richLine(line, x, y, size, color, anchor, S, { bold = false, cls = 'g-label', font } = {}) {
@@ -101,7 +102,10 @@ function pills(items, room, S) {
   return { rows: used, h: used.length ? used.length * (h + 5) - 5 : 0, w: Math.max(0, ...used.map((r) => r.at(-1).x + r.at(-1).w)), pill: h, size };
 }
 
-// Preserve legacy reflow for label.lines; explicit newlines in block text stay.
+// Lines an agent broke by hand at some other width read ragged once wrapped again ("…the" / "cheapest" /
+// "evidence…"). When a line would wrap anyway, and the break falls mid-sentence (the line doesn't end a
+// sentence and the next starts lowercase), the two become one paragraph and wrap as one. Lines that fit stay
+// as written.
 function reflow(lines, room, size, S) {
   const fits = (t) => measureText(t, size, S.charWidth) <= room;
   const out = [];
@@ -124,7 +128,7 @@ function measureBlock(b, room, size, S, align) {
         draw: (x, y, width, color) => lines.map((l, i) => richLine(l, at(x, width), y + ts * LINE * (i + 0.5), ts, color, anchor, S, { bold: true })).join('') };
     }
     case 'text': {
-      const lines = wrapRich(b.text, room, size, S);
+      const lines = wrapRich(reflow(String(b.text ?? '').split('\n'), room, size, S).join('\n'), room, size, S);
       return { w: Math.max(0, ...lines.map((l) => l.w)), h: lines.length * lh,
         draw: (x, y, width, color) => lines.map((l, i) => richLine(l, at(x, width), y + lh * (i + 0.5), size, color, anchor, S)).join('') };
     }
 
@@ -8,6 +8,8 @@ const opening = /[（「『【〔〈《\uff08([]$/u;
 const space = (t) => /^[ \t]+$/.test(t);
 
 export function measureText(text, size, charWidth, bold = false) {
+  text = String(text);
+  if (/^[\x20-\x7e]*$/.test(text)) return text.length * size * charWidth * (bold ? 1.07 : 1); // plain ASCII: no segmenting needed
   return graphemes(text).reduce((w, g) => w + (wide.test(g) ? Math.max(1, charWidth * 2) : /^\p{Mark}+$/u.test(g) ? 0 : charWidth) * size, 0) * (bold ? 1.07 : 1);
 }
 
@@ -51,6 +53,7 @@ export function wrapRuns(runs, room, widthOf, { preserveSpace = false } = {}) {
     }
     if (end < atoms.length) {
       if (lastBreak > start) end = lastBreak;
+      else if (!preserveSpace && !wide.test(atoms[start].t)) while (end < atoms.length && !preferred(end)) end++; // a Latin word longer than the line stays whole (its box grows)
       else {
         while (end > start && !allowed(end)) end--;
         if (end === start) {
 
@@ -9,8 +9,8 @@ const out = path.join(root, '_site');
 
 fs.rmSync(out, { recursive: true, force: true });
 fs.mkdirSync(path.join(out, 'lib'), { recursive: true });
-// The browser-side modules the player needs.
-for (const f of ['edit.js', 'render.js', 'styles.js', 'blocks.js', 'scenes.js']) fs.copyFileSync(path.join(root, 'lib', f), path.join(out, 'lib', f));
+// All of lib/, so a module the player starts importing can't be missing from the site (it was: chart.js, issue #1).
+for (const f of fs.readdirSync(path.join(root, 'lib')).filter((f) => f.endsWith('.js'))) fs.copyFileSync(path.join(root, 'lib', f), path.join(out, 'lib', f));
 for (const f of ['index.html', 'giotto-docs.json', 'styles.js', 'card.png']) fs.copyFileSync(path.join(root, 'site', f), path.join(out, f));
 fs.writeFileSync(path.join(out, '.nojekyll'), '');
 console.log(`Built ${out}`);
@@ -50,8 +50,9 @@ test('wrapText prefers word boundaries for English and Korean', () => {
   assert.deepEqual(wrapText('한국어 문장 확인', 35, size, charWidth), ['한국어', '문장', '확인']);
 });
 
-test('wrapText splits overlong words and unspaced Korean without losing content', () => {
-  assert.deepEqual(wrapText('abcdefgh', 15, size, charWidth), ['abc', 'def', 'gh']);
+test('wrapText keeps long Latin words whole, cuts code, and splits unspaced Korean without losing content', () => {
+  assert.deepEqual(wrapText('abcdefgh', 15, size, charWidth), ['abcdefgh']); // a Latin word stays whole; its box grows to fit
+  assert.deepEqual(wrapText('abcdefgh', 15, size, charWidth, { preserveSpace: true }), ['abc', 'def', 'gh']); // code is cut
   assert.deepEqual(wrapText('한국어문장', 20, size, charWidth), ['한국', '어문', '장']);
 });
Original file line number	Diff line number	Diff line change
`@@ -8,6 +8,8 @@ const opening = /[（「『【〔〈《\uff08([]$/u;`
`8`	`8`	`const space = (t) => /^[ \t]+$/.test(t);`
`9`	`9`
`10`	`10`	`export function measureText(text, size, charWidth, bold = false) {`
	`11`	`+ text = String(text);`
	`12`	`+ if (/^[\x20-\x7e]$/.test(text)) return text.length size * charWidth * (bold ? 1.07 : 1); // plain ASCII: no segmenting needed`
`11`	`13`	`return graphemes(text).reduce((w, g) => w + (wide.test(g) ? Math.max(1, charWidth * 2) : /^\p{Mark}+$/u.test(g) ? 0 : charWidth) * size, 0) * (bold ? 1.07 : 1);`
`12`	`14`	`}`
`13`	`15`
`@@ -51,6 +53,7 @@ export function wrapRuns(runs, room, widthOf, { preserveSpace = false } = {}) {`
`51`	`53`	`}`
`52`	`54`	`if (end < atoms.length) {`
`53`	`55`	`if (lastBreak > start) end = lastBreak;`
	`56`	`+ else if (!preserveSpace && !wide.test(atoms[start].t)) while (end < atoms.length && !preferred(end)) end++; // a Latin word longer than the line stays whole (its box grows)`
`54`	`57`	`else {`
`55`	`58`	`while (end > start && !allowed(end)) end--;`
`56`	`59`	`if (end === start) {`