loop-task 1.1.0 → 1.3.0

package/README.md

@@ -1,87 +1,151 @@
+<div align="center">
+
 # loop-task
 
-A cross-platform CLI that repeatedly executes a shell command at a human-readable interval.
+**Run commands on repeat. Manage them from a terminal board.**
+
+`loop-task` is a cross-platform CLI that runs shell commands at human-readable intervals. Create loops in the background, manage them from an interactive TUI board, or run them in the foreground.
+
+[![npm version](https://img.shields.io/npm/v/loop-task?style=flat-square&color=black)](https://www.npmjs.com/package/loop-task)
+[![npm downloads](https://img.shields.io/npm/dm/loop-task?style=flat-square&color=black)](https://www.npmjs.com/package/loop-task)
+[![license](https://img.shields.io/npm/l/loop-task?style=flat-square&color=black)](./LICENSE)
+[![node](https://img.shields.io/node/v/loop-task?style=flat-square&color=black)](https://nodejs.org)
 
-Inspired by agent loops, but intentionally simple.
+</div>
 
-## Installation
+## Quick start
 
 ```bash
 npm install -g loop-task
+loop-task                          # open the board (requires Bun)
+loop-task start                    # start the daemon, restore persisted loops
+loop-task new 30m -- npm test      # create a background loop
+loop-task run --now 10s -- echo hi # run a loop in the foreground
 ```
 
-Or use directly with npx:
+Or run it directly:
 
 ```bash
-npx loop-task 30m npm test
+npx loop-task
+npx loop-task new 30m -- npm test
 ```
 
-## Usage
+## Requirements
 
-```bash
-loop-task [options] <interval> <command>
-```
+- **Node.js >= 20** — required for all commands
+- **Bun >= 1.2** — required for the interactive board only
 
-### Basic examples
+Install Bun:
 
 ```bash
-loop-task 30m npm test
-loop-task 1h opencode --prompt '/ob-init'
-loop-task 1d node sync.js
+npm install -g bun
 ```
 
-### With npx
+`start`, `new`, and `run` work with Node alone. The board auto-delegates to Bun when needed.
 
-```bash
-npx loop-task 30m npm test
-npx loop-task 1h opencode --prompt '/ob-init'
-```
+## Commands
 
-### Options
+| Command | Description |
+| ------- | ----------- |
+| `loop-task` | Open the interactive board (requires Bun) |
+| `loop-task start` | Start the background daemon, restore persisted loops |
+| `loop-task new <interval> -- <command>` | Create a background loop |
+| `loop-task run <interval> -- <command>` | Run a loop in the foreground |
 
-Options must come before the interval:
+### Options (for `new` and `run`)
 
-| Option            | Description                      |
-| ----------------- | -------------------------------- |
-| `--now`           | Run immediately before waiting   |
-| `--max-runs <n>`  | Stop after N executions          |
-| `--verbose`       | Show execution details           |
-| `-h, --help`      | Display help                     |
-| `-V, --version`   | Display version                  |
+| Option | Description |
+| ------ | ----------- |
+| `--now` | Run immediately before waiting |
+| `--max-runs <n>` | Stop after N executions |
+| `--cwd <dir>` | Working directory for the command |
+| `--verbose` | Show execution details |
+| `-h, --help` | Display help |
+| `-V, --version` | Display version |
 
 ## Examples
 
-### Agent workflows
-
 ```bash
-npx loop-task 30m --now -- opencode run "search for missing translation text and translate them, 3 maximum" --model "opencode/big-pickle"
-```
+# Run tests every 30 minutes
+loop-task new 30m -- npm test
 
-### Run tests every 30 minutes
+# Run immediately, then every hour
+loop-task new --now 1h -- npm test
 
-```bash
-loop-task 30m npm test
+# Run up to 5 times, then stop
+loop-task run --max-runs 5 5m -- npm test
+
+# Agent workflow — schedule an AI task every 30 minutes
+loop-task new 30m --now -- opencode run "find and fix lint issues"
+
+# Run in a specific directory
+loop-task new 30m --cwd ./packages/api -- npm test
+
+# Verbose mode
+loop-task run --verbose 30m -- npm test
 ```
 
-### Run immediately, then every hour
+When the command has its own flags, use `--` to stop argument parsing:
 
 ```bash
-loop-task --now 1h npm test
+loop-task new 30m -- node -e "console.log('hello')"
 ```
 
-### Run up to 5 times then stop
+## The board
 
-```bash
-loop-task --max-runs 5 5m npm test
+The board is the primary way to manage loops. It shows all loops, their status, run history, and logs in a single terminal interface.
+
+### Board controls
+
+```
+↑/↓, j/k    move selection
+Enter       edit selected loop
+n           create a new loop
+p           pause / resume selected loop
+r           force run selected loop now
+del         delete selected loop
+/           search loops
+f           cycle status filter
+s           cycle sort mode
+←/→         switch between panels
+h           toggle help
+Esc         quit
 ```
 
-### Verbose mode
+Destructive actions (pause, force run, delete) prompt a confirmation before executing.
+
+### Loop fields
+
+When creating or editing a loop:
+
+| Field | Description |
+| ----- | ----------- |
+| **Interval** | How often to run (`30s`, `5m`, `1h`, `1d`, `1w`) |
+| **Command** | The full command line |
+| **Description** | Optional label shown in the list; defaults to the command |
+| **Working dir** | Directory the command runs in; defaults to current directory |
+| **Run immediately?** | Run once now, then every interval, or wait the first interval |
+| **Max runs** | Stop after N runs, or leave blank to run forever |
+
+## How it works
 
-```bash
-loop-task --verbose 30m npm test
 ```
+loop-task (board) ──IPC──► daemon ──► loop 1 (background process)
+                          ├──► loop 2
+                          └──► loop 3
+```
+
+- The **daemon** is a background process that manages all loops. It starts automatically when you run `loop-task start` or any command that needs it.
+- The **board** is a terminal UI that connects to the daemon via IPC.
+- Loops **persist to disk** — they survive daemon restarts and system reboots. When the daemon starts, it restores all loops and accounts for elapsed time.
 
-Shows start/end timestamps, exit code, execution duration, and next scheduled run.
+### Lifecycle
+
+1. `loop-task start` or `loop-task new ...` spawns the daemon if not running
+2. The daemon creates a loop and persists its state to disk
+3. `loop-task` opens the board for interactive management
+4. Closing the board or terminal does **not** stop loops — the daemon keeps running
+5. After a reboot, `loop-task start` restores all persisted loops with correct timing
 
 ## Supported intervals
 
@@ -95,17 +159,35 @@ Shows start/end timestamps, exit code, execution duration, and next scheduled ru
 
 ## Behavior
 
-- **No overlapping**: waits for the command to finish before starting the next interval
-- **Resilient**: continues looping even if a command exits with a non-zero code
-- **Graceful shutdown**: finishes current execution on Ctrl+C, then exits cleanly
+- **No overlapping** — waits for the command to finish before starting the next interval
+- **Resilient** — continues looping even if a command exits with a non-zero code
+- **Persistent** — loop state is saved after every run; survives restarts
+- **Graceful shutdown** — background loops are daemon-managed; foreground loops finish the current execution on Ctrl+C
 
 ## Development
 
+Requires [Bun](https://bun.sh) >= 1.2 for package management and the board, and [Node.js](https://nodejs.org) >= 20 for the CLI and daemon.
+
+```bash
+bun install
+npm run build
+```
+
+Run locally:
+
+```bash
+bun run dev                                    # board
+node dist/entry.js new --now 30m -- npm test   # background loop
+node dist/entry.js run --now --max-runs 1 10s -- echo hello  # foreground
+```
+
+Quality gates:
+
 ```bash
-pnpm install
-pnpm run build
-pnpm run test
-pnpm run lint
+bun run typecheck
+bun run lint
+bun run test
+npm run build
 ```
 
 ## License

package/dist/board/App.js

@@ -0,0 +1,202 @@
+import { jsx as _jsx, jsxs as _jsxs } from "@opentui/react/jsx-runtime";
+import { useMemo, useRef, useState } from "react";
+import { applyLoopFilters, cycleSortMode, cycleStatusFilter, defaultFilters, } from "./state.js";
+import { ToastStack, useToasts } from "./toast.js";
+import { t } from "../i18n/index.js";
+import { useLoopPolling } from "./hooks/useLoopPolling.js";
+import { useLogStream } from "./hooks/useLogStream.js";
+import { useBoardKeybindings } from "./hooks/useBoardKeybindings.js";
+import { Header } from "./components/Header.js";
+import { FilterBar } from "./components/FilterBar.js";
+import { Navigator } from "./components/Navigator.js";
+import { Inspector } from "./components/Inspector.js";
+import { RunHistory } from "./components/RunHistory.js";
+import { ActionButtons } from "./components/ActionButtons.js";
+import { HelpModal } from "./components/HelpModal.js";
+import { Footer } from "./components/Footer.js";
+import { ConfirmModal } from "./components/ConfirmModal.js";
+import { CreateView, createInitialValues } from "./components/CreateForm.js";
+import { LogModal } from "./components/LogModal.js";
+import { fetchRunLog, deleteLoop, pauseLoop, resumeLoop, triggerLoop } from "./daemon.js";
+import { useBreakpoint } from "./hooks/useBreakpoint.js";
+const BOARD_REFRESH_DELAY_MS = 150;
+export function App(props) {
+    const { loops, daemonStatus, refresh } = useLoopPolling();
+    const [view, setView] = useState("board");
+    const [filters, setFilters] = useState(defaultFilters);
+    const [sort, setSort] = useState("description");
+    const [selectedIndex, setSelectedIndex] = useState(0);
+    const [searchActive, setSearchActive] = useState(false);
+    const [helpOpen, setHelpOpen] = useState(false);
+    const [confirm, setConfirm] = useState(null);
+    const [confirmChoice, setConfirmChoice] = useState(0);
+    const [editTarget, setEditTarget] = useState(null);
+    const [selectedRunIndex, setSelectedRunIndex] = useState(0);
+    const [selectedAction, setSelectedAction] = useState(0);
+    const [focusedPanel, setFocusedPanel] = useState("loops");
+    const [logModalRun, setLogModalRun] = useState(null);
+    const [logModalLines, setLogModalLines] = useState([]);
+    const [logModalLoading, setLogModalLoading] = useState(false);
+    const { toasts, push } = useToasts();
+    const breakpoint = useBreakpoint();
+    const visible = useMemo(() => applyLoopFilters(loops, filters, sort), [loops, filters, sort]);
+    const clampedIndex = Math.min(selectedIndex, Math.max(0, visible.length - 1));
+    const selected = visible[clampedIndex] ?? null;
+    const selectedId = selected?.id ?? null;
+    const prevSelectedId = useRef(null);
+    if (selectedId !== prevSelectedId.current) {
+        prevSelectedId.current = selectedId;
+        setSelectedRunIndex(0);
+    }
+    const { destroy: destroyLogSocket } = useLogStream(selectedId, view, (error) => push("error", t("board.logStreamError", { message: error.message })));
+    function runAction(label, action) {
+        return async () => {
+            try {
+                await action();
+                setTimeout(() => {
+                    void refresh();
+                }, BOARD_REFRESH_DELAY_MS);
+                push("success", label);
+            }
+            catch (error) {
+                push("error", error instanceof Error ? error.message : String(error));
+            }
+        };
+    }
+    function handleOpenRunLog(run) {
+        if (!selectedId)
+            return;
+        setLogModalRun(run);
+        setLogModalLoading(true);
+        setLogModalLines([]);
+        fetchRunLog(selectedId, run.runNumber)
+            .then((log) => {
+            setLogModalLines(log ? log.split("\n") : []);
+            setLogModalLoading(false);
+        })
+            .catch(() => {
+            setLogModalLines([]);
+            setLogModalLoading(false);
+        });
+    }
+    function handleAction(action) {
+        if (!selected || !selectedId)
+            return;
+        switch (action) {
+            case "pause-resume": {
+                const actionLabel = selected.status === "paused" ? t("board.actionResume") : t("board.actionPause");
+                const actionVerb = selected.status === "paused" ? t("board.actionResumed") : t("board.actionPaused");
+                const actionFn = selected.status === "paused"
+                    ? () => resumeLoop(selectedId)
+                    : () => pauseLoop(selectedId);
+                setConfirmChoice(0);
+                setConfirm({
+                    message: t("board.confirmPauseResume", { action: actionLabel, id: selectedId }),
+                    action: runAction(t("board.toastActionId", { verb: actionVerb, id: selectedId }), actionFn),
+                });
+                break;
+            }
+            case "run": {
+                setConfirmChoice(0);
+                setConfirm({
+                    message: t("board.confirmForceRun", { id: selectedId }),
+                    action: runAction(t("board.toastTriggered", { id: selectedId }), () => triggerLoop(selectedId)),
+                });
+                break;
+            }
+            case "edit": {
+                setEditTarget(selected);
+                setView("create");
+                break;
+            }
+            case "delete": {
+                setConfirmChoice(0);
+                setConfirm({
+                    message: t("board.confirmDelete", { id: selectedId }),
+                    action: runAction(t("board.toastDeleted", { id: selectedId }), () => deleteLoop(selectedId)),
+                });
+                break;
+            }
+        }
+    }
+    useBoardKeybindings({
+        confirm,
+        confirmChoice,
+        setConfirm,
+        setConfirmChoice,
+        helpOpen,
+        setHelpOpen,
+        searchActive,
+        setSearchActive,
+        view,
+        setView,
+        setEditTarget,
+        selected,
+        visibleCount: visible.length,
+        setSelectedIndex,
+        setFilters,
+        setSort,
+        onQuit: props.onQuit,
+        destroyLogSocket,
+        logModalRun,
+        setLogModalRun,
+        selectedRunIndex,
+        setSelectedRunIndex,
+        selectedRunCount: selected?.runHistory?.length ?? 0,
+        focusedPanel,
+        setFocusedPanel,
+        selectedAction,
+        setSelectedAction,
+        onAction: handleAction,
+        onOpenRunLog: handleOpenRunLog,
+    });
+    const counts = {
+        total: loops.length,
+        running: loops.filter((l) => l.status === "running").length,
+        waiting: loops.filter((l) => l.status === "waiting").length,
+        paused: loops.filter((l) => l.status === "paused").length,
+    };
+    const mode = confirm
+        ? "confirm"
+        : searchActive
+            ? "search"
+            : helpOpen
+                ? "help"
+                : view === "create"
+                    ? "create"
+                    : "normal";
+    return (_jsxs("box", { style: { flexDirection: "column", width: "100%", height: "100%", backgroundColor: "#0b0b0b" }, children: [_jsx(Header, { daemonStatus: daemonStatus, counts: counts }), view === "board" ? (_jsx(FilterBar, { filters: filters, sort: sort, searchActive: searchActive, focusedPanel: focusedPanel, onSearch: (q) => {
+                    setFilters((prev) => ({ ...prev, query: q }));
+                    setSelectedIndex(0);
+                }, onStatusCycle: () => setFilters((prev) => ({ ...prev, status: cycleStatusFilter(prev.status) })), onSortCycle: () => setSort(cycleSortMode(sort)), onNewLoop: () => {
+                    setEditTarget(null);
+                    setView("create");
+                } })) : null, _jsx("box", { style: { flexGrow: 1, backgroundColor: "#0b0b0b" }, children: view === "create" ? (_jsx(CreateView, { mode: editTarget ? "edit" : "create", editId: editTarget?.id ?? null, initial: createInitialValues(editTarget), onCancel: () => {
+                        setEditTarget(null);
+                        setView("board");
+                    }, onDone: (updated, id) => {
+                        setEditTarget(null);
+                        setView("board");
+                        push("success", updated ? t("board.toastUpdated", { id }) : t("board.toastStarted", { id }));
+                        setTimeout(() => {
+                            void refresh();
+                        }, BOARD_REFRESH_DELAY_MS);
+                    } })) : (_jsxs("box", { style: { flexDirection: breakpoint === "narrow" ? "column" : "row", flexGrow: 1, backgroundColor: "#0b0b0b" }, children: [_jsx(Navigator, { visible: visible, total: loops.length, selectedIndex: clampedIndex, filters: filters, sort: sort, breakpoint: breakpoint, focused: focusedPanel === "loops", onSelect: (index) => {
+                                setSelectedIndex(index);
+                                setFocusedPanel("loops");
+                            }, onActivate: (index) => {
+                                setSelectedIndex(index);
+                                const loop = visible[index];
+                                if (loop) {
+                                    setEditTarget(loop);
+                                    setView("create");
+                                }
+                            } }, `nav-${visible.length}-${visible[0]?.id ?? ""}`), _jsxs("box", { style: { flexDirection: "column", flexGrow: 1, backgroundColor: "#0b0b0b", overflow: "hidden" }, children: [_jsx(Inspector, { loop: selected }, `insp-${selected?.id}-${selected?.status}`), _jsx(RunHistory, { loop: selected, selectedRunIndex: selectedRunIndex, focused: focusedPanel === "runs", onSelectRun: (index) => {
+                                        setSelectedRunIndex(index);
+                                        setFocusedPanel("runs");
+                                    }, onOpenRun: handleOpenRunLog }, `rh-${selected?.id}-${selected?.runHistory?.length ?? 0}`), _jsx(ActionButtons, { loop: selected, focused: focusedPanel === "actions", selectedAction: selectedAction, onAction: handleAction }, `ab-${selected?.id}`)] })] })) }, view === "create" ? `${view}:${editTarget?.id ?? "new"}` : view), _jsx(Footer, { mode: mode }), confirm ? (_jsx(ConfirmModal, { message: confirm.message, choice: confirmChoice, onYes: () => {
+                    const action = confirm.action;
+                    setConfirm(null);
+                    void action();
+                }, onNo: () => setConfirm(null) })) : null, helpOpen ? _jsx(HelpModal, {}) : null, logModalRun ? (_jsx(LogModal, { run: logModalRun, logLines: logModalLines, loading: logModalLoading, onClose: () => setLogModalRun(null) })) : null, _jsx(ToastStack, { toasts: toasts })] }));
+}

package/dist/board/board-log.js

@@ -0,0 +1,18 @@
+import fs from "node:fs";
+import { getBoardLogFile, getDataDir } from "../config/paths.js";
+function formatError(error) {
+    if (error instanceof Error) {
+        return error.stack ?? `${error.name}: ${error.message}`;
+    }
+    return typeof error === "string" ? error : JSON.stringify(error);
+}
+export function boardLog(message, error) {
+    try {
+        fs.mkdirSync(getDataDir(), { recursive: true });
+        const suffix = error === undefined ? "" : `\n${formatError(error)}\n`;
+        fs.appendFileSync(getBoardLogFile(), `${new Date().toISOString()} ${message}${suffix}`);
+    }
+    catch {
+        // best effort crash logging only
+    }
+}

package/dist/board/components/ActionButtons.js

@@ -0,0 +1,25 @@
+import { jsx as _jsx } from "@opentui/react/jsx-runtime";
+import { t } from "../../i18n/index.js";
+import { useHoverState } from "../hooks/useHoverState.js";
+import { HOVER_BG } from "../../config/constants.js";
+export function ActionButtons(props) {
+    const { loop, focused, selectedAction, onAction } = props;
+    if (!loop) {
+        return (_jsx("box", { border: true, borderColor: focused ? "#38bdf8" : undefined, style: { flexDirection: "row", height: 3, flexShrink: 0, backgroundColor: "#0b0b0b", justifyContent: "center", alignItems: "center" }, children: _jsx("text", { fg: "#9ca3af", children: t("board.noActions") }) }));
+    }
+    const isPaused = loop.status === "paused";
+    const pauseResumeLabel = isPaused ? t("board.actionResume") : t("board.actionPause");
+    const actions = [
+        { key: "pause-resume", label: pauseResumeLabel },
+        { key: "run", label: t("board.actionRun") },
+        { key: "edit", label: t("board.actionEdit") },
+        { key: "delete", label: t("board.actionDelete") },
+    ];
+    return (_jsx("box", { border: true, borderColor: focused ? "#38bdf8" : undefined, style: { flexDirection: "row", height: 3, flexShrink: 0, paddingLeft: 1, backgroundColor: "#0b0b0b", alignItems: "center" }, children: actions.map((action, i) => (_jsx(ActionButton, { label: action.label, selected: focused && selectedAction === i, onMouseDown: () => onAction(action.key) }, action.key))) }));
+}
+function ActionButton(props) {
+    const { isHovered, hoverProps } = useHoverState();
+    const bg = props.selected ? "#1e3a8a" : isHovered ? HOVER_BG : undefined;
+    const fg = props.selected ? "#ffffff" : isHovered ? "#e5e7eb" : "#9ca3af";
+    return (_jsx("box", { onMouseDown: props.onMouseDown, style: { backgroundColor: bg, paddingLeft: 1, paddingRight: 1, marginRight: 1 }, ...hoverProps, children: _jsx("text", { fg: fg, children: _jsx("strong", { children: props.label }) }) }));
+}

package/dist/board/components/BoardButton.js

@@ -0,0 +1,58 @@
+import { jsx as _jsx } from "@opentui/react/jsx-runtime";
+import { useHoverState } from "../hooks/useHoverState.js";
+const PRIMARY_REST = "#1e3a5f";
+const PRIMARY_HOVER = "#2a4f7a";
+const PRIMARY_FOCUSED = "#1e3a8a";
+const DEFAULT_HOVER = "#334155";
+const DEFAULT_FOCUSED = "#374151";
+export function BoardButton(props) {
+    const { label, onMouseDown, focused, variant = "default", marginRight } = props;
+    const { isHovered, hoverProps } = useHoverState();
+    let bg;
+    const fg = "#e5e7eb";
+    let border;
+    if (variant === "primary") {
+        if (focused) {
+            bg = PRIMARY_FOCUSED;
+            border = "#38bdf8";
+        }
+        else if (isHovered) {
+            bg = PRIMARY_HOVER;
+        }
+        else {
+            bg = PRIMARY_REST;
+        }
+    }
+    else if (variant === "danger") {
+        if (focused) {
+            bg = "#7f1d1d";
+            border = "#f87171";
+        }
+        else if (isHovered) {
+            bg = "#7f1d1d";
+        }
+        else {
+            bg = "#0b0b0b";
+        }
+    }
+    else {
+        if (focused) {
+            bg = DEFAULT_FOCUSED;
+            border = "#38bdf8";
+        }
+        else if (isHovered) {
+            bg = DEFAULT_HOVER;
+        }
+        else {
+            bg = "#0b0b0b";
+        }
+    }
+    return (_jsx("box", { border: true, onMouseDown: onMouseDown, borderColor: border, style: {
+            paddingLeft: 2,
+            paddingRight: 2,
+            marginRight,
+            backgroundColor: bg,
+            justifyContent: "center",
+            alignItems: "center",
+        }, ...hoverProps, children: _jsx("text", { fg: fg, children: _jsx("strong", { children: label }) }) }));
+}

package/dist/board/components/ConfirmModal.js

@@ -0,0 +1,36 @@
+import { jsx as _jsx, jsxs as _jsxs } from "@opentui/react/jsx-runtime";
+import { useTerminalDimensions } from "@opentui/react";
+import { t } from "../../i18n/index.js";
+import { useHoverState } from "../hooks/useHoverState.js";
+import { HOVER_BG } from "../../config/constants.js";
+export function ConfirmModal(props) {
+    const { message, choice, onYes, onNo } = props;
+    const { width } = useTerminalDimensions();
+    return (_jsx("box", { style: {
+            position: "absolute",
+            top: 0,
+            left: 0,
+            width: "100%",
+            height: "100%",
+            justifyContent: "center",
+            alignItems: "center",
+            zIndex: 100,
+        }, children: _jsxs("box", { title: t("board.confirmTitle"), border: true, style: {
+                flexDirection: "column",
+                padding: 1,
+                minWidth: Math.min(44, width - 4),
+                backgroundColor: "#111827",
+            }, children: [_jsx("text", { children: message }), _jsx("text", { children: " " }), _jsxs("box", { style: { flexDirection: "row", justifyContent: "center" }, children: [_jsx(ConfirmButton, { label: t("board.yes"), onMouseDown: onYes, selected: choice === 1, width: 12, marginRight: 1 }), _jsx(ConfirmButton, { label: t("board.no"), onMouseDown: onNo, selected: choice === 0, width: 12 })] })] }) }));
+}
+function ConfirmButton(props) {
+    const { isHovered, hoverProps } = useHoverState();
+    const bg = props.selected ? "#1e3a8a" : isHovered ? HOVER_BG : undefined;
+    const borderColor = props.selected ? "#38bdf8" : undefined;
+    return (_jsx("box", { border: true, onMouseDown: props.onMouseDown, borderColor: borderColor, style: {
+            width: props.width,
+            backgroundColor: bg,
+            justifyContent: "center",
+            alignItems: "center",
+            marginRight: props.marginRight,
+        }, ...hoverProps, children: _jsx("text", { fg: "#e5e7eb", children: _jsx("strong", { children: props.label }) }) }));
+}