@verdify/ui 0.1.0

package/dist/components/tooltip/tooltip.js

@@ -0,0 +1,44 @@
+"use client";
+import { jsx, jsxs } from "react/jsx-runtime";
+import * as React from "react";
+import { Tooltip as TooltipPrimitive } from "radix-ui";
+import { cn } from "../../lib/cn";
+import { tooltipContentClass, tooltipArrowClass } from "./tooltip.variants";
+function TooltipProvider({ delayDuration = 300, ...props }) {
+  return /* @__PURE__ */ jsx(TooltipPrimitive.Provider, { delayDuration, ...props });
+}
+function Tooltip(props) {
+  return /* @__PURE__ */ jsx(TooltipPrimitive.Root, { ...props });
+}
+const TooltipTrigger = React.forwardRef(function TooltipTrigger2(props, ref) {
+  return /* @__PURE__ */ jsx(TooltipPrimitive.Trigger, { ref, ...props });
+});
+const TooltipContent = React.forwardRef(function TooltipContent2({ className, children, sideOffset = 6, arrow = true, variant: _variant = "description", ...props }, ref) {
+  return /* @__PURE__ */ jsx(TooltipPrimitive.Portal, { children: /* @__PURE__ */ jsxs(
+    TooltipPrimitive.Content,
+    {
+      ref,
+      "data-testid": "tooltip-content",
+      sideOffset,
+      className: cn(tooltipContentClass, className),
+      ...props,
+      children: [
+        children,
+        arrow ? /* @__PURE__ */ jsx(
+          TooltipPrimitive.Arrow,
+          {
+            "data-testid": "tooltip-arrow",
+            className: tooltipArrowClass
+          }
+        ) : null
+      ]
+    }
+  ) });
+});
+export {
+  Tooltip,
+  TooltipContent,
+  TooltipProvider,
+  TooltipTrigger
+};
+//# sourceMappingURL=tooltip.js.map

package/dist/components/tooltip/tooltip.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/components/tooltip/tooltip.tsx"],"sourcesContent":["\"use client\";\n\nimport * as React from \"react\";\nimport { Tooltip as TooltipPrimitive } from \"radix-ui\";\nimport { cn } from \"../../lib/cn\";\nimport { tooltipContentClass, tooltipArrowClass } from \"./tooltip.variants\";\n\nexport interface TooltipProviderProps\n  extends React.ComponentPropsWithoutRef<typeof TooltipPrimitive.Provider> {}\n\n/**\n * Wraps the app (or a region of it) to provide global tooltip timing (spec §4). It owns the open\n * DELAY: hovering a trigger opens its tooltip after a short delay (`delayDuration`), while moving\n * between triggers within `skipDelayDuration` opens the next one immediately, so a row of icon\n * buttons does not re-delay on every hover. Keyboard focus always opens with NO delay regardless of\n * this setting, so a keyboard user gets the same information a pointer user does (spec §4 Focus).\n *\n * `disableHoverableContent` is intentionally NOT defaulted on: leaving it OFF keeps the tooltip open\n * while the pointer moves onto the content, which is what makes the tooltip HOVERABLE under\n * WCAG 1.4.13 — disabling it has accessibility consequences, so prefer the default.\n *\n * Place ONE Provider near the root of the app; individual tooltips read its timing. Wraps the Radix\n * Tooltip Provider — a stateful primitive, so this file is `'use client'`.\n */\nexport function TooltipProvider({ delayDuration = 300, ...props }: TooltipProviderProps) {\n  return <TooltipPrimitive.Provider delayDuration={delayDuration} {...props} />;\n}\n\nexport interface TooltipProps\n  extends React.ComponentPropsWithoutRef<typeof TooltipPrimitive.Root> {}\n\n/**\n * One tooltip: the trigger-plus-tooltip pair (spec §2/§4). Wraps `TooltipTrigger` and\n * `TooltipContent`. The tooltip is hidden until its trigger is hovered or focused, stays open while\n * the trigger holds focus or the pointer is over the trigger or the content (WCAG 1.4.13 hoverable\n * / persistent), and is dismissible with Escape (1.4.13 dismissible) — Radix wires all of this. Pass\n * a per-tooltip `delayDuration` (e.g. `0` for an instant open) to override the Provider's timing.\n */\nexport function Tooltip(props: TooltipProps) {\n  return <TooltipPrimitive.Root {...props} />;\n}\n\nexport interface TooltipTriggerProps\n  extends React.ComponentPropsWithoutRef<typeof TooltipPrimitive.Trigger> {}\n\n/**\n * The control the tooltip describes (spec §2 trigger): a REAL control — a button, a link, a field —\n * never inert text. The trigger owns the single tab stop and the 2px focus ring; the tooltip itself\n * never takes focus (spec §2/§4 Focus/§7). Radix sets the trigger's `aria-describedby` to the\n * tooltip's id while it is open, so the tooltip is announced as a DESCRIPTION after the trigger's own\n * name (spec §7) — it supplements the name, it does not replace it.\n *\n * Pass `asChild` to project the trigger onto your own control (commonly a Button) so the trigger\n * inherits that control's role, keyboard, and focus ring rather than nesting a second button — the\n * Menu/Dialog trigger precedent.\n *\n * The `label` variant (spec §3): on an ICON-ONLY control with no other accessible name, give that\n * control its OWN name (e.g. `aria-label=\"Revoke\"`) so it is never nameless — the tooltip still\n * describes it. The Tooltip surface is identical for both variants; the distinction is purely how the\n * caller names the trigger, which is the caller's responsibility and cannot be forced onto an\n * arbitrary child here.\n */\nexport const TooltipTrigger = React.forwardRef<\n  React.ElementRef<typeof TooltipPrimitive.Trigger>,\n  TooltipTriggerProps\n>(function TooltipTrigger(props, ref) {\n  return <TooltipPrimitive.Trigger ref={ref} {...props} />;\n});\n\n/** The two spec §3 variants. They share ONE neutral surface; the distinction is how the trigger is named (§7). */\nexport type TooltipVariant = \"label\" | \"description\";\n\nexport interface TooltipContentProps\n  extends React.ComponentPropsWithoutRef<typeof TooltipPrimitive.Content> {\n  /**\n   * Which spec §3 variant this tooltip plays (default `description`). `description` adds a short hint\n   * to a control that already has a visible label; `label` shows AND names an icon-only control (the\n   * trigger must still carry its own `aria-label`/`aria-labelledby` — see `TooltipTrigger`). This is\n   * a documentation/intent marker: the rendered surface is identical for both, and Radix wires the\n   * trigger's `aria-describedby` either way — neutrals carry the whole surface, no status or brand\n   * tint, by design (spec §3/§5).\n   */\n  variant?: TooltipVariant;\n  /** Render the optional decorative arrow connecting the content to its trigger (spec §2 arrow). Default `true`. */\n  arrow?: boolean;\n}\n\n/**\n * The floating label (spec §2 content, §3/§5): a `role=\"tooltip\"` element holding ONE short line of\n * plain text, raised above the page on the POPOVER layer and anchored to its trigger. It holds NO\n * interactive content — no link, no button, no field (if you need those, you need a Popover, spec\n * §1/§2). It is a NON-MODAL popover: no scrim, no `aria-modal`, no focus-trap — focus never enters\n * it, so there is nothing to trap (spec §7). A NEUTRAL surface: the brand violet and a status color\n * never appear on a tooltip (spec §3/§5/§8, brand != state).\n *\n * The open/close is the FAST motion duration and a plain fade — no slide, no bounce — instant under\n * `prefers-reduced-motion`; never the deliberate \"check\" duration, which is the VerifiedBadge-only\n * theatre (spec §4, G-U3). Portaled so it escapes overflow clipping. The decorative arrow's `fill`\n * matches the surface; Radix's bare arrow does not carry the surface's outer BORDER edge — a\n * conformant, non-load-bearing deviation from the §5 \"arrow edge\" border, flagged for amendment\n * rather than hand-rolling a custom bordered arrow polygon.\n */\nexport const TooltipContent = React.forwardRef<\n  React.ElementRef<typeof TooltipPrimitive.Content>,\n  TooltipContentProps\n>(function TooltipContent(\n  // `variant` is consumed for intent/TSDoc only — it does not alter the rendered surface or the ARIA\n  // wiring (both variants are one neutral surface described via aria-describedby); destructured out so\n  // it is not spread onto the DOM element.\n  { className, children, sideOffset = 6, arrow = true, variant: _variant = \"description\", ...props },\n  ref,\n) {\n  return (\n    <TooltipPrimitive.Portal>\n      <TooltipPrimitive.Content\n        ref={ref}\n        // The VISIBLE styled popup. Radix renders the accessible `role=\"tooltip\"` node as a SEPARATE\n        // visually-hidden span (the `aria-describedby` target); this Content element carries the\n        // surface bindings + Radix's `data-state` but is presentational, so a testid is the reliable\n        // handle for the styled surface (the role node is found by `getByRole(\"tooltip\")`).\n        data-testid=\"tooltip-content\"\n        sideOffset={sideOffset}\n        className={cn(tooltipContentClass, className)}\n        {...props}\n      >\n        {children}\n        {arrow ? (\n          <TooltipPrimitive.Arrow\n            data-testid=\"tooltip-arrow\"\n            className={tooltipArrowClass}\n          />\n        ) : null}\n      </TooltipPrimitive.Content>\n    </TooltipPrimitive.Portal>\n  );\n});\n"],"mappings":";AAyBS,cAyFH,YAzFG;AAvBT,YAAY,WAAW;AACvB,SAAS,WAAW,wBAAwB;AAC5C,SAAS,UAAU;AACnB,SAAS,qBAAqB,yBAAyB;AAmBhD,SAAS,gBAAgB,EAAE,gBAAgB,KAAK,GAAG,MAAM,GAAyB;AACvF,SAAO,oBAAC,iBAAiB,UAAjB,EAA0B,eAA+B,GAAG,OAAO;AAC7E;AAYO,SAAS,QAAQ,OAAqB;AAC3C,SAAO,oBAAC,iBAAiB,MAAjB,EAAuB,GAAG,OAAO;AAC3C;AAsBO,MAAM,iBAAiB,MAAM,WAGlC,SAASA,gBAAe,OAAO,KAAK;AACpC,SAAO,oBAAC,iBAAiB,SAAjB,EAAyB,KAAW,GAAG,OAAO;AACxD,CAAC;AAmCM,MAAM,iBAAiB,MAAM,WAGlC,SAASC,gBAIT,EAAE,WAAW,UAAU,aAAa,GAAG,QAAQ,MAAM,SAAS,WAAW,eAAe,GAAG,MAAM,GACjG,KACA;AACA,SACE,oBAAC,iBAAiB,QAAjB,EACC;AAAA,IAAC,iBAAiB;AAAA,IAAjB;AAAA,MACC;AAAA,MAKA,eAAY;AAAA,MACZ;AAAA,MACA,WAAW,GAAG,qBAAqB,SAAS;AAAA,MAC3C,GAAG;AAAA,MAEH;AAAA;AAAA,QACA,QACC;AAAA,UAAC,iBAAiB;AAAA,UAAjB;AAAA,YACC,eAAY;AAAA,YACZ,WAAW;AAAA;AAAA,QACb,IACE;AAAA;AAAA;AAAA,EACN,GACF;AAEJ,CAAC;","names":["TooltipTrigger","TooltipContent"]}

package/dist/components/tooltip/tooltip.variants.d.ts

@@ -0,0 +1,3 @@
+export declare const tooltipContentClass: string;
+export declare const tooltipArrowClass = "fill-surface-raised";
+//# sourceMappingURL=tooltip.variants.d.ts.map

package/dist/components/tooltip/tooltip.variants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tooltip.variants.d.ts","sourceRoot":"","sources":["../../../src/components/tooltip/tooltip.variants.ts"],"names":[],"mappings":"AAuBA,eAAO,MAAM,mBAAmB,QAO6E,CAAC;AAM9G,eAAO,MAAM,iBAAiB,wBAAwB,CAAC"}

package/dist/components/tooltip/tooltip.variants.js

@@ -0,0 +1,7 @@
+const tooltipContentClass = "z-(--z-index-popover) max-w-(--container-sm) select-none px-(--space-3) py-(--space-2) bg-surface-raised border border-surface-border rounded-(--radius-sm) shadow-(--shadow-md) text-label text-text-primary transition-opacity duration-(--motion-duration-fast) ease-(--motion-easing-verdify) motion-reduce:duration-(--motion-duration-instant) data-[state=delayed-open]:opacity-100 data-[state=instant-open]:opacity-100 data-[state=closed]:opacity-0";
+const tooltipArrowClass = "fill-surface-raised";
+export {
+  tooltipArrowClass,
+  tooltipContentClass
+};
+//# sourceMappingURL=tooltip.variants.js.map

package/dist/components/tooltip/tooltip.variants.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/components/tooltip/tooltip.variants.ts"],"sourcesContent":["// A Tooltip is a small floating label that DESCRIBES the control it is attached to (spec §1). It is\n// a NON-MODAL popover, not a modal overlay: NO scrim, NO aria-modal, NO focus-trap — the page behind\n// stays live and the tooltip never takes focus. It is a NEUTRAL surface (spec §3/§5): the surface\n// and the only color on it (the text) are neutral, and NOTHING here binds a --color-status-* token\n// or the brand action-primary tier — a tooltip describes a control, it never reports a result, so\n// the brand violet and Verified Green never appear on it (brand != state, G-U2). This is the ONLY\n// token-binding site (skill §5 hard rule). All open/close motion is the FAST token transition on the\n// verdify easing, instant under reduced motion — never the 350ms VerifiedBadge-only theatre (G-U3).\n\n// The floating label (spec §2 content, §5): a NEUTRAL raised surface (--color-surface-raised) with\n// the outer surface border and the arrow edge color, the sm corner radius, and the md elevation\n// shadow above the page content, on the POPOVER z-layer (a tooltip is a non-modal popover layer, not\n// the modal layer). The label TEXT is the PRIMARY text color at the LABEL type role (spec §5\n// --color-text-primary / --text-label); the surface stays neutral and the only color is the text on\n// it. One short line — `max-w-(--container-sm)` keeps a long line from running the width of the\n// viewport, and the host can narrow it further via className. Internal padding from --space-2 /\n// --space-3 (the gap FROM the trigger is Radix's numeric `sideOffset`, a layout pixel offset with no\n// token-class seam, mirroring Menu's `sideOffset`). The open/close fade is a PLAIN fast transition +\n// verdify easing, instant under reduced motion — never the 350ms VerifiedBadge-only theatre (G-U3).\n// Enter/exit ride Radix's data-state on the content (attribute-selector variants, not arbitrary\n// values): Radix sets `delayed-open` (hover, after the open delay), `instant-open` (focus / no\n// delay), and `closed`, so BOTH open states fade in. `select-none` because a tooltip is read, not\n// selected.\nexport const tooltipContentClass =\n  \"z-(--z-index-popover) max-w-(--container-sm) select-none \" +\n  \"px-(--space-3) py-(--space-2) \" +\n  \"bg-surface-raised border border-surface-border rounded-(--radius-sm) shadow-(--shadow-md) \" +\n  \"text-label text-text-primary \" +\n  \"transition-opacity duration-(--motion-duration-fast) ease-(--motion-easing-verdify) \" +\n  \"motion-reduce:duration-(--motion-duration-instant) \" +\n  \"data-[state=delayed-open]:opacity-100 data-[state=instant-open]:opacity-100 data-[state=closed]:opacity-0\";\n\n// The arrow (spec §2 arrow): a small DECORATIVE pointer connecting the content to its trigger,\n// carrying no meaning of its own (it is aria-hidden via the wrapper). It is filled with the SAME\n// neutral raised surface as the content so the pointer reads as part of the surface, never a brand\n// or status fill (spec §3/§5). `fill-*` is the SVG fill utility for the Radix arrow polygon.\nexport const tooltipArrowClass = \"fill-surface-raised\";\n"],"mappings":"AAuBO,MAAM,sBACX;AAYK,MAAM,oBAAoB;","names":[]}

package/dist/components/trust-score/index.d.ts

@@ -0,0 +1,3 @@
+export { TrustScore, type TrustScoreProps, type TrustScoreVariant, type TrustScoreState, } from "./trust-score";
+export { trustScoreVariants, type TrustScoreVariantProps, } from "./trust-score.variants";
+//# sourceMappingURL=index.d.ts.map

package/dist/components/trust-score/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/components/trust-score/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,UAAU,EACV,KAAK,eAAe,EACpB,KAAK,iBAAiB,EACtB,KAAK,eAAe,GACrB,MAAM,eAAe,CAAC;AACvB,OAAO,EACL,kBAAkB,EAClB,KAAK,sBAAsB,GAC5B,MAAM,wBAAwB,CAAC"}

package/dist/components/trust-score/index.js

@@ -0,0 +1,11 @@
+import {
+  TrustScore
+} from "./trust-score";
+import {
+  trustScoreVariants
+} from "./trust-score.variants";
+export {
+  TrustScore,
+  trustScoreVariants
+};
+//# sourceMappingURL=index.js.map

package/dist/components/trust-score/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/components/trust-score/index.ts"],"sourcesContent":["export {\n  TrustScore,\n  type TrustScoreProps,\n  type TrustScoreVariant,\n  type TrustScoreState,\n} from \"./trust-score\";\nexport {\n  trustScoreVariants,\n  type TrustScoreVariantProps,\n} from \"./trust-score.variants\";\n"],"mappings":"AAAA;AAAA,EACE;AAAA,OAIK;AACP;AAAA,EACE;AAAA,OAEK;","names":[]}

package/dist/components/trust-score/trust-score.d.ts

@@ -0,0 +1,100 @@
+import * as React from "react";
+import { type TrustScoreVariantProps } from "./trust-score.variants";
+/** The display form of the TrustScore (spec §3). Defaults to `value`. */
+export type TrustScoreVariant = NonNullable<TrustScoreVariantProps["variant"]>;
+/**
+ * The state the score's VALUE can be in (spec §4). TrustScore is a status output, not a
+ * control, so it has no hover/pressed/focus/disabled state of its own — only the states
+ * its value can be in. Defaults to `default` (the resolved score at rest).
+ */
+export type TrustScoreState = "default" | "updating" | "loading" | "unavailable";
+export interface TrustScoreProps extends Omit<React.HTMLAttributes<HTMLDivElement>, "aria-label">, Pick<TrustScoreVariantProps, "variant" | "carded"> {
+    /**
+     * The trust score itself (spec §2/§4) — the rolled-up number. Rendered in tabular
+     * figures so digits hold their place when the value updates, always paired with the
+     * label; the digit alone never carries the meaning. Omit it only in the `loading` and
+     * `unavailable` states, where no honest number exists — never pass a guessed `0`.
+     */
+    score?: number;
+    /**
+     * The text naming what the number is, "Trust score" (spec §2). Rendered as visible text
+     * AND bound to the value as the group's accessible name (`aria-labelledby`). TrustScore
+     * is never an unlabeled number; provide EITHER a visible `label` or an `aria-label`.
+     */
+    label?: React.ReactNode;
+    /**
+     * The accessible name when no visible {@link label} fits (spec §7) — "Trust score".
+     * Used only when there is no visible label; the group is never nameless to assistive
+     * technology, and a bare figure is never left to read as a rating it is not.
+     */
+    "aria-label"?: string;
+    /**
+     * The plain bound the number reads against, "out of 100" (spec §2). Shown when the
+     * scale is not obvious from context, so the value is legible without the reader guessing
+     * the range. Also bounds the optional gauge's `aria-valuetext`.
+     */
+    scale?: React.ReactNode;
+    /**
+     * The upper bound of the scale (spec §7). Default `100`. Bounds the optional gauge
+     * (`aria-valuemax`) and the indicator length.
+     */
+    max?: number;
+    /**
+     * The lower bound of the scale (spec §7). Default `0`. Bounds the optional gauge
+     * (`aria-valuemin`) and the indicator length.
+     */
+    min?: number;
+    /**
+     * One line stating what the score means or when it last changed (spec §2), written as a
+     * statement ending with a period. Use it to keep the reader oriented, not to editorialise
+     * the number up or down.
+     */
+    description?: React.ReactNode;
+    /**
+     * The state the value is in (spec §4). `updating` announces the new value politely and
+     * settles it on the fast duration (a moving score is information, not an event);
+     * `loading` shows a Skeleton in the value's place (never a `0`); `unavailable` states
+     * the absence in plain words ("Not yet scored") rather than a misleading number.
+     */
+    state?: TrustScoreState;
+    /**
+     * The plain message shown where the number would be in the `unavailable` state (spec
+     * §4) — "Not yet scored" or "Score unavailable". Names the absence honestly; defaults to
+     * "Score unavailable".
+     */
+    unavailableLabel?: React.ReactNode;
+}
+/**
+ * TrustScore displays the cross-ecosystem trust score Verdify owns and computes — a single
+ * number rolled up from trust signals across the platform, shown so you can read where an
+ * identity stands at a glance (spec §1). It is a Verdify molecule: it reports a state
+ * Verdify HOLDS about an identity, not a credential the identity presents, so it encodes
+ * "identity is not credentials" — it reads the score against the identity without standing
+ * in for any login or document.
+ *
+ * It is calm by contract. It states the number plainly and never alarms, because a trust
+ * score is CONTEXT, not a verdict (spec §1). It is not a credit score, not a ranking, and
+ * not a pass/fail gate; it does not borrow the verified-status green to imply a binary
+ * "verified" result, and the brand (Sovereign Violet) is never used to make the score look
+ * important — the score is a MEASURE, neither a status nor an action, so it binds nothing
+ * from either the status or the action tier (brand != state, spec §3/§5/§8). There is no
+ * "good"/"warning"/"danger" band: banding the number by color would turn a calm measure
+ * into an alarmist verdict.
+ *
+ * It is a status OUTPUT, not a control (spec §4/§6/§7): it takes no focus, binds no keys,
+ * is never a tab stop, and renders no focus ring or target-size floor. The value and its
+ * label are exposed as an associated group named by the visible label, so a screen reader
+ * hears "Trust score, 82 out of 100", not a bare "82"; when the score updates, the new
+ * value reads through a POLITE live region (a moving trust score is not urgent), and the
+ * settle runs on the fast duration with verdify easing — never the 350ms verified-check
+ * theatre duration, because a score update is not a verification. A control that opens the
+ * score breakdown is a separate Button or Popover trigger with its own focus ring and
+ * keyboard model; it is not TrustScore gaining a state (spec §6).
+ *
+ * The optional `meter` gauge takes `role="meter"` (a present value, never a `progressbar`,
+ * which would read as work advancing) with `aria-valuenow`/`min`/`max` and a plain
+ * `aria-valuetext`; in the `unavailable` state it drops `aria-valuenow` so no value is
+ * claimed. The gauge is a calm rail in neutral control roles, never a colored threshold.
+ */
+export declare const TrustScore: React.ForwardRefExoticComponent<TrustScoreProps & React.RefAttributes<HTMLDivElement>>;
+//# sourceMappingURL=trust-score.d.ts.map

package/dist/components/trust-score/trust-score.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"trust-score.d.ts","sourceRoot":"","sources":["../../../src/components/trust-score/trust-score.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAG/B,OAAO,EAWL,KAAK,sBAAsB,EAC5B,MAAM,wBAAwB,CAAC;AAEhC,yEAAyE;AACzE,MAAM,MAAM,iBAAiB,GAAG,WAAW,CAAC,sBAAsB,CAAC,SAAS,CAAC,CAAC,CAAC;AAE/E;;;;GAIG;AACH,MAAM,MAAM,eAAe,GAAG,SAAS,GAAG,UAAU,GAAG,SAAS,GAAG,aAAa,CAAC;AAEjF,MAAM,WAAW,eACf,SAAQ,IAAI,CAAC,KAAK,CAAC,cAAc,CAAC,cAAc,CAAC,EAAE,YAAY,CAAC,EAC9D,IAAI,CAAC,sBAAsB,EAAE,SAAS,GAAG,QAAQ,CAAC;IACpD;;;;;OAKG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;IACf;;;;OAIG;IACH,KAAK,CAAC,EAAE,KAAK,CAAC,SAAS,CAAC;IACxB;;;;OAIG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB;;;;OAIG;IACH,KAAK,CAAC,EAAE,KAAK,CAAC,SAAS,CAAC;IACxB;;;OAGG;IACH,GAAG,CAAC,EAAE,MAAM,CAAC;IACb;;;OAGG;IACH,GAAG,CAAC,EAAE,MAAM,CAAC;IACb;;;;OAIG;IACH,WAAW,CAAC,EAAE,KAAK,CAAC,SAAS,CAAC;IAC9B;;;;;OAKG;IACH,KAAK,CAAC,EAAE,eAAe,CAAC;IACxB;;;;OAIG;IACH,gBAAgB,CAAC,EAAE,KAAK,CAAC,SAAS,CAAC;CACpC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,eAAO,MAAM,UAAU,wFAmKtB,CAAC"}

package/dist/components/trust-score/trust-score.js

@@ -0,0 +1,146 @@
+"use client";
+import { jsx, jsxs } from "react/jsx-runtime";
+import * as React from "react";
+import { cn } from "../../lib/cn";
+import { Skeleton } from "../skeleton";
+import {
+  trustScoreVariants,
+  trustScoreRowClass,
+  trustScoreValueClass,
+  trustScoreValueCompactClass,
+  trustScoreLabelClass,
+  trustScoreScaleClass,
+  trustScoreDescriptionClass,
+  trustScoreUnavailableClass,
+  trustScoreTrackClass,
+  trustScoreIndicatorClass
+} from "./trust-score.variants";
+const TrustScore = React.forwardRef(
+  function TrustScore2({
+    className,
+    variant = "value",
+    carded,
+    score,
+    label,
+    "aria-label": ariaLabel,
+    scale,
+    max = 100,
+    min = 0,
+    description,
+    state = "default",
+    unavailableLabel = "Score unavailable",
+    ...props
+  }, ref) {
+    const labelId = React.useId();
+    const valueId = React.useId();
+    const descriptionId = React.useId();
+    const hasVisibleLabel = label != null && label !== false;
+    const hasScale = scale != null && scale !== false;
+    const hasDescription = description != null && description !== false;
+    const isLoading = state === "loading";
+    const isUnavailable = state === "unavailable";
+    const hasScore = !isLoading && !isUnavailable && score != null;
+    const isCompact = variant === "compact";
+    const clampedPct = hasScore && max > min ? Math.min(100, Math.max(0, (score - min) / (max - min) * 100)) : 0;
+    const valueText = hasScore && typeof scale === "string" ? `${score} ${scale}` : hasScore ? String(score) : void 0;
+    const describedBy = hasDescription ? descriptionId : void 0;
+    return (
+      // role="group": the value and its label are an associated group whose accessible
+      // name is the visible label (aria-labelledby), or an aria-label when no visible
+      // label exists — never both, never nameless (spec §2/§7). Non-interactive: no
+      // tabIndex, no focus ring, no target-size floor (spec §4/§6/§7).
+      /* @__PURE__ */ jsxs(
+        "div",
+        {
+          ref,
+          role: "group",
+          "aria-labelledby": hasVisibleLabel ? labelId : void 0,
+          "aria-label": hasVisibleLabel ? void 0 : ariaLabel,
+          "aria-describedby": describedBy,
+          className: cn(trustScoreVariants({ variant, carded }), className),
+          ...props,
+          children: [
+            /* @__PURE__ */ jsxs("div", { className: trustScoreRowClass, children: [
+              isLoading ? (
+                // LOADING (spec §4): a Skeleton in the value's place rather than a 0, a guessed
+                // number, or an empty readout — a placeholder zero would be a false score. It
+                // is decorative (the Skeleton is aria-hidden); the real value replaces it on
+                // resolve.
+                /* @__PURE__ */ jsx(
+                  Skeleton,
+                  {
+                    variant: "block",
+                    "data-testid": "trust-score-loading",
+                    className: "h-(--space-6) w-(--space-16)"
+                  }
+                )
+              ) : isUnavailable ? (
+                // UNAVAILABLE (spec §4/§7): plain text where the number would be, in the muted
+                // color. It reads as the group's value, so assistive technology announces the
+                // absence rather than a false number. It is the value region's polite live
+                // region so a transition into "unavailable" is announced, not asserted.
+                /* @__PURE__ */ jsx(
+                  "span",
+                  {
+                    id: valueId,
+                    "data-testid": "trust-score-unavailable",
+                    "aria-live": "polite",
+                    className: trustScoreUnavailableClass,
+                    children: unavailableLabel
+                  }
+                )
+              ) : (
+                // DEFAULT / UPDATING (spec §4): the resolved score in tabular figures. It is a
+                // polite live region so a changed value is announced without interruption; the
+                // settle runs on the fast duration (never the deliberate verified-check
+                // theatre). The number is always paired with the label, so the digit alone
+                // never carries the meaning.
+                /* @__PURE__ */ jsx(
+                  "span",
+                  {
+                    id: valueId,
+                    "data-testid": "trust-score-value",
+                    "aria-live": "polite",
+                    className: isCompact ? trustScoreValueCompactClass : trustScoreValueClass,
+                    children: score
+                  }
+                )
+              ),
+              hasScale ? /* @__PURE__ */ jsx("span", { "data-testid": "trust-score-scale", className: trustScoreScaleClass, children: scale }) : null
+            ] }),
+            hasVisibleLabel ? /* @__PURE__ */ jsx("span", { id: labelId, className: trustScoreLabelClass, children: label }) : null,
+            variant === "meter" ? /* @__PURE__ */ jsx(
+              "div",
+              {
+                "data-testid": "trust-score-track",
+                role: isUnavailable ? void 0 : "meter",
+                "aria-hidden": isUnavailable ? true : void 0,
+                "aria-valuenow": isUnavailable ? void 0 : hasScore ? score : void 0,
+                "aria-valuemin": isUnavailable ? void 0 : min,
+                "aria-valuemax": isUnavailable ? void 0 : max,
+                "aria-valuetext": isUnavailable ? void 0 : valueText,
+                "aria-labelledby": isUnavailable || !hasVisibleLabel ? void 0 : labelId,
+                "aria-label": isUnavailable || hasVisibleLabel ? void 0 : ariaLabel,
+                className: trustScoreTrackClass,
+                children: /* @__PURE__ */ jsx(
+                  "span",
+                  {
+                    "data-testid": "trust-score-indicator",
+                    "aria-hidden": "true",
+                    className: trustScoreIndicatorClass,
+                    style: { inlineSize: `${clampedPct}%` }
+                  }
+                )
+              }
+            ) : null,
+            hasDescription ? /* @__PURE__ */ jsx("span", { id: descriptionId, className: trustScoreDescriptionClass, children: description }) : null
+          ]
+        }
+      )
+    );
+  }
+);
+export {
+  TrustScore
+};
+//# sourceMappingURL=trust-score.js.map

package/dist/components/trust-score/trust-score.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/components/trust-score/trust-score.tsx"],"sourcesContent":["\"use client\";\nimport * as React from \"react\";\nimport { cn } from \"../../lib/cn\";\nimport { Skeleton } from \"../skeleton\";\nimport {\n  trustScoreVariants,\n  trustScoreRowClass,\n  trustScoreValueClass,\n  trustScoreValueCompactClass,\n  trustScoreLabelClass,\n  trustScoreScaleClass,\n  trustScoreDescriptionClass,\n  trustScoreUnavailableClass,\n  trustScoreTrackClass,\n  trustScoreIndicatorClass,\n  type TrustScoreVariantProps,\n} from \"./trust-score.variants\";\n\n/** The display form of the TrustScore (spec §3). Defaults to `value`. */\nexport type TrustScoreVariant = NonNullable<TrustScoreVariantProps[\"variant\"]>;\n\n/**\n * The state the score's VALUE can be in (spec §4). TrustScore is a status output, not a\n * control, so it has no hover/pressed/focus/disabled state of its own — only the states\n * its value can be in. Defaults to `default` (the resolved score at rest).\n */\nexport type TrustScoreState = \"default\" | \"updating\" | \"loading\" | \"unavailable\";\n\nexport interface TrustScoreProps\n  extends Omit<React.HTMLAttributes<HTMLDivElement>, \"aria-label\">,\n    Pick<TrustScoreVariantProps, \"variant\" | \"carded\"> {\n  /**\n   * The trust score itself (spec §2/§4) — the rolled-up number. Rendered in tabular\n   * figures so digits hold their place when the value updates, always paired with the\n   * label; the digit alone never carries the meaning. Omit it only in the `loading` and\n   * `unavailable` states, where no honest number exists — never pass a guessed `0`.\n   */\n  score?: number;\n  /**\n   * The text naming what the number is, \"Trust score\" (spec §2). Rendered as visible text\n   * AND bound to the value as the group's accessible name (`aria-labelledby`). TrustScore\n   * is never an unlabeled number; provide EITHER a visible `label` or an `aria-label`.\n   */\n  label?: React.ReactNode;\n  /**\n   * The accessible name when no visible {@link label} fits (spec §7) — \"Trust score\".\n   * Used only when there is no visible label; the group is never nameless to assistive\n   * technology, and a bare figure is never left to read as a rating it is not.\n   */\n  \"aria-label\"?: string;\n  /**\n   * The plain bound the number reads against, \"out of 100\" (spec §2). Shown when the\n   * scale is not obvious from context, so the value is legible without the reader guessing\n   * the range. Also bounds the optional gauge's `aria-valuetext`.\n   */\n  scale?: React.ReactNode;\n  /**\n   * The upper bound of the scale (spec §7). Default `100`. Bounds the optional gauge\n   * (`aria-valuemax`) and the indicator length.\n   */\n  max?: number;\n  /**\n   * The lower bound of the scale (spec §7). Default `0`. Bounds the optional gauge\n   * (`aria-valuemin`) and the indicator length.\n   */\n  min?: number;\n  /**\n   * One line stating what the score means or when it last changed (spec §2), written as a\n   * statement ending with a period. Use it to keep the reader oriented, not to editorialise\n   * the number up or down.\n   */\n  description?: React.ReactNode;\n  /**\n   * The state the value is in (spec §4). `updating` announces the new value politely and\n   * settles it on the fast duration (a moving score is information, not an event);\n   * `loading` shows a Skeleton in the value's place (never a `0`); `unavailable` states\n   * the absence in plain words (\"Not yet scored\") rather than a misleading number.\n   */\n  state?: TrustScoreState;\n  /**\n   * The plain message shown where the number would be in the `unavailable` state (spec\n   * §4) — \"Not yet scored\" or \"Score unavailable\". Names the absence honestly; defaults to\n   * \"Score unavailable\".\n   */\n  unavailableLabel?: React.ReactNode;\n}\n\n/**\n * TrustScore displays the cross-ecosystem trust score Verdify owns and computes — a single\n * number rolled up from trust signals across the platform, shown so you can read where an\n * identity stands at a glance (spec §1). It is a Verdify molecule: it reports a state\n * Verdify HOLDS about an identity, not a credential the identity presents, so it encodes\n * \"identity is not credentials\" — it reads the score against the identity without standing\n * in for any login or document.\n *\n * It is calm by contract. It states the number plainly and never alarms, because a trust\n * score is CONTEXT, not a verdict (spec §1). It is not a credit score, not a ranking, and\n * not a pass/fail gate; it does not borrow the verified-status green to imply a binary\n * \"verified\" result, and the brand (Sovereign Violet) is never used to make the score look\n * important — the score is a MEASURE, neither a status nor an action, so it binds nothing\n * from either the status or the action tier (brand != state, spec §3/§5/§8). There is no\n * \"good\"/\"warning\"/\"danger\" band: banding the number by color would turn a calm measure\n * into an alarmist verdict.\n *\n * It is a status OUTPUT, not a control (spec §4/§6/§7): it takes no focus, binds no keys,\n * is never a tab stop, and renders no focus ring or target-size floor. The value and its\n * label are exposed as an associated group named by the visible label, so a screen reader\n * hears \"Trust score, 82 out of 100\", not a bare \"82\"; when the score updates, the new\n * value reads through a POLITE live region (a moving trust score is not urgent), and the\n * settle runs on the fast duration with verdify easing — never the 350ms verified-check\n * theatre duration, because a score update is not a verification. A control that opens the\n * score breakdown is a separate Button or Popover trigger with its own focus ring and\n * keyboard model; it is not TrustScore gaining a state (spec §6).\n *\n * The optional `meter` gauge takes `role=\"meter\"` (a present value, never a `progressbar`,\n * which would read as work advancing) with `aria-valuenow`/`min`/`max` and a plain\n * `aria-valuetext`; in the `unavailable` state it drops `aria-valuenow` so no value is\n * claimed. The gauge is a calm rail in neutral control roles, never a colored threshold.\n */\nexport const TrustScore = React.forwardRef<HTMLDivElement, TrustScoreProps>(\n  function TrustScore(\n    {\n      className,\n      variant = \"value\",\n      carded,\n      score,\n      label,\n      \"aria-label\": ariaLabel,\n      scale,\n      max = 100,\n      min = 0,\n      description,\n      state = \"default\",\n      unavailableLabel = \"Score unavailable\",\n      ...props\n    },\n    ref,\n  ) {\n    const labelId = React.useId();\n    const valueId = React.useId();\n    const descriptionId = React.useId();\n\n    const hasVisibleLabel = label != null && label !== false;\n    const hasScale = scale != null && scale !== false;\n    const hasDescription = description != null && description !== false;\n    const isLoading = state === \"loading\";\n    const isUnavailable = state === \"unavailable\";\n    // a resolved number exists only outside the loading/unavailable states\n    const hasScore = !isLoading && !isUnavailable && score != null;\n    const isCompact = variant === \"compact\";\n\n    // the meter indicator length is the score as a percentage of the scale, clamped to\n    // 0..100% so an out-of-range value never overflows the rail (spec §4). aria-valuenow\n    // still reports the raw score the caller passed.\n    const clampedPct =\n      hasScore && max > min\n        ? Math.min(100, Math.max(0, ((score! - min) / (max - min)) * 100))\n        : 0;\n\n    // a plain readout for the gauge (\"82 out of 100\") so it announces a measure, not a\n    // task in progress (spec §7). Falls back to the bare number when no scale is given.\n    const valueText =\n      hasScore && typeof scale === \"string\"\n        ? `${score} ${scale}`\n        : hasScore\n          ? String(score)\n          : undefined;\n\n    // description is read with the group via aria-describedby when present (spec §2/§7).\n    const describedBy = hasDescription ? descriptionId : undefined;\n\n    return (\n      // role=\"group\": the value and its label are an associated group whose accessible\n      // name is the visible label (aria-labelledby), or an aria-label when no visible\n      // label exists — never both, never nameless (spec §2/§7). Non-interactive: no\n      // tabIndex, no focus ring, no target-size floor (spec §4/§6/§7).\n      <div\n        ref={ref}\n        role=\"group\"\n        aria-labelledby={hasVisibleLabel ? labelId : undefined}\n        aria-label={hasVisibleLabel ? undefined : ariaLabel}\n        aria-describedby={describedBy}\n        className={cn(trustScoreVariants({ variant, carded }), className)}\n        {...props}\n      >\n        <div className={trustScoreRowClass}>\n          {isLoading ? (\n            // LOADING (spec §4): a Skeleton in the value's place rather than a 0, a guessed\n            // number, or an empty readout — a placeholder zero would be a false score. It\n            // is decorative (the Skeleton is aria-hidden); the real value replaces it on\n            // resolve.\n            <Skeleton\n              variant=\"block\"\n              data-testid=\"trust-score-loading\"\n              className=\"h-(--space-6) w-(--space-16)\"\n            />\n          ) : isUnavailable ? (\n            // UNAVAILABLE (spec §4/§7): plain text where the number would be, in the muted\n            // color. It reads as the group's value, so assistive technology announces the\n            // absence rather than a false number. It is the value region's polite live\n            // region so a transition into \"unavailable\" is announced, not asserted.\n            <span\n              id={valueId}\n              data-testid=\"trust-score-unavailable\"\n              aria-live=\"polite\"\n              className={trustScoreUnavailableClass}\n            >\n              {unavailableLabel}\n            </span>\n          ) : (\n            // DEFAULT / UPDATING (spec §4): the resolved score in tabular figures. It is a\n            // polite live region so a changed value is announced without interruption; the\n            // settle runs on the fast duration (never the deliberate verified-check\n            // theatre). The number is always paired with the label, so the digit alone\n            // never carries the meaning.\n            <span\n              id={valueId}\n              data-testid=\"trust-score-value\"\n              aria-live=\"polite\"\n              className={isCompact ? trustScoreValueCompactClass : trustScoreValueClass}\n            >\n              {score}\n            </span>\n          )}\n\n          {/* the optional inline scale (\"out of 100\"), so the value is legible without\n              guessing the range (spec §2). Shown alongside the number; the gauge's\n              aria-valuetext carries it to assistive technology too. */}\n          {hasScale ? (\n            <span data-testid=\"trust-score-scale\" className={trustScoreScaleClass}>\n              {scale}\n            </span>\n          ) : null}\n        </div>\n\n        {/* the visible label naming the number, bound to the group as its accessible name\n            (spec §2/§7). TrustScore is never an unlabeled number. */}\n        {hasVisibleLabel ? (\n          <span id={labelId} className={trustScoreLabelClass}>\n            {label}\n          </span>\n        ) : null}\n\n        {/* the optional meter gauge (spec §2/§3/§7): role=\"meter\" is a PRESENT value, not\n            a task advancing, so it is never a progressbar. It is bounded by\n            aria-valuemin/aria-valuemax with aria-valuenow + a plain aria-valuetext.\n            UNAVAILABLE: no value may be claimed for an absent score, and role=\"meter\"\n            REQUIRES aria-valuenow (an ARIA owned attribute) — a valueless meter is invalid\n            ARIA. So the gauge drops role=\"meter\" and becomes the spec's \"decorative gauge\n            with no semantic value\", aria-hidden, with the absence carried by the labelled\n            text instead. Neutral rail, never a colored threshold. */}\n        {variant === \"meter\" ? (\n          <div\n            data-testid=\"trust-score-track\"\n            role={isUnavailable ? undefined : \"meter\"}\n            aria-hidden={isUnavailable ? true : undefined}\n            aria-valuenow={isUnavailable ? undefined : hasScore ? score : undefined}\n            aria-valuemin={isUnavailable ? undefined : min}\n            aria-valuemax={isUnavailable ? undefined : max}\n            aria-valuetext={isUnavailable ? undefined : valueText}\n            aria-labelledby={isUnavailable || !hasVisibleLabel ? undefined : labelId}\n            aria-label={isUnavailable || hasVisibleLabel ? undefined : ariaLabel}\n            className={trustScoreTrackClass}\n          >\n            <span\n              data-testid=\"trust-score-indicator\"\n              aria-hidden=\"true\"\n              className={trustScoreIndicatorClass}\n              style={{ inlineSize: `${clampedPct}%` }}\n            />\n          </div>\n        ) : null}\n\n        {/* the optional one-line description, read with the group (spec §2/§7). */}\n        {hasDescription ? (\n          <span id={descriptionId} className={trustScoreDescriptionClass}>\n            {description}\n          </span>\n        ) : null}\n      </div>\n    );\n  },\n);\n"],"mappings":";AAyLQ,SAMI,KANJ;AAxLR,YAAY,WAAW;AACvB,SAAS,UAAU;AACnB,SAAS,gBAAgB;AACzB;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OAEK;AAuGA,MAAM,aAAa,MAAM;AAAA,EAC9B,SAASA,YACP;AAAA,IACE;AAAA,IACA,UAAU;AAAA,IACV;AAAA,IACA;AAAA,IACA;AAAA,IACA,cAAc;AAAA,IACd;AAAA,IACA,MAAM;AAAA,IACN,MAAM;AAAA,IACN;AAAA,IACA,QAAQ;AAAA,IACR,mBAAmB;AAAA,IACnB,GAAG;AAAA,EACL,GACA,KACA;AACA,UAAM,UAAU,MAAM,MAAM;AAC5B,UAAM,UAAU,MAAM,MAAM;AAC5B,UAAM,gBAAgB,MAAM,MAAM;AAElC,UAAM,kBAAkB,SAAS,QAAQ,UAAU;AACnD,UAAM,WAAW,SAAS,QAAQ,UAAU;AAC5C,UAAM,iBAAiB,eAAe,QAAQ,gBAAgB;AAC9D,UAAM,YAAY,UAAU;AAC5B,UAAM,gBAAgB,UAAU;AAEhC,UAAM,WAAW,CAAC,aAAa,CAAC,iBAAiB,SAAS;AAC1D,UAAM,YAAY,YAAY;AAK9B,UAAM,aACJ,YAAY,MAAM,MACd,KAAK,IAAI,KAAK,KAAK,IAAI,IAAK,QAAS,QAAQ,MAAM,OAAQ,GAAG,CAAC,IAC/D;AAIN,UAAM,YACJ,YAAY,OAAO,UAAU,WACzB,GAAG,KAAK,IAAI,KAAK,KACjB,WACE,OAAO,KAAK,IACZ;AAGR,UAAM,cAAc,iBAAiB,gBAAgB;AAErD;AAAA;AAAA;AAAA;AAAA;AAAA,MAKE;AAAA,QAAC;AAAA;AAAA,UACC;AAAA,UACA,MAAK;AAAA,UACL,mBAAiB,kBAAkB,UAAU;AAAA,UAC7C,cAAY,kBAAkB,SAAY;AAAA,UAC1C,oBAAkB;AAAA,UAClB,WAAW,GAAG,mBAAmB,EAAE,SAAS,OAAO,CAAC,GAAG,SAAS;AAAA,UAC/D,GAAG;AAAA,UAEJ;AAAA,iCAAC,SAAI,WAAW,oBACb;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,gBAKC;AAAA,kBAAC;AAAA;AAAA,oBACC,SAAQ;AAAA,oBACR,eAAY;AAAA,oBACZ,WAAU;AAAA;AAAA,gBACZ;AAAA,kBACE;AAAA;AAAA;AAAA;AAAA;AAAA,gBAKF;AAAA,kBAAC;AAAA;AAAA,oBACC,IAAI;AAAA,oBACJ,eAAY;AAAA,oBACZ,aAAU;AAAA,oBACV,WAAW;AAAA,oBAEV;AAAA;AAAA,gBACH;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,gBAOA;AAAA,kBAAC;AAAA;AAAA,oBACC,IAAI;AAAA,oBACJ,eAAY;AAAA,oBACZ,aAAU;AAAA,oBACV,WAAW,YAAY,8BAA8B;AAAA,oBAEpD;AAAA;AAAA,gBACH;AAAA;AAAA,cAMD,WACC,oBAAC,UAAK,eAAY,qBAAoB,WAAW,sBAC9C,iBACH,IACE;AAAA,eACN;AAAA,YAIC,kBACC,oBAAC,UAAK,IAAI,SAAS,WAAW,sBAC3B,iBACH,IACE;AAAA,YAUH,YAAY,UACX;AAAA,cAAC;AAAA;AAAA,gBACC,eAAY;AAAA,gBACZ,MAAM,gBAAgB,SAAY;AAAA,gBAClC,eAAa,gBAAgB,OAAO;AAAA,gBACpC,iBAAe,gBAAgB,SAAY,WAAW,QAAQ;AAAA,gBAC9D,iBAAe,gBAAgB,SAAY;AAAA,gBAC3C,iBAAe,gBAAgB,SAAY;AAAA,gBAC3C,kBAAgB,gBAAgB,SAAY;AAAA,gBAC5C,mBAAiB,iBAAiB,CAAC,kBAAkB,SAAY;AAAA,gBACjE,cAAY,iBAAiB,kBAAkB,SAAY;AAAA,gBAC3D,WAAW;AAAA,gBAEX;AAAA,kBAAC;AAAA;AAAA,oBACC,eAAY;AAAA,oBACZ,eAAY;AAAA,oBACZ,WAAW;AAAA,oBACX,OAAO,EAAE,YAAY,GAAG,UAAU,IAAI;AAAA;AAAA,gBACxC;AAAA;AAAA,YACF,IACE;AAAA,YAGH,iBACC,oBAAC,UAAK,IAAI,eAAe,WAAW,4BACjC,uBACH,IACE;AAAA;AAAA;AAAA,MACN;AAAA;AAAA,EAEJ;AACF;","names":["TrustScore"]}

package/dist/components/trust-score/trust-score.variants.d.ts

@@ -0,0 +1,16 @@
+import { type VariantProps } from "class-variance-authority";
+export declare const trustScoreVariants: (props?: ({
+    variant?: "value" | "meter" | "compact" | null | undefined;
+    carded?: boolean | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+export declare const trustScoreRowClass = "flex items-baseline gap-(--space-2)";
+export declare const trustScoreValueClass: string;
+export declare const trustScoreValueCompactClass: string;
+export declare const trustScoreLabelClass = "text-label text-text-secondary";
+export declare const trustScoreScaleClass = "text-label text-text-secondary";
+export declare const trustScoreDescriptionClass = "text-caption text-text-secondary";
+export declare const trustScoreUnavailableClass = "text-caption text-text-muted";
+export declare const trustScoreTrackClass: string;
+export declare const trustScoreIndicatorClass: string;
+export type TrustScoreVariantProps = VariantProps<typeof trustScoreVariants>;
+//# sourceMappingURL=trust-score.variants.d.ts.map

package/dist/components/trust-score/trust-score.variants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"trust-score.variants.d.ts","sourceRoot":"","sources":["../../../src/components/trust-score/trust-score.variants.ts"],"names":[],"mappings":"AAAA,OAAO,EAAO,KAAK,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAkClE,eAAO,MAAM,kBAAkB;;;8EA0B7B,CAAC;AAIH,eAAO,MAAM,kBAAkB,wCAAwC,CAAC;AASxE,eAAO,MAAM,oBAAoB,QAGqB,CAAC;AAIvD,eAAO,MAAM,2BAA2B,QAGc,CAAC;AAIvD,eAAO,MAAM,oBAAoB,mCAAmC,CAAC;AAKrE,eAAO,MAAM,oBAAoB,mCAAmC,CAAC;AAIrE,eAAO,MAAM,0BAA0B,qCAAqC,CAAC;AAM7E,eAAO,MAAM,0BAA0B,iCAAiC,CAAC;AAQzE,eAAO,MAAM,oBAAoB,QAEqC,CAAC;AAQvE,eAAO,MAAM,wBAAwB,QAGiB,CAAC;AAEvD,MAAM,MAAM,sBAAsB,GAAG,YAAY,CAAC,OAAO,kBAAkB,CAAC,CAAC"}

package/dist/components/trust-score/trust-score.variants.js

@@ -0,0 +1,50 @@
+import { cva } from "class-variance-authority";
+const trustScoreVariants = cva("flex flex-col gap-(--space-2)", {
+  variants: {
+    // STRUCTURAL axis = spec §3: a form of DISPLAY, never a level of alarm. None of the
+    // variants recolors the readout — they differ only in what is shown and at which
+    // type role, so the meaning is identical across all three.
+    variant: {
+      // value (default): the number with its label and optional scale, no gauge — the
+      // common, calmest case (a profile header, a row, a card).
+      value: "",
+      // meter: the number plus the neutral track gauge, for a surface where seeing the
+      // value against its scale helps. The gauge is a calm rail in neutral control roles.
+      meter: "",
+      // compact: the bare number at a smaller footprint for dense rows and inline
+      // contexts; the full label + scale still reach assistive technology via the group
+      // name. Same meaning at a smaller type role, not a different component.
+      compact: ""
+    },
+    // When carded, paint the neutral container: the raised surface, the muted surface
+    // border, the medium corner radius, and the internal padding (spec §5). No status,
+    // no action — a calm container for a calm measure.
+    carded: {
+      true: "rounded-(--radius-md) border bg-surface-raised border-surface-border-muted p-(--space-3)",
+      false: ""
+    }
+  },
+  defaultVariants: { variant: "value", carded: false }
+});
+const trustScoreRowClass = "flex items-baseline gap-(--space-2)";
+const trustScoreValueClass = "tabular-nums text-h2 text-text-primary transition-[color,opacity] duration-(--motion-duration-fast) ease-(--motion-easing-verdify) motion-reduce:duration-(--motion-duration-instant)";
+const trustScoreValueCompactClass = "tabular-nums text-label text-text-primary transition-[color,opacity] duration-(--motion-duration-fast) ease-(--motion-easing-verdify) motion-reduce:duration-(--motion-duration-instant)";
+const trustScoreLabelClass = "text-label text-text-secondary";
+const trustScoreScaleClass = "text-label text-text-secondary";
+const trustScoreDescriptionClass = "text-caption text-text-secondary";
+const trustScoreUnavailableClass = "text-caption text-text-muted";
+const trustScoreTrackClass = "relative block h-(--space-2) w-full overflow-hidden rounded-(--radius-full) bg-control-bg border border-control-border";
+const trustScoreIndicatorClass = "block h-full rounded-(--radius-full) bg-control-fg transition-[inline-size] duration-(--motion-duration-fast) ease-(--motion-easing-verdify) motion-reduce:duration-(--motion-duration-instant)";
+export {
+  trustScoreDescriptionClass,
+  trustScoreIndicatorClass,
+  trustScoreLabelClass,
+  trustScoreRowClass,
+  trustScoreScaleClass,
+  trustScoreTrackClass,
+  trustScoreUnavailableClass,
+  trustScoreValueClass,
+  trustScoreValueCompactClass,
+  trustScoreVariants
+};
+//# sourceMappingURL=trust-score.variants.js.map

package/dist/components/trust-score/trust-score.variants.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/components/trust-score/trust-score.variants.ts"],"sourcesContent":["import { cva, type VariantProps } from \"class-variance-authority\";\n\n// TrustScore displays the cross-ecosystem trust score Verdify owns and computes — a\n// single rolled-up number, shown so the reader can read where an identity stands at a\n// glance (spec §1). It is a status OUTPUT, not a control: it takes no focus, binds no\n// keys, is never a tab stop, and renders no focus ring or target-size floor — the value\n// reaches assistive technology through a named group + a polite live region, never\n// through motion (spec §4/§6/§7).\n//\n// CALM BY CONTRACT — brand != state (spec §1/§3/§5/§8). A trust score is a MEASURE, not\n// a verdict and not a credential. TrustScore therefore paints from NEUTRAL text/surface\n// roles and the neutral --color-control-* roles for the optional gauge, and binds:\n//   * NOTHING from the action tier — the brand (Sovereign Violet) is never used to make\n//     the score look important, because the brand is not a status; and\n//   * NOTHING from the status tier — the verified-status green is never used to color a\n//     \"high\" score (that green means one verified result and nothing else, so lending it\n//     to a number tells the reader the score is a verification it is not), and there is\n//     no caution/critical \"danger\" band — banding the number by color turns a calm\n//     measure into an alarmist verdict.\n// There is no \"good\"/\"warning\"/\"danger\" variant: the variants below are forms of DISPLAY\n// (value / meter / compact), never levels of alarm. This whole-tree neutrality is pinned\n// as a component test in trust-score.test.tsx (the static brand!=state gate only catches\n// a cva-keyed status<->action cross-wire, not a neutral-leak — see the build-on-brand\n// skill, note B).\n//\n// The value also never animates on the deliberate verified-check duration — that 350ms\n// theatre is the verified check's alone, and a score update is not a verification; the\n// update settles on the fast duration with verdify easing (spec §4).\n\n// The root container (spec §2): a layout column stacking the value/scale row, the optional\n// label, the optional gauge, and the optional description at the --space-2 gap. Non-\n// interactive: no focus ring, no tab stop, no target-size floor (spec §4/§6/§7). When the\n// score sits in its own card the `carded` axis adds the neutral raised surface, the muted\n// surface border, the medium corner radius, and the --space-3 internal padding (spec §5).\nexport const trustScoreVariants = cva(\"flex flex-col gap-(--space-2)\", {\n  variants: {\n    // STRUCTURAL axis = spec §3: a form of DISPLAY, never a level of alarm. None of the\n    // variants recolors the readout — they differ only in what is shown and at which\n    // type role, so the meaning is identical across all three.\n    variant: {\n      // value (default): the number with its label and optional scale, no gauge — the\n      // common, calmest case (a profile header, a row, a card).\n      value: \"\",\n      // meter: the number plus the neutral track gauge, for a surface where seeing the\n      // value against its scale helps. The gauge is a calm rail in neutral control roles.\n      meter: \"\",\n      // compact: the bare number at a smaller footprint for dense rows and inline\n      // contexts; the full label + scale still reach assistive technology via the group\n      // name. Same meaning at a smaller type role, not a different component.\n      compact: \"\",\n    },\n    // When carded, paint the neutral container: the raised surface, the muted surface\n    // border, the medium corner radius, and the internal padding (spec §5). No status,\n    // no action — a calm container for a calm measure.\n    carded: {\n      true: \"rounded-(--radius-md) border bg-surface-raised border-surface-border-muted p-(--space-3)\",\n      false: \"\",\n    },\n  },\n  defaultVariants: { variant: \"value\", carded: false },\n});\n\n// The value/scale row (spec §2): the number and its optional inline scale, baseline-\n// aligned at the small gap.\nexport const trustScoreRowClass = \"flex items-baseline gap-(--space-2)\";\n\n// The score numeric readout (spec §2/§4/§5): the trust score itself, in TABULAR figures\n// so digits hold their place when the value updates, at the h2 type role in the PRIMARY\n// text color. It is a polite live region (set in tsx) so a changed score is announced\n// without interruption; the value-settle transition runs on the FAST duration with\n// verdify easing, collapsing to the instant endpoint under reduced motion — a moving\n// trust score is information, not an event, and NEVER the 350ms verified-check theatre\n// duration (spec §4). The compact form drops the type role to the label role below.\nexport const trustScoreValueClass =\n  \"tabular-nums text-h2 text-text-primary \" +\n  \"transition-[color,opacity] duration-(--motion-duration-fast) ease-(--motion-easing-verdify) \" +\n  \"motion-reduce:duration-(--motion-duration-instant)\";\n\n// The compact value (spec §3): the same primary readout at the smaller label type role\n// for dense rows. Same tabular figures and the same settle transition.\nexport const trustScoreValueCompactClass =\n  \"tabular-nums text-label text-text-primary \" +\n  \"transition-[color,opacity] duration-(--motion-duration-fast) ease-(--motion-easing-verdify) \" +\n  \"motion-reduce:duration-(--motion-duration-instant)\";\n\n// The label (spec §2/§5): the text naming what the number is (\"Trust score\"), in the\n// secondary text color at the label type role. TrustScore is never an unlabeled number.\nexport const trustScoreLabelClass = \"text-label text-text-secondary\";\n\n// The scale (spec §2/§5): the plain bound the number reads against (\"out of 100\"), in the\n// secondary text color at the label type role, so the value is legible without guessing\n// the range.\nexport const trustScoreScaleClass = \"text-label text-text-secondary\";\n\n// The optional one-line description (spec §2/§5): a statement of what the score means or\n// when it last changed, in the secondary text color at the caption role.\nexport const trustScoreDescriptionClass = \"text-caption text-text-secondary\";\n\n// The unavailable message (spec §4/§5/§7): plain text where the number would be (\"Not yet\n// scored\" / \"Score unavailable\"), in the MUTED text color at the caption role, naming the\n// absence honestly rather than showing a misleading 0 or a low number. Honest about hard\n// things: an absent score is said, not faked.\nexport const trustScoreUnavailableClass = \"text-caption text-text-muted\";\n\n// The optional meter track (spec §2/§5): a restrained gauge rail visualising the score\n// against its scale, in the NEUTRAL control surface with the control border, clipped so\n// the rounded indicator end never bleeds past the rail, on the full radius. It is a calm\n// gauge, NEVER a progress fill racing toward a target and NEVER recolored to a status to\n// imply alarm or approval (spec §2/§3/§4) — the non-text contrast bar (1.4.11) is met by\n// the control roles, not by a colored band.\nexport const trustScoreTrackClass =\n  \"relative block h-(--space-2) w-full overflow-hidden \" +\n  \"rounded-(--radius-full) bg-control-bg border border-control-border\";\n\n// The meter filled-portion indicator (spec §2/§4/§5): the portion of the rail up to the\n// score, in the NEUTRAL control foreground, rounded on the full radius. Its inline length\n// is the score as a percentage of the scale (set as an inline width in tsx — a data\n// percentage, not a design token). The length CHANGES on the FAST duration with verdify\n// easing, collapsing to the instant endpoint under reduced motion — a calm settle, never\n// the verified-check theatre duration (spec §4). It is neutral: no status, no action.\nexport const trustScoreIndicatorClass =\n  \"block h-full rounded-(--radius-full) bg-control-fg \" +\n  \"transition-[inline-size] duration-(--motion-duration-fast) ease-(--motion-easing-verdify) \" +\n  \"motion-reduce:duration-(--motion-duration-instant)\";\n\nexport type TrustScoreVariantProps = VariantProps<typeof trustScoreVariants>;\n"],"mappings":"AAAA,SAAS,WAA8B;AAkChC,MAAM,qBAAqB,IAAI,iCAAiC;AAAA,EACrE,UAAU;AAAA;AAAA;AAAA;AAAA,IAIR,SAAS;AAAA;AAAA;AAAA,MAGP,OAAO;AAAA;AAAA;AAAA,MAGP,OAAO;AAAA;AAAA;AAAA;AAAA,MAIP,SAAS;AAAA,IACX;AAAA;AAAA;AAAA;AAAA,IAIA,QAAQ;AAAA,MACN,MAAM;AAAA,MACN,OAAO;AAAA,IACT;AAAA,EACF;AAAA,EACA,iBAAiB,EAAE,SAAS,SAAS,QAAQ,MAAM;AACrD,CAAC;AAIM,MAAM,qBAAqB;AAS3B,MAAM,uBACX;AAMK,MAAM,8BACX;AAMK,MAAM,uBAAuB;AAK7B,MAAM,uBAAuB;AAI7B,MAAM,6BAA6B;AAMnC,MAAM,6BAA6B;AAQnC,MAAM,uBACX;AASK,MAAM,2BACX;","names":[]}

package/dist/components/verified-badge/index.d.ts

@@ -0,0 +1,3 @@
+export { VerifiedBadge, type VerifiedBadgeProps } from "./verified-badge";
+export { verifiedBadgeVariants, verifiedBadgeCheckVariants, verifiedBadgeCheckStrokeClass, VERIFIED_BADGE_REVEAL_KEYFRAME, type VerifiedBadgeVariantProps, } from "./verified-badge.variants";
+//# sourceMappingURL=index.d.ts.map

package/dist/components/verified-badge/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/components/verified-badge/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,KAAK,kBAAkB,EAAE,MAAM,kBAAkB,CAAC;AAC1E,OAAO,EACL,qBAAqB,EACrB,0BAA0B,EAC1B,6BAA6B,EAC7B,8BAA8B,EAC9B,KAAK,yBAAyB,GAC/B,MAAM,2BAA2B,CAAC"}

package/dist/components/verified-badge/index.js

@@ -0,0 +1,15 @@
+import { VerifiedBadge } from "./verified-badge";
+import {
+  verifiedBadgeVariants,
+  verifiedBadgeCheckVariants,
+  verifiedBadgeCheckStrokeClass,
+  VERIFIED_BADGE_REVEAL_KEYFRAME
+} from "./verified-badge.variants";
+export {
+  VERIFIED_BADGE_REVEAL_KEYFRAME,
+  VerifiedBadge,
+  verifiedBadgeCheckStrokeClass,
+  verifiedBadgeCheckVariants,
+  verifiedBadgeVariants
+};
+//# sourceMappingURL=index.js.map

package/dist/components/verified-badge/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/components/verified-badge/index.ts"],"sourcesContent":["export { VerifiedBadge, type VerifiedBadgeProps } from \"./verified-badge\";\nexport {\n  verifiedBadgeVariants,\n  verifiedBadgeCheckVariants,\n  verifiedBadgeCheckStrokeClass,\n  VERIFIED_BADGE_REVEAL_KEYFRAME,\n  type VerifiedBadgeVariantProps,\n} from \"./verified-badge.variants\";\n"],"mappings":"AAAA,SAAS,qBAA8C;AACvD;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OAEK;","names":[]}

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

@@ -0,0 +1,55 @@
+import * as React from "react";
+import { type VerifiedBadgeVariantProps } from "./verified-badge.variants";
+export interface VerifiedBadgeProps extends Omit<React.HTMLAttributes<HTMLSpanElement>, "aria-label">, VerifiedBadgeVariantProps {
+    /**
+     * Short text naming what was verified (spec §2), a plain statement in sentence case
+     * ("ID verified.", "Email verified.") — no all-caps, no exclamation mark. When present it
+     * is the visible name AND the accessible name. Omit it together with {@link labelHidden}
+     * for the check-only marker, in which case an {@link "aria-label"} carries the full
+     * statement (the badge is never nameless to assistive technology).
+     */
+    label?: React.ReactNode;
+    /**
+     * Hide the visible label, leaving the check standing alone (spec §3 `label-hidden`): a
+     * tight row or a repeated column. The accessible name is STILL required and still states
+     * what was verified, so the meaning never rests on the green check alone — supply it via
+     * {@link "aria-label"}. The check is decorative either way.
+     */
+    labelHidden?: boolean;
+    /**
+     * The accessible name when the label is hidden (spec §7). State what was verified
+     * ("ID verified."). Required whenever {@link labelHidden} is set — the green check alone is
+     * not an accessible name (1.4.1 / 1.3.1). Ignored when a visible {@link label} is present,
+     * because the visible text is already the name (never both).
+     */
+    "aria-label"?: string;
+}
+/**
+ * A VerifiedBadge shows the in-product VERIFIED state of one specific claim — that a proof
+ * checked out (spec §1). It reports a RESULT, not an action: it states that something was
+ * verified and names what, and it owns the verified-status treatment end to end, so a verified
+ * result looks the same everywhere and no screen hand-colors its own.
+ *
+ * It encodes "proofs, not documents": it asserts that a proof passed, never that a document is
+ * on file, so its label and its accessible name speak to the claim that was proven (spec §1).
+ * It keeps brand and status apart — the verified state is the GREEN verified status, never the
+ * brand violet — so it binds nothing from the action (brand) tier (brand != state, spec
+ * §3/§5/§8). It carries the ONE deliberate motion in the system: the verified check draws ONCE
+ * with the deliberate duration the moment a result first resolves, then holds as a static mark
+ * and never animates again (spec §4/§8). Under prefers-reduced-motion the draw is suppressed and
+ * the check appears already drawn (spec §4/§7).
+ *
+ * It has exactly one meaning — verified — so there is NO pending / failed VerifiedBadge: a
+ * claim that is pending, expiring, or failed is a generic Badge or an Alert in the matching
+ * status color, and only a confirmed verified result earns this molecule and the verified green
+ * (spec §3). There is no loading state on the badge itself: while a check is still running, show
+ * a Spinner or a Skeleton in its place and mount the VerifiedBadge only once the result is
+ * verified — its appearance IS the confirmation (spec §4).
+ *
+ * It is NON-INTERACTIVE (spec §4/§6): it takes no focus, binds no keys, is never a tab stop, and
+ * renders no focus ring or target-size floor. Acting on a verified result — opening the proof,
+ * managing the claim — is a SEPARATE control (a Button or link) with its own keyboard model and
+ * focus ring; the badge only reports (spec §6).
+ */
+export declare const VerifiedBadge: React.ForwardRefExoticComponent<VerifiedBadgeProps & React.RefAttributes<HTMLSpanElement>>;
+//# sourceMappingURL=verified-badge.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"verified-badge.d.ts","sourceRoot":"","sources":["../../../src/components/verified-badge/verified-badge.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAE/B,OAAO,EAKL,KAAK,yBAAyB,EAC/B,MAAM,2BAA2B,CAAC;AAYnC,MAAM,WAAW,kBACf,SAAQ,IAAI,CAAC,KAAK,CAAC,cAAc,CAAC,eAAe,CAAC,EAAE,YAAY,CAAC,EAC/D,yBAAyB;IAC3B;;;;;;OAMG;IACH,KAAK,CAAC,EAAE,KAAK,CAAC,SAAS,CAAC;IACxB;;;;;OAKG;IACH,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB;;;;;OAKG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,eAAO,MAAM,aAAa,4FAwEzB,CAAC"}