@agimon-ai/doompi-web-components 0.0.1-alpha.38 → 0.0.1-alpha.39

package/dist/lib/hashlineView.d.cts

@@ -1,60 +0,0 @@
-//#region src/lib/hashlineView.d.ts
-export declare const READ_COLLAPSED_LINES = 10;
-export declare const GREP_COLLAPSED_LINES = 15;
-export type HashlineResultKind = 'read' | 'grep';
-export type TaggedLineMarker = 'match' | 'context';
-/**
- * The part of a tool result this parser reads.
- *
- * Named structurally rather than imported: the component library sits below
- * the web contract and must not depend on it, so it states the shape it needs
- * and any `ToolResultView` satisfies it.
- */
-export interface HashlineResult {
-  readonly content: readonly unknown[];
-}
-export interface TaggedLine {
-  readonly line: number;
-  readonly content: string;
-  readonly marker: TaggedLineMarker | undefined;
-}
-export type PresentedLine = {
-  readonly type: 'file';
-  readonly path: string;
-} | {
-  readonly type: 'tagged';
-  readonly value: TaggedLine;
-} | {
-  readonly type: 'plain';
-  readonly text: string;
-};
-export interface HashlineBody {
-  readonly shown: readonly PresentedLine[];
-  /** Lines the collapsed view holds back; zero once expanded. */
-  readonly hidden: number;
-  /** The bracketed pagination or compaction note the tool appends after its lines. */
-  readonly notice: string | undefined;
-  /** Widest line number among the shown anchored lines, in characters. */
-  readonly gutter: number;
-}
-/**
- * The result's text as lines: tabs widened, CRLF folded, trailing blanks
- * dropped. A result with no text but an image block reads as the TUI's
- * placeholder. The joined `output` stands in when no result view exists.
- */
-export declare function resultTextLines(result: HashlineResult | null, output: string): string[];
-/** Detaches the tool's trailing `[...]` note so the body numbers file content only. */
-export declare function takeTrailingNotice(lines: string[]): string | undefined;
-export declare function parseTaggedLine(value: string): TaggedLine | undefined;
-export declare function parseFileHeader(value: string): string | undefined;
-/**
- * Lines as the card presents them. A read shows one file, so its header is
- * dropped; a grep groups anchored matches under each file's path.
- */
-export declare function presentHashlineLines(lines: readonly string[], kind: HashlineResultKind): PresentedLine[];
-/** The body a card shows for one result, collapsed to the kind's line budget unless expanded. */
-export declare function hashlineBody(result: HashlineResult | null, output: string, kind: HashlineResultKind, expanded: boolean): HashlineBody;
-/** The `key · key` detail list beside a call's primary argument, with absent values dropped. */
-export declare function compactDetails(values: ReadonlyArray<string | undefined>): string[];
-//#endregion
-//# sourceMappingURL=hashlineView.d.cts.map

package/dist/lib/hashlineView.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"hashlineView.d.cts","names":[],"sources":["../../src/lib/hashlineView.ts"],"mappings":";qBAoBa;qBACA;YAED;YACA;;;;;;;;iBASK;WACN;;iBAGM;WACN;WACA;WACA,QAAQ;;YAGP;WACG;WAAuB;;WACvB;WAAyB,OAAO;;WAChC;WAAwB;;iBAEtB;WACN,gBAAgB;;WAEhB;;WAEA;;WAEA;;;;;;;wBAiBK,gBAAgB,QAAQ,uBAAuB;;wBAa/C,mBAAmB;wBAQnB,gBAAgB,gBAAgB;wBAYhC,gBAAgB;;;;;wBAQhB,qBAAqB,0BAA0B,MAAM,qBAAqB;;wBAmB1E,aACd,QAAQ,uBACR,gBACA,MAAM,oBACN,oBACC;;wBAca,eAAe,QAAQ"}

package/dist/lib/media.d.cts

@@ -1,11 +0,0 @@
-import { MediaKind } from "../types/editor.cjs";
-//#region src/lib/media.d.ts
-/**
- * How to show the file at this path. Anything unrecognised is a download,
- * which is the honest answer for a `.docx` or a `.zip`: a browser cannot
- * render it, and pretending otherwise costs a converter that loses the
- * formatting it converted.
- */
-export declare function mediaKindOf(filePath: string): MediaKind;
-//#endregion
-//# sourceMappingURL=media.d.cts.map

package/dist/lib/media.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"media.d.cts","names":[],"sources":["../../src/lib/media.ts"],"mappings":";;;;;;;;wBAyCgB,YAAY,mBAAmB"}

package/dist/lib/optionList.d.cts

@@ -1,21 +0,0 @@
-import { KeyboardEvent } from "react";
-//#region src/lib/optionList.d.ts
-/** Digits are a shortcut, not the only way in: only the first nine can have one. */
-export declare const MAX_DIGIT_SHORTCUT = 9;
-/**
- * The keyboard an option list answers to, handled on whichever element the
- * surrounding overlay focuses. Every key it claims is consumed, so a digit
- * that answers the agent never also reaches the rail's session shortcuts.
- */
-export declare function handleOptionListKey(event: KeyboardEvent, input: {
-  options: readonly string[];
-  cursor: number;
-  onCursorChange: (cursor: number) => void;
-  onSelect: (option: string) => void;
-}): void;
-/** What the footer should promise, given how many options there are. */
-export declare function optionListHint(count: number): string;
-/** The digit a row answers to, or the bullet that says it has none. */
-export declare function optionMarker(index: number): string;
-//#endregion
-//# sourceMappingURL=optionList.d.cts.map

package/dist/lib/optionList.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"optionList.d.cts","names":[],"sources":["../../src/lib/optionList.ts"],"mappings":";;;qBAGa;;;;;;wBAOG,oBACd,OAAO,eACP;EACE;EACA;EACA,iBAAiB;EACjB,WAAW;;;wBA8BC,eAAe;;wBAKf,aAAa"}

package/dist/lib/syntaxHighlight.d.cts

@@ -1,54 +0,0 @@
-import { GrammarKey } from "./editorLanguage.cjs";
-import { DOOM_SYNTAX_STYLES } from "./editorTheme.cjs";
-import { CSSProperties } from "react";
-//#region src/lib/syntaxHighlight.d.ts
-/**
- * Static syntax highlighting for read-only code, the timeline's half of the
- * editor's `syntaxHighlighting`.
- *
- * A tool card shows code it cannot edit, so it needs the colours without the
- * editor: the same grammars `editorLanguage.ts` loads and the same token
- * palette `editorTheme.ts` names, run once over a string and handed back as
- * spans. Everything CodeMirror-shaped is behind a dynamic import, so a session
- * that never opens a code result never downloads a parser, and the caller
- * always has plain text to show first.
- */
-/** The palette keys a token can land on; the styles themselves are the editor's. */
-export type SyntaxToken = keyof typeof DOOM_SYNTAX_STYLES;
-/** One run of same-styled text inside a line. `token` absent means unstyled. */
-export interface SyntaxSpan {
-  text: string;
-  token?: SyntaxToken;
-}
-/** Lines of spans, one array per source line, so a gutter can pair with them. */
-export type SyntaxLines = readonly (readonly SyntaxSpan[])[];
-export interface GrammarQuery {
-  /** The file the text came from, when the tool knows one. */
-  path?: string | undefined;
-  /** The text itself, used only when the path settles nothing. */
-  text?: string | undefined;
-}
-/**
- * Which grammar to colour a result with.
- *
- * The path decides whenever it can, because a name is evidence and a body is a
- * guess. Sniffing only answers for text that arrived without a usable name: a
- * shebang says what runs the script, and a document that opens and closes with
- * brackets is treated as JSON. Anything else stays plain rather than being
- * coloured as the wrong language.
- */
-export declare function detectGrammar(query: GrammarQuery): GrammarKey | undefined;
-/** The inline style a token wears. Colours come from the editor palette, which names theme tokens. */
-export declare function syntaxStyleOf(token: SyntaxToken | undefined): CSSProperties | undefined;
-/**
- * Colours `text` as `grammar`, as lines of spans.
- *
- * The whole text is parsed at once even though the caller may render it line
- * by line, because a template literal or a block comment only makes sense with
- * its neighbours. Text past the size cap, and a grammar whose extension turns
- * out to carry no parser, come back unhighlighted rather than throwing: colour
- * is decoration, and the caller already has the plain text on screen.
- */
-export declare function highlightToLines(text: string, grammar: GrammarKey): Promise<SyntaxLines | undefined>;
-//#endregion
-//# sourceMappingURL=syntaxHighlight.d.cts.map

package/dist/lib/syntaxHighlight.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"syntaxHighlight.d.cts","names":[],"sources":["../../src/lib/syntaxHighlight.ts"],"mappings":";;;;;;;;;;;;;;;;YAkBY,2BAA2B;;iBAGtB;EACf;EACA,QAAQ;;;YAIE,iCAAiC;iBAqB5B;;EAEf;;EAEA;;;;;;;;;;;wBAYc,cAAc,OAAO,eAAe;;wBAkBpC,cAAc,OAAO,0BAA0B;;;;;;;;;;wBA4DzC,iBAAiB,cAAc,SAAS,aAAa,QAAQ"}

package/dist/lib/tone.d.cts

@@ -1,25 +0,0 @@
-import { ChipTone, DotTone, MessageLineTone, StatusTone } from "../types/tone.cjs";
-//#region src/lib/tone.d.ts
-/**
- * Translations between the tone vocabularies.
- *
- * Every surface that shows an outcome used to carry its own
- * `Record<Tone, string>` table mapping a state onto a colour class. Those
- * tables disagreed as often as they agreed. These maps are the one place the
- * translation lives, so a card picks a status tone from its own domain and
- * asks here what colour that reads as.
- */
-/** The colour a status reads as, for the chip and border families. */
-export declare const STATUS_TO_CHIP: Readonly<Record<StatusTone, ChipTone>>;
-/** The dot a status reads as; a neutral status is present but not live. */
-export declare const STATUS_TO_DOT: Readonly<Record<StatusTone, DotTone>>;
-/**
- * The status a colour stands for, for a caller that has only a chip tone.
- * Lossy on purpose: the palette has more colours than there are outcomes, and
- * a colour with no outcome of its own reads as neutral.
- */
-export declare const CHIP_TO_STATUS: Readonly<Record<ChipTone, StatusTone>>;
-/** The status a body line's role corresponds to, for a card that badges its worst line. */
-export declare const LINE_TONE_TO_STATUS: Readonly<Record<MessageLineTone, StatusTone>>;
-//#endregion
-//# sourceMappingURL=tone.d.cts.map

package/dist/lib/tone.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"tone.d.cts","names":[],"sources":["../../src/lib/tone.ts"],"mappings":";;;;;;;;;;;;qBAaa,gBAAgB,SAAS,OAAO,YAAY;;qBAU5C,eAAe,SAAS,OAAO,YAAY;;;;;;qBAc3C,gBAAgB,SAAS,OAAO,UAAU;;qBAc1C,qBAAqB,SAAS,OAAO,iBAAiB"}

package/dist/theme/apply.d.cts

@@ -1,25 +0,0 @@
-import { ThemeConfig } from "../types/theme.cjs";
-//#region src/theme/apply.d.ts
-/** The attribute the active theme's name is stamped on, for CSS that keys off a theme. */
-export declare const THEME_ATTRIBUTE = "data-theme";
-/** Every custom property a theme publishes, keyed by property name. */
-export declare function themeCssVariables(theme: ThemeConfig): Record<string, string>;
-/** The theme as a stylesheet rule, for a server that wants to inline it. */
-export declare function themeCssText(theme: ThemeConfig, selector?: string): string;
-/** The subset of an element the theme touches, so tests can pass a plain object. */
-export interface ThemeRoot {
-  style: {
-    setProperty(name: string, value: string): void;
-    colorScheme: string;
-  };
-  setAttribute(name: string, value: string): void;
-}
-/**
- * Applies a theme to the page: every token becomes a custom property on the
- * root, the colour scheme follows, and the theme name is stamped so a style
- * may key off it. Idempotent and synchronous, so calling it before the first
- * render avoids a flash of the default theme.
- */
-export declare function applyTheme(theme: ThemeConfig, root: ThemeRoot): void;
-//#endregion
-//# sourceMappingURL=apply.d.cts.map

package/dist/theme/apply.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"apply.d.cts","names":[],"sources":["../../src/theme/apply.ts"],"mappings":";;;qBAIa;;wBAGG,kBAAkB,OAAO,cAAc;;wBAQvC,aAAa,OAAO,aAAa;;iBAMhC;EACf;IAAS,YAAY,cAAc;IAAsB;;EACzD,aAAa,cAAc;;;;;;;;wBASb,WAAW,OAAO,aAAa,MAAM"}

package/dist/theme/builtinThemes.d.cts

@@ -1,11 +0,0 @@
-import { ThemeConfig } from "../types/theme.cjs";
-//#region src/theme/builtinThemes.d.ts
-/** The theme the cockpit renders with until a preference says otherwise. */
-export declare const DEFAULT_THEME_NAME = "doom-one-dark";
-/** The themes this package ships, default first. */
-export declare const BUILTIN_THEMES: readonly ThemeConfig[];
-export declare const DEFAULT_THEME: ThemeConfig;
-/** A shipped theme by name, or undefined for a name nothing shipped under. */
-export declare function builtinTheme(name: string): ThemeConfig | undefined;
-//#endregion
-//# sourceMappingURL=builtinThemes.d.cts.map

package/dist/theme/builtinThemes.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"builtinThemes.d.cts","names":[],"sources":["../../src/theme/builtinThemes.ts"],"mappings":";;;qBAaa;;qBAGA,yBAAyB;qBAMzB,eAAe;;wBAGZ,aAAa,eAAe"}

package/dist/theme/derive.d.cts

@@ -1,14 +0,0 @@
-import { DerivedToken, ThemeConfig, ThemeToken } from "../types/theme.cjs";
-//#region src/theme/derive.d.ts
-export declare const DEFAULT_FONT_MONO = "'JetBrains Mono', ui-monospace, SFMono-Regular, 'SF Mono', Menlo, Consolas, monospace";
-/**
- * A derived token's fallback: a CSS colour expression over the palette, so a
- * theme that supplies only its palette still gets coherent tints and edges.
- */
-export declare function derivedFallback(token: DerivedToken): string;
-/** Every derived token, in a stable order. */
-export declare function derivedTokens(): DerivedToken[];
-/** The value a theme publishes for a token: its own, or the derived fallback. */
-export declare function tokenValue(theme: ThemeConfig, token: ThemeToken): string;
-//#endregion
-//# sourceMappingURL=derive.d.cts.map

package/dist/theme/derive.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"derive.d.cts","names":[],"sources":["../../src/theme/derive.ts"],"mappings":";;qBASa;;;;;wBAOG,gBAAgB,OAAO;;wBAWvB,iBAAiB;;wBASjB,WAAW,OAAO,aAAa,OAAO"}

package/dist/theme/parse.d.cts

@@ -1,10 +0,0 @@
-import { ThemeConfig } from "../types/theme.cjs";
-//#region src/theme/parse.d.ts
-/**
- * Validates a theme config read from JSON. Returns null rather than throwing
- * because a bad theme file must never take the cockpit down; the caller falls
- * back to the shipped default and says so.
- */
-export declare function parseThemeConfig(input: unknown): ThemeConfig | null;
-//#endregion
-//# sourceMappingURL=parse.d.cts.map

package/dist/theme/parse.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"parse.d.cts","names":[],"sources":["../../src/theme/parse.ts"],"mappings":";;;;;;;wBAgBgB,iBAAiB,iBAAiB"}

package/dist/theme/piTheme.d.cts

@@ -1,19 +0,0 @@
-import { ThemeConfig, ThemeScheme } from "../types/theme.cjs";
-//#region src/theme/piTheme.d.ts
-export interface PiThemeBridgeOptions {
-  /** The web theme's id; defaults to the Pi theme's name. */
-  name?: string;
-  label?: string;
-  /** Forced scheme; otherwise inferred from the background luminance. */
-  scheme?: ThemeScheme;
-}
-/**
- * Builds a web theme from a Pi TUI theme, so the palette DoomPi ships for
- * the terminal (doompi-ui/themes/doom-pi-dark.json) drives the browser too.
- * The mapping is by role, not by name: Pi has no cockpit "deep" surface or
- * "border-soft" line, so those are mixed from the nearest vars. Returns null
- * when the input is not a Pi theme with a complete palette.
- */
-export declare function themeFromPiTheme(input: unknown, options?: PiThemeBridgeOptions): ThemeConfig | null;
-//#endregion
-//# sourceMappingURL=piTheme.d.cts.map

package/dist/theme/piTheme.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"piTheme.d.cts","names":[],"sources":["../../src/theme/piTheme.ts"],"mappings":";;iBAiCiB;;EAEf;EACA;;EAEA,SAAS;;;;;;;;;wBAUK,iBAAiB,gBAAgB,UAAS,uBAA4B"}

package/dist/theme/preference.d.cts

@@ -1,15 +0,0 @@
-//#region src/theme/preference.d.ts
-/** Where the page remembers the chosen theme; one key, machine-local. */
-export declare const THEME_STORAGE_KEY = "doompi.web.theme";
-/** The two Storage calls the preference needs, so tests pass a plain map. */
-export interface PreferenceStorage {
-  getItem(key: string): string | null;
-  setItem(key: string, value: string): void;
-  removeItem(key: string): void;
-}
-/** The stored theme name, or null when nothing was chosen or storage is unavailable. */
-export declare function readThemePreference(storage: PreferenceStorage | undefined): string | null;
-/** Remembers a theme name; null forgets it. Storage failures are swallowed: a theme is a convenience. */
-export declare function writeThemePreference(storage: PreferenceStorage | undefined, name: string | null): void;
-//#endregion
-//# sourceMappingURL=preference.d.cts.map

package/dist/theme/preference.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"preference.d.cts","names":[],"sources":["../../src/theme/preference.ts"],"mappings":";;qBACa;;iBAGI;EACf,QAAQ;EACR,QAAQ,aAAa;EACrB,WAAW;;;wBAIG,oBAAoB,SAAS;;wBAU7B,qBAAqB,SAAS,+BAA+B"}

package/dist/theme.d.cts

@@ -1,8 +0,0 @@
-import { ACCENT_TOKENS, AccentToken, DERIVED_TOKENS, DerivedToken, PALETTE_TOKENS, PaletteToken, THEME_TOKENS, ThemeConfig, ThemeScheme, ThemeToken, themeVariable } from "./types/theme.cjs";
-import { THEME_ATTRIBUTE, ThemeRoot, applyTheme, themeCssText, themeCssVariables } from "./theme/apply.cjs";
-import { BUILTIN_THEMES, DEFAULT_THEME, DEFAULT_THEME_NAME, builtinTheme } from "./theme/builtinThemes.cjs";
-import { DEFAULT_FONT_MONO, derivedFallback, derivedTokens, tokenValue } from "./theme/derive.cjs";
-import { parseThemeConfig } from "./theme/parse.cjs";
-import { PiThemeBridgeOptions, themeFromPiTheme } from "./theme/piTheme.cjs";
-import { PreferenceStorage, THEME_STORAGE_KEY, readThemePreference, writeThemePreference } from "./theme/preference.cjs";
-export { ACCENT_TOKENS, type AccentToken, BUILTIN_THEMES, DEFAULT_FONT_MONO, DEFAULT_THEME, DEFAULT_THEME_NAME, DERIVED_TOKENS, type DerivedToken, PALETTE_TOKENS, type PaletteToken, type PiThemeBridgeOptions, type PreferenceStorage, THEME_ATTRIBUTE, THEME_STORAGE_KEY, THEME_TOKENS, type ThemeConfig, type ThemeRoot, type ThemeScheme, type ThemeToken, applyTheme, builtinTheme, derivedFallback, derivedTokens, parseThemeConfig, readThemePreference, themeCssText, themeCssVariables, themeFromPiTheme, themeVariable, tokenValue, writeThemePreference };

package/dist/types/editor.d.cts

@@ -1,78 +0,0 @@
-//#region src/types/editor.d.ts
-/**
- * The vocabulary a file surface shares: how a file is shown, and what an
- * editor hands back when a reader selects part of one.
- *
- * It lives here rather than beside the components so a caller can classify a
- * path, or hold a selection in its own state, without pulling the editor
- * chunk in behind it.
- */
-/** How a file is shown when its bytes are not text: inline by kind, or offered as a download. */
-export declare const MEDIA_KINDS: readonly ['image', 'video', 'pdf', 'download'];
-export type MediaKind = (typeof MEDIA_KINDS)[number];
-/**
- * What a reader picked out, in the terms a review comment needs: the text
- * itself, and where it sits. Lines are one-based, matching what an editor
- * gutter shows, and a caret with nothing selected reports the same line twice
- * with empty text.
- */
-export interface EditorSelectionRange {
-  text: string;
-  /** Zero-based, half-open offsets in the mounted document. */
-  from: number;
-  to: number;
-  startLine: number;
-  endLine: number;
-}
-/** A zero-based half-open range in the mounted editor document. */
-export interface EditorTextRange {
-  from: number;
-  to: number;
-}
-/** A persistent numbered annotation drawn over a mounted editor range. */
-export interface EditorMarkedRange extends EditorTextRange {
-  label: string;
-}
-/** One replacement applied with the other edits in a single editor transaction. */
-export interface EditorEdit extends EditorTextRange {
-  insert: string;
-}
-/** A client-coordinate rectangle over the visible editor viewport. */
-export interface EditorViewportRectangle {
-  left: number;
-  top: number;
-  right: number;
-  bottom: number;
-}
-/** The deliberately small imperative surface exposed by a mounted editor. */
-export interface CodeEditorController {
-  focus: () => void;
-  revealAndSelect: (range: EditorTextRange) => void;
-  applyEdits: (edits: readonly EditorEdit[]) => void;
-  setClosedRanges: (ranges: readonly EditorTextRange[]) => void;
-  setMarkedRanges: (ranges: readonly EditorMarkedRange[]) => void;
-  /** Resolves visible geometry to a document-native range, or null when it misses the document. */
-  resolveViewportRegion: (rectangle: EditorViewportRectangle) => EditorSelectionRange | null;
-}
-export interface CodeEditorProps {
-  value: string;
-  /**
-   * The file this content came from. It picks the syntax grammar and nothing
-   * else; leave it off and the editor stays plain text.
-   */
-  path?: string;
-  readOnly?: boolean;
-  /**
-   * Wraps long lines rather than scrolling sideways. On by default, because
-   * the cockpit is read on phones and unwrapped code there is unreadable.
-   */
-  lineWrapping?: boolean;
-  className?: string;
-  'data-testid'?: string;
-  onChange?: (value: string) => void;
-  onSelect?: (range: EditorSelectionRange) => void;
-  /** Receives the controller while the CodeMirror view is mounted, and `null` after it is destroyed. */
-  controllerRef?: import('react').Ref<CodeEditorController>;
-}
-//#endregion
-//# sourceMappingURL=editor.d.cts.map

package/dist/types/editor.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"editor.d.cts","names":[],"sources":["../../src/types/editor.ts"],"mappings":";;;;;;;;;;qBAUa;YACD,oBAAoB;;;;;;;iBAQf;EACf;;EAEA;EACA;EACA;EACA;;;iBAIe;EACf;EACA;;;iBAIe,0BAA0B;EACzC;;;iBAGe,mBAAmB;EAClC;;;iBAIe;EACf;EACA;EACA;EACA;;;iBAIe;EACf;EACA,kBAAkB,OAAO;EACzB,aAAa,gBAAgB;EAC7B,kBAAkB,iBAAiB;EACnC,kBAAkB,iBAAiB;;EAEnC,wBAAwB,WAAW,4BAA4B;;iBAGhD;EACf;;;;;EAKA;EACA;;;;;EAKA;EACA;EACA;EACA,YAAY;EACZ,YAAY,OAAO;;EAEnB,gCAAgC,IAAI"}

package/dist/types/theme.d.cts

@@ -1,38 +0,0 @@
-//#region src/types/theme.d.ts
-/**
- * The web theme contract: the named colours every cockpit surface is built
- * from. Palette tokens are the hand-picked values a theme must supply; the
- * derived tokens (tinted backgrounds, accented borders) are computed from the
- * palette unless a theme pins them, which is how the shipped dark theme keeps
- * its exact mockup values while a third-party theme needs only the palette.
- */
-export declare const PALETTE_TOKENS: readonly ['bg', 'rail', 'panel', 'deep', 'border', 'border-soft', 'hi', 'text', 'dim', 'faint', 'blue', 'green', 'yellow', 'red', 'magenta', 'violet', 'cyan', 'orange', 'teal', 'selected'];
-export declare const ACCENT_TOKENS: readonly ['blue', 'green', 'yellow', 'red', 'magenta', 'violet', 'cyan', 'orange', 'teal'];
-export declare const DERIVED_TOKENS: readonly ['tint-blue', 'tint-green', 'tint-yellow', 'tint-red', 'tint-magenta', 'tint-violet', 'tint-cyan', 'tint-orange', 'tint-teal', 'edge-blue', 'edge-green', 'edge-yellow', 'edge-red', 'edge-magenta', 'edge-violet', 'edge-cyan', 'edge-orange', 'edge-teal',
-/**
- * The readable foreground on the `selected` surface. Derived so an existing
- * theme stays valid, but a theme whose `selected` is pale must pin it: CSS
- * cannot pick a contrasting colour on its own, and the fallback assumes a
- * saturated selection, which is what both shipped themes use.
- */
-'on-selected', 'font-mono'];
-export declare const THEME_TOKENS: readonly ["bg", "rail", "panel", "deep", "border", "border-soft", "hi", "text", "dim", "faint", "blue", "green", "yellow", "red", "magenta", "violet", "cyan", "orange", "teal", "selected", "tint-blue", "tint-green", "tint-yellow", "tint-red", "tint-magenta", "tint-violet", "tint-cyan", "tint-orange", "tint-teal", "edge-blue", "edge-green", "edge-yellow", "edge-red", "edge-magenta", "edge-violet", "edge-cyan", "edge-orange", "edge-teal", "on-selected", "font-mono"];
-export type PaletteToken = (typeof PALETTE_TOKENS)[number];
-export type AccentToken = (typeof ACCENT_TOKENS)[number];
-export type DerivedToken = (typeof DERIVED_TOKENS)[number];
-export type ThemeToken = (typeof THEME_TOKENS)[number];
-export type ThemeScheme = 'dark' | 'light';
-/** A theme config as written in JSON: identity, colour scheme, and the token values. */
-export interface ThemeConfig {
-  /** Stable id, kebab-case; the `data-theme` attribute and the stored preference. */
-  name: string;
-  /** What a picker shows. */
-  label: string;
-  /** Drives `color-scheme` so native controls and scrollbars match. */
-  scheme: ThemeScheme;
-  tokens: Record<PaletteToken, string> & Partial<Record<DerivedToken, string>>;
-}
-/** The CSS custom property a token is published as. */
-export declare function themeVariable(token: ThemeToken): `--doom-${ThemeToken}`;
-//#endregion
-//# sourceMappingURL=theme.d.cts.map

package/dist/types/theme.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"theme.d.cts","names":[],"sources":["../../src/types/theme.ts"],"mappings":";;;;;;;;qBAOa;qBAuBA;qBAEA;;;;;;;;qBA6BA;YAED,uBAAuB;YACvB,sBAAsB;YACtB,uBAAuB;YACvB,qBAAqB;YAErB;;iBAGK;;EAEf;;EAEA;;EAEA,QAAQ;EACR,QAAQ,OAAO,wBAAwB,QAAQ,OAAO;;;wBAIxC,cAAc,OAAO,uBAAuB"}

package/dist/types/tone.d.cts

@@ -1,28 +0,0 @@
-//#region src/types/tone.d.ts
-/**
- * The tone vocabularies every surface shares.
- *
- * Three of them exist because they answer different questions. A chromatic
- * tone names a colour ("this chip is violet"), a status tone names an outcome
- * ("this run failed"), and a line tone names a role inside a body of text.
- * They live here, not beside the components that draw them, so a consumer can
- * translate between them without importing a component, and so adding a tone
- * to one table without the others fails to compile.
- */
-/** The accents a theme supplies; mirrors ACCENT_TOKENS in ./theme.ts. */
-export declare const ACCENT_TONES: readonly ['blue', 'green', 'yellow', 'red', 'magenta', 'violet', 'cyan', 'orange', 'teal'];
-export type AccentTone = (typeof ACCENT_TONES)[number];
-/** What a chip may be: an accent, or the quiet default. */
-export declare const CHIP_TONES: readonly ["neutral", "blue", "green", "yellow", "red", "magenta", "violet", "cyan", "orange", "teal"];
-export type ChipTone = (typeof CHIP_TONES)[number];
-/** A dot adds `muted` for a thing that exists but is not live. */
-export declare const DOT_TONES: readonly ["neutral", "muted", "blue", "green", "yellow", "red", "magenta", "violet", "cyan", "orange", "teal"];
-export type DotTone = (typeof DOT_TONES)[number];
-/** What happened, rather than what colour it is. */
-export declare const STATUS_TONES: readonly ['neutral', 'running', 'ok', 'error', 'info', 'accent'];
-export type StatusTone = (typeof STATUS_TONES)[number];
-/** The role a single line of a message body plays. */
-export declare const MESSAGE_LINE_TONES: readonly ['hi', 'text', 'dim', 'muted', 'success', 'error', 'warning', 'accent'];
-export type MessageLineTone = (typeof MESSAGE_LINE_TONES)[number];
-//#endregion
-//# sourceMappingURL=tone.d.cts.map

package/dist/types/tone.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"tone.d.cts","names":[],"sources":["../../src/types/tone.ts"],"mappings":";;;;;;;;;;;;qBAYa;YACD,qBAAqB;;qBAGpB;YACD,mBAAmB;;qBAGlB;YACD,kBAAkB;;qBAGjB;YACD,qBAAqB;;qBAGpB;YACD,0BAA0B"}