Release v1.4.1 — restore README guards dropped by v1.4.0 rewrite

CI on the v1.4.0 main commit failed DocumentationCoverageTest because
the README rewrite removed three structural sections that the test
baselines:

- ## Table component (canonical addTable / DocumentTableColumn snippet)
- ## Line primitive (canonical addDivider / addShape snippet)
- ## Architecture at a glance (mermaid diagram)

This patch re-adds the three sections (with the table snippet now also
pointing readers at the v1.4 column-span feature) and bumps the project
version to 1.4.1. Documentation-only patch release; no public API
changes.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: DemchaAV

CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## v1.4.1 - 2026-04-27
+
+### Documentation
+
+- README rewrite for v1.4.0 dropped three structural sections (`## Table component`, `## Line primitive`, `## Architecture at a glance`) that the `DocumentationCoverageTest` guards baseline. CI flagged the regression on the `main` branch; v1.4.1 restores the sections (the table snippet now also points readers to the new column-span feature), keeps the canonical-DSL anti-patterns out of the snippets, and moves the architecture mermaid diagram back into its dedicated section.
+
+### Tooling
+
+- `examples/src/main/java/com/demcha/examples/GenerateAllExamples.java` now wires `CinematicProposalFileExample.generate()` into the orchestrator, so the runnable examples module produces all seven fixtures (including `project-proposal-cinematic.pdf`) used by the README visual previews.
+
+This is a documentation-only patch release. There are no public API changes; v1.4.0 consumers can upgrade with no code changes.
+
+---
+
 ## v1.4.0 - 2026-04-27
 
 ### Headline — "cinematic document engine"

README.md

@@ -346,17 +346,61 @@ To bless a fresh baseline, set `-Dgraphcompose.visual.approve=true` (or `GRAPHCO
 
 ---
 
-## Extending GraphCompose
+## Table component
 
-GraphCompose is built around explicit seams — you do not have to fork the library to add a new node, a new backend, or a new template family.
+```java
+import com.demcha.compose.document.style.DocumentColor;
+import com.demcha.compose.document.style.DocumentInsets;
+import com.demcha.compose.document.table.DocumentTableColumn;
+import com.demcha.compose.document.table.DocumentTableStyle;
+
+document.pageFlow()
+        .name("StatusSection")
+        .spacing(12)
+        .addTable(table -> table
+                .name("StatusTable")
+                .columns(
+                        DocumentTableColumn.fixed(90),
+                        DocumentTableColumn.auto(),
+                        DocumentTableColumn.auto())
+                .width(520)
+                .defaultCellStyle(DocumentTableStyle.builder()
+                        .padding(DocumentInsets.of(6))
+                        .build())
+                .headerStyle(DocumentTableStyle.builder()
+                        .fillColor(DocumentColor.LIGHT_GRAY)
+                        .padding(DocumentInsets.of(6))
+                        .build())
+                .header("Role", "Owner", "Status")
+                .rows(
+                        new String[]{"Engine", "GraphCompose", "Stable"},
+                        new String[]{"Feature", "Table Builder", "Canonical"}))
+        .build();
+```
 
-- **Add a new semantic node.** Implement `DocumentNode`, register a `NodeDefinition<MyNode>` with the `NodeRegistry`, and the layout compiler picks it up. The definition controls measurement, pagination policy, splitting, and fragment emission. See [`com.demcha.compose.document.layout.NodeDefinition`](./src/main/java/com/demcha/compose/document/layout/NodeDefinition.java) and the built-ins in `BuiltInNodeDefinitions` for the established pattern.
-- **Add a fragment payload.** Reuse `BuiltInNodeDefinitions.ShapeFragmentPayload` / `ParagraphFragmentPayload` / `LineFragmentPayload` / `BarcodeFragmentPayload` / `ImageFragmentPayload` &mdash; or define your own and register a matching `PdfFragmentRenderHandler`. The PDF backend dispatches by payload type.
-- **Add a fluent builder.** Extend `AbstractFlowBuilder<T, N>` to inherit `addParagraph / addTable / addRow / addSection / addRich / softPanel / accent*` etc. for free.
-- **Add a backend.** Implement `FixedLayoutBackend<R>` (PDF-style) or `SemanticBackend` (DOCX/PPTX-style) and consume the resolved `LayoutGraph`. Page background, layer stacks, spans, and theme tokens are all expressed in canonical fragment types &mdash; no engine internals needed.
-- **Test for layout regressions.** Use `LayoutSnapshotAssertions` (graph-level) and `PdfVisualRegression` (pixel-level). Both ship in test scope, both gate at the snapshot/baseline level so you can refactor with confidence.
+For totals rows, header groupings, and full-width section dividers, combine the snippet above with `DocumentTableCell.text(...).colSpan(n)` &mdash; see [Column spans](#column-spans).
 
-The architecture diagram:
+## Line primitive
+
+```java
+import com.demcha.compose.document.style.DocumentColor;
+
+document.pageFlow()
+        .name("LinePrimitives")
+        .spacing(12)
+        .addDivider(divider -> divider
+                .name("HorizontalRule")
+                .width(220)
+                .thickness(3)
+                .color(DocumentColor.ROYAL_BLUE))
+        .addShape(shape -> shape
+                .name("VerticalAccent")
+                .size(3, 90)
+                .fillColor(DocumentColor.ORANGE))
+        .build();
+```
+
+## Architecture at a glance
 
 ```mermaid
 graph TD
@@ -382,6 +426,16 @@ graph TD
 
 Public authoring lives in `com.demcha.compose`, `document.api`, `document.dsl`, `document.node`, `document.style`, `document.table`, `document.theme` (v1.4), and `font`. Engine internals live under `com.demcha.compose.engine.*` and are not the recommended application API; they are guarded by `PublicApiNoEngineLeakTest`.
 
+## Extending GraphCompose
+
+GraphCompose is built around explicit seams &mdash; you do not have to fork the library to add a new node, a new backend, or a new template family.
+
+- **Add a new semantic node.** Implement `DocumentNode`, register a `NodeDefinition<MyNode>` with the `NodeRegistry`, and the layout compiler picks it up. The definition controls measurement, pagination policy, splitting, and fragment emission. See [`com.demcha.compose.document.layout.NodeDefinition`](./src/main/java/com/demcha/compose/document/layout/NodeDefinition.java) and the built-ins in `BuiltInNodeDefinitions` for the established pattern.
+- **Add a fragment payload.** Reuse `BuiltInNodeDefinitions.ShapeFragmentPayload` / `ParagraphFragmentPayload` / `LineFragmentPayload` / `BarcodeFragmentPayload` / `ImageFragmentPayload` &mdash; or define your own and register a matching `PdfFragmentRenderHandler`. The PDF backend dispatches by payload type.
+- **Add a fluent builder.** Extend `AbstractFlowBuilder<T, N>` to inherit `addParagraph / addTable / addRow / addSection / addRich / softPanel / accent*` etc. for free.
+- **Add a backend.** Implement `FixedLayoutBackend<R>` (PDF-style) or `SemanticBackend` (DOCX/PPTX-style) and consume the resolved `LayoutGraph`. Page background, layer stacks, spans, and theme tokens are all expressed in canonical fragment types &mdash; no engine internals needed.
+- **Test for layout regressions.** Use `LayoutSnapshotAssertions` (graph-level) and `PdfVisualRegression` (pixel-level). Both ship in test scope, both gate at the snapshot/baseline level so you can refactor with confidence.
+
 ## Performance (v1.4)
 
 All numbers below come from `scripts/run-benchmarks.ps1` &mdash; the full local benchmark workflow that builds the test classpath once and runs `current-speed`, `comparative`, `core-engine`, `full-cv`, `scalability`, and `stress` suites in sequence. They were captured on a developer laptop; CI machines are typically 1.5&ndash;2&times; slower.

examples/pom.xml

@@ -6,12 +6,12 @@
 
     <groupId>io.github.demchaav</groupId>
     <artifactId>graphcompose-examples</artifactId>
-    <version>1.4.0</version>
+    <version>1.4.1</version>
     <name>GraphCompose Examples</name>
     <description>Runnable file-render examples for GraphCompose templates.</description>
 
     <properties>
-        <graphcompose.version>1.4.0</graphcompose.version>
+        <graphcompose.version>1.4.1</graphcompose.version>
         <logback.version>1.5.18</logback.version>
         <maven.compiler.release>21</maven.compiler.release>
     </properties>

pom.xml

@@ -6,7 +6,7 @@
 
     <groupId>io.github.demchaav</groupId>
     <artifactId>graphcompose</artifactId>
-    <version>1.4.0</version>
+    <version>1.4.1</version>
 
     <name>GraphCompose</name>
     <description>A declarative layout engine for programmatic document generation, implemented primarily in Java.</description>