@transitrix/diagrams 1.13.3 → 1.14.0-rc.0

package/dist/compliance/canon-catalog.js

@@ -44,7 +44,7 @@ export function buildComplianceScan(docs) {
     const catalogMap = new Map();
     const pathById = new Map();
     for (const { path, data } of docs) {
-        const ingested = ingestComplianceDoc(complianceCanon, data);
+        const ingested = ingestComplianceDoc(complianceCanon, data, path);
         if (ingested)
             pathById.set(ingested, path);
         const admitted = admitDocumentToCatalog(catalogMap, data);

package/dist/compliance/classify.d.ts

@@ -1,3 +1,4 @@
+import type { ChainRecord, ChainFinding } from './types.js';
 import type { IndexAssertion, IndexRequirement, IndexVerification, IndexNeed, IndexValidation } from './types.js';
 export interface ComplianceProduct {
     id: string;
@@ -11,6 +12,8 @@ export interface ComplianceCodexDoc {
 }
 /** The bucketed result of scanning a repo for compliance canon. */
 export interface ComplianceCanon {
+    records: ChainRecord[];
+    findings: ChainFinding[];
     products: ComplianceProduct[];
     requirements: IndexRequirement[];
     assertions: IndexAssertion[];
@@ -49,4 +52,4 @@ export declare function emptyCanon(): ComplianceCanon;
  * its id duplicates one already ingested into the same bucket (see
  * `canon.duplicateIds`).
  */
-export declare function ingestComplianceDoc(canon: ComplianceCanon, doc: unknown): string | null;
+export declare function ingestComplianceDoc(canon: ComplianceCanon, doc: unknown, sourcePath?: string): string | null;

package/dist/compliance/classify.js

@@ -2,8 +2,11 @@
 // for "what is a compliance artefact" — used by both the Studio extension scan
 // (webview previews) and the CLI scan (`export-compliance`), so the recognition
 // rules live once. Pure: takes a parsed YAML document, no IO.
+import { typeOfId } from '../typed-id.js';
 export function emptyCanon() {
     return {
+        records: [],
+        findings: [],
         products: [],
         requirements: [],
         assertions: [],
@@ -40,7 +43,8 @@ function pushUnique(canon, list, item) {
  * its id duplicates one already ingested into the same bucket (see
  * `canon.duplicateIds`).
  */
-export function ingestComplianceDoc(canon, doc) {
+export function ingestComplianceDoc(canon, doc, sourcePath = '') {
+    retainChainRecord(canon, doc, sourcePath);
     if (doc === null || typeof doc !== 'object' || Array.isArray(doc))
         return null;
     const d = doc;
@@ -128,3 +132,19 @@ export function ingestComplianceDoc(canon, doc) {
     }
     return null;
 }
+/** Retain malformed values and cross-type duplicates without changing legacy buckets. */
+function retainChainRecord(canon, doc, sourcePath) {
+    if (!doc || typeof doc !== 'object' || Array.isArray(doc)) {
+        canon.findings.push({ id: `${sourcePath}:document`, owner: sourcePath, field: '',
+            code: 'INTAKE', message: 'Expected a document mapping', reference: false, severity: 'error' });
+        return;
+    }
+    const raw = structuredClone(doc);
+    if (typeof raw.id !== 'string' || !raw.id.trim()) {
+        if ('id' in raw || 'zone' in raw || ['requirement', 'verification', 'need', 'product', 'release', 'relation', 'driver'].includes(String(raw.notation)))
+            canon.findings.push({ id: `${sourcePath}:id`, owner: sourcePath,
+                field: 'id', code: 'INTAKE', message: 'Missing record identity', reference: false, severity: 'error' });
+        return;
+    }
+    canon.records.push({ id: raw.id, type: typeOfId(raw.id) ?? '', sourcePath, raw });
+}

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>;
+}