@ccslabs/xtend 0.1.0-rc.1

package/catalog/epic13-release-owner-acceptance.js

@@ -0,0 +1,354 @@
+const {
+  KERNEL_BOUNDARY,
+  createEpic12Rc0HandoffReport
+} = require('./epic12-rc0-handoff');
+const {
+  EPIC13_RC1_READINESS_REPORT_SCHEMA,
+  EPIC13_RC1_READINESS_SCHEMA,
+  createEpic13Rc1ReadinessModel,
+  createEpic13Rc1ReadinessReport,
+  validateEpic13Rc1ReadinessModel
+} = require('./epic13-rc1-readiness');
+
+const EPIC13_RELEASE_OWNER_ACCEPTANCE_SCHEMA = 'xtend.epic13.release-owner-acceptance.v1';
+const EPIC13_RELEASE_OWNER_ACCEPTANCE_REPORT_SCHEMA = 'xtend.epic13.release-owner-acceptance-report.v1';
+const EPIC13_RELEASE_OWNER_ACCEPTANCE_WORKPACKAGE = 'WP-E13-02';
+const EPIC13_RELEASE_OWNER_ACCEPTANCE_STATUS = 'accepted-release-owner-acceptance-contract';
+const EPIC13_RELEASE_OWNER_ACCEPTANCE_TARGET = 'release-owner-acceptance-contract-ready';
+const EPIC13_RELEASE_OWNER_ACCEPTANCE_MODULE = 'catalog/epic13-release-owner-acceptance.js';
+const EPIC13_RELEASE_OWNER_ACCEPTANCE_SUITE = 'tests/platform/epic13_release_owner_acceptance_suite.js';
+const EPIC13_RELEASE_OWNER_ACCEPTANCE_STEERING = 'development/RC0-RC1-transfer-EPIC13.md';
+const EPIC13_RELEASE_OWNER_ACCEPTANCE_CONTRACT = 'development/XTend-Epic13-Release-Owner-Acceptance-Contract.md';
+const EPIC13_RELEASE_OWNER_ACCEPTANCE_WORKPACKAGE_DOC = 'development/WP-E13-02-Release-Owner-Acceptance-Contract-definieren.md';
+const EPIC13_RELEASE_OWNER_ACCEPTANCE_DOCS = 'docs/release-owner-acceptance.md';
+const EPIC13_RELEASE_OWNER_ACCEPTANCE_LOCAL_GATE = 'node scripts/run_xtend_tests.js epic13-release-owner-acceptance --json';
+const EPIC13_RELEASE_OWNER_ACCEPTANCE_PACKAGE_SCRIPT = 'npm run test:epic13-release-owner-acceptance';
+const PUBLISH_BOUNDARY = 'private-until-release-owner-acceptance';
+
+const OWNER_DECISION_STATES = Object.freeze([
+  'accepted',
+  'deferred',
+  'blocked'
+]);
+
+const REQUIRED_OWNER_INPUTS = Object.freeze([
+  'xtend-release-gate-report',
+  'xtend-release-report',
+  'xtend-rc0-gate-matrix-report',
+  'xtend-epic12-rc0-handoff-report',
+  'xtend-epic13-rc1-readiness-report',
+  'package-dry-run-output',
+  'conditional-network-gate-status',
+  'known-residual-policy',
+  'migration-notes',
+  'publish-boundary-decision'
+]);
+
+const REQUIRED_LOCAL_GATES = Object.freeze([
+  'epic12-rc0-handoff',
+  'epic13-rc1-readiness',
+  'release:report',
+  'references'
+]);
+
+const REQUIRED_SOURCE_SCHEMAS = Object.freeze([
+  'xtend.epic12.rc0-handoff.v1',
+  EPIC13_RC1_READINESS_SCHEMA,
+  EPIC13_RC1_READINESS_REPORT_SCHEMA,
+  'xtend.release.checklist-semver-policy.v1',
+  'xtend.ci.gate-matrix.v1'
+]);
+
+const REQUIRED_DOCS = Object.freeze([
+  EPIC13_RELEASE_OWNER_ACCEPTANCE_STEERING,
+  EPIC13_RELEASE_OWNER_ACCEPTANCE_CONTRACT,
+  EPIC13_RELEASE_OWNER_ACCEPTANCE_WORKPACKAGE_DOC,
+  EPIC13_RELEASE_OWNER_ACCEPTANCE_DOCS,
+  'development/XTend-Epic13-RC1-Readiness-Modell.md',
+  'development/XTend-Epic12-Abschluss-und-RC0-Handoff.md',
+  'development/XTend-Release-Checklist-und-SemVer-Policy.md',
+  'development/XTend-CI-Gate-Matrix.md',
+  'docs/rc1-readiness.md',
+  'docs/enterprise-adoption.md'
+]);
+
+const OWNER_REVIEW_CHECKLIST = Object.freeze([
+  {
+    id: 'rc1-readiness-model',
+    status: 'accepted',
+    artifact: 'xtend.epic13.rc1-production-readiness.v1',
+    ownerQuestion: 'Ist der RC0-zu-RC1-Schnitt formal nachvollziehbar?',
+    evidence: 'catalog/epic13-rc1-readiness.js'
+  },
+  {
+    id: 'rc0-owner-handoff',
+    status: 'accepted',
+    artifact: 'xtend.epic12.rc0-handoff.v1',
+    ownerQuestion: 'Ist RC0 als Review-Basis akzeptiert?',
+    evidence: 'development/XTend-Epic12-Abschluss-und-RC0-Handoff.md'
+  },
+  {
+    id: 'release-report-required',
+    status: 'accepted',
+    artifact: 'npm run release:report',
+    ownerQuestion: 'Bleibt der lokale Release Report ein Pflichtartefakt?',
+    evidence: '.xtend-test-results/xtend-release-report.json'
+  },
+  {
+    id: 'package-private-boundary',
+    status: 'accepted',
+    artifact: PUBLISH_BOUNDARY,
+    ownerQuestion: 'Bleibt `private: true` bis zur Owner-Freigabe aktiv?',
+    evidence: 'package.json'
+  },
+  {
+    id: 'rmt-kernel-neutrality',
+    status: 'accepted',
+    artifact: KERNEL_BOUNDARY,
+    ownerQuestion: 'Bleibt XTendRMT framework-agnostisch?',
+    evidence: 'xtendrmt/rmt-core.esm.js'
+  },
+  {
+    id: 'conditional-network-evidence',
+    status: 'accepted',
+    targetWorkpackages: [],
+    ownerQuestion: 'Wurden Audit und SBOM ausgefuehrt oder begruendet deferred?',
+    evidence: 'xtend.epic13.conditional-network-evidence.v1'
+  },
+  {
+    id: 'package-dry-run-export-lock',
+    status: 'accepted',
+    targetWorkpackages: [],
+    ownerQuestion: 'Ist der Paketinhalt maschinenlesbar gelockt?',
+    evidence: 'xtend.epic13.package-export-lock.v1'
+  },
+  {
+    id: 'known-residual-renewal',
+    status: 'accepted',
+    targetWorkpackages: [],
+    ownerQuestion: 'Sind RC0-Residuals fuer RC1 geschlossen oder neu akzeptiert?',
+    evidence: 'xtend.epic13.known-residual-triage.v1, xtend.epic13.hydration-performance-closure.v1'
+  },
+  {
+    id: 'prod-browser-csp-smoke',
+    status: 'accepted',
+    targetWorkpackages: [],
+    ownerQuestion: 'Sind PROD-nahe Browser-, Server- und Trusted-DOM-Pfade geprueft?',
+    evidence: 'npm run test:browser, npm run test:manifest-policy'
+  },
+  {
+    id: 'trusted-dom-boundary',
+    status: 'accepted',
+    targetWorkpackages: [],
+    ownerQuestion: 'Ist die Trusted-DOM-Boundary fuer Parsedown und RMT HTML browsernah belegt?',
+    evidence: 'xtend.epic13.trusted-dom-boundary.v1'
+  },
+  {
+    id: 'visual-owner-artifact',
+    status: 'accepted',
+    targetWorkpackages: [],
+    ownerQuestion: 'Gibt es ein fuer Owner reviewbares UI-Artefakt?',
+    evidence: 'xtend.epic13.visual-owner-artifact.v1'
+  },
+  {
+    id: 'rmt-production-readiness',
+    status: 'accepted',
+    targetWorkpackages: [],
+    ownerQuestion: 'Ist die RMT-first App Shell als PROD-Pfad gebuendelt?',
+    evidence: 'xtend.epic13.rmt-production-readiness.v1'
+  },
+  {
+    id: 'docs-rmt-production-hardening',
+    status: 'accepted',
+    targetWorkpackages: [],
+    ownerQuestion: 'Ist die Docs-App RMT Parsedown Shell fuer PROD-nahe Erweiterungen gehaertet?',
+    evidence: 'xtend.epic13.docs-rmt-production-hardening.v1'
+  },
+  {
+    id: 'rc1-migration-notes',
+    status: 'accepted',
+    targetWorkpackages: [],
+    ownerQuestion: 'Sind Migration Notes und SemVer-Entscheid konsumierbar?',
+    evidence: 'xtend.epic13.rc1-migration-notes-semver.v1'
+  },
+  {
+    id: 'rc1-gate-matrix',
+    status: 'deferred',
+    targetWorkpackages: ['WP-E13-13'],
+    ownerQuestion: 'Sind alle RC1-Gates in einer finalen Matrix verbunden?',
+    evidence: 'development/XTend-CI-Gate-Matrix.md'
+  },
+  {
+    id: 'automatic-publish-approval',
+    status: 'blocked',
+    targetWorkpackages: ['WP-E13-14'],
+    ownerQuestion: 'Darf ein gruener Gate automatisch publishen?',
+    evidence: 'package.json private=true'
+  }
+]).map((entry) => ({
+  targetWorkpackages: [],
+  ...entry
+}));
+
+function summarizeChecklist(checklist) {
+  return checklist.reduce((summary, item) => {
+    summary[item.status] = (summary[item.status] || 0) + 1;
+    summary.total += 1;
+    summary.byStatus[item.status].push(item.id);
+    return summary;
+  }, {
+    total: 0,
+    accepted: 0,
+    deferred: 0,
+    blocked: 0,
+    byStatus: {
+      accepted: [],
+      deferred: [],
+      blocked: []
+    }
+  });
+}
+
+function createEpic13ReleaseOwnerAcceptanceContract(options = {}) {
+  const rc1ReadinessModel = options.rc1ReadinessModel || createEpic13Rc1ReadinessModel(options);
+  const rc1ReadinessValidation = options.rc1ReadinessValidation || validateEpic13Rc1ReadinessModel(rc1ReadinessModel);
+  const rc1ReadinessReport = options.rc1ReadinessReport || createEpic13Rc1ReadinessReport({ ...options, model: rc1ReadinessModel });
+  const rc0HandoffReport = options.rc0HandoffReport || createEpic12Rc0HandoffReport(options);
+  const reviewChecklist = OWNER_REVIEW_CHECKLIST.map((entry) => ({
+    ...entry,
+    targetWorkpackages: entry.targetWorkpackages.slice()
+  }));
+  const decisionSummary = summarizeChecklist(reviewChecklist);
+
+  return {
+    schema: EPIC13_RELEASE_OWNER_ACCEPTANCE_SCHEMA,
+    reportSchema: EPIC13_RELEASE_OWNER_ACCEPTANCE_REPORT_SCHEMA,
+    workpackage: EPIC13_RELEASE_OWNER_ACCEPTANCE_WORKPACKAGE,
+    status: EPIC13_RELEASE_OWNER_ACCEPTANCE_STATUS,
+    generatedAt: options.generatedAt || 'static-local',
+    module: EPIC13_RELEASE_OWNER_ACCEPTANCE_MODULE,
+    suite: EPIC13_RELEASE_OWNER_ACCEPTANCE_SUITE,
+    steeringDocument: EPIC13_RELEASE_OWNER_ACCEPTANCE_STEERING,
+    contract: EPIC13_RELEASE_OWNER_ACCEPTANCE_CONTRACT,
+    workpackageDocument: EPIC13_RELEASE_OWNER_ACCEPTANCE_WORKPACKAGE_DOC,
+    docs: EPIC13_RELEASE_OWNER_ACCEPTANCE_DOCS,
+    localGate: EPIC13_RELEASE_OWNER_ACCEPTANCE_LOCAL_GATE,
+    packageScript: EPIC13_RELEASE_OWNER_ACCEPTANCE_PACKAGE_SCRIPT,
+    sourceSchema: EPIC13_RC1_READINESS_SCHEMA,
+    sourceReportSchema: EPIC13_RC1_READINESS_REPORT_SCHEMA,
+    sourceStatus: rc1ReadinessModel.status,
+    sourceTargetReadiness: rc1ReadinessModel.targetReadiness,
+    sourceReportOk: rc1ReadinessReport.ok,
+    sourceValidationOk: rc1ReadinessValidation.ok,
+    rc0HandoffOk: rc0HandoffReport.ok,
+    releaseCandidate: 'RC1',
+    targetReadiness: EPIC13_RELEASE_OWNER_ACCEPTANCE_TARGET,
+    ownerDecisionStates: OWNER_DECISION_STATES.slice(),
+    reviewChecklist,
+    decisionSummary,
+    requiredOwnerInputs: REQUIRED_OWNER_INPUTS.slice(),
+    requiredLocalGates: REQUIRED_LOCAL_GATES.slice(),
+    requiredSourceSchemas: REQUIRED_SOURCE_SCHEMAS.slice(),
+    requiredDocs: REQUIRED_DOCS.slice(),
+    deferralPolicy: {
+      allowed: true,
+      ownerReasonRequired: true,
+      targetWorkpackageRequired: true,
+      publishAllowedForDeferredItems: false
+    },
+    nextDecision: 'rc1-gate-matrix-ci-handoff',
+    nextWorkpackage: 'WP-E13-13',
+    kernelBoundary: KERNEL_BOUNDARY,
+    publishBoundary: PUBLISH_BOUNDARY,
+    publishAllowed: false,
+    automaticPublishApproval: false,
+    packagePrivateRequired: true
+  };
+}
+
+function validateEpic13ReleaseOwnerAcceptanceContract(contract = createEpic13ReleaseOwnerAcceptanceContract()) {
+  const errors = [];
+  const checklist = contract && Array.isArray(contract.reviewChecklist) ? contract.reviewChecklist : [];
+  const invalidStatuses = checklist.filter((entry) => !OWNER_DECISION_STATES.includes(entry.status));
+  const deferredWithoutTargets = checklist.filter((entry) => entry.status === 'deferred' && (!Array.isArray(entry.targetWorkpackages) || entry.targetWorkpackages.length === 0));
+  const blockedPublish = checklist.find((entry) => entry.id === 'automatic-publish-approval' && entry.status === 'blocked');
+
+  if (!contract || contract.schema !== EPIC13_RELEASE_OWNER_ACCEPTANCE_SCHEMA) errors.push(`schema must be ${EPIC13_RELEASE_OWNER_ACCEPTANCE_SCHEMA}`);
+  if (!contract || contract.reportSchema !== EPIC13_RELEASE_OWNER_ACCEPTANCE_REPORT_SCHEMA) errors.push(`reportSchema must be ${EPIC13_RELEASE_OWNER_ACCEPTANCE_REPORT_SCHEMA}`);
+  if (!contract || contract.workpackage !== EPIC13_RELEASE_OWNER_ACCEPTANCE_WORKPACKAGE) errors.push(`workpackage must be ${EPIC13_RELEASE_OWNER_ACCEPTANCE_WORKPACKAGE}`);
+  if (!contract || contract.status !== EPIC13_RELEASE_OWNER_ACCEPTANCE_STATUS) errors.push(`status must be ${EPIC13_RELEASE_OWNER_ACCEPTANCE_STATUS}`);
+  if (!contract || contract.sourceSchema !== EPIC13_RC1_READINESS_SCHEMA) errors.push('source schema must be Epic 13 RC1 readiness');
+  if (!contract || contract.sourceValidationOk !== true || contract.sourceReportOk !== true || contract.rc0HandoffOk !== true) errors.push('source readiness and RC0 handoff must validate');
+  if (!contract || contract.targetReadiness !== EPIC13_RELEASE_OWNER_ACCEPTANCE_TARGET) errors.push(`targetReadiness must be ${EPIC13_RELEASE_OWNER_ACCEPTANCE_TARGET}`);
+  if (!contract || contract.nextDecision !== 'rc1-gate-matrix-ci-handoff') errors.push('next decision must be RC1 Gate Matrix und CI-Handoff');
+  if (!contract || contract.nextWorkpackage !== 'WP-E13-13') errors.push('next workpackage must be WP-E13-13');
+  if (!contract || contract.kernelBoundary !== KERNEL_BOUNDARY) errors.push(`kernelBoundary must be ${KERNEL_BOUNDARY}`);
+  if (!contract || contract.publishBoundary !== PUBLISH_BOUNDARY) errors.push(`publishBoundary must be ${PUBLISH_BOUNDARY}`);
+  if (!contract || contract.publishAllowed !== false || contract.automaticPublishApproval !== false || contract.packagePrivateRequired !== true) errors.push('publish must remain blocked and private');
+  if (!contract || !Array.isArray(contract.ownerDecisionStates) || contract.ownerDecisionStates.join('|') !== OWNER_DECISION_STATES.join('|')) errors.push('owner decision states must be accepted/deferred/blocked');
+  if (invalidStatuses.length > 0) errors.push(`invalid owner decision states: ${invalidStatuses.map((entry) => entry.id).join(', ')}`);
+  if (deferredWithoutTargets.length > 0) errors.push(`deferred items must name target workpackages: ${deferredWithoutTargets.map((entry) => entry.id).join(', ')}`);
+  if (!blockedPublish) errors.push('automatic publish approval must be blocked');
+  if (!contract || contract.decisionSummary.accepted < 5) errors.push('owner checklist must accept RC1 baseline items');
+  if (!contract || contract.decisionSummary.deferred < 1) errors.push('owner checklist must defer remaining RC1 hardening items');
+  if (!contract || contract.decisionSummary.blocked < 1) errors.push('owner checklist must block automatic publish');
+  REQUIRED_OWNER_INPUTS.forEach((input) => {
+    if (!contract || !contract.requiredOwnerInputs.includes(input)) errors.push(`owner input missing: ${input}`);
+  });
+  REQUIRED_LOCAL_GATES.forEach((gate) => {
+    if (!contract || !contract.requiredLocalGates.includes(gate)) errors.push(`local gate missing: ${gate}`);
+  });
+  REQUIRED_SOURCE_SCHEMAS.forEach((schema) => {
+    if (!contract || !contract.requiredSourceSchemas.includes(schema)) errors.push(`source schema missing: ${schema}`);
+  });
+
+  return {
+    schema: EPIC13_RELEASE_OWNER_ACCEPTANCE_REPORT_SCHEMA,
+    ok: errors.length === 0,
+    errors
+  };
+}
+
+function createEpic13ReleaseOwnerAcceptanceReport(options = {}) {
+  const contract = options.contract || createEpic13ReleaseOwnerAcceptanceContract(options);
+  const validation = validateEpic13ReleaseOwnerAcceptanceContract(contract);
+
+  return {
+    schema: EPIC13_RELEASE_OWNER_ACCEPTANCE_REPORT_SCHEMA,
+    ok: validation.ok,
+    errors: validation.errors,
+    contract,
+    decisionSummary: contract.decisionSummary,
+    checklistCount: contract.reviewChecklist.length,
+    requiredOwnerInputCount: contract.requiredOwnerInputs.length,
+    publishAllowed: contract.publishAllowed,
+    automaticPublishApproval: contract.automaticPublishApproval,
+    nextWorkpackage: contract.nextWorkpackage
+  };
+}
+
+module.exports = {
+  EPIC13_RELEASE_OWNER_ACCEPTANCE_CONTRACT,
+  EPIC13_RELEASE_OWNER_ACCEPTANCE_DOCS,
+  EPIC13_RELEASE_OWNER_ACCEPTANCE_LOCAL_GATE,
+  EPIC13_RELEASE_OWNER_ACCEPTANCE_MODULE,
+  EPIC13_RELEASE_OWNER_ACCEPTANCE_PACKAGE_SCRIPT,
+  EPIC13_RELEASE_OWNER_ACCEPTANCE_REPORT_SCHEMA,
+  EPIC13_RELEASE_OWNER_ACCEPTANCE_SCHEMA,
+  EPIC13_RELEASE_OWNER_ACCEPTANCE_STATUS,
+  EPIC13_RELEASE_OWNER_ACCEPTANCE_STEERING,
+  EPIC13_RELEASE_OWNER_ACCEPTANCE_SUITE,
+  EPIC13_RELEASE_OWNER_ACCEPTANCE_TARGET,
+  EPIC13_RELEASE_OWNER_ACCEPTANCE_WORKPACKAGE,
+  EPIC13_RELEASE_OWNER_ACCEPTANCE_WORKPACKAGE_DOC,
+  OWNER_DECISION_STATES,
+  OWNER_REVIEW_CHECKLIST,
+  PUBLISH_BOUNDARY,
+  REQUIRED_DOCS,
+  REQUIRED_LOCAL_GATES,
+  REQUIRED_OWNER_INPUTS,
+  REQUIRED_SOURCE_SCHEMAS,
+  createEpic13ReleaseOwnerAcceptanceContract,
+  createEpic13ReleaseOwnerAcceptanceReport,
+  validateEpic13ReleaseOwnerAcceptanceContract
+};

package/catalog/epic13-release-report-pack-dry-run-evidence.d.ts

@@ -0,0 +1,36 @@
+import type {
+  XtendCatalogConstant,
+  XtendCatalogOptions,
+  XtendCatalogPlan,
+  XtendCatalogRecord,
+  XtendCatalogReport
+} from './catalog-public-types';
+
+
+export declare const EPIC13_RELEASE_REPORT_PACK_DRY_RUN_EVIDENCE_CONTRACT: string;
+export declare const EPIC13_RELEASE_REPORT_PACK_DRY_RUN_EVIDENCE_DOCS: readonly XtendCatalogConstant[] | XtendCatalogConstant;
+export declare const EPIC13_RELEASE_REPORT_PACK_DRY_RUN_EVIDENCE_LOCAL_GATE: string;
+export declare const EPIC13_RELEASE_REPORT_PACK_DRY_RUN_EVIDENCE_MODULE: string;
+export declare const EPIC13_RELEASE_REPORT_PACK_DRY_RUN_EVIDENCE_PACKAGE_EXPORT: string;
+export declare const EPIC13_RELEASE_REPORT_PACK_DRY_RUN_EVIDENCE_PACKAGE_SCRIPT: string;
+export declare const EPIC13_RELEASE_REPORT_PACK_DRY_RUN_EVIDENCE_REPORT_ARTIFACT: string;
+export declare const EPIC13_RELEASE_REPORT_PACK_DRY_RUN_EVIDENCE_REPORT_SCHEMA: string;
+export declare const EPIC13_RELEASE_REPORT_PACK_DRY_RUN_EVIDENCE_SCHEMA: string;
+export declare const EPIC13_RELEASE_REPORT_PACK_DRY_RUN_EVIDENCE_STATUS: string;
+export declare const EPIC13_RELEASE_REPORT_PACK_DRY_RUN_EVIDENCE_SUITE: string;
+export declare const EPIC13_RELEASE_REPORT_PACK_DRY_RUN_EVIDENCE_TARGET: string;
+export declare const EPIC13_RELEASE_REPORT_PACK_DRY_RUN_EVIDENCE_WORKPACKAGE: string;
+export declare const EPIC13_RELEASE_REPORT_PACK_DRY_RUN_EVIDENCE_WORKPACKAGE_DOC: XtendCatalogConstant;
+export declare const NEXT_DECISION: XtendCatalogConstant;
+export declare const NEXT_WORKPACKAGE: string;
+export declare const PACK_DRY_RUN_COMMAND: string;
+export declare const PACK_DRY_RUN_RAW_COMMAND: string;
+export declare const PACK_DRY_RUN_REPORT_COMMAND: string;
+export declare const PUBLISH_BOUNDARY: XtendCatalogConstant;
+export declare const RELEASE_REPORT_ARTIFACT: string;
+export declare const RELEASE_REPORT_COMMAND: string;
+export declare const REQUIRED_OWNER_EVIDENCE: readonly XtendCatalogRecord[] | XtendCatalogRecord;
+export declare const REQUIRED_REFERENCE_PATHS: readonly XtendCatalogConstant[] | XtendCatalogConstant;
+export declare function createEpic13ReleaseReportPackDryRunEvidencePlan(options?: XtendCatalogOptions): XtendCatalogPlan;
+export declare function createEpic13ReleaseReportPackDryRunEvidenceReport(options?: XtendCatalogOptions): XtendCatalogReport;
+export declare function validateEpic13ReleaseReportPackDryRunEvidencePlan(plan?: unknown): XtendCatalogReport;

package/catalog/epic13-release-report-pack-dry-run-evidence.js

@@ -0,0 +1,253 @@
+const {
+  createEpic13Rc1GateMatrixCiHandoffPlan,
+  createEpic13Rc1GateMatrixCiHandoffReport,
+  validateEpic13Rc1GateMatrixCiHandoffPlan
+} = require('./epic13-rc1-gate-matrix-ci-handoff');
+const {
+  PACKAGE_DRY_RUN_ARTIFACT,
+  PACKAGE_EXPORT_LOCK_REPORT_ARTIFACT,
+  PACKAGE_EXPORT_SURFACE_ARTIFACT
+} = require('./epic13-package-export-lock');
+
+const EPIC13_RELEASE_REPORT_PACK_DRY_RUN_EVIDENCE_SCHEMA = 'xtend.epic13.release-report-pack-dry-run-evidence.v1';
+const EPIC13_RELEASE_REPORT_PACK_DRY_RUN_EVIDENCE_REPORT_SCHEMA = 'xtend.epic13.release-report-pack-dry-run-evidence-report.v1';
+const EPIC13_RELEASE_REPORT_PACK_DRY_RUN_EVIDENCE_WORKPACKAGE = 'DPF-WP-02-release-report-pack-dry-run';
+const EPIC13_RELEASE_REPORT_PACK_DRY_RUN_EVIDENCE_STATUS = 'accepted-release-report-pack-dry-run-evidence';
+const EPIC13_RELEASE_REPORT_PACK_DRY_RUN_EVIDENCE_TARGET = 'release-owner-artifacts-reproducible';
+const EPIC13_RELEASE_REPORT_PACK_DRY_RUN_EVIDENCE_MODULE = 'catalog/epic13-release-report-pack-dry-run-evidence.js';
+const EPIC13_RELEASE_REPORT_PACK_DRY_RUN_EVIDENCE_SUITE = 'tests/platform/epic13_release_report_pack_dry_run_evidence_suite.js';
+const EPIC13_RELEASE_REPORT_PACK_DRY_RUN_EVIDENCE_CONTRACT = 'development/XTend-Epic13-Release-Report-und-Pack-Dry-Run-Evidence.md';
+const EPIC13_RELEASE_REPORT_PACK_DRY_RUN_EVIDENCE_WORKPACKAGE_DOC = 'development/DPF-WP-02-Release-Report-und-Pack-Dry-Run-Evidence.md';
+const EPIC13_RELEASE_REPORT_PACK_DRY_RUN_EVIDENCE_DOCS = 'docs/release-report-pack-dry-run-evidence.md';
+const EPIC13_RELEASE_REPORT_PACK_DRY_RUN_EVIDENCE_LOCAL_GATE = 'node scripts/run_xtend_tests.js epic13-release-report-pack-dry-run-evidence --json';
+const EPIC13_RELEASE_REPORT_PACK_DRY_RUN_EVIDENCE_PACKAGE_SCRIPT = 'npm run test:epic13-release-report-pack-dry-run-evidence';
+const EPIC13_RELEASE_REPORT_PACK_DRY_RUN_EVIDENCE_REPORT_ARTIFACT = '.xtend-test-results/xtend-epic13-release-report-pack-dry-run-evidence-report.json';
+const EPIC13_RELEASE_REPORT_PACK_DRY_RUN_EVIDENCE_PACKAGE_EXPORT = './catalog/epic13-release-report-pack-dry-run-evidence';
+const RELEASE_REPORT_COMMAND = 'npm run release:report';
+const RELEASE_REPORT_ARTIFACT = '.xtend-test-results/xtend-release-report.json';
+const PACK_DRY_RUN_COMMAND = 'npm run pack:dry-run';
+const PACK_DRY_RUN_REPORT_COMMAND = 'npm run pack:dry-run:report';
+const PACK_DRY_RUN_RAW_COMMAND = 'npm run pack:dry-run:raw';
+const NEXT_WORKPACKAGE = 'DPF-WP-03-conditional-network-evidence-ci';
+const NEXT_DECISION = 'conditional-network-evidence-ci';
+const PUBLISH_BOUNDARY = 'private-until-release-owner-acceptance';
+
+const REQUIRED_OWNER_EVIDENCE = Object.freeze([
+  {
+    id: 'release-report',
+    command: RELEASE_REPORT_COMMAND,
+    artifact: RELEASE_REPORT_ARTIFACT,
+    schema: 'xtend.test.report.v1',
+    reproducible: true,
+    ownerVisible: true,
+    networkRequired: false
+  },
+  {
+    id: 'pack-dry-run',
+    command: PACK_DRY_RUN_COMMAND,
+    artifact: PACKAGE_DRY_RUN_ARTIFACT,
+    schema: 'npm-pack-dry-run-json-array',
+    reproducible: true,
+    ownerVisible: true,
+    networkRequired: false
+  },
+  {
+    id: 'package-export-surface-lock',
+    command: PACK_DRY_RUN_COMMAND,
+    artifact: PACKAGE_EXPORT_SURFACE_ARTIFACT,
+    schema: 'xtend.epic13.package-export-surface.v1',
+    reproducible: true,
+    ownerVisible: true,
+    networkRequired: false
+  },
+  {
+    id: 'package-export-lock-report',
+    command: PACK_DRY_RUN_COMMAND,
+    artifact: PACKAGE_EXPORT_LOCK_REPORT_ARTIFACT,
+    schema: 'xtend.epic13.package-export-lock-report.v1',
+    reproducible: true,
+    ownerVisible: true,
+    networkRequired: false
+  }
+]);
+
+const REQUIRED_REFERENCE_PATHS = Object.freeze([
+  EPIC13_RELEASE_REPORT_PACK_DRY_RUN_EVIDENCE_MODULE,
+  EPIC13_RELEASE_REPORT_PACK_DRY_RUN_EVIDENCE_SUITE,
+  EPIC13_RELEASE_REPORT_PACK_DRY_RUN_EVIDENCE_CONTRACT,
+  EPIC13_RELEASE_REPORT_PACK_DRY_RUN_EVIDENCE_WORKPACKAGE_DOC,
+  EPIC13_RELEASE_REPORT_PACK_DRY_RUN_EVIDENCE_DOCS,
+  'scripts/capture_pack_dry_run.js',
+  'development/XTend-Epic13-RC1-Gate-Matrix-und-CI-Handoff.md',
+  'docs/rc1-gate-matrix-ci-handoff.md',
+  'development/XTend-Release-Checklist-und-SemVer-Policy.md',
+  'development/XTend-CI-Gate-Matrix.md',
+  'development/XTend-Dokumentations-und-Demo-Referenzpfade.md',
+  'docs/README.md',
+  'docs/menu.json',
+  'README.md',
+  'CHANGELOG.md',
+  'tests/README.md',
+  'package.json',
+  'xtend-builder/scaffold.config.js'
+]);
+
+function getDefaultPackageManifest() {
+  return require('../package.json');
+}
+
+function createEpic13ReleaseReportPackDryRunEvidencePlan(options = {}) {
+  const packageManifest = options.packageManifest || getDefaultPackageManifest();
+  const rc1Handoff = options.rc1Handoff || createEpic13Rc1GateMatrixCiHandoffPlan(options);
+  const rc1HandoffValidation = options.rc1HandoffValidation || validateEpic13Rc1GateMatrixCiHandoffPlan(rc1Handoff);
+  const rc1HandoffReport = options.rc1HandoffReport || createEpic13Rc1GateMatrixCiHandoffReport({ ...options, plan: rc1Handoff });
+  const scripts = packageManifest.scripts || {};
+
+  return {
+    schema: EPIC13_RELEASE_REPORT_PACK_DRY_RUN_EVIDENCE_SCHEMA,
+    reportSchema: EPIC13_RELEASE_REPORT_PACK_DRY_RUN_EVIDENCE_REPORT_SCHEMA,
+    workpackage: EPIC13_RELEASE_REPORT_PACK_DRY_RUN_EVIDENCE_WORKPACKAGE,
+    status: EPIC13_RELEASE_REPORT_PACK_DRY_RUN_EVIDENCE_STATUS,
+    generatedAt: options.generatedAt || 'static-local',
+    module: EPIC13_RELEASE_REPORT_PACK_DRY_RUN_EVIDENCE_MODULE,
+    suite: EPIC13_RELEASE_REPORT_PACK_DRY_RUN_EVIDENCE_SUITE,
+    contract: EPIC13_RELEASE_REPORT_PACK_DRY_RUN_EVIDENCE_CONTRACT,
+    workpackageDocument: EPIC13_RELEASE_REPORT_PACK_DRY_RUN_EVIDENCE_WORKPACKAGE_DOC,
+    docs: EPIC13_RELEASE_REPORT_PACK_DRY_RUN_EVIDENCE_DOCS,
+    localGate: EPIC13_RELEASE_REPORT_PACK_DRY_RUN_EVIDENCE_LOCAL_GATE,
+    packageScript: EPIC13_RELEASE_REPORT_PACK_DRY_RUN_EVIDENCE_PACKAGE_SCRIPT,
+    packageExport: EPIC13_RELEASE_REPORT_PACK_DRY_RUN_EVIDENCE_PACKAGE_EXPORT,
+    reportArtifact: EPIC13_RELEASE_REPORT_PACK_DRY_RUN_EVIDENCE_REPORT_ARTIFACT,
+    targetReadiness: EPIC13_RELEASE_REPORT_PACK_DRY_RUN_EVIDENCE_TARGET,
+    sourceSchema: rc1Handoff.schema,
+    sourceReportSchema: rc1Handoff.reportSchema,
+    sourceValidationOk: rc1HandoffValidation.ok,
+    sourceReportOk: rc1HandoffReport.ok,
+    releaseReportCommand: RELEASE_REPORT_COMMAND,
+    releaseReportArtifact: RELEASE_REPORT_ARTIFACT,
+    packDryRunCommand: PACK_DRY_RUN_COMMAND,
+    packDryRunReportCommand: PACK_DRY_RUN_REPORT_COMMAND,
+    packDryRunRawCommand: PACK_DRY_RUN_RAW_COMMAND,
+    packDryRunArtifact: PACKAGE_DRY_RUN_ARTIFACT,
+    packageExportSurfaceArtifact: PACKAGE_EXPORT_SURFACE_ARTIFACT,
+    packageExportLockReportArtifact: PACKAGE_EXPORT_LOCK_REPORT_ARTIFACT,
+    packageScripts: {
+      releaseReport: scripts['release:report'],
+      packDryRun: scripts['pack:dry-run'],
+      packDryRunReport: scripts['pack:dry-run:report'],
+      packDryRunRaw: scripts['pack:dry-run:raw']
+    },
+    ownerEvidence: REQUIRED_OWNER_EVIDENCE.map((entry) => ({ ...entry })),
+    referencePaths: REQUIRED_REFERENCE_PATHS.slice(),
+    rc1HandoffReferences: [
+      RELEASE_REPORT_ARTIFACT,
+      PACKAGE_DRY_RUN_ARTIFACT,
+      PACKAGE_EXPORT_SURFACE_ARTIFACT,
+      PACKAGE_EXPORT_LOCK_REPORT_ARTIFACT,
+      EPIC13_RELEASE_REPORT_PACK_DRY_RUN_EVIDENCE_REPORT_ARTIFACT
+    ],
+    auditSbomIncluded: false,
+    publicPublishDecisionIncluded: false,
+    licenseDecisionIncluded: false,
+    docsMenuSlug: 'release-report-pack-dry-run-evidence',
+    nextDecision: NEXT_DECISION,
+    nextWorkpackage: NEXT_WORKPACKAGE,
+    publishBoundary: PUBLISH_BOUNDARY,
+    publishAllowed: false,
+    packagePrivateRequired: true
+  };
+}
+
+function validateEpic13ReleaseReportPackDryRunEvidencePlan(plan = createEpic13ReleaseReportPackDryRunEvidencePlan()) {
+  const errors = [];
+  const evidence = plan && Array.isArray(plan.ownerEvidence) ? plan.ownerEvidence : [];
+  const references = plan && Array.isArray(plan.referencePaths) ? plan.referencePaths : [];
+
+  if (!plan || plan.schema !== EPIC13_RELEASE_REPORT_PACK_DRY_RUN_EVIDENCE_SCHEMA) errors.push(`schema must be ${EPIC13_RELEASE_REPORT_PACK_DRY_RUN_EVIDENCE_SCHEMA}`);
+  if (!plan || plan.reportSchema !== EPIC13_RELEASE_REPORT_PACK_DRY_RUN_EVIDENCE_REPORT_SCHEMA) errors.push(`reportSchema must be ${EPIC13_RELEASE_REPORT_PACK_DRY_RUN_EVIDENCE_REPORT_SCHEMA}`);
+  if (!plan || plan.workpackage !== EPIC13_RELEASE_REPORT_PACK_DRY_RUN_EVIDENCE_WORKPACKAGE) errors.push(`workpackage must be ${EPIC13_RELEASE_REPORT_PACK_DRY_RUN_EVIDENCE_WORKPACKAGE}`);
+  if (!plan || plan.status !== EPIC13_RELEASE_REPORT_PACK_DRY_RUN_EVIDENCE_STATUS) errors.push(`status must be ${EPIC13_RELEASE_REPORT_PACK_DRY_RUN_EVIDENCE_STATUS}`);
+  if (!plan || plan.targetReadiness !== EPIC13_RELEASE_REPORT_PACK_DRY_RUN_EVIDENCE_TARGET) errors.push(`targetReadiness must be ${EPIC13_RELEASE_REPORT_PACK_DRY_RUN_EVIDENCE_TARGET}`);
+  if (!plan || plan.sourceSchema !== 'xtend.epic13.rc1-gate-matrix-ci-handoff.v1') errors.push('source schema must be RC1 gate matrix CI handoff');
+  if (!plan || plan.sourceValidationOk !== true || plan.sourceReportOk !== true) errors.push('RC1 gate matrix source must validate');
+  if (!plan || plan.packageExport !== EPIC13_RELEASE_REPORT_PACK_DRY_RUN_EVIDENCE_PACKAGE_EXPORT) errors.push('package export must be registered');
+  if (!plan || plan.packageScripts.releaseReport !== 'node scripts/run_xtend_tests.js --report .xtend-test-results/xtend-release-report.json') errors.push('release:report must write xtend-release-report.json');
+  if (!plan || plan.packageScripts.packDryRun !== 'node scripts/capture_pack_dry_run.js') errors.push('pack:dry-run must write reproducible pack artifacts');
+  if (!plan || plan.packageScripts.packDryRunReport !== 'node scripts/capture_pack_dry_run.js') errors.push('pack:dry-run:report must stay as compatibility alias');
+  if (!plan || plan.packageScripts.packDryRunRaw !== 'npm pack --dry-run') errors.push('pack:dry-run:raw must expose raw npm dry-run output');
+
+  REQUIRED_OWNER_EVIDENCE.forEach((required) => {
+    const entry = evidence.find((candidate) => candidate.id === required.id);
+    if (!entry) errors.push(`owner evidence missing: ${required.id}`);
+    if (entry && entry.artifact !== required.artifact) errors.push(`owner evidence artifact mismatch: ${required.id}`);
+    if (entry && entry.reproducible !== true) errors.push(`owner evidence must be reproducible: ${required.id}`);
+    if (entry && entry.ownerVisible !== true) errors.push(`owner evidence must be owner-visible: ${required.id}`);
+    if (entry && entry.networkRequired !== false) errors.push(`owner evidence must stay network-free: ${required.id}`);
+  });
+  REQUIRED_REFERENCE_PATHS.forEach((referencePath) => {
+    if (!references.includes(referencePath)) errors.push(`reference path missing: ${referencePath}`);
+  });
+  [RELEASE_REPORT_ARTIFACT, PACKAGE_DRY_RUN_ARTIFACT, PACKAGE_EXPORT_SURFACE_ARTIFACT, PACKAGE_EXPORT_LOCK_REPORT_ARTIFACT].forEach((artifact) => {
+    if (!plan || !plan.rc1HandoffReferences.includes(artifact)) errors.push(`RC1 handoff reference missing: ${artifact}`);
+  });
+  if (!plan || plan.auditSbomIncluded !== false || plan.publicPublishDecisionIncluded !== false || plan.licenseDecisionIncluded !== false) errors.push('audit/SBOM, public publish and license decisions must remain outside DPF-WP-02');
+  if (!plan || plan.docsMenuSlug !== 'release-report-pack-dry-run-evidence') errors.push('docs menu slug must be release-report-pack-dry-run-evidence');
+  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_RELEASE_REPORT_PACK_DRY_RUN_EVIDENCE_REPORT_SCHEMA,
+    ok: errors.length === 0,
+    errors
+  };
+}
+
+function createEpic13ReleaseReportPackDryRunEvidenceReport(options = {}) {
+  const plan = options.plan || createEpic13ReleaseReportPackDryRunEvidencePlan(options);
+  const validation = validateEpic13ReleaseReportPackDryRunEvidencePlan(plan);
+
+  return {
+    schema: EPIC13_RELEASE_REPORT_PACK_DRY_RUN_EVIDENCE_REPORT_SCHEMA,
+    ok: validation.ok,
+    errors: validation.errors,
+    plan,
+    ownerEvidenceCount: plan.ownerEvidence.length,
+    referencePathCount: plan.referencePaths.length,
+    releaseReportArtifact: plan.releaseReportArtifact,
+    packDryRunArtifact: plan.packDryRunArtifact,
+    publishAllowed: plan.publishAllowed,
+    nextWorkpackage: plan.nextWorkpackage
+  };
+}
+
+module.exports = {
+  EPIC13_RELEASE_REPORT_PACK_DRY_RUN_EVIDENCE_CONTRACT,
+  EPIC13_RELEASE_REPORT_PACK_DRY_RUN_EVIDENCE_DOCS,
+  EPIC13_RELEASE_REPORT_PACK_DRY_RUN_EVIDENCE_LOCAL_GATE,
+  EPIC13_RELEASE_REPORT_PACK_DRY_RUN_EVIDENCE_MODULE,
+  EPIC13_RELEASE_REPORT_PACK_DRY_RUN_EVIDENCE_PACKAGE_EXPORT,
+  EPIC13_RELEASE_REPORT_PACK_DRY_RUN_EVIDENCE_PACKAGE_SCRIPT,
+  EPIC13_RELEASE_REPORT_PACK_DRY_RUN_EVIDENCE_REPORT_ARTIFACT,
+  EPIC13_RELEASE_REPORT_PACK_DRY_RUN_EVIDENCE_REPORT_SCHEMA,
+  EPIC13_RELEASE_REPORT_PACK_DRY_RUN_EVIDENCE_SCHEMA,
+  EPIC13_RELEASE_REPORT_PACK_DRY_RUN_EVIDENCE_STATUS,
+  EPIC13_RELEASE_REPORT_PACK_DRY_RUN_EVIDENCE_SUITE,
+  EPIC13_RELEASE_REPORT_PACK_DRY_RUN_EVIDENCE_TARGET,
+  EPIC13_RELEASE_REPORT_PACK_DRY_RUN_EVIDENCE_WORKPACKAGE,
+  EPIC13_RELEASE_REPORT_PACK_DRY_RUN_EVIDENCE_WORKPACKAGE_DOC,
+  NEXT_DECISION,
+  NEXT_WORKPACKAGE,
+  PACK_DRY_RUN_COMMAND,
+  PACK_DRY_RUN_RAW_COMMAND,
+  PACK_DRY_RUN_REPORT_COMMAND,
+  PUBLISH_BOUNDARY,
+  RELEASE_REPORT_ARTIFACT,
+  RELEASE_REPORT_COMMAND,
+  REQUIRED_OWNER_EVIDENCE,
+  REQUIRED_REFERENCE_PATHS,
+  createEpic13ReleaseReportPackDryRunEvidencePlan,
+  createEpic13ReleaseReportPackDryRunEvidenceReport,
+  validateEpic13ReleaseReportPackDryRunEvidencePlan
+};