@ccslabs/xtend 0.1.0-rc.1

package/catalog/epic13-rmt-production-readiness.d.ts

@@ -0,0 +1,35 @@
+import type {
+  XtendCatalogConstant,
+  XtendCatalogGate,
+  XtendCatalogOptions,
+  XtendCatalogPlan,
+  XtendCatalogRecord,
+  XtendCatalogReport
+} from './catalog-public-types';
+
+
+export declare const EPIC13_RMT_PRODUCTION_READINESS_CONTRACT: string;
+export declare const EPIC13_RMT_PRODUCTION_READINESS_DOCS: readonly XtendCatalogConstant[] | XtendCatalogConstant;
+export declare const EPIC13_RMT_PRODUCTION_READINESS_LOCAL_GATE: string;
+export declare const EPIC13_RMT_PRODUCTION_READINESS_MODULE: string;
+export declare const EPIC13_RMT_PRODUCTION_READINESS_PACKAGE_SCRIPT: string;
+export declare const EPIC13_RMT_PRODUCTION_READINESS_REPORT_ARTIFACT: string;
+export declare const EPIC13_RMT_PRODUCTION_READINESS_REPORT_SCHEMA: string;
+export declare const EPIC13_RMT_PRODUCTION_READINESS_SCHEMA: string;
+export declare const EPIC13_RMT_PRODUCTION_READINESS_STATUS: string;
+export declare const EPIC13_RMT_PRODUCTION_READINESS_STEERING: XtendCatalogConstant;
+export declare const EPIC13_RMT_PRODUCTION_READINESS_SUITE: string;
+export declare const EPIC13_RMT_PRODUCTION_READINESS_TARGET: string;
+export declare const EPIC13_RMT_PRODUCTION_READINESS_WORKPACKAGE: string;
+export declare const EPIC13_RMT_PRODUCTION_READINESS_WORKPACKAGE_DOC: XtendCatalogConstant;
+export declare const NEXT_DECISION: XtendCatalogConstant;
+export declare const NEXT_WORKPACKAGE: string;
+export declare const PUBLISH_BOUNDARY: XtendCatalogConstant;
+export declare const REQUIRED_DOCS: readonly XtendCatalogConstant[] | XtendCatalogConstant;
+export declare const REQUIRED_RMT_ARTIFACTS: readonly XtendCatalogConstant[] | XtendCatalogConstant;
+export declare const REQUIRED_RMT_DOMAINS: readonly XtendCatalogConstant[] | XtendCatalogConstant;
+export declare const REQUIRED_RMT_SOURCE_GATES: readonly XtendCatalogConstant[] | XtendCatalogConstant;
+export declare const RMT_EVIDENCE_RECORDS: readonly XtendCatalogConstant[] | XtendCatalogConstant;
+export declare function createEpic13RmtProductionReadinessPlan(options?: XtendCatalogOptions): XtendCatalogPlan;
+export declare function createEpic13RmtProductionReadinessReport(options?: XtendCatalogOptions): XtendCatalogReport;
+export declare function validateEpic13RmtProductionReadinessPlan(plan?: unknown): XtendCatalogReport;

package/catalog/epic13-rmt-production-readiness.js

@@ -0,0 +1,314 @@
+const {
+  KERNEL_BOUNDARY
+} = require('./epic12-rc0-gate-matrix');
+const {
+  EPIC13_VISUAL_OWNER_ARTIFACT_REPORT_SCHEMA,
+  EPIC13_VISUAL_OWNER_ARTIFACT_SCHEMA,
+  createEpic13VisualOwnerArtifactPlan,
+  createEpic13VisualOwnerArtifactReport,
+  validateEpic13VisualOwnerArtifactPlan
+} = require('./epic13-visual-owner-artifact');
+
+const EPIC13_RMT_PRODUCTION_READINESS_SCHEMA = 'xtend.epic13.rmt-production-readiness.v1';
+const EPIC13_RMT_PRODUCTION_READINESS_REPORT_SCHEMA = 'xtend.epic13.rmt-production-readiness-report.v1';
+const EPIC13_RMT_PRODUCTION_READINESS_WORKPACKAGE = 'WP-E13-09';
+const EPIC13_RMT_PRODUCTION_READINESS_STATUS = 'accepted-rmt-production-readiness-bundling';
+const EPIC13_RMT_PRODUCTION_READINESS_TARGET = 'rmt-first-production-readiness-bundled';
+const EPIC13_RMT_PRODUCTION_READINESS_MODULE = 'catalog/epic13-rmt-production-readiness.js';
+const EPIC13_RMT_PRODUCTION_READINESS_SUITE = 'tests/platform/epic13_rmt_production_readiness_suite.js';
+const EPIC13_RMT_PRODUCTION_READINESS_STEERING = 'development/RC0-RC1-transfer-EPIC13.md';
+const EPIC13_RMT_PRODUCTION_READINESS_CONTRACT = 'development/XTend-Epic13-RMT-Production-Readiness-Contract.md';
+const EPIC13_RMT_PRODUCTION_READINESS_WORKPACKAGE_DOC = 'development/WP-E13-09-RMT-first-App-Production-Readiness-Gate-buendeln.md';
+const EPIC13_RMT_PRODUCTION_READINESS_DOCS = 'docs/rmt-production-readiness.md';
+const EPIC13_RMT_PRODUCTION_READINESS_LOCAL_GATE = 'node scripts/run_xtend_tests.js epic13-rmt-production-readiness --json';
+const EPIC13_RMT_PRODUCTION_READINESS_PACKAGE_SCRIPT = 'npm run test:epic13-rmt-production-readiness';
+const EPIC13_RMT_PRODUCTION_READINESS_REPORT_ARTIFACT = '.xtend-test-results/xtend-epic13-rmt-production-readiness-report.json';
+const PUBLISH_BOUNDARY = 'private-until-release-owner-acceptance';
+const NEXT_DECISION = 'rc1-gate-matrix-ci-handoff';
+const NEXT_WORKPACKAGE = 'WP-E13-13';
+
+const REQUIRED_RMT_SOURCE_GATES = Object.freeze([
+  'npm run test:rmt-compatibility',
+  'npm run test:rmt-first-class-app',
+  'npm run test:rmt-first-demo-app',
+  'npm run test:rmt-artifact-parity',
+  'npm run test:rmt-component-fabric-ingestion',
+  'npm run test:rmt-component-lifecycle-telemetry',
+  'npm run test:epic13-visual-owner-artifact'
+]);
+
+const REQUIRED_RMT_DOMAINS = Object.freeze([
+  'app-shell',
+  'routing',
+  'components',
+  'fabric',
+  'lanes',
+  'diagnostics',
+  'artifact-parity',
+  'kernel-boundary'
+]);
+
+const REQUIRED_RMT_ARTIFACTS = Object.freeze([
+  'tests/fixtures/rmt-first-class-xtend-app.rmt',
+  'xtendrmt/rmt-first-demo-app.rmt',
+  'xtendrmt/rmt-first-demo-app.js',
+  'xtendrmt-rmt-first-demo.html',
+  'tests/browser/fixtures/rmt-first-demo-app-smoke.html',
+  'xtendrmt/rmt-core.esm.js',
+  'xtendrmt/rmt-runtime.esm.js',
+  'xtendrmt/rmt-runtime.browser.js',
+  'xtendrmt/rmt-core.d.ts',
+  'xtendrmt/rmt.schema.json',
+  'xtendrmt/rmt-manifest.json'
+]);
+
+const REQUIRED_DOCS = Object.freeze([
+  EPIC13_RMT_PRODUCTION_READINESS_STEERING,
+  EPIC13_RMT_PRODUCTION_READINESS_CONTRACT,
+  EPIC13_RMT_PRODUCTION_READINESS_WORKPACKAGE_DOC,
+  EPIC13_RMT_PRODUCTION_READINESS_DOCS,
+  'development/XTend-RMT-First-Class-App-Authoring.md',
+  'development/WP-E10-13-RMT-first-Demo-App-ohne-manuelle-Shell-bauen.md',
+  'development/XTend-Fabric-Component-Compatibility-v2.md',
+  'development/XTend-Component-Lifecycle-Telemetry-Contract.md',
+  'docs/rmt-first-xtend-apps.md',
+  'docs/rmt-first-demo-app.md',
+  'docs/xtendrmt-app-dsl.md',
+  'docs/xtendrmt-native-authoring.md',
+  'docs/xtend-fabric-rmt-lane-mapping.md',
+  'docs/visual-owner-artifacts.md',
+  'docs/enterprise-adoption.md'
+]);
+
+const RMT_EVIDENCE_RECORDS = Object.freeze([
+  {
+    id: 'rmt-compatibility',
+    command: 'npm run test:rmt-compatibility',
+    schema: 'xtend.scaffold.rmt-compatibility-binding.v1',
+    domains: ['kernel-boundary', 'artifact-parity', 'diagnostics'],
+    evidence: 'tests/rmt/rmt_compatibility_suite.js',
+    status: 'covered'
+  },
+  {
+    id: 'rmt-first-class-app',
+    command: 'npm run test:rmt-first-class-app',
+    schema: 'xtend.rmt.first-class-app-authoring.v1',
+    domains: ['app-shell', 'routing', 'components', 'lanes', 'diagnostics'],
+    evidence: 'tests/fixtures/rmt-first-class-xtend-app.rmt',
+    status: 'covered'
+  },
+  {
+    id: 'rmt-first-demo-app',
+    command: 'npm run test:rmt-first-demo-app',
+    schema: 'xtend.epic10.rmt-first-demo-app.v1',
+    domains: ['app-shell', 'routing', 'components', 'fabric', 'lanes', 'diagnostics'],
+    evidence: 'xtendrmt/rmt-first-demo-app.rmt',
+    status: 'covered'
+  },
+  {
+    id: 'rmt-artifact-parity',
+    command: 'npm run test:rmt-artifact-parity',
+    schema: 'xtend.rmt.artifact-parity.v1',
+    domains: ['artifact-parity', 'kernel-boundary'],
+    evidence: 'scripts/verify_xtendrmt_artifact_parity.js',
+    status: 'covered'
+  },
+  {
+    id: 'component-fabric-lane-ingestion',
+    command: 'npm run test:rmt-component-fabric-ingestion',
+    schema: 'xtend.component.fabric-lane-ingestion.v2',
+    domains: ['fabric', 'lanes', 'components'],
+    evidence: 'tests/rmt/rmt_component_fabric_lane_ingestion_suite.js',
+    status: 'covered'
+  },
+  {
+    id: 'component-lifecycle-telemetry',
+    command: 'npm run test:rmt-component-lifecycle-telemetry',
+    schema: 'xtend.component.lifecycle-telemetry.v1',
+    domains: ['fabric', 'diagnostics', 'components'],
+    evidence: 'tests/rmt/rmt_component_lifecycle_telemetry_suite.js',
+    status: 'covered'
+  },
+  {
+    id: 'visual-owner-artifact',
+    command: 'npm run test:epic13-visual-owner-artifact',
+    schema: EPIC13_VISUAL_OWNER_ARTIFACT_SCHEMA,
+    domains: ['diagnostics'],
+    evidence: 'tests/browser/visual-baselines/rc1-visual-owner-artifact.manifest.json',
+    status: 'covered'
+  }
+]);
+
+function unique(values) {
+  return [...new Set(values)];
+}
+
+function createEpic13RmtProductionReadinessPlan(options = {}) {
+  const sourcePlan = options.sourcePlan || createEpic13VisualOwnerArtifactPlan(options);
+  const sourceValidation = options.sourceValidation || validateEpic13VisualOwnerArtifactPlan(sourcePlan);
+  const sourceReport = options.sourceReport || createEpic13VisualOwnerArtifactReport({ ...options, plan: sourcePlan });
+  const evidenceRecords = RMT_EVIDENCE_RECORDS.map((record) => ({
+    ...record,
+    domains: record.domains.slice()
+  }));
+  const coveredDomains = unique(evidenceRecords.flatMap((record) => record.domains));
+  const missingDomains = REQUIRED_RMT_DOMAINS.filter((domain) => !coveredDomains.includes(domain));
+
+  return {
+    schema: EPIC13_RMT_PRODUCTION_READINESS_SCHEMA,
+    reportSchema: EPIC13_RMT_PRODUCTION_READINESS_REPORT_SCHEMA,
+    workpackage: EPIC13_RMT_PRODUCTION_READINESS_WORKPACKAGE,
+    status: EPIC13_RMT_PRODUCTION_READINESS_STATUS,
+    generatedAt: options.generatedAt || 'static-local',
+    module: EPIC13_RMT_PRODUCTION_READINESS_MODULE,
+    suite: EPIC13_RMT_PRODUCTION_READINESS_SUITE,
+    steeringDocument: EPIC13_RMT_PRODUCTION_READINESS_STEERING,
+    contract: EPIC13_RMT_PRODUCTION_READINESS_CONTRACT,
+    workpackageDocument: EPIC13_RMT_PRODUCTION_READINESS_WORKPACKAGE_DOC,
+    docs: EPIC13_RMT_PRODUCTION_READINESS_DOCS,
+    localGate: EPIC13_RMT_PRODUCTION_READINESS_LOCAL_GATE,
+    packageScript: EPIC13_RMT_PRODUCTION_READINESS_PACKAGE_SCRIPT,
+    reportArtifact: EPIC13_RMT_PRODUCTION_READINESS_REPORT_ARTIFACT,
+    sourceSchema: EPIC13_VISUAL_OWNER_ARTIFACT_SCHEMA,
+    sourceReportSchema: EPIC13_VISUAL_OWNER_ARTIFACT_REPORT_SCHEMA,
+    sourceStatus: sourcePlan.status,
+    sourceValidationOk: sourceValidation.ok,
+    sourceReportOk: sourceReport.ok,
+    releaseCandidate: 'RC1',
+    targetReadiness: EPIC13_RMT_PRODUCTION_READINESS_TARGET,
+    appAuthoringSchema: 'xtend.rmt.first-class-app-authoring.v1',
+    demoAppSchema: 'xtend.epic10.rmt-first-demo-app.v1',
+    artifactParitySchema: 'xtend.rmt.artifact-parity.v1',
+    fabricLaneIngestionSchema: 'xtend.component.fabric-lane-ingestion.v2',
+    lifecycleTelemetrySchema: 'xtend.component.lifecycle-telemetry.v1',
+    requiredDomains: REQUIRED_RMT_DOMAINS.slice(),
+    coveredDomains,
+    missingDomains,
+    sourceGates: REQUIRED_RMT_SOURCE_GATES.slice(),
+    evidenceRecords,
+    artifactPaths: REQUIRED_RMT_ARTIFACTS.slice(),
+    requiredDocs: REQUIRED_DOCS.slice(),
+    coverageSummary: {
+      requiredDomainCount: REQUIRED_RMT_DOMAINS.length,
+      coveredDomainCount: coveredDomains.length,
+      missingDomainCount: missingDomains.length,
+      requiredGateCount: REQUIRED_RMT_SOURCE_GATES.length,
+      evidenceRecordCount: evidenceRecords.length
+    },
+    productionBundle: {
+      shellFirst: true,
+      routingNativeInRmt: true,
+      componentAdapterRequired: true,
+      fabricLaneIngestionRequired: true,
+      lifecycleTelemetryRequired: true,
+      diagnosticsRequired: true,
+      artifactParityRequired: true
+    },
+    kernelBoundary: KERNEL_BOUNDARY,
+    rmtKernelImportsXtendTypes: false,
+    adapterBoundary: 'xtend-adapters-only',
+    frameworkAgnostic: true,
+    localGateMode: 'static-rc1-rmt-gate-bundle',
+    externalBrowserRequiredInLocalGate: false,
+    externalNetworkAllowedInLocalGate: false,
+    nextDecision: NEXT_DECISION,
+    nextWorkpackage: NEXT_WORKPACKAGE,
+    publishBoundary: PUBLISH_BOUNDARY,
+    publishAllowed: false,
+    packagePrivateRequired: true
+  };
+}
+
+function validateEpic13RmtProductionReadinessPlan(plan = createEpic13RmtProductionReadinessPlan()) {
+  const errors = [];
+  const evidence = plan && Array.isArray(plan.evidenceRecords) ? plan.evidenceRecords : [];
+
+  if (!plan || plan.schema !== EPIC13_RMT_PRODUCTION_READINESS_SCHEMA) errors.push(`schema must be ${EPIC13_RMT_PRODUCTION_READINESS_SCHEMA}`);
+  if (!plan || plan.reportSchema !== EPIC13_RMT_PRODUCTION_READINESS_REPORT_SCHEMA) errors.push(`reportSchema must be ${EPIC13_RMT_PRODUCTION_READINESS_REPORT_SCHEMA}`);
+  if (!plan || plan.workpackage !== EPIC13_RMT_PRODUCTION_READINESS_WORKPACKAGE) errors.push(`workpackage must be ${EPIC13_RMT_PRODUCTION_READINESS_WORKPACKAGE}`);
+  if (!plan || plan.status !== EPIC13_RMT_PRODUCTION_READINESS_STATUS) errors.push(`status must be ${EPIC13_RMT_PRODUCTION_READINESS_STATUS}`);
+  if (!plan || plan.sourceSchema !== EPIC13_VISUAL_OWNER_ARTIFACT_SCHEMA) errors.push('source schema must be visual owner artifact');
+  if (!plan || plan.sourceValidationOk !== true || plan.sourceReportOk !== true) errors.push('visual owner artifact source must validate');
+  if (!plan || plan.targetReadiness !== EPIC13_RMT_PRODUCTION_READINESS_TARGET) errors.push(`targetReadiness must be ${EPIC13_RMT_PRODUCTION_READINESS_TARGET}`);
+  REQUIRED_RMT_SOURCE_GATES.forEach((gate) => {
+    if (!plan || !plan.sourceGates.includes(gate)) errors.push(`source gate missing: ${gate}`);
+  });
+  REQUIRED_RMT_DOMAINS.forEach((domain) => {
+    if (!plan || !plan.coveredDomains.includes(domain)) errors.push(`domain missing: ${domain}`);
+  });
+  REQUIRED_RMT_ARTIFACTS.forEach((artifactPath) => {
+    if (!plan || !plan.artifactPaths.includes(artifactPath)) errors.push(`artifact missing: ${artifactPath}`);
+  });
+  REQUIRED_DOCS.forEach((docPath) => {
+    if (!plan || !plan.requiredDocs.includes(docPath)) errors.push(`doc missing: ${docPath}`);
+  });
+  if (!plan || plan.missingDomains.length !== 0) errors.push(`missing RMT readiness domains: ${plan ? plan.missingDomains.join(', ') : '<plan missing>'}`);
+  if (!plan || plan.coverageSummary.requiredGateCount !== REQUIRED_RMT_SOURCE_GATES.length) errors.push('required gate count must match source gate list');
+  if (!plan || plan.coverageSummary.evidenceRecordCount !== RMT_EVIDENCE_RECORDS.length) errors.push('evidence record count must match RMT evidence list');
+  if (!plan || evidence.some((record) => record.status !== 'covered')) errors.push('all RMT evidence records must be covered');
+  if (!plan || !plan.productionBundle.shellFirst || !plan.productionBundle.routingNativeInRmt) errors.push('RMT production bundle must be shell-first and routing-native');
+  if (!plan || !plan.productionBundle.componentAdapterRequired || !plan.productionBundle.fabricLaneIngestionRequired || !plan.productionBundle.lifecycleTelemetryRequired) errors.push('component, Fabric/Lane and Lifecycle Telemetry coverage are required');
+  if (!plan || !plan.productionBundle.diagnosticsRequired || !plan.productionBundle.artifactParityRequired) errors.push('diagnostics and artifact parity are required');
+  if (!plan || plan.kernelBoundary !== KERNEL_BOUNDARY) errors.push(`kernelBoundary must be ${KERNEL_BOUNDARY}`);
+  if (!plan || plan.rmtKernelImportsXtendTypes !== false) errors.push('RMT kernel must not import XTend types');
+  if (!plan || plan.adapterBoundary !== 'xtend-adapters-only') errors.push('adapter boundary must remain XTend adapters only');
+  if (!plan || plan.frameworkAgnostic !== true) errors.push('RMT production readiness must remain framework agnostic');
+  if (!plan || plan.localGateMode !== 'static-rc1-rmt-gate-bundle') errors.push('local gate mode must remain static RC1 RMT bundle');
+  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_RMT_PRODUCTION_READINESS_REPORT_SCHEMA,
+    ok: errors.length === 0,
+    errors
+  };
+}
+
+function createEpic13RmtProductionReadinessReport(options = {}) {
+  const plan = options.plan || createEpic13RmtProductionReadinessPlan(options);
+  const validation = validateEpic13RmtProductionReadinessPlan(plan);
+
+  return {
+    schema: EPIC13_RMT_PRODUCTION_READINESS_REPORT_SCHEMA,
+    ok: validation.ok,
+    errors: validation.errors,
+    plan,
+    sourceGateCount: plan.sourceGates.length,
+    coveredDomainCount: plan.coveredDomains.length,
+    evidenceRecordCount: plan.evidenceRecords.length,
+    artifactCount: plan.artifactPaths.length,
+    publishAllowed: plan.publishAllowed,
+    nextWorkpackage: plan.nextWorkpackage
+  };
+}
+
+module.exports = {
+  EPIC13_RMT_PRODUCTION_READINESS_CONTRACT,
+  EPIC13_RMT_PRODUCTION_READINESS_DOCS,
+  EPIC13_RMT_PRODUCTION_READINESS_LOCAL_GATE,
+  EPIC13_RMT_PRODUCTION_READINESS_MODULE,
+  EPIC13_RMT_PRODUCTION_READINESS_PACKAGE_SCRIPT,
+  EPIC13_RMT_PRODUCTION_READINESS_REPORT_ARTIFACT,
+  EPIC13_RMT_PRODUCTION_READINESS_REPORT_SCHEMA,
+  EPIC13_RMT_PRODUCTION_READINESS_SCHEMA,
+  EPIC13_RMT_PRODUCTION_READINESS_STATUS,
+  EPIC13_RMT_PRODUCTION_READINESS_STEERING,
+  EPIC13_RMT_PRODUCTION_READINESS_SUITE,
+  EPIC13_RMT_PRODUCTION_READINESS_TARGET,
+  EPIC13_RMT_PRODUCTION_READINESS_WORKPACKAGE,
+  EPIC13_RMT_PRODUCTION_READINESS_WORKPACKAGE_DOC,
+  NEXT_DECISION,
+  NEXT_WORKPACKAGE,
+  PUBLISH_BOUNDARY,
+  REQUIRED_DOCS,
+  REQUIRED_RMT_ARTIFACTS,
+  REQUIRED_RMT_DOMAINS,
+  REQUIRED_RMT_SOURCE_GATES,
+  RMT_EVIDENCE_RECORDS,
+  createEpic13RmtProductionReadinessPlan,
+  createEpic13RmtProductionReadinessReport,
+  validateEpic13RmtProductionReadinessPlan
+};

package/catalog/epic13-trusted-dom-boundary.d.ts

@@ -0,0 +1,36 @@
+import type {
+  XtendCatalogConstant,
+  XtendCatalogGate,
+  XtendCatalogOptions,
+  XtendCatalogPlan,
+  XtendCatalogRecord,
+  XtendCatalogReport
+} from './catalog-public-types';
+
+
+export declare const EPIC13_TRUSTED_DOM_BOUNDARY_CONTRACT: string;
+export declare const EPIC13_TRUSTED_DOM_BOUNDARY_DOCS: readonly XtendCatalogConstant[] | XtendCatalogConstant;
+export declare const EPIC13_TRUSTED_DOM_BOUNDARY_FIXTURE_SCHEMA: string;
+export declare const EPIC13_TRUSTED_DOM_BOUNDARY_LOCAL_GATE: string;
+export declare const EPIC13_TRUSTED_DOM_BOUNDARY_MODULE: string;
+export declare const EPIC13_TRUSTED_DOM_BOUNDARY_PACKAGE_SCRIPT: string;
+export declare const EPIC13_TRUSTED_DOM_BOUNDARY_REPORT_ARTIFACT: string;
+export declare const EPIC13_TRUSTED_DOM_BOUNDARY_REPORT_SCHEMA: string;
+export declare const EPIC13_TRUSTED_DOM_BOUNDARY_SCHEMA: string;
+export declare const EPIC13_TRUSTED_DOM_BOUNDARY_STATUS: string;
+export declare const EPIC13_TRUSTED_DOM_BOUNDARY_STEERING: XtendCatalogConstant;
+export declare const EPIC13_TRUSTED_DOM_BOUNDARY_SUITE: string;
+export declare const EPIC13_TRUSTED_DOM_BOUNDARY_TARGET: string;
+export declare const EPIC13_TRUSTED_DOM_BOUNDARY_WORKPACKAGE: string;
+export declare const EPIC13_TRUSTED_DOM_BOUNDARY_WORKPACKAGE_DOC: XtendCatalogConstant;
+export declare const NEXT_DECISION: XtendCatalogConstant;
+export declare const NEXT_WORKPACKAGE: string;
+export declare const PUBLISH_BOUNDARY: XtendCatalogConstant;
+export declare const REQUIRED_ARTIFACTS: readonly XtendCatalogConstant[] | XtendCatalogConstant;
+export declare const REQUIRED_BROWSER_ASSERTIONS: readonly XtendCatalogConstant[] | XtendCatalogConstant;
+export declare const REQUIRED_SOURCE_GATES: readonly XtendCatalogConstant[] | XtendCatalogConstant;
+export declare const TRUSTED_DOM_BOUNDARY_FIXTURE: XtendCatalogConstant;
+export declare const TRUSTED_DOM_BOUNDARY_RESULT_KEY: string;
+export declare function createEpic13TrustedDomBoundaryPlan(options?: XtendCatalogOptions): XtendCatalogPlan;
+export declare function createEpic13TrustedDomBoundaryReport(options?: XtendCatalogOptions): XtendCatalogReport;
+export declare function validateEpic13TrustedDomBoundaryPlan(plan?: unknown): XtendCatalogReport;

package/catalog/epic13-trusted-dom-boundary.js

@@ -0,0 +1,230 @@
+const {
+  KERNEL_BOUNDARY
+} = require('./epic12-rc0-gate-matrix');
+const {
+  EPIC13_DOCS_RMT_PRODUCTION_HARDENING_REPORT_SCHEMA,
+  EPIC13_DOCS_RMT_PRODUCTION_HARDENING_SCHEMA,
+  createEpic13DocsRmtProductionHardeningPlan,
+  createEpic13DocsRmtProductionHardeningReport,
+  validateEpic13DocsRmtProductionHardeningPlan
+} = require('./epic13-docs-rmt-production-hardening');
+const {
+  SANITIZING_BOUNDARY_CONTRACT,
+  TRUSTED_DOM_POLICY_CONTRACT,
+  TRUSTED_DOM_SANITIZER_CONTRACT
+} = require('../security/trusted-dom-policy');
+
+const EPIC13_TRUSTED_DOM_BOUNDARY_SCHEMA = 'xtend.epic13.trusted-dom-boundary.v1';
+const EPIC13_TRUSTED_DOM_BOUNDARY_FIXTURE_SCHEMA = 'xtend.epic13.trusted-dom-boundary-browser-smoke.v1';
+const EPIC13_TRUSTED_DOM_BOUNDARY_REPORT_SCHEMA = 'xtend.epic13.trusted-dom-boundary-report.v1';
+const EPIC13_TRUSTED_DOM_BOUNDARY_WORKPACKAGE = 'WP-E13-11';
+const EPIC13_TRUSTED_DOM_BOUNDARY_STATUS = 'accepted-trusted-dom-boundary-browser-proof';
+const EPIC13_TRUSTED_DOM_BOUNDARY_TARGET = 'trusted-dom-parsedown-rmt-html-boundary-browser-proofed';
+const EPIC13_TRUSTED_DOM_BOUNDARY_MODULE = 'catalog/epic13-trusted-dom-boundary.js';
+const EPIC13_TRUSTED_DOM_BOUNDARY_SUITE = 'tests/platform/epic13_trusted_dom_boundary_suite.js';
+const EPIC13_TRUSTED_DOM_BOUNDARY_STEERING = 'development/RC0-RC1-transfer-EPIC13.md';
+const EPIC13_TRUSTED_DOM_BOUNDARY_CONTRACT = 'development/XTend-Epic13-Trusted-DOM-Boundary-Contract.md';
+const EPIC13_TRUSTED_DOM_BOUNDARY_WORKPACKAGE_DOC = 'development/WP-E13-11-Trusted-DOM-Parsedown-und-RMT-HTML-Boundary-browsernah-pruefen.md';
+const EPIC13_TRUSTED_DOM_BOUNDARY_DOCS = 'docs/trusted-dom-boundary-browser-proof.md';
+const EPIC13_TRUSTED_DOM_BOUNDARY_LOCAL_GATE = 'node scripts/run_xtend_tests.js epic13-trusted-dom-boundary --json';
+const EPIC13_TRUSTED_DOM_BOUNDARY_PACKAGE_SCRIPT = 'npm run test:epic13-trusted-dom-boundary';
+const EPIC13_TRUSTED_DOM_BOUNDARY_REPORT_ARTIFACT = '.xtend-test-results/xtend-epic13-trusted-dom-boundary-report.json';
+const TRUSTED_DOM_BOUNDARY_FIXTURE = 'tests/browser/fixtures/epic13-trusted-dom-boundary-smoke.html';
+const TRUSTED_DOM_BOUNDARY_RESULT_KEY = '__xtendEpic13TrustedDomBoundaryResult';
+const NEXT_DECISION = 'rc1-gate-matrix-ci-handoff';
+const NEXT_WORKPACKAGE = 'WP-E13-13';
+const PUBLISH_BOUNDARY = 'private-until-release-owner-acceptance';
+
+const REQUIRED_SOURCE_GATES = Object.freeze([
+  'npm run test:manifest-policy',
+  'npm run test:docs-rmt-pilot',
+  'npm run test:browser',
+  'npm run test:epic13-prod-browser-csp-smoke',
+  'npm run test:epic13-docs-rmt-production-hardening'
+]);
+
+const REQUIRED_BROWSER_ASSERTIONS = Object.freeze([
+  'parsedown-content-sanitized-before-innerhtml-sink',
+  'trusted-dom-proof-schema-marked-on-sink',
+  'script-element-removed',
+  'iframe-element-removed',
+  'event-handler-attributes-removed',
+  'javascript-urls-removed',
+  'srcdoc-removed',
+  'safe-parsedown-text-preserved',
+  'sanitizer-records-removed-payloads',
+  'malicious-script-did-not-execute',
+  'rmt-shell-remained-shell-first',
+  'rmt-kernel-remains-parser-neutral'
+]);
+
+const REQUIRED_ARTIFACTS = Object.freeze([
+  EPIC13_TRUSTED_DOM_BOUNDARY_STEERING,
+  EPIC13_TRUSTED_DOM_BOUNDARY_CONTRACT,
+  EPIC13_TRUSTED_DOM_BOUNDARY_WORKPACKAGE_DOC,
+  EPIC13_TRUSTED_DOM_BOUNDARY_DOCS,
+  TRUSTED_DOM_BOUNDARY_FIXTURE,
+  'security/trusted-dom-policy.js',
+  'docs/utils/pageloader.js',
+  'docs/index.php',
+  'docs/xtendrmt-parsedown-docs.rmt',
+  'docs/trusted-dom-sanitizing.md',
+  'docs/docs-rmt-production-hardening.md',
+  'docs/prod-browser-csp-smokes.md'
+]);
+
+function createEpic13TrustedDomBoundaryPlan(options = {}) {
+  const sourcePlan = options.sourcePlan || createEpic13DocsRmtProductionHardeningPlan(options);
+  const sourceValidation = options.sourceValidation || validateEpic13DocsRmtProductionHardeningPlan(sourcePlan);
+  const sourceReport = options.sourceReport || createEpic13DocsRmtProductionHardeningReport({ ...options, plan: sourcePlan });
+
+  return {
+    schema: EPIC13_TRUSTED_DOM_BOUNDARY_SCHEMA,
+    fixtureSchema: EPIC13_TRUSTED_DOM_BOUNDARY_FIXTURE_SCHEMA,
+    reportSchema: EPIC13_TRUSTED_DOM_BOUNDARY_REPORT_SCHEMA,
+    workpackage: EPIC13_TRUSTED_DOM_BOUNDARY_WORKPACKAGE,
+    status: EPIC13_TRUSTED_DOM_BOUNDARY_STATUS,
+    generatedAt: options.generatedAt || 'static-local',
+    module: EPIC13_TRUSTED_DOM_BOUNDARY_MODULE,
+    suite: EPIC13_TRUSTED_DOM_BOUNDARY_SUITE,
+    steeringDocument: EPIC13_TRUSTED_DOM_BOUNDARY_STEERING,
+    contract: EPIC13_TRUSTED_DOM_BOUNDARY_CONTRACT,
+    workpackageDocument: EPIC13_TRUSTED_DOM_BOUNDARY_WORKPACKAGE_DOC,
+    docs: EPIC13_TRUSTED_DOM_BOUNDARY_DOCS,
+    localGate: EPIC13_TRUSTED_DOM_BOUNDARY_LOCAL_GATE,
+    packageScript: EPIC13_TRUSTED_DOM_BOUNDARY_PACKAGE_SCRIPT,
+    reportArtifact: EPIC13_TRUSTED_DOM_BOUNDARY_REPORT_ARTIFACT,
+    sourceSchema: EPIC13_DOCS_RMT_PRODUCTION_HARDENING_SCHEMA,
+    sourceReportSchema: EPIC13_DOCS_RMT_PRODUCTION_HARDENING_REPORT_SCHEMA,
+    sourceStatus: sourcePlan.status,
+    sourceValidationOk: sourceValidation.ok,
+    sourceReportOk: sourceReport.ok,
+    targetReadiness: EPIC13_TRUSTED_DOM_BOUNDARY_TARGET,
+    trustedDomPolicy: TRUSTED_DOM_POLICY_CONTRACT,
+    trustedDomSanitizer: TRUSTED_DOM_SANITIZER_CONTRACT,
+    trustBoundary: SANITIZING_BOUNDARY_CONTRACT,
+    fixture: TRUSTED_DOM_BOUNDARY_FIXTURE,
+    resultKey: TRUSTED_DOM_BOUNDARY_RESULT_KEY,
+    sourceGates: REQUIRED_SOURCE_GATES.slice(),
+    requiredBrowserAssertions: REQUIRED_BROWSER_ASSERTIONS.slice(),
+    artifactPaths: REQUIRED_ARTIFACTS.slice(),
+    boundaryProof: {
+      parsedownHtmlRequiresSanitizer: true,
+      rmtHtmlFragmentRequiresSanitizer: true,
+      structuredDomDescriptorPreferred: true,
+      hostOwnsSanitizingSink: true,
+      scriptsBlocked: true,
+      inlineEventHandlersBlocked: true,
+      javascriptUrlsBlocked: true,
+      srcdocBlocked: true,
+      cspSmokeLinked: true
+    },
+    localGateMode: 'static-fixture-plus-trusted-dom-sanitizer-proof',
+    externalBrowserRequiredInLocalGate: false,
+    externalNetworkAllowedInLocalGate: false,
+    browserExecutionMode: 'optional-driver-or-owner-artifact',
+    frameworkAgnostic: true,
+    rmtKernelImportsSanitizer: false,
+    rmtKernelImportsParsedown: false,
+    rmtKernelImportsXtendTypes: false,
+    kernelBoundary: KERNEL_BOUNDARY,
+    nextDecision: NEXT_DECISION,
+    nextWorkpackage: NEXT_WORKPACKAGE,
+    publishBoundary: PUBLISH_BOUNDARY,
+    publishAllowed: false,
+    packagePrivateRequired: true
+  };
+}
+
+function validateEpic13TrustedDomBoundaryPlan(plan = createEpic13TrustedDomBoundaryPlan()) {
+  const errors = [];
+  const proof = plan && plan.boundaryProof ? plan.boundaryProof : {};
+
+  if (!plan || plan.schema !== EPIC13_TRUSTED_DOM_BOUNDARY_SCHEMA) errors.push(`schema must be ${EPIC13_TRUSTED_DOM_BOUNDARY_SCHEMA}`);
+  if (!plan || plan.fixtureSchema !== EPIC13_TRUSTED_DOM_BOUNDARY_FIXTURE_SCHEMA) errors.push(`fixtureSchema must be ${EPIC13_TRUSTED_DOM_BOUNDARY_FIXTURE_SCHEMA}`);
+  if (!plan || plan.reportSchema !== EPIC13_TRUSTED_DOM_BOUNDARY_REPORT_SCHEMA) errors.push(`reportSchema must be ${EPIC13_TRUSTED_DOM_BOUNDARY_REPORT_SCHEMA}`);
+  if (!plan || plan.workpackage !== EPIC13_TRUSTED_DOM_BOUNDARY_WORKPACKAGE) errors.push(`workpackage must be ${EPIC13_TRUSTED_DOM_BOUNDARY_WORKPACKAGE}`);
+  if (!plan || plan.status !== EPIC13_TRUSTED_DOM_BOUNDARY_STATUS) errors.push(`status must be ${EPIC13_TRUSTED_DOM_BOUNDARY_STATUS}`);
+  if (!plan || plan.sourceSchema !== EPIC13_DOCS_RMT_PRODUCTION_HARDENING_SCHEMA) errors.push('source schema must be Docs RMT production hardening');
+  if (!plan || plan.sourceValidationOk !== true || plan.sourceReportOk !== true) errors.push('Docs RMT production hardening source must validate');
+  if (!plan || plan.targetReadiness !== EPIC13_TRUSTED_DOM_BOUNDARY_TARGET) errors.push(`targetReadiness must be ${EPIC13_TRUSTED_DOM_BOUNDARY_TARGET}`);
+  if (!plan || plan.trustedDomPolicy !== TRUSTED_DOM_POLICY_CONTRACT) errors.push(`trustedDomPolicy must be ${TRUSTED_DOM_POLICY_CONTRACT}`);
+  if (!plan || plan.trustedDomSanitizer !== TRUSTED_DOM_SANITIZER_CONTRACT) errors.push(`trustedDomSanitizer must be ${TRUSTED_DOM_SANITIZER_CONTRACT}`);
+  if (!plan || plan.trustBoundary !== SANITIZING_BOUNDARY_CONTRACT) errors.push(`trustBoundary must be ${SANITIZING_BOUNDARY_CONTRACT}`);
+  if (!plan || plan.fixture !== TRUSTED_DOM_BOUNDARY_FIXTURE) errors.push(`fixture must be ${TRUSTED_DOM_BOUNDARY_FIXTURE}`);
+  if (!plan || plan.resultKey !== TRUSTED_DOM_BOUNDARY_RESULT_KEY) errors.push(`resultKey must be ${TRUSTED_DOM_BOUNDARY_RESULT_KEY}`);
+  REQUIRED_SOURCE_GATES.forEach((gate) => {
+    if (!plan || !plan.sourceGates.includes(gate)) errors.push(`source gate missing: ${gate}`);
+  });
+  REQUIRED_BROWSER_ASSERTIONS.forEach((assertion) => {
+    if (!plan || !plan.requiredBrowserAssertions.includes(assertion)) errors.push(`browser assertion missing: ${assertion}`);
+  });
+  REQUIRED_ARTIFACTS.forEach((artifact) => {
+    if (!plan || !plan.artifactPaths.includes(artifact)) errors.push(`artifact missing: ${artifact}`);
+  });
+  if (!proof.parsedownHtmlRequiresSanitizer || !proof.rmtHtmlFragmentRequiresSanitizer) errors.push('Parsedown HTML and RMT HTML fragments must require sanitizer');
+  if (!proof.structuredDomDescriptorPreferred || !proof.hostOwnsSanitizingSink) errors.push('Structured descriptors must stay preferred and host must own sanitizing sink');
+  if (!proof.scriptsBlocked || !proof.inlineEventHandlersBlocked || !proof.javascriptUrlsBlocked || !proof.srcdocBlocked) errors.push('trusted DOM proof must block scripts, inline handlers, javascript URLs and srcdoc');
+  if (!plan || plan.localGateMode !== 'static-fixture-plus-trusted-dom-sanitizer-proof') errors.push('local gate mode must stay static fixture plus sanitizer proof');
+  if (!plan || plan.externalBrowserRequiredInLocalGate !== false || plan.externalNetworkAllowedInLocalGate !== false) errors.push('local gate must not require external browser or network');
+  if (!plan || plan.frameworkAgnostic !== true) errors.push('trusted DOM boundary proof must stay framework agnostic');
+  if (!plan || plan.rmtKernelImportsSanitizer !== false || plan.rmtKernelImportsParsedown !== false || plan.rmtKernelImportsXtendTypes !== false) errors.push('RMT kernel must not import sanitizer, Parsedown or XTend types');
+  if (!plan || plan.kernelBoundary !== KERNEL_BOUNDARY) errors.push(`kernelBoundary must be ${KERNEL_BOUNDARY}`);
+  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_TRUSTED_DOM_BOUNDARY_REPORT_SCHEMA,
+    ok: errors.length === 0,
+    errors
+  };
+}
+
+function createEpic13TrustedDomBoundaryReport(options = {}) {
+  const plan = options.plan || createEpic13TrustedDomBoundaryPlan(options);
+  const validation = validateEpic13TrustedDomBoundaryPlan(plan);
+
+  return {
+    schema: EPIC13_TRUSTED_DOM_BOUNDARY_REPORT_SCHEMA,
+    ok: validation.ok,
+    errors: validation.errors,
+    plan,
+    sourceGateCount: plan.sourceGates.length,
+    browserAssertionCount: plan.requiredBrowserAssertions.length,
+    fixture: plan.fixture,
+    trustedDomSanitizer: plan.trustedDomSanitizer,
+    publishAllowed: plan.publishAllowed,
+    nextWorkpackage: plan.nextWorkpackage
+  };
+}
+
+module.exports = {
+  EPIC13_TRUSTED_DOM_BOUNDARY_CONTRACT,
+  EPIC13_TRUSTED_DOM_BOUNDARY_DOCS,
+  EPIC13_TRUSTED_DOM_BOUNDARY_FIXTURE_SCHEMA,
+  EPIC13_TRUSTED_DOM_BOUNDARY_LOCAL_GATE,
+  EPIC13_TRUSTED_DOM_BOUNDARY_MODULE,
+  EPIC13_TRUSTED_DOM_BOUNDARY_PACKAGE_SCRIPT,
+  EPIC13_TRUSTED_DOM_BOUNDARY_REPORT_ARTIFACT,
+  EPIC13_TRUSTED_DOM_BOUNDARY_REPORT_SCHEMA,
+  EPIC13_TRUSTED_DOM_BOUNDARY_SCHEMA,
+  EPIC13_TRUSTED_DOM_BOUNDARY_STATUS,
+  EPIC13_TRUSTED_DOM_BOUNDARY_STEERING,
+  EPIC13_TRUSTED_DOM_BOUNDARY_SUITE,
+  EPIC13_TRUSTED_DOM_BOUNDARY_TARGET,
+  EPIC13_TRUSTED_DOM_BOUNDARY_WORKPACKAGE,
+  EPIC13_TRUSTED_DOM_BOUNDARY_WORKPACKAGE_DOC,
+  NEXT_DECISION,
+  NEXT_WORKPACKAGE,
+  PUBLISH_BOUNDARY,
+  REQUIRED_ARTIFACTS,
+  REQUIRED_BROWSER_ASSERTIONS,
+  REQUIRED_SOURCE_GATES,
+  TRUSTED_DOM_BOUNDARY_FIXTURE,
+  TRUSTED_DOM_BOUNDARY_RESULT_KEY,
+  createEpic13TrustedDomBoundaryPlan,
+  createEpic13TrustedDomBoundaryReport,
+  validateEpic13TrustedDomBoundaryPlan
+};

package/catalog/epic13-visual-owner-artifact.d.ts

@@ -0,0 +1,35 @@
+import type {
+  XtendCatalogConstant,
+  XtendCatalogGate,
+  XtendCatalogOptions,
+  XtendCatalogPlan,
+  XtendCatalogRecord,
+  XtendCatalogReport
+} from './catalog-public-types';
+
+
+export declare const DETERMINISTIC_VIEWPORTS: readonly XtendCatalogConstant[] | XtendCatalogConstant;
+export declare const EPIC13_VISUAL_OWNER_ARTIFACT_CONTRACT: string;
+export declare const EPIC13_VISUAL_OWNER_ARTIFACT_DOCS: readonly XtendCatalogConstant[] | XtendCatalogConstant;
+export declare const EPIC13_VISUAL_OWNER_ARTIFACT_LOCAL_GATE: string;
+export declare const EPIC13_VISUAL_OWNER_ARTIFACT_MANIFEST_SCHEMA: string;
+export declare const EPIC13_VISUAL_OWNER_ARTIFACT_MODULE: string;
+export declare const EPIC13_VISUAL_OWNER_ARTIFACT_PACKAGE_SCRIPT: string;
+export declare const EPIC13_VISUAL_OWNER_ARTIFACT_REPORT_SCHEMA: string;
+export declare const EPIC13_VISUAL_OWNER_ARTIFACT_SCHEMA: string;
+export declare const EPIC13_VISUAL_OWNER_ARTIFACT_STATUS: string;
+export declare const EPIC13_VISUAL_OWNER_ARTIFACT_STEERING: XtendCatalogConstant;
+export declare const EPIC13_VISUAL_OWNER_ARTIFACT_SUITE: string;
+export declare const EPIC13_VISUAL_OWNER_ARTIFACT_TARGET: string;
+export declare const EPIC13_VISUAL_OWNER_ARTIFACT_WORKPACKAGE: string;
+export declare const EPIC13_VISUAL_OWNER_ARTIFACT_WORKPACKAGE_DOC: 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 const VISUAL_OWNER_ARTIFACT_MANIFEST: XtendCatalogConstant;
+export declare const VISUAL_OWNER_ARTIFACT_PATH_TEMPLATE: XtendCatalogConstant;
+export declare const VISUAL_OWNER_ARTIFACT_REPORT: XtendCatalogConstant;
+export declare const VISUAL_OWNER_ARTIFACT_ROOT: XtendCatalogConstant;
+export declare function createEpic13VisualOwnerArtifactPlan(options?: XtendCatalogOptions): XtendCatalogPlan;
+export declare function createEpic13VisualOwnerArtifactReport(options?: XtendCatalogOptions): XtendCatalogReport;
+export declare function validateEpic13VisualOwnerArtifactPlan(plan?: unknown): XtendCatalogReport;