@supportpages.io/wtfm 0.0.0-stage → 0.3.0

package/engine/detect-project/scripts/test_runtime_coverage.js

@@ -0,0 +1,323 @@
+#!/usr/bin/env node
+'use strict';
+
+const assert = require('assert');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { spawnSync } = require('child_process');
+
+const checker = path.join(__dirname, 'check_runtime_coverage.js');
+
+function write(file, value) {
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.writeFileSync(file, typeof value === 'string' ? value : JSON.stringify(value, null, 2));
+}
+
+function run(mutator = () => {}) {
+    const root = fs.mkdtempSync(path.join(os.tmpdir(), 'rtfm-runtime-coverage-'));
+    write(path.join(root, 'views/editor.php'), 'enqueue(); app.initializeEditor("editor", {}); <div id="editor"></div>');
+    write(path.join(root, 'views/other.php'), 'plain server rendered page');
+    write(path.join(root, 'views/preview.webp'), 'representative-image');
+    const map = {
+        layouts: [{ name: 'editor', path: 'views/editor.php', chrome: [], runtime_chrome: {
+            source_kind: 'repo', source_files: ['views/editor.php'], regions: [], states: [],
+        }}],
+        route_index: { editor: { controller: 'views/editor.php', layout: 'editor' },
+            other: { controller: 'views/other.php', layout: 'plain' } },
+    };
+    mutator(map, root);
+    write(path.join(root, 'project_map.json'), map);
+    const reportPath = path.join(root, 'coverage.json');
+    const proc = spawnSync(process.execPath, [checker, path.join(root, 'project_map.json'), root, '--json', reportPath], { encoding: 'utf8' });
+    const report = JSON.parse(fs.readFileSync(reportPath, 'utf8'));
+    fs.rmSync(root, { recursive: true, force: true });
+    return { proc, report };
+}
+
+function strongSiteEditorRecipe() {
+    const src = ['views/editor.php'];
+    return {
+        app: 'Site editor',
+        mode_note: 'The editor opens with persistent navigation, toolbar, and canvas.',
+        source_kind: 'repo',
+        source_files: src,
+        regions: [
+            { id: 'toolbar', region: 'editor toolbar', placement: 'top', required: true,
+                appearance: 'A full-width dark toolbar above the workspace.',
+                items: ['site icon', 'view toggle', 'save control'], ui_strings: ['View', 'Save'],
+                required_strings: ['Save'], source_files: src },
+            { id: 'site-navigation', region: 'site navigation', placement: 'left', required: true,
+                appearance: 'A wide left rail of editor destinations.',
+                items: ['Navigation row', 'Styles row', 'Templates row'],
+                ui_strings: ['Navigation', 'Styles', 'Templates'], required_strings: ['Styles'], source_files: src },
+            { id: 'canvas', region: 'editing canvas', placement: 'canvas', required: true,
+                appearance: 'A dominant central preview of the site.',
+                items: ['site preview', 'selected content outline'], ui_strings: ['Design'],
+                required_strings: ['Design'], source_files: src },
+            { id: 'settings', region: 'editing settings', placement: 'right', required: false,
+                appearance: 'A settings sidebar aligned to the right edge.',
+                items: ['settings tabs', 'property controls'], ui_strings: ['Settings'],
+                required_strings: ['Settings'], source_files: src },
+            { id: 'save-confirmation', region: 'save confirmation', placement: 'overlay-right', required: false,
+                appearance: 'A raised confirmation panel over the right side of the canvas.',
+                items: ['changed items summary', 'cancel button', 'confirm save button'],
+                ui_strings: ['Review changes', 'Cancel', 'Save'],
+                required_strings: ['Review changes', 'Save'], source_files: src },
+        ],
+        states: [
+            { id: 'overview', name: 'overview', kind: 'overview', screenshot_required: false,
+                entered_by: 'open the editor', shows: 'the editor overview',
+                visible_regions: ['toolbar', 'site-navigation', 'canvas'], required_regions: [],
+                required_strings: [], source_files: src },
+            { id: 'edit-styles', name: 'edit styles', kind: 'action', screenshot_required: true,
+                entered_by: 'open Styles', shows: 'style controls beside the preview',
+                visible_regions: ['toolbar', 'site-navigation', 'canvas', 'settings'], required_regions: ['settings'],
+                required_strings: ['Styles'], source_files: src },
+            { id: 'edit-templates', name: 'edit templates', kind: 'action', screenshot_required: true,
+                entered_by: 'open Templates', shows: 'template controls beside the preview',
+                visible_regions: ['toolbar', 'site-navigation', 'canvas', 'settings'], required_regions: ['settings'],
+                required_strings: ['Templates'], source_files: src },
+            { id: 'confirm-save', name: 'confirm save', kind: 'confirm', screenshot_required: true,
+                entered_by: 'press Save', shows: 'the save review over the edited canvas',
+                visible_regions: ['toolbar', 'site-navigation', 'canvas', 'settings', 'save-confirmation'],
+                required_regions: ['save-confirmation'], required_strings: ['Save'], source_files: src },
+        ],
+    };
+}
+
+function runV3(recipeMutator = () => {}) {
+    return run(map => {
+        map.schema_version = 3;
+        map.layouts[0].runtime_chrome = strongSiteEditorRecipe();
+        recipeMutator(map.layouts[0].runtime_chrome, map);
+    });
+}
+
+function runV4(recipeMutator = () => {}) {
+    return run(map => {
+        map.schema_version = 4;
+        const recipe = strongSiteEditorRecipe();
+        for (const region of recipe.regions) {
+            region.items = region.items.map((description, index) => ({ id: `item-${index + 1}`, description }));
+            if (region.placement === 'canvas') Object.assign(region, {
+                content_mode: 'populated', media_expectation: 'required',
+                representative_assets: ['views/preview.webp'], max_selected_outlines: 1,
+            });
+        }
+        const priorities = ['orientation', 'primary-action', 'secondary-action', 'terminal-action'];
+        recipe.states.forEach((state, index) => {
+            state.topic_tags = [state.name];
+            state.instructional_priority = priorities[index];
+            if (state.kind === 'action') state.screenshot_required = false;
+        });
+        map.layouts[0].runtime_chrome = recipe;
+        recipeMutator(recipe, map);
+    });
+}
+
+let result = run();
+assert.strictEqual(result.proc.status, 0, result.proc.stderr);
+assert.strictEqual(result.report.candidates.length, 1);
+
+result = run((map, root) => {
+    write(path.join(root, 'views/site.php'), 'scripts(); product.initializeApplication("site", {});');
+    map.route_index.site = { controller: 'views/site.php', layout: 'editor' };
+});
+assert.strictEqual(result.proc.status, 1);
+assert(result.report.errors.some(error => error.includes('views/site.php')));
+
+result = run((map, root) => {
+    write(path.join(root, 'views/site.php'), 'scripts(); product.initializeApplication("site", {});');
+    map.route_index.site = { controller: 'views/site.php', layout: 'editor' };
+    map.layouts[0].runtime_chrome.source_files.push('views/site.php');
+});
+assert.strictEqual(result.proc.status, 1);
+assert(result.report.errors.some(error => error.includes('combines distinct mount files')));
+
+result = run((map, root) => {
+    write(path.join(root, 'views/site.php'), 'scripts(); product.initializeApplication("site", {});');
+    map.route_index.site = { controller: 'views/site.php', layout: 'editor' };
+    map.runtime_surface_coverage = { ignored: [{ source_file: 'views/site.php', reason: 'progressive enhancement only' }] };
+});
+assert.strictEqual(result.proc.status, 0, result.proc.stderr);
+
+// A complete schema-v3 Site Editor-shaped recipe is accepted.
+result = runV3();
+assert.strictEqual(result.proc.status, 0, result.proc.stderr);
+
+// The old descriptive recipe shape cannot pass as an enforceable v3 recipe.
+result = run((map) => {
+    map.schema_version = 3;
+    map.layouts[0].runtime_chrome = {
+        app: 'Site editor', mode_note: 'Fullscreen editor', source_kind: 'repo',
+        source_files: ['views/editor.php'],
+        regions: [
+            { id: 'navigation', region: 'navigation', placement: 'left', required: true,
+                items: ['Navigation', 'Styles', 'Templates'], ui_strings: ['Navigation', 'Styles', 'Templates'],
+                required_strings: ['Styles'], source_files: ['views/editor.php'] },
+            { id: 'canvas', region: 'canvas', placement: 'canvas', required: true,
+                items: ['preview'], ui_strings: ['Design'], required_strings: ['Design'], source_files: ['views/editor.php'] },
+            { id: 'confirm', region: 'confirmation', placement: 'overlay-right', required: false,
+                items: ['Save'], ui_strings: ['Save'], required_strings: ['Save'], source_files: ['views/editor.php'] },
+        ],
+        states: [
+            { id: 'editing', kind: 'action', screenshot_required: true, required_strings: ['Styles'] },
+            { id: 'confirm-save', kind: 'confirm', screenshot_required: true, required_strings: ['Save'] },
+        ],
+    };
+});
+assert.strictEqual(result.proc.status, 1);
+assert(result.report.errors.some(error => error.includes('appearance')));
+assert(result.report.errors.some(error => error.includes('visible_regions')));
+assert(result.report.errors.some(error => error.includes('overlay runtime region')));
+
+// The schema-v3 contract rejects weak IDs and inconsistent region visibility.
+result = runV3(recipe => { recipe.regions[0].id = 'Bad ID'; });
+assert.strictEqual(result.proc.status, 1);
+assert(result.report.errors.some(error => error.includes('unique kebab-case region ids')));
+
+result = runV3(recipe => { recipe.states[2].id = recipe.states[1].id; });
+assert.strictEqual(result.proc.status, 1);
+assert(result.report.errors.some(error => error.includes('unique kebab-case state ids')));
+
+result = runV3(recipe => {
+    recipe.app = '';
+    recipe.mode_note = ' ';
+    recipe.regions[0].region = '';
+    recipe.regions[0].items = [];
+    recipe.regions[0].appearance = '';
+});
+assert.strictEqual(result.proc.status, 1);
+for (const field of ['app', 'mode_note', 'region label', 'items', 'appearance']) {
+    assert(result.report.errors.some(error => error.includes(field)), `missing ${field} validation`);
+}
+
+result = runV3(recipe => { recipe.regions[3].required = true; });
+assert.strictEqual(result.proc.status, 1);
+assert(result.report.errors.some(error => error.includes("runtime region 'settings' required")));
+
+result = runV3(recipe => { recipe.states[1].visible_regions = ['canvas', 'toolbar']; });
+assert.strictEqual(result.proc.status, 1);
+assert(result.report.errors.some(error => error.includes('recipe order')));
+
+result = runV3(recipe => { recipe.states[0].screenshot_required = true; });
+assert.strictEqual(result.proc.status, 1);
+assert(result.report.errors.some(error => error.includes('overview state')));
+
+result = runV3(recipe => {
+    recipe.states[0].kind = 'action';
+    recipe.states[0].screenshot_required = true;
+    recipe.states[0].required_strings = ['Design'];
+});
+assert.strictEqual(result.proc.status, 1);
+assert(result.report.errors.some(error => error.includes('more than three screenshot-required states')));
+
+result = runV3(recipe => {
+    recipe.states[1].visible_regions = [];
+    recipe.states[1].required_strings = [];
+});
+assert.strictEqual(result.proc.status, 1);
+assert(result.report.errors.some(error => error.includes('must have visible_regions')));
+assert(result.report.errors.some(error => error.includes('visible required string assertion')));
+
+result = runV3(recipe => { recipe.regions[4].required_strings = ['Save']; });
+assert.strictEqual(result.proc.status, 1);
+assert(result.report.errors.some(error => error.includes('at least two required_strings')));
+
+result = runV3(recipe => { recipe.regions[4].items = ['summary', 'save']; });
+assert.strictEqual(result.proc.status, 1);
+assert(result.report.errors.some(error => error.includes('at least three items')));
+
+result = runV3(recipe => {
+    recipe.states = recipe.states.filter(state => state.id !== 'edit-templates');
+});
+assert.strictEqual(result.proc.status, 1);
+assert(result.report.errors.some(error => error.includes('at least two action states')));
+assert(result.report.errors.some(error => error.includes('at least two screenshot-required action states')));
+
+result = runV3(recipe => {
+    recipe.source_files = ['views/other.php'];
+});
+assert.strictEqual(result.proc.status, 1);
+assert(result.report.errors.some(error => error.includes('must include its layout mount')));
+
+// Schema v4 adds executable item inventories, topic-aware state selection,
+// and source-backed populated-canvas evidence without requiring every action
+// branch to consume a screenshot slot.
+result = runV4();
+assert.strictEqual(result.proc.status, 0, result.proc.stderr);
+
+result = runV4(recipe => { recipe.regions[0].items[0] = { id: 'Bad ID', description: '' }; });
+assert.strictEqual(result.proc.status, 1);
+assert(result.report.errors.some(error => error.includes('ordered items')));
+
+result = runV4(recipe => { delete recipe.states[1].topic_tags; });
+assert.strictEqual(result.proc.status, 1);
+assert(result.report.errors.some(error => error.includes('topic_tags')));
+
+result = runV4(recipe => { recipe.regions[2].representative_assets = []; });
+assert.strictEqual(result.proc.status, 1);
+assert(result.report.errors.some(error => error.includes('requires representative_assets')));
+
+function v5Mutator(extra = () => {}) {
+    return (recipe, map) => {
+        map.schema_version = 5;
+        for (const region of recipe.regions) {
+            for (const item of region.items) Object.assign(item, { kind: 'control-group', required_strings: [] });
+        }
+        const overlay = recipe.regions.find(region => region.placement.startsWith('overlay-'));
+        overlay.items[0].kind = 'group-heading';
+        overlay.items[1].kind = 'selection-row';
+        overlay.items[2].kind = 'actions';
+        for (const state of recipe.states) {
+            state.canvas_presentation = 'The populated canvas fills the workspace.';
+            if (['action', 'confirm'].includes(state.kind)) {
+                state.context_label = 'Editor document';
+                state.required_strings.push(state.context_label);
+            }
+        }
+        extra(recipe, map);
+    };
+}
+
+result = runV4(v5Mutator());
+assert.strictEqual(result.proc.status, 0, result.proc.stderr);
+
+result = runV4(v5Mutator(recipe => { delete recipe.regions[0].items[0].kind; }));
+assert.strictEqual(result.proc.status, 1);
+assert(result.report.errors.some(error => error.includes('items require kebab-case kind')));
+
+result = runV4(v5Mutator(recipe => { recipe.states[1].context_label = 'Missing from assertions'; }));
+assert.strictEqual(result.proc.status, 1);
+assert(result.report.errors.some(error => error.includes('concrete context_label')));
+
+result = runV4(v5Mutator(recipe => { recipe.regions[4].items[1].description = 'No changes'; }));
+assert.strictEqual(result.proc.status, 1);
+assert(result.report.errors.some(error => error.includes('concrete changed entities')));
+
+// Ignore entries are typed, unique, and mutually exclusive with ownership.
+result = run((map) => {
+    map.runtime_surface_coverage = { ignored: 'views/editor.php' };
+});
+assert.strictEqual(result.proc.status, 1);
+assert(result.report.errors.some(error => error.includes('ignored must be an array')));
+
+result = run((map) => {
+    map.layouts = [];
+    map.runtime_surface_coverage = { ignored: [{ source_file: 'views/editor.php', reason: 'x' }] };
+});
+assert.strictEqual(result.proc.status, 1);
+assert(result.report.errors.some(error => error.includes('specific reason')));
+
+result = run((map) => {
+    map.runtime_surface_coverage = { ignored: [
+        { source_file: 'views/editor.php', reason: 'progressive enhancement only' },
+        { source_file: 'views/editor.php', reason: 'duplicate progressive enhancement' },
+    ] };
+});
+assert.strictEqual(result.proc.status, 1);
+assert(result.report.errors.some(error => error.includes('duplicate source_file')));
+assert(result.report.errors.some(error => error.includes('both owned and ignored')));
+
+console.log('runtime surface coverage tests passed');

package/engine/detect-project/scripts/test_runtime_recipe_quality.js

@@ -0,0 +1,187 @@
+#!/usr/bin/env node
+'use strict';
+
+const assert = require('assert');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { spawnSync } = require('child_process');
+
+const checker = path.join(__dirname, 'check_runtime_recipe_quality.js');
+const profiles = path.join(__dirname, 'apply_runtime_profiles.js');
+const coverage = path.join(__dirname, 'check_runtime_coverage.js');
+
+function write(file, value) {
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.writeFileSync(file, typeof value === 'string' ? value : `${JSON.stringify(value, null, 2)}\n`);
+}
+
+function files(root) {
+    const values = {
+        'views/editor.js': 'app.initializeEditor("editor", {});',
+        'views/template.html': '<main>Blog Home</main>',
+        'views/header.html': '<header>My Site</header>',
+        'views/footer.html': '<footer>Designed with WordPress</footer>',
+        'views/preview.webp': 'image',
+    };
+    for (const [rel, value] of Object.entries(values)) write(path.join(root, rel), value);
+}
+
+function strongMap() {
+    const mount = ['views/editor.js'];
+    const content = ['views/template.html', 'views/header.html', 'views/footer.html'];
+    return {
+        schema_version: 5,
+        default_user_assumptions: ['JavaScript enabled'],
+        app_shell: { root_classes: { html: ['with-toolbar'], body: ['app-shell'] } },
+        runtime_surface_coverage: { ignored: [] },
+        layouts: [{
+            name: 'site-editor', path: 'views/editor.js', area: 'fullscreen editor with no classic toolbar', chrome: [],
+            root_classes: { html: [], body: ['editor', 'is-fullscreen-mode'] },
+            runtime_chrome: {
+                app: 'Site editor', mode_note: 'Always fullscreen with the shell hidden.',
+                source_kind: 'knowledge', source_files: mount,
+                regions: [
+                    { id: 'navigation', region: 'design navigation', placement: 'left', required: false,
+                        appearance: 'dark #111 sidebar',
+                        items: [{ id: 'identity', kind: 'identity', description: 'site identity', required_strings: [] },
+                            { id: 'destinations', kind: 'navigation-list', description: 'destinations', required_strings: ['Styles', 'Templates'] }],
+                        ui_strings: ['Styles', 'Templates'], required_strings: ['Styles'], source_files: mount },
+                    { id: 'toolbar', region: 'editing toolbar', placement: 'top', required: false,
+                        appearance: 'light full-width toolbar',
+                        items: [{ id: 'identity', kind: 'identity', description: 'back identity', required_strings: [] },
+                            { id: 'editing-tools', kind: 'control-group', description: 'editing controls', required_strings: [] },
+                            { id: 'document-title', kind: 'document-context', description: 'document title', required_strings: ['Blog Home'] },
+                            { id: 'view-tools', kind: 'control-group', description: 'view controls', required_strings: [] },
+                            { id: 'save', kind: 'primary-action', description: 'save action', required_strings: ['Save'] }],
+                        ui_strings: ['Blog Home', 'Save'], required_strings: ['Save'], source_files: mount },
+                    { id: 'canvas', region: 'site canvas', placement: 'canvas', required: true,
+                        appearance: 'largest white populated canvas', content_mode: 'populated', media_expectation: 'required',
+                        representative_assets: ['views/preview.webp'], max_selected_outlines: 1,
+                        items: [{ id: 'header', kind: 'content-section', description: 'header', required_strings: [] },
+                            { id: 'main', kind: 'content-section', description: 'main content', required_strings: [] },
+                            { id: 'footer', kind: 'content-section', description: 'footer', required_strings: ['Designed with WordPress'] }],
+                        ui_strings: ['Designed with WordPress'], required_strings: ['Designed with WordPress'], source_files: content },
+                    { id: 'styles-panel', region: 'styles inspector', placement: 'right', required: false,
+                        appearance: 'light right sidebar',
+                        items: [{ id: 'heading', kind: 'panel-heading', description: 'heading', required_strings: ['Styles'] },
+                            { id: 'browse', kind: 'action-card', description: 'browse styles', required_strings: ['Browse styles'] },
+                            { id: 'colors', kind: 'panel-row', description: 'colors row', required_strings: ['Colors'] },
+                            { id: 'layout', kind: 'panel-row', description: 'layout row', required_strings: ['Layout'] }],
+                        ui_strings: ['Styles', 'Browse styles', 'Colors', 'Layout'], required_strings: ['Styles'], source_files: mount },
+                    { id: 'template-panel', region: 'template inspector', placement: 'right', required: false,
+                        appearance: 'light right sidebar',
+                        items: [{ id: 'heading', kind: 'panel-heading', description: 'heading', required_strings: ['Template'] },
+                            { id: 'summary', kind: 'settings-list', description: 'summary', required_strings: ['Blog Home'] },
+                            { id: 'header', kind: 'panel-row', description: 'header row', required_strings: ['Header'] },
+                            { id: 'footer', kind: 'panel-row', description: 'footer row', required_strings: ['Footer'] }],
+                        ui_strings: ['Template', 'Blog Home', 'Header', 'Footer'], required_strings: ['Template'], source_files: mount },
+                    { id: 'confirm', region: 'save confirmation', placement: 'overlay-right', required: false,
+                        appearance: 'light right overlay panel',
+                        items: [{ id: 'heading', kind: 'panel-heading', description: 'heading', required_strings: ['Ready to save?'] },
+                            { id: 'styles-group', kind: 'group-heading', description: 'styles group', required_strings: ['Styles'] },
+                            { id: 'styles-change', kind: 'selection-row', description: 'theme change', required_strings: ['Example Theme'] },
+                            { id: 'templates-group', kind: 'group-heading', description: 'templates group', required_strings: ['Templates'] },
+                            { id: 'template-change', kind: 'selection-row', description: 'template change', required_strings: ['Blog Home'] },
+                            { id: 'actions', kind: 'actions', description: 'actions', required_strings: ['Cancel', 'Save'] }],
+                        ui_strings: ['Ready to save?', 'Styles', 'Templates', 'Cancel', 'Save'],
+                        required_strings: ['Ready to save?', 'Cancel', 'Save'], source_files: mount },
+                ],
+                states: [
+                    { id: 'overview', kind: 'overview', visible_regions: ['navigation', 'canvas'], required_regions: [],
+                        screenshot_required: false, required_strings: ['Styles'], source_files: content },
+                    { id: 'styles-editing', kind: 'action', context_label: 'Blog Home', visible_regions: ['toolbar', 'canvas', 'styles-panel'],
+                        required_regions: ['toolbar', 'styles-panel'], screenshot_required: false, required_strings: ['Blog Home'], source_files: content },
+                    { id: 'template-editing', kind: 'action', context_label: 'Blog Home', visible_regions: ['toolbar', 'canvas', 'template-panel'],
+                        required_regions: ['toolbar', 'template-panel'], screenshot_required: false, required_strings: ['Blog Home'], source_files: content },
+                    { id: 'confirm-save', kind: 'confirm', context_label: 'Blog Home', visible_regions: ['toolbar', 'canvas', 'confirm'],
+                        required_regions: ['confirm'], screenshot_required: true, required_strings: ['Blog Home', 'Save'], source_files: content },
+                ],
+            },
+        }],
+        route_index: { editor: { path: '/editor', controller: 'views/editor.js', primary_view: 'views/editor.js',
+            controller_action: 'views/editor.js', layout: 'site-editor', partials_expanded: content } },
+    };
+}
+
+function runQuality(mutator = () => {}) {
+    const root = fs.mkdtempSync(path.join(os.tmpdir(), 'rtfm-runtime-quality-'));
+    files(root);
+    const map = strongMap();
+    mutator(map, root);
+    const mapPath = path.join(root, 'project_map.json');
+    write(mapPath, map);
+    const reportPath = path.join(root, 'report.json');
+    const proc = spawnSync(process.execPath, [checker, mapPath, root, '--json', reportPath], { encoding: 'utf8' });
+    const report = JSON.parse(fs.readFileSync(reportPath, 'utf8'));
+    fs.rmSync(root, { recursive: true, force: true });
+    return { proc, report };
+}
+
+let result = runQuality();
+assert.strictEqual(result.proc.status, 0, result.proc.stderr);
+
+result = runQuality(map => { map.layouts[0].runtime_chrome.regions.find(region => region.id === 'canvas').items.length = 1; });
+assert.strictEqual(result.proc.status, 1);
+assert(result.report.errors.some(error => error.includes('three source-backed anatomy items')));
+
+result = runQuality(map => { map.layouts[0].runtime_chrome.states[1].context_label = 'Styles'; });
+assert.strictEqual(result.proc.status, 1);
+assert(result.report.errors.some(error => error.includes('generic feature label')));
+
+result = runQuality(map => {
+    const overlay = map.layouts[0].runtime_chrome.regions.find(region => region.id === 'confirm');
+    overlay.items = overlay.items.filter(item => !['templates-group', 'template-change'].includes(item.id));
+});
+assert.strictEqual(result.proc.status, 1);
+assert(result.report.errors.some(error => error.includes('changed-entity group')));
+
+result = runQuality(map => { map.route_index.editor.partials_expanded = []; });
+assert.strictEqual(result.proc.status, 1);
+assert(result.report.errors.some(error => error.includes('recursively expanded')));
+
+// The reusable WordPress profile converts a shallow detector result into a
+// source-backed schema-v5 recipe that passes both coverage and quality gates.
+{
+    const root = fs.mkdtempSync(path.join(os.tmpdir(), 'rtfm-runtime-profile-'));
+    const required = {
+        'src/wp-admin/site-editor.php': "wp.editSite.initializeEditor('site-editor', {});",
+        'src/wp-includes/default-constants.php': "define( 'WP_DEFAULT_THEME', 'twentytwentyfive' );",
+        'src/wp-includes/block-template-utils.php': "'home' => array(\n 'title' => _x( 'Blog Home', 'Template name' ),\n 'description' => __( 'Displays the latest posts.' ),\n),",
+        'src/wp-content/themes/twentytwentyfive/style.css': 'Theme Name: Twenty Twenty-Five\n',
+        'src/wp-content/themes/twentytwentyfive/templates/home.html': '<main>home</main>',
+        'src/wp-content/themes/twentytwentyfive/parts/header.html': '<header/>',
+        'src/wp-content/themes/twentytwentyfive/parts/footer.html': '<footer/>',
+        'src/wp-content/themes/twentytwentyfive/patterns/header.php': 'header',
+        'src/wp-content/themes/twentytwentyfive/patterns/footer.php': 'Designed with WordPress',
+        'src/wp-content/themes/twentytwentyfive/patterns/hidden-blog-heading.php': 'Blog',
+        'src/wp-content/themes/twentytwentyfive/patterns/template-query-loop.php': 'query',
+        'src/wp-content/themes/twentytwentyfive/theme.json': '{}',
+        'src/wp-content/themes/twentytwentyfive/assets/images/botany-flowers.webp': 'image',
+        'src/wp-content/themes/twentytwentyfive/assets/images/category-sunflowers.webp': 'image',
+    };
+    for (const [rel, value] of Object.entries(required)) write(path.join(root, rel), value);
+    const mapPath = path.join(root, 'project_map.json');
+    write(mapPath, {
+        schema_version: 5, app_shell: { root_classes: { html: ['wp-toolbar'], body: ['wp-admin'] } },
+        layouts: [{ name: 'site-editor', path: 'src/wp-admin/site-editor.php', chrome: [], runtime_chrome: {
+            source_kind: 'knowledge', source_files: ['src/wp-admin/site-editor.php'], regions: [], states: [],
+        }}],
+        route_index: { 'site-editor': { path: '/wp-admin/site-editor.php', primary_view: 'src/wp-admin/site-editor.php', layout: 'site-editor' } },
+        default_user_assumptions: [], runtime_surface_coverage: { ignored: [] },
+    });
+    let proc = spawnSync(process.execPath, [profiles, mapPath, root], { encoding: 'utf8' });
+    assert.strictEqual(proc.status, 0, proc.stderr);
+    const enriched = JSON.parse(fs.readFileSync(mapPath, 'utf8'));
+    const site = enriched.layouts.find(layout => layout.name === 'site-editor');
+    assert.strictEqual(site.runtime_chrome.states[1].context_label, 'Blog Home');
+    assert.strictEqual(site.runtime_chrome.regions.find(region => region.id === 'navigation').appearance.includes('dark #1e1e1e'), true);
+    assert.strictEqual(site.runtime_chrome.regions.find(region => region.id === 'confirm').items.filter(item => item.kind === 'selection-row').length, 2);
+    proc = spawnSync(process.execPath, [coverage, mapPath, root], { encoding: 'utf8' });
+    assert.strictEqual(proc.status, 0, proc.stderr);
+    proc = spawnSync(process.execPath, [checker, mapPath, root], { encoding: 'utf8' });
+    assert.strictEqual(proc.status, 0, proc.stderr);
+    fs.rmSync(root, { recursive: true, force: true });
+}
+
+console.log('runtime recipe quality tests passed');