@chemx/create-chemx 26.9.13-272 → 26.9.13-383

package/cli/audit/ai-slop-detector.js

@@ -222,12 +222,13 @@ export const createAiSlopVisitors = ({ relativePath, violations }) => {
     VariableDeclarator(astPath) {
       if (!isComponentFile) return;
       const idName = astPath.node.id?.name?.toLowerCase();
-      if (
-        idName &&
-        REINVENTED_UTILS.has(idName) &&
-        (t.isArrowFunctionExpression(astPath.node.init) || t.isFunctionExpression(astPath.node.init))
-      ) {
-        const line = astPath.node.loc?.start.line || 1;
+      if (!idName || !REINVENTED_UTILS.has(idName)) return;
+
+      const initNode = astPath.node.init;
+      const isFunction = t.isArrowFunctionExpression(initNode) || t.isFunctionExpression(initNode);
+      if (!isFunction) return;
+
+      const line = astPath.node.loc?.start.line || 1;
         const meta = RULE_REGISTRY.AI_SLOP_UTILITY_REINVENTION;
         violations.push({
           filePath: relativePath,
@@ -240,7 +241,6 @@ export const createAiSlopVisitors = ({ relativePath, violations }) => {
           directive: meta.directive,
           isAiSlop: true
         });
-      }
     }
   };
 };

package/cli/audit/extended-visitors.js

@@ -3,6 +3,11 @@ import path from 'node:path';
 import * as t from '@babel/types';
 import { RULE_REGISTRY } from './rules-registry.js';
 import { toResultSync } from './rules-helpers.js';
+import {
+  isComponentExtension,
+  isTemplateExtension,
+  isCommentLine
+} from './rules-predicates.js';
 
 const BARE_BOOLEANS = new Set([
   'loading', 'valid', 'active', 'visible', 'open', 'disabled',
@@ -37,11 +42,12 @@ const checkMoleculeCoLocatedTest = (filePath, relativePath, violations) => {
 
   // Stage 1: Atomic Concept Declarations
   const isMoleculePath = relativePath.includes('molecules') || baseName.startsWith('m-');
-  const isComponentExt = ext === '.vue' || ext === '.tsx' || ext === '.jsx';
+  const isComponentExt = isComponentExtension(ext);
   const isTestOrSpecFile = baseName.includes('.spec.') || baseName.includes('.test.');
 
   // Stage 2: Unified Decision Variable & Early Guard Clause
-  const isMoleculeComponent = isMoleculePath && isComponentExt && !isTestOrSpecFile;
+  const isCandidateComponent = isMoleculePath && isComponentExt;
+  const isMoleculeComponent = isCandidateComponent && !isTestOrSpecFile;
   if (!isMoleculeComponent) return;
 
   const dir = path.dirname(filePath);
@@ -75,12 +81,12 @@ export const checkExtendedTextPatterns = (content, lines, relativePath, filePath
 
   const isTestFile = /\.(test|spec)\.[jt]sx?$/.test(filePath);
   const ext = path.extname(filePath);
-  const isTemplateFile = ext === '.vue' || ext === '.html' || ext === '.svelte';
+  const isTemplateFile = isTemplateExtension(ext);
 
   lines.forEach((lineText, idx) => {
     const lineNum = idx + 1;
     const trimmed = lineText.trim();
-    const isComment = trimmed.startsWith('//') || trimmed.startsWith('*') || trimmed.startsWith('/*');
+    const isComment = isCommentLine(trimmed);
 
     // Pillar 9: Hardcoded Secret Detection
     const hasEnvReference = trimmed.includes('process.env') || trimmed.includes('import.meta.env');

package/cli/audit/history.js

@@ -1,6 +1,7 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { groupViolationsBySeverity } from './reporter.js';
+import { hasMatchingAuditMetrics } from './rules-predicates.js';
 
 const RESET = '\x1b[0m';
 const BOLD = '\x1b[1m';
@@ -177,10 +178,7 @@ export const saveAuditSnapshot = (report, cwd = process.cwd()) => {
   if (history.length > 0) {
     const last = history[history.length - 1];
     const timeDiff = Math.abs(Date.now() - new Date(last.timestamp).getTime());
-    const isSameMetrics =
-      last.health?.score === snapshot.health?.score &&
-      last.metrics?.totalLoc === snapshot.metrics?.totalLoc &&
-      last.violations?.total === snapshot.violations?.total;
+    const isSameMetrics = hasMatchingAuditMetrics(last, snapshot);
 
     if (timeDiff < 5000 && isSameMetrics) {
       return {

package/cli/audit/prompts.js

@@ -252,6 +252,43 @@ export const buildHotspotsPrompt = (report) => {
   return lines.join('\n');
 };
 
+export const buildPillarPrompt = (report, pillarName) => {
+  const { violations = [], hotspots = [] } = report;
+  const pillarViolations = violations.filter((v) => v.pillar === pillarName);
+  const isPillar1 = pillarName === 'Line Budgets & Monolith Decomposition';
+  const relevantHotspots = isPillar1 ? hotspots.filter((h) => h.isMonolith || h.lineCount > 500) : [];
+
+  const hasNoViolations = pillarViolations.length === 0;
+  const hasNoHotspots = relevantHotspots.length === 0;
+  if (hasNoViolations && hasNoHotspots) return '';
+
+  const lines = [];
+  lines.push(`Act as a Principal Systems Architect. Surgically refactor the following ${pillarName} violations according to Chemical X Molecular Architecture Standards:\n`);
+
+  if (relevantHotspots.length > 0) {
+    lines.push('### MONOLITHIC REFACTORING HOTSPOTS');
+    lines.push('Action: Decompose into crystalline molecule capsules (< 100 lines) and declarative Table-of-Contents views.\n');
+    relevantHotspots.forEach((h, i) => {
+      lines.push(`${i + 1}. File: \`${h.filePath}\` (${h.lineCount} lines, ${h.violationCount} hazards)`);
+    });
+    lines.push('');
+  }
+
+  if (pillarViolations.length > 0) {
+    lines.push(`### ${pillarName.toUpperCase()} HAZARD VIOLATIONS`);
+    lines.push(...formatGroupedPromptViolations(pillarViolations));
+  }
+
+  lines.push('### STRICT EXECUTION RULES:');
+  lines.push('1. Branch First: Change to a new branch prefixed with `chem-x/NAMEOFIMPROVEMENT` before making changes.');
+  lines.push('2. Pre-Split Pattern Discovery: Survey cross-file patterns before slicing; extract canonical shared capsules first.');
+  lines.push('3. Molecular Capsule Limit: Maximum 100 lines per molecule capsule file.');
+  lines.push('4. Table-of-Contents Views: Top-level page views must be 10 to 20 line declarative templates assembling components via named slots.');
+  lines.push('5. Zero breaking changes to external component APIs, route exports, or existing props.');
+
+  return lines.join('\n');
+};
+
 export const buildMasterPrompt = (report) => {
   const sections = [
     buildGradeFPrompt(report, { excludeAiSlop: true }),

package/cli/audit/reporter-sections.d.ts

@@ -5,6 +5,7 @@ export declare function formatCriticalSection(report: AuditReport): string;
 export declare function formatHighMediumSection(report: AuditReport): string;
 export declare function formatLowSection(report: AuditReport): string;
 export declare function formatPillarsSection(report: AuditReport, themeColor?: string | null): string;
+export declare function formatSinglePillarSection(report: AuditReport, pillarName: string, themeColor?: string | null): string;
 export declare function formatHotspotsSection(report: AuditReport, themeColor?: string | null): string;
 export declare function formatContextAnalysisSection(report: AuditReport, themeColor?: string | null): string;
 export declare function formatAiSlopSection(report: AuditReport, themeColor?: string | null): string;

package/cli/audit/reporter-sections.js

@@ -14,6 +14,7 @@ import {
   resolveRiskColor,
   resolveHotspotBadge,
   resolveTopSectionColor,
+  resolveIndividualPillarGrade,
   PILLAR_EMOJIS,
   formatPillarReactionBadgesTerminal
 } from './reporter-utils.js';
@@ -24,6 +25,7 @@ import {
   buildHotspotsPrompt,
   formatPromptBox
 } from './prompts.js';
+import { resolveFirstDefined } from './rules-predicates.js';
 
 const isSlopViolation = (v) => Boolean(v.isAiSlop);
 
@@ -35,7 +37,8 @@ const formatHotspotItem = (h, idx) => {
 export const formatScorecardSection = (report, themeColor = null) => {
   const { metrics, health } = report;
   const sectionColor = themeColor || resolveTopSectionColor(report);
-  const gradeColor = resolveGradeColor(health?.score ?? health?.grade ?? 'A');
+  const gradeTarget = resolveFirstDefined(health?.score, health?.grade, 'A');
+  const gradeColor = resolveGradeColor(gradeTarget);
   const lines = [];
 
   lines.push('');
@@ -176,6 +179,57 @@ export const formatPillarsSection = (report, themeColor = null) => {
   return lines.join('\n');
 };
 
+export const formatSinglePillarSection = (report, pillarName, themeColor = null) => {
+  const pillarData = report?.pillars?.[pillarName] || {
+    violations: 0,
+    critical: 0,
+    high: 0,
+    medium: 0,
+    low: 0,
+    status: 'PASSED'
+  };
+  const grade = resolveIndividualPillarGrade(pillarData);
+  const gradeColor = resolveGradeColor(grade);
+  const sectionColor = themeColor || gradeColor;
+  const icon = PILLAR_EMOJIS[pillarName] || '🏛️';
+  const lines = [];
+
+  lines.push('');
+  lines.push(`${sectionColor}======================================================================${RESET}`);
+  lines.push(`${BOLD}${sectionColor}   [ ${icon} ] PILLAR ARCHITECTURAL AUDIT : ${pillarName.toUpperCase()}${RESET}`);
+  lines.push(`${sectionColor}======================================================================${RESET}`);
+  lines.push(`   Pillar Grade:      ${gradeColor}${BOLD}Grade: ${grade}${RESET}`);
+  lines.push(`   Compliance Status: ${getStatusBadge(pillarData.status)}`);
+  lines.push(`   Violations:        ${pillarData.violations} total (${pillarData.critical} Critical, ${pillarData.high} High, ${pillarData.medium} Medium, ${pillarData.low} Low)`);
+  lines.push(`${sectionColor}----------------------------------------------------------------------${RESET}`);
+
+  if (pillarData.violations === 0) {
+    lines.push(`\n   ${GREEN}✔ Outstanding! Zero violations detected for this pillar.${RESET}`);
+    lines.push(`   ${DIM}All inspected modules adhere strictly to Chemical X standards for ${pillarName}.${RESET}\n`);
+  } else {
+    const pillarViolations = (report.violations || []).filter((v) => v.pillar === pillarName);
+    if (pillarViolations.length > 0) {
+      lines.push(`\n   ${BOLD}${sectionColor}🚨 DETECTED VIOLATIONS (${pillarViolations.length}):${RESET}\n`);
+      lines.push(renderGroupedViolationsTerminal(pillarViolations));
+    }
+  }
+
+  const isPillar1 = pillarName === 'Line Budgets & Monolith Decomposition';
+  if (isPillar1) {
+    const monolithHotspots = (report?.hotspots || []).filter((h) => h.isMonolith || h.lineCount > 500);
+    if (monolithHotspots.length > 0) {
+      lines.push(`   ${BOLD}${sectionColor}🔥 MONOLITHIC HOTSPOTS (${monolithHotspots.length}):${RESET}`);
+      monolithHotspots.forEach((h, idx) => {
+        lines.push(formatHotspotItem(h, idx));
+      });
+      lines.push('');
+    }
+  }
+
+  lines.push(`${sectionColor}======================================================================${RESET}\n`);
+  return lines.join('\n');
+};
+
 export const formatHotspotsSection = (report, themeColor = null, options = {}) => {
   const { includePrompt = true } = typeof options === 'boolean' ? { includePrompt: options } : options;
   const { hotspots } = report;

package/cli/audit/reporter-utils.js

@@ -63,6 +63,34 @@ export const getStatusBadge = (status) => {
   }
 };
 
+export const resolveIndividualPillarGrade = (pillarData) => {
+  const hasNoViolations = !pillarData || pillarData.violations === 0;
+  if (hasNoViolations) return 'A+';
+
+  const hasCritical = (pillarData.critical || 0) > 0;
+  if (hasCritical) return 'F';
+
+  const hasHigh = (pillarData.high || 0) > 0;
+  if (hasHigh) return 'D';
+
+  const hasMedium = (pillarData.medium || 0) > 0;
+  if (hasMedium) return 'C';
+
+  const hasLow = (pillarData.low || 0) > 0;
+  if (hasLow) return 'B';
+
+  return 'A+';
+};
+
+export const resolvePillarRiskWeight = (pillarData) => {
+  if (!pillarData) return 0;
+  const critical = pillarData.critical || 0;
+  const high = pillarData.high || 0;
+  const medium = pillarData.medium || 0;
+  const low = pillarData.low || 0;
+  return critical * 8 + high * 4 + medium * 2 + low * 1;
+};
+
 export const resolveGradeColor = (scoreOrGrade) => {
   if (typeof scoreOrGrade === 'string') {
     const g = scoreOrGrade.toUpperCase();

package/cli/audit/reporter.js

@@ -16,6 +16,7 @@ import {
   formatHighMediumSection,
   formatLowSection,
   formatPillarsSection,
+  formatSinglePillarSection,
   formatHotspotsSection,
   formatContextAnalysisSection,
   formatAiSlopSection
@@ -108,6 +109,7 @@ export {
   formatHighMediumSection,
   formatLowSection,
   formatPillarsSection,
+  formatSinglePillarSection,
   formatHotspotsSection,
   formatContextAnalysisSection,
   formatAiSlopSection

package/cli/audit/rules-predicates.d.ts

@@ -1,6 +1,9 @@
 import type * as babelTypes from '@babel/types';
 
 export declare function isComponentPath(path: string): boolean;
+export declare function isComponentExtension(ext: string): boolean;
+export declare function isTemplateExtension(ext: string): boolean;
+export declare function isCommentLine(line: string): boolean;
 export declare function isCodeLine(line: string): boolean;
 export declare function isConsoleCallStatement(stmt: unknown, t: typeof babelTypes): boolean;
 export declare function isShallowCatchBody(body: readonly unknown[], t: typeof babelTypes): boolean;
@@ -9,6 +12,8 @@ export declare function isRedundantPassthroughReturn(curr: unknown, next: unknow
 export declare function isHookIdentifier(idNode: unknown): boolean;
 export declare function isCustomHookFunction(astPath: unknown): boolean;
 export declare function resolveStartLine(primaryNode?: unknown, fallbackNode?: unknown, defaultLine?: number): number;
+export declare function resolveFirstDefined<T>(...candidates: readonly (T | null | undefined)[]): T | undefined;
+export declare function hasMatchingAuditMetrics(a: Record<string, any>, b: Record<string, any>): boolean;
 export declare function isZeroDelayTimeout(callee: unknown, delayArg: unknown, t: typeof babelTypes): boolean;
 export declare function isUnguardedConsoleCall(callee: unknown, t: typeof babelTypes): boolean;
 export declare function matchesDiscussionTitle(titleLower: string, targetLower: string): boolean;

package/cli/audit/rules-predicates.js

@@ -4,14 +4,27 @@
  */
 
 const COMPONENT_PATH_SEGMENTS = ['molecules', 'components', '/m-', '/views/', '/pages/'];
+const COMPONENT_EXTENSIONS = new Set(['.vue', '.tsx', '.jsx']);
+const TEMPLATE_EXTENSIONS = new Set(['.vue', '.html', '.svelte']);
+const COMMENT_PREFIXES = ['//', '*', '/*'];
 const CONSOLE_LOG_METHODS = ['log', 'info', 'warn'];
 const NON_INTERACTIVE_FLAGS = ['--non-interactive', '--no-interactive', '--ci'];
+const FORMAT_FLAGS = ['--markdown', '--md', '--json'];
 const GRADE_RANKS = { 'A+': 5, 'A': 4, 'B': 3, 'C': 2, 'D': 1, 'F': 0 };
 
 export const isComponentPath = (path) => {
   return COMPONENT_PATH_SEGMENTS.some((segment) => path.includes(segment));
 };
 
+export const isComponentExtension = (ext) => COMPONENT_EXTENSIONS.has(ext);
+
+export const isTemplateExtension = (ext) => TEMPLATE_EXTENSIONS.has(ext);
+
+export const isCommentLine = (line) => {
+  if (!line) return false;
+  return COMMENT_PREFIXES.some((prefix) => line.startsWith(prefix));
+};
+
 export const isCodeLine = (line) => {
   if (!line) return false;
   const isLineComment = line.startsWith('//');
@@ -60,7 +73,26 @@ export const isCustomHookFunction = (astPath) => {
 };
 
 export const resolveStartLine = (primaryNode, fallbackNode, defaultLine = 1) => {
-  return primaryNode?.loc?.start?.line ?? fallbackNode?.loc?.start?.line ?? defaultLine;
+  const primaryLine = primaryNode?.loc?.start?.line;
+  if (primaryLine !== undefined) return primaryLine;
+  const fallbackLine = fallbackNode?.loc?.start?.line;
+  if (fallbackLine !== undefined) return fallbackLine;
+  return defaultLine;
+};
+
+export const resolveFirstDefined = (...candidates) => {
+  for (const val of candidates) {
+    if (val !== null && val !== undefined) return val;
+  }
+  return undefined;
+};
+
+export const hasMatchingAuditMetrics = (a, b) => {
+  const isScoreMatch = a.health?.score === b.health?.score;
+  if (!isScoreMatch) return false;
+  const isLocMatch = a.metrics?.totalLoc === b.metrics?.totalLoc;
+  if (!isLocMatch) return false;
+  return a.violations?.total === b.violations?.total;
 };
 
 export const isZeroDelayTimeout = (callee, delayArg, t) => {
@@ -101,7 +133,7 @@ export const evaluateAuditFailure = (conditions = []) => {
 export const isNonInteractiveSession = (rawArgs, env = process.env) => {
   const hasCliFlag = NON_INTERACTIVE_FLAGS.some((flag) => rawArgs.includes(flag));
   const hasOutputFlag = rawArgs.some((arg) => arg.startsWith('--output=') || arg.startsWith('-o='));
-  const hasFormatFlag = rawArgs.includes('--markdown') || rawArgs.includes('--md') || rawArgs.includes('--json');
+  const hasFormatFlag = FORMAT_FLAGS.some((flag) => rawArgs.includes(flag));
   const hasCiEnv = Boolean(env.CI || env.GIT_DIR);
-  return hasCliFlag || hasOutputFlag || hasFormatFlag || hasCiEnv;
+  return [hasCliFlag, hasOutputFlag, hasFormatFlag, hasCiEnv].some(Boolean);
 };

package/cli/audit.js

@@ -32,6 +32,7 @@ import {
   formatHighMediumSection,
   formatLowSection,
   formatPillarsSection,
+  formatSinglePillarSection,
   formatHotspotsSection,
   formatContextAnalysisSection,
   formatFailuresSection,
@@ -50,6 +51,7 @@ import {
   formatPillarReactionBadgesMarkdown,
   formatPillarShieldBadges,
   resolveBadgeColor,
+  PILLAR_EMOJIS,
   PILLAR_SHORT_NAMES
 } from './audit/reporter.js';
 import {
@@ -59,6 +61,7 @@ import {
   buildGradeBPrompt,
   buildAiSlopPrompt,
   buildHotspotsPrompt,
+  buildPillarPrompt,
   buildMasterPrompt,
   formatPromptBox,
   formatGroupedPromptViolations
@@ -78,14 +81,14 @@ const IGNORED_DIRS = new Set([
   'out'
 ]);
 
+const EXCLUDED_NAME_PATTERNS = ['.test.', '.spec.', '.min.'];
+
 const isSourceFile = (name) => {
-  return (
-    /\.(tsx|ts|jsx|js|vue)$/.test(name) &&
-    !name.endsWith('.d.ts') &&
-    !name.includes('.test.') &&
-    !name.includes('.spec.') &&
-    !name.includes('.min.')
-  );
+  const isExtensionValid = /\.(tsx|ts|jsx|js|vue)$/.test(name);
+  if (!isExtensionValid) return false;
+  if (name.endsWith('.d.ts')) return false;
+  const isExcluded = EXCLUDED_NAME_PATTERNS.some((pat) => name.includes(pat));
+  return !isExcluded;
 };
 
 export const auditFile = (filePath, relativePath) => {
@@ -249,6 +252,7 @@ export {
   formatHighMediumSection,
   formatLowSection,
   formatPillarsSection,
+  formatSinglePillarSection,
   formatHotspotsSection,
   formatContextAnalysisSection,
   formatFailuresSection,
@@ -267,6 +271,7 @@ export {
   formatPillarReactionBadgesMarkdown,
   formatPillarShieldBadges,
   resolveBadgeColor,
+  PILLAR_EMOJIS,
   PILLAR_SHORT_NAMES,
   buildGradeFPrompt,
   buildGradeDPrompt,
@@ -274,6 +279,7 @@ export {
   buildGradeBPrompt,
   buildAiSlopPrompt,
   buildHotspotsPrompt,
+  buildPillarPrompt,
   buildMasterPrompt,
   formatPromptBox,
   formatGroupedPromptViolations,

package/cli/build.js

@@ -5,6 +5,10 @@ import { groupBuildDiagnostics } from './build/grouper.js';
 import { formatTerminalBuildReport, formatJsonBuildReport } from './build/reporter.js';
 import { ANSI } from './theme.js';
 
+const IGNORED_COMMAND_TOKENS = new Set(['build', 'run', 'wrap']);
+
+const isCommandCandidate = (arg) => !arg.startsWith('-') && !IGNORED_COMMAND_TOKENS.has(arg);
+
 const parseCommandFromArgs = (args) => {
   const dashDashIndex = args.indexOf('--');
   if (dashDashIndex !== -1) {
@@ -12,7 +16,7 @@ const parseCommandFromArgs = (args) => {
     if (afterDash.length > 0) return afterDash;
   }
 
-  const candidate = args.find((a) => !a.startsWith('-') && a !== 'build' && a !== 'run' && a !== 'wrap');
+  const candidate = args.find(isCommandCandidate);
   return candidate ? candidate.trim() : null;
 };
 

package/cli/generator.js

@@ -34,6 +34,9 @@ const detectBaseDir = () => {
   return '.';
 };
 
+const IGNORED_NAME_TOKENS = new Set(['generate', 'capsule', 'add']);
+const isCapsuleNameArg = (arg) => !arg.startsWith('-') && !IGNORED_NAME_TOKENS.has(arg);
+
 export const runGenerateWizard = async (rawArgs = []) => {
   renderBanner('Chemical X: Molecular Capsule Wizard');
   await checkOrPromptEvaluation('generate capsule');
@@ -41,7 +44,7 @@ export const runGenerateWizard = async (rawArgs = []) => {
   const useGum = hasGum();
   const isYes = rawArgs.includes('-y') || rawArgs.includes('--yes');
 
-  const nameArg = rawArgs.find((a) => !a.startsWith('-') && a !== 'generate' && a !== 'capsule' && a !== 'add');
+  const nameArg = rawArgs.find(isCapsuleNameArg);
   const frameworkArg = (rawArgs.find((a) => a.startsWith('--framework=')) || '').split('=')[1]
     || (rawArgs.includes('-f') ? rawArgs[rawArgs.indexOf('-f') + 1] : null);
   const tierArg = (rawArgs.find((a) => a.startsWith('--tier=')) || '').split('=')[1];

package/cli/index.js

@@ -36,6 +36,9 @@ import { runBuildAudit } from './build.js';
 
 const rawArgs = process.argv.slice(2);
 const invokedBin = path.basename(process.argv[1] || '');
+const CAPSULE_PREFIXES = ['m-', 'a-', 'o-', 't-'];
+
+const isCapsulePrefix = (arg) => CAPSULE_PREFIXES.some((prefix) => arg.startsWith(prefix));
 
 const loadProjectConfig = () => {
   const cfgPath = path.resolve(process.cwd(), '.chemx', 'config.json');
@@ -212,7 +215,7 @@ const main = async () => {
       printHelp();
       break;
     default:
-      if (firstArg && (firstArg.startsWith('m-') || firstArg.startsWith('a-') || firstArg.startsWith('o-') || firstArg.startsWith('t-'))) {
+      if (firstArg && isCapsulePrefix(firstArg)) {
         await runGenerateWizard(rawArgs);
       } else if (firstArg && !firstArg.startsWith('-')) {
         await runScaffold(firstArg, rawArgs, runAudit);

package/cli/license.js

@@ -16,11 +16,28 @@ export const CONFIG_FILE = path.join(CONFIG_DIR, 'config.json');
 export const DEVICE_FILE = path.join(CONFIG_DIR, 'device_id');
 
 export const API_BASE = process.env.CHEMICAL_X_API_URL || 'https://chemicalx.xophz.com';
+export const GATEKEEPER_API_URL = process.env.COMPASS_GATEKEEPER_URL || 'https://mycompassconsulting.com/wp-json/compass/v1/gatekeeper';
 export const URL_LEARN = 'https://chemicalx.xophz.com';
 export const URL_SPONSOR = 'https://github.com/sponsors/Chemical-X-Protocol';
 export const URL_STANDARD = 'https://mycompassconsulting.com/buy/chemical-x/standard';
 export const URL_MASTER = 'https://mycompassconsulting.com/buy/chemical-x/master';
 
+export const verifyWithGatekeeper = async (keyOrUser, deviceId = null) => {
+  const effectiveDeviceId = deviceId || getOrCreateDeviceId();
+  try {
+    const res = await fetch(`${GATEKEEPER_API_URL}/licenses/validate`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ key: keyOrUser, deviceId: effectiveDeviceId })
+    });
+    if (!res.ok) return { valid: false };
+    return await res.json();
+  } catch {
+    return { valid: false };
+  }
+};
+
+
 export const ensureConfigDir = () => {
   if (fs.existsSync(CONFIG_DIR)) return true;
   const [, err] = toResultSync(() => fs.mkdirSync(CONFIG_DIR, { recursive: true }));
@@ -328,9 +345,42 @@ export const fetchStarterKitFiles = async (licenseKey) => {
     );
     return responseData.files || {};
   } catch (err) {
+    // Fallback: Verify with Gatekeeper or local blueprints
+    const gatekeeperCheck = await verifyWithGatekeeper(normalizedKey, deviceId);
+    if (gatekeeperCheck.valid) {
+      saveLicenseKey(normalizedKey);
+      process.stdout.write(
+        `\x1b[32m✔ Verified via Gatekeeper for @${gatekeeperCheck.github_user || 'sponsor'} [Tier: ${gatekeeperCheck.tier}]\x1b[0m\n\n`
+      );
+      const localFiles = loadLocalBlueprintFiles();
+      if (Object.keys(localFiles).length > 0) return localFiles;
+    }
+
     process.stderr.write(
       `\x1b[31m✕ Network Error: Failed to reach edge server (${err.message}).\x1b[0m\n`
     );
     process.exit(1);
   }
 };
+
+export const loadLocalBlueprintFiles = () => {
+  const blueprintsDir = path.resolve(path.dirname(new URL(import.meta.url).pathname), '../blueprints');
+  const files = {};
+  if (!fs.existsSync(blueprintsDir)) return files;
+
+  const walk = (dir, base = '') => {
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const rel = base ? `${base}/${entry.name}` : entry.name;
+      const full = path.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        walk(full, rel);
+      } else {
+        files[rel] = fs.readFileSync(full, 'utf-8');
+      }
+    }
+  };
+  walk(blueprintsDir);
+  return files;
+};
+

package/cli/navigator-actions.js

@@ -27,13 +27,21 @@ import {
   buildGradeCPrompt,
   buildGradeBPrompt,
   buildAiSlopPrompt,
+  formatSinglePillarSection,
+  buildPillarPrompt,
+  PILLAR_EMOJIS,
+  PILLAR_SHORT_NAMES,
   buildHotspotsPrompt,
   buildMasterPrompt,
   formatRoadmapSection,
   buildSelfHealingRoadmapPrompt,
   copyToClipboard
 } from "./audit.js";
-import { resolveGradeBadge } from "./navigator-grades.js";
+import {
+  resolveGradeBadge,
+  resolveIndividualPillarGrade,
+  resolvePillarRiskWeight
+} from "./navigator-grades.js";
 import { showPagedContent } from "./navigator-paged.js";
 import { showConversionMenu } from "./navigator-conversion.js";
 import { handleShareToDiscussions } from "./navigator-share.js";
@@ -41,111 +49,99 @@ import { runInstallWizard } from "./installer.js";
 import { formatButtonTag } from "./navigator-menu.js";
 import { runBadgeCommand } from "./badge.js";
 
-const isExtremeMonolith = (h) => h.lineCount >= 2000;
-const isSevereMonolith = (h) => h.lineCount >= 1000 && h.lineCount < 2000;
-const isWarningMonolith = (h) => h.lineCount >= 500 && h.lineCount < 1000;
-const isPassedPillar = (p) => p.status === "PASSED";
-const isFailedPillar = (p) => p.status === "FAILED";
-const isWarnPillar = (p) => p.status === "WARN";
+const GRADE_RISK_RANKS = {
+  F: 5,
+  D: 4,
+  C: 3,
+  B: 2,
+  A: 1,
+  'A+': 0
+};
 
-export const buildActiveGrades = (report) => {
-  const { hotspots, violations, pillars } = report;
-  const { critical, high, medium, low } = groupViolationsBySeverity(violations);
+const comparePillarsByRisk = (a, b) => {
+  const rankA = GRADE_RISK_RANKS[a.grade] ?? 0;
+  const rankB = GRADE_RISK_RANKS[b.grade] ?? 0;
+  if (rankA !== rankB) {
+    return rankB - rankA;
+  }
 
-  const passedPillarsCount = Object.values(pillars || {}).filter(isPassedPillar).length;
-  const failedPillarsCount = Object.values(pillars || {}).filter(isFailedPillar).length;
-  const warnPillarsCount = Object.values(pillars || {}).filter(isWarnPillar).length;
+  if (b.riskWeight !== a.riskWeight) {
+    return b.riskWeight - a.riskWeight;
+  }
 
-  const extremeMonoliths = hotspots.filter(isExtremeMonolith);
-  const severeMonoliths = hotspots.filter(isSevereMonolith);
-  const warningMonoliths = hotspots.filter(isWarningMonolith);
+  if (b.violations !== a.violations) {
+    return b.violations - a.violations;
+  }
 
-  const gradeFCount = critical.length + extremeMonoliths.length + failedPillarsCount;
-  const gradeDCount = high.length + severeMonoliths.length + warnPillarsCount;
-  const gradeCCount = medium.length + warningMonoliths.length;
-  const gradeBCount = low.length;
-  const gradeACount = passedPillarsCount;
+  return a.originalIndex - b.originalIndex;
+};
 
-  const handleGradeAAction = async () => {
-    await showPagedContent(formatGradeASection(report));
-  };
-  const handleGradeBAction = async () => {
-    await showPagedContent(formatGradeBSection(report), buildGradeBPrompt(report));
-  };
-  const handleGradeCAction = async () => {
-    await showPagedContent(formatGradeCSection(report), buildGradeCPrompt(report));
-  };
-  const handleGradeDAction = async () => {
-    await showPagedContent(formatGradeDSection(report), buildGradeDPrompt(report));
-  };
-  const handleGradeFAction = async () => {
-    await showPagedContent(formatGradeFSection(report), buildGradeFPrompt(report));
-  };
-  const slopViolations = (violations || []).filter((v) => v.isAiSlop);
-  const handleSlopAction = async () => {
-    await showPagedContent(formatAiSlopSection(report), buildAiSlopPrompt(report));
-  };
+export const buildActiveGrades = (report) => {
+  const { pillars = {}, violations = [], aiSlop } = report;
+  const pillarEntries = Object.entries(pillars);
+  const items = [];
+
+  pillarEntries.forEach(([pillarName, data], index) => {
+    const grade = resolveIndividualPillarGrade(data);
+    const riskWeight = resolvePillarRiskWeight(data);
+    const icon = PILLAR_EMOJIS[pillarName] || '🏛️';
+    const shortName = PILLAR_SHORT_NAMES[pillarName] || pillarName;
+    const isClean = data.violations === 0;
+    const countLabel = isClean
+      ? '0 items'
+      : `${data.violations} ${data.violations === 1 ? 'item' : 'items'}`;
+
+    const handlePillarAction = async () => {
+      await showPagedContent(
+        formatSinglePillarSection(report, pillarName),
+        buildPillarPrompt(report, pillarName)
+      );
+    };
+
+    items.push({
+      key: `pillar_${data.pillarKey || index + 1}`,
+      name: pillarName,
+      shortName,
+      grade,
+      riskWeight,
+      violations: data.violations || 0,
+      originalIndex: index,
+      tag: resolveGradeBadge(grade, 11),
+      label: `${icon} ${pillarName} (${countLabel})`,
+      action: handlePillarAction
+    });
+  });
 
-  const gradeTiers = [
-    {
-      key: "grade_a",
-      grade: "A",
-      count: gradeACount,
-      icon: "✅",
-      description: "Compliant Checks & Passing Pillars",
-      action: handleGradeAAction
-    },
-    {
-      key: "grade_slop",
-      grade: report.aiSlop?.grade || (slopViolations.length > 0 ? "D" : "A"),
-      count: slopViolations.length,
-      icon: "🤖",
-      description: `AI Slop & Authenticity (${report.aiSlop?.score ?? 100}/100 - ${report.aiSlop?.label ?? "Pure Artisanal"})`,
+  if (aiSlop) {
+    const slopViolations = violations.filter((v) => v.isAiSlop);
+    const slopGrade = aiSlop.grade || (slopViolations.length > 0 ? 'D' : 'A+');
+    const slopRiskWeight = resolvePillarRiskWeight(aiSlop.breakdown);
+    const slopCount = slopViolations.length;
+    const isSlopClean = slopCount === 0;
+    const slopCountLabel = isSlopClean
+      ? '0 items'
+      : `${slopCount} ${slopCount === 1 ? 'item' : 'items'}`;
+
+    const handleSlopAction = async () => {
+      await showPagedContent(formatAiSlopSection(report), buildAiSlopPrompt(report));
+    };
+
+    items.push({
+      key: 'grade_slop',
+      name: 'AI Slop & Code Authenticity',
+      shortName: 'Slop',
+      grade: slopGrade,
+      riskWeight: slopRiskWeight,
+      violations: slopCount,
+      originalIndex: pillarEntries.length,
+      tag: resolveGradeBadge(slopGrade, 11),
+      label: `🤖 AI Slop & Authenticity (${aiSlop.score ?? 100}/100 - ${aiSlop.label ?? 'Pure Artisanal'}) (${slopCountLabel})`,
       action: handleSlopAction
-    },
-    {
-      key: "grade_b",
-      grade: "B",
-      count: gradeBCount,
-      icon: "💣",
-      description: "Low Hygiene Issues & Minor Debts",
-      action: handleGradeBAction
-    },
-    {
-      key: "grade_c",
-      grade: "C",
-      count: gradeCCount,
-      icon: "⚡",
-      description: "Medium Severity Debts & Monolith Drift",
-      action: handleGradeCAction
-    },
-    {
-      key: "grade_d",
-      grade: "D",
-      count: gradeDCount,
-      icon: "🔥",
-      description: "High Severity Debts & Severe Monoliths",
-      action: handleGradeDAction
-    },
-    {
-      key: "grade_f",
-      grade: "F",
-      count: gradeFCount,
-      icon: "💥",
-      description: "Critical Hazards & Extreme Monoliths",
-      action: handleGradeFAction
-    }
-  ];
-
-  const createActiveGradeItem = (g) => ({
-    key: g.key || `grade_${g.grade.toLowerCase()}`,
-    grade: g.grade.toLowerCase(),
-    tag: resolveGradeBadge(g.grade, 11),
-    label: `${g.icon} Grade ${g.grade}: ${g.description} (${g.count} ${g.grade === "A" ? "clean" : "items"})`,
-    action: g.action
-  });
+    });
+  }
 
-  return gradeTiers.map(createActiveGradeItem);
+  items.sort(comparePillarsByRisk);
+  return items;
 };
 
 export const buildDashboardActionGroups = ({ report, onScaffold = null, onRerun = null }) => {

package/cli/navigator-grades.js

@@ -53,6 +53,34 @@ export const resolveLowGrade = (count) => {
 const isFailedPillar = (p) => p.status === 'FAILED';
 const isWarnPillar = (p) => p.status === 'WARN';
 
+export const resolveIndividualPillarGrade = (pillarData) => {
+  const hasNoViolations = !pillarData || pillarData.violations === 0;
+  if (hasNoViolations) return 'A+';
+
+  const hasCritical = (pillarData.critical || 0) > 0;
+  if (hasCritical) return 'F';
+
+  const hasHigh = (pillarData.high || 0) > 0;
+  if (hasHigh) return 'D';
+
+  const hasMedium = (pillarData.medium || 0) > 0;
+  if (hasMedium) return 'C';
+
+  const hasLow = (pillarData.low || 0) > 0;
+  if (hasLow) return 'B';
+
+  return 'A+';
+};
+
+export const resolvePillarRiskWeight = (pillarData) => {
+  if (!pillarData) return 0;
+  const critical = pillarData.critical || 0;
+  const high = pillarData.high || 0;
+  const medium = pillarData.medium || 0;
+  const low = pillarData.low || 0;
+  return critical * 8 + high * 4 + medium * 2 + low * 1;
+};
+
 export const resolvePillarGrade = (pillars) => {
   const values = Object.values(pillars || {});
   const failed = values.filter(isFailedPillar).length;

package/cli/navigator-menu.js

@@ -30,6 +30,12 @@ export const buildNavigatorMenu = (topActions, activeGrades, midActions, bottomA
   return { menuItems, menuOptions };
 };
 
+const ROADMAP_KEYWORDS = ['Roadmap', 'Healing', 'Self-Healing'];
+const RERUN_KEYWORDS = ['Re-Run', 'Rerun', 'Re-run', 'Re-Audit'];
+const SHARE_KEYWORDS = ['Share', 'Discussions', 'Plug your'];
+
+const isAnyKeywordPresent = (text, keywords) => keywords.some((kw) => text.includes(kw));
+
 const isChoiceMatchingItem = (cleanChoice) => (item) => {
   const prefix = `${item.index}.`;
   if (cleanChoice.startsWith(prefix) || cleanChoice === String(item.index)) return true;
@@ -51,19 +57,10 @@ const isChoiceMatchingItem = (cleanChoice) => (item) => {
   ) {
     return true;
   }
-  if (
-    item.key === "roadmap" &&
-    (cleanChoice.includes("Roadmap") || cleanChoice.includes("Healing") || cleanChoice.includes("Self-Healing"))
-  ) {
+  if (item.key === "roadmap" && isAnyKeywordPresent(cleanChoice, ROADMAP_KEYWORDS)) {
     return true;
   }
-  if (
-    item.key === "rerun" &&
-    (cleanChoice.includes("Re-Run") ||
-      cleanChoice.includes("Rerun") ||
-      cleanChoice.includes("Re-run") ||
-      cleanChoice.includes("Re-Audit"))
-  ) {
+  if (item.key === "rerun" && isAnyKeywordPresent(cleanChoice, RERUN_KEYWORDS)) {
     return true;
   }
   if (
@@ -73,12 +70,7 @@ const isChoiceMatchingItem = (cleanChoice) => (item) => {
     return true;
   }
   if (item.key === "progress" && cleanChoice.includes("Progress")) return true;
-  if (
-    item.key === "share" &&
-    (cleanChoice.includes("Share") ||
-      cleanChoice.includes("Discussions") ||
-      cleanChoice.includes("Plug your"))
-  ) {
+  if (item.key === "share" && isAnyKeywordPresent(cleanChoice, SHARE_KEYWORDS)) {
     return true;
   }
   if (item.key === "export" && cleanChoice.includes("Export")) return true;
@@ -111,6 +103,12 @@ const isChoiceMatchingItem = (cleanChoice) => (item) => {
   ) {
     return true;
   }
+  if (item.name && cleanChoice.toLowerCase().includes(item.name.toLowerCase())) {
+    return true;
+  }
+  if (item.shortName && cleanChoice.toLowerCase().includes(item.shortName.toLowerCase())) {
+    return true;
+  }
   if (
     item.grade &&
     (cleanChoice.toLowerCase().includes(`grade ${item.grade}`) ||
@@ -168,6 +166,9 @@ const isEffectiveMatchingItem = (effective, exitIndex) => (item) => {
   ) {
     return true;
   }
+  if (item.name && effective === item.name.toLowerCase()) return true;
+  if (item.shortName && effective === item.shortName.toLowerCase()) return true;
+  if (item.key && (effective === item.key.toLowerCase() || effective === item.key.replace(/^pillar_/, '').toLowerCase())) return true;
   if (item.key === effective) return true;
   if (item.grade && (effective === item.grade || effective === `grade ${item.grade}`)) {
     return true;

package/cli/navigator.d.ts

@@ -7,6 +7,8 @@ export declare function resolveCriticalGrade(count: number): string;
 export declare function resolveHighMedGrade(count: number): string;
 export declare function resolveLowGrade(count: number): string;
 export declare function resolvePillarGrade(pillars: Record<string, unknown>): string;
+export declare function resolveIndividualPillarGrade(pillarData: unknown): string;
+export declare function resolvePillarRiskWeight(pillarData: unknown): number;
 export declare function resolveHotspotGrade(hotspots: readonly { readonly lineCount: number }[]): string;
 export declare function resolveContextGrade(riskTier: string): string;
 

package/cli/navigator.js

@@ -29,6 +29,8 @@ export {
   resolveHighMedGrade,
   resolveLowGrade,
   resolvePillarGrade,
+  resolveIndividualPillarGrade,
+  resolvePillarRiskWeight,
   resolveHotspotGrade,
   resolveContextGrade,
   resolveAiSlopGrade

package/cli/scaffold.js

@@ -1,15 +1,27 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { hasGum, gumInput, promptQuestion, renderBanner } from './terminal.js';
-import { obtainLicenseKey, fetchStarterKitFiles } from './license.js';
+import { obtainLicenseKey, fetchStarterKitFiles, loadLocalBlueprintFiles } from './license.js';
 
 export const runScaffold = async (projectName, rawArgs = [], onRunAudit = null) => {
   renderBanner('Chemical X: Molecular Architecture Scaffolder (npm create chemx)');
 
   const licenseKey = await obtainLicenseKey(rawArgs, onRunAudit);
+  let isCommunity = false;
+  let files = {};
+
   if (!licenseKey) {
-    process.stderr.write('\x1b[31m✕ Valid license key is required to scaffold blueprints.\x1b[0m\n');
-    process.exit(1);
+    process.stdout.write(
+      '\n\x1b[38;2;98;201;255m⚡ Chemical X: Community Edition (Free)\x1b[0m\n' +
+      'The Community version is free because you tell us about your project\n' +
+      'and the app will automatically post your scorecard to our GitHub Discussions.\n' +
+      'You get a free plug, we get data to prove Chemical X works and brings real value.\n' +
+      'Everybody wins! Thank you for supporting our Community version.\n\n'
+    );
+    files = loadLocalBlueprintFiles();
+    isCommunity = true;
+  } else {
+    files = await fetchStarterKitFiles(licenseKey);
   }
 
   let targetName = projectName;
@@ -29,8 +41,6 @@ export const runScaffold = async (projectName, rawArgs = [], onRunAudit = null)
     process.exit(1);
   }
 
-  const files = await fetchStarterKitFiles(licenseKey);
-
   process.stdout.write(`Scaffolding Molecular Architecture into: \x1b[36m${finalDirName}/\x1b[0m\n`);
   fs.mkdirSync(targetDir, { recursive: true });
 
@@ -66,13 +76,18 @@ export const runInit = async (targetSubDir = 'src/chemical-x', rawArgs = [], onR
 
   const targetDir = path.resolve(process.cwd(), targetSubDir);
   const licenseKey = await obtainLicenseKey(rawArgs, onRunAudit);
+  let files = {};
+
   if (!licenseKey) {
-    process.stderr.write('\x1b[31m✕ Valid license key is required.\x1b[0m\n');
-    process.exit(1);
+    process.stdout.write(
+      '\n\x1b[38;2;98;201;255m⚡ Chemical X: Community Drop-in (Free)\x1b[0m\n' +
+      'Unpacking standard blueprints for your project. Support community standards: chemicalx.xophz.com\n\n'
+    );
+    files = loadLocalBlueprintFiles();
+  } else {
+    files = await fetchStarterKitFiles(licenseKey);
   }
 
-  const files = await fetchStarterKitFiles(licenseKey);
-
   process.stdout.write(`Unpacking blueprints and hooks into: \x1b[36m${targetSubDir}/\x1b[0m\n`);
 
   let count = 0;

package/docs/CHANGELOG.md

@@ -4,9 +4,20 @@ All notable changes to the Chemical X Starter Kit repository will be documented
 
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
 
+## [2026-09-13]
+
+### Added
+- **Gatekeeper SaaS & Sponsor Verification**: Integrated client license validation in `cli/license.js` with `Xophz Gatekeeper` (`/wp-json/compass/v1/gatekeeper/licenses/validate`), allowing verification of both license keys (`CX-ST-`, `CX-SP-`) and GitHub Sponsor handles.
+- **Community Edition Flow**: Added reciprocal free Community Edition scaffolding in `cli/scaffold.js` allowing developers to unpack blueprints locally while sharing scorecards with community GitHub Discussions.
+- **Local Blueprint Fallback**: Added `loadLocalBlueprintFiles` in `cli/license.js` enabling offline and community blueprint scaffolding without remote edge download dependencies.
+
 ## [2026-09-12]
 
 ### Added
+- Added individual pillar grading and risk-ordered navigation menu (`cli/navigator-actions.js`, `cli/navigator-menu.js`, `cli/navigator-grades.js`):
+  - Replaced generic letter-grade buckets with individual architectural pillar categories, dynamically displaying each pillar's specific grade tag (`A+` to `F`) and item counts.
+  - Sorted pillar categories dynamically from highest to lowest risk based on severity weight (`critical * 8 + high * 4 + medium * 2 + low * 1`), while preserving canonical 1 to 11 order when all pillars pass with Grade A+.
+  - Added dedicated individual pillar report view (`formatSinglePillarSection` in `cli/audit/reporter-sections.js`) and pillar AI refactoring prompt generator (`buildPillarPrompt` in `cli/audit/prompts.js`).
 - Added Build Auditor wrapper command (`chemx build`, aliases `run`, `wrap`) with token-optimized silent execution (`cli/build.js`, `cli/build/`):
   - Wraps arbitrary or auto-detected build scripts (`pnpm run build`, `yarn build`, `bun run build`, `npm run build`, `vite build`, `tsc --noEmit`).
   - Automatically parses and catalogs TypeScript (`TS*`), Rollup/Vite resolution, Sass/PostCSS syntax, and bundle budget errors into structured diagnostic categories with 1-line remediation hints.
@@ -20,6 +31,17 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
 - Preserved clean stdout in workflows by writing markdown reports to `--output` files without dumping raw markdown to the terminal.
 - Replaced top-level synchronous config directory creation in `cli/license.js` with lazy `ensureConfigDir` and `toResultSync` Result Tuple pattern.
 
+### Refactored
+- Harmonized multi-clause boolean predicate topologies across CLI and audit modules:
+  - Extracted canonical extension helpers (`isComponentExtension`, `isTemplateExtension`, `isCommentLine`), metric comparison (`hasMatchingAuditMetrics`), and fallback resolution (`resolveFirstDefined`) in `cli/audit/rules-predicates.js` and `cli/audit/rules-predicates.d.ts`.
+  - Refactored `checkMoleculeCoLocatedTest` and `checkExtendedTextPatterns` in `cli/audit/extended-visitors.js` to use canonical predicate helpers and 2-stage atomic booleans.
+  - Refactored `VariableDeclarator` in `cli/audit/ai-slop-detector.js` to use sequential guard clauses for reinvented utility detection.
+  - Refactored `saveAuditSnapshot` in `cli/audit/history.js` using `hasMatchingAuditMetrics`.
+  - Refactored capsule prefix detection in `cli/index.js` and CLI build/generate argument parsing in `cli/build.js` and `cli/generator.js` using predicate helpers.
+  - Refactored menu choice matching in `cli/navigator-menu.js` using `isAnyKeywordPresent` and keyword catalogs.
+  - Refactored scorecard grade target resolution in `cli/audit/reporter-sections.js` using `resolveFirstDefined`.
+  - Refactored source file detection in `cli/audit.js` using early return guard clauses and exclusion arrays.
+
 ## [2026-09-08]
 
 ### Added

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chemx/create-chemx",
-  "version": "26.9.13-272",
+  "version": "26.9.13-383",
   "description": "Chemical X Protocol: Private drop-in architecture starter kit and capsule generator",
   "type": "module",
   "bin": {