@transitrix/diagrams 1.13.3 → 1.14.0

package/dist/compliance/coverage-metric.js

@@ -16,14 +16,14 @@ export function collectCoverageViewResolutionFindings(config, catalog, complianc
         const t = catalog.typeOf(id);
         if (t === undefined) {
             findings.push({
-                code: 'COVMET-REF',
+                code: 'COVMET-003',
                 severity: 'error',
                 message: `subjects.products: "${id}" does not resolve to an admitted artefact.`,
             });
         }
         else if (t !== 'PRODUCT') {
             findings.push({
-                code: 'COVMET-REF',
+                code: 'COVMET-003',
                 severity: 'error',
                 message: `subjects.products: "${id}" resolves to ${t}, not PRODUCT.`,
             });
@@ -32,7 +32,7 @@ export function collectCoverageViewResolutionFindings(config, catalog, complianc
     for (const id of config.regimes?.include ?? []) {
         if (!codexIds.has(id)) {
             findings.push({
-                code: 'COVMET-REF',
+                code: 'COVMET-003',
                 severity: 'error',
                 message: `regimes.include: "${id}" does not resolve to an admitted codex artefact.`,
             });

package/dist/compliance/impact.js

@@ -26,14 +26,14 @@ export function collectImpactViewResolutionFindings(config, catalog, complianceC
             const t = catalog.typeOf(id);
             if (t === undefined) {
                 findings.push({
-                    code: 'COMPIMP-REF',
+                    code: 'COMPIMP-003',
                     severity: 'error',
                     message: `${path}: "${id}" does not resolve to an admitted artefact.`,
                 });
             }
             else if (t !== expectedType) {
                 findings.push({
-                    code: 'COMPIMP-REF',
+                    code: 'COMPIMP-003',
                     severity: 'error',
                     message: `${path}: "${id}" resolves to ${t}, not ${expectedType}.`,
                 });
@@ -44,7 +44,7 @@ export function collectImpactViewResolutionFindings(config, catalog, complianceC
         const t = catalog.typeOf(id);
         if (t === undefined || t !== 'REQUIREMENT') {
             findings.push({
-                code: 'COMPIMP-REF',
+                code: 'COMPIMP-003',
                 severity: 'error',
                 message: `obligations.include: "${id}" does not resolve to an admitted REQUIREMENT.`,
             });
@@ -53,7 +53,7 @@ export function collectImpactViewResolutionFindings(config, catalog, complianceC
     for (const id of config.obligations.filter?.derived_from_codex ?? []) {
         if (!codexIds.has(id)) {
             findings.push({
-                code: 'COMPIMP-REF',
+                code: 'COMPIMP-003',
                 severity: 'error',
                 message: `obligations.filter.derived_from_codex: "${id}" does not resolve to an admitted codex artefact.`,
             });

package/dist/compliance/index.d.ts

@@ -19,3 +19,6 @@ export { assertionToScoringElement, complianceConfidenceHeader, requirementToSco
 export { parseCoverageMetricConfig, buildCoverageMatrix, collectCoverageViewResolutionFindings, } from './coverage-metric.js';
 export type { CoverageMetricConfig, CoverageMetricRegimes, CoverageMetricRegimesFilter, CoverageMetricSubjects, CoverageMetricThresholds, CoverageMatrix, CoverageRow, CoverageViewFinding, ParseCoverageMetricResult, RagStatus, } from './coverage-metric.js';
 export type { ComplianceIndex, ComplianceIndexInput, DeadlineStatus, IndexRequirement, IndexAssertion, IndexVerification, IndexNeed, IndexValidation, LawTree, LawTreeRequirement, ProductView, ProductRequirementStatus, ObjectDetailDef, ObjectDetailInput, RequirementTrace, TraceAssertionRow, TraceVerificationRow, TraceElementCatalog, TraceElementRef, TraceSourceRef, } from './types.js';
+export { buildRequirementChain, requirementReleaseCounts, selectRequirementChain, RequirementChainSnapshot, CHAIN_STAGES, chainDate } from './requirement-chain.js';
+export type { ChainInput, ChainScope, ChainSet, RequirementChainNode, RequirementChainEdge, RequirementChainProjection } from './requirement-chain.js';
+export type { ChainRecord, ChainFinding } from './types.js';

package/dist/compliance/index.js

@@ -11,3 +11,4 @@ export { renderComplianceHtml, renderImpactMatrixHtml } from './html.js';
 export { buildImpactMatrix, renderImpactMarkdown, parseImpactViewConfig, collectImpactViewResolutionFindings, COMPLIANCE_IMPACT_DEFAULTS, extractObjectDetails, extractProcessFlowTasks, mergeStageTaskDetails, computeDeadlineStatus } from './impact.js';
 export { assertionToScoringElement, complianceConfidenceHeader, requirementToScoringElement, scoreComplianceView, } from './confidence.js';
 export { parseCoverageMetricConfig, buildCoverageMatrix, collectCoverageViewResolutionFindings, } from './coverage-metric.js';
+export { buildRequirementChain, requirementReleaseCounts, selectRequirementChain, RequirementChainSnapshot, CHAIN_STAGES, chainDate } from './requirement-chain.js';

package/dist/compliance/requirement-chain.d.ts

@@ -0,0 +1,111 @@
+import type { ChainRecord, ChainFinding, ComplianceIndex } from './types.js';
+export declare const CHAIN_STAGES: readonly ["Source document", "Driver", "Need", "Stakeholder requirement", "System requirement", "Software requirement", "Unclassified requirement", "Verification definition", "Result"];
+export interface ChainScope {
+    catalogue: string;
+    product?: string;
+    release?: string;
+    project?: string;
+}
+export interface ChainInput {
+    index: ComplianceIndex;
+    scope: ChainScope;
+    asAt: string;
+    snapshotId: string;
+    sourceRevision?: string;
+    complete: boolean;
+}
+export interface ChainSet {
+    ids: string[];
+    completeness: 'complete' | 'incomplete';
+    total: number | null;
+}
+export interface RequirementChainNode {
+    id: string;
+    recordId: string;
+    name: string;
+    stage: number;
+    sourcePath: string;
+    context: string[];
+    raw: Record<string, unknown>;
+}
+export interface RequirementChainEdge {
+    id: string;
+    kind: string;
+    storedFrom: string;
+    storedTo: string;
+    from: string;
+    to: string;
+    identities: string[];
+    trace: boolean;
+    valid: boolean;
+}
+export interface ChainAssignment {
+    requirement: string;
+    nearest: string;
+    depth: number;
+    relations: string[];
+}
+export interface RequirementChainProjection {
+    contract: 'requirement-chain/0.2';
+    contractRevision: string;
+    asAt: string;
+    snapshotId: string;
+    sourceRevision?: string;
+    scope: ChainScope;
+    completeness: 'complete' | 'incomplete';
+    scopeFindings: string[];
+    populations: {
+        product: ChainSet;
+        release: ChainSet;
+        selected: ChainSet;
+        inactive: ChainSet;
+        unresolved: ChainSet;
+    };
+    assignments: {
+        here: ChainSet;
+        otherReleaseOnly: ChainSet;
+        unassigned: ChainSet;
+        invalid: ChainSet;
+        provenance: ChainAssignment[];
+    };
+    stages: ChainSet[];
+    metrics: {
+        broken: ChainSet;
+        noSource: ChainSet;
+        noDefinition: ChainSet;
+        noResult: ChainSet;
+        failed: ChainSet;
+        unassigned: ChainSet;
+    };
+    records: ChainRecord[];
+    nodes: RequirementChainNode[];
+    edges: RequirementChainEdge[];
+    findings: ChainFinding[];
+    defectiveReferences: ChainSet;
+    selectedReferences: ChainSet;
+    unattributableFindings: ChainSet;
+    affectedRequirements: Record<string, string[]>;
+    definitions: Record<string, string[]>;
+    executions: Record<string, string[]>;
+}
+export declare function chainDate(v: unknown): v is string;
+/** Pure, lossless release projection; no legacy coverage verdict is reinterpreted. */
+export declare function buildRequirementChain(input: ChainInput): RequirementChainProjection;
+/** Both is two independent walks, never an expansion from the union frontier. */
+export declare function selectRequirementChain(p: RequirementChainProjection, focus?: string, direction?: 'upstream' | 'downstream' | 'both'): {
+    nodes: RequirementChainNode[];
+    edges: RequirementChainEdge[];
+};
+/** Count/list contract for the release report, derived solely from the shared snapshot. */
+export declare function requirementReleaseCounts(p: RequirementChainProjection): Record<string, {
+    label: string;
+    unit: "requirements" | "references" | "findings" | "source documents" | "drivers" | "needs" | "definition parts" | "result parts";
+    set: ChainSet;
+}>;
+/** Monotonic refresh gate shared by reports; late successes and failures cannot replace newer data. */
+export declare class RequirementChainSnapshot {
+    private generation;
+    current?: RequirementChainProjection;
+    stale: boolean;
+    refresh(load: () => Promise<ChainInput>): Promise<boolean>;
+}