diff --git a/CHANGELOG.md b/CHANGELOG.md
index 95689af3c..723b7f002 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -96,6 +96,29 @@ for this cycle.
   (`graph-compose-render-docx` / `graph-compose-render-pptx`) stay opt-in and are not
   bundled.
 
+## v1.9.1 — 2026-07-06
+
+Table columns now contain long inline-code content instead of letting it spill
+over the next column.
+
+### Bug fixes
+
+- **Long inline-code chips no longer overflow their column.** A long
+  `inlineCode(...)` / `inlineHighlight(...)` token with no spaces — a package
+  coordinate, fully-qualified class name or URL — now breaks *within* its
+  paragraph or table cell instead of drawing over the neighbouring content. It
+  breaks at `.` `:` `/` `-` seams and char-splits only when a segment is still
+  too wide, keeping the rounded chip fill intact on every wrapped fragment.
+  Applies to all three paragraph wrap paths (plain, inline, markdown); text that
+  already fits is laid out exactly as before.
+
+- **`auto()` table columns grow to fit composed cell content.** A composed cell
+  (`DocumentTableCell.node(...)`) in an `auto()` column now contributes its
+  intrinsic content width, so the column sizes to the content (e.g. an
+  inline-code chip) instead of collapsing toward zero. `fixed(...)` columns are
+  unchanged. As with plain-text auto columns, a table too narrow for the summed
+  intrinsic width of its auto columns reports `exceeds available width`.
+
 ## v1.9.0 — 2026-06-29
 
 In-document navigation. Rendered PDFs can now declare named **anchors** and
diff --git a/assets/readme/examples/inline-code-column-wrap.pdf b/assets/readme/examples/inline-code-column-wrap.pdf
new file mode 100644
index 000000000..c4f1ee395
Binary files /dev/null and b/assets/readme/examples/inline-code-column-wrap.pdf differ
diff --git a/examples/README.md b/examples/README.md
index 4d222bb27..1aadb5f4b 100644
--- a/examples/README.md
+++ b/examples/README.md
@@ -75,6 +75,7 @@ are with the canonical DSL, then jump to its detailed section below.
 | [Section presets](#section-presets) | `pageBackground`, `band`, `softPanel`, `accentLeft / Right / Top / Bottom`, per-corner `DocumentCornerRadius` | [PDF](../assets/readme/examples/section-presets.pdf) · [Source](src/main/java/com/demcha/examples/features/text/SectionPresetsExample.java) |
 | [Nested lists](#nested-lists-v16) | `ListBuilder.addItem(label, Consumer)` — depth cascade, per-depth markers, mixed flat / nested authoring | [PDF](../assets/readme/examples/nested-list-showcase.pdf) · [Source](src/main/java/com/demcha/examples/features/lists/NestedListExample.java) |
 | [Composed table cells](#composed-table-cells-v16) | `DocumentTableCell.node(DocumentNode)` — paragraphs, lists, sub-tables inside cells with two-pass measurement | [PDF](../assets/readme/examples/composed-table-cell-showcase.pdf) · [Source](src/main/java/com/demcha/examples/features/tables/ComposedTableCellExample.java) |
+| [Inline-code column wrap](#inline-code-column-wrap) | A long `inlineCode(...)` coordinate breaks at its `. : / -` seams inside a narrow **fixed** column and an **auto** column grows to fit it on one line | [PDF](../assets/readme/examples/inline-code-column-wrap.pdf) · [Source](src/main/java/com/demcha/examples/features/tables/InlineCodeColumnWrapExample.java) |
 | [Canvas layer (free placement)](#canvas-layer-v16) | `CanvasLayerNode` — pixel-precise `(x, y)` placement of children inside a fixed bounding box, with `ClipPolicy` clipping | [PDF](../assets/readme/examples/canvas-layer-showcase.pdf) · [Source](src/main/java/com/demcha/examples/features/canvas/CanvasLayerExample.java) |
 | [Transforms](#transforms) | `rotate`, `scale`, and per-layer `zIndex` swap | [PDF](../assets/readme/examples/transforms.pdf) · [Source](src/main/java/com/demcha/examples/features/transforms/TransformsExample.java) |
 | [Block alignment](#block-alignment) | `addAligned(align, node)` / `addSvgIcon(icon, w, align)` — seat any fixed-size node left / centre / right across the content width | [PDF](../assets/readme/examples/block-align.pdf) · [Source](src/main/java/com/demcha/examples/features/layout/BlockAlignExample.java) |
@@ -535,6 +536,44 @@ table.columns(...)
 [📄 View PDF](../assets/readme/examples/table-advanced.pdf) ·
 [📜 Full source](src/main/java/com/demcha/examples/features/tables/TableAdvancedExample.java)
 
+### Inline-code column wrap
+
+A composed cell holding one long `inlineCode(...)` token — a Maven coordinate,
+fully-qualified class name or URL — stays inside its column. In a narrow
+**fixed** column the chip breaks at its `. : / -` seams (char-splitting only
+when a segment is still too wide), with the rounded fill intact on every
+fragment; in an **auto** column the column grows to fit the coordinate on one
+line instead of collapsing.
+
+```java
+DocumentTableCell.node(document.dsl().paragraph()
+        .inlineCode("org.junit.jupiter:junit-jupiter:5.10.2").build())
+// fixed(104) column -> wraps at seams;  auto() column -> grows to one line
+```
+
+[📄 View PDF](../assets/readme/examples/inline-code-column-wrap.pdf) ·
+[📜 Full source](src/main/java/com/demcha/examples/features/tables/InlineCodeColumnWrapExample.java)
+
+### Custom Business Theme
+
+Build a `BusinessTheme` from raw `DocumentPalette` / `SpacingScale` /
+`TextScale` / `TablePreset` records — no factory shortcut. Plug it
+straight into `InvoiceTemplateV2` to retheme the whole template
+without touching any code that uses it.
+
+```java
+BusinessTheme studioEmerald = new BusinessTheme(
+        new DocumentPalette(/* page, surface, surfaceMuted, ink, accent, … */),
+        SpacingScale.cinematic(),
+        new TextScale(/* h1, h2, body, caption fonts … */),
+        TablePreset.cinematic());
+
+new InvoiceTemplateV2(studioEmerald).compose(document, invoice);
+```
+
+[📄 View PDF](../assets/readme/examples/invoice-custom-theme.pdf) ·
+[📜 Full source](src/main/java/com/demcha/examples/features/themes/CustomBusinessThemeExample.java)
+
 ---
 
 ## Public-API surface
diff --git a/examples/src/main/java/com/demcha/examples/GenerateAllExamples.java b/examples/src/main/java/com/demcha/examples/GenerateAllExamples.java
index b7fad09d7..67ae395c6 100644
--- a/examples/src/main/java/com/demcha/examples/GenerateAllExamples.java
+++ b/examples/src/main/java/com/demcha/examples/GenerateAllExamples.java
@@ -24,6 +24,7 @@
 import com.demcha.examples.features.streaming.HttpStreamingExample;
 import com.demcha.examples.features.svg.SvgIconGalleryExample;
 import com.demcha.examples.features.tables.ComposedTableCellExample;
+import com.demcha.examples.features.tables.InlineCodeColumnWrapExample;
 import com.demcha.examples.features.tables.TableAdvancedExample;
 import com.demcha.examples.features.text.EmojiGalleryExample;
 import com.demcha.examples.features.text.EmojiShortcodeExample;
@@ -151,6 +152,7 @@ public static void main(String[] args) throws Exception {
         // v1.6 layout primitives
         System.out.println("Generated: " + NestedListExample.generate());
         System.out.println("Generated: " + ComposedTableCellExample.generate());
+        System.out.println("Generated: " + InlineCodeColumnWrapExample.generate());
         System.out.println("Generated: " + CanvasLayerExample.generate());
 
         // v1.5 visual primitives
diff --git a/examples/src/main/java/com/demcha/examples/features/tables/InlineCodeColumnWrapExample.java b/examples/src/main/java/com/demcha/examples/features/tables/InlineCodeColumnWrapExample.java
new file mode 100644
index 000000000..37df23ee9
--- /dev/null
+++ b/examples/src/main/java/com/demcha/examples/features/tables/InlineCodeColumnWrapExample.java
@@ -0,0 +1,121 @@
+package com.demcha.examples.features.tables;
+
+import com.demcha.compose.GraphCompose;
+import com.demcha.compose.document.api.DocumentPageSize;
+import com.demcha.compose.document.api.DocumentSession;
+import com.demcha.compose.document.node.TableNode;
+import com.demcha.compose.document.style.DocumentColor;
+import com.demcha.compose.document.style.DocumentInsets;
+import com.demcha.compose.document.style.DocumentStroke;
+import com.demcha.compose.document.style.DocumentTextDecoration;
+import com.demcha.compose.document.style.DocumentTextStyle;
+import com.demcha.compose.document.table.DocumentTableCell;
+import com.demcha.compose.document.table.DocumentTableColumn;
+import com.demcha.compose.document.table.DocumentTableStyle;
+import com.demcha.compose.font.FontName;
+import com.demcha.examples.support.ExampleOutputPaths;
+
+import java.nio.file.Path;
+import java.util.List;
+
+/**
+ * Runnable showcase for long inline-code coordinates inside table columns.
+ *
+ * <p>A composed cell holding a single long {@code inlineCode(...)} token — a
+ * Maven coordinate, fully-qualified class name or URL — no longer overflows its
+ * column. In a narrow <b>fixed</b> column the chip breaks <em>inside</em> the
+ * cell, preferring its {@code . : / -} seams and char-splitting only as a last
+ * resort, with the rounded fill intact on every fragment. In an <b>auto</b>
+ * column the column grows to fit the coordinate on one line instead of
+ * collapsing.</p>
+ *
+ * @author Artem Demchyshyn
+ */
+public final class InlineCodeColumnWrapExample {
+
+    private static final DocumentColor INK = DocumentColor.rgb(34, 38, 50);
+    private static final DocumentColor MUTED = DocumentColor.rgb(102, 106, 118);
+    private static final DocumentColor RULE = DocumentColor.rgb(180, 188, 200);
+    private static final DocumentColor HEADER_FILL = DocumentColor.rgb(20, 60, 75);
+    private static final DocumentColor ROW_TINT = DocumentColor.rgb(244, 247, 252);
+
+    private static final List<String> COORDINATES = List.of(
+            "org.junit.jupiter:junit-jupiter:5.10.2",
+            "io.github.demchaav:graph-compose:1.9.0",
+            "https://repo1.maven.org/maven2/");
+
+    private InlineCodeColumnWrapExample() {
+    }
+
+    public static Path generate() throws Exception {
+        Path outputFile = ExampleOutputPaths.prepare("features/tables", "inline-code-column-wrap.pdf");
+
+        DocumentTextStyle title = DocumentTextStyle.builder()
+                .fontName(FontName.HELVETICA_BOLD).size(20).color(INK)
+                .decoration(DocumentTextDecoration.BOLD).build();
+        DocumentTextStyle caption = DocumentTextStyle.builder()
+                .fontName(FontName.HELVETICA_OBLIQUE).size(10).color(MUTED).build();
+        DocumentTextStyle body = DocumentTextStyle.builder()
+                .fontName(FontName.HELVETICA).size(10.5).color(INK).build();
+        DocumentTextStyle headerText = DocumentTextStyle.builder()
+                .fontName(FontName.HELVETICA_BOLD).size(11).color(DocumentColor.WHITE)
+                .decoration(DocumentTextDecoration.BOLD).build();
+
+        DocumentTableStyle headerStyle = DocumentTableStyle.builder()
+                .fillColor(HEADER_FILL).stroke(DocumentStroke.of(RULE, 0.6))
+                .padding(DocumentInsets.of(8)).textStyle(headerText).build();
+        DocumentTableStyle bodyCellStyle = DocumentTableStyle.builder()
+                .stroke(DocumentStroke.of(RULE, 0.6)).padding(DocumentInsets.of(8)).textStyle(body).build();
+        DocumentTableStyle tintedCellStyle = DocumentTableStyle.builder()
+                .fillColor(ROW_TINT).stroke(DocumentStroke.of(RULE, 0.6))
+                .padding(DocumentInsets.of(8)).textStyle(body).build();
+
+        try (DocumentSession document = GraphCompose.document(outputFile)
+                .pageSize(DocumentPageSize.A4)
+                .margin(36, 36, 36, 36)
+                .create()) {
+
+            document.pageFlow()
+                    .name("CodeWrapShowcase")
+                    .spacing(8)
+                    .addParagraph("Long inline-code coordinates stay inside the column", title)
+                    .addParagraph(
+                            "A composed cell with one long inlineCode(...) token used to spill over the "
+                                    + "next column. It now breaks at its . : / - seams inside a narrow FIXED "
+                                    + "column (char-splitting only when a segment is still too wide), and an "
+                                    + "AUTO column grows to fit it on one line.", caption)
+                    .build();
+
+            List<List<DocumentTableCell>> rows = new java.util.ArrayList<>();
+            rows.add(List.of(
+                    DocumentTableCell.text("Fixed 104pt").withStyle(headerStyle),
+                    DocumentTableCell.text("Auto").withStyle(headerStyle)));
+            for (int i = 0; i < COORDINATES.size(); i++) {
+                String coordinate = COORDINATES.get(i);
+                DocumentTableStyle cellStyle = i % 2 == 0 ? bodyCellStyle : tintedCellStyle;
+                rows.add(List.of(
+                        DocumentTableCell.node(document.dsl().paragraph().inlineCode(coordinate).build())
+                                .withStyle(cellStyle),
+                        DocumentTableCell.node(document.dsl().paragraph().inlineCode(coordinate).build())
+                                .withStyle(cellStyle)));
+            }
+
+            document.add(new TableNode(
+                    "CodeWrapTable",
+                    List.of(DocumentTableColumn.fixed(104),
+                            DocumentTableColumn.auto()),
+                    rows,
+                    bodyCellStyle,
+                    null,
+                    DocumentInsets.zero(),
+                    DocumentInsets.zero()));
+
+            document.buildPdf();
+        }
+        return outputFile;
+    }
+
+    public static void main(String[] args) throws Exception {
+        System.out.println("Generated: " + generate());
+    }
+}
diff --git a/examples/src/main/java/com/demcha/examples/flagships/EngineDeckExample.java b/examples/src/main/java/com/demcha/examples/flagships/EngineDeckExample.java
index c73a92547..112d91490 100644
--- a/examples/src/main/java/com/demcha/examples/flagships/EngineDeckExample.java
+++ b/examples/src/main/java/com/demcha/examples/flagships/EngineDeckExample.java
@@ -411,9 +411,13 @@ private static DocumentNode brandLine() {
 
     /** Version pill ("v1.8.0") with the codename centred beside it as a tag. */
     private static DocumentNode versionBlock() {
+        // Show the base version only: a dev/pre-release qualifier ("2.0.0-SNAPSHOT",
+        // "2.0.0-beta.1") is wider than the 96pt pill, and the engine wraps long
+        // tokens at their "." / "-" seams — the pill would break onto two lines.
+        String pillVersion = VERSION.replaceFirst("-.*$", "");
         DocumentNode pill = new ShapeContainerBuilder().name("VerPill")
                 .roundedRect(96, 30, 8).fillColor(VIOLET_DEEP)
-                .center(new ParagraphBuilder().text("v" + VERSION)
+                .center(new ParagraphBuilder().text("v" + pillVersion)
                         .textStyle(DocumentTextStyle.builder().fontName(FontName.HELVETICA_BOLD)
                                 .size(14).color(DocumentColor.WHITE).build())
                         .align(TextAlign.CENTER).margin(DocumentInsets.zero()).build())
diff --git a/pom.xml b/pom.xml
index c22dff16f..060771842 100644
--- a/pom.xml
+++ b/pom.xml
@@ -56,7 +56,7 @@
         <assertj.version>3.27.7</assertj.version>
         <junit.bom.version>6.1.1</junit.bom.version>
         <mockito.version>5.23.0</mockito.version>
-        <byteBuddy.version>1.18.10</byteBuddy.version>
+        <byteBuddy.version>1.18.11</byteBuddy.version>
 
         <!-- Bundled fonts / emoji, pulled in at test scope only. Pinned to the
              independent 1.0.0 line (not bumped in engine lockstep); keep in step
diff --git a/qa/src/test/java/com/demcha/compose/document/dsl/InlineHighlightRenderTest.java b/qa/src/test/java/com/demcha/compose/document/dsl/InlineHighlightRenderTest.java
index a504b94c2..f96287b68 100644
--- a/qa/src/test/java/com/demcha/compose/document/dsl/InlineHighlightRenderTest.java
+++ b/qa/src/test/java/com/demcha/compose/document/dsl/InlineHighlightRenderTest.java
@@ -150,18 +150,33 @@ void multiWordChipStaysOneSpanAndCollapsesNewlines() throws Exception {
     }
 
     @Test
-    void overWideAtomicChipRendersWithoutThrowing() throws Exception {
-        // A chip wider than the column is emitted on its own line (atomic);
-        // it must still render the text on one page without throwing.
+    void overWideChipBreaksWithinColumnWithoutThrowing() throws Exception {
+        // A single-word chip wider than the column breaks within it (at soft seams,
+        // char-split as a last resort): every visual fragment stays inside the inner
+        // width, keeps its rounded fill, and the coordinate survives end-to-end.
+        double innerWidth = 90 - 20;
+        List<ParagraphLine> lines;
         byte[] pdf;
         try (DocumentSession session = GraphCompose.document().pageSize(90, 140).margin(10, 10, 10, 10).create()) {
             session.dsl().pageFlow().name("Flow")
                     .addParagraph(p -> p.inlineCode("io.github.demchaav.a.very.long.package.name")).build();
+            lines = paragraphLines(session.layoutGraph());
             pdf = session.toPdfBytes();
         }
+        List<ParagraphLine> chipLines = lines.stream()
+                .filter(l -> l.spans().stream().anyMatch(s -> s instanceof ParagraphTextSpan ts && ts.background() != null))
+                .toList();
+        assertThat(chipLines).as("the over-wide chip breaks to >= 2 fragments").hasSizeGreaterThanOrEqualTo(2);
+        for (ParagraphLine line : chipLines) {
+            ParagraphTextSpan fragment = chipSpan(line);
+            assertThat(fragment.width()).as("each fragment stays inside the inner width")
+                    .isLessThanOrEqualTo(innerWidth + 0.5);
+            assertThat(fragment.background()).as("each fragment keeps its fill").isNotNull();
+        }
         try (PDDocument document = Loader.loadPDF(pdf)) {
             assertThat(document.getNumberOfPages()).isEqualTo(1);
-            assertThat(new PDFTextStripper().getText(document)).doesNotContain("?");
+            String text = new PDFTextStripper().getText(document).replaceAll("\\s+", "");
+            assertThat(text).contains("io.github.demchaav.a.very.long.package.name").doesNotContain("?");
         }
     }
 
@@ -336,6 +351,111 @@ void wrappedLinkedChipEmitsAClickableRectPerFragment() throws Exception {
         }
     }
 
+    @Test
+    void overWideCodeChipBreaksAtSoftSeams() throws Exception {
+        // A coordinate breaks at its . : / - joiners, not mid-identifier: at least
+        // one non-final fragment ends with a soft-break character.
+        List<ParagraphLine> lines;
+        try (DocumentSession session = GraphCompose.document().pageSize(120, 200).margin(10, 10, 10, 10).create()) {
+            session.dsl().pageFlow().name("Flow")
+                    .addParagraph(p -> p.inlineCode("org.junit.jupiter:junit-jupiter:5.10.2")).build();
+            lines = paragraphLines(session.layoutGraph());
+        }
+        List<ParagraphLine> chipLines = lines.stream()
+                .filter(l -> l.spans().stream().anyMatch(s -> s instanceof ParagraphTextSpan ts && ts.background() != null))
+                .toList();
+        assertThat(chipLines).hasSizeGreaterThanOrEqualTo(2);
+        boolean seamBreak = chipLines.subList(0, chipLines.size() - 1).stream()
+                .map(l -> chipSpan(l).text())
+                .anyMatch(t -> !t.isEmpty() && ".:/-".indexOf(t.charAt(t.length() - 1)) >= 0);
+        assertThat(seamBreak).as("the coordinate breaks at a . : / - seam, not mid-identifier").isTrue();
+    }
+
+    @Test
+    void overWidePlainTokenBreaksWithinColumn() throws Exception {
+        // The plain wrap path (no inline runs, no markdown): a lone over-wide first
+        // token char-splits within the column instead of overflowing it.
+        double innerWidth = 90 - 20;
+        String token = "abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz";
+        List<ParagraphLine> lines;
+        try (DocumentSession session = GraphCompose.document().pageSize(90, 160).margin(10, 10, 10, 10).create()) {
+            session.dsl().pageFlow().name("Flow").addParagraph(p -> p.text(token)).build();
+            lines = paragraphLines(session.layoutGraph());
+        }
+        assertThat(lines).as("the over-wide plain token breaks to >= 2 lines").hasSizeGreaterThanOrEqualTo(2);
+        for (ParagraphLine line : lines) {
+            assertThat(line.width()).as("each line stays inside the inner width").isLessThanOrEqualTo(innerWidth + 0.5);
+        }
+        String joined = lines.stream().flatMap(l -> l.spans().stream())
+                .filter(ParagraphTextSpan.class::isInstance).map(s -> ((ParagraphTextSpan) s).text())
+                .reduce("", String::concat).replaceAll("\\s+", "");
+        assertThat(joined).isEqualTo(token);
+    }
+
+    @Test
+    void overWideTokenInMarkdownBreaksWithinColumn() throws Exception {
+        // The markdown wrap path (markdown enabled + markdown syntax present): a lone
+        // over-wide token still breaks within the column.
+        double innerWidth = 90 - 20;
+        String token = "abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz";
+        List<ParagraphLine> lines;
+        try (DocumentSession session = GraphCompose.document().pageSize(90, 160).margin(10, 10, 10, 10).create()) {
+            session.markdown(true);
+            session.dsl().pageFlow().name("Flow").addParagraph(p -> p.text("**b** " + token)).build();
+            lines = paragraphLines(session.layoutGraph());
+        }
+        assertThat(lines).hasSizeGreaterThanOrEqualTo(2);
+        for (ParagraphLine line : lines) {
+            assertThat(line.width()).as("each line stays inside the inner width").isLessThanOrEqualTo(innerWidth + 0.5);
+        }
+        String joined = lines.stream().flatMap(l -> l.spans().stream())
+                .filter(ParagraphTextSpan.class::isInstance).map(s -> ((ParagraphTextSpan) s).text())
+                .reduce("", String::concat).replaceAll("\\s+", "");
+        assertThat(joined).as("the long token survives the break").contains(token);
+    }
+
+    @Test
+    void nonFirstOverWideChipBreaksWithinColumn() throws Exception {
+        // The over-wide chip is NOT the first token: leading prose is flushed, then
+        // the chip breaks on the following lines (it still fits none of them whole).
+        double innerWidth = 120 - 20;
+        List<ParagraphLine> lines;
+        try (DocumentSession session = GraphCompose.document().pageSize(120, 200).margin(10, 10, 10, 10).create()) {
+            session.dsl().pageFlow().name("Flow")
+                    .addParagraph(p -> p.inlineText("Use ").inlineCode("io.github.demchaav.a.very.long.package.name"))
+                    .build();
+            lines = paragraphLines(session.layoutGraph());
+        }
+        List<ParagraphLine> chipLines = lines.stream()
+                .filter(l -> l.spans().stream().anyMatch(s -> s instanceof ParagraphTextSpan ts && ts.background() != null))
+                .toList();
+        assertThat(chipLines).as("the trailing chip breaks to >= 2 fragments").hasSizeGreaterThanOrEqualTo(2);
+        for (ParagraphLine line : chipLines) {
+            assertThat(chipSpan(line).width()).isLessThanOrEqualTo(innerWidth + 0.5);
+        }
+    }
+
+    @Test
+    void overWideLinkedChipEmitsAClickableRectPerFragment() throws Exception {
+        // Char-split (single-word) linked chip: each visual fragment is independently
+        // clickable, mirroring the multi-word wrapped-chip guarantee.
+        byte[] pdf;
+        try (DocumentSession session = GraphCompose.document().pageSize(120, 200).margin(10, 10, 10, 10).create()) {
+            session.dsl().pageFlow().name("Flow")
+                    .addParagraph(p -> p.inlineHighlight(
+                            "io.github.demchaav.a.very.long.package.name", MONO, FILL, 3.0, PAD,
+                            new DocumentLinkOptions("https://example.com")))
+                    .build();
+            pdf = session.toPdfBytes();
+        }
+        try (PDDocument document = Loader.loadPDF(pdf)) {
+            long links = document.getPage(0).getAnnotations().stream()
+                    .filter(PDAnnotationLink.class::isInstance).count();
+            assertThat(links).as("a char-split linked chip is clickable on each fragment")
+                    .isGreaterThanOrEqualTo(2);
+        }
+    }
+
     private static byte[] render(Consumer<ParagraphBuilder> body) throws Exception {
         try (DocumentSession session = GraphCompose.document().pageSize(320, 140).margin(16, 16, 16, 16).create()) {
             session.dsl().pageFlow().name("Flow").addParagraph(body::accept).build();
diff --git a/qa/src/test/java/com/demcha/compose/document/table/TableAutoColumnComposedWidthTest.java b/qa/src/test/java/com/demcha/compose/document/table/TableAutoColumnComposedWidthTest.java
new file mode 100644
index 000000000..66afd93c5
--- /dev/null
+++ b/qa/src/test/java/com/demcha/compose/document/table/TableAutoColumnComposedWidthTest.java
@@ -0,0 +1,74 @@
+package com.demcha.compose.document.table;
+
+import com.demcha.compose.GraphCompose;
+import com.demcha.compose.document.api.DocumentSession;
+import com.demcha.compose.document.layout.PlacedFragment;
+import com.demcha.compose.document.layout.payloads.ParagraphFragmentPayload;
+import com.demcha.compose.document.layout.payloads.ParagraphTextSpan;
+import com.demcha.compose.document.node.TableNode;
+import com.demcha.compose.document.style.DocumentInsets;
+import org.junit.jupiter.api.Test;
+
+import java.util.List;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+/**
+ * An AUTO column sizes to fit a composed cell's intrinsic content (e.g. an
+ * inline-code chip) instead of collapsing to zero because the composed cell
+ * contributed no natural width. A FIXED column keeps its declared width, so an
+ * over-wide chip breaks inside it (handled by the paragraph wrap engine).
+ */
+class TableAutoColumnComposedWidthTest {
+
+    private static final String CODE = "io.github.demchaav";
+
+    /** Number of visual chip fragments (rounded-fill spans) rendered by the composed cell. */
+    private static long chipFragmentCount(DocumentSession session) {
+        return session.layoutGraph().fragments().stream()
+                .map(PlacedFragment::payload)
+                .filter(ParagraphFragmentPayload.class::isInstance)
+                .map(ParagraphFragmentPayload.class::cast)
+                .flatMap(payload -> payload.lines().stream())
+                .filter(line -> line.spans().stream()
+                        .anyMatch(s -> s instanceof ParagraphTextSpan ts && ts.background() != null))
+                .count();
+    }
+
+    private static TableNode chipTable(DocumentSession session, DocumentTableColumn column) {
+        return new TableNode(
+                "ChipTable",
+                List.of(column),
+                List.of(List.of(DocumentTableCell.node(session.dsl().paragraph().inlineCode(CODE).build()))),
+                DocumentTableStyle.empty(),
+                null,
+                DocumentInsets.zero(),
+                DocumentInsets.zero());
+    }
+
+    @Test
+    void autoColumnGrowsToFitComposedChipOnOneFragment() throws Exception {
+        try (DocumentSession session = GraphCompose.document()
+                .pageSize(300, 160)
+                .margin(DocumentInsets.of(10))
+                .create()) {
+            session.add(chipTable(session, DocumentTableColumn.auto()));
+            // The AUTO column sizes to the chip's natural width (the page is wide
+            // enough), so the chip renders on ONE fragment instead of collapsing to
+            // zero width and breaking character by character.
+            assertThat(chipFragmentCount(session)).isEqualTo(1);
+        }
+    }
+
+    @Test
+    void fixedNarrowColumnStillBreaksTheComposedChip() throws Exception {
+        try (DocumentSession session = GraphCompose.document()
+                .pageSize(300, 160)
+                .margin(DocumentInsets.of(10))
+                .create()) {
+            session.add(chipTable(session, DocumentTableColumn.fixed(40)));
+            // A FIXED column is never grown; the over-wide chip breaks inside it.
+            assertThat(chipFragmentCount(session)).isGreaterThanOrEqualTo(2);
+        }
+    }
+}
diff --git a/qa/src/test/java/com/demcha/compose/document/table/TableCellInlineCodeWrapTest.java b/qa/src/test/java/com/demcha/compose/document/table/TableCellInlineCodeWrapTest.java
new file mode 100644
index 000000000..c286f8d3a
--- /dev/null
+++ b/qa/src/test/java/com/demcha/compose/document/table/TableCellInlineCodeWrapTest.java
@@ -0,0 +1,110 @@
+package com.demcha.compose.document.table;
+
+import com.demcha.compose.GraphCompose;
+import com.demcha.compose.document.api.DocumentSession;
+import com.demcha.compose.document.layout.LayoutGraph;
+import com.demcha.compose.document.layout.PlacedFragment;
+import com.demcha.compose.document.layout.payloads.ParagraphFragmentPayload;
+import com.demcha.compose.document.layout.payloads.ParagraphLine;
+import com.demcha.compose.document.layout.payloads.ParagraphTextSpan;
+import com.demcha.compose.document.node.TableNode;
+import com.demcha.compose.document.style.DocumentInsets;
+import com.demcha.compose.testing.layout.LayoutSnapshotAssertions;
+import com.demcha.testing.VisualTestOutputs;
+import org.apache.pdfbox.Loader;
+import org.apache.pdfbox.pdmodel.PDDocument;
+import org.apache.pdfbox.text.PDFTextStripper;
+import org.junit.jupiter.api.Test;
+
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.List;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+/**
+ * Regression for the reported "long inline-code chip overflows its table column":
+ * a composed cell holding a single over-wide {@code inlineCode(...)} coordinate in a
+ * narrow fixed column must break the chip <em>inside</em> the cell (fill intact per
+ * fragment), never draw past the cell box, and never throw.
+ */
+class TableCellInlineCodeWrapTest {
+
+    /** Fixed column widths: a deliberately narrow middle column holds the chip. */
+    private static final double MIDDLE_CELL_WIDTH = 60.0;
+    private static final String COORDINATE = "org.junit.jupiter:junit-jupiter:5.10.2";
+
+    private static TableNode narrowCodeTable(DocumentSession session) {
+        DocumentTableCell left = DocumentTableCell.text("L");
+        DocumentTableCell mid = DocumentTableCell.node(
+                session.dsl().paragraph().inlineCode(COORDINATE).build());
+        DocumentTableCell right = DocumentTableCell.text("R");
+        return new TableNode(
+                "CodeTable",
+                List.of(DocumentTableColumn.fixed(40),
+                        DocumentTableColumn.fixed(MIDDLE_CELL_WIDTH),
+                        DocumentTableColumn.fixed(40)),
+                List.of(List.of(left, mid, right)),
+                DocumentTableStyle.empty(),
+                140.0,
+                DocumentInsets.zero(),
+                DocumentInsets.zero());
+    }
+
+    @Test
+    void narrowCellInlineCodeBreaksWithinCell() throws Exception {
+        byte[] pdf;
+        List<ParagraphLine> chipLines;
+        try (DocumentSession session = GraphCompose.document()
+                .pageSize(220, 200)
+                .margin(DocumentInsets.of(10))
+                .create()) {
+            session.add(narrowCodeTable(session));
+
+            LayoutGraph graph = session.layoutGraph();
+            chipLines = graph.fragments().stream()
+                    .map(PlacedFragment::payload)
+                    .filter(ParagraphFragmentPayload.class::isInstance)
+                    .map(ParagraphFragmentPayload.class::cast)
+                    .flatMap(payload -> payload.lines().stream())
+                    .filter(l -> l.spans().stream()
+                            .anyMatch(s -> s instanceof ParagraphTextSpan ts && ts.background() != null))
+                    .toList();
+            pdf = session.toPdfBytes();
+        }
+
+        assertThat(chipLines).as("the over-wide chip breaks to >= 2 fragments in the cell")
+                .hasSizeGreaterThanOrEqualTo(2);
+        for (ParagraphLine line : chipLines) {
+            ParagraphTextSpan fragment = (ParagraphTextSpan) line.spans().stream()
+                    .filter(s -> s instanceof ParagraphTextSpan ts && ts.background() != null)
+                    .findFirst().orElseThrow();
+            assertThat(fragment.width()).as("no chip fragment draws past the cell's inner width")
+                    .isLessThanOrEqualTo(MIDDLE_CELL_WIDTH + 0.5);
+            assertThat(fragment.background()).as("each fragment keeps its fill").isNotNull();
+        }
+
+        // Human-inspectable artifact: the chip wraps inside the middle column.
+        Path output = VisualTestOutputs.preparePdf("inline_code_wrap_narrow_cell", "tables");
+        Files.write(output, pdf);
+        assertThat(new String(pdf, 0, 8, StandardCharsets.US_ASCII)).startsWith("%PDF-");
+
+        try (PDDocument document = Loader.loadPDF(pdf)) {
+            assertThat(document.getNumberOfPages()).isEqualTo(1);
+            String text = new PDFTextStripper().getText(document).replaceAll("\\s+", "");
+            assertThat(text).contains(COORDINATE).doesNotContain("?");
+        }
+    }
+
+    @Test
+    void narrowCellInlineCodeLayoutSnapshot() throws Exception {
+        try (DocumentSession session = GraphCompose.document()
+                .pageSize(220, 200)
+                .margin(DocumentInsets.of(10))
+                .create()) {
+            session.add(narrowCodeTable(session));
+            LayoutSnapshotAssertions.assertMatches(session, "tables/inline_code_wrap_narrow_cell");
+        }
+    }
+}
diff --git a/qa/src/test/resources/layout-snapshots/tables/inline_code_wrap_narrow_cell.json b/qa/src/test/resources/layout-snapshots/tables/inline_code_wrap_narrow_cell.json
new file mode 100644
index 000000000..a12bf8cb6
--- /dev/null
+++ b/qa/src/test/resources/layout-snapshots/tables/inline_code_wrap_narrow_cell.json
@@ -0,0 +1,47 @@
+{
+  "formatVersion" : "2.0",
+  "canvas" : {
+    "pageWidth" : 220.0,
+    "pageHeight" : 200.0,
+    "innerWidth" : 200.0,
+    "innerHeight" : 180.0,
+    "margin" : {
+      "top" : 10.0,
+      "right" : 10.0,
+      "bottom" : 10.0,
+      "left" : 10.0
+    }
+  },
+  "totalPages" : 1,
+  "nodes" : [ {
+    "path" : "CodeTable[0]",
+    "entityName" : "CodeTable",
+    "entityKind" : "TableNode",
+    "parentPath" : null,
+    "childIndex" : 0,
+    "depth" : 1,
+    "layer" : 1,
+    "computedX" : 10.0,
+    "computedY" : 71.96,
+    "placementX" : 10.0,
+    "placementY" : 71.96,
+    "placementWidth" : 140.0,
+    "placementHeight" : 118.04,
+    "startPage" : 0,
+    "endPage" : 0,
+    "contentWidth" : 140.0,
+    "contentHeight" : 118.04,
+    "margin" : {
+      "top" : 0.0,
+      "right" : 0.0,
+      "bottom" : 0.0,
+      "left" : 0.0
+    },
+    "padding" : {
+      "top" : 0.0,
+      "right" : 0.0,
+      "bottom" : 0.0,
+      "left" : 0.0
+    }
+  } ]
+}
diff --git a/src/main/java/com/demcha/compose/document/layout/TableLayoutSupport.java b/src/main/java/com/demcha/compose/document/layout/TableLayoutSupport.java
index 1529d0f55..93be462fb 100644
--- a/src/main/java/com/demcha/compose/document/layout/TableLayoutSupport.java
+++ b/src/main/java/com/demcha/compose/document/layout/TableLayoutSupport.java
@@ -47,12 +47,13 @@ static ResolvedTableLayoutWithContents resolveTableLayout(TableNode node,
         List<List<LogicalCell>> logicalRows = buildLogicalRows(node, columnCount);
         List<TableColumnLayout> normalizedSpecs = normalizeSpecs(node, columnCount);
         TableCellLayoutStyle[][] stylesGrid = buildStylesGrid(node, logicalRows, columnCount);
-        double[] naturalWidths = resolveNaturalColumnWidths(node, normalizedSpecs, logicalRows, stylesGrid, columnCount, measurement);
+        double innerAvailableWidth = Math.max(0.0, availableWidth - node.padding().horizontal());
+        double[] naturalWidths = resolveNaturalColumnWidths(node, normalizedSpecs, logicalRows, stylesGrid,
+                columnCount, measurement, prepareContext, innerAvailableWidth);
         double naturalWidth = sum(naturalWidths);
         double[] finalWidths = resolveFinalColumnWidths(node, normalizedSpecs, naturalWidths, naturalWidth);
         double finalWidth = sum(finalWidths);
 
-        double innerAvailableWidth = Math.max(0.0, availableWidth - node.padding().horizontal());
         if (finalWidth > innerAvailableWidth + EPS) {
             throw new IllegalStateException("Table '" + displayName(node) + "' width " + finalWidth
                                             + " exceeds available width " + innerAvailableWidth + ".");
@@ -488,7 +489,9 @@ private static double[] resolveNaturalColumnWidths(TableNode node,
                                                        List<List<LogicalCell>> logicalRows,
                                                        TableCellLayoutStyle[][] stylesGrid,
                                                        int columnCount,
-                                                       TextMeasurementSystem measurement) {
+                                                       TextMeasurementSystem measurement,
+                                                       PrepareContext prepareContext,
+                                                       double innerAvailableWidth) {
         double[] widths = new double[columnCount];
         double[] singleCellRequired = new double[columnCount];
 
@@ -498,8 +501,12 @@ private static double[] resolveNaturalColumnWidths(TableNode node,
                     continue;
                 }
                 int col = logical.startColumn();
-                singleCellRequired[col] = Math.max(singleCellRequired[col],
-                        cellNaturalWidth(logical.sanitizedLines(), stylesGrid[rowIndex][col], measurement));
+                double required = composedAutoCellNaturalWidth(logical, normalizedSpecs.get(col),
+                        stylesGrid[rowIndex][col], prepareContext, innerAvailableWidth);
+                if (required < 0.0) {
+                    required = cellNaturalWidth(logical.sanitizedLines(), stylesGrid[rowIndex][col], measurement);
+                }
+                singleCellRequired[col] = Math.max(singleCellRequired[col], required);
             }
         }
 
@@ -596,6 +603,35 @@ private static double[] resolveFinalColumnWidths(TableNode node,
         return finalWidths;
     }
 
+    /**
+     * Natural width contribution of a composed cell that sits in an AUTO column:
+     * the child's intrinsic content width plus the cell padding, so the AUTO
+     * column grows to fit composed content (e.g. an inline-code chip) instead of
+     * being sized to zero by its plain-text siblings. The child is measured
+     * against the table's inner width, so the result is already clamped to what
+     * the table can give — it never forces the table past its available width.
+     *
+     * <p>Returns a negative sentinel when this is not a composed cell in an AUTO
+     * column, so the caller falls back to the plain-text {@link #cellNaturalWidth}
+     * formula. Composed cells in FIXED columns keep contributing nothing: the
+     * column width is fixed and an over-wide child wraps/breaks inside it.</p>
+     */
+    private static double composedAutoCellNaturalWidth(LogicalCell logical,
+                                                       TableColumnLayout spec,
+                                                       TableCellLayoutStyle style,
+                                                       PrepareContext prepareContext,
+                                                       double innerAvailableWidth) {
+        DocumentTableCell src = logical.source();
+        if (src == null || !src.hasComposedContent() || !spec.isAuto() || prepareContext == null) {
+            return -1.0;
+        }
+        Padding padding = style.padding() == null ? Padding.zero() : style.padding();
+        double childInner = Math.max(0.0, innerAvailableWidth - padding.horizontal());
+        double natural = prepareContext.prepare(src.content(), BoxConstraints.natural(childInner))
+                .measureResult().width();
+        return natural + padding.horizontal();
+    }
+
     private static double cellNaturalWidth(List<String> sanitizedLines,
                                            TableCellLayoutStyle style,
                                            TextMeasurementSystem measurement) {
diff --git a/src/main/java/com/demcha/compose/document/layout/TextFlowSupport.java b/src/main/java/com/demcha/compose/document/layout/TextFlowSupport.java
index f18ec44da..ef9b41802 100644
--- a/src/main/java/com/demcha/compose/document/layout/TextFlowSupport.java
+++ b/src/main/java/com/demcha/compose/document/layout/TextFlowSupport.java
@@ -827,32 +827,38 @@ private static List<String> wrapParagraph(List<String> logicalLines,
                 }
 
                 double nextTokenWidth = measurement.textWidth(style, nextToken);
-                if (!hasContent || currentWidth + nextTokenWidth <= maxWidth + EPS) {
+                if (currentWidth + nextTokenWidth <= maxWidth + EPS) {
                     currentLine.append(nextToken);
                     currentWidth += nextTokenWidth;
                     hasContent = true;
                     continue;
                 }
 
-                result.add(trimTrailingSpaces(currentLine.toString()));
-                currentPrefix = continuationPrefix;
-                currentLine.setLength(0);
-                currentLine.append(continuationPrefix);
-                currentWidth = measurement.textWidth(style, continuationPrefix);
-                hasContent = false;
-
-                double availableWidth = availableWidthForPrefix(maxWidth, currentPrefix, style, measurement);
+                // Does not fit. If the line already has content, flush it and retry
+                // the token on a fresh line before resorting to a break.
                 String strippedToken = nextToken.stripLeading();
                 double strippedTokenWidth = measurement.textWidth(style, strippedToken);
-                if (currentWidth + strippedTokenWidth <= maxWidth + EPS) {
+                if (hasContent) {
+                    result.add(trimTrailingSpaces(currentLine.toString()));
+                    currentPrefix = continuationPrefix;
                     currentLine.setLength(0);
-                    currentLine.append(currentPrefix).append(strippedToken);
-                    currentWidth += strippedTokenWidth;
-                    hasContent = true;
-                    continue;
+                    currentLine.append(continuationPrefix);
+                    currentWidth = measurement.textWidth(style, continuationPrefix);
+                    hasContent = false;
+
+                    if (currentWidth + strippedTokenWidth <= maxWidth + EPS) {
+                        currentLine.setLength(0);
+                        currentLine.append(currentPrefix).append(strippedToken);
+                        currentWidth += strippedTokenWidth;
+                        hasContent = true;
+                        continue;
+                    }
                 }
 
-                List<String> chunks = splitLongToken(strippedToken, style, availableWidth, measurement);
+                // Over-wide on a fresh (or already empty) line: break it at soft seams,
+                // char-splitting as a last resort.
+                double availableWidth = availableWidthForPrefix(maxWidth, currentPrefix, style, measurement);
+                List<String> chunks = TokenBreaking.breakLongToken(strippedToken, style, availableWidth, measurement);
                 if (chunks.isEmpty()) {
                     continue;
                 }
@@ -938,62 +944,81 @@ private static List<ParagraphLine> wrapInlineParagraph(List<InlineRun> runs,
                 }
 
                 double tokenWidth = sanitizedToken.wrapWidth();
-                if (currentLine.isEmpty() || currentWidth + tokenWidth <= maxWidth + EPS) {
+                if (currentWidth + tokenWidth <= maxWidth + EPS) {
                     currentLine.add(sanitizedToken);
                     currentWidth += tokenWidth;
                     continue;
                 }
 
+                // Does not fit. If the line already has content, flush it and retry
+                // the token on a fresh line before resorting to a break.
                 if (!currentLine.isEmpty()) {
                     result.add(toInlineParagraphLine(currentLine, defaultMetrics, measurement));
-                }
-                currentLine = new ArrayList<>();
-                if (!continuationPrefix.isEmpty()) {
-                    currentLine.add(InlineTextToken.of(continuationPrefix, defaultStyle, null, measurement));
-                }
-                currentWidth = inlineLineWidth(currentLine);
+                    currentLine = new ArrayList<>();
+                    if (!continuationPrefix.isEmpty()) {
+                        currentLine.add(InlineTextToken.of(continuationPrefix, defaultStyle, null, measurement));
+                    }
+                    currentWidth = inlineLineWidth(currentLine);
 
-                sanitizedToken = trimLeadingIfInlineLineStart(token, currentLine, measurement);
-                if (sanitizedToken == null) {
-                    continue;
-                }
-                tokenWidth = sanitizedToken.wrapWidth();
-                if (currentWidth + tokenWidth <= maxWidth + EPS) {
-                    currentLine.add(sanitizedToken);
-                    currentWidth += tokenWidth;
-                    continue;
+                    sanitizedToken = trimLeadingIfInlineLineStart(token, currentLine, measurement);
+                    if (sanitizedToken == null) {
+                        continue;
+                    }
+                    tokenWidth = sanitizedToken.wrapWidth();
+                    if (currentWidth + tokenWidth <= maxWidth + EPS) {
+                        currentLine.add(sanitizedToken);
+                        currentWidth += tokenWidth;
+                        continue;
+                    }
                 }
 
-                if (!(sanitizedToken instanceof InlineTextToken textToken)
-                        || textToken.highlightGroup() != null) {
-                    // Atomic runs that exceed the available width are emitted on their
-                    // own line; further breaking is not possible (image / shape / SVG,
-                    // and a single highlight-chip word — a chip wraps between its words
-                    // but a lone over-wide chip word is not char-split).
+                // Still over-wide on a fresh (or already empty) line. Text tokens —
+                // plain OR highlight chip — are broken within the column; a graphic
+                // (image / shape / SVG) has no break point and is emitted as-is.
+                if (!(sanitizedToken instanceof InlineTextToken textToken)) {
                     currentLine.add(sanitizedToken);
-                    currentWidth += tokenWidth;
+                    currentWidth += sanitizedToken.wrapWidth();
                     continue;
                 }
 
-                List<String> chunks = splitLongToken(
+                boolean chip = textToken.highlightGroup() != null;
+                // A chip fragment paints leadPad + glyphs + trailPad, but the break
+                // budgets glyphs only, so reserve the run's padding here to keep the
+                // coalesced fill inside the column. Interior fragments under-fill by
+                // at most that padding — cosmetic, and only on an over-wide chip.
+                double reserve = chip ? textToken.leadPad() + textToken.trailPad() : 0.0;
+                List<String> pieces = TokenBreaking.breakLongToken(
                         textToken.text(),
                         textToken.textStyle(),
-                        Math.max(1.0, maxWidth - currentWidth),
+                        Math.max(1.0, maxWidth - currentWidth - reserve),
                         measurement);
-                for (int chunkIndex = 0; chunkIndex < chunks.size(); chunkIndex++) {
-                    String chunk = chunks.get(chunkIndex);
-                    if (chunk.isEmpty()) {
+                for (int pieceIndex = 0; pieceIndex < pieces.size(); pieceIndex++) {
+                    String piece = pieces.get(pieceIndex);
+                    if (piece.isEmpty()) {
                         continue;
                     }
-                    InlineTextToken chunkToken = InlineTextToken.of(
-                            chunk,
-                            textToken.textStyle(),
-                            textToken.linkTarget(),
-                            measurement);
+                    // Chip pieces keep the run's group + background so the coalescer
+                    // paints one fill per fragment; the run's outer pad sits on the
+                    // first/last piece only, leaving the break seams open.
+                    InlineTextToken chunkToken = chip
+                            ? InlineTextToken.ofHighlight(
+                                    piece,
+                                    textToken.textStyle(),
+                                    textToken.linkTarget(),
+                                    textToken.background(),
+                                    textToken.highlightGroup(),
+                                    pieceIndex == 0 ? textToken.leadPad() : 0.0,
+                                    pieceIndex == pieces.size() - 1 ? textToken.trailPad() : 0.0,
+                                    measurement)
+                            : InlineTextToken.of(
+                                    piece,
+                                    textToken.textStyle(),
+                                    textToken.linkTarget(),
+                                    measurement);
                     currentLine.add(chunkToken);
-                    currentWidth += chunkToken.width();
+                    currentWidth += chunkToken.wrapWidth();
 
-                    if (chunkIndex < chunks.size() - 1) {
+                    if (pieceIndex < pieces.size() - 1) {
                         result.add(toInlineParagraphLine(currentLine, defaultMetrics, measurement));
                         currentLine = new ArrayList<>();
                         if (!continuationPrefix.isEmpty()) {
@@ -1064,33 +1089,35 @@ private static List<ParagraphLine> wrapMarkdownParagraph(List<String> logicalLin
                 }
 
                 double tokenWidth = measurement.textWidth(sanitizedToken.textStyle(), sanitizedToken.text());
-                if (currentLine.isEmpty() || currentWidth + tokenWidth <= maxWidth + EPS) {
+                if (currentWidth + tokenWidth <= maxWidth + EPS) {
                     currentLine.add(sanitizedToken);
                     currentWidth += tokenWidth;
                     continue;
                 }
 
+                // Does not fit. If the line already has content, flush it and retry
+                // the token on a fresh line before resorting to a break.
                 if (!currentLine.isEmpty()) {
                     result.add(toParagraphLine(currentLine, metrics, measurement));
-                }
-                currentLine = new ArrayList<>();
-                if (!continuationPrefix.isEmpty()) {
-                    currentLine.add(new TextDataBody(continuationPrefix, style));
-                }
-                currentWidth = lineWidth(currentLine, measurement);
+                    currentLine = new ArrayList<>();
+                    if (!continuationPrefix.isEmpty()) {
+                        currentLine.add(new TextDataBody(continuationPrefix, style));
+                    }
+                    currentWidth = lineWidth(currentLine, measurement);
 
-                sanitizedToken = trimLeadingIfLineStart(token, currentLine);
-                if (sanitizedToken == null || sanitizedToken.text().isEmpty()) {
-                    continue;
-                }
-                tokenWidth = measurement.textWidth(sanitizedToken.textStyle(), sanitizedToken.text());
-                if (currentWidth + tokenWidth <= maxWidth + EPS) {
-                    currentLine.add(sanitizedToken);
-                    currentWidth += tokenWidth;
-                    continue;
+                    sanitizedToken = trimLeadingIfLineStart(token, currentLine);
+                    if (sanitizedToken == null || sanitizedToken.text().isEmpty()) {
+                        continue;
+                    }
+                    tokenWidth = measurement.textWidth(sanitizedToken.textStyle(), sanitizedToken.text());
+                    if (currentWidth + tokenWidth <= maxWidth + EPS) {
+                        currentLine.add(sanitizedToken);
+                        currentWidth += tokenWidth;
+                        continue;
+                    }
                 }
 
-                List<String> chunks = splitLongToken(
+                List<String> chunks = TokenBreaking.breakLongToken(
                         sanitizedToken.text(),
                         sanitizedToken.textStyle(),
                         Math.max(1.0, maxWidth - currentWidth),
@@ -1604,54 +1631,6 @@ private static double lineWidth(List<TextDataBody> bodies,
         return width;
     }
 
-    private static List<String> splitLongToken(String token,
-                                               TextStyle style,
-                                               double maxWidth,
-                                               TextMeasurementSystem measurement) {
-        if (token == null || token.isEmpty()) {
-            return List.of();
-        }
-
-        List<String> pieces = new ArrayList<>();
-        String remaining = token;
-        while (!remaining.isEmpty()) {
-            int splitIndex = fitCharacters(remaining, style, maxWidth, measurement);
-            if (splitIndex <= 0 || splitIndex >= remaining.length()) {
-                pieces.add(remaining);
-                break;
-            }
-            pieces.add(remaining.substring(0, splitIndex));
-            remaining = remaining.substring(splitIndex).stripLeading();
-        }
-        return List.copyOf(pieces);
-    }
-
-    private static int fitCharacters(String text,
-                                     TextStyle style,
-                                     double maxWidth,
-                                     TextMeasurementSystem measurement) {
-        // Largest prefix length whose width fits. The fit predicate
-        // width(substring(0,n)) <= maxWidth is monotonic in n (each added char
-        // contributes a non-negative glyph advance), so the fitting lengths form
-        // a prefix [1..lastFitting] and a binary search finds the SAME boundary
-        // as the old linear scan — but in O(log n) width calls instead of
-        // measuring every growing prefix (which was O(n) calls and O(n^2)
-        // measured characters for a long unbreakable token).
-        int lastFitting = 0;
-        int low = 1;
-        int high = text.length();
-        while (low <= high) {
-            int mid = (low + high) >>> 1;
-            if (measurement.textWidth(style, text.substring(0, mid)) <= maxWidth + EPS) {
-                lastFitting = mid;
-                low = mid + 1;
-            } else {
-                high = mid - 1;
-            }
-        }
-        return lastFitting == 0 ? Math.min(1, text.length()) : lastFitting;
-    }
-
     private static String trimTrailingSpaces(String value) {
         int end = value.length();
         while (end > 0 && Character.isWhitespace(value.charAt(end - 1))) {
diff --git a/src/main/java/com/demcha/compose/document/layout/TokenBreaking.java b/src/main/java/com/demcha/compose/document/layout/TokenBreaking.java
new file mode 100644
index 000000000..136cb0a65
--- /dev/null
+++ b/src/main/java/com/demcha/compose/document/layout/TokenBreaking.java
@@ -0,0 +1,166 @@
+package com.demcha.compose.document.layout;
+
+import com.demcha.compose.engine.components.content.text.TextStyle;
+import com.demcha.compose.engine.measurement.TextMeasurementSystem;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import static com.demcha.compose.document.layout.NodeDefinitionSupport.EPS;
+
+/**
+ * Breaks a single over-wide, otherwise-unbreakable token into line-pieces that
+ * each fit a width budget. Prefers wrapping at readable soft seams
+ * ({@code . : / -}) so package coordinates, fully-qualified class names and URLs
+ * split naturally, and falls back to character-level splitting for a lone
+ * segment that is still too wide.
+ *
+ * <p>Extracted from {@link TextFlowSupport} (which enters only through
+ * {@link #breakLongToken}) so the pure breaking logic is unit-testable in
+ * isolation and does not grow the wrap-loop file. Package-private intentionally
+ * — engine surface, not public API.</p>
+ *
+ * @author Artem Demchyshyn
+ */
+final class TokenBreaking {
+
+    /**
+     * Characters after which a long, otherwise-unbreakable token may wrap. These
+     * are the joiners inside package coordinates, fully-qualified class names and
+     * URLs ({@code org.junit.jupiter:junit-jupiter:5.10.2}, {@code a/b/c}), so an
+     * over-wide code token breaks at a readable seam instead of mid-identifier.
+     */
+    private static final String SOFT_BREAK_AFTER_CHARS = ".:/-";
+
+    private TokenBreaking() {
+    }
+
+    /**
+     * Breaks a single over-wide token into line-pieces that each fit
+     * {@code maxWidth}. Prefers breaking at {@link #SOFT_BREAK_AFTER_CHARS soft
+     * seams} (after {@code . : / -}) so coordinates and URLs split naturally, and
+     * falls back to character-level {@link #splitLongToken splitting} for any lone
+     * segment still too wide (e.g. a long dot-less identifier). The returned pieces
+     * have the same shape the wrap loops consume — for a token with no soft seams
+     * the result is identical to a bare {@link #splitLongToken}.
+     */
+    static List<String> breakLongToken(String token,
+                                       TextStyle style,
+                                       double maxWidth,
+                                       TextMeasurementSystem measurement) {
+        if (token == null || token.isEmpty()) {
+            return List.of();
+        }
+        List<String> segments = softBreakSegments(token);
+        List<String> pieces = new ArrayList<>();
+        StringBuilder current = new StringBuilder();
+        double currentWidth = 0.0;
+        for (String segment : segments) {
+            double segmentWidth = measurement.textWidth(style, segment);
+            if (current.length() > 0 && currentWidth + segmentWidth > maxWidth + EPS) {
+                pieces.add(current.toString());
+                current.setLength(0);
+                currentWidth = 0.0;
+            }
+            if (current.length() == 0 && segmentWidth > maxWidth + EPS) {
+                // A single seam-delimited segment is itself too wide: char-split it.
+                // Every char-chunk but the last is a finished piece; the tail seeds
+                // the current piece so a following short segment can still join it.
+                List<String> chars = splitLongToken(segment, style, maxWidth, measurement);
+                for (int index = 0; index < chars.size() - 1; index++) {
+                    pieces.add(chars.get(index));
+                }
+                String tail = chars.get(chars.size() - 1);
+                current.append(tail);
+                currentWidth = measurement.textWidth(style, tail);
+            } else {
+                current.append(segment);
+                currentWidth += segmentWidth;
+            }
+        }
+        if (current.length() > 0) {
+            pieces.add(current.toString());
+        }
+        return List.copyOf(pieces);
+    }
+
+    /**
+     * Splits a token after each {@link #SOFT_BREAK_AFTER_CHARS soft-break
+     * character}, keeping the delimiter with the preceding segment
+     * ({@code org.junit.jupiter:} then {@code junit-jupiter:} then {@code 5.10.2}).
+     * A token with no such characters yields a single segment (itself).
+     */
+    static List<String> softBreakSegments(String token) {
+        if (token == null || token.isEmpty()) {
+            return List.of();
+        }
+        List<String> segments = new ArrayList<>();
+        int start = 0;
+        for (int index = 0; index < token.length(); index++) {
+            if (SOFT_BREAK_AFTER_CHARS.indexOf(token.charAt(index)) >= 0) {
+                segments.add(token.substring(start, index + 1));
+                start = index + 1;
+            }
+        }
+        if (start < token.length()) {
+            segments.add(token.substring(start));
+        }
+        return segments;
+    }
+
+    /**
+     * Character-level fallback: splits a token into the longest prefixes that each
+     * fit {@code maxWidth}, guaranteeing at least one character per piece.
+     */
+    static List<String> splitLongToken(String token,
+                                       TextStyle style,
+                                       double maxWidth,
+                                       TextMeasurementSystem measurement) {
+        if (token == null || token.isEmpty()) {
+            return List.of();
+        }
+
+        List<String> pieces = new ArrayList<>();
+        String remaining = token;
+        while (!remaining.isEmpty()) {
+            int splitIndex = fitCharacters(remaining, style, maxWidth, measurement);
+            if (splitIndex <= 0 || splitIndex >= remaining.length()) {
+                pieces.add(remaining);
+                break;
+            }
+            pieces.add(remaining.substring(0, splitIndex));
+            remaining = remaining.substring(splitIndex).stripLeading();
+        }
+        return List.copyOf(pieces);
+    }
+
+    /**
+     * Largest prefix length of {@code text} whose width fits {@code maxWidth},
+     * or 1 (the guaranteed minimum) when not even the first character fits.
+     */
+    static int fitCharacters(String text,
+                             TextStyle style,
+                             double maxWidth,
+                             TextMeasurementSystem measurement) {
+        // Largest prefix length whose width fits. The fit predicate
+        // width(substring(0,n)) <= maxWidth is monotonic in n (each added char
+        // contributes a non-negative glyph advance), so the fitting lengths form
+        // a prefix [1..lastFitting] and a binary search finds the SAME boundary
+        // as the old linear scan — but in O(log n) width calls instead of
+        // measuring every growing prefix (which was O(n) calls and O(n^2)
+        // measured characters for a long unbreakable token).
+        int lastFitting = 0;
+        int low = 1;
+        int high = text.length();
+        while (low <= high) {
+            int mid = (low + high) >>> 1;
+            if (measurement.textWidth(style, text.substring(0, mid)) <= maxWidth + EPS) {
+                lastFitting = mid;
+                low = mid + 1;
+            } else {
+                high = mid - 1;
+            }
+        }
+        return lastFitting == 0 ? Math.min(1, text.length()) : lastFitting;
+    }
+}
diff --git a/src/test/java/com/demcha/compose/document/layout/TokenBreakingTest.java b/src/test/java/com/demcha/compose/document/layout/TokenBreakingTest.java
new file mode 100644
index 000000000..e7001f7d1
--- /dev/null
+++ b/src/test/java/com/demcha/compose/document/layout/TokenBreakingTest.java
@@ -0,0 +1,136 @@
+package com.demcha.compose.document.layout;
+
+import com.demcha.compose.engine.components.content.text.TextStyle;
+import com.demcha.compose.engine.components.geometry.ContentSize;
+import com.demcha.compose.engine.measurement.TextMeasurementSystem;
+import org.junit.jupiter.api.Test;
+
+import java.util.List;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+/**
+ * Direct unit coverage for {@link TokenBreaking} — soft-seam segmentation, greedy
+ * packing, and the character-level fallback — driven by a deterministic
+ * fixed-width measurement so the assertions do not depend on real font metrics.
+ */
+class TokenBreakingTest {
+
+    private static final TextStyle STYLE = TextStyle.DEFAULT_STYLE;
+    /** Each character is exactly 1.0 wide, so a token's width equals its length. */
+    private static final TextMeasurementSystem UNIT = new FixedWidthMeasurement(1.0);
+
+    // ── softBreakSegments (pure, no measurement) ────────────────────────────
+
+    @Test
+    void softBreakSegmentsSplitsAfterEachSeamKeepingTheDelimiter() {
+        assertThat(TokenBreaking.softBreakSegments("org.junit.jupiter:junit-jupiter:5.10.2"))
+                .containsExactly("org.", "junit.", "jupiter:", "junit-", "jupiter:", "5.", "10.", "2");
+    }
+
+    @Test
+    void softBreakSegmentsWithNoSeamReturnsTheWholeToken() {
+        assertThat(TokenBreaking.softBreakSegments("abcdefgh")).containsExactly("abcdefgh");
+    }
+
+    @Test
+    void softBreakSegmentsHandlesLeadingAndTrailingDelimiters() {
+        assertThat(TokenBreaking.softBreakSegments("/a/b")).containsExactly("/", "a/", "b");
+        assertThat(TokenBreaking.softBreakSegments("...")).containsExactly(".", ".", ".");
+        // The concatenation of the segments always reconstructs the input.
+        assertThat(String.join("", TokenBreaking.softBreakSegments("a.b:c/d-e"))).isEqualTo("a.b:c/d-e");
+    }
+
+    @Test
+    void softBreakSegmentsOnNullOrEmptyIsEmpty() {
+        assertThat(TokenBreaking.softBreakSegments(null)).isEmpty();
+        assertThat(TokenBreaking.softBreakSegments("")).isEmpty();
+    }
+
+    // ── fitCharacters ───────────────────────────────────────────────────────
+
+    @Test
+    void fitCharactersReturnsTheLongestFittingPrefix() {
+        assertThat(TokenBreaking.fitCharacters("abcdefgh", STYLE, 3.0, UNIT)).isEqualTo(3);
+    }
+
+    @Test
+    void fitCharactersReturnsAtLeastOneCharBelowGlyphWidth() {
+        assertThat(TokenBreaking.fitCharacters("abc", STYLE, 0.4, UNIT)).isEqualTo(1);
+    }
+
+    // ── splitLongToken (char-level) ─────────────────────────────────────────
+
+    @Test
+    void splitLongTokenBreaksIntoFittingChunks() {
+        assertThat(TokenBreaking.splitLongToken("abcdefgh", STYLE, 3.0, UNIT))
+                .containsExactly("abc", "def", "gh");
+    }
+
+    // ── breakLongToken (seam-aware, char-split fallback) ────────────────────
+
+    @Test
+    void breakLongTokenWithoutSeamsMatchesSplitLongToken() {
+        List<String> viaBreak = TokenBreaking.breakLongToken("abcdefgh", STYLE, 3.0, UNIT);
+        List<String> viaSplit = TokenBreaking.splitLongToken("abcdefgh", STYLE, 3.0, UNIT);
+        assertThat(viaBreak).isEqualTo(viaSplit).containsExactly("abc", "def", "gh");
+    }
+
+    @Test
+    void breakLongTokenReturnsTheWholeTokenWhenItAlreadyFits() {
+        // A no-seam token that fits the budget is returned as a single piece.
+        assertThat(TokenBreaking.breakLongToken("abc", STYLE, 10.0, UNIT)).containsExactly("abc");
+    }
+
+    @Test
+    void breakLongTokenPacksSegmentsAtSeams() {
+        // "org." + "junit." fill width 10 exactly; "jupiter" starts a new piece.
+        assertThat(TokenBreaking.breakLongToken("org.junit.jupiter", STYLE, 10.0, UNIT))
+                .containsExactly("org.junit.", "jupiter");
+    }
+
+    @Test
+    void breakLongTokenCharSplitsAnOverWideSegment() {
+        // "verylongsegment." (16) exceeds width 5, so it char-splits; the tail seeds
+        // the piece that the following short "x" segment then joins.
+        assertThat(TokenBreaking.breakLongToken("verylongsegment.x", STYLE, 5.0, UNIT))
+                .containsExactly("veryl", "ongse", "gment", ".x");
+    }
+
+    @Test
+    void breakLongTokenEveryPieceFitsAndReconstructsTheInput() {
+        for (String token : List.of(
+                "org.junit.jupiter:junit-jupiter:5.10.2",
+                "https://repo1.maven.org/maven2/",
+                "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa")) {
+            for (double width : new double[] {1.0, 4.0, 7.0, 12.0}) {
+                List<String> pieces = TokenBreaking.breakLongToken(token, STYLE, width, UNIT);
+                assertThat(String.join("", pieces))
+                        .as("pieces reconstruct the token at width %s", width).isEqualTo(token);
+                assertThat(pieces).allSatisfy(piece ->
+                        assertThat((double) piece.length())
+                                .as("each piece fits width %s", width)
+                                .isLessThanOrEqualTo(width + 1e-6));
+            }
+        }
+    }
+
+    @Test
+    void breakLongTokenEmptyOrNullReturnsEmpty() {
+        assertThat(TokenBreaking.breakLongToken("", STYLE, 5.0, UNIT)).isEmpty();
+        assertThat(TokenBreaking.breakLongToken(null, STYLE, 5.0, UNIT)).isEmpty();
+    }
+
+    /** Deterministic measurement: width == character count * unit; metrics are inert. */
+    private record FixedWidthMeasurement(double unit) implements TextMeasurementSystem {
+        @Override
+        public ContentSize measure(TextStyle style, String text) {
+            return new ContentSize(text.length() * unit, unit);
+        }
+
+        @Override
+        public LineMetrics lineMetrics(TextStyle style) {
+            return new LineMetrics(unit, 0.0, 0.0);
+        }
+    }
+}
diff --git a/web/styles.css b/web/styles.css
index e025c7f20..e1799be46 100644
--- a/web/styles.css
+++ b/web/styles.css
@@ -1246,6 +1246,8 @@ code[class*="language-"] .token.class-name {
   font-size: 0.82rem;
   font-weight: 660;
   text-decoration: none;
+  white-space: nowrap;
+  flex-shrink: 0;
   transition: all 0.15s ease;
 }
 
@@ -1435,6 +1437,7 @@ code[class*="language-"] .token.class-name {
 
 .lightbox-title {
   margin: 0;
+  min-width: 0; /* let the title absorb the squeeze (wrap) instead of the buttons */
   color: #f8fafc; /* lightbox overlay is always dark in both themes */
   font-size: 1.05rem;
   font-weight: 720;
@@ -1445,6 +1448,7 @@ code[class*="language-"] .token.class-name {
   display: flex;
   gap: 10px;
   align-items: center;
+  flex-shrink: 0; /* actions keep their full size regardless of title length */
 }
 
 .lightbox-close {