{
  "$defs": {
    "addresses": {
      "$comment": "Field order is the declared order; python scripts/build_from_ground.py --format writes it.",
      "additionalProperties": false,
      "description": "What the surface projects and how it is addressed: every projection, the fragments, the doors, the frame, and the addresses the site once answered to.",
      "properties": {
        "doors": {
          "$ref": "#/$defs/door_vocabulary",
          "description": "Every door of the site."
        },
        "fragments": {
          "$ref": "#/$defs/fragment_vocabulary",
          "description": "The fragment each structured-data entity carries on its page, and the two a composition lives in."
        },
        "frame": {
          "$ref": "#/$defs/frame_vocabulary",
          "description": "The names the built frame itself answers and nothing in the model declares."
        },
        "groups": {
          "$ref": "#/$defs/door_groups",
          "description": "The groups the doors fall into."
        },
        "projections": {
          "$ref": "#/$defs/projection_vocabulary",
          "description": "Everything the surface projects: page types as templates drawn by their routes, files served to machines."
        },
        "redirect_statuses": {
          "$ref": "#/$defs/redirect_status_vocabulary",
          "description": "What a former address may say now."
        },
        "retired": {
          "description": "Addresses the site itself once answered to and no row ever did, each redirected or gone like a row's.",
          "items": {
            "$ref": "#/$defs/redirect"
          },
          "minItems": 1,
          "type": "array",
          "uniqueItems": true
        }
      },
      "required": [
        "fragments",
        "frame",
        "projections",
        "redirect_statuses",
        "groups",
        "doors"
      ],
      "type": "object"
    },
    "answer_value": {
      "$comment": "Field order is the declared order; python scripts/build_from_ground.py --format writes it.",
      "additionalProperties": false,
      "description": "One way a bound pattern draws itself, the condition that selects it, and what draws it. The condition is two inclusive ranges, over the count of roles and the count of bindings. Written once here, and read by the schema and the surface.",
      "properties": {
        "about": {
          "description": "What this way of drawing shows.",
          "minLength": 1,
          "type": "string"
        },
        "bindings": {
          "$ref": "#/$defs/bound",
          "description": "How many bindings this way of drawing takes."
        },
        "drawn_by": {
          "description": "The files under site/src that draw it, each naming this value.",
          "items": {
            "minLength": 1,
            "type": "string"
          },
          "minItems": 1,
          "type": "array"
        },
        "roles": {
          "$ref": "#/$defs/bound",
          "description": "How many roles this way of drawing takes."
        }
      },
      "required": [
        "about",
        "roles",
        "bindings",
        "drawn_by"
      ],
      "type": "object"
    },
    "answer_vocabulary": {
      "$comment": "Field order is the declared order; python scripts/build_from_ground.py --format writes it.",
      "additionalProperties": false,
      "description": "The ways a binding draws itself, and what holds them.",
      "properties": {
        "about": {
          "description": "What this vocabulary governs.",
          "minLength": 1,
          "type": "string"
        },
        "enforced_by": {
          "description": "The gate that holds this vocabulary: a check, a ring or an eval the law catalogs.",
          "minLength": 1,
          "pattern": "^(FND-\\d{3}|ring:\\d|eval:[a-z-]+)$",
          "type": "string"
        },
        "values": {
          "additionalProperties": {
            "$ref": "#/$defs/answer_value"
          },
          "description": "Each way of drawing, by name.",
          "type": "object"
        }
      },
      "required": [
        "about",
        "enforced_by",
        "values"
      ],
      "type": "object"
    },
    "arrangement_value": {
      "$comment": "Field order is the declared order; python scripts/build_from_ground.py --format writes it.",
      "additionalProperties": false,
      "description": "One way the map arranges the model: what it draws, how the control names it, and the files that draw it.",
      "properties": {
        "about": {
          "description": "What this arrangement draws.",
          "minLength": 1,
          "type": "string"
        },
        "default": {
          "description": "Whether a reader who has chosen nothing sees this arrangement; exactly one is the default.",
          "type": "boolean"
        },
        "drawn_by": {
          "description": "The files that draw it, as paths from the repository root, each naming this arrangement.",
          "items": {
            "minLength": 1,
            "type": "string"
          },
          "minItems": 1,
          "type": "array",
          "uniqueItems": true
        },
        "mark": {
          "description": "What the control that chooses this arrangement says.",
          "minLength": 1,
          "type": "string"
        }
      },
      "required": [
        "about",
        "mark",
        "drawn_by"
      ],
      "type": "object"
    },
    "arrangement_vocabulary": {
      "$comment": "Field order is the declared order; python scripts/build_from_ground.py --format writes it.",
      "additionalProperties": false,
      "description": "The ways the map arranges the model, and what holds them.",
      "properties": {
        "about": {
          "description": "What this vocabulary governs.",
          "minLength": 1,
          "type": "string"
        },
        "enforced_by": {
          "description": "The gate that holds this vocabulary: a check, a ring or an eval the law catalogs.",
          "minLength": 1,
          "pattern": "^(FND-\\d{3}|ring:\\d|eval:[a-z-]+)$",
          "type": "string"
        },
        "key": {
          "description": "The key the reader’s choice is kept under in the browser.",
          "minLength": 1,
          "type": "string"
        },
        "values": {
          "additionalProperties": {
            "$ref": "#/$defs/arrangement_value"
          },
          "description": "Each arrangement, by name.",
          "type": "object"
        }
      },
      "required": [
        "about",
        "enforced_by",
        "key",
        "values"
      ],
      "type": "object"
    },
    "board_declaration": {
      "$comment": "Field order is the declared order; python scripts/build_from_ground.py --format writes it.",
      "additionalProperties": false,
      "description": "The board the compose door makes of the kinds arrangement, and the files that draw it.",
      "properties": {
        "about": {
          "description": "What the board does.",
          "minLength": 1,
          "type": "string"
        },
        "drawn_by": {
          "description": "The files that draw it, each naming the board.",
          "items": {
            "minLength": 1,
            "type": "string"
          },
          "minItems": 1,
          "type": "array",
          "uniqueItems": true
        },
        "enforced_by": {
          "description": "The gate that holds it.",
          "minLength": 1,
          "pattern": "^(FND-\\d{3}|ring:\\d|eval:[a-z-]+)$",
          "type": "string"
        }
      },
      "required": [
        "about",
        "enforced_by",
        "drawn_by"
      ],
      "type": "object"
    },
    "bound": {
      "$comment": "Field order is the declared order; python scripts/build_from_ground.py --format writes it.",
      "additionalProperties": false,
      "description": "An inclusive range of counts. `to` absent is unbounded.",
      "properties": {
        "from": {
          "description": "Least, inclusive.",
          "type": "integer"
        },
        "to": {
          "description": "Greatest, inclusive; absent is unbounded.",
          "type": "integer"
        }
      },
      "required": [
        "from"
      ],
      "type": "object"
    },
    "bridge": {
      "$comment": "Field order is the declared order; python scripts/build_from_ground.py --format writes it.",
      "additionalProperties": false,
      "description": "One crossing between two bands that rests on a single road, and why that road is load-bearing.",
      "properties": {
        "relationship": {
          "description": "The road that joins the two bands, as its identifier.",
          "minLength": 1,
          "type": "string"
        },
        "why": {
          "description": "What is lost if the road goes.",
          "minLength": 1,
          "type": "string"
        }
      },
      "required": [
        "relationship",
        "why"
      ],
      "type": "object"
    },
    "caching_value": {
      "$comment": "Field order is the declared order; python scripts/build_from_ground.py --format writes it.",
      "additionalProperties": false,
      "description": "One caching rule: the form of path it selects, and how long a browser may keep what was served.",
      "properties": {
        "about": {
          "description": "Why this rule.",
          "minLength": 1,
          "type": "string"
        },
        "cache_control": {
          "description": "The Cache-Control the host answers with.",
          "minLength": 1,
          "type": "string"
        },
        "prefix": {
          "description": "Selects a path that begins with this.",
          "minLength": 1,
          "type": "string"
        },
        "suffix": {
          "description": "Selects a path that ends with this.",
          "minLength": 1,
          "type": "string"
        }
      },
      "required": [
        "about",
        "cache_control"
      ],
      "type": "object"
    },
    "caching_vocabulary": {
      "$comment": "Field order is the declared order; python scripts/build_from_ground.py --format writes it.",
      "additionalProperties": false,
      "description": "How long a browser may keep what the host served, and what holds it.",
      "properties": {
        "about": {
          "description": "What this vocabulary governs.",
          "minLength": 1,
          "type": "string"
        },
        "enforced_by": {
          "description": "The gate that holds this vocabulary: a check, a ring or an eval the law catalogs.",
          "minLength": 1,
          "pattern": "^(FND-\\d{3}|ring:\\d|eval:[a-z-]+)$",
          "type": "string"
        },
        "values": {
          "additionalProperties": {
            "$ref": "#/$defs/caching_value"
          },
          "description": "Each rule, by name.",
          "type": "object"
        }
      },
      "required": [
        "about",
        "enforced_by",
        "values"
      ],
      "type": "object"
    },
    "campaign_pattern": {
      "$comment": "Field order is the declared order; python scripts/build_from_ground.py --format writes it.",
      "additionalProperties": false,
      "description": "What the campaign pattern requires and forbids: kinds, specifications, the closed set of purposes.",
      "properties": {
        "forbidden_kinds": {
          "description": "Kinds the pattern must not reintroduce.",
          "items": {
            "minLength": 1,
            "type": "string"
          },
          "type": "array"
        },
        "purposes": {
          "description": "The closed set of campaign purposes.",
          "items": {
            "minLength": 1,
            "type": "string"
          },
          "type": "array"
        },
        "required_kinds": {
          "description": "Kinds the pattern needs.",
          "items": {
            "minLength": 1,
            "type": "string"
          },
          "type": "array"
        },
        "within": {
          "description": "The containments of the hierarchy, each held by FND-038.",
          "items": {
            "$ref": "#/$defs/containment"
          },
          "type": "array"
        }
      },
      "required": [
        "required_kinds",
        "forbidden_kinds",
        "purposes",
        "within"
      ],
      "type": "object"
    },
    "cited_source": {
      "$comment": "Field order is the declared order; python scripts/build_from_ground.py --format writes it.",
      "additionalProperties": false,
      "description": "A cited work, as a commitment names it: the work and its page, and nothing its own entry carries a second time.",
      "properties": {
        "id": {
          "description": "SRC and a name.",
          "minLength": 1,
          "type": "string"
        },
        "label": {
          "description": "Its title.",
          "minLength": 1,
          "type": "string"
        },
        "path": {
          "description": "The source's page.",
          "minLength": 1,
          "pattern": "^/([a-z0-9.-]+/)*([a-z0-9.-]+)?(#[a-z0-9-]+)?$",
          "type": "string"
        }
      },
      "required": [
        "id",
        "label",
        "path"
      ],
      "type": "object"
    },
    "claim_value": {
      "$comment": "Field order is the declared order; python scripts/build_from_ground.py --format writes it.",
      "additionalProperties": false,
      "description": "One claim a relationship may make, and the register it is drawn in.",
      "properties": {
        "about": {
          "description": "What kind of assertion this claim makes.",
          "minLength": 1,
          "type": "string"
        },
        "register": {
          "description": "How strongly it is read, and so how the surface draws it.",
          "enum": [
            "world",
            "gov",
            "owed"
          ],
          "minLength": 1,
          "type": "string"
        }
      },
      "required": [
        "about",
        "register"
      ],
      "type": "object"
    },
    "claim_vocabulary": {
      "$comment": "Field order is the declared order; python scripts/build_from_ground.py --format writes it.",
      "additionalProperties": false,
      "description": "The claims a relationship may make, and what holds them.",
      "properties": {
        "about": {
          "description": "What this vocabulary governs.",
          "minLength": 1,
          "type": "string"
        },
        "enforced_by": {
          "description": "The gate that holds this vocabulary: a check, a ring or an eval the law catalogs.",
          "minLength": 1,
          "pattern": "^(FND-\\d{3}|ring:\\d|eval:[a-z-]+)$",
          "type": "string"
        },
        "values": {
          "additionalProperties": {
            "$ref": "#/$defs/claim_value"
          },
          "description": "Each claim, by name.",
          "type": "object"
        }
      },
      "required": [
        "about",
        "enforced_by",
        "values"
      ],
      "type": "object"
    },
    "containment": {
      "$comment": "Field order is the declared order; python scripts/build_from_ground.py --format writes it.",
      "additionalProperties": false,
      "description": "One containment of the accountable hierarchy: the road a child declares, the road its parent declares, the road that makes one the child of the other, and whether the child narrows what the parent declares or keeps what it honours.",
      "properties": {
        "along": {
          "description": "The specification from the parent to the child.",
          "minLength": 1,
          "type": "string"
        },
        "child": {
          "description": "The child's specification.",
          "minLength": 1,
          "type": "string"
        },
        "parent": {
          "description": "The parent's specification, on the same terms.",
          "minLength": 1,
          "type": "string"
        },
        "rule": {
          "description": "narrows: the child declares nothing the parent does not; keeps: the child declares everything the parent does.",
          "minLength": 1,
          "type": "string"
        },
        "why": {
          "description": "The reason, in one line.",
          "minLength": 1,
          "type": "string"
        }
      },
      "required": [
        "child",
        "parent",
        "along",
        "rule",
        "why"
      ],
      "type": "object"
    },
    "contract_status": {
      "$comment": "Field order is the declared order; python scripts/build_from_ground.py --format writes it.",
      "additionalProperties": false,
      "description": "Which kinds may declare a contract status, the closed set of statuses, and what holds them.",
      "properties": {
        "about": {
          "description": "What this vocabulary governs.",
          "minLength": 1,
          "type": "string"
        },
        "enforced_by": {
          "description": "The gate that holds this vocabulary: a check, a ring or an eval the law catalogs.",
          "minLength": 1,
          "pattern": "^(FND-\\d{3}|ring:\\d|eval:[a-z-]+)$",
          "type": "string"
        },
        "kinds": {
          "description": "Kinds whose rows may carry it.",
          "items": {
            "minLength": 1,
            "type": "string"
          },
          "type": "array"
        },
        "values": {
          "description": "The closed set.",
          "items": {
            "minLength": 1,
            "type": "string"
          },
          "type": "array"
        }
      },
      "required": [
        "about",
        "enforced_by",
        "kinds",
        "values"
      ],
      "type": "object"
    },
    "door": {
      "$comment": "Field order is the declared order; python scripts/build_from_ground.py --format writes it.",
      "additionalProperties": false,
      "description": "One door of the site: the name it opens, what a reader is told it is, and which group it belongs to. The address is not written here, because the name already is it.",
      "properties": {
        "at": {
          "description": "The top-level name this door opens; the door declares it, and nothing lists it a second time.",
          "minLength": 1,
          "type": "string"
        },
        "group": {
          "description": "The group it belongs to.",
          "enum": [
            "make",
            "reads",
            "take",
            "frame",
            "holds"
          ],
          "minLength": 1,
          "type": "string"
        },
        "label": {
          "description": "What the door is called in a header, a crumb and a link.",
          "minLength": 1,
          "type": "string"
        },
        "label_from": {
          "description": "Where the label comes from instead, when it is the manifest's to say.",
          "minLength": 1,
          "type": "string"
        },
        "name": {
          "description": "The longer name the page uses for itself, where that differs from the label.",
          "minLength": 1,
          "type": "string"
        },
        "opens": {
          "additionalProperties": {
            "minLength": 1,
            "type": "string"
          },
          "description": "The registry this door opens and what of it it shows: for a registry the law splits, a value of the split; for one it does not, `*`. Every value of each split is opened by exactly one door.",
          "type": "object"
        }
      },
      "required": [
        "at",
        "group"
      ],
      "type": "object"
    },
    "door_groups": {
      "$comment": "Field order is the declared order; python scripts/build_from_ground.py --format writes it.",
      "additionalProperties": false,
      "description": "The groups the doors fall into, and what holds them.",
      "properties": {
        "about": {
          "description": "What this vocabulary governs.",
          "minLength": 1,
          "type": "string"
        },
        "enforced_by": {
          "description": "The gate that holds this vocabulary: a check, a ring or an eval the law catalogs.",
          "minLength": 1,
          "pattern": "^(FND-\\d{3}|ring:\\d|eval:[a-z-]+)$",
          "type": "string"
        },
        "values": {
          "additionalProperties": {
            "$ref": "#/$defs/group_value"
          },
          "description": "Each group, and what falls into it.",
          "type": "object"
        }
      },
      "required": [
        "about",
        "enforced_by",
        "values"
      ],
      "type": "object"
    },
    "door_vocabulary": {
      "$comment": "Field order is the declared order; python scripts/build_from_ground.py --format writes it.",
      "additionalProperties": false,
      "description": "Every door of the site, and what holds them.",
      "properties": {
        "about": {
          "description": "What this vocabulary governs.",
          "minLength": 1,
          "type": "string"
        },
        "enforced_by": {
          "description": "The gate that holds this vocabulary: a check, a ring or an eval the law catalogs.",
          "minLength": 1,
          "pattern": "^(FND-\\d{3}|ring:\\d|eval:[a-z-]+)$",
          "type": "string"
        },
        "values": {
          "additionalProperties": {
            "$ref": "#/$defs/door"
          },
          "description": "Each door, by the name the surface knows it by.",
          "type": "object"
        }
      },
      "required": [
        "about",
        "enforced_by",
        "values"
      ],
      "type": "object"
    },
    "edge": {
      "$comment": "Field order is the declared order; python scripts/build_from_ground.py --format writes it.",
      "additionalProperties": false,
      "description": "An assertion.",
      "properties": {
        "source": {
          "description": "The source row.",
          "minLength": 1,
          "type": "string"
        },
        "spec": {
          "description": "The relationship, as Kind·verb.",
          "minLength": 1,
          "type": "string"
        },
        "target": {
          "description": "The target row.",
          "minLength": 1,
          "type": "string"
        }
      },
      "required": [
        "spec",
        "source",
        "target"
      ],
      "type": "object"
    },
    "edge_spec": {
      "$comment": "Field order is the declared order; python scripts/build_from_ground.py --format writes it.",
      "additionalProperties": false,
      "description": "A relationship specification as the site reads it.",
      "properties": {
        "acyclic": {
          "description": "Whether it is walked for cycles.",
          "type": "boolean"
        },
        "cardinality": {
          "description": "The bound.",
          "minLength": 1,
          "pattern": "^\\d+\\.\\.(\\d+|\\*)$",
          "type": "string"
        },
        "cardinality_rule": {
          "anyOf": [
            {
              "minLength": 1,
              "type": "string"
            },
            {
              "type": "null"
            }
          ],
          "description": "The commitment that licenses its bound."
        },
        "claim": {
          "description": "The claim class.",
          "minLength": 1,
          "type": "string"
        },
        "filled": {
          "description": "How many source rows assert it.",
          "type": "integer"
        },
        "grain": {
          "description": "Vocabulary or record: whether the registry asserts it, or only an instance can.",
          "enum": [
            "vocabulary",
            "record"
          ],
          "minLength": 1,
          "type": "string"
        },
        "id": {
          "description": "Kind·verb.",
          "minLength": 1,
          "type": "string"
        },
        "inverse": {
          "description": "The reverse reading.",
          "minLength": 1,
          "type": "string"
        },
        "of": {
          "description": "How many source rows there are.",
          "type": "integer"
        },
        "path": {
          "description": "The specification's anchor on the relationships page; the standards export's IRI for it.",
          "minLength": 1,
          "pattern": "^/([a-z0-9.-]+/)*([a-z0-9.-]+)?(#[a-z0-9-]+)?$",
          "type": "string"
        },
        "relation_kind": {
          "description": "Association, Typing, Hierarchy or Grounding.",
          "enum": [
            "Association",
            "Hierarchy",
            "Typing",
            "Grounding",
            "Mapping"
          ],
          "minLength": 1,
          "type": "string"
        },
        "rule_ids": {
          "description": "The commitments that license it.",
          "items": {
            "minLength": 1,
            "type": "string"
          },
          "type": "array"
        },
        "source_kind": {
          "description": "The kind it is from.",
          "minLength": 1,
          "type": "string"
        },
        "target_kinds": {
          "description": "The kinds it reaches.",
          "items": {
            "minLength": 1,
            "type": "string"
          },
          "type": "array"
        },
        "terminal": {
          "description": "Whether a walk stops at it.",
          "type": "boolean"
        },
        "verb": {
          "description": "The verb.",
          "minLength": 1,
          "type": "string"
        }
      },
      "required": [
        "id",
        "verb",
        "rule_ids",
        "source_kind",
        "target_kinds",
        "relation_kind",
        "claim",
        "grain",
        "inverse",
        "acyclic",
        "cardinality",
        "terminal",
        "filled",
        "of",
        "path"
      ],
      "type": "object"
    },
    "enforcement_value": {
      "$comment": "Field order is the declared order; python scripts/build_from_ground.py --format writes it.",
      "additionalProperties": false,
      "description": "One way a commitment is held, what the surface says beside it, and the register it is drawn in.",
      "properties": {
        "about": {
          "description": "What this way of holding means.",
          "minLength": 1,
          "type": "string"
        },
        "label": {
          "description": "What the surface says beside a commitment held this way.",
          "minLength": 1,
          "type": "string"
        },
        "register": {
          "description": "The register the surface draws it in.",
          "enum": [
            "world",
            "gov",
            "owed"
          ],
          "minLength": 1,
          "type": "string"
        }
      },
      "required": [
        "about",
        "label",
        "register"
      ],
      "type": "object"
    },
    "enforcement_vocabulary": {
      "$comment": "Field order is the declared order; python scripts/build_from_ground.py --format writes it.",
      "additionalProperties": false,
      "description": "The ways a commitment is held, and what holds them.",
      "properties": {
        "about": {
          "description": "What this vocabulary governs.",
          "minLength": 1,
          "type": "string"
        },
        "enforced_by": {
          "description": "The gate that holds this vocabulary: a check, a ring or an eval the law catalogs.",
          "minLength": 1,
          "pattern": "^(FND-\\d{3}|ring:\\d|eval:[a-z-]+)$",
          "type": "string"
        },
        "values": {
          "additionalProperties": {
            "$ref": "#/$defs/enforcement_value"
          },
          "description": "Each way, by name.",
          "type": "object"
        }
      },
      "required": [
        "about",
        "enforced_by",
        "values"
      ],
      "type": "object"
    },
    "eval": {
      "$comment": "Field order is the declared order; python scripts/build_from_ground.py --format writes it.",
      "additionalProperties": false,
      "description": "One eval: a proof about the machinery or the record, run beside the rings rather than in the chain.",
      "properties": {
        "holds": {
          "description": "What must be true for the eval to pass.",
          "minLength": 1,
          "type": "string"
        },
        "id": {
          "description": "eval and a name.",
          "minLength": 1,
          "pattern": "^eval:[a-z-]+$",
          "type": "string"
        },
        "label": {
          "description": "What it proves, in a phrase.",
          "minLength": 1,
          "type": "string"
        },
        "run_by": {
          "description": "What runs it, and when.",
          "minLength": 1,
          "type": "string"
        }
      },
      "required": [
        "id",
        "label",
        "holds",
        "run_by"
      ],
      "type": "object"
    },
    "evidence_declaration": {
      "$comment": "Field order is the declared order; python scripts/build_from_ground.py --format writes it.",
      "additionalProperties": false,
      "description": "How a reading's cause is read: the kind of evidence designs, the road a metric declares its design on, the record road credit divides over, and the kind whose rows are the attribution rules, which type into one design.",
      "properties": {
        "credit": {
          "description": "The record road attribution divides credit over.",
          "minLength": 1,
          "type": "string"
        },
        "kind": {
          "description": "The kind whose rows are the evidence designs.",
          "minLength": 1,
          "type": "string"
        },
        "relationship": {
          "description": "The specification on which a metric declares the design it is read by.",
          "minLength": 1,
          "type": "string"
        },
        "rules": {
          "description": "The kind whose rows are the attribution rules, each typed into one design.",
          "minLength": 1,
          "type": "string"
        }
      },
      "required": [
        "kind",
        "relationship",
        "credit",
        "rules"
      ],
      "type": "object"
    },
    "evidence_vocabulary": {
      "$comment": "Field order is the declared order; python scripts/build_from_ground.py --format writes it.",
      "additionalProperties": false,
      "description": "The ways a row may be admitted, and what holds them.",
      "properties": {
        "about": {
          "description": "What this vocabulary governs.",
          "minLength": 1,
          "type": "string"
        },
        "enforced_by": {
          "description": "The gate that holds this vocabulary: a check, a ring or an eval the law catalogs.",
          "minLength": 1,
          "pattern": "^(FND-\\d{3}|ring:\\d|eval:[a-z-]+)$",
          "type": "string"
        },
        "values": {
          "additionalProperties": {
            "minLength": 1,
            "type": "string"
          },
          "description": "Each class, and the label the site shows for it.",
          "type": "object"
        }
      },
      "required": [
        "about",
        "enforced_by",
        "values"
      ],
      "type": "object"
    },
    "foundations": {
      "$comment": "Field order is the declared order; python scripts/build_from_ground.py --format writes it.",
      "additionalProperties": false,
      "description": "The knowledge ledger as the site reads it.",
      "properties": {
        "checks": {
          "description": "The checks by name.",
          "items": {
            "$ref": "#/$defs/graph_check"
          },
          "type": "array"
        },
        "evals": {
          "description": "The evals beside the rings, in order.",
          "items": {
            "$ref": "#/$defs/eval"
          },
          "minItems": 1,
          "type": "array"
        },
        "lenses": {
          "description": "The foundations.",
          "items": {
            "$ref": "#/$defs/graph_lens"
          },
          "type": "array"
        },
        "report": {
          "$ref": "#/$defs/report",
          "description": "The verification report."
        },
        "rings": {
          "description": "The rings of the gate chain, in order.",
          "items": {
            "$ref": "#/$defs/ring"
          },
          "minItems": 1,
          "type": "array"
        },
        "rules": {
          "description": "The commitments.",
          "items": {
            "$ref": "#/$defs/graph_rule"
          },
          "type": "array"
        },
        "sources": {
          "description": "The cited works.",
          "items": {
            "$ref": "#/$defs/graph_source"
          },
          "type": "array"
        }
      },
      "required": [
        "report",
        "rings",
        "evals",
        "lenses",
        "checks",
        "rules",
        "sources"
      ],
      "type": "object"
    },
    "fragment_value": {
      "$comment": "Field order is the declared order; python scripts/build_from_ground.py --format writes it.",
      "additionalProperties": false,
      "description": "One fragment: what carries it, the fragment itself, and the files that write it.",
      "properties": {
        "about": {
          "description": "What carries this fragment.",
          "minLength": 1,
          "type": "string"
        },
        "at": {
          "description": "The fragment, with its hash.",
          "minLength": 1,
          "pattern": "^#[a-z][a-z0-9-]*$",
          "type": "string"
        },
        "drawn_by": {
          "description": "The files that write it, as paths from the repository root, each naming this fragment.",
          "items": {
            "minLength": 1,
            "type": "string"
          },
          "minItems": 1,
          "type": "array"
        }
      },
      "required": [
        "about",
        "at",
        "drawn_by"
      ],
      "type": "object"
    },
    "fragment_vocabulary": {
      "$comment": "Field order is the declared order; python scripts/build_from_ground.py --format writes it.",
      "additionalProperties": false,
      "description": "The fragments entities carry on their pages, and what holds them.",
      "properties": {
        "about": {
          "description": "What this vocabulary governs.",
          "minLength": 1,
          "type": "string"
        },
        "enforced_by": {
          "description": "The gate that holds this vocabulary: a check, a ring or an eval the law catalogs.",
          "minLength": 1,
          "pattern": "^(FND-\\d{3}|ring:\\d|eval:[a-z-]+)$",
          "type": "string"
        },
        "values": {
          "additionalProperties": {
            "$ref": "#/$defs/fragment_value"
          },
          "description": "Each fragment, by what carries it.",
          "type": "object"
        }
      },
      "required": [
        "about",
        "enforced_by",
        "values"
      ],
      "type": "object"
    },
    "frame_value": {
      "$comment": "Field order is the declared order; python scripts/build_from_ground.py --format writes it.",
      "additionalProperties": false,
      "description": "One name the frame answers.",
      "properties": {
        "about": {
          "description": "What answers there.",
          "minLength": 1,
          "type": "string"
        }
      },
      "required": [
        "about"
      ],
      "type": "object"
    },
    "frame_vocabulary": {
      "$comment": "Field order is the declared order; python scripts/build_from_ground.py --format writes it.",
      "additionalProperties": false,
      "description": "The frame's own names, and what holds them.",
      "properties": {
        "about": {
          "description": "What this vocabulary governs.",
          "minLength": 1,
          "type": "string"
        },
        "enforced_by": {
          "description": "The gate that holds this vocabulary: a check, a ring or an eval the law catalogs.",
          "minLength": 1,
          "pattern": "^(FND-\\d{3}|ring:\\d|eval:[a-z-]+)$",
          "type": "string"
        },
        "values": {
          "additionalProperties": {
            "$ref": "#/$defs/frame_value"
          },
          "description": "Each name, as the frame answers it.",
          "type": "object"
        }
      },
      "required": [
        "about",
        "enforced_by",
        "values"
      ],
      "type": "object"
    },
    "frontier_declaration": {
      "$comment": "Field order is the declared order; python scripts/build_from_ground.py --format writes it.",
      "additionalProperties": false,
      "description": "The frontier kinds and relationships this model must carry, and which admit records only against a source. Not a pattern in the sense patterns.json means: a requirement list.",
      "properties": {
        "kinds": {
          "description": "Kinds the patterns need.",
          "items": {
            "minLength": 1,
            "type": "string"
          },
          "type": "array"
        }
      },
      "required": [
        "kinds"
      ],
      "type": "object"
    },
    "graph": {
      "$comment": "Field order is the declared order; python scripts/build_from_ground.py --format writes it.",
      "additionalProperties": false,
      "description": "The graph the site reads: everything derived from the ground, and nothing else.",
      "properties": {
        "bands": {
          "description": "The bands in map order.",
          "items": {
            "$ref": "#/$defs/graph_band"
          },
          "type": "array"
        },
        "deliverables": {
          "description": "What this model hands over, each a bundle of views.",
          "items": {
            "$ref": "#/$defs/graph_deliverable"
          },
          "type": "array"
        },
        "edge_specs": {
          "description": "Every relationship specification, with how many rows fill it.",
          "items": {
            "$ref": "#/$defs/edge_spec"
          },
          "type": "array"
        },
        "edges": {
          "description": "Every assertion, in canonical direction.",
          "items": {
            "$ref": "#/$defs/edge"
          },
          "type": "array"
        },
        "foundations": {
          "$ref": "#/$defs/foundations",
          "description": "The knowledge ledger as the site reads it."
        },
        "meta": {
          "$ref": "#/$defs/meta",
          "description": "What the graph says about itself."
        },
        "node_kinds": {
          "additionalProperties": {
            "$ref": "#/$defs/node_kind"
          },
          "description": "Every kind, by name.",
          "type": "object"
        },
        "nodes": {
          "description": "Every row.",
          "items": {
            "$ref": "#/$defs/node"
          },
          "type": "array"
        },
        "patterns": {
          "description": "The declared patterns, each bound against the model.",
          "items": {
            "$ref": "#/$defs/graph_pattern"
          },
          "type": "array"
        },
        "redirects": {
          "description": "Every address the site once answered to, and what it says now.",
          "items": {
            "$ref": "#/$defs/redirect"
          },
          "type": "array"
        },
        "relations": {
          "description": "The verbs, folded across the kinds that speak them.",
          "items": {
            "$ref": "#/$defs/relation"
          },
          "type": "array"
        },
        "views": {
          "description": "The views, each walked from every row that answers it.",
          "items": {
            "$ref": "#/$defs/graph_view"
          },
          "type": "array"
        }
      },
      "required": [
        "meta",
        "node_kinds",
        "nodes",
        "edges",
        "edge_specs",
        "bands",
        "foundations",
        "relations",
        "redirects",
        "views",
        "deliverables",
        "patterns"
      ],
      "type": "object"
    },
    "graph_band": {
      "$comment": "Field order is the declared order; python scripts/build_from_ground.py --format writes it.",
      "additionalProperties": false,
      "description": "A band as the site reads it.",
      "properties": {
        "colour": {
          "description": "Its colour.",
          "minLength": 1,
          "pattern": "^#[0-9a-f]{6}$",
          "type": "string"
        },
        "label": {
          "description": "The band's name.",
          "minLength": 1,
          "type": "string"
        },
        "modified": {
          "description": "When its page's content last changed.",
          "minLength": 1,
          "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
          "type": "string"
        },
        "path": {
          "description": "The band's page.",
          "minLength": 1,
          "pattern": "^/([a-z0-9.-]+/)*([a-z0-9.-]+)?(#[a-z0-9-]+)?$",
          "type": "string"
        }
      },
      "required": [
        "label",
        "colour",
        "modified",
        "path"
      ],
      "type": "object"
    },
    "graph_check": {
      "$comment": "Field order is the declared order; python scripts/build_from_ground.py --format writes it.",
      "additionalProperties": false,
      "description": "A check as the graph carries it: the law's declaration and its anchor on the checks page.",
      "properties": {
        "definition": {
          "description": "What it holds.",
          "minLength": 1,
          "type": "string"
        },
        "id": {
          "description": "FND and a number.",
          "minLength": 1,
          "type": "string"
        },
        "label": {
          "description": "Its name.",
          "minLength": 1,
          "type": "string"
        },
        "path": {
          "description": "The check's anchor on the checks page.",
          "minLength": 1,
          "pattern": "^/([a-z0-9.-]+/)*([a-z0-9.-]+)?(#[a-z0-9-]+)?$",
          "type": "string"
        },
        "ring": {
          "description": "The ring the check runs in.",
          "minLength": 1,
          "pattern": "^ring:\\d$",
          "type": "string"
        },
        "runs": {
          "description": "Which integrity it runs in.",
          "minLength": 1,
          "type": "string"
        }
      },
      "required": [
        "id",
        "label",
        "runs",
        "definition",
        "ring",
        "path"
      ],
      "type": "object"
    },
    "graph_deliverable": {
      "$comment": "Field order is the declared order; python scripts/build_from_ground.py --format writes it.",
      "additionalProperties": false,
      "description": "One deliverable as the site reads it: what it is, its views, every kind those touch, the commitments that license it, and its address.",
      "properties": {
        "definition": {
          "description": "What it is.",
          "minLength": 1,
          "type": "string"
        },
        "id": {
          "description": "DLV-NNN.",
          "minLength": 1,
          "pattern": "^DLV-\\d{3}$",
          "type": "string"
        },
        "kinds": {
          "description": "Every kind its views touch.",
          "items": {
            "minLength": 1,
            "type": "string"
          },
          "type": "array"
        },
        "label": {
          "description": "Its name.",
          "minLength": 1,
          "type": "string"
        },
        "leaves_with": {
          "description": "What a reader leaves with.",
          "minLength": 1,
          "type": "string"
        },
        "mentions": {
          "description": "The governed things its texts name, resolved; absent where none.",
          "items": {
            "$ref": "#/$defs/mention"
          },
          "type": "array"
        },
        "modified": {
          "description": "When its content last changed.",
          "minLength": 1,
          "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
          "type": "string"
        },
        "path": {
          "description": "Its address.",
          "minLength": 1,
          "pattern": "^/",
          "type": "string"
        },
        "rule_ids": {
          "description": "The commitments that license it, by id.",
          "items": {
            "minLength": 1,
            "type": "string"
          },
          "type": "array"
        },
        "views": {
          "description": "The views that belong to it, in registry order.",
          "items": {
            "minLength": 1,
            "type": "string"
          },
          "minItems": 1,
          "type": "array"
        }
      },
      "required": [
        "id",
        "label",
        "definition",
        "leaves_with",
        "path",
        "views",
        "kinds",
        "rule_ids",
        "modified"
      ],
      "type": "object"
    },
    "graph_edge": {
      "$comment": "Field order is the declared order; python scripts/build_from_ground.py --format writes it.",
      "additionalProperties": false,
      "description": "One edge of a pattern as the site reads it, with the reading in both directions.",
      "properties": {
        "from": {
          "description": "The role it is asserted from.",
          "minLength": 1,
          "type": "string"
        },
        "inverse": {
          "description": "How it reads back.",
          "minLength": 1,
          "type": "string"
        },
        "to": {
          "description": "The role it reaches.",
          "minLength": 1,
          "type": "string"
        },
        "verb": {
          "description": "How it reads forward.",
          "minLength": 1,
          "type": "string"
        },
        "via": {
          "description": "The relationship.",
          "minLength": 1,
          "type": "string"
        }
      },
      "required": [
        "from",
        "via",
        "verb",
        "inverse",
        "to"
      ],
      "type": "object"
    },
    "graph_lens": {
      "$comment": "Field order is the declared order; python scripts/build_from_ground.py --format writes it.",
      "additionalProperties": false,
      "description": "A foundation as the site reads it.",
      "properties": {
        "asks": {
          "description": "The question it asks.",
          "minLength": 1,
          "type": "string"
        },
        "definition": {
          "description": "The discipline.",
          "minLength": 1,
          "type": "string"
        },
        "here": {
          "description": "This model's answer.",
          "minLength": 1,
          "type": "string"
        },
        "id": {
          "description": "Its name in lower case.",
          "minLength": 1,
          "type": "string"
        },
        "label": {
          "description": "Its name.",
          "minLength": 1,
          "type": "string"
        },
        "layer": {
          "description": "Its layer.",
          "minLength": 1,
          "type": "string"
        },
        "mentions": {
          "description": "The governed things its texts name, resolved; absent where none.",
          "items": {
            "$ref": "#/$defs/mention"
          },
          "type": "array"
        },
        "modified": {
          "description": "When its page's content last changed.",
          "minLength": 1,
          "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
          "type": "string"
        },
        "path": {
          "description": "The foundation's page.",
          "minLength": 1,
          "pattern": "^/([a-z0-9.-]+/)*([a-z0-9.-]+)?(#[a-z0-9-]+)?$",
          "type": "string"
        },
        "proved_by": {
          "description": "The gates that prove it: checks, rings and evals.",
          "items": {
            "minLength": 1,
            "type": "string"
          },
          "type": "array"
        },
        "rule_ids": {
          "description": "The commitments that answer it.",
          "items": {
            "minLength": 1,
            "type": "string"
          },
          "type": "array"
        },
        "standards": {
          "description": "The engineering standards that state it directly.",
          "items": {
            "minLength": 1,
            "type": "string"
          },
          "type": "array"
        }
      },
      "required": [
        "id",
        "label",
        "layer",
        "asks",
        "definition",
        "here",
        "standards",
        "rule_ids",
        "proved_by",
        "modified",
        "path"
      ],
      "type": "object"
    },
    "graph_pattern": {
      "$comment": "Field order is the declared order; python scripts/build_from_ground.py --format writes it.",
      "additionalProperties": false,
      "description": "One pattern as the site reads it: its shape, what it touches, and one worked instance.",
      "properties": {
        "answers": {
          "description": "For a question: every row it is answered from, each an answer page; absent for a shape.",
          "items": {
            "$ref": "#/$defs/pattern_answer"
          },
          "type": "array"
        },
        "asks": {
          "description": "The question it answers, where it is one.",
          "minLength": 1,
          "type": "string"
        },
        "edges": {
          "description": "Its edges.",
          "items": {
            "$ref": "#/$defs/graph_edge"
          },
          "minItems": 1,
          "type": "array"
        },
        "example": {
          "description": "One binding, a row per role in reading order.",
          "items": {
            "minLength": 1,
            "type": "string"
          },
          "type": "array"
        },
        "grain": {
          "description": "Vocabulary or record.",
          "enum": [
            "vocabulary",
            "record"
          ],
          "minLength": 1,
          "type": "string"
        },
        "id": {
          "description": "PTN and a three-digit ordinal.",
          "minLength": 1,
          "pattern": "^PTN-\\d{3}$",
          "type": "string"
        },
        "instances": {
          "description": "How many complete bindings the model holds.",
          "type": "integer"
        },
        "kind": {
          "description": "Whether this is a question or a shape, as declared and proven.",
          "enum": [
            "question",
            "shape"
          ],
          "minLength": 1,
          "type": "string"
        },
        "kinds": {
          "description": "The kinds its roles name, in reading order, derived from them.",
          "items": {
            "minLength": 1,
            "type": "string"
          },
          "minItems": 2,
          "type": "array"
        },
        "label": {
          "description": "The pattern's name.",
          "minLength": 1,
          "type": "string"
        },
        "mentions": {
          "description": "The governed things its texts name, resolved; absent where none.",
          "items": {
            "$ref": "#/$defs/mention"
          },
          "type": "array"
        },
        "modified": {
          "description": "When its content last changed.",
          "minLength": 1,
          "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
          "type": "string"
        },
        "named_in": {
          "description": "The texts that name it; absent where none.",
          "items": {
            "$ref": "#/$defs/naming"
          },
          "type": "array"
        },
        "path": {
          "description": "Its page.",
          "minLength": 1,
          "pattern": "^/",
          "type": "string"
        },
        "roles": {
          "description": "Its roles in reading order.",
          "items": {
            "$ref": "#/$defs/graph_role"
          },
          "minItems": 2,
          "type": "array"
        },
        "root": {
          "description": "The role a reader stands on, where there is one.",
          "minLength": 1,
          "type": "string"
        }
      },
      "required": [
        "id",
        "label",
        "kind",
        "grain",
        "roles",
        "edges",
        "kinds",
        "instances",
        "path",
        "modified"
      ],
      "type": "object"
    },
    "graph_role": {
      "$comment": "Field order is the declared order; python scripts/build_from_ground.py --format writes it.",
      "additionalProperties": false,
      "description": "One role of a pattern as the site reads it.",
      "properties": {
        "kind": {
          "description": "The kind that fills it.",
          "minLength": 1,
          "type": "string"
        },
        "name": {
          "description": "The role's name.",
          "minLength": 1,
          "type": "string"
        },
        "reached": {
          "description": "How many distinct rows fill it across every binding of the pattern.",
          "type": "integer"
        }
      },
      "required": [
        "name",
        "kind",
        "reached"
      ],
      "type": "object"
    },
    "graph_rule": {
      "$comment": "Field order is the declared order; python scripts/build_from_ground.py --format writes it.",
      "additionalProperties": false,
      "description": "A commitment as the site reads it.",
      "properties": {
        "current": {
          "description": "What is true under it.",
          "items": {
            "minLength": 1,
            "type": "string"
          },
          "type": "array"
        },
        "deferred": {
          "description": "What is deferred under it.",
          "items": {
            "minLength": 1,
            "type": "string"
          },
          "type": "array"
        },
        "enforcement": {
          "description": "Enforced or guidance.",
          "minLength": 1,
          "type": "string"
        },
        "id": {
          "description": "RUL and a number.",
          "minLength": 1,
          "type": "string"
        },
        "kinds": {
          "description": "The kinds it licenses.",
          "items": {
            "minLength": 1,
            "type": "string"
          },
          "type": "array"
        },
        "label": {
          "description": "Its name.",
          "minLength": 1,
          "type": "string"
        },
        "mentions": {
          "description": "The governed things its texts name, resolved; absent where none.",
          "items": {
            "$ref": "#/$defs/mention"
          },
          "type": "array"
        },
        "modified": {
          "description": "When its page's content last changed.",
          "minLength": 1,
          "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
          "type": "string"
        },
        "named_in": {
          "description": "The texts that name it; absent where none.",
          "items": {
            "$ref": "#/$defs/naming"
          },
          "type": "array"
        },
        "path": {
          "description": "The commitment's page.",
          "minLength": 1,
          "pattern": "^/([a-z0-9.-]+/)*([a-z0-9.-]+)?(#[a-z0-9-]+)?$",
          "type": "string"
        },
        "proved_by": {
          "description": "The gates that prove it: checks, rings and evals.",
          "items": {
            "minLength": 1,
            "type": "string"
          },
          "type": "array"
        },
        "relationships": {
          "description": "The relationships it licenses.",
          "items": {
            "minLength": 1,
            "type": "string"
          },
          "type": "array"
        },
        "sources": {
          "description": "The works it is derived from.",
          "items": {
            "$ref": "#/$defs/cited_source"
          },
          "type": "array"
        },
        "statement": {
          "description": "What it holds.",
          "minLength": 1,
          "type": "string"
        },
        "status": {
          "description": "Adopted, proposed or deferred.",
          "minLength": 1,
          "type": "string"
        },
        "why": {
          "description": "What goes wrong without it.",
          "minLength": 1,
          "type": "string"
        }
      },
      "required": [
        "id",
        "label",
        "status",
        "enforcement",
        "proved_by",
        "statement",
        "why",
        "current",
        "deferred",
        "kinds",
        "relationships",
        "sources",
        "modified",
        "path"
      ],
      "type": "object"
    },
    "graph_source": {
      "$comment": "Field order is the declared order; python scripts/build_from_ground.py --format writes it.",
      "additionalProperties": false,
      "description": "A cited work as the site reads it.",
      "properties": {
        "id": {
          "description": "SRC and a name.",
          "minLength": 1,
          "type": "string"
        },
        "label": {
          "description": "Its title.",
          "minLength": 1,
          "type": "string"
        },
        "modified": {
          "description": "When its page's content last changed.",
          "minLength": 1,
          "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
          "type": "string"
        },
        "named_in": {
          "description": "The texts that name it; absent where none.",
          "items": {
            "$ref": "#/$defs/naming"
          },
          "type": "array"
        },
        "path": {
          "description": "The source's page.",
          "minLength": 1,
          "pattern": "^/([a-z0-9.-]+/)*([a-z0-9.-]+)?(#[a-z0-9-]+)?$",
          "type": "string"
        },
        "publisher": {
          "description": "Who published it.",
          "minLength": 1,
          "type": "string"
        },
        "reference": {
          "anyOf": [
            {
              "minLength": 1,
              "type": "string"
            },
            {
              "type": "null"
            }
          ],
          "description": "A citation where it has no address."
        },
        "retrieved_on": {
          "description": "When it was last read.",
          "minLength": 1,
          "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
          "type": "string"
        },
        "role": {
          "description": "What it supports here.",
          "minLength": 1,
          "type": "string"
        },
        "rule_ids": {
          "description": "The commitments that cite it.",
          "items": {
            "minLength": 1,
            "type": "string"
          },
          "type": "array"
        },
        "type": {
          "description": "What kind of work.",
          "minLength": 1,
          "type": "string"
        },
        "url": {
          "anyOf": [
            {
              "minLength": 1,
              "type": "string"
            },
            {
              "type": "null"
            }
          ],
          "description": "Where it is."
        }
      },
      "required": [
        "id",
        "label",
        "publisher",
        "type",
        "role",
        "url",
        "reference",
        "retrieved_on",
        "rule_ids",
        "modified",
        "path"
      ],
      "type": "object"
    },
    "graph_view": {
      "$comment": "Field order is the declared order; python scripts/build_from_ground.py --format writes it.",
      "additionalProperties": false,
      "description": "One view as the site reads it: what it is, the patterns it binds, the kind and kinds they touch, and every row it answers from.",
      "properties": {
        "answers": {
          "description": "Every row of the starting kind it answers from.",
          "items": {
            "$ref": "#/$defs/view_binding"
          },
          "minItems": 1,
          "type": "array"
        },
        "asks": {
          "description": "The work it does, in a reader's words.",
          "minLength": 1,
          "type": "string"
        },
        "composes": {
          "description": "The declared patterns it binds, in reading order; each is rooted in the same kind.",
          "items": {
            "minLength": 1,
            "pattern": "^PTN-\\d{3}$",
            "type": "string"
          },
          "minItems": 1,
          "type": "array"
        },
        "definition": {
          "description": "What it shows.",
          "minLength": 1,
          "type": "string"
        },
        "deliverable": {
          "description": "The deliverable this belongs to, by id, where it belongs to one.",
          "minLength": 1,
          "pattern": "^DLV-\\d{3}$",
          "type": "string"
        },
        "from": {
          "description": "What the reader is holding.",
          "minLength": 1,
          "type": "string"
        },
        "id": {
          "description": "CMP and a three-digit ordinal.",
          "minLength": 1,
          "pattern": "^CMP-\\d{3}$",
          "type": "string"
        },
        "kinds": {
          "description": "Every kind its patterns touch, in the order they are first reached, derived from them.",
          "items": {
            "minLength": 1,
            "type": "string"
          },
          "minItems": 1,
          "type": "array"
        },
        "label": {
          "description": "The view's name.",
          "minLength": 1,
          "type": "string"
        },
        "leaves_with": {
          "description": "What the reader takes away.",
          "minLength": 1,
          "type": "string"
        },
        "mentions": {
          "description": "The governed things its texts name, resolved; absent where none.",
          "items": {
            "$ref": "#/$defs/mention"
          },
          "type": "array"
        },
        "modified": {
          "description": "When its content last changed.",
          "minLength": 1,
          "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
          "type": "string"
        },
        "named_in": {
          "description": "The texts that name it; absent where none.",
          "items": {
            "$ref": "#/$defs/naming"
          },
          "type": "array"
        },
        "path": {
          "description": "The view's own page.",
          "minLength": 1,
          "pattern": "^/",
          "type": "string"
        },
        "renders": {
          "description": "How it is drawn.",
          "enum": [
            "table",
            "path"
          ],
          "minLength": 1,
          "type": "string"
        },
        "start": {
          "description": "The kind its patterns are all asked from, derived from them.",
          "minLength": 1,
          "type": "string"
        }
      },
      "required": [
        "id",
        "label",
        "renders",
        "definition",
        "asks",
        "from",
        "leaves_with",
        "start",
        "kinds",
        "path",
        "modified",
        "composes",
        "answers"
      ],
      "type": "object"
    },
    "grounding": {
      "$comment": "Field order is the declared order; python scripts/build_from_ground.py --format writes it.",
      "additionalProperties": false,
      "description": "The grounding relationship, from every kind to the entity a row is about.",
      "properties": {
        "cardinality": {
          "description": "How many targets one row states, as lower..upper with * for open.",
          "minLength": 1,
          "pattern": "^\\d+\\.\\.(\\d+|\\*)$",
          "type": "string"
        },
        "cardinality_rule": {
          "description": "The commitment that licenses a bound tighter than open.",
          "minLength": 1,
          "pattern": "^RUL-\\d{3}$",
          "type": "string"
        },
        "claim": {
          "description": "What kind of claim the relationship makes.",
          "enum": [
            "advisory",
            "causal",
            "constitutive",
            "dispositional",
            "evidential"
          ],
          "minLength": 1,
          "type": "string"
        },
        "grain": {
          "description": "The grain grounding is asserted at: a fact about every row, so vocabulary.",
          "enum": [
            "vocabulary",
            "record"
          ],
          "minLength": 1,
          "type": "string"
        },
        "inverse": {
          "description": "The verb the reverse reading uses.",
          "minLength": 1,
          "type": "string"
        },
        "licensed_by": {
          "description": "The commitment that licenses grounding itself.",
          "minLength": 1,
          "pattern": "^RUL-\\d{3}$",
          "type": "string"
        },
        "relation_kind": {
          "description": "The grounding every kind makes. Declared once here and expanded for every kind, so it is the one relationship kind a verb entry may not carry.",
          "enum": [
            "Grounding"
          ],
          "minLength": 1,
          "type": "string"
        },
        "terminal": {
          "description": "Whether a walk stops here.",
          "type": "boolean"
        },
        "to": {
          "description": "The kinds it reaches, as a list even when there is one.",
          "items": {
            "minLength": 1,
            "type": "string"
          },
          "minItems": 1,
          "type": "array",
          "uniqueItems": true
        },
        "verb": {
          "description": "The verb every kind speaks to its entity.",
          "minLength": 1,
          "type": "string"
        }
      },
      "required": [
        "verb",
        "to",
        "relation_kind",
        "terminal",
        "cardinality",
        "claim",
        "grain",
        "inverse",
        "licensed_by"
      ],
      "type": "object"
    },
    "group_value": {
      "$comment": "Field order is the declared order; python scripts/build_from_ground.py --format writes it.",
      "additionalProperties": false,
      "description": "One group of doors, and the mark the header draws its doors with, if any.",
      "properties": {
        "about": {
          "description": "What falls into this group.",
          "minLength": 1,
          "type": "string"
        },
        "mark": {
          "description": "A glyph drawn before each door of this group. Absent, the door is drawn plain.",
          "minLength": 1,
          "type": "string"
        },
        "placed": {
          "description": "Where this group's doors are drawn.",
          "enum": [
            "header",
            "hub"
          ],
          "minLength": 1,
          "type": "string"
        },
        "within": {
          "description": "For a group gathered into a hub, the door that is that hub. It is drawn in the header, so nothing gathered is unreachable.",
          "minLength": 1,
          "type": "string"
        }
      },
      "required": [
        "about",
        "placed"
      ],
      "type": "object"
    },
    "header_value": {
      "$comment": "Field order is the declared order; python scripts/build_from_ground.py --format writes it.",
      "additionalProperties": false,
      "description": "One header the host owes on every response.",
      "properties": {
        "about": {
          "description": "Why the host owes it.",
          "minLength": 1,
          "type": "string"
        },
        "name": {
          "description": "The header's name.",
          "minLength": 1,
          "pattern": "^[A-Z][A-Za-z-]*$",
          "type": "string"
        },
        "value": {
          "description": "The value it answers with.",
          "minLength": 1,
          "type": "string"
        }
      },
      "required": [
        "about",
        "name",
        "value"
      ],
      "type": "object"
    },
    "header_vocabulary": {
      "$comment": "Field order is the declared order; python scripts/build_from_ground.py --format writes it.",
      "additionalProperties": false,
      "description": "The headers the host owes on every response, and what holds them.",
      "properties": {
        "about": {
          "description": "What this vocabulary governs.",
          "minLength": 1,
          "type": "string"
        },
        "enforced_by": {
          "description": "The gate that holds this vocabulary: a check, a ring or an eval the law catalogs.",
          "minLength": 1,
          "pattern": "^(FND-\\d{3}|ring:\\d|eval:[a-z-]+)$",
          "type": "string"
        },
        "values": {
          "additionalProperties": {
            "$ref": "#/$defs/header_value"
          },
          "description": "Each header, by name.",
          "type": "object"
        }
      },
      "required": [
        "about",
        "enforced_by",
        "values"
      ],
      "type": "object"
    },
    "host_declaration": {
      "$comment": "Field order is the declared order; python scripts/build_from_ground.py --format writes it.",
      "additionalProperties": false,
      "description": "How the host answers: what a browser may keep, and the headers it owes.",
      "properties": {
        "caching": {
          "$ref": "#/$defs/caching_vocabulary",
          "description": "What a browser may keep, by the form of the path."
        },
        "headers": {
          "$ref": "#/$defs/header_vocabulary",
          "description": "The headers the host owes on every response."
        }
      },
      "required": [
        "caching",
        "headers"
      ],
      "type": "object"
    },
    "instrumentation_declaration": {
      "$comment": "Field order is the declared order; python scripts/build_from_ground.py --format writes it.",
      "additionalProperties": false,
      "description": "What instruments the site itself: the kind whose rows the site's own signals are.",
      "properties": {
        "kind": {
          "description": "The kind whose rows the site's page view, search and link click are.",
          "minLength": 1,
          "type": "string"
        }
      },
      "required": [
        "kind"
      ],
      "type": "object"
    },
    "kernel": {
      "$comment": "Field order is the declared order; python scripts/build_from_ground.py --format writes it.",
      "additionalProperties": false,
      "description": "What this model must carry: the grounding every kind makes, the spines, the patterns, how a metric derives, the contract-status escape and the hedging verbs. It names this model's kinds and verbs; the law names none, and the band crossings that rest on a single road.",
      "properties": {
        "bridges": {
          "description": "Each crossing between two bands that rests on a single road, and why that road is load-bearing.",
          "items": {
            "$ref": "#/$defs/bridge"
          },
          "minItems": 1,
          "type": "array",
          "uniqueItems": true
        },
        "campaign": {
          "$ref": "#/$defs/campaign_pattern",
          "description": "The accountable initiative and what it requires."
        },
        "contract_status": {
          "$ref": "#/$defs/contract_status",
          "description": "The escape a measure declares when its source does not yet exist."
        },
        "evidence": {
          "$ref": "#/$defs/evidence_declaration",
          "description": "How a reading's cause is read."
        },
        "frontier": {
          "$ref": "#/$defs/frontier_declaration",
          "description": "The frontier kinds and relationships the model must carry."
        },
        "grounding": {
          "$ref": "#/$defs/grounding",
          "description": "The one relationship every kind makes, declared once and expanded per kind by the loader."
        },
        "hedged_verbs": {
          "description": "Verb openings that hedge; a hedging verb may claim no more than it says.",
          "items": {
            "minLength": 1,
            "type": "string"
          },
          "minItems": 1,
          "type": "array"
        },
        "instrumentation": {
          "$ref": "#/$defs/instrumentation_declaration",
          "description": "The kind that instruments the site."
        },
        "loops": {
          "description": "The shapes the model must instantiate: each a pattern whose edges form one cycle over all its roles, so that energy sent along its roads comes back to where it started, held to at least one instance on every build.",
          "items": {
            "minLength": 1,
            "type": "string"
          },
          "minItems": 1,
          "type": "array",
          "uniqueItems": true
        },
        "machine": {
          "$ref": "#/$defs/machine_declaration",
          "description": "The journey machine's kinds and verbs."
        },
        "metrics": {
          "$ref": "#/$defs/metric_derivation",
          "description": "How a metric is derived."
        },
        "resolution": {
          "$ref": "#/$defs/resolution_declaration",
          "description": "How far a person is resolved, and the level a move may not rest on."
        },
        "settings": {
          "$ref": "#/$defs/settings_declaration",
          "description": "What a reader may set."
        },
        "spines": {
          "description": "What every row of a kind must state, or one of, or be reached by.",
          "items": {
            "$ref": "#/$defs/spine"
          },
          "minItems": 1,
          "type": "array"
        }
      },
      "required": [
        "grounding",
        "machine",
        "instrumentation",
        "resolution",
        "evidence",
        "settings",
        "spines",
        "campaign",
        "frontier",
        "bridges",
        "metrics",
        "loops",
        "contract_status",
        "hedged_verbs"
      ],
      "type": "object"
    },
    "law_vocabularies": {
      "$comment": "Field order is the declared order; python scripts/build_from_ground.py --format writes it.",
      "additionalProperties": false,
      "description": "The law's free-standing vocabularies, carried so the artifact says what its values mean and an agent reading it needs nothing from the repository. The ones that belong to a section of the law travel with that section instead: how a view is drawn under `views`, the doors' groups and the redirect statuses under `addresses`, the contract statuses under `kernel`.",
      "properties": {
        "claims": {
          "$ref": "#/$defs/claim_vocabulary",
          "description": "What a relationship may claim."
        },
        "enforcement": {
          "$ref": "#/$defs/enforcement_vocabulary",
          "description": "The ways a commitment is held."
        },
        "evidence_classes": {
          "$ref": "#/$defs/evidence_vocabulary",
          "description": "How a row may be admitted."
        },
        "grains": {
          "$ref": "#/$defs/plain_vocabulary",
          "description": "The grains a relationship is asserted at."
        },
        "instance_policies": {
          "$ref": "#/$defs/plain_vocabulary",
          "description": "The policies a kind may declare."
        },
        "kind_shapes": {
          "$ref": "#/$defs/plain_vocabulary",
          "description": "The shapes a kind may have."
        },
        "layers": {
          "$ref": "#/$defs/plain_vocabulary",
          "description": "The layers a foundation belongs to, in reading order."
        },
        "map": {
          "$ref": "#/$defs/map_declaration",
          "description": "How the model is drawn beside every page, and the board."
        },
        "modes": {
          "$ref": "#/$defs/mode_vocabulary",
          "description": "The ways a page is read."
        },
        "operations": {
          "$ref": "#/$defs/operation_vocabulary",
          "description": "The operations anything may perform with the parts."
        },
        "pattern_kinds": {
          "$ref": "#/$defs/pattern_kind_vocabulary",
          "description": "The kinds a pattern may be."
        },
        "prose": {
          "$ref": "#/$defs/prose_vocabulary",
          "description": "The texts a kind carries."
        },
        "references": {
          "$ref": "#/$defs/reference_vocabulary",
          "description": "How prose names a governed thing."
        },
        "registers": {
          "$ref": "#/$defs/plain_vocabulary",
          "description": "The registers a claim is drawn in."
        },
        "relation_kinds": {
          "$ref": "#/$defs/relation_kind_vocabulary",
          "description": "What a relationship may be."
        },
        "retired": {
          "$ref": "#/$defs/retired_vocabulary",
          "description": "The words this model has retired."
        },
        "statuses": {
          "$ref": "#/$defs/status_vocabulary",
          "description": "The standings a commitment may have."
        }
      },
      "required": [
        "claims",
        "relation_kinds",
        "evidence_classes",
        "kind_shapes",
        "instance_policies",
        "registers",
        "retired",
        "pattern_kinds",
        "operations",
        "statuses",
        "enforcement",
        "layers",
        "prose",
        "modes",
        "map",
        "references",
        "grains"
      ],
      "type": "object"
    },
    "machine_declaration": {
      "$comment": "Field order is the declared order; python scripts/build_from_ground.py --format writes it.",
      "additionalProperties": false,
      "description": "The journey machine: which kinds are its journeys, states, transitions, stages and conditions, and the verbs it is read through. The site draws and exports a journey from these; nothing downstream names a kind or a verb of its own.",
      "properties": {
        "condition": {
          "description": "The kind whose rows a state realizes, each sitting in a stage.",
          "minLength": 1,
          "type": "string"
        },
        "journey": {
          "description": "The kind whose rows are journeys, and whose rows have a machine-readable twin.",
          "minLength": 1,
          "type": "string"
        },
        "says": {
          "additionalProperties": {
            "minLength": 1,
            "type": "string"
          },
          "description": "What a reader is told each role's rows are, by role.; the surface keeps no phrases of its own.",
          "type": "object"
        },
        "speaks": {
          "$ref": "#/$defs/machine_speakers",
          "description": "Which role of the machine speaks each verb."
        },
        "stage": {
          "description": "The kind whose rows are the rungs of the lifecycle ladder.",
          "minLength": 1,
          "type": "string"
        },
        "state": {
          "description": "The kind whose rows are a journey's positions.",
          "minLength": 1,
          "type": "string"
        },
        "transition": {
          "description": "The kind whose rows are a journey's legal moves.",
          "minLength": 1,
          "type": "string"
        },
        "verbs": {
          "$ref": "#/$defs/machine_verbs",
          "description": "The verbs, by role."
        }
      },
      "required": [
        "journey",
        "state",
        "transition",
        "stage",
        "condition",
        "verbs",
        "speaks",
        "says"
      ],
      "type": "object"
    },
    "machine_speakers": {
      "$comment": "Field order is the declared order; python scripts/build_from_ground.py --format writes it.",
      "additionalProperties": false,
      "description": "Which verbs each role of the machine speaks, by the verb's key in `verbs`. The law that holds the machine to its kinds and the site that says what the kernel asks of a kind read this one table.",
      "properties": {
        "condition": {
          "description": "The verb keys the condition kind declares.",
          "items": {
            "minLength": 1,
            "type": "string"
          },
          "minItems": 1,
          "type": "array",
          "uniqueItems": true
        },
        "journey": {
          "description": "The verb keys the journey kind declares.",
          "items": {
            "minLength": 1,
            "type": "string"
          },
          "minItems": 1,
          "type": "array",
          "uniqueItems": true
        },
        "stage": {
          "description": "The verb keys the stage kind declares.",
          "items": {
            "minLength": 1,
            "type": "string"
          },
          "minItems": 1,
          "type": "array",
          "uniqueItems": true
        },
        "state": {
          "description": "The verb keys the state kind declares.",
          "items": {
            "minLength": 1,
            "type": "string"
          },
          "minItems": 1,
          "type": "array",
          "uniqueItems": true
        },
        "transition": {
          "description": "The verb keys the transition kind declares.",
          "items": {
            "minLength": 1,
            "type": "string"
          },
          "minItems": 1,
          "type": "array",
          "uniqueItems": true
        }
      },
      "required": [
        "journey",
        "state",
        "transition",
        "stage",
        "condition"
      ],
      "type": "object"
    },
    "machine_verbs": {
      "$comment": "Field order is the declared order; python scripts/build_from_ground.py --format writes it.",
      "additionalProperties": false,
      "description": "The verbs the journey machine is read through, by the role each plays.",
      "properties": {
        "begins_at": {
          "description": "A journey begins at a state.",
          "minLength": 1,
          "type": "string"
        },
        "belongs_to_journey": {
          "description": "A state or a transition belongs to a journey.",
          "minLength": 1,
          "type": "string"
        },
        "from_state": {
          "description": "A transition leaves a state.",
          "minLength": 1,
          "type": "string"
        },
        "precedes": {
          "description": "A stage precedes the next stage on the ladder.",
          "minLength": 1,
          "type": "string"
        },
        "realizes": {
          "description": "A state realizes a condition.",
          "minLength": 1,
          "type": "string"
        },
        "sits_in_stage": {
          "description": "A condition sits in a stage.",
          "minLength": 1,
          "type": "string"
        },
        "to_state": {
          "description": "A transition enters a state.",
          "minLength": 1,
          "type": "string"
        },
        "triggered_by": {
          "description": "A transition is triggered by an observed event.",
          "minLength": 1,
          "type": "string"
        }
      },
      "required": [
        "precedes",
        "sits_in_stage",
        "belongs_to_journey",
        "realizes",
        "from_state",
        "to_state",
        "triggered_by",
        "begins_at"
      ],
      "type": "object"
    },
    "map_declaration": {
      "$comment": "Field order is the declared order; python scripts/build_from_ground.py --format writes it.",
      "additionalProperties": false,
      "description": "How the model is drawn beside every page: the arrangements the map offers, and the board.",
      "properties": {
        "about": {
          "description": "What this section governs.",
          "minLength": 1,
          "type": "string"
        },
        "arrangements": {
          "$ref": "#/$defs/arrangement_vocabulary",
          "description": "The ways the map arranges the model."
        },
        "board": {
          "$ref": "#/$defs/board_declaration",
          "description": "The board the compose door makes of the kinds arrangement."
        }
      },
      "required": [
        "about",
        "arrangements",
        "board"
      ],
      "type": "object"
    },
    "mention": {
      "$comment": "Field order is the declared order; python scripts/build_from_ground.py --format writes it.",
      "additionalProperties": false,
      "description": "One governed thing a text names, resolved: the reference as written, what kind of thing it is, and where it is.",
      "properties": {
        "label": {
          "description": "The target's label.",
          "minLength": 1,
          "type": "string"
        },
        "of": {
          "description": "What kind of thing it names, as the references vocabulary names it.",
          "enum": [
            "kind",
            "row",
            "commitment",
            "source",
            "pattern",
            "view"
          ],
          "minLength": 1,
          "type": "string"
        },
        "path": {
          "description": "The target's page.",
          "minLength": 1,
          "type": "string"
        },
        "ref": {
          "description": "The reference as written between the brackets, before any bar.",
          "minLength": 1,
          "type": "string"
        }
      },
      "required": [
        "ref",
        "of",
        "label",
        "path"
      ],
      "type": "object"
    },
    "meta": {
      "$comment": "Field order is the declared order; python scripts/build_from_ground.py --format writes it.",
      "additionalProperties": false,
      "description": "What the graph says about itself.",
      "properties": {
        "addresses": {
          "$ref": "#/$defs/addresses",
          "description": "The address scheme every path in this graph was made by."
        },
        "contract": {
          "description": "The SHA-256 of the model's own shape: the kinds, the roads with their bound, claim, grain and inverse, the compositions, the kernel's requirements and the vocabularies they are typed by, with every row and assertion outside it. Beside the ground, the pair says whether the model moved or only its contents.",
          "minLength": 1,
          "pattern": "^[0-9a-f]{64}$",
          "type": "string"
        },
        "ground": {
          "description": "The SHA-256 of the ground this graph is a function of: every registry and ledger file's canonical bytes, in path order.",
          "minLength": 1,
          "pattern": "^[0-9a-f]{64}$",
          "type": "string"
        },
        "host": {
          "$ref": "#/$defs/host_declaration",
          "description": "How the host answers."
        },
        "kernel": {
          "$ref": "#/$defs/kernel",
          "description": "What this model must carry, as the build read it; the standards export's shapes are cut from it."
        },
        "modified": {
          "description": "The latest date any content changed.",
          "minLength": 1,
          "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
          "type": "string"
        },
        "names": {
          "description": "Every top-level name the site answers that is not a kind's, derived from what declares it: the frame, a page template's root, a door, a projection, a retired address of the site's own.",
          "items": {
            "minLength": 1,
            "type": "string"
          },
          "minItems": 1,
          "type": "array",
          "uniqueItems": true
        },
        "pages": {
          "additionalProperties": {
            "minLength": 1,
            "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
            "type": "string"
          },
          "description": "The date each index page's content last changed, by page name.",
          "type": "object"
        },
        "proposed": {
          "description": "Pairs of rows a text joins that the registry does not, where their kinds may relate; for the author, asserted by nothing.",
          "items": {
            "$ref": "#/$defs/proposal"
          },
          "type": "array"
        },
        "tagline": {
          "description": "One line on what the model is.",
          "minLength": 1,
          "type": "string"
        },
        "title": {
          "description": "The title every page carries.",
          "minLength": 1,
          "type": "string"
        },
        "views": {
          "$ref": "#/$defs/view_vocabularies",
          "description": "The vocabulary a view is drawn by, so the site names a shape the law's way."
        },
        "vocabularies": {
          "$ref": "#/$defs/law_vocabularies",
          "description": "The law's free-standing vocabularies, by name."
        }
      },
      "required": [
        "title",
        "tagline",
        "pages",
        "modified",
        "ground",
        "contract",
        "addresses",
        "names",
        "host",
        "kernel",
        "views",
        "vocabularies",
        "proposed"
      ],
      "type": "object"
    },
    "metric_derivation": {
      "$comment": "Field order is the declared order; python scripts/build_from_ground.py --format writes it.",
      "additionalProperties": false,
      "description": "How a metric is derived: the specifications that compose it, read its inputs, and bind it to a formula.",
      "properties": {
        "component_relationships": {
          "description": "Specifications that compose a metric from metrics.",
          "items": {
            "minLength": 1,
            "type": "string"
          },
          "type": "array"
        },
        "direct_input_relationships": {
          "description": "Specifications that read a metric's inputs directly.",
          "items": {
            "minLength": 1,
            "type": "string"
          },
          "type": "array"
        },
        "formula_input_relationship": {
          "description": "The specification by which a formula takes an input.",
          "minLength": 1,
          "type": "string"
        },
        "formula_relationship": {
          "description": "The specification by which a metric computes from a formula.",
          "minLength": 1,
          "type": "string"
        }
      },
      "required": [
        "component_relationships",
        "direct_input_relationships",
        "formula_relationship",
        "formula_input_relationship"
      ],
      "type": "object"
    },
    "mode_value": {
      "$comment": "Field order is the declared order; python scripts/build_from_ground.py --format writes it.",
      "additionalProperties": false,
      "description": "One way a page is read: what it shows, how the control names it, and what its surface never says.",
      "properties": {
        "about": {
          "description": "What this mode shows.",
          "minLength": 1,
          "type": "string"
        },
        "default": {
          "description": "Whether a reader who has chosen nothing reads in this mode; exactly one mode is the default.",
          "type": "boolean"
        },
        "drawn_by": {
          "description": "The files under site/src that draw it, each naming this value.",
          "items": {
            "minLength": 1,
            "type": "string"
          },
          "minItems": 1,
          "type": "array"
        },
        "mark": {
          "description": "What the control that chooses this mode says.",
          "minLength": 1,
          "type": "string"
        },
        "never": {
          "description": "Words this mode's surface never says: the model's own words for what the reader meets under the kind's noun.",
          "items": {
            "minLength": 1,
            "type": "string"
          },
          "type": "array",
          "uniqueItems": true
        }
      },
      "required": [
        "about",
        "mark",
        "drawn_by"
      ],
      "type": "object"
    },
    "mode_vocabulary": {
      "$comment": "Field order is the declared order; python scripts/build_from_ground.py --format writes it.",
      "additionalProperties": false,
      "description": "The ways a page is read, and what holds them.",
      "properties": {
        "about": {
          "description": "What this vocabulary governs.",
          "minLength": 1,
          "type": "string"
        },
        "attribute": {
          "description": "The attribute on the document's root that carries the mode the page is shown in.",
          "minLength": 1,
          "pattern": "^data-[a-z-]+$",
          "type": "string"
        },
        "enforced_by": {
          "description": "The gate that holds this vocabulary: a check, a ring or an eval the law catalogs.",
          "minLength": 1,
          "pattern": "^(FND-\\d{3}|ring:\\d|eval:[a-z-]+)$",
          "type": "string"
        },
        "key": {
          "description": "The key the reader's choice is kept under in the browser.",
          "minLength": 1,
          "pattern": "^[a-z.]+$",
          "type": "string"
        },
        "values": {
          "additionalProperties": {
            "$ref": "#/$defs/mode_value"
          },
          "description": "Each mode, by name.",
          "type": "object"
        }
      },
      "required": [
        "about",
        "enforced_by",
        "attribute",
        "key",
        "values"
      ],
      "type": "object"
    },
    "naming": {
      "$comment": "Field order is the declared order; python scripts/build_from_ground.py --format writes it.",
      "additionalProperties": false,
      "description": "One text that names this thing: whose, where, and in which field.",
      "properties": {
        "in": {
          "description": "The field the text is.",
          "minLength": 1,
          "type": "string"
        },
        "label": {
          "description": "The label of what carries the text.",
          "minLength": 1,
          "type": "string"
        },
        "path": {
          "description": "Its page.",
          "minLength": 1,
          "type": "string"
        }
      },
      "required": [
        "label",
        "path",
        "in"
      ],
      "type": "object"
    },
    "node": {
      "$comment": "Field order is the declared order; python scripts/build_from_ground.py --format writes it.",
      "additionalProperties": false,
      "description": "A row as the site reads it.",
      "properties": {
        "also_called": {
          "description": "Other established names.",
          "items": {
            "minLength": 1,
            "type": "string"
          },
          "type": "array"
        },
        "exemplar": {
          "description": "Whether it is the exemplar of its kind.",
          "type": "boolean"
        },
        "id": {
          "description": "The identifier.",
          "minLength": 1,
          "type": "string"
        },
        "kind": {
          "description": "The kind.",
          "minLength": 1,
          "type": "string"
        },
        "label": {
          "description": "The name.",
          "minLength": 1,
          "type": "string"
        },
        "machine": {
          "description": "The row's machine-readable twin, present on rows of the machine kind.",
          "minLength": 1,
          "pattern": "^/([a-z0-9.-]+/)*([a-z0-9.-]+)?(#[a-z0-9-]+)?$",
          "type": "string"
        },
        "mentions": {
          "description": "The governed things its texts name, resolved; absent where none.",
          "items": {
            "$ref": "#/$defs/mention"
          },
          "type": "array"
        },
        "modified": {
          "description": "When its page's content last changed.",
          "minLength": 1,
          "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
          "type": "string"
        },
        "named_in": {
          "description": "The texts that name it; absent where none.",
          "items": {
            "$ref": "#/$defs/naming"
          },
          "type": "array"
        },
        "node_class": {
          "description": "Always row.",
          "enum": [
            "row"
          ],
          "minLength": 1,
          "type": "string"
        },
        "path": {
          "description": "The row's page, made from its kind's and its own label.",
          "minLength": 1,
          "pattern": "^/([a-z0-9.-]+/)*([a-z0-9.-]+)?(#[a-z0-9-]+)?$",
          "type": "string"
        },
        "properties": {
          "additionalProperties": {
            "minLength": 1,
            "type": "string"
          },
          "description": "What the page shows beside the label, by heading.",
          "type": "object"
        },
        "reaches": {
          "anyOf": [
            {
              "minLength": 1,
              "type": "string"
            },
            {
              "type": "null"
            }
          ],
          "description": "The Entities row it is about."
        },
        "was": {
          "description": "Former labels; each made an address the site once answered to.",
          "items": {
            "minLength": 1,
            "type": "string"
          },
          "type": "array"
        }
      },
      "required": [
        "id",
        "node_class",
        "kind",
        "label",
        "properties",
        "reaches",
        "exemplar",
        "modified",
        "path"
      ],
      "type": "object"
    },
    "node_kind": {
      "$comment": "Field order is the declared order; python scripts/build_from_ground.py --format writes it.",
      "additionalProperties": false,
      "description": "A kind as the site reads it.",
      "properties": {
        "band": {
          "description": "The band it sits in.",
          "minLength": 1,
          "type": "string"
        },
        "definition": {
          "description": "What one row is.",
          "minLength": 1,
          "type": "string"
        },
        "evidence": {
          "description": "The evidence class, for a reader.",
          "minLength": 1,
          "type": "string"
        },
        "evidence_class": {
          "description": "What admits a row.",
          "minLength": 1,
          "type": "string"
        },
        "exemplars": {
          "description": "How many of them are exemplars.",
          "type": "integer"
        },
        "identity_rule": {
          "anyOf": [
            {
              "minLength": 1,
              "type": "string"
            },
            {
              "type": "null"
            }
          ],
          "description": "How a source-backed row is named."
        },
        "instance_policy": {
          "anyOf": [
            {
              "minLength": 1,
              "type": "string"
            },
            {
              "type": "null"
            }
          ],
          "description": "How records are admitted, where the kind is source-backed."
        },
        "kind": {
          "description": "The kind's name.",
          "minLength": 1,
          "type": "string"
        },
        "many": {
          "description": "The noun for several.",
          "minLength": 1,
          "type": "string"
        },
        "mentions": {
          "description": "The governed things its texts name, resolved; absent where none.",
          "items": {
            "$ref": "#/$defs/mention"
          },
          "type": "array"
        },
        "modified": {
          "description": "When its page's content last changed.",
          "minLength": 1,
          "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
          "type": "string"
        },
        "named_in": {
          "description": "The texts that name it; absent where none.",
          "items": {
            "$ref": "#/$defs/naming"
          },
          "type": "array"
        },
        "one": {
          "description": "The noun for one of its rows.",
          "minLength": 1,
          "type": "string"
        },
        "path": {
          "description": "The kind's page.",
          "minLength": 1,
          "pattern": "^/([a-z0-9.-]+/)*([a-z0-9.-]+)?(#[a-z0-9-]+)?$",
          "type": "string"
        },
        "practice": {
          "description": "What one is used for and how it shows up in the work; absent where not yet authored.",
          "minLength": 1,
          "type": "string"
        },
        "prefix": {
          "description": "Its identifier prefix.",
          "minLength": 1,
          "type": "string"
        },
        "rows": {
          "description": "How many rows it holds.",
          "type": "integer"
        },
        "rule_ids": {
          "description": "The commitments that license it.",
          "items": {
            "minLength": 1,
            "type": "string"
          },
          "type": "array"
        },
        "shape": {
          "description": "Registry or Vocabulary.",
          "minLength": 1,
          "type": "string"
        },
        "story": {
          "description": "Where it came from and how it fits; absent where not yet authored.",
          "minLength": 1,
          "type": "string"
        }
      },
      "required": [
        "kind",
        "one",
        "many",
        "prefix",
        "shape",
        "band",
        "rows",
        "exemplars",
        "definition",
        "instance_policy",
        "identity_rule",
        "evidence_class",
        "evidence",
        "rule_ids",
        "modified",
        "path"
      ],
      "type": "object"
    },
    "operation_value": {
      "$comment": "Field order is the declared order; python scripts/build_from_ground.py --format writes it.",
      "additionalProperties": false,
      "description": "One operation: what it takes, what it gives, what it reads, and what serves it.",
      "properties": {
        "about": {
          "description": "What this operation does.",
          "minLength": 1,
          "type": "string"
        },
        "gives": {
          "description": "What it produces.",
          "minLength": 1,
          "type": "string"
        },
        "key": {
          "description": "The browser key a value this operation holds is kept under, where it keeps one.",
          "minLength": 1,
          "type": "string"
        },
        "reads": {
          "description": "The published addresses it needs; each is one the law reserves.",
          "items": {
            "minLength": 1,
            "type": "string"
          },
          "type": "array"
        },
        "served_by": {
          "description": "The files that implement it, under site/src, scripts or the standards export, each naming this operation.",
          "items": {
            "minLength": 1,
            "type": "string"
          },
          "minItems": 1,
          "type": "array"
        },
        "takes": {
          "description": "Its inputs, in the reader's words.",
          "items": {
            "minLength": 1,
            "type": "string"
          },
          "type": "array"
        }
      },
      "required": [
        "about",
        "takes",
        "gives",
        "reads",
        "served_by"
      ],
      "type": "object"
    },
    "operation_vocabulary": {
      "$comment": "Field order is the declared order; python scripts/build_from_ground.py --format writes it.",
      "additionalProperties": false,
      "description": "The operations anything may perform with the published parts, and what holds them.",
      "properties": {
        "about": {
          "description": "What this vocabulary governs.",
          "minLength": 1,
          "type": "string"
        },
        "enforced_by": {
          "description": "The gate that holds this vocabulary: a check, a ring or an eval the law catalogs.",
          "minLength": 1,
          "pattern": "^(FND-\\d{3}|ring:\\d|eval:[a-z-]+)$",
          "type": "string"
        },
        "values": {
          "additionalProperties": {
            "$ref": "#/$defs/operation_value"
          },
          "description": "Each operation, by name.",
          "type": "object"
        }
      },
      "required": [
        "about",
        "enforced_by",
        "values"
      ],
      "type": "object"
    },
    "pattern_answer": {
      "$comment": "Field order is the declared order; python scripts/build_from_ground.py --format writes it.",
      "additionalProperties": false,
      "description": "One row a question is answered from, and every whole binding the walk makes from it.",
      "properties": {
        "bindings": {
          "description": "Every complete binding, each a row per role in the question's reading order.",
          "items": {
            "items": {
              "minLength": 1,
              "type": "string"
            },
            "type": "array"
          },
          "minItems": 1,
          "type": "array"
        },
        "label": {
          "description": "That row's label.",
          "minLength": 1,
          "type": "string"
        },
        "modified": {
          "description": "When its content last changed.",
          "minLength": 1,
          "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
          "type": "string"
        },
        "path": {
          "description": "Where the answer is published.",
          "minLength": 1,
          "pattern": "^/",
          "type": "string"
        },
        "row": {
          "description": "The row the question is asked from.",
          "minLength": 1,
          "type": "string"
        }
      },
      "required": [
        "row",
        "label",
        "path",
        "modified",
        "bindings"
      ],
      "type": "object"
    },
    "pattern_binding": {
      "$comment": "Field order is the declared order; python scripts/build_from_ground.py --format writes it.",
      "additionalProperties": false,
      "description": "One pattern of a view, bound from one row: every complete binding it found.",
      "properties": {
        "bindings": {
          "description": "Every complete binding, each a row per role in the pattern's reading order.",
          "items": {
            "items": {
              "minLength": 1,
              "type": "string"
            },
            "type": "array"
          },
          "minItems": 1,
          "type": "array"
        },
        "pattern": {
          "description": "The pattern bound.",
          "minLength": 1,
          "pattern": "^PTN-\\d{3}$",
          "type": "string"
        }
      },
      "required": [
        "pattern",
        "bindings"
      ],
      "type": "object"
    },
    "pattern_kind_value": {
      "$comment": "Field order is the declared order; python scripts/build_from_ground.py --format writes it.",
      "additionalProperties": false,
      "description": "One kind of pattern, the structural condition that selects it, and what draws it.",
      "properties": {
        "about": {
          "description": "What this kind of pattern is.",
          "minLength": 1,
          "type": "string"
        },
        "drawn_by": {
          "description": "The files under site/src that draw it, each naming this value.",
          "items": {
            "minLength": 1,
            "type": "string"
          },
          "minItems": 1,
          "type": "array"
        },
        "line": {
          "description": "Whether the roles fall in one line from a root. The build proves the declared kind against this.",
          "type": "boolean"
        }
      },
      "required": [
        "about",
        "line",
        "drawn_by"
      ],
      "type": "object"
    },
    "pattern_kind_vocabulary": {
      "$comment": "Field order is the declared order; python scripts/build_from_ground.py --format writes it.",
      "additionalProperties": false,
      "description": "The kinds a pattern may be, and what holds them.",
      "properties": {
        "about": {
          "description": "What this vocabulary governs.",
          "minLength": 1,
          "type": "string"
        },
        "enforced_by": {
          "description": "The gate that holds this vocabulary: a check, a ring or an eval the law catalogs.",
          "minLength": 1,
          "pattern": "^(FND-\\d{3}|ring:\\d|eval:[a-z-]+)$",
          "type": "string"
        },
        "values": {
          "additionalProperties": {
            "$ref": "#/$defs/pattern_kind_value"
          },
          "description": "Each kind, by name.",
          "type": "object"
        }
      },
      "required": [
        "about",
        "enforced_by",
        "values"
      ],
      "type": "object"
    },
    "plain_vocabulary": {
      "$comment": "Field order is the declared order; python scripts/build_from_ground.py --format writes it.",
      "additionalProperties": false,
      "description": "A governed vocabulary whose values need nothing but a meaning each.",
      "properties": {
        "about": {
          "description": "What this vocabulary governs.",
          "minLength": 1,
          "type": "string"
        },
        "enforced_by": {
          "description": "The gate that holds this vocabulary: a check, a ring or an eval the law catalogs.",
          "minLength": 1,
          "pattern": "^(FND-\\d{3}|ring:\\d|eval:[a-z-]+)$",
          "type": "string"
        },
        "values": {
          "additionalProperties": {
            "minLength": 1,
            "type": "string"
          },
          "description": "Each value, and what it means.",
          "type": "object"
        }
      },
      "required": [
        "about",
        "enforced_by",
        "values"
      ],
      "type": "object"
    },
    "projection_value": {
      "$comment": "Field order is the declared order; python scripts/build_from_ground.py --format writes it.",
      "additionalProperties": false,
      "description": "One projection: what it is, where it answers, and what draws or serves it; a file says what it is cut from.",
      "properties": {
        "about": {
          "description": "What this projection is.",
          "minLength": 1,
          "type": "string"
        },
        "at": {
          "description": "The address: a path template for a page type, or a file's path. A page ends in a slash and a file names itself; {slug} is the label's slug, {kind} the kind's, {id} an identifier in lower case, {verb} a verb's slug, {view} a view's slug, {deliverable} a deliverable's, {page} a page's own path, {type} a sitemap child's page type.",
          "minLength": 1,
          "pattern": "^(/|\\{page\\})[A-Za-z0-9/._{}#-]+$",
          "type": "string"
        },
        "cut_from": {
          "description": "The artifact's root fields it is cut from; absent where it is cut from the law or the site's own declarations rather than the graph.",
          "items": {
            "minLength": 1,
            "type": "string"
          },
          "minItems": 1,
          "type": "array",
          "uniqueItems": true
        },
        "drawn_by": {
          "description": "For a page: the routes that draw it, as paths from the repository root, each naming this projection.",
          "items": {
            "minLength": 1,
            "type": "string"
          },
          "minItems": 1,
          "type": "array"
        },
        "label": {
          "description": "What a reader is told the file is, in the reader’s words, where the file is offered to a reader; a projection drawn as a page carries none.",
          "minLength": 1,
          "type": "string"
        },
        "served_by": {
          "description": "For a file: the files that serve it, as paths from the repository root, each naming this projection.",
          "items": {
            "minLength": 1,
            "type": "string"
          },
          "minItems": 1,
          "type": "array"
        }
      },
      "required": [
        "about",
        "at"
      ],
      "type": "object"
    },
    "projection_vocabulary": {
      "$comment": "Field order is the declared order; python scripts/build_from_ground.py --format writes it.",
      "additionalProperties": false,
      "description": "The files the host serves for a machine to read, and what holds them.",
      "properties": {
        "about": {
          "description": "What this vocabulary governs.",
          "minLength": 1,
          "type": "string"
        },
        "enforced_by": {
          "description": "The gate that holds this vocabulary: a check, a ring or an eval the law catalogs.",
          "minLength": 1,
          "pattern": "^(FND-\\d{3}|ring:\\d|eval:[a-z-]+)$",
          "type": "string"
        },
        "values": {
          "additionalProperties": {
            "$ref": "#/$defs/projection_value"
          },
          "description": "Each projection, by name.",
          "type": "object"
        }
      },
      "required": [
        "about",
        "enforced_by",
        "values"
      ],
      "type": "object"
    },
    "proposal": {
      "$comment": "Field order is the declared order; python scripts/build_from_ground.py --format writes it.",
      "additionalProperties": false,
      "description": "Two rows a text joins that the registry does not, where their kinds may relate: named for the author, asserted by nothing.",
      "properties": {
        "from": {
          "description": "The row whose text names the other.",
          "minLength": 1,
          "type": "string"
        },
        "in": {
          "description": "The field the text is.",
          "minLength": 1,
          "type": "string"
        },
        "to": {
          "description": "The row named.",
          "minLength": 1,
          "type": "string"
        },
        "verb": {
          "description": "A relationship their kinds may stand in.",
          "minLength": 1,
          "type": "string"
        }
      },
      "required": [
        "from",
        "to",
        "verb",
        "in"
      ],
      "type": "object"
    },
    "prose_value": {
      "$comment": "Field order is the declared order; python scripts/build_from_ground.py --format writes it.",
      "additionalProperties": false,
      "description": "One text a kind may carry: the question it answers, the mode it is read in, and either the span it is authored within or what it is derived from.",
      "properties": {
        "about": {
          "description": "What the text says.",
          "minLength": 1,
          "type": "string"
        },
        "asks": {
          "description": "The question a reader brings that this text answers.",
          "minLength": 1,
          "type": "string"
        },
        "derived_from": {
          "description": "What the build derives the text from, where it is never authored: the commitments that license the kind, or the kernel.",
          "minLength": 1,
          "pattern": "^(commitments|kernel)$",
          "type": "string"
        },
        "drawn_by": {
          "description": "The files under site/src that draw it, each naming this value.",
          "items": {
            "minLength": 1,
            "type": "string"
          },
          "minItems": 1,
          "type": "array"
        },
        "mode": {
          "description": "The mode this text is drawn in.",
          "enum": [
            "read",
            "build"
          ],
          "minLength": 1,
          "type": "string"
        },
        "sentences": {
          "$ref": "#/$defs/bound",
          "description": "The span of sentences an authored text is held within; absent on a derived text."
        },
        "skos": {
          "description": "The SKOS documentation property the standards export carries this text under.",
          "minLength": 1,
          "pattern": "^skos:(definition|scopeNote|historyNote|editorialNote|changeNote|example|note)$",
          "type": "string"
        }
      },
      "required": [
        "about",
        "asks",
        "mode",
        "drawn_by"
      ],
      "type": "object"
    },
    "prose_vocabulary": {
      "$comment": "Field order is the declared order; python scripts/build_from_ground.py --format writes it.",
      "additionalProperties": false,
      "description": "The texts a kind carries, and what holds them.",
      "properties": {
        "about": {
          "description": "What this vocabulary governs.",
          "minLength": 1,
          "type": "string"
        },
        "enforced_by": {
          "description": "The gate that holds this vocabulary: a check, a ring or an eval the law catalogs.",
          "minLength": 1,
          "pattern": "^(FND-\\d{3}|ring:\\d|eval:[a-z-]+)$",
          "type": "string"
        },
        "values": {
          "additionalProperties": {
            "$ref": "#/$defs/prose_value"
          },
          "description": "Each text, by name.",
          "type": "object"
        }
      },
      "required": [
        "about",
        "enforced_by",
        "values"
      ],
      "type": "object"
    },
    "redirect": {
      "$comment": "Field order is the declared order; python scripts/build_from_ground.py --format writes it.",
      "additionalProperties": false,
      "description": "An address the site once answered to, and what it says now: moved, to the row's present address, or gone, for a retired identifier.",
      "properties": {
        "because": {
          "description": "Why it went.",
          "minLength": 1,
          "type": "string"
        },
        "from": {
          "description": "The former address.",
          "minLength": 1,
          "pattern": "^/",
          "type": "string"
        },
        "id": {
          "description": "The row that moved, or the identifier that was retired; absent where the address was the site's own and no row's.",
          "minLength": 1,
          "type": "string"
        },
        "on": {
          "description": "The day a retired identifier went.",
          "minLength": 1,
          "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
          "type": "string"
        },
        "status": {
          "description": "moved or gone.",
          "enum": [
            "moved",
            "gone"
          ],
          "minLength": 1,
          "type": "string"
        },
        "to": {
          "description": "Where a moved address goes: the row's present address.",
          "minLength": 1,
          "pattern": "^/",
          "type": "string"
        }
      },
      "required": [
        "from",
        "status"
      ],
      "type": "object"
    },
    "redirect_status_value": {
      "$comment": "Field order is the declared order; python scripts/build_from_ground.py --format writes it.",
      "additionalProperties": false,
      "description": "One thing a former address may say now, and the status it answers with.",
      "properties": {
        "about": {
          "description": "What this status means.",
          "minLength": 1,
          "type": "string"
        },
        "http": {
          "description": "The HTTP status the host answers with.",
          "type": "integer"
        }
      },
      "required": [
        "about",
        "http"
      ],
      "type": "object"
    },
    "redirect_status_vocabulary": {
      "$comment": "Field order is the declared order; python scripts/build_from_ground.py --format writes it.",
      "additionalProperties": false,
      "description": "The statuses a former address may have, and what holds them.",
      "properties": {
        "about": {
          "description": "What this vocabulary governs.",
          "minLength": 1,
          "type": "string"
        },
        "enforced_by": {
          "description": "The gate that holds this vocabulary: a check, a ring or an eval the law catalogs.",
          "minLength": 1,
          "pattern": "^(FND-\\d{3}|ring:\\d|eval:[a-z-]+)$",
          "type": "string"
        },
        "values": {
          "additionalProperties": {
            "$ref": "#/$defs/redirect_status_value"
          },
          "description": "Each status, by name.",
          "type": "object"
        }
      },
      "required": [
        "about",
        "enforced_by",
        "values"
      ],
      "type": "object"
    },
    "reference_value": {
      "$comment": "Field order is the declared order; python scripts/build_from_ground.py --format writes it.",
      "additionalProperties": false,
      "description": "One kind of thing a reference may name, and the registry it resolves in.",
      "properties": {
        "about": {
          "description": "What is named, and by what.",
          "minLength": 1,
          "type": "string"
        },
        "resolves": {
          "description": "The registry the target is found in.",
          "minLength": 1,
          "pattern": "^(kinds|rows|rules|sources|patterns|views)$",
          "type": "string"
        }
      },
      "required": [
        "about",
        "resolves"
      ],
      "type": "object"
    },
    "reference_vocabulary": {
      "$comment": "Field order is the declared order; python scripts/build_from_ground.py --format writes it.",
      "additionalProperties": false,
      "description": "How prose names a governed thing, what a reference may name, and where references are read.",
      "properties": {
        "about": {
          "description": "What this vocabulary governs.",
          "minLength": 1,
          "type": "string"
        },
        "enforced_by": {
          "description": "The gate that holds this vocabulary: a check, a ring or an eval the law catalogs.",
          "minLength": 1,
          "pattern": "^(FND-\\d{3}|ring:\\d|eval:[a-z-]+)$",
          "type": "string"
        },
        "in": {
          "description": "The texts references are read from, each as `type.field`: a type the schema or the ledger declares and a string field of it.",
          "items": {
            "minLength": 1,
            "type": "string"
          },
          "minItems": 1,
          "type": "array",
          "uniqueItems": true
        },
        "pattern": {
          "description": "The form of a reference in prose, as a regular expression whose first group is the target and whose second, where present, is what to show.",
          "minLength": 1,
          "type": "string"
        },
        "values": {
          "additionalProperties": {
            "$ref": "#/$defs/reference_value"
          },
          "description": "What a reference may name, by kind of target.",
          "type": "object"
        }
      },
      "required": [
        "about",
        "enforced_by",
        "pattern",
        "in",
        "values"
      ],
      "type": "object"
    },
    "relation": {
      "$comment": "Field order is the declared order; python scripts/build_from_ground.py --format writes it.",
      "additionalProperties": false,
      "description": "A verb folded across the kinds that speak it.",
      "properties": {
        "cardinality": {
          "description": "The bounds it takes.",
          "items": {
            "minLength": 1,
            "type": "string"
          },
          "type": "array"
        },
        "claims": {
          "description": "The claim it makes.",
          "items": {
            "minLength": 1,
            "type": "string"
          },
          "type": "array"
        },
        "columns": {
          "description": "The specifications that speak it.",
          "items": {
            "minLength": 1,
            "type": "string"
          },
          "type": "array"
        },
        "from_kinds": {
          "description": "The kinds it is from.",
          "items": {
            "minLength": 1,
            "type": "string"
          },
          "type": "array"
        },
        "inverses": {
          "description": "Its reverse readings.",
          "items": {
            "minLength": 1,
            "type": "string"
          },
          "type": "array"
        },
        "path": {
          "description": "The verb's anchor on the relationships page.",
          "minLength": 1,
          "pattern": "^/([a-z0-9.-]+/)*([a-z0-9.-]+)?(#[a-z0-9-]+)?$",
          "type": "string"
        },
        "relation_kinds": {
          "description": "The relation kinds it takes.",
          "items": {
            "minLength": 1,
            "type": "string"
          },
          "type": "array"
        },
        "rule_ids": {
          "description": "The commitments that license it.",
          "items": {
            "minLength": 1,
            "type": "string"
          },
          "type": "array"
        },
        "terminal": {
          "description": "Whether any of its specifications is terminal.",
          "type": "boolean"
        },
        "to_kinds": {
          "description": "The kinds it reaches.",
          "items": {
            "minLength": 1,
            "type": "string"
          },
          "type": "array"
        },
        "verb": {
          "description": "The verb.",
          "minLength": 1,
          "type": "string"
        }
      },
      "required": [
        "verb",
        "columns",
        "from_kinds",
        "to_kinds",
        "relation_kinds",
        "cardinality",
        "claims",
        "inverses",
        "rule_ids",
        "terminal",
        "path"
      ],
      "type": "object"
    },
    "relation_kind_value": {
      "$comment": "Field order is the declared order; python scripts/build_from_ground.py --format writes it.",
      "additionalProperties": false,
      "description": "One kind of relationship, and whether it is a road.",
      "properties": {
        "about": {
          "description": "What this kind of relationship asserts.",
          "minLength": 1,
          "type": "string"
        },
        "road": {
          "description": "Whether a reader or the map may follow it from row to row. A classification is not a step.",
          "type": "boolean"
        }
      },
      "required": [
        "about",
        "road"
      ],
      "type": "object"
    },
    "relation_kind_vocabulary": {
      "$comment": "Field order is the declared order; python scripts/build_from_ground.py --format writes it.",
      "additionalProperties": false,
      "description": "The kinds a relationship may be, and what holds them.",
      "properties": {
        "about": {
          "description": "What this vocabulary governs.",
          "minLength": 1,
          "type": "string"
        },
        "enforced_by": {
          "description": "The gate that holds this vocabulary: a check, a ring or an eval the law catalogs.",
          "minLength": 1,
          "pattern": "^(FND-\\d{3}|ring:\\d|eval:[a-z-]+)$",
          "type": "string"
        },
        "values": {
          "additionalProperties": {
            "$ref": "#/$defs/relation_kind_value"
          },
          "description": "Each kind of relationship, by name.",
          "type": "object"
        }
      },
      "required": [
        "about",
        "enforced_by",
        "values"
      ],
      "type": "object"
    },
    "render_value": {
      "$comment": "Field order is the declared order; python scripts/build_from_ground.py --format writes it.",
      "additionalProperties": false,
      "description": "One way a view may be drawn, and what draws it.",
      "properties": {
        "about": {
          "description": "What this way of drawing shows.",
          "minLength": 1,
          "type": "string"
        },
        "drawn_by": {
          "description": "The files under site/src that draw it, each naming this value.",
          "items": {
            "minLength": 1,
            "type": "string"
          },
          "minItems": 1,
          "type": "array"
        },
        "mark": {
          "description": "The glyph a pill of the map's layer carries for a view drawn this way.",
          "minLength": 1,
          "type": "string"
        }
      },
      "required": [
        "about",
        "drawn_by"
      ],
      "type": "object"
    },
    "render_vocabulary": {
      "$comment": "Field order is the declared order; python scripts/build_from_ground.py --format writes it.",
      "additionalProperties": false,
      "description": "The ways a view may be drawn, and what holds them.",
      "properties": {
        "about": {
          "description": "What this vocabulary governs.",
          "minLength": 1,
          "type": "string"
        },
        "enforced_by": {
          "description": "The gate that holds this vocabulary: a check, a ring or an eval the law catalogs.",
          "minLength": 1,
          "pattern": "^(FND-\\d{3}|ring:\\d|eval:[a-z-]+)$",
          "type": "string"
        },
        "values": {
          "additionalProperties": {
            "$ref": "#/$defs/render_value"
          },
          "description": "Each way of drawing, by name.",
          "type": "object"
        }
      },
      "required": [
        "about",
        "enforced_by",
        "values"
      ],
      "type": "object"
    },
    "report": {
      "$comment": "Field order is the declared order; python scripts/build_from_ground.py --format writes it.",
      "additionalProperties": false,
      "description": "What the build verified, against which ground.",
      "properties": {
        "checks_run": {
          "description": "How many checks by name.",
          "type": "integer"
        },
        "conforms": {
          "description": "Whether every check passed; a graph is only written when it did.",
          "type": "boolean"
        },
        "ground": {
          "description": "The digest of the ground the checks ran against.",
          "minLength": 1,
          "pattern": "^[0-9a-f]{64}$",
          "type": "string"
        }
      },
      "required": [
        "conforms",
        "checks_run",
        "ground"
      ],
      "type": "object"
    },
    "resolution_declaration": {
      "$comment": "Field order is the declared order; python scripts/build_from_ground.py --format writes it.",
      "additionalProperties": false,
      "description": "How far a person is resolved: the kind of identity levels, the road on which the instrumenting kind declares its level, and the level at which nobody is told apart.",
      "properties": {
        "kind": {
          "description": "The kind whose rows are the identity levels.",
          "minLength": 1,
          "type": "string"
        },
        "relationship": {
          "description": "The specification on which an instrument declares the level it identifies a person at.",
          "minLength": 1,
          "type": "string"
        },
        "unresolved": {
          "description": "The row of the kind at which one person cannot be told from another; a move may not rest on evidence observed only there.",
          "minLength": 1,
          "pattern": "^[A-Z][A-Z0-9]*-\\d{3}$",
          "type": "string"
        }
      },
      "required": [
        "kind",
        "relationship",
        "unresolved"
      ],
      "type": "object"
    },
    "retired_vocabulary": {
      "$comment": "Field order is the declared order; python scripts/build_from_ground.py --format writes it.",
      "additionalProperties": false,
      "description": "The words this model has retired. A rename that leaves the old word in the prose leaves two names for one thing; the prose ring holds every authored file to this list, the site's own copy included, and this file may write a retired word because the reader lifts this section out before reading the rest.",
      "properties": {
        "about": {
          "description": "Why the list exists and what is held to it.",
          "minLength": 1,
          "type": "string"
        },
        "enforced_by": {
          "description": "The gate that holds this vocabulary: a check, a ring or an eval the law catalogs.",
          "minLength": 1,
          "pattern": "^(FND-\\d{3}|ring:\\d|eval:[a-z-]+)$",
          "type": "string"
        },
        "values": {
          "additionalProperties": {
            "minLength": 1,
            "type": "string"
          },
          "description": "Each retired word, and what to say instead.",
          "type": "object"
        }
      },
      "required": [
        "about",
        "enforced_by",
        "values"
      ],
      "type": "object"
    },
    "ring": {
      "$comment": "Field order is the declared order; python scripts/build_from_ground.py --format writes it.",
      "additionalProperties": false,
      "description": "One ring of the gate chain, in order.",
      "properties": {
        "holds": {
          "description": "What must be true for the ring to pass.",
          "minLength": 1,
          "type": "string"
        },
        "id": {
          "description": "ring and a number, in running order.",
          "minLength": 1,
          "pattern": "^ring:\\d$",
          "type": "string"
        },
        "label": {
          "description": "One word for what it holds.",
          "minLength": 1,
          "type": "string"
        },
        "run_by": {
          "description": "What runs it.",
          "minLength": 1,
          "type": "string"
        },
        "unclaimed": {
          "description": "Why no commitment here claims it; only a ring nothing in this repository runs.",
          "minLength": 1,
          "type": "string"
        }
      },
      "required": [
        "id",
        "label",
        "holds",
        "run_by"
      ],
      "type": "object"
    },
    "settings_declaration": {
      "$comment": "Field order is the declared order; python scripts/build_from_ground.py --format writes it.",
      "additionalProperties": false,
      "description": "What a reader may set: the kind whose rows are the parameters, the road on which a parameter declares its unit, the kind whose rows are the bases a value may rest on and the road a parameter declares its default basis on, and the record shape a set value takes.",
      "properties": {
        "basis_kind": {
          "description": "The kind whose rows are the bases a value may rest on.",
          "minLength": 1,
          "type": "string"
        },
        "basis_relationship": {
          "description": "The specification on which a parameter declares the basis its default rests on.",
          "minLength": 1,
          "type": "string"
        },
        "kind": {
          "description": "The kind whose rows are the parameters.",
          "minLength": 1,
          "type": "string"
        },
        "shape": {
          "description": "The record shape a set value takes, by pattern id.",
          "minLength": 1,
          "pattern": "^PTN-\\d{3}$",
          "type": "string"
        },
        "unit_relationship": {
          "description": "The specification on which a parameter declares the unit it is measured in.",
          "minLength": 1,
          "type": "string"
        }
      },
      "required": [
        "kind",
        "unit_relationship",
        "basis_kind",
        "basis_relationship",
        "shape"
      ],
      "type": "object"
    },
    "spine": {
      "$comment": "Field order is the declared order; python scripts/build_from_ground.py --format writes it.",
      "additionalProperties": false,
      "description": "A participation every row of a kind must state, or one of, or be reached by.",
      "properties": {
        "all_of": {
          "description": "Verbs every row states.",
          "items": {
            "minLength": 1,
            "type": "string"
          },
          "type": "array"
        },
        "inbound_all_of": {
          "description": "Verbs by which every row is reached.",
          "items": {
            "minLength": 1,
            "type": "string"
          },
          "type": "array"
        },
        "kind": {
          "description": "The kind whose rows carry the spine.",
          "minLength": 1,
          "type": "string"
        },
        "one_of": {
          "description": "Verbs of which every row states at least one.",
          "items": {
            "minLength": 1,
            "type": "string"
          },
          "type": "array"
        },
        "or_field": {
          "description": "A field whose presence stands in for the one_of verbs.",
          "minLength": 1,
          "type": "string"
        },
        "why": {
          "description": "What the spine keeps true.",
          "minLength": 1,
          "type": "string"
        }
      },
      "required": [
        "kind",
        "why"
      ],
      "type": "object"
    },
    "status_value": {
      "$comment": "Field order is the declared order; python scripts/build_from_ground.py --format writes it.",
      "additionalProperties": false,
      "description": "One standing a commitment may have, and the register it is drawn in.",
      "properties": {
        "about": {
          "description": "What this standing means.",
          "minLength": 1,
          "type": "string"
        },
        "register": {
          "description": "The register the surface draws it in.",
          "enum": [
            "world",
            "gov",
            "owed"
          ],
          "minLength": 1,
          "type": "string"
        }
      },
      "required": [
        "about",
        "register"
      ],
      "type": "object"
    },
    "status_vocabulary": {
      "$comment": "Field order is the declared order; python scripts/build_from_ground.py --format writes it.",
      "additionalProperties": false,
      "description": "The standings a commitment may have, and what holds them.",
      "properties": {
        "about": {
          "description": "What this vocabulary governs.",
          "minLength": 1,
          "type": "string"
        },
        "enforced_by": {
          "description": "The gate that holds this vocabulary: a check, a ring or an eval the law catalogs.",
          "minLength": 1,
          "pattern": "^(FND-\\d{3}|ring:\\d|eval:[a-z-]+)$",
          "type": "string"
        },
        "values": {
          "additionalProperties": {
            "$ref": "#/$defs/status_value"
          },
          "description": "Each standing, by name.",
          "type": "object"
        }
      },
      "required": [
        "about",
        "enforced_by",
        "values"
      ],
      "type": "object"
    },
    "view_binding": {
      "$comment": "Field order is the declared order; python scripts/build_from_ground.py --format writes it.",
      "additionalProperties": false,
      "description": "One row of a view's starting kind, and the view's patterns bound from it.",
      "properties": {
        "bound": {
          "description": "Every pattern of the view that bound from this row, in the order declared.",
          "items": {
            "$ref": "#/$defs/pattern_binding"
          },
          "minItems": 1,
          "type": "array"
        },
        "label": {
          "description": "That row's label.",
          "minLength": 1,
          "type": "string"
        },
        "modified": {
          "description": "When its content last changed.",
          "minLength": 1,
          "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
          "type": "string"
        },
        "path": {
          "description": "Where the answer is published.",
          "minLength": 1,
          "pattern": "^/",
          "type": "string"
        },
        "row": {
          "description": "The row the job is answered from.",
          "minLength": 1,
          "type": "string"
        }
      },
      "required": [
        "row",
        "label",
        "path",
        "modified",
        "bound"
      ],
      "type": "object"
    },
    "view_vocabularies": {
      "$comment": "Field order is the declared order; python scripts/build_from_ground.py --format writes it.",
      "additionalProperties": false,
      "description": "The two vocabularies a view is read by: how it is drawn, and how one binding of it draws itself.",
      "properties": {
        "about": {
          "description": "What these vocabularies govern, and what they leave to the kernel.",
          "minLength": 1,
          "type": "string"
        },
        "answers": {
          "$ref": "#/$defs/answer_vocabulary",
          "description": "How one bound pattern draws itself."
        },
        "renders": {
          "$ref": "#/$defs/render_vocabulary",
          "description": "How a view may be drawn."
        }
      },
      "required": [
        "about",
        "renders",
        "answers"
      ],
      "type": "object"
    }
  },
  "$id": "urn:umi-graph:schema:graph",
  "$ref": "#/$defs/graph",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "description": "The shape of public/graph.json, the one derived artifact, as the build validates it before writing.",
  "title": "umi-graph graph"
}