@deneb-ui/cli 2.0.88 → 2.0.90

package/src/arc/__tests__/canonical.test.cjs

@@ -0,0 +1,57 @@
+'use strict';
+
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const { canonicalField, fieldRef, isValidCanonicalPath, validatePathAlignment } = require('../canonical-paths.cjs');
+
+test('Canonical Field: builds canonical fields and extracts segments', () => {
+  const field = canonicalField('home.hero.title');
+  assert.equal(field.path, 'home.hero.title');
+  assert.equal(field.scope, 'home');
+  assert.equal(field.section, 'hero');
+  assert.equal(field.fieldName, 'title');
+  assert.equal(field.previewPath, 'home.hero.title');
+  assert.equal(field.previewMarker, 'data-preview-field-path="home.hero.title"');
+  assert.equal(field.runtimePath, 'siteData.content.home.hero.title');
+  assert.equal(field.manifestSchemaPath, 'home.hero.title');
+  assert.equal(field.diagnosticsId, 'field:home.hero.title');
+  assert.equal(field.toSetterCode('val'), 'siteData.content.home.hero.title = val;');
+  assert.equal(field.validate().valid, true);
+});
+
+test('Canonical Field: handles collection child derivations and paths', () => {
+  const col = canonicalField('home.categories');
+  const item = col.toCollectionItem(0);
+  assert.equal(item.path, 'home.categories[0]');
+  assert.equal(item.isCollection, true);
+
+  const nestedChild = item.toCollectionChild('products', 1);
+  assert.equal(nestedChild.path, 'home.categories[0].products[1]');
+});
+
+test('Canonical Field: generates recast AST for getter, fallback binding, and preview attributes', () => {
+  const field = canonicalField('home.story.title');
+  const getterAst = field.toGetterAst();
+  assert.equal(getterAst.type, 'OptionalMemberExpression');
+
+  const bindingAst = field.toBindingAst('Our Story');
+  assert.equal(bindingAst.type, 'LogicalExpression');
+
+  const attrAst = field.toPreviewAttrAst();
+  assert.equal(attrAst.name.name, 'data-preview-field-path');
+  assert.equal(attrAst.value.value, 'home.story.title');
+
+  const styleAttrAst = field.toPreviewStyleTargetAst();
+  assert.equal(styleAttrAst.name.name, 'data-preview-style-target');
+});
+
+test('Canonical Field: validates path syntax and getter-to-marker alignment', () => {
+  assert.ok(isValidCanonicalPath('home.hero.title'));
+  assert.ok(isValidCanonicalPath('common.header.logoText'));
+  assert.ok(isValidCanonicalPath('home.categories[0].products[${index}].title'));
+  assert.ok(!isValidCanonicalPath(''));
+  assert.ok(!isValidCanonicalPath('invalid path with spaces'));
+
+  assert.ok(validatePathAlignment('siteData?.content?.home?.hero?.title', 'data-preview-field-path="home.hero.title"'));
+  assert.ok(!validatePathAlignment('siteData?.content?.about?.title', 'data-preview-field-path="home.hero.title"'));
+});

package/src/arc/__tests__/classification.test.cjs

@@ -0,0 +1,54 @@
+'use strict';
+
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const {
+  DATA_CLASSIFICATION,
+  classifyDataCandidate,
+  isEditableClassification,
+  isPlatformControlledPath,
+} = require('../data-classification.cjs');
+
+test('Data Classification: correctly assigns all 7 data tiers', () => {
+  // 1. CONTENT
+  assert.equal(classifyDataCandidate({ tag: 'h1', kind: 'text', value: 'Fresh Roasted Beans' }).classification, DATA_CLASSIFICATION.CONTENT);
+
+  // 2. COMMERCE_CONTENT
+  assert.equal(classifyDataCandidate({ tag: 'h2', kind: 'text', value: 'Espresso Blend', propName: 'productTitle' }).classification, DATA_CLASSIFICATION.COMMERCE_CONTENT);
+
+  // 3. PLATFORM_CONTROLLED
+  assert.equal(classifyDataCandidate({ tag: 'span', kind: 'text', value: 'USD', field: 'common.currency' }).classification, DATA_CLASSIFICATION.PLATFORM_CONTROLLED);
+  assert.equal(classifyDataCandidate({ tag: 'span', kind: 'text', value: 'prod-123', propName: 'productId' }).classification, DATA_CLASSIFICATION.PLATFORM_CONTROLLED);
+
+  // 4. INTERACTION_STATE
+  assert.equal(classifyDataCandidate({ tag: 'div', kind: 'text', propName: 'isOpen', value: 'true' }).classification, DATA_CLASSIFICATION.INTERACTION_STATE);
+  assert.equal(classifyDataCandidate({ tag: 'div', kind: 'text', propName: 'activeTab', value: 'reviews' }).classification, DATA_CLASSIFICATION.INTERACTION_STATE);
+
+  // 5. COMPUTED_DATA
+  assert.equal(classifyDataCandidate({ tag: 'span', kind: 'text', value: 'formatPrice(item.price * qty)' }).classification, DATA_CLASSIFICATION.COMPUTED_DATA);
+
+  // 6. RUNTIME_DATA
+  assert.equal(classifyDataCandidate({ tag: 'span', kind: 'text', value: 'user.email' }).classification, DATA_CLASSIFICATION.RUNTIME_DATA);
+  assert.equal(classifyDataCandidate({ tag: 'span', kind: 'text', value: 'cart.total' }).classification, DATA_CLASSIFICATION.RUNTIME_DATA);
+
+  // 7. DECORATIVE
+  assert.equal(classifyDataCandidate({ tag: 'span', kind: 'text', value: '•' }).classification, DATA_CLASSIFICATION.DECORATIVE);
+});
+
+test('Data Classification: recognizes editable vs non-editable classifications', () => {
+  assert.equal(isEditableClassification(DATA_CLASSIFICATION.CONTENT), true);
+  assert.equal(isEditableClassification(DATA_CLASSIFICATION.COMMERCE_CONTENT), true);
+
+  assert.equal(isEditableClassification(DATA_CLASSIFICATION.PLATFORM_CONTROLLED), false);
+  assert.equal(isEditableClassification(DATA_CLASSIFICATION.RUNTIME_DATA), false);
+  assert.equal(isEditableClassification(DATA_CLASSIFICATION.COMPUTED_DATA), false);
+  assert.equal(isEditableClassification(DATA_CLASSIFICATION.DECORATIVE), false);
+  assert.equal(isEditableClassification(DATA_CLASSIFICATION.INTERACTION_STATE), false);
+});
+
+test('Data Classification: identifies platform controlled paths accurately', () => {
+  assert.equal(isPlatformControlledPath('common.currency'), true);
+  assert.equal(isPlatformControlledPath('products[0].id'), true);
+  assert.equal(isPlatformControlledPath('categories[2].slug'), true);
+  assert.equal(isPlatformControlledPath('home.hero.title'), false);
+});

package/src/arc/__tests__/corpus.test.cjs

@@ -0,0 +1,144 @@
+'use strict';
+
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const path = require('path');
+const fs = require('fs');
+const os = require('os');
+const {
+  KNOWN_STOREFRONTS,
+  resolveWorkspaceStorefrontsDir,
+  auditStorefrontTemplate,
+  verifyStorefrontCorpus,
+} = require('../corpus-verifier.cjs');
+
+function createMockCompliantProject() {
+  const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'deneb-corpus-compliant-'));
+  const appDir = path.join(tempDir, 'src', 'app');
+  const dataDir = path.join(tempDir, 'src', 'data');
+  fs.mkdirSync(appDir, { recursive: true });
+  fs.mkdirSync(dataDir, { recursive: true });
+  fs.writeFileSync(path.join(tempDir, 'package.json'), JSON.stringify({ name: 'sample', dependencies: { next: '15.0.0' } }));
+  fs.writeFileSync(path.join(tempDir, 'fivora-template.json'), JSON.stringify({
+    framework: 'nextjs-static-export',
+    version: 2,
+    arcVersion: '2.1.0',
+    schemaVersion: 2,
+    siteDataFile: 'src/data/site-data.json',
+    pages: [{ id: 'home', label: 'Home', route: '/', required: true }],
+    editorSchema: {
+      version: 1,
+      sections: [
+        { id: 'home', path: 'home', type: 'object', label: 'Home', fields: [{ key: 'heroTitle', type: 'text' }] }
+      ]
+    },
+    visualEditing: {
+      contractVersion: 1,
+      mode: 'strict',
+      controlOnlyPaths: []
+    }
+  }, null, 2));
+  fs.writeFileSync(path.join(dataDir, 'site-data.json'), JSON.stringify({
+    content: {
+      home: { heroTitle: 'Welcome' }
+    }
+  }, null, 2));
+  fs.writeFileSync(path.join(appDir, 'layout.tsx'), 'export default function RootLayout({ children }: any) { return <html><body>{children}</body></html>; }');
+  fs.writeFileSync(path.join(appDir, 'page.tsx'), 'export default function HomePage() { return <main data-preview-page-id="home"><h1 data-preview-field-path="home.heroTitle">Welcome</h1></main>; }');
+
+  return {
+    dir: tempDir,
+    cleanup: () => fs.rmSync(tempDir, { recursive: true, force: true }),
+  };
+}
+
+function createMockBlockedProject() {
+  const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'deneb-corpus-blocked-'));
+  const appDir = path.join(tempDir, 'src', 'app');
+  const dataDir = path.join(tempDir, 'src', 'data');
+  fs.mkdirSync(appDir, { recursive: true });
+  fs.mkdirSync(dataDir, { recursive: true });
+  fs.writeFileSync(path.join(tempDir, 'package.json'), JSON.stringify({ name: 'blocked-sample', dependencies: { next: '15.0.0' } }));
+  fs.writeFileSync(path.join(tempDir, 'fivora-template.json'), JSON.stringify({
+    framework: 'nextjs-static-export',
+    version: 2,
+    arcVersion: '2.1.0',
+    schemaVersion: 2,
+    siteDataFile: 'src/data/site-data.json',
+    pages: [{ id: 'home', label: 'Home', route: '/', required: true }],
+    editorSchema: {
+      sections: [
+        { id: 'home', path: 'home', type: 'object', fields: [{ key: 'unmappedField', type: 'currency' }] }
+      ]
+    }
+  }));
+  fs.writeFileSync(path.join(dataDir, 'site-data.json'), JSON.stringify({
+    content: { home: { unmappedField: 'Hello' } }
+  }));
+  fs.writeFileSync(path.join(appDir, 'page.tsx'), 'export default function Page() { return <div>No Marker</div>; }');
+
+  return {
+    dir: tempDir,
+    cleanup: () => fs.rmSync(tempDir, { recursive: true, force: true }),
+  };
+}
+
+test('Corpus Verifier: audits storefront and verifies 100% pass across all 12 gates', () => {
+  const baseDir = resolveWorkspaceStorefrontsDir();
+  const coffeeDir = path.join(baseDir, 'coffee');
+  const hasRealCoffee = fs.existsSync(coffeeDir) && fs.existsSync(path.join(coffeeDir, 'fivora-template.json'));
+
+  let targetDir = coffeeDir;
+  let cleanup = null;
+  if (!hasRealCoffee) {
+    const fixture = createMockCompliantProject();
+    targetDir = fixture.dir;
+    cleanup = fixture.cleanup;
+  }
+
+  try {
+    const result = auditStorefrontTemplate(targetDir, { templateId: 'coffee', templateName: 'Coffee Shop' });
+    assert.equal(result.validStructure, true);
+    assert.equal(result.fivoraContract.passed, true);
+    assert.equal(result.fivoraContract.violationCount, 0);
+    assert.equal(result.runtimeEditability.passed, true);
+    assert.equal(result.collectionOperations.passed, true);
+    assert.equal(result.acceptanceGates.passed, true);
+    assert.equal(result.acceptanceGates.status, 'CONVERSION_PASSED');
+    assert.equal(result.passed, true);
+  } finally {
+    if (cleanup) cleanup();
+  }
+});
+
+test('Corpus Verifier: blocks conversions with contract violations and refuses false success', () => {
+  const fixture = createMockBlockedProject();
+  try {
+    const result = auditStorefrontTemplate(fixture.dir, { templateId: 'blocked', templateName: 'Blocked Template' });
+    assert.equal(result.fivoraContract.passed, false);
+    assert.ok(result.fivoraContract.violationCount > 0);
+    assert.equal(result.acceptanceGates.status, 'CONVERSION_FAILED');
+    assert.equal(result.passed, false);
+  } finally {
+    fixture.cleanup();
+  }
+});
+
+test('Corpus Verifier: executes corpus verification across all known storefronts', () => {
+  const baseDir = resolveWorkspaceStorefrontsDir();
+  const hasWorkspaceCorpus = fs.existsSync(path.join(baseDir, 'coffee')) && fs.existsSync(path.join(baseDir, 'car-sale'));
+
+  const report = verifyStorefrontCorpus();
+  assert.equal(report.totalTemplates, 6);
+
+  if (hasWorkspaceCorpus) {
+    assert.equal(report.passedTemplates, 6);
+    assert.equal(report.failedTemplates, 0);
+    assert.equal(report.corpusSuccessRate, 100);
+    assert.equal(report.allTemplatesPassed, true);
+  } else {
+    assert.ok(report.results.length === 6);
+    assert.equal(report.failedTemplates, 6);
+    assert.equal(report.allTemplatesPassed, false);
+  }
+});

package/src/arc/__tests__/explain-blocked.test.cjs

@@ -0,0 +1,192 @@
+'use strict';
+
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const path = require('path');
+const fs = require('fs');
+const os = require('os');
+const {
+  analyzeBlockedProject,
+  formatBlockedExplanationTerminal,
+} = require('../explain-blocked.cjs');
+const { resolveWorkspaceStorefrontsDir } = require('../corpus-verifier.cjs');
+
+function createMockCompliantProject() {
+  const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'deneb-compliant-'));
+  const appDir = path.join(tempDir, 'src', 'app');
+  const dataDir = path.join(tempDir, 'src', 'data');
+  fs.mkdirSync(appDir, { recursive: true });
+  fs.mkdirSync(dataDir, { recursive: true });
+  fs.writeFileSync(path.join(tempDir, 'package.json'), JSON.stringify({ name: 'sample', dependencies: { next: '15.0.0' } }));
+  fs.writeFileSync(path.join(tempDir, 'fivora-template.json'), JSON.stringify({
+    framework: 'nextjs-static-export',
+    version: 2,
+    arcVersion: '2.1.0',
+    schemaVersion: 2,
+    siteDataFile: 'src/data/site-data.json',
+    pages: [{ id: 'home', label: 'Home', route: '/', required: true }],
+    editorSchema: {
+      version: 1,
+      sections: [
+        { id: 'home', path: 'home', type: 'object', label: 'Home', fields: [{ key: 'heroTitle', type: 'text' }] }
+      ]
+    },
+    visualEditing: {
+      contractVersion: 1,
+      mode: 'strict',
+      controlOnlyPaths: []
+    }
+  }, null, 2));
+  fs.writeFileSync(path.join(dataDir, 'site-data.json'), JSON.stringify({
+    content: {
+      home: { heroTitle: 'Welcome' }
+    }
+  }, null, 2));
+  fs.writeFileSync(path.join(appDir, 'layout.tsx'), 'export default function RootLayout({ children }: any) { return <html><body>{children}</body></html>; }');
+  fs.writeFileSync(path.join(appDir, 'page.tsx'), 'export default function HomePage() { return <main data-preview-page-id="home"><h1 data-preview-field-path="home.heroTitle">Welcome</h1></main>; }');
+
+  return {
+    dir: tempDir,
+    cleanup: () => fs.rmSync(tempDir, { recursive: true, force: true }),
+  };
+}
+
+test('Explain Blocked: identifies clean status for compliant storefront (coffee)', () => {
+  const baseDir = resolveWorkspaceStorefrontsDir();
+  const coffeeDir = path.join(baseDir, 'coffee');
+  const hasRealCoffee = fs.existsSync(coffeeDir) && fs.existsSync(path.join(coffeeDir, 'fivora-template.json'));
+
+  let compliantDir = coffeeDir;
+  let compliantCleanup = null;
+  if (!hasRealCoffee) {
+    const fixture = createMockCompliantProject();
+    compliantDir = fixture.dir;
+    compliantCleanup = fixture.cleanup;
+  }
+
+  try {
+    const report = analyzeBlockedProject(compliantDir);
+    assert.equal(report.blocked, false);
+    assert.equal(report.totalBlockingIssues, 0);
+    assert.equal(report.findings.length, 0);
+    assert.equal(report.summary.contractPassed, true);
+  } finally {
+    if (compliantCleanup) compliantCleanup();
+  }
+});
+
+test('Explain Blocked: pinpoints exact unmapped field paths and locations for blocked storefront', () => {
+  const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'deneb-explain-unmapped-'));
+  const compDir = path.join(tempDir, 'src', 'components');
+  const dataDir = path.join(tempDir, 'src', 'data');
+  fs.mkdirSync(compDir, { recursive: true });
+  fs.mkdirSync(dataDir, { recursive: true });
+  fs.writeFileSync(path.join(dataDir, 'site-data.json'), JSON.stringify({
+    content: {
+      home: {
+        missingField: 'Unmapped Content',
+      },
+    },
+  }));
+  fs.writeFileSync(path.join(tempDir, 'fivora-template.json'), JSON.stringify({
+    framework: 'nextjs-static-export',
+    siteDataFile: 'src/data/site-data.json',
+    editorSchema: {
+      sections: [{ id: 'home', path: 'home', type: 'object', fields: [{ key: 'missingField', type: 'text' }] }],
+    },
+  }));
+  fs.writeFileSync(path.join(compDir, 'Showcase.tsx'), 'export function Showcase() {\n  return <div><span>No Marker</span></div>;\n}');
+
+  try {
+    const report = analyzeBlockedProject(tempDir);
+    assert.equal(report.blocked, true);
+    assert.equal(report.totalBlockingIssues, 1);
+    assert.equal(report.summary.contractPassed, false);
+
+    const first = report.findings[0];
+    assert.equal(first.ruleId, 'FIVORA_UNMAPPED_FIELD');
+    assert.ok(first.file.includes('Showcase.tsx'));
+    assert.ok(first.line >= 1);
+    assert.ok(first.remediation.includes('data-preview-field-path') || first.remediation.includes('controlOnlyPaths'));
+  } finally {
+    fs.rmSync(tempDir, { recursive: true, force: true });
+  }
+});
+
+test('Explain Blocked: identifies unsupported schema type and duplicate sections for blocked storefront', () => {
+  const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'deneb-explain-schema-'));
+  const dataDir = path.join(tempDir, 'src', 'data');
+  fs.mkdirSync(dataDir, { recursive: true });
+  fs.writeFileSync(path.join(dataDir, 'site-data.json'), JSON.stringify({ content: {} }));
+  fs.writeFileSync(path.join(tempDir, 'fivora-template.json'), JSON.stringify({
+    framework: 'nextjs-static-export',
+    siteDataFile: 'src/data/site-data.json',
+    editorSchema: {
+      sections: [
+        {
+          id: 'shop',
+          path: 'shop',
+          type: 'object',
+          fields: [
+            { key: 'price', type: 'currency', label: 'Price' },
+            { key: 'dup', type: 'text', label: 'Dup' },
+          ],
+        },
+        {
+          id: 'shop_dup',
+          path: 'shop',
+          type: 'object',
+          fields: [
+            { key: 'dup', type: 'text', label: 'Dup' },
+          ],
+        },
+      ],
+    },
+  }));
+
+  try {
+    const report = analyzeBlockedProject(tempDir);
+    assert.equal(report.blocked, true);
+    assert.ok(report.totalBlockingIssues >= 2);
+
+    const hasUnsupportedType = report.findings.some((f) => f.ruleId === 'SCHEMA_UNSUPPORTED_TYPE');
+    assert.equal(hasUnsupportedType, true);
+
+    const unsupported = report.findings.find((f) => f.ruleId === 'SCHEMA_UNSUPPORTED_TYPE');
+    assert.ok(unsupported.message.includes('currency'));
+    assert.ok(unsupported.remediation.includes('Replace type \'currency\' with \'number\' or \'text\''));
+  } finally {
+    fs.rmSync(tempDir, { recursive: true, force: true });
+  }
+});
+
+test('Explain Blocked: formats terminal UI with clear problem and fix descriptions', () => {
+  const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'deneb-explain-ui-'));
+  const compDir = path.join(tempDir, 'src', 'components');
+  const dataDir = path.join(tempDir, 'src', 'data');
+  fs.mkdirSync(compDir, { recursive: true });
+  fs.mkdirSync(dataDir, { recursive: true });
+  fs.writeFileSync(path.join(dataDir, 'site-data.json'), JSON.stringify({
+    content: { home: { testField: 'Hello' } },
+  }));
+  fs.writeFileSync(path.join(tempDir, 'fivora-template.json'), JSON.stringify({
+    framework: 'nextjs-static-export',
+    siteDataFile: 'src/data/site-data.json',
+    editorSchema: {
+      sections: [{ id: 'home', path: 'home', type: 'object', fields: [{ key: 'testField', type: 'text' }] }],
+    },
+  }));
+  fs.writeFileSync(path.join(compDir, 'Comp.tsx'), 'export function Comp() { return <div>Unbound</div>; }');
+
+  try {
+    const report = analyzeBlockedProject(tempDir);
+    const terminal = formatBlockedExplanationTerminal(report);
+
+    assert.ok(terminal.includes('DENEB CONVERSION BLOCKED'));
+    assert.ok(terminal.includes('Comp.tsx'));
+    assert.ok(terminal.includes('Fix:'));
+    assert.ok(terminal.includes('npx @deneb-ui/cli init'));
+  } finally {
+    fs.rmSync(tempDir, { recursive: true, force: true });
+  }
+});

package/src/arc/__tests__/fuzz.test.cjs

@@ -0,0 +1,106 @@
+'use strict';
+
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const {
+  MUTATION_TYPES,
+  DEFAULT_SAMPLE_COMPONENT,
+  applyMutation,
+  generateFuzzCorpus,
+  testMutationResilience,
+  runFuzzHarness,
+} = require('../fuzz-engine.cjs');
+
+test('Fuzz Engine: applies individual AST mutations cleanly', () => {
+  // 1. PROP_RENAME
+  const renameResult = applyMutation(DEFAULT_SAMPLE_COMPONENT, 'PROP_RENAME');
+  assert.equal(renameResult.applied, true);
+  assert.ok(renameResult.mutatedCode.includes('fuzzed_') || renameResult.mutatedCode !== DEFAULT_SAMPLE_COMPONENT);
+
+  // 2. WRAP_FRAGMENT
+  const fragmentResult = applyMutation(DEFAULT_SAMPLE_COMPONENT, 'WRAP_FRAGMENT');
+  assert.equal(fragmentResult.applied, true);
+  assert.ok(fragmentResult.mutatedCode.includes('<>') && fragmentResult.mutatedCode.includes('</>'));
+
+  // 3. WRAP_DIV
+  const divResult = applyMutation(DEFAULT_SAMPLE_COMPONENT, 'WRAP_DIV');
+  assert.equal(divResult.applied, true);
+  assert.ok(divResult.mutatedCode.includes('fuzzed-container-wrapper'));
+
+  // 4. SPREAD_PROPS
+  const spreadResult = applyMutation(DEFAULT_SAMPLE_COMPONENT, 'SPREAD_PROPS');
+  assert.equal(spreadResult.applied, true);
+  assert.ok(spreadResult.mutatedCode.includes('...fuzzedProps'));
+
+  // 5. CONDITIONAL_TERNARY
+  const ternaryResult = applyMutation(DEFAULT_SAMPLE_COMPONENT, 'CONDITIONAL_TERNARY');
+  assert.equal(ternaryResult.applied, true);
+  assert.ok(ternaryResult.mutatedCode.includes('isFuzzedConditionActive'));
+
+  // 6. CONDITIONAL_LOGICAL
+  const logicalResult = applyMutation(DEFAULT_SAMPLE_COMPONENT, 'CONDITIONAL_LOGICAL');
+  assert.equal(logicalResult.applied, true);
+  assert.ok(logicalResult.mutatedCode.includes('showFuzzedContent &&'));
+
+  // 7. INJECT_OPTIONAL_CHAIN
+  const optionalResult = applyMutation(DEFAULT_SAMPLE_COMPONENT, 'INJECT_OPTIONAL_CHAIN');
+  assert.equal(optionalResult.applied, true);
+  assert.ok(optionalResult.mutatedCode.includes('?.'));
+
+  // 8. NEST_MEMBER_COLLECTION
+  const nestResult = applyMutation(DEFAULT_SAMPLE_COMPONENT, 'NEST_MEMBER_COLLECTION');
+  assert.equal(nestResult.applied, true);
+  assert.ok(nestResult.mutatedCode.includes('.map('));
+
+  // 9. CORRUPT_SYNTAX
+  const corruptResult = applyMutation(DEFAULT_SAMPLE_COMPONENT, 'CORRUPT_SYNTAX');
+  assert.equal(corruptResult.applied, true);
+  assert.ok(corruptResult.mutatedCode.includes('MALFORMED_SYNTAX'));
+});
+
+test('Fuzz Engine: generateFuzzCorpus creates a full mutation suite', () => {
+  const corpus = generateFuzzCorpus(DEFAULT_SAMPLE_COMPONENT);
+  assert.equal(corpus.length, MUTATION_TYPES.length);
+
+  for (const item of corpus) {
+    assert.equal(item.applied, true);
+    assert.notEqual(item.mutatedCode, DEFAULT_SAMPLE_COMPONENT);
+    assert.ok(MUTATION_TYPES.includes(item.mutationType));
+  }
+});
+
+test('Fuzz Engine: cleanly catches corrupt syntax without unhandled crash', () => {
+  const corrupt = applyMutation(DEFAULT_SAMPLE_COMPONENT, 'CORRUPT_SYNTAX');
+  const result = testMutationResilience(corrupt.mutatedCode, 'CORRUPT_SYNTAX');
+
+  assert.equal(result.crashed, false);
+  assert.equal(result.resilient, true);
+  assert.equal(result.status, 'PARSER_REJECTED_CLEANLY');
+});
+
+test('Fuzz Engine: verifies compiler resilience across structural mutations', () => {
+  // Test spread props resilience
+  const spread = applyMutation(DEFAULT_SAMPLE_COMPONENT, 'SPREAD_PROPS');
+  const spreadRes = testMutationResilience(spread.mutatedCode, 'SPREAD_PROPS');
+  assert.equal(spreadRes.crashed, false);
+  assert.equal(spreadRes.resilient, true);
+  assert.equal(spreadRes.outputValidSyntax, true);
+
+  // Test fragment wrapping resilience
+  const frag = applyMutation(DEFAULT_SAMPLE_COMPONENT, 'WRAP_FRAGMENT');
+  const fragRes = testMutationResilience(frag.mutatedCode, 'WRAP_FRAGMENT');
+  assert.equal(fragRes.crashed, false);
+  assert.equal(fragRes.resilient, true);
+  assert.equal(fragRes.outputValidSyntax, true);
+});
+
+test('Fuzz Engine: runFuzzHarness executes end-to-end with 100% resilience score', () => {
+  const report = runFuzzHarness(DEFAULT_SAMPLE_COMPONENT);
+
+  assert.equal(report.totalMutations, MUTATION_TYPES.length);
+  assert.equal(report.crashedCount, 0, 'Must have zero unhandled crashes');
+  assert.equal(report.syntaxErrorsInOutput, 0, 'Must have zero syntax errors in output');
+  assert.equal(report.resilienceScore, 100.0, 'Resilience score must be 100%');
+  assert.equal(report.allResilient, true);
+  assert.ok(report.results.length === MUTATION_TYPES.length);
+});

package/src/arc/__tests__/interaction.test.cjs

@@ -0,0 +1,85 @@
+'use strict';
+
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const {
+  INTERACTIVE_PATTERNS,
+  analyzeComponentInteractivity,
+  verifyInteractionsSync,
+} = require('../interaction-verifier.cjs');
+
+test('Interaction Verifier: detects mobile menu toggles and event handlers', () => {
+  const code = `
+    export function Navbar() {
+      const [isOpen, setIsOpen] = useState(false);
+      return (
+        <nav>
+          <button
+            aria-label="Toggle Menu"
+            className="hamburger-menu"
+            onClick={() => setIsOpen(!isOpen)}
+          >
+            <span />
+          </button>
+        </nav>
+      );
+    }
+  `;
+
+  const report = verifyInteractionsSync({ code, componentName: 'Navbar' });
+  assert.equal(report.passed, true);
+  assert.equal(report.interactionScore, 100.0);
+
+  const toggleCheck = report.patterns.find((p) => p.pattern === INTERACTIVE_PATTERNS.NAVBAR_MOBILE_TOGGLE);
+  assert.ok(toggleCheck);
+  assert.equal(toggleCheck.passed, true);
+});
+
+test('Interaction Verifier: detects accordions, tabs, dialogs, and carousels across files', () => {
+  const files = [
+    {
+      file: 'components/Faq.tsx',
+      code: `export function Faq() { return <AccordionTrigger>Question 1</AccordionTrigger>; }`,
+    },
+    {
+      file: 'components/ProductTabs.tsx',
+      code: `export function ProductTabs() { return <TabsTrigger value="details">Details</TabsTrigger>; }`,
+    },
+    {
+      file: 'components/QuickView.tsx',
+      code: `export function QuickView() { return <Dialog>Content</Dialog>; }`,
+    },
+    {
+      file: 'components/HeroCarousel.tsx',
+      code: `export function HeroCarousel() { return <Swiper><SwiperSlide>1</SwiperSlide></Swiper>; }`,
+    },
+    {
+      file: 'components/ContactForm.tsx',
+      code: `export function ContactForm() { return <form onSubmit={(e) => handleSubmit(e)}><button type="submit">Send</button></form>; }`,
+    },
+  ];
+
+  const report = verifyInteractionsSync({ files });
+  assert.equal(report.passed, true);
+  assert.equal(report.totalTested, 5);
+  assert.equal(report.passedTests, 5);
+  assert.equal(report.failedTests, 0);
+  assert.equal(report.interactionScore, 100.0);
+});
+
+test('Interaction Verifier: flags missing event handler on interactive trigger', () => {
+  const code = `
+    export function BrokenNav() {
+      return (
+        <button aria-label="Toggle Menu" className="nav-toggle">
+          <span>Click</span>
+        </button>
+      );
+    }
+  `;
+
+  const report = verifyInteractionsSync({ code, componentName: 'BrokenNav' });
+  assert.equal(report.passed, false);
+  assert.equal(report.failedTests, 1);
+  assert.ok(report.patterns[0].reason.includes('Missing onClick handler'));
+});