@haruhimemoe/ui 0.6.0 → 0.8.0

package/dist/components/palette/hotkeys.d.ts

@@ -0,0 +1,57 @@
+/**
+ * @file src/components/palette/hotkeys.ts
+ * @desc Shortcut text ("mod+k", "?", a chord "g p") parsed, matched against keydown events and
+ *       shown as kbd parts. `mod` is Command on a Mac (platform.ts decides) and Control
+ *       elsewhere. A chord is two bare keys in a row; CommandPalette times it. Editable targets
+ *       (fields, contenteditable, a dialog that isn't the palette) never fire command shortcuts.
+ *       Pure: no directive, so server-safe files (PaletteRow) can import it.
+ * @author David @dvhsh (https://dvh.sh)
+ * @created Sat Oct 3, 2026
+ * @modified Sat Oct 3, 2026
+ */
+/** A key with modifiers. `key` is lower-case, compared to `event.key`. */
+export type Combo = {
+    key: string;
+    mod: boolean;
+    shift: boolean;
+    alt: boolean;
+    ctrl: boolean;
+    meta: boolean;
+};
+/** A combo, or a chord of two bare keys pressed in turn. */
+export type Shortcut = {
+    kind: "combo";
+    combo: Combo;
+} | {
+    kind: "chord";
+    keys: readonly [string, string];
+};
+/**
+ * @function parseShortcut
+ * @param text {string} "mod+shift+c", "?" or "g p"
+ * @returns {Shortcut | null} the parsed shortcut, or null for text that isn't one
+ */
+export declare function parseShortcut(text: string): Shortcut | null;
+/**
+ * @function matchesCombo
+ * @param event {KeyboardEvent} a keydown
+ * @param combo {Combo} the parsed combo
+ * @param mac {boolean} whether `mod` means Meta
+ * @returns {boolean} true when the key and the exact modifier set match. Shift is not required
+ *          for a symbol key such as "?", which needs it on most layouts.
+ */
+export declare function matchesCombo(event: KeyboardEvent, combo: Combo, mac: boolean): boolean;
+/**
+ * @function isEditableTarget
+ * @param target {EventTarget | null} the keydown's target
+ * @returns {boolean} true inside an input, textarea, select, contenteditable, or a `<dialog>`
+ *          without `data-palette`
+ */
+export declare function isEditableTarget(target: EventTarget | null): boolean;
+/**
+ * @function displayShortcut
+ * @param shortcut {Shortcut} a parsed shortcut
+ * @param mac {boolean} symbols (⌘ ⇧ ⌥ ⌃) on a Mac, words elsewhere
+ * @returns {string[]} one entry per `<kbd>`, in order
+ */
+export declare function displayShortcut(shortcut: Shortcut, mac: boolean): string[];

package/dist/components/palette/hotkeys.js

@@ -0,0 +1,111 @@
+/**
+ * @file src/components/palette/hotkeys.ts
+ * @desc Shortcut text ("mod+k", "?", a chord "g p") parsed, matched against keydown events and
+ *       shown as kbd parts. `mod` is Command on a Mac (platform.ts decides) and Control
+ *       elsewhere. A chord is two bare keys in a row; CommandPalette times it. Editable targets
+ *       (fields, contenteditable, a dialog that isn't the palette) never fire command shortcuts.
+ *       Pure: no directive, so server-safe files (PaletteRow) can import it.
+ * @author David @dvhsh (https://dvh.sh)
+ * @created Sat Oct 3, 2026
+ * @modified Sat Oct 3, 2026
+ */
+const MODIFIERS = new Set(["mod", "shift", "alt", "ctrl", "meta"]);
+/**
+ * @function parseShortcut
+ * @param text {string} "mod+shift+c", "?" or "g p"
+ * @returns {Shortcut | null} the parsed shortcut, or null for text that isn't one
+ */
+export function parseShortcut(text) {
+    const trimmed = text.trim().toLowerCase();
+    if (trimmed.length === 0)
+        return null;
+    const chord = trimmed.split(/\s+/);
+    if (chord.length === 2 && chord.every((k) => k.length === 1)) {
+        return { kind: "chord", keys: [chord[0], chord[1]] };
+    }
+    if (chord.length !== 1)
+        return null;
+    const parts = trimmed.split("+");
+    const key = parts.pop();
+    if (!key || parts.some((part) => !MODIFIERS.has(part)))
+        return null;
+    const has = (name) => parts.includes(name);
+    return {
+        kind: "combo",
+        combo: {
+            key,
+            mod: has("mod"),
+            shift: has("shift"),
+            alt: has("alt"),
+            ctrl: has("ctrl"),
+            meta: has("meta"),
+        },
+    };
+}
+const isLetterOrDigit = (key) => /^[a-z0-9]$/i.test(key);
+/**
+ * @function matchesCombo
+ * @param event {KeyboardEvent} a keydown
+ * @param combo {Combo} the parsed combo
+ * @param mac {boolean} whether `mod` means Meta
+ * @returns {boolean} true when the key and the exact modifier set match. Shift is not required
+ *          for a symbol key such as "?", which needs it on most layouts.
+ */
+export function matchesCombo(event, combo, mac) {
+    if (event.key.toLowerCase() !== combo.key)
+        return false;
+    const wantMeta = combo.meta || (combo.mod && mac);
+    const wantCtrl = combo.ctrl || (combo.mod && !mac);
+    if (event.metaKey !== wantMeta || event.ctrlKey !== wantCtrl || event.altKey !== combo.alt)
+        return false;
+    if (combo.key.length === 1 && !isLetterOrDigit(combo.key) && !combo.shift)
+        return true;
+    return event.shiftKey === combo.shift;
+}
+/**
+ * @function isEditableTarget
+ * @param target {EventTarget | null} the keydown's target
+ * @returns {boolean} true inside an input, textarea, select, contenteditable, or a `<dialog>`
+ *          without `data-palette`
+ */
+export function isEditableTarget(target) {
+    if (!(target instanceof Element))
+        return false;
+    const tag = target.tagName;
+    if (tag === "INPUT" || tag === "TEXTAREA" || tag === "SELECT")
+        return true;
+    if (target instanceof HTMLElement && target.isContentEditable)
+        return true;
+    const dialog = target.closest("dialog");
+    return dialog !== null && !dialog.hasAttribute("data-palette");
+}
+const KEY_NAMES = {
+    arrowup: "↑",
+    arrowdown: "↓",
+    enter: "↵",
+    escape: "Esc",
+    backspace: "⌫",
+};
+/**
+ * @function displayShortcut
+ * @param shortcut {Shortcut} a parsed shortcut
+ * @param mac {boolean} symbols (⌘ ⇧ ⌥ ⌃) on a Mac, words elsewhere
+ * @returns {string[]} one entry per `<kbd>`, in order
+ */
+export function displayShortcut(shortcut, mac) {
+    const name = (key) => KEY_NAMES[key] ?? key.toUpperCase();
+    if (shortcut.kind === "chord")
+        return shortcut.keys.map(name);
+    const { combo } = shortcut;
+    const parts = [];
+    if (combo.ctrl || (combo.mod && !mac))
+        parts.push(mac ? "⌃" : "Ctrl");
+    if (combo.alt)
+        parts.push(mac ? "⌥" : "Alt");
+    if (combo.shift)
+        parts.push(mac ? "⇧" : "Shift");
+    if (combo.meta || (combo.mod && mac))
+        parts.push(mac ? "⌘" : "Win");
+    parts.push(name(combo.key));
+    return parts;
+}

package/dist/components/palette/paletteEvents.d.ts

@@ -0,0 +1,22 @@
+/**
+ * @file src/components/palette/paletteEvents.ts
+ * @desc How anything opens the mounted CommandPalette without a context provider: a CustomEvent
+ *       on window that the palette listens for. `CommandPaletteButton` and app code call
+ *       `openCommandPalette`, optionally with a page to open onto.
+ * @author David @dvhsh (https://dvh.sh)
+ * @created Sat Oct 3, 2026
+ * @modified Sat Oct 3, 2026
+ */
+import type { Page } from "./types.js";
+/** The event name CommandPalette listens for on window. */
+export declare const PALETTE_EVENT = "haruhime:palette";
+/** The event's detail. */
+export type PaletteEventDetail = {
+    page?: Page | undefined;
+};
+/**
+ * @function openCommandPalette
+ * @param page {Page} a page to open straight onto, above the root
+ * @returns {void}
+ */
+export declare function openCommandPalette(page?: Page): void;

package/dist/components/palette/paletteEvents.js

@@ -0,0 +1,22 @@
+/**
+ * @file src/components/palette/paletteEvents.ts
+ * @desc How anything opens the mounted CommandPalette without a context provider: a CustomEvent
+ *       on window that the palette listens for. `CommandPaletteButton` and app code call
+ *       `openCommandPalette`, optionally with a page to open onto.
+ * @author David @dvhsh (https://dvh.sh)
+ * @created Sat Oct 3, 2026
+ * @modified Sat Oct 3, 2026
+ */
+"use client";
+/** The event name CommandPalette listens for on window. */
+export const PALETTE_EVENT = "haruhime:palette";
+/**
+ * @function openCommandPalette
+ * @param page {Page} a page to open straight onto, above the root
+ * @returns {void}
+ */
+export function openCommandPalette(page) {
+    if (typeof window === "undefined")
+        return;
+    window.dispatchEvent(new CustomEvent(PALETTE_EVENT, { detail: { page } }));
+}

package/dist/components/palette/platform.d.ts

@@ -0,0 +1,13 @@
+/**
+ * @file src/components/palette/platform.ts
+ * @desc Whether this is a Mac, so `mod` means Command and hints say ⌘. Client-only (reads
+ *       navigator); the palette and its button call it after mount.
+ * @author David @dvhsh (https://dvh.sh)
+ * @created Sat Oct 3, 2026
+ * @modified Sat Oct 3, 2026
+ */
+/**
+ * @function isMac
+ * @returns {boolean} true on macOS, from `userAgentData.platform` or `navigator.platform`
+ */
+export declare function isMac(): boolean;

package/dist/components/palette/platform.js

@@ -0,0 +1,21 @@
+/**
+ * @file src/components/palette/platform.ts
+ * @desc Whether this is a Mac, so `mod` means Command and hints say ⌘. Client-only (reads
+ *       navigator); the palette and its button call it after mount.
+ * @author David @dvhsh (https://dvh.sh)
+ * @created Sat Oct 3, 2026
+ * @modified Sat Oct 3, 2026
+ */
+"use client";
+/**
+ * @function isMac
+ * @returns {boolean} true on macOS, from `userAgentData.platform` or `navigator.platform`
+ */
+export function isMac() {
+    if (typeof navigator === "undefined")
+        return false;
+    const data = navigator.userAgentData;
+    if (data?.platform)
+        return data.platform === "macOS";
+    return /^Mac/.test(navigator.platform ?? "");
+}

package/dist/components/palette/recents.d.ts

@@ -0,0 +1,48 @@
+/**
+ * @file src/components/palette/recents.ts
+ * @desc Which commands get used, in localStorage under "haruhime:palette:<key>": run count and
+ *       last-use time per command id, pruned to the 50 most recent. Every read and write is
+ *       guarded, so a blocked or full store means no recents, never an error.
+ * @author David @dvhsh (https://dvh.sh)
+ * @created Sat Oct 3, 2026
+ * @modified Sat Oct 3, 2026
+ */
+/** Per command id: how many runs and when the last one was (ms since epoch). */
+export type Recents = Record<string, {
+    n: number;
+    t: number;
+}>;
+/**
+ * @function storageKeyFor
+ * @param key {string} the app's namespace (CommandPalette's `storageKey`)
+ * @returns {string} the localStorage key
+ */
+export declare const storageKeyFor: (key: string) => string;
+/**
+ * @function readRecents
+ * @param key {string} the app's namespace
+ * @returns {Recents} the stored recents, dropping entries that aren't `{ n, t }`; empty when
+ *          storage is missing, throws, or holds something that isn't JSON
+ */
+export declare function readRecents(key: string): Recents;
+/**
+ * @function recordRecent
+ * @param key {string} the app's namespace
+ * @param id {string} the command that ran
+ * @param now {number} the time, default Date.now()
+ * @returns {Recents} the recents after the write (empty when storage is unavailable)
+ */
+export declare function recordRecent(key: string, id: string, now?: number): Recents;
+/**
+ * @function recentIds
+ * @param recents {Recents} the stored recents
+ * @param limit {number} how many, default 5
+ * @returns {string[]} ids by last use, newest first
+ */
+export declare const recentIds: (recents: Recents, limit?: number) => string[];
+/**
+ * @function boostFrom
+ * @param recents {Recents} the stored recents
+ * @returns {(id: string) => number} the run count per id, 0 for unknown ids (rankResults' boost)
+ */
+export declare const boostFrom: (recents: Recents) => (id: string) => number;

package/dist/components/palette/recents.js

@@ -0,0 +1,85 @@
+/**
+ * @file src/components/palette/recents.ts
+ * @desc Which commands get used, in localStorage under "haruhime:palette:<key>": run count and
+ *       last-use time per command id, pruned to the 50 most recent. Every read and write is
+ *       guarded, so a blocked or full store means no recents, never an error.
+ * @author David @dvhsh (https://dvh.sh)
+ * @created Sat Oct 3, 2026
+ * @modified Sat Oct 3, 2026
+ */
+const LIMIT = 50;
+/**
+ * @function storageKeyFor
+ * @param key {string} the app's namespace (CommandPalette's `storageKey`)
+ * @returns {string} the localStorage key
+ */
+export const storageKeyFor = (key) => `haruhime:palette:${key}`;
+const isEntry = (value) => typeof value === "object" &&
+    value !== null &&
+    typeof value.n === "number" &&
+    typeof value.t === "number";
+/**
+ * @function readRecents
+ * @param key {string} the app's namespace
+ * @returns {Recents} the stored recents, dropping entries that aren't `{ n, t }`; empty when
+ *          storage is missing, throws, or holds something that isn't JSON
+ */
+export function readRecents(key) {
+    try {
+        const raw = localStorage.getItem(storageKeyFor(key));
+        if (!raw)
+            return {};
+        const parsed = JSON.parse(raw);
+        if (typeof parsed !== "object" || parsed === null)
+            return {};
+        return Object.fromEntries(Object.entries(parsed).filter(([, value]) => isEntry(value)));
+    }
+    catch {
+        return {};
+    }
+}
+/**
+ * @function recordRecent
+ * @param key {string} the app's namespace
+ * @param id {string} the command that ran
+ * @param now {number} the time, default Date.now()
+ * @returns {Recents} the recents after the write (empty when storage is unavailable)
+ */
+export function recordRecent(key, id, now = Date.now()) {
+    // Storage that can't be read is treated as absent: nothing is written over it either.
+    try {
+        localStorage.getItem(storageKeyFor(key));
+    }
+    catch {
+        return {};
+    }
+    const recents = readRecents(key);
+    const entry = recents[id];
+    recents[id] = { n: (entry?.n ?? 0) + 1, t: now };
+    const kept = Object.fromEntries(Object.entries(recents)
+        .sort(([, a], [, b]) => b.t - a.t)
+        .slice(0, LIMIT));
+    try {
+        localStorage.setItem(storageKeyFor(key), JSON.stringify(kept));
+        return kept;
+    }
+    catch {
+        return {};
+    }
+}
+/**
+ * @function recentIds
+ * @param recents {Recents} the stored recents
+ * @param limit {number} how many, default 5
+ * @returns {string[]} ids by last use, newest first
+ */
+export const recentIds = (recents, limit = 5) => Object.entries(recents)
+    .sort(([, a], [, b]) => b.t - a.t)
+    .slice(0, limit)
+    .map(([id]) => id);
+/**
+ * @function boostFrom
+ * @param recents {Recents} the stored recents
+ * @returns {(id: string) => number} the run count per id, 0 for unknown ids (rankResults' boost)
+ */
+export const boostFrom = (recents) => (id) => recents[id]?.n ?? 0;

package/dist/components/palette/rows.d.ts

@@ -0,0 +1,63 @@
+/**
+ * @file src/components/palette/rows.ts
+ * @desc What the list shows for a state, pure: option rows (a command under a group heading,
+ *       with the title's matched spans) and hint rows (not selectable: provider states, no
+ *       matches). Empty query: Recent, then every group in declaration order. A query: the
+ *       calculator row at the root, the ranked static matches, then each provider's rows or its
+ *       state. In a choice prompt: the choices, fuzzy-filtered.
+ * @author David @dvhsh (https://dvh.sh)
+ * @created Sat Oct 3, 2026
+ * @modified Sat Oct 3, 2026
+ */
+import { type FuzzyMatch } from "./fuzzy.js";
+import type { ArgState, ProviderResult } from "./store.js";
+import type { Command, PaletteContext, Provider } from "./types.js";
+/** One list entry. Options are selectable; hints are text. */
+export type Row = {
+    kind: "option";
+    id: string;
+    command: Command;
+    ranges: FuzzyMatch["ranges"];
+    group: string;
+} | {
+    kind: "hint";
+    id: string;
+    text: string;
+};
+/** What buildRows needs from the palette. */
+export type RowsInput = {
+    query: string;
+    commands: readonly Command[];
+    providers: readonly Provider[];
+    providerResults: Record<string, ProviderResult>;
+    recentIds: readonly string[];
+    boost: (id: string) => number;
+    isRoot: boolean;
+    calculator: boolean;
+    arg: ArgState | null;
+    ctx: PaletteContext;
+};
+/** The id of the calculator's row and command. */
+export declare const CALC_ID = "calc";
+/**
+ * @function buildRows
+ * @param input {RowsInput} the query, commands, providers and their results, recents, and the
+ *        argument prompt in progress
+ * @returns {Row[]} the list, top to bottom
+ */
+export declare function buildRows(input: RowsInput): Row[];
+/**
+ * @function optionCount
+ * @param rows {readonly Row[]} the list
+ * @returns {number} how many rows can be selected
+ */
+export declare const optionCount: (rows: readonly Row[]) => number;
+/**
+ * @function optionAt
+ * @param rows {readonly Row[]} the list
+ * @param index {number} the active index, counting options only
+ * @returns {Extract<Row, { kind: "option" }> | undefined} that option
+ */
+export declare const optionAt: (rows: readonly Row[], index: number) => Extract<Row, {
+    kind: "option";
+}> | undefined;

package/dist/components/palette/rows.js

@@ -0,0 +1,136 @@
+/**
+ * @file src/components/palette/rows.ts
+ * @desc What the list shows for a state, pure: option rows (a command under a group heading,
+ *       with the title's matched spans) and hint rows (not selectable: provider states, no
+ *       matches). Empty query: Recent, then every group in declaration order. A query: the
+ *       calculator row at the root, the ranked static matches, then each provider's rows or its
+ *       state. In a choice prompt: the choices, fuzzy-filtered.
+ * @author David @dvhsh (https://dvh.sh)
+ * @created Sat Oct 3, 2026
+ * @modified Sat Oct 3, 2026
+ */
+import { evaluate, formatResult, isBareNumber } from "./calc.js";
+import { rankResults } from "./fuzzy.js";
+/** The id of the calculator's row and command. */
+export const CALC_ID = "calc";
+const DEFAULT_GROUP = "Commands";
+const DEFAULT_MIN = 2;
+const option = (command, group, ranges = [], prefix = "") => ({
+    kind: "option",
+    id: `${prefix}${group}/${command.id}`,
+    command,
+    ranges,
+    group,
+});
+const hint = (text, scope = "") => ({
+    kind: "hint",
+    id: `hint:${scope}${text}`,
+    text,
+});
+const visible = (commands, ctx) => commands.filter((command) => {
+    if (!command.when)
+        return true;
+    try {
+        return command.when(ctx);
+    }
+    catch (error) {
+        console.error(`CommandPalette: "${command.id}" when() threw`, error);
+        return false;
+    }
+});
+const choiceRows = (arg) => {
+    const spec = arg.command.args?.[arg.index];
+    if (spec?.type !== "choice")
+        return [];
+    const group = spec.label;
+    const rows = (spec.choices ?? []).map((choice) => ({
+        id: choice.value,
+        title: choice.label,
+        subtitle: choice.subtitle,
+    }));
+    if (arg.query.trim() === "")
+        return rows.map((row) => option(row, group));
+    return rankResults(arg.query, rows, () => 0).map((scored) => option(scored.command, group, scored.ranges));
+};
+// A bare word ("e", "pi") is a search, not a sum, even though the calculator knows it.
+const BARE_WORD = /^[a-z]+$/i;
+const calcRow = (query) => {
+    if (isBareNumber(query) || BARE_WORD.test(query))
+        return null;
+    const value = evaluate(query);
+    if (value === null)
+        return null;
+    const text = formatResult(value);
+    const command = {
+        id: CALC_ID,
+        title: `= ${text}`,
+        subtitle: "Enter to copy",
+        closeOnRun: false,
+        run: (ctx) => ctx.copy(text),
+    };
+    return option(command, "Calculator");
+};
+const providerRows = (input) => input.providers.flatMap((provider) => {
+    const group = provider.group ?? "Results";
+    const min = provider.minLength ?? DEFAULT_MIN;
+    const scope = `${provider.id}:`;
+    if (input.query.trim().length < min)
+        return [hint(`Type ${min} characters to search`, scope)];
+    const result = input.providerResults[provider.id];
+    const rows = (result?.rows ?? []).map((command) => option(command, group, [], scope));
+    // Searching: the last rows stay under the hint, so the list doesn't flash per keystroke.
+    if (!result || result.state === "loading")
+        return [hint("Searching…", scope), ...rows];
+    if (result.state === "error")
+        return [hint("Couldn't search, try again", scope)];
+    if (rows.length === 0)
+        return [hint(`No results for “${input.query.trim()}”`, scope)];
+    return rows;
+});
+/**
+ * @function buildRows
+ * @param input {RowsInput} the query, commands, providers and their results, recents, and the
+ *        argument prompt in progress
+ * @returns {Row[]} the list, top to bottom
+ */
+export function buildRows(input) {
+    if (input.arg)
+        return choiceRows(input.arg);
+    const commands = visible(input.commands, input.ctx);
+    const query = input.query.trim();
+    if (query === "") {
+        const recent = input.recentIds
+            .map((id) => commands.find((command) => command.id === id))
+            .filter((command) => command !== undefined)
+            .map((command) => option(command, "Recent", [], "recent:"));
+        return [
+            ...recent,
+            ...commands.map((command) => option(command, command.group ?? DEFAULT_GROUP)),
+        ];
+    }
+    const rows = [];
+    const calc = input.isRoot && input.calculator ? calcRow(query) : null;
+    if (calc)
+        rows.push(calc);
+    for (const scored of rankResults(query, commands, input.boost)) {
+        rows.push(option(scored.command, scored.command.group ?? DEFAULT_GROUP, scored.ranges));
+    }
+    rows.push(...providerRows(input));
+    if (!rows.some((row) => row.kind === "option") && input.providers.length === 0) {
+        rows.push(hint("No matching commands"));
+    }
+    return rows;
+}
+/**
+ * @function optionCount
+ * @param rows {readonly Row[]} the list
+ * @returns {number} how many rows can be selected
+ */
+export const optionCount = (rows) => rows.filter((row) => row.kind === "option").length;
+/**
+ * @function optionAt
+ * @param rows {readonly Row[]} the list
+ * @param index {number} the active index, counting options only
+ * @returns {Extract<Row, { kind: "option" }> | undefined} that option
+ */
+export const optionAt = (rows, index) => rows.filter((row) => row.kind === "option")[index];

package/dist/components/palette/siteCommands.d.ts

@@ -0,0 +1,38 @@
+/**
+ * @file src/components/palette/siteCommands.ts
+ * @desc The default command set every tool gets: "Go to <page>" from the nav items, "Open
+ *       <tool>" from HARUHIME_TOOLS, page actions (copy URL, back, top, reload, GitHub), account
+ *       (sign in, my account, sign out by signedIn), and help (the shortcuts page, report a bug).
+ *       Ids are stable ("site.copy-url") so recents survive relabeling. Client-only: it opens
+ *       tabs and scrolls.
+ * @author David @dvhsh (https://dvh.sh)
+ * @created Sat Oct 3, 2026
+ * @modified Sat Oct 3, 2026
+ */
+import { type HaruhimeToolId } from "../shell/haruhimeTools.js";
+import type { SiteLinkItem } from "../shell/links.js";
+import type { Command } from "./types.js";
+/** Which default groups to build and what they need. */
+export type SiteCommandsOptions = {
+    /** The nav items the app passes to SiteHeader; one "Go to <label>" per linked item. */
+    pages?: readonly SiteLinkItem[] | undefined;
+    /** "Open <tool>" for every other live tool plus haruhime.moe. The current tool is skipped. false leaves them out. */
+    tools?: HaruhimeToolId | false | undefined;
+    /** The app's repo URL: "Open on GitHub" and "Report a bug". */
+    repo?: string | undefined;
+    account?: {
+        signedIn: boolean;
+        signInHref: string;
+        accountHref?: string | undefined;
+        /** Navigated, not fetched (next-kit's sign-out route). */
+        signOutHref?: string | undefined;
+    } | undefined;
+    /** Default: every group. */
+    include?: readonly ("navigate" | "page" | "account" | "help")[] | undefined;
+};
+/**
+ * @function siteCommands
+ * @param options {SiteCommandsOptions} pages, tools, repo, account and which groups to include
+ * @returns {Command[]} the defaults in order: Navigate, Page, Account, Help
+ */
+export declare function siteCommands(options?: SiteCommandsOptions): Command[];