@deneb-ui/cli 2.0.88 → 2.0.89

package/src/arc/residual.cjs

@@ -449,7 +449,29 @@ function applyResidualPass({ code, file, ownerScope, usedPaths, componentName, r
   };
 }
 
+const RESIDUAL_REASONS = {
+  STATIC_INTENTIONAL: 'STATIC_INTENTIONAL',
+  STATIC_DECORATIVE: 'STATIC_DECORATIVE',
+  PLATFORM_CONTROLLED: 'PLATFORM_CONTROLLED',
+  RUNTIME_DATA: 'RUNTIME_DATA',
+  UNSUPPORTED_SAFE: 'UNSUPPORTED_SAFE',
+  CONVERSION_FAILED: 'CONVERSION_FAILED',
+};
+
+function normalizeResidualReason(rawReason) {
+  if (!rawReason) return RESIDUAL_REASONS.STATIC_DECORATIVE;
+  const lower = String(rawReason).toLowerCase();
+  if (lower.includes('fail') || lower.includes('error')) return RESIDUAL_REASONS.CONVERSION_FAILED;
+  if (lower.includes('platform') || lower.includes('control')) return RESIDUAL_REASONS.PLATFORM_CONTROLLED;
+  if (lower.includes('runtime') || lower.includes('session') || lower.includes('cart')) return RESIDUAL_REASONS.RUNTIME_DATA;
+  if (lower.includes('intentional') || lower.includes('brand')) return RESIDUAL_REASONS.STATIC_INTENTIONAL;
+  if (lower.includes('unsupported') || lower.includes('complex')) return RESIDUAL_REASONS.UNSUPPORTED_SAFE;
+  return RESIDUAL_REASONS.STATIC_DECORATIVE;
+}
+
 module.exports = {
   applyResidualPass,
   isMeaningfulVisibleText,
+  RESIDUAL_REASONS,
+  normalizeResidualReason,
 };

package/src/arc/rsc-boundary.cjs

@@ -4,8 +4,9 @@ const recast = require('recast');
 const b = recast.types.builders;
 
 /**
- * RSC (React Server Components) Boundary Intelligence for Next.js App Router.
- * Ensures proper placement of 'use client' directives and prevents metadata export conflicts.
+ * Deneb ARC v3 — Conservative RSC (React Server Components) Boundary Optimizer.
+ * Ensures proper placement of 'use client' directives, minimal boundary isolation,
+ * metadata export protection, and RSC metrics tracking.
  */
 
 /**
@@ -54,6 +55,37 @@ function hasMetadataExport(ast) {
   return hasMetadata;
 }
 
+/**
+ * Detects if the AST defines an async component (async function Page).
+ * Async components in Next.js are strictly server-side and cannot have 'use client'.
+ */
+function isAsyncServerComponent(ast) {
+  let isAsync = false;
+
+  recast.types.visit(ast, {
+    visitExportDefaultDeclaration(pathNode) {
+      const decl = pathNode.node.declaration;
+      if (decl && (decl.type === 'FunctionDeclaration' || decl.type === 'ArrowFunctionExpression' || decl.type === 'FunctionExpression')) {
+        if (decl.async) {
+          isAsync = true;
+          return false;
+        }
+      }
+      this.traverse(pathNode);
+    },
+    visitFunctionDeclaration(pathNode) {
+      const name = pathNode.node.id?.name;
+      if (name && /^(Page|Layout|Template|[A-Z])/.test(name) && pathNode.node.async) {
+        isAsync = true;
+        return false;
+      }
+      this.traverse(pathNode);
+    },
+  });
+
+  return isAsync;
+}
+
 /**
  * Detects if the AST has a 'use client' directive.
  */
@@ -105,7 +137,7 @@ function needsClientDirective(ast, code = '') {
  * Determines whether 'use client' can be safely injected into the file.
  * Returns false if:
  * 1. File exports metadata or generateMetadata.
- * 2. File is a layout with metadata.
+ * 2. File is an async server component.
  */
 function canSafelyInjectClientDirective(ast, relativeFile = '', profile = {}) {
   const isAppRouter = profile.router === 'next-app' || (profile.appDir && relativeFile.startsWith(profile.appDir));
@@ -113,7 +145,7 @@ function canSafelyInjectClientDirective(ast, relativeFile = '', profile = {}) {
     return true;
   }
 
-  if (hasMetadataExport(ast)) {
+  if (hasMetadataExport(ast) || isAsyncServerComponent(ast)) {
     return false;
   }
 
@@ -145,10 +177,79 @@ function ensureClientDirective(ast) {
   return true;
 }
 
+/**
+ * Calculates the smallest client-editable boundary.
+ * Prevents turning entire server page trees into client components.
+ */
+function calculateMinimalClientBoundary(componentInfo = {}) {
+  if (componentInfo.isAsync || componentInfo.hasMetadata) {
+    return 'server';
+  }
+  if (componentInfo.hasHooks || componentInfo.hasEvents) {
+    return 'client';
+  }
+  return componentInfo.isLeaf ? 'client' : 'server';
+}
+
+/**
+ * Computes RSC metrics across the compilation run.
+ */
+function computeRscMetrics(files = []) {
+  let clientBoundariesBefore = 0;
+  let clientBoundariesAfter = 0;
+  let serverComponentsConverted = 0;
+  let serverComponentsPreserved = 0;
+
+  for (const f of files) {
+    if (f.hadClientDirective) clientBoundariesBefore++;
+    if (f.hasClientDirective) clientBoundariesAfter++;
+
+    if (!f.hadClientDirective && f.hasClientDirective) {
+      serverComponentsConverted++;
+    } else if (!f.hasClientDirective) {
+      serverComponentsPreserved++;
+    }
+  }
+
+  const total = files.length || 1;
+  const minimalBoundarySuccessRate = Number(((serverComponentsPreserved / total) * 100).toFixed(2));
+  const conversionExceededThreshold = serverComponentsConverted > 10;
+
+  return {
+    clientBoundariesBefore,
+    clientBoundariesAfter,
+    serverComponentsConverted,
+    serverComponentsPreserved,
+    minimalBoundarySuccessRate,
+    conversionExceededThreshold,
+  };
+}
+
+/**
+ * Validates RSC metrics against threshold limits.
+ */
+function validateRscBoundaryIntegrity(metrics, maxAllowedConversions = 10) {
+  if (metrics.serverComponentsConverted > maxAllowedConversions) {
+    return {
+      valid: false,
+      error: `Excessive RSC conversions: ${metrics.serverComponentsConverted} server components converted to client (max allowed: ${maxAllowedConversions})`,
+      metrics,
+    };
+  }
+  return {
+    valid: true,
+    metrics,
+  };
+}
+
 module.exports = {
   hasMetadataExport,
   hasClientDirective,
+  isAsyncServerComponent,
   needsClientDirective,
   canSafelyInjectClientDirective,
   ensureClientDirective,
+  calculateMinimalClientBoundary,
+  computeRscMetrics,
+  validateRscBoundaryIntegrity,
 };

package/src/arc/runtime-validator.cjs

@@ -269,6 +269,70 @@ class RuntimeValidator {
   }
 }
 
+function validateCollectionOperations(siteData = {}) {
+  const content = siteData.content || siteData;
+  const results = [];
+  let allPassed = true;
+
+  function findCollections(obj, prefix = '') {
+    for (const [k, v] of Object.entries(obj || {})) {
+      const fullPath = prefix ? `${prefix}.${k}` : k;
+      if (Array.isArray(v)) {
+        // Test 1: Add Item
+        const cloned = JSON.parse(JSON.stringify(v));
+        const sampleItem = cloned[0] && typeof cloned[0] === 'object' ? { ...cloned[0], id: 'new-999' } : 'new-item';
+        cloned.push(sampleItem);
+        const addPassed = cloned.length === v.length + 1;
+
+        // Test 2: Remove Item
+        const removeCloned = JSON.parse(JSON.stringify(v));
+        removeCloned.pop();
+        const removePassed = removeCloned.length === Math.max(0, v.length - 1);
+
+        // Test 3: Reorder Items
+        const reorderCloned = JSON.parse(JSON.stringify(v));
+        reorderCloned.reverse();
+        const reorderPassed = reorderCloned.length === v.length;
+
+        // Test 4: Mutate Item Field
+        let mutatePassed = true;
+        if (v.length > 0 && typeof v[0] === 'object' && v[0] !== null) {
+          const firstKey = Object.keys(v[0])[0];
+          if (firstKey) {
+            const mutateCloned = JSON.parse(JSON.stringify(v));
+            mutateCloned[0][firstKey] = '__MUTATED__';
+            mutatePassed = mutateCloned[0][firstKey] === '__MUTATED__';
+          }
+        }
+
+        const colPassed = addPassed && removePassed && reorderPassed && mutatePassed;
+        if (!colPassed) allPassed = false;
+
+        results.push({
+          path: fullPath,
+          itemCount: v.length,
+          operations: {
+            addItem: addPassed,
+            removeItem: removePassed,
+            reorderItems: reorderPassed,
+            mutateItemField: mutatePassed,
+          },
+          passed: colPassed,
+        });
+      } else if (typeof v === 'object' && v !== null) {
+        findCollections(v, fullPath);
+      }
+    }
+  }
+
+  findCollections(content);
+  return {
+    passed: allPassed,
+    collections: results,
+    totalCollections: results.length,
+  };
+}
+
 function validateRuntimeEditabilitySync(options) {
   const validator = new RuntimeValidator(options);
   return validator.runSync();
@@ -283,4 +347,5 @@ module.exports = {
   RuntimeValidator,
   validateRuntimeEditability,
   validateRuntimeEditabilitySync,
+  validateCollectionOperations,
 };

package/src/arc/semantic.cjs

@@ -530,7 +530,16 @@ function collectLooseText(code) {
   return /<(h[1-6]|p|Button|span)[^>]*>\s*[A-Za-z]/.test(code);
 }
 
-function analyzeFile({ code, relativeFile, profile, graph, ownerScope, componentMeta, ir = profile?.ir || null }) {
+function analyzeFile(optionsOrFile, codeArg, profileArg) {
+  let code, relativeFile, profile, graph, ownerScope, componentMeta, ir;
+  if (typeof optionsOrFile === 'string') {
+    relativeFile = optionsOrFile;
+    code = codeArg;
+    profile = profileArg;
+    ir = profile?.ir || null;
+  } else {
+    ({ code, relativeFile, profile, graph, ownerScope, componentMeta, ir = profile?.ir || null } = optionsOrFile || {});
+  }
   const adapters = activeAdapters(profile);
   const fileSkip = skipReasonForFile(relativeFile, code);
   if (fileSkip) {
@@ -1165,6 +1174,8 @@ function analyzeFile({ code, relativeFile, profile, graph, ownerScope, component
     alreadyEditable: fileAlreadyEditable(code),
     bindings: Object.fromEntries([...bindings.entries()].filter(([, v]) => typeof v === 'string')),
     imports,
+    code,
+    relativeFile,
   };
 }