@deneb-ui/cli 2.0.50 → 2.0.52

package/src/arc/fivora-contract.cjs

@@ -8,6 +8,9 @@
  * locally rather than at upload time.
  */
 
+const recast = require('recast');
+const { parseSource, getJsxName, hasJsxAttribute, collectJsxText } = require('./ast.cjs');
+
 const MARKER_ATTRIBUTE_TO_KIND = {
   'data-preview-field-path': 'field',
   'data-preview-list-path': 'list',
@@ -214,6 +217,17 @@ function auditMarkerPlacement(code, filePath) {
     const staticMatch = attrs.match(/\bdata-preview-static\s*=\s*(?:"([^"]*)"|'([^']*)')/);
     const hasStatic = /\bdata-preview-static\b/.test(attrs);
 
+    const isHidden =
+      /\bhidden(?:[\s=]|\/?>)/i.test(attrs) ||
+      /\baria-hidden\s*=\s*(?:"true"|'true'|\{\s*true\s*\})/i.test(attrs) ||
+      /\bstyle\s*=\s*\{\s*\{[\s\S]*?\b(?:display\s*:\s*['"]none['"]|visibility\s*:\s*['"]hidden['"])[\s\S]*?\}\s*\}/i.test(attrs) ||
+      /\bclassName\s*=\s*(?:"[^"]*\bhidden\b[^"]*"|'[^']*\bhidden\b[^']*'|\{\s*`[^`]*\bhidden\b[^`]*`\s*\})/i.test(attrs);
+
+    if ((hasField || hasList || hasItem) && isHidden) {
+      errors.push(
+        `${filePath}:${line} data-preview field/list/item marker is hidden. Strict visual-edit targets must remain visible and clickable in the exported page.`
+      );
+    }
     if (hasStatic && !(staticMatch?.[1] ?? staticMatch?.[2] ?? '').trim()) {
       errors.push(`${filePath}:${line} data-preview-static requires a reason.`);
     }
@@ -234,6 +248,33 @@ function auditMarkerPlacement(code, filePath) {
     }
   }
 
+  errors.push(...auditCoupledListMarkers(code, filePath));
+  return errors;
+}
+
+/**
+ * Detects coupling parallel arrays by index: rendering a field from list B inside an item belonging to list A.
+ */
+function auditCoupledListMarkers(code, filePath) {
+  const errors = [];
+  const itemBlockPattern = /<\s*([a-zA-Z][a-zA-Z0-9.:-]*)((?:[^<>{}]|\{[^{}]*\})*?)\bdata-preview-item-path\s*=\s*(?:"([^"]*)"|'([^']*)'|\{\s*`([^`]*)`\s*\})([\s\S]*?)<\/\1>/g;
+  for (const match of String(code).matchAll(itemBlockPattern)) {
+    const itemPath = match[3] ?? match[4] ?? match[5] ?? '';
+    const inner = match[6] || '';
+    if (!itemPath) continue;
+    const baseList = itemPath.replace(/\[[^\]]*\]$/, '');
+
+    for (const fieldMatch of inner.matchAll(/\bdata-preview-field-path\s*=\s*(?:"([^"]*)"|'([^']*)'|\{\s*`([^`]*)`\s*\})/g)) {
+      const fieldPath = fieldMatch[1] ?? fieldMatch[2] ?? fieldMatch[3] ?? '';
+      if (!fieldPath || !/\[\d+\]/.test(fieldPath)) continue;
+      const fieldList = fieldPath.replace(/\[\d+\][\s\S]*$/, '');
+      if (fieldList && baseList && fieldList !== baseList) {
+        errors.push(
+          `${filePath}:${lineNumberAt(code, match.index ?? 0)} repeated field "${fieldPath}" is rendered inside item "${itemPath}" but belongs to a different list. Model one visual card as one object-list item instead of coupling parallel arrays by index.`
+        );
+      }
+    }
+  }
   return errors;
 }
 
@@ -475,8 +516,71 @@ function auditPreviewRuntime(sources) {
 /**
  * Finds meaningful visible JSX text that is neither bound to a field nor marked
  * static. Strict mode treats these as errors in the exported HTML.
+ * Prefers an AST walk so TypeScript generics and nested tags are not misread.
  */
 function findUncoveredVisibleText(code, filePath) {
+  let ast;
+  try {
+    ast = parseSource(code, filePath);
+  } catch {
+    return findUncoveredVisibleTextRegex(code, filePath);
+  }
+
+  const findings = [];
+  recast.types.visit(ast, {
+    visitJSXElement(pathNode) {
+      const node = pathNode.node;
+      const tag = getJsxName(node);
+      const lower = String(tag || '').toLowerCase();
+      if (!tag || lower === 'option' || lower === 'script' || lower === 'style') {
+        this.traverse(pathNode);
+        return;
+      }
+      if (
+        hasJsxAttribute(node, 'data-preview-field-path') ||
+        hasJsxAttribute(node, 'data-preview-static')
+      ) {
+        this.traverse(pathNode);
+        return;
+      }
+      if (ancestorHasStaticMarker(pathNode)) {
+        this.traverse(pathNode);
+        return;
+      }
+      const text = collectJsxText(node);
+      if (isMeaningfulUncoveredText(text)) {
+        findings.push({
+          tag,
+          text,
+          filePath,
+          line: node.loc?.start?.line || 1,
+        });
+      }
+      this.traverse(pathNode);
+    },
+  });
+  return findings;
+}
+
+function ancestorHasStaticMarker(pathNode) {
+  let current = pathNode.parent;
+  while (current) {
+    const node = current.node || current.value;
+    if (node && node.type === 'JSXElement' && hasJsxAttribute(node, 'data-preview-static')) return true;
+    current = current.parentPath || current.parent;
+  }
+  return false;
+}
+
+function isMeaningfulUncoveredText(text) {
+  const value = String(text || '').replace(/\s+/g, ' ').trim();
+  if (!value || value.length <= 2 || !/\p{L}/u.test(value)) return false;
+  if (!/^[\p{L}\p{N}"'(¡¿#$€£]/u.test(value)) return false;
+  if (/^(?:true|false|null|undefined)$/i.test(value)) return false;
+  return true;
+}
+
+function findUncoveredVisibleTextRegex(code, filePath) {
   const findings = [];
   const source = String(code);
   const elementPattern = /<\s*([a-zA-Z][a-zA-Z0-9.:-]*)((?:[^<>{}]|\{[^{}]*\})*?)>([^<>{}]*)</g;
@@ -487,13 +591,9 @@ function findUncoveredVisibleText(code, filePath) {
     const text = (match[3] || '').replace(/\s+/g, ' ').trim();
     const offset = match.index ?? 0;
 
-    // A `<` preceded by an identifier character is a TypeScript generic
-    // (forwardRef<HTMLButtonElement, Props>), never a JSX element.
     if (/[\w$)\]]/.test(source[offset - 1] || '')) continue;
     if (tag.toLowerCase() === 'option') continue;
-    if (!text || text.length <= 2 || !/\p{L}/u.test(text)) continue;
-    if (!/^[\p{L}\p{N}"'(¡¿#$€£]/u.test(text)) continue;
-    if (/^(?:true|false|null|undefined)$/i.test(text)) continue;
+    if (!isMeaningfulUncoveredText(text)) continue;
     if (/\bdata-preview-(?:field-path|static)\b/.test(attrs)) continue;
 
     findings.push({ tag, text, filePath, line: lineNumberAt(source, offset) });
@@ -502,6 +602,161 @@ function findUncoveredVisibleText(code, filePath) {
   return findings;
 }
 
+function auditEmptyStateSource(code, filePath) {
+  const errors = [];
+  const source = String(code);
+  const andPattern =
+    /\{([^{}]{0,120}?)\s*&&\s*\(?\s*<\s*([a-zA-Z][\w.:-]*)([^>]*data-preview-(?:field-path|list-path|item-path)[^>]*)>/g;
+  for (const match of source.matchAll(andPattern)) {
+    errors.push(
+      `${filePath}:${lineNumberAt(source, match.index ?? 0)} editable marker is gated behind "${String(match[1]).trim()} &&". Keep the target mounted when its value is empty, false, or zero.`
+    );
+  }
+  const ternaryPattern =
+    /\{([^{}]{0,80}?)\s*\?\s*<\s*([a-zA-Z][\w.:-]*)([^>]*data-preview-(?:field-path|list-path|item-path)[^>]*)>[\s\S]{0,200}?\?\s*(?:null|false|undefined)/g;
+  for (const match of source.matchAll(ternaryPattern)) {
+    errors.push(
+      `${filePath}:${lineNumberAt(source, match.index ?? 0)} editable marker unmounts on a falsy ternary. Keep the target mounted when its value is empty.`
+    );
+  }
+  return errors;
+}
+
+function auditSelectOptions(editorSchema, pages = []) {
+  const errors = [];
+  const declaredPageIds = new Set((pages || []).map((page) => page?.id).filter(Boolean));
+
+  function checkSelect(path, options) {
+    if (!Array.isArray(options) || !options.some((option) => typeof option === 'string' && option.trim())) {
+      errors.push(
+        `editorSchema select field "${path}" must declare at least one non-empty option for strict visual editing.`
+      );
+      return;
+    }
+    if (!declaredPageIds.size) return;
+    if (!/(?:destination|action|targetpage|buttonaction|pagekey)/i.test(path)) return;
+    for (const option of options) {
+      const opt = typeof option === 'string' ? option.trim() : '';
+      if (opt && opt !== 'none' && opt !== 'external' && !declaredPageIds.has(opt)) {
+        errors.push(
+          `editorSchema select field "${path}" declares destination option "${opt}" which is not in fivora-template.json pages[].`
+        );
+      }
+    }
+  }
+
+  function walk(path, node) {
+    if (!node) return;
+    if (node.type === 'select') {
+      checkSelect(path, node.options);
+      return;
+    }
+    if (node.type === 'object') {
+      for (const field of node.fields || []) walk(appendPath(path, field.key), field);
+      return;
+    }
+    if (node.type !== 'list') return;
+    const itemPath = `${wildcardPath(path)}[*]`;
+    if (node.itemField?.type === 'select') checkSelect(itemPath, node.itemField.options);
+    for (const field of node.fields || []) walk(appendPath(itemPath, field.key), field);
+  }
+
+  for (const section of editorSchema?.sections || []) walk(section.path, section);
+  return errors;
+}
+
+function auditListBounds(editorSchema, content) {
+  const errors = [];
+
+  function validBound(value) {
+    return typeof value === 'number' && Number.isSafeInteger(value) && value >= 0 ? value : null;
+  }
+
+  function readValue(path) {
+    let value = content || {};
+    for (const part of String(path).split('.')) {
+      if (!part || !isPlainObject(value)) return undefined;
+      value = value[part];
+    }
+    return value;
+  }
+
+  function walkSchema(path, node) {
+    if (!node) return;
+    if (node.type === 'object') {
+      for (const field of node.fields || []) walkSchema(appendPath(path, field.key), field);
+      return;
+    }
+    if (node.type !== 'list') return;
+    const minItems = validBound(node.minItems);
+    const maxItems = validBound(node.maxItems);
+    if (node.minItems !== undefined && minItems === null) {
+      errors.push(`editorSchema list "${path}" minItems must be a non-negative safe integer.`);
+    }
+    if (node.maxItems !== undefined && maxItems === null) {
+      errors.push(`editorSchema list "${path}" maxItems must be a non-negative safe integer.`);
+    }
+    const effectiveMinimum = minItems ?? (node.required ? 1 : 0);
+    if (maxItems !== null && effectiveMinimum > maxItems) {
+      errors.push(
+        `editorSchema list "${path}" requires at least ${effectiveMinimum} item(s) but maxItems is ${maxItems}.`
+      );
+    }
+    const items = Array.isArray(readValue(path)) ? readValue(path) : [];
+    if (maxItems !== null && items.length > maxItems) {
+      errors.push(
+        `site-data.json content list "${path}" contains ${items.length} items, exceeding editorSchema maxItems ${maxItems}.`
+      );
+    }
+    const itemPath = `${wildcardPath(path)}[*]`;
+    for (const field of node.fields || []) walkSchema(appendPath(itemPath, field.key), field);
+  }
+
+  for (const section of editorSchema?.sections || []) walkSchema(section.path, section);
+  return errors;
+}
+
+function auditStaticMarkerAuthorship(code, filePath) {
+  if (!/\.[cm]?[jt]s$/i.test(filePath) || /\.(tsx|jsx)$/i.test(filePath)) return [];
+  const mutation =
+    /\b(?:setAttribute|setAttributeNS|toggleAttribute)\s*\(\s*['"`]data-preview-static['"`]/.exec(code) ||
+    /\b(?:writeFile|writeFileSync)\s*\([\s\S]{0,200}data-preview-static/.exec(code);
+  if (!mutation) return [];
+  return [
+    `${filePath}:${lineNumberAt(code, mutation.index || 0)} programmatically injects data-preview-static. Author each intentional static annotation directly on the smallest source element.`,
+  ];
+}
+
+function auditRouteOwnedMarkerCoverage({ editorSchema, pages, markers, controlOnlyPaths }) {
+  const errors = [];
+  const pagesById = new Map((pages || []).map((page) => [page.id, page]));
+  const sections = (editorSchema?.sections || [])
+    .map((section) => ({ section, canonicalPath: canonicalizeMarkerPath(section.path) }))
+    .filter((entry) => entry.canonicalPath);
+
+  for (const marker of markers || []) {
+    if (marker.kind === 'page' || marker.kind === 'item') continue;
+    const canonical = canonicalizeMarkerPath(marker.value);
+    if (!canonical) continue;
+    if (marker.kind === 'field' && isControlOnly(canonical, controlOnlyPaths)) continue;
+    const owner = sections
+      .filter((entry) => {
+        const sectionPath = wildcardPath(entry.canonicalPath);
+        const markerPath = wildcardPath(canonical);
+        return markerPath === sectionPath || markerPath.startsWith(`${sectionPath}.`) || markerPath.startsWith(`${sectionPath}[`);
+      })
+      .sort((left, right) => right.canonicalPath.length - left.canonicalPath.length)[0];
+    if (!owner?.section.pageKey) continue;
+    const page = pagesById.get(owner.section.pageKey);
+    if (!page) {
+      errors.push(
+        `editorSchema section "${owner.section.path}" assigns ${marker.kind} "${canonical}" to unknown manifest page "${owner.section.pageKey}".`
+      );
+    }
+  }
+  return errors;
+}
+
 module.exports = {
   BROAD_CONTENT_CONTAINERS,
   PRIMITIVE_TYPES,
@@ -509,11 +764,17 @@ module.exports = {
   enumerateSchemaPaths,
   extractMarkers,
   auditMarkerPlacement,
+  auditCoupledListMarkers,
   auditActionLabelCollision,
   auditPathCoverage,
   auditSchemaUniqueness,
   auditPageCoverage,
   auditPreviewRuntime,
+  auditEmptyStateSource,
+  auditSelectOptions,
+  auditListBounds,
+  auditStaticMarkerAuthorship,
+  auditRouteOwnedMarkerCoverage,
   findUncoveredVisibleText,
   canonicalizeMarkerPath,
   wildcardPath,

package/src/arc/index.cjs

@@ -14,10 +14,11 @@ const fs = require('fs');
 const path = require('path');
 const { ARC_NAME, ARC_VERSION, SCHEMA_VERSION, ENGINE_ID } = require('./version.cjs');
 const { walkFiles, isJsxFile, rel, copyFilePreserve, writeJson, readJsonSafe, findFirstExisting } = require('./fs-utils.cjs');
-const { scanProject, buildDependencyGraph, inferOwnerScope } = require('./scanner.cjs');
+const { scanProject, buildDependencyGraph, inferOwnerScope, resolvePageFileOnDisk } = require('./scanner.cjs');
 const { analyzeFile, collectDesignSnapshot } = require('./semantic.cjs');
 const { planTransformations } = require('./planner.cjs');
 const { applyFilePlan, instrumentLayoutSource, instrumentPageKey, resolveSiteDataSpecifier, resolveSiteDataRuntimeSpecifier, rewriteRecursiveSiteDataContext, ensureJsonModule, sanitizeContradictoryMarkersInSource } = require('./transformer.cjs');
+const { applyResidualPass } = require('./residual.cjs');
 const { parseSource } = require('./ast.cjs');
 const { buildSiteDataAndManifest, writeDataBank, loadExistingData, countSchemaFields } = require('./manifest.cjs');
 const { validateAstFiles, validateContracts, designPreservationScore, coverageMetrics } = require('./validator.cjs');
@@ -34,6 +35,11 @@ const {
   auditPageCoverage,
   auditPreviewRuntime,
   findUncoveredVisibleText,
+  auditEmptyStateSource,
+  auditSelectOptions,
+  auditListBounds,
+  auditStaticMarkerAuthorship,
+  auditRouteOwnedMarkerCoverage,
 } = require('./fivora-contract.cjs');
 const printer = require('./printer.cjs');
 const { classifyComponents } = require('./component-registry.cjs');
@@ -52,6 +58,7 @@ function parseArcOptions(raw = {}) {
     json: Boolean(raw.json),
     aiEnabled: Boolean(raw.aiEnabled),
     aiDryRun: Boolean(raw.aiDryRun),
+    strict: Boolean(raw.strict),
   };
 }
 
@@ -151,6 +158,8 @@ function auditFivoraContract({ profile, siteData, manifest, inventory }) {
   const placement = [];
   const collisions = [];
   const uncoveredText = [];
+  const emptyState = [];
+  const staticAuthorship = [];
   const allMarkers = [];
 
   for (const source of inventory.sources) {
@@ -159,6 +168,8 @@ function auditFivoraContract({ profile, siteData, manifest, inventory }) {
     placement.push(...auditMarkerPlacement(source.code, source.rel));
     collisions.push(...auditActionLabelCollision(source.code, source.rel));
     uncoveredText.push(...findUncoveredVisibleText(source.code, source.rel));
+    emptyState.push(...auditEmptyStateSource(source.code, source.rel));
+    staticAuthorship.push(...auditStaticMarkerAuthorship(source.code, source.rel));
   }
 
   const coverage = auditPathCoverage({
@@ -177,19 +188,34 @@ function auditFivoraContract({ profile, siteData, manifest, inventory }) {
     ...coverage.errors,
     ...placement,
     ...collisions,
+    ...emptyState,
+    ...staticAuthorship,
     ...auditSchemaUniqueness(manifest.editorSchema),
+    ...auditSelectOptions(manifest.editorSchema, manifest.pages),
+    ...auditListBounds(manifest.editorSchema, siteData.content),
     ...auditPageCoverage({
       pages: manifest.pages,
       routeFiles,
       pageMarkersByFile: inventory.pageKeysByFile,
     }),
+    ...auditRouteOwnedMarkerCoverage({
+      editorSchema: manifest.editorSchema,
+      pages: manifest.pages,
+      markers: allMarkers,
+      controlOnlyPaths: manifest.visualEditing?.controlOnlyPaths || [],
+    }),
     ...auditPreviewRuntime(inventory.sources.map((source) => source.code)),
   ];
 
   return {
-    passed: errors.length === 0,
+    passed: errors.length === 0 && uncoveredText.length === 0,
     errors: [...new Set(errors)],
     uncoveredVisibleText: uncoveredText,
+    emptyStatePassed: emptyState.length === 0,
+    fieldMarkers: coverage.fieldMarkers,
+    listMarkers: coverage.listMarkers,
+    itemMarkers: coverage.itemMarkers,
+    pathCoverage: coverage,
   };
 }
 
@@ -230,6 +256,21 @@ function analyzeProjectFiles(profile, graph) {
   return analyses;
 }
 
+function mergeDetectedPages(profile, detectedPages) {
+  if (!Array.isArray(detectedPages) || !detectedPages.length) return;
+  const scannedIds = new Set(profile.routes.map((route) => route.id));
+  const scannedRoutes = new Set(profile.routes.map((route) => route.route));
+  for (const page of detectedPages) {
+    if (!page || !page.id) continue;
+    if (scannedIds.has(page.id) || scannedRoutes.has(page.route)) continue;
+    const file = resolvePageFileOnDisk(profile.root, page);
+    if (!file) continue;
+    profile.routes.push({ ...page, file });
+    scannedIds.add(page.id);
+    scannedRoutes.add(page.route);
+  }
+}
+
 async function runDenebArcAsync(projectDir, projectName, options = {}) {
   const opts = parseArcOptions(options);
   const runId = createRunId();
@@ -238,15 +279,7 @@ async function runDenebArcAsync(projectDir, projectName, options = {}) {
   printer.printBanner(opts.dryRun ? 'dry-run' : opts.explain ? 'explain' : 'run');
 
   const profile = scanProject(projectDir);
-  if (opts.detectedPages && Array.isArray(opts.detectedPages) && opts.detectedPages.length) {
-    const scannedIds = new Set(profile.routes.map((r) => r.id));
-    for (const page of opts.detectedPages) {
-      if (page && page.id && !scannedIds.has(page.id)) {
-        profile.routes.push(page);
-      }
-    }
-  }
-
+  mergeDetectedPages(profile, opts.detectedPages);
   printer.printProfile(profile);
   const graph = buildDependencyGraph(profile);
   const analyses = analyzeProjectFiles(profile, graph);
@@ -256,7 +289,7 @@ async function runDenebArcAsync(projectDir, projectName, options = {}) {
     0
   );
   const actionCount = analyses.reduce(
-    (n, a) => n + (a.candidates || []).filter((c) => c.operation === 'split-action-contract' || c.kind === 'url').length,
+    (n, a) => n + (a.candidates || []).filter((c) => c.operation === 'split-action-contract' || c.operation === 'form-submit-action' || c.kind === 'url').length,
     0
   );
   printer.printScan(profile, graph, candidateCount, actionCount);
@@ -379,14 +412,7 @@ function runDenebArcSync(projectDir, projectName, options = {}) {
   printer.printBanner(opts.dryRun ? 'dry-run' : opts.explain ? 'explain' : 'run');
 
   const profile = scanProject(projectDir);
-  if (opts.detectedPages && Array.isArray(opts.detectedPages) && opts.detectedPages.length) {
-    const scannedIds = new Set(profile.routes.map((r) => r.id));
-    for (const page of opts.detectedPages) {
-      if (page && page.id && !scannedIds.has(page.id)) {
-        profile.routes.push(page);
-      }
-    }
-  }
+  mergeDetectedPages(profile, opts.detectedPages);
 
   printer.printProfile(profile);
   const graph = buildDependencyGraph(profile);
@@ -397,7 +423,7 @@ function runDenebArcSync(projectDir, projectName, options = {}) {
     0
   );
   const actionCount = analyses.reduce(
-    (n, a) => n + (a.candidates || []).filter((c) => c.operation === 'split-action-contract' || c.kind === 'url').length,
+    (n, a) => n + (a.candidates || []).filter((c) => c.operation === 'split-action-contract' || c.operation === 'form-submit-action' || c.kind === 'url').length,
     0
   );
   printer.printScan(profile, graph, candidateCount, actionCount);
@@ -545,6 +571,48 @@ function runArcTransformations(projectDir, projectName, opts, profile, graph, an
     }
   }
 
+  const residualFields = [];
+  const usedPaths = new Set(plan.usedPaths || []);
+  for (const relativeFile of profile.jsxFiles || []) {
+    const abs = path.join(projectDir, relativeFile);
+    if (!fs.existsSync(abs)) continue;
+    const original = fs.readFileSync(abs, 'utf8');
+    const analysis = analyses.find((item) => item.relativeFile === relativeFile);
+    const residual = applyResidualPass({
+      code: original,
+      file: relativeFile,
+      ownerScope: analysis?.ownerScope || inferOwnerScope(profile, graph, relativeFile),
+      usedPaths,
+      componentName: analysis?.componentMeta?.name,
+      role: analysis?.componentMeta?.role,
+    });
+    if (!residual.changed) continue;
+    try {
+      parseSource(residual.code, relativeFile);
+    } catch {
+      continue;
+    }
+    backupFile(projectDir, backupDir, abs);
+    fs.writeFileSync(abs, residual.code, 'utf8');
+    if (!changedFiles.includes(relativeFile)) changedFiles.push(relativeFile);
+    afterFiles[relativeFile] = residual.code;
+    appliedCount += residual.applied || 0;
+    residualFields.push(...(residual.fields || []));
+  }
+
+  for (const relativeFile of profile.jsxFiles || []) {
+    const abs = path.join(projectDir, relativeFile);
+    if (!fs.existsSync(abs)) continue;
+    const original = fs.readFileSync(abs, 'utf8');
+    const sanitized = sanitizeContradictoryMarkersInSource(original, relativeFile);
+    if (sanitized.updated && sanitized.code !== original) {
+      backupFile(projectDir, backupDir, abs);
+      fs.writeFileSync(abs, sanitized.code, 'utf8');
+      if (!changedFiles.includes(relativeFile)) changedFiles.push(relativeFile);
+      afterFiles[relativeFile] = sanitized.code;
+    }
+  }
+
   if (profile.framework === 'nextjs') {
     const before = findNextConfig(projectDir);
     if (before) backupFile(projectDir, backupDir, before.abs);
@@ -589,6 +657,8 @@ function runArcTransformations(projectDir, projectName, opts, profile, graph, an
     existingSiteData: existing.siteData,
     existingManifest: existing.manifest,
     boundFieldPaths: markerInventory.fieldPaths,
+    boundListPaths: markerInventory.listPaths,
+    extraFields: residualFields,
     markerRoutes: markerInventory.markerRoutes,
   });
 
@@ -611,13 +681,6 @@ function runArcTransformations(projectDir, projectName, opts, profile, graph, an
   const design = designPreservationScore(plan.files, afterFiles);
   const alreadyEditable = analyses.filter((a) => a.alreadyEditable).length;
   const skippedDynamic = plan.skipped.filter((s) => /dynamic|api/.test(s.reason || '')).length;
-  const coverage = coverageMetrics({
-    analyses,
-    plan,
-    appliedCount,
-    skippedDynamic,
-    alreadyEditable,
-  });
 
   const fivoraAudit = auditFivoraContract({
     profile,
@@ -626,11 +689,24 @@ function runArcTransformations(projectDir, projectName, opts, profile, graph, an
     inventory: collectMarkerInventory(projectDir, profile, graph),
   });
 
+  const coverage = coverageMetrics({
+    analyses,
+    plan,
+    appliedCount,
+    skippedDynamic,
+    alreadyEditable,
+    content: dataBundle.siteData.content,
+    controlOnlyPaths: dataBundle.manifest.visualEditing?.controlOnlyPaths || [],
+    pathCoverage: fivoraAudit.pathCoverage,
+    uncoveredVisibleText: fivoraAudit.uncoveredVisibleText,
+  });
+
   const validation = {
     syntaxPassed,
     fivoraContractPassed: fivoraAudit.passed,
     fivoraContractErrors: fivoraAudit.errors,
     uncoveredVisibleText: fivoraAudit.uncoveredVisibleText.length,
+    emptyStatePassed: fivoraAudit.emptyStatePassed !== false,
     contractPassed: contracts.contractPassed,
     orphans: contracts.orphans.length,
     missingSchema: contracts.missingSchema.length,
@@ -638,9 +714,12 @@ function runArcTransformations(projectDir, projectName, opts, profile, graph, an
     staticAncestorCollisions: contracts.staticAncestorCollisions,
     astFailures: astResults.filter((r) => !r.passed),
     transformFailures,
+    designPreservation: design.score,
   };
 
-  const criticalFailure = !syntaxPassed || contracts.actionCollisions > 0 && appliedCount === 0;
+  const criticalFailure = !syntaxPassed || (contracts.actionCollisions > 0 && appliedCount === 0);
+  const contractFailure = !fivoraAudit.passed || fivoraAudit.uncoveredVisibleText.length > 0;
+  const designFailure = design.score < 98 && design.total > 0;
   let outcome = 'success';
   if (criticalFailure) {
     restoreBackup(projectDir, backupDir);
@@ -653,6 +732,21 @@ function runArcTransformations(projectDir, projectName, opts, profile, graph, an
     }
     outcome = 'rolled-back';
     printer.printRollback(validation.astFailures[0]?.error || 'Critical validation failed');
+  } else if (opts.strict && (contractFailure || designFailure)) {
+    restoreBackup(projectDir, backupDir);
+    for (const created of createdDuringRun) {
+      try {
+        if (fs.existsSync(created)) fs.rmSync(created, { force: true });
+      } catch {
+        // ignore
+      }
+    }
+    outcome = 'rolled-back';
+    printer.printRollback('Strict Fivora contract failed');
+  } else if (contractFailure) {
+    outcome = 'contract-failed';
+  } else if (designFailure) {
+    outcome = 'design-regression';
   }
 
   printer.printValidation(validation, coverage, design);
@@ -686,7 +780,10 @@ function runArcTransformations(projectDir, projectName, opts, profile, graph, an
     validation: {
       syntaxPassed,
       contractPassed: contracts.contractPassed,
-      visualPassed: design.score >= 95,
+      fivoraContractPassed: fivoraAudit.passed,
+      emptyStatePassed: fivoraAudit.emptyStatePassed !== false,
+      uncoveredVisibleText: fivoraAudit.uncoveredVisibleText.length,
+      visualPassed: design.score >= 98,
       idempotencyPassed: true,
     },
     outcome,
@@ -749,6 +846,8 @@ function runArcTransformations(projectDir, projectName, opts, profile, graph, an
   if (outcome === 'success') {
     printer.printSuccess();
     printer.printDeveloperNextSteps();
+  } else if (outcome === 'contract-failed' || outcome === 'design-regression') {
+    printer.printContractFailed();
   }
   return result;
 }

package/src/arc/learning.cjs

@@ -34,6 +34,7 @@ function recordExperience({ projectDir, profile, plan, validation, outcome, tele
   if (telemetry && telemetry !== 'off') {
     // Network upload is intentionally unimplemented. Local persistence only.
   }
+  const learningOutcome = honestOutcome(validation, outcome);
   const records = [];
   for (const file of plan.files || []) {
     for (const t of file.transformations || []) {
@@ -51,10 +52,12 @@ function recordExperience({ projectDir, profile, plan, validation, outcome, tele
           typecheckPassed: validation.typecheckPassed,
           buildPassed: validation.buildPassed,
           contractPassed: Boolean(validation.contractPassed),
+          fivoraContractPassed: Boolean(validation.fivoraContractPassed),
+          emptyStatePassed: validation.emptyStatePassed !== false,
           visualPassed: validation.visualPassed,
           idempotencyPassed: validation.idempotencyPassed,
         },
-        outcome,
+        outcome: learningOutcome,
         anonymizedFeatures: {
           tag: t.tag,
           operation: t.operation,
@@ -85,6 +88,20 @@ function recordExperience({ projectDir, profile, plan, validation, outcome, tele
   return records;
 }
 
+function honestOutcome(validation, outcome) {
+  if (outcome === 'rolled-back') return 'rolled-back';
+  const passed =
+    validation &&
+    validation.syntaxPassed !== false &&
+    validation.contractPassed !== false &&
+    validation.fivoraContractPassed !== false &&
+    validation.emptyStatePassed !== false &&
+    !(validation.uncoveredVisibleText > 0);
+  if (!passed) return 'failure';
+  if (outcome && outcome !== 'success' && outcome !== 'dry-run') return 'failure';
+  return outcome === 'dry-run' ? 'dry-run' : 'success';
+}
+
 function loadFingerprintBoost(fingerprint) {
   if (!fingerprint) {
     return { boost: 0, skip: false, state: null };
@@ -118,6 +135,7 @@ function mapOperation(operation) {
     case 'extract-url':
       return 'url-extraction';
     case 'split-action-contract':
+    case 'form-submit-action':
       return 'contract-split';
     case 'style-bind':
       return 'style-bind';
@@ -235,6 +253,7 @@ module.exports = {
   registryArchitecture,
   redactSecrets,
   promoteState,
+  honestOutcome,
   localStorePath,
   fingerprintStorePath,
   RULE_STATES,