@glasshome/ui 0.5.3 → 1.0.0

package/dist/solid/input-group.d.ts

@@ -1,26 +1,74 @@
 import { type VariantProps } from "cva";
 import { type Component, type ComponentProps } from "solid-js";
-import { Button } from "./button";
+import { Button } from "./button.js";
 declare const InputGroup: Component<ComponentProps<"div">>;
-declare const inputGroupAddonVariants: (props?: ({
-    align?: "inline-end" | "inline-start" | "block-end" | "block-start" | undefined;
-} & ({
-    class?: import("cva").ClassValue;
-    className?: never;
-} | {
-    class?: never;
-    className?: import("cva").ClassValue;
-})) | undefined) => string;
+declare const inputGroupAddonVariants: import("cva").CVAComponent<Omit<{
+    base: string;
+    variants: {
+        align: {
+            "inline-start": string;
+            "inline-end": string;
+            "block-start": string;
+            "block-end": string;
+        };
+    };
+    defaultVariants: {
+        align: "inline-start";
+    };
+}, "defaultVariants"> & {
+    variants: {
+        align: {
+            "inline-start": string;
+            "inline-end": string;
+            "block-start": string;
+            "block-end": string;
+        };
+    };
+    defaultVariants: Omit<{}, "align"> & {
+        align: "inline-start";
+    };
+}, {
+    align: {
+        "inline-start": string;
+        "inline-end": string;
+        "block-start": string;
+        "block-end": string;
+    };
+}>;
 declare const InputGroupAddon: Component<ComponentProps<"div"> & VariantProps<typeof inputGroupAddonVariants>>;
-declare const inputGroupButtonVariants: (props?: ({
-    size?: "sm" | "xs" | "icon-xs" | "icon-sm" | undefined;
-} & ({
-    class?: import("cva").ClassValue;
-    className?: never;
-} | {
-    class?: never;
-    className?: import("cva").ClassValue;
-})) | undefined) => string;
+declare const inputGroupButtonVariants: import("cva").CVAComponent<Omit<{
+    base: string;
+    variants: {
+        size: {
+            xs: string;
+            sm: string;
+            "icon-xs": string;
+            "icon-sm": string;
+        };
+    };
+    defaultVariants: {
+        size: "xs";
+    };
+}, "defaultVariants"> & {
+    variants: {
+        size: {
+            xs: string;
+            sm: string;
+            "icon-xs": string;
+            "icon-sm": string;
+        };
+    };
+    defaultVariants: Omit<{}, "size"> & {
+        size: "xs";
+    };
+}, {
+    size: {
+        xs: string;
+        sm: string;
+        "icon-xs": string;
+        "icon-sm": string;
+    };
+}>;
 declare const InputGroupButton: Component<Omit<ComponentProps<typeof Button>, "size"> & VariantProps<typeof inputGroupButtonVariants>>;
 declare const InputGroupText: Component<ComponentProps<"span">>;
 declare const InputGroupInput: Component<ComponentProps<"input">>;

package/dist/solid/item.d.ts

@@ -1,30 +1,86 @@
 import { type VariantProps } from "cva";
 import { type Component, type ComponentProps, type ValidComponent } from "solid-js";
-import { Separator } from "./separator";
+import { Separator } from "./separator.js";
 declare const ItemGroup: Component<ComponentProps<"ul">>;
 declare const ItemSeparator: Component<ComponentProps<typeof Separator>>;
-declare const itemVariants: (props?: ({
-    variant?: "default" | "outline" | "muted" | undefined;
-    size?: "default" | "sm" | undefined;
-} & ({
-    class?: import("cva").ClassValue;
-    className?: never;
-} | {
-    class?: never;
-    className?: import("cva").ClassValue;
-})) | undefined) => string;
+declare const itemVariants: import("cva").CVAComponent<Omit<{
+    base: string;
+    variants: {
+        variant: {
+            default: string;
+            outline: string;
+            muted: string;
+        };
+        size: {
+            default: string;
+            sm: string;
+        };
+    };
+    defaultVariants: {
+        variant: "default";
+        size: "default";
+    };
+}, "defaultVariants"> & {
+    variants: {
+        variant: {
+            default: string;
+            outline: string;
+            muted: string;
+        };
+        size: {
+            default: string;
+            sm: string;
+        };
+    };
+    defaultVariants: Omit<{}, "variant" | "size"> & {
+        variant: "default";
+        size: "default";
+    };
+}, {
+    variant: {
+        default: string;
+        outline: string;
+        muted: string;
+    };
+    size: {
+        default: string;
+        sm: string;
+    };
+}>;
 declare const Item: Component<ComponentProps<"div"> & VariantProps<typeof itemVariants> & {
-    component?: ValidComponent;
+    as?: ValidComponent;
+    href?: string;
+}>;
+declare const itemMediaVariants: import("cva").CVAComponent<Omit<{
+    base: string;
+    variants: {
+        variant: {
+            default: string;
+            icon: string;
+            image: string;
+        };
+    };
+    defaultVariants: {
+        variant: "default";
+    };
+}, "defaultVariants"> & {
+    variants: {
+        variant: {
+            default: string;
+            icon: string;
+            image: string;
+        };
+    };
+    defaultVariants: Omit<{}, "variant"> & {
+        variant: "default";
+    };
+}, {
+    variant: {
+        default: string;
+        icon: string;
+        image: string;
+    };
 }>;
-declare const itemMediaVariants: (props?: ({
-    variant?: "default" | "icon" | "image" | undefined;
-} & ({
-    class?: import("cva").ClassValue;
-    className?: never;
-} | {
-    class?: never;
-    className?: import("cva").ClassValue;
-})) | undefined) => string;
 declare const ItemMedia: Component<ComponentProps<"div"> & VariantProps<typeof itemMediaVariants>>;
 declare const ItemContent: Component<ComponentProps<"div">>;
 declare const ItemTitle: Component<ComponentProps<"div">>;

package/dist/solid/logo.d.ts

@@ -0,0 +1,23 @@
+import { type Component, type ComponentProps, type JSX } from "solid-js";
+import { type LogoSize } from "../lib/logo-lockup.js";
+type LogoProps = Omit<ComponentProps<"div">, "children"> & {
+    /** Sub-brand line. Defaults to "Dash". */
+    sub?: string;
+    size?: LogoSize;
+    /** Renders the lockup as a link when set. */
+    href?: string;
+    /** Override the mark asset. Both apps serve the default path. */
+    src?: string;
+    /** Extra classes for the mark, e.g. a hover transform. */
+    markClass?: string;
+    /** Replaces the sub-brand line for surfaces that animate over it. */
+    subSlot?: JSX.Element;
+};
+/**
+ * The GlassHome lockup: mark + "GlassHome" + the sub-brand line. One ratio
+ * everywhere (audit L2) — the sub-line is the dominant element, the wordmark
+ * rides above it as a smaller eyebrow, and both scale together via `size`.
+ * Never hand-build this stack; the spec lives in lib/logo-lockup.ts.
+ */
+declare const Logo: Component<LogoProps>;
+export { Logo };

package/dist/solid/number-field.d.ts

@@ -0,0 +1,3 @@
+import { type Component, type ComponentProps } from "solid-js";
+declare const NumberField: Component<Omit<ComponentProps<"input">, "type">>;
+export { NumberField };

package/dist/solid/overlay.d.ts

@@ -0,0 +1,3 @@
+import { type Component, type ComponentProps } from "solid-js";
+declare const Overlay: Component<ComponentProps<"div">>;
+export { Overlay };

package/dist/solid/page-header.d.ts

@@ -0,0 +1,18 @@
+import { type JSX } from "solid-js";
+import type { GlassSurface } from "./section-card.js";
+export declare function PageHeader(props: {
+    /** Iconify icon name for the banner glyph. */
+    icon?: string;
+    /** Custom glyph, overrides `icon`. */
+    iconNode?: JSX.Element;
+    title: JSX.Element;
+    subtitle?: JSX.Element;
+    /** Small count pill next to the title. Rendered only when not null/undefined. */
+    count?: number | string;
+    /** Right-side actions. */
+    actions?: JSX.Element;
+    /** Watermark image src (e.g. the app logo). Omit for no watermark. */
+    logo?: string;
+    /** Performant-blur injection (dash). Omit for a normal frosted banner. */
+    glass?: GlassSurface;
+}): JSX.Element;

package/dist/solid/popover.d.ts

@@ -13,4 +13,10 @@ declare const Popover: typeof import("@kobalte/core/popover").Root & {
 declare const PopoverTrigger: Component<ComponentProps<typeof PopoverPrimitive.Trigger>>;
 declare const PopoverContent: Component<ComponentProps<typeof PopoverPrimitive.Content>>;
 declare const PopoverAnchor: Component<ComponentProps<typeof PopoverPrimitive.Anchor>>;
-export { Popover, PopoverAnchor, PopoverContent, PopoverTrigger };
+declare const anchorToTriggerTop: (anchor?: HTMLElement) => {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+};
+export { anchorToTriggerTop, Popover, PopoverAnchor, PopoverContent, PopoverTrigger };

package/dist/solid/scope-indicator.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Scope pill: `@scope (personal|org)`. The publisher-scope marker shared across
+ * widget cards and detail surfaces in both apps.
+ */
+export declare function ScopeIndicator(props: {
+    scope: string;
+    type: "personal" | "organization";
+}): import("solid-js").JSX.Element;

package/dist/solid/section-card.d.ts

@@ -0,0 +1,54 @@
+import { type ComponentProps, type JSX } from "solid-js";
+export type GlassSurface = {
+    ref?: (el: HTMLElement) => void;
+    style?: () => JSX.CSSProperties;
+    active?: () => boolean;
+};
+type SectionCardProps = {
+    icon?: string;
+    title?: JSX.Element;
+    subtitle?: JSX.Element;
+    count?: number | string;
+    action?: JSX.Element;
+    toolbar?: JSX.Element;
+    headerClass?: string;
+    glass?: GlassSurface;
+    children: JSX.Element;
+};
+export declare function SectionCard(props: SectionCardProps): JSX.Element;
+export declare function SectionRow(props: ComponentProps<"div">): JSX.Element;
+type SectionIconSize = "sm" | "md" | "lg";
+declare const ICON_TONES: {
+    readonly neutral: "bg-foreground/10 text-foreground/80";
+    readonly primary: "bg-primary/10 text-primary";
+};
+export declare function SectionIcon(props: {
+    icon?: string;
+    children?: JSX.Element;
+    size?: SectionIconSize;
+    tone?: keyof typeof ICON_TONES;
+    class?: string;
+}): JSX.Element;
+export declare function SectionTitle(props: {
+    children: JSX.Element;
+    class?: string;
+}): JSX.Element;
+export declare function SectionSubtitle(props: {
+    children: JSX.Element;
+    class?: string;
+}): JSX.Element;
+export declare function SectionLabel(props: {
+    children: JSX.Element;
+    class?: string;
+}): JSX.Element;
+export declare function SectionMeta(props: {
+    children: JSX.Element;
+    class?: string;
+}): JSX.Element;
+export declare function SectionRowSkeleton(props: {
+    class?: string;
+}): JSX.Element;
+export declare function SectionRowSkeletons(props: {
+    count?: number;
+}): JSX.Element;
+export {};

package/dist/solid/select.d.ts

@@ -1,23 +1,6 @@
 import { Select as SelectPrimitive } from "@kobalte/core/select";
 import { type Component, type ComponentProps, type ParentComponent } from "solid-js";
-declare const Select: typeof import("@kobalte/core/select").Root & {
-    Arrow: typeof import("@kobalte/core/popover").Arrow;
-    Content: typeof import("@kobalte/core/select").Content;
-    Description: typeof import("@kobalte/core/color-slider").Description;
-    ErrorMessage: typeof import("@kobalte/core/color-slider").ErrorMessage;
-    HiddenSelect: typeof import("@kobalte/core/select").HiddenSelect;
-    Icon: typeof import("@kobalte/core/select").Icon;
-    Item: typeof import("@kobalte/core/select").Item;
-    ItemDescription: typeof import("@kobalte/core/select").ItemDescription;
-    ItemIndicator: typeof import("@kobalte/core/select").ItemIndicator;
-    ItemLabel: typeof import("@kobalte/core/select").ItemLabel;
-    Label: typeof import("@kobalte/core/select").Label;
-    Listbox: typeof import("@kobalte/core/select").Listbox;
-    Portal: typeof import("@kobalte/core/select").Portal;
-    Section: typeof import("@kobalte/core/select").Section;
-    Trigger: typeof import("@kobalte/core/select").Trigger;
-    Value: typeof import("@kobalte/core/select").Value;
-};
+declare const Select: typeof SelectPrimitive;
 declare const SelectValue: typeof import("@kobalte/core/select").Value;
 declare const SelectTrigger: ParentComponent<ComponentProps<typeof SelectPrimitive.Trigger> & {
     size?: "sm" | "default";

package/dist/solid/settings-row.d.ts

@@ -0,0 +1,34 @@
+import { type JSX } from "solid-js";
+/**
+ * Generic settings/list row primitives, shared by dash settings and any list UI.
+ * Presentational only — no app data or routing. (dash's LabeledIconPicker stays
+ * local since it depends on the dash IconPicker.)
+ */
+export declare function SectionAddButton(props: {
+    onClick: () => void;
+}): JSX.Element;
+export declare function SectionEmpty(props: {
+    children: JSX.Element;
+}): JSX.Element;
+export declare function RowActions(props: {
+    onEdit: () => void;
+    onDelete: () => void;
+    deleteDisabled?: boolean;
+    deleteTitle?: string;
+    showDelete?: boolean;
+}): JSX.Element;
+export declare function LabeledField(props: {
+    label: string;
+    children: JSX.Element;
+}): JSX.Element;
+export declare function LabeledInput(props: {
+    label: string;
+    value: string;
+    onInput: (value: string) => void;
+    placeholder?: string;
+}): JSX.Element;
+export declare function SwitchRow(props: {
+    label: string;
+    checked: boolean;
+    onChange: (value: boolean) => void;
+}): JSX.Element;

package/dist/solid/sliding-indicator.d.ts

@@ -0,0 +1,32 @@
+import { type ComponentProps, type JSX } from "solid-js";
+/**
+ * The sliding "moving background": a tinted indicator that measures the active item
+ * among its children and animates its position/size behind it. Reusable across
+ * any component with a selected item among siblings (Dock, Tabs, ToggleGroup,
+ * segmented controls…). Presentational + controlled — pass the active index.
+ *
+ * Wrap the items directly; by default it measures each direct child (excluding
+ * its own indicator). Give it `indicatorClass` for the look and `orientation` for the axis.
+ */
+interface SlidingIndicatorProps extends ComponentProps<"div"> {
+    /** Index-based active item among the measured children, or null to hide.
+     *  Use this when you own the selection (e.g. Dock). */
+    active?: number | null;
+    /** Attribute-based active item: a selector for the currently-active child
+     *  (e.g. "[data-selected]"). Use this with libraries that mark the active item
+     *  in the DOM (Kobalte Tabs/ToggleGroup); a MutationObserver re-slides on change. */
+    activeSelector?: string;
+    orientation?: "horizontal" | "vertical";
+    /** Extra classes for the sliding indicator — radius and any per-surface `--glass-*`
+     *  knob overrides. The trusted `.glass` material is ALWAYS applied underneath, so
+     *  this can't flatten the indicator; it only tunes it. Default radius: `rounded-lg`. */
+    indicatorClass?: string;
+    /** Glass tone that drives the `.glass` material (`--glass-tone`). Defaults to
+     *  `var(--primary)` — the one trusted look. Pass another CSS color to re-tint. */
+    indicatorTone?: string;
+    /** Selector for the measurable items. Default: direct children (minus the indicator). */
+    itemSelector?: string;
+    children: JSX.Element;
+}
+export declare function SlidingIndicator(props: SlidingIndicatorProps): JSX.Element;
+export {};

package/dist/solid/sonner.d.ts

@@ -1,5 +1,36 @@
-import { type Component, type ComponentProps } from "solid-js";
-import { Toaster as SolidSonner } from "solid-sonner";
+import { type Component, type ComponentProps, type JSX } from "solid-js";
+import { type ExternalToast, Toaster as SolidSonner } from "solid-sonner";
+type ToastMessage = JSX.Element | string;
+type ToastKind = "success" | "error" | "warning" | "info" | "loading" | "message";
+type GlassToastProps = {
+    kind: ToastKind;
+    title: ToastMessage;
+    description?: ToastMessage;
+    icon?: JSX.Element;
+    action?: JSX.Element;
+};
+declare const GlassToast: Component<GlassToastProps>;
+type PromiseData<T> = Omit<ExternalToast, "description"> & {
+    loading?: ToastMessage;
+    success?: ToastMessage | ((data: T) => ToastMessage);
+    error?: ToastMessage | ((err: unknown) => ToastMessage);
+    finally?: () => void | Promise<void>;
+};
+declare function glassPromise<T>(promise: Promise<T> | (() => Promise<T>), data?: PromiseData<T>): {
+    unwrap: () => Promise<T>;
+};
+declare const toast: ((message: ToastMessage, data?: ExternalToast) => string | number) & {
+    success: (message: ToastMessage, data?: ExternalToast) => string | number;
+    error: (message: ToastMessage, data?: ExternalToast) => string | number;
+    warning: (message: ToastMessage, data?: ExternalToast) => string | number;
+    info: (message: ToastMessage, data?: ExternalToast) => string | number;
+    message: (message: ToastMessage, data?: ExternalToast) => string | number;
+    loading: (message: ToastMessage, data?: ExternalToast) => string | number;
+    custom: (jsx: (id: number | string) => JSX.Element, data?: ExternalToast) => string | number;
+    dismiss: (id?: number | string) => string | number | undefined;
+    promise: typeof glassPromise;
+    getHistory: () => (import("solid-sonner").ToastT | import("solid-sonner").ToastToDismiss)[];
+    getToasts: () => import("solid-sonner").ToastT[];
+};
 declare const Toaster: Component<ComponentProps<typeof SolidSonner>>;
-export { toast } from "solid-sonner";
-export { Toaster };
+export { GlassToast, Toaster, toast };

package/dist/solid/spinner.d.ts

@@ -1,3 +1,4 @@
+import { Icon } from "@iconify-icon/solid";
 import { type Component, type ComponentProps } from "solid-js";
-declare const Spinner: Component<ComponentProps<"svg">>;
+declare const Spinner: Component<Omit<ComponentProps<typeof Icon>, "icon">>;
 export { Spinner };

package/dist/solid/switch.d.ts

@@ -1,5 +1,5 @@
 import { type Component } from "solid-js";
-export interface SwitchProps {
+interface SwitchProps {
     checked?: boolean;
     defaultChecked?: boolean;
     onChange?: (checked: boolean) => void;

package/dist/solid/toggle-group.d.ts

@@ -1,7 +1,7 @@
 import { ToggleGroup as ToggleGroupPrimitive } from "@kobalte/core/toggle-group";
 import type { VariantProps } from "cva";
 import { type Component, type ComponentProps, type ParentComponent } from "solid-js";
-import { toggleVariants } from "./toggle";
+import { toggleVariants } from "./toggle.js";
 declare const ToggleGroup: ParentComponent<ComponentProps<typeof ToggleGroupPrimitive> & VariantProps<typeof toggleVariants>>;
 declare const ToggleGroupItem: Component<ComponentProps<typeof ToggleGroupPrimitive.Item> & VariantProps<typeof toggleVariants>>;
 export { ToggleGroup, ToggleGroupItem };

package/dist/solid/toggle.d.ts

@@ -1,15 +1,49 @@
 import { ToggleButton as ToggleButtonPrimitive } from "@kobalte/core/toggle-button";
 import { type VariantProps } from "cva";
 import { type Component, type ComponentProps } from "solid-js";
-declare const toggleVariants: (props?: ({
-    variant?: "default" | "outline" | undefined;
-    size?: "default" | "sm" | "lg" | undefined;
-} & ({
-    class?: import("cva").ClassValue;
-    className?: never;
-} | {
-    class?: never;
-    className?: import("cva").ClassValue;
-})) | undefined) => string;
+declare const toggleVariants: import("cva").CVAComponent<Omit<{
+    base: string;
+    variants: {
+        variant: {
+            default: string;
+            outline: string;
+        };
+        size: {
+            default: string;
+            sm: string;
+            lg: string;
+        };
+    };
+    defaultVariants: {
+        variant: "default";
+        size: "default";
+    };
+}, "defaultVariants"> & {
+    variants: {
+        variant: {
+            default: string;
+            outline: string;
+        };
+        size: {
+            default: string;
+            sm: string;
+            lg: string;
+        };
+    };
+    defaultVariants: Omit<{}, "variant" | "size"> & {
+        variant: "default";
+        size: "default";
+    };
+}, {
+    variant: {
+        default: string;
+        outline: string;
+    };
+    size: {
+        default: string;
+        sm: string;
+        lg: string;
+    };
+}>;
 declare const Toggle: Component<ComponentProps<typeof ToggleButtonPrimitive> & VariantProps<typeof toggleVariants>>;
 export { Toggle, toggleVariants };

package/dist/solid/widget-card.d.ts

@@ -0,0 +1,29 @@
+import { type JSX } from "solid-js";
+import { type WidgetSummary } from "./widget-identity.js";
+/**
+ * The registry widget card: `row` for dense lists, `tile` for grids/galleries.
+ * Both are a <Card> + the WidgetIdentity/WidgetMeta nucleus. Shared by every
+ * widget surface (registry gallery, dashboard browse, admin tables) across
+ * apps; the data model is `WidgetSummary`.
+ */
+type WidgetCardProps = {
+    widget: WidgetSummary;
+    /** `row` for dense lists, `tile` for grids/galleries. Default `row`. */
+    layout?: "row" | "tile";
+    /** When set, the whole card becomes a link. */
+    href?: string;
+    /** Click handler (used when no href). */
+    onClick?: (e: MouseEvent) => void;
+    /** Show the (personal/org) scope pill. Default false. */
+    showScopeIndicator?: boolean;
+    /** Show the version-count meta. Default false. */
+    showVersions?: boolean;
+    /** Show the description (tile only). Default true for tiles. */
+    showDescription?: boolean;
+    /** Custom trailing element for the row layout. Defaults to a chevron when
+     *  the card is interactive (href/onClick), otherwise nothing. */
+    trailing?: JSX.Element;
+    class?: string;
+};
+export declare function WidgetCard(_props: WidgetCardProps): JSX.Element;
+export {};

package/dist/solid/widget-identity.d.ts

@@ -0,0 +1,47 @@
+import { type JSX } from "solid-js";
+/**
+ * The reusable nucleus for rendering one widget/package: icon pill + name (with
+ * official/unlisted markers + inline version) + the @scope/name line, plus the
+ * download/version meta cluster. Shared by every widget surface (registry
+ * gallery, dashboard browse, admin tables). App-specific cards (hub's row/tile
+ * registry card, dash's interactive picker) compose this; the data model is
+ * `WidgetSummary`.
+ */
+export interface WidgetSummary {
+    scope: string;
+    name: string;
+    displayName?: string | null;
+    icon?: string | null;
+    description?: string | null;
+    isOfficial?: boolean;
+    isUnlisted?: boolean;
+    downloadCount?: number;
+    latestVersion?: string | null;
+    versionCount?: number;
+    ownerType?: "personal" | "organization";
+}
+/** Canonical public detail URL for a widget (`/widgets/@scope/name`). */
+export declare function widgetHref(w: {
+    scope: string;
+    name: string;
+}): string;
+/** Compact download/count formatting, shared by every surface. */
+export declare function formatWidgetCount(n: number | null | undefined): string;
+type WidgetIdentityProps = {
+    widget: WidgetSummary;
+    /** Icon pill size. Rows use sm, tiles use md. */
+    iconSize?: "sm" | "md";
+    /** Append `v{latestVersion}` next to the name. Default true. */
+    showVersionInline?: boolean;
+    /** Show the (personal/org) scope pill after the @scope/name line. */
+    showScopeIndicator?: boolean;
+    class?: string;
+};
+export declare function WidgetIdentity(_props: WidgetIdentityProps): JSX.Element;
+/** Downloads (+ optional version count) meta cluster. */
+export declare function WidgetMeta(props: {
+    widget: WidgetSummary;
+    showVersions?: boolean;
+    class?: string;
+}): JSX.Element;
+export {};

package/dist/solid/widget-trust-badge.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Official / Community trust marker, single source for every widget surface
+ * (browser card, picker card, detail dialog) in both apps. Was drifted: hub used
+ * `lucide:badge-check`, dash used `mdi:check-decagram`; unified on the decagram,
+ * inlined as SVG so it needs no iconify collection registered by the consumer
+ * (hub has no `mdi` collection). The `title` is hover-only and ignored by screen
+ * readers, so the sr-only span carries the verbal label alongside the glyph.
+ *
+ * Both states are glyph-only: official is the decagram check (primary),
+ * community is the account-group people icon (muted). Community was a full
+ * `Badge` word before, but the label ate horizontal space next to the widget
+ * name, so it now matches the official marker's compact icon form.
+ */
+export declare function WidgetTrustBadge(props: {
+    isOfficial: boolean;
+}): import("solid-js").JSX.Element;

package/dist/tokens/index.d.ts

@@ -2,6 +2,6 @@
  * Design tokens as data, framework-free. Must stay in sync with
  * styles/theme.css (presets.ts is the machine-readable form of that palette).
  */
-export * from "./hex";
-export * from "./presets";
-export * from "./theme-colors";
+export * from "./hex.js";
+export * from "./presets.js";
+export * from "./theme-colors.js";