@nadicodeai/ui 12.1.128 → 12.1.129

package/dist/components/agent-list-row.d.ts

@@ -10,7 +10,7 @@ import { type StatusBadgeTone } from "./status-badge.js";
  * @instead An Agent as a record among others in a page's list is a RecordList row with an agent IdentityMark; an Agent's own page heads with ObjectPage.
  * @behaviour It is the row's presentation alone: the consumer owns the control around it (Nadia's button that opens the Agent, a scene's list item that opens nothing). The current row's name is set in 500. A state tone draws the state line as a small StatusBadge; without a tone it stays plain text. Narrow, the orb stands alone and the words stay for a screen reader; the consumer names it with its state line in a tooltip, as Nadia's list does. Only the orb moves in the list. The name is 14 px and the state line 12 px at every size. The drawn orb leaves about 10 px of its 64 px box empty, so at 64 px that empty edge overlaps the row's padding (6 px above and below, 4 px at the start) and the words stand 4 px from the box: the row hugs the visible orb and the name sits beside it, as beside a solid picture. In Nadia's list her orb is 64 px in her real state, and 40 px in the narrow column from 640 to 899 px.
  * @words The name, then one state line: what she is doing now ("Answering on Telegram", "Working") or what she is for ("Sorts requests"). The tone never says more than the line does. Nadia's list says "Working", "Idle" or "Needs you"; the badge marks a state that needs the person ("Needs you", a failed set-up), and the orb shows working by itself.
- * @access The orb is decorative; the name and the state line are the row's text, read by its control. StatusBadge owns its decorative mark, so the line carries its meaning.
+ * @access The orb is decorative; the name and the state line are the row's text, read by its control. StatusBadge owns its decorative shape, so the line carries its meaning.
  */
 export declare function AgentListRow({ className, color, current, form, motionKey, name, narrow, size, state, stateLine, stateTone, ...props }: Omit<React.ComponentProps<"span">, "color"> & {
     /** The pigment of the Agent's chosen form; Nadia's striped ribbon keeps her own. */

package/dist/components/agent-list-row.js

@@ -12,7 +12,7 @@ import { cn } from "../lib/utils.js";
  * @instead An Agent as a record among others in a page's list is a RecordList row with an agent IdentityMark; an Agent's own page heads with ObjectPage.
  * @behaviour It is the row's presentation alone: the consumer owns the control around it (Nadia's button that opens the Agent, a scene's list item that opens nothing). The current row's name is set in 500. A state tone draws the state line as a small StatusBadge; without a tone it stays plain text. Narrow, the orb stands alone and the words stay for a screen reader; the consumer names it with its state line in a tooltip, as Nadia's list does. Only the orb moves in the list. The name is 14 px and the state line 12 px at every size. The drawn orb leaves about 10 px of its 64 px box empty, so at 64 px that empty edge overlaps the row's padding (6 px above and below, 4 px at the start) and the words stand 4 px from the box: the row hugs the visible orb and the name sits beside it, as beside a solid picture. In Nadia's list her orb is 64 px in her real state, and 40 px in the narrow column from 640 to 899 px.
  * @words The name, then one state line: what she is doing now ("Answering on Telegram", "Working") or what she is for ("Sorts requests"). The tone never says more than the line does. Nadia's list says "Working", "Idle" or "Needs you"; the badge marks a state that needs the person ("Needs you", a failed set-up), and the orb shows working by itself.
- * @access The orb is decorative; the name and the state line are the row's text, read by its control. StatusBadge owns its decorative mark, so the line carries its meaning.
+ * @access The orb is decorative; the name and the state line are the row's text, read by its control. StatusBadge owns its decorative shape, so the line carries its meaning.
  */
 export function AgentListRow({ className, color, current = false, form, motionKey, name, narrow = false, size = 40, state = "idle", stateLine, stateTone, ...props }) {
     return (_jsxs("span", { className: cn("flex w-full min-w-0 items-center gap-3 text-left text-sm", size === 64 && "gap-1", narrow && "justify-center", className), "data-slot": "agent-list-row", "data-current": current || undefined, ...props, children: [_jsx(AgentOrb, { className: cn(size === 64 && "-my-1.5 -ml-1"), color: color, decorative: true, form: form, motionKey: motionKey, size: size, state: state }), _jsxs("span", { className: cn("grid min-w-0", narrow && "sr-only"), children: [_jsx("span", { className: cn("truncate text-foreground", current && "font-medium"), children: name }), stateLine ? (_jsx("span", { className: "flex min-w-0 items-center gap-1.5 text-xs text-muted-foreground", children: stateTone ? (_jsx(StatusBadge, { label: stateLine, size: "sm", tone: stateTone })) : (_jsx("span", { className: "truncate", children: stateLine })) })) : null] })] }));

package/dist/components/badge.d.ts

@@ -28,11 +28,12 @@ type BadgeProps = Omit<useRender.ComponentProps<"span">, "onClick" | "children"
  * type beside it: `sm` (20 px) next to small labels, `md` (24 px) in a row, `lg` (32 px) in a
  * header. The category fills (teal, purple, pink) name a kind.
  * @instead "For a colored dot without text, use `Status Dot`." (https://vercel.com/geist/badge)
- * Ours: status dots are not used; a state keeps its mark and word together in `StatusBadge`.
+ * Ours: a single dot is never a status; a state is `StatusBadge`, its tone's shape of dots and its
+ * word, with no pill.
  * "For clickable filter chips that toggle a query, use the `pill` variant or a small `Button`." (https://vercel.com/geist/badge)
  * Ours: there is no `pill` variant; a filter that toggles a query is a `Button` or
- * `CollectionFilters`. For a state use `StatusBadge`, which picks the tone and its mark: the gray,
- * green, red, amber and blue fills, soft or solid, are its alone. One categorical fact in a row is
+ * `CollectionFilters`. For a state use `StatusBadge`, which draws the tone as its shape; Badge has
+ * no gray, green, red, amber or blue fill. One categorical fact in a row is
  * a `Tag`. A change in a figure is a `TrendBadge`.
  * @behaviour "Badges are static labels." (https://vercel.com/geist/badge)
  * "Don’t wire `onClick` onto them; promote to a Button or link if the user can act on the value." (https://vercel.com/geist/badge)
@@ -45,11 +46,11 @@ type BadgeProps = Omit<useRender.ComponentProps<"span">, "onClick" | "children"
  * Ours: the badge is the `render` of a `TooltipTrigger` with `tabIndex={0}`, so keyboard and touch
  * users reach the limit it names.
  * "Don’t add a checkmark icon for success states or an X for errors; the variant carries that signal." (https://vercel.com/geist/badge)
- * Ours: only `StatusBadge` carries a state, and it always draws its tone's mark.
+ * Ours: only `StatusBadge` carries a state, and it always draws its tone's shape.
  * "Map meaning to color: `green` for healthy, `red` for error, `amber` for warning, `blue` for informational or production, `gray` for neutral." (https://vercel.com/geist/badge)
  * "The `-subtle` suffix tones any of them down on dense surfaces." (https://vercel.com/geist/badge)
- * Ours: those fills are `StatusBadge`'s, as the tones `success`, `danger`, `warning`, `info` and
- * `neutral`, with `emphasis` `subtle` or `solid`. `Badge` is a fixed-height pill (20, 24 or 32 px)
+ * Ours: those meanings are `StatusBadge`'s, as the tones `success`, `danger`, `warning`, `info` and
+ * `neutral`, each drawn as its shape. `Badge` is a fixed-height pill (20, 24 or 32 px)
  * with no border: colour sits on the fill and the word. A soft fill takes its hue's strong shade
  * for the word, `default` is the foreground colour inverted, and `outline` is neutral, a
  * page-colour fill held by a 1 px inset ring. With an icon, the left padding is 6, 8 or 12 px, so

package/dist/components/badge.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"badge.d.ts","sourceRoot":"","sources":["../../src/components/badge.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AAEvC,OAAO,EAAE,SAAS,EAAE,MAAM,2BAA2B,CAAC;AACtD,OAAO,EAAO,KAAK,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAIlE,QAAA,MAAM,aAAa;;;8EAuBlB,CAAC;AAEF,KAAK,SAAS,GAAG,WAAW,CAAC,YAAY,CAAC,OAAO,aAAa,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC;AAEzE,KAAK,UAAU,GAAG,IAAI,CAAC,SAAS,CAAC,cAAc,CAAC,MAAM,CAAC,EAAE,SAAS,GAAG,UAAU,GAAG,OAAO,CAAC,GACxF,YAAY,CAAC,OAAO,aAAa,CAAC,GAClC,CACI;IACE,QAAQ,EAAE,SAAS,CAAC;IACpB,qDAAqD;IACrD,IAAI,CAAC,EAAE,SAAS,CAAC;IACjB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,GACD;IACE,QAAQ,CAAC,EAAE,KAAK,CAAC;IACjB,IAAI,EAAE,SAAS,CAAC;IAChB,iEAAiE;IACjE,KAAK,EAAE,MAAM,CAAC;CACf,CACJ,CAAC;AAEJ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CG;AACH,iBAAS,KAAK,CAAC,EACb,SAAS,EACT,OAAmB,EACnB,IAAW,EACX,IAAI,EACJ,QAAQ,EACR,MAAM,EACN,GAAG,KAAK,EACT,EAAE,UAAU,8FA0BZ;AAED,OAAO,EAAE,KAAK,EAAE,aAAa,EAAE,KAAK,UAAU,EAAE,KAAK,SAAS,EAAE,CAAC"}
+{"version":3,"file":"badge.d.ts","sourceRoot":"","sources":["../../src/components/badge.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AAEvC,OAAO,EAAE,SAAS,EAAE,MAAM,2BAA2B,CAAC;AACtD,OAAO,EAAO,KAAK,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAIlE,QAAA,MAAM,aAAa;;;8EAuBlB,CAAC;AAEF,KAAK,SAAS,GAAG,WAAW,CAAC,YAAY,CAAC,OAAO,aAAa,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC;AAEzE,KAAK,UAAU,GAAG,IAAI,CAAC,SAAS,CAAC,cAAc,CAAC,MAAM,CAAC,EAAE,SAAS,GAAG,UAAU,GAAG,OAAO,CAAC,GACxF,YAAY,CAAC,OAAO,aAAa,CAAC,GAClC,CACI;IACE,QAAQ,EAAE,SAAS,CAAC;IACpB,qDAAqD;IACrD,IAAI,CAAC,EAAE,SAAS,CAAC;IACjB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,GACD;IACE,QAAQ,CAAC,EAAE,KAAK,CAAC;IACjB,IAAI,EAAE,SAAS,CAAC;IAChB,iEAAiE;IACjE,KAAK,EAAE,MAAM,CAAC;CACf,CACJ,CAAC;AAEJ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+CG;AACH,iBAAS,KAAK,CAAC,EACb,SAAS,EACT,OAAmB,EACnB,IAAW,EACX,IAAI,EACJ,QAAQ,EACR,MAAM,EACN,GAAG,KAAK,EACT,EAAE,UAAU,8FA0BZ;AAED,OAAO,EAAE,KAAK,EAAE,aAAa,EAAE,KAAK,UAAU,EAAE,KAAK,SAAS,EAAE,CAAC"}

package/dist/components/badge.js

@@ -35,11 +35,12 @@ const badgeVariants = cva("group/badge inline-flex w-fit max-w-full shrink-0 ite
  * type beside it: `sm` (20 px) next to small labels, `md` (24 px) in a row, `lg` (32 px) in a
  * header. The category fills (teal, purple, pink) name a kind.
  * @instead "For a colored dot without text, use `Status Dot`." (https://vercel.com/geist/badge)
- * Ours: status dots are not used; a state keeps its mark and word together in `StatusBadge`.
+ * Ours: a single dot is never a status; a state is `StatusBadge`, its tone's shape of dots and its
+ * word, with no pill.
  * "For clickable filter chips that toggle a query, use the `pill` variant or a small `Button`." (https://vercel.com/geist/badge)
  * Ours: there is no `pill` variant; a filter that toggles a query is a `Button` or
- * `CollectionFilters`. For a state use `StatusBadge`, which picks the tone and its mark: the gray,
- * green, red, amber and blue fills, soft or solid, are its alone. One categorical fact in a row is
+ * `CollectionFilters`. For a state use `StatusBadge`, which draws the tone as its shape; Badge has
+ * no gray, green, red, amber or blue fill. One categorical fact in a row is
  * a `Tag`. A change in a figure is a `TrendBadge`.
  * @behaviour "Badges are static labels." (https://vercel.com/geist/badge)
  * "Don’t wire `onClick` onto them; promote to a Button or link if the user can act on the value." (https://vercel.com/geist/badge)
@@ -52,11 +53,11 @@ const badgeVariants = cva("group/badge inline-flex w-fit max-w-full shrink-0 ite
  * Ours: the badge is the `render` of a `TooltipTrigger` with `tabIndex={0}`, so keyboard and touch
  * users reach the limit it names.
  * "Don’t add a checkmark icon for success states or an X for errors; the variant carries that signal." (https://vercel.com/geist/badge)
- * Ours: only `StatusBadge` carries a state, and it always draws its tone's mark.
+ * Ours: only `StatusBadge` carries a state, and it always draws its tone's shape.
  * "Map meaning to color: `green` for healthy, `red` for error, `amber` for warning, `blue` for informational or production, `gray` for neutral." (https://vercel.com/geist/badge)
  * "The `-subtle` suffix tones any of them down on dense surfaces." (https://vercel.com/geist/badge)
- * Ours: those fills are `StatusBadge`'s, as the tones `success`, `danger`, `warning`, `info` and
- * `neutral`, with `emphasis` `subtle` or `solid`. `Badge` is a fixed-height pill (20, 24 or 32 px)
+ * Ours: those meanings are `StatusBadge`'s, as the tones `success`, `danger`, `warning`, `info` and
+ * `neutral`, each drawn as its shape. `Badge` is a fixed-height pill (20, 24 or 32 px)
  * with no border: colour sits on the fill and the word. A soft fill takes its hue's strong shade
  * for the word, `default` is the foreground colour inverted, and `outline` is neutral, a
  * page-colour fill held by a 1 px inset ring. With an icon, the left padding is 6, 8 or 12 px, so

package/dist/components/status-badge.d.ts

@@ -1,56 +1,51 @@
 import type { ComponentProps } from "react";
-import { type BadgeSize } from "./badge.js";
 type StatusBadgeTone = "success" | "warning" | "danger" | "info" | "neutral";
-type StatusBadgeEmphasis = "subtle" | "solid";
+type StatusBadgeSize = "sm" | "md" | "lg";
 type StatusBadgeProps = Omit<ComponentProps<"span">, "children" | "onClick"> & {
     tone: StatusBadgeTone;
     label: string;
-    size?: BadgeSize;
-    /** `subtle` in rows, tables, lists and menus; `solid` where the status stands on its own. */
-    emphasis?: StatusBadgeEmphasis;
+    size?: StatusBadgeSize;
     /** How long the status has held, set after the word in tabular figures. */
     since?: string;
 };
 /**
- * A record's state: a mark and a word in one of five tones.
+ * A record's state: a shape of dots and a word, in one of five tones.
  *
  * @family Status
  * @when "Use Badge for short, scannable metadata that sits next to the thing it describes: status, plan tier, environment, or role." (https://vercel.com/geist/badge)
  * Ours: a record's state, when it sets the row apart: failed, waiting on a person, a step in
  * motion, paused, connected. Gray is the default and every terminal state that needs no action;
  * green is healthy or complete; red is unusable or failed; amber is waiting on a person's
- * decision; blue is a step in motion.
+ * decision; blue is a step in motion. Each tone has its own shape: green a circle, blue a diamond,
+ * amber a triangle, red a square, gray an empty ring.
  * "Map meaning to color: `green` for healthy, `red` for error, `amber` for warning, `blue` for informational or production, `gray` for neutral." (https://vercel.com/geist/badge)
  * Ours: success is green, danger red, warning amber, info blue, neutral gray, whatever the state's
  * name, in our colour values. The tone and the word are required, and the type asks for both.
  * @instead "For non-deployment statuses (Workflow runs, Queue messages, Sandbox, Cron jobs), use a `Badge` with the canonical state vocabulary instead of repurposing the dot." (https://vercel.com/geist/status-dot)
  * Ours: that `Badge` is `StatusBadge`. For a category (an installation, a partner) use `Tag`. For
  * plain metadata (a role, a plan) use `Badge`. For a control reporting its own action use
- * `ActionStatus`. A state beside its name still uses this badge; status dots are not used.
+ * `ActionStatus`. A state beside its name still uses this component.
  * @behaviour "Badges are static labels." (https://vercel.com/geist/badge)
  * "Don’t wire `onClick` onto them; promote to a Button or link if the user can act on the value." (https://vercel.com/geist/badge)
- * Ours: a status never moves and is never a button.
- * "The `-subtle` suffix tones any of them down on dense surfaces." (https://vercel.com/geist/badge)
- * Ours: `subtle`, the default, is for rows, tables, lists and menus: it fills the pill with the
- * tone's soft ground and sets the mark and the word in its strong shade; gray takes the foreground
- * colour, never a muted one. `solid` is for a status that stands on its own, such as an object's
- * page header or a card title: it fills the pill with the tone's strong colour and sets the mark
- * and the word on it. No border and no ring either way. The `subtle` pairs are the tone's soft
- * ground with its deep shade (gray: `canvas-soft-2` with the foreground colour).
- * "Don’t add a checkmark icon for success states or an X for errors; the variant carries that signal." (https://vercel.com/geist/badge)
- * Ours: it always draws its tone's mark, even for success and error: the mark repeats the tone as a
- * shape so a status reads without colour. Each app keeps one value-to-tone map in one module;
- * nothing else picks a status colour. A healthy record shows no badge, except the
- * operational-state and run-outcome columns defined by DESIGN.md's Status rule.
+ * Ours: a status never moves and is never a button. It is the tone's shape and the word, with no
+ * pill, no fill and no border, as Vercel's deployment list sets a state beside its time. The shape
+ * is filled with dots on a honeycomb grid, the material of the Agent orbs: an outline of evenly
+ * spaced dots and a field of dots inside it; gray's ring stays empty, the quiet tone. The dots
+ * take the tone's colour and the word the foreground colour; amber's outline takes its deep step
+ * so the triangle holds on white. `size`
+ * follows the type beside it: `sm` (a 14 px shape, 12 px word) in a small line such as an Agent's
+ * state line, `md` (16 px, 13 px) in a row, `lg` (20 px, 14 px) beside an object's name.
  * @words "Title Case, one word when possible, two max: `Active`, `Pending`, `Pro`, `Enterprise Trial`." (https://vercel.com/geist/badge)
  * Ours: a state, not a verb (*Failed*, *Waiting for you*), in sentence case, one to three words, no
  * trailing ellipsis. Italian runs a third longer: *In attesa di te*.
  * "Match the canonical API or log term: `Production` not `Prod`, `Deployed` not `Live`, `Canceled` not `Cancelled` (the Vercel API uses one L)." (https://vercel.com/geist/badge)
  * "Skip stuffing sentences inside (`Currently Active`, `You are on Pro`); the surrounding row supplies the context." (https://vercel.com/geist/badge)
  * @access "Don’t rely on color alone; the text has to be readable without it." (https://vercel.com/geist/badge)
- * Ours: the word is the name; the mark is `aria-hidden`, so colour never carries the state alone.
- * Not focusable.
+ * Ours: the word is the name; the shape is `aria-hidden`, so colour never carries the state alone.
+ * Not focusable. Each app keeps one value-to-tone map in one module; nothing else picks a status
+ * colour. A healthy record shows no status, except the operational-state and run-outcome columns
+ * defined by DESIGN.md's Status rule.
  */
-declare function StatusBadge({ tone, label, since, className, size, emphasis, ...props }: StatusBadgeProps): import("react").JSX.Element;
-export { StatusBadge, type StatusBadgeEmphasis, type StatusBadgeProps, type StatusBadgeTone };
+declare function StatusBadge({ tone, label, since, className, size, ...props }: StatusBadgeProps): import("react").JSX.Element;
+export { StatusBadge, type StatusBadgeProps, type StatusBadgeTone };
 //# sourceMappingURL=status-badge.d.ts.map

package/dist/components/status-badge.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"status-badge.d.ts","sourceRoot":"","sources":["../../src/components/status-badge.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,OAAO,CAAC;AAG5C,OAAO,EAAS,KAAK,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAG3D,KAAK,eAAe,GAAG,SAAS,GAAG,SAAS,GAAG,QAAQ,GAAG,MAAM,GAAG,SAAS,CAAC;AAE7E,KAAK,mBAAmB,GAAG,QAAQ,GAAG,OAAO,CAAC;AAgD9C,KAAK,gBAAgB,GAAG,IAAI,CAAC,cAAc,CAAC,MAAM,CAAC,EAAE,UAAU,GAAG,SAAS,CAAC,GAAG;IAC7E,IAAI,EAAE,eAAe,CAAC;IACtB,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,SAAS,CAAC;IACjB,6FAA6F;IAC7F,QAAQ,CAAC,EAAE,mBAAmB,CAAC;IAC/B,2EAA2E;IAC3E,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AACH,iBAAS,WAAW,CAAC,EACnB,IAAI,EACJ,KAAK,EACL,KAAK,EACL,SAAS,EACT,IAAW,EACX,QAAmB,EACnB,GAAG,KAAK,EACT,EAAE,gBAAgB,+BAqBlB;AAED,OAAO,EAAE,WAAW,EAAE,KAAK,mBAAmB,EAAE,KAAK,gBAAgB,EAAE,KAAK,eAAe,EAAE,CAAC"}
+{"version":3,"file":"status-badge.d.ts","sourceRoot":"","sources":["../../src/components/status-badge.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,OAAO,CAAC;AAS5C,KAAK,eAAe,GAAG,SAAS,GAAG,SAAS,GAAG,QAAQ,GAAG,MAAM,GAAG,SAAS,CAAC;AAE7E,KAAK,eAAe,GAAG,IAAI,GAAG,IAAI,GAAG,IAAI,CAAC;AAsD1C,KAAK,gBAAgB,GAAG,IAAI,CAAC,cAAc,CAAC,MAAM,CAAC,EAAE,UAAU,GAAG,SAAS,CAAC,GAAG;IAC7E,IAAI,EAAE,eAAe,CAAC;IACtB,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,eAAe,CAAC;IACvB,2EAA2E;IAC3E,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,iBAAS,WAAW,CAAC,EAAE,IAAI,EAAE,KAAK,EAAE,KAAK,EAAE,SAAS,EAAE,IAAW,EAAE,GAAG,KAAK,EAAE,EAAE,gBAAgB,+BA4B9F;AAED,OAAO,EAAE,WAAW,EAAE,KAAK,gBAAgB,EAAE,KAAK,eAAe,EAAE,CAAC"}

package/dist/components/status-badge.js

@@ -1,93 +1,71 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { CircleCheck, CircleDot, CirclePause, CircleX, Clock } from "lucide-react";
-import { Badge } from "./badge.js";
+import { STATUS_MARK_DOT_RADIUS, STATUS_MARK_PATHS, } from "../internal/status-mark.js";
 import { cn } from "../lib/utils.js";
-const FILL_BY_TONE = {
-    success: {
-        name: "green",
-        subtle: "bg-success-soft text-success-soft-foreground",
-        solid: "bg-success text-success-foreground",
-    },
+// One shape per tone, always the same one: the tone said again as a shape, so a
+// status reads without colour. Amber's edge takes the deep step, because giallo
+// alone does not hold a shape on white.
+const TONE = {
+    success: { name: "green", shape: "circle", ink: "text-success" },
     warning: {
         name: "amber",
-        subtle: "bg-warning-soft text-warning-soft-foreground",
-        solid: "bg-warning text-warning-foreground",
-    },
-    danger: {
-        name: "red",
-        subtle: "bg-destructive-soft text-destructive-soft-foreground",
-        solid: "bg-destructive text-destructive-foreground",
-    },
-    info: {
-        name: "blue",
-        subtle: "bg-info-soft text-info-soft-foreground",
-        solid: "bg-info text-info-foreground",
+        shape: "triangle",
+        ink: "text-warning",
+        edge: "text-warning-soft-foreground",
     },
-    neutral: {
-        name: "gray",
-        subtle: "bg-accent text-foreground",
-        solid: "bg-muted-foreground text-background",
-    },
-};
-// One mark per tone, always the same one: the tone said again as a shape, so a
-// status reads without colour. The info dot is filled and still.
-const MARK_BY_TONE = {
-    success: CircleCheck,
-    warning: Clock,
-    danger: CircleX,
-    info: CircleDot,
-    neutral: CirclePause,
+    danger: { name: "red", shape: "square", ink: "text-destructive" },
+    info: { name: "blue", shape: "diamond", ink: "text-info" },
+    neutral: { name: "gray", shape: "ring", ink: "text-muted-foreground" },
 };
-// Every mark is a circle, which has less air round it than a square glyph, so
-// it sits closer to the pill's edge.
-const CIRCLE_MARK_INSET = {
-    sm: "has-data-[icon=inline-start]:pl-1",
-    md: "has-data-[icon=inline-start]:pl-1.25",
-    lg: "has-data-[icon=inline-start]:pl-2",
+const SIZE = {
+    sm: { text: "text-caption gap-1", mark: "size-3.5" },
+    md: { text: "text-label-sm gap-1.5", mark: "size-4" },
+    lg: { text: "text-label gap-2", mark: "size-5" },
 };
+function StatusMark({ shape, className, edge, }) {
+    const paths = STATUS_MARK_PATHS[shape];
+    return (_jsxs("svg", { "aria-hidden": "true", className: cn("shrink-0", className), "data-slot": "status-badge-mark", "data-mark": shape, fill: "none", stroke: "currentColor", strokeLinecap: "round", viewBox: "-10 -10 20 20", children: [_jsx("path", { d: paths.inner, strokeOpacity: 0.92, strokeWidth: 2 * STATUS_MARK_DOT_RADIUS.inner }), _jsx("path", { className: edge, d: paths.edge, strokeWidth: 2 * STATUS_MARK_DOT_RADIUS.edge })] }));
+}
 /**
- * A record's state: a mark and a word in one of five tones.
+ * A record's state: a shape of dots and a word, in one of five tones.
  *
  * @family Status
  * @when "Use Badge for short, scannable metadata that sits next to the thing it describes: status, plan tier, environment, or role." (https://vercel.com/geist/badge)
  * Ours: a record's state, when it sets the row apart: failed, waiting on a person, a step in
  * motion, paused, connected. Gray is the default and every terminal state that needs no action;
  * green is healthy or complete; red is unusable or failed; amber is waiting on a person's
- * decision; blue is a step in motion.
+ * decision; blue is a step in motion. Each tone has its own shape: green a circle, blue a diamond,
+ * amber a triangle, red a square, gray an empty ring.
  * "Map meaning to color: `green` for healthy, `red` for error, `amber` for warning, `blue` for informational or production, `gray` for neutral." (https://vercel.com/geist/badge)
  * Ours: success is green, danger red, warning amber, info blue, neutral gray, whatever the state's
  * name, in our colour values. The tone and the word are required, and the type asks for both.
  * @instead "For non-deployment statuses (Workflow runs, Queue messages, Sandbox, Cron jobs), use a `Badge` with the canonical state vocabulary instead of repurposing the dot." (https://vercel.com/geist/status-dot)
  * Ours: that `Badge` is `StatusBadge`. For a category (an installation, a partner) use `Tag`. For
  * plain metadata (a role, a plan) use `Badge`. For a control reporting its own action use
- * `ActionStatus`. A state beside its name still uses this badge; status dots are not used.
+ * `ActionStatus`. A state beside its name still uses this component.
  * @behaviour "Badges are static labels." (https://vercel.com/geist/badge)
  * "Don’t wire `onClick` onto them; promote to a Button or link if the user can act on the value." (https://vercel.com/geist/badge)
- * Ours: a status never moves and is never a button.
- * "The `-subtle` suffix tones any of them down on dense surfaces." (https://vercel.com/geist/badge)
- * Ours: `subtle`, the default, is for rows, tables, lists and menus: it fills the pill with the
- * tone's soft ground and sets the mark and the word in its strong shade; gray takes the foreground
- * colour, never a muted one. `solid` is for a status that stands on its own, such as an object's
- * page header or a card title: it fills the pill with the tone's strong colour and sets the mark
- * and the word on it. No border and no ring either way. The `subtle` pairs are the tone's soft
- * ground with its deep shade (gray: `canvas-soft-2` with the foreground colour).
- * "Don’t add a checkmark icon for success states or an X for errors; the variant carries that signal." (https://vercel.com/geist/badge)
- * Ours: it always draws its tone's mark, even for success and error: the mark repeats the tone as a
- * shape so a status reads without colour. Each app keeps one value-to-tone map in one module;
- * nothing else picks a status colour. A healthy record shows no badge, except the
- * operational-state and run-outcome columns defined by DESIGN.md's Status rule.
+ * Ours: a status never moves and is never a button. It is the tone's shape and the word, with no
+ * pill, no fill and no border, as Vercel's deployment list sets a state beside its time. The shape
+ * is filled with dots on a honeycomb grid, the material of the Agent orbs: an outline of evenly
+ * spaced dots and a field of dots inside it; gray's ring stays empty, the quiet tone. The dots
+ * take the tone's colour and the word the foreground colour; amber's outline takes its deep step
+ * so the triangle holds on white. `size`
+ * follows the type beside it: `sm` (a 14 px shape, 12 px word) in a small line such as an Agent's
+ * state line, `md` (16 px, 13 px) in a row, `lg` (20 px, 14 px) beside an object's name.
  * @words "Title Case, one word when possible, two max: `Active`, `Pending`, `Pro`, `Enterprise Trial`." (https://vercel.com/geist/badge)
  * Ours: a state, not a verb (*Failed*, *Waiting for you*), in sentence case, one to three words, no
  * trailing ellipsis. Italian runs a third longer: *In attesa di te*.
  * "Match the canonical API or log term: `Production` not `Prod`, `Deployed` not `Live`, `Canceled` not `Cancelled` (the Vercel API uses one L)." (https://vercel.com/geist/badge)
  * "Skip stuffing sentences inside (`Currently Active`, `You are on Pro`); the surrounding row supplies the context." (https://vercel.com/geist/badge)
  * @access "Don’t rely on color alone; the text has to be readable without it." (https://vercel.com/geist/badge)
- * Ours: the word is the name; the mark is `aria-hidden`, so colour never carries the state alone.
- * Not focusable.
+ * Ours: the word is the name; the shape is `aria-hidden`, so colour never carries the state alone.
+ * Not focusable. Each app keeps one value-to-tone map in one module; nothing else picks a status
+ * colour. A healthy record shows no status, except the operational-state and run-outcome columns
+ * defined by DESIGN.md's Status rule.
  */
-function StatusBadge({ tone, label, since, className, size = "md", emphasis = "subtle", ...props }) {
-    const Mark = MARK_BY_TONE[tone];
-    const fill = FILL_BY_TONE[tone];
-    return (_jsxs(Badge, { className: cn(fill[emphasis], CIRCLE_MARK_INSET[size], className), "data-emphasis": emphasis, "data-variant": fill.name, icon: _jsx(Mark, { "aria-hidden": "true" }), size: size, ...props, children: [label, since ? (_jsx("span", { className: "tabular-nums", "data-slot": "status-badge-since", children: since })) : null] }));
+function StatusBadge({ tone, label, since, className, size = "md", ...props }) {
+    const { name, shape, ink, edge } = TONE[tone];
+    const { text, mark } = SIZE[size];
+    return (_jsxs("span", { className: cn("inline-flex w-fit max-w-full shrink-0 items-center font-medium whitespace-nowrap text-foreground", text, className), "data-size": size, "data-slot": "status-badge", "data-variant": name, ...props, children: [_jsx(StatusMark, { className: cn(mark, ink), edge: edge, shape: shape }), label, since ? (_jsx("span", { className: "font-normal text-muted-foreground tabular-nums", "data-slot": "status-badge-since", children: since })) : null] }));
 }
 export { StatusBadge };

package/dist/internal/status-mark.d.ts

@@ -0,0 +1,16 @@
+export type StatusMarkShape = "circle" | "diamond" | "triangle" | "square" | "ring";
+export type StatusMarkDot = {
+    x: number;
+    y: number;
+    edge: boolean;
+};
+export declare const STATUS_MARK_DOTS: Record<StatusMarkShape, readonly StatusMarkDot[]>;
+export declare const STATUS_MARK_DOT_RADIUS: {
+    readonly inner: 0.7;
+    readonly edge: 0.76;
+};
+export declare const STATUS_MARK_PATHS: Record<StatusMarkShape, {
+    inner: string;
+    edge: string;
+}>;
+//# sourceMappingURL=status-mark.d.ts.map

package/dist/internal/status-mark.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"status-mark.d.ts","sourceRoot":"","sources":["../../src/internal/status-mark.ts"],"names":[],"mappings":"AAQA,MAAM,MAAM,eAAe,GAAG,QAAQ,GAAG,SAAS,GAAG,UAAU,GAAG,QAAQ,GAAG,MAAM,CAAC;AAEpF,MAAM,MAAM,aAAa,GAAG;IAAE,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,OAAO,CAAA;CAAE,CAAC;AA+GpE,eAAO,MAAM,gBAAgB,EAAE,MAAM,CAAC,eAAe,EAAE,SAAS,aAAa,EAAE,CAM9E,CAAC;AAEF,eAAO,MAAM,sBAAsB;;;CAAsC,CAAC;AAgB1E,eAAO,MAAM,iBAAiB,EAAE,MAAM,CAAC,eAAe,EAAE;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAMtF,CAAC"}

package/dist/internal/status-mark.js

@@ -0,0 +1,128 @@
+/*
+ * The five status marks: a shape filled with dots on a honeycomb grid, the
+ * material of the Agent orbs' dotted forms. Every coordinate is on a 20-unit
+ * square centred on 0, the size the marks are tuned at; a row of evenly spaced
+ * edge dots draws the outline and the inner dots keep clear of it, so the
+ * shape reads before the texture. The dots are computed once, at load.
+ */
+const PITCH = 1.9;
+// Sized by eye so the five carry the same weight beside a word; the triangle
+// sits low because its weight is in its base.
+const MARKS = {
+    circle: { outline: { kind: "circle", r: 6.7 } },
+    diamond: {
+        outline: {
+            kind: "polygon",
+            corners: [
+                [0, -7.8],
+                [7.8, 0],
+                [0, 7.8],
+                [-7.8, 0],
+            ],
+        },
+    },
+    triangle: {
+        outline: {
+            kind: "polygon",
+            corners: [
+                [0, -6.9],
+                [7.9, 6.6],
+                [-7.9, 6.6],
+            ],
+        },
+    },
+    square: {
+        outline: {
+            kind: "polygon",
+            corners: [
+                [-5.8, -5.8],
+                [5.8, -5.8],
+                [5.8, 5.8],
+                [-5.8, 5.8],
+            ],
+        },
+    },
+    ring: { outline: { kind: "circle", r: 6.7 }, hollow: true },
+};
+function sides(corners) {
+    return corners.map((start, index) => [start, corners[(index + 1) % corners.length]]);
+}
+function contains(outline, [x, y]) {
+    if (outline.kind === "circle")
+        return Math.hypot(x, y) <= outline.r;
+    let inside = false;
+    for (const [[ax, ay], [bx, by]] of sides(outline.corners)) {
+        if (ay > y !== by > y && x < ((bx - ax) * (y - ay)) / (by - ay) + ax)
+            inside = !inside;
+    }
+    return inside;
+}
+function distanceToEdge(outline, [x, y]) {
+    if (outline.kind === "circle")
+        return outline.r - Math.hypot(x, y);
+    return Math.min(...sides(outline.corners).map(([[ax, ay], [bx, by]]) => {
+        const dx = bx - ax;
+        const dy = by - ay;
+        const t = Math.max(0, Math.min(1, ((x - ax) * dx + (y - ay) * dy) / (dx * dx + dy * dy)));
+        return Math.hypot(x - ax - t * dx, y - ay - t * dy);
+    }));
+}
+// A dot on every corner, then evenly spaced along each side.
+function edgeDots(outline) {
+    if (outline.kind === "circle") {
+        const count = Math.round((2 * Math.PI * outline.r) / PITCH);
+        return Array.from({ length: count }, (_, index) => {
+            const angle = -Math.PI / 2 + (index / count) * 2 * Math.PI;
+            return [Math.cos(angle) * outline.r, Math.sin(angle) * outline.r];
+        });
+    }
+    return sides(outline.corners).flatMap(([[ax, ay], [bx, by]]) => {
+        const count = Math.max(1, Math.round(Math.hypot(bx - ax, by - ay) / PITCH));
+        return Array.from({ length: count }, (_, step) => [ax + ((bx - ax) * step) / count, ay + ((by - ay) * step) / count]);
+    });
+}
+function innerDots(outline) {
+    const rowHeight = (PITCH * Math.sqrt(3)) / 2;
+    const dots = [];
+    for (let row = -6; row <= 6; row++) {
+        for (let column = -6; column <= 6; column++) {
+            const dot = [column * PITCH + (row % 2 === 0 ? 0 : PITCH / 2), row * rowHeight];
+            if (contains(outline, dot) && distanceToEdge(outline, dot) >= PITCH * 0.85)
+                dots.push(dot);
+        }
+    }
+    return dots;
+}
+function dotsOf(shape) {
+    const { outline, hollow } = MARKS[shape];
+    return [
+        ...(hollow ? [] : innerDots(outline)).map(([x, y]) => ({ x, y, edge: false })),
+        ...edgeDots(outline).map(([x, y]) => ({ x, y, edge: true })),
+    ];
+}
+export const STATUS_MARK_DOTS = {
+    circle: dotsOf("circle"),
+    diamond: dotsOf("diamond"),
+    triangle: dotsOf("triangle"),
+    square: dotsOf("square"),
+    ring: dotsOf("ring"),
+};
+export const STATUS_MARK_DOT_RADIUS = { inner: 0.7, edge: 0.76 };
+// Each layer of dots as one path of zero-length strokes: drawn with round caps
+// at twice the dot's radius, every `M x y h0` is one dot, so a mark is two
+// nodes however many dots it has.
+const pathOf = (dots) => dots.map(({ x, y }) => `M${x.toFixed(2)} ${y.toFixed(2)}h0`).join("");
+function pathsOf(shape) {
+    const dots = STATUS_MARK_DOTS[shape];
+    return {
+        inner: pathOf(dots.filter((dot) => !dot.edge)),
+        edge: pathOf(dots.filter((dot) => dot.edge)),
+    };
+}
+export const STATUS_MARK_PATHS = {
+    circle: pathsOf("circle"),
+    diamond: pathsOf("diamond"),
+    triangle: pathsOf("triangle"),
+    square: pathsOf("square"),
+    ring: pathsOf("ring"),
+};

package/dist/showcase/usage.generated.js

@@ -669,8 +669,8 @@ export const USAGE = [
         family: "Status",
         summary: 'Short metadata beside its subject: a role, a plan, "Beta".',
         when: '"Use Badge for short, scannable metadata that sits next to the thing it describes: status, plan tier, environment, or role." (https://vercel.com/geist/badge) "One badge per row; two side by side is a sign the row needs a second column." (https://vercel.com/geist/badge) Ours: a state is a `StatusBadge`; a `Badge` is a role (*Owner*), a plan, an environment, *Beta*. It always has a word, or one `icon` with a `title`, and the type asks for it. `size` follows the type beside it: `sm` (20 px) next to small labels, `md` (24 px) in a row, `lg` (32 px) in a header. The category fills (teal, purple, pink) name a kind.',
-        instead: '"For a colored dot without text, use `Status Dot`." (https://vercel.com/geist/badge) Ours: status dots are not used; a state keeps its mark and word together in `StatusBadge`. "For clickable filter chips that toggle a query, use the `pill` variant or a small `Button`." (https://vercel.com/geist/badge) Ours: there is no `pill` variant; a filter that toggles a query is a `Button` or `CollectionFilters`. For a state use `StatusBadge`, which picks the tone and its mark: the gray, green, red, amber and blue fills, soft or solid, are its alone. One categorical fact in a row is a `Tag`. A change in a figure is a `TrendBadge`.',
-        behaviour: '"Badges are static labels." (https://vercel.com/geist/badge) "Don’t wire `onClick` onto them; promote to a Button or link if the user can act on the value." (https://vercel.com/geist/badge) Ours: it takes no `onClick`, no hover and no focus; it becomes a link only through `render` with a real anchor, and only `outline` takes the hover, a gray fill. "Keep badge content to text or `icon` + text." (https://vercel.com/geist/badge) "Never stack two icons or a child Badge inside a Badge." (https://vercel.com/geist/badge) Ours: never a paragraph either. "Pair lifecycle badges (`Alpha`, `Beta`, `Early Access`) with a `Tooltip` that names the limit, like `Alpha: API may change before GA`." (https://vercel.com/geist/badge) Ours: the badge is the `render` of a `TooltipTrigger` with `tabIndex={0}`, so keyboard and touch users reach the limit it names. "Don’t add a checkmark icon for success states or an X for errors; the variant carries that signal." (https://vercel.com/geist/badge) Ours: only `StatusBadge` carries a state, and it always draws its tone\'s mark. "Map meaning to color: `green` for healthy, `red` for error, `amber` for warning, `blue` for informational or production, `gray` for neutral." (https://vercel.com/geist/badge) "The `-subtle` suffix tones any of them down on dense surfaces." (https://vercel.com/geist/badge) Ours: those fills are `StatusBadge`\'s, as the tones `success`, `danger`, `warning`, `info` and `neutral`, with `emphasis` `subtle` or `solid`. `Badge` is a fixed-height pill (20, 24 or 32 px) with no border: colour sits on the fill and the word. A soft fill takes its hue\'s strong shade for the word, `default` is the foreground colour inverted, and `outline` is neutral, a page-colour fill held by a 1 px inset ring. With an icon, the left padding is 6, 8 or 12 px, so the mark and the word look evenly spaced. The icon takes the word\'s colour.',
+        instead: '"For a colored dot without text, use `Status Dot`." (https://vercel.com/geist/badge) Ours: a single dot is never a status; a state is `StatusBadge`, its tone\'s shape of dots and its word, with no pill. "For clickable filter chips that toggle a query, use the `pill` variant or a small `Button`." (https://vercel.com/geist/badge) Ours: there is no `pill` variant; a filter that toggles a query is a `Button` or `CollectionFilters`. For a state use `StatusBadge`, which draws the tone as its shape; Badge has no gray, green, red, amber or blue fill. One categorical fact in a row is a `Tag`. A change in a figure is a `TrendBadge`.',
+        behaviour: '"Badges are static labels." (https://vercel.com/geist/badge) "Don’t wire `onClick` onto them; promote to a Button or link if the user can act on the value." (https://vercel.com/geist/badge) Ours: it takes no `onClick`, no hover and no focus; it becomes a link only through `render` with a real anchor, and only `outline` takes the hover, a gray fill. "Keep badge content to text or `icon` + text." (https://vercel.com/geist/badge) "Never stack two icons or a child Badge inside a Badge." (https://vercel.com/geist/badge) Ours: never a paragraph either. "Pair lifecycle badges (`Alpha`, `Beta`, `Early Access`) with a `Tooltip` that names the limit, like `Alpha: API may change before GA`." (https://vercel.com/geist/badge) Ours: the badge is the `render` of a `TooltipTrigger` with `tabIndex={0}`, so keyboard and touch users reach the limit it names. "Don’t add a checkmark icon for success states or an X for errors; the variant carries that signal." (https://vercel.com/geist/badge) Ours: only `StatusBadge` carries a state, and it always draws its tone\'s shape. "Map meaning to color: `green` for healthy, `red` for error, `amber` for warning, `blue` for informational or production, `gray` for neutral." (https://vercel.com/geist/badge) "The `-subtle` suffix tones any of them down on dense surfaces." (https://vercel.com/geist/badge) Ours: those meanings are `StatusBadge`\'s, as the tones `success`, `danger`, `warning`, `info` and `neutral`, each drawn as its shape. `Badge` is a fixed-height pill (20, 24 or 32 px) with no border: colour sits on the fill and the word. A soft fill takes its hue\'s strong shade for the word, `default` is the foreground colour inverted, and `outline` is neutral, a page-colour fill held by a 1 px inset ring. With an icon, the left padding is 6, 8 or 12 px, so the mark and the word look evenly spaced. The icon takes the word\'s colour.',
         words: '"Title Case, one word when possible, two max: `Active`, `Pending`, `Pro`, `Enterprise Trial`." (https://vercel.com/geist/badge) Ours: sentence case (*Enterprise trial*). "Match the canonical API or log term: `Production` not `Prod`, `Deployed` not `Live`, `Canceled` not `Cancelled` (the Vercel API uses one L)." (https://vercel.com/geist/badge) Ours: the term is our own API\'s. "Skip stuffing sentences inside (`Currently Active`, `You are on Pro`); the surrounding row supplies the context." (https://vercel.com/geist/badge)',
         access: '"Set `title` for icon-only or ambiguous badges so screen readers announce the meaning." (https://vercel.com/geist/badge) Ours: an icon alone must set `title`, and the type asks for it. Read in place as text. "Don’t rely on color alone; the text has to be readable without it." (https://vercel.com/geist/badge) Ours: a coloured variant still carries its word.',
     },
@@ -788,12 +788,12 @@ export const USAGE = [
         name: "StatusBadge",
         module: "status-badge",
         family: "Status",
-        summary: "A record's state: a mark and a word in one of five tones.",
-        when: '"Use Badge for short, scannable metadata that sits next to the thing it describes: status, plan tier, environment, or role." (https://vercel.com/geist/badge) Ours: a record\'s state, when it sets the row apart: failed, waiting on a person, a step in motion, paused, connected. Gray is the default and every terminal state that needs no action; green is healthy or complete; red is unusable or failed; amber is waiting on a person\'s decision; blue is a step in motion. "Map meaning to color: `green` for healthy, `red` for error, `amber` for warning, `blue` for informational or production, `gray` for neutral." (https://vercel.com/geist/badge) Ours: success is green, danger red, warning amber, info blue, neutral gray, whatever the state\'s name, in our colour values. The tone and the word are required, and the type asks for both.',
-        instead: '"For non-deployment statuses (Workflow runs, Queue messages, Sandbox, Cron jobs), use a `Badge` with the canonical state vocabulary instead of repurposing the dot." (https://vercel.com/geist/status-dot) Ours: that `Badge` is `StatusBadge`. For a category (an installation, a partner) use `Tag`. For plain metadata (a role, a plan) use `Badge`. For a control reporting its own action use `ActionStatus`. A state beside its name still uses this badge; status dots are not used.',
-        behaviour: '"Badges are static labels." (https://vercel.com/geist/badge) "Don’t wire `onClick` onto them; promote to a Button or link if the user can act on the value." (https://vercel.com/geist/badge) Ours: a status never moves and is never a button. "The `-subtle` suffix tones any of them down on dense surfaces." (https://vercel.com/geist/badge) Ours: `subtle`, the default, is for rows, tables, lists and menus: it fills the pill with the tone\'s soft ground and sets the mark and the word in its strong shade; gray takes the foreground colour, never a muted one. `solid` is for a status that stands on its own, such as an object\'s page header or a card title: it fills the pill with the tone\'s strong colour and sets the mark and the word on it. No border and no ring either way. The `subtle` pairs are the tone\'s soft ground with its deep shade (gray: `canvas-soft-2` with the foreground colour). "Don’t add a checkmark icon for success states or an X for errors; the variant carries that signal." (https://vercel.com/geist/badge) Ours: it always draws its tone\'s mark, even for success and error: the mark repeats the tone as a shape so a status reads without colour. Each app keeps one value-to-tone map in one module; nothing else picks a status colour. A healthy record shows no badge, except the operational-state and run-outcome columns defined by DESIGN.md\'s Status rule.',
+        summary: "A record's state: a shape of dots and a word, in one of five tones.",
+        when: '"Use Badge for short, scannable metadata that sits next to the thing it describes: status, plan tier, environment, or role." (https://vercel.com/geist/badge) Ours: a record\'s state, when it sets the row apart: failed, waiting on a person, a step in motion, paused, connected. Gray is the default and every terminal state that needs no action; green is healthy or complete; red is unusable or failed; amber is waiting on a person\'s decision; blue is a step in motion. Each tone has its own shape: green a circle, blue a diamond, amber a triangle, red a square, gray an empty ring. "Map meaning to color: `green` for healthy, `red` for error, `amber` for warning, `blue` for informational or production, `gray` for neutral." (https://vercel.com/geist/badge) Ours: success is green, danger red, warning amber, info blue, neutral gray, whatever the state\'s name, in our colour values. The tone and the word are required, and the type asks for both.',
+        instead: '"For non-deployment statuses (Workflow runs, Queue messages, Sandbox, Cron jobs), use a `Badge` with the canonical state vocabulary instead of repurposing the dot." (https://vercel.com/geist/status-dot) Ours: that `Badge` is `StatusBadge`. For a category (an installation, a partner) use `Tag`. For plain metadata (a role, a plan) use `Badge`. For a control reporting its own action use `ActionStatus`. A state beside its name still uses this component.',
+        behaviour: "\"Badges are static labels.\" (https://vercel.com/geist/badge) \"Don’t wire `onClick` onto them; promote to a Button or link if the user can act on the value.\" (https://vercel.com/geist/badge) Ours: a status never moves and is never a button. It is the tone's shape and the word, with no pill, no fill and no border, as Vercel's deployment list sets a state beside its time. The shape is filled with dots on a honeycomb grid, the material of the Agent orbs: an outline of evenly spaced dots and a field of dots inside it; gray's ring stays empty, the quiet tone. The dots take the tone's colour and the word the foreground colour; amber's outline takes its deep step so the triangle holds on white. `size` follows the type beside it: `sm` (a 14 px shape, 12 px word) in a small line such as an Agent's state line, `md` (16 px, 13 px) in a row, `lg` (20 px, 14 px) beside an object's name.",
         words: '"Title Case, one word when possible, two max: `Active`, `Pending`, `Pro`, `Enterprise Trial`." (https://vercel.com/geist/badge) Ours: a state, not a verb (*Failed*, *Waiting for you*), in sentence case, one to three words, no trailing ellipsis. Italian runs a third longer: *In attesa di te*. "Match the canonical API or log term: `Production` not `Prod`, `Deployed` not `Live`, `Canceled` not `Cancelled` (the Vercel API uses one L)." (https://vercel.com/geist/badge) "Skip stuffing sentences inside (`Currently Active`, `You are on Pro`); the surrounding row supplies the context." (https://vercel.com/geist/badge)',
-        access: '"Don’t rely on color alone; the text has to be readable without it." (https://vercel.com/geist/badge) Ours: the word is the name; the mark is `aria-hidden`, so colour never carries the state alone. Not focusable.',
+        access: '"Don’t rely on color alone; the text has to be readable without it." (https://vercel.com/geist/badge) Ours: the word is the name; the shape is `aria-hidden`, so colour never carries the state alone. Not focusable. Each app keeps one value-to-tone map in one module; nothing else picks a status colour. A healthy record shows no status, except the operational-state and run-outcome columns defined by DESIGN.md\'s Status rule.',
     },
     {
         name: "Tag",
@@ -815,7 +815,7 @@ export const USAGE = [
         instead: "An Agent as a record among others in a page's list is a RecordList row with an agent IdentityMark; an Agent's own page heads with ObjectPage.",
         behaviour: "It is the row's presentation alone: the consumer owns the control around it (Nadia's button that opens the Agent, a scene's list item that opens nothing). The current row's name is set in 500. A state tone draws the state line as a small StatusBadge; without a tone it stays plain text. Narrow, the orb stands alone and the words stay for a screen reader; the consumer names it with its state line in a tooltip, as Nadia's list does. Only the orb moves in the list. The name is 14 px and the state line 12 px at every size. The drawn orb leaves about 10 px of its 64 px box empty, so at 64 px that empty edge overlaps the row's padding (6 px above and below, 4 px at the start) and the words stand 4 px from the box: the row hugs the visible orb and the name sits beside it, as beside a solid picture. In Nadia's list her orb is 64 px in her real state, and 40 px in the narrow column from 640 to 899 px.",
         words: 'The name, then one state line: what she is doing now ("Answering on Telegram", "Working") or what she is for ("Sorts requests"). The tone never says more than the line does. Nadia\'s list says "Working", "Idle" or "Needs you"; the badge marks a state that needs the person ("Needs you", a failed set-up), and the orb shows working by itself.',
-        access: "The orb is decorative; the name and the state line are the row's text, read by its control. StatusBadge owns its decorative mark, so the line carries its meaning.",
+        access: "The orb is decorative; the name and the state line are the row's text, read by its control. StatusBadge owns its decorative shape, so the line carries its meaning.",
     },
     {
         name: "Breadcrumb",

package/dist/styles/components.css

@@ -171,6 +171,7 @@
     :has(
       > :only-child:is(
           [data-slot="badge"],
+          [data-slot="status-badge"],
           [data-slot="trend-badge"],
           [data-slot="chart-sparkline"],
           [data-slot="button"],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nadicodeai/ui",
-  "version": "12.1.128",
+  "version": "12.1.129",
   "type": "module",
   "publishConfig": {
     "access": "public"
@@ -83,7 +83,7 @@
     "@base-ui/react": "^1.9.0",
     "@iconify-icons/logos": "^2.0.3",
     "@iconify/react": "^6.0.2",
-    "@nadicodeai/design-system": "12.1.128",
+    "@nadicodeai/design-system": "12.1.129",
     "@tanstack/react-table": "^9.3.1",
     "@vgpu/wgsl": "0.6.0",
     "class-variance-authority": "^0.7.1",