ddduck 0.1.0

package/docs/model.md

@@ -0,0 +1,75 @@
+# Product model
+
+ddduck models a product from canonical YAML. A product root contains one `product.yaml`,
+its model nodes, decision records, and derived views. The root can live wherever the repository
+chooses; `docs/ddd/` works well when the model is part of the repository's documentation, while
+`ddd/` remains a compact default for a dedicated product root.
+
+```text
+docs/ddd/
+  product.yaml
+  model/
+    domains/
+    concepts/
+    relationships/
+    use-cases/
+    interfaces/
+    guarantees/
+  decisions/
+  generated/
+    docs/model-overview.md
+    graph/model-graph.json
+    graph/model-graph.ndjson
+```
+
+`product.yaml` and `model/**/*.yaml` are canonical. `generated/` is derived output and
+must be regenerated through `ddduck generate` rather than edited directly.
+`.ddduck/config.json` may point commands at the selected root, but `.ddduck/` is tool metadata,
+not product source.
+
+## Nodes
+
+Every canonical node declares a `schemaVersion`, `kind`, and `id`. The product root is the
+one `Model` node; it does **not** declare `model`. Its `domains`, `useCases`,
+`relationships`, and `decisions` list the owned top-level records. Every child node declares
+`model` with that Model ID; domain-owned children also declare `ownerDomain`.
+
+| Kind              | Purpose                                                               |
+| ----------------- | --------------------------------------------------------------------- |
+| `Domain`          | Owns concepts, interfaces, and guarantees.                            |
+| `Concept`         | Names a domain-owned product idea.                                    |
+| `Relationship`    | Records an explicit connection between canonical nodes.               |
+| `UseCase`         | States a goal, its guarantee preconditions, outcomes, and interfaces. |
+| `DomainInterface` | Declares a command or query boundary and its guarantees.              |
+| `Guarantee`       | States an invariant or acceptance criterion with lifecycle state.     |
+
+Guarantee IDs are stable. An active Guarantee can be moved, split into existing active
+successors, or retired only when an ADR authorizes that lifecycle transition. Use cases and
+interfaces cannot retain references to non-effective Guarantees.
+
+```mermaid
+flowchart LR
+  Active -->|move; preserve ID and prior owner| Active
+  Active -->|split; active successors and ADR-NNN| Split
+  Active -->|retire; ADR-NNN| Retired
+  Reference[Active UseCase and DomainInterface references] -. block .-> Split
+  Reference -. block .-> Retired
+```
+
+## Decisions and evidence
+
+Decision records live in `decisions/` and use the `ADR-NNN-*.md` filename convention.
+Nodes may cite decisions. Interfaces may also declare evidence anchors with a product-relative
+path, anchor name, and role (`source`, `decision`, or `verification`). The checker rejects an
+anchor that escapes the selected product root or does not resolve to a regular file.
+
+## Derived views and validation
+
+`ddduck generate --root <product-root>` creates the model overview and graph views. `ddduck
+check --root <product-root>` validates schemas, node ownership, references, decisions,
+Guarantee lifecycle, evidence anchors, global policies, and documentation references. With
+`--base <previous-product-root>`, it also verifies that historical Guarantee IDs were not
+silently removed.
+
+Use [the model reference](model-reference.md) for fields and minimal YAML, and
+[the CLI reference](cli.md) for exact commands and JSON query contracts.

package/package.json

@@ -0,0 +1,76 @@
+{
+  "name": "ddduck",
+  "version": "0.1.0",
+  "description": "An opinionated DDD framework for authoring, validating, and visualizing machine-readable product-spec models.",
+  "keywords": [
+    "ddd",
+    "domain-driven-design",
+    "product-spec",
+    "model",
+    "traceability",
+    "yaml",
+    "json-schema",
+    "cli"
+  ],
+  "license": "MIT",
+  "author": "diegomarino <760919+diegomarino@users.noreply.github.com> (https://github.com/diegomarino)",
+  "homepage": "https://github.com/diegomarino/ddduck#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/diegomarino/ddduck.git"
+  },
+  "bugs": {
+    "url": "https://github.com/diegomarino/ddduck/issues"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "type": "module",
+  "files": [
+    "scripts/",
+    "schemas/",
+    "policies/",
+    "skills/",
+    "docs/architecture.md",
+    "docs/getting-started.md",
+    "docs/model.md",
+    "docs/model-reference.md",
+    "docs/cli.md"
+  ],
+  "bin": {
+    "ddduck": "scripts/ddduck.mjs"
+  },
+  "scripts": {
+    "check": "npm run check:model && npm run check:docs && npm run check:graph && npm run check:graph:svg && npm run lint && npm run lint:md && npm run format:check && npm test",
+    "check:docs": "node scripts/check-generated-docs.mjs",
+    "check:graph": "node scripts/check-generated-graph.mjs",
+    "check:graph:svg": "node scripts/check-generated-graph-svg.mjs",
+    "check:model": "node scripts/check-model.mjs --root docs/ddd --docs-root docs/ddd --docs-root .",
+    "format:check": "prettier --check .",
+    "generate:docs": "node scripts/generate-docs.mjs",
+    "generate:graph": "node scripts/generate-graph.mjs",
+    "generate:graph:svg": "node scripts/generate-graph-svg.mjs",
+    "lint": "eslint .",
+    "lint:md": "markdownlint-cli2 \"*.md\" \"docs/**/*.md\" \"examples/**/*.md\"",
+    "test": "node --test test/*.test.mjs",
+    "test:coverage": "node --test --experimental-test-coverage test/*.test.mjs",
+    "pack:dry-run": "npm pack --dry-run --cache .npm-cache",
+    "release:check": "npm run check && npm run pack:dry-run",
+    "prepublishOnly": "npm run release:check"
+  },
+  "dependencies": {
+    "@hpcc-js/wasm": "^2.35.0",
+    "ajv": "^8.20.0",
+    "remark-parse": "^11.0.0",
+    "unified": "^11.0.5",
+    "yaml": "^2.8.0"
+  },
+  "devDependencies": {
+    "eslint": "^10.8.0",
+    "markdownlint-cli2": "^0.23.2",
+    "prettier": "^3.9.6"
+  },
+  "overrides": {
+    "fast-uri": "^3.1.5"
+  }
+}

package/policies/concept-owner-domain.yaml

@@ -0,0 +1,8 @@
+schemaVersion: "1"
+kind: PolicySpec
+id: policy:concept-owner-domain
+name: Concept Owner Domain
+condition: Each domain-owned product fact resolves to exactly one owner domain.
+implementation:
+  checker: check-model
+  check: concept-owner-domain

package/policies/documentation-model-reference-resolution.yaml

@@ -0,0 +1,8 @@
+schemaVersion: "1"
+kind: PolicySpec
+id: policy:documentation-model-reference-resolution
+name: Documentation Model Reference Resolution
+condition: Structural documentation references resolve in the canonical model.
+implementation:
+  checker: check-model
+  check: documentation-model-reference-resolution

package/policies/no-dangling-model-reference.yaml

@@ -0,0 +1,8 @@
+schemaVersion: "1"
+kind: PolicySpec
+id: policy:no-dangling-model-reference
+name: No Dangling Model Reference
+condition: Every declared product reference resolves.
+implementation:
+  checker: check-model
+  check: no-dangling-model-reference

package/policies/policy-spec.schema.json

@@ -0,0 +1,23 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://ddduck.local/policies/policy-spec.schema.json",
+  "type": "object",
+  "additionalProperties": false,
+  "required": ["schemaVersion", "kind", "id", "name", "condition", "implementation"],
+  "properties": {
+    "schemaVersion": { "const": "1" },
+    "kind": { "const": "PolicySpec" },
+    "id": { "type": "string", "pattern": "^policy:[a-z0-9][a-z0-9-]*$" },
+    "name": { "type": "string", "minLength": 1 },
+    "condition": { "type": "string", "minLength": 1 },
+    "implementation": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["checker", "check"],
+      "properties": {
+        "checker": { "const": "check-model" },
+        "check": { "type": "string", "minLength": 1 }
+      }
+    }
+  }
+}

package/schemas/context-pack.schema.json

@@ -0,0 +1,83 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://ddduck.local/schemas/context-pack.schema.json",
+  "type": "object",
+  "additionalProperties": false,
+  "required": ["schemaVersion", "query", "rootModelId", "snapshot", "result", "diagnostics"],
+  "properties": {
+    "schemaVersion": { "const": "1" },
+    "query": { "$ref": "#/$defs/query" },
+    "rootModelId": { "type": "string", "minLength": 1 },
+    "snapshot": { "$ref": "#/$defs/snapshot" },
+    "result": { "$ref": "#/$defs/result" },
+    "diagnostics": { "type": "array" }
+  },
+  "$defs": {
+    "query": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["operation", "ids", "history"],
+      "properties": {
+        "operation": { "const": "context" },
+        "ids": {
+          "type": "array",
+          "minItems": 1,
+          "uniqueItems": true,
+          "items": { "type": "string", "minLength": 1 }
+        },
+        "history": { "const": false }
+      }
+    },
+    "snapshot": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["algorithm", "sourceDigest"],
+      "properties": {
+        "algorithm": { "const": "sha256" },
+        "sourceDigest": { "type": "string", "pattern": "^[a-f0-9]{64}$" }
+      }
+    },
+    "result": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["selected", "edges", "neighbors"],
+      "properties": {
+        "selected": { "type": "array", "items": { "$ref": "#/$defs/selectedNode" } },
+        "edges": { "type": "array", "items": { "$ref": "#/$defs/edge" } },
+        "neighbors": { "type": "array", "items": { "$ref": "#/$defs/neighbor" } }
+      }
+    },
+    "selectedNode": {
+      "type": "object",
+      "required": ["id", "kind", "sourcePath"],
+      "properties": {
+        "id": { "type": "string", "minLength": 1 },
+        "kind": { "type": "string", "minLength": 1 },
+        "sourcePath": { "type": "string", "minLength": 1 }
+      },
+      "additionalProperties": true
+    },
+    "edge": {
+      "type": "object",
+      "required": ["id", "from", "to", "kind"],
+      "properties": {
+        "id": { "type": "string", "minLength": 1 },
+        "from": { "type": "string", "minLength": 1 },
+        "to": { "type": "string", "minLength": 1 },
+        "kind": { "type": "string", "minLength": 1 }
+      },
+      "additionalProperties": true
+    },
+    "neighbor": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["id", "kind", "name", "sourcePath"],
+      "properties": {
+        "id": { "type": "string", "minLength": 1 },
+        "kind": { "type": "string", "minLength": 1 },
+        "name": { "type": ["string", "null"] },
+        "sourcePath": { "type": "string", "minLength": 1 }
+      }
+    }
+  }
+}

package/schemas/fr-to-code-audit.schema.json

@@ -0,0 +1,85 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://ddduck.local/schemas/fr-to-code-audit.schema.json",
+  "description": "This standard JSON Schema validates record structure. verifyFrToCodeAudit is the normative semantic validator for within-record constraints, including unique source IDs and anchor endLine >= startLine.",
+  "type": "object",
+  "additionalProperties": false,
+  "required": [
+    "schemaVersion",
+    "kind",
+    "id",
+    "sources",
+    "requirement",
+    "coverage",
+    "verdict",
+    "productionAnchors",
+    "testAnchors",
+    "reviewerDisposition"
+  ],
+  "properties": {
+    "schemaVersion": { "const": "1" },
+    "kind": { "const": "FrToCodeAudit" },
+    "id": { "$ref": "#/$defs/nonEmptyString" },
+    "sources": {
+      "type": "array",
+      "minItems": 1,
+      "items": { "$ref": "#/$defs/source" }
+    },
+    "requirement": { "$ref": "#/$defs/requirement" },
+    "coverage": { "$ref": "#/$defs/coverage" },
+    "verdict": { "enum": ["realized-and-tested", "realized-untested", "unrealized"] },
+    "productionAnchors": { "type": "array", "items": { "$ref": "#/$defs/anchor" } },
+    "testAnchors": { "type": "array", "items": { "$ref": "#/$defs/anchor" } },
+    "reviewerDisposition": { "enum": ["accepted", "rejected"] }
+  },
+  "$defs": {
+    "nonEmptyString": { "type": "string", "minLength": 1 },
+    "source": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["id", "repository", "revision"],
+      "properties": {
+        "id": { "$ref": "#/$defs/nonEmptyString" },
+        "repository": { "$ref": "#/$defs/nonEmptyString" },
+        "revision": { "type": "string", "pattern": "^[0-9a-f]{40}$" }
+      }
+    },
+    "requirement": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["sourceId", "sourcePath", "id", "qualifier"],
+      "properties": {
+        "sourceId": { "$ref": "#/$defs/nonEmptyString" },
+        "sourcePath": { "$ref": "#/$defs/nonEmptyString" },
+        "id": { "$ref": "#/$defs/nonEmptyString" },
+        "qualifier": { "$ref": "#/$defs/nonEmptyString" },
+        "tracedGuarantee": { "$ref": "#/$defs/nonEmptyString" }
+      }
+    },
+    "coverage": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["includes", "excludes"],
+      "properties": {
+        "includes": { "$ref": "#/$defs/nonEmptyStrings" },
+        "excludes": { "$ref": "#/$defs/nonEmptyStrings" }
+      }
+    },
+    "nonEmptyStrings": {
+      "type": "array",
+      "minItems": 1,
+      "items": { "$ref": "#/$defs/nonEmptyString" }
+    },
+    "anchor": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["sourceId", "path", "startLine", "endLine"],
+      "properties": {
+        "sourceId": { "$ref": "#/$defs/nonEmptyString" },
+        "path": { "$ref": "#/$defs/nonEmptyString" },
+        "startLine": { "type": "integer", "minimum": 1 },
+        "endLine": { "type": "integer", "minimum": 1 }
+      }
+    }
+  }
+}

package/schemas/product/concept.schema.json

@@ -0,0 +1,17 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://ddduck.local/schemas/product/concept.schema.json",
+  "type": "object",
+  "additionalProperties": false,
+  "required": ["schemaVersion", "kind", "id", "model", "ownerDomain", "name", "purpose"],
+  "properties": {
+    "schemaVersion": { "const": "1" },
+    "kind": { "const": "Concept" },
+    "id": { "type": "string", "pattern": "^concept:[a-z0-9][a-z0-9-]*$" },
+    "model": { "type": "string", "pattern": "^model:" },
+    "ownerDomain": { "type": "string", "pattern": "^domain:" },
+    "name": { "type": "string", "minLength": 1 },
+    "purpose": { "type": "string", "minLength": 1 },
+    "decisions": { "type": "array", "items": { "type": "string", "pattern": "^ADR-[0-9]{3}$" }, "uniqueItems": true }
+  }
+}

package/schemas/product/domain-interface.schema.json

@@ -0,0 +1,18 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://ddduck.local/schemas/product/domain-interface.schema.json",
+  "type": "object",
+  "additionalProperties": false,
+  "required": ["schemaVersion", "kind", "id", "model", "ownerDomain", "name", "operationKind"],
+  "properties": {
+    "schemaVersion": { "const": "1" },
+    "kind": { "const": "DomainInterface" },
+    "id": { "type": "string", "pattern": "^interface:[a-z0-9][a-z0-9-]*$" },
+    "model": { "type": "string", "pattern": "^model:" },
+    "ownerDomain": { "type": "string", "pattern": "^domain:" },
+    "name": { "type": "string", "minLength": 1 },
+    "operationKind": { "enum": ["query", "command"] },
+    "guarantees": { "$ref": "evidence-anchor.schema.json#/$defs/guaranteeReferenceArray" },
+    "evidence": { "$ref": "evidence-anchor.schema.json#/$defs/evidenceAnchors" }
+  }
+}

package/schemas/product/domain.schema.json

@@ -0,0 +1,24 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://ddduck.local/schemas/product/domain.schema.json",
+  "type": "object",
+  "additionalProperties": false,
+  "required": ["schemaVersion", "kind", "id", "model", "name", "purpose"],
+  "properties": {
+    "schemaVersion": { "const": "1" },
+    "kind": { "const": "Domain" },
+    "id": { "type": "string", "pattern": "^domain:[a-z0-9][a-z0-9-]*$" },
+    "model": { "type": "string", "pattern": "^model:" },
+    "name": { "type": "string", "minLength": 1 },
+    "purpose": { "type": "string", "minLength": 1 },
+    "concepts": { "type": "array", "items": { "type": "string", "pattern": "^concept:" }, "uniqueItems": true },
+    "excludedConcepts": { "type": "array", "items": { "type": "string", "pattern": "^concept:" }, "uniqueItems": true },
+    "interfaces": { "type": "array", "items": { "type": "string", "pattern": "^interface:" }, "uniqueItems": true },
+    "guarantees": {
+      "type": "array",
+      "items": { "type": "string", "pattern": "^(?:[A-Z][A-Z0-9-]+-(?:INV|AC)-[0-9]+)$" },
+      "uniqueItems": true
+    },
+    "decisions": { "type": "array", "items": { "type": "string", "pattern": "^ADR-[0-9]{3}$" }, "uniqueItems": true }
+  }
+}

package/schemas/product/evidence-anchor.schema.json

@@ -0,0 +1,30 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://ddduck.local/schemas/product/evidence-anchor.schema.json",
+  "$defs": {
+    "guaranteeReferenceArray": {
+      "type": "array",
+      "items": { "type": "string", "pattern": "^[A-Z][A-Z0-9-]+-(?:INV|AC)-[0-9]+$" },
+      "uniqueItems": true
+    },
+    "guaranteeReferences": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["requires"],
+      "properties": { "requires": { "$ref": "#/$defs/guaranteeReferenceArray" } }
+    },
+    "evidenceAnchors": {
+      "type": "array",
+      "items": {
+        "type": "object",
+        "additionalProperties": false,
+        "required": ["path", "anchor", "role"],
+        "properties": {
+          "path": { "type": "string", "minLength": 1 },
+          "anchor": { "type": "string", "minLength": 1 },
+          "role": { "enum": ["source", "decision", "verification"] }
+        }
+      }
+    }
+  }
+}

package/schemas/product/guarantee.schema.json

@@ -0,0 +1,35 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://ddduck.local/schemas/product/guarantee.schema.json",
+  "type": "object",
+  "additionalProperties": false,
+  "required": ["schemaVersion", "kind", "id", "model", "ownerDomain", "classification", "statement", "status"],
+  "properties": {
+    "schemaVersion": { "const": "1" },
+    "kind": { "const": "Guarantee" },
+    "id": { "type": "string", "pattern": "^[A-Z][A-Z0-9-]+-(?:INV|AC)-[0-9]+$" },
+    "model": { "type": "string", "pattern": "^model:" },
+    "ownerDomain": { "type": "string", "pattern": "^domain:" },
+    "classification": { "enum": ["invariant", "acceptance-criterion"] },
+    "statement": { "type": "string", "minLength": 1 },
+    "status": { "enum": ["active", "split", "retired"] },
+    "lifecycleDecision": { "type": "string", "pattern": "^ADR-[0-9]{3}$" },
+    "successors": { "$ref": "evidence-anchor.schema.json#/$defs/guaranteeReferenceArray" },
+    "ownershipHistory": {
+      "type": "array",
+      "items": { "type": "string", "pattern": "^domain:" },
+      "uniqueItems": true
+    },
+    "evidence": { "$ref": "evidence-anchor.schema.json#/$defs/evidenceAnchors" }
+  },
+  "allOf": [
+    {
+      "if": { "properties": { "status": { "const": "active" } } },
+      "then": { "not": { "required": ["lifecycleDecision"] } }
+    },
+    {
+      "if": { "properties": { "status": { "enum": ["split", "retired"] } } },
+      "then": { "required": ["lifecycleDecision"] }
+    }
+  ]
+}

package/schemas/product/model.schema.json

@@ -0,0 +1,20 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://ddduck.local/schemas/product/model.schema.json",
+  "type": "object",
+  "additionalProperties": false,
+  "required": ["schemaVersion", "kind", "id", "name", "purpose", "domains"],
+  "properties": {
+    "schemaVersion": { "const": "1" },
+    "kind": { "const": "Model" },
+    "id": { "type": "string", "pattern": "^model:[a-z0-9][a-z0-9-]*$" },
+    "name": { "type": "string", "minLength": 1 },
+    "nameStatus": { "type": "string", "minLength": 1 },
+    "purpose": { "type": "string", "minLength": 1 },
+    "domains": { "type": "array", "items": { "type": "string", "pattern": "^domain:" }, "uniqueItems": true },
+    "useCases": { "type": "array", "items": { "type": "string", "pattern": "^use-case:" }, "uniqueItems": true },
+    "relationships": { "type": "array", "items": { "type": "string", "pattern": "^rel:" }, "uniqueItems": true },
+    "decisions": { "type": "array", "items": { "type": "string", "pattern": "^ADR-[0-9]{3}$" }, "uniqueItems": true },
+    "notes": { "type": "array", "items": { "type": "string" } }
+  }
+}

package/schemas/product/relationship.schema.json

@@ -0,0 +1,21 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://ddduck.local/schemas/product/relationship.schema.json",
+  "type": "object",
+  "additionalProperties": false,
+  "required": ["schemaVersion", "kind", "id", "model", "from", "to", "relationshipType", "mode", "ownedBy"],
+  "properties": {
+    "schemaVersion": { "const": "1" },
+    "kind": { "const": "Relationship" },
+    "id": { "type": "string", "pattern": "^rel:[a-z0-9][a-z0-9-]*$" },
+    "model": { "type": "string", "pattern": "^model:" },
+    "from": { "type": "string", "minLength": 1 },
+    "to": { "type": "string", "minLength": 1 },
+    "relationshipType": { "type": "string", "minLength": 1 },
+    "mode": { "type": "string", "minLength": 1 },
+    "ownedBy": { "type": "string", "pattern": "^domain:" },
+    "description": { "type": "string" },
+    "constraints": { "type": "array", "items": { "type": "string" } },
+    "decisions": { "type": "array", "items": { "type": "string", "pattern": "^ADR-[0-9]{3}$" }, "uniqueItems": true }
+  }
+}

package/schemas/product/use-case.schema.json

@@ -0,0 +1,27 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://ddduck.local/schemas/product/use-case.schema.json",
+  "type": "object",
+  "additionalProperties": false,
+  "required": ["schemaVersion", "kind", "id", "model", "name", "goal", "preconditions", "success"],
+  "properties": {
+    "schemaVersion": { "const": "1" },
+    "kind": { "const": "UseCase" },
+    "id": { "type": "string", "pattern": "^use-case:[a-z0-9][a-z0-9-]*$" },
+    "model": { "type": "string", "pattern": "^model:" },
+    "name": { "type": "string", "minLength": 1 },
+    "goal": { "type": "string", "minLength": 1 },
+    "preconditions": { "$ref": "evidence-anchor.schema.json#/$defs/guaranteeReferences" },
+    "success": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["preserves", "establishes"],
+      "properties": {
+        "preserves": { "$ref": "evidence-anchor.schema.json#/$defs/guaranteeReferenceArray" },
+        "establishes": { "$ref": "evidence-anchor.schema.json#/$defs/guaranteeReferenceArray" }
+      }
+    },
+    "interfaces": { "type": "array", "items": { "type": "string", "pattern": "^interface:" }, "uniqueItems": true },
+    "evidence": { "$ref": "evidence-anchor.schema.json#/$defs/evidenceAnchors" }
+  }
+}