paneltir 0.6.0

package/dist/index.d.ts

@@ -0,0 +1,1489 @@
+import React from 'react';
+
+/**
+ * What version of the kit a project is actually running.
+ *
+ * A dashboard that cannot say which Paneltir it is built on is a dashboard
+ * nobody can support: "it looks wrong" and "it is three versions behind" are
+ * indistinguishable from the outside. Both values are injected at build time
+ * from `package.json` and `fingerprint.json`, so they cannot be restated by
+ * hand and cannot drift.
+ */
+/** The released version, matching the `vX.Y.Z` tag consumers install. */
+declare const PANELTIR_VERSION: string;
+/** SHA-256 over every tracked file at that version. */
+declare const PANELTIR_FINGERPRINT: string;
+/** How many files that fingerprint covers. */
+declare const PANELTIR_FILE_COUNT: number;
+/**
+ * Everything needed to report the kit in a panel's own footer or settings
+ * sheet, and to check it against the released version without opening
+ * node_modules.
+ */
+declare const paneltirBuild: {
+    readonly version: string;
+    readonly fingerprint: string;
+    readonly fileCount: number;
+    /** The tag this build came from, ready to compare or to link. */
+    readonly tag: `v${string}`;
+    /** Short form, for a footer that has one line to spare. */
+    readonly short: `v${string} \u00B7 ${string}`;
+};
+
+/**
+ * Colour roles every project maps to its own palette.
+ *
+ * The library ships no defaults on purpose: when a project leaves a token
+ * out, the component that uses it renders without colour, so the omission is
+ * visible immediately instead of inheriting a generic colour nobody asked for.
+ */
+interface DashboardThemeTokens {
+    /** Page background. */
+    ground: string;
+    /** First stop of the top gradient, and the background of the detail sheet. */
+    groundRaised: string;
+    /** Columns, tiles, chips, form fields. */
+    panel: string;
+    /** Cards, resting on top of "panel". */
+    raised: string;
+    /** A real border (alpha around 0.13 over white in dark themes). */
+    line: string;
+    /** A faint divider (alpha around 0.07 over white in dark themes). */
+    lineFaint: string;
+    /** Content text, full opacity. */
+    ink: string;
+    /** Secondary text (about 0.62 of ink). */
+    inkDim: string;
+    /** Labels and placeholders (about 0.34 of ink). */
+    inkFaint: string;
+    /** The single accent: active chip, primary button, focus ring. */
+    accent: string;
+    /** First stop of the primary button gradient. Defaults to accent. */
+    accentStart?: string;
+    /** Second stop of the primary button gradient. Defaults to accent. */
+    accentEnd?: string;
+    /** Text colour on top of the accent — usually the same value as "ground". */
+    accentInk?: string;
+    danger: string;
+    warning: string;
+    success: string;
+    neutral: string;
+}
+
+/**
+ * Shape roles, the counterpart to the colour roles in `tokens.ts`.
+ *
+ * A theme that only swaps colour produces the same panel in a different
+ * palette, which is fine for a preset but not for an identity: Old Money and
+ * Midnight are not the same object painted twice. So a theme carries a form
+ * as well — how square things are, how heavy the rules are, what a card is.
+ *
+ * The kit still defines the structure; a form only chooses among the shapes
+ * the kit already knows how to draw. `shape` picks the drawing, everything
+ * else tunes it. All of it is optional: leave the form out and the library
+ * renders exactly as it did before forms existed.
+ */
+interface DashboardThemeForm {
+    /**
+     * Which drawing the board uses.
+     *
+     * - `panel` — cards are raised chips floating in a rounded column, each
+     *   carrying a coloured bar. The default.
+     * - `ledger` — cards are ruled rows in a column with no fill, separated by
+     *   hairlines and marked in the gutter. Reads as a book rather than a HUD.
+     */
+    shape?: 'panel' | 'ledger';
+    /** Radius of columns, tiles and sheets. */
+    radiusPanel?: string;
+    /** Radius of cards. */
+    radiusCard?: string;
+    /** Radius of buttons, chips and fields. */
+    radiusControl?: string;
+    /** Radius of small square controls. */
+    radiusSquare?: string;
+    /**
+     * Radius of chips, tags and pills. A ledger squares these off; leave it out
+     * and they stay fully rounded.
+     */
+    radiusPill?: string;
+    /** Border weight. A ledger wants a hairline; a HUD can afford more. */
+    borderWidth?: string;
+    /** Body face. */
+    fontFamily?: string;
+    /** Face for column headers and titles, when it differs from the body. */
+    fontFamilyDisplay?: string;
+    /** Base text size. */
+    fontSize?: string;
+    /** Tracking on the small uppercase labels. */
+    labelTracking?: string;
+    /** Multiplies the spacing scale: below 1 is denser, above 1 is airier. */
+    density?: number;
+}
+
+interface DashboardThemeProviderProps {
+    tokens: DashboardThemeTokens;
+    /** Shape roles. Omitted, the library keeps its default "panel" form. */
+    form?: DashboardThemeForm;
+    children: React.ReactNode;
+    className?: string;
+    style?: React.CSSProperties;
+}
+/**
+ * Injects the project's colour tokens as CSS variables on a container.
+ * Everything the library renders inside this provider reads colour through
+ * those variables — never from a hard-coded value.
+ */
+declare function DashboardThemeProvider({ tokens, form, children, className, style }: DashboardThemeProviderProps): React.JSX.Element;
+/** The active form, or null when the theme did not declare one. */
+declare function useDashboardForm(): DashboardThemeForm | null;
+declare function useDashboardTheme(): DashboardThemeTokens;
+
+/**
+ * Base themes for projects that do not have a palette of their own yet (see
+ * INSTALL.md, step 3). They are nobody's identity — just a decent starting
+ * point, meant to be replaced as soon as the project has one.
+ *
+ * All three follow the same system rules (a single accent, the four semantic
+ * colours kept apart from it, three surface levels): what differs between
+ * them is the choice of colour, not the structure.
+ */
+declare const midnightTheme: DashboardThemeTokens;
+declare const oldMoneyTheme: DashboardThemeTokens;
+declare const cyberpunkTheme: DashboardThemeTokens;
+/**
+ * Warm paper and clay. The one light theme the kit ships.
+ *
+ * Every other preset is dark, which made "light" an untested claim rather than
+ * an option: the tokens were always capable of it, but nothing proved a board
+ * drawn on a pale ground stayed legible. This is that proof as well as a
+ * theme — ink is near-black rather than pure, surfaces separate by warmth
+ * instead of by brightness alone, and the accent is a clay that reads against
+ * paper without shouting.
+ *
+ * `accentInk` matters more here than anywhere: on a dark theme an accent is
+ * always lighter than what it sits on, so text over it is dark by default. On
+ * this one it is the other way round.
+ */
+declare const claudeTheme: DashboardThemeTokens;
+/**
+ * The default form: raised cards floating in a rounded column. Everything the
+ * library drew before forms existed.
+ */
+declare const panelForm: DashboardThemeForm;
+/**
+ * A ledger. Squared off, ruled rather than boxed, set in a serif with more air
+ * between the rows — a book of accounts, not a HUD. Old Money is built on it,
+ * which is why that theme is not another one in green.
+ */
+declare const ledgerForm: DashboardThemeForm;
+/**
+ * Softer than `panel` and roomier: larger radii, a hairline border, and a
+ * humanist face. Paper does not need the contrast a dark surface gets for
+ * free, so the shape does the separating instead.
+ */
+declare const paperForm: DashboardThemeForm;
+declare const THEME_FORMS: {
+    readonly panel: DashboardThemeForm;
+    readonly ledger: DashboardThemeForm;
+    readonly paper: DashboardThemeForm;
+};
+type ThemeFormName = keyof typeof THEME_FORMS;
+declare const THEME_PRESETS: {
+    readonly midnight: DashboardThemeTokens;
+    readonly oldMoney: DashboardThemeTokens;
+    readonly cyberpunk: DashboardThemeTokens;
+    readonly claude: DashboardThemeTokens;
+};
+type ThemePresetName = keyof typeof THEME_PRESETS;
+
+interface DashboardHeaderProps {
+    /** Project name — the component applies uppercase and letter spacing, so pass it as written. */
+    wordmark: React.ReactNode;
+    /** Compact status line, for example "3 pending". */
+    status?: React.ReactNode;
+    /** Small controls (buttons, toggles) placed before the text link. */
+    controls?: React.ReactNode;
+    /** Plain text link at the end of the header. */
+    linkLabel?: string;
+    linkHref?: string;
+    onLinkClick?: () => void;
+}
+declare function DashboardHeader({ wordmark, status, controls, linkLabel, linkHref, onLinkClick }: DashboardHeaderProps): React.JSX.Element;
+
+interface AlertBannerProps {
+    visible: boolean;
+    message: React.ReactNode;
+    actionLabel?: string;
+    onAction?: () => void;
+}
+/** Full-width banner under the header. Hidden by default (visible=false). */
+declare function AlertBanner({ visible, message, actionLabel, onAction }: AlertBannerProps): React.JSX.Element | null;
+
+interface StatTileProps {
+    label: string;
+    value: React.ReactNode;
+    /** Semantic colour for when the value matters, for example something is pending. */
+    tone?: 'neutral' | 'danger' | 'warning' | 'success';
+    /** When the value is zero or empty, render it calm instead of semantic. */
+    isZero?: boolean;
+}
+declare function StatTile({ label, value, tone, isZero }: StatTileProps): React.JSX.Element;
+declare function StatTileGrid({ children }: {
+    children: React.ReactNode;
+}): React.JSX.Element;
+
+type HealthStatus = 'ok' | 'warning' | 'bad' | 'unknown';
+interface HealthPillProps {
+    label: string;
+    value: React.ReactNode;
+    status: HealthStatus;
+}
+/** Facts about the system itself: credential countdown, environment, last sync. */
+declare function HealthPill({ label, value, status }: HealthPillProps): React.JSX.Element;
+declare function HealthPillRow({ children }: {
+    children: React.ReactNode;
+}): React.JSX.Element;
+
+interface FilterChipProps {
+    label: string;
+    count?: number;
+    active: boolean;
+    onClick: () => void;
+}
+declare function FilterChip({ label, count, active, onClick }: FilterChipProps): React.JSX.Element;
+/** Horizontal scrolling row with no visible scrollbar. */
+declare function FilterChipRow({ children }: {
+    children: React.ReactNode;
+}): React.JSX.Element;
+
+interface BoardCardData {
+    id: string;
+}
+interface BoardColumnData<TCard extends BoardCardData = BoardCardData> {
+    id: string;
+    title: string;
+    /**
+     * What the column means, shown on hover and to a screen reader.
+     *
+     * A column head is two words; whether a card sitting there is waiting on you
+     * or on someone else is the thing you actually need, and two words cannot
+     * carry it.
+     */
+    hint?: string;
+    cards: TCard[];
+}
+interface BoardMoveResult {
+    cardId: string;
+    fromColumnId: string;
+    toColumnId: string;
+    toIndex: number;
+}
+
+interface BoardProps<TCard extends BoardCardData> {
+    columns: BoardColumnData<TCard>[];
+    /** Renders the content of each card — normally a <Card /> from this library. */
+    renderCard: (card: TCard, index: number, columnId: string) => React.ReactNode;
+    onMove: (result: BoardMoveResult) => void;
+    onAddCard?: (columnId: string) => void;
+}
+/** A row of columns with horizontal scroll-snap and drag and drop between them. */
+declare function Board<TCard extends BoardCardData>({ columns, renderCard, onMove, onAddCard }: BoardProps<TCard>): React.JSX.Element;
+
+interface BoardTag {
+    label: string;
+    tone?: 'neutral' | 'danger' | 'warning' | 'success';
+    /** The most important tag: inverted to a solid accent fill. */
+    emphasize?: boolean;
+}
+interface CardProps {
+    cardId: string;
+    columnId: string;
+    index: number;
+    title: React.ReactNode;
+    /** Colour of the 3px stripe that encodes priority. */
+    priorityColor?: string;
+    tags?: BoardTag[];
+    progress?: {
+        done: number;
+        total: number;
+    };
+    children?: React.ReactNode;
+    onClick?: () => void;
+}
+/** Dragging starts only from the grip, so the rest of the card still scrolls the column. */
+declare function Card$1({ cardId, columnId, index, title, priorityColor, tags, progress, children, onClick }: CardProps): React.JSX.Element;
+
+/**
+ * Applies a BoardMoveResult (what onMove emits) to an array of columns and
+ * returns the new array. This is the piece of logic where an off-by-one slips
+ * in most easily when every project rewrites it, which is why it lives here
+ * rather than in a written convention.
+ */
+declare function moveCardInColumns<TCard extends BoardCardData>(columns: BoardColumnData<TCard>[], move: BoardMoveResult): BoardColumnData<TCard>[];
+
+interface DetailSheetProps {
+    open: boolean;
+    onClose: () => void;
+    children: React.ReactNode;
+    ariaLabel?: string;
+}
+/**
+ * Below 760px this is a sheet rising from the bottom; from 760px up the same
+ * markup becomes a centred floating dialog. The breakpoint is handled in CSS,
+ * so there are not two different components.
+ */
+declare function DetailSheet({ open, onClose, children, ariaLabel }: DetailSheetProps): React.JSX.Element | null;
+interface DetailSectionProps {
+    title: string;
+    /** Clarifying phrase in lowercase, printed after an em dash. */
+    subtitle?: string;
+    children: React.ReactNode;
+}
+declare function DetailSection({ title, subtitle, children }: DetailSectionProps): React.JSX.Element;
+
+/**
+ * Whether a note has been dismissed, and how to dismiss it.
+ *
+ * Starts as "shown but not yet decided" so the first paint matches the server
+ * and nothing flashes into place; the stored answer arrives on the first
+ * effect.
+ */
+declare function useGuideNote(id: string, remember?: boolean): {
+    visible: boolean;
+    dismiss: () => void;
+};
+/** Clears every dismissal, so the guidance can be asked for again. */
+declare function resetGuide(): void;
+interface GuideNoteProps {
+    /** Stable across releases: changing it makes the note reappear for everyone. */
+    id: string;
+    title: React.ReactNode;
+    children: React.ReactNode;
+    /** Wording of the dismiss button. Say what it does, not "OK". */
+    dismissLabel?: string;
+    /** Shown after the note, for the one thing it wants the reader to do. */
+    action?: {
+        label: string;
+        onClick: () => void;
+    };
+    /** Position in a sequence, so a first session reads as a tour, not a pile. */
+    step?: {
+        index: number;
+        total: number;
+    };
+    /** Told after the note is dismissed, so a sequence can move on. */
+    onDismissed?: () => void;
+    /**
+     * Whether to record the dismissal in localStorage. False when the caller
+     * keeps that answer itself, so the two cannot disagree.
+     */
+    remember?: boolean;
+}
+declare function GuideNote({ id, title, children, dismissLabel, action, step, onDismissed, remember, }: GuideNoteProps): React.JSX.Element | null;
+interface GuideTourProps {
+    /** Notes in order. Only the first undismissed one shows, so it reads as a tour. */
+    notes: Array<Omit<GuideNoteProps, 'step' | 'onDismissed'>>;
+    /**
+     * Which notes are already dismissed, when the caller keeps that somewhere
+     * durable. Leave it out and each reader's browser remembers, which is the
+     * right home for a fact about one browser — and the wrong one for a panel
+     * with a single owner, who would be told the same tour again on a new
+     * machine.
+     */
+    dismissed?: string[];
+    /** Told when a note is dismissed. Required for `dismissed` to mean anything. */
+    onDismiss?: (id: string) => void;
+}
+/**
+ * One note at a time, in order.
+ *
+ * Five notes at once is a wall nobody reads. Shown one at a time, dismissing
+ * each reveals the next, and a reader who dismisses all of them has been
+ * through the tour rather than having closed a box.
+ */
+declare function GuideTour({ notes, dismissed, onDismiss }: GuideTourProps): React.JSX.Element | null;
+
+type NotificationTone = 'info' | 'attention';
+interface PanelNotification {
+    /**
+     * Stable for the life of the event. Two different events must never share
+     * one, or marking the first seen silences the second; the same event must
+     * never change it, or it comes back every time the page loads.
+     */
+    id: string;
+    title: React.ReactNode;
+    detail?: React.ReactNode;
+    /** Shown as given, so the caller decides the format its readers expect. */
+    at?: string;
+    /** `attention` for something waiting on the reader, `info` for the rest. */
+    tone?: NotificationTone;
+    /** Where this leads. Called before the notification is marked seen. */
+    onOpen?: () => void;
+}
+interface NotificationLabels {
+    /** Names the control for a screen reader and on hover. */
+    title: string;
+    empty: string;
+    markAll: string;
+    /** Given the count, e.g. (n) => `${n} unread`. */
+    unread: (count: number) => string;
+}
+interface NotificationBellProps {
+    notifications: PanelNotification[];
+    labels?: Partial<NotificationLabels>;
+    /**
+     * What this reader has already seen, when the caller keeps it somewhere
+     * durable. Leave it out and the bell remembers in localStorage, which is the
+     * right home for a fact about one browser.
+     *
+     * A panel with one password has one owner, and there "this reader" and "this
+     * project" are the same person — so a panel that saves its board can keep
+     * this in it and have it survive a new browser. That is the caller's call to
+     * make, not the component's, which is why both work.
+     */
+    seen?: string[];
+    /** Told which ids were just seen. Required for `seen` to mean anything. */
+    onSeen?: (ids: string[]) => void;
+}
+declare function NotificationBell({ notifications, labels, seen: given, onSeen }: NotificationBellProps): React.JSX.Element | null;
+
+/**
+ * A block of text whose whole purpose is to end up somewhere else.
+ *
+ * Anything a panel tells someone to paste — a settings fragment, two commands,
+ * a shell line — is read once and copied. So the copy is the primary action
+ * and the text is selectable underneath it, rather than the other way round.
+ *
+ * The clipboard API is not always there. It needs a secure context and can be
+ * refused outright, and a copy button that silently does nothing is worse than
+ * no button at all: the reader walks away believing they have the text. So the
+ * failure falls back to selecting the block, and says which of the two
+ * happened.
+ */
+interface CopyBlockProps {
+    /** Exactly what lands on the clipboard. Shown verbatim. */
+    text: string;
+    /** What this block is, above it. */
+    label?: React.ReactNode;
+    /** Why the reader wants it, and anything they must know before pasting. */
+    note?: React.ReactNode;
+    /** Wording, so the kit stays language-agnostic. */
+    labels?: Partial<CopyBlockLabels>;
+}
+interface CopyBlockLabels {
+    copy: string;
+    copied: string;
+    /** Used when the clipboard refused and the text was selected instead. */
+    selected: string;
+}
+declare function CopyBlock({ text, label, note, labels }: CopyBlockProps): React.JSX.Element;
+
+/**
+ * What the panel needs in order to work, and what to do about what is missing.
+ *
+ * A panel with no token does not look broken — it looks fine until the moment
+ * someone presses Save, and then it fails with something the person reading it
+ * did not cause and cannot place. This turns that into a list they can read
+ * before it happens, and act on without leaving the panel.
+ *
+ * The status comes from the server, which is the only place that can see the
+ * environment. It reports *whether* a variable is set and never its value, so
+ * this component has nothing worth leaking.
+ */
+type SetupStatus = 'ok' | 'missing' | 'unknown';
+interface SetupRequirement {
+    id: string;
+    /** What it is, in the reader's terms rather than the variable's. */
+    label: React.ReactNode;
+    status: SetupStatus;
+    /** The environment variable behind it, when there is one to name. */
+    variable?: string;
+    /** What it lets the panel do — so a missing one has a visible cost. */
+    enables?: React.ReactNode;
+    /** Exactly what to do, shown only when it is missing. */
+    fix?: React.ReactNode;
+}
+interface SetupGuideProps {
+    requirements: SetupRequirement[];
+    /** Shown when everything is in place, instead of an empty list. */
+    readyMessage?: React.ReactNode;
+    /** Wording, so the kit stays language-agnostic. */
+    labels?: Partial<{
+        ok: string;
+        missing: string;
+        unknown: string;
+        whatToDo: string;
+    }>;
+}
+declare function SetupGuide({ requirements, readyMessage, labels }: SetupGuideProps): React.JSX.Element;
+
+type Handler = (payload: Record<string, string>, event: MouseEvent) => void;
+/**
+ * A single click listener on document that dispatches by data-* attributes,
+ * instead of one handler per element. Meant for a project's own actions; the
+ * Board does not use it internally.
+ *
+ * Example: useDelegatedClick('data-action', (payload) => { if (payload.action === 'delete') ... })
+ * with buttons such as <button data-action="delete" data-id="42">
+ */
+declare function useDelegatedClick(attribute: string, handler: Handler): void;
+
+declare function useMediaQuery(query: string): boolean;
+
+/**
+ * A board is read in one language and written in another.
+ *
+ * This is the mechanism only — the types and the resolution. The panel's own
+ * wording lives with the panel: a library that shipped its copy would be a
+ * library deciding what a project's board says.
+ */
+type Lang = 'en' | 'es';
+declare const LANGS: Lang[];
+declare const LANG_LABELS: Record<Lang, string>;
+/**
+ * A string, or the same string per language.
+ *
+ * A plain string is a claim: this text is right in either language — true for
+ * a product name, a number, a file id, and almost never for prose. An object
+ * is the honest shape for a sentence, and one that carries a single language
+ * says "written, not translated yet", which is exactly what the next session
+ * needs to know.
+ */
+type Text = string | Partial<Record<Lang, string>>;
+declare function text(value: Text | undefined, lang: Lang): string;
+/** True when a sentence exists in one language only. */
+declare function untranslated(value: Text | undefined): boolean;
+/**
+ * Writing replaces the language being typed and drops the other copy of that
+ * field. Deliberate: a translation of a sentence somebody just rewrote is a
+ * lie about what the card says, and the gap is the panel telling the next
+ * session what to fill in.
+ */
+declare function writeText(lang: Lang, value: string): Text;
+
+type Weight = 'primary' | 'secondary' | 'off';
+type Severity = 'high' | 'medium' | 'low';
+type SuggestionStatus = 'new' | 'doing' | 'done' | 'dismissed';
+interface Goal {
+    id: string;
+    label: Text;
+    weight: Weight;
+}
+interface Constraint {
+    id: string;
+    label: Text;
+    on: boolean;
+}
+interface Reading {
+    date: string;
+    value: number;
+    note?: Text;
+}
+interface Metric {
+    id: string;
+    label: Text;
+    unit: string;
+    /** Which direction counts as better. A reading against it is what "drifting" means. */
+    goal: 'up' | 'down';
+    readings: Reading[];
+}
+interface Strategy {
+    id: string;
+    title: Text;
+    thesis: Text;
+    horizon: Text;
+    /** 0–10, so three bars can be compared at a glance rather than read. */
+    effort: number;
+    risk: number;
+    upside: number;
+    moves: Text[];
+}
+interface Suggestion {
+    id: string;
+    area: string;
+    severity: Severity;
+    status: SuggestionStatus;
+    date: string;
+    text: Text;
+}
+/**
+ * A question the owner answers and Claude reads.
+ *
+ * This is the whole point of the analysis view. A board says what to do; a
+ * choice says how the project wants it done, in the owner's words, once —
+ * instead of being asked again on every card. Claude reads these before
+ * deciding anything, so answering one here is worth more than answering it
+ * in a message that scrolls away.
+ *
+ * `value` of null is not missing data. It means nobody has decided, which is
+ * information: Claude must not guess an answer to a question the owner has
+ * deliberately left open.
+ */
+interface Choice {
+    id: string;
+    question: Text;
+    /** What actually changes depending on the answer. Never "choose an option". */
+    why?: Text;
+    options: ChoiceOption[];
+    value: string | null;
+    decidedAt?: string;
+    decidedBy?: string;
+}
+interface ChoiceOption {
+    id: string;
+    label: Text;
+    /** What picking this commits the project to. */
+    detail?: Text;
+}
+/** Who the work is for, and against what. */
+interface Market {
+    audience: Text;
+    positioning: Text;
+    competitors: Competitor[];
+    pricing?: Text;
+    notes?: Text[];
+}
+interface Competitor {
+    id: string;
+    name: string;
+    /** What they do better. Written honestly or it is worthless. */
+    strength: Text;
+    /** Where they leave room. */
+    gap: Text;
+}
+/** The four things the analysis is about, each its own screen. */
+type AnalysisSection = 'board' | 'project' | 'strategy' | 'market';
+declare const ANALYSIS_SECTIONS: AnalysisSection[];
+interface Analysis {
+    brief: Text;
+    stage: string;
+    goals: Goal[];
+    constraints: Constraint[];
+    metrics: Metric[];
+    strategies: Strategy[];
+    /** The path the owner picked. Null is a decision waiting, and it is theirs. */
+    chosen: string | null;
+    suggestions: Suggestion[];
+    /** Who this is for and against what. Optional: not every board is a product. */
+    market?: Market;
+    /**
+     * Standing answers, grouped by the screen they belong to. Claude reads them
+     * before deciding anything the board does not already settle.
+     */
+    choices?: Partial<Record<AnalysisSection, Choice[]>>;
+}
+/** Everything the owner has actually decided, newest first. */
+declare function decided(analysis: Analysis): {
+    section: AnalysisSection;
+    choice: Choice;
+    option: ChoiceOption;
+}[];
+/** Questions still open. A count of these is the honest state of the analysis. */
+declare function undecided(analysis: Analysis): {
+    section: AnalysisSection;
+    choice: Choice;
+}[];
+/**
+ * What the board itself says, counted rather than declared.
+ *
+ * These are not stored: a number typed into the analysis is a number that
+ * disagrees with the board the moment a card moves. They are derived on every
+ * render from the cards, so they cannot be wrong.
+ */
+interface BoardFacts {
+    total: number;
+    open: number;
+    byColumn: {
+        id: string;
+        title: Text;
+        count: number;
+    }[];
+    waitingOnOwner: number;
+    orders: number;
+    highRisk: number;
+    /** Cards claiming to be finished that were never picked up. */
+    claimed: Pick<Card, 'id' | 'title'>[];
+    /** Age of the oldest card still open. Null when nothing is open. */
+    oldestOpenDays: number | null;
+    oldestOpen: Pick<Card, 'id' | 'title'> | null;
+}
+/**
+ * Counts the board rather than believing a number somebody typed.
+ *
+ * `today` is passed in so the same cards always produce the same answer — a
+ * function that reads the clock cannot be checked.
+ */
+declare function boardFacts(cards: Card[], columns: ColumnDef[], today: string): BoardFacts;
+interface Trend {
+    latest: Reading | undefined;
+    previous: Reading | undefined;
+    delta: number | null;
+    /** True when the last move went against the metric's declared direction. */
+    against: boolean;
+}
+declare function trendOf(metric: Metric): Trend;
+/**
+ * Points for a sparkline in a 0–1 box, so the caller only decides the size.
+ * A flat series sits on the middle line rather than collapsing to the floor.
+ */
+declare function sparkPoints(readings: Reading[]): {
+    x: number;
+    y: number;
+}[];
+
+type Level = 'high' | 'medium' | 'low';
+type Owner = 'claude' | 'you';
+/**
+ * What the owner wants done with a card next, in one tap.
+ *
+ * Free text would be clearer to write and useless to obey: "solve it if you
+ * can" and "solve it yourself" are the same sentence and different
+ * instructions. A fixed set gives each one an exact, documented meaning, so a
+ * tap is a contract rather than a hint. Absent is a real state: no
+ * instruction, use judgement.
+ *
+ * Three of them — explain, askme, hold — are refusals to act. Honouring them
+ * exactly matters more than the work: they are the only way to say "not yet".
+ */
+declare const INTENTS: readonly ["decide", "explain", "solve", "do", "cheap", "safe", "fast", "askme", "hold"];
+type Intent = (typeof INTENTS)[number];
+interface IntentCopy {
+    label: Record<Lang, string>;
+    meaning: Record<Lang, string>;
+}
+declare const INTENT_COPY: Record<Intent, IntentCopy>;
+interface Check {
+    id: string;
+    text: Text;
+    done: boolean;
+}
+interface Note {
+    id: string;
+    by: Owner;
+    date: string;
+    text: Text;
+}
+interface Card {
+    id: string;
+    column: string;
+    title: Text;
+    body: Text;
+    area: string;
+    priority: Level;
+    risk: Level;
+    owner: Owner;
+    /** The one flag that means "I am asking you to do this". */
+    order: boolean;
+    intent: Intent | null;
+    checks: Check[];
+    notes: Note[];
+    createdAt: string;
+    updatedAt: string;
+    /**
+     * Stamped by the board when the card enters the working column, and when it
+     * reaches a done column. They are written by the move, never typed, so a
+     * card that carries `completedAt` with no `startedAt` is one that was
+     * declared finished without ever being picked up — which is exactly the
+     * thing worth being able to see.
+     */
+    startedAt?: string | null;
+    completedAt?: string | null;
+}
+interface ColumnDef {
+    id: string;
+    title: Text;
+    /** What the column means, shown on hover. Two words cannot say whether a
+        card sitting here is waiting on you or on Claude. */
+    hint?: Text;
+    /** Work in flight: entering this column stamps the card as started. */
+    active?: boolean;
+    /** Cards here are finished: they leave the open counts alone. */
+    done?: boolean;
+}
+/**
+ * One pass over the board: what a session changed, and which cards it
+ * touched. Written at the end of a run, so the panel keeps the account
+ * rather than the account living in a chat nobody can re-read.
+ */
+interface Run {
+    id: string;
+    date: string;
+    by: Owner;
+    summary: Text;
+    /** Card ids this run touched, so a claim can be checked against the board. */
+    cards: string[];
+    /** The kit fingerprint at the time, twelve characters is enough to compare. */
+    fingerprint?: string;
+}
+interface HealthFact {
+    label: Text;
+    value: Text;
+    status: 'ok' | 'warning' | 'bad' | 'unknown';
+}
+/**
+ * A theme Claude derived from the project it is installed in.
+ *
+ * Stored with where it came from, not only with its colours. "Update the
+ * theme" is only a meaningful request if the next answer can be compared with
+ * this one — otherwise a regenerated theme is a different theme for reasons
+ * nobody can see. `from` is what makes the difference readable.
+ *
+ * `refreshRequested` is a message, not a trigger: a panel cannot run Claude.
+ * Tapping Update writes the date here, the bell shows it, and the next session
+ * regenerates. Pretending the button does the work itself would leave the
+ * owner waiting for something that was never going to happen.
+ */
+interface ImportedTheme {
+    /** What to call it in the theme list. */
+    label: Text;
+    tokens: Record<string, string>;
+    form?: Record<string, string | number>;
+    from: {
+        /** Files the colours were read out of, so the claim can be checked. */
+        files: string[];
+        /** The colours actually found, before they were mapped to tokens. */
+        colours: string[];
+        /** Why these tokens and not others. One or two sentences. */
+        reasoning: Text;
+    };
+    importedAt: string;
+    importedBy: 'claude';
+    /** Set by the panel when the owner asks for it to be derived again. */
+    refreshRequested?: string | null;
+}
+/**
+ * What the owner has chosen, kept in the board so it survives a new browser.
+ *
+ * The kit's default is to remember these per browser, in localStorage, because
+ * for a component "which notes this reader dismissed" is a fact about a reader
+ * and not about a project. A panel with one password is the case where those
+ * two are the same person: keeping it here means the theme, the language and
+ * what has already been read follow the owner to a new machine instead of
+ * greeting them with a tour they finished months ago.
+ *
+ * The cost is real and worth naming: anyone who shares the password shares
+ * this. It holds a theme name and a list of ids — nothing worth stealing, and
+ * nothing anyone else would want.
+ */
+interface Preferences {
+    theme?: string;
+    lang?: Lang;
+    /** Ids of notifications already read. Bounded when saved. */
+    seen?: string[];
+    /** Ids of guide notes already dismissed. */
+    guideDismissed?: string[];
+}
+interface PanelState {
+    v: 2;
+    project: string;
+    environment: Text;
+    updatedAt: string;
+    notice?: Text;
+    columns: ColumnDef[];
+    areas: {
+        id: string;
+        label: Text;
+    }[];
+    health: HealthFact[];
+    cards: Card[];
+    /** Newest first. Capped when saving, so the file cannot grow without end. */
+    runs: Run[];
+    /** What any of the work is for: goals, constraints, metrics, strategies. */
+    analysis?: Analysis;
+    /** The owner's choices, so they survive a new browser. */
+    preferences?: Preferences;
+    /** A theme Claude derived from this project, with where it came from. */
+    importedTheme?: ImportedTheme;
+}
+declare const LEVELS: Level[];
+declare const OWNERS: Owner[];
+declare function newId(): string;
+declare function today(): string;
+/** A card is created empty and named second — the same as tapping "+" on paper. */
+declare function emptyCard(column: string, area: string): Card;
+/**
+ * Applies the column's own meaning to a card that just moved into it: a card
+ * entering the working column is started, one reaching a done column is
+ * finished, and one dragged back out of done is not finished any more.
+ */
+declare function stampForColumn(card: Card, columns: ColumnDef[]): Card;
+/** A card claiming to be finished that was never picked up. */
+declare function claimedWithoutStarting(card: Card): boolean;
+interface Counts {
+    open: number;
+    orders: number;
+    yours: number;
+    decisions: number;
+    highRisk: number;
+    done: number;
+}
+declare function countCards(state: PanelState): Counts;
+/** How many checklist steps are ticked, for the counter on a card. */
+declare function checkProgress(card: Card): {
+    done: number;
+    total: number;
+} | undefined;
+
+/**
+ * Reads a board and says what is wrong with it, in words.
+ *
+ * The board is a JSON file in somebody's repository. That is the whole point —
+ * it has a diff, a history and an author — and it is also the reason this
+ * exists: a file anyone can open is a file anyone can break, and until now
+ * nothing looked. `v: 2` was declared in the type and checked nowhere. A
+ * renamed column left its cards in a place that does not exist and they simply
+ * stopped being drawn; a missing `areas` rendered as a fault with no message.
+ *
+ * So the shape is checked at both ends. On the way in, so a panel with a
+ * broken board says which line is broken instead of showing an empty screen.
+ * On the way out, so a write that would break it is refused while the good
+ * copy is still the one in the repository — that is the only moment refusing
+ * is cheap.
+ *
+ * Two things this deliberately does not do. It does not repair: a board
+ * quietly corrected is a board whose owner never learns what they typed. And
+ * it does not judge content — an empty title, a card nobody will ever do, a
+ * question with no answer are all legitimate states of a real board.
+ */
+
+/**
+ * The shape this version of the kit reads.
+ *
+ * A board carrying an older number is not broken, it is old, and that is a
+ * different answer: `readBoard` reports it as something to migrate rather than
+ * something to fix.
+ */
+declare const BOARD_VERSION = 2;
+interface BoardProblem {
+    /** Where it is, in the shape a person can find in the file: `cards[3].column`. */
+    at: string;
+    /** What is wrong, as a sentence. */
+    says: string;
+}
+type BoardCheck = {
+    ok: true;
+    board: PanelState;
+    problems: [];
+}
+/** The shape is wrong. `problems` says where, and is never empty. */
+ | {
+    ok: false;
+    reason: 'shape';
+    problems: BoardProblem[];
+}
+/** The shape is right but written for a different version of the kit. */
+ | {
+    ok: false;
+    reason: 'version';
+    found: unknown;
+    expected: number;
+    problems: BoardProblem[];
+};
+/**
+ * Checks a parsed board.
+ *
+ * Every problem is collected rather than thrown at the first one: somebody
+ * fixing a file by hand wants the list, not one item of it at a time.
+ */
+declare function validateBoard(value: unknown): BoardCheck;
+/**
+ * Parses text and checks it, so a caller holding a file has one call.
+ *
+ * Invalid JSON is a shape problem like any other. It arrives with the parser's
+ * own message, which names the line — more useful than anything worth
+ * rewriting.
+ */
+declare function readBoard(text: string): BoardCheck;
+/** The problems as lines, for a log, an HTTP body or a screen. */
+declare function explainBoard(check: BoardCheck): string;
+/** Narrowing helper, so a caller can keep a `Card` without repeating the cast. */
+declare function isCard(value: unknown): value is Card;
+
+/**
+ * The identities a panel offers in its settings sheet.
+ *
+ * The site kept this as four parallel records — tokens, forms, labels, notes —
+ * keyed by the same name, which is four places to remember when a theme is
+ * added and four chances to add it to three of them. One record of objects
+ * cannot fall out of step with itself.
+ *
+ * A panel that passes none gets the kit's presets, so a project installs the
+ * panel and has something to switch between on the first session rather than a
+ * settings sheet with one entry.
+ */
+
+interface PanelTheme {
+    /** What the button says. Not translated: a name is a name. */
+    label: string;
+    tokens: DashboardThemeTokens;
+    /**
+     * The shape it is drawn in. Colour alone would make one identity another in
+     * a different hue; a form makes it a different object.
+     */
+    form?: DashboardThemeForm;
+    /** One line under the row, saying what this one is. */
+    note?: string;
+}
+type PanelThemes = Record<string, PanelTheme>;
+/** Every preset the kit ships, as a panel would offer them. */
+declare const PRESET_PANEL_THEMES: PanelThemes;
+
+/**
+ * What the panel shows for the dfklabs catalogue, and the three ways to
+ * install something from it.
+ *
+ * The snippets are built here rather than written into the markup so that the
+ * one a reader copies is generated from the same tool record the row above it
+ * was drawn from. A snippet typed out by hand next to a list is a snippet that
+ * names the wrong tool the first time a name changes.
+ */
+declare const MARKETPLACE_NAME = "dfklabs";
+declare const MARKETPLACE_URL = "https://studio.dfklabs.com/marketplace.json";
+/**
+ * Which marketplace a snippet names.
+ *
+ * Taken from the report rather than from the constants above, so the panel
+ * cannot tell someone to register one marketplace while showing them the
+ * contents of another — which is exactly what a hard-coded name does the first
+ * time the same screen is pointed somewhere else.
+ */
+interface Marketplace {
+    name: string;
+    url: string;
+}
+type InstallState = 'active' | 'disabled' | 'absent' | 'misconfigured' | 'unknown';
+type SettingsStatus = 'ok' | 'absent' | 'unparseable' | 'unreadable';
+interface MarketplaceTool {
+    id: string;
+    name: string;
+    summary: string | null;
+    repo: string | null;
+    homepage: string | null;
+    tags: string[];
+    claudePlugin: boolean;
+    standaloneCommand: string | null;
+    version: string | null;
+    versionError: string | null;
+    /** Null when the catalogue does not offer this as a plugin. */
+    state: InstallState | null;
+}
+interface MarketplaceReport {
+    marketplace: {
+        name: string;
+        url: string;
+    };
+    source: string;
+    fetchedAt: string;
+    ageSeconds: number;
+    /** True when this is the last good copy, served because a refresh failed. */
+    stale: boolean;
+    error: string | null;
+    /** True only when there is nothing at all to show. */
+    unavailable: boolean;
+    project: {
+        repo: string;
+        file: string;
+        settingsStatus: SettingsStatus;
+        marketplaceRegistered: boolean;
+        marketplaceUrl: string | null;
+        detail: string | null;
+    };
+    tools: MarketplaceTool[];
+}
+/**
+ * The two keys a repository needs, as JSON to merge into its settings.
+ *
+ * Merged, not pasted over: a project's settings file holds other things, and a
+ * snippet that replaces it is a snippet that quietly removes them. The panel
+ * says so beside the block, because the block itself cannot.
+ *
+ * The shape is the one a real Claude Code install writes — an object keyed by
+ * marketplace name, and a plugin key carrying the marketplace suffix — rather
+ * than the one the documentation describes. Written the documented way it
+ * parses, saves, and installs nothing.
+ */
+declare function repositorySnippet(toolId: string, marketplace?: Marketplace): string;
+/** The two commands, for Claude Code in a terminal or the desktop app. */
+declare function commandSnippet(toolId: string, marketplace?: Marketplace): string;
+
+declare function readStoredLang(fallback?: Lang): Lang;
+declare function storeLang(lang: Lang): void;
+interface UiStrings {
+    settings: string;
+    dismiss: string;
+    close: string;
+    all: string;
+    board: string;
+    analysis: string;
+    cardDetail: string;
+    panelSettings: string;
+    title: string;
+    titlePlaceholder: string;
+    untitled: string;
+    detail: string;
+    detailPlaceholder: string;
+    areaLabel: string;
+    priority: string;
+    risk: string;
+    riskHint: string;
+    levelHigh: string;
+    levelMedium: string;
+    levelLow: string;
+    dependsOn: string;
+    ownerClaude: string;
+    ownerYou: string;
+    orderTitle: string;
+    orderOn: string;
+    orderOff: string;
+    intentTitle: string;
+    intentHint: string;
+    intentNone: string;
+    checklist: string;
+    addStep: string;
+    addStepPlaceholder: string;
+    notes: string;
+    notePlaceholder: string;
+    leaveNote: string;
+    columnTitle: string;
+    started: string;
+    completed: string;
+    neverStarted: string;
+    deleteCard: string;
+    addCard: string;
+    untranslatedBadge: string;
+    filterForClaude: string;
+    filterYours: string;
+    filterHighRisk: string;
+    statOpen: string;
+    statOrders: string;
+    statYours: string;
+    statDecisions: string;
+    statHighRisk: string;
+    statDone: string;
+    theme: string;
+    themeSubtitle: string;
+    themeNote: string;
+    language: string;
+    languageSubtitle: string;
+    fingerprint: string;
+    fingerprintSubtitle: string;
+    trackedFiles: (count: number, version: string) => string;
+    notifications: string;
+    nothingNew: string;
+    markAllSeen: string;
+    unreadCount: (n: number) => string;
+    notifRun: (by: string) => string;
+    notifWaiting: string;
+    notifSuggestion: (area: string) => string;
+    help: string;
+    helpTitle: string;
+    setupReady: string;
+    setupOk: string;
+    setupMissing: string;
+    setupUnknown: string;
+    setupWhatToDo: string;
+    setupChecking: string;
+    setupWriteTarget: (repo: string, branch: string, file: string) => string;
+    needPassword: string;
+    needPasswordEnables: string;
+    needToken: string;
+    needTokenEnables: string;
+    needRepo: string;
+    needRepoEnables: string;
+    fixTokenCreate: string;
+    fixTokenScope: string;
+    fixTokenPaste: string;
+    fixTokenRedeploy: string;
+    fixRepo: string;
+    demoTourWelcomeTitle: string;
+    demoTourWelcomeBody: string;
+    demoTourBoardTitle: string;
+    demoTourBoardBody: string;
+    demoTourThemeTitle: string;
+    demoTourThemeBody: string;
+    demoTourKeepTitle: string;
+    demoTourKeepBody: string;
+    tourWelcomeTitle: string;
+    tourWelcomeBody: string;
+    tourBoardTitle: string;
+    tourBoardBody: string;
+    tourOrdersTitle: string;
+    tourOrdersBody: string;
+    tourSaveTitle: string;
+    tourSaveBody: string;
+    tourThemeTitle: string;
+    tourThemeBody: string;
+    gotIt: string;
+    showGuideAgain: string;
+    guideSection: string;
+    session: string;
+    sessionSubtitle: string;
+    signOut: string;
+    signingOut: string;
+    signOutFailed: string;
+    links: string;
+    home: string;
+    demo: string;
+    repository: string;
+    terms: string;
+    save: string;
+    saving: string;
+    savedAt: (time: string) => string;
+    savedWithCommit: string;
+    saveFailed: string;
+    saveConflict: string;
+    unsaved: string;
+    saveSection: string;
+    saveSubtitle: string;
+    saveHelp: string;
+    upToDate: string;
+    demoNotice: string;
+    historyEyebrow: string;
+    historyTitle: string;
+    historyIntro: string;
+    historyEmpty: string;
+    historyTouched: string;
+    analysisEyebrow: string;
+    briefTitle: string;
+    stage: string;
+    goalsTitle: string;
+    constraintsTitle: string;
+    constraintOn: string;
+    constraintOff: string;
+    weights: Record<'primary' | 'secondary' | 'off', string>;
+    metricsTitle: string;
+    metricsIntro: string;
+    metricWith: string;
+    metricAgainst: string;
+    strategiesTitle: string;
+    strategyOpenHint: string;
+    strategyChosenHint: string;
+    strategyChoose: string;
+    strategyChosen: string;
+    effort: string;
+    riskShort: string;
+    upside: string;
+    suggestionsTitle: string;
+    suggestionsIntro: string;
+    severities: Record<'high' | 'medium' | 'low', string>;
+    suggestionStatuses: Record<'new' | 'doing' | 'done' | 'dismissed', string>;
+    analysisSections: Record<AnalysisSection, string>;
+    analysisSectionHints: Record<AnalysisSection, string>;
+    analysisAnswered: (answered: number, total: number) => string;
+    analysisAllDecided: string;
+    choicesTitle: string;
+    choicesIntro: string;
+    choiceOpen: string;
+    choiceDecidedAt: (at: string) => string;
+    choiceReopen: string;
+    choicesNone: string;
+    claudeReadsTitle: string;
+    claudeReadsIntro: string;
+    claudeOpenTitle: string;
+    claudeOpenIntro: string;
+    boardFactsTitle: string;
+    boardFactsIntro: string;
+    factOpen: string;
+    factWaiting: string;
+    factOrders: string;
+    factHighRisk: string;
+    factOldest: string;
+    factDays: (n: number) => string;
+    factColumnsTitle: string;
+    factClaimedTitle: string;
+    factClaimedIntro: string;
+    factClaimedNone: string;
+    marketIntro: string;
+    marketEmpty: string;
+    audienceTitle: string;
+    positioningTitle: string;
+    competitorsTitle: string;
+    competitorStrength: string;
+    competitorGap: string;
+    pricingTitle: string;
+    marketNotesTitle: string;
+    importedTheme: string;
+    importedFrom: (at: string, files: string) => string;
+    importedRefresh: string;
+    importedRefreshAsked: (at: string) => string;
+    importedRefreshHow: string;
+    notifThemeRefresh: string;
+    marketplace: string;
+    marketplaceEyebrow: string;
+    marketplaceTitle: string;
+    marketplaceIntro: string;
+    marketplaceSource: (url: string) => string;
+    refresh: string;
+    refreshing: string;
+    readAt: (age: string) => string;
+    catalogueStale: (age: string) => string;
+    catalogueUnavailable: string;
+    catalogueFailed: string;
+    catalogueLoading: string;
+    catalogueEmpty: string;
+    stateFrom: (repo: string, file: string) => string;
+    settingsAbsent: string;
+    settingsUnreadable: string;
+    settingsUnparseable: string;
+    filterPlugins: string;
+    filterActive: string;
+    filterStandalone: string;
+    installStates: Record<InstallState, string>;
+    stateMisconfiguredWhy: string;
+    toolCommandOnly: string;
+    versionUnknown: string;
+    runIt: string;
+    install: string;
+    howToRun: string;
+    learnMore: string;
+    copy: string;
+    copied: string;
+    copySelected: string;
+    installTitle: string;
+    installRepoTitle: string;
+    installRepoHint: string;
+    installRepoMerge: string;
+    installRepoMergeRegistered: string;
+    installCliTitle: string;
+    installCliHint: string;
+    installStandaloneTitle: string;
+    installStandaloneHint: string;
+    installNoStandalone: string;
+    installNoPlugin: string;
+    brandEyebrow: string;
+    logosTitle: string;
+    logosIntro: string;
+    functionsEyebrow: string;
+    functionsTitle: string;
+    functionsIntro: string;
+}
+declare const UI: Record<Lang, UiStrings>;
+
+/**
+ * The Functions section of the panel: what the kit can do for a project
+ * today, and how to wire Claude to it so that keeping the panel current
+ * costs as few tokens as possible. Bilingual, because it is read from the
+ * private panel.
+ */
+interface Capability {
+    id: string;
+    title: Text;
+    summary: Text;
+    points: Text[];
+    code?: {
+        caption: Text;
+        body: string;
+    };
+}
+declare const CAPABILITIES: Capability[];
+
+interface PanelAppProps {
+    state: PanelState;
+    /**
+     * The identities the settings sheet offers. Defaults to the kit's presets,
+     * so a panel has something to switch between on its first session.
+     */
+    themes?: PanelThemes;
+    /** Which one to draw before the board has said. Defaults to the first. */
+    defaultTheme?: string;
+    /**
+     * What sits where a name goes in the header.
+     *
+     * A string by default — this project's own name, which is what a board
+     * belongs to. A caller with a wordmark passes it here; the kit has no
+     * business drawing anybody's mark, including its own.
+     */
+    brand?: React.ReactNode;
+    /** Rendered inside the theme provider, behind everything: a caller's screen effects. */
+    decoration?: React.ReactNode;
+    /** Put on the theme root, so a caller's stylesheet has something to hang on. */
+    className?: string;
+    /** Rendered under the panel. A caller's footer, or nothing. */
+    footer?: React.ReactNode;
+    /** The Links section of the settings sheet. Omitted when there are none. */
+    links?: {
+        label: string;
+        href: string;
+    }[];
+    /**
+     * The Functions section: what the kit does and how an agent should use it.
+     * Pass a list to show it, or leave it out and the section is not drawn.
+     * `CAPABILITIES` is the kit's own, which is what most panels want.
+     */
+    capabilities?: Capability[];
+    /** An extra section of the caller's own, drawn above Functions. */
+    extras?: React.ReactNode;
+    /** Language switch. The public pages stay in English; the panel does not. */
+    showLanguage?: boolean;
+    /** The revision log: one entry per session, newest first. */
+    showHistory?: boolean;
+    /** Endpoint that commits the board back to the repository, when there is one. */
+    saveEndpoint?: string;
+    /**
+     * Endpoint that assembles the dfklabs catalogue server-side. Present only
+     * where there is a server and a session — the demo is handed a fixed
+     * catalogue instead, so the screen exists in both without the public one
+     * reaching for an endpoint it cannot call.
+     */
+    marketplaceEndpoint?: string;
+    /** A ready-made report, for a panel with no server to ask. */
+    marketplaceReport?: MarketplaceReport;
+    fingerprint?: {
+        version: string;
+        hash: string;
+        fileCount: number;
+    };
+}
+declare function PanelApp({ state: initialState, themes, defaultTheme, brand, decoration, className, footer, links, capabilities, extras, showLanguage, showHistory, saveEndpoint, marketplaceEndpoint, marketplaceReport, fingerprint, }: PanelAppProps): React.JSX.Element;
+
+/**
+ * Applies a board move to the flat card list.
+ *
+ * The board can be filtered, so `toIndex` counts visible cards only. Dropping
+ * on the third visible card must not reorder the hidden ones: the move is
+ * anchored to the visible card it lands before, and the rest of the column
+ * keeps its relative order.
+ */
+declare function applyMove(cards: Card[], move: BoardMoveResult, visible: Card[]): Card[];
+
+interface AnalysisViewProps {
+    analysis: Analysis;
+    /** The cards themselves: the Board screen counts them rather than trusting a stored number. */
+    cards: Card[];
+    columns: ColumnDef[];
+    today: string;
+    lang: Lang;
+    ui: UiStrings;
+    onChooseStrategy: (id: string) => void;
+    onSuggestionStatus: (id: string, status: SuggestionStatus) => void;
+    onDecide: (section: AnalysisSection, choiceId: string, optionId: string | null) => void;
+    /** Opening the card a fact is about, so a number is never a dead end. */
+    onOpenCard?: (id: string) => void;
+}
+declare function AnalysisView({ analysis, cards, columns, today, lang, ui, onChooseStrategy, onSuggestionStatus, onDecide, onOpenCard, }: AnalysisViewProps): React.JSX.Element;
+
+interface MarketplaceViewProps {
+    /** Null while the catalogue is still being asked for. */
+    report: MarketplaceReport | null;
+    loading: boolean;
+    /** Set when the panel could not reach its own server. */
+    failure: string | null;
+    lang: Lang;
+    ui: UiStrings;
+    /** Absent where there is no server to ask, so no dead button is drawn. */
+    onRefresh?: () => void;
+}
+declare function MarketplaceView({ report, loading, failure, lang, ui, onRefresh }: MarketplaceViewProps): React.JSX.Element;
+
+interface CardSheetProps {
+    card: Card | null;
+    state: PanelState;
+    lang: Lang;
+    ui: UiStrings;
+    onChange: (card: Card) => void;
+    onDelete: (id: string) => void;
+    onClose: () => void;
+}
+declare function CardSheet({ card, state, lang, ui, onChange, onDelete, onClose }: CardSheetProps): React.JSX.Element | null;
+
+export { ANALYSIS_SECTIONS, AlertBanner, type AlertBannerProps, type Analysis, type AnalysisSection, AnalysisView, BOARD_VERSION, Board, type BoardCardData, type BoardCheck, type BoardColumnData, type BoardFacts, type BoardMoveResult, type BoardProblem, type BoardProps, type BoardTag, CAPABILITIES, type Capability, Card$1 as Card, type CardProps, CardSheet, type Check, type Choice, type ChoiceOption, type ColumnDef, type Competitor, type Constraint, CopyBlock, type CopyBlockLabels, type CopyBlockProps, type Counts, DashboardHeader, type DashboardHeaderProps, type DashboardThemeForm, DashboardThemeProvider, type DashboardThemeTokens, DetailSection, type DetailSectionProps, DetailSheet, type DetailSheetProps, FilterChip, type FilterChipProps, FilterChipRow, type Goal, GuideNote, type GuideNoteProps, GuideTour, type GuideTourProps, type HealthFact, HealthPill, type HealthPillProps, HealthPillRow, type HealthStatus, INTENTS, INTENT_COPY, type ImportedTheme, type InstallState, type Intent, type IntentCopy, LANGS, LANG_LABELS, LEVELS, type Lang, type Level, MARKETPLACE_NAME, MARKETPLACE_URL, type Market, type MarketplaceReport, type MarketplaceTool, MarketplaceView, type Metric, type Note, NotificationBell, type NotificationBellProps, type NotificationLabels, type NotificationTone, OWNERS, type Owner, PANELTIR_FILE_COUNT, PANELTIR_FINGERPRINT, PANELTIR_VERSION, PRESET_PANEL_THEMES, PanelApp, type PanelAppProps, type Card as PanelCard, type PanelNotification, type PanelState, type PanelTheme, type PanelThemes, type Preferences, type Reading, type Run, SetupGuide, type SetupGuideProps, type SetupRequirement, type SetupStatus, type Severity, StatTile, StatTileGrid, type StatTileProps, type Strategy, type Suggestion, type SuggestionStatus, THEME_FORMS, THEME_PRESETS, type Text, type ThemeFormName, type ThemePresetName, type Trend, UI, type UiStrings, type Weight, applyMove, boardFacts, checkProgress, claimedWithoutStarting, claudeTheme, commandSnippet, countCards, cyberpunkTheme, decided, emptyCard, explainBoard, isCard, ledgerForm, midnightTheme, moveCardInColumns, newId, oldMoneyTheme, panelForm, paneltirBuild, paperForm, readBoard, readStoredLang, repositorySnippet, resetGuide, sparkPoints, stampForColumn, storeLang, text, today, trendOf, undecided, untranslated, useDashboardForm, useDashboardTheme, useDelegatedClick, useGuideNote, useMediaQuery, validateBoard, writeText };