@ccslabs/xtend 0.1.0-rc.1

package/catalog/epic13-conditional-network-evidence-ci.js

@@ -0,0 +1,278 @@
+const {
+  COMMAND_ARTIFACTS,
+  DEFERRAL_REASONS,
+  EPIC13_CONDITIONAL_NETWORK_DEFERRAL_SCHEMA,
+  EPIC13_CONDITIONAL_NETWORK_EVIDENCE_REPORT_SCHEMA,
+  EPIC13_CONDITIONAL_NETWORK_EVIDENCE_SCHEMA,
+  REQUIRED_ARTIFACTS,
+  createEpic13ConditionalNetworkEvidencePlan,
+  createEpic13ConditionalNetworkEvidenceReport,
+  validateEpic13ConditionalNetworkEvidencePlan
+} = require('./epic13-conditional-network-evidence');
+const {
+  EPIC13_RELEASE_REPORT_PACK_DRY_RUN_EVIDENCE_REPORT_SCHEMA,
+  EPIC13_RELEASE_REPORT_PACK_DRY_RUN_EVIDENCE_SCHEMA,
+  createEpic13ReleaseReportPackDryRunEvidencePlan,
+  createEpic13ReleaseReportPackDryRunEvidenceReport,
+  validateEpic13ReleaseReportPackDryRunEvidencePlan
+} = require('./epic13-release-report-pack-dry-run-evidence');
+
+const EPIC13_CONDITIONAL_NETWORK_EVIDENCE_CI_SCHEMA = 'xtend.epic13.conditional-network-evidence-ci.v1';
+const EPIC13_CONDITIONAL_NETWORK_EVIDENCE_CI_REPORT_SCHEMA = 'xtend.epic13.conditional-network-evidence-ci-report.v1';
+const EPIC13_CONDITIONAL_NETWORK_EVIDENCE_CI_WORKPACKAGE = 'DPF-WP-03-conditional-network-evidence-ci';
+const EPIC13_CONDITIONAL_NETWORK_EVIDENCE_CI_STATUS = 'accepted-conditional-network-evidence-ci';
+const EPIC13_CONDITIONAL_NETWORK_EVIDENCE_CI_TARGET = 'conditional-network-evidence-ci-ready';
+const EPIC13_CONDITIONAL_NETWORK_EVIDENCE_CI_MODULE = 'catalog/epic13-conditional-network-evidence-ci.js';
+const EPIC13_CONDITIONAL_NETWORK_EVIDENCE_CI_SUITE = 'tests/platform/epic13_conditional_network_evidence_ci_suite.js';
+const EPIC13_CONDITIONAL_NETWORK_EVIDENCE_CI_CONTRACT = 'development/XTend-Epic13-Conditional-Network-Evidence-CI-Contract.md';
+const EPIC13_CONDITIONAL_NETWORK_EVIDENCE_CI_WORKPACKAGE_DOC = 'development/DPF-WP-03-Conditional-Network-Evidence-CI.md';
+const EPIC13_CONDITIONAL_NETWORK_EVIDENCE_CI_DOCS = 'docs/conditional-network-evidence-ci.md';
+const EPIC13_CONDITIONAL_NETWORK_EVIDENCE_CI_LOCAL_GATE = 'node scripts/run_xtend_tests.js epic13-conditional-network-evidence-ci --json';
+const EPIC13_CONDITIONAL_NETWORK_EVIDENCE_CI_PACKAGE_SCRIPT = 'npm run test:epic13-conditional-network-evidence-ci';
+const EPIC13_CONDITIONAL_NETWORK_EVIDENCE_CI_PACKAGE_EXPORT = './catalog/epic13-conditional-network-evidence-ci';
+const EPIC13_CONDITIONAL_NETWORK_EVIDENCE_CI_REPORT_ARTIFACT = '.xtend-test-results/xtend-epic13-conditional-network-evidence-ci-report.json';
+const CONDITIONAL_NETWORK_EVIDENCE_CAPTURE_SCRIPT = 'node scripts/capture_conditional_network_evidence.js';
+const CONDITIONAL_NETWORK_EVIDENCE_CAPTURE_COMMAND = 'npm run conditional-network:evidence';
+const CONDITIONAL_NETWORK_EVIDENCE_CAPTURE_MODULE = 'scripts/capture_conditional_network_evidence.js';
+const CONDITIONAL_NETWORK_EVIDENCE_WORKFLOW = '.github/workflows/xtend-default-gates.yml';
+const CONDITIONAL_NETWORK_EVIDENCE_WORKFLOW_JOB = 'conditional-network-evidence';
+const CONDITIONAL_NETWORK_EVIDENCE_WORKFLOW_ARTIFACT = 'xtend-conditional-network-evidence-node-26';
+const NEXT_WORKPACKAGE = 'DPF-WP-04-visual-pixel-evidence-storage';
+const NEXT_DECISION = 'visual-pixel-evidence-storage';
+const PUBLISH_BOUNDARY = 'private-until-release-owner-acceptance';
+
+const CI_EVIDENCE_ARTIFACTS = Object.freeze([
+  '.xtend-test-results/xtend-npm-audit-report.json',
+  '.xtend-test-results/xtend-npm-sbom.json',
+  '.xtend-test-results/xtend-conditional-network-evidence-report.json'
+]);
+
+const REQUIRED_REFERENCE_PATHS = Object.freeze([
+  EPIC13_CONDITIONAL_NETWORK_EVIDENCE_CI_MODULE,
+  EPIC13_CONDITIONAL_NETWORK_EVIDENCE_CI_SUITE,
+  EPIC13_CONDITIONAL_NETWORK_EVIDENCE_CI_CONTRACT,
+  EPIC13_CONDITIONAL_NETWORK_EVIDENCE_CI_WORKPACKAGE_DOC,
+  EPIC13_CONDITIONAL_NETWORK_EVIDENCE_CI_DOCS,
+  CONDITIONAL_NETWORK_EVIDENCE_CAPTURE_MODULE,
+  CONDITIONAL_NETWORK_EVIDENCE_WORKFLOW,
+  'catalog/epic13-conditional-network-evidence.js',
+  'catalog/epic13-release-report-pack-dry-run-evidence.js',
+  'development/XTend-Epic13-Conditional-Network-Evidence-Contract.md',
+  'development/XTend-Epic13-Release-Report-und-Pack-Dry-Run-Evidence.md',
+  'development/XTend-Epic13-RC1-Gate-Matrix-und-CI-Handoff.md',
+  'docs/conditional-network-evidence.md',
+  'docs/release-report-pack-dry-run-evidence.md',
+  'docs/rc1-gate-matrix-ci-handoff.md',
+  'development/XTend-CI-Gate-Matrix.md',
+  'development/XTend-Release-Checklist-und-SemVer-Policy.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 createEpic13ConditionalNetworkEvidenceCiPlan(options = {}) {
+  const packageManifest = options.packageManifest || getDefaultPackageManifest();
+  const conditionalPlan = options.conditionalPlan || createEpic13ConditionalNetworkEvidencePlan(options);
+  const conditionalValidation = options.conditionalValidation || validateEpic13ConditionalNetworkEvidencePlan(conditionalPlan);
+  const conditionalReport = options.conditionalReport || createEpic13ConditionalNetworkEvidenceReport({ ...options, plan: conditionalPlan });
+  const releaseEvidence = options.releaseEvidence || createEpic13ReleaseReportPackDryRunEvidencePlan(options);
+  const releaseEvidenceValidation = options.releaseEvidenceValidation || validateEpic13ReleaseReportPackDryRunEvidencePlan(releaseEvidence);
+  const releaseEvidenceReport = options.releaseEvidenceReport || createEpic13ReleaseReportPackDryRunEvidenceReport({ ...options, plan: releaseEvidence });
+  const scripts = packageManifest.scripts || {};
+
+  return {
+    schema: EPIC13_CONDITIONAL_NETWORK_EVIDENCE_CI_SCHEMA,
+    reportSchema: EPIC13_CONDITIONAL_NETWORK_EVIDENCE_CI_REPORT_SCHEMA,
+    workpackage: EPIC13_CONDITIONAL_NETWORK_EVIDENCE_CI_WORKPACKAGE,
+    status: EPIC13_CONDITIONAL_NETWORK_EVIDENCE_CI_STATUS,
+    generatedAt: options.generatedAt || 'static-local',
+    module: EPIC13_CONDITIONAL_NETWORK_EVIDENCE_CI_MODULE,
+    suite: EPIC13_CONDITIONAL_NETWORK_EVIDENCE_CI_SUITE,
+    contract: EPIC13_CONDITIONAL_NETWORK_EVIDENCE_CI_CONTRACT,
+    workpackageDocument: EPIC13_CONDITIONAL_NETWORK_EVIDENCE_CI_WORKPACKAGE_DOC,
+    docs: EPIC13_CONDITIONAL_NETWORK_EVIDENCE_CI_DOCS,
+    localGate: EPIC13_CONDITIONAL_NETWORK_EVIDENCE_CI_LOCAL_GATE,
+    packageScript: EPIC13_CONDITIONAL_NETWORK_EVIDENCE_CI_PACKAGE_SCRIPT,
+    packageExport: EPIC13_CONDITIONAL_NETWORK_EVIDENCE_CI_PACKAGE_EXPORT,
+    reportArtifact: EPIC13_CONDITIONAL_NETWORK_EVIDENCE_CI_REPORT_ARTIFACT,
+    targetReadiness: EPIC13_CONDITIONAL_NETWORK_EVIDENCE_CI_TARGET,
+    sourceSchema: EPIC13_CONDITIONAL_NETWORK_EVIDENCE_SCHEMA,
+    sourceReportSchema: EPIC13_CONDITIONAL_NETWORK_EVIDENCE_REPORT_SCHEMA,
+    sourceValidationOk: conditionalValidation.ok,
+    sourceReportOk: conditionalReport.ok,
+    releaseEvidenceSchema: EPIC13_RELEASE_REPORT_PACK_DRY_RUN_EVIDENCE_SCHEMA,
+    releaseEvidenceReportSchema: EPIC13_RELEASE_REPORT_PACK_DRY_RUN_EVIDENCE_REPORT_SCHEMA,
+    releaseEvidenceValidationOk: releaseEvidenceValidation.ok,
+    releaseEvidenceReportOk: releaseEvidenceReport.ok,
+    captureScript: CONDITIONAL_NETWORK_EVIDENCE_CAPTURE_SCRIPT,
+    captureCommand: CONDITIONAL_NETWORK_EVIDENCE_CAPTURE_COMMAND,
+    captureModule: CONDITIONAL_NETWORK_EVIDENCE_CAPTURE_MODULE,
+    workflow: {
+      path: CONDITIONAL_NETWORK_EVIDENCE_WORKFLOW,
+      jobId: CONDITIONAL_NETWORK_EVIDENCE_WORKFLOW_JOB,
+      nodeVersion: '26.x',
+      command: CONDITIONAL_NETWORK_EVIDENCE_CAPTURE_COMMAND,
+      executeEnv: 'XTEND_CONDITIONAL_NETWORK_EXECUTE=1',
+      artifactName: CONDITIONAL_NETWORK_EVIDENCE_WORKFLOW_ARTIFACT,
+      artifactPaths: CI_EVIDENCE_ARTIFACTS.slice(),
+      ifCondition: "github.event_name != 'pull_request'"
+    },
+    packageScripts: {
+      capture: scripts['conditional-network:evidence'],
+      localGate: scripts['test:epic13-conditional-network-evidence-ci']
+    },
+    commands: COMMAND_ARTIFACTS.map((entry) => ({
+      id: entry.id,
+      command: entry.command,
+      jsonCommand: entry.jsonCommand,
+      expectedArtifact: entry.expectedArtifact,
+      ciMode: 'execute-or-owner-deferral',
+      publishBlocking: true
+    })),
+    evidenceArtifacts: CI_EVIDENCE_ARTIFACTS.slice(),
+    expectedDeferralSchema: EPIC13_CONDITIONAL_NETWORK_DEFERRAL_SCHEMA,
+    allowedDeferralReasons: DEFERRAL_REASONS.slice(),
+    localGateRequiresNetwork: false,
+    ciJobRequiresNetwork: true,
+    ownerDeferralAllowed: true,
+    publishRequiresExecutedOrOwnerAcceptedDeferral: true,
+    dependencyUpgradesIncluded: false,
+    vulnerabilityFixesIncluded: false,
+    publicPublishDecisionIncluded: false,
+    docsMenuSlug: 'conditional-network-evidence-ci',
+    referencePaths: REQUIRED_REFERENCE_PATHS.slice(),
+    rc1HandoffReferences: [
+      '.xtend-test-results/xtend-npm-audit-report.json',
+      '.xtend-test-results/xtend-npm-sbom.json',
+      '.xtend-test-results/xtend-conditional-network-evidence-report.json',
+      EPIC13_CONDITIONAL_NETWORK_EVIDENCE_CI_REPORT_ARTIFACT
+    ],
+    nextDecision: NEXT_DECISION,
+    nextWorkpackage: NEXT_WORKPACKAGE,
+    publishBoundary: PUBLISH_BOUNDARY,
+    publishAllowed: false,
+    packagePrivateRequired: true
+  };
+}
+
+function validateEpic13ConditionalNetworkEvidenceCiPlan(plan = createEpic13ConditionalNetworkEvidenceCiPlan()) {
+  const errors = [];
+  const references = plan && Array.isArray(plan.referencePaths) ? plan.referencePaths : [];
+  const artifacts = plan && Array.isArray(plan.evidenceArtifacts) ? plan.evidenceArtifacts : [];
+  const workflowArtifacts = plan && plan.workflow && Array.isArray(plan.workflow.artifactPaths) ? plan.workflow.artifactPaths : [];
+
+  if (!plan || plan.schema !== EPIC13_CONDITIONAL_NETWORK_EVIDENCE_CI_SCHEMA) errors.push(`schema must be ${EPIC13_CONDITIONAL_NETWORK_EVIDENCE_CI_SCHEMA}`);
+  if (!plan || plan.reportSchema !== EPIC13_CONDITIONAL_NETWORK_EVIDENCE_CI_REPORT_SCHEMA) errors.push(`reportSchema must be ${EPIC13_CONDITIONAL_NETWORK_EVIDENCE_CI_REPORT_SCHEMA}`);
+  if (!plan || plan.workpackage !== EPIC13_CONDITIONAL_NETWORK_EVIDENCE_CI_WORKPACKAGE) errors.push(`workpackage must be ${EPIC13_CONDITIONAL_NETWORK_EVIDENCE_CI_WORKPACKAGE}`);
+  if (!plan || plan.status !== EPIC13_CONDITIONAL_NETWORK_EVIDENCE_CI_STATUS) errors.push(`status must be ${EPIC13_CONDITIONAL_NETWORK_EVIDENCE_CI_STATUS}`);
+  if (!plan || plan.targetReadiness !== EPIC13_CONDITIONAL_NETWORK_EVIDENCE_CI_TARGET) errors.push(`targetReadiness must be ${EPIC13_CONDITIONAL_NETWORK_EVIDENCE_CI_TARGET}`);
+  if (!plan || plan.sourceSchema !== EPIC13_CONDITIONAL_NETWORK_EVIDENCE_SCHEMA) errors.push('source schema must be Conditional Network Evidence');
+  if (!plan || plan.sourceValidationOk !== true || plan.sourceReportOk !== true) errors.push('Conditional Network Evidence source must validate');
+  if (!plan || plan.releaseEvidenceSchema !== EPIC13_RELEASE_REPORT_PACK_DRY_RUN_EVIDENCE_SCHEMA) errors.push('release evidence source schema must be DPF-WP-02');
+  if (!plan || plan.releaseEvidenceValidationOk !== true || plan.releaseEvidenceReportOk !== true) errors.push('DPF-WP-02 release evidence source must validate');
+  if (!plan || plan.packageScripts.capture !== CONDITIONAL_NETWORK_EVIDENCE_CAPTURE_SCRIPT) errors.push('conditional-network:evidence must capture audit/SBOM evidence');
+  if (!plan || plan.packageScripts.localGate !== 'node scripts/run_xtend_tests.js epic13-conditional-network-evidence-ci') errors.push('package local gate script missing');
+  if (!plan || plan.captureScript !== CONDITIONAL_NETWORK_EVIDENCE_CAPTURE_SCRIPT) errors.push('capture script must stay stable');
+  if (!plan || plan.captureCommand !== CONDITIONAL_NETWORK_EVIDENCE_CAPTURE_COMMAND) errors.push('capture command must stay stable');
+  if (!plan || !plan.workflow || plan.workflow.path !== CONDITIONAL_NETWORK_EVIDENCE_WORKFLOW) errors.push('workflow path must be xtend-default-gates');
+  if (!plan || !plan.workflow || plan.workflow.jobId !== CONDITIONAL_NETWORK_EVIDENCE_WORKFLOW_JOB) errors.push('workflow job id must be conditional-network-evidence');
+  if (!plan || !plan.workflow || plan.workflow.command !== CONDITIONAL_NETWORK_EVIDENCE_CAPTURE_COMMAND) errors.push('workflow must run conditional-network:evidence');
+  if (!plan || !plan.workflow || plan.workflow.executeEnv !== 'XTEND_CONDITIONAL_NETWORK_EXECUTE=1') errors.push('workflow must opt into network execution');
+  if (!plan || !plan.workflow || plan.workflow.artifactName !== CONDITIONAL_NETWORK_EVIDENCE_WORKFLOW_ARTIFACT) errors.push('workflow artifact name must be stable');
+  CI_EVIDENCE_ARTIFACTS.forEach((artifact) => {
+    if (!artifacts.includes(artifact)) errors.push(`evidence artifact missing: ${artifact}`);
+    if (!workflowArtifacts.includes(artifact)) errors.push(`workflow artifact path missing: ${artifact}`);
+    if (!plan || !plan.rc1HandoffReferences.includes(artifact)) errors.push(`RC1 handoff artifact missing: ${artifact}`);
+  });
+  REQUIRED_ARTIFACTS.forEach((artifact) => {
+    if (!artifacts.includes(artifact)) errors.push(`existing network artifact missing: ${artifact}`);
+  });
+  COMMAND_ARTIFACTS.forEach((entry) => {
+    const command = plan && Array.isArray(plan.commands) ? plan.commands.find((candidate) => candidate.id === entry.id) : null;
+    if (!command) errors.push(`command missing: ${entry.id}`);
+    if (command && command.command !== entry.command) errors.push(`command mismatch: ${entry.id}`);
+    if (command && command.jsonCommand !== entry.jsonCommand) errors.push(`json command mismatch: ${entry.id}`);
+    if (command && command.expectedArtifact !== entry.expectedArtifact) errors.push(`artifact mismatch: ${entry.id}`);
+    if (command && command.ciMode !== 'execute-or-owner-deferral') errors.push(`ci mode mismatch: ${entry.id}`);
+  });
+  if (!plan || plan.expectedDeferralSchema !== EPIC13_CONDITIONAL_NETWORK_DEFERRAL_SCHEMA) errors.push('deferral schema must stay conditional network deferral');
+  DEFERRAL_REASONS.forEach((reason) => {
+    if (!plan || !plan.allowedDeferralReasons.includes(reason)) errors.push(`deferral reason missing: ${reason}`);
+  });
+  REQUIRED_REFERENCE_PATHS.forEach((referencePath) => {
+    if (!references.includes(referencePath)) errors.push(`reference path missing: ${referencePath}`);
+  });
+  if (!plan || plan.localGateRequiresNetwork !== false) errors.push('local gate must remain network-free');
+  if (!plan || plan.ciJobRequiresNetwork !== true) errors.push('CI job must be the network execution boundary');
+  if (!plan || plan.ownerDeferralAllowed !== true || plan.publishRequiresExecutedOrOwnerAcceptedDeferral !== true) errors.push('owner deferral and publish blocking must stay explicit');
+  if (!plan || plan.dependencyUpgradesIncluded !== false || plan.vulnerabilityFixesIncluded !== false || plan.publicPublishDecisionIncluded !== false) errors.push('dependency upgrades, vulnerability fixes and public publish must remain outside DPF-WP-03');
+  if (!plan || plan.docsMenuSlug !== 'conditional-network-evidence-ci') errors.push('docs menu slug must be conditional-network-evidence-ci');
+  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_CONDITIONAL_NETWORK_EVIDENCE_CI_REPORT_SCHEMA,
+    ok: errors.length === 0,
+    errors
+  };
+}
+
+function createEpic13ConditionalNetworkEvidenceCiReport(options = {}) {
+  const plan = options.plan || createEpic13ConditionalNetworkEvidenceCiPlan(options);
+  const validation = validateEpic13ConditionalNetworkEvidenceCiPlan(plan);
+
+  return {
+    schema: EPIC13_CONDITIONAL_NETWORK_EVIDENCE_CI_REPORT_SCHEMA,
+    ok: validation.ok,
+    errors: validation.errors,
+    plan,
+    commandCount: plan.commands.length,
+    evidenceArtifactCount: plan.evidenceArtifacts.length,
+    referencePathCount: plan.referencePaths.length,
+    workflowJob: plan.workflow.jobId,
+    publishAllowed: plan.publishAllowed,
+    nextWorkpackage: plan.nextWorkpackage
+  };
+}
+
+module.exports = {
+  CI_EVIDENCE_ARTIFACTS,
+  CONDITIONAL_NETWORK_EVIDENCE_CAPTURE_COMMAND,
+  CONDITIONAL_NETWORK_EVIDENCE_CAPTURE_MODULE,
+  CONDITIONAL_NETWORK_EVIDENCE_CAPTURE_SCRIPT,
+  CONDITIONAL_NETWORK_EVIDENCE_WORKFLOW,
+  CONDITIONAL_NETWORK_EVIDENCE_WORKFLOW_ARTIFACT,
+  CONDITIONAL_NETWORK_EVIDENCE_WORKFLOW_JOB,
+  EPIC13_CONDITIONAL_NETWORK_EVIDENCE_CI_CONTRACT,
+  EPIC13_CONDITIONAL_NETWORK_EVIDENCE_CI_DOCS,
+  EPIC13_CONDITIONAL_NETWORK_EVIDENCE_CI_LOCAL_GATE,
+  EPIC13_CONDITIONAL_NETWORK_EVIDENCE_CI_MODULE,
+  EPIC13_CONDITIONAL_NETWORK_EVIDENCE_CI_PACKAGE_EXPORT,
+  EPIC13_CONDITIONAL_NETWORK_EVIDENCE_CI_PACKAGE_SCRIPT,
+  EPIC13_CONDITIONAL_NETWORK_EVIDENCE_CI_REPORT_ARTIFACT,
+  EPIC13_CONDITIONAL_NETWORK_EVIDENCE_CI_REPORT_SCHEMA,
+  EPIC13_CONDITIONAL_NETWORK_EVIDENCE_CI_SCHEMA,
+  EPIC13_CONDITIONAL_NETWORK_EVIDENCE_CI_STATUS,
+  EPIC13_CONDITIONAL_NETWORK_EVIDENCE_CI_SUITE,
+  EPIC13_CONDITIONAL_NETWORK_EVIDENCE_CI_TARGET,
+  EPIC13_CONDITIONAL_NETWORK_EVIDENCE_CI_WORKPACKAGE,
+  EPIC13_CONDITIONAL_NETWORK_EVIDENCE_CI_WORKPACKAGE_DOC,
+  NEXT_DECISION,
+  NEXT_WORKPACKAGE,
+  PUBLISH_BOUNDARY,
+  REQUIRED_REFERENCE_PATHS,
+  createEpic13ConditionalNetworkEvidenceCiPlan,
+  createEpic13ConditionalNetworkEvidenceCiReport,
+  validateEpic13ConditionalNetworkEvidenceCiPlan
+};

package/catalog/epic13-conditional-network-evidence.d.ts

@@ -0,0 +1,34 @@
+import type {
+  XtendCatalogConstant,
+  XtendCatalogGate,
+  XtendCatalogOptions,
+  XtendCatalogPlan,
+  XtendCatalogRecord,
+  XtendCatalogReport
+} from './catalog-public-types';
+
+
+export declare const COMMAND_ARTIFACTS: readonly XtendCatalogConstant[] | XtendCatalogConstant;
+export declare const DEFERRAL_REASONS: XtendCatalogConstant;
+export declare const EPIC13_CONDITIONAL_NETWORK_DEFERRAL_SCHEMA: string;
+export declare const EPIC13_CONDITIONAL_NETWORK_EVIDENCE_CONTRACT: string;
+export declare const EPIC13_CONDITIONAL_NETWORK_EVIDENCE_DOCS: readonly XtendCatalogConstant[] | XtendCatalogConstant;
+export declare const EPIC13_CONDITIONAL_NETWORK_EVIDENCE_LOCAL_GATE: string;
+export declare const EPIC13_CONDITIONAL_NETWORK_EVIDENCE_MODULE: string;
+export declare const EPIC13_CONDITIONAL_NETWORK_EVIDENCE_PACKAGE_SCRIPT: string;
+export declare const EPIC13_CONDITIONAL_NETWORK_EVIDENCE_REPORT_SCHEMA: string;
+export declare const EPIC13_CONDITIONAL_NETWORK_EVIDENCE_SCHEMA: string;
+export declare const EPIC13_CONDITIONAL_NETWORK_EVIDENCE_STATUS: string;
+export declare const EPIC13_CONDITIONAL_NETWORK_EVIDENCE_STEERING: XtendCatalogConstant;
+export declare const EPIC13_CONDITIONAL_NETWORK_EVIDENCE_SUITE: string;
+export declare const EPIC13_CONDITIONAL_NETWORK_EVIDENCE_TARGET: string;
+export declare const EPIC13_CONDITIONAL_NETWORK_EVIDENCE_WORKPACKAGE: string;
+export declare const EPIC13_CONDITIONAL_NETWORK_EVIDENCE_WORKPACKAGE_DOC: XtendCatalogConstant;
+export declare const EVIDENCE_STATUSES: XtendCatalogConstant;
+export declare const PUBLISH_BOUNDARY: XtendCatalogConstant;
+export declare const REQUIRED_ARTIFACTS: readonly XtendCatalogConstant[] | XtendCatalogConstant;
+export declare const REQUIRED_DOCS: readonly XtendCatalogConstant[] | XtendCatalogConstant;
+export declare const REQUIRED_SOURCE_SCHEMAS: XtendCatalogConstant;
+export declare function createEpic13ConditionalNetworkEvidencePlan(options?: XtendCatalogOptions): XtendCatalogPlan;
+export declare function createEpic13ConditionalNetworkEvidenceReport(options?: XtendCatalogOptions): XtendCatalogReport;
+export declare function validateEpic13ConditionalNetworkEvidencePlan(plan?: unknown): XtendCatalogReport;

package/catalog/epic13-conditional-network-evidence.js

@@ -0,0 +1,280 @@
+const {
+  CONDITIONAL_NETWORK_COMMANDS,
+  createEpic12Rc0GateMatrix,
+  createEpic12Rc0GateMatrixReport,
+  validateEpic12Rc0GateMatrix
+} = require('./epic12-rc0-gate-matrix');
+const {
+  EPIC13_RELEASE_OWNER_ACCEPTANCE_REPORT_SCHEMA,
+  EPIC13_RELEASE_OWNER_ACCEPTANCE_SCHEMA,
+  createEpic13ReleaseOwnerAcceptanceContract,
+  createEpic13ReleaseOwnerAcceptanceReport,
+  validateEpic13ReleaseOwnerAcceptanceContract
+} = require('./epic13-release-owner-acceptance');
+const {
+  KERNEL_BOUNDARY
+} = require('./epic12-rc0-handoff');
+
+const EPIC13_CONDITIONAL_NETWORK_EVIDENCE_SCHEMA = 'xtend.epic13.conditional-network-evidence.v1';
+const EPIC13_CONDITIONAL_NETWORK_EVIDENCE_REPORT_SCHEMA = 'xtend.epic13.conditional-network-evidence-report.v1';
+const EPIC13_CONDITIONAL_NETWORK_DEFERRAL_SCHEMA = 'xtend.epic13.conditional-network-deferral.v1';
+const EPIC13_CONDITIONAL_NETWORK_EVIDENCE_WORKPACKAGE = 'WP-E13-03';
+const EPIC13_CONDITIONAL_NETWORK_EVIDENCE_STATUS = 'accepted-conditional-network-evidence-contract';
+const EPIC13_CONDITIONAL_NETWORK_EVIDENCE_TARGET = 'conditional-network-evidence-ready';
+const EPIC13_CONDITIONAL_NETWORK_EVIDENCE_MODULE = 'catalog/epic13-conditional-network-evidence.js';
+const EPIC13_CONDITIONAL_NETWORK_EVIDENCE_SUITE = 'tests/platform/epic13_conditional_network_evidence_suite.js';
+const EPIC13_CONDITIONAL_NETWORK_EVIDENCE_STEERING = 'development/RC0-RC1-transfer-EPIC13.md';
+const EPIC13_CONDITIONAL_NETWORK_EVIDENCE_CONTRACT = 'development/XTend-Epic13-Conditional-Network-Evidence-Contract.md';
+const EPIC13_CONDITIONAL_NETWORK_EVIDENCE_WORKPACKAGE_DOC = 'development/WP-E13-03-Conditional-Network-Gate-Evidence-vorbereiten.md';
+const EPIC13_CONDITIONAL_NETWORK_EVIDENCE_DOCS = 'docs/conditional-network-evidence.md';
+const EPIC13_CONDITIONAL_NETWORK_EVIDENCE_LOCAL_GATE = 'node scripts/run_xtend_tests.js epic13-conditional-network-evidence --json';
+const EPIC13_CONDITIONAL_NETWORK_EVIDENCE_PACKAGE_SCRIPT = 'npm run test:epic13-conditional-network-evidence';
+const PUBLISH_BOUNDARY = 'private-until-release-owner-acceptance';
+
+const EVIDENCE_STATUSES = Object.freeze([
+  'executed',
+  'deferred'
+]);
+
+const DEFERRAL_REASONS = Object.freeze([
+  'network-restricted-local-default',
+  'sandbox-network-unavailable',
+  'registry-auth-unavailable',
+  'owner-approved-offline-run'
+]);
+
+const REQUIRED_ARTIFACTS = Object.freeze([
+  '.xtend-test-results/xtend-npm-audit-report.json',
+  '.xtend-test-results/xtend-npm-sbom.json',
+  '.xtend-test-results/xtend-conditional-network-evidence-report.json'
+]);
+
+const REQUIRED_SOURCE_SCHEMAS = Object.freeze([
+  EPIC13_RELEASE_OWNER_ACCEPTANCE_SCHEMA,
+  EPIC13_RELEASE_OWNER_ACCEPTANCE_REPORT_SCHEMA,
+  'xtend.epic12.rc0-gate-matrix.v1',
+  'xtend.security.supply-chain-gate-plan.v1',
+  'xtend.security.vulnerability-policy.v1'
+]);
+
+const REQUIRED_DOCS = Object.freeze([
+  EPIC13_CONDITIONAL_NETWORK_EVIDENCE_STEERING,
+  EPIC13_CONDITIONAL_NETWORK_EVIDENCE_CONTRACT,
+  EPIC13_CONDITIONAL_NETWORK_EVIDENCE_WORKPACKAGE_DOC,
+  EPIC13_CONDITIONAL_NETWORK_EVIDENCE_DOCS,
+  'development/XTend-Epic13-Release-Owner-Acceptance-Contract.md',
+  'development/XTend-Release-Checklist-und-SemVer-Policy.md',
+  'development/XTend-CI-Gate-Matrix.md',
+  'development/XTend-RC0-Gate-Matrix.md',
+  'docs/release-owner-acceptance.md',
+  'docs/supply-chain-gates.md',
+  'docs/enterprise-adoption.md'
+]);
+
+const COMMAND_ARTIFACTS = Object.freeze([
+  {
+    id: 'npm-audit-moderate',
+    command: 'npm audit --audit-level=moderate',
+    jsonCommand: 'npm audit --audit-level=moderate --json',
+    expectedArtifact: '.xtend-test-results/xtend-npm-audit-report.json',
+    validates: ['vulnerability-policy', 'moderate-or-higher-findings'],
+    publishRequired: true
+  },
+  {
+    id: 'npm-sbom-json',
+    command: 'npm sbom --sbom-format=cyclonedx --json',
+    jsonCommand: 'npm sbom --sbom-format=cyclonedx --json',
+    expectedArtifact: '.xtend-test-results/xtend-npm-sbom.json',
+    validates: ['dependency-inventory', 'sbom-export'],
+    publishRequired: true
+  }
+]);
+
+function clone(value) {
+  return JSON.parse(JSON.stringify(value));
+}
+
+function createEvidenceRecord(commandArtifact, execution = {}) {
+  const status = execution.status || 'deferred';
+  const reason = execution.reason || 'network-restricted-local-default';
+
+  return {
+    schema: EPIC13_CONDITIONAL_NETWORK_DEFERRAL_SCHEMA,
+    id: commandArtifact.id,
+    command: commandArtifact.command,
+    jsonCommand: commandArtifact.jsonCommand,
+    expectedArtifact: commandArtifact.expectedArtifact,
+    status,
+    reason: status === 'deferred' ? reason : null,
+    executedAt: execution.executedAt || null,
+    artifactPresent: execution.artifactPresent === true,
+    ownerDecisionRequired: status === 'deferred',
+    localGateBlocking: false,
+    publishBlocking: commandArtifact.publishRequired,
+    requiredBefore: 'release-owner-publish-acceptance',
+    validates: commandArtifact.validates.slice()
+  };
+}
+
+function summarizeEvidence(records) {
+  return records.reduce((summary, record) => {
+    summary.total += 1;
+    summary.byStatus[record.status] = (summary.byStatus[record.status] || 0) + 1;
+    if (record.publishBlocking) summary.publishBlocking.push(record.id);
+    if (record.status === 'deferred') summary.deferred.push(record.id);
+    if (record.status === 'executed') summary.executed.push(record.id);
+    return summary;
+  }, {
+    total: 0,
+    byStatus: {},
+    executed: [],
+    deferred: [],
+    publishBlocking: []
+  });
+}
+
+function createEpic13ConditionalNetworkEvidencePlan(options = {}) {
+  const ownerAcceptance = options.ownerAcceptance || createEpic13ReleaseOwnerAcceptanceContract(options);
+  const ownerAcceptanceValidation = options.ownerAcceptanceValidation || validateEpic13ReleaseOwnerAcceptanceContract(ownerAcceptance);
+  const ownerAcceptanceReport = options.ownerAcceptanceReport || createEpic13ReleaseOwnerAcceptanceReport({ ...options, contract: ownerAcceptance });
+  const rc0Matrix = options.rc0Matrix || createEpic12Rc0GateMatrix(options);
+  const rc0MatrixValidation = options.rc0MatrixValidation || validateEpic12Rc0GateMatrix(rc0Matrix);
+  const rc0MatrixReport = options.rc0MatrixReport || createEpic12Rc0GateMatrixReport({ ...options, matrix: rc0Matrix });
+  const executions = options.executions || {};
+  const evidenceRecords = COMMAND_ARTIFACTS.map((commandArtifact) => {
+    return createEvidenceRecord(commandArtifact, executions[commandArtifact.id]);
+  });
+  const evidenceSummary = summarizeEvidence(evidenceRecords);
+
+  return {
+    schema: EPIC13_CONDITIONAL_NETWORK_EVIDENCE_SCHEMA,
+    reportSchema: EPIC13_CONDITIONAL_NETWORK_EVIDENCE_REPORT_SCHEMA,
+    deferralSchema: EPIC13_CONDITIONAL_NETWORK_DEFERRAL_SCHEMA,
+    workpackage: EPIC13_CONDITIONAL_NETWORK_EVIDENCE_WORKPACKAGE,
+    status: EPIC13_CONDITIONAL_NETWORK_EVIDENCE_STATUS,
+    generatedAt: options.generatedAt || 'static-local',
+    module: EPIC13_CONDITIONAL_NETWORK_EVIDENCE_MODULE,
+    suite: EPIC13_CONDITIONAL_NETWORK_EVIDENCE_SUITE,
+    steeringDocument: EPIC13_CONDITIONAL_NETWORK_EVIDENCE_STEERING,
+    contract: EPIC13_CONDITIONAL_NETWORK_EVIDENCE_CONTRACT,
+    workpackageDocument: EPIC13_CONDITIONAL_NETWORK_EVIDENCE_WORKPACKAGE_DOC,
+    docs: EPIC13_CONDITIONAL_NETWORK_EVIDENCE_DOCS,
+    localGate: EPIC13_CONDITIONAL_NETWORK_EVIDENCE_LOCAL_GATE,
+    packageScript: EPIC13_CONDITIONAL_NETWORK_EVIDENCE_PACKAGE_SCRIPT,
+    sourceSchema: EPIC13_RELEASE_OWNER_ACCEPTANCE_SCHEMA,
+    sourceReportSchema: EPIC13_RELEASE_OWNER_ACCEPTANCE_REPORT_SCHEMA,
+    sourceStatus: ownerAcceptance.status,
+    sourceReportOk: ownerAcceptanceReport.ok,
+    sourceValidationOk: ownerAcceptanceValidation.ok,
+    rc0GateMatrixOk: rc0MatrixValidation.ok && rc0MatrixReport.ok,
+    releaseCandidate: 'RC1',
+    targetReadiness: EPIC13_CONDITIONAL_NETWORK_EVIDENCE_TARGET,
+    commands: CONDITIONAL_NETWORK_COMMANDS.slice(),
+    commandArtifacts: clone(COMMAND_ARTIFACTS),
+    evidenceRecords,
+    evidenceSummary,
+    allowedEvidenceStatuses: EVIDENCE_STATUSES.slice(),
+    allowedDeferralReasons: DEFERRAL_REASONS.slice(),
+    requiredArtifacts: REQUIRED_ARTIFACTS.slice(),
+    requiredSourceSchemas: REQUIRED_SOURCE_SCHEMAS.slice(),
+    requiredDocs: REQUIRED_DOCS.slice(),
+    localDefaultMode: 'defer-with-owner-reason',
+    externalNetworkAllowedInLocalGate: false,
+    ownerDeferralAllowed: true,
+    ownerDeferralRequiredWhenNotExecuted: true,
+    publishRequiresExecutedOrOwnerAcceptedDeferral: true,
+    nextDecision: 'rc1-gate-matrix-ci-handoff',
+    nextWorkpackage: 'WP-E13-13',
+    kernelBoundary: KERNEL_BOUNDARY,
+    publishBoundary: PUBLISH_BOUNDARY,
+    publishAllowed: false,
+    packagePrivateRequired: true
+  };
+}
+
+function validateEpic13ConditionalNetworkEvidencePlan(plan = createEpic13ConditionalNetworkEvidencePlan()) {
+  const errors = [];
+  const records = plan && Array.isArray(plan.evidenceRecords) ? plan.evidenceRecords : [];
+  const invalidStatuses = records.filter((record) => !EVIDENCE_STATUSES.includes(record.status));
+  const invalidReasons = records.filter((record) => record.status === 'deferred' && !DEFERRAL_REASONS.includes(record.reason));
+
+  if (!plan || plan.schema !== EPIC13_CONDITIONAL_NETWORK_EVIDENCE_SCHEMA) errors.push(`schema must be ${EPIC13_CONDITIONAL_NETWORK_EVIDENCE_SCHEMA}`);
+  if (!plan || plan.reportSchema !== EPIC13_CONDITIONAL_NETWORK_EVIDENCE_REPORT_SCHEMA) errors.push(`reportSchema must be ${EPIC13_CONDITIONAL_NETWORK_EVIDENCE_REPORT_SCHEMA}`);
+  if (!plan || plan.deferralSchema !== EPIC13_CONDITIONAL_NETWORK_DEFERRAL_SCHEMA) errors.push(`deferralSchema must be ${EPIC13_CONDITIONAL_NETWORK_DEFERRAL_SCHEMA}`);
+  if (!plan || plan.workpackage !== EPIC13_CONDITIONAL_NETWORK_EVIDENCE_WORKPACKAGE) errors.push(`workpackage must be ${EPIC13_CONDITIONAL_NETWORK_EVIDENCE_WORKPACKAGE}`);
+  if (!plan || plan.status !== EPIC13_CONDITIONAL_NETWORK_EVIDENCE_STATUS) errors.push(`status must be ${EPIC13_CONDITIONAL_NETWORK_EVIDENCE_STATUS}`);
+  if (!plan || plan.sourceSchema !== EPIC13_RELEASE_OWNER_ACCEPTANCE_SCHEMA) errors.push('source schema must be Release Owner Acceptance');
+  if (!plan || plan.sourceValidationOk !== true || plan.sourceReportOk !== true || plan.rc0GateMatrixOk !== true) errors.push('source acceptance and RC0 gate matrix must validate');
+  if (!plan || plan.targetReadiness !== EPIC13_CONDITIONAL_NETWORK_EVIDENCE_TARGET) errors.push(`targetReadiness must be ${EPIC13_CONDITIONAL_NETWORK_EVIDENCE_TARGET}`);
+  CONDITIONAL_NETWORK_COMMANDS.forEach((command) => {
+    if (!plan || !plan.commands.includes(command)) errors.push(`conditional network command missing: ${command}`);
+  });
+  REQUIRED_ARTIFACTS.forEach((artifact) => {
+    if (!plan || !plan.requiredArtifacts.includes(artifact)) errors.push(`required artifact missing: ${artifact}`);
+  });
+  REQUIRED_SOURCE_SCHEMAS.forEach((schema) => {
+    if (!plan || !plan.requiredSourceSchemas.includes(schema)) errors.push(`source schema missing: ${schema}`);
+  });
+  if (!plan || plan.evidenceRecords.length !== COMMAND_ARTIFACTS.length) errors.push('all conditional network commands must have evidence records');
+  if (invalidStatuses.length > 0) errors.push(`invalid evidence statuses: ${invalidStatuses.map((record) => record.id).join(', ')}`);
+  if (invalidReasons.length > 0) errors.push(`invalid deferral reasons: ${invalidReasons.map((record) => record.id).join(', ')}`);
+  if (!plan || plan.evidenceRecords.some((record) => record.localGateBlocking !== false)) errors.push('conditional network records must not block local gate');
+  if (!plan || plan.evidenceRecords.some((record) => record.publishBlocking !== true)) errors.push('conditional network records must block publish until executed or owner-accepted');
+  if (!plan || plan.externalNetworkAllowedInLocalGate !== false) errors.push('local gate must not require external network');
+  if (!plan || plan.ownerDeferralAllowed !== true || plan.ownerDeferralRequiredWhenNotExecuted !== true) errors.push('owner deferral must be explicit when commands are not executed');
+  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_CONDITIONAL_NETWORK_EVIDENCE_REPORT_SCHEMA,
+    ok: errors.length === 0,
+    errors
+  };
+}
+
+function createEpic13ConditionalNetworkEvidenceReport(options = {}) {
+  const plan = options.plan || createEpic13ConditionalNetworkEvidencePlan(options);
+  const validation = validateEpic13ConditionalNetworkEvidencePlan(plan);
+
+  return {
+    schema: EPIC13_CONDITIONAL_NETWORK_EVIDENCE_REPORT_SCHEMA,
+    ok: validation.ok,
+    errors: validation.errors,
+    plan,
+    commandCount: plan.commands.length,
+    evidenceSummary: plan.evidenceSummary,
+    requiredArtifactCount: plan.requiredArtifacts.length,
+    publishAllowed: plan.publishAllowed,
+    nextWorkpackage: plan.nextWorkpackage
+  };
+}
+
+module.exports = {
+  COMMAND_ARTIFACTS,
+  DEFERRAL_REASONS,
+  EPIC13_CONDITIONAL_NETWORK_DEFERRAL_SCHEMA,
+  EPIC13_CONDITIONAL_NETWORK_EVIDENCE_CONTRACT,
+  EPIC13_CONDITIONAL_NETWORK_EVIDENCE_DOCS,
+  EPIC13_CONDITIONAL_NETWORK_EVIDENCE_LOCAL_GATE,
+  EPIC13_CONDITIONAL_NETWORK_EVIDENCE_MODULE,
+  EPIC13_CONDITIONAL_NETWORK_EVIDENCE_PACKAGE_SCRIPT,
+  EPIC13_CONDITIONAL_NETWORK_EVIDENCE_REPORT_SCHEMA,
+  EPIC13_CONDITIONAL_NETWORK_EVIDENCE_SCHEMA,
+  EPIC13_CONDITIONAL_NETWORK_EVIDENCE_STATUS,
+  EPIC13_CONDITIONAL_NETWORK_EVIDENCE_STEERING,
+  EPIC13_CONDITIONAL_NETWORK_EVIDENCE_SUITE,
+  EPIC13_CONDITIONAL_NETWORK_EVIDENCE_TARGET,
+  EPIC13_CONDITIONAL_NETWORK_EVIDENCE_WORKPACKAGE,
+  EPIC13_CONDITIONAL_NETWORK_EVIDENCE_WORKPACKAGE_DOC,
+  EVIDENCE_STATUSES,
+  PUBLISH_BOUNDARY,
+  REQUIRED_ARTIFACTS,
+  REQUIRED_DOCS,
+  REQUIRED_SOURCE_SCHEMAS,
+  createEpic13ConditionalNetworkEvidencePlan,
+  createEpic13ConditionalNetworkEvidenceReport,
+  validateEpic13ConditionalNetworkEvidencePlan
+};

package/catalog/epic13-docs-rmt-production-hardening.d.ts

@@ -0,0 +1,39 @@
+import type {
+  XtendCatalogConstant,
+  XtendCatalogGate,
+  XtendCatalogOptions,
+  XtendCatalogPlan,
+  XtendCatalogRecord,
+  XtendCatalogReport
+} from './catalog-public-types';
+
+
+export declare const DOCS_RMT_DOCUMENT: XtendCatalogConstant;
+export declare const DOCS_RMT_HOST: XtendCatalogConstant;
+export declare const DOCS_RMT_PAGE_LOADER: XtendCatalogConstant;
+export declare const DOCS_RMT_PILOT_SCHEMA: string;
+export declare const DOCS_RMT_RENDER_SCHEMA: string;
+export declare const EPIC13_DOCS_RMT_PRODUCTION_HARDENING_CONTRACT: string;
+export declare const EPIC13_DOCS_RMT_PRODUCTION_HARDENING_DOCS: readonly XtendCatalogConstant[] | XtendCatalogConstant;
+export declare const EPIC13_DOCS_RMT_PRODUCTION_HARDENING_LOCAL_GATE: string;
+export declare const EPIC13_DOCS_RMT_PRODUCTION_HARDENING_MODULE: string;
+export declare const EPIC13_DOCS_RMT_PRODUCTION_HARDENING_PACKAGE_SCRIPT: string;
+export declare const EPIC13_DOCS_RMT_PRODUCTION_HARDENING_REPORT_ARTIFACT: string;
+export declare const EPIC13_DOCS_RMT_PRODUCTION_HARDENING_REPORT_SCHEMA: string;
+export declare const EPIC13_DOCS_RMT_PRODUCTION_HARDENING_SCHEMA: string;
+export declare const EPIC13_DOCS_RMT_PRODUCTION_HARDENING_STATUS: string;
+export declare const EPIC13_DOCS_RMT_PRODUCTION_HARDENING_STEERING: XtendCatalogConstant;
+export declare const EPIC13_DOCS_RMT_PRODUCTION_HARDENING_SUITE: string;
+export declare const EPIC13_DOCS_RMT_PRODUCTION_HARDENING_TARGET: string;
+export declare const EPIC13_DOCS_RMT_PRODUCTION_HARDENING_WORKPACKAGE: string;
+export declare const EPIC13_DOCS_RMT_PRODUCTION_HARDENING_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_RMT_ARTIFACTS: readonly XtendCatalogConstant[] | XtendCatalogConstant;
+export declare const REQUIRED_DOCS_RMT_GATES: readonly XtendCatalogConstant[] | XtendCatalogConstant;
+export declare const REQUIRED_EXTENSION_SLOTS: readonly XtendCatalogConstant[] | XtendCatalogConstant;
+export declare const TRUST_BOUNDARY: XtendCatalogConstant;
+export declare function createEpic13DocsRmtProductionHardeningPlan(options?: XtendCatalogOptions): XtendCatalogPlan;
+export declare function createEpic13DocsRmtProductionHardeningReport(options?: XtendCatalogOptions): XtendCatalogReport;
+export declare function validateEpic13DocsRmtProductionHardeningPlan(plan?: unknown): XtendCatalogReport;