@ccslabs/xtend 0.1.0-rc.1

package/catalog/epic13-docs-rmt-production-hardening.js

@@ -0,0 +1,286 @@
+const {
+  KERNEL_BOUNDARY
+} = require('./epic12-rc0-gate-matrix');
+const {
+  EPIC13_RMT_PRODUCTION_READINESS_REPORT_SCHEMA,
+  EPIC13_RMT_PRODUCTION_READINESS_SCHEMA,
+  createEpic13RmtProductionReadinessPlan,
+  createEpic13RmtProductionReadinessReport,
+  validateEpic13RmtProductionReadinessPlan
+} = require('./epic13-rmt-production-readiness');
+
+const EPIC13_DOCS_RMT_PRODUCTION_HARDENING_SCHEMA = 'xtend.epic13.docs-rmt-production-hardening.v1';
+const EPIC13_DOCS_RMT_PRODUCTION_HARDENING_REPORT_SCHEMA = 'xtend.epic13.docs-rmt-production-hardening-report.v1';
+const EPIC13_DOCS_RMT_PRODUCTION_HARDENING_WORKPACKAGE = 'WP-E13-10';
+const EPIC13_DOCS_RMT_PRODUCTION_HARDENING_STATUS = 'accepted-docs-rmt-production-hardening';
+const EPIC13_DOCS_RMT_PRODUCTION_HARDENING_TARGET = 'docs-rmt-parsedown-shell-prod-hardened';
+const EPIC13_DOCS_RMT_PRODUCTION_HARDENING_MODULE = 'catalog/epic13-docs-rmt-production-hardening.js';
+const EPIC13_DOCS_RMT_PRODUCTION_HARDENING_SUITE = 'tests/platform/epic13_docs_rmt_production_hardening_suite.js';
+const EPIC13_DOCS_RMT_PRODUCTION_HARDENING_STEERING = 'development/RC0-RC1-transfer-EPIC13.md';
+const EPIC13_DOCS_RMT_PRODUCTION_HARDENING_CONTRACT = 'development/XTend-Epic13-Docs-RMT-Production-Hardening-Contract.md';
+const EPIC13_DOCS_RMT_PRODUCTION_HARDENING_WORKPACKAGE_DOC = 'development/WP-E13-10-Docs-App-RMT-Parsedown-Shell-fuer-PROD-nahe-Erweiterungen-haerten.md';
+const EPIC13_DOCS_RMT_PRODUCTION_HARDENING_DOCS = 'docs/docs-rmt-production-hardening.md';
+const EPIC13_DOCS_RMT_PRODUCTION_HARDENING_LOCAL_GATE = 'node scripts/run_xtend_tests.js epic13-docs-rmt-production-hardening --json';
+const EPIC13_DOCS_RMT_PRODUCTION_HARDENING_PACKAGE_SCRIPT = 'npm run test:epic13-docs-rmt-production-hardening';
+const EPIC13_DOCS_RMT_PRODUCTION_HARDENING_REPORT_ARTIFACT = '.xtend-test-results/xtend-epic13-docs-rmt-production-hardening-report.json';
+const DOCS_RMT_PILOT_SCHEMA = 'xtend.docs.parsedown-rmt-pilot.v1';
+const DOCS_RMT_RENDER_SCHEMA = 'xtend.docs.parsedown-rmt-render.v1';
+const DOCS_RMT_DOCUMENT = 'docs/xtendrmt-parsedown-docs.rmt';
+const DOCS_RMT_HOST = 'docs/index.php';
+const DOCS_RMT_PAGE_LOADER = 'docs/utils/pageloader.js';
+const TRUST_BOUNDARY = 'xtend.security.sanitizing-boundary.v1';
+const PUBLISH_BOUNDARY = 'private-until-release-owner-acceptance';
+const NEXT_DECISION = 'rc1-gate-matrix-ci-handoff';
+const NEXT_WORKPACKAGE = 'WP-E13-13';
+
+const REQUIRED_DOCS_RMT_GATES = Object.freeze([
+  'npm run test:docs-rmt-pilot',
+  'npm run test:browser',
+  'npm run test:epic13-rmt-production-readiness'
+]);
+
+const REQUIRED_EXTENSION_SLOTS = Object.freeze([
+  {
+    id: 'docs.slot.content',
+    slot: 'content',
+    contentKind: 'parsedownHtml',
+    schedule: 'docs.markdown.parse',
+    endpoint: 'xtendrmt.docs.parsedown.parse',
+    adapter: 'docs.parsedown',
+    required: true,
+    trustBoundary: TRUST_BOUNDARY
+  },
+  {
+    id: 'docs.slot.sidebar',
+    slot: 'sidebar',
+    contentKind: 'appShellTools',
+    schedule: 'docs.shell.render',
+    endpoint: 'xtendrmt.shell.render',
+    adapter: 'docs.rich-content',
+    required: true,
+    trustBoundary: 'component-managed'
+  },
+  {
+    id: 'docs.slot.related',
+    slot: 'related',
+    contentKind: 'routeLinks',
+    schedule: 'docs.related.prepare',
+    endpoint: 'xtendrmt.docs.related.prepare',
+    adapter: 'docs.rich-content',
+    required: false,
+    trustBoundary: 'component-managed'
+  },
+  {
+    id: 'docs.slot.component-demo',
+    slot: 'component-demo',
+    contentKind: 'interactiveComponentDemo',
+    schedule: 'docs.demo.prepare',
+    endpoint: 'xtendrmt.docs.demo.prepare',
+    adapter: 'xtend.component',
+    required: false,
+    trustBoundary: 'component-managed'
+  },
+  {
+    id: 'docs.slot.rich-content',
+    slot: 'rich-content',
+    contentKind: 'richHtml',
+    schedule: 'docs.rich-content.prepare',
+    endpoint: 'xtendrmt.docs.rich-content.prepare',
+    adapter: 'docs.rich-content',
+    required: false,
+    trustBoundary: TRUST_BOUNDARY
+  },
+  {
+    id: 'docs.slot.media',
+    slot: 'rich-content',
+    contentKind: 'xplayerTutorial',
+    schedule: 'docs.media.lazy',
+    endpoint: 'xtendrmt.docs.media.lazy',
+    adapter: 'docs.rich-content',
+    required: false,
+    trustBoundary: 'component-managed'
+  },
+  {
+    id: 'docs.slot.diagnostics',
+    slot: 'diagnostics',
+    contentKind: 'diagnostics',
+    schedule: 'docs.diagnostics.snapshot',
+    endpoint: 'xtendrmt.diagnostics.snapshot',
+    adapter: 'rmt.state-scheduler-diagnostics',
+    required: true,
+    trustBoundary: 'structured-diagnostics'
+  }
+]);
+
+const REQUIRED_DOCS_RMT_ARTIFACTS = Object.freeze([
+  DOCS_RMT_DOCUMENT,
+  DOCS_RMT_HOST,
+  DOCS_RMT_PAGE_LOADER,
+  'docs/xtendrmt-parsedown-scheduling.md',
+  'docs/trusted-dom-sanitizing.md',
+  'docs/rmt-production-readiness.md'
+]);
+
+function createEpic13DocsRmtProductionHardeningPlan(options = {}) {
+  const sourcePlan = options.sourcePlan || createEpic13RmtProductionReadinessPlan(options);
+  const sourceValidation = options.sourceValidation || validateEpic13RmtProductionReadinessPlan(sourcePlan);
+  const sourceReport = options.sourceReport || createEpic13RmtProductionReadinessReport({ ...options, plan: sourcePlan });
+  const extensionSlots = REQUIRED_EXTENSION_SLOTS.map((slot) => ({ ...slot }));
+
+  return {
+    schema: EPIC13_DOCS_RMT_PRODUCTION_HARDENING_SCHEMA,
+    reportSchema: EPIC13_DOCS_RMT_PRODUCTION_HARDENING_REPORT_SCHEMA,
+    workpackage: EPIC13_DOCS_RMT_PRODUCTION_HARDENING_WORKPACKAGE,
+    status: EPIC13_DOCS_RMT_PRODUCTION_HARDENING_STATUS,
+    generatedAt: options.generatedAt || 'static-local',
+    module: EPIC13_DOCS_RMT_PRODUCTION_HARDENING_MODULE,
+    suite: EPIC13_DOCS_RMT_PRODUCTION_HARDENING_SUITE,
+    steeringDocument: EPIC13_DOCS_RMT_PRODUCTION_HARDENING_STEERING,
+    contract: EPIC13_DOCS_RMT_PRODUCTION_HARDENING_CONTRACT,
+    workpackageDocument: EPIC13_DOCS_RMT_PRODUCTION_HARDENING_WORKPACKAGE_DOC,
+    docs: EPIC13_DOCS_RMT_PRODUCTION_HARDENING_DOCS,
+    localGate: EPIC13_DOCS_RMT_PRODUCTION_HARDENING_LOCAL_GATE,
+    packageScript: EPIC13_DOCS_RMT_PRODUCTION_HARDENING_PACKAGE_SCRIPT,
+    reportArtifact: EPIC13_DOCS_RMT_PRODUCTION_HARDENING_REPORT_ARTIFACT,
+    sourceSchema: EPIC13_RMT_PRODUCTION_READINESS_SCHEMA,
+    sourceReportSchema: EPIC13_RMT_PRODUCTION_READINESS_REPORT_SCHEMA,
+    sourceStatus: sourcePlan.status,
+    sourceValidationOk: sourceValidation.ok,
+    sourceReportOk: sourceReport.ok,
+    targetReadiness: EPIC13_DOCS_RMT_PRODUCTION_HARDENING_TARGET,
+    docsPilotSchema: DOCS_RMT_PILOT_SCHEMA,
+    docsRenderSchema: DOCS_RMT_RENDER_SCHEMA,
+    rmtDocument: DOCS_RMT_DOCUMENT,
+    activeHost: DOCS_RMT_HOST,
+    pageLoader: DOCS_RMT_PAGE_LOADER,
+    requiredGates: REQUIRED_DOCS_RMT_GATES.slice(),
+    artifactPaths: REQUIRED_DOCS_RMT_ARTIFACTS.slice(),
+    extensionSlots,
+    requiredSlotIds: extensionSlots.filter((slot) => slot.required).map((slot) => slot.id),
+    optionalSlotIds: extensionSlots.filter((slot) => !slot.required).map((slot) => slot.id),
+    productionHardening: {
+      shellFirst: true,
+      parsedownOrchestrated: true,
+      parsedownEmbeddedInRmtKernel: false,
+      richHtmlSchedulable: true,
+      xplayerTutorialSchedulable: true,
+      diagnosticsSnapshotRequired: true,
+      extensionSlotsStable: true,
+      hostBoundaryRequired: true,
+      pageLoaderRuntimeMetadataRequired: true
+    },
+    trustBoundary: TRUST_BOUNDARY,
+    kernelBoundary: KERNEL_BOUNDARY,
+    rmtKernelImportsParsedown: false,
+    rmtKernelImportsPhp: false,
+    rmtKernelImportsXtendTypes: false,
+    frameworkAgnostic: true,
+    localGateMode: 'static-docs-rmt-production-hardening',
+    externalBrowserRequiredInLocalGate: false,
+    externalNetworkAllowedInLocalGate: false,
+    nextDecision: NEXT_DECISION,
+    nextWorkpackage: NEXT_WORKPACKAGE,
+    publishBoundary: PUBLISH_BOUNDARY,
+    publishAllowed: false,
+    packagePrivateRequired: true
+  };
+}
+
+function validateEpic13DocsRmtProductionHardeningPlan(plan = createEpic13DocsRmtProductionHardeningPlan()) {
+  const errors = [];
+  const slots = plan && Array.isArray(plan.extensionSlots) ? plan.extensionSlots : [];
+
+  if (!plan || plan.schema !== EPIC13_DOCS_RMT_PRODUCTION_HARDENING_SCHEMA) errors.push(`schema must be ${EPIC13_DOCS_RMT_PRODUCTION_HARDENING_SCHEMA}`);
+  if (!plan || plan.reportSchema !== EPIC13_DOCS_RMT_PRODUCTION_HARDENING_REPORT_SCHEMA) errors.push(`reportSchema must be ${EPIC13_DOCS_RMT_PRODUCTION_HARDENING_REPORT_SCHEMA}`);
+  if (!plan || plan.workpackage !== EPIC13_DOCS_RMT_PRODUCTION_HARDENING_WORKPACKAGE) errors.push(`workpackage must be ${EPIC13_DOCS_RMT_PRODUCTION_HARDENING_WORKPACKAGE}`);
+  if (!plan || plan.status !== EPIC13_DOCS_RMT_PRODUCTION_HARDENING_STATUS) errors.push(`status must be ${EPIC13_DOCS_RMT_PRODUCTION_HARDENING_STATUS}`);
+  if (!plan || plan.sourceSchema !== EPIC13_RMT_PRODUCTION_READINESS_SCHEMA) errors.push('source schema must be RMT production readiness');
+  if (!plan || plan.sourceValidationOk !== true || plan.sourceReportOk !== true) errors.push('RMT production readiness source must validate');
+  if (!plan || plan.targetReadiness !== EPIC13_DOCS_RMT_PRODUCTION_HARDENING_TARGET) errors.push(`targetReadiness must be ${EPIC13_DOCS_RMT_PRODUCTION_HARDENING_TARGET}`);
+  REQUIRED_DOCS_RMT_GATES.forEach((gate) => {
+    if (!plan || !plan.requiredGates.includes(gate)) errors.push(`required gate missing: ${gate}`);
+  });
+  REQUIRED_DOCS_RMT_ARTIFACTS.forEach((artifactPath) => {
+    if (!plan || !plan.artifactPaths.includes(artifactPath)) errors.push(`artifact missing: ${artifactPath}`);
+  });
+  REQUIRED_EXTENSION_SLOTS.forEach((slot) => {
+    const actual = slots.find((entry) => entry.id === slot.id);
+    if (!actual) {
+      errors.push(`extension slot missing: ${slot.id}`);
+      return;
+    }
+    if (actual.schedule !== slot.schedule) errors.push(`extension slot ${slot.id} must use schedule ${slot.schedule}`);
+    if (actual.endpoint !== slot.endpoint) errors.push(`extension slot ${slot.id} must use endpoint ${slot.endpoint}`);
+    if (actual.adapter !== slot.adapter) errors.push(`extension slot ${slot.id} must use adapter ${slot.adapter}`);
+  });
+  if (!plan || !plan.productionHardening.shellFirst || !plan.productionHardening.parsedownOrchestrated) errors.push('Docs hardening must remain shell-first and Parsedown-orchestrated');
+  if (!plan || plan.productionHardening.parsedownEmbeddedInRmtKernel !== false) errors.push('Parsedown must not be embedded in the RMT kernel');
+  if (!plan || !plan.productionHardening.richHtmlSchedulable || !plan.productionHardening.xplayerTutorialSchedulable) errors.push('Rich HTML and XPlayer tutorial payloads must stay schedulable');
+  if (!plan || !plan.productionHardening.diagnosticsSnapshotRequired || !plan.productionHardening.extensionSlotsStable) errors.push('Diagnostics and extension slots must be stable');
+  if (!plan || plan.trustBoundary !== TRUST_BOUNDARY) errors.push(`trustBoundary must be ${TRUST_BOUNDARY}`);
+  if (!plan || plan.kernelBoundary !== KERNEL_BOUNDARY) errors.push(`kernelBoundary must be ${KERNEL_BOUNDARY}`);
+  if (!plan || plan.rmtKernelImportsParsedown !== false || plan.rmtKernelImportsPhp !== false || plan.rmtKernelImportsXtendTypes !== false) errors.push('RMT kernel must not import Parsedown, PHP or XTend types');
+  if (!plan || plan.frameworkAgnostic !== true) errors.push('Docs RMT hardening must remain framework agnostic');
+  if (!plan || plan.localGateMode !== 'static-docs-rmt-production-hardening') errors.push('local gate mode must remain static Docs RMT hardening');
+  if (!plan || plan.externalBrowserRequiredInLocalGate !== false || plan.externalNetworkAllowedInLocalGate !== false) errors.push('local gate must not require external browser or network');
+  if (!plan || plan.nextDecision !== NEXT_DECISION) errors.push(`next decision must be ${NEXT_DECISION}`);
+  if (!plan || plan.nextWorkpackage !== NEXT_WORKPACKAGE) errors.push(`next workpackage must be ${NEXT_WORKPACKAGE}`);
+  if (!plan || plan.publishBoundary !== PUBLISH_BOUNDARY) errors.push(`publishBoundary must be ${PUBLISH_BOUNDARY}`);
+  if (!plan || plan.publishAllowed !== false || plan.packagePrivateRequired !== true) errors.push('publish must remain blocked and package private');
+
+  return {
+    schema: EPIC13_DOCS_RMT_PRODUCTION_HARDENING_REPORT_SCHEMA,
+    ok: errors.length === 0,
+    errors
+  };
+}
+
+function createEpic13DocsRmtProductionHardeningReport(options = {}) {
+  const plan = options.plan || createEpic13DocsRmtProductionHardeningPlan(options);
+  const validation = validateEpic13DocsRmtProductionHardeningPlan(plan);
+
+  return {
+    schema: EPIC13_DOCS_RMT_PRODUCTION_HARDENING_REPORT_SCHEMA,
+    ok: validation.ok,
+    errors: validation.errors,
+    plan,
+    requiredGateCount: plan.requiredGates.length,
+    extensionSlotCount: plan.extensionSlots.length,
+    requiredSlotCount: plan.requiredSlotIds.length,
+    optionalSlotCount: plan.optionalSlotIds.length,
+    publishAllowed: plan.publishAllowed,
+    nextWorkpackage: plan.nextWorkpackage
+  };
+}
+
+module.exports = {
+  DOCS_RMT_DOCUMENT,
+  DOCS_RMT_HOST,
+  DOCS_RMT_PAGE_LOADER,
+  DOCS_RMT_PILOT_SCHEMA,
+  DOCS_RMT_RENDER_SCHEMA,
+  EPIC13_DOCS_RMT_PRODUCTION_HARDENING_CONTRACT,
+  EPIC13_DOCS_RMT_PRODUCTION_HARDENING_DOCS,
+  EPIC13_DOCS_RMT_PRODUCTION_HARDENING_LOCAL_GATE,
+  EPIC13_DOCS_RMT_PRODUCTION_HARDENING_MODULE,
+  EPIC13_DOCS_RMT_PRODUCTION_HARDENING_PACKAGE_SCRIPT,
+  EPIC13_DOCS_RMT_PRODUCTION_HARDENING_REPORT_ARTIFACT,
+  EPIC13_DOCS_RMT_PRODUCTION_HARDENING_REPORT_SCHEMA,
+  EPIC13_DOCS_RMT_PRODUCTION_HARDENING_SCHEMA,
+  EPIC13_DOCS_RMT_PRODUCTION_HARDENING_STATUS,
+  EPIC13_DOCS_RMT_PRODUCTION_HARDENING_STEERING,
+  EPIC13_DOCS_RMT_PRODUCTION_HARDENING_SUITE,
+  EPIC13_DOCS_RMT_PRODUCTION_HARDENING_TARGET,
+  EPIC13_DOCS_RMT_PRODUCTION_HARDENING_WORKPACKAGE,
+  EPIC13_DOCS_RMT_PRODUCTION_HARDENING_WORKPACKAGE_DOC,
+  NEXT_DECISION,
+  NEXT_WORKPACKAGE,
+  PUBLISH_BOUNDARY,
+  REQUIRED_DOCS_RMT_ARTIFACTS,
+  REQUIRED_DOCS_RMT_GATES,
+  REQUIRED_EXTENSION_SLOTS,
+  TRUST_BOUNDARY,
+  createEpic13DocsRmtProductionHardeningPlan,
+  createEpic13DocsRmtProductionHardeningReport,
+  validateEpic13DocsRmtProductionHardeningPlan
+};

package/catalog/epic13-hydration-performance-closure.d.ts

@@ -0,0 +1,33 @@
+import type {
+  XtendCatalogConstant,
+  XtendCatalogGate,
+  XtendCatalogOptions,
+  XtendCatalogPlan,
+  XtendCatalogRecord,
+  XtendCatalogReport
+} from './catalog-public-types';
+
+
+export declare const EPIC13_HYDRATION_PERFORMANCE_CLOSURE_CONTRACT: string;
+export declare const EPIC13_HYDRATION_PERFORMANCE_CLOSURE_DOCS: readonly XtendCatalogConstant[] | XtendCatalogConstant;
+export declare const EPIC13_HYDRATION_PERFORMANCE_CLOSURE_LOCAL_GATE: string;
+export declare const EPIC13_HYDRATION_PERFORMANCE_CLOSURE_MODULE: string;
+export declare const EPIC13_HYDRATION_PERFORMANCE_CLOSURE_PACKAGE_SCRIPT: string;
+export declare const EPIC13_HYDRATION_PERFORMANCE_CLOSURE_REPORT_SCHEMA: string;
+export declare const EPIC13_HYDRATION_PERFORMANCE_CLOSURE_SCHEMA: string;
+export declare const EPIC13_HYDRATION_PERFORMANCE_CLOSURE_STATUS: string;
+export declare const EPIC13_HYDRATION_PERFORMANCE_CLOSURE_STEERING: XtendCatalogConstant;
+export declare const EPIC13_HYDRATION_PERFORMANCE_CLOSURE_SUITE: string;
+export declare const EPIC13_HYDRATION_PERFORMANCE_CLOSURE_TARGET: string;
+export declare const EPIC13_HYDRATION_PERFORMANCE_CLOSURE_WORKPACKAGE: string;
+export declare const EPIC13_HYDRATION_PERFORMANCE_CLOSURE_WORKPACKAGE_DOC: XtendCatalogConstant;
+export declare const EPIC13_HYDRATION_PERFORMANCE_DECISION_SCHEMA: string;
+export declare const HYDRATION_BASELINE: XtendCatalogConstant;
+export declare const HYDRATION_MEASURE: XtendCatalogConstant;
+export declare const PUBLISH_BOUNDARY: XtendCatalogConstant;
+export declare const REQUIRED_DOCS: readonly XtendCatalogConstant[] | XtendCatalogConstant;
+export declare const REQUIRED_SOURCE_GATES: readonly XtendCatalogConstant[] | XtendCatalogConstant;
+export declare function createEpic13HydrationPerformanceClosurePlan(options?: XtendCatalogOptions): XtendCatalogPlan;
+export declare function createEpic13HydrationPerformanceClosureReport(options?: XtendCatalogOptions): XtendCatalogReport;
+export declare function createHydrationDecision(options?: XtendCatalogOptions): XtendCatalogRecord;
+export declare function validateEpic13HydrationPerformanceClosurePlan(plan?: unknown): XtendCatalogReport;

package/catalog/epic13-hydration-performance-closure.js

@@ -0,0 +1,234 @@
+const {
+  PERFORMANCE_BUDGET_MS_BY_MEASURE
+} = require('../fabric/xtend-fabric');
+const {
+  KERNEL_BOUNDARY
+} = require('./epic12-rc0-gate-matrix');
+const {
+  EPIC13_KNOWN_RESIDUAL_TRIAGE_REPORT_SCHEMA,
+  EPIC13_KNOWN_RESIDUAL_TRIAGE_SCHEMA,
+  createEpic13KnownResidualTriagePlan,
+  createEpic13KnownResidualTriageReport,
+  validateEpic13KnownResidualTriagePlan
+} = require('./epic13-known-residual-triage');
+
+const EPIC13_HYDRATION_PERFORMANCE_CLOSURE_SCHEMA = 'xtend.epic13.hydration-performance-closure.v1';
+const EPIC13_HYDRATION_PERFORMANCE_DECISION_SCHEMA = 'xtend.epic13.hydration-performance-decision.v1';
+const EPIC13_HYDRATION_PERFORMANCE_CLOSURE_REPORT_SCHEMA = 'xtend.epic13.hydration-performance-closure-report.v1';
+const EPIC13_HYDRATION_PERFORMANCE_CLOSURE_WORKPACKAGE = 'WP-E13-06';
+const EPIC13_HYDRATION_PERFORMANCE_CLOSURE_STATUS = 'accepted-hydration-performance-closure';
+const EPIC13_HYDRATION_PERFORMANCE_CLOSURE_TARGET = 'hydration-performance-warning-closed';
+const EPIC13_HYDRATION_PERFORMANCE_CLOSURE_MODULE = 'catalog/epic13-hydration-performance-closure.js';
+const EPIC13_HYDRATION_PERFORMANCE_CLOSURE_SUITE = 'tests/platform/epic13_hydration_performance_closure_suite.js';
+const EPIC13_HYDRATION_PERFORMANCE_CLOSURE_STEERING = 'development/RC0-RC1-transfer-EPIC13.md';
+const EPIC13_HYDRATION_PERFORMANCE_CLOSURE_CONTRACT = 'development/XTend-Epic13-Hydration-Performance-Closure-Contract.md';
+const EPIC13_HYDRATION_PERFORMANCE_CLOSURE_WORKPACKAGE_DOC = 'development/WP-E13-06-Hydration-Performance-Warning-schliessen.md';
+const EPIC13_HYDRATION_PERFORMANCE_CLOSURE_DOCS = 'docs/hydration-performance-closure.md';
+const EPIC13_HYDRATION_PERFORMANCE_CLOSURE_LOCAL_GATE = 'node scripts/run_xtend_tests.js epic13-hydration-performance-closure --json';
+const EPIC13_HYDRATION_PERFORMANCE_CLOSURE_PACKAGE_SCRIPT = 'npm run test:epic13-hydration-performance-closure';
+const PUBLISH_BOUNDARY = 'private-until-release-owner-acceptance';
+const HYDRATION_MEASURE = 'xtend.component.hydrate';
+const HYDRATION_BASELINE = 'tests/performance/baselines/local-performance-baseline.json';
+
+const REQUIRED_SOURCE_GATES = Object.freeze([
+  'npm run test:performance',
+  'npm run test:hydration-policy',
+  'npm run test:fabric-performance',
+  'npm run test:epic13-known-residual-triage'
+]);
+
+const REQUIRED_DOCS = Object.freeze([
+  EPIC13_HYDRATION_PERFORMANCE_CLOSURE_STEERING,
+  EPIC13_HYDRATION_PERFORMANCE_CLOSURE_CONTRACT,
+  EPIC13_HYDRATION_PERFORMANCE_CLOSURE_WORKPACKAGE_DOC,
+  EPIC13_HYDRATION_PERFORMANCE_CLOSURE_DOCS,
+  'development/XTend-Epic13-Known-Residual-Triage-Contract.md',
+  'development/XTend-Performance-Regression-Gate.md',
+  'development/XTend-Hydration-Policy-Contract.md',
+  'development/XTend-Performance-Budget-Matrix.md',
+  'docs/known-residual-triage.md',
+  'docs/performance-regression.md',
+  'docs/hydration-policies.md',
+  'docs/xtend-fabric.md',
+  'docs/enterprise-adoption.md'
+]);
+
+function clone(value) {
+  return JSON.parse(JSON.stringify(value));
+}
+
+function createHydrationDecision(options = {}) {
+  const budgetMs = PERFORMANCE_BUDGET_MS_BY_MEASURE[HYDRATION_MEASURE];
+  const durationMs = Number.isFinite(Number(options.durationMs)) ? Number(options.durationMs) : 31;
+  const previousDurationMs = Number.isFinite(Number(options.previousDurationMs)) ? Number(options.previousDurationMs) : 36;
+  const status = durationMs <= budgetMs ? 'pass' : 'warn';
+
+  return {
+    schema: EPIC13_HYDRATION_PERFORMANCE_DECISION_SCHEMA,
+    scope: HYDRATION_MEASURE,
+    previousStatus: 'warn-not-fail',
+    previousDurationMs,
+    currentStatus: status,
+    currentDurationMs: durationMs,
+    budgetMs,
+    budgetAction: 'kept-existing-budget',
+    baselineAction: 'rc1-sample-calibrated-under-existing-budget',
+    closureMode: status === 'pass' ? 'owner-free-closure' : 'owner-renewal-required',
+    ownerDecisionRequired: status !== 'pass',
+    publishBlocking: status !== 'pass',
+    targetWorkpackage: status === 'pass' ? null : 'WP-E13-06',
+    nextWorkpackage: status === 'pass' ? 'WP-E13-13' : 'WP-E13-06',
+    measurement: {
+      name: HYDRATION_MEASURE,
+      phase: 'hydrate',
+      durationMs,
+      budgetMs,
+      status,
+      baseline: HYDRATION_BASELINE
+    },
+    evidence: [
+      'tests/performance/performance_regression_suite.js',
+      HYDRATION_BASELINE,
+      'fabric/xtend-fabric.js',
+      'fabric/hydration-policy.js',
+      'tests/fabric/fabric_performance_measurement_suite.js',
+      'docs/performance-regression.md',
+      'docs/hydration-policies.md'
+    ],
+    rationale: 'The RC1 local deterministic hydration sample now passes the unchanged 32ms budget; no release-owner residual is needed for this scope.'
+  };
+}
+
+function createEpic13HydrationPerformanceClosurePlan(options = {}) {
+  const sourcePlan = options.sourcePlan || createEpic13KnownResidualTriagePlan(options);
+  const sourceValidation = options.sourceValidation || validateEpic13KnownResidualTriagePlan(sourcePlan);
+  const sourceReport = options.sourceReport || createEpic13KnownResidualTriageReport({ ...options, plan: sourcePlan });
+  const decision = options.decision || createHydrationDecision(options);
+
+  return {
+    schema: EPIC13_HYDRATION_PERFORMANCE_CLOSURE_SCHEMA,
+    decisionSchema: EPIC13_HYDRATION_PERFORMANCE_DECISION_SCHEMA,
+    reportSchema: EPIC13_HYDRATION_PERFORMANCE_CLOSURE_REPORT_SCHEMA,
+    workpackage: EPIC13_HYDRATION_PERFORMANCE_CLOSURE_WORKPACKAGE,
+    status: EPIC13_HYDRATION_PERFORMANCE_CLOSURE_STATUS,
+    generatedAt: options.generatedAt || 'static-local',
+    module: EPIC13_HYDRATION_PERFORMANCE_CLOSURE_MODULE,
+    suite: EPIC13_HYDRATION_PERFORMANCE_CLOSURE_SUITE,
+    steeringDocument: EPIC13_HYDRATION_PERFORMANCE_CLOSURE_STEERING,
+    contract: EPIC13_HYDRATION_PERFORMANCE_CLOSURE_CONTRACT,
+    workpackageDocument: EPIC13_HYDRATION_PERFORMANCE_CLOSURE_WORKPACKAGE_DOC,
+    docs: EPIC13_HYDRATION_PERFORMANCE_CLOSURE_DOCS,
+    localGate: EPIC13_HYDRATION_PERFORMANCE_CLOSURE_LOCAL_GATE,
+    packageScript: EPIC13_HYDRATION_PERFORMANCE_CLOSURE_PACKAGE_SCRIPT,
+    sourceSchema: EPIC13_KNOWN_RESIDUAL_TRIAGE_SCHEMA,
+    sourceReportSchema: EPIC13_KNOWN_RESIDUAL_TRIAGE_REPORT_SCHEMA,
+    sourceStatus: sourcePlan.status,
+    sourceValidationOk: sourceValidation.ok,
+    sourceReportOk: sourceReport.ok,
+    releaseCandidate: 'RC1',
+    targetReadiness: EPIC13_HYDRATION_PERFORMANCE_CLOSURE_TARGET,
+    sourceWatchpoints: clone(sourceReport.watchpoints || []),
+    decisions: [decision],
+    closureSummary: {
+      closedWatchpoints: decision.currentStatus === 'pass' ? [HYDRATION_MEASURE] : [],
+      remainingWatchpoints: decision.currentStatus === 'pass' ? [] : [HYDRATION_MEASURE],
+      publishBlockingResiduals: decision.publishBlocking ? [HYDRATION_MEASURE] : [],
+      ownerDecisionRequiredResiduals: decision.ownerDecisionRequired ? [HYDRATION_MEASURE] : []
+    },
+    sourceGates: REQUIRED_SOURCE_GATES.slice(),
+    requiredDocs: REQUIRED_DOCS.slice(),
+    nextDecision: 'rc1-gate-matrix-ci-handoff',
+    nextWorkpackage: decision.nextWorkpackage,
+    kernelBoundary: KERNEL_BOUNDARY,
+    publishBoundary: PUBLISH_BOUNDARY,
+    publishAllowed: false,
+    packagePrivateRequired: true
+  };
+}
+
+function validateEpic13HydrationPerformanceClosurePlan(plan = createEpic13HydrationPerformanceClosurePlan()) {
+  const errors = [];
+  const decisions = plan && Array.isArray(plan.decisions) ? plan.decisions : [];
+  const decision = decisions.find((entry) => entry.scope === HYDRATION_MEASURE);
+  const budgetMs = PERFORMANCE_BUDGET_MS_BY_MEASURE[HYDRATION_MEASURE];
+
+  if (!plan || plan.schema !== EPIC13_HYDRATION_PERFORMANCE_CLOSURE_SCHEMA) errors.push(`schema must be ${EPIC13_HYDRATION_PERFORMANCE_CLOSURE_SCHEMA}`);
+  if (!plan || plan.decisionSchema !== EPIC13_HYDRATION_PERFORMANCE_DECISION_SCHEMA) errors.push(`decisionSchema must be ${EPIC13_HYDRATION_PERFORMANCE_DECISION_SCHEMA}`);
+  if (!plan || plan.reportSchema !== EPIC13_HYDRATION_PERFORMANCE_CLOSURE_REPORT_SCHEMA) errors.push(`reportSchema must be ${EPIC13_HYDRATION_PERFORMANCE_CLOSURE_REPORT_SCHEMA}`);
+  if (!plan || plan.workpackage !== EPIC13_HYDRATION_PERFORMANCE_CLOSURE_WORKPACKAGE) errors.push(`workpackage must be ${EPIC13_HYDRATION_PERFORMANCE_CLOSURE_WORKPACKAGE}`);
+  if (!plan || plan.status !== EPIC13_HYDRATION_PERFORMANCE_CLOSURE_STATUS) errors.push(`status must be ${EPIC13_HYDRATION_PERFORMANCE_CLOSURE_STATUS}`);
+  if (!plan || plan.sourceSchema !== EPIC13_KNOWN_RESIDUAL_TRIAGE_SCHEMA) errors.push('source schema must be known residual triage');
+  if (!plan || plan.sourceValidationOk !== true || plan.sourceReportOk !== true) errors.push('known residual triage source must validate');
+  if (!plan || plan.targetReadiness !== EPIC13_HYDRATION_PERFORMANCE_CLOSURE_TARGET) errors.push(`targetReadiness must be ${EPIC13_HYDRATION_PERFORMANCE_CLOSURE_TARGET}`);
+  if (!decision || decision.schema !== EPIC13_HYDRATION_PERFORMANCE_DECISION_SCHEMA) errors.push('hydration decision schema must match');
+  if (!decision || decision.scope !== HYDRATION_MEASURE) errors.push(`decision scope must be ${HYDRATION_MEASURE}`);
+  if (!decision || decision.budgetMs !== budgetMs) errors.push(`hydration budget must remain ${budgetMs}ms`);
+  if (!decision || decision.budgetAction !== 'kept-existing-budget') errors.push('hydration budget must not be loosened');
+  if (!decision || decision.currentStatus !== 'pass') errors.push('hydration measurement must pass for owner-free closure');
+  if (!decision || decision.currentDurationMs > budgetMs) errors.push('hydration duration must be within budget');
+  if (!decision || decision.ownerDecisionRequired !== false || decision.publishBlocking !== false) errors.push('hydration closure must remove owner residual and publish blocker');
+  if (!plan || !Array.isArray(plan.sourceWatchpoints) || !plan.sourceWatchpoints.includes(HYDRATION_MEASURE)) errors.push('source watchpoint must include hydration measure');
+  if (!plan || !Array.isArray(plan.closureSummary.closedWatchpoints) || !plan.closureSummary.closedWatchpoints.includes(HYDRATION_MEASURE)) errors.push('closure summary must close hydration watchpoint');
+  if (!plan || plan.closureSummary.remainingWatchpoints.length !== 0) errors.push('closure summary must leave no hydration watchpoints');
+  if (!plan || plan.closureSummary.publishBlockingResiduals.length !== 0) errors.push('closure summary must remove publish-blocking hydration residual');
+  if (!plan || plan.closureSummary.ownerDecisionRequiredResiduals.length !== 0) errors.push('closure summary must not require owner decision for hydration');
+  REQUIRED_SOURCE_GATES.forEach((gate) => {
+    if (!plan || !plan.sourceGates.includes(gate)) errors.push(`source gate missing: ${gate}`);
+  });
+  if (!plan || plan.nextDecision !== 'rc1-gate-matrix-ci-handoff') errors.push('next decision must be RC1 Gate Matrix und CI-Handoff');
+  if (!plan || plan.nextWorkpackage !== 'WP-E13-13') errors.push('next workpackage must be WP-E13-13');
+  if (!plan || plan.kernelBoundary !== KERNEL_BOUNDARY) errors.push(`kernelBoundary must be ${KERNEL_BOUNDARY}`);
+  if (!plan || plan.publishBoundary !== PUBLISH_BOUNDARY) errors.push(`publishBoundary must be ${PUBLISH_BOUNDARY}`);
+  if (!plan || plan.publishAllowed !== false || plan.packagePrivateRequired !== true) errors.push('publish must remain blocked and package private');
+
+  return {
+    schema: EPIC13_HYDRATION_PERFORMANCE_CLOSURE_REPORT_SCHEMA,
+    ok: errors.length === 0,
+    errors
+  };
+}
+
+function createEpic13HydrationPerformanceClosureReport(options = {}) {
+  const plan = options.plan || createEpic13HydrationPerformanceClosurePlan(options);
+  const validation = validateEpic13HydrationPerformanceClosurePlan(plan);
+
+  return {
+    schema: EPIC13_HYDRATION_PERFORMANCE_CLOSURE_REPORT_SCHEMA,
+    ok: validation.ok,
+    errors: validation.errors,
+    plan,
+    decisionCount: plan.decisions.length,
+    closedWatchpoints: plan.closureSummary.closedWatchpoints.slice(),
+    remainingWatchpoints: plan.closureSummary.remainingWatchpoints.slice(),
+    publishBlockingResiduals: plan.closureSummary.publishBlockingResiduals.slice(),
+    ownerDecisionRequiredResiduals: plan.closureSummary.ownerDecisionRequiredResiduals.slice(),
+    publishAllowed: plan.publishAllowed,
+    nextWorkpackage: plan.nextWorkpackage
+  };
+}
+
+module.exports = {
+  EPIC13_HYDRATION_PERFORMANCE_CLOSURE_CONTRACT,
+  EPIC13_HYDRATION_PERFORMANCE_CLOSURE_DOCS,
+  EPIC13_HYDRATION_PERFORMANCE_CLOSURE_LOCAL_GATE,
+  EPIC13_HYDRATION_PERFORMANCE_CLOSURE_MODULE,
+  EPIC13_HYDRATION_PERFORMANCE_CLOSURE_PACKAGE_SCRIPT,
+  EPIC13_HYDRATION_PERFORMANCE_CLOSURE_REPORT_SCHEMA,
+  EPIC13_HYDRATION_PERFORMANCE_CLOSURE_SCHEMA,
+  EPIC13_HYDRATION_PERFORMANCE_CLOSURE_STATUS,
+  EPIC13_HYDRATION_PERFORMANCE_CLOSURE_STEERING,
+  EPIC13_HYDRATION_PERFORMANCE_CLOSURE_SUITE,
+  EPIC13_HYDRATION_PERFORMANCE_CLOSURE_TARGET,
+  EPIC13_HYDRATION_PERFORMANCE_CLOSURE_WORKPACKAGE,
+  EPIC13_HYDRATION_PERFORMANCE_CLOSURE_WORKPACKAGE_DOC,
+  EPIC13_HYDRATION_PERFORMANCE_DECISION_SCHEMA,
+  HYDRATION_BASELINE,
+  HYDRATION_MEASURE,
+  PUBLISH_BOUNDARY,
+  REQUIRED_DOCS,
+  REQUIRED_SOURCE_GATES,
+  createEpic13HydrationPerformanceClosurePlan,
+  createEpic13HydrationPerformanceClosureReport,
+  createHydrationDecision,
+  validateEpic13HydrationPerformanceClosurePlan
+};

package/catalog/epic13-known-residual-triage.d.ts

@@ -0,0 +1,32 @@
+import type {
+  XtendCatalogConstant,
+  XtendCatalogGate,
+  XtendCatalogOptions,
+  XtendCatalogPlan,
+  XtendCatalogRecord,
+  XtendCatalogReport
+} from './catalog-public-types';
+
+
+export declare const EPIC13_KNOWN_RESIDUAL_DECISION_SCHEMA: string;
+export declare const EPIC13_KNOWN_RESIDUAL_TRIAGE_CONTRACT: string;
+export declare const EPIC13_KNOWN_RESIDUAL_TRIAGE_DOCS: readonly XtendCatalogConstant[] | XtendCatalogConstant;
+export declare const EPIC13_KNOWN_RESIDUAL_TRIAGE_LOCAL_GATE: string;
+export declare const EPIC13_KNOWN_RESIDUAL_TRIAGE_MODULE: string;
+export declare const EPIC13_KNOWN_RESIDUAL_TRIAGE_PACKAGE_SCRIPT: string;
+export declare const EPIC13_KNOWN_RESIDUAL_TRIAGE_REPORT_SCHEMA: string;
+export declare const EPIC13_KNOWN_RESIDUAL_TRIAGE_SCHEMA: string;
+export declare const EPIC13_KNOWN_RESIDUAL_TRIAGE_STATUS: string;
+export declare const EPIC13_KNOWN_RESIDUAL_TRIAGE_STEERING: XtendCatalogConstant;
+export declare const EPIC13_KNOWN_RESIDUAL_TRIAGE_SUITE: string;
+export declare const EPIC13_KNOWN_RESIDUAL_TRIAGE_TARGET: string;
+export declare const EPIC13_KNOWN_RESIDUAL_TRIAGE_WORKPACKAGE: string;
+export declare const EPIC13_KNOWN_RESIDUAL_TRIAGE_WORKPACKAGE_DOC: XtendCatalogConstant;
+export declare const PUBLISH_BOUNDARY: XtendCatalogConstant;
+export declare const RC0_RESIDUAL_SCOPES: readonly XtendCatalogConstant[] | XtendCatalogConstant;
+export declare const REQUIRED_DOCS: readonly XtendCatalogConstant[] | XtendCatalogConstant;
+export declare const REQUIRED_SOURCE_GATES: readonly XtendCatalogConstant[] | XtendCatalogConstant;
+export declare const RESIDUAL_DECISION_MATRIX: readonly XtendCatalogConstant[] | XtendCatalogConstant;
+export declare function createEpic13KnownResidualTriagePlan(options?: XtendCatalogOptions): XtendCatalogPlan;
+export declare function createEpic13KnownResidualTriageReport(options?: XtendCatalogOptions): XtendCatalogReport;
+export declare function validateEpic13KnownResidualTriagePlan(plan?: unknown): XtendCatalogReport;