@ccslabs/xtend 0.1.0-rc.1

package/catalog/component-long-tail-migration.js

@@ -0,0 +1,305 @@
+const {
+  createComponentCatalogCoverageReport
+} = require('./component-catalog-coverage');
+const {
+  createComponentRegressionPriorityPlan
+} = require('./component-regression-priority');
+
+const COMPONENT_LONG_TAIL_MIGRATION_SCHEMA = 'xtend.epic11.legacy-long-tail-migration.v1';
+const COMPONENT_LONG_TAIL_MIGRATION_ENTRY_SCHEMA = 'xtend.epic11.legacy-long-tail-migration-entry.v1';
+const COMPONENT_LONG_TAIL_MIGRATION_GATE_SCHEMA = 'xtend.epic11.legacy-long-tail-migration-gate.v1';
+
+const KERNEL_BOUNDARY = 'no-rmt-kernel-import-of-xtend-types';
+
+const WAVE_DEFINITIONS = Object.freeze({
+  'wave-1-p0-routing-interaction': {
+    label: 'P0 routing and interaction closure',
+    goal: 'P0 controls reach ux-stable without broad runtime rewrites.',
+    components: ['x-tabs']
+  },
+  'wave-2-p1-theme-and-interaction': {
+    label: 'P1 theme and interaction hardening',
+    goal: 'P1 interactive and theme primitives receive explicit A11y and performance profiles.',
+    components: ['x-theme', 'x-button', 'x-menu']
+  },
+  'wave-3-infrastructure-and-utility-probes': {
+    label: 'Infrastructure and utility boundary probes',
+    goal: 'Non-visual helper surfaces get suites, types and adapter-boundary probes instead of forced visual shells.',
+    components: ['xstate', 'x-utils']
+  }
+});
+
+const REQUIRED_SOURCE_GATES = Object.freeze([
+  'catalog-coverage',
+  'regression-priority',
+  'component-ux-authoring-docs',
+  'component-ux-browser-smokes',
+  'component-shell-theme-matrix',
+  'references'
+]);
+
+function unique(values) {
+  return Array.from(new Set((values || []).filter(Boolean)));
+}
+
+function sortMigrationEntries(entries) {
+  const waveOrder = Object.keys(WAVE_DEFINITIONS);
+  const priorityOrder = { P0: 0, P1: 1, P2: 2 };
+  return entries.slice().sort((left, right) => {
+    const waveDiff = waveOrder.indexOf(left.wave) - waveOrder.indexOf(right.wave);
+    if (waveDiff !== 0) return waveDiff;
+    const priorityDiff = (priorityOrder[left.priority] || 99) - (priorityOrder[right.priority] || 99);
+    if (priorityDiff !== 0) return priorityDiff;
+    return left.tag.localeCompare(right.tag);
+  });
+}
+
+function resolveWave(tag) {
+  return Object.entries(WAVE_DEFINITIONS).find(([, definition]) => definition.components.includes(tag))?.[0]
+    || 'wave-3-infrastructure-and-utility-probes';
+}
+
+function resolveMissingDimensions(coverage) {
+  return Object.entries(coverage || {})
+    .filter(([, covered]) => covered !== true)
+    .map(([dimension]) => dimension);
+}
+
+function resolveTargetMaturity(entry) {
+  if ((entry.profiles || []).includes('infrastructure') || (entry.profiles || []).includes('utility')) {
+    return 'ux-baseline-probe';
+  }
+  if (entry.priority === 'P0') return 'ux-stable';
+  if (entry.priority === 'P1') return 'ux-ready';
+  return entry.customElement === false ? 'ux-baseline-probe' : 'ux-ready';
+}
+
+function resolveMigrationKind(entry, missingDimensions) {
+  if (entry.customElement === false) {
+    return 'adapter-boundary-probe';
+  }
+  if (missingDimensions.length === 1 && missingDimensions.includes('performance')) {
+    return 'profile-completion';
+  }
+  return 'component-hardening';
+}
+
+function resolveRequiredActions(entry, missingDimensions) {
+  const actions = [];
+  if (missingDimensions.includes('componentSuite')) actions.push('component-suite-authoring');
+  if (missingDimensions.includes('fixture')) actions.push('fixture-authoring');
+  if (missingDimensions.includes('types')) actions.push('public-types-authoring');
+  if (missingDimensions.includes('a11y')) actions.push('runtime-a11y-profile');
+  if (missingDimensions.includes('performance')) actions.push('performance-profile');
+  if (entry.customElement === false) actions.push('non-custom-element-integration-probe');
+  if (entry.customElement === true) actions.push('browser-smoke-and-theme-matrix-coverage');
+  return unique(actions);
+}
+
+function resolveRequiredGates(entry, migrationKind) {
+  const gates = [
+    'node scripts/run_xtend_tests.js catalog-coverage --json',
+    'node scripts/run_xtend_tests.js regression-priority --json',
+    'node scripts/run_xtend_tests.js references --json'
+  ];
+  if (migrationKind !== 'adapter-boundary-probe') {
+    gates.push('node scripts/run_xtend_tests.js component-ux-browser-smokes --json');
+    gates.push('node scripts/run_xtend_tests.js component-shell-theme-matrix --json');
+  }
+  if (entry.priority === 'P0') {
+    gates.push('node scripts/run_xtend_tests.js browser --json');
+  }
+  return unique(gates);
+}
+
+function createMigrationEntry(catalogEntry, regressionEntry) {
+  const missingDimensions = resolveMissingDimensions(catalogEntry.coverage);
+  const wave = resolveWave(catalogEntry.tag);
+  const migrationKind = resolveMigrationKind(catalogEntry, missingDimensions);
+  return {
+    schema: COMPONENT_LONG_TAIL_MIGRATION_ENTRY_SCHEMA,
+    tag: catalogEntry.tag,
+    status: catalogEntry.status,
+    priority: catalogEntry.priority,
+    profiles: catalogEntry.profiles.slice(),
+    wave,
+    waveLabel: WAVE_DEFINITIONS[wave].label,
+    targetMaturity: resolveTargetMaturity(catalogEntry),
+    migrationKind,
+    customElement: catalogEntry.customElement,
+    missingDimensions,
+    requiredActions: resolveRequiredActions(catalogEntry, missingDimensions),
+    regressionTier: regressionEntry ? regressionEntry.tier : 'unclassified',
+    browserSmokes: regressionEntry ? regressionEntry.browserSmokes.slice() : [],
+    visualStates: regressionEntry ? regressionEntry.visualStates.slice() : [],
+    requiredGates: resolveRequiredGates(catalogEntry, migrationKind),
+    kernelBoundary: KERNEL_BOUNDARY
+  };
+}
+
+function summarizeMigrationEntries(entries) {
+  return entries.reduce((summary, entry) => {
+    summary.byWave[entry.wave] = (summary.byWave[entry.wave] || 0) + 1;
+    summary.byMigrationKind[entry.migrationKind] = (summary.byMigrationKind[entry.migrationKind] || 0) + 1;
+    summary.byTargetMaturity[entry.targetMaturity] = (summary.byTargetMaturity[entry.targetMaturity] || 0) + 1;
+    entry.missingDimensions.forEach((dimension) => {
+      summary.missingByDimension[dimension] = summary.missingByDimension[dimension] || [];
+      summary.missingByDimension[dimension].push(entry.tag);
+    });
+    if (entry.customElement) {
+      summary.customElementCount += 1;
+    } else {
+      summary.boundaryProbeCount += 1;
+    }
+    return summary;
+  }, {
+    componentCount: entries.length,
+    byWave: {},
+    byMigrationKind: {},
+    byTargetMaturity: {},
+    missingByDimension: {},
+    customElementCount: 0,
+    boundaryProbeCount: 0
+  });
+}
+
+function createComponentLongTailMigrationPlan(options = {}) {
+  const coverageReport = options.coverageReport || createComponentCatalogCoverageReport(options);
+  const regressionPlan = options.regressionPlan || createComponentRegressionPriorityPlan({
+    rootDir: options.rootDir,
+    coverageReport
+  });
+  const regressionByTag = new Map(regressionPlan.entries.map((entry) => [entry.tag, entry]));
+  const entries = sortMigrationEntries(
+    coverageReport.entries
+      .filter((entry) => entry.status !== 'enterprise-ready')
+      .map((entry) => createMigrationEntry(entry, regressionByTag.get(entry.tag)))
+  );
+  const waves = Object.entries(WAVE_DEFINITIONS).map(([id, definition]) => ({
+    id,
+    label: definition.label,
+    goal: definition.goal,
+    components: definition.components.slice()
+  }));
+
+  return {
+    schema: COMPONENT_LONG_TAIL_MIGRATION_SCHEMA,
+    entrySchema: COMPONENT_LONG_TAIL_MIGRATION_ENTRY_SCHEMA,
+    gateSchema: COMPONENT_LONG_TAIL_MIGRATION_GATE_SCHEMA,
+    generatedAt: options.generatedAt || 'static-local',
+    workpackage: 'WP-E11-17',
+    status: 'accepted-migration-plan',
+    sourceSchemas: [
+      coverageReport.schema,
+      regressionPlan.schema,
+      'xtend.epic11.component-ux-authoring-docs.v1',
+      'xtend.epic11.component-ux-browser-smokes.v1',
+      'xtend.epic11.component-shell-theme-matrix.v1'
+    ],
+    strategy: 'incremental-no-big-bang',
+    kernelBoundary: KERNEL_BOUNDARY,
+    gates: {
+      local: 'node scripts/run_xtend_tests.js component-long-tail-migration --json',
+      packageScript: 'npm run test:component-long-tail-migration',
+      source: REQUIRED_SOURCE_GATES.slice()
+    },
+    waves,
+    entries,
+    summary: summarizeMigrationEntries(entries),
+    handoff: {
+      nextWorkpackage: 'WP-E11-18',
+      nextTitle: 'Epic-11-Abschlussreview und Enterprise UX Handoff',
+      releaseReadinessGate: 'npm test'
+    }
+  };
+}
+
+function validateComponentLongTailMigrationPlan(plan) {
+  const errors = [];
+  if (!plan || plan.schema !== COMPONENT_LONG_TAIL_MIGRATION_SCHEMA) {
+    errors.push('plan schema must be xtend.epic11.legacy-long-tail-migration.v1');
+  }
+  if (!plan || plan.entrySchema !== COMPONENT_LONG_TAIL_MIGRATION_ENTRY_SCHEMA) {
+    errors.push('entry schema must be xtend.epic11.legacy-long-tail-migration-entry.v1');
+  }
+  if (!plan || !Array.isArray(plan.entries) || plan.entries.length === 0) {
+    errors.push('plan entries must be a non-empty array');
+  }
+  if (!plan || plan.strategy !== 'incremental-no-big-bang') {
+    errors.push('migration strategy must avoid a big-bang rewrite');
+  }
+  if (!plan || plan.kernelBoundary !== KERNEL_BOUNDARY) {
+    errors.push('RMT kernel boundary must stay visible');
+  }
+
+  (plan && plan.entries || []).forEach((entry) => {
+    if (entry.schema !== COMPONENT_LONG_TAIL_MIGRATION_ENTRY_SCHEMA) {
+      errors.push(`${entry.tag || '<unknown>'}: entry schema must match`);
+    }
+    if (!entry.tag || entry.status === 'enterprise-ready') {
+      errors.push(`${entry.tag || '<unknown>'}: only non-enterprise-ready entries are part of the long-tail plan`);
+    }
+    if (!Array.isArray(entry.missingDimensions) || entry.missingDimensions.length === 0) {
+      errors.push(`${entry.tag}: missing dimensions must be explicit`);
+    }
+    if (!Array.isArray(entry.requiredActions) || entry.requiredActions.length === 0) {
+      errors.push(`${entry.tag}: required actions must be explicit`);
+    }
+    if (!Array.isArray(entry.requiredGates) || !entry.requiredGates.some((gate) => gate.includes('catalog-coverage'))) {
+      errors.push(`${entry.tag}: catalog-coverage gate must remain required`);
+    }
+    if (entry.customElement === false && !entry.requiredActions.includes('non-custom-element-integration-probe')) {
+      errors.push(`${entry.tag}: non-custom elements require an integration probe`);
+    }
+    if (entry.priority === 'P0' && entry.targetMaturity !== 'ux-stable') {
+      errors.push(`${entry.tag}: P0 long-tail entries must target ux-stable`);
+    }
+  });
+
+  return {
+    schema: COMPONENT_LONG_TAIL_MIGRATION_GATE_SCHEMA,
+    ok: errors.length === 0,
+    errors
+  };
+}
+
+function createMarkdownMatrix(plan) {
+  const rows = [
+    '| Tag | Wave | Current | Target | Missing | Actions |',
+    '|-----|------|---------|--------|---------|---------|'
+  ];
+  plan.entries.forEach((entry) => {
+    rows.push([
+      `| \`${entry.tag}\``,
+      `\`${entry.wave}\``,
+      `\`${entry.status}\``,
+      `\`${entry.targetMaturity}\``,
+      `\`${entry.missingDimensions.join(', ')}\``,
+      `\`${entry.requiredActions.join(', ')}\` |`
+    ].join(' | '));
+  });
+  return rows.join('\n');
+}
+
+function createComponentLongTailMigrationGate(options = {}) {
+  const plan = createComponentLongTailMigrationPlan(options);
+  const validation = validateComponentLongTailMigrationPlan(plan);
+  return {
+    schema: COMPONENT_LONG_TAIL_MIGRATION_GATE_SCHEMA,
+    ok: validation.ok,
+    plan,
+    errors: validation.errors,
+    warnings: []
+  };
+}
+
+module.exports = {
+  COMPONENT_LONG_TAIL_MIGRATION_SCHEMA,
+  COMPONENT_LONG_TAIL_MIGRATION_ENTRY_SCHEMA,
+  COMPONENT_LONG_TAIL_MIGRATION_GATE_SCHEMA,
+  KERNEL_BOUNDARY,
+  createComponentLongTailMigrationGate,
+  createComponentLongTailMigrationPlan,
+  createMarkdownMatrix,
+  validateComponentLongTailMigrationPlan
+};

package/catalog/component-regression-priority.d.ts

@@ -0,0 +1,20 @@
+import type {
+  XtendCatalogConstant,
+  XtendCatalogGate,
+  XtendCatalogOptions,
+  XtendCatalogPlan,
+  XtendCatalogRecord,
+  XtendCatalogReport
+} from './catalog-public-types';
+
+
+export declare const COMPONENT_REGRESSION_PRIORITY_ENTRY_SCHEMA: string;
+export declare const COMPONENT_REGRESSION_PRIORITY_GATE_SCHEMA: string;
+export declare const COMPONENT_REGRESSION_PRIORITY_SCHEMA: string;
+export declare const CORE_THEME_VARIANTS: readonly XtendCatalogConstant[] | XtendCatalogConstant;
+export declare const CORE_VIEWPORTS: readonly XtendCatalogConstant[] | XtendCatalogConstant;
+export declare const PROFILE_BROWSER_SMOKES: readonly XtendCatalogConstant[] | XtendCatalogConstant;
+export declare const PROFILE_VISUAL_STATES: readonly XtendCatalogConstant[] | XtendCatalogConstant;
+export declare function createComponentRegressionPriorityGate(options?: XtendCatalogOptions): XtendCatalogGate;
+export declare function createComponentRegressionPriorityPlan(options?: XtendCatalogOptions): XtendCatalogPlan;
+export declare function validateComponentRegressionPriorityPlan(plan?: unknown): XtendCatalogReport;

package/catalog/component-regression-priority.js

@@ -0,0 +1,305 @@
+const {
+  createComponentCatalogCoverageReport
+} = require('./component-catalog-coverage');
+const {
+  createComponentPerformanceProfile
+} = require('../xtend-builder/performance/component-performance-profile');
+
+const COMPONENT_REGRESSION_PRIORITY_SCHEMA = 'xtend.catalog.component-regression-priority-plan.v1';
+const COMPONENT_REGRESSION_PRIORITY_ENTRY_SCHEMA = 'xtend.catalog.component-regression-priority-entry.v1';
+const COMPONENT_REGRESSION_PRIORITY_GATE_SCHEMA = 'xtend.catalog.component-regression-priority-gate.v1';
+
+const CORE_VIEWPORTS = Object.freeze([
+  'desktop-1280',
+  'mobile-390'
+]);
+
+const CORE_THEME_VARIANTS = Object.freeze([
+  'light',
+  'dark',
+  'forced-colors',
+  'reduced-motion'
+]);
+
+const PROFILE_BROWSER_SMOKES = Object.freeze({
+  routing: ['route-change', 'keyboard-navigation', 'history-state', 'rmt-route-adapter'],
+  form: ['input-sync', 'validation-feedback', 'keyboard-entry', 'form-associated-submit'],
+  overlay: ['focus-trap', 'escape-close', 'scroll-lock', 'focus-restore'],
+  feedback: ['live-region', 'dismiss-timer', 'reduced-motion'],
+  interactive: ['keyboard-activation', 'focus-visible', 'mobile-tap'],
+  media: ['media-controls', 'poster-load', 'fullscreen-toggle'],
+  theme: ['theme-switch', 'token-contrast', 'forced-colors'],
+  stateful: ['state-sync', 'derived-render-cache'],
+  display: ['layout-stability', 'responsive-overflow'],
+  iconography: ['layout-stability', 'theme-token-color'],
+  infrastructure: ['state-api-integration'],
+  utility: ['utility-integration-probe']
+});
+
+const PROFILE_VISUAL_STATES = Object.freeze({
+  routing: ['initial-route', 'active-route', 'rmt-scheduled-route'],
+  form: ['default', 'focus', 'invalid', 'disabled'],
+  overlay: ['closed', 'open', 'focus-trapped', 'reduced-motion-open'],
+  feedback: ['info', 'warning', 'error', 'dismissed'],
+  interactive: ['default', 'hover', 'focus-visible', 'active', 'disabled'],
+  media: ['poster', 'playing', 'controls-focus'],
+  theme: ['light-theme', 'dark-theme', 'forced-colors'],
+  stateful: ['initial-state', 'state-updated'],
+  display: ['default-layout', 'narrow-layout'],
+  iconography: ['default-layout', 'high-contrast-currentColor'],
+  infrastructure: ['api-ready'],
+  utility: ['helper-ready']
+});
+
+const WAVE_LABELS = Object.freeze({
+  1: 'P0 browser-critical regression baseline',
+  2: 'P1 visual and performance baseline',
+  3: 'P2 long-tail suite and fixture completion',
+  4: 'visual snapshot automation handoff'
+});
+
+function unique(values) {
+  return Array.from(new Set((values || []).filter(Boolean)));
+}
+
+function sortEntriesByPriority(entries) {
+  const priorityOrder = { P0: 0, P1: 1, P2: 2 };
+  return entries.slice().sort((left, right) => {
+    const priorityDiff = (priorityOrder[left.priority] || 99) - (priorityOrder[right.priority] || 99);
+    if (priorityDiff !== 0) return priorityDiff;
+    return left.tag.localeCompare(right.tag);
+  });
+}
+
+function resolveTier(entry) {
+  if (entry.priority === 'P0') return 'p0-browser-critical';
+  if (entry.priority === 'P1' || entry.status === 'typed-contract-gated') return 'p1-visual-performance';
+  return 'p2-long-tail';
+}
+
+function resolveWave(entry) {
+  if (entry.priority === 'P0') return 1;
+  if (entry.priority === 'P1') return 2;
+  if (!entry.coverage.componentSuite || !entry.coverage.fixture || !entry.coverage.types) return 3;
+  return 4;
+}
+
+function collectByProfiles(profiles, source) {
+  return unique(profiles.flatMap((profile) => source[profile] || []));
+}
+
+function resolveRemediation(entry) {
+  const remediation = [];
+  if (!entry.coverage.componentSuite || !entry.coverage.fixture) {
+    remediation.push('long-tail-component-suite-and-fixture');
+  }
+  if (!entry.coverage.types) {
+    remediation.push('public-types-long-tail');
+  }
+  if (!entry.coverage.a11y) {
+    remediation.push('a11y-profile-remediation');
+  }
+  if (!entry.coverage.performance) {
+    remediation.push('performance-profile-authoring');
+  }
+  if (entry.customElement === false) {
+    remediation.push('non-custom-element-integration-probe');
+  }
+  return remediation;
+}
+
+function createRegressionPriorityEntry(entry) {
+  const profiles = entry.profiles || ['display'];
+  const performanceProfile = createComponentPerformanceProfile({
+    tag: entry.tag,
+    name: entry.tag.replace(/^x-/, ''),
+    profiles
+  });
+  const tier = resolveTier(entry);
+  const wave = resolveWave(entry);
+  const browserSmokes = collectByProfiles(profiles, PROFILE_BROWSER_SMOKES);
+  const visualStates = collectByProfiles(profiles, PROFILE_VISUAL_STATES);
+
+  return {
+    schema: COMPONENT_REGRESSION_PRIORITY_ENTRY_SCHEMA,
+    tag: entry.tag,
+    catalogStatus: entry.status,
+    priority: entry.priority,
+    profiles,
+    tier,
+    wave,
+    waveLabel: WAVE_LABELS[wave],
+    customElement: entry.customElement,
+    viewports: CORE_VIEWPORTS.slice(),
+    themeVariants: CORE_THEME_VARIANTS.slice(),
+    browserSmokes,
+    visualStates,
+    performanceProfile: {
+      schema: performanceProfile.schema,
+      budgetClass: performanceProfile.budgetClass,
+      lane: performanceProfile.lane,
+      hydrationPolicy: performanceProfile.hydrationPolicy,
+      primaryProfile: performanceProfile.primaryProfile,
+      criticalMeasurements: performanceProfile.criticalMeasurements
+    },
+    remediation: resolveRemediation(entry),
+    requiredGates: [
+      'node scripts/run_xtend_tests.js browser --json',
+      'node scripts/run_xtend_tests.js performance-regression --json',
+      'node scripts/run_xtend_tests.js catalog-coverage --json',
+      'node scripts/run_xtend_tests.js references --json'
+    ],
+    nextAction: wave === 1
+      ? 'ER-WP-36: CI Gate fuer browserkritische Regression produktisieren'
+      : 'ER-WP-36/ER-WP-38: Regression in CI und Release Checklist staffeln'
+  };
+}
+
+function summarizeRegressionPriorityEntries(entries) {
+  return entries.reduce((summary, entry) => {
+    summary.byTier[entry.tier] = (summary.byTier[entry.tier] || 0) + 1;
+    summary.byWave[String(entry.wave)] = (summary.byWave[String(entry.wave)] || 0) + 1;
+    if (entry.remediation.includes('performance-profile-authoring')) {
+      summary.requiresPerformanceProfile += 1;
+    }
+    if (entry.remediation.includes('a11y-profile-remediation')) {
+      summary.requiresA11yRemediation += 1;
+    }
+    if (entry.remediation.includes('long-tail-component-suite-and-fixture')) {
+      summary.requiresLongTailSuite += 1;
+    }
+    return summary;
+  }, {
+    componentCount: entries.length,
+    byTier: {},
+    byWave: {},
+    requiresPerformanceProfile: 0,
+    requiresA11yRemediation: 0,
+    requiresLongTailSuite: 0
+  });
+}
+
+function createComponentRegressionPriorityPlan(options = {}) {
+  const coverageReport = options.coverageReport || createComponentCatalogCoverageReport(options);
+  const entries = sortEntriesByPriority(coverageReport.entries).map(createRegressionPriorityEntry);
+
+  return {
+    schema: COMPONENT_REGRESSION_PRIORITY_SCHEMA,
+    generatedAt: options.generatedAt || 'static-local',
+    sourceCoverageSchema: coverageReport.schema,
+    entrySchema: COMPONENT_REGRESSION_PRIORITY_ENTRY_SCHEMA,
+    gateSchema: COMPONENT_REGRESSION_PRIORITY_GATE_SCHEMA,
+    workpackage: 'ER-WP-35',
+    scope: [
+      'visual-snapshots',
+      'browser-smokes',
+      'mobile-viewports',
+      'theme-variants',
+      'performance-profiles',
+      'long-tail-regression'
+    ],
+    viewports: CORE_VIEWPORTS.slice(),
+    themeVariants: CORE_THEME_VARIANTS.slice(),
+    waves: Object.assign({}, WAVE_LABELS),
+    entries,
+    summary: summarizeRegressionPriorityEntries(entries),
+    gates: {
+      local: 'node scripts/run_xtend_tests.js regression-priority --json',
+      packageScript: 'npm run test:regression-priority',
+      browser: 'node scripts/run_xtend_tests.js browser --json',
+      performance: 'node scripts/run_xtend_tests.js performance-regression --json',
+      references: 'node scripts/run_xtend_tests.js references --json'
+    },
+    handoff: {
+      ci: 'ER-WP-36',
+      releaseChecklist: 'ER-WP-38',
+      adoptionGuide: 'ER-WP-39'
+    }
+  };
+}
+
+function validateComponentRegressionPriorityPlan(plan) {
+  const errors = [];
+  if (!plan || plan.schema !== COMPONENT_REGRESSION_PRIORITY_SCHEMA) {
+    errors.push('plan schema must be xtend.catalog.component-regression-priority-plan.v1');
+  }
+  if (!plan || !Array.isArray(plan.entries) || plan.entries.length === 0) {
+    errors.push('plan entries must be a non-empty array');
+  }
+
+  (plan && plan.entries || []).forEach((entry) => {
+    if (entry.schema !== COMPONENT_REGRESSION_PRIORITY_ENTRY_SCHEMA) {
+      errors.push(`${entry.tag || '<unknown>'}: entry schema must be xtend.catalog.component-regression-priority-entry.v1`);
+    }
+    if (!Array.isArray(entry.viewports) || !entry.viewports.includes('desktop-1280') || !entry.viewports.includes('mobile-390')) {
+      errors.push(`${entry.tag}: desktop and mobile viewport coverage must be planned`);
+    }
+    if (!Array.isArray(entry.themeVariants) || !entry.themeVariants.includes('light') || !entry.themeVariants.includes('dark')) {
+      errors.push(`${entry.tag}: light and dark theme variants must be planned`);
+    }
+    if (!entry.performanceProfile || entry.performanceProfile.schema !== 'xtend.performance.component-profile.v1') {
+      errors.push(`${entry.tag}: performance profile plan must be derived`);
+    }
+    if (entry.priority === 'P0' && entry.tier !== 'p0-browser-critical') {
+      errors.push(`${entry.tag}: P0 component must be browser-critical`);
+    }
+    if (entry.customElement !== false && (!Array.isArray(entry.visualStates) || entry.visualStates.length === 0)) {
+      errors.push(`${entry.tag}: custom element must define visual states`);
+    }
+  });
+
+  return {
+    schema: COMPONENT_REGRESSION_PRIORITY_GATE_SCHEMA,
+    ok: errors.length === 0,
+    errors
+  };
+}
+
+function createComponentRegressionPriorityGate(options = {}) {
+  const plan = createComponentRegressionPriorityPlan(options);
+  const validation = validateComponentRegressionPriorityPlan(plan);
+  const warnings = [];
+
+  if (plan.summary.requiresPerformanceProfile > 0) {
+    warnings.push({
+      dimension: 'performance',
+      count: plan.summary.requiresPerformanceProfile,
+      message: `${plan.summary.requiresPerformanceProfile} component performance profiles still need runtime/source authoring`
+    });
+  }
+  if (plan.summary.requiresA11yRemediation > 0) {
+    warnings.push({
+      dimension: 'a11y',
+      count: plan.summary.requiresA11yRemediation,
+      message: `${plan.summary.requiresA11yRemediation} components need A11y remediation before enterprise-ready classification`
+    });
+  }
+  if (plan.summary.requiresLongTailSuite > 0) {
+    warnings.push({
+      dimension: 'long-tail',
+      count: plan.summary.requiresLongTailSuite,
+      message: `${plan.summary.requiresLongTailSuite} long-tail components still need suite and fixture coverage`
+    });
+  }
+
+  return {
+    schema: COMPONENT_REGRESSION_PRIORITY_GATE_SCHEMA,
+    ok: validation.ok,
+    plan,
+    errors: validation.errors,
+    warnings
+  };
+}
+
+module.exports = {
+  COMPONENT_REGRESSION_PRIORITY_ENTRY_SCHEMA,
+  COMPONENT_REGRESSION_PRIORITY_GATE_SCHEMA,
+  COMPONENT_REGRESSION_PRIORITY_SCHEMA,
+  CORE_THEME_VARIANTS,
+  CORE_VIEWPORTS,
+  PROFILE_BROWSER_SMOKES,
+  PROFILE_VISUAL_STATES,
+  createComponentRegressionPriorityGate,
+  createComponentRegressionPriorityPlan,
+  validateComponentRegressionPriorityPlan
+};

package/catalog/enterprise-component-flex-release-handoff.d.ts

@@ -0,0 +1,32 @@
+import type {
+  XtendCatalogConstant,
+  XtendCatalogOptions,
+  XtendCatalogRecord,
+  XtendCatalogReport
+} from './catalog-public-types';
+
+export declare const ADOPTION_RISKS: readonly XtendCatalogRecord[];
+export declare const COMPATIBILITY_ALIASES: readonly XtendCatalogRecord[];
+export declare const CURRENT_VERSION: string;
+export declare const ENTERPRISE_COMPONENT_FLEX_RELEASE_HANDOFF_BACKLOG: string;
+export declare const ENTERPRISE_COMPONENT_FLEX_RELEASE_HANDOFF_DOC: string;
+export declare const ENTERPRISE_COMPONENT_FLEX_RELEASE_HANDOFF_LOCAL_GATE: string;
+export declare const ENTERPRISE_COMPONENT_FLEX_RELEASE_HANDOFF_MODULE: string;
+export declare const ENTERPRISE_COMPONENT_FLEX_RELEASE_HANDOFF_PACKAGE_SCRIPT: string;
+export declare const ENTERPRISE_COMPONENT_FLEX_RELEASE_HANDOFF_REPORT_SCHEMA: string;
+export declare const ENTERPRISE_COMPONENT_FLEX_RELEASE_HANDOFF_SCHEMA: string;
+export declare const ENTERPRISE_COMPONENT_FLEX_RELEASE_HANDOFF_STATUS: string;
+export declare const ENTERPRISE_COMPONENT_FLEX_RELEASE_HANDOFF_SUITE: string;
+export declare const ENTERPRISE_COMPONENT_FLEX_RELEASE_HANDOFF_TARGET: string;
+export declare const ENTERPRISE_COMPONENT_FLEX_RELEASE_HANDOFF_WORKPACKAGE: string;
+export declare const MIGRATION_SECTIONS: readonly XtendCatalogRecord[];
+export declare const PROPOSED_VERSION: string;
+export declare const PUBLISH_BOUNDARY: string;
+export declare const RELEASE_CHECKLIST: readonly XtendCatalogConstant[];
+export declare const RELEASE_GATES: readonly XtendCatalogConstant[];
+export declare const REQUIRED_WORKPACKAGES: readonly XtendCatalogConstant[];
+export declare const SEMVER_IMPACTS: readonly XtendCatalogRecord[];
+export declare const SOURCE_GATES: readonly XtendCatalogConstant[];
+export declare function createEnterpriseComponentFlexReleaseHandoff(options?: XtendCatalogOptions): XtendCatalogRecord;
+export declare function createEnterpriseComponentFlexReleaseHandoffReport(options?: XtendCatalogOptions): XtendCatalogReport;
+export declare function validateEnterpriseComponentFlexReleaseHandoff(handoff?: unknown): XtendCatalogReport;