@hanzo/ui 8.0.8 → 8.0.12

package/dist/product/AnimatedLogo.d.ts

@@ -0,0 +1,47 @@
+/**
+ * AnimatedLogo — the ONE animated brand logo across every Hanzo surface.
+ *
+ * On mount the full wordmark shows ("Hanzo {surface}", e.g. "Hanzo Cloud"), then
+ * collapses INTO just the brand mark; hover or keyboard-focus expands it back to
+ * the full name. This is the shared brand-identity primitive — the behavior that
+ * ships on hanzo.ai and cloud.hanzo.ai, made one component, white-label aware.
+ *
+ *   <AnimatedLogo surface="Cloud" />                    // Hanzo Cloud → H
+ *   <AnimatedLogo surface="Studio" />                   // Hanzo Studio → H
+ *   <AnimatedLogo surface="Cloud" brand={LUX} />        // Lux Cloud → Lux mark
+ *
+ * Presentational + host-agnostic (plain React + inline SVG, no @hanzo/gui, no
+ * framer): drops into any surface — the Tamagui console, the Next marketing site,
+ * a desktop shell. Theme-aware (the mark is `currentColor`), and accessible: the
+ * accessible name is always the full "Hanzo {surface}" regardless of the visual
+ * collapse, and `prefers-reduced-motion` yields a static mark with no animation.
+ */
+import React from 'react';
+import { type BrandIdentity } from './brand';
+export interface AnimatedLogoProps {
+    /** Surface word after the brand ("AI", "Cloud", "Studio", "Chat", "App", "Console", "Team"). */
+    surface?: string;
+    /** Brand identity — mark + name + home. Defaults to Hanzo. */
+    brand?: BrandIdentity;
+    /** Mark size in px (square). Default 22. */
+    size?: number;
+    /** Gap in px between the mark and the wordmark when expanded. Default 8. */
+    gap?: number;
+    /** Hold in ms before the wordmark auto-collapses on mount. 0 disables the intro
+     *  (starts collapsed). Default 1500. */
+    introMs?: number;
+    /** Collapse/expand duration in ms. Default 360 (echoes the mark's fold-in). */
+    durationMs?: number;
+    /** Easing curve. Default the Hanzo house expo-out. */
+    easing?: string;
+    /** Link target. Defaults to the brand's home. */
+    href?: string;
+    onClick?: React.MouseEventHandler;
+    /** Root element/component (e.g. a router `Link`). Default `'a'`. */
+    component?: React.ElementType;
+    className?: string;
+    style?: React.CSSProperties;
+    /** Override the accessible name (default is the full "Hanzo {surface}"). */
+    'aria-label'?: string;
+}
+export declare function AnimatedLogo({ surface, brand, size, gap, introMs, durationMs, easing, href, onClick, component, className, style, 'aria-label': ariaLabel, }: AnimatedLogoProps): import("react/jsx-runtime").JSX.Element;

package/dist/product/BackendState.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Honest backend states for `/v1`-backed modules — ONE place that maps a thrown
+ * HTTP error to a truthful explanation.
+ *
+ * A 503 means the runtime/keys aren't wired on this deployment yet, a 404/405
+ * means the route isn't mounted here, 401/403 means the session can't read it,
+ * 402 means the org has no funded balance. Nothing is fabricated — on failure the
+ * caller shows this card instead of placeholder rows/charts.
+ *
+ * Classification is duck-typed on `status`, so any client's error class works
+ * (console's `ApiError`, commerce's `CommerceError`, …) without this layer
+ * depending on one. Effects come from `useHost()`.
+ */
+import type { ReactNode } from 'react';
+export type BackendStateKind = 'not-initialized' | 'unavailable' | 'not-implemented' | 'access' | 'signin' | 'billing' | 'error';
+export type BackendState = {
+    kind: BackendStateKind;
+    message: string;
+};
+/**
+ * Classify a thrown `/v1` error into an honest kind + raw message.
+ *
+ * 401 and 403 are DISTINCT for a signed-in user: 401 = the session is expired /
+ * not recognized (re-auth fixes it → `signin`), 403 = the account IS signed in
+ * but this surface isn't authorized/enabled for its org (`access`). A signed-in
+ * user is NEVER told to "sign in" for a 403 — that would be a false instruction.
+ */
+export declare function classifyBackend(e: unknown): BackendState;
+/**
+ * Classify a READ (GET/list) failure. Identical to `classifyBackend` EXCEPT a 402
+ * is NOT a wall: listing/reading a resource is never credit-gated, so a 402 on a
+ * read means "nothing is provisioned yet" — the caller shows its honest EMPTY
+ * state (e.g. "No buckets yet · Create one"), never an "add credits" paywall
+ * (that belongs only on a paid WRITE). Returns `null` for a 402 → treat as empty.
+ */
+export declare function classifyRead(e: unknown): BackendState | null;
+/** A truthful state card for a `/v1` load failure, with an optional retry + hint. */
+export declare function BackendStateCard({ state, onRetry, hint, }: {
+    state: BackendState;
+    onRetry?: () => void;
+    hint?: ReactNode;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/product/Charts.d.ts

@@ -34,6 +34,10 @@ export type Slice = {
     color?: string;
     hint?: string;
 };
+export declare function useContainerWidth(): {
+    ref: import("react").RefObject<HTMLDivElement | null>;
+    w: number;
+};
 export declare function Sparkline({ values, width, height, color, }: {
     values: number[];
     width?: number;

package/dist/product/CommerceResource.d.ts

@@ -0,0 +1,32 @@
+/**
+ * CommerceResource — the ONE list surface every Commerce store page renders (Products,
+ * Orders, Customers, Inventory, Promotions). It owns the fetch → honest loading / empty
+ * / error lifecycle (identical to the Subscriptions/Functions modules) so each page is
+ * just a title + a `load()` + its columns; there is one way to render a store list.
+ *
+ * `load` is held in a ref so a page can pass an inline `() => CommerceApi.products()`
+ * without re-triggering the mount effect — the list fetches once and on explicit
+ * Refresh. Every row is real (the caller's org-scoped `/v1` fetch); an empty store
+ * shows the honest empty copy, never a placeholder row. Both the console's Store
+ * category and the standalone Commerce admin render THIS.
+ */
+import { type ReactNode } from 'react';
+import { type Column } from './DataTable';
+/** A commerce list page — the rows on this page plus the total the backend reports. */
+export type CommerceList<T> = {
+    rows: T[];
+    count: number;
+};
+export declare function CommerceResource<T>({ title, subtitle, load, columns, rowKey, empty, hint, actions, }: {
+    title: string;
+    subtitle: string;
+    /** Real per-org fetch (via the `/commerce` proxy). Identity may change per render. */
+    load: () => Promise<CommerceList<T>>;
+    columns: Column<T>[];
+    rowKey: (row: T) => string;
+    empty: string;
+    /** BackendStateCard hint — the real endpoint, e.g. `GET /v1/product`. */
+    hint: string;
+    /** Optional extra header actions (given the reload fn), left of Refresh. */
+    actions?: (reload: () => void) => ReactNode;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/product/ConfirmDelete.d.ts

@@ -0,0 +1,8 @@
+export declare function ConfirmDelete({ message, confirmLabel, run, onDone, }: {
+    /** The full consequence, stated plainly ("Delete X and all N of its records?"). */
+    message: string;
+    confirmLabel: string;
+    run: () => Promise<void>;
+    /** Called on success AND on cancel — the caller closes the drawer and reloads. */
+    onDone: () => void;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/product/DataTable.d.ts

@@ -3,7 +3,16 @@
  *
  * Rows are typed `<T>`; columns declare a key, header, and optional cell
  * renderer. Built on Hanzo GUI Stacks (shorthand style props per the v5 config)
- * so it adapts across platforms. Loading and empty states are first-class.
+ * so it adapts across platforms. Loading and empty states are first-class:
+ * loading paints SKELETON ROWS in the real column layout (an honest "loading",
+ * never a spinner void); numeric columns opt into right-aligned Geist Mono
+ * tabular figures so amounts/counts/IDs read as precise, column-aligned data.
+ *
+ * SORTING is opt-in and caller-owned: a column marks itself `sortable`, the caller
+ * passes the current `sort` + an `onSortChange`, and the table only reports the
+ * clicked key (it never reorders `rows` itself — the caller's own pure comparator
+ * stays the one source of order). Omit all three and the table behaves exactly as
+ * before, so every existing consumer is unchanged.
  */
 import type { ReactNode } from 'react';
 export type Column<T> = {
@@ -13,12 +22,31 @@ export type Column<T> = {
     render?: (row: T) => ReactNode;
     /** Fixed width (px) for the column; otherwise flexes. */
     width?: number;
+    /** Horizontal alignment — `right` for numeric/amount columns. */
+    align?: 'left' | 'right';
+    /** Typeset the default cell + header as Geist Mono tabular (counts, amounts, IDs). */
+    mono?: boolean;
+    /** Clickable header that reports `onSortChange(key)` (needs both table props). */
+    sortable?: boolean;
+};
+/** The active sort — which column key, which direction. */
+export type SortState = {
+    key: string;
+    dir: 'asc' | 'desc';
 };
-export declare function DataTable<T>({ columns, rows, loading, empty, rowKey, onRowPress, }: {
+export declare function DataTable<T>({ columns, rows, loading, empty, rowKey, onRowPress, isRowExpanded, renderExpanded, sort, onSortChange, }: {
     columns: Column<T>[];
     rows: T[];
     loading?: boolean;
     empty?: string;
     rowKey: (row: T) => string;
     onRowPress?: (row: T) => void;
+    /** When set + true for a row, its `renderExpanded` panel is shown below it. */
+    isRowExpanded?: (row: T) => boolean;
+    /** Full-width detail panel rendered under an expanded row (master-detail accordion). */
+    renderExpanded?: (row: T) => ReactNode;
+    /** The active sort, for the header caret + `aria-sort`. */
+    sort?: SortState;
+    /** Called with the clicked column key; the caller owns the reordering. */
+    onSortChange?: (key: string) => void;
 }): import("react/jsx-runtime").JSX.Element;

package/dist/product/Field.d.ts

@@ -6,7 +6,11 @@
  * use the v5 shorthand set (p/px/items/justify/...).
  */
 import type { ReactNode } from 'react';
-/** Labeled row: fixed label column + flexing control. */
+/**
+ * Labeled row. STACKED on phones (label full-width above a full-width control) so a
+ * form inside a SlideOver stays usable and never clips its labels; a fixed 180px
+ * label column + flexing control at $md+ (the two-column desktop/tablet layout).
+ */
 export declare function FieldRow({ label, children }: {
     label: string;
     children: ReactNode;
@@ -29,11 +33,12 @@ export declare function FieldSwitch({ checked, onChange, disabled, }: {
     onChange: (v: boolean) => void;
     disabled?: boolean;
 }): import("react/jsx-runtime").JSX.Element;
-export declare function FieldSelect({ value, options, onChange, disabled, }: {
+export declare function FieldSelect({ value, options, onChange, disabled, placeholder, }: {
     value: string;
     options: string[];
     onChange: (v: string) => void;
     disabled?: boolean;
+    placeholder?: string;
 }): import("react/jsx-runtime").JSX.Element;
 export declare function FieldSlider({ value, min, max, step, onChange, disabled, }: {
     value: number;

package/dist/product/Filters.d.ts

@@ -0,0 +1,29 @@
+/**
+ * List-filter atoms — the ONE segmented pill control and the ONE search box every
+ * table surface filters with.
+ *
+ * These were first written for the Inference endpoints dashboard; promoted here so a
+ * sibling product (Infrastructure, …) never reaches into `inference/` for shell chrome
+ * — the same separation-of-concerns move `ui/Metric.tsx` made out of `gpus/`.
+ * `inference/parts.tsx` re-exports them, so there is exactly one definition.
+ */
+import type { ComponentProps } from 'react';
+import { Button } from '@hanzo/gui';
+/** One pill in a segmented control. */
+export type Option<T extends string> = {
+    label: string;
+    value: T;
+};
+/** A compact segmented pill control — the ONE way filters/ranges/toggles render. */
+export declare function Segmented<T extends string>({ options, value, onChange, size, }: {
+    options: Option<T>[];
+    value: T;
+    onChange: (v: T) => void;
+    size?: ComponentProps<typeof Button>['size'];
+}): import("react/jsx-runtime").JSX.Element;
+/** A search input with a leading magnifier. */
+export declare function SearchInput({ value, onChange, placeholder }: {
+    value: string;
+    onChange: (v: string) => void;
+    placeholder?: string;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/product/OrgMark.d.ts

@@ -0,0 +1,21 @@
+import type { Org } from './scope';
+/**
+ * The monogram for a name: the first letter of each of the first two words,
+ * uppercased — the SAME rule @hanzo/iam's account widget applies to a person, so
+ * a workspace and a user wear one treatment. Words break on whitespace and on the
+ * separators an org id carries (`.`, `_`, `-`, `/`), so `acme-labs` reads AL
+ * while a single word reads its one initial.
+ */
+export declare function monogram(name: string): string;
+export type OrgMarkProps = {
+    /** The org to mark — its `logo` wins, else the monogram of its display name. */
+    org: Org;
+    /** Edge of the square tile / height of the logo. Default 22. */
+    size?: number;
+    /**
+     * Widest a LOGO may run, for a wordmark that is not square. Omit to keep the
+     * logo square like the monogram (a switcher row, an avatar slot).
+     */
+    maxW?: number;
+};
+export declare function OrgMark({ org, size, maxW }: OrgMarkProps): import("react/jsx-runtime").JSX.Element;

package/dist/product/OrgSwitcher.d.ts

@@ -10,9 +10,16 @@ export type OrgSwitcherProps = {
     orgs?: (page: number, query: string) => Promise<Org[]>;
     /** Rows per page the loader returns. Default 20. */
     pageSize?: number;
+    /**
+     * The org the surface is scoped to, already resolved (display name + logo).
+     * Omit and the trigger synthesizes it from the scope id alone — enough to name
+     * the org, but it cannot know a logo. Pass it wherever the host already
+     * resolves the org, so the switcher and the chrome's org mark agree.
+     */
+    current?: Org;
     /** Create-org hook → the created org's id; omit to hide the affordance. */
     create?: (name: string) => Promise<string>;
     /** Show the "All organizations" de-scope row (`scope.leaveOrg`). */
     picker?: boolean;
 };
-export declare function OrgSwitcher({ scope, orgs, pageSize, create, picker }: OrgSwitcherProps): import("react/jsx-runtime").JSX.Element;
+export declare function OrgSwitcher({ scope, orgs, pageSize, current: given, create, picker }: OrgSwitcherProps): import("react/jsx-runtime").JSX.Element;

package/dist/product/PrimaryButton.d.ts

@@ -6,6 +6,11 @@
  * hue accent. Use it for the single primary action in a view (sign in, save,
  * get started). Secondary and destructive actions use the default neutral
  * `Button`.
+ *
+ * When an org enables a custom brand color, this — the console's one primary
+ * action — recolors to the org accent (inline bg + the color prop the label/icon
+ * inherit), reading the live accent from `useAccent()`; with no custom theme it
+ * stays the default white. A caller's own `style`/`color` still win (spread last).
  */
 import type { ComponentProps } from 'react';
 import { Button } from '@hanzo/gui';

package/dist/product/SiteFooter.d.ts

@@ -0,0 +1,28 @@
+/**
+ * SiteFooter — the ONE footer, rendering `@hanzo/products`' `FOOTER`.
+ *
+ * 57 hand-written footers existed across the stack, differing in link set, column
+ * count, type scale and legal line, so the bottom of every Hanzo page quietly
+ * disagreed about what the company offers. The content question is already
+ * settled in `@hanzo/products` (columns built from `FAMILY` and `DESTINATIONS`,
+ * so a footer link and its menu twin cannot diverge); this is only the renderer.
+ *
+ * Deliberately not a mirror of the launcher: a footer is an index, not a menu, so
+ * every entry is a plain link and no product copy is repeated here.
+ */
+import type { ReactNode } from 'react';
+import type { Footer } from '@hanzo/products';
+import type { LinkRender } from './SiteNav';
+export type SiteFooterProps = {
+    /** The footer model — `FOOTER` from @hanzo/products. */
+    footer: Footer;
+    /** Brand slot above the columns — usually `<BrandMark/>`. */
+    brand?: ReactNode;
+    /** One line under the brand: what this company is. */
+    tagline?: string;
+    /** Social / status / app-store row, rendered opposite the copyright. */
+    meta?: ReactNode;
+    /** Host link primitive. */
+    link?: LinkRender;
+};
+export declare function SiteFooter({ footer, brand, tagline, meta, link }: SiteFooterProps): import("react/jsx-runtime").JSX.Element;

package/dist/product/SiteNav.d.ts

@@ -0,0 +1,60 @@
+/**
+ * SiteNav — the ONE header every Hanzo property renders.
+ *
+ * `@hanzo/products` already decides WHAT the navigation is: `HEADERS[site]` gives
+ * a property's local nav and its call-to-action, and `MEET_HANZO_MENU` gives the
+ * ecosystem launcher (the six-product grid, the utility row, the install row).
+ * Nothing about that content lives here. This module is only the renderer — the
+ * missing half — so a property supplies a `SiteId` and gets the same header as
+ * every other property, and the six hand-written `DesktopNav`/`MobileMenu` copies
+ * that used to drift have nothing left to disagree about.
+ *
+ * It sits at the same 52px, border and background as `AppHeader`, so the
+ * signed-out marketing bar and the signed-in shell bar read as one object.
+ *
+ * Three deliberate choices, each fixing something the old menus got wrong:
+ *
+ *   • The panel is FULL-BLEED. The old ones anchored a floating card to whichever
+ *     word opened it, so a wide panel hung off-centre and the bar's alignment
+ *     stopped meaning anything. Anchoring to the bar lets columns line up with the
+ *     header and with each other.
+ *   • Hover switches menus but never opens one. A bar where a passing cursor
+ *     throws a full-width panel is hostile; the first open must be intentional.
+ *   • ONE action. `SiteHeader.action` is a single call-to-action, so a property
+ *     cannot render two competing sign-in buttons the way cloud.hanzo.ai did.
+ *
+ * Host-agnostic like the rest of this layer: `link` injects the host's navigation
+ * primitive and `icon` resolves a product/link id to a glyph, so nothing here
+ * imports a framework or an icon set.
+ */
+import { type ReactNode } from 'react';
+import type { MeetHanzoMenu, SiteHeader } from '@hanzo/products';
+/** Render a destination. Hosts pass next/link etc.; the default is a plain anchor. */
+export type LinkRender = (props: {
+    href: string;
+    children: ReactNode;
+    onNavigate?: () => void;
+}) => ReactNode;
+export type SiteNavProps = {
+    /** The property's header model — `HEADERS[site]` from @hanzo/products. */
+    header: SiteHeader;
+    /** The ecosystem launcher — `MEET_HANZO_MENU`. Omit to hide the launcher. */
+    menu?: MeetHanzoMenu;
+    /** Brand slot — usually `<BrandMark/>`; pressing it goes home. */
+    brand?: ReactNode;
+    /**
+     * Right-hand cluster BEFORE the action: an identity menu when signed in, or a
+     * sign-in link when signed out. The action itself comes from `header`, so this
+     * slot must not repeat it.
+     */
+    actions?: ReactNode;
+    /** Host link primitive. */
+    link?: LinkRender;
+    /** Resolve a product/link `id` to a glyph. Entries render fine without it. */
+    icon?: (id: string) => ReactNode;
+    /** Marks the active local-nav item by its `Link.id`. */
+    active?: string;
+    /** Launcher label. */
+    meetLabel?: string;
+};
+export declare function SiteNav({ header, menu, brand, actions, link, icon, active, meetLabel }: SiteNavProps): import("react/jsx-runtime").JSX.Element;

package/dist/product/accent.d.ts

@@ -0,0 +1,33 @@
+/** An org's persisted theme block (mirrors IAM `themeData`; only the fields we apply). */
+export type OrgThemeData = {
+    colorPrimary?: string;
+    isEnabled?: boolean;
+};
+/** The live accent — a resolved hex + a readable text color for content on it, or null. */
+export type Accent = {
+    accent: string | null;
+    contrast: string;
+};
+/** True for a 3- or 6-digit CSS hex color (`#RGB` / `#RRGGBB`). */
+export declare function isHexColor(v: string | undefined | null): boolean;
+/**
+ * The accent hex to apply for an org, or `null` when no custom accent should be used —
+ * i.e. the theme is disabled, missing, or the color is not a valid hex. PURE.
+ */
+export declare function resolveAccent(theme: OrgThemeData | null | undefined): string | null;
+/**
+ * A readable text color (`#000000` / `#ffffff`) for content placed ON the accent,
+ * chosen by the accent's relative luminance (WCAG-style). PURE. Falls back to white
+ * for a non-hex input (never throws).
+ */
+export declare function contrastText(hex: string): '#000000' | '#ffffff';
+/** Resolve a theme block to the `Accent` value it should apply (accent+contrast or null). PURE. */
+export declare function accentFor(theme: OrgThemeData | null | undefined): Accent;
+/**
+ * Set the live accent from an org theme block. Called on load (from the fetched org) AND
+ * immediately on save — the SINGLE mechanism, so the accent survives reload and updates
+ * without one. A no-op when the resolved accent is unchanged (keeps the snapshot stable).
+ */
+export declare function setOrgAccent(theme: OrgThemeData | null | undefined): void;
+/** The live accent (subscribes to the store). Returns the default until an org theme is applied. */
+export declare function useAccent(): Accent;

package/dist/product/animatedLogo.logic.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Pure logic for `AnimatedLogo` — the wordmark ⇄ mark collapse. No React, no DOM,
+ * no @hanzo/gui: just the state → style math, unit-tested in a plain Node env
+ * (the house convention — view components are proven by build + visual e2e).
+ */
+/**
+ * The Hanzo house motion curve (expo-out) — the ONE easing used across the app
+ * shell (sidebar collapse, fade-up) and the animated mark's fold-in. Reused here
+ * so the wordmark collapse feels of a piece with every other Hanzo surface.
+ */
+export declare const HOUSE_EASE = "cubic-bezier(0.16, 1, 0.3, 1)";
+/** Default collapse/expand duration (ms) — echoes the mark's ~0.4s fold-in. */
+export declare const DEFAULT_DURATION_MS = 360;
+/** Default hold before the wordmark auto-collapses to the mark on mount (ms). */
+export declare const DEFAULT_INTRO_MS = 1500;
+/** Default gap (px) between the mark and the wordmark when expanded. */
+export declare const DEFAULT_GAP = 8;
+/** The full accessible/visible name: brand word + optional surface word. */
+export declare function wordmarkText(name: string, surface?: string): string;
+/**
+ * Is the wordmark shown? Expanded whenever the user is pointing at or keyboard-
+ * focused on the logo, OR during the on-mount intro (full name shows, then tucks
+ * into the mark). Hover/focus always win, so the name is reachable after intro.
+ */
+export declare function isExpanded(s: {
+    hovered: boolean;
+    focused: boolean;
+    introShowing: boolean;
+}): boolean;
+export interface WordmarkStyleInput {
+    expanded: boolean;
+    /** Measured natural width (px); undefined before first measure (SSR/first paint). */
+    naturalWidth?: number;
+    gap: number;
+    durationMs: number;
+    easing: string;
+    /** prefers-reduced-motion: no transition (instant), so there is no motion. */
+    reduce: boolean;
+}
+export interface WordmarkStyle {
+    width: number | string;
+    opacity: number;
+    marginLeft: number;
+    transition: string;
+}
+/**
+ * The inline style for the clipping wordmark wrapper. Collapsed = width 0 /
+ * opacity 0 / no gap (the name tucks fully into the mark); expanded = the measured
+ * natural width (or `auto` until measured). Under reduced motion the transition is
+ * dropped entirely — the state still resolves, just without animating.
+ */
+export declare function wordmarkStyle(i: WordmarkStyleInput): WordmarkStyle;

package/dist/product/brand.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Brand identities for the animated logo — the white-label source of truth.
+ *
+ * ONE component (`AnimatedLogo`) renders any brand: pass a `BrandIdentity` and it
+ * shows THAT brand's mark + name (never a hardcoded Hanzo asset). The mark
+ * geometry is byte-identical to the console's host-driven brand registry
+ * (`console/src/lib/branding/brands.ts`) so a lux/zoo/pars surface renders the
+ * exact same glyph the chrome already uses — one mark, everywhere.
+ *
+ * `content` is inner SVG markup (a build-time-trusted constant, never user
+ * input). Marks use `currentColor` so they inherit the surrounding text color and
+ * adapt to the dark/light theme with no per-theme asset — except Zoo, whose mark
+ * is intentionally full-color (`fullColor`).
+ */
+export interface BrandIdentity {
+    /** Stable id — also the IAM org slug (hanzo/lux/zoo/pars). */
+    id: string;
+    /** Brand word shown before the surface (e.g. "Hanzo" → "Hanzo Cloud"). */
+    name: string;
+    /** viewBox for the inline mark SVG. */
+    viewBox: string;
+    /** Inner SVG markup for the mark (multi-path, build-time-trusted constant). */
+    content: string;
+    /** The mark carries its own fills (Zoo) — do NOT force `currentColor`. */
+    fullColor?: boolean;
+    /** Brand home, used as the logo link's default href. */
+    href?: string;
+}
+/**
+ * The canonical Hanzo block-"H" — 5 paths, no opacity facets, `currentColor`.
+ * Byte-identical to the mark shipped in the chrome (HanzoMark + brand registry),
+ * so the default render matches the existing product surfaces exactly.
+ */
+export declare const HANZO_MARK_CONTENT: string;
+export declare const HANZO: BrandIdentity;
+/** Lux — downward triangle (the explorer/console registry mark, currentColor). */
+export declare const LUX: BrandIdentity;
+/** Zoo — interlocking circles (intentional full-color fills, not currentColor). */
+export declare const ZOO: BrandIdentity;
+/** Pars — Persian 8-pointed star (the explorer/console registry mark). */
+export declare const PARS: BrandIdentity;
+/** All shipped brands, keyed by id — the white-label registry. */
+export declare const BRANDS: Record<string, BrandIdentity>;
+/** Resolve a brand by id, falling back to Hanzo (the canonical default). */
+export declare function resolveBrand(id?: string): BrandIdentity;

package/dist/product/host.d.ts

@@ -0,0 +1,21 @@
+/**
+ * The host seam — the ONE place an app injects its effects into this layer.
+ *
+ * The product layer is presentational and host-agnostic: it never imports a
+ * router or an auth module. An honest state card still has to OFFER "Sign in
+ * again" (401) or "Add credits" (402), so the app provides those two effects
+ * once at its root and every card below renders the right affordance. Without a
+ * provider the affordance is simply not offered — nothing is faked.
+ */
+import { type ReactNode } from 'react';
+export type HostActions = {
+    /** Re-authenticate and return to this exact page (401). */
+    signIn?: () => void;
+    /** Navigate to the org's top-up surface (402). */
+    addCredits?: () => void;
+};
+export declare const HostProvider: ({ actions, children }: {
+    actions: HostActions;
+    children: ReactNode;
+}) => import("react/jsx-runtime").JSX.Element;
+export declare const useHost: () => HostActions;