@ccslabs/xtend 0.1.0-rc.1

package/tools/rmt-linter/reporter.js

@@ -0,0 +1,472 @@
+const fs = require('fs');
+const path = require('path');
+const { pathToFileURL } = require('url');
+const {
+  buildSemanticGraph
+} = require('../rmt-language/semantic-graph');
+const {
+  lintRmtSource
+} = require('../rmt-language/diagnostics');
+const {
+  getRmtCodeActions
+} = require('../rmt-language/code-actions');
+const {
+  analyzeRmtVNextToolingSource,
+  isLikelyRmtVNextSource,
+  lintRmtVNextToolingSource
+} = require('../rmt-language/vnext-tooling');
+
+const RMT_AGENT_REPAIR_REPORT_SCHEMA = 'xtend.rmt.ai-agent-repair-report.v1';
+const RMT_AGENT_REPAIR_FILE_SCHEMA = 'xtend.rmt.ai-agent-repair-file.v1';
+const RMT_AGENT_REPAIR_STEP_SCHEMA = 'xtend.rmt.ai-agent-repair-step.v1';
+const RMT_AGENT_NOOP_SCHEMA = 'xtend.rmt.ai-agent-noop.v1';
+const RMT_AGENT_REPAIR_REPORT_WORKPACKAGE = 'WP-E14-11';
+const RMT_AGENT_REPAIR_REPORT_MODULE_PATH = 'tools/rmt-linter/reporter.js';
+const RMT_AGENT_REPAIR_REPORT_SUITE_PATH = 'tests/rmt-language/rmt_agent_repair_report_suite.js';
+const RMT_AGENT_REPAIR_REPORT_PACKAGE_SCRIPT = 'npm run test:rmt-agent-report';
+const DEFAULT_TOOL_ROOT_DIR = path.resolve(__dirname, '..', '..');
+
+const SEVERITY_RANK = Object.freeze({
+  error: 0,
+  warning: 1,
+  info: 2,
+  hint: 3
+});
+
+const REPAIR_PRIORITY = Object.freeze({
+  'rename-file-extension': 10,
+  'create-schedule': 20,
+  'create-template-stub': 30,
+  'create-component-stub': 40,
+  'replace-field-value': 50,
+  'add-route-title': 60,
+  'append-property': 70
+});
+
+function normalizeString(value) {
+  return typeof value === 'string' ? value.trim() : '';
+}
+
+function toArray(value) {
+  return Array.isArray(value) ? value : [];
+}
+
+function normalizeSeverity(value) {
+  return Object.prototype.hasOwnProperty.call(SEVERITY_RANK, value) ? value : 'info';
+}
+
+function severityRank(value) {
+  return SEVERITY_RANK[normalizeSeverity(value)];
+}
+
+function shouldFail(summary, failOn = 'error') {
+  const threshold = severityRank(failOn);
+
+  return Object.entries(SEVERITY_RANK).some(([severity, rank]) => {
+    if (rank > threshold) {
+      return false;
+    }
+
+    return (summary[`${severity}Count`] || 0) > 0;
+  });
+}
+
+function createUri(input = {}) {
+  if (input.uri) {
+    return input.uri;
+  }
+
+  if (input.filePath) {
+    return pathToFileURL(path.resolve(input.filePath)).href;
+  }
+
+  return 'untitled:rmt-agent-report';
+}
+
+function createLanguageToolingOptions(options = {}) {
+  return {
+    ...options,
+    workspaceRoot: options.rootDir || options.workspaceRoot || null,
+    rootDir: path.resolve(options.toolRootDir || options.formatRootDir || DEFAULT_TOOL_ROOT_DIR)
+  };
+}
+
+function normalizeDiagnostic(diagnostic = {}) {
+  return {
+    schema: diagnostic.schema || 'xtend.rmt.linter.diagnostic.v1',
+    source: diagnostic.source || 'rmt-linter',
+    code: diagnostic.code || 'rmt.diagnostic',
+    ruleId: diagnostic.ruleId || null,
+    severity: normalizeSeverity(diagnostic.severity),
+    category: diagnostic.category || null,
+    message: diagnostic.message || diagnostic.code || 'RMT diagnostic',
+    uri: diagnostic.uri || null,
+    file: diagnostic.file || null,
+    pointer: diagnostic.pointer || null,
+    range: diagnostic.range || null,
+    repair: diagnostic.repair || null,
+    relatedInformation: toArray(diagnostic.relatedInformation)
+  };
+}
+
+function summarizeDiagnostics(diagnostics) {
+  return diagnostics.reduce((summary, diagnostic) => {
+    const severity = normalizeSeverity(diagnostic.severity);
+    const key = `${severity}Count`;
+
+    summary.totalCount += 1;
+    summary[key] += 1;
+
+    return summary;
+  }, {
+    totalCount: 0,
+    errorCount: 0,
+    warningCount: 0,
+    infoCount: 0,
+    hintCount: 0
+  });
+}
+
+function inferImpact(diagnostic = {}) {
+  if (diagnostic.code === 'rmt.template.inline-script.refused'
+    || diagnostic.code === 'rmt.xtend.kernel-boundary.violation') {
+    return 'critical';
+  }
+
+  if (diagnostic.severity === 'error') {
+    return 'high';
+  }
+
+  if (diagnostic.severity === 'warning') {
+    return 'medium';
+  }
+
+  return 'low';
+}
+
+function inferNoopReason(diagnostic = {}, actions = []) {
+  if (actions.some((action) => action.diagnosticCode === diagnostic.code)) {
+    return 'covered-by-related-repair';
+  }
+
+  if (diagnostic.code === 'rmt.syntax.invalid-json') {
+    return 'source-not-parseable';
+  }
+
+  if (diagnostic.code === 'rmt.template.inline-script.refused'
+    || diagnostic.code === 'rmt.xtend.kernel-boundary.violation') {
+    return 'unsafe-automatic-edit';
+  }
+
+  if (diagnostic.code && diagnostic.code.startsWith('rmt.ref.component')) {
+    return 'component-stub-needs-authoring-context';
+  }
+
+  return 'no-safe-mvp-fix';
+}
+
+function explainNoop(diagnostic = {}, actions = []) {
+  const reason = inferNoopReason(diagnostic, actions);
+
+  if (reason === 'covered-by-related-repair') {
+    return 'Eine verwandte Diagnose desselben Typs erzeugt bereits einen deduplizierten Fix. Diesen Fix zuerst anwenden und danach erneut linten.';
+  }
+
+  if (reason === 'source-not-parseable') {
+    return 'Die Quelle ist syntaktisch nicht parsebar. Erst JSON/RMT-Syntax korrigieren, dann semantische Fixes erneut anfordern.';
+  }
+
+  if (reason === 'unsafe-automatic-edit') {
+    return 'Die Diagnose betrifft Security- oder Kernel-Boundary-Verhalten. Automatisches Entfernen waere zu riskant und benoetigt Review.';
+  }
+
+  if (reason === 'component-stub-needs-authoring-context') {
+    return 'Ein Component-Stub benoetigt bewusstes UI-/Adapter-Authoring. Der MVP erzeugt dafuer keinen automatischen Stub.';
+  }
+
+  return 'Fuer diese Diagnose gibt es im sicheren MVP noch keinen deterministischen Quick Fix.';
+}
+
+function repairKindForAction(action = {}) {
+  if (action.edit && action.edit.metadata && action.edit.metadata.repairKind) {
+    return action.edit.metadata.repairKind;
+  }
+
+  if (action.command && action.command.command === 'xtend.rmt.renameFileExtension') {
+    return 'rename-file-extension';
+  }
+
+  return action.diagnosticCode || 'manual-review';
+}
+
+function repairPriority(action = {}) {
+  const repairKind = repairKindForAction(action);
+
+  return REPAIR_PRIORITY[repairKind] || 100;
+}
+
+function relatedDiagnosticsFor(diagnostic, diagnostics) {
+  const pointer = diagnostic.pointer || null;
+
+  if (!pointer) {
+    return [];
+  }
+
+  return diagnostics
+    .filter((entry) => entry !== diagnostic && entry.pointer === pointer)
+    .map((entry) => ({
+      code: entry.code,
+      severity: entry.severity,
+      message: entry.message,
+      pointer: entry.pointer,
+      impact: inferImpact(entry)
+    }));
+}
+
+function actionMatchesDiagnostic(action, diagnostic) {
+  return toArray(action.diagnostics).some((entry) => {
+    return entry.code === diagnostic.code && (entry.pointer || null) === (diagnostic.pointer || null);
+  });
+}
+
+function normalizeActionForAgent(action, diagnostic, diagnostics, order) {
+  const repairKind = repairKindForAction(action);
+
+  return {
+    schema: RMT_AGENT_REPAIR_STEP_SCHEMA,
+    order,
+    title: action.title,
+    diagnosticCode: action.diagnosticCode,
+    pointer: action.pointer || (diagnostic && diagnostic.pointer) || null,
+    severity: diagnostic ? diagnostic.severity : 'info',
+    impact: diagnostic ? inferImpact(diagnostic) : 'low',
+    confidence: action.confidence || 'high',
+    safe: action.safe !== false,
+    repairKind,
+    applyMode: action.edit ? 'workspace-edit' : action.command ? 'command' : 'manual',
+    action,
+    edit: action.edit || null,
+    command: action.command || null,
+    relatedDiagnostics: diagnostic ? relatedDiagnosticsFor(diagnostic, diagnostics) : []
+  };
+}
+
+function createNoop(diagnostic, diagnostics, actions = []) {
+  return {
+    schema: RMT_AGENT_NOOP_SCHEMA,
+    diagnosticCode: diagnostic.code,
+    pointer: diagnostic.pointer || null,
+    severity: diagnostic.severity,
+    impact: inferImpact(diagnostic),
+    confidence: 'none',
+    repairable: false,
+    reason: inferNoopReason(diagnostic, actions),
+    explanation: explainNoop(diagnostic, actions),
+    relatedDiagnostics: relatedDiagnosticsFor(diagnostic, diagnostics)
+  };
+}
+
+function sortRepairSteps(steps) {
+  return steps.sort((a, b) => {
+    const severityDiff = severityRank(a.severity) - severityRank(b.severity);
+
+    if (severityDiff !== 0) {
+      return severityDiff;
+    }
+
+    const priorityDiff = repairPriority(a.action) - repairPriority(b.action);
+
+    if (priorityDiff !== 0) {
+      return priorityDiff;
+    }
+
+    const pointerDiff = String(a.pointer || '').localeCompare(String(b.pointer || ''));
+
+    if (pointerDiff !== 0) {
+      return pointerDiff;
+    }
+
+    return String(a.title || '').localeCompare(String(b.title || ''));
+  }).map((step, index) => ({
+    ...step,
+    order: index + 1
+  }));
+}
+
+function createFileAgentReport(input = {}, options = {}) {
+  const sourceInput = {
+    text: String(input.text || ''),
+    uri: input.uri,
+    filePath: input.filePath || null,
+    version: input.version || 0,
+    languageId: input.languageId || 'rmt'
+  };
+  const uri = createUri(sourceInput);
+  const languageOptions = createLanguageToolingOptions(options);
+  const vnext = isLikelyRmtVNextSource(sourceInput, languageOptions);
+  const graph = options.graph || (vnext
+    ? analyzeRmtVNextToolingSource(sourceInput, languageOptions)
+    : buildSemanticGraph(sourceInput, languageOptions));
+  const lintReport = options.lintReport || (vnext
+    ? lintRmtVNextToolingSource(sourceInput, {
+      ...languageOptions,
+      analysis: graph
+    })
+    : lintRmtSource(sourceInput, {
+      ...languageOptions,
+      graph
+    }));
+  const codeActionReport = options.codeActionReport || (vnext
+    ? {
+      actions: []
+    }
+    : getCodeActionReport(sourceInput, graph, lintReport, languageOptions));
+  const diagnostics = toArray(lintReport.diagnostics).map(normalizeDiagnostic);
+  const actions = toArray(codeActionReport.actions);
+  const matchedDiagnostics = new Set();
+  const repairSteps = [];
+
+  actions.forEach((action) => {
+    const diagnostic = diagnostics.find((entry) => actionMatchesDiagnostic(action, entry))
+      || diagnostics.find((entry) => entry.code === action.diagnosticCode);
+
+    if (diagnostic) {
+      matchedDiagnostics.add(diagnostic);
+    }
+
+    repairSteps.push(normalizeActionForAgent(action, diagnostic, diagnostics, repairSteps.length + 1));
+  });
+
+  const sortedRepairSteps = sortRepairSteps(repairSteps);
+  const noOps = diagnostics
+    .filter((diagnostic) => !matchedDiagnostics.has(diagnostic))
+    .map((diagnostic) => createNoop(diagnostic, diagnostics, actions))
+    .sort((a, b) => {
+      const severityDiff = severityRank(a.severity) - severityRank(b.severity);
+
+      if (severityDiff !== 0) {
+        return severityDiff;
+      }
+
+      const pointerDiff = String(a.pointer || '').localeCompare(String(b.pointer || ''));
+
+      if (pointerDiff !== 0) {
+        return pointerDiff;
+      }
+
+      return String(a.diagnosticCode || '').localeCompare(String(b.diagnosticCode || ''));
+    });
+  const summary = summarizeDiagnostics(diagnostics);
+
+  return {
+    schema: RMT_AGENT_REPAIR_FILE_SCHEMA,
+    uri,
+    file: sourceInput.filePath,
+    status: lintReport.status,
+    ok: lintReport.ok,
+    languageMode: vnext ? 'vnext' : 'legacy',
+    graphStatus: graph.status,
+    sourceMapSummary: graph.sourceMapSummary || null,
+    diagnostics,
+    repairPlan: sortedRepairSteps,
+    noOps,
+    actionableCount: sortedRepairSteps.length,
+    noOpCount: noOps.length,
+    ...summary
+  };
+}
+
+function getCodeActionReport(sourceInput, graph, lintReport, options = {}) {
+  const {
+    getRmtCodeActions
+  } = require('../rmt-language/code-actions');
+
+  return getRmtCodeActions(sourceInput, {
+    ...options,
+    graph,
+    lintReport
+  });
+}
+
+function createFileInputFromPath(filePath) {
+  const absolutePath = path.resolve(filePath);
+
+  return {
+    text: fs.readFileSync(absolutePath, 'utf8'),
+    filePath: absolutePath
+  };
+}
+
+function createRmtAgentRepairReport(inputs = [], options = {}) {
+  const sourceInputs = (Array.isArray(inputs) ? inputs : [inputs]).map((input) => {
+    if (typeof input === 'string') {
+      return createFileInputFromPath(input);
+    }
+
+    return input;
+  });
+  const fileReports = sourceInputs.map((input) => createFileAgentReport(input, options));
+  const diagnostics = fileReports.flatMap((fileReport) => fileReport.diagnostics);
+  const repairPlan = fileReports.flatMap((fileReport) => fileReport.repairPlan.map((step) => ({
+    ...step,
+    uri: fileReport.uri,
+    file: fileReport.file
+  })));
+  const sortedRepairPlan = sortRepairSteps(repairPlan);
+  const noOps = fileReports.flatMap((fileReport) => fileReport.noOps.map((noop) => ({
+    ...noop,
+    uri: fileReport.uri,
+    file: fileReport.file
+  })));
+  const summary = summarizeDiagnostics(diagnostics);
+  const failOn = normalizeSeverity(options.failOn || 'error');
+  const status = shouldFail(summary, failOn) ? 'failed' : 'passed';
+
+  return {
+    schema: RMT_AGENT_REPAIR_REPORT_SCHEMA,
+    sourceReportSchema: 'xtend.rmt.linter.report.v1',
+    codeActionProviderSchema: 'xtend.rmt.code-action-provider.v1',
+    workpackage: RMT_AGENT_REPAIR_REPORT_WORKPACKAGE,
+    status,
+    ok: status === 'passed',
+    failOn,
+    files: fileReports.length,
+    fileReports,
+    diagnostics,
+    repairPlan: sortedRepairPlan,
+    fixOrder: sortedRepairPlan.map((step) => ({
+      order: step.order,
+      title: step.title,
+      diagnosticCode: step.diagnosticCode,
+      pointer: step.pointer,
+      uri: step.uri,
+      applyMode: step.applyMode,
+      safe: step.safe,
+      confidence: step.confidence,
+      impact: step.impact
+    })),
+    noOps,
+    actionableCount: sortedRepairPlan.length,
+    noOpCount: noOps.length,
+    ...summary
+  };
+}
+
+function createRmtAgentRepairReportForFiles(files = [], options = {}) {
+  return createRmtAgentRepairReport(files, options);
+}
+
+module.exports = {
+  RMT_AGENT_NOOP_SCHEMA,
+  RMT_AGENT_REPAIR_FILE_SCHEMA,
+  RMT_AGENT_REPAIR_REPORT_MODULE_PATH,
+  RMT_AGENT_REPAIR_REPORT_PACKAGE_SCRIPT,
+  RMT_AGENT_REPAIR_REPORT_SCHEMA,
+  RMT_AGENT_REPAIR_REPORT_SUITE_PATH,
+  RMT_AGENT_REPAIR_REPORT_WORKPACKAGE,
+  RMT_AGENT_REPAIR_STEP_SCHEMA,
+  createRmtAgentRepairReport,
+  createRmtAgentRepairReportForFiles,
+  createFileAgentReport,
+  inferImpact
+};

package/xtend-builder/README.md

@@ -0,0 +1,83 @@
+# XTend-Scaffold
+
+`XTend-Scaffold` ist das repo-lokale Build-Environment fuer kuenftige XTend-Generatoren. Epic 03 hat es als generator-only, dry-run-first Scaffold abgeschlossen; Epic 17 baut daraus einen dry-run-first, aber produktiv schreibfaehigen Buildpfad.
+
+## Local Entry Points
+
+```bash
+xt --help
+xt validate --json
+xt component-files --tag x-example --profile display --json
+xtend validate --json
+xtend-scaffold verify --json
+node xtend-builder/scaffold.js --help
+node xtend-builder/scaffold.js layout
+node xtend-builder/scaffold.js layout --json
+node xtend-builder/scaffold.js blueprint --json
+node xtend-builder/scaffold.js generators --json
+node xtend-builder/scaffold.js templates --json
+node xtend-builder/scaffold.js component-plan --tag x-example --profile display --json
+node xtend-builder/scaffold.js component-files --tag x-example --profile display --json
+node xtend-builder/scaffold.js component-files --tag x-example --profile display --write --json
+node xtend-builder/scaffold.js component-files --tag x-example --profile display --check --json
+node xtend-builder/scaffold.js typing --tag x-example --profile display --json
+node xtend-builder/scaffold.js preview --tag x-example --profile display --json
+node xtend-builder/scaffold.js extensions --tag x-example --profile display --json
+node xtend-builder/scaffold.js rmt-build --source xtendrmt/rmt-lifecycle-demo.rmt --write --json
+node xtend-builder/scaffold.js workflow --json
+node xtend-builder/scaffold.js verify --json
+node scripts/run_xtend_tests.js rmt-compatibility --json
+npm run scaffold -- layout
+npm run scaffold:workflow
+npm run scaffold:verify
+npm run scaffold:dry-run
+npm run scaffold:typing
+npm run scaffold:preview
+npm run scaffold:extensions
+```
+
+`xt` ist der kurze lokale CLI-Alias fuer dieselbe Scaffold-Implementierung wie `xtend` und `xtend-scaffold`. `validate` ist ein stabiler Alias fuer `verify`, damit lokale Gates kurz als `xt validate --json` aufgerufen werden koennen.
+
+## Projektlayout
+
+| Bereich | Pfad | Grenze |
+|---------|------|--------|
+| CLI | `xtend-builder/scaffold.js` | lokaler Einstieg fuer Hilfe, Layout und spaetere Generatorbefehle |
+| CLI-Modul | `xtend-builder/lib/cli.js` | Argumentauswertung und Dispatch ohne Schreiblogik |
+| Layout-Contract | `xtend-builder/lib/layout.js` | maschinenlesbare Struktur fuer Docs, Tests und CLI |
+| Blueprints | `xtend-builder/blueprints/` | Komponenten-Blueprint und Artefaktcontract |
+| Generators | `xtend-builder/generators/` | Generator-Registry, Component-Plan und dry-run Component-Files |
+| Templates | `xtend-builder/templates/` | Template-Registry, Ladepfad und konkrete Pflichtartefakt-Templates |
+| Wiring | `xtend-builder/wiring/` | Manifest-, Hydrations- und Feature-Contracts fuer dry-run Component-Files |
+| Typing | `xtend-builder/typing/` | Type-Contracts fuer `.d.ts` Artefakte und vorbereiteten XTendRMT-Anschluss |
+| Preview | `xtend-builder/preview/` | Preview- und Referenzpfad-Contracts fuer scaffolded Demo-Plaene |
+| Extensions | `xtend-builder/extensions/` | Extension-Point-Contracts fuer Templating, Rendering und Root-Lifecycle |
+| A11y | `xtend-builder/a11y/` | A11y- und Screenreader-Signal-Profilplan fuer neue Komponenten, Fixtures, Docs, Tests, Types und Manifest |
+| Performance | `xtend-builder/performance/` | Performance-Profilplan fuer neue Komponenten, Budgets, Lanes, Hydration und Gates |
+| Workflows | `xtend-builder/workflows/` | lokale Dry-Run-, Verify- und Reporting-Schrittfolgen |
+| Utils | `xtend-builder/utils/` | pure Helfer fuer Naming, Tokenersetzung und Validierung |
+| Writing | `xtend-builder/writing/` | zentraler WritePlan, strukturierte Patcher und kontrollierte Dateischreibpfade fuer produktive Scaffold-Builds |
+| Config | `xtend-builder/scaffold.config.js` | zentrale Profile, Pfade, Testpflicht und Tooling-Entscheidung |
+
+## Modulgrenzen
+
+- `lib/` darf CLI-, Layout- und spaeter reine Orchestrierungslogik enthalten.
+- `blueprints/` beschreibt Zielartefakte und Contracts, erzeugt aber nichts selbst.
+- `generators/` enthaelt ab `WP-E03-11` Plan-, Render-, Typing-, Preview- und Extension-Contract-Generatorlogik.
+- `templates/` enthaelt ab `WP-E03-05` konkrete Ausgabetemplates fuer Komponente, Doku, Tests, Fixture, Types und Manifest-Patch-Plan.
+- `wiring/` enthaelt ab `WP-E03-07` reine Builder-Contracts fuer Manifest-Patchplaene, Hydration-Mindestpfade und profilbasierte Feature-Wiring-Patterns.
+- `typing/` enthaelt ab `WP-E03-09` reine Type-Contracts fuer oeffentliche APIs, Events, Attribute und vorbereitete XTendRMT-Adapter-Anbindung.
+- `preview/` enthaelt ab `WP-E03-10` reine Preview- und Reference-Gate-Contracts fuer scaffolded Komponenten.
+- `extensions/` enthaelt ab `WP-E03-11` reine Extension-Point-Contracts fuer Templating, Rendering und Root-Lifecycle.
+- `a11y/` enthaelt ab `ER-WP-23` reine A11y-Profilplaene nach `xtend.a11y.profile.v1`; ab `ER-WP-25` haengt es `xtend.a11y.screenreader-signals.v1` fuer Live-Region-, Status- und Error-Signale an; ab `ER-WP-26` haengt es `xtend.a11y.motion-contrast-policy.v1` fuer Reduced Motion und High Contrast an. Die Schicht erzeugt keine Runtime, sondern verpflichtet neue Artefakte auf Rolle, Namen, Fokus, Keyboard, ARIA, Screenreader, Reduced Motion und Kontrast.
+- `performance/` enthaelt ab `ER-WP-21` reine Performance-Profilplaene nach `xtend.performance.component-profile.v1`; sie erzeugen keine Runtime, sondern verpflichten neue Artefakte auf Budgetklasse, Lane, Hydration Policy, Messpunkte und lokale Gates.
+- `workflows/` enthaelt ab `WP-E03-08` lokale Dry-Run- und Verify-Contracts ohne Schreibzugriff.
+- `utils/` enthaelt nur seiteneffektarme Helfer; Schreibstrategien muessen dry-run-first bleiben.
+- `writing/` enthaelt ab `WP-E17-01` den zentralen WritePlan und Writer fuer kontrollierte Dateioperationen. Produktive Buildbefehle duerfen darueber schreiben, muessen aber weiterhin dry-run-first, reportbar und root-begrenzt bleiben.
+- `component-files --write` nutzt ab `WP-E17-02` das Sidecar `.xtend-build/scaffold-ownership.json` nach `xtend.scaffold.generated-ownership.v1`, damit generierte Dateien idempotent aktualisiert und unowned Dateien ohne `--force` blockiert werden.
+- `manifest-patcher.js` patcht ab `WP-E17-03` `components/manifest.json` als echtes JSON nach `xtend.scaffold.manifest-patcher.v1` und schreibt stabile Build Reports nach `.xtend-build/component-files/`.
+- `rmt-build` uebersetzt ab `WP-E17-04` RMT vNext Templates in Core JSON, XTend Custom Element, App-Modul, HTTP-Host, Browser-Smoke-Fixture und Scaffold Report.
+
+## Aktueller Stand
+
+Epic 03 ist abgeschlossen. `WP-E03-02` definiert Struktur und Entry Points. `WP-E03-03` definiert den Komponenten-Blueprint und Artefaktcontract. `WP-E03-04` definiert Generator-Registry, Template-Ladepfad, Eingabevalidierung und Plan-Ausgabe. `WP-E03-05` rendert daraus echte Pflichtartefakt-Inhalte im Dry-Run-Modus. `WP-E03-06` ergaenzt deterministisches Manifest-Wiring und den Hydration-Mindestcontract ohne externe Importquellen. `WP-E03-07` ergaenzt State-, API- und Feature-Wiring-Patterns nach Core-Contract. `WP-E03-08` standardisiert lokale Dry-Run-, Verify- und Reporting-Workflows. `WP-E03-09` standardisiert Typ-Artefakte und den vorbereiteten Template-/XTendRMT-Anschluss. `WP-E03-10` bindet Preview- und Referenzpfade an die lokale Reference-Suite an. `WP-E03-11` bereitet Templating-, Rendering- und Root-Lifecycle-Extension-Punkte als Dry-Run-Contract vor. `WP-E03-12` nimmt den Epic gegen KPI, Testpflicht und Erweiterbarkeit final ab. Epic 04 / `WP-E04-08` fuehrt den dedizierten `rmt-compatibility` Gate fuer RMT-kompatible Scaffold-Artefakte ein. `ER-WP-21` erweitert die Scaffold-Ausgaben um Performance-Profilpflichten nach `xtend.performance.component-profile.v1`; `ER-WP-23` erweitert sie um A11y-Profilpflichten nach `xtend.a11y.profile.v1`; `ER-WP-25` fuegt Screenreader-Signal-Contracts nach `xtend.a11y.screenreader-signals.v1` hinzu; `ER-WP-26` fuegt Motion-/Contrast-Policies nach `xtend.a11y.motion-contrast-policy.v1` hinzu.

package/xtend-builder/a11y/README.md

@@ -0,0 +1,42 @@
+# XTend Scaffold A11y
+
+Status: implemented by ER-WP-23, extended by ER-WP-25 and ER-WP-26
+
+## Zweck
+
+`xtend-builder/a11y/` enthaelt den A11y-Profilplan fuer neue Scaffold-Komponenten. Der Plan uebersetzt den A11y Component Contract `xtend.a11y.component-contract.v1` in konkrete Dry-Run-Artefakte.
+
+Ab ER-WP-25 haengt das Profil zusätzlich den Screenreader-Signal-Contract an. Neue Komponenten deklarieren damit nicht nur Rolle, Namen und Keyboard-Pflichten, sondern auch maschinenlesbare Live-Region-, Status- und Error-Signale fuer Fabric/RMT-A11y-Lanes.
+
+Ab ER-WP-26 haengt das Profil zudem `xtend.a11y.motion-contrast-policy.v1` an. Neue Komponenten erhalten damit pruefbare Regeln fuer `prefers-reduced-motion`, `forced-colors`, Fokus, Theme Tokens und Nicht-Farbstatus.
+
+## Contract IDs
+
+- Component Contract: `xtend.a11y.component-contract.v1`
+- Profil: `xtend.a11y.profile.v1`
+- Screenreader Signals: `xtend.a11y.screenreader-signals.v1`
+- Screenreader Signal Record: `xtend.a11y.screenreader-signal.v1`
+- Motion/Contrast Policy: `xtend.a11y.motion-contrast-policy.v1`
+- Motion Policy: `xtend.a11y.motion-policy.v1`
+- Contrast Policy: `xtend.a11y.contrast-policy.v1`
+- Test Contract: `xtend.a11y.test-contract.v1`
+- Scaffold Plan: `xtend.scaffold.a11y-profile-plan.v1`
+
+## Artefaktwirkung
+
+- Source: statischer Getter `xtendScaffoldA11yProfile`
+- Docs: Abschnitte `A11y-Profil`, `Screenreader-Signale` und `Motion-und-Contrast-Policy`
+- Fixture: `aria-label` und Hydration-Ergebnis fuer Rolle, Name, Profil, Screenreader-Signale und Motion/Contrast
+- Tests: Assertions fuer A11y-Profil, Rolle, Name, Screenreader-Signale, Motion/Contrast und A11y-Hydration-Gate
+- Manifest: `a11yProfile`, `screenreaderSignals` und `motionContrastPolicy`
+- Types: `X<Component>A11yProfile`, `X<Component>ScreenreaderSignalContract` und `X<Component>MotionContrastPolicy`
+
+## Gates
+
+```bash
+node scripts/run_xtend_tests.js components
+node scripts/run_xtend_tests.js a11y-hydration
+node scripts/run_xtend_tests.js screenreader-signals
+node scripts/run_xtend_tests.js motion-contrast
+node scripts/run_xtend_tests.js references
+```

package/xtend-builder/a11y/component-a11y-profile.d.ts

@@ -0,0 +1,14 @@
+import type { XtendBuilderComponentInput, XtendBuilderRecord } from '../builder-public-types';
+
+export declare const A11Y_COMPONENT_CONTRACT_SCHEMA: string;
+export declare const A11Y_PROFILE_SCHEMA: string;
+export declare const A11Y_MOTION_CONTRAST_POLICY_SCHEMA: string;
+export declare const A11Y_MOTION_POLICY_SCHEMA: string;
+export declare const A11Y_CONTRAST_POLICY_SCHEMA: string;
+export declare const A11Y_MOTION_CONTRAST_TEST_SCHEMA: string;
+export declare const A11Y_SCREENREADER_SIGNALS_SCHEMA: string;
+export declare const A11Y_SCREENREADER_SIGNAL_RECORD_SCHEMA: string;
+export declare const A11Y_TEST_CONTRACT_SCHEMA: string;
+export declare const PROFILE_A11Y_RULES: XtendBuilderRecord;
+export declare const SCAFFOLD_A11Y_PROFILE_PLAN_SCHEMA: string;
+export declare function createComponentA11yProfile(input?: XtendBuilderComponentInput, options?: XtendBuilderRecord): XtendBuilderRecord;