@zseven-w/pen-core 0.7.1 → 0.7.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zseven-w/pen-core",
-  "version": "0.7.1",
+  "version": "0.7.3",
   "description": "Core document operations, tree utils, variables, layout engine for OpenPencil",
   "homepage": "https://github.com/ZSeven-W/openpencil/tree/main/packages/pen-core",
   "bugs": {
@@ -30,7 +30,7 @@
     "typecheck": "tsc --noEmit"
   },
   "dependencies": {
-    "@zseven-w/pen-types": "0.7.1",
+    "@zseven-w/pen-types": "0.7.3",
     "nanoid": "^5.1.6",
     "paper": "^0.12.18"
   },

package/src/__tests__/strip-redundant-section-fills.test.ts

@@ -235,6 +235,58 @@ describe('stripRedundantSectionFills', () => {
     expect((deepInner as PenNode & { fill?: unknown }).fill).toEqual(solidFill('#0A0A0A'));
   });
 
+  it('strips stale #FFFFFF section fills on a dark root (legacy alternation residue)', () => {
+    // Regression guard for 2026-04-15: the legacy fixSectionAlternation
+    // painted #FFFFFF / #F8FAFC on unfilled section runs regardless of
+    // page theme. After the alternation skip for dark parents landed,
+    // stale docs (and weak-model hedges) still carry those whites.
+    // stripRedundantSectionFills must now clean them up.
+    const section1 = frame({
+      id: 's1',
+      name: 'Hero',
+      role: 'hero',
+      fill: solidFill('#FFFFFF'),
+    });
+    const section2 = frame({
+      id: 's2',
+      name: 'Stats',
+      role: 'stats-section',
+      fill: solidFill('#F8FAFC'),
+    });
+    const section3 = frame({
+      id: 's3',
+      name: 'CTA',
+      role: 'cta-section',
+      fill: solidFill('#FFFFFF'),
+    });
+    const root = frame({
+      id: 'root',
+      fill: solidFill('#111111'),
+      children: [section1, section2, section3],
+    });
+    const changed = stripRedundantSectionFills(root);
+    expect(changed).toBe(true);
+    expect((section1 as PenNode & { fill?: unknown }).fill).toBeUndefined();
+    expect((section2 as PenNode & { fill?: unknown }).fill).toBeUndefined();
+    expect((section3 as PenNode & { fill?: unknown }).fill).toBeUndefined();
+  });
+
+  it('strips a safe-light hedge even when the root has no fill', () => {
+    // Mirror of the existing "root frame without a fill" dark case: a
+    // bare #FFFFFF on a section root is almost certainly the sub-agent
+    // hedging against a missing background spec, not a deliberate choice.
+    const section = frame({
+      id: 'sec',
+      fill: solidFill('#FAFAFA'),
+    });
+    const root = frame({
+      id: 'root',
+      children: [section],
+    });
+    stripRedundantSectionFills(root);
+    expect((section as PenNode & { fill?: unknown }).fill).toBeUndefined();
+  });
+
   it('reproduces the M2.7 health-tracker case', () => {
     // Direct repro of the actual failure: root #1a1a2e, six section roots
     // all hardcoded #0A0A0A, including one real card. The six section

package/src/layout/strip-redundant-section-fills.ts

@@ -126,13 +126,41 @@ const SAFE_DARK_HEXES = new Set([
   '#202020',
 ]);
 
+/**
+ * Light-mode counterparts of SAFE_DARK_HEXES. Two sources produce these
+ * on section roots:
+ *   1. Weaker sub-agents that hedge with pure white / near-white instead
+ *      of the role-correct transparent fill.
+ *   2. The legacy `fixSectionAlternation` post-pass that painted an
+ *      #FFFFFF / #F8FAFC ladder on every run of ≥3 unfilled sections.
+ *      On dark pages that ladder leaves visible white strips; if a doc
+ *      with those stale fills is re-opened or re-rendered after the
+ *      alternation skip landed, the fills are still there and the skip
+ *      alone won't remove them.
+ * Treat these the same as safe-dark hedges: strip on any section root.
+ */
+const SAFE_LIGHT_HEXES = new Set([
+  '#ffffff',
+  '#fff',
+  '#fefefe',
+  '#fdfdfd',
+  '#fcfcfc',
+  '#fafafa',
+  '#f9fafb',
+  '#f8f8f8',
+  '#f8fafc',
+  '#f5f5f5',
+  '#f4f4f5',
+  '#f3f4f6',
+]);
+
 function shouldStripFill(childFill: string, rootFill: string | null): boolean {
   const childKey = normalizeHex(childFill);
   if (rootFill) {
     const rootKey = normalizeHex(rootFill);
     if (childKey === rootKey) return true;
   }
-  return SAFE_DARK_HEXES.has(childKey);
+  return SAFE_DARK_HEXES.has(childKey) || SAFE_LIGHT_HEXES.has(childKey);
 }
 
 function normalizeHex(color: string): string {