Arena v12.0.0

angular

• ArenaMenu clears align off its host, so the menu part aligns its text as React's does

audit

• unknown-input names a static attribute an Arena element in an Angular template does not take, which no Arena component reads
• a danger tint is not a filled danger surface, and no message names a palette colour
• every finding hands its rule to the report, and a stale allowance is a rule of its own
• a modal's scope ran past its close tag when comment blanking ate the closing line
• one-primary counted a button in a comment, a type argument, a statement branch or a modal as the page's
• inBranch carried a second comment in a file whose one header is the whole allowance
• a closed branch element still counted as the ancestor of a later sibling of the same name
• a bare button wrapped in an element inside a JSX branch was counted, and braces in string literals opened blocks
• a bare button in a conditional branch and an interpolated class were counted as an implicit primary
• a button with no emphasis class draws as the primary and one-primary did not count it

badge

• arena-size-sm draws a compact marker, so a live indicator over a picture is a badge and not a hand-painted danger fill
• arena-mark-solid fills a status mark with its hue's ink and writes on-ink over it, so a filled marker is a class and not a danger surface

baseline-tree

• the marker is compared as the path join writes, so the suite holds on Windows too

catalogue

• an index generated from each entry's line is what a cold start reads, because the site and the server list no directory

cli

• a root style plugin silent on a role with a kernel default builds through its own answers, and the build notes the role
• a role may carry a kernel default, and the catalogue the packages ship carries it beside the type
• a palette or style plugin named for a class Arena is going to ship is refused, naming the component that holds it
• a named stylesheet.components list is closed over what its components draw, and the run notes what it added
• what a sheet needs is followed to its end by one function, and "auto" pulls through it
• the check and doctor usage are held to their kinds-only --strict head and help line, word for word
• heldAs and auditFindings state what they return, and an audit line stays inside the width its module keeps
• --strict= names a rule as kind:rule, and refuses one its kind does not have
• a report carries the rule that produced it, and --strict can hold one rule of a kind by name
• the arena audit summary said "those hold" with nothing for "those" to name
• arena audit said no gate reads your application right after reading it
• one arena command with build, check, audit, usage, init, doctor and clean subcommands replaces arena-to-prod in both packages

consumer

• a list naming arena-table alone has to import the pagination and select the table draws, and say so

contracts

• a root plugin is total through its own answers and the kernel defaults, and a role outside the roster carries one
• a plugin name RESERVED holds is refused, and the component that ships the name deletes its entry

contrast

• a chart's axis measures heavier than its grid in every plugin Arena ships, and arena check says when a project's does not

core

• what counts as new to --strict closes the page, and "Running them" sits under the scripts it names

docs

• stack.md did not say what the audit reads, and two references left the package specifier's layer undefined
• the references contradicted the package on tag tones, role counts, what the audit reads, the stylesheet specifier and a plugin's class

figure

• the frame's one track is minmax(0, 1fr), so a picture taller than its ratio is fitted and never stretches the frame

fill is the first vocabulary family

• ArenaButton, ArenaIconButton, ArenaSegmentedControl, ArenaTooltip and ArenaMenu answer it through a channel registered as not inherited, full leaves the contract and both layers, --audit names arena-fill in its place, and check:proximity measures the cascade in Chromium in both load orders

graph

• generate:prompt-api and check:prompts declared reading whole component directories

hero

• five benches that differ most in hue, radius, weight and face, and a dashed your-style slot for the reader's own

init

• arena:audit names every rule that exists, so one added later is reported and held only once named

mcp

• arena_find stopped reading the opening of every JSON resource, so radius no longer found roles and sp-4 found nothing
• jsonIn sliced the directory off a path by length, which the portability gate rejects
• token and behaviour entries put shared words in every title and opening, burying the reference that answers a query
• the token values and the behaviour contracts had no URI, so --sp-4 could not be read over MCP

prompts

• a keyless @keys region dropped the pattern name, and the prompt scripts described three regions
• the Angular ArenaButton example drew three bare buttons, so copying it failed one-primary
• ArenaTag's lead said its tone follows Badge's taxonomy, which carries info
• the keys region cut each key's text at its first semicolon, hiding clauses the pattern states
• a table or alert prompt claimed it binds no pattern, and the region cost the route its budget
• no prompt named the keys its behaviour pattern requires

references

• style names the default plugin's three layout answers as one plugin's, generated from it, and arenaBreadcrumbList is public in both layers
• a toast, a static artifact, the token values, the install command and the style store each have a page that answers them, and every new fragment compiles against its package
• the package sheet alone carries no colour, the kernel states first that no role carries a default, each layer names its own events, and no consumer type cites a repo path
• config names the roles carrying a default, the density sheet an intro page imports is tracked, Scales lists every dz text step, and a control's role keeps its press
• the router routes the helpers by name, a static page links its sheets from the site, and the route budgets pay for what the pages add
• exports wires the focus trap, the predicates and density in each layer, and media-register writes the feed's keys
• config lists the names the build refuses and the note a defaulted role prints, and locale lists every field it takes
• a root plugin may be silent only on a role carrying a default, and the kernel says where that default is written
• a role carrying Arena's default takes it when the root plugin is silent, and a minor may add a role
• a palette or plugin name Arena holds for a class it is going to ship is refused, so a minor never lands on one
• a named sheet list is closed the way "auto" is, and the list a project keeps is what it renders itself
• cli's --strict paragraphs keep every sentence under the register's length, and say an audit finding ends in its rule
• cli and versioning say what kind:rule holds, and the CLI page says what counts as new
• the non-component consumer probe found toast examples calling no queue, a missing z step and a versioning page answering another question
• four consumer pages said nothing reads your sources beside a command that does

roles

• a side nav row and an app bar's band each read a padding pair of their own, whose defaults are the row padding, the gutter and sp.3

routes

• the install route's budget pays for cli quoting the scripts init writes, which name every audit rule

rules

• a test required the own-class sentence to end at "vocabulary page"
• the no-gradients depth sentence dropped base-200 from the three-step surface scale
• the gradientMark clause named neither the file nor the author, and surface.md's class sentence had no antecedent
• the three new sentences pushed the consumer route past its budget
• the gradientMark clause read as a licence to paint gradients in a plugin directory
• the router did not say a bare button is the primary, how each layer checks a class, or gradientMark

vocabulary

• a family's block selects its part as :scope[…] and every bundler reads it as written

vocabulary types

• check-api re-exported OWN_ELEMENTLESS, a second path to a map that has one home
• ArenaTabsClass was emitted for a component that takes no className

Everything else

• Every surface that states a version states 12.0.0
• build:intro: a bundle reads the scripts its page imports, so the overview is rebuilt when one changes
• check:role-contract: a kernel default aliases a role or an emitted token of its type, a role outside the roster carries one, and the default plugin answers it as the default does
• arena init prints the script to write as one unquoted line, and an explicit --config that is not there stops audit and usage
• The comments in colors.css, intro/styles.css and the identity pages name arena build
• The contributor pages name the arena command and the subcommand that does each thing
• The consumer pages, the README and the rules list name arena build, check and audit where they named the old command and the --audit flag
• The arena page gives a config it cannot read exit 2 and doctor exit 1 on whatever stops a build, names pnpm exec beside npx, the sync test refuses a kind on the wrong strict row, and the CLI's header and router name what ships and no count
• The consumer reference for the arena command is cli.md, held to the dispatch, every command's flags and the kinds --strict holds by a sync test, and the route, the router, the npm questions and every link point at it
• The generate/core page describes arena-cli as one binary with subcommands behind plan(), its entry arena.ts and its flat modules
• check-support reads arena@version, a sentence-final arena, quoted arena, npm x and bun x as the foreign package, and accepts --no only where the runner documents it
• check-support refuses npx, bunx and npm exec arena without --no-install, and pnpm dlx or yarn dlx arena, since the registry holds a different arena
• The generated pages and the language rules name arena audit where they named the old command, and the issue template offers the arena command
• check-consumer snapshots every read-only command on an unbuilt and a stale tree and clean around a sibling file, plan tests carry the shipped-icons and outside-a-package cases, and the icon error prefix names no command
• The generate/core router names arena.ts and bin/arena.mjs where it named the old entry
• The npm bin is arena: arena-to-prod and its test are gone, the steps drop the audit option, and check-consumer runs every subcommand from a node_modules path
• arena init refuses a --config path holding a backslash, by name, like the other characters a script cannot quote alike
• arena init wraps a --config path in plain double quotes, which sh and cmd.exe read alike, and refuses one holding ", $, `, % or ! by name
• The arena doctor engines case runs against a host with an icon manifest, so its held count is the Node report alone, and node imports come first
• The arena check suite asserts the exact glyph report line and drops a fixture it never read
• arena build prints each sheet as it writes it, so a later failed write still reports the earlier ones, and an orphan already gone is no error
• arena build --watch reopens a source dir recreated under it, waits on the parent of a path that is missing, keeps watching after a first build that throws, and leaves the host separator to posix.ts
• arena build --watch builds once, then rebuilds after each settled burst of relevant changes to the config, sources and plugins, and stops on Ctrl-C
• arena doctor compares the tree with what a build would leave, names missing, stale and orphan sheets and the environment around them, and writes nothing
• arena check names what the sheets and your sources get wrong, writes nothing, and holds components, contrast, ramp, weight, glyph and markers only under --strict
• arena init refuses a package.json that is not an object or a scripts field that is not one, quotes a config path that needs it, and keeps CRLF line endings
• arena build writes the sheets a plan answers, only those whose bytes changed, removes orphans, and leaves a watchBuild seam for --watch
• arena init copies the example config and wires prebuild, predev or prestart, arena:check and arena:audit without rewriting what a project already wrote
• arena audit reads the sources and style plugins against the rules of the language, writes nothing, and holds audit and restated findings only under --strict
• arena usage names the components your sources draw nowhere and the parts your style plugins paint, and holds no report
• A fatal plan keeps the reports gathered before it, and --version reads only the package manifest
• arena clean removes the three sheets arena build writes from --out, by name, and nothing else
• arena.ts dispatches the seven subcommands and hostManifest names the package around it, with each command a stub until it is built
• plan() works out the theme, plugin and icons sheets and the orphans a build would leave, and writes none of them
• Every subcommand's flags, strict sets, neighbour messages and usage come from one spec in args.ts, and io.ts is what a command speaks through
• Each command that holds reports owns a set of kinds, and reports.ts names the holder and the held message
• The CLI's host, sources, sheets and steps are modules of their own, and its suite is split along them
• check:mcp accepts a site page the site build writes, such as llms.txt, and still fails one it does not
• The CLI lives in scripts/generate/core/arena-cli, and copyCli reads its directory from CLI_SOURCES rather than the bin name
• The final review's findings are fixed: the npm intro reads, the head and layout questions read on their own, and the release step says to tag after the regenerated pages
• Published copies point relative links at the release tag, and check:docs forbids GitHub blob links into this repository
• The sentences beside the relative links say the path resolves in a clone and a published copy points at the repository
• The router links every consumer reference, the docs that named the npm pages point at the references, and links into this repository are relative paths
• The gates that read an npm page's content read the consumer references instead, each layer held to its own sections and the shared ones
• The question gate declares what it reads, counts an anchored skill link as a link, and slugs repeated headings and link syntax as GitHub does
• The npm pages are an intro and a generated question table linking the skill references, and each generated region lands only in the targets mapped to it
• The consumer references name the wash kind and both layer packages, and carry no literal count outside the generated regions
• The non-component consumer knowledge of the npm pages has a reference of its own: install, config, the command, theme, locale, exports, stylesheets, contracts, the MCP server and versioning
• The neutrality gate finds a computed member's function by its definition and reads strings as strings, and its geometry exemption covers the name rule alone
• The pages route each question to the page that answers it and state what Arena is, in the present tense and without its past
• A string member taking a CSS length or named for a geometry axis fails the neutrality gate, and each computed member is held to a function that reads it
• The audit reports what a project writes against the vocabulary of this version, and an axis decided twice on one component, and names nothing an earlier version shipped
• The MCP check reads every class against the vocabulary each layer ships, so a vocabulary class on a component is never the adopter's own
• The audit names the member a retired danger variant became, reports an axis decided twice only where a class and its property contest one channel, and fills every option a family ships into its message
• The contributor pages say a chart's manifest holds its frame, legend and tooltip, and the audit closes each finding with the class, property or member that answers it
• Each layer's page states how it positions its own floating parts, and the one place both layers are read together says they differ there
• The contributor pages state the geometry axes, the keyed column, the kind roles and every ruling the phase closes, in the page each belongs to
• The style reference says a value no step names is the family's property, set on a container with a token, and a column's width and alignment are set under its key
• The prompts write a grid, a section, a board, a scroller, a dialog, a figure, a skeleton and a table column's geometry as the classes and properties that say it
• The audit names the class or the property that says each retired geometry member, a column's width or alignment, and an axis decided twice on one component
• The parts gate's rules are held where they are wired, chart sources and contract descriptions read roles and never a compat alias, and an allowance ignores a part that draws no box
• The Angular avatar test states its rule without naming another layer
• An Angular icon button with no pressed state says none, and an avatar with an unknown status draws offline, as in React
• A React calendar event is clickable only when it is interactive and enabled, as in Angular
• Angular charts draw inside their frame slot and paint in roles, a calendar event's panel takes its layer from its slot, and a declared part no layer draws fails the parts gate
• An allowance covers what its parts paint, their rendered descendants' boxes included, so a chart's label overhanging its frame is inside the chart
• React charts draw inside their frame slot and paint their rules, labels and rings in the roles a plugin answers
• Every chart draws inside a frame slot a plugin can reach, axis lines are a role, a calendar event's panel sits on the dropdown layer, and a day head is never shorter than the comfortable row
• Every numeric step a kind with roles still spends says whether it sizes air or something else
• A card head's top, a pinned sheet's sides, a text-sized control's block padding, a floating list's rows and an action row's gap are roles each kind answers
• The recorded Angular tree of the skeleton corner case sets the corner it measures
• The package page names the keyed column family and every sheet it ships, the two layers' paired matrices and every specimen card are held by a test, a skeleton's circle and corner are measured, and a non-finite line count draws an empty stack
• The React cell test asserts a keyed cell carries a style before reading its channels, so the layer typechecks
• An Angular table binds a column's width and alignment under its key on every header and cell, and warns once about a key that cannot name a property
• A React table binds a column's width and alignment under its key on every header and cell, and warns once about a key that cannot name a property
• A table column is named by an optional key and its width and alignment are properties set under that key, a demo sets a property the way an adopter would, and no contract member is left for the vocabulary to take
• An Angular skeleton is one box in the shape its class names, or a stack of the lines it is given, and a circle given only a width takes it as its diameter
• A React skeleton is one box in the shape its class names, or a stack of the lines it is given, and writes no style of its own
• A skeleton's shape is a class, its width, height and corner are properties an adopter sets, and the number of lines it is given decides whether it is a box or a stack
• A dialog probes its width property through the document's own view and only once it knows it is not filling, and the compiled sheet holds filling above any width the property sets
• The React dialog and figure tests read the family a component answers from the layer's own generated manifest, so no React file imports the Tailwind layer
• No Angular dialog or figure takes a width or a ratio, and a dialog warns once when the width property it is given is not a width
• No React dialog or figure takes a width or a ratio, and a dialog warns once when the width property it is given is not a width
• A dialog's width and a figure's frame are families an adopter writes as a class or sets as a property, and no contract member takes a CSS value
• No Angular board or scroller takes a column or an item width, and a scroller's class reaches the items it holds
• No React board or scroller takes a column or an item width, and a scroller's class reaches the items it holds
• A board's narrowest column and a scroller's item width are families an adopter writes as a class or sets as a property, and a scroller hands its class to the items it holds
• No Angular grid or section takes a minimum, a ceiling, a gap or a rhythm
• No React grid or section takes a minimum, a ceiling, a gap or a rhythm
• A grid's narrowest cell, its ceiling and its gap, and a section's rhythm, are families an adopter writes as a class or sets as a property on a container, and a nested grid inside a card is not reached by its parent's
• A manifest that reads an axis answers its family, the keyed binding is found only in the bound component's own directories beside a channel it writes, a fallback through an axis is compared exactly, and each allowance says what it matched
• The baseline mode takes an allowance per sink as a selector, and fails a difference outside the parts it names or a page that changed size
• An enum is appearance when two of its values, or its only one, are options of one family
• A family may declare several axes and is read through them, a keyed family declares its properties and the components that bind it, and an answers region names every property a component takes
• The prompts' prose says what each size, emphasis, accent, elevation, alignment, orientation and placement class does on the component, and that a focused button draws its ring over any hover
• Each prompt's answers region lists only the options its component answers, marks the component's own default, and writes its example with an option the component takes
• The avatar diameters stay out of the script tokens, since no image box reads them any more
• A keyboard-focused ArenaButton draws its focus ring over any hover shadow, whatever its emphasis
• The people-list face case measures the height a shrinking row cannot mask, and an option a part does not answer has a proximity case that fails when the option filter is removed
• The vocabulary type test runs inside bun's limit, the accent levels say what they wash like their neighbours, and the Angular playground fixture models an avatar's kind
• check:playgrounds refuses a context option a component answers the family without, and check:coverage excludes an option role by its option's own prefix
• The consumer pages name the option roles a button and a card read, and each layer page states its rule only as far as the code holds it
• The safe-area gate's header fits the comment rule and the collapsible's prompt keeps every sentence under the register's length
• The contributor pages state how a component answers a family with a default of its own and through its root, where a context class stops, what an option role asks and who answers it, and how a design member is caught by its shape
• The audit names the class, the role or the member that says each retired appearance attribute and each retired value, and counts a second primary by its emphasis class
• The prompts and the consumer pages write size, emphasis, accent, elevation, alignment, layout, orientation and placement as classes, and an avatar's kind as the member it is
• The side nav's indent is the plugin's answer of one level times the row's depth, and no member multiplies it
• No Angular component takes an alignment, a layout or a placement, and the hero binds no style of its own
• No React component takes an alignment, a layout or a placement, and the hero writes no style of its own
• The alignment and layout of a hero, the alignment of a page head and the edge or corner a sheet or a toast stack is pinned to are families an adopter writes as classes, and a hero's tracks are a channel rather than a style its render writes
• No Angular component takes a variant, an editorial tone, an accent or a floating flag, and the components that draw a button inside write its emphasis as a class
• No React component takes a variant, an editorial tone, an accent or a floating flag, and the components that draw a button inside write its emphasis as a class
• Editorial accent and elevation are families an adopter writes as classes, meaning keeps the hue it names over any accent, no tone type carries an editorial value, and the contrast sweep reads the levels and washes the families write
• Emphasis is a family an adopter writes as a class, every emphasis question is an option role, and a destructive action keeps the danger it names over any emphasis
• No Angular component takes a size or an orientation, a person row hands its avatar the list's face, an avatar draws its image at the size its box is given, and every floating surface says it is one
• No React component takes a size or an orientation, a person row hands its avatar the list's face, an avatar draws its image at the size its box is given, and every floating surface says it is one
• Size and orientation are families an adopter writes as classes, every size question is an option role, a component answers the options it has with a default of its own, a floating surface is where a context class stops, and an avatar says whether it stands for a person or a team
• Every option of the families this phase adds declares the roles its look asks, and every plugin answers them with what it paints today
• check:coverage excludes the option roles a family channel reads, a channel read whose fallback is zero or an unmodelled unit is a legal bracket, and the audit refuses an option a component does not answer
• A demo fixture and a component node it holds write vocabulary classes, both layers' playgrounds and kitchen sinks render them, and check:playgrounds refuses a class the component does not take
• check:contracts-neutrality fails an enum whose value is the suffix of a family option unless COMPUTED records it, and the members the render draws, positions or measures with are recorded there with the function that reads them
• A manifest answers a family with the options it has and a default of its own, a context option stops at a floating surface and reaches a component through its root, a channel read survives the build whole and is checked whole, a React component takes a list of vocabulary classes, and every arena utility the theme sheet ships is a family option or a recorded exemption
• The end-aligned menu test states its reason without a bare dimension, so check:dimensions passes over it
• The React slot-attribute scan reads a balanced class expression, check:channels also refuses a plugin sheet writing the danger strong fill role, the swatch hue fallback is tested, and the pages say which marks read the ink
• A base slot that states a fixed status names its hue under hues.always and reads the channels, and the success, warning and info strong fills each paint a presence dot, a progress bar and an activity dot while danger keeps the ink
• An end-aligned menu panel is pinned in both layers, every slot a manifest gives attributes binds them in each layer's own test, and check:channels refuses a style plugin sheet that writes a hue channel
• The board's presence dot reads its hue only where its colour id writes it, the confirmation's invalid input and the textarea's near-limit counter read the hue channels, a destructive button rests flat as danger did, and the pages and the wash test say what the tree holds
• Both packages' pages name the hue sheet each component ships, check:packages accepts it as a pattern row, and the tag prompts keep every sentence under the register's length
• The text-contrast gate row states that it reads hue channels through the hue sheet, and the pages that cite how identity renders name arenaCatIndex
• The contributor pages state that meaning reaches the DOM as data and owns the hue channels, where the danger floor lives, and how a variant compiles
• The prompts and the consumer pages say destructive, colorId, colorIds and numeric, and name identity as an attribute rather than a custom property
• Identity reaches a tag, a board column and the catalogue's plugins through data-arena-color-id and the hue channels alone, and the photo feed's destructive menu rule selects a part that exists
• Angular renders identity and a legend's hue as data-arena attributes, and no Angular component writes a colour of its own
• React renders identity and a legend's hue as data-arena attributes, and no React component writes a colour of its own
• Meaning writes the hue channels from a per-component hue sheet whose rules read the hue roles and levels, every status colour a manifest paints is a read of those channels, and the contrast sweeps measure the same washes and levels through them
• A manifest variant compiles to its slot class qualified by the group's data-arena attribute inside :where(), so TS chooses no class by a value and the cascade keeps its specificity and order
• check:text-contrast reads a compound's condition from its manifest, so a disabled menu item's muted ink stays exempt as a compound, and the check:api row fits the contributor route's budget
• The hue matrix is a set of roles every plugin answers, the danger hue's strong fill is a closed set holding only transparent, and the final confirmation reads roles of its own
• Every Angular slot carries its groups as data-arena attributes, on a template element through ArenaSlotAttributes and on a host through a binding per attribute
• Every React slot carries its groups as data-arena attributes beside its part hook
• check:api holds every manifest group to a member, a field of a member's type or an internal entry with its reason, and counts the groups a design member still decides
• Every specimen card renders its slots' group attributes beside their classes
• Read-only fields, the switch's state, the current navigation item, the textarea's near-limit counter, the current page, the palette's active row and the menu's aligned panel and disabled or destructive items are groups named for what they say, on one slot each
• The table's sortable head, first and interactive rows and figure cells, the key-value figures, the skeleton's last line, the onboarding's current dot and the progress bar's indeterminate track are groups on one slot rather than slots TS chooses
• Every manifest group that names no member is declared internal in its manifest with the reason it exists
• ArenaButton says a destructive action with destructive, a series and a column say identity and figures with colorId, colorIds and numeric, and every member phase 4 rules is a contract, a COMPUTED entry citing the function that reads it, or a phase-5 debt
• arenaStyles renders each slot's group attributes beside its classes, an enum as its resolved value and a boolean as the attribute's presence, and the class module records each group's values and the slots that carry it
• check:roles judges pad-surface and every single-word role stem by kind, the catalogue answers the row padding and gap with its own control and item air so its rows keep their register, and the pages state the dimension rule, the side nav depth channel, the kind-free gaps and the recorded steps as the tree holds them
• React's scatter chart draws its size key from the chart's legend and legend item slots as Angular's does, so the two layers paint the same pixels, and the doughnut's legend row, a pointer target, reaches the 48px floor in comfortable density through min-h-row-min
• The phase's tree passes its own sweep: the pages name the declaration files the tree holds, the inline-style rule is stated without naming a layer, the vocabulary link resolves, each Angular chart barrel exports its styles as the chart card's does, the chart tests assert a chart's legend and tooltip manifest, and the packages, contracts package, playgrounds and demos are rebuilt
• StylePlugins.md states the kinds and the roles that answer each kind's padding, gap and radius, with a row's padding as its role times the density row factor, frameworks/tailwind/AGENTS.md states the kind key and how check:roles judges by it, and CHARTS.md says a chart's legend and tooltip render from its manifest while HAND_DRAWN keeps the plot
• check:dimensions scans every style write in both layers, Angular's style bindings included, and passes a channel binding, a write COMPUTED lists with the function that computes it, or an EXEMPT entry, and the React page states the rule
• A menu item reaches the 48px target in comfortable density through min-h-row-min, the one pointer-target row the measurement found under it, and stays as it is at base and compact
• Angular's charts draw their legend and tooltip from each chart's manifest, carrying its parts, keep as bindings only the values the render computes, and the shared chart tooltip and legend style modules are gone
• React's charts draw their legend and tooltip from each chart's manifest, carrying its parts, and keep inline only the series colour, the tooltip's anchor, the strip height and the hover opacity the render computes
• The component stylesheets read the row padding's calc over Arena tokens rather than the --spacing-row-x and --spacing-row-y theme properties, and --arena-side-nav-depth is a channel a component writes, so check:component-css holds over the row and side nav sheets
• The seven charts draw their legend and tooltip from a manifest of their own, the tooltip fills with the new fill-surface-raised role and reads the floating edge and shadow, the legend reads the marker gap and radius, HAND_DRAWN keeps only the plot, and a hand-drawn component may own a manifest for the slots it does not draw by hand
• Angular's side nav rows bind --arena-side-nav-depth to arenaIndentDepth(indentStep, depth) while expanded and write no inline padding, and the prompt states indentStep as a count of the theme's indent steps
• React's side nav rows bind --arena-side-nav-depth to arenaIndentDepth(indentStep, depth) while expanded and write no inline padding, and the prompt states indentStep as a count of the theme's indent steps
• The side nav's item, trigger and section label inset by the row padding plus the indent role times the --arena-side-nav-depth channel, only while expanded, and indentStep is a count of the theme's indent steps
• SCALE_USES records every padding, gap, margin and radius a slot keeps outside its kind's role, each saying what the slot is and why its length is its own, and the sheet's sides and the coachmark's padding are recorded against the floating role
• check:roles judges every slot by its kind, failing a slot with no kind, a numeric padding, gap or margin step, and a padding, gap or radius role of another kind unless SCALE_USES records it, the manifest claims assert the side nav and tab rows by role, and check:tailwind admits a theme key derived by calc from Arena tokens
• Every layout and navigation manifest declares the kind of each slot, the side nav, palette and tab rows read the row roles, the menu rows, the bottom nav item and the side nav section label scale their own steps by the row factor, and the palette's esc key and the side nav badge read the marker role
• Every feedback and form manifest declares the kind of each slot, the dialogs and the sheet read the floating roles, the alert and the toast read the status roles, and the error state's code reads the marker role
• Every brand, chart and display manifest declares the kind of each slot, the badge, tag and calendar chip read the marker roles, the activity feed and the people list rows read the row roles or scale their own steps by the row factor, and the calendar's day heads re-densify with them
• A manifest may declare the kind of each slot, slot-kinds.ts names the kinds, the air and shapes free of any kind and the roles each kind's padding, gap and radius read, and kindProblems() reports a slot without a kind, an unknown kind or a kind naming no slot
• The kernel declares the floating, status, marker and row padding roles, the marker and row gaps and the row indent, every plugin answers them with the step the tree draws and complete with its own, density restates a row factor per axis and a row minimum, and check:coverage reads every var() inside a theme value
• Manifest claims resolve through classesFor, the compiler's own concatenation, a slot renders through arenaStyles with no merge at render time, tailwind-variants is no dependency, and tailwind-merge stays a devDependency for theme-namespaces.ts alone
• The consumer-page reason claims no headroom its budget lacks, the redeclared-groups test checks each group against the families that restate that group, the vocabulary and npm pages name their layout and context classes from the families, check:proximity waits for the load event and bounds the face wait, and step-comfortable tells --dz-text-xs from --dz-text-2xs
• The phase's pages and gates agree with the tree: check:proximity pins the viewport and the shipped face, the vocabulary preamble and the npm region say density goes on a component and the Tailwind utilities are not vocabulary, style.md names the sheets that ship and is a stop on its route, and the graph, portability, register, type and package gates hold
• The style reference states where the page's column, the rhythm and density are written, page.md keeps the colour roles, the floor and the scale, the density rule points at the vocabulary page, and no consumer page names a css file the packages no longer ship
• frameworks/tailwind/AGENTS.md states the markup family and the restating family as rules of the format, and the hand-authored sheets are the three a manifest names
• The stylesheet table on both npm pages is the generated @shared sheets region, listing css/vocabulary/ one file per family, and check:packages fails a css file the package ships that its page never names or a css path the page names that the package does not ship
• check:families reads the compiled and shipped sheets and fails an arena- class that no family and no manifest emits, so every class an adopter writes has a family
• The rhythm, page, prose, numerals and sr-only classes come from their families alone: the five hand-authored sheets, their imports in Theme.css, the preset and the packages' consumer sheets are gone, and the computed-style cases pass on the compiled families
• density is a markup context family restating the dz group from density.compact.json and density.comfortable.json, the spacing sheet no longer carries its two classes, intro/styles.css imports its sheet, and every component takes it as a class
• sr-only is a markup family, its classes compiled from frameworks/tailwind/vocabulary/arena-sr-only in the order SrOnly.css declares them and listed on the vocabulary page
• num is a markup family, its classes compiled from frameworks/tailwind/vocabulary/arena-num in the order Numerals.css declares them and listed on the vocabulary page
• prose is a markup family, its classes compiled from frameworks/tailwind/vocabulary/arena-prose in the order Prose.css declares them and listed on the vocabulary page
• band is a markup family, its classes compiled from frameworks/tailwind/vocabulary/arena-band in the order Page.css declares them and listed on the vocabulary page
• shell is a markup family, its classes compiled from frameworks/tailwind/vocabulary/arena-shell in the order Page.css declares them and listed on the vocabulary page
• row is a markup family, its classes compiled from frameworks/tailwind/vocabulary/arena-row in the order Rhythm.css declares them and listed on the vocabulary page
• stack is a markup family, its five classes compiled from frameworks/tailwind/vocabulary/arena-stack in the order Rhythm.css declares them and listed on the vocabulary page
• The --step-* restatement stays, because the ten step-* markup cases of check:proximity measure it holding in every density and plugin order, and generate-tokens.ts names them as what holds it
• A markup family's classes go in no component's type and are reported by --audit on a component, the vocabulary page and the npm vocabulary section say where a markup class goes, the index carries each class's target, and check:channels lets a family write the contract group it restates
• check:proximity measures the step roles against the density nearest them, with a plugin class outside, inside or on the same element as a density class, nested densities in both orders, and a density class on the html element
• A family may target the adopter's own markup, compiling unlayered to one @scope over :scope per option in the order its file writes them, and may restate a contract group's literal values, and check:families fails a markup family with a default, an axis or an answering manifest, and a component family nobody answers
• check:proximity measures markup cases, the computed style of every rhythm, page, prose, numerals, sr-only and density class recorded from the hand-authored sheets in both load orders, a class on the html element and two modifiers on one element included
• The box-class-stops-at-a-boundary case measures the fill channel past the card body so a leak turns it red, a baseline worktree left registered or unmarked by an earlier run is cleared before the next is added, style.md says an overlay leaves the trigger's subtree only where the layer portals it, and both npm pages end the vocabulary class list cleanly
• frameworks/VOCABULARY.md lists every class an adopter writes on a component, and every consumer surface points at it: the style reference, the rules of the language, the router's table, both npm pages, an Answers region in every prompt and the MCP index
• The roof states who decides how a component looks, the API page that a member decides no appearance the render does not compute with, the Tailwind page the vocabulary and its compilation, the envelope the @scope browser baseline, the router where a style decision starts, and six contributor routes take the cost of those rules
• check:families, check:channels and check:boundaries hold the vocabulary, its channels and the boundary records, the audit reads a class against the arena.vocabulary.json a package carries, and DESIGN_MEMBERS records the members still to migrate with the phase owning each
• Every React component with an element of its own takes a className typed with its generated vocabulary class and filtered to it at runtime, landing on one element it draws; check:api holds the member to that type, and an Angular host keeps a vocabulary class on both host shapes
• An Angular table cell with no link is a boundary on its host and its card value, as the React cell is
• Every element that projects adopter content carries data-arena-boundary in both layers, the triggers of ArenaTooltip and ArenaMenu are declared transparent with their reason, and a derived render suite per layer holds both
• The baseline worktree resolves git through hostBinary and runs bun as the process running it, and check:vocabulary reads no executor scratch under .superpowers/
• A vocabulary family compiles to one @scope block per option over the parts that read its channel, stopped inside every boundary when its reach is a box, and the package assembly ships each one under css/vocabulary/
• check:pixel-parity --baseline compares each layer with the same page built at that ref in a cached worktree, so a phase can show it moved no pixel against the commit before it
• The Angular doughnut prompt says its host keeps no box and the chart measures a frame of its own template
• Both container helpers observe the border box, so a padding or a border that changes while the content box stays put still reaches the number
• The ArenaCard inline-width suites type in the React layer and name no other layer in the Angular one
• ArenaGrid's description says its two claims in two sentences, and ArenaBoard's minColumn ends a sentence where check:dimensions read a property
• An inline component keeps its own width in a flex column or a grid cell: every inline-level root declares w-fit, held by check:intrinsic-width
• ArenaGrid keeps the empty tracks of a row its items do not fill, so a card on a short last page is as wide as one on a full page, and its rows keep their content height
• The consumer router sends a sizing question to the two pages that answer it and returns to its budget, and the bp token names the helpers rather than their files
• Each layer mounts every component MEASURED names and asserts the element it measures carries the slot the map declares
• check:measured-box refuses a branch that moves the outer box of the element its width is measured on, and the debt it replaces leaves DOUBTS.md
• A container watch React discards under StrictMode starts no observer, and useArenaViewportBelow asks matchMedia once per threshold
• arenaContainerWidth reports the box's outer width too, and every Angular chart measures an element of its own template rather than a host a consumer can style
• useArenaContainerWidth reports the box's outer width, its border box with no transform, so padding, a border or a scale that a branch restyles no longer moves the number
• The container helpers measure a target already attached, keep the last width when a box is hidden, and let an unmounted hook stop watching a ref it was handed
• DOUBTS.md files the threshold band where a table or a bulk action bar alternates between its two shapes
• The npm pages and the page reference say the width tools one claim a sentence, each naming its subject
• The width helpers and their first-paint suites name a threshold and a box rather than a width, so check:dimensions reads no bare literal
• The convention says a component asks its container and a frame asks the viewport, and the bp group says who reads it
• The npm pages, the page reference and the frame prompts say which width tool is for which case
• Angular's container signal reads the box inside its render hook, so a responsive component draws its narrow shape in the first tick
• React's container hook measures when its ref attaches, so a responsive component paints its narrow shape first
• Angular's viewport signal reads matchMedia at construction, so the first change detection draws the right frame
• React's viewport hook answers in the first render, through useSyncExternalStore
• The avatar and person-row prompts say when a face stops speaking its name
• A person row says its person's name once
• An avatar can be told its name is already said, and keeps its presence when it is
• Page.css names the two bands that compose its gutter ceiling
• The app bar and the site footer stand off the edge by the page column's ceiling

Every commit: v11.1.0...v12.0.0