@qilin-agent/client-ui-primitives 3.1.5 → 3.1.7

package/lib/types/InlineEditor.d.ts

@@ -0,0 +1,23 @@
+/** Multi-line inline editor for short saved-on-Enter drafts such as queued messages and goals. */
+/**
+ * Render an autofocused textarea that grows with its text up to six lines, then scrolls.
+ * A textarea rather than an input: HTML strips newlines from single-line input values.
+ * Enter saves, Shift+Enter breaks the line, Enter during IME composition does nothing,
+ * and Escape cancels.
+ * @param props.value - current draft text.
+ * @param props.label - localized accessible name.
+ * @param props.onChange - receives the edited text.
+ * @param props.onSave - called for a plain Enter.
+ * @param props.onCancel - called for Escape.
+ * @param props.className - extra class for the editor's placement.
+ * @returns the textarea.
+ */
+export declare function InlineEditor({ value, label, onChange, onSave, onCancel, className }: {
+    value: string;
+    label: string;
+    onChange: (value: string) => void;
+    onSave: () => void;
+    onCancel: () => void;
+    className?: string;
+}): import("react").JSX.Element;
+//# sourceMappingURL=InlineEditor.d.ts.map

package/lib/types/LinkIcon.d.ts

@@ -1,34 +1,15 @@
 /**
- * Leading category glyph for clickable artifact links (anchors, file
- * mentions, produced-file chips). One component keyed by link category;
- * every glyph renders fill="currentColor" and so rides the link's own
- * color. Glyphs stay private to this module: the public surface is the
- * category vocabulary, not the individual glyph components, so consumers
- * cannot compose a glyph outside a link. Design sources:
- * ic_globe_language_outline_20, ic_code_outline_20, ic_folder_outline_20,
- * ic_photo_outline_20, ic_paper_doc_outline_20, ic_paper_outline_20.
- *
- * A `url` glyph whose destination names a well-known site is that site's own
- * mark instead of the globe (`SiteGlyph.tsx`); every mark keeps the same
- * currentColor-only rule.
+ * Leading current-color category glyphs for clickable artifact links. The
+ * public component keeps individual artwork private to the link vocabulary.
  */
 import type { ReactNode } from 'react';
 import type { IconProps } from './icons/props.ts';
-/**
- * Link categories with distinct leading glyphs. `url` and `folder` are
- * destination categories the consumer states directly; the rest are file
- * categories `classifyLinkPath` derives from a path. Code, web, and data
- * files share the `code` glyph by design.
- */
+/** Link categories with distinct leading glyphs. */
 export type LinkIconKind = 'url' | 'folder' | 'code' | 'image' | 'document' | 'other';
-/** Props for {@link LinkIcon}: the category plus the shared icon sizing seat. */
+/** Props for link icons: the category plus the shared icon sizing seat. */
 export interface LinkIconProps extends IconProps {
     kind: LinkIconKind;
-    /**
-     * Destination of a `url` link. A well-known site draws its own mark, so
-     * callers that know the destination should pass it; anything else keeps the
-     * globe. Other kinds ignore it — their destination is a path, not a site.
-     */
+    /** Destination of a URL link; known HTTP(S) hosts render their site mark. */
     href?: string | undefined;
 }
 /**
@@ -39,11 +20,15 @@ export interface LinkIconProps extends IconProps {
  */
 export declare function classifyLinkPath(path: string): LinkIconKind;
 /**
- * Render the leading glyph for one clickable artifact link.
- * @param props - The link category, the optional destination that can select a
- * site mark, optional size (default 14px — the inline link text size these
- * glyphs sit beside), and optional CSS class.
- * @returns The category's SVG glyph, riding currentColor.
+ * Render a regular one-pixel link icon.
+ * @param props - Link category, size, and optional class.
+ * @returns The regular decorative link glyph.
+ */
+export declare function LinkIconRegular(props: LinkIconProps): ReactNode;
+/**
+ * Render a medium 1.3px link icon.
+ * @param props - Link category, size, and optional class.
+ * @returns The medium decorative link glyph.
  */
-export declare function LinkIcon({ kind, href, size, className }: LinkIconProps): ReactNode;
+export declare function LinkIconMedium(props: LinkIconProps): ReactNode;
 //# sourceMappingURL=LinkIcon.d.ts.map

package/lib/types/Menu.d.ts

@@ -37,6 +37,8 @@ export interface MenuItemButtonProps {
     shortcut?: MenuItem['shortcut'];
     /** Leading icon (figma .Menu_cell gap 8). */
     icon?: ReactNode;
+    /** Whether this row identifies the currently displayed page or view. */
+    current?: boolean;
     /** Whether the row cannot be activated. */
     disabled?: boolean;
     /** Destructive row: error-colored text/icon and danger hover fill. */
@@ -60,13 +62,14 @@ export interface MenuItemButtonProps {
  * @param props.children - visible row label.
  * @param props.shortcut - effective key labels and accessible combination.
  * @param props.icon - optional leading icon.
+ * @param props.current - whether the row identifies the currently displayed page or view.
  * @param props.disabled - whether the row cannot be activated.
  * @param props.danger - whether to use the destructive row colors.
  * @param props.separatorBefore - whether this row starts a new group (hairline above it).
  * @param props.onSelect - row activation callback.
  * @returns one menu-item row.
  */
-export declare function MenuItemButton({ children, shortcut, icon, disabled, danger, separatorBefore, onSelect, }: MenuItemButtonProps): import("react").JSX.Element;
+export declare function MenuItemButton({ children, shortcut, icon, current, disabled, danger, separatorBefore, onSelect, }: MenuItemButtonProps): import("react").JSX.Element;
 /**
  * Render an anchored dropdown menu. While the list is open its keys mirror the
  * composer's: Tab settles the focused row — from the trigger, Tab enters the
@@ -77,17 +80,17 @@ export declare function MenuItemButton({ children, shortcut, icon, disabled, dan
  * @param props.autoFocus - focus the first item on open; the arrow keys walk the list either way.
  * @param props.open - whether the list is showing (owner-controlled).
  * @param props.anchor - the trigger element (rendered in place).
- * @param props.items - selectable rows and optional separators.
+ * @param props.items - selectable data rows and optional separators (default none; with no `children` either, the list is empty).
  * @param props.selectedId - row shown as selected.
  * @param props.selectedIds - rows shown as selected when a menu contains independent option groups.
- * @param props.onSelect - row click callback (not called for disabled rows or submenu parents that only open children).
+ * @param props.onSelect - data-row activation callback (not called for disabled rows or submenu parents that only open children).
  * @param props.onClose - invoked on outside click, Escape, or a window blur
  * that moved focus into an iframe (the only signal a pointerdown inside a
  * cross-origin iframe leaves).
  * @param props.align - list alignment against the anchor (default 'start').
  * @param props.side - open below (`bottom`, default) or above (`top`) the anchor.
  * @param props.portal - render the list into document.body, fixed-positioned
- * from the anchor rect (repositions on scroll/resize while open). Use when an
+ * from the anchor rect (follows movement and resizing while open). Use when an
  * ancestor's overflow clipping would crop the in-place list; default false
  * keeps the pure-CSS in-place behavior.
  * @param props.closeOnPointerLeave - close the list once the pointer has left
@@ -100,25 +103,35 @@ export declare function MenuItemButton({ children, shortcut, icon, disabled, dan
  * directly (e.g. from a host-owned trigger button) instead of measuring the
  * Menu's own wrapper span. Required when the wrapper isn't itself laid out at
  * the trigger (render-prop anchors, effect-positioned proxies — measuring the
- * wrapper there races the host's layout effects). Called on open and on every
- * scroll/resize; return null to skip placement for that frame.
+ * wrapper there races the host's layout effects). Called on open, each animation
+ * frame, and scroll/resize; return null to skip placement for that frame.
+ * @param props.minWidthFromAnchor - in portal mode, keep the menu at least as wide as its anchor, bounded by viewport margins.
  * @param props.footer - rows pinned below the scrolling items area, separated
  * by a hairline; they stay visible while the items above scroll.
+ * @param props.children - component rows rendered after `items` in the same
+ * list, each a `role="menuitem"` button such as {@link MenuItemButton}; they
+ * share the keyboard walk, the submenu exclusivity, and the post-selection
+ * focus return.
  * @param props.selection - how a selected row is marked: a trailing check
  * (`'check'`, default — figma .Menu_cell) or the hover fill held on the row
  * with no check (`'fill'`, for icon-labelled rows where a trailing glyph
  * crowds the cell).
+ * @param props.className - extra class on the anchor wrapper span.
+ * @param props.listClassName - extra class on the dropdown card itself; the
+ * only style hook that reaches a portaled list, which renders under
+ * document.body outside the owner's DOM subtree.
  * @returns anchor wrapper with the conditional list.
  */
-export declare function Menu({ open, anchor, items, selectedId, selectedIds, onSelect, onClose, align, side, portal, closeOnPointerLeave, dense, compact, autoFocus, selection, getAnchorRect, footer, className }: {
+export declare function Menu({ open, anchor, items, children, selectedId, selectedIds, onSelect, onClose, align, side, portal, closeOnPointerLeave, dense, compact, autoFocus, selection, getAnchorRect, minWidthFromAnchor, footer, className, listClassName }: {
     open: boolean;
     autoFocus?: boolean;
     anchor: ReactNode;
-    items: readonly MenuEntry[];
+    items?: readonly MenuEntry[];
+    children?: ReactNode;
     footer?: readonly MenuEntry[];
     selectedId?: string | undefined;
     selectedIds?: readonly string[] | undefined;
-    onSelect: (id: string) => void;
+    onSelect?: (id: string) => void;
     onClose: () => void;
     align?: 'start' | 'end';
     side?: 'bottom' | 'top' | 'right';
@@ -128,6 +141,8 @@ export declare function Menu({ open, anchor, items, selectedId, selectedIds, onS
     compact?: boolean;
     selection?: 'check' | 'fill';
     getAnchorRect?: () => DOMRect | null;
+    minWidthFromAnchor?: boolean;
     className?: string | undefined;
+    listClassName?: string | undefined;
 }): import("react").JSX.Element;
 //# sourceMappingURL=Menu.d.ts.map

package/lib/types/PermissionIcon.d.ts

@@ -0,0 +1,51 @@
+import type { ReactNode } from 'react';
+import type { IconProps } from './icons/props.ts';
+/**
+ * Render the read-only permission icon with a one-pixel stroke.
+ * @param props - Size and optional class.
+ * @returns The regular decorative permission glyph.
+ */
+export declare function PermissionIconReadOnlyRegular(props: IconProps): ReactNode;
+/**
+ * Render the read-only permission icon with a 1.3px stroke.
+ * @param props - Size and optional class.
+ * @returns The medium decorative permission glyph.
+ */
+export declare function PermissionIconReadOnlyMedium(props: IconProps): ReactNode;
+/**
+ * Render the workspace-write permission icon with a one-pixel stroke.
+ * @param props - Size and optional class.
+ * @returns The regular decorative permission glyph.
+ */
+export declare function PermissionIconWorkspaceWriteRegular(props: IconProps): ReactNode;
+/**
+ * Render the workspace-write permission icon with a 1.3px stroke.
+ * @param props - Size and optional class.
+ * @returns The medium decorative permission glyph.
+ */
+export declare function PermissionIconWorkspaceWriteMedium(props: IconProps): ReactNode;
+/**
+ * Render the full-access permission icon with a one-pixel stroke.
+ * @param props - Size and optional class.
+ * @returns The regular decorative permission glyph.
+ */
+export declare function PermissionIconFullAccessRegular(props: IconProps): ReactNode;
+/**
+ * Render the full-access permission icon with a 1.3px stroke.
+ * @param props - Size and optional class.
+ * @returns The medium decorative permission glyph.
+ */
+export declare function PermissionIconFullAccessMedium(props: IconProps): ReactNode;
+/**
+ * Render the auto-review permission icon with a one-pixel stroke.
+ * @param props - Size and optional class.
+ * @returns The regular decorative permission glyph.
+ */
+export declare function PermissionIconAutoReviewRegular(props: IconProps): ReactNode;
+/**
+ * Render the auto-review permission icon with a 1.3px stroke.
+ * @param props - Size and optional class.
+ * @returns The medium decorative permission glyph.
+ */
+export declare function PermissionIconAutoReviewMedium(props: IconProps): ReactNode;
+//# sourceMappingURL=PermissionIcon.d.ts.map

package/lib/types/ReferenceIcon.d.ts

@@ -1,16 +1,21 @@
 import type { ReactNode } from 'react';
+import type { IconProps } from './icons/props.ts';
 /** Reference domains with distinct composer and transcript glyphs. */
 export type ReferenceIconKind = 'session' | 'file' | 'folder';
 /** Props shared by inline reference glyphs. */
-export interface ReferenceIconProps {
+export interface ReferenceIconProps extends IconProps {
     kind: ReferenceIconKind;
-    size?: number;
-    className?: string | undefined;
 }
 /**
- * Render the icon that identifies one inline reference domain.
- * @param props - Reference kind, optional size, and optional CSS class.
- * @returns The corresponding current-color SVG glyph.
+ * Render a regular one-pixel reference icon.
+ * @param props - Reference kind, size, and optional class.
+ * @returns The regular decorative reference glyph.
  */
-export declare function ReferenceIcon({ kind, size, className }: ReferenceIconProps): ReactNode;
+export declare function ReferenceIconRegular(props: ReferenceIconProps): ReactNode;
+/**
+ * Render a medium 1.3px reference icon.
+ * @param props - Reference kind, size, and optional class.
+ * @returns The medium decorative reference glyph.
+ */
+export declare function ReferenceIconMedium(props: ReferenceIconProps): ReactNode;
 //# sourceMappingURL=ReferenceIcon.d.ts.map

package/lib/types/SecretText.d.ts

@@ -0,0 +1,25 @@
+/** Copy for the control that reveals one masked credential. */
+export interface SecretTextLabels {
+    /** Name while the value stays masked. */
+    readonly reveal: string;
+    /** Name while the value is shown. */
+    readonly hide: string;
+}
+/** Props of one masked credential. */
+export interface SecretTextProps {
+    /** Display form of the range; line breaks stay in place. */
+    readonly masked: string;
+    /** Original spelling, revealed on demand, and the identity that re-masks a different value. */
+    readonly raw: string;
+    /** Reveal-control copy; absent in text that offers no reveal control. */
+    readonly labels?: SecretTextLabels | undefined;
+}
+/**
+ * Draw one credential masked. Interactive text adds a control that reveals or
+ * hides this value; every mount, and every different original value at the same
+ * position, starts masked.
+ * @param props - the masked form, the original spelling, and optional control copy.
+ * @returns the masked run, with the reveal control when copy is supplied.
+ */
+export declare function SecretText({ masked, raw, labels }: SecretTextProps): import("react").JSX.Element;
+//# sourceMappingURL=SecretText.d.ts.map

package/lib/types/SegmentedTabs.d.ts

@@ -0,0 +1,26 @@
+import type { ReactNode } from 'react';
+/** A tab links its localized label to a caller-owned panel. */
+export interface SegmentedTab<Value extends string = string> {
+    value: Value;
+    label: ReactNode;
+    id: string;
+    panelId: string;
+}
+/**
+ * Render equal-width, controlled tabs with a sliding selection indicator.
+ * @param props.items - non-empty ordered tabs with unique values and DOM ids.
+ * @param props.value - selected value, which must belong to items.
+ * @param props.onChange - selection requested by click, Left/Right, or Home/End.
+ * Keyboard selection also moves focus; only the selected tab is a tab stop.
+ * @param props.label - localized accessible name for the tab list.
+ * @param props.className - layout placement; panels remain caller-owned.
+ * @returns the tab list, without its panels.
+ */
+export declare function SegmentedTabs<Value extends string>({ items, value, onChange, label, className }: {
+    items: readonly [SegmentedTab<Value>, ...SegmentedTab<Value>[]];
+    value: Value;
+    onChange: (value: Value) => void;
+    label: string;
+    className?: string | undefined;
+}): ReactNode;
+//# sourceMappingURL=SegmentedTabs.d.ts.map

package/lib/types/SiteGlyph.d.ts

@@ -1,5 +1,5 @@
 /**
- * Site marks for well-known external link hosts. {@link LinkIcon} renders one in
+ * Site marks for well-known external link hosts. {@link LinkIconMedium} renders one in
  * the leading glyph seat, so a familiar destination leads with its own mark
  * instead of the generic globe. The marks are the `simple-icons` artwork set
  * (CC0-1.0), pinned by this package's dependency on it; each mark takes the

package/lib/types/TerminalBlock.d.ts

@@ -52,6 +52,12 @@ export interface TerminalBlockProps {
      * output printed so far when there is any, with no copy control until it settles.
      */
     running?: boolean | undefined;
+    /**
+     * The call launches background work (default false). `running` describes the
+     * launch call only; after it returns, retain the command without job status
+     * or output.
+     */
+    background?: boolean | undefined;
     /** Height cap in output lines before the middle collapses (default {@link DEFAULT_TERMINAL_MAX_LINES}); Infinity disables the cap. */
     maxLines?: number | undefined;
     /** Extra class merged onto the wrapper (callers position; this component draws). */
@@ -64,5 +70,5 @@ export interface TerminalBlockProps {
  * @param props - see {@link TerminalBlockProps}.
  * @returns the terminal block element.
  */
-export declare function TerminalBlock({ command, cwd, home, output, exitCode, signal, running, maxLines, className, labels, }: TerminalBlockProps): import("react").JSX.Element;
+export declare function TerminalBlock({ command, cwd, home, output, exitCode, signal, running, background, maxLines, className, labels, }: TerminalBlockProps): import("react").JSX.Element;
 //# sourceMappingURL=TerminalBlock.d.ts.map

package/lib/types/Tooltip.d.ts

@@ -1,45 +1,64 @@
+/** Anchor-preserving tooltips; an optional body portal escapes clipping containers and stacking contexts that cap the bubble's z-index. */
 import type { FocusEventHandler, MouseEventHandler, ReactElement, Ref } from 'react';
-/** Bubble placement relative to the anchor. */
-export type TooltipSide = 'right' | 'bottom' | 'top';
+import { type TooltipSide } from './tooltip-placement.ts';
+export type { TooltipSide } from './tooltip-placement.ts';
 /**
- * Suppression channel for enclosing tooltip and hover-card anchors: a visible
- * tooltip within an anchor withdraws the enclosing preview while its bubble is shown.
+ * Suppression channel for nested tooltips: a visible descendant tooltip
+ * withdraws the enclosing tooltip while its bubble is shown.
  */
 export declare const TooltipSuppression: import("react").Context<((suppressed: boolean) => void) | null>;
 /** Props Tooltip injects into its anchor child; the child's own handlers are chained ahead of the tooltip's. */
 interface AnchorProps {
+    'aria-describedby'?: string | undefined;
     ref?: Ref<HTMLElement> | undefined;
     onMouseEnter?: MouseEventHandler | undefined;
     onMouseLeave?: MouseEventHandler | undefined;
+    onClick?: MouseEventHandler | undefined;
     onFocus?: FocusEventHandler | undefined;
     onBlur?: FocusEventHandler | undefined;
 }
 type TooltipLabel = string | (() => string);
 /**
  * Attach a hover/focus tooltip to an anchor element.
- * @param props.label - bubble text, or a resolver evaluated only while the bubble is visible.
+ * @param props.label - bubble text, or a resolver evaluated only while visible; an empty string shows only shortcut keys.
  * @param props.shortcutKeys - effective key labels rendered as platform-formatted keycaps after optional text.
- * @param props.side - placement relative to the anchor (default 'right').
- * @param props.delayMs - hover delay in milliseconds; keyboard focus remains immediate.
+ * @param props.side - preferred placement (default 'right'); fitting tries the opposite then perpendicular sides.
+ * @param props.align - horizontal anchor-edge alignment for 'bottom'/'top' bubbles: 'end' pins
+ * the bubble's right edge to the anchor's (for anchors beside other hover surfaces the centered
+ * bubble would overlap); default 'center'. Horizontal placements ignore it.
+ * @param props.portal - render the bubble under document.body, so an ancestor's clipping or its
+ * stacking context (which confines the bubble's z-index to that context) cannot hide it.
+ * @param props.delayMs - hover delay in milliseconds (default 0).
+ * @param props.focusDelayMs - keyboard focus delay in milliseconds (default 0); blur, click,
+ * mouse leave, disabling, and unmount cancel a pending show.
+ * @param props.gap - anchor-to-bubble distance in pixels for 'bottom'/'top' bubbles (default 8);
+ * horizontal placements use 10px, including after a flip.
  * @param props.disabled - suppress the bubble while true; the anchor renders identically so
  * toggling never remounts it (which would cut its CSS transitions).
- * @param props.portal - render the bubble under document.body, so an ancestor's clipping or its
- * stacking context can neither clip the bubble nor paint over it.
  * @param props.maxWidth - bubble width cap in pixels, for labels long enough that the default
- * half-viewport cap would render a slab wider than the surface the anchor sits on.
+ * half-viewport cap would render a slab wider than the surface the anchor sits on; always bounded by viewport margins.
+ * @param props.openOnClick - clicking also pins the bubble for reading; another click, Escape,
+ * Tab, or an outside pointerdown dismisses it. Defaults to false for ordinary action tooltips.
  * @param props.children - a single anchor element; its own ref (callback or object) is forwarded alongside the tooltip's.
  * An anchor that accepts no ref still positions the bubble: a raise records the element the event ran on.
- * @returns the cloned anchor plus a fixed-position bubble while hovered/focused.
+ * @returns the cloned anchor plus a fixed-position bubble, optionally portaled to the body.
+ * The bubble stays hidden until ResizeObserver supplies its size for viewport fitting; clicking the
+ * anchor dismisses the bubble unless openOnClick is enabled, and focus arriving after a pointer
+ * interaction (a closing menu refocusing its trigger) never raises it. When no side fits, the
+ * viewport-bounded fallback may overlap the anchor; oversized content is scrollable when pinned.
  */
-export declare function Tooltip({ label, shortcutKeys, side, delayMs, disabled, portal, maxWidth, children }: {
+export declare function Tooltip({ label, shortcutKeys, side, align, delayMs, focusDelayMs, gap, disabled, portal, maxWidth, openOnClick, children }: {
     label: TooltipLabel;
     shortcutKeys?: readonly string[] | undefined;
     side?: TooltipSide;
+    align?: 'center' | 'end';
     delayMs?: number;
+    focusDelayMs?: number;
+    gap?: number;
     disabled?: boolean;
     portal?: boolean;
     maxWidth?: number;
+    openOnClick?: boolean;
     children: ReactElement<AnchorProps>;
 }): import("react").JSX.Element;
-export {};
 //# sourceMappingURL=Tooltip.d.ts.map

package/lib/types/code-file-types.d.ts

@@ -14,7 +14,7 @@ export interface FileTypeProjectContext {
  */
 export declare function isCodeFileType(type: string): type is CodeFileType;
 /**
- * Test whether an extension belonged to the established coarse LinkIcon code category.
+ * Test whether an extension belongs to the established coarse link-icon code category.
  * @param extension - Extension without a leading dot.
  * @returns Whether clickable links keep the code glyph for this extension.
  */

package/lib/types/credential-formats.d.ts

@@ -0,0 +1,63 @@
+/**
+ * The credential formats the scanner recognizes, as data: the literal each
+ * format begins with, how its candidate is validated, and the ASCII character
+ * classes those checks use. [format-tables.ts](./format-tables.ts) derives
+ * lookup tables from this list on first use.
+ */
+/** `[A-Za-z0-9_-]` */
+export declare const KEY = 1;
+/** `[A-Za-z0-9]` */
+export declare const ALNUM = 2;
+/** `\w` */
+export declare const WORD = 4;
+/** `[A-Za-z0-9-]` */
+export declare const ALNUM_DASH = 8;
+/** `[A-Z0-9]` */
+export declare const UPPER_ALNUM = 16;
+/** `[A-Z0-9 ]` */
+export declare const LABEL = 32;
+/** `[a-z0-9+.-]` */
+export declare const SCHEME = 64;
+/** `[a-z]` */
+export declare const LOWER = 128;
+/** `[^\s/:@?#]` */
+export declare const USER = 256;
+/** `[^\s/@?#]` */
+export declare const PASSWORD = 512;
+/** A private key block from its `-----BEGIN` line. */
+export declare const KEY_BLOCK = 0;
+/** The password of an address that carries credentials. */
+export declare const ADDRESS = 1;
+/** A provider key or token after its fixed prefix. */
+export declare const PREFIXED = 2;
+/** The whole run, at least `min`. */
+export declare const RUN = 0;
+/** `min` to `max`, then `\b`. */
+export declare const BOUNDED = 1;
+/** At least `min`, with a digit among the first 256. */
+export declare const SK = 2;
+/** Exactly `min`. */
+export declare const GOOGLE = 3;
+/** Three runs joined by `.eyJ` and `.`. */
+export declare const JWT = 4;
+/** One recognized format. */
+export interface CredentialFormat {
+    /** ASCII literal the candidate begins with; no literal occurs inside another. */
+    readonly literal: string;
+    /** Which kind of candidate the literal heads. */
+    readonly kind: typeof KEY_BLOCK | typeof ADDRESS | typeof PREFIXED;
+    /** Prefixed formats only: how the run after the literal is validated. */
+    readonly check: number;
+    /** Prefixed formats only: the class bit of the run after the literal. */
+    readonly run: number;
+    /** Prefixed formats only: run length below which a candidate is not this format. */
+    readonly min: number;
+    /** Prefixed formats only: longest accepted run for `BOUNDED` and `JWT`. */
+    readonly max: number;
+}
+/**
+ * Every prefixed format matches more than the eight characters a mask leaves
+ * readable, so a near miss never exposes a whole value.
+ */
+export declare const CREDENTIAL_FORMATS: readonly CredentialFormat[];
+//# sourceMappingURL=credential-formats.d.ts.map

package/lib/types/credential-masks.d.ts

@@ -0,0 +1,60 @@
+/** Character that replaces each hidden credential character. */
+export declare const MASK = "*";
+/** Builds masks; owns the shared mark strings and its sticky run pattern. */
+export declare class CredentialMasks {
+    private readonly marksOnly;
+    private readonly marksLf;
+    private readonly marksCr;
+    /** Code units that `lines` counts without inspection: neither line breaks nor surrogates. Set `lastIndex` before each test. */
+    private readonly ordinary;
+    /**
+     * The display form of `text[start, end)`, whose earliest candidate has `kind`.
+     * @param text - the queried text.
+     * @param kind - the literal kind of the range's earliest candidate.
+     * @param plain - the range holds only prefixed-format characters: ASCII without line breaks.
+     * @param start - first offset of the range.
+     * @param end - offset after the range.
+     * @returns the mask; line breaks stay in place, one mark per code point.
+     */
+    masked(text: string, kind: number, plain: boolean, start: number, end: number): string;
+    /**
+     * Marks for a run of hidden characters.
+     * @param count - how many marks.
+     * @returns `count` marks, one slice of the shared string where it reaches.
+     */
+    private marks;
+    /**
+     * Marks, then one line break, in a single slice.
+     * @param count - how many marks.
+     * @param code - the line break's code unit, 10 or 13.
+     * @returns `count` marks and that line break.
+     */
+    private marksThen;
+    /**
+     * Keep the `BEGIN` line, the `END` line when present, and every line break; a block written on
+     * one line is masked whole. Both searches stay inside the range, so they cost what the mask costs.
+     * @param text - the queried text.
+     * @param start - first offset of the range.
+     * @param end - offset after the range.
+     * @returns the masked block.
+     */
+    private keyBlock;
+    /**
+     * Replace every character except line breaks; a surrogate pair is one character,
+     * as `[^\r\n]` with the `u` flag counts it. A character loop: a native run could read far past `end`.
+     * @param text - the queried text.
+     * @param start - first offset of the range.
+     * @param end - offset after the range.
+     * @returns the masked range.
+     */
+    private range;
+    /**
+     * `range` for a body that ends at a line break or the end of the text, where native runs stop.
+     * @param text - the queried text.
+     * @param start - first offset of the range.
+     * @param end - offset after the range.
+     * @returns the masked body.
+     */
+    private lines;
+}
+//# sourceMappingURL=credential-masks.d.ts.map