@mr.dj2u/cli 0.1.14 → 0.1.16

package/dist/cess-intake.js

@@ -76,6 +76,7 @@ const CESS_QUESTIONS = [
         options: () => [
             { value: 'uniwind', label: 'Uniwind', hint: 'Default and MDS preference' },
             { value: 'nativewind', label: 'NativeWind' },
+            { value: 'nativewindui', label: 'NativeWindUI' },
             { value: 'tamagui', label: 'Tamagui' },
             { value: 'restyle', label: 'Restyle' },
             { value: 'stylesheet', label: 'StyleSheet only' },
@@ -350,137 +351,214 @@ const CESS_QUESTIONS = [
 ];
 const CESS_SNAPSHOT_START = '<!-- MDS_CESS_SNAPSHOT_START -->';
 const CESS_SNAPSHOT_END = '<!-- MDS_CESS_SNAPSHOT_END -->';
+const SNAPSHOT_PRIORITY = 10;
+const TECH_STACK_PRIORITY = 20;
+const VISIBLE_SECTION_PRIORITY = 30;
+const DERIVED_TITLE_PRIORITY = 40;
+const EXPLICIT_INPUT_PRIORITY = 50;
 export function extractCessInfoFromMarkdown(input) {
     const infoMarkdown = normalizeLineEndings(input.infoMarkdown);
     const sections = parseMarkdownSections(infoMarkdown);
     const evidence = {};
     const prefilledAnswers = {};
     const ambiguousQuestionIds = new Set();
+    const assignedAnswerSources = new Map();
     const usedSections = new Set();
     const explicitAppName = normalizeText(input.appName);
     let derivedDisplayName = explicitAppName;
+    let derivedDisplayNamePriority = explicitAppName ? EXPLICIT_INPUT_PRIORITY : undefined;
+    let derivedDisplayNameNote = explicitAppName ? 'Explicit app name input' : undefined;
     let derivedFolderSlug = explicitAppName ? slugifyAppName(explicitAppName) : undefined;
     const recordEvidence = (key, note) => {
         evidence[key] = [...(evidence[key] ?? []), note];
     };
-    const assignValue = (id, value, note) => {
+    const assignValue = (id, value, note, priority = VISIBLE_SECTION_PRIORITY) => {
         const normalized = normalizeExtractedAnswerValue(id, value);
         if (normalized === undefined) {
             return;
         }
+        if (isGenericExtractedAnswerValue(id, normalized)) {
+            recordEvidence(id, `${note} ignored because it looked like scaffold/default placeholder data`);
+            return;
+        }
         if (ambiguousQuestionIds.has(id)) {
+            const ambiguousSource = assignedAnswerSources.get(id);
+            if (priority > (ambiguousSource?.priority ?? -1)) {
+                ambiguousQuestionIds.delete(id);
+                prefilledAnswers[id] = normalized;
+                assignedAnswerSources.set(id, { priority, note });
+                recordEvidence(id, `${note} selected over earlier lower-priority ambiguous values`);
+                return;
+            }
+            recordEvidence(id, `${note} ignored because ${ambiguousSource?.note ?? 'another visible source'} already made this field ambiguous`);
             return;
         }
         const current = prefilledAnswers[id];
+        const currentSource = assignedAnswerSources.get(id);
         if (current !== undefined && !areAnswerValuesEquivalent(id, current, normalized)) {
+            if (priority > (currentSource?.priority ?? -1)) {
+                prefilledAnswers[id] = normalized;
+                assignedAnswerSources.set(id, { priority, note });
+                recordEvidence(id, `${note} selected over lower-priority value from ${currentSource?.note ?? 'earlier extraction'}`);
+                return;
+            }
+            if (priority < (currentSource?.priority ?? -1)) {
+                recordEvidence(id, `${note} ignored because ${currentSource?.note ?? 'an earlier source'} had a higher-priority value`);
+                return;
+            }
             delete prefilledAnswers[id];
             ambiguousQuestionIds.add(id);
+            assignedAnswerSources.set(id, {
+                priority,
+                note: `${currentSource?.note ?? 'earlier extraction'} and ${note}`,
+            });
             recordEvidence(id, `${note} (conflicts with earlier extracted value)`);
             return;
         }
         prefilledAnswers[id] = normalized;
+        assignedAnswerSources.set(id, { priority, note });
         recordEvidence(id, note);
     };
     const snapshot = parseCessSnapshot(infoMarkdown);
     if (snapshot) {
         recordEvidence('snapshot', 'Parsed machine-readable MDS snapshot block.');
-        if (!derivedDisplayName) {
-            derivedDisplayName = normalizeText(snapshot.displayAppName);
-        }
-        if (!derivedFolderSlug) {
-            derivedFolderSlug = normalizeText(snapshot.folderSlug) ?? slugifyAppName(snapshot.displayAppName);
-        }
-        const snapshotAnswers = normalizeCessIntakeAnswers(snapshot.answers);
-        for (const [key, value] of Object.entries(snapshotAnswers)) {
-            assignValue(key, value, 'MDS snapshot');
+    }
+    const appNameSection = getMarkdownSection(sections, 'App Name');
+    if (!derivedDisplayName && appNameSection) {
+        const appNameFromSection = normalizeSectionText(appNameSection);
+        if (appNameFromSection && !isGenericTextValue(appNameFromSection)) {
+            derivedDisplayName = appNameFromSection;
+            derivedDisplayNamePriority = VISIBLE_SECTION_PRIORITY;
+            derivedDisplayNameNote = 'App Name section';
+            derivedFolderSlug = slugifyAppName(appNameFromSection);
+            recordEvidence('appName', `Derived app name from App Name section: ${appNameFromSection}`);
         }
+        usedSections.add('App Name');
     }
     const title = extractProjectTitle(infoMarkdown);
     if (!derivedDisplayName && title) {
         derivedDisplayName = title;
+        derivedDisplayNamePriority = DERIVED_TITLE_PRIORITY;
+        derivedDisplayNameNote = `Derived app name from title: ${title}`;
         recordEvidence('appName', `Derived app name from title: ${title}`);
     }
     if (!derivedFolderSlug && derivedDisplayName) {
         derivedFolderSlug = slugifyAppName(derivedDisplayName);
     }
-    const targetUsers = sections.get('Target Users');
+    const targetUsers = getMarkdownSection(sections, 'Target Users');
     if (targetUsers) {
         usedSections.add('Target Users');
-        assignValue('audience', normalizeSectionText(targetUsers), 'Target Users section');
+        assignValue('audience', normalizeSectionText(targetUsers), 'Target Users section', VISIBLE_SECTION_PRIORITY);
     }
     else {
-        const overview = sections.get('Overview');
+        const overview = getMarkdownSection(sections, 'Overview');
         const overviewAudience = extractAudienceFromOverview(overview);
         if (overviewAudience) {
             usedSections.add('Overview');
-            assignValue('audience', overviewAudience, 'Overview section');
+            assignValue('audience', overviewAudience, 'Overview section', VISIBLE_SECTION_PRIORITY);
+        }
+    }
+    const firstUserFlow = getMarkdownSection(sections, 'First User Flow');
+    const coreFlowsAndFeatures = getMarkdownSection(sections, 'Core Flows and Features');
+    const coreUserFlows = getMarkdownSection(sections, 'Core User Flows');
+    if (firstUserFlow || coreFlowsAndFeatures) {
+        const combinedFlows = [normalizeListSection(firstUserFlow), normalizeListSection(coreFlowsAndFeatures)]
+            .filter(Boolean)
+            .join('\n');
+        if (combinedFlows) {
+            assignValue('coreFlows', combinedFlows, 'First User Flow and Core Flows and Features sections', VISIBLE_SECTION_PRIORITY);
+        }
+        if (firstUserFlow) {
+            usedSections.add('First User Flow');
+        }
+        if (coreFlowsAndFeatures) {
+            usedSections.add('Core Flows and Features');
         }
     }
-    const coreUserFlows = sections.get('Core User Flows');
-    if (coreUserFlows) {
+    else if (coreUserFlows) {
         usedSections.add('Core User Flows');
-        assignValue('coreFlows', normalizeListSection(coreUserFlows), 'Core User Flows section');
+        assignValue('coreFlows', normalizeListSection(coreUserFlows), 'Core User Flows section', VISIBLE_SECTION_PRIORITY);
     }
-    const mustIncludeScreens = sections.get('Must-Include Screens Or Flows');
+    const mustIncludeScreens = getMarkdownSection(sections, 'Screens', 'Must-Include Screens Or Flows');
     if (mustIncludeScreens) {
-        usedSections.add('Must-Include Screens Or Flows');
-        assignValue('screens', normalizeListSection(mustIncludeScreens), 'Must-Include Screens Or Flows section');
+        usedSections.add(sections.has('Screens') ? 'Screens' : 'Must-Include Screens Or Flows');
+        assignValue('screens', normalizeListSection(mustIncludeScreens), 'Screens section', VISIBLE_SECTION_PRIORITY);
     }
-    const dataAndBackend = sections.get('Data And Backend');
+    const dataAndBackend = getMarkdownSection(sections, 'Data And Backend');
     if (dataAndBackend) {
         usedSections.add('Data And Backend');
         const inferredDataNeeds = inferDataNeedSelections(dataAndBackend);
         if (inferredDataNeeds.length > 0) {
-            assignValue('dataNeedSelections', inferredDataNeeds, 'Data And Backend section');
+            assignValue('dataNeedSelections', inferredDataNeeds, 'Data And Backend section', VISIBLE_SECTION_PRIORITY);
         }
         const dataStart = inferDataStart(dataAndBackend);
         if (dataStart) {
-            assignValue('dataStart', dataStart, 'Data And Backend section');
+            assignValue('dataStart', dataStart, 'Data And Backend section', VISIBLE_SECTION_PRIORITY);
         }
         const authBackend = inferAuthBackend(dataAndBackend);
         if (authBackend) {
-            assignValue('authBackend', authBackend, 'Data And Backend section');
+            assignValue('authBackend', authBackend, 'Data And Backend section', VISIBLE_SECTION_PRIORITY);
         }
     }
-    const platforms = sections.get('Platforms');
+    const platforms = getMarkdownSection(sections, 'Platforms');
     if (platforms) {
         usedSections.add('Platforms');
-        extractPlatformDecisions(platforms, assignValue);
+        extractPlatformDecisions(platforms, assignValue, VISIBLE_SECTION_PRIORITY);
     }
-    const packageChoices = sections.get('Package Choices');
+    const packageChoices = getMarkdownSection(sections, 'Package Choices');
     if (packageChoices) {
         usedSections.add('Package Choices');
-        extractPackageChoices(packageChoices, assignValue);
+        extractPackageChoices(packageChoices, assignValue, VISIBLE_SECTION_PRIORITY);
     }
-    const releaseStrategy = sections.get('Release Strategy');
+    const releaseStrategy = getMarkdownSection(sections, 'Release Strategy');
     if (releaseStrategy) {
         usedSections.add('Release Strategy');
         const deploymentTarget = extractBulletValue(releaseStrategy, 'Deployment plan');
         if (deploymentTarget) {
-            assignValue('deploymentTarget', deploymentTarget, 'Release Strategy section');
+            assignValue('deploymentTarget', deploymentTarget, 'Release Strategy section', VISIBLE_SECTION_PRIORITY);
         }
         const easUses = inferEasUses(extractBulletValue(releaseStrategy, 'EAS usage') ?? releaseStrategy);
         if (easUses.length > 0) {
-            assignValue('easUses', easUses, 'Release Strategy section');
-            assignValue('easSetup', true, 'Release Strategy section');
+            assignValue('easUses', easUses, 'Release Strategy section', VISIBLE_SECTION_PRIORITY);
+            assignValue('easSetup', true, 'Release Strategy section', VISIBLE_SECTION_PRIORITY);
         }
         const testToMain = parseBooleanValue(extractBulletValue(releaseStrategy, 'Test-to-main safeguards'));
         if (typeof testToMain === 'boolean') {
-            assignValue('testToMainSafeguards', testToMain, 'Release Strategy section');
+            assignValue('testToMainSafeguards', testToMain, 'Release Strategy section', VISIBLE_SECTION_PRIORITY);
         }
     }
-    const techStackSection = sections.get('Tech Stack & MDS Onboarding');
+    const techStackSection = getMarkdownSection(sections, 'Tech Stack & CESS Onboarding', 'Tech Stack & MDS Onboarding');
     if (techStackSection) {
-        usedSections.add('Tech Stack & MDS Onboarding');
-        extractTechStackDecisions(techStackSection, assignValue);
+        usedSections.add(sections.has('Tech Stack & CESS Onboarding') ? 'Tech Stack & CESS Onboarding' : 'Tech Stack & MDS Onboarding');
+        extractTechStackDecisions(techStackSection, assignValue, TECH_STACK_PRIORITY);
     }
     const onboardingDecisionsSection = sections.get('Onboarding Decisions');
     if (onboardingDecisionsSection) {
         usedSections.add('Onboarding Decisions');
-        extractOnboardingDecisionLines(onboardingDecisionsSection, assignValue);
+        extractOnboardingDecisionLines(onboardingDecisionsSection, assignValue, VISIBLE_SECTION_PRIORITY);
+    }
+    if (!derivedDisplayName && snapshot?.displayAppName && !isGenericTextValue(snapshot.displayAppName)) {
+        derivedDisplayName = snapshot.displayAppName;
+        derivedDisplayNamePriority = SNAPSHOT_PRIORITY;
+        derivedDisplayNameNote = 'MDS snapshot metadata';
+    }
+    else if (!derivedDisplayName && snapshot?.displayAppName) {
+        recordEvidence('displayAppName', 'MDS snapshot metadata ignored because it looked like scaffold/default placeholder data');
+    }
+    if (!derivedFolderSlug && snapshot?.folderSlug && !isGenericTextValue(snapshot.folderSlug)) {
+        derivedFolderSlug = snapshot.folderSlug;
+    }
+    else if (!derivedFolderSlug && snapshot?.displayAppName && !isGenericTextValue(snapshot.displayAppName)) {
+        derivedFolderSlug = slugifyAppName(snapshot.displayAppName);
     }
     if (derivedDisplayName) {
-        assignValue('displayAppName', derivedDisplayName, 'Derived app name');
+        assignValue('displayAppName', derivedDisplayName, derivedDisplayNameNote ?? 'Derived app name', derivedDisplayNamePriority ?? DERIVED_TITLE_PRIORITY);
+    }
+    if (snapshot) {
+        const snapshotAnswers = normalizeCessIntakeAnswers(snapshot.answers);
+        for (const [key, value] of Object.entries(snapshotAnswers)) {
+            assignValue(key, value, 'MDS snapshot', SNAPSHOT_PRIORITY);
+        }
     }
     const preservedNotes = [...sections.entries()]
         .filter(([heading, body]) => !usedSections.has(heading) && normalizeSectionText(body))
@@ -536,14 +614,16 @@ function extractProjectTitle(infoMarkdown) {
 }
 function parseMarkdownSections(markdown) {
     const sections = new Map();
-    const matches = [...markdown.matchAll(/^##\s+(.+?)\s*$/gmu)];
+    const matches = [...markdown.matchAll(/^(#{1,2})\s+(.+?)\s*$/gmu)].filter((match) => {
+        return !(match.index === 0 && match[1] === '#');
+    });
     for (let index = 0; index < matches.length; index += 1) {
         const match = matches[index];
         const next = matches[index + 1];
         if (!match) {
             continue;
         }
-        const heading = match?.[1]?.trim();
+        const heading = match?.[2]?.trim();
         if (!heading || match.index === undefined) {
             continue;
         }
@@ -553,6 +633,24 @@ function parseMarkdownSections(markdown) {
     }
     return sections;
 }
+function getMarkdownSection(sections, ...headings) {
+    for (const heading of headings) {
+        const exact = sections.get(heading);
+        if (exact !== undefined) {
+            return exact;
+        }
+        const normalizedHeading = normalizeHeadingKey(heading);
+        for (const [candidate, body] of sections.entries()) {
+            if (normalizeHeadingKey(candidate) === normalizedHeading) {
+                return body;
+            }
+        }
+    }
+    return undefined;
+}
+function normalizeHeadingKey(value) {
+    return value.trim().toLowerCase().replace(/\s+/gu, ' ');
+}
 function extractAudienceFromOverview(overview) {
     const text = normalizeSectionText(overview);
     if (!text) {
@@ -644,161 +742,290 @@ function inferAuthBackend(value) {
     }
     return undefined;
 }
-function extractPlatformDecisions(value, assignValue) {
+function extractPlatformDecisions(value, assignValue, priority = VISIBLE_SECTION_PRIORITY) {
     const targetPlatforms = parsePlatformList(extractBulletValue(value, 'Target platforms'));
     if (targetPlatforms.length > 0) {
-        assignValue('targetPlatforms', targetPlatforms, 'Platforms section');
+        assignValue('targetPlatforms', targetPlatforms, 'Platforms section', priority);
     }
     const firstTargetPlatform = normalizeChoice(extractBulletValue(value, 'First MVP platform'), PLATFORM_OPTIONS);
     if (firstTargetPlatform) {
-        assignValue('firstTargetPlatform', firstTargetPlatform, 'Platforms section');
+        assignValue('firstTargetPlatform', firstTargetPlatform, 'Platforms section', priority);
     }
     const appDirectoryValue = extractBulletValue(value, 'Expo Router app directory');
     if (appDirectoryValue?.includes('src/app')) {
-        assignValue('appDirectory', 'src', 'Platforms section');
+        assignValue('appDirectory', 'src', 'Platforms section', priority);
     }
     else if (appDirectoryValue?.includes('app')) {
-        assignValue('appDirectory', 'root', 'Platforms section');
+        assignValue('appDirectory', 'root', 'Platforms section', priority);
     }
     const organization = extractBulletValue(value, 'Platform-specific organization') ?? '';
     if (organization.toLowerCase().includes('folder')) {
-        assignValue('platformStrategy', 'folders', 'Platforms section');
+        assignValue('platformStrategy', 'folders', 'Platforms section', priority);
     }
     else if (organization.toLowerCase().includes('file')) {
-        assignValue('platformStrategy', 'files-only', 'Platforms section');
+        assignValue('platformStrategy', 'files-only', 'Platforms section', priority);
     }
     const layoutMode = extractBulletValue(value, 'Platform layout mode');
     if (layoutMode?.toLowerCase().includes('platform-specific')) {
-        assignValue('platformLayouts', 'platform-specific', 'Platforms section');
+        assignValue('platformLayouts', 'platform-specific', 'Platforms section', priority);
     }
     else if (layoutMode?.toLowerCase().includes('shared')) {
-        assignValue('platformLayouts', 'shared', 'Platforms section');
+        assignValue('platformLayouts', 'shared', 'Platforms section', priority);
     }
     const webOutput = normalizeChoice(extractBulletValue(value, 'Web output'), ['static', 'server', 'spa', 'none']);
     if (webOutput) {
-        assignValue('webOutput', webOutput, 'Platforms section');
+        assignValue('webOutput', webOutput, 'Platforms section', priority);
     }
     const deployedServer = (extractBulletValue(value, 'Deployed server') ?? '').toLowerCase();
     if (deployedServer.includes('no deployed server') || deployedServer === 'none') {
-        assignValue('expoServerAdapter', 'none', 'Platforms section');
-        assignValue('customBackend', false, 'Platforms section');
+        assignValue('expoServerAdapter', 'none', 'Platforms section', priority);
+        assignValue('customBackend', false, 'Platforms section', priority);
     }
     else if (deployedServer.includes('eas')) {
-        assignValue('expoServerAdapter', 'eas', 'Platforms section');
+        assignValue('expoServerAdapter', 'eas', 'Platforms section', priority);
     }
     else if (deployedServer.includes('express')) {
-        assignValue('expoServerAdapter', 'express', 'Platforms section');
+        assignValue('expoServerAdapter', 'express', 'Platforms section', priority);
     }
     else if (deployedServer.includes('bun')) {
-        assignValue('expoServerAdapter', 'bun', 'Platforms section');
+        assignValue('expoServerAdapter', 'bun', 'Platforms section', priority);
     }
     else if (deployedServer.includes('custom')) {
-        assignValue('expoServerAdapter', 'other', 'Platforms section');
-        assignValue('customBackend', true, 'Platforms section');
+        assignValue('expoServerAdapter', 'other', 'Platforms section', priority);
+        assignValue('customBackend', true, 'Platforms section', priority);
     }
     const expoUi = parseBooleanValue(extractBulletValue(value, 'Expo UI'));
     if (typeof expoUi === 'boolean') {
-        assignValue('usesExpoUi', expoUi, 'Platforms section');
+        assignValue('usesExpoUi', expoUi, 'Platforms section', priority);
     }
     const expoUiUniversal = parseBooleanValue(extractBulletValue(value, 'Expo UI Universal components'));
     if (typeof expoUiUniversal === 'boolean') {
-        assignValue('usesExpoUiUniversalComponents', expoUiUniversal, 'Platforms section');
+        assignValue('usesExpoUiUniversalComponents', expoUiUniversal, 'Platforms section', priority);
     }
     const expoNativeTabs = parseBooleanValue(extractBulletValue(value, 'Expo Native Tabs'));
     if (typeof expoNativeTabs === 'boolean') {
-        assignValue('usesExpoNativeTabs', expoNativeTabs, 'Platforms section');
+        assignValue('usesExpoNativeTabs', expoNativeTabs, 'Platforms section', priority);
     }
 }
-function extractPackageChoices(value, assignValue) {
+function extractPackageChoices(value, assignValue, priority = VISIBLE_SECTION_PRIORITY) {
     const entries = normalizeListSection(value)
         ?.split('\n')
         .map((item) => item.trim().toLowerCase())
         .filter(Boolean) ?? [];
     for (const entry of entries) {
         if (entry === 'uniwind') {
-            assignValue('stylingSystem', 'uniwind', 'Package Choices section');
+            assignValue('stylingSystem', 'uniwind', 'Package Choices section', priority);
         }
         else if (entry === 'nativewind') {
-            assignValue('stylingSystem', 'nativewind', 'Package Choices section');
+            assignValue('stylingSystem', 'nativewind', 'Package Choices section', priority);
+        }
+        else if (entry === 'nativewindui') {
+            assignValue('stylingSystem', 'nativewindui', 'Package Choices section', priority);
         }
         else if (entry === 'tamagui') {
-            assignValue('stylingSystem', 'tamagui', 'Package Choices section');
+            assignValue('stylingSystem', 'tamagui', 'Package Choices section', priority);
         }
         else if (entry === 'restyle') {
-            assignValue('stylingSystem', 'restyle', 'Package Choices section');
+            assignValue('stylingSystem', 'restyle', 'Package Choices section', priority);
         }
         else if (entry === 'supabase') {
-            assignValue('authBackend', 'supabase', 'Package Choices section');
+            assignValue('authBackend', 'supabase', 'Package Choices section', priority);
         }
         else if (entry === 'firebase') {
-            assignValue('authBackend', 'firebase', 'Package Choices section');
+            assignValue('authBackend', 'firebase', 'Package Choices section', priority);
         }
     }
 }
-function extractTechStackDecisions(value, assignValue) {
+function extractTechStackDecisions(value, assignValue, priority = TECH_STACK_PRIORITY) {
+    const typeScriptChoice = parseBooleanValue(extractKeyValue(value, 'TypeScript'));
+    if (typeof typeScriptChoice === 'boolean') {
+        assignValue('scriptLanguage', typeScriptChoice ? 'typescript' : 'javascript', 'Tech Stack & CESS Onboarding section', priority);
+    }
+    const packageManagerChoice = normalizeChoiceLabel(extractKeyValue(value, 'Package Manager'), ['npm', 'pnpm', 'yarn', 'bun']);
+    if (packageManagerChoice) {
+        assignValue('packageManager', packageManagerChoice, 'Tech Stack & CESS Onboarding section', priority);
+    }
+    const navigationChoice = (extractKeyValue(value, 'Navigation') ?? '').toLowerCase();
+    if (isConcreteChoiceValue(navigationChoice)) {
+        if (navigationChoice.includes('react navigation')) {
+            assignValue('navigationLibrary', 'react-navigation', 'Tech Stack & CESS Onboarding section', priority);
+        }
+        else if (navigationChoice.includes('expo router')) {
+            assignValue('navigationLibrary', 'expo-router', 'Tech Stack & CESS Onboarding section', priority);
+        }
+    }
+    const navigationType = (extractKeyValue(value, 'Type of Navigation') ?? '').toLowerCase();
+    if (isConcreteChoiceValue(navigationType)) {
+        if (navigationType.includes('drawer')) {
+            assignValue('reactNavigationLayout', 'drawer', 'Tech Stack & CESS Onboarding section', priority);
+        }
+        else if (navigationType.includes('tabs')) {
+            assignValue('reactNavigationLayout', 'tabs', 'Tech Stack & CESS Onboarding section', priority);
+        }
+        else if (navigationType.includes('stack')) {
+            assignValue('reactNavigationLayout', 'stack', 'Tech Stack & CESS Onboarding section', priority);
+        }
+    }
+    const appDirectoryValue = extractKeyValue(value, 'Expo Router app directory');
+    if (appDirectoryValue?.includes('src/app')) {
+        assignValue('appDirectory', 'src', 'Tech Stack & CESS Onboarding section', priority);
+    }
+    else if (appDirectoryValue === 'app' || appDirectoryValue?.includes('`app`')) {
+        assignValue('appDirectory', 'root', 'Tech Stack & CESS Onboarding section', priority);
+    }
+    const organization = (extractKeyValue(value, 'Platform-specific organization (folders, files, or inline)') ?? '').toLowerCase();
+    if (isConcreteChoiceValue(organization)) {
+        if (organization.includes('folder')) {
+            assignValue('platformStrategy', 'folders', 'Tech Stack & CESS Onboarding section', priority);
+        }
+        else if (organization.includes('file')) {
+            assignValue('platformStrategy', 'files-only', 'Tech Stack & CESS Onboarding section', priority);
+        }
+    }
+    const layoutMode = (extractKeyValue(value, 'Platform layout mode') ?? '').toLowerCase();
+    if (isConcreteChoiceValue(layoutMode)) {
+        if (layoutMode.includes('platform-specific')) {
+            assignValue('platformLayouts', 'platform-specific', 'Tech Stack & CESS Onboarding section', priority);
+        }
+        else if (layoutMode.includes('shared')) {
+            assignValue('platformLayouts', 'shared', 'Tech Stack & CESS Onboarding section', priority);
+        }
+    }
+    const webOutput = normalizeChoiceLabel(extractKeyValue(value, 'Web output'), ['static', 'server', 'spa', 'none']);
+    if (webOutput) {
+        assignValue('webOutput', webOutput, 'Tech Stack & CESS Onboarding section', priority);
+    }
+    const styleLibrary = (extractKeyValue(value, 'Style Library') ?? '').toLowerCase();
+    if (isConcreteChoiceValue(styleLibrary)) {
+        if (styleLibrary.includes('nativewindui')) {
+            assignValue('stylingSystem', 'nativewindui', 'Tech Stack & CESS Onboarding section', priority);
+        }
+        else if (styleLibrary.includes('nativewind')) {
+            assignValue('stylingSystem', 'nativewind', 'Tech Stack & CESS Onboarding section', priority);
+        }
+        else if (styleLibrary.includes('uniwind')) {
+            assignValue('stylingSystem', 'uniwind', 'Tech Stack & CESS Onboarding section', priority);
+        }
+        else if (styleLibrary.includes('tamagui')) {
+            assignValue('stylingSystem', 'tamagui', 'Tech Stack & CESS Onboarding section', priority);
+        }
+        else if (styleLibrary.includes('restyle')) {
+            assignValue('stylingSystem', 'restyle', 'Tech Stack & CESS Onboarding section', priority);
+        }
+        else if (styleLibrary.includes('stylesheet')) {
+            assignValue('stylingSystem', 'stylesheet', 'Tech Stack & CESS Onboarding section', priority);
+        }
+    }
+    assignBooleanKey(value, 'Components from create-expo-app', 'includeCreateExpoComponents', assignValue, priority);
+    assignBooleanKey(value, 'Expo UI', 'usesExpoUi', assignValue, priority);
+    assignBooleanKey(value, 'Expo UI Universal components', 'usesExpoUiUniversalComponents', assignValue, priority);
+    assignBooleanKey(value, 'Expo Native Tabs', 'usesExpoNativeTabs', assignValue, priority);
+    const stateManagementChoice = (extractKeyValue(value, 'State management library') ?? '').toLowerCase();
+    if (isConcreteChoiceValue(stateManagementChoice)) {
+        if (stateManagementChoice.includes('zustand')) {
+            assignValue('stateManagement', 'zustand', 'Tech Stack & CESS Onboarding section', priority);
+        }
+        else if (stateManagementChoice.includes('none')) {
+            assignValue('stateManagement', 'none', 'Tech Stack & CESS Onboarding section', priority);
+        }
+    }
+    const authChoice = inferAuthBackend(extractKeyValue(value, 'Auth') ?? '');
+    if (authChoice) {
+        assignValue('authBackend', authChoice, 'Tech Stack & CESS Onboarding section', priority);
+    }
+    else if ((extractKeyValue(value, 'Auth') ?? '').toLowerCase().includes('none')) {
+        assignValue('authBackend', 'none', 'Tech Stack & CESS Onboarding section', priority);
+    }
+    const dataCategories = extractKeyValue(value, 'Data Categories');
+    if (dataCategories) {
+        const inferredDataNeeds = inferDataNeedSelections(dataCategories);
+        if (inferredDataNeeds.length > 0) {
+            assignValue('dataNeedSelections', inferredDataNeeds, 'Tech Stack & CESS Onboarding section', priority);
+        }
+    }
+    const startingDataMode = inferDataStart(extractKeyValue(value, 'Starting Data mode') ?? '');
+    if (startingDataMode) {
+        assignValue('dataStart', startingDataMode, 'Tech Stack & CESS Onboarding section', priority);
+    }
+    const easChoice = parseBooleanValue(extractKeyValue(value, 'EAS'));
+    if (typeof easChoice === 'boolean') {
+        assignValue('easSetup', easChoice, 'Tech Stack & CESS Onboarding section', priority);
+    }
+    const newEasUses = inferEasUses(extractKeyValue(value, 'EAS Usage') ?? '');
+    if (newEasUses.length > 0) {
+        assignValue('easUses', newEasUses, 'Tech Stack & CESS Onboarding section', priority);
+        assignValue('easSetup', true, 'Tech Stack & CESS Onboarding section', priority);
+    }
+    extractPlatformDecisions(`- Deployed server: ${extractKeyValue(value, 'Deployed server') ?? ''}`, assignValue, priority);
+    const initialDeploymentPlan = extractKeyValue(value, 'Initial Deployment plan');
+    if (initialDeploymentPlan && isConcreteChoiceValue(initialDeploymentPlan)) {
+        assignValue('deploymentTarget', initialDeploymentPlan, 'Tech Stack & CESS Onboarding section', priority);
+    }
+    assignBooleanKey(value, 'Start with MDS project guidelines template', 'guidelinesTemplate', assignValue, priority);
+    assignBooleanKey(value, 'Use test-to-main safeguards', 'testToMainSafeguards', assignValue, priority);
     const language = normalizeChoice(extractKeyValue(value, 'Language'), ['typescript', 'javascript']);
     if (language) {
-        assignValue('scriptLanguage', language, 'Tech Stack & MDS Onboarding section');
+        assignValue('scriptLanguage', language, 'Tech Stack & MDS Onboarding section', priority);
     }
     const packageManager = normalizeChoice(extractKeyValue(value, 'Package manager'), ['npm', 'pnpm', 'yarn', 'bun']);
     if (packageManager) {
-        assignValue('packageManager', packageManager, 'Tech Stack & MDS Onboarding section');
+        assignValue('packageManager', packageManager, 'Tech Stack & MDS Onboarding section', priority);
     }
     const routing = (extractKeyValue(value, 'Routing') ?? '').toLowerCase();
     if (routing.includes('react navigation')) {
-        assignValue('navigationLibrary', 'react-navigation', 'Tech Stack & MDS Onboarding section');
+        assignValue('navigationLibrary', 'react-navigation', 'Tech Stack & MDS Onboarding section', priority);
         if (routing.includes('tabs')) {
-            assignValue('reactNavigationLayout', 'tabs', 'Tech Stack & MDS Onboarding section');
+            assignValue('reactNavigationLayout', 'tabs', 'Tech Stack & MDS Onboarding section', priority);
         }
         else if (routing.includes('drawer')) {
-            assignValue('reactNavigationLayout', 'drawer', 'Tech Stack & MDS Onboarding section');
+            assignValue('reactNavigationLayout', 'drawer', 'Tech Stack & MDS Onboarding section', priority);
         }
         else {
-            assignValue('reactNavigationLayout', 'stack', 'Tech Stack & MDS Onboarding section');
+            assignValue('reactNavigationLayout', 'stack', 'Tech Stack & MDS Onboarding section', priority);
         }
     }
     else if (routing.includes('expo router')) {
-        assignValue('navigationLibrary', 'expo-router', 'Tech Stack & MDS Onboarding section');
+        assignValue('navigationLibrary', 'expo-router', 'Tech Stack & MDS Onboarding section', priority);
     }
     const styling = (extractKeyValue(value, 'Styling') ?? '').toLowerCase();
     if (styling.includes('uniwind')) {
-        assignValue('stylingSystem', 'uniwind', 'Tech Stack & MDS Onboarding section');
+        assignValue('stylingSystem', 'uniwind', 'Tech Stack & MDS Onboarding section', priority);
     }
     else if (styling.includes('nativewind')) {
-        assignValue('stylingSystem', 'nativewind', 'Tech Stack & MDS Onboarding section');
+        assignValue('stylingSystem', 'nativewind', 'Tech Stack & MDS Onboarding section', priority);
     }
     else if (styling.includes('tamagui')) {
-        assignValue('stylingSystem', 'tamagui', 'Tech Stack & MDS Onboarding section');
+        assignValue('stylingSystem', 'tamagui', 'Tech Stack & MDS Onboarding section', priority);
     }
     else if (styling.includes('restyle')) {
-        assignValue('stylingSystem', 'restyle', 'Tech Stack & MDS Onboarding section');
+        assignValue('stylingSystem', 'restyle', 'Tech Stack & MDS Onboarding section', priority);
     }
     else if (styling.includes('stylesheet')) {
-        assignValue('stylingSystem', 'stylesheet', 'Tech Stack & MDS Onboarding section');
+        assignValue('stylingSystem', 'stylesheet', 'Tech Stack & MDS Onboarding section', priority);
     }
     const stateManagement = (extractKeyValue(value, 'State management') ?? '').toLowerCase();
     if (stateManagement.includes('zustand')) {
-        assignValue('stateManagement', 'zustand', 'Tech Stack & MDS Onboarding section');
+        assignValue('stateManagement', 'zustand', 'Tech Stack & MDS Onboarding section', priority);
     }
     else if (stateManagement.includes('none')) {
-        assignValue('stateManagement', 'none', 'Tech Stack & MDS Onboarding section');
+        assignValue('stateManagement', 'none', 'Tech Stack & MDS Onboarding section', priority);
     }
     const auth = inferAuthBackend(extractKeyValue(value, 'Auth') ?? '');
     if (auth) {
-        assignValue('authBackend', auth, 'Tech Stack & MDS Onboarding section');
+        assignValue('authBackend', auth, 'Tech Stack & MDS Onboarding section', priority);
     }
     const distribution = extractKeyValue(value, 'Distribution');
     if (distribution) {
-        assignValue('deploymentTarget', distribution, 'Tech Stack & MDS Onboarding section');
+        assignValue('deploymentTarget', distribution, 'Tech Stack & MDS Onboarding section', priority);
     }
     const easUses = inferEasUses(extractKeyValue(value, 'EAS') ?? '');
     if (easUses.length > 0) {
-        assignValue('easUses', easUses, 'Tech Stack & MDS Onboarding section');
-        assignValue('easSetup', true, 'Tech Stack & MDS Onboarding section');
+        assignValue('easUses', easUses, 'Tech Stack & MDS Onboarding section', priority);
+        assignValue('easSetup', true, 'Tech Stack & MDS Onboarding section', priority);
     }
-    extractOnboardingDecisionLines(value, assignValue);
+    extractOnboardingDecisionLines(value, assignValue, priority);
 }
-function extractOnboardingDecisionLines(value, assignValue) {
+function extractOnboardingDecisionLines(value, assignValue, priority = VISIBLE_SECTION_PRIORITY) {
     const lines = normalizeLineEndings(value)
         .split('\n')
         .map((line) => line.trim())
@@ -815,57 +1042,57 @@ function extractOnboardingDecisionLines(value, assignValue) {
             continue;
         }
         if (loweredKey === 'create expo starter components') {
-            assignValue('includeCreateExpoComponents', parseBooleanValue(rawValue), 'Onboarding decisions');
+            assignValue('includeCreateExpoComponents', parseBooleanValue(rawValue), 'Onboarding decisions', priority);
         }
         else if (loweredKey === 'latest expo sdk preference') {
             // Captured for human context only; SDK targeting is enforced by the generator.
             continue;
         }
         else if (loweredKey === 'expo ui') {
-            assignValue('usesExpoUi', parseBooleanValue(rawValue), 'Onboarding decisions');
+            assignValue('usesExpoUi', parseBooleanValue(rawValue), 'Onboarding decisions', priority);
         }
         else if (loweredKey === 'expo ui universal components') {
-            assignValue('usesExpoUiUniversalComponents', parseBooleanValue(rawValue), 'Onboarding decisions');
+            assignValue('usesExpoUiUniversalComponents', parseBooleanValue(rawValue), 'Onboarding decisions', priority);
         }
         else if (loweredKey === 'expo native tabs') {
-            assignValue('usesExpoNativeTabs', parseBooleanValue(rawValue), 'Onboarding decisions');
+            assignValue('usesExpoNativeTabs', parseBooleanValue(rawValue), 'Onboarding decisions', priority);
         }
         else if (loweredKey === 'target platforms') {
             const targetPlatforms = parsePlatformList(rawValue);
             if (targetPlatforms.length > 0) {
-                assignValue('targetPlatforms', targetPlatforms, 'Onboarding decisions');
+                assignValue('targetPlatforms', targetPlatforms, 'Onboarding decisions', priority);
             }
         }
         else if (loweredKey === 'first mvp platform') {
-            assignValue('firstTargetPlatform', normalizeChoice(rawValue, PLATFORM_OPTIONS), 'Onboarding decisions');
+            assignValue('firstTargetPlatform', normalizeChoice(rawValue, PLATFORM_OPTIONS), 'Onboarding decisions', priority);
         }
         else if (loweredKey === 'expo router app directory') {
-            assignValue('appDirectory', rawValue.includes('src/app') ? 'src' : 'root', 'Onboarding decisions');
+            assignValue('appDirectory', rawValue.includes('src/app') ? 'src' : 'root', 'Onboarding decisions', priority);
         }
         else if (loweredKey === 'platform-specific organization') {
-            assignValue('platformStrategy', rawValue.toLowerCase().includes('folder') ? 'folders' : 'files-only', 'Onboarding decisions');
+            assignValue('platformStrategy', rawValue.toLowerCase().includes('folder') ? 'folders' : 'files-only', 'Onboarding decisions', priority);
         }
         else if (loweredKey === 'platform layout mode') {
-            assignValue('platformLayouts', rawValue.toLowerCase().includes('platform-specific') ? 'platform-specific' : 'shared', 'Onboarding decisions');
+            assignValue('platformLayouts', rawValue.toLowerCase().includes('platform-specific') ? 'platform-specific' : 'shared', 'Onboarding decisions', priority);
         }
         else if (loweredKey === 'web output') {
-            assignValue('webOutput', normalizeChoice(rawValue, ['static', 'server', 'spa', 'none']), 'Onboarding decisions');
+            assignValue('webOutput', normalizeChoice(rawValue, ['static', 'server', 'spa', 'none']), 'Onboarding decisions', priority);
         }
         else if (loweredKey === 'deployed server') {
-            extractPlatformDecisions(`- Deployed server: ${rawValue}`, assignValue);
+            extractPlatformDecisions(`- Deployed server: ${rawValue}`, assignValue, priority);
         }
         else if (loweredKey === 'eas usage') {
             const easUses = inferEasUses(rawValue);
             if (easUses.length > 0) {
-                assignValue('easUses', easUses, 'Onboarding decisions');
-                assignValue('easSetup', true, 'Onboarding decisions');
+                assignValue('easUses', easUses, 'Onboarding decisions', priority);
+                assignValue('easSetup', true, 'Onboarding decisions', priority);
             }
         }
         else if (loweredKey === 'data start') {
-            assignValue('dataStart', inferDataStart(rawValue), 'Onboarding decisions');
+            assignValue('dataStart', inferDataStart(rawValue), 'Onboarding decisions', priority);
         }
         else if (loweredKey === 'test-to-main safeguards') {
-            assignValue('testToMainSafeguards', parseBooleanValue(rawValue), 'Onboarding decisions');
+            assignValue('testToMainSafeguards', parseBooleanValue(rawValue), 'Onboarding decisions', priority);
         }
     }
 }
@@ -877,9 +1104,29 @@ function extractKeyValue(value, label) {
     const match = new RegExp(`^-\\s+(?:\\*\\*)?${escapeRegExp(label)}(?:\\*\\*)?:\\s+(.+)$`, 'imu').exec(value);
     return normalizeText(match?.[1]);
 }
+function assignBooleanKey(value, label, id, assignValue, priority) {
+    const bool = parseBooleanValue(extractKeyValue(value, label));
+    if (typeof bool === 'boolean') {
+        assignValue(id, bool, 'Tech Stack & CESS Onboarding section', priority);
+    }
+}
+function normalizeChoiceLabel(value, choices) {
+    const normalized = normalizeText(value)?.toLowerCase().replace(/[`]/gu, '').trim();
+    if (!normalized || !isConcreteChoiceValue(normalized)) {
+        return undefined;
+    }
+    return choices.find((choice) => choice.toLowerCase() === normalized);
+}
+function isConcreteChoiceValue(value) {
+    return !/\s\/\s/u.test(value);
+}
 function inferEasUses(value) {
     const normalized = value.toLowerCase();
-    return EAS_USE_OPTIONS.filter((item) => normalized.includes(item.toLowerCase()));
+    const selected = EAS_USE_OPTIONS.filter((item) => normalized.includes(item.toLowerCase()));
+    if (/\bbuilding mobile apps?\b/u.test(normalized) && !selected.includes('building mobile applications')) {
+        selected.push('building mobile applications');
+    }
+    return selected;
 }
 function parsePlatformList(value) {
     const normalized = value
@@ -934,17 +1181,17 @@ function normalizeExtractedAnswerValue(id, value) {
         case 'reactNavigationLayout':
             return normalizeEnum(value, ['stack', 'tabs', 'drawer']);
         case 'stylingSystem':
-            return normalizeEnum(value, ['uniwind', 'nativewind', 'tamagui', 'restyle', 'stylesheet']);
+            return normalizeEnum(value, ['uniwind', 'nativewind', 'nativewindui', 'tamagui', 'restyle', 'stylesheet']);
         case 'stateManagement':
             return normalizeEnum(value, ['zustand', 'none']);
         case 'authBackend':
             return normalizeEnum(value, ['none', 'supabase', 'firebase']);
         case 'platformStrategy':
-            return normalizeEnum(value, ['folders', 'files-only']);
+            return normalizePlatformStrategyValue(value);
         case 'appDirectory':
-            return normalizeEnum(value, ['src', 'root']);
+            return normalizeAppDirectoryValue(value);
         case 'platformLayouts':
-            return normalizeEnum(value, ['shared', 'platform-specific']);
+            return normalizePlatformLayoutsValue(value);
         case 'webOutput':
             return normalizeEnum(value, ['static', 'server', 'spa', 'none']);
         case 'expoServerAdapter':
@@ -957,6 +1204,41 @@ function normalizeExtractedAnswerValue(id, value) {
             return normalizeText(value);
     }
 }
+function isGenericExtractedAnswerValue(id, value) {
+    if (id === 'displayAppName') {
+        return isGenericTextValue(value);
+    }
+    if (id === 'audience') {
+        return normalizeText(value)?.toLowerCase() === 'expo app users';
+    }
+    if (id === 'coreFlows') {
+        const normalized = normalizeText(value)?.toLowerCase();
+        return (!normalized ||
+            normalized === AGENT_DERIVED_CORE_FLOWS.toLowerCase() ||
+            normalized.includes('let the agent derive') ||
+            normalized.startsWith('# todoforcontext'));
+    }
+    if (id === 'screens') {
+        const normalized = normalizeText(value)?.toLowerCase();
+        return !normalized || normalized === 'defer' || normalized.startsWith('# todoforcontext');
+    }
+    if (id === 'targetPlatforms') {
+        const platforms = normalizeStringArray(value);
+        return (platforms?.length === PLATFORM_OPTIONS.length &&
+            PLATFORM_OPTIONS.every((platform) => platforms.includes(platform)));
+    }
+    if (id === 'deploymentTarget') {
+        return normalizeText(value)?.toLowerCase() === 'expo web/native deployment';
+    }
+    return false;
+}
+function isGenericTextValue(value) {
+    const normalized = normalizeText(value)
+        ?.toLowerCase()
+        .replace(/\s+/gu, ' ')
+        .trim();
+    return !normalized || normalized === 'template' || normalized === 'my expo app' || normalized === 'my-expo-app';
+}
 function areAnswerValuesEquivalent(id, left, right) {
     if (Array.isArray(left) || Array.isArray(right)) {
         return JSON.stringify(normalizeStringArray(left) ?? []) === JSON.stringify(normalizeStringArray(right) ?? []);
@@ -1146,6 +1428,7 @@ export function normalizeCessIntakeAnswers(answers) {
     normalized.stylingSystem = normalizeEnum(answers.stylingSystem, [
         'uniwind',
         'nativewind',
+        'nativewindui',
         'tamagui',
         'restyle',
         'stylesheet',
@@ -1161,9 +1444,9 @@ export function normalizeCessIntakeAnswers(answers) {
     normalized.dataNeedsOther = normalizeText(answers.dataNeedsOther);
     normalized.targetPlatforms = normalizePlatforms(answers.targetPlatforms);
     normalized.firstTargetPlatform = normalizeText(answers.firstTargetPlatform);
-    normalized.platformStrategy = normalizeEnum(answers.platformStrategy, ['folders', 'files-only']);
-    normalized.appDirectory = normalizeEnum(answers.appDirectory, ['src', 'root']);
-    normalized.platformLayouts = normalizeEnum(answers.platformLayouts, ['shared', 'platform-specific']);
+    normalized.platformStrategy = normalizePlatformStrategyValue(answers.platformStrategy);
+    normalized.appDirectory = normalizeAppDirectoryValue(answers.appDirectory);
+    normalized.platformLayouts = normalizePlatformLayoutsValue(answers.platformLayouts);
     normalized.webOutput = normalizeEnum(answers.webOutput, ['static', 'server', 'spa', 'none']);
     normalized.expoServerAdapter = normalizeEnum(answers.expoServerAdapter, [
         'eas',
@@ -1206,6 +1489,9 @@ export function buildCreateExpoStackFlags(answers) {
         case 'nativewind':
             flags.push('--nativewind');
             break;
+        case 'nativewindui':
+            flags.push('--nativewindui');
+            break;
         case 'tamagui':
             flags.push('--tamagui');
             break;
@@ -1421,8 +1707,40 @@ function buildOnboardArgvFromCess(parentDir, appName, answers) {
         dataStart: answers.dataStart,
         testToMain: answers.testToMainSafeguards,
         saveDefaults: answers.saveDefaults,
+        defaults: buildOnboardDefaultsFromCessAnswers(answers),
     };
 }
+function buildOnboardDefaultsFromCessAnswers(answers) {
+    const defaults = new Set(['project-docs', 'guidelines']);
+    switch (answers.stylingSystem) {
+        case 'nativewindui':
+            defaults.add('nativewindui');
+            break;
+        case 'nativewind':
+            defaults.add('nativewind');
+            break;
+        case 'tamagui':
+            defaults.add('tamagui');
+            break;
+        case 'restyle':
+            defaults.add('restyle');
+            break;
+        case 'stylesheet':
+            break;
+        case 'uniwind':
+        default:
+            defaults.add('uniwind');
+            break;
+    }
+    if (answers.dataStart === 'supabase' || answers.authBackend === 'supabase') {
+        defaults.add('supabase');
+    }
+    defaults.add('doctor');
+    if (answers.testToMainSafeguards ?? true) {
+        defaults.add('test-to-main');
+    }
+    return [...defaults].join(',');
+}
 function materializeQuestion(definition, context) {
     return {
         id: definition.id,
@@ -1476,6 +1794,45 @@ function normalizeEnum(value, choices) {
 function normalizeChoice(value, choices) {
     return normalizeEnum(value, choices);
 }
+function normalizePlatformStrategyValue(value) {
+    const normalized = normalizeText(value)?.toLowerCase();
+    if (!normalized) {
+        return undefined;
+    }
+    if (normalized === 'folders' || normalized.includes('folder')) {
+        return 'folders';
+    }
+    if (normalized === 'files-only' || normalized.includes('file')) {
+        return 'files-only';
+    }
+    return undefined;
+}
+function normalizeAppDirectoryValue(value) {
+    const normalized = normalizeText(value)?.toLowerCase().replace(/[`]/gu, '').trim();
+    if (!normalized) {
+        return undefined;
+    }
+    if (normalized === 'src' || normalized === 'src/app') {
+        return 'src';
+    }
+    if (normalized === 'root' || normalized === 'app') {
+        return 'root';
+    }
+    return undefined;
+}
+function normalizePlatformLayoutsValue(value) {
+    const normalized = normalizeText(value)?.toLowerCase();
+    if (!normalized) {
+        return undefined;
+    }
+    if (normalized === 'shared' || normalized.includes('shared')) {
+        return 'shared';
+    }
+    if (normalized === 'platform-specific' || normalized.includes('platform-specific')) {
+        return 'platform-specific';
+    }
+    return undefined;
+}
 function normalizeText(value) {
     if (typeof value !== 'string') {
         return undefined;
@@ -1532,6 +1889,8 @@ function formatStylingLabel(value) {
             return 'Uniwind';
         case 'nativewind':
             return 'NativeWind';
+        case 'nativewindui':
+            return 'NativeWindUI';
         case 'tamagui':
             return 'Tamagui';
         case 'restyle':