@oscharko-dev/keiko 0.2.0-beta.2 → 0.2.0-beta.4

package/node_modules/@oscharko-dev/keiko-quality-intelligence/dist/domain/figma/normalize.js

@@ -3,6 +3,17 @@
 // Projects each kept node to a compact `IrNode`: id/name/type, text content, bounding box, image
 // fill refs, kept children, and a best-effort `interactionHint`.
 //
+// In addition to the structural fields, five additive optional fields are projected when present:
+//   layout     — auto-layout direction/gap/padding/alignment (HORIZONTAL/VERTICAL layoutMode)
+//   sizing     — per-axis sizing mode (layoutSizingHorizontal/Vertical: FIXED|HUG|FILL)
+//   cornerRadius — corner radius in pixels (cornerRadius > 0)
+//   typography — per-TEXT fontFamily/fontSize/fontWeight (from the `style` block)
+//
+// These fields are OMITTED when absent or when the source values are missing/malformed — never
+// defaulted. They are hash-neutral (#753/#735): re-normalizing the same structural design after
+// these fields ship does not change the drift identity. Negative, NaN, and non-finite values are
+// clamped to absent.
+//
 // The interaction hint is a HINT, never load-bearing — downstream (#754) treats button/input
 // classification as advisory and degrades to `container`. Three classes are purely structural:
 //   link  — the node carries a navigating prototype interaction/reaction (it navigates).
@@ -64,13 +75,107 @@ const classify = (node, imageFills) => {
 // text-vs-background pairing without re-deriving paints. Both are absent when there is no solid fill.
 const readTextColor = (node) => nodeType(node) === "TEXT" ? firstSolidPaintHex(node, "fills") : undefined;
 const readBackgroundColor = (node) => nodeType(node) === "TEXT" ? undefined : firstSolidPaintHex(node, "fills");
-const buildNode = (pruned) => {
+// ─── Layout / sizing / cornerRadius / typography projection ──────────────────
+const ALIGN_MAP = {
+    MIN: "start",
+    CENTER: "center",
+    MAX: "end",
+    SPACE_BETWEEN: "space-between",
+};
+const readAlign = (value) => {
+    const s = readString(value);
+    return s !== undefined ? ALIGN_MAP[s] : undefined;
+};
+const readLayoutMode = (value) => {
+    const s = readString(value);
+    if (s === "HORIZONTAL")
+        return "row";
+    if (s === "VERTICAL")
+        return "column";
+    return undefined;
+};
+const readLayoutSizing = (value) => {
+    const s = readString(value);
+    if (s === "FIXED")
+        return "fixed";
+    if (s === "HUG")
+        return "hug";
+    if (s === "FILL")
+        return "fill";
+    return undefined;
+};
+// A padding value is valid only when it is a finite, non-negative number.
+const readPaddingValue = (value) => {
+    const n = readNumber(value);
+    return n !== undefined && n >= 0 ? n : undefined;
+};
+// Returns [top, right, bottom, left] when at least one side is non-zero; undefined otherwise.
+const readLayoutPadding = (node) => {
+    const top = readPaddingValue(node.paddingTop) ?? 0;
+    const right = readPaddingValue(node.paddingRight) ?? 0;
+    const bottom = readPaddingValue(node.paddingBottom) ?? 0;
+    const left = readPaddingValue(node.paddingLeft) ?? 0;
+    return top > 0 || right > 0 || bottom > 0 || left > 0 ? [top, right, bottom, left] : undefined;
+};
+const readLayout = (node) => {
+    const mode = readLayoutMode(node.layoutMode);
+    if (mode === undefined)
+        return undefined;
+    const itemSpacing = readNumber(node.itemSpacing);
+    const padding = readLayoutPadding(node);
+    const primaryAlign = readAlign(node.primaryAxisAlignItems);
+    const counterAlign = readAlign(node.counterAxisAlignItems);
+    return {
+        mode,
+        ...(itemSpacing !== undefined && itemSpacing > 0 ? { itemSpacing } : {}),
+        ...(padding !== undefined ? { padding } : {}),
+        ...(primaryAlign !== undefined ? { primaryAlign } : {}),
+        ...(counterAlign !== undefined ? { counterAlign } : {}),
+    };
+};
+const readSizing = (node) => {
+    const horizontal = readLayoutSizing(node.layoutSizingHorizontal);
+    const vertical = readLayoutSizing(node.layoutSizingVertical);
+    if (horizontal === undefined && vertical === undefined)
+        return undefined;
+    return {
+        ...(horizontal !== undefined ? { horizontal } : {}),
+        ...(vertical !== undefined ? { vertical } : {}),
+    };
+};
+const readCornerRadius = (node) => {
+    const value = readNumber(node.cornerRadius);
+    return value !== undefined && value > 0 ? value : undefined;
+};
+const readTypography = (node) => {
+    if (nodeType(node) !== "TEXT")
+        return undefined;
+    const style = asNode(node.style);
+    if (style === undefined)
+        return undefined;
+    const fontFamily = readString(style.fontFamily);
+    const fontSize = readNumber(style.fontSize);
+    const fontWeight = readNumber(style.fontWeight);
+    if (fontFamily === undefined || fontSize === undefined || fontWeight === undefined)
+        return undefined;
+    return { fontFamily, fontSize, fontWeight };
+};
+// Subtrees deeper than this are truncated to prevent RangeError on malformed chain-like inputs.
+// Same shared constant as prune.ts — see there for the rationale. Must stay in sync with every
+// other recursive walk in this pipeline (tokens, links, a11y, screenIrTestBaseline).
+const MAX_TREE_DEPTH = 512;
+function buildNodeAt(pruned, depth) {
     const node = pruned.source;
     const imageFills = readImageFills(node);
     const text = readString(node.characters);
     const boundingBox = readBoundingBox(node);
     const textColor = readTextColor(node);
     const backgroundColor = readBackgroundColor(node);
+    const children = depth >= MAX_TREE_DEPTH ? [] : pruned.children.map((c) => buildNodeAt(c, depth + 1));
+    const layout = readLayout(node);
+    const sizing = readSizing(node);
+    const cornerRadius = readCornerRadius(node);
+    const typography = readTypography(node);
     return {
         id: nodeId(node),
         name: nodeName(node),
@@ -80,11 +185,20 @@ const buildNode = (pruned) => {
         ...(boundingBox !== undefined ? { boundingBox } : {}),
         ...(textColor !== undefined ? { textColor } : {}),
         ...(backgroundColor !== undefined ? { backgroundColor } : {}),
+        ...(layout !== undefined ? { layout } : {}),
+        ...(sizing !== undefined ? { sizing } : {}),
+        ...(cornerRadius !== undefined ? { cornerRadius } : {}),
+        ...(typography !== undefined ? { typography } : {}),
         imageFills,
-        children: pruned.children.map(buildNode),
+        children,
     };
-};
+}
 /** Normalize a pruned screen root into its IR node tree. Child order follows source order. */
-export const normalizeScreenRoot = (pruned) => buildNode(pruned);
+export const normalizeScreenRoot = (pruned) => buildNodeAt(pruned, 0);
+function countIrNodesAt(node, depth) {
+    if (depth > MAX_TREE_DEPTH)
+        return 1;
+    return 1 + node.children.reduce((sum, child) => sum + countIrNodesAt(child, depth + 1), 0);
+}
 /** Count the IR nodes in a normalized tree, used for the reduction ratio. */
-export const countIrNodes = (node) => 1 + node.children.reduce((sum, child) => sum + countIrNodes(child), 0);
+export const countIrNodes = (node) => countIrNodesAt(node, 0);

package/node_modules/@oscharko-dev/keiko-quality-intelligence/dist/domain/figma/prune.d.ts

@@ -6,7 +6,8 @@ export interface PrunedNode {
 }
 /**
  * Prune a node, returning the kept node (with kept children) or `undefined` when the node itself is
- * dropped. A node is dropped when hidden, a component master, or an empty scaffold.
+ * dropped. A node is dropped when hidden, a component master, or an empty scaffold. Subtrees deeper
+ * than MAX_TREE_DEPTH are truncated so malformed chain-like inputs degrade rather than overflow.
  */
 export declare const pruneNode: (node: FigmaSourceNode) => PrunedNode | undefined;
 /** Total node count of a raw subtree (root included), used for the reduction ratio. */

package/node_modules/@oscharko-dev/keiko-quality-intelligence/dist/domain/figma/prune.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"prune.d.ts","sourceRoot":"","sources":["../../../src/domain/figma/prune.ts"],"names":[],"mappings":"AAaA,OAAO,EAOL,KAAK,eAAe,EACrB,MAAM,iBAAiB,CAAC;AAIzB,qEAAqE;AACrE,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,MAAM,EAAE,eAAe,CAAC;IACjC,QAAQ,CAAC,QAAQ,EAAE,SAAS,UAAU,EAAE,CAAC;CAC1C;AAYD;;;GAGG;AACH,eAAO,MAAM,SAAS,GAAI,MAAM,eAAe,KAAG,UAAU,GAAG,SAW9D,CAAC;AAEF,uFAAuF;AACvF,eAAO,MAAM,gBAAgB,GAAI,MAAM,eAAe,KAAG,MAIxD,CAAC"}
+{"version":3,"file":"prune.d.ts","sourceRoot":"","sources":["../../../src/domain/figma/prune.ts"],"names":[],"mappings":"AAaA,OAAO,EAOL,KAAK,eAAe,EACrB,MAAM,iBAAiB,CAAC;AAazB,qEAAqE;AACrE,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,MAAM,EAAE,eAAe,CAAC;IACjC,QAAQ,CAAC,QAAQ,EAAE,SAAS,UAAU,EAAE,CAAC;CAC1C;AA0BD;;;;GAIG;AACH,eAAO,MAAM,SAAS,GAAI,MAAM,eAAe,KAAG,UAAU,GAAG,SAAiC,CAAC;AASjG,uFAAuF;AACvF,eAAO,MAAM,gBAAgB,GAAI,MAAM,eAAe,KAAG,MAAqC,CAAC"}

package/node_modules/@oscharko-dev/keiko-quality-intelligence/dist/domain/figma/prune.js

@@ -12,6 +12,14 @@
 // Pruning is name-agnostic. No copy, screen name, or component vocabulary participates.
 import { asNode, childNodes, isHidden, nodeType, readArray, readString, } from "./sourceNode.js";
 const MASTER_TYPES = new Set(["COMPONENT", "COMPONENT_SET"]);
+// Subtrees deeper than this are truncated (not walked). Prevents RangeError on malformed inputs with
+// chain-like node trees thousands of levels deep. Documented contract: malformed input degrades, never
+// crashes (cleanToScreenIr.ts header).
+// Shared contract: every recursive tree walk in this pipeline (prune → normalize → tokens → links →
+// a11y → screenIrTestBaseline) uses the same value so that none overflow before the others. 512 is
+// far above any legitimate Figma board depth (< 50 in practice) while staying safe inside vitest
+// worker threads, which have a smaller default JS stack than bare Node.
+const MAX_TREE_DEPTH = 512;
 const hasOwnPayload = (node) => {
     if (readString(node.characters) !== undefined)
         return true;
@@ -24,27 +32,34 @@ const hasOwnPayload = (node) => {
     return false;
 };
 const isDroppedByType = (node) => MASTER_TYPES.has(nodeType(node));
-/**
- * Prune a node, returning the kept node (with kept children) or `undefined` when the node itself is
- * dropped. A node is dropped when hidden, a component master, or an empty scaffold.
- */
-export const pruneNode = (node) => {
+function pruneNodeAt(node, depth) {
+    if (depth > MAX_TREE_DEPTH)
+        return undefined;
     if (isHidden(node) || isDroppedByType(node))
         return undefined;
     const children = [];
     for (const child of childNodes(node)) {
-        const kept = pruneNode(child);
+        const kept = pruneNodeAt(child, depth + 1);
         if (kept !== undefined)
             children.push(kept);
     }
     if (children.length === 0 && !hasOwnPayload(node))
         return undefined;
     return { source: node, children };
-};
-/** Total node count of a raw subtree (root included), used for the reduction ratio. */
-export const countSourceNodes = (node) => {
+}
+/**
+ * Prune a node, returning the kept node (with kept children) or `undefined` when the node itself is
+ * dropped. A node is dropped when hidden, a component master, or an empty scaffold. Subtrees deeper
+ * than MAX_TREE_DEPTH are truncated so malformed chain-like inputs degrade rather than overflow.
+ */
+export const pruneNode = (node) => pruneNodeAt(node, 0);
+function countSourceNodesAt(node, depth) {
+    if (depth > MAX_TREE_DEPTH)
+        return 1; // count the truncated subtree root only
     let total = 1;
     for (const child of childNodes(node))
-        total += countSourceNodes(child);
+        total += countSourceNodesAt(child, depth + 1);
     return total;
-};
+}
+/** Total node count of a raw subtree (root included), used for the reduction ratio. */
+export const countSourceNodes = (node) => countSourceNodesAt(node, 0);

package/node_modules/@oscharko-dev/keiko-quality-intelligence/dist/domain/figma/screenIrTestBaseline.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"screenIrTestBaseline.d.ts","sourceRoot":"","sources":["../../../src/domain/figma/screenIrTestBaseline.ts"],"names":[],"mappings":"AAiBA,OAAO,KAAK,EAAuB,QAAQ,EAAE,MAAM,cAAc,CAAC;AAElE,MAAM,MAAM,sBAAsB,GAC9B,gBAAgB,GAChB,kBAAkB,GAClB,gBAAgB,GAChB,eAAe,GACf,OAAO,GAGP,YAAY,GACZ,MAAM,GAGN,MAAM,GACN,iBAAiB,CAAC;AAEtB,uFAAuF;AACvF,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,QAAQ,EAAE,sBAAsB,CAAC;IAC1C,kFAAkF;IAClF,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,2FAA2F;IAC3F,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,CAAC;CAChC;AAED,sFAAsF;AACtF,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,KAAK,EAAE,SAAS,kBAAkB,EAAE,CAAC;CAC/C;AA0FD;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,OAAO,GAAG,QAAQ,GAAG,SAAS,CAKlE;AAiGD;;;;;GAKG;AACH,wBAAgB,wBAAwB,CACtC,MAAM,EAAE,QAAQ,EAChB,UAAU,GAAE,SAAS,kBAAkB,EAAO,GAC7C,kBAAkB,CAMpB;AAED;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,kBAAkB,GAAG,MAAM,CAQvE"}
+{"version":3,"file":"screenIrTestBaseline.d.ts","sourceRoot":"","sources":["../../../src/domain/figma/screenIrTestBaseline.ts"],"names":[],"mappings":"AAiBA,OAAO,KAAK,EAAuB,QAAQ,EAAE,MAAM,cAAc,CAAC;AAElE,MAAM,MAAM,sBAAsB,GAC9B,gBAAgB,GAChB,kBAAkB,GAClB,gBAAgB,GAChB,eAAe,GACf,OAAO,GAGP,YAAY,GACZ,MAAM,GAGN,MAAM,GACN,iBAAiB,CAAC;AAEtB,uFAAuF;AACvF,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,QAAQ,EAAE,sBAAsB,CAAC;IAC1C,kFAAkF;IAClF,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,2FAA2F;IAC3F,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,CAAC;CAChC;AAED,sFAAsF;AACtF,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,KAAK,EAAE,SAAS,kBAAkB,EAAE,CAAC;CAC/C;AAwKD;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,OAAO,GAAG,QAAQ,GAAG,SAAS,CAKlE;AA2GD;;;;;GAKG;AACH,wBAAgB,wBAAwB,CACtC,MAAM,EAAE,QAAQ,EAChB,UAAU,GAAE,SAAS,kBAAkB,EAAO,GAC7C,kBAAkB,CAMpB;AAED;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,kBAAkB,GAAG,MAAM,CAWvE"}

package/node_modules/@oscharko-dev/keiko-quality-intelligence/dist/domain/figma/screenIrTestBaseline.js

@@ -55,33 +55,99 @@ function parseImageFills(value) {
     }
     return refs;
 }
+// Subtrees deeper than this are truncated during parse so a chain-like persisted irJson cannot cause
+// a RangeError. Shared constant — see prune.ts for rationale. Must stay in sync with every walk.
+const MAX_TREE_DEPTH = 512;
 // Parse a node's children list, dropping any malformed child rather than failing the whole node.
-function parseIrChildren(value) {
+// depth tracks how deep we are so the recursion is bounded at MAX_TREE_DEPTH.
+function parseIrChildren(value, depth) {
+    if (depth > MAX_TREE_DEPTH)
+        return [];
     if (!Array.isArray(value))
         return [];
     const children = [];
     for (const child of value) {
-        const parsed = parseIrNode(child);
+        const parsed = parseIrNodeAt(child, depth);
         if (parsed !== undefined)
             children.push(parsed);
     }
     return children;
 }
-// The optional, additive node fields (text, bounding box, a11y colours #812). Each is present only
-// when well-typed; a malformed value is dropped so a corrupt node degrades rather than crashing.
+// The optional, additive node fields (text, bounding box, a11y colours #812, layout fidelity).
+// Each is present only when well-typed; a malformed value is dropped so a corrupt node degrades
+// rather than crashing.
 function parseOptionalNodeFields(value) {
     const boundingBox = parseBoundingBox(value.boundingBox);
+    const layout = parseIrLayout(value.layout);
+    const sizing = parseIrSizing(value.sizing);
+    const typography = parseIrTypography(value.typography);
+    const cornerRadius = isFiniteNumber(value.cornerRadius) ? value.cornerRadius : undefined;
     return {
         ...(isString(value.text) ? { text: value.text } : {}),
         ...(boundingBox !== undefined ? { boundingBox } : {}),
         ...(isString(value.textColor) ? { textColor: value.textColor } : {}),
         ...(isString(value.backgroundColor) ? { backgroundColor: value.backgroundColor } : {}),
+        ...(layout !== undefined ? { layout } : {}),
+        ...(sizing !== undefined ? { sizing } : {}),
+        ...(cornerRadius !== undefined ? { cornerRadius } : {}),
+        ...(typography !== undefined ? { typography } : {}),
+    };
+}
+const LAYOUT_MODES = new Set(["row", "column"]);
+const ALIGN_VALUES = new Set(["start", "center", "end", "space-between"]);
+const SIZING_VALUES = new Set(["fixed", "hug", "fill"]);
+const parseAlign = (value) => isString(value) && ALIGN_VALUES.has(value) ? value : undefined;
+// Re-hydrate the layout-fidelity fields persisted in irJson (codegen path). Persisted snapshots
+// from before these fields existed simply omit them — every branch is total and optional.
+function parseIrLayout(value) {
+    if (!isObject(value) || !isString(value.mode) || !LAYOUT_MODES.has(value.mode))
+        return undefined;
+    const padding = parsePadding(value.padding);
+    const itemSpacing = isFiniteNumber(value.itemSpacing) ? value.itemSpacing : undefined;
+    const primaryAlign = parseAlign(value.primaryAlign);
+    const counterAlign = parseAlign(value.counterAlign);
+    return {
+        mode: value.mode,
+        ...(itemSpacing !== undefined ? { itemSpacing } : {}),
+        ...(padding !== undefined ? { padding } : {}),
+        ...(primaryAlign !== undefined ? { primaryAlign } : {}),
+        ...(counterAlign !== undefined ? { counterAlign } : {}),
+    };
+}
+function parsePadding(value) {
+    if (!Array.isArray(value) || value.length !== 4)
+        return undefined;
+    return value.every(isFiniteNumber)
+        ? value
+        : undefined;
+}
+const parseSizingValue = (value) => isString(value) && SIZING_VALUES.has(value) ? value : undefined;
+function parseIrSizing(value) {
+    if (!isObject(value))
+        return undefined;
+    const horizontal = parseSizingValue(value.horizontal);
+    const vertical = parseSizingValue(value.vertical);
+    if (horizontal === undefined && vertical === undefined)
+        return undefined;
+    return {
+        ...(horizontal !== undefined ? { horizontal } : {}),
+        ...(vertical !== undefined ? { vertical } : {}),
     };
 }
+function parseIrTypography(value) {
+    if (!isObject(value))
+        return undefined;
+    const { fontFamily, fontSize, fontWeight } = value;
+    if (!isString(fontFamily) || !isFiniteNumber(fontSize) || !isFiniteNumber(fontWeight)) {
+        return undefined;
+    }
+    return { fontFamily, fontSize, fontWeight };
+}
 // Total, defensive IR-node parser: an opaque serialised node (from the snapshot's `irJson`) is
 // accepted only when its required structural fields are present and well-typed; anything malformed
 // yields `undefined` so a corrupt screen degrades to "no items" rather than crashing the run.
-function parseIrNode(value) {
+// depth is passed through parseIrChildren to bound total recursion at MAX_TREE_DEPTH.
+function parseIrNodeAt(value, depth) {
     if (!isObject(value))
         return undefined;
     const { id, name, type, interactionHint } = value;
@@ -96,9 +162,12 @@ function parseIrNode(value) {
         interactionHint: interactionHint,
         ...parseOptionalNodeFields(value),
         imageFills: parseImageFills(value.imageFills),
-        children: parseIrChildren(value.children),
+        children: parseIrChildren(value.children, depth + 1),
     };
 }
+function parseIrNode(value) {
+    return parseIrNodeAt(value, 0);
+}
 /**
  * Total, defensive Screen-IR parser for the snapshot's opaque `irJson`. Returns `undefined` for a
  * missing or malformed value (no `root`, malformed node tree) so the caller can skip an unparseable
@@ -175,7 +244,9 @@ function stateItem(node, ctx, label) {
         title: `Element "${node.name}" renders correctly in state "${label}" on screen "${ctx.screenName}"`,
     };
 }
-function collectNodeItems(node, ctx, out) {
+function collectNodeItemsAt(node, ctx, out, depth) {
+    if (depth > MAX_TREE_DEPTH)
+        return;
     if (node.interactionHint === "input")
         out.push(...fieldItems(node, ctx));
     if (node.interactionHint === "button" || node.interactionHint === "link") {
@@ -185,7 +256,10 @@ function collectNodeItems(node, ctx, out) {
     if (state !== undefined)
         out.push(stateItem(node, ctx, state));
     for (const child of node.children)
-        collectNodeItems(child, ctx, out);
+        collectNodeItemsAt(child, ctx, out, depth + 1);
+}
+function collectNodeItems(node, ctx, out) {
+    collectNodeItemsAt(node, ctx, out, 0);
 }
 function screenRenderItem(ctx) {
     return {
@@ -217,7 +291,10 @@ export function deriveScreenTestBaseline(screen, extraItems = []) {
  */
 export function renderBaselineText(baseline) {
     const header = `Screen: ${baseline.screenName} [${baseline.screenId}]`;
-    const lines = baseline.items.map((item) => `- (${item.category}) ${item.title}`);
+    const lines = baseline.items.map((item) => {
+        const nodeRef = item.sourceNodeId !== undefined ? ` [node:${item.sourceNodeId}]` : "";
+        return `- (${item.category}) ${item.title}${nodeRef}`;
+    });
     return [
         header,
         "Structural test baseline (deterministic, derived from Screen-IR):",

package/node_modules/@oscharko-dev/keiko-quality-intelligence/dist/domain/figma/tokens.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tokens.d.ts","sourceRoot":"","sources":["../../../src/domain/figma/tokens.ts"],"names":[],"mappings":"AAqBA,OAAO,KAAK,EAEV,YAAY,EAIb,MAAM,cAAc,CAAC;AACtB,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAoE7C,kFAAkF;AAClF,eAAO,MAAM,mBAAmB,GAAI,SAAS,SAAS,UAAU,EAAE,KAAG,YAepE,CAAC;AA0DF;;;;GAIG;AACH,eAAO,MAAM,iBAAiB,GAAI,OAAO,OAAO,KAAG,YAQlD,CAAC"}
+{"version":3,"file":"tokens.d.ts","sourceRoot":"","sources":["../../../src/domain/figma/tokens.ts"],"names":[],"mappings":"AAqBA,OAAO,KAAK,EAEV,YAAY,EAIb,MAAM,cAAc,CAAC;AACtB,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AA4E7C,kFAAkF;AAClF,eAAO,MAAM,mBAAmB,GAAI,SAAS,SAAS,UAAU,EAAE,KAAG,YAiBpE,CAAC;AA0DF;;;;GAIG;AACH,eAAO,MAAM,iBAAiB,GAAI,OAAO,OAAO,KAAG,YAQlD,CAAC"}

package/node_modules/@oscharko-dev/keiko-quality-intelligence/dist/domain/figma/tokens.js

@@ -49,7 +49,11 @@ const collectRadius = (node, out) => {
     if (value !== undefined && value > 0)
         out.add(value);
 };
-const visit = (pruned, acc) => {
+// Shared constant — see prune.ts for rationale. Must stay in sync with every other recursive walk.
+const MAX_TREE_DEPTH = 512;
+function visitAt(pruned, acc, depth) {
+    if (depth > MAX_TREE_DEPTH)
+        return;
     const node = pruned.source;
     collectPaintColors(node, "fills", acc.colors);
     collectPaintColors(node, "strokes", acc.colors);
@@ -57,7 +61,10 @@ const visit = (pruned, acc) => {
     collectSpacing(node, acc.spacing);
     collectRadius(node, acc.radius);
     for (const child of pruned.children)
-        visit(child, acc);
+        visitAt(child, acc, depth + 1);
+}
+const visit = (pruned, acc) => {
+    visitAt(pruned, acc, 0);
 };
 const toColorTokens = (values) => [...values].sort().map((value) => ({ id: `color:${value}`, kind: "color", value }));
 const toSpacingTokens = (values) => [...values]
@@ -78,7 +85,7 @@ export const extractDesignTokens = (screens) => {
         visit(screen, acc);
     return {
         colors: toColorTokens(acc.colors),
-        typography: [...acc.typography.values()].sort((a, b) => a.id.localeCompare(b.id)),
+        typography: [...acc.typography.values()].sort((a, b) => a.id < b.id ? -1 : a.id > b.id ? 1 : 0),
         spacing: toSpacingTokens(acc.spacing),
         radius: toRadiusTokens(acc.radius),
     };

package/node_modules/@oscharko-dev/keiko-quality-intelligence/dist/domain/validation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["../../src/domain/validation.ts"],"names":[],"mappings":"AAoBA,OAAO,EAAE,mBAAmB,EAAE,MAAM,+BAA+B,CAAC;AA4JpE;;;GAGG;AACH,eAAO,MAAM,kBAAkB,GAC7B,OAAO,mBAAmB,CAAC,wBAAwB,EACnD,YAAY,SAAS,mBAAmB,CAAC,oCAAoC,EAAE,KAC9E,SAAS,mBAAmB,CAAC,oCAAoC,EAoBnE,CAAC"}
+{"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["../../src/domain/validation.ts"],"names":[],"mappings":"AAqBA,OAAO,EAAE,mBAAmB,EAAE,MAAM,+BAA+B,CAAC;AA6JpE;;;GAGG;AACH,eAAO,MAAM,kBAAkB,GAC7B,OAAO,mBAAmB,CAAC,wBAAwB,EACnD,YAAY,SAAS,mBAAmB,CAAC,oCAAoC,EAAE,KAC9E,SAAS,mBAAmB,CAAC,oCAAoC,EAoBnE,CAAC"}

package/node_modules/@oscharko-dev/keiko-quality-intelligence/dist/domain/validation.js

@@ -9,9 +9,10 @@
 //   1. schema-completeness — title/steps/expectedResults must be non-empty.
 //   2. step-acyclicity     — no canonical-line repeats in the step sequence.
 //   3. expected-presence    — at least one expected result must be present.
-//   4. trivial-contradiction — a precondition that is also negated in an
-//      expected result is a logic defect (e.g. precondition "user is logged
-//      in" and expected "user is not logged in").
+//   4. trivial-contradiction — a precondition and an expected result share the
+//      same negation-stripped core but have opposite negation parity (XOR):
+//      exactly one of the two contains a negation word. Both positive or both
+//      negated → consistent; one positive + one negated → contradiction.
 //
 // Structurally inspired by
 // Test Intelligence reference (TI) packages/core-engine/src/
@@ -90,21 +91,22 @@ const checkTrivialContradictions = (runId, candidate) => {
     if (candidate.preconditions.length === 0 || candidate.expectedResults.length === 0) {
         return [];
     }
-    const preStripped = candidate.preconditions.map((line) => stripNegation(canonicaliseLine(line)));
     for (const result of candidate.expectedResults) {
         const resultCanonical = canonicaliseLine(result);
-        if (!NEGATION_PATTERN.test(resultCanonical)) {
+        const resultCore = stripNegation(resultCanonical);
+        if (resultCore.length === 0) {
             continue;
         }
-        const stripped = stripNegation(resultCanonical);
-        if (stripped.length === 0) {
-            continue;
-        }
-        for (const pre of preStripped) {
-            if (pre.length === 0) {
+        const negatedResult = NEGATION_PATTERN.test(resultCanonical);
+        for (const pre of candidate.preconditions) {
+            const preCanonical = canonicaliseLine(pre);
+            const preCore = stripNegation(preCanonical);
+            if (preCore.length === 0) {
                 continue;
             }
-            if (pre === stripped) {
+            const negatedPre = NEGATION_PATTERN.test(preCanonical);
+            // Contradiction iff cores match AND exactly one side carries a negation (XOR parity).
+            if (preCore === resultCore && negatedPre !== negatedResult) {
                 return [
                     buildSemanticDefect(runId, candidate, 4, "medium", "Expected result trivially contradicts a precondition (post-negation match)."),
                 ];

package/node_modules/@oscharko-dev/keiko-quality-intelligence/dist/ingestion/untrustedContentNormalisation.d.ts

@@ -12,7 +12,7 @@ export interface NormaliseUntrustedContentResult {
 /**
  * Normalise an untrusted free-text payload:
  *   1. NFKC normalise.
- *   2. Strip C0/C1/DEL control characters.
+ *   2. Strip C0/C1/DEL control characters (keeping TAB/LF/CR text whitespace).
  *   3. Escape Markdown-injection vectors (heading, fenced code, image, link).
  *   4. Clamp to `maxBytes` UTF-8 bytes (default 64 KiB).
  *

package/node_modules/@oscharko-dev/keiko-quality-intelligence/dist/ingestion/untrustedContentNormalisation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"untrustedContentNormalisation.d.ts","sourceRoot":"","sources":["../../src/ingestion/untrustedContentNormalisation.ts"],"names":[],"mappings":"AAgBA,yCAAyC;AACzC,MAAM,WAAW,gCAAgC;IAC/C,+DAA+D;IAC/D,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;CAC5B;AAED,MAAM,WAAW,+BAA+B;IAC9C,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,QAAQ,CAAC,0BAA0B,EAAE,OAAO,CAAC;IAC7C,QAAQ,CAAC,wBAAwB,EAAE,MAAM,CAAC;CAC3C;AAoFD;;;;;;;;GAQG;AACH,eAAO,MAAM,yBAAyB,GACpC,KAAK,MAAM,EACX,UAAS,gCAAqC,KAC7C,+BAYF,CAAC;AAEF,eAAO,MAAM,mCAAmC,QAAoB,CAAC"}
+{"version":3,"file":"untrustedContentNormalisation.d.ts","sourceRoot":"","sources":["../../src/ingestion/untrustedContentNormalisation.ts"],"names":[],"mappings":"AAgBA,yCAAyC;AACzC,MAAM,WAAW,gCAAgC;IAC/C,+DAA+D;IAC/D,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;CAC5B;AAED,MAAM,WAAW,+BAA+B;IAC9C,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,QAAQ,CAAC,0BAA0B,EAAE,OAAO,CAAC;IAC7C,QAAQ,CAAC,wBAAwB,EAAE,MAAM,CAAC;CAC3C;AA2FD;;;;;;;;GAQG;AACH,eAAO,MAAM,yBAAyB,GACpC,KAAK,MAAM,EACX,UAAS,gCAAqC,KAC7C,+BAYF,CAAC;AAEF,eAAO,MAAM,mCAAmC,QAAoB,CAAC"}

package/node_modules/@oscharko-dev/keiko-quality-intelligence/dist/ingestion/untrustedContentNormalisation.js

@@ -19,6 +19,14 @@ const FENCED_CODE = /```/gu;
 const IMAGE_OPEN = /!\[/gu;
 const LINK_OPEN = /(?<!!)\[([^\]]*)\]\(/gu;
 const isControlCodePoint = (code) => {
+    // TAB (0x09), LF (0x0A), and CR (0x0D) are C0 code points but are legitimate
+    // text whitespace: stripping them would collapse multi-line content (e.g. a
+    // code block or a multi-line document excerpt) into a single run-on line. They
+    // must survive normalisation. This mirrors the prompt-boundary scrubber and the
+    // single-file binary guard (keiko-server isControlChar), so every layer treats
+    // the same code points as text.
+    if (code === 0x09 || code === 0x0a || code === 0x0d)
+        return false;
     // C0 controls 0x00–0x1F, DEL 0x7F, C1 controls 0x80–0x9F.
     if (code <= 0x1f)
         return true;
@@ -91,7 +99,7 @@ const clampToBytes = (value, maxBytes) => {
 /**
  * Normalise an untrusted free-text payload:
  *   1. NFKC normalise.
- *   2. Strip C0/C1/DEL control characters.
+ *   2. Strip C0/C1/DEL control characters (keeping TAB/LF/CR text whitespace).
  *   3. Escape Markdown-injection vectors (heading, fenced code, image, link).
  *   4. Clamp to `maxBytes` UTF-8 bytes (default 64 KiB).
  *

package/node_modules/@oscharko-dev/keiko-quality-intelligence/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@oscharko-dev/keiko-quality-intelligence",
-  "version": "0.2.0-beta.2",
+  "version": "0.2.0-beta.4",
   "private": true,
   "type": "module",
   "license": "Apache-2.0",
@@ -15,7 +15,7 @@
   },
   "scripts": {
     "build": "tsc -b tsconfig.json",
-    "typecheck": "tsc -b tsconfig.json --noEmit",
+    "typecheck": "tsc -b tsconfig.json",
     "test": "vitest run"
   },
   "files": [