@mitre/hdf-diff 3.4.3 → 3.5.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/README.md +1 -0
- package/dist/index.d.ts +156 -5
- package/dist/index.d.ts.map +1 -1
- package/dist/index.js +514 -39
- package/dist/index.js.map +1 -1
- package/package.json +3 -3
package/README.md
CHANGED
|
@@ -11,6 +11,7 @@ Compares HDF documents (results, baselines, or system documents) and produces a
|
|
|
11
11
|
- **System drift** (`diffSystems`) — compare two HDF system documents for component, data flow, and configuration changes
|
|
12
12
|
- **SBOM comparison** (`diffSboms`) — CycloneDX/SPDX package-level diffs (added, removed, updated)
|
|
13
13
|
- **Amendment operations** (Go only, `amend` subpackage) — merge overrides into results, verify amendment chains, compute effectiveStatus/effectiveImpact/disposition
|
|
14
|
+
- **Requirement change events** (`changeEventFromPrevious`, `applyChangeEvents`, `foldChangeEventsIntoComparison`) — the continuous-monitoring kernel (ADR-0005): derive a per-requirement change-event stream between two scans, fold a batch of events into a comparison, and replay events onto a seed to reassemble a reconciled results document (parity law: `applyChangeEvents(A, derive(A→B)) ≡ B` at requirement level). Dual Go + TS; wrapped by the `hdf events` CLI command group.
|
|
14
15
|
|
|
15
16
|
Additional capabilities:
|
|
16
17
|
- Multiple comparison modes: temporal, baseline, fleet, multi-source
|
package/dist/index.d.ts
CHANGED
|
@@ -321,12 +321,13 @@ declare function diffSystems(oldSystem: Record<string, unknown>, newSystem: Reco
|
|
|
321
321
|
//#endregion
|
|
322
322
|
//#region src/status.d.ts
|
|
323
323
|
/**
|
|
324
|
-
* Determine the effective status of a requirement from its results and
|
|
324
|
+
* Determine the effective status of a requirement from its results and
|
|
325
|
+
* overrides, delegating to the canonical shared implementation in
|
|
326
|
+
* `@mitre/hdf-utilities` (see status-determination.md):
|
|
325
327
|
*
|
|
326
|
-
* Priority:
|
|
327
328
|
* 1. impact === 0 → notApplicable (regardless of results)
|
|
328
|
-
* 2.
|
|
329
|
-
* 3.
|
|
329
|
+
* 2. the governing (most recent non-expired) status override's status
|
|
330
|
+
* 3. effectiveStatus field set (and no statusOverrides) → use it
|
|
330
331
|
* 4. Aggregate results using worst-wins
|
|
331
332
|
* 5. Empty results → notReviewed
|
|
332
333
|
*/
|
|
@@ -346,6 +347,156 @@ declare function classifyChangeReasons(oldReq: Record<string, unknown>, newReq:
|
|
|
346
347
|
*/
|
|
347
348
|
declare function classifyDiffStatus(oldEffectiveStatus: string, newEffectiveStatus: string): RequirementState;
|
|
348
349
|
//#endregion
|
|
350
|
+
//#region src/effective-checksum.d.ts
|
|
351
|
+
interface EffectiveChecksum {
|
|
352
|
+
algorithm: 'sha256';
|
|
353
|
+
value: string;
|
|
354
|
+
}
|
|
355
|
+
/**
|
|
356
|
+
* Determine the effective impact of a requirement: the most recently applied
|
|
357
|
+
* non-expired override carrying an impact value wins (the schema's definition
|
|
358
|
+
* of effectiveImpact, selected by the shared governing helper); with no
|
|
359
|
+
* overrides, a stored effectiveImpact field is honored; otherwise the base
|
|
360
|
+
* impact. (Go parity: ComputeEffectiveImpact in hdf-diff/go/effective_checksum.go.)
|
|
361
|
+
*/
|
|
362
|
+
declare function computeEffectiveImpact(requirement: Record<string, unknown>, referenceTimestamp?: string): number;
|
|
363
|
+
/**
|
|
364
|
+
* Return the Override_Type of the governing (most recently applied
|
|
365
|
+
* non-expired) override, a stored disposition field when no overrides are
|
|
366
|
+
* present, or null. (Go parity: ComputeDisposition.)
|
|
367
|
+
*/
|
|
368
|
+
declare function computeDisposition(requirement: Record<string, unknown>, referenceTimestamp?: string): string | null;
|
|
369
|
+
/**
|
|
370
|
+
* Hash the resolved effective posture of a requirement: sha256 over the
|
|
371
|
+
* canonical JSON {"status":<resolved>,"impact":<resolved>,"disposition":<type|null>}.
|
|
372
|
+
* Flips exactly when the operative status, impact, or disposition changes;
|
|
373
|
+
* stable under all other document churn. Byte-identical with the Go
|
|
374
|
+
* implementation (ComputeEffectiveChecksum) — the key order of the canonical
|
|
375
|
+
* object is part of the contract. Pass the document timestamp as
|
|
376
|
+
* referenceTimestamp for determinism. A missing or unparseable reference
|
|
377
|
+
* falls back to the wall clock inside the shared governing-override helper,
|
|
378
|
+
* so callers that need reproducible output must always supply a valid
|
|
379
|
+
* timestamp.
|
|
380
|
+
*/
|
|
381
|
+
declare function computeEffectiveChecksum(requirement: Record<string, unknown>, referenceTimestamp?: string): Promise<EffectiveChecksum>;
|
|
382
|
+
//#endregion
|
|
383
|
+
//#region src/change-event.d.ts
|
|
384
|
+
/**
|
|
385
|
+
* The reconciler's per-key last-value state (ADR-0005 §1): the minimal
|
|
386
|
+
* posture a producer compares against to decide whether a requirement moved.
|
|
387
|
+
* Go parity: KeyState in hdf-diff/go/change_event.go.
|
|
388
|
+
*/
|
|
389
|
+
interface KeyState {
|
|
390
|
+
effectiveStatus: string;
|
|
391
|
+
effectiveImpact: number;
|
|
392
|
+
checksum: EffectiveChecksum;
|
|
393
|
+
}
|
|
394
|
+
/**
|
|
395
|
+
* Caller-injected envelope identity for an emitted event. Everything is
|
|
396
|
+
* supplied by the caller — the kernel touches no wall clock and no RNG, so
|
|
397
|
+
* identical inputs always produce identical events. referenceTimestamp
|
|
398
|
+
* anchors override expiry (pass the new document's timestamp); timestamp is
|
|
399
|
+
* the event's occurrence time (RFC 3339, trimmed UTC).
|
|
400
|
+
*/
|
|
401
|
+
interface EventInputs {
|
|
402
|
+
eventId: string;
|
|
403
|
+
source: string;
|
|
404
|
+
sequence: number;
|
|
405
|
+
systemRef: string;
|
|
406
|
+
componentId: string;
|
|
407
|
+
requirementId: string;
|
|
408
|
+
timestamp: string;
|
|
409
|
+
referenceTimestamp: string;
|
|
410
|
+
/** Prior observation's timestamp — enables overrideExpired detection across the window. */
|
|
411
|
+
prevReferenceTimestamp?: string;
|
|
412
|
+
schemaRef?: string;
|
|
413
|
+
}
|
|
414
|
+
/**
|
|
415
|
+
* The pure detection kernel (ADR-0005): compare a requirement's resolved
|
|
416
|
+
* posture against the stored last-value state and emit a
|
|
417
|
+
* Requirement_Change_Event when it moved, or null when it did not.
|
|
418
|
+
*
|
|
419
|
+
* - prev null → state "new" (chain start: null before/priorChecksum)
|
|
420
|
+
* - newReq null → state "absent" (after null, thin before preserved)
|
|
421
|
+
* - checksum match → null (no event; the steady-state majority)
|
|
422
|
+
* - otherwise → fixed/regressed/updated per the effective-status
|
|
423
|
+
* transition, with the full after requirement as payload
|
|
424
|
+
*
|
|
425
|
+
* prevReq (optional) is the full prior requirement when the caller's
|
|
426
|
+
* materialized state has it; it enables complete changeReasons
|
|
427
|
+
* classification via the batch classifier, filtered to the event
|
|
428
|
+
* vocabulary. Without it, only reasons provable from the thin state
|
|
429
|
+
* (impactChanged) are emitted. Byte-parity with the Go kernel
|
|
430
|
+
* (ChangeEventFromPrevious) is pinned by shared test vectors.
|
|
431
|
+
*/
|
|
432
|
+
declare function changeEventFromPrevious(prev: KeyState | null, newReq: Record<string, unknown> | null, prevReq: Record<string, unknown> | null, inputs: EventInputs): Promise<Record<string, unknown> | null>;
|
|
433
|
+
//#endregion
|
|
434
|
+
//#region src/apply-events.d.ts
|
|
435
|
+
/**
|
|
436
|
+
* Caller-supplied identity for a reassembly run. Everything else in the
|
|
437
|
+
* derivation block is computed from the seed text and the event batch — no
|
|
438
|
+
* wall clock, no RNG. Go parity: ApplyInputs in hdf-diff/go/apply_events.go.
|
|
439
|
+
*/
|
|
440
|
+
interface ApplyInputs {
|
|
441
|
+
/** Names the reconciling tool — a reconciled document never masquerades as scanner output. */
|
|
442
|
+
generator: {
|
|
443
|
+
name: string;
|
|
444
|
+
version: string;
|
|
445
|
+
};
|
|
446
|
+
/** Locates the seed snapshot; its checksum is computed from the seed text. */
|
|
447
|
+
seedUri: string;
|
|
448
|
+
/** The event-stream producer context recorded in the derivation block. */
|
|
449
|
+
source: string;
|
|
450
|
+
}
|
|
451
|
+
/**
|
|
452
|
+
* A non-fatal per-key anomaly. Warnings never abort the fold: the key is
|
|
453
|
+
* still applied last-value-wins and the warning marks it unverified
|
|
454
|
+
* (ADR-0005 §4 fold contract).
|
|
455
|
+
*/
|
|
456
|
+
interface ApplyWarning {
|
|
457
|
+
requirementId: string;
|
|
458
|
+
/** chainGap | newOnExisting | absentUnknown | multiBaseline */
|
|
459
|
+
kind: string;
|
|
460
|
+
message: string;
|
|
461
|
+
}
|
|
462
|
+
interface ApplyResult {
|
|
463
|
+
results: Record<string, unknown>;
|
|
464
|
+
warnings: ApplyWarning[];
|
|
465
|
+
}
|
|
466
|
+
type Doc$1 = Record<string, unknown>;
|
|
467
|
+
/**
|
|
468
|
+
* Reassemble the current posture from a seed hdf-results document plus a
|
|
469
|
+
* batch of requirement-change events (ADR-0005 §§4-7): keyed last-value-wins
|
|
470
|
+
* by sequence, idempotent via (source, eventId) dedup, tombstone-aware
|
|
471
|
+
* (absent removes), total over the event-state enum. Delivery order and
|
|
472
|
+
* duplicates never change the output. The result carries the caller's
|
|
473
|
+
* generator and a derivation block (seed pinned by content, watermark,
|
|
474
|
+
* count, asOf) so it can never masquerade as scan evidence. Chain gaps and
|
|
475
|
+
* anomalies surface as warnings, never as refusal. Go parity:
|
|
476
|
+
* ApplyChangeEvents.
|
|
477
|
+
*/
|
|
478
|
+
declare function applyChangeEvents(seedJson: string, events: Doc$1[], inputs: ApplyInputs): Promise<ApplyResult>;
|
|
479
|
+
//#endregion
|
|
480
|
+
//#region src/fold-events.d.ts
|
|
481
|
+
type Doc = Record<string, unknown>;
|
|
482
|
+
interface FoldResult {
|
|
483
|
+
comparison: Record<string, unknown>;
|
|
484
|
+
warnings: ApplyWarning[];
|
|
485
|
+
}
|
|
486
|
+
/**
|
|
487
|
+
* Materialize a change-event batch into a full systemDrift hdf-comparison
|
|
488
|
+
* against the seed document (ADR-0005 §5): each winning event lifts into the
|
|
489
|
+
* Requirement_Diff shape the batch engine produces — before from the seed,
|
|
490
|
+
* after from the event payload, field changes derived by the batch engine's
|
|
491
|
+
* own computeFieldChanges — under the same fold contract as
|
|
492
|
+
* applyChangeEvents (dedup, last-value-wins by sequence, tombstone-aware,
|
|
493
|
+
* warnings never abort). Deterministic: the comparison timestamp is the
|
|
494
|
+
* latest event occurrence, and seed-side override expiry anchors to the
|
|
495
|
+
* seed's own timestamp (falling back to the event occurrence when the seed
|
|
496
|
+
* has none) — never wall clock. Go parity: FoldChangeEventsIntoComparison.
|
|
497
|
+
*/
|
|
498
|
+
declare function foldChangeEventsIntoComparison(seedJson: string, events: Doc[]): Promise<FoldResult>;
|
|
499
|
+
//#endregion
|
|
349
500
|
//#region src/summary.d.ts
|
|
350
501
|
/**
|
|
351
502
|
* Compute summary counts from an array of RequirementDiff entries.
|
|
@@ -697,5 +848,5 @@ declare function renderCsv(comparison: HDFComparison, options?: RenderOptions):
|
|
|
697
848
|
*/
|
|
698
849
|
declare function render(comparison: HDFComparison, format: 'json' | 'markdown' | 'terminal' | 'csv', options?: RenderOptions): string;
|
|
699
850
|
//#endregion
|
|
700
|
-
export { type Annotation, type BaselineDiff, type ChangeReason, type ComparisonSummary, type ComponentDiff, type DetailLevel, type DiffOptions, type DiffStatus, type DiffSummary, EXIT_DETAILED_BASELINE_CHANGED, EXIT_DETAILED_DRIFT_ONLY, EXIT_DETAILED_ERROR, EXIT_DETAILED_FIXES_ONLY, EXIT_DETAILED_IDENTICAL, EXIT_DETAILED_MIXED, EXIT_DETAILED_REGRESSIONS_ONLY, EXIT_DIFFERENCES, EXIT_ERROR, EXIT_IDENTICAL, type FieldChange, type HDFComparison, type HdfComparison, type HdfDiff, type MatchOptions, type MatchPair, type MatchResult, type MatchStrategy, type MatchingConfig, type PackageDiff, type RenderOptions, type RequirementDiff, type RequirementState, type SbomDiffResult, type Source, type ValidationResult, classifyChangeReasons, classifyDiffStatus, computeDetailedExitCode, computeEffectiveStatus, computeExitCode, computeSummary, createCciMatchStrategy, createExactIdStrategy, createFuzzyTitleStrategy, createMappedIdStrategy, createSrgCciTiebreakStrategy, createSrgDeterministicStrategy, createVendorFuzzyTitleStrategy, diffBaselines, diffHdf, diffSboms, diffSystems, isV1Format, jaccardSimilarity, levenshteinDistance, matchRequirements, normalizeToV2, normalizedLevenshtein, render, renderCsv, renderJson, renderMarkdown, renderTerminal, tokenize, validateComparison };
|
|
851
|
+
export { type Annotation, type ApplyInputs, type ApplyResult, type ApplyWarning, type BaselineDiff, type ChangeReason, type ComparisonSummary, type ComponentDiff, type DetailLevel, type DiffOptions, type DiffStatus, type DiffSummary, EXIT_DETAILED_BASELINE_CHANGED, EXIT_DETAILED_DRIFT_ONLY, EXIT_DETAILED_ERROR, EXIT_DETAILED_FIXES_ONLY, EXIT_DETAILED_IDENTICAL, EXIT_DETAILED_MIXED, EXIT_DETAILED_REGRESSIONS_ONLY, EXIT_DIFFERENCES, EXIT_ERROR, EXIT_IDENTICAL, type EffectiveChecksum, type EventInputs, type FieldChange, type FoldResult, type HDFComparison, type HdfComparison, type HdfDiff, type KeyState, type MatchOptions, type MatchPair, type MatchResult, type MatchStrategy, type MatchingConfig, type PackageDiff, type RenderOptions, type RequirementDiff, type RequirementState, type SbomDiffResult, type Source, type ValidationResult, applyChangeEvents, changeEventFromPrevious, classifyChangeReasons, classifyDiffStatus, computeDetailedExitCode, computeDisposition, computeEffectiveChecksum, computeEffectiveImpact, computeEffectiveStatus, computeExitCode, computeSummary, createCciMatchStrategy, createExactIdStrategy, createFuzzyTitleStrategy, createMappedIdStrategy, createSrgCciTiebreakStrategy, createSrgDeterministicStrategy, createVendorFuzzyTitleStrategy, diffBaselines, diffHdf, diffSboms, diffSystems, foldChangeEventsIntoComparison, isV1Format, jaccardSimilarity, levenshteinDistance, matchRequirements, normalizeToV2, normalizedLevenshtein, render, renderCsv, renderJson, renderMarkdown, renderTerminal, tokenize, validateComparison };
|
|
701
852
|
//# sourceMappingURL=index.d.ts.map
|
package/dist/index.d.ts.map
CHANGED
|
@@ -1 +1 @@
|
|
|
1
|
-
{"version":3,"file":"index.d.ts","names":[],"sources":["../src/sbom.ts","../src/types.ts","../src/diff.ts","../src/status.ts","../src/summary.ts","../src/normalize.ts","../src/matching/types.ts","../src/matching/exact-id.ts","../src/matching/mapped-id.ts","../src/matching/cci-match.ts","../src/matching/fuzzy-match.ts","../src/matching/srg-deterministic.ts","../src/matching/srg-cci-tiebreak.ts","../src/matching/vendor-fuzzy-title.ts","../src/matching/index.ts","../src/validate.ts","../src/exit-codes.ts","../src/renderers/types.ts","../src/renderers/json.ts","../src/renderers/markdown.ts","../src/renderers/terminal.ts","../src/renderers/csv.ts","../src/renderers/index.ts"],"mappings":";;;;;;;;;;;;;;UAciB;EACf;EACA;EACA;EACA;EACA;EACA;;;;;UAMe;EACf,cAAc;EACd;EACA;EACA;EACA;;;;;;;;;;;iBAsBc,UAAU,iBAAiB,kBAAkB;;;;;;;;;;;;;;;;;;;;KCpCjD;;;;;;;;;;;;;;;KA8BA;;;;UAcK;;EAEf;;;;;;;;;;EAUA;;EAEA;;EAEA;;;;;;EAMA;;;;;UAwBe;;EAEf;;EAEA,OAAO;;EAEP,eAAe;;EAGf,QAAQ;;EAER,OAAO;;EAGP;;EAEA;;EAEA;;EAEA;;EAEA;;EAGA,cAAc;;EAGd;;EAEA;;EAGA;;;;;UAMe;;EAEf;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;;;;;UAOe;;EAEf;;EAEA;;EAEA,QAAQ;;EAER,OAAO;;EAEP,cAAc;;;;;UAMC;;EAEf;;EAEA;;EAEA;;EAEA;;;;;UAMe;;EAEf;;EAEA;;EAEA;;EAEA;;EAEA;;;;;UAMe;;EAEf;;EAEA;;EAEA;;;;;UAMe;;EAEf;;EAEA;;EAEA;;EAEA,SAAS;;EAET,WAAW;;EAEX,SAAS;;EAET,eAAe;;EAEf,kBAAkB;;;EAGlB,iBAAiB;;;;;EAKjB,eALiB;;EAOjB;;EAEA,QAAQ;;EAER,cAAc,eAAe;;EAE7B,aAAa;;;;;UAME;;EAEf;;EAEA;;;KAOU,aAAa;;KAGb,cAAc;;KAGd,gBAAgB;;KAGhB,UAAU;;;;;;UC9QL;;EAEf;;EAEA;;EAEA;;EAEA;;EAEA,eAAe;;EAEf;;EAEA;;;;;;;;;;;iBA0Dc,QACd,YAAY,yBACZ,YAAY,0BAA0B,2BACtC,UAAU,cACT;;;;;;;;;iBA6zBa,cACd,aAAa,yBACb,aAAa,yBACb,UAAU,cACT;;;;;;;;;iBAyKa,YACd,WAAW,yBACX,WAAW,yBACX,UAAU,cACT
|
|
1
|
+
{"version":3,"file":"index.d.ts","names":[],"sources":["../src/sbom.ts","../src/types.ts","../src/diff.ts","../src/status.ts","../src/effective-checksum.ts","../src/change-event.ts","../src/apply-events.ts","../src/fold-events.ts","../src/summary.ts","../src/normalize.ts","../src/matching/types.ts","../src/matching/exact-id.ts","../src/matching/mapped-id.ts","../src/matching/cci-match.ts","../src/matching/fuzzy-match.ts","../src/matching/srg-deterministic.ts","../src/matching/srg-cci-tiebreak.ts","../src/matching/vendor-fuzzy-title.ts","../src/matching/index.ts","../src/validate.ts","../src/exit-codes.ts","../src/renderers/types.ts","../src/renderers/json.ts","../src/renderers/markdown.ts","../src/renderers/terminal.ts","../src/renderers/csv.ts","../src/renderers/index.ts"],"mappings":"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"}
|