@documentation-robotics/cli 0.1.0 → 0.1.7

package/dist/schemas/bundled/testing.json

@@ -0,0 +1,3120 @@
+{
+  "specVersion": "0.8.4",
+  "layer": {
+    "id": "testing",
+    "number": 12,
+    "name": "Testing Layer",
+    "description": "Layer 12: Testing Layer",
+    "inspired_by": {
+      "standard": "IEEE 829-2008",
+      "version": "2008",
+      "url": "https://en.wikipedia.org/wiki/IEEE_829"
+    },
+    "node_types": [
+      "testing.contextvariation",
+      "testing.coverageexclusion",
+      "testing.coveragegap",
+      "testing.coveragerequirement",
+      "testing.coveragesummary",
+      "testing.environmentfactor",
+      "testing.inputpartitionselection",
+      "testing.inputselection",
+      "testing.inputspacepartition",
+      "testing.outcomecategory",
+      "testing.partitiondependency",
+      "testing.partitionvalue",
+      "testing.targetcoveragesummary",
+      "testing.targetinputfield",
+      "testing.testcasesketch",
+      "testing.testcoveragemodel",
+      "testing.testcoveragetarget"
+    ]
+  },
+  "nodeSchemas": {
+    "contextvariation": {
+      "$schema": "http://json-schema.org/draft-07/schema#",
+      "title": "ContextVariation",
+      "description": "A distinct test type or environmental context under which a coverage target may be invoked, used to parameterize test design across different execution conditions (functional correctness, load behavior, security posture, regression state). Maps to environmental needs documented in IEEE 829-2008 test design specifications.",
+      "allOf": [
+        {
+          "$ref": "urn:dr:spec:base:spec-node"
+        }
+      ],
+      "properties": {
+        "spec_node_id": {
+          "const": "testing.contextvariation"
+        },
+        "layer_id": {
+          "const": "testing"
+        },
+        "type": {
+          "const": "contextvariation"
+        },
+        "attributes": {
+          "type": "object",
+          "properties": {
+            "description": {
+              "type": "string"
+            },
+            "contextType": {
+              "type": "string",
+              "enum": [
+                "functional",
+                "load",
+                "security",
+                "regression",
+                "smoke",
+                "exploratory"
+              ],
+              "description": "The category of test context this variation represents"
+            },
+            "environmentFactors": {
+              "type": "array",
+              "description": "References EnvironmentFactor nodes specifying the concrete environmental constraints (OS, locale, network, hardware, dependency versions) that define this context variation."
+            }
+          },
+          "required": ["contextType"],
+          "additionalProperties": false
+        }
+      },
+      "$id": "urn:dr:spec:node:testing.contextvariation"
+    },
+    "coverageexclusion": {
+      "$schema": "http://json-schema.org/draft-07/schema#",
+      "title": "CoverageExclusion",
+      "description": "A formally approved exclusion of a coverage target or requirement from the test coverage model, documenting the rationale, accepted risk, and accountable approver per test plan scope documentation in IEEE 829-2008.",
+      "allOf": [
+        {
+          "$ref": "urn:dr:spec:base:spec-node"
+        }
+      ],
+      "properties": {
+        "spec_node_id": {
+          "const": "testing.coverageexclusion"
+        },
+        "layer_id": {
+          "const": "testing"
+        },
+        "type": {
+          "const": "coverageexclusion"
+        },
+        "attributes": {
+          "type": "object",
+          "properties": {
+            "description": {
+              "type": "string"
+            },
+            "reason": {
+              "type": "string"
+            },
+            "riskAccepted": {
+              "type": "boolean"
+            },
+            "approvedBy": {
+              "type": "string"
+            },
+            "affectedTargetRef": {
+              "type": "string",
+              "description": "ID of the testing.testcoveragetarget or testing.coveragerequirement being excluded from coverage"
+            },
+            "dateApproved": {
+              "type": "string",
+              "format": "date",
+              "description": "ISO date when the exclusion was formally approved, supporting audit trail requirements"
+            }
+          },
+          "required": ["reason", "riskAccepted", "approvedBy"],
+          "additionalProperties": false
+        }
+      },
+      "$id": "urn:dr:spec:node:testing.coverageexclusion"
+    },
+    "coveragegap": {
+      "$schema": "http://json-schema.org/draft-07/schema#",
+      "title": "CoverageGap",
+      "description": "An identified deficit between required and achieved test coverage for a target or requirement, typically surfaced during test summary reporting per IEEE 829-2008. Gaps require remediation, risk acceptance (CoverageExclusion), or deferral.",
+      "allOf": [
+        {
+          "$ref": "urn:dr:spec:base:spec-node"
+        }
+      ],
+      "properties": {
+        "spec_node_id": {
+          "const": "testing.coveragegap"
+        },
+        "layer_id": {
+          "const": "testing"
+        },
+        "type": {
+          "const": "coveragegap"
+        },
+        "attributes": {
+          "type": "object",
+          "properties": {
+            "description": {
+              "type": "string"
+            },
+            "severity": {
+              "type": "string",
+              "enum": ["critical", "high", "medium", "low"],
+              "description": "Risk level of leaving this gap unaddressed"
+            },
+            "affectedRequirements": {
+              "type": "string",
+              "description": "Identifier or reference to the requirement(s) that remain uncovered due to this gap."
+            },
+            "remediationStatus": {
+              "type": "string",
+              "enum": ["open", "deferred", "resolved", "accepted-risk"],
+              "description": "Lifecycle state of this coverage gap."
+            },
+            "targetRef": {
+              "type": "string",
+              "description": "ID of the testing.testcoveragetarget where this gap was identified"
+            }
+          },
+          "required": ["severity", "affectedRequirements"],
+          "additionalProperties": false
+        }
+      },
+      "$id": "urn:dr:spec:node:testing.coveragegap"
+    },
+    "coveragerequirement": {
+      "$schema": "http://json-schema.org/draft-07/schema#",
+      "title": "CoverageRequirement",
+      "description": "A specification of coverage criteria that must be satisfied for a TestCoverageTarget, defining which input partitions, context variations, and outcome categories must be exercised per IEEE 829-2008 test design specification requirements. The specific partitions, context variations, and outcome categories are associated via relationships (to InputPartitionSelection, ContextVariation, and OutcomeCategory nodes) rather than direct attributes.",
+      "allOf": [
+        {
+          "$ref": "urn:dr:spec:base:spec-node"
+        }
+      ],
+      "properties": {
+        "spec_node_id": {
+          "const": "testing.coveragerequirement"
+        },
+        "layer_id": {
+          "const": "testing"
+        },
+        "type": {
+          "const": "coveragerequirement"
+        },
+        "attributes": {
+          "type": "object",
+          "properties": {
+            "description": {
+              "type": "string"
+            },
+            "coverageCriteria": {
+              "type": "string",
+              "enum": [
+                "all-partitions",
+                "boundary-values",
+                "pairwise",
+                "each-choice",
+                "MC/DC",
+                "path-coverage"
+              ],
+              "description": "The coverage strategy defining which combinations of partition values must be exercised"
+            },
+            "priority": {
+              "type": "string",
+              "enum": ["critical", "high", "medium", "low"],
+              "description": "Relative importance of fulfilling this coverage requirement"
+            }
+          },
+          "required": ["coverageCriteria"],
+          "additionalProperties": false
+        }
+      },
+      "$id": "urn:dr:spec:node:testing.coveragerequirement"
+    },
+    "coveragesummary": {
+      "$schema": "http://json-schema.org/draft-07/schema#",
+      "title": "CoverageSummary",
+      "description": "Aggregated coverage status across all targets and requirements within a test coverage model, suitable for test summary reporting.",
+      "allOf": [
+        {
+          "$ref": "urn:dr:spec:base:spec-node"
+        }
+      ],
+      "properties": {
+        "spec_node_id": {
+          "const": "testing.coveragesummary"
+        },
+        "layer_id": {
+          "const": "testing"
+        },
+        "type": {
+          "const": "coveragesummary"
+        },
+        "attributes": {
+          "type": "object",
+          "properties": {
+            "modelRef": {
+              "type": "string",
+              "description": "ID of the testing.testcoveragemodel this summary aggregates"
+            },
+            "generatedAt": {
+              "type": "string"
+            },
+            "totalTargets": {
+              "type": "integer"
+            },
+            "totalRequirements": {
+              "type": "integer"
+            },
+            "totalSketches": {
+              "type": "integer"
+            }
+          },
+          "required": ["totalTargets", "totalRequirements", "totalSketches"],
+          "additionalProperties": false
+        }
+      },
+      "$id": "urn:dr:spec:node:testing.coveragesummary"
+    },
+    "environmentfactor": {
+      "$schema": "http://json-schema.org/draft-07/schema#",
+      "title": "EnvironmentFactor",
+      "description": "A specific environmental variable (OS version, network latency, locale setting, hardware configuration, dependency version) documented as affecting test behavior. Used to parameterize ContextVariation instances with concrete environmental constraints per IEEE 829-2008 environmental needs specification.",
+      "allOf": [
+        {
+          "$ref": "urn:dr:spec:base:spec-node"
+        }
+      ],
+      "properties": {
+        "spec_node_id": {
+          "const": "testing.environmentfactor"
+        },
+        "layer_id": {
+          "const": "testing"
+        },
+        "type": {
+          "const": "environmentfactor"
+        },
+        "attributes": {
+          "type": "object",
+          "properties": {
+            "factorType": {
+              "type": "string",
+              "enum": [
+                "os",
+                "network",
+                "locale",
+                "hardware",
+                "dependency-version"
+              ],
+              "description": "Category of environmental variable being documented."
+            },
+            "value": {
+              "type": "string",
+              "description": "The specific value or constraint for this factor (e.g., 'Ubuntu 22.04', 'latency < 100ms', 'en-US', 'Node.js 20.x')."
+            },
+            "expectedRange": {
+              "type": "string",
+              "description": "Acceptable range or set of values for this factor in the test environment (e.g., 'latency 50-200ms', 'Ubuntu 20.04 or 22.04')."
+            },
+            "testImpact": {
+              "type": "string",
+              "description": "Description of how variations in this factor are expected to affect test behavior or outcomes."
+            },
+            "description": {
+              "type": "string"
+            }
+          },
+          "required": ["factorType", "value"],
+          "additionalProperties": false
+        }
+      },
+      "$id": "urn:dr:spec:node:testing.environmentfactor"
+    },
+    "inputpartitionselection": {
+      "$schema": "http://json-schema.org/draft-07/schema#",
+      "title": "InputPartitionSelection",
+      "description": "A specification of which values from an InputSpacePartition must be exercised within a CoverageRequirement, supporting selective coverage of equivalence classes per IEEE 829-2008 test design specification. When coverAllCategories is true, all partition values are included except those in excludeValues; otherwise, only the values listed in coverValues are included.",
+      "allOf": [
+        {
+          "$ref": "urn:dr:spec:base:spec-node"
+        }
+      ],
+      "properties": {
+        "spec_node_id": {
+          "const": "testing.inputpartitionselection"
+        },
+        "layer_id": {
+          "const": "testing"
+        },
+        "type": {
+          "const": "inputpartitionselection"
+        },
+        "attributes": {
+          "type": "object",
+          "properties": {
+            "partitionRef": {
+              "type": "string",
+              "description": "ID of the testing.inputspacepartition from which values are being selected for coverage."
+            },
+            "coverValues": {
+              "type": "string",
+              "description": "Comma-separated labels or IDs of specific partition values to include in coverage. Ignored when coverAllCategories is true."
+            },
+            "coverAllCategories": {
+              "type": "boolean",
+              "description": "When true, all partition values are included in coverage except those listed in excludeValues. Overrides coverValues."
+            },
+            "excludeValues": {
+              "type": "string",
+              "description": "Comma-separated labels or IDs of partition values to exclude from coverage. Applied when coverAllCategories is true to carve out specific values."
+            }
+          },
+          "required": [
+            "partitionRef",
+            "coverValues",
+            "coverAllCategories",
+            "excludeValues"
+          ],
+          "additionalProperties": false
+        }
+      },
+      "$id": "urn:dr:spec:node:testing.inputpartitionselection"
+    },
+    "inputselection": {
+      "$schema": "http://json-schema.org/draft-07/schema#",
+      "title": "InputSelection",
+      "description": "A concrete input value assignment for a TestCaseSketch, binding an abstract partition representative value (selectedValue) to a specific concrete test datum (concreteValue), per test case input specification in IEEE 829-2008.",
+      "allOf": [
+        {
+          "$ref": "urn:dr:spec:base:spec-node"
+        }
+      ],
+      "properties": {
+        "spec_node_id": {
+          "const": "testing.inputselection"
+        },
+        "layer_id": {
+          "const": "testing"
+        },
+        "type": {
+          "const": "inputselection"
+        },
+        "attributes": {
+          "type": "object",
+          "properties": {
+            "partitionRef": {
+              "type": "string"
+            },
+            "selectedValue": {
+              "type": "string"
+            },
+            "concreteValue": {
+              "type": "string"
+            },
+            "valueSource": {
+              "type": "string",
+              "enum": ["manual", "generated", "data-driven", "fixture"],
+              "description": "How the concrete value was obtained: manually authored, algorithmically generated, drawn from a data set, or loaded from a test fixture"
+            }
+          },
+          "required": [
+            "partitionRef",
+            "selectedValue",
+            "concreteValue",
+            "valueSource"
+          ],
+          "additionalProperties": false
+        }
+      },
+      "$id": "urn:dr:spec:node:testing.inputselection"
+    },
+    "inputspacepartition": {
+      "$schema": "http://json-schema.org/draft-07/schema#",
+      "title": "InputSpacePartition",
+      "description": "Partitioning of an input dimension into testable equivalence classes, where each class groups values expected to behave identically under test. Enables systematic, structured coverage analysis per IEEE 829-2008 equivalence partitioning guidance by ensuring distinct behavioral categories are explicitly identified before test case selection.",
+      "allOf": [
+        {
+          "$ref": "urn:dr:spec:base:spec-node"
+        }
+      ],
+      "properties": {
+        "spec_node_id": {
+          "const": "testing.inputspacepartition"
+        },
+        "layer_id": {
+          "const": "testing"
+        },
+        "type": {
+          "const": "inputspacepartition"
+        },
+        "attributes": {
+          "type": "object",
+          "properties": {
+            "description": {
+              "type": "string"
+            },
+            "fieldRef": {
+              "type": "string"
+            },
+            "presenceRule": {
+              "type": "string",
+              "enum": [
+                "required",
+                "optional",
+                "conditional",
+                "forbidden",
+                "mutually-exclusive"
+              ],
+              "description": "Whether this input field must be present in test inputs for this partition"
+            }
+          },
+          "required": ["fieldRef", "presenceRule"],
+          "additionalProperties": false
+        }
+      },
+      "$id": "urn:dr:spec:node:testing.inputspacepartition"
+    },
+    "outcomecategory": {
+      "$schema": "http://json-schema.org/draft-07/schema#",
+      "title": "OutcomeCategory",
+      "description": "An abstract category of observable outcomes (e.g., success, validation error, authorization error, timeout) associated with a TestCoverageTarget, used during test design to organize expected results before test case specification per IEEE 829-2008. Distinguished from specific assertions — OutcomeCategory defines the class of outcome, not the exact expected value.",
+      "allOf": [
+        {
+          "$ref": "urn:dr:spec:base:spec-node"
+        }
+      ],
+      "properties": {
+        "spec_node_id": {
+          "const": "testing.outcomecategory"
+        },
+        "layer_id": {
+          "const": "testing"
+        },
+        "type": {
+          "const": "outcomecategory"
+        },
+        "attributes": {
+          "type": "object",
+          "properties": {
+            "description": {
+              "type": "string"
+            },
+            "outcomeType": {
+              "type": "string",
+              "enum": [
+                "success",
+                "validation-error",
+                "authorization-error",
+                "not-found",
+                "server-error",
+                "exception",
+                "timeout"
+              ],
+              "description": "The class of observable outcome this category represents, used to group test cases by expected result type for coverage analysis and reporting."
+            }
+          },
+          "required": ["outcomeType"],
+          "additionalProperties": false
+        }
+      },
+      "$id": "urn:dr:spec:node:testing.outcomecategory"
+    },
+    "partitiondependency": {
+      "$schema": "http://json-schema.org/draft-07/schema#",
+      "title": "PartitionDependency",
+      "description": "A constraint specifying how selection of a partition value in one field affects valid or available partition values in another field, enabling combinatorial test design to avoid invalid input combinations per IEEE 829-2008 test design specification.",
+      "allOf": [
+        {
+          "$ref": "urn:dr:spec:base:spec-node"
+        }
+      ],
+      "properties": {
+        "spec_node_id": {
+          "const": "testing.partitiondependency"
+        },
+        "layer_id": {
+          "const": "testing"
+        },
+        "type": {
+          "const": "partitiondependency"
+        },
+        "attributes": {
+          "type": "object",
+          "properties": {
+            "dependsOnPartition": {
+              "type": "string",
+              "description": "ID of the testing.inputspacepartition that triggers this dependency"
+            },
+            "dependsOnValue": {
+              "type": "string",
+              "description": "Label or ID of the testing.partitionvalue that activates this dependency"
+            },
+            "effect": {
+              "type": "string",
+              "enum": [
+                "excludes",
+                "requires",
+                "restricts-to",
+                "modifies-range"
+              ],
+              "description": "How the dependency affects the related partition values"
+            },
+            "affectedValues": {
+              "type": "string",
+              "description": "Comma-separated labels or IDs of the partition values in the dependent field whose availability is modified by this dependency (e.g., values that are excluded, required, or restricted when the trigger value is selected)."
+            },
+            "description": {
+              "type": "string"
+            }
+          },
+          "required": [
+            "dependsOnPartition",
+            "dependsOnValue",
+            "effect",
+            "affectedValues"
+          ],
+          "additionalProperties": false
+        }
+      },
+      "$id": "urn:dr:spec:node:testing.partitiondependency"
+    },
+    "partitionvalue": {
+      "$schema": "http://json-schema.org/draft-07/schema#",
+      "title": "PartitionValue",
+      "description": "An individual equivalence class within an InputSpacePartition, characterized by a label, representative value, and optional constraint expression, used to enumerate the testable categories of an input dimension per IEEE 829-2008 test design specification.",
+      "allOf": [
+        {
+          "$ref": "urn:dr:spec:base:spec-node"
+        }
+      ],
+      "properties": {
+        "spec_node_id": {
+          "const": "testing.partitionvalue"
+        },
+        "layer_id": {
+          "const": "testing"
+        },
+        "type": {
+          "const": "partitionvalue"
+        },
+        "attributes": {
+          "type": "object",
+          "properties": {
+            "label": {
+              "type": "string"
+            },
+            "description": {
+              "type": "string"
+            },
+            "constraint": {
+              "type": "string",
+              "description": "Human-readable description of the condition this partition boundary represents (e.g., 'must be between 0 and 100', 'must not be null or empty')."
+            },
+            "constraintExpression": {
+              "type": "string",
+              "description": "Machine-evaluable expression encoding the partition boundary condition (e.g., a regex pattern, JSONPath predicate, or comparison expression such as 'value >= 0 && value <= 100')."
+            },
+            "category": {
+              "type": "string",
+              "enum": [
+                "valid",
+                "invalid",
+                "boundary-valid",
+                "boundary-invalid",
+                "null-empty",
+                "special-character"
+              ],
+              "description": "Equivalence partition category for this value"
+            },
+            "representativeValue": {
+              "type": "string"
+            }
+          },
+          "required": [
+            "label",
+            "constraint",
+            "constraintExpression",
+            "category",
+            "representativeValue"
+          ],
+          "additionalProperties": false
+        }
+      },
+      "$id": "urn:dr:spec:node:testing.partitionvalue"
+    },
+    "targetcoveragesummary": {
+      "$schema": "http://json-schema.org/draft-07/schema#",
+      "title": "TargetCoverageSummary",
+      "description": "Coverage metrics summary for a single test coverage target",
+      "allOf": [
+        {
+          "$ref": "urn:dr:spec:base:spec-node"
+        }
+      ],
+      "properties": {
+        "spec_node_id": {
+          "const": "testing.targetcoveragesummary"
+        },
+        "layer_id": {
+          "const": "testing"
+        },
+        "type": {
+          "const": "targetcoveragesummary"
+        },
+        "attributes": {
+          "type": "object",
+          "properties": {
+            "targetRef": {
+              "type": "string",
+              "description": "ID of the testing.testcoveragetarget this summary covers"
+            },
+            "sketchCount": {
+              "type": "integer",
+              "description": "Total number of TestCaseSketch nodes for this target (design-time count; superset of implementedCount)"
+            },
+            "implementedCount": {
+              "type": "integer",
+              "description": "Number of sketches with a concrete test case implementation (must be ≤ sketchCount; superset of automatedCount)"
+            },
+            "automatedCount": {
+              "type": "integer",
+              "description": "Number of implemented test cases that are automated (must be ≤ implementedCount)"
+            },
+            "coveragePercentage": {
+              "type": "number",
+              "description": "Percentage of coverage requirements with at least one implemented test case sketch (0–100)"
+            }
+          },
+          "required": [
+            "targetRef",
+            "sketchCount",
+            "implementedCount",
+            "automatedCount"
+          ],
+          "additionalProperties": false
+        }
+      },
+      "$id": "urn:dr:spec:node:testing.targetcoveragesummary"
+    },
+    "targetinputfield": {
+      "$schema": "http://json-schema.org/draft-07/schema#",
+      "title": "TargetInputField",
+      "description": "An association between a TestCoverageTarget and a specific input field of the target artifact, defining which InputSpacePartition applies to that field and documenting its coverage relevance per IEEE 829-2008 test case specification.",
+      "allOf": [
+        {
+          "$ref": "urn:dr:spec:base:spec-node"
+        }
+      ],
+      "properties": {
+        "spec_node_id": {
+          "const": "testing.targetinputfield"
+        },
+        "layer_id": {
+          "const": "testing"
+        },
+        "type": {
+          "const": "targetinputfield"
+        },
+        "attributes": {
+          "type": "object",
+          "properties": {
+            "fieldRef": {
+              "type": "string",
+              "description": "ID of the referenced field element in the API layer (e.g., an API parameter) or Data Model layer (e.g., a data-model property)"
+            },
+            "partitionRef": {
+              "type": "string",
+              "description": "ID of the testing.inputspacepartition that defines the equivalence classes or boundary values for this input field."
+            },
+            "description": {
+              "type": "string"
+            },
+            "relevance": {
+              "type": "string",
+              "enum": ["required", "optional", "conditional", "not-applicable"],
+              "description": "Whether this field must be included in test case input specifications"
+            }
+          },
+          "required": ["fieldRef", "partitionRef"],
+          "additionalProperties": false
+        }
+      },
+      "$id": "urn:dr:spec:node:testing.targetinputfield"
+    },
+    "testcasesketch": {
+      "$schema": "http://json-schema.org/draft-07/schema#",
+      "title": "TestCaseSketch",
+      "description": "A design-time test case specification that selects concrete input partition values for a CoverageRequirement, serving as the bridge between test design (InputPartitionSelection) and executable test case specification per IEEE 829-2008. Exists in sketch (unimplemented) or implemented status — not yet tied to a specific test runner or execution framework.",
+      "allOf": [
+        {
+          "$ref": "urn:dr:spec:base:spec-node"
+        }
+      ],
+      "properties": {
+        "spec_node_id": {
+          "const": "testing.testcasesketch"
+        },
+        "layer_id": {
+          "const": "testing"
+        },
+        "type": {
+          "const": "testcasesketch"
+        },
+        "attributes": {
+          "type": "object",
+          "properties": {
+            "description": {
+              "type": "string"
+            },
+            "status": {
+              "type": "string",
+              "enum": [
+                "draft",
+                "under-review",
+                "approved",
+                "implemented",
+                "automated",
+                "deprecated"
+              ],
+              "description": "Lifecycle status of the test case sketch"
+            },
+            "inputSelections": {
+              "type": "array",
+              "description": "References InputPartitionSelection nodes specifying which partition values this sketch exercises."
+            },
+            "implementationFormat": {
+              "type": "string",
+              "enum": ["manual", "automated", "semi-automated", "exploratory"],
+              "description": "How the test case will be executed"
+            },
+            "source": {
+              "type": "object",
+              "description": "Source code reference to the test case implementation"
+            }
+          },
+          "required": ["status"],
+          "additionalProperties": false
+        }
+      },
+      "$id": "urn:dr:spec:node:testing.testcasesketch"
+    },
+    "testcoveragemodel": {
+      "$schema": "http://json-schema.org/draft-07/schema#",
+      "title": "TestCoverageModel",
+      "description": "The root artifact of a testing layer coverage specification, aggregating all TestCoverageTargets, InputSpacePartitions, ContextVariations, CoverageRequirements, and TestCaseSketches for an application. Corresponds to the test plan document structure in IEEE 829-2008, providing a single point of reference for coverage governance.",
+      "allOf": [
+        {
+          "$ref": "urn:dr:spec:base:spec-node"
+        }
+      ],
+      "properties": {
+        "spec_node_id": {
+          "const": "testing.testcoveragemodel"
+        },
+        "layer_id": {
+          "const": "testing"
+        },
+        "type": {
+          "const": "testcoveragemodel"
+        },
+        "attributes": {
+          "type": "object",
+          "properties": {
+            "version": {
+              "type": "string"
+            },
+            "application": {
+              "type": "string",
+              "description": "Cross-layer reference ID to the application or API element (application layer or api layer) being covered by this model"
+            },
+            "description": {
+              "type": "string"
+            },
+            "source": {
+              "type": "object",
+              "description": "Provenance information indicating the origin of this model (e.g., manually authored, imported from OpenAPI, or generated from source artifacts)"
+            }
+          },
+          "required": ["version", "application"],
+          "additionalProperties": false
+        }
+      },
+      "$id": "urn:dr:spec:node:testing.testcoveragemodel"
+    },
+    "testcoveragetarget": {
+      "$schema": "http://json-schema.org/draft-07/schema#",
+      "title": "TestCoverageTarget",
+      "description": "The primary unit of test scope governance in a TestCoverageModel, identifying an artifact or functionality that requires test coverage per IEEE 829-2008 Section 5.2.3 (Features to be tested). A target may represent an API endpoint, UI component, business workflow, or integration point — each anchoring a set of CoverageRequirements and TestCaseSketches.",
+      "allOf": [
+        {
+          "$ref": "urn:dr:spec:base:spec-node"
+        }
+      ],
+      "properties": {
+        "spec_node_id": {
+          "const": "testing.testcoveragetarget"
+        },
+        "layer_id": {
+          "const": "testing"
+        },
+        "type": {
+          "const": "testcoveragetarget"
+        },
+        "attributes": {
+          "type": "object",
+          "properties": {
+            "description": {
+              "type": "string"
+            },
+            "targetType": {
+              "type": "string",
+              "enum": [
+                "api-endpoint",
+                "business-workflow",
+                "ui-component",
+                "data-migration",
+                "integration-flow",
+                "scheduled-job"
+              ],
+              "description": "The kind of artifact or functionality requiring test coverage"
+            },
+            "priority": {
+              "type": "string",
+              "enum": ["critical", "high", "medium", "low"],
+              "description": "Relative importance of achieving coverage for this target"
+            },
+            "source": {
+              "type": "object",
+              "description": "Source code reference for the artifact requiring test coverage"
+            }
+          },
+          "required": ["targetType"],
+          "additionalProperties": false
+        }
+      },
+      "$id": "urn:dr:spec:node:testing.testcoveragetarget"
+    }
+  },
+  "relationshipSchemas": {
+    "testing.contextvariation.depends-on.testing.contextvariation": {
+      "id": "testing.contextvariation.depends-on.testing.contextvariation",
+      "source_spec_node_id": "testing.contextvariation",
+      "source_layer": "testing",
+      "destination_spec_node_id": "testing.contextvariation",
+      "destination_layer": "testing",
+      "predicate": "depends-on",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.contextvariation.references.testing.environmentfactor": {
+      "id": "testing.contextvariation.references.testing.environmentfactor",
+      "source_spec_node_id": "testing.contextvariation",
+      "source_layer": "testing",
+      "destination_spec_node_id": "testing.environmentfactor",
+      "destination_layer": "testing",
+      "predicate": "references",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.contextvariation.serves.testing.testcoveragetarget": {
+      "id": "testing.contextvariation.serves.testing.testcoveragetarget",
+      "source_spec_node_id": "testing.contextvariation",
+      "source_layer": "testing",
+      "destination_spec_node_id": "testing.testcoveragetarget",
+      "destination_layer": "testing",
+      "predicate": "serves",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.coverageexclusion.references.testing.coveragegap": {
+      "id": "testing.coverageexclusion.references.testing.coveragegap",
+      "source_spec_node_id": "testing.coverageexclusion",
+      "source_layer": "testing",
+      "destination_spec_node_id": "testing.coveragegap",
+      "destination_layer": "testing",
+      "predicate": "references",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.coverageexclusion.references.testing.coveragerequirement": {
+      "id": "testing.coverageexclusion.references.testing.coveragerequirement",
+      "source_spec_node_id": "testing.coverageexclusion",
+      "source_layer": "testing",
+      "destination_spec_node_id": "testing.coveragerequirement",
+      "destination_layer": "testing",
+      "predicate": "references",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.coverageexclusion.references.testing.testcoveragetarget": {
+      "id": "testing.coverageexclusion.references.testing.testcoveragetarget",
+      "source_spec_node_id": "testing.coverageexclusion",
+      "source_layer": "testing",
+      "destination_spec_node_id": "testing.testcoveragetarget",
+      "destination_layer": "testing",
+      "predicate": "references",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.coveragegap.flows-to.testing.coverageexclusion": {
+      "id": "testing.coveragegap.flows-to.testing.coverageexclusion",
+      "source_spec_node_id": "testing.coveragegap",
+      "source_layer": "testing",
+      "destination_spec_node_id": "testing.coverageexclusion",
+      "destination_layer": "testing",
+      "predicate": "flows-to",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.coveragegap.references.testing.coveragerequirement": {
+      "id": "testing.coveragegap.references.testing.coveragerequirement",
+      "source_spec_node_id": "testing.coveragegap",
+      "source_layer": "testing",
+      "destination_spec_node_id": "testing.coveragerequirement",
+      "destination_layer": "testing",
+      "predicate": "references",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.coveragegap.references.testing.testcoveragetarget": {
+      "id": "testing.coveragegap.references.testing.testcoveragetarget",
+      "source_spec_node_id": "testing.coveragegap",
+      "source_layer": "testing",
+      "destination_spec_node_id": "testing.testcoveragetarget",
+      "destination_layer": "testing",
+      "predicate": "references",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.coveragegap.triggers.testing.coveragerequirement": {
+      "id": "testing.coveragegap.triggers.testing.coveragerequirement",
+      "source_spec_node_id": "testing.coveragegap",
+      "source_layer": "testing",
+      "destination_spec_node_id": "testing.coveragerequirement",
+      "destination_layer": "testing",
+      "predicate": "triggers",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.coveragegap.triggers.testing.partitionvalue": {
+      "id": "testing.coveragegap.triggers.testing.partitionvalue",
+      "source_spec_node_id": "testing.coveragegap",
+      "source_layer": "testing",
+      "destination_spec_node_id": "testing.partitionvalue",
+      "destination_layer": "testing",
+      "predicate": "triggers",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.coveragerequirement.accesses.testing.inputpartitionselection": {
+      "id": "testing.coveragerequirement.accesses.testing.inputpartitionselection",
+      "source_spec_node_id": "testing.coveragerequirement",
+      "source_layer": "testing",
+      "destination_spec_node_id": "testing.inputpartitionselection",
+      "destination_layer": "testing",
+      "predicate": "accesses",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.coveragerequirement.accesses.testing.inputselection": {
+      "id": "testing.coveragerequirement.accesses.testing.inputselection",
+      "source_spec_node_id": "testing.coveragerequirement",
+      "source_layer": "testing",
+      "destination_spec_node_id": "testing.inputselection",
+      "destination_layer": "testing",
+      "predicate": "accesses",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.coveragerequirement.aggregates.testing.contextvariation": {
+      "id": "testing.coveragerequirement.aggregates.testing.contextvariation",
+      "source_spec_node_id": "testing.coveragerequirement",
+      "source_layer": "testing",
+      "destination_spec_node_id": "testing.contextvariation",
+      "destination_layer": "testing",
+      "predicate": "aggregates",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.coveragerequirement.aggregates.testing.coverageexclusion": {
+      "id": "testing.coveragerequirement.aggregates.testing.coverageexclusion",
+      "source_spec_node_id": "testing.coveragerequirement",
+      "source_layer": "testing",
+      "destination_spec_node_id": "testing.coverageexclusion",
+      "destination_layer": "testing",
+      "predicate": "aggregates",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.coveragerequirement.aggregates.testing.partitionvalue": {
+      "id": "testing.coveragerequirement.aggregates.testing.partitionvalue",
+      "source_spec_node_id": "testing.coveragerequirement",
+      "source_layer": "testing",
+      "destination_spec_node_id": "testing.partitionvalue",
+      "destination_layer": "testing",
+      "predicate": "aggregates",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.coveragerequirement.composes.testing.inputpartitionselection": {
+      "id": "testing.coveragerequirement.composes.testing.inputpartitionselection",
+      "source_spec_node_id": "testing.coveragerequirement",
+      "source_layer": "testing",
+      "destination_spec_node_id": "testing.inputpartitionselection",
+      "destination_layer": "testing",
+      "predicate": "composes",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.coveragerequirement.composes.testing.outcomecategory": {
+      "id": "testing.coveragerequirement.composes.testing.outcomecategory",
+      "source_spec_node_id": "testing.coveragerequirement",
+      "source_layer": "testing",
+      "destination_spec_node_id": "testing.outcomecategory",
+      "destination_layer": "testing",
+      "predicate": "composes",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.coveragerequirement.composes.testing.testcoveragetarget": {
+      "id": "testing.coveragerequirement.composes.testing.testcoveragetarget",
+      "source_spec_node_id": "testing.coveragerequirement",
+      "source_layer": "testing",
+      "destination_spec_node_id": "testing.testcoveragetarget",
+      "destination_layer": "testing",
+      "predicate": "composes",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.coveragerequirement.constrained-by.motivation.constraint": {
+      "id": "testing.coveragerequirement.constrained-by.motivation.constraint",
+      "source_spec_node_id": "testing.coveragerequirement",
+      "source_layer": "testing",
+      "destination_spec_node_id": "motivation.constraint",
+      "destination_layer": "motivation",
+      "predicate": "constrained-by",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.coveragerequirement.covers.application.applicationfunction": {
+      "id": "testing.coveragerequirement.covers.application.applicationfunction",
+      "source_spec_node_id": "testing.coveragerequirement",
+      "source_layer": "testing",
+      "destination_spec_node_id": "application.applicationfunction",
+      "destination_layer": "application",
+      "predicate": "covers",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.coveragerequirement.covers.ux.experiencestate": {
+      "id": "testing.coveragerequirement.covers.ux.experiencestate",
+      "source_spec_node_id": "testing.coveragerequirement",
+      "source_layer": "testing",
+      "destination_spec_node_id": "ux.experiencestate",
+      "destination_layer": "ux",
+      "predicate": "covers",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.coveragerequirement.covers.navigation.navigationguard": {
+      "id": "testing.coveragerequirement.covers.navigation.navigationguard",
+      "source_spec_node_id": "testing.coveragerequirement",
+      "source_layer": "testing",
+      "destination_spec_node_id": "navigation.navigationguard",
+      "destination_layer": "navigation",
+      "predicate": "covers",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.coveragerequirement.covers.data-model.schemaproperty": {
+      "id": "testing.coveragerequirement.covers.data-model.schemaproperty",
+      "source_spec_node_id": "testing.coveragerequirement",
+      "source_layer": "testing",
+      "destination_spec_node_id": "data-model.schemaproperty",
+      "destination_layer": "data-model",
+      "predicate": "covers",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.coveragerequirement.depends-on.testing.contextvariation": {
+      "id": "testing.coveragerequirement.depends-on.testing.contextvariation",
+      "source_spec_node_id": "testing.coveragerequirement",
+      "source_layer": "testing",
+      "destination_spec_node_id": "testing.contextvariation",
+      "destination_layer": "testing",
+      "predicate": "depends-on",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.coveragerequirement.depends-on.testing.inputspacepartition": {
+      "id": "testing.coveragerequirement.depends-on.testing.inputspacepartition",
+      "source_spec_node_id": "testing.coveragerequirement",
+      "source_layer": "testing",
+      "destination_spec_node_id": "testing.inputspacepartition",
+      "destination_layer": "testing",
+      "predicate": "depends-on",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.coveragerequirement.depends-on.testing.outcomecategory": {
+      "id": "testing.coveragerequirement.depends-on.testing.outcomecategory",
+      "source_spec_node_id": "testing.coveragerequirement",
+      "source_layer": "testing",
+      "destination_spec_node_id": "testing.outcomecategory",
+      "destination_layer": "testing",
+      "predicate": "depends-on",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.coveragerequirement.flows-to.testing.coveragerequirement": {
+      "id": "testing.coveragerequirement.flows-to.testing.coveragerequirement",
+      "source_spec_node_id": "testing.coveragerequirement",
+      "source_layer": "testing",
+      "destination_spec_node_id": "testing.coveragerequirement",
+      "destination_layer": "testing",
+      "predicate": "flows-to",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.coveragerequirement.flows-to.testing.testcasesketch": {
+      "id": "testing.coveragerequirement.flows-to.testing.testcasesketch",
+      "source_spec_node_id": "testing.coveragerequirement",
+      "source_layer": "testing",
+      "destination_spec_node_id": "testing.testcasesketch",
+      "destination_layer": "testing",
+      "predicate": "flows-to",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.coveragerequirement.fulfills-requirements.motivation.requirement": {
+      "id": "testing.coveragerequirement.fulfills-requirements.motivation.requirement",
+      "source_spec_node_id": "testing.coveragerequirement",
+      "source_layer": "testing",
+      "destination_spec_node_id": "motivation.requirement",
+      "destination_layer": "motivation",
+      "predicate": "fulfills-requirements",
+      "cardinality": "many-to-many",
+      "strength": "high",
+      "required": false
+    },
+    "testing.coveragerequirement.references.business.businessfunction": {
+      "id": "testing.coveragerequirement.references.business.businessfunction",
+      "source_spec_node_id": "testing.coveragerequirement",
+      "source_layer": "testing",
+      "destination_spec_node_id": "business.businessfunction",
+      "destination_layer": "business",
+      "predicate": "references",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.coveragerequirement.references.testing.coveragerequirement": {
+      "id": "testing.coveragerequirement.references.testing.coveragerequirement",
+      "source_spec_node_id": "testing.coveragerequirement",
+      "source_layer": "testing",
+      "destination_spec_node_id": "testing.coveragerequirement",
+      "destination_layer": "testing",
+      "predicate": "references",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.coveragerequirement.references.apm.metricinstrument": {
+      "id": "testing.coveragerequirement.references.apm.metricinstrument",
+      "source_spec_node_id": "testing.coveragerequirement",
+      "source_layer": "testing",
+      "destination_spec_node_id": "apm.metricinstrument",
+      "destination_layer": "apm",
+      "predicate": "references",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.coveragerequirement.references.api.operation": {
+      "id": "testing.coveragerequirement.references.api.operation",
+      "source_spec_node_id": "testing.coveragerequirement",
+      "source_layer": "testing",
+      "destination_spec_node_id": "api.operation",
+      "destination_layer": "api",
+      "predicate": "references",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.coveragerequirement.references.testing.partitionvalue": {
+      "id": "testing.coveragerequirement.references.testing.partitionvalue",
+      "source_spec_node_id": "testing.coveragerequirement",
+      "source_layer": "testing",
+      "destination_spec_node_id": "testing.partitionvalue",
+      "destination_layer": "testing",
+      "predicate": "references",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.coveragerequirement.references.security.securitypolicy": {
+      "id": "testing.coveragerequirement.references.security.securitypolicy",
+      "source_spec_node_id": "testing.coveragerequirement",
+      "source_layer": "testing",
+      "destination_spec_node_id": "security.securitypolicy",
+      "destination_layer": "security",
+      "predicate": "references",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.coveragerequirement.references.testing.testcoveragetarget": {
+      "id": "testing.coveragerequirement.references.testing.testcoveragetarget",
+      "source_spec_node_id": "testing.coveragerequirement",
+      "source_layer": "testing",
+      "destination_spec_node_id": "testing.testcoveragetarget",
+      "destination_layer": "testing",
+      "predicate": "references",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.coveragerequirement.supports-goals.motivation.goal": {
+      "id": "testing.coveragerequirement.supports-goals.motivation.goal",
+      "source_spec_node_id": "testing.coveragerequirement",
+      "source_layer": "testing",
+      "destination_spec_node_id": "motivation.goal",
+      "destination_layer": "motivation",
+      "predicate": "supports-goals",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.coveragesummary.aggregates.testing.coveragerequirement": {
+      "id": "testing.coveragesummary.aggregates.testing.coveragerequirement",
+      "source_spec_node_id": "testing.coveragesummary",
+      "source_layer": "testing",
+      "destination_spec_node_id": "testing.coveragerequirement",
+      "destination_layer": "testing",
+      "predicate": "aggregates",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.coveragesummary.aggregates.testing.targetcoveragesummary": {
+      "id": "testing.coveragesummary.aggregates.testing.targetcoveragesummary",
+      "source_spec_node_id": "testing.coveragesummary",
+      "source_layer": "testing",
+      "destination_spec_node_id": "testing.targetcoveragesummary",
+      "destination_layer": "testing",
+      "predicate": "aggregates",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.coveragesummary.aggregates.testing.testcasesketch": {
+      "id": "testing.coveragesummary.aggregates.testing.testcasesketch",
+      "source_spec_node_id": "testing.coveragesummary",
+      "source_layer": "testing",
+      "destination_spec_node_id": "testing.testcasesketch",
+      "destination_layer": "testing",
+      "predicate": "aggregates",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.coveragesummary.aggregates.testing.testcoveragemodel": {
+      "id": "testing.coveragesummary.aggregates.testing.testcoveragemodel",
+      "source_spec_node_id": "testing.coveragesummary",
+      "source_layer": "testing",
+      "destination_spec_node_id": "testing.testcoveragemodel",
+      "destination_layer": "testing",
+      "predicate": "aggregates",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.coveragesummary.depends-on.testing.testcoveragetarget": {
+      "id": "testing.coveragesummary.depends-on.testing.testcoveragetarget",
+      "source_spec_node_id": "testing.coveragesummary",
+      "source_layer": "testing",
+      "destination_spec_node_id": "testing.testcoveragetarget",
+      "destination_layer": "testing",
+      "predicate": "depends-on",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.coveragesummary.fulfills-requirements.motivation.requirement": {
+      "id": "testing.coveragesummary.fulfills-requirements.motivation.requirement",
+      "source_spec_node_id": "testing.coveragesummary",
+      "source_layer": "testing",
+      "destination_spec_node_id": "motivation.requirement",
+      "destination_layer": "motivation",
+      "predicate": "fulfills-requirements",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.coveragesummary.measures-outcome.motivation.outcome": {
+      "id": "testing.coveragesummary.measures-outcome.motivation.outcome",
+      "source_spec_node_id": "testing.coveragesummary",
+      "source_layer": "testing",
+      "destination_spec_node_id": "motivation.outcome",
+      "destination_layer": "motivation",
+      "predicate": "measures-outcome",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.coveragesummary.references.business.businessprocess": {
+      "id": "testing.coveragesummary.references.business.businessprocess",
+      "source_spec_node_id": "testing.coveragesummary",
+      "source_layer": "testing",
+      "destination_spec_node_id": "business.businessprocess",
+      "destination_layer": "business",
+      "predicate": "references",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.coveragesummary.references.testing.coverageexclusion": {
+      "id": "testing.coveragesummary.references.testing.coverageexclusion",
+      "source_spec_node_id": "testing.coveragesummary",
+      "source_layer": "testing",
+      "destination_spec_node_id": "testing.coverageexclusion",
+      "destination_layer": "testing",
+      "predicate": "references",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.coveragesummary.references.testing.coveragegap": {
+      "id": "testing.coveragesummary.references.testing.coveragegap",
+      "source_spec_node_id": "testing.coveragesummary",
+      "source_layer": "testing",
+      "destination_spec_node_id": "testing.coveragegap",
+      "destination_layer": "testing",
+      "predicate": "references",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.coveragesummary.references.testing.testcoveragemodel": {
+      "id": "testing.coveragesummary.references.testing.testcoveragemodel",
+      "source_spec_node_id": "testing.coveragesummary",
+      "source_layer": "testing",
+      "destination_spec_node_id": "testing.testcoveragemodel",
+      "destination_layer": "testing",
+      "predicate": "references",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.coveragesummary.serves.testing.testcoveragemodel": {
+      "id": "testing.coveragesummary.serves.testing.testcoveragemodel",
+      "source_spec_node_id": "testing.coveragesummary",
+      "source_layer": "testing",
+      "destination_spec_node_id": "testing.testcoveragemodel",
+      "destination_layer": "testing",
+      "predicate": "serves",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.coveragesummary.validates.testing.coveragerequirement": {
+      "id": "testing.coveragesummary.validates.testing.coveragerequirement",
+      "source_spec_node_id": "testing.coveragesummary",
+      "source_layer": "testing",
+      "destination_spec_node_id": "testing.coveragerequirement",
+      "destination_layer": "testing",
+      "predicate": "validates",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.environmentfactor.composes.testing.contextvariation": {
+      "id": "testing.environmentfactor.composes.testing.contextvariation",
+      "source_spec_node_id": "testing.environmentfactor",
+      "source_layer": "testing",
+      "destination_spec_node_id": "testing.contextvariation",
+      "destination_layer": "testing",
+      "predicate": "composes",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.environmentfactor.composes.testing.inputspacepartition": {
+      "id": "testing.environmentfactor.composes.testing.inputspacepartition",
+      "source_spec_node_id": "testing.environmentfactor",
+      "source_layer": "testing",
+      "destination_spec_node_id": "testing.inputspacepartition",
+      "destination_layer": "testing",
+      "predicate": "composes",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.environmentfactor.flows-to.testing.coveragesummary": {
+      "id": "testing.environmentfactor.flows-to.testing.coveragesummary",
+      "source_spec_node_id": "testing.environmentfactor",
+      "source_layer": "testing",
+      "destination_spec_node_id": "testing.coveragesummary",
+      "destination_layer": "testing",
+      "predicate": "flows-to",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.environmentfactor.references.apm.instrumentationconfig": {
+      "id": "testing.environmentfactor.references.apm.instrumentationconfig",
+      "source_spec_node_id": "testing.environmentfactor",
+      "source_layer": "testing",
+      "destination_spec_node_id": "apm.instrumentationconfig",
+      "destination_layer": "apm",
+      "predicate": "references",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.environmentfactor.references.technology.node": {
+      "id": "testing.environmentfactor.references.technology.node",
+      "source_spec_node_id": "testing.environmentfactor",
+      "source_layer": "testing",
+      "destination_spec_node_id": "technology.node",
+      "destination_layer": "technology",
+      "predicate": "references",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.environmentfactor.references.testing.partitionvalue": {
+      "id": "testing.environmentfactor.references.testing.partitionvalue",
+      "source_spec_node_id": "testing.environmentfactor",
+      "source_layer": "testing",
+      "destination_spec_node_id": "testing.partitionvalue",
+      "destination_layer": "testing",
+      "predicate": "references",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.environmentfactor.references.security.securitypolicy": {
+      "id": "testing.environmentfactor.references.security.securitypolicy",
+      "source_spec_node_id": "testing.environmentfactor",
+      "source_layer": "testing",
+      "destination_spec_node_id": "security.securitypolicy",
+      "destination_layer": "security",
+      "predicate": "references",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.environmentfactor.references.technology.systemsoftware": {
+      "id": "testing.environmentfactor.references.technology.systemsoftware",
+      "source_spec_node_id": "testing.environmentfactor",
+      "source_layer": "testing",
+      "destination_spec_node_id": "technology.systemsoftware",
+      "destination_layer": "technology",
+      "predicate": "references",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.environmentfactor.serves.testing.coveragerequirement": {
+      "id": "testing.environmentfactor.serves.testing.coveragerequirement",
+      "source_spec_node_id": "testing.environmentfactor",
+      "source_layer": "testing",
+      "destination_spec_node_id": "testing.coveragerequirement",
+      "destination_layer": "testing",
+      "predicate": "serves",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.environmentfactor.serves.testing.testcasesketch": {
+      "id": "testing.environmentfactor.serves.testing.testcasesketch",
+      "source_spec_node_id": "testing.environmentfactor",
+      "source_layer": "testing",
+      "destination_spec_node_id": "testing.testcasesketch",
+      "destination_layer": "testing",
+      "predicate": "serves",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.environmentfactor.serves.testing.testcoveragemodel": {
+      "id": "testing.environmentfactor.serves.testing.testcoveragemodel",
+      "source_spec_node_id": "testing.environmentfactor",
+      "source_layer": "testing",
+      "destination_spec_node_id": "testing.testcoveragemodel",
+      "destination_layer": "testing",
+      "predicate": "serves",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.inputpartitionselection.aggregates.testing.contextvariation": {
+      "id": "testing.inputpartitionselection.aggregates.testing.contextvariation",
+      "source_spec_node_id": "testing.inputpartitionselection",
+      "source_layer": "testing",
+      "destination_spec_node_id": "testing.contextvariation",
+      "destination_layer": "testing",
+      "predicate": "aggregates",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.inputpartitionselection.aggregates.testing.partitionvalue": {
+      "id": "testing.inputpartitionselection.aggregates.testing.partitionvalue",
+      "source_spec_node_id": "testing.inputpartitionselection",
+      "source_layer": "testing",
+      "destination_spec_node_id": "testing.partitionvalue",
+      "destination_layer": "testing",
+      "predicate": "aggregates",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.inputselection.references.testing.coveragerequirement": {
+      "id": "testing.inputselection.references.testing.coveragerequirement",
+      "source_spec_node_id": "testing.inputselection",
+      "source_layer": "testing",
+      "destination_spec_node_id": "testing.coveragerequirement",
+      "destination_layer": "testing",
+      "predicate": "references",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.inputselection.references.testing.partitionvalue": {
+      "id": "testing.inputselection.references.testing.partitionvalue",
+      "source_spec_node_id": "testing.inputselection",
+      "source_layer": "testing",
+      "destination_spec_node_id": "testing.partitionvalue",
+      "destination_layer": "testing",
+      "predicate": "references",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.inputselection.references.testing.testcoveragetarget": {
+      "id": "testing.inputselection.references.testing.testcoveragetarget",
+      "source_spec_node_id": "testing.inputselection",
+      "source_layer": "testing",
+      "destination_spec_node_id": "testing.testcoveragetarget",
+      "destination_layer": "testing",
+      "predicate": "references",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.inputspacepartition.composes.partitionvalue": {
+      "id": "testing.inputspacepartition.composes.partitionvalue",
+      "source_spec_node_id": "testing.inputspacepartition",
+      "source_layer": "testing",
+      "destination_spec_node_id": "testing.partitionvalue",
+      "destination_layer": "testing",
+      "predicate": "composes",
+      "cardinality": "one-to-many",
+      "strength": "high",
+      "required": false
+    },
+    "testing.inputspacepartition.depends-on.inputspacepartition": {
+      "id": "testing.inputspacepartition.depends-on.inputspacepartition",
+      "source_spec_node_id": "testing.inputspacepartition",
+      "source_layer": "testing",
+      "destination_spec_node_id": "testing.inputspacepartition",
+      "destination_layer": "testing",
+      "predicate": "depends-on",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.inputspacepartition.references.data-store.collection": {
+      "id": "testing.inputspacepartition.references.data-store.collection",
+      "source_spec_node_id": "testing.inputspacepartition",
+      "source_layer": "testing",
+      "destination_spec_node_id": "data-store.collection",
+      "destination_layer": "data-store",
+      "predicate": "references",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.inputspacepartition.references.data-model.jsonschema": {
+      "id": "testing.inputspacepartition.references.data-model.jsonschema",
+      "source_spec_node_id": "testing.inputspacepartition",
+      "source_layer": "testing",
+      "destination_spec_node_id": "data-model.jsonschema",
+      "destination_layer": "data-model",
+      "predicate": "references",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.inputspacepartition.references.api.parameter": {
+      "id": "testing.inputspacepartition.references.api.parameter",
+      "source_spec_node_id": "testing.inputspacepartition",
+      "source_layer": "testing",
+      "destination_spec_node_id": "api.parameter",
+      "destination_layer": "api",
+      "predicate": "references",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.inputspacepartition.references.data-model.schemaproperty": {
+      "id": "testing.inputspacepartition.references.data-model.schemaproperty",
+      "source_spec_node_id": "testing.inputspacepartition",
+      "source_layer": "testing",
+      "destination_spec_node_id": "data-model.schemaproperty",
+      "destination_layer": "data-model",
+      "predicate": "references",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.inputspacepartition.serves.testing.testcoveragetarget": {
+      "id": "testing.inputspacepartition.serves.testing.testcoveragetarget",
+      "source_spec_node_id": "testing.inputspacepartition",
+      "source_layer": "testing",
+      "destination_spec_node_id": "testing.testcoveragetarget",
+      "destination_layer": "testing",
+      "predicate": "serves",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.outcomecategory.aggregates.testing.testcasesketch": {
+      "id": "testing.outcomecategory.aggregates.testing.testcasesketch",
+      "source_spec_node_id": "testing.outcomecategory",
+      "source_layer": "testing",
+      "destination_spec_node_id": "testing.testcasesketch",
+      "destination_layer": "testing",
+      "predicate": "aggregates",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.outcomecategory.constrained-by.testing.environmentfactor": {
+      "id": "testing.outcomecategory.constrained-by.testing.environmentfactor",
+      "source_spec_node_id": "testing.outcomecategory",
+      "source_layer": "testing",
+      "destination_spec_node_id": "testing.environmentfactor",
+      "destination_layer": "testing",
+      "predicate": "constrained-by",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.outcomecategory.flows-to.testing.coveragesummary": {
+      "id": "testing.outcomecategory.flows-to.testing.coveragesummary",
+      "source_spec_node_id": "testing.outcomecategory",
+      "source_layer": "testing",
+      "destination_spec_node_id": "testing.coveragesummary",
+      "destination_layer": "testing",
+      "predicate": "flows-to",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.outcomecategory.references.testing.targetinputfield": {
+      "id": "testing.outcomecategory.references.testing.targetinputfield",
+      "source_spec_node_id": "testing.outcomecategory",
+      "source_layer": "testing",
+      "destination_spec_node_id": "testing.targetinputfield",
+      "destination_layer": "testing",
+      "predicate": "references",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.outcomecategory.serves.testing.coveragerequirement": {
+      "id": "testing.outcomecategory.serves.testing.coveragerequirement",
+      "source_spec_node_id": "testing.outcomecategory",
+      "source_layer": "testing",
+      "destination_spec_node_id": "testing.coveragerequirement",
+      "destination_layer": "testing",
+      "predicate": "serves",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.partitiondependency.constrained-by.testing.inputpartitionselection": {
+      "id": "testing.partitiondependency.constrained-by.testing.inputpartitionselection",
+      "source_spec_node_id": "testing.partitiondependency",
+      "source_layer": "testing",
+      "destination_spec_node_id": "testing.inputpartitionselection",
+      "destination_layer": "testing",
+      "predicate": "constrained-by",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.partitiondependency.references.testing.inputspacepartition": {
+      "id": "testing.partitiondependency.references.testing.inputspacepartition",
+      "source_spec_node_id": "testing.partitiondependency",
+      "source_layer": "testing",
+      "destination_spec_node_id": "testing.inputspacepartition",
+      "destination_layer": "testing",
+      "predicate": "references",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.partitiondependency.triggers.testing.coveragerequirement": {
+      "id": "testing.partitiondependency.triggers.testing.coveragerequirement",
+      "source_spec_node_id": "testing.partitiondependency",
+      "source_layer": "testing",
+      "destination_spec_node_id": "testing.coveragerequirement",
+      "destination_layer": "testing",
+      "predicate": "triggers",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.partitiondependency.triggers.testing.partitionvalue": {
+      "id": "testing.partitiondependency.triggers.testing.partitionvalue",
+      "source_spec_node_id": "testing.partitiondependency",
+      "source_layer": "testing",
+      "destination_spec_node_id": "testing.partitionvalue",
+      "destination_layer": "testing",
+      "predicate": "triggers",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.partitionvalue.composes.testing.inputspacepartition": {
+      "id": "testing.partitionvalue.composes.testing.inputspacepartition",
+      "source_spec_node_id": "testing.partitionvalue",
+      "source_layer": "testing",
+      "destination_spec_node_id": "testing.inputspacepartition",
+      "destination_layer": "testing",
+      "predicate": "composes",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.partitionvalue.constrained-by.testing.coveragerequirement": {
+      "id": "testing.partitionvalue.constrained-by.testing.coveragerequirement",
+      "source_spec_node_id": "testing.partitionvalue",
+      "source_layer": "testing",
+      "destination_spec_node_id": "testing.coveragerequirement",
+      "destination_layer": "testing",
+      "predicate": "constrained-by",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.partitionvalue.depends-on.testing.environmentfactor": {
+      "id": "testing.partitionvalue.depends-on.testing.environmentfactor",
+      "source_spec_node_id": "testing.partitionvalue",
+      "source_layer": "testing",
+      "destination_spec_node_id": "testing.environmentfactor",
+      "destination_layer": "testing",
+      "predicate": "depends-on",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.partitionvalue.flows-to.testing.outcomecategory": {
+      "id": "testing.partitionvalue.flows-to.testing.outcomecategory",
+      "source_spec_node_id": "testing.partitionvalue",
+      "source_layer": "testing",
+      "destination_spec_node_id": "testing.outcomecategory",
+      "destination_layer": "testing",
+      "predicate": "flows-to",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.partitionvalue.references.testing.coverageexclusion": {
+      "id": "testing.partitionvalue.references.testing.coverageexclusion",
+      "source_spec_node_id": "testing.partitionvalue",
+      "source_layer": "testing",
+      "destination_spec_node_id": "testing.coverageexclusion",
+      "destination_layer": "testing",
+      "predicate": "references",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.partitionvalue.triggers.testing.coveragegap": {
+      "id": "testing.partitionvalue.triggers.testing.coveragegap",
+      "source_spec_node_id": "testing.partitionvalue",
+      "source_layer": "testing",
+      "destination_spec_node_id": "testing.coveragegap",
+      "destination_layer": "testing",
+      "predicate": "triggers",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.targetcoveragesummary.aggregates.testing.testcasesketch": {
+      "id": "testing.targetcoveragesummary.aggregates.testing.testcasesketch",
+      "source_spec_node_id": "testing.targetcoveragesummary",
+      "source_layer": "testing",
+      "destination_spec_node_id": "testing.testcasesketch",
+      "destination_layer": "testing",
+      "predicate": "aggregates",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.targetcoveragesummary.references.testing.coverageexclusion": {
+      "id": "testing.targetcoveragesummary.references.testing.coverageexclusion",
+      "source_spec_node_id": "testing.targetcoveragesummary",
+      "source_layer": "testing",
+      "destination_spec_node_id": "testing.coverageexclusion",
+      "destination_layer": "testing",
+      "predicate": "references",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.targetcoveragesummary.references.testing.coveragegap": {
+      "id": "testing.targetcoveragesummary.references.testing.coveragegap",
+      "source_spec_node_id": "testing.targetcoveragesummary",
+      "source_layer": "testing",
+      "destination_spec_node_id": "testing.coveragegap",
+      "destination_layer": "testing",
+      "predicate": "references",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.targetcoveragesummary.validates.testing.coveragerequirement": {
+      "id": "testing.targetcoveragesummary.validates.testing.coveragerequirement",
+      "source_spec_node_id": "testing.targetcoveragesummary",
+      "source_layer": "testing",
+      "destination_spec_node_id": "testing.coveragerequirement",
+      "destination_layer": "testing",
+      "predicate": "validates",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.targetcoveragesummary.validates.testing.testcoveragetarget": {
+      "id": "testing.targetcoveragesummary.validates.testing.testcoveragetarget",
+      "source_spec_node_id": "testing.targetcoveragesummary",
+      "source_layer": "testing",
+      "destination_spec_node_id": "testing.testcoveragetarget",
+      "destination_layer": "testing",
+      "predicate": "validates",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.targetinputfield.aggregates.testing.partitionvalue": {
+      "id": "testing.targetinputfield.aggregates.testing.partitionvalue",
+      "source_spec_node_id": "testing.targetinputfield",
+      "source_layer": "testing",
+      "destination_spec_node_id": "testing.partitionvalue",
+      "destination_layer": "testing",
+      "predicate": "aggregates",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.targetinputfield.constrained-by.testing.coveragerequirement": {
+      "id": "testing.targetinputfield.constrained-by.testing.coveragerequirement",
+      "source_spec_node_id": "testing.targetinputfield",
+      "source_layer": "testing",
+      "destination_spec_node_id": "testing.coveragerequirement",
+      "destination_layer": "testing",
+      "predicate": "constrained-by",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.targetinputfield.depends-on.testing.contextvariation": {
+      "id": "testing.targetinputfield.depends-on.testing.contextvariation",
+      "source_spec_node_id": "testing.targetinputfield",
+      "source_layer": "testing",
+      "destination_spec_node_id": "testing.contextvariation",
+      "destination_layer": "testing",
+      "predicate": "depends-on",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.targetinputfield.flows-to.testing.inputpartitionselection": {
+      "id": "testing.targetinputfield.flows-to.testing.inputpartitionselection",
+      "source_spec_node_id": "testing.targetinputfield",
+      "source_layer": "testing",
+      "destination_spec_node_id": "testing.inputpartitionselection",
+      "destination_layer": "testing",
+      "predicate": "flows-to",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.targetinputfield.maps-to.ux.actioncomponent": {
+      "id": "testing.targetinputfield.maps-to.ux.actioncomponent",
+      "source_spec_node_id": "testing.targetinputfield",
+      "source_layer": "testing",
+      "destination_spec_node_id": "ux.actioncomponent",
+      "destination_layer": "ux",
+      "predicate": "maps-to",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.targetinputfield.references.testing.inputspacepartition": {
+      "id": "testing.targetinputfield.references.testing.inputspacepartition",
+      "source_spec_node_id": "testing.targetinputfield",
+      "source_layer": "testing",
+      "destination_spec_node_id": "testing.inputspacepartition",
+      "destination_layer": "testing",
+      "predicate": "references",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.targetinputfield.references.api.parameter": {
+      "id": "testing.targetinputfield.references.api.parameter",
+      "source_spec_node_id": "testing.targetinputfield",
+      "source_layer": "testing",
+      "destination_spec_node_id": "api.parameter",
+      "destination_layer": "api",
+      "predicate": "references",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.targetinputfield.references.data-model.schemaproperty": {
+      "id": "testing.targetinputfield.references.data-model.schemaproperty",
+      "source_spec_node_id": "testing.targetinputfield",
+      "source_layer": "testing",
+      "destination_spec_node_id": "data-model.schemaproperty",
+      "destination_layer": "data-model",
+      "predicate": "references",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.targetinputfield.references.testing.testcoveragetarget": {
+      "id": "testing.targetinputfield.references.testing.testcoveragetarget",
+      "source_spec_node_id": "testing.targetinputfield",
+      "source_layer": "testing",
+      "destination_spec_node_id": "testing.testcoveragetarget",
+      "destination_layer": "testing",
+      "predicate": "references",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.testcasesketch.accesses.data-store.collection": {
+      "id": "testing.testcasesketch.accesses.data-store.collection",
+      "source_spec_node_id": "testing.testcasesketch",
+      "source_layer": "testing",
+      "destination_spec_node_id": "data-store.collection",
+      "destination_layer": "data-store",
+      "predicate": "accesses",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.testcasesketch.accesses.testing.inputpartitionselection": {
+      "id": "testing.testcasesketch.accesses.testing.inputpartitionselection",
+      "source_spec_node_id": "testing.testcasesketch",
+      "source_layer": "testing",
+      "destination_spec_node_id": "testing.inputpartitionselection",
+      "destination_layer": "testing",
+      "predicate": "accesses",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.testcasesketch.accesses.testing.inputselection": {
+      "id": "testing.testcasesketch.accesses.testing.inputselection",
+      "source_spec_node_id": "testing.testcasesketch",
+      "source_layer": "testing",
+      "destination_spec_node_id": "testing.inputselection",
+      "destination_layer": "testing",
+      "predicate": "accesses",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.testcasesketch.accesses.api.requestbody": {
+      "id": "testing.testcasesketch.accesses.api.requestbody",
+      "source_spec_node_id": "testing.testcasesketch",
+      "source_layer": "testing",
+      "destination_spec_node_id": "api.requestbody",
+      "destination_layer": "api",
+      "predicate": "accesses",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.testcasesketch.accesses.data-store.view": {
+      "id": "testing.testcasesketch.accesses.data-store.view",
+      "source_spec_node_id": "testing.testcasesketch",
+      "source_layer": "testing",
+      "destination_spec_node_id": "data-store.view",
+      "destination_layer": "data-store",
+      "predicate": "accesses",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.testcasesketch.composes.testing.inputselection": {
+      "id": "testing.testcasesketch.composes.testing.inputselection",
+      "source_spec_node_id": "testing.testcasesketch",
+      "source_layer": "testing",
+      "destination_spec_node_id": "testing.inputselection",
+      "destination_layer": "testing",
+      "predicate": "composes",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.testcasesketch.constrained-by.motivation.constraint": {
+      "id": "testing.testcasesketch.constrained-by.motivation.constraint",
+      "source_spec_node_id": "testing.testcasesketch",
+      "source_layer": "testing",
+      "destination_spec_node_id": "motivation.constraint",
+      "destination_layer": "motivation",
+      "predicate": "constrained-by",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.testcasesketch.depends-on.testing.contextvariation": {
+      "id": "testing.testcasesketch.depends-on.testing.contextvariation",
+      "source_spec_node_id": "testing.testcasesketch",
+      "source_layer": "testing",
+      "destination_spec_node_id": "testing.contextvariation",
+      "destination_layer": "testing",
+      "predicate": "depends-on",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.testcasesketch.depends-on.testing.inputspacepartition": {
+      "id": "testing.testcasesketch.depends-on.testing.inputspacepartition",
+      "source_spec_node_id": "testing.testcasesketch",
+      "source_layer": "testing",
+      "destination_spec_node_id": "testing.inputspacepartition",
+      "destination_layer": "testing",
+      "predicate": "depends-on",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.testcasesketch.depends-on.testing.outcomecategory": {
+      "id": "testing.testcasesketch.depends-on.testing.outcomecategory",
+      "source_spec_node_id": "testing.testcasesketch",
+      "source_layer": "testing",
+      "destination_spec_node_id": "testing.outcomecategory",
+      "destination_layer": "testing",
+      "predicate": "depends-on",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.testcasesketch.depends-on.testing.testcasesketch": {
+      "id": "testing.testcasesketch.depends-on.testing.testcasesketch",
+      "source_spec_node_id": "testing.testcasesketch",
+      "source_layer": "testing",
+      "destination_spec_node_id": "testing.testcasesketch",
+      "destination_layer": "testing",
+      "predicate": "depends-on",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.testcasesketch.fulfills-requirements.motivation.requirement": {
+      "id": "testing.testcasesketch.fulfills-requirements.motivation.requirement",
+      "source_spec_node_id": "testing.testcasesketch",
+      "source_layer": "testing",
+      "destination_spec_node_id": "motivation.requirement",
+      "destination_layer": "motivation",
+      "predicate": "fulfills-requirements",
+      "cardinality": "many-to-many",
+      "strength": "high",
+      "required": false
+    },
+    "testing.testcasesketch.references.testing.coveragerequirement": {
+      "id": "testing.testcasesketch.references.testing.coveragerequirement",
+      "source_spec_node_id": "testing.testcasesketch",
+      "source_layer": "testing",
+      "destination_spec_node_id": "testing.coveragerequirement",
+      "destination_layer": "testing",
+      "predicate": "references",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.testcasesketch.references.apm.logconfiguration": {
+      "id": "testing.testcasesketch.references.apm.logconfiguration",
+      "source_spec_node_id": "testing.testcasesketch",
+      "source_layer": "testing",
+      "destination_spec_node_id": "apm.logconfiguration",
+      "destination_layer": "apm",
+      "predicate": "references",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.testcasesketch.references.testing.partitionvalue": {
+      "id": "testing.testcasesketch.references.testing.partitionvalue",
+      "source_spec_node_id": "testing.testcasesketch",
+      "source_layer": "testing",
+      "destination_spec_node_id": "testing.partitionvalue",
+      "destination_layer": "testing",
+      "predicate": "references",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.testcasesketch.references.apm.span": {
+      "id": "testing.testcasesketch.references.apm.span",
+      "source_spec_node_id": "testing.testcasesketch",
+      "source_layer": "testing",
+      "destination_spec_node_id": "apm.span",
+      "destination_layer": "apm",
+      "predicate": "references",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.testcasesketch.references.testing.testcoveragetarget": {
+      "id": "testing.testcasesketch.references.testing.testcoveragetarget",
+      "source_spec_node_id": "testing.testcasesketch",
+      "source_layer": "testing",
+      "destination_spec_node_id": "testing.testcoveragetarget",
+      "destination_layer": "testing",
+      "predicate": "references",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.testcasesketch.requires.technology.systemsoftware": {
+      "id": "testing.testcasesketch.requires.technology.systemsoftware",
+      "source_spec_node_id": "testing.testcasesketch",
+      "source_layer": "testing",
+      "destination_spec_node_id": "technology.systemsoftware",
+      "destination_layer": "technology",
+      "predicate": "requires",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.testcasesketch.supports-goals.motivation.goal": {
+      "id": "testing.testcasesketch.supports-goals.motivation.goal",
+      "source_spec_node_id": "testing.testcasesketch",
+      "source_layer": "testing",
+      "destination_spec_node_id": "motivation.goal",
+      "destination_layer": "motivation",
+      "predicate": "supports-goals",
+      "cardinality": "many-to-many",
+      "strength": "high",
+      "required": false
+    },
+    "testing.testcasesketch.tests.ux.actioncomponent": {
+      "id": "testing.testcasesketch.tests.ux.actioncomponent",
+      "source_spec_node_id": "testing.testcasesketch",
+      "source_layer": "testing",
+      "destination_spec_node_id": "ux.actioncomponent",
+      "destination_layer": "ux",
+      "predicate": "tests",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.testcasesketch.tests.application.applicationfunction": {
+      "id": "testing.testcasesketch.tests.application.applicationfunction",
+      "source_spec_node_id": "testing.testcasesketch",
+      "source_layer": "testing",
+      "destination_spec_node_id": "application.applicationfunction",
+      "destination_layer": "application",
+      "predicate": "tests",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.testcasesketch.tests.application.applicationinterface": {
+      "id": "testing.testcasesketch.tests.application.applicationinterface",
+      "source_spec_node_id": "testing.testcasesketch",
+      "source_layer": "testing",
+      "destination_spec_node_id": "application.applicationinterface",
+      "destination_layer": "application",
+      "predicate": "tests",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.testcasesketch.tests.application.applicationservice": {
+      "id": "testing.testcasesketch.tests.application.applicationservice",
+      "source_spec_node_id": "testing.testcasesketch",
+      "source_layer": "testing",
+      "destination_spec_node_id": "application.applicationservice",
+      "destination_layer": "application",
+      "predicate": "tests",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.testcasesketch.tests.business.businessprocess": {
+      "id": "testing.testcasesketch.tests.business.businessprocess",
+      "source_spec_node_id": "testing.testcasesketch",
+      "source_layer": "testing",
+      "destination_spec_node_id": "business.businessprocess",
+      "destination_layer": "business",
+      "predicate": "tests",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.testcasesketch.tests.business.businessservice": {
+      "id": "testing.testcasesketch.tests.business.businessservice",
+      "source_spec_node_id": "testing.testcasesketch",
+      "source_layer": "testing",
+      "destination_spec_node_id": "business.businessservice",
+      "destination_layer": "business",
+      "predicate": "tests",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.testcasesketch.tests.security.countermeasure": {
+      "id": "testing.testcasesketch.tests.security.countermeasure",
+      "source_spec_node_id": "testing.testcasesketch",
+      "source_layer": "testing",
+      "destination_spec_node_id": "security.countermeasure",
+      "destination_layer": "security",
+      "predicate": "tests",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.testcasesketch.tests.testing.coveragerequirement": {
+      "id": "testing.testcasesketch.tests.testing.coveragerequirement",
+      "source_spec_node_id": "testing.testcasesketch",
+      "source_layer": "testing",
+      "destination_spec_node_id": "testing.coveragerequirement",
+      "destination_layer": "testing",
+      "predicate": "tests",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.testcasesketch.tests.ux.librarycomponent": {
+      "id": "testing.testcasesketch.tests.ux.librarycomponent",
+      "source_spec_node_id": "testing.testcasesketch",
+      "source_layer": "testing",
+      "destination_spec_node_id": "ux.librarycomponent",
+      "destination_layer": "ux",
+      "predicate": "tests",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.testcasesketch.tests.apm.metricinstrument": {
+      "id": "testing.testcasesketch.tests.apm.metricinstrument",
+      "source_spec_node_id": "testing.testcasesketch",
+      "source_layer": "testing",
+      "destination_spec_node_id": "apm.metricinstrument",
+      "destination_layer": "apm",
+      "predicate": "tests",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.testcasesketch.tests.navigation.navigationflow": {
+      "id": "testing.testcasesketch.tests.navigation.navigationflow",
+      "source_spec_node_id": "testing.testcasesketch",
+      "source_layer": "testing",
+      "destination_spec_node_id": "navigation.navigationflow",
+      "destination_layer": "navigation",
+      "predicate": "tests",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.testcasesketch.tests.navigation.navigationguard": {
+      "id": "testing.testcasesketch.tests.navigation.navigationguard",
+      "source_spec_node_id": "testing.testcasesketch",
+      "source_layer": "testing",
+      "destination_spec_node_id": "navigation.navigationguard",
+      "destination_layer": "navigation",
+      "predicate": "tests",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.testcasesketch.tests.api.operation": {
+      "id": "testing.testcasesketch.tests.api.operation",
+      "source_spec_node_id": "testing.testcasesketch",
+      "source_layer": "testing",
+      "destination_spec_node_id": "api.operation",
+      "destination_layer": "api",
+      "predicate": "tests",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.testcasesketch.tests.navigation.route": {
+      "id": "testing.testcasesketch.tests.navigation.route",
+      "source_spec_node_id": "testing.testcasesketch",
+      "source_layer": "testing",
+      "destination_spec_node_id": "navigation.route",
+      "destination_layer": "navigation",
+      "predicate": "tests",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.testcasesketch.tests.data-model.schemadefinition": {
+      "id": "testing.testcasesketch.tests.data-model.schemadefinition",
+      "source_spec_node_id": "testing.testcasesketch",
+      "source_layer": "testing",
+      "destination_spec_node_id": "data-model.schemadefinition",
+      "destination_layer": "data-model",
+      "predicate": "tests",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.testcasesketch.tests.security.threat": {
+      "id": "testing.testcasesketch.tests.security.threat",
+      "source_spec_node_id": "testing.testcasesketch",
+      "source_layer": "testing",
+      "destination_spec_node_id": "security.threat",
+      "destination_layer": "security",
+      "predicate": "tests",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.testcasesketch.tests.data-store.validationrule": {
+      "id": "testing.testcasesketch.tests.data-store.validationrule",
+      "source_spec_node_id": "testing.testcasesketch",
+      "source_layer": "testing",
+      "destination_spec_node_id": "data-store.validationrule",
+      "destination_layer": "data-store",
+      "predicate": "tests",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.testcasesketch.tests.ux.view": {
+      "id": "testing.testcasesketch.tests.ux.view",
+      "source_spec_node_id": "testing.testcasesketch",
+      "source_layer": "testing",
+      "destination_spec_node_id": "ux.view",
+      "destination_layer": "ux",
+      "predicate": "tests",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.testcasesketch.validates.testing.coveragerequirement": {
+      "id": "testing.testcasesketch.validates.testing.coveragerequirement",
+      "source_spec_node_id": "testing.testcasesketch",
+      "source_layer": "testing",
+      "destination_spec_node_id": "testing.coveragerequirement",
+      "destination_layer": "testing",
+      "predicate": "validates",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.testcasesketch.validates.api.response": {
+      "id": "testing.testcasesketch.validates.api.response",
+      "source_spec_node_id": "testing.testcasesketch",
+      "source_layer": "testing",
+      "destination_spec_node_id": "api.response",
+      "destination_layer": "api",
+      "predicate": "validates",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.testcasesketch.validates.security.securitypolicy": {
+      "id": "testing.testcasesketch.validates.security.securitypolicy",
+      "source_spec_node_id": "testing.testcasesketch",
+      "source_layer": "testing",
+      "destination_spec_node_id": "security.securitypolicy",
+      "destination_layer": "security",
+      "predicate": "validates",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.testcasesketch.validates.testing.testcoveragetarget": {
+      "id": "testing.testcasesketch.validates.testing.testcoveragetarget",
+      "source_spec_node_id": "testing.testcasesketch",
+      "source_layer": "testing",
+      "destination_spec_node_id": "testing.testcoveragetarget",
+      "destination_layer": "testing",
+      "predicate": "validates",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.testcoveragemodel.aggregates.contextvariation": {
+      "id": "testing.testcoveragemodel.aggregates.contextvariation",
+      "source_spec_node_id": "testing.testcoveragemodel",
+      "source_layer": "testing",
+      "destination_spec_node_id": "testing.contextvariation",
+      "destination_layer": "testing",
+      "predicate": "aggregates",
+      "cardinality": "one-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.testcoveragemodel.aggregates.inputspacepartition": {
+      "id": "testing.testcoveragemodel.aggregates.inputspacepartition",
+      "source_spec_node_id": "testing.testcoveragemodel",
+      "source_layer": "testing",
+      "destination_spec_node_id": "testing.inputspacepartition",
+      "destination_layer": "testing",
+      "predicate": "aggregates",
+      "cardinality": "one-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.testcoveragemodel.aggregates.testcasesketch": {
+      "id": "testing.testcoveragemodel.aggregates.testcasesketch",
+      "source_spec_node_id": "testing.testcoveragemodel",
+      "source_layer": "testing",
+      "destination_spec_node_id": "testing.testcasesketch",
+      "destination_layer": "testing",
+      "predicate": "aggregates",
+      "cardinality": "one-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.testcoveragemodel.aggregates.testing.testcoveragetarget": {
+      "id": "testing.testcoveragemodel.aggregates.testing.testcoveragetarget",
+      "source_spec_node_id": "testing.testcoveragemodel",
+      "source_layer": "testing",
+      "destination_spec_node_id": "testing.testcoveragetarget",
+      "destination_layer": "testing",
+      "predicate": "aggregates",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.testcoveragemodel.composes.testing.coverageexclusion": {
+      "id": "testing.testcoveragemodel.composes.testing.coverageexclusion",
+      "source_spec_node_id": "testing.testcoveragemodel",
+      "source_layer": "testing",
+      "destination_spec_node_id": "testing.coverageexclusion",
+      "destination_layer": "testing",
+      "predicate": "composes",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.testcoveragemodel.composes.testing.coveragerequirement": {
+      "id": "testing.testcoveragemodel.composes.testing.coveragerequirement",
+      "source_spec_node_id": "testing.testcoveragemodel",
+      "source_layer": "testing",
+      "destination_spec_node_id": "testing.coveragerequirement",
+      "destination_layer": "testing",
+      "predicate": "composes",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.testcoveragemodel.composes.testing.coveragesummary": {
+      "id": "testing.testcoveragemodel.composes.testing.coveragesummary",
+      "source_spec_node_id": "testing.testcoveragemodel",
+      "source_layer": "testing",
+      "destination_spec_node_id": "testing.coveragesummary",
+      "destination_layer": "testing",
+      "predicate": "composes",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.testcoveragemodel.composes.testing.inputpartitionselection": {
+      "id": "testing.testcoveragemodel.composes.testing.inputpartitionselection",
+      "source_spec_node_id": "testing.testcoveragemodel",
+      "source_layer": "testing",
+      "destination_spec_node_id": "testing.inputpartitionselection",
+      "destination_layer": "testing",
+      "predicate": "composes",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.testcoveragemodel.composes.testing.outcomecategory": {
+      "id": "testing.testcoveragemodel.composes.testing.outcomecategory",
+      "source_spec_node_id": "testing.testcoveragemodel",
+      "source_layer": "testing",
+      "destination_spec_node_id": "testing.outcomecategory",
+      "destination_layer": "testing",
+      "predicate": "composes",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.testcoveragemodel.composes.testing.testcoveragetarget": {
+      "id": "testing.testcoveragemodel.composes.testing.testcoveragetarget",
+      "source_spec_node_id": "testing.testcoveragemodel",
+      "source_layer": "testing",
+      "destination_spec_node_id": "testing.testcoveragetarget",
+      "destination_layer": "testing",
+      "predicate": "composes",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.testcoveragemodel.constrained-by.motivation.constraint": {
+      "id": "testing.testcoveragemodel.constrained-by.motivation.constraint",
+      "source_spec_node_id": "testing.testcoveragemodel",
+      "source_layer": "testing",
+      "destination_spec_node_id": "motivation.constraint",
+      "destination_layer": "motivation",
+      "predicate": "constrained-by",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.testcoveragemodel.covers.application.applicationcomponent": {
+      "id": "testing.testcoveragemodel.covers.application.applicationcomponent",
+      "source_spec_node_id": "testing.testcoveragemodel",
+      "source_layer": "testing",
+      "destination_spec_node_id": "application.applicationcomponent",
+      "destination_layer": "application",
+      "predicate": "covers",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.testcoveragemodel.covers.application.applicationservice": {
+      "id": "testing.testcoveragemodel.covers.application.applicationservice",
+      "source_spec_node_id": "testing.testcoveragemodel",
+      "source_layer": "testing",
+      "destination_spec_node_id": "application.applicationservice",
+      "destination_layer": "application",
+      "predicate": "covers",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.testcoveragemodel.covers.business.businessfunction": {
+      "id": "testing.testcoveragemodel.covers.business.businessfunction",
+      "source_spec_node_id": "testing.testcoveragemodel",
+      "source_layer": "testing",
+      "destination_spec_node_id": "business.businessfunction",
+      "destination_layer": "business",
+      "predicate": "covers",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.testcoveragemodel.covers.business.businessprocess": {
+      "id": "testing.testcoveragemodel.covers.business.businessprocess",
+      "source_spec_node_id": "testing.testcoveragemodel",
+      "source_layer": "testing",
+      "destination_spec_node_id": "business.businessprocess",
+      "destination_layer": "business",
+      "predicate": "covers",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.testcoveragemodel.covers.business.businessservice": {
+      "id": "testing.testcoveragemodel.covers.business.businessservice",
+      "source_spec_node_id": "testing.testcoveragemodel",
+      "source_layer": "testing",
+      "destination_spec_node_id": "business.businessservice",
+      "destination_layer": "business",
+      "predicate": "covers",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.testcoveragemodel.covers.data-model.objectschema": {
+      "id": "testing.testcoveragemodel.covers.data-model.objectschema",
+      "source_spec_node_id": "testing.testcoveragemodel",
+      "source_layer": "testing",
+      "destination_spec_node_id": "data-model.objectschema",
+      "destination_layer": "data-model",
+      "predicate": "covers",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.testcoveragemodel.covers.api.openapidocument": {
+      "id": "testing.testcoveragemodel.covers.api.openapidocument",
+      "source_spec_node_id": "testing.testcoveragemodel",
+      "source_layer": "testing",
+      "destination_spec_node_id": "api.openapidocument",
+      "destination_layer": "api",
+      "predicate": "covers",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.testcoveragemodel.covers.navigation.route": {
+      "id": "testing.testcoveragemodel.covers.navigation.route",
+      "source_spec_node_id": "testing.testcoveragemodel",
+      "source_layer": "testing",
+      "destination_spec_node_id": "navigation.route",
+      "destination_layer": "navigation",
+      "predicate": "covers",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.testcoveragemodel.covers.security.securitypolicy": {
+      "id": "testing.testcoveragemodel.covers.security.securitypolicy",
+      "source_spec_node_id": "testing.testcoveragemodel",
+      "source_layer": "testing",
+      "destination_spec_node_id": "security.securitypolicy",
+      "destination_layer": "security",
+      "predicate": "covers",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.testcoveragemodel.covers.ux.uxapplication": {
+      "id": "testing.testcoveragemodel.covers.ux.uxapplication",
+      "source_spec_node_id": "testing.testcoveragemodel",
+      "source_layer": "testing",
+      "destination_spec_node_id": "ux.uxapplication",
+      "destination_layer": "ux",
+      "predicate": "covers",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.testcoveragemodel.fulfills-requirements.motivation.requirement": {
+      "id": "testing.testcoveragemodel.fulfills-requirements.motivation.requirement",
+      "source_spec_node_id": "testing.testcoveragemodel",
+      "source_layer": "testing",
+      "destination_spec_node_id": "motivation.requirement",
+      "destination_layer": "motivation",
+      "predicate": "fulfills-requirements",
+      "cardinality": "many-to-many",
+      "strength": "high",
+      "required": false
+    },
+    "testing.testcoveragemodel.governed-by-principles.motivation.principle": {
+      "id": "testing.testcoveragemodel.governed-by-principles.motivation.principle",
+      "source_spec_node_id": "testing.testcoveragemodel",
+      "source_layer": "testing",
+      "destination_spec_node_id": "motivation.principle",
+      "destination_layer": "motivation",
+      "predicate": "governed-by-principles",
+      "cardinality": "many-to-many",
+      "strength": "high",
+      "required": false
+    },
+    "testing.testcoveragemodel.measures-outcome.motivation.outcome": {
+      "id": "testing.testcoveragemodel.measures-outcome.motivation.outcome",
+      "source_spec_node_id": "testing.testcoveragemodel",
+      "source_layer": "testing",
+      "destination_spec_node_id": "motivation.outcome",
+      "destination_layer": "motivation",
+      "predicate": "measures-outcome",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.testcoveragemodel.references.data-store.database": {
+      "id": "testing.testcoveragemodel.references.data-store.database",
+      "source_spec_node_id": "testing.testcoveragemodel",
+      "source_layer": "testing",
+      "destination_spec_node_id": "data-store.database",
+      "destination_layer": "data-store",
+      "predicate": "references",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.testcoveragemodel.references.motivation.driver": {
+      "id": "testing.testcoveragemodel.references.motivation.driver",
+      "source_spec_node_id": "testing.testcoveragemodel",
+      "source_layer": "testing",
+      "destination_spec_node_id": "motivation.driver",
+      "destination_layer": "motivation",
+      "predicate": "references",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.testcoveragemodel.references.apm.instrumentationscope": {
+      "id": "testing.testcoveragemodel.references.apm.instrumentationscope",
+      "source_spec_node_id": "testing.testcoveragemodel",
+      "source_layer": "testing",
+      "destination_spec_node_id": "apm.instrumentationscope",
+      "destination_layer": "apm",
+      "predicate": "references",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.testcoveragemodel.references.security.threat": {
+      "id": "testing.testcoveragemodel.references.security.threat",
+      "source_spec_node_id": "testing.testcoveragemodel",
+      "source_layer": "testing",
+      "destination_spec_node_id": "security.threat",
+      "destination_layer": "security",
+      "predicate": "references",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.testcoveragemodel.references.apm.traceconfiguration": {
+      "id": "testing.testcoveragemodel.references.apm.traceconfiguration",
+      "source_spec_node_id": "testing.testcoveragemodel",
+      "source_layer": "testing",
+      "destination_spec_node_id": "apm.traceconfiguration",
+      "destination_layer": "apm",
+      "predicate": "references",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.testcoveragemodel.supports-goals.motivation.goal": {
+      "id": "testing.testcoveragemodel.supports-goals.motivation.goal",
+      "source_spec_node_id": "testing.testcoveragemodel",
+      "source_layer": "testing",
+      "destination_spec_node_id": "motivation.goal",
+      "destination_layer": "motivation",
+      "predicate": "supports-goals",
+      "cardinality": "many-to-many",
+      "strength": "high",
+      "required": false
+    },
+    "testing.testcoveragemodel.tests.technology.systemsoftware": {
+      "id": "testing.testcoveragemodel.tests.technology.systemsoftware",
+      "source_spec_node_id": "testing.testcoveragemodel",
+      "source_layer": "testing",
+      "destination_spec_node_id": "technology.systemsoftware",
+      "destination_layer": "technology",
+      "predicate": "tests",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.testcoveragemodel.tests.technology.technologyservice": {
+      "id": "testing.testcoveragemodel.tests.technology.technologyservice",
+      "source_spec_node_id": "testing.testcoveragemodel",
+      "source_layer": "testing",
+      "destination_spec_node_id": "technology.technologyservice",
+      "destination_layer": "technology",
+      "predicate": "tests",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.testcoveragetarget.aggregates.contextvariation": {
+      "id": "testing.testcoveragetarget.aggregates.contextvariation",
+      "source_spec_node_id": "testing.testcoveragetarget",
+      "source_layer": "testing",
+      "destination_spec_node_id": "testing.contextvariation",
+      "destination_layer": "testing",
+      "predicate": "aggregates",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.testcoveragetarget.composes.testing.coveragerequirement": {
+      "id": "testing.testcoveragetarget.composes.testing.coveragerequirement",
+      "source_spec_node_id": "testing.testcoveragetarget",
+      "source_layer": "testing",
+      "destination_spec_node_id": "testing.coveragerequirement",
+      "destination_layer": "testing",
+      "predicate": "composes",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.testcoveragetarget.composes.testing.inputpartitionselection": {
+      "id": "testing.testcoveragetarget.composes.testing.inputpartitionselection",
+      "source_spec_node_id": "testing.testcoveragetarget",
+      "source_layer": "testing",
+      "destination_spec_node_id": "testing.inputpartitionselection",
+      "destination_layer": "testing",
+      "predicate": "composes",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.testcoveragetarget.composes.testing.outcomecategory": {
+      "id": "testing.testcoveragetarget.composes.testing.outcomecategory",
+      "source_spec_node_id": "testing.testcoveragetarget",
+      "source_layer": "testing",
+      "destination_spec_node_id": "testing.outcomecategory",
+      "destination_layer": "testing",
+      "predicate": "composes",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.testcoveragetarget.composes.testing.targetinputfield": {
+      "id": "testing.testcoveragetarget.composes.testing.targetinputfield",
+      "source_spec_node_id": "testing.testcoveragetarget",
+      "source_layer": "testing",
+      "destination_spec_node_id": "testing.targetinputfield",
+      "destination_layer": "testing",
+      "predicate": "composes",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.testcoveragetarget.composes.testing.testcoveragetarget": {
+      "id": "testing.testcoveragetarget.composes.testing.testcoveragetarget",
+      "source_spec_node_id": "testing.testcoveragetarget",
+      "source_layer": "testing",
+      "destination_spec_node_id": "testing.testcoveragetarget",
+      "destination_layer": "testing",
+      "predicate": "composes",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.testcoveragetarget.covers.application.applicationservice": {
+      "id": "testing.testcoveragetarget.covers.application.applicationservice",
+      "source_spec_node_id": "testing.testcoveragetarget",
+      "source_layer": "testing",
+      "destination_spec_node_id": "application.applicationservice",
+      "destination_layer": "application",
+      "predicate": "covers",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.testcoveragetarget.covers.data-model.objectschema": {
+      "id": "testing.testcoveragetarget.covers.data-model.objectschema",
+      "source_spec_node_id": "testing.testcoveragetarget",
+      "source_layer": "testing",
+      "destination_spec_node_id": "data-model.objectschema",
+      "destination_layer": "data-model",
+      "predicate": "covers",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.testcoveragetarget.covers.ux.subview": {
+      "id": "testing.testcoveragetarget.covers.ux.subview",
+      "source_spec_node_id": "testing.testcoveragetarget",
+      "source_layer": "testing",
+      "destination_spec_node_id": "ux.subview",
+      "destination_layer": "ux",
+      "predicate": "covers",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.testcoveragetarget.covers.ux.view": {
+      "id": "testing.testcoveragetarget.covers.ux.view",
+      "source_spec_node_id": "testing.testcoveragetarget",
+      "source_layer": "testing",
+      "destination_spec_node_id": "ux.view",
+      "destination_layer": "ux",
+      "predicate": "covers",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.testcoveragetarget.flows-to.testing.coveragerequirement": {
+      "id": "testing.testcoveragetarget.flows-to.testing.coveragerequirement",
+      "source_spec_node_id": "testing.testcoveragetarget",
+      "source_layer": "testing",
+      "destination_spec_node_id": "testing.coveragerequirement",
+      "destination_layer": "testing",
+      "predicate": "flows-to",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.testcoveragetarget.flows-to.testing.testcasesketch": {
+      "id": "testing.testcoveragetarget.flows-to.testing.testcasesketch",
+      "source_spec_node_id": "testing.testcoveragetarget",
+      "source_layer": "testing",
+      "destination_spec_node_id": "testing.testcasesketch",
+      "destination_layer": "testing",
+      "predicate": "flows-to",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.testcoveragetarget.fulfills-requirements.motivation.requirement": {
+      "id": "testing.testcoveragetarget.fulfills-requirements.motivation.requirement",
+      "source_spec_node_id": "testing.testcoveragetarget",
+      "source_layer": "testing",
+      "destination_spec_node_id": "motivation.requirement",
+      "destination_layer": "motivation",
+      "predicate": "fulfills-requirements",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.testcoveragetarget.references.business.businessprocess": {
+      "id": "testing.testcoveragetarget.references.business.businessprocess",
+      "source_spec_node_id": "testing.testcoveragetarget",
+      "source_layer": "testing",
+      "destination_spec_node_id": "business.businessprocess",
+      "destination_layer": "business",
+      "predicate": "references",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.testcoveragetarget.references.apm.metricinstrument": {
+      "id": "testing.testcoveragetarget.references.apm.metricinstrument",
+      "source_spec_node_id": "testing.testcoveragetarget",
+      "source_layer": "testing",
+      "destination_spec_node_id": "apm.metricinstrument",
+      "destination_layer": "apm",
+      "predicate": "references",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.testcoveragetarget.references.technology.node": {
+      "id": "testing.testcoveragetarget.references.technology.node",
+      "source_spec_node_id": "testing.testcoveragetarget",
+      "source_layer": "testing",
+      "destination_spec_node_id": "technology.node",
+      "destination_layer": "technology",
+      "predicate": "references",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.testcoveragetarget.references.navigation.route": {
+      "id": "testing.testcoveragetarget.references.navigation.route",
+      "source_spec_node_id": "testing.testcoveragetarget",
+      "source_layer": "testing",
+      "destination_spec_node_id": "navigation.route",
+      "destination_layer": "navigation",
+      "predicate": "references",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.testcoveragetarget.references.security.secureresource": {
+      "id": "testing.testcoveragetarget.references.security.secureresource",
+      "source_spec_node_id": "testing.testcoveragetarget",
+      "source_layer": "testing",
+      "destination_spec_node_id": "security.secureresource",
+      "destination_layer": "security",
+      "predicate": "references",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.testcoveragetarget.references.technology.systemsoftware": {
+      "id": "testing.testcoveragetarget.references.technology.systemsoftware",
+      "source_spec_node_id": "testing.testcoveragetarget",
+      "source_layer": "testing",
+      "destination_spec_node_id": "technology.systemsoftware",
+      "destination_layer": "technology",
+      "predicate": "references",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.testcoveragetarget.references.technology.technologyservice": {
+      "id": "testing.testcoveragetarget.references.technology.technologyservice",
+      "source_spec_node_id": "testing.testcoveragetarget",
+      "source_layer": "testing",
+      "destination_spec_node_id": "technology.technologyservice",
+      "destination_layer": "technology",
+      "predicate": "references",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.testcoveragetarget.supports-goals.motivation.goal": {
+      "id": "testing.testcoveragetarget.supports-goals.motivation.goal",
+      "source_spec_node_id": "testing.testcoveragetarget",
+      "source_layer": "testing",
+      "destination_spec_node_id": "motivation.goal",
+      "destination_layer": "motivation",
+      "predicate": "supports-goals",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.testcoveragetarget.tests.application.applicationcomponent": {
+      "id": "testing.testcoveragetarget.tests.application.applicationcomponent",
+      "source_spec_node_id": "testing.testcoveragetarget",
+      "source_layer": "testing",
+      "destination_spec_node_id": "application.applicationcomponent",
+      "destination_layer": "application",
+      "predicate": "tests",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.testcoveragetarget.tests.data-store.collection": {
+      "id": "testing.testcoveragetarget.tests.data-store.collection",
+      "source_spec_node_id": "testing.testcoveragetarget",
+      "source_layer": "testing",
+      "destination_spec_node_id": "data-store.collection",
+      "destination_layer": "data-store",
+      "predicate": "tests",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.testcoveragetarget.tests.api.operation": {
+      "id": "testing.testcoveragetarget.tests.api.operation",
+      "source_spec_node_id": "testing.testcoveragetarget",
+      "source_layer": "testing",
+      "destination_spec_node_id": "api.operation",
+      "destination_layer": "api",
+      "predicate": "tests",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.testcoveragetarget.tests.data-store.storedlogic": {
+      "id": "testing.testcoveragetarget.tests.data-store.storedlogic",
+      "source_spec_node_id": "testing.testcoveragetarget",
+      "source_layer": "testing",
+      "destination_spec_node_id": "data-store.storedlogic",
+      "destination_layer": "data-store",
+      "predicate": "tests",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    },
+    "testing.testcoveragetarget.tests.data-store.view": {
+      "id": "testing.testcoveragetarget.tests.data-store.view",
+      "source_spec_node_id": "testing.testcoveragetarget",
+      "source_layer": "testing",
+      "destination_spec_node_id": "data-store.view",
+      "destination_layer": "data-store",
+      "predicate": "tests",
+      "cardinality": "many-to-many",
+      "strength": "medium",
+      "required": false
+    }
+  }
+}