@canonical/anatomy-dsl 0.3.0 → 0.5.0

package/README.md

@@ -9,12 +9,11 @@ A YAML-based DSL for representing design system component anatomies — platform
 node:
   uri: global.component.button
   styles:
-    layout.type: flow
-    layout.direction: horizontal
+    layout.type: inline-flex
     layout.align: center
-    spacing.internal: spacing/medium
-    appearance.background: color/surface/button
-    appearance.radius: radius/button
+    spacing.internal.inline.start: spacing.inset.action.inline
+    appearance.background: [modifier.color.foreground.primary, color.foreground.primary]
+    appearance.radius: dimension.radius.medium
   edges:
     - node:
         uri: global.subcomponent.button-icon
@@ -28,7 +27,30 @@ node:
         slotName: default
 ```
 
-Style values are **design token paths** (`spacing/medium`, `color/surface/button`) — forward-slash delimited references resolved at runtime against the active theme. Primitives like `flow` and `center` are used for layout semantics that don't vary across themes.
+Style values are **token symbols**, written in the symbol's own dotted
+spelling: `dimension.radius.medium`, `color.foreground.primary`. A list is
+the **fallback order** — a one-to-one transcription of the implementation's
+own `var()` chain, so `[modifier.color.foreground.primary,
+color.foreground.primary]` says "read the primary-foreground channel, and
+fall back to the primary foreground token", which is what the reference CSS
+does. A **channel** (`modifier.*`, `surface.*`) is a symbol like any other:
+the anatomy consumes it by name where the implementation reads the channel,
+and the semantic token by name where it reads the token — nothing is
+inferred. Primitives like `inline-flex` and `center` are used for layout
+semantics that do not vary across themes, and one may end a list where the
+implementation's chain ends in a literal
+(`[modifier.color.icon, modifier.color.text, currentColor]`).
+
+Keys come from a **closed roster** — `definitions/style-keys.yaml`, from
+which `definitions/registry.ttl` is generated. The roster is measured, not
+designed: its 111 keys are the right-hand column of a table whose left-hand
+column was every CSS property bound on a component selector across 89
+published component stylesheets, so a key exists because an implementation
+binds the property. That measurement lives in `canonical/design-system`,
+where the reference stylesheets are an input; this package reads no CSS and
+holds the roster, with its provenance stated in both files. The
+slash-delimited path and the trailing `?` marker of earlier versions are
+retired — see `docs/api-reference.md` §5, §11 and §12.
 
 ## Projections
 
@@ -138,13 +160,13 @@ usage in anatomies splits into exactly two cases:
 Semantics:
 
 - Pins live on **named nodes only** — anonymous nodes have no prop surface.
-  This is enforced in the types, the parser, the JSON Schema, and SHACL.
+  This is enforced in the types, the parser, and SHACL.
 - The DSL **never defines a prop surface** (names, types, optionality live in
   the design system ontology); it only asserts values. Whether a pinned prop
   exists on the component, and whether a value is admissible (e.g. a glyph
   name in the icon set), are consumer-side checks against the DS graph — the
   same posture as projection checking against the provider SDL.
-- Values are scalars, coerced to strings — no token paths or fallback arrays.
+- Values are scalars, coerced to strings — no symbols and no fallback lists: a pin is a value, not a style.
   Pins are *values with meaning*, not styles: a theme may reskin what
   `chevron-down` looks like (asset layer), but never remap which glyph an
   anatomy means.
@@ -166,10 +188,11 @@ key is the default state:
 styles:
   interaction.cursor: pointer
   interaction.cursor@disabled: not-allowed
-  appearance.background: color/fill/default
-  appearance.background@hover: color/fill/default/hover
-  appearance.background@disabled: color/fill/default/disabled
-  appearance.outline@focus: color/focus-ring   # exists only in a state
+  appearance.background: [modifier.color.foreground.primary, color.foreground.primary]
+  appearance.background@hover: color.foreground.primary.hover
+  appearance.background@disabled: color.foreground.primary.disabled
+  # A slot may read a channel only in one state.
+  appearance.outline.color@focus: [modifier.color.focusRing, color.focusRing, currentColor]
 ```
 
 The state vocabulary is **closed and registry-governed**: `hover`, `active`,
@@ -188,15 +211,16 @@ The boundaries that keep "state machines out of scope" true:
   transitions, triggers, or logic.
 - **Gate vs appearance**: `props: { disabled: true }` (or the consumer) puts
   a node in the disabled state; `…@disabled` styles say how it looks there.
-- The canonical state token is the base token path plus a state leaf segment
-  (`color/fill/default/hover`), matching the token tree. A consumer-side lint
-  checks that a state-leafed token value agrees with its key's `@state`.
+- A state-scoped value that differs from its base state's is a **lint, not a
+  constraint**: it is reported with the ranks at which they differ and never
+  rejected, because the reference does it — Button's `:disabled` reads
+  `color.text.disabled`, a different symbol from its resting `color.text`.
 - The grammar reserves repeatable markers for compound states
   (`@selected@hover`, canonical order: value/control state before user-action
   state); v1 permits a single `@`.
 
 In TTL, the Style tuple gains one optional dimension:
-`[ styleKey "appearance.background" ; styleState "hover" ; styleValue "…" ]`.
+`[ a :Style ; :styleKey "appearance.background" ; :styleState "hover" ; :styleValue "…" ]`.
 See `examples/yaml/stateful-button.anatomy.yaml`.
 
 ## Install
@@ -219,19 +243,19 @@ const ttl = anatomyToTTL(spec);
 The button example above produces:
 
 ```turtle
-@prefix : <http://anatomy-dsl.example.org/ontology#> .
+@prefix : <https://anatomy.canonical.com/> .
+@prefix dt: <https://dt.canonical.com/> .
 
 [] a :Specification ;
     :rootNode [
         a :NamedNode ;
         :uri "global.component.button" ;
         :hasStyle
-            [ :styleKey "layout.type" ; :styleValue "flow" ] ,
-            [ :styleKey "layout.direction" ; :styleValue "horizontal" ] ,
-            [ :styleKey "layout.align" ; :styleValue "center" ] ,
-            [ :styleKey "spacing.internal" ; :styleValue "spacing/medium" ] ,
-            [ :styleKey "appearance.background" ; :styleValue "color/surface/button" ] ,
-            [ :styleKey "appearance.radius" ; :styleValue "radius/button" ] ;
+            [ a :Style ; :styleKey "layout.type" ; :styleValue "inline-flex" ] ,
+            [ a :Style ; :styleKey "layout.align" ; :styleValue "center" ] ,
+            [ a :Style ; :styleKey "spacing.internal.inline.start" ; :styleValue "spacing.inset.action.inline" ; :consumes ( dt:spacing.inset.action.inline ) ] ,
+            [ a :Style ; :styleKey "appearance.background" ; :styleValue "[modifier.color.foreground.primary, color.foreground.primary]" ; :consumes ( dt:modifier.color.foreground.primary dt:color.foreground.primary ) ] ,
+            [ a :Style ; :styleKey "appearance.radius" ; :styleValue "dimension.radius.medium" ; :consumes ( dt:dimension.radius.medium ) ] ;
         :hasEdge [
             a :Edge ;
             :edgeTarget [
@@ -290,11 +314,14 @@ All types mirror the [OWL ontology](definitions/ontology.ttl) exactly:
 ## Repository Structure
 
 ```
-definitions/   Turtle ontology (OWL) + SHACL shapes
-schemas/       JSON Schema for validating .anatomy.yaml files
+definitions/   Turtle ontology (OWL) + SHACL shapes, the style-key roster and
+               the registry generated from it, and the lift fixture — all of
+               it public API, since exports lists it
 docs/          API reference (WD404 + WD404.1 + WD404.2 + WD404.3)
-examples/      Example anatomy files (YAML + Turtle pairs)
-src/           TypeScript types, parser, and transform
+examples/      Example anatomy files (YAML + Turtle pairs), the corpus the
+               round-trip and SHACL tests read
+src/           TypeScript types, parser, value grammar, transform and the
+               generators
 ```
 
 ## Scope
@@ -313,7 +340,15 @@ component configuration at a position), and **state-scoped styles**
 
 ## Design Notes
 
-Styles are modelled as reified key-value tuples (`hasStyle [ styleKey "…" ; styleValue "…" ]`). This keeps the ontology open-ended while remaining lossless. Frequently used style keys may be promoted to first-class datatype properties in a future version.
+Styles are modelled as reified key-value tuples
+(`hasStyle [ a :Style ; :styleKey "…" ; :styleValue "…" ]`), which stays
+lossless whatever the key roster becomes. Since 0.4.0 a tuple whose key takes
+a token also carries `:consumes`, an ordered `rdf:List` of the `dt:` symbols
+it reads: `:styleValue` is the authored spelling kept verbatim as evidence —
+it is where a terminal literal lives, since a literal is not a symbol — and
+`:consumes` is the form a query can walk. The key vocabulary is no longer
+open: `anatomy:styleKey`'s `sh:in` is projected from the registry, so a key
+outside the roster is a SHACL violation rather than a silent addition.
 
 Projections and pinned props reuse the same reification idiom (`hasProjection [ projectionType "…" ; projectionField "…" ]`, `hasProp [ propName "…" ; propValue "…" ]`). Projections attach to both nodes and relations — the reified `Relation` is precisely what makes slot-level traversal annotations possible without changing the `Edge` class; pins attach to named nodes only.
 

package/definitions/lift.fixture.json

@@ -0,0 +1,216 @@
+{
+  "$comment": [
+    "The committed lift fixture (ADR J §4.1, §8.2). Both TypeScript repositories assert against it, so anatomy-dsl and design-system lift identically and cannot drift apart without a failing test.",
+    "`values` is the value lift this package implements: `liftSymbols(value)` over what the YAML parser holds for a style value — a scalar or a sequence of scalars — returning the symbols in fallback order. A primitive is not a symbol: it resolves against nothing by design, so it is never lifted.",
+    "`rejections` is the retired notation, with the rule each breaks. Every one throws an AnatomyValueError naming the value and the rule.",
+    "`names` is the CSS-name lift of §5.1 step 5d, which design-system implements because it needs S4 to run: a custom-property name to the dotted symbol it lifts to, or null where it names no symbol in any stratum and is kept as consumed with a register row (AT.09). It is DATA here, not an implementation — this package ships it so the two repositories agree on the expected pairs."
+  ],
+  "values": [
+    { "case": "a symbol", "value": "color.text", "symbols": ["color.text"] },
+    {
+      "case": "a camelCase segment is the symbol's own spelling, not renamed",
+      "value": "color.focusRing",
+      "symbols": ["color.focusRing"]
+    },
+    {
+      "case": "a numeric segment",
+      "value": "dimension.100",
+      "symbols": ["dimension.100"]
+    },
+    {
+      "case": "a deep camelCase symbol",
+      "value": "typography.weight.semiBold",
+      "symbols": ["typography.weight.semiBold"]
+    },
+    {
+      "case": "a channel symbol, consumed by name where the implementation reads the channel",
+      "value": "modifier.color.text",
+      "symbols": ["modifier.color.text"]
+    },
+    {
+      "case": "the surface channel spelling",
+      "value": "surface.color.background",
+      "symbols": ["surface.color.background"]
+    },
+    {
+      "case": "the programme's central binding: a channel then the semantic token",
+      "value": ["modifier.color.text", "color.text"],
+      "symbols": ["modifier.color.text", "color.text"]
+    },
+    {
+      "case": "three ranks, in the reference's own order",
+      "value": ["modifier.color.border", "color.border.highlighted", "color.border"],
+      "symbols": [
+        "modifier.color.border",
+        "color.border.highlighted",
+        "color.border"
+      ]
+    },
+    {
+      "case": "a terminal literal is kept in the value and lifted from none of it",
+      "value": ["modifier.color.icon", "modifier.color.text", "currentColor"],
+      "symbols": ["modifier.color.icon", "modifier.color.text"]
+    },
+    {
+      "case": "a dimension tail",
+      "value": ["dimension.stroke.thickness.large", "2px"],
+      "symbols": ["dimension.stroke.thickness.large"]
+    },
+    {
+      "case": "a bare keyword, for a key the registry says takes a primitive",
+      "value": "flow",
+      "symbols": []
+    },
+    {
+      "case": "a hyphenated CSS keyword, which the reference uses throughout",
+      "value": "not-allowed",
+      "symbols": []
+    },
+    { "case": "a number", "value": "1.6", "symbols": [] },
+    { "case": "a percentage", "value": "0%", "symbols": [] },
+    { "case": "a colour", "value": "#ccc", "symbols": [] },
+    {
+      "case": "a literal holding a slash between spaces: the slash ban is on symbol spellings, never on literals",
+      "value": "1 / -1",
+      "symbols": []
+    },
+    {
+      "case": "a literal a bare YAML would read as an alias",
+      "value": "*",
+      "symbols": []
+    },
+    {
+      "case": "an undeclared name is still a symbol by grammar: whether it resolves is the register's question, not the parser's",
+      "value": ["modifier.surface", "color.foreground.primary"],
+      "symbols": ["modifier.surface", "color.foreground.primary"]
+    },
+    {
+      "case": "a computed state variable, kept as consumed under the hover.X spelling",
+      "value": ["hover.color.foreground.secondary", "color.foreground.secondary.hover"],
+      "symbols": [
+        "hover.color.foreground.secondary",
+        "color.foreground.secondary.hover"
+      ]
+    }
+  ],
+  "rejections": [
+    { "case": "a slash path", "value": "spacing/medium", "rule": "slashPath" },
+    {
+      "case": "a slash path with a camelCase-bearing segment",
+      "value": "color/focus-ring",
+      "rule": "slashPath"
+    },
+    {
+      "case": "a slash path inside a sequence",
+      "value": ["modifier/color/foreground", "color/foreground/primary"],
+      "rule": "slashPath"
+    },
+    {
+      "case": "the retired optional marker on a slash path",
+      "value": "color/surface/button?",
+      "rule": "slashPath"
+    },
+    {
+      "case": "the retired optional marker on a dotted symbol",
+      "value": "color.surface.button?",
+      "rule": "marker"
+    },
+    { "case": "the reserved root segment", "value": "$root", "rule": "root" },
+    {
+      "case": "the reserved root segment inside a dotted name",
+      "value": "color.$root.text",
+      "rule": "root"
+    },
+    {
+      "case": "a bare root segment",
+      "value": "color.root.text",
+      "rule": "root"
+    },
+    {
+      "case": "a primitive before the end: the sequence is the fallback order and a literal is what the chain ends in",
+      "value": ["2px", "dimension.stroke.thickness.large"],
+      "rule": "primitiveNotLast"
+    },
+    {
+      "case": "a primitive in the middle",
+      "value": ["modifier.color.text", "currentColor", "color.text"],
+      "rule": "primitiveNotLast"
+    },
+    {
+      "case": "a one-element sequence: a fallback order needs two",
+      "value": ["color.text"],
+      "rule": "singleton"
+    },
+    { "case": "an empty sequence", "value": [], "rule": "empty" },
+    { "case": "an empty scalar", "value": "", "rule": "empty" }
+  ],
+  "names": [
+    {
+      "case": "a plain semantic token",
+      "variable": "--color-text",
+      "symbol": "color.text"
+    },
+    {
+      "case": "camelCase is restored from the kebab spelling S4 emits",
+      "variable": "--color-focus-ring",
+      "symbol": "color.focusRing"
+    },
+    {
+      "case": "the drift spelling S4 also emits for the same symbol",
+      "variable": "--color-focusRing",
+      "symbol": "color.focusRing"
+    },
+    {
+      "case": "a modifier channel",
+      "variable": "--modifier-color-text",
+      "symbol": "modifier.color.text"
+    },
+    {
+      "case": "a surface channel",
+      "variable": "--surface-color-background",
+      "symbol": "surface.color.background"
+    },
+    {
+      "case": "a channel with no base symbol: kept as consumed, register row X7",
+      "variable": "--modifier-surface",
+      "symbol": "modifier.surface",
+      "resolves": false
+    },
+    {
+      "case": "a state variant of a channel: register row X5",
+      "variable": "--modifier-surface-hover",
+      "symbol": "modifier.surface.hover",
+      "resolves": false
+    },
+    {
+      "case": "a computed state variable: the double dash lifts to a dot, register row X15",
+      "variable": "--hover--color-foreground-secondary",
+      "symbol": "hover.color.foreground.secondary",
+      "resolves": false
+    },
+    {
+      "case": "a component-local variable is followed through its :root definition and replaced by what it consumes",
+      "variable": "--button-color-text",
+      "symbol": "color.text",
+      "via": "--button-color-text: var(--color-text)"
+    },
+    {
+      "case": "a component-local variable whose definition is itself a chain",
+      "variable": "--button-color-background",
+      "symbol": "modifier.color.foreground.primary",
+      "via": "--button-color-background: var(--modifier-color-foreground-primary, var(--color-foreground-primary))"
+    },
+    {
+      "case": "an undeclared name: kept as consumed with a comment, register row X1",
+      "variable": "--motion-duration-fast",
+      "symbol": "motion.duration.fast",
+      "resolves": false
+    },
+    {
+      "case": "a composite typography slot no stratum declares",
+      "variable": "--typography-text-secondary-font-size",
+      "symbol": "typography.text.secondary.fontSize",
+      "resolves": false
+    }
+  ]
+}

package/definitions/ontology.ttl

@@ -1,17 +1,25 @@
-@prefix anatomy: <http://anatomy-dsl.example.org/ontology#> .
+@prefix anatomy: <https://anatomy.canonical.com/> .
 @prefix owl:     <http://www.w3.org/2002/07/owl#> .
 @prefix rdfs:    <http://www.w3.org/2000/01/rdf-schema#> .
 @prefix rdf:     <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .
 @prefix xsd:     <http://www.w3.org/2001/XMLSchema#> .
 @prefix skos:    <http://www.w3.org/2004/02/skos/core#> .
 @prefix graphql: <https://pragma.canonical.com/graphql#> .
+# The two graphs this one is read beside. `dt:` is the token graph
+# (@canonical/token-ontology): a style value's symbols are dt:TokenSymbol
+# individuals, and anatomy:consumes names them. `ds:` is the design system
+# graph (canonical/design-system), whose ds:TokenBinding record reuses
+# anatomy:styleKey and anatomy:styleState — which is why neither carries an
+# rdfs:domain any more.
+@prefix dt:      <https://dt.canonical.com/> .
+@prefix ds:      <https://ds.canonical.com/> .
 
 # ═══════════════════════════════════════════════════════════════
 # ONTOLOGY DECLARATION
 # ═══════════════════════════════════════════════════════════════
 
-<http://anatomy-dsl.example.org/ontology> a owl:Ontology ;
-    owl:versionInfo "0.3.2" ;
+<https://anatomy.canonical.com/> a owl:Ontology ;
+    owl:versionInfo "0.4.0" ;
     rdfs:label "Anatomy DSL Ontology" ;
     rdfs:comment "Compliant with OWL DL profile" ;
     skos:definition """Meta-model for the Anatomy DSL — a YAML-based language
@@ -101,6 +109,57 @@ anatomy:SwitchCase a owl:Class ;
     rdfs:label "Switch Case" ;
     skos:definition "One alternative within a Switch." .
 
+# ═══════════════════════════════════════════════════════════════
+# THE STYLE-KEY REGISTRY
+# ═══════════════════════════════════════════════════════════════
+#
+# The individuals live in registry.ttl, projected from the roster in
+# style-keys.yaml by `bun run generate:registry`; the same roster closes
+# anatomy:styleKey's sh:in in shapes.ttl. The vocabulary was open until
+# 0.4.0 — "about 14 keys" documented against 39 the corpus used — and an
+# open roster is what admitted `background.color` on a component whose
+# stylesheet says `background-color`.
+
+anatomy:StyleKey a owl:Class ;
+    rdfs:label "Style Key" ;
+    skos:definition """One canonical style key: a platform-agnostic property
+    the anatomy may bind. The roster was measured, not designed: it is the
+    right-hand column of a table whose left-hand column was every CSS property
+    the reference implementations bind, so a key exists because an
+    implementation binds the property, never because the vocabulary looked
+    incomplete. registry.ttl states where that measurement lives.""" ;
+    skos:example "appearance.background" ,
+                 "spacing.internal.inline.start" ,
+                 "typography.color" .
+
+anatomy:valueKind a owl:DatatypeProperty ;
+    rdfs:label "value kind" ;
+    rdfs:domain anatomy:StyleKey ;
+    rdfs:range xsd:string ;
+    skos:definition """What the key admits: "token" (a symbol, or a list of
+    symbols ending at most in one primitive), "primitive" (a literal the
+    implementation writes as it stands), or "either". Measured from the
+    reference declarations mapped onto the key when the roster was taken —
+    all reading a var() is token, none is primitive, mixed is either. An
+    "either" key compiles to an sh:or in StyleShape: it carries
+    anatomy:consumes, or it carries a primitive styleValue.""" ;
+    skos:example "token" , "primitive" , "either" .
+
+anatomy:tokenNamespace a owl:DatatypeProperty ;
+    rdfs:label "token namespace" ;
+    rdfs:domain anatomy:StyleKey ;
+    rdfs:range xsd:string ;
+    skos:definition """A dotted prefix, ending in a dot, whose symbols the key
+    admits — matched against a symbol's dotted NAME with STRSTARTS, never
+    against its IRI. Multi-valued, and a key whose base namespace is `N.`
+    carries `N.`, `modifier.N.` and `surface.N.`: a channel of a symbol in
+    `N.` is exactly what the anatomy consumes where the implementation reads
+    the channel, so without the channel spellings every channel binding in
+    the corpus would be a namespace violation. It is the single declaration of
+    which symbols a key admits, and the inverse question — which keys admit
+    this symbol — is the query over it (dt:appliesTo is retired).""" ;
+    skos:example "color." , "modifier.color." , "spacing." .
+
 # ═══════════════════════════════════════════════════════════════
 # OBJECT PROPERTIES
 # ═══════════════════════════════════════════════════════════════
@@ -165,6 +224,31 @@ anatomy:hasProp a owl:ObjectProperty ;
     rdfs:range anatomy:Prop ;
     skos:definition "Attaches a pinned prop value to a named node. Named nodes only: anonymous nodes have no prop surface to pin." .
 
+anatomy:consumes a owl:ObjectProperty ;
+    rdfs:label "consumes" ;
+    rdfs:domain anatomy:Style ;
+    rdfs:range rdf:List ;
+    skos:definition """The token symbols this style binding consumes, as an
+    ordered rdf:List whose elements are dt:TokenSymbol individuals in FALLBACK
+    ORDER: rdf:first is the primary symbol, and each rest is what the
+    implementation falls back to when the one before it is undefined. It is
+    the RDF form of the authored value — a one-to-one transcription of the
+    implementation's `var(a, var(b, …))` chain — and the reason the list and
+    not a single symbol is that the fallback is a per-slot choice: a
+    component's background and its text fall back differently, so no rule
+    declared once on a symbol can carry it.
+
+    A slot consumes a CHANNEL by name where the implementation reads the
+    channel (`modifier.color.text`) and the semantic token by name where it
+    reads the token; nothing is inferred from the spelling. A terminal
+    literal the chain ends in (`currentColor`, `0`, `1em`) is NOT an element
+    here — it resolves against nothing by design — and is carried in
+    anatomy:styleValue, which keeps the authored spelling verbatim as
+    evidence. Whether a key carries this at all is anatomy:valueKind's
+    business, and whether a symbol RESOLVES is the consumer's: a name no
+    stratum declares is kept as consumed with a register row.""" ;
+    skos:example "( dt:modifier.color.text dt:color.text )" .
+
 # ═══════════════════════════════════════════════════════════════
 # DATATYPE PROPERTIES
 # ═══════════════════════════════════════════════════════════════
@@ -217,11 +301,17 @@ anatomy:slotName a owl:DatatypeProperty ;
 
 anatomy:styleKey a owl:DatatypeProperty ;
     rdfs:label "style key" ;
-    rdfs:domain anatomy:Style ;
+    # No rdfs:domain, deliberately. design-system's ds:TokenBinding record
+    # (one per consumed symbol per rank) carries the key and the state of the
+    # tuple it was derived from, so a domain of anatomy:Style would type every
+    # record an anatomy:Style. The constraint that a tuple carries exactly one
+    # key lives in shapes.ttl, where it belongs. Stays an
+    # owl:DatatypeProperty: pragma asserts every term a lookup selects is a
+    # declared datatype or object property.
     rdfs:range xsd:string ;
     skos:definition "Platform-agnostic style property identifier." ;
     skos:example "layout.type" ,
-                 "spacing.internal" ,
+                 "spacing.internal.inline.start" ,
                  "appearance.background" ,
                  "typography.weight" .
 
@@ -229,15 +319,24 @@ anatomy:styleValue a owl:DatatypeProperty ;
     rdfs:label "style value" ;
     rdfs:domain anatomy:Style ;
     rdfs:range xsd:string ;
-    skos:definition "Value for a style property." ;
-    skos:example "stack" ,
-                 "spacing/medium" ,
-                 "color/surface/primary" ,
-                 "color/surface/button?" .
+    skos:definition """The AUTHORED SPELLING of the value, verbatim: a scalar
+    as written, a sequence in its flow form. It is the evidence of what the
+    reference says, and it is kept even where anatomy:consumes carries the
+    same symbols in a form a query can walk — the terminal literal of a
+    fallback chain lives only here, because a literal is not a symbol.
+
+    A value is a symbol, a primitive, or a sequence whose elements are
+    symbols with at most one primitive and only as the last element. The
+    slash-delimited path and the trailing '?' marker are RETIRED: an element
+    that resolves nowhere is a register row and a comment, not a sigil.""" ;
+    skos:example "flow" ,
+                 "dimension.100" ,
+                 "[modifier.color.text, color.text]" ,
+                 "[modifier.color.icon, modifier.color.text, currentColor]" .
 
 anatomy:styleState a owl:DatatypeProperty ;
     rdfs:label "style state" ;
-    rdfs:domain anatomy:Style ;
+    # No rdfs:domain, for the reason anatomy:styleKey gives.
     rdfs:range xsd:string ;
     skos:definition """Interaction state this style value applies in. Absent
     means the default state. Closed vocabulary (hover, active, focus,