nucleus-core-ts 0.9.781 → 0.9.783

package/dist/fe/components/IntegrationsPage/components/RunHistoryRow.js

@@ -0,0 +1,129 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useEffect, useEffectEvent, useState } from 'react';
+import { cn } from '../../../utils/cn';
+import { useIntegrationsStore } from '../store';
+import { integrationsPageTheme } from '../theme';
+import { Badge } from './Primitives';
+import { RunRevertConflicts } from './RunRevertConflicts';
+import { countersLine, errorText, formatDuration, formatMoment, RUN_STATUS_TONE, toEpochMs } from './runFormat';
+/**
+ * One past run, and the one thing an operator can still do to it.
+ *
+ * Undo is offered only while the pre-images behind it still exist; once they are
+ * gone the button stays visible but disabled, with the reason spelled out, because
+ * a button that quietly disappears reads as a bug rather than as an expiry.
+ */ const theme = integrationsPageTheme;
+export function RunHistoryRow({ run, actions, onReverted }) {
+    const store = useIntegrationsStore();
+    const [reverting, setReverting] = useState(false);
+    const [conflicts, setConflicts] = useState(null);
+    const [conflictMessage, setConflictMessage] = useState('');
+    // Read after mount, never during render: `Date.now()` on the server and in the
+    // browser are different numbers, and the disabled state would tear on hydration.
+    const [nowMs, setNowMs] = useState(0);
+    const readClock = useEffectEvent(()=>{
+        setNowMs(Date.now());
+    });
+    useEffect(()=>{
+        readClock();
+    }, []);
+    const expiresAt = toEpochMs(run.preImagesExpireAt);
+    const clockRead = nowMs > 0;
+    const undoable = run.status === 'succeeded';
+    const withinWindow = clockRead && expiresAt !== null && expiresAt > nowMs;
+    const blockedReason = expiresAt === null ? 'This run kept no pre-images, so there is no earlier state to restore.' : 'This run is too old to undo — the earlier state of the rows it changed has been cleaned up.';
+    const reportedTotal = run.sourceReportedTotal;
+    const mismatch = reportedTotal !== null && reportedTotal !== undefined && reportedTotal !== run.totalFetched;
+    const revert = (force)=>{
+        store.setError(null);
+        setReverting(true);
+        actions.revertRun(run.id, force).then((result)=>{
+            setReverting(false);
+            if (result.ok) {
+                setConflicts(null);
+                onReverted();
+                return;
+            }
+            const found = result.conflicts ?? [];
+            if (found.length > 0) {
+                setConflicts(found);
+                setConflictMessage(result.message);
+                return;
+            }
+            store.setError(result.message);
+        }).catch((error)=>{
+            setReverting(false);
+            store.setError(errorText(error, 'The run could not be undone.'));
+        });
+    };
+    return /*#__PURE__*/ _jsxs("li", {
+        className: cn(theme.card.wrapper, 'flex flex-col gap-2 p-3'),
+        children: [
+            /*#__PURE__*/ _jsxs("div", {
+                className: "flex flex-wrap items-center gap-2",
+                children: [
+                    /*#__PURE__*/ _jsx(Badge, {
+                        tone: RUN_STATUS_TONE[run.status],
+                        children: run.status
+                    }),
+                    /*#__PURE__*/ _jsx("span", {
+                        className: theme.card.title,
+                        children: run.targetEntity ?? 'unknown target'
+                    }),
+                    run.writeMode ? /*#__PURE__*/ _jsx(Badge, {
+                        tone: "neutral",
+                        children: run.writeMode
+                    }) : null,
+                    run.trigger ? /*#__PURE__*/ _jsx(Badge, {
+                        tone: "neutral",
+                        children: run.trigger
+                    }) : null,
+                    mismatch ? /*#__PURE__*/ _jsx(Badge, {
+                        tone: "warning",
+                        children: `read ${run.totalFetched} of ${reportedTotal}`
+                    }) : null
+                ]
+            }),
+            /*#__PURE__*/ _jsx("p", {
+                className: theme.field.hint,
+                children: countersLine(run)
+            }),
+            /*#__PURE__*/ _jsx("p", {
+                className: theme.field.hint,
+                children: `${formatMoment(run.startedAt ?? run.createdAt)} · took ${formatDuration(run.startedAt, run.finishedAt)} · ${run.totalFetched} fetched`
+            }),
+            undoable ? /*#__PURE__*/ _jsxs("div", {
+                className: "flex flex-wrap items-center gap-2",
+                children: [
+                    /*#__PURE__*/ _jsx("button", {
+                        className: theme.button.secondary,
+                        disabled: !withinWindow || reverting,
+                        onClick: ()=>revert(false),
+                        type: "button",
+                        children: reverting ? 'Undoing…' : 'Undo'
+                    }),
+                    withinWindow ? /*#__PURE__*/ _jsx("span", {
+                        className: theme.field.hint,
+                        children: `Can be undone until ${formatMoment(run.preImagesExpireAt)}`
+                    }) : null,
+                    clockRead && !withinWindow ? /*#__PURE__*/ _jsx("span", {
+                        className: theme.field.hint,
+                        children: blockedReason
+                    }) : null
+                ]
+            }) : null,
+            run.revertedAt ? /*#__PURE__*/ _jsx("p", {
+                className: theme.field.hint,
+                children: `Undone at ${formatMoment(run.revertedAt)}`
+            }) : null,
+            conflicts ? /*#__PURE__*/ _jsx(RunRevertConflicts, {
+                conflicts: conflicts,
+                message: conflictMessage,
+                onDismiss: ()=>setConflicts(null),
+                onOverwrite: ()=>revert(true),
+                working: reverting
+            }) : null
+        ]
+    });
+}

package/dist/fe/components/IntegrationsPage/components/RunPanel.d.ts

@@ -0,0 +1,9 @@
+import type { IntegrationMapping, IntegrationsActions, RunProgressValue } from '../types';
+export type RunPanelProps = {
+    mapping: IntegrationMapping;
+    actions: IntegrationsActions;
+    onSubscribeProgress?: (handler: (progress: RunProgressValue) => void) => () => void;
+    /** Called when a run reaches its end, so the history beneath can refetch. */
+    onRunSettled?: () => void;
+};
+export declare function RunPanel({ mapping, actions, onSubscribeProgress, onRunSettled }: RunPanelProps): import("react/jsx-runtime").JSX.Element;

package/dist/fe/components/IntegrationsPage/components/RunPanel.js

@@ -0,0 +1,160 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useEffect, useEffectEvent, useState } from 'react';
+import { useIntegrationsStore } from '../store';
+import { integrationsPageTheme } from '../theme';
+import { Notice } from './Primitives';
+import { RunConfirmStep } from './RunConfirmStep';
+import { RunPlanSummary } from './RunPlanSummary';
+import { RunProgressBar } from './RunProgressBar';
+import { describeLosses, errorText } from './runFormat';
+import { StatGridSkeleton } from './Skeletons';
+/**
+ * Preview, then run.
+ *
+ * The two are separate on purpose: a preview writes nothing and can be repeated,
+ * and the counts it reports are what the confirmation step later quotes back. The
+ * panel owns no data of its own — the plan, the progress and the active run all
+ * live in the store, so a tab switch cannot lose a running import.
+ */ const theme = integrationsPageTheme;
+export function RunPanel({ mapping, actions, onSubscribeProgress, onRunSettled }) {
+    const store = useIntegrationsStore();
+    const [confirming, setConfirming] = useState(false);
+    const [starting, setStarting] = useState(false);
+    const [cancelling, setCancelling] = useState(false);
+    const activeRunId = store.activeRunId;
+    const plan = store.plan;
+    const preview = ()=>{
+        store.setError(null);
+        store.setPlanning(true);
+        actions.previewRun(mapping.id).then((result)=>{
+            if (result.error) store.setError(result.error);
+            store.setPlan(result.plan);
+        }).catch((error)=>{
+            store.setPlanning(false);
+            store.setError(errorText(error, 'The preview could not be computed.'));
+        });
+    };
+    const start = (confirm)=>{
+        store.setError(null);
+        setStarting(true);
+        actions.startRun(mapping.id, confirm).then((result)=>{
+            setStarting(false);
+            // The server decides what counts as destructive; the panel only asks.
+            if (result.needsConfirm) {
+                setConfirming(true);
+                return;
+            }
+            if (result.error) {
+                store.setError(result.error);
+                return;
+            }
+            if (!result.runId) {
+                store.setError('The import was accepted but no run id came back, so it cannot be tracked.');
+                return;
+            }
+            setConfirming(false);
+            store.setActiveRun(result.runId);
+        }).catch((error)=>{
+            setStarting(false);
+            store.setError(errorText(error, 'The import could not be started.'));
+        });
+    };
+    const cancel = ()=>{
+        const runId = store.activeRunId;
+        if (!runId) return;
+        setCancelling(true);
+        actions.cancelRun(runId).then((accepted)=>{
+            setCancelling(false);
+            if (!accepted) store.setError('The run did not accept the cancel request.');
+        }).catch((error)=>{
+            setCancelling(false);
+            store.setError(errorText(error, 'The cancel request failed.'));
+        });
+    };
+    // Progress for SOMEONE ELSE'S run is dropped: the topic is shared, and a
+    // second operator's import must not drive this panel's bar.
+    const applyProgress = useEffectEvent((progress)=>{
+        if (store.activeRunId !== progress.runId) return;
+        store.setProgress(progress);
+        if (progress.phase === 'done') {
+            store.setActiveRun(null);
+            onRunSettled?.();
+        }
+    });
+    const openProgressStream = useEffectEvent(()=>onSubscribeProgress?.(applyProgress));
+    useEffect(()=>{
+        // The app hands back its own unsubscribe; returning it is the cleanup.
+        const close = openProgressStream();
+        return close;
+    }, []);
+    return /*#__PURE__*/ _jsxs("section", {
+        className: theme.card.wrapper,
+        children: [
+            /*#__PURE__*/ _jsxs("header", {
+                className: theme.card.header,
+                children: [
+                    /*#__PURE__*/ _jsxs("div", {
+                        className: "flex min-w-0 flex-col gap-0.5",
+                        children: [
+                            /*#__PURE__*/ _jsx("h3", {
+                                className: theme.card.title,
+                                children: mapping.name
+                            }),
+                            /*#__PURE__*/ _jsx("p", {
+                                className: theme.field.hint,
+                                children: `Writes into ${mapping.targetEntity} · ${mapping.writeMode} · missing rows: ${mapping.missingRecordPolicy}`
+                            })
+                        ]
+                    }),
+                    /*#__PURE__*/ _jsxs("div", {
+                        className: theme.header.actions,
+                        children: [
+                            /*#__PURE__*/ _jsx("button", {
+                                className: theme.button.secondary,
+                                disabled: store.planning || activeRunId !== null,
+                                onClick: preview,
+                                type: "button",
+                                children: store.planning ? 'Previewing…' : 'Preview'
+                            }),
+                            /*#__PURE__*/ _jsx("button", {
+                                className: theme.button.primary,
+                                disabled: starting || confirming || activeRunId !== null,
+                                onClick: ()=>start(false),
+                                type: "button",
+                                children: starting ? 'Starting…' : 'Run import'
+                            })
+                        ]
+                    })
+                ]
+            }),
+            /*#__PURE__*/ _jsxs("div", {
+                className: theme.card.body,
+                children: [
+                    activeRunId ? /*#__PURE__*/ _jsx(RunProgressBar, {
+                        cancelling: cancelling,
+                        onCancel: cancel,
+                        progress: store.progress,
+                        runId: activeRunId
+                    }) : null,
+                    confirming ? /*#__PURE__*/ _jsx(RunConfirmStep, {
+                        counted: plan !== null,
+                        lines: describeLosses(mapping, plan),
+                        onConfirm: ()=>start(true),
+                        onDismiss: ()=>setConfirming(false),
+                        working: starting
+                    }) : null,
+                    store.planning ? /*#__PURE__*/ _jsx(StatGridSkeleton, {}) : null,
+                    !store.planning && plan ? /*#__PURE__*/ _jsx(RunPlanSummary, {
+                        plan: plan
+                    }) : null,
+                    !(store.planning || plan || activeRunId) ? /*#__PURE__*/ _jsx(Notice, {
+                        tone: "info",
+                        title: "Preview before you run",
+                        children: "A preview reads the source without writing anything, and reports how many rows would be created, updated, skipped, and how many rows in the target the source no longer returns."
+                    }) : null
+                ]
+            })
+        ]
+    });
+}

package/dist/fe/components/IntegrationsPage/components/RunPlanIssues.d.ts

@@ -0,0 +1,5 @@
+import type { RunIssueValue } from '../types';
+export type RunPlanIssuesProps = {
+    issues: RunIssueValue[];
+};
+export declare function RunPlanIssues({ issues }: RunPlanIssuesProps): import("react/jsx-runtime").JSX.Element | null;

package/dist/fe/components/IntegrationsPage/components/RunPlanIssues.js

@@ -0,0 +1,43 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { cn } from '../../../utils/cn';
+import { integrationsPageTheme } from '../theme';
+/**
+ * The records the planner could not use, folded away.
+ *
+ * Folded because a healthy plan has none and an unhealthy one can have hundreds;
+ * open because the source index is the only way back to the offending record.
+ * Messages wrap rather than truncate — a clipped reason is a reason nobody acts on.
+ */ const theme = integrationsPageTheme;
+export function RunPlanIssues({ issues }) {
+    if (issues.length === 0) return null;
+    return /*#__PURE__*/ _jsxs("details", {
+        className: cn(theme.card.wrapper, 'px-3 py-2.5 sm:px-4 sm:py-3'),
+        children: [
+            /*#__PURE__*/ _jsx("summary", {
+                className: cn(theme.card.title, 'cursor-pointer'),
+                children: `${issues.length} record(s) the plan could not use`
+            }),
+            /*#__PURE__*/ _jsx("ul", {
+                className: "mt-2 flex flex-col gap-2",
+                children: issues.map((issue, index)=>/*#__PURE__*/ _jsxs("li", {
+                        className: "flex flex-col gap-0.5",
+                        children: [
+                            /*#__PURE__*/ _jsx("span", {
+                                className: theme.card.title,
+                                children: `Source record #${issue.sourceIndex} — ${issue.kind}`
+                            }),
+                            /*#__PURE__*/ _jsx("span", {
+                                className: theme.field.hint,
+                                children: issue.message
+                            }),
+                            issue.dedupKey ? /*#__PURE__*/ _jsx("span", {
+                                className: theme.field.hint,
+                                children: `Dedup key: ${issue.dedupKey}`
+                            }) : null
+                        ]
+                    }, `${issue.sourceIndex}-${issue.kind}-${index}`))
+            })
+        ]
+    });
+}

package/dist/fe/components/IntegrationsPage/components/RunPlanSummary.d.ts

@@ -0,0 +1,5 @@
+import type { RunPlanValue } from '../types';
+export type RunPlanSummaryProps = {
+    plan: RunPlanValue;
+};
+export declare function RunPlanSummary({ plan }: RunPlanSummaryProps): import("react/jsx-runtime").JSX.Element;

package/dist/fe/components/IntegrationsPage/components/RunPlanSummary.js

@@ -0,0 +1,92 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { integrationsPageTheme } from '../theme';
+import { Badge, Notice, Stat } from './Primitives';
+import { RunPlanIssues } from './RunPlanIssues';
+/**
+ * What the run WOULD do, before it does any of it.
+ *
+ * The counts come first because they are what gets approved; the server's own
+ * warnings are reproduced word for word underneath, never shortened — a warning
+ * an operator has to expand to read is a warning they run past.
+ */ const theme = integrationsPageTheme;
+/** Missing rows are only alarming when the policy actually does something to them. */ function missingTone(plan) {
+    if (plan.missing === 0) return undefined;
+    if (plan.missingPolicy === 'delete') return 'danger';
+    if (plan.missingPolicy === 'deactivate') return 'warning';
+    return undefined;
+}
+export function RunPlanSummary({ plan }) {
+    // A source that reports a total and hands over a different number of records
+    // is the loudest symptom of a wrong pagination profile, and the run that
+    // follows treats everything it never saw as missing.
+    const countMismatch = plan.reportedTotal !== null && plan.reportedTotal !== plan.totalFetched;
+    return /*#__PURE__*/ _jsxs("section", {
+        className: "flex flex-col gap-3",
+        children: [
+            /*#__PURE__*/ _jsxs("div", {
+                className: "flex flex-wrap items-center gap-2",
+                children: [
+                    /*#__PURE__*/ _jsx(Badge, {
+                        tone: "neutral",
+                        children: plan.targetEntity
+                    }),
+                    /*#__PURE__*/ _jsx(Badge, {
+                        tone: "info",
+                        children: plan.writeMode
+                    }),
+                    /*#__PURE__*/ _jsx(Badge, {
+                        tone: plan.dedupConfigured ? 'neutral' : 'warning',
+                        children: plan.dedupConfigured ? 'dedup key set' : 'no dedup key'
+                    }),
+                    /*#__PURE__*/ _jsx(Badge, {
+                        tone: "neutral",
+                        children: `missing rows: ${plan.missingPolicy}`
+                    })
+                ]
+            }),
+            countMismatch ? /*#__PURE__*/ _jsx(Notice, {
+                tone: "danger",
+                title: "The source and the reader disagree on how many records exist",
+                children: `The source reports ${plan.reportedTotal} record(s); ${plan.totalFetched} were actually read. Check the endpoint's pagination profile before running: a wrong profile reads one page, and every record it never saw counts as missing.`
+            }) : null,
+            /*#__PURE__*/ _jsxs("div", {
+                className: theme.stat.grid,
+                children: [
+                    /*#__PURE__*/ _jsx(Stat, {
+                        label: "To create",
+                        value: plan.toCreate
+                    }),
+                    /*#__PURE__*/ _jsx(Stat, {
+                        label: "To update",
+                        value: plan.toUpdate
+                    }),
+                    /*#__PURE__*/ _jsx(Stat, {
+                        label: "To skip",
+                        value: plan.toSkip
+                    }),
+                    /*#__PURE__*/ _jsx(Stat, {
+                        label: "Missing",
+                        tone: missingTone(plan),
+                        value: plan.missing
+                    }),
+                    /*#__PURE__*/ _jsx(Stat, {
+                        label: "Already there",
+                        value: plan.existingCount
+                    }),
+                    /*#__PURE__*/ _jsx(Stat, {
+                        label: "Fetched",
+                        value: plan.totalFetched
+                    })
+                ]
+            }),
+            plan.warnings.map((warning, index)=>/*#__PURE__*/ _jsx(Notice, {
+                    title: warning,
+                    tone: "warning"
+                }, `${index}-${warning}`)),
+            /*#__PURE__*/ _jsx(RunPlanIssues, {
+                issues: plan.issues
+            })
+        ]
+    });
+}

package/dist/fe/components/IntegrationsPage/components/RunProgressBar.d.ts

@@ -0,0 +1,8 @@
+import type { RunProgressValue } from '../types';
+export type RunProgressBarProps = {
+    runId: string;
+    progress: RunProgressValue | null;
+    cancelling: boolean;
+    onCancel: () => void;
+};
+export declare function RunProgressBar({ runId, progress, cancelling, onCancel }: RunProgressBarProps): import("react/jsx-runtime").JSX.Element;

package/dist/fe/components/IntegrationsPage/components/RunProgressBar.js

@@ -0,0 +1,77 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { cn } from '../../../utils/cn';
+import { integrationsPageTheme } from '../theme';
+/**
+ * How far the run this panel started has got.
+ *
+ * A run that reports no total still gets a bar — an indeterminate one — because
+ * the alternative is a screen that looks frozen while the source is being paged.
+ * Cancel lives here, next to the thing it stops, and nowhere else.
+ */ const theme = integrationsPageTheme;
+const PHASE_LABEL = {
+    fetching: 'Reading from the source',
+    mapping: 'Mapping fields',
+    validating: 'Validating records',
+    writing: 'Writing to the target',
+    done: 'Finished'
+};
+export function RunProgressBar({ runId, progress, cancelling, onCancel }) {
+    const total = progress?.total ?? 0;
+    const processed = progress?.processed ?? 0;
+    const determinate = total > 0;
+    const percent = determinate ? Math.min(100, Math.max(0, Math.round(processed / total * 100))) : 0;
+    return /*#__PURE__*/ _jsxs("section", {
+        "aria-live": "polite",
+        className: "flex flex-col gap-2",
+        children: [
+            /*#__PURE__*/ _jsxs("div", {
+                className: "flex flex-wrap items-center justify-between gap-2",
+                children: [
+                    /*#__PURE__*/ _jsx("span", {
+                        className: theme.progress.label,
+                        children: progress ? PHASE_LABEL[progress.phase] : 'Waiting for the first update'
+                    }),
+                    /*#__PURE__*/ _jsx("span", {
+                        className: theme.progress.label,
+                        children: determinate ? `${processed} / ${total} (${percent}%)` : `${processed} processed`
+                    })
+                ]
+            }),
+            /*#__PURE__*/ _jsx("div", {
+                "aria-label": "Import progress",
+                "aria-valuemax": determinate ? total : undefined,
+                "aria-valuemin": determinate ? 0 : undefined,
+                "aria-valuenow": determinate ? processed : undefined,
+                className: theme.progress.track,
+                role: "progressbar",
+                children: /*#__PURE__*/ _jsx("div", {
+                    className: cn(theme.progress.bar, !determinate && 'animate-pulse'),
+                    style: {
+                        width: determinate ? `${percent}%` : '100%'
+                    }
+                })
+            }),
+            progress?.message ? /*#__PURE__*/ _jsx("p", {
+                className: theme.progress.label,
+                children: progress.message
+            }) : null,
+            /*#__PURE__*/ _jsxs("div", {
+                className: "flex flex-wrap items-center justify-between gap-2",
+                children: [
+                    /*#__PURE__*/ _jsx("span", {
+                        className: theme.progress.label,
+                        children: `Run ${runId}`
+                    }),
+                    /*#__PURE__*/ _jsx("button", {
+                        className: theme.button.danger,
+                        disabled: cancelling,
+                        onClick: onCancel,
+                        type: "button",
+                        children: cancelling ? 'Cancelling…' : 'Cancel'
+                    })
+                ]
+            })
+        ]
+    });
+}

package/dist/fe/components/IntegrationsPage/components/RunRevertConflicts.d.ts

@@ -0,0 +1,13 @@
+export type RevertConflictValue = {
+    id: string;
+    reason: string;
+};
+export type RunRevertConflictsProps = {
+    conflicts: RevertConflictValue[];
+    /** What the server said when it refused. Shown as it came. */
+    message: string;
+    working: boolean;
+    onOverwrite: () => void;
+    onDismiss: () => void;
+};
+export declare function RunRevertConflicts({ conflicts, message, working, onOverwrite, onDismiss, }: RunRevertConflictsProps): import("react/jsx-runtime").JSX.Element;

package/dist/fe/components/IntegrationsPage/components/RunRevertConflicts.js

@@ -0,0 +1,65 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { integrationsPageTheme } from '../theme';
+/**
+ * The rows somebody edited by hand after the import wrote them.
+ *
+ * Undoing the run would restore the pre-image over that person's work, so the
+ * first Undo stops here and names every row it would trample. Overwriting is a
+ * SECOND, separate decision — it never rides along on the first click.
+ */ const theme = integrationsPageTheme;
+export function RunRevertConflicts({ conflicts, message, working, onOverwrite, onDismiss }) {
+    return /*#__PURE__*/ _jsxs("section", {
+        className: theme.notice.danger,
+        role: "alert",
+        children: [
+            /*#__PURE__*/ _jsx("p", {
+                className: theme.notice.title,
+                children: `${conflicts.length} row(s) changed after this run. Undoing would overwrite those changes.`
+            }),
+            /*#__PURE__*/ _jsxs("div", {
+                className: theme.notice.body,
+                children: [
+                    message ? /*#__PURE__*/ _jsx("p", {
+                        children: message
+                    }) : null,
+                    /*#__PURE__*/ _jsx("ul", {
+                        className: "mt-2 flex flex-col gap-1",
+                        children: conflicts.map((conflict)=>/*#__PURE__*/ _jsxs("li", {
+                                className: "flex flex-col gap-0.5",
+                                children: [
+                                    /*#__PURE__*/ _jsx("span", {
+                                        className: "font-mono text-xs",
+                                        children: conflict.id
+                                    }),
+                                    /*#__PURE__*/ _jsx("span", {
+                                        className: "text-xs opacity-90",
+                                        children: conflict.reason
+                                    })
+                                ]
+                            }, conflict.id))
+                    }),
+                    /*#__PURE__*/ _jsxs("div", {
+                        className: "mt-3 flex flex-wrap items-center gap-2",
+                        children: [
+                            /*#__PURE__*/ _jsx("button", {
+                                className: theme.button.danger,
+                                disabled: working,
+                                onClick: onOverwrite,
+                                type: "button",
+                                children: working ? 'Overwriting…' : 'Overwrite them anyway'
+                            }),
+                            /*#__PURE__*/ _jsx("button", {
+                                className: theme.button.secondary,
+                                disabled: working,
+                                onClick: onDismiss,
+                                type: "button",
+                                children: "Leave those rows alone"
+                            })
+                        ]
+                    })
+                ]
+            })
+        ]
+    });
+}

package/dist/fe/components/IntegrationsPage/components/RunsTab.d.ts

@@ -0,0 +1,13 @@
+import type { IntegrationsActions, RunProgressValue } from '../types';
+/**
+ * The runs tab: what an import would do, and what every import has done.
+ *
+ * The panel needs a mapping — it is the mapping that names a target and a write
+ * mode — but the history does not, so a connection with no mapping selected still
+ * shows its past runs instead of an empty screen.
+ */
+export type RunsTabProps = {
+    actions: IntegrationsActions;
+    onSubscribeProgress?: (handler: (progress: RunProgressValue) => void) => () => void;
+};
+export declare function RunsTab({ actions, onSubscribeProgress }: RunsTabProps): import("react/jsx-runtime").JSX.Element;