Skip to content

World's first open-source enterprise world model.

26.5 KB
Raw Blame
// 数据映射:业务概念在数据库里对应什么、怎么算。
//
// **这一页在此之前不存在**,而它管的东西一直都在:口径由探查任务提出、在
// 「审阅」里被确认,然后沉进问数的 system prompt——人再也看不见它,也改不动。
// `mappings::revise` 连同它的留痕表从建表起就是零调用的。
//
// 审批留在同一个端点上(`review/mappings/{id}`,那里已经在写审计流水),
// 搬的是界面不是逻辑:判断一条口径对不对要看得见表结构,而那在这一页。
import { useEffect, useState } from "react";
import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
import { Database, Plug, Plus, Search } from "lucide-react";
import { useNavigate } from "@tanstack/react-router";
import { api, type ConceptMapping } from "../api";
import { S } from "../i18n";
import { useKb } from "../kb";
import { toast } from "../toast";
import {
  Button,
  Checkbox,
  Chip,
  Dropdown,
  EmptyState,
  ErrorText,
  Input,
  Loading,
  PageHeader,
  Pager,
  RAIL_CLS,
  Row,
  SearchSelect,
  Status,
  cn,
  type ChipTone,
} from "../ui";
import { fetchMe } from "../authSession";

const PAGE = 25;

type StatusFilter = "all" | "proposed" | "confirmed" | "rejected";
type MappingDecision = Extract<
  ConceptMapping["status"],
  "confirmed" | "rejected"
>;
const NO_PENDING_MAPPING_IDS: ReadonlySet<string> = new Set();

export const decideMappings = async (
  ids: string[],
  decide: (id: string) => Promise<unknown>,
) => {
  const outcomes = await Promise.allSettled(ids.map((id) => decide(id)));
  const failure = outcomes.find((outcome) => outcome.status === "rejected");
  if (failure?.status === "rejected") throw failure.reason;
};

export const selectedMappingIds = (
  mappings: Pick<ConceptMapping, "id" | "status">[],
  picked: ReadonlySet<string>,
  pending: ReadonlySet<string> = NO_PENDING_MAPPING_IDS,
) =>
  mappings
    .filter(
      (mapping) =>
        mapping.status === "proposed" &&
        picked.has(mapping.id) &&
        !pending.has(mapping.id),
    )
    .map((mapping) => mapping.id);

const TONE: Record<string, ChipTone> = {
  proposed: "warn",
  confirmed: "success",
  rejected: "neutral",
};

/** 「这个数怎么算」。SQL / 表达式 / 表名按这个优先级取一个——
 *  三者都在回答同一个问题,而 SQL 最具体、表名最粗 */
const howComputed = (m: ConceptMapping) =>
  m.sql ?? m.expr ?? m.table_name ?? null;

const statusLabel = (s: string) =>
  s === "proposed"
    ? S.mapping.filterProposed
    : s === "confirmed"
      ? S.mapping.filterConfirmed
      : S.mapping.filterRejected;

export function Mappings() {
  const { kb } = useKb();
  const queryClient = useQueryClient();
  const [tab, setTab] = useState<"definitions" | "sources">("definitions");
  const [status, setStatus] = useState<StatusFilter>("all");
  const [q, setQ] = useState("");
  const [page, setPage] = useState(0);
  const [picked, setPicked] = useState<Set<string>>(() => new Set());
  const [deciding, setDeciding] = useState<Set<string>>(() => new Set());
  useEffect(() => setPicked(new Set()), [kb?.id, page, q, status, tab]);

  const data = useQuery({
    queryKey: ["mappings", kb?.id, status, q, page],
    queryFn: () =>
      api.mappings(kb!.id, {
        status: status === "all" ? undefined : status,
        q: q || undefined,
        limit: PAGE,
        offset: page * PAGE,
      }),
    enabled: !!kb,
  });

  const refresh = () =>
    queryClient.invalidateQueries({ queryKey: ["mappings", kb?.id] });

  const batch = useMutation({
    mutationFn: ({ ids, status }: { ids: string[]; status: MappingDecision }) =>
      decideMappings(ids, (id) => api.decideMapping(kb!.id, id, status)),
    onSuccess: () => setPicked(new Set()),
    onError: (e: unknown) => toast.error((e as Error).message),
    onSettled: refresh,
  });

  if (!kb) return <Loading>{S.nav.loading}</Loading>;

  const counts = data.data?.counts;
  const selectable =
    data.data?.items.filter(
      (m) => m.status === "proposed" && !deciding.has(m.id),
    ) ?? [];
  const selectedIds = selectedMappingIds(
    data.data?.items ?? [],
    picked,
    deciding,
  );
  const individualPending = deciding.size > 0;
  const FILTERS: { key: StatusFilter; label: string; n?: number }[] = [
    { key: "all", label: S.mapping.filterAll },
    { key: "proposed", label: S.mapping.filterProposed, n: counts?.proposed },
    {
      key: "confirmed",
      label: S.mapping.filterConfirmed,
      n: counts?.confirmed,
    },
    { key: "rejected", label: S.mapping.filterRejected, n: counts?.rejected },
  ];

  return (
    /* **左栏切功能,不是标签页**:定义与数据源是两件不同的事(一个是判读,
       一个是登记连接),全站凡是这种切换都在左栏(文库、审阅、本体都是)。
       从前这里是一排按钮做的标签,选中那个还是实心主按钮——在这套语汇里
       实心说的是"这一屏最该按的那一下",四个标签四个行动号召。
       内容区也从设置页那套居中限宽(max-w-4xl)改成内容页的铺满(px-8 py-6)。 */
    <div className="flex h-full">
      <aside className={`${RAIL_CLS} u-rail-list px-2 py-3`}>
        {(["definitions", "sources"] as const).map((t) => (
          <Row
            key={t}
            density="nav"
            active={tab === t}
            icon={t === "definitions" ? <Database size={14} /> : <Plug size={14} />}
            onClick={() => setTab(t)}
          >
            {t === "definitions" ? S.mapping.tabDefinitions : S.mapping.tabSources}
          </Row>
        ))}
      </aside>

      <div className="u-scroll flex-1 min-w-0 overflow-y-auto px-8 py-6">
        <PageHeader
          title={S.mapping.title}
          sub={S.mapping.hint}
          className="mb-4"
        />

      {tab === "sources" ? (
        <DataSources kbId={kb.id} onExplored={refresh} />
      ) : (
        <div className="space-y-4">
          {/* 筛选是下拉,不是一排按钮:四档状态是"挑一个看",与全站其它页面的
              筛选同一副控件(Dropdown),计数跟在标签里 */}
          <div className="flex items-center gap-2 flex-wrap">
            {/* 筛选条与 Members、文库、图谱同一副身材:**带放大镜的 w-64 输入框在前**,
                下拉跟在后面。这里从前是下拉在前、输入框 flex-1——一个人从一页走到
                另一页,同样的一条工具行,控件换了顺序、搜索框还横跨整屏。 */}
            <Input
              icon={<Search size={13} />}
              className="w-64"
              placeholder={S.mapping.searchPlaceholder}
              value={q}
              onChange={(e) => {
                setQ(e.target.value);
                setPage(0);
              }}
            />
            <Dropdown
              className="w-40"
              value={status}
              onChange={(v) => {
                setStatus(v as StatusFilter);
                setPage(0);
              }}
              /* 计数写进括号里,不是用间隔点挂在后面。「Pending · 0」读起来是
                 两样并列的东西(这一页别处的 `·` 正是这个用法:口径 · 来源 ·
                 表),而这里的 0 不是第二个字段,是「Pending 有几条」——
                 括号说的就是这个从属关系。 */
              options={FILTERS.map((f) => ({
                value: f.key,
                label: f.n != null ? `${f.label} (${f.n})` : f.label,
              }))}
            />
            {/* **一条工具行**:筛选、搜索、全选、批量动作排在一起。
                从前它们各占一行,三行控件压在内容上面,读到列表要先翻过一块 */}
            {selectable.length > 0 && (
              <Checkbox
                checked={selectable.every((m) => picked.has(m.id))}
                disabled={batch.isPending || individualPending}
                onChange={(v) =>
                  setPicked(
                    v
                      ? new Set(selectable.map((m) => m.id))
                      : new Set(),
                  )
                }
                label={S.mapping.selectPage}
                className="shrink-0"
              />
            )}
            {selectedIds.length > 0 && (
              <>
                  <span className="u-num text-small text-ink-2">
                    {S.mapping.selected(selectedIds.length)}
                  </span>
                  <Button
                    variant="secondary"
                    size="sm"
                    disabled={batch.isPending || individualPending}
                    onClick={() =>
                      batch.mutate({
                        ids: selectedIds,
                        status: "confirmed",
                      })
                    }
                  >
                    {S.mapping.approve}
                  </Button>
                  <Button
                    variant="ghost"
                    size="sm"
                    className="text-danger"
                    disabled={batch.isPending || individualPending}
                    onClick={() =>
                      batch.mutate({
                        ids: selectedIds,
                        status: "rejected",
                      })
                    }
                  >
                    {S.mapping.reject}
                  </Button>
              </>
            )}
          </div>

          {status === "rejected" && (
            <p className="text-small text-ink-2">{S.mapping.rejectedHint}</p>
          )}
          {/* 最近一轮探索的账(#503)。**单看列表答不了「漏了多少」**——十二条
              提议对着八十列的宽表与刚好覆盖完一个小库长得一样。这条贴出来人才能
              从「等量提议」里看出覆盖范围。filtered out of view 反而更糟:搜索框
              在搜索的时候人最容易忘上一次跑了多深 */}
          {data.data?.last_run ? (
            <p className="text-small text-ink-2">
              {S.mapping.lastRun({
                tables: data.data.last_run.tables_scanned,
                columns: data.data.last_run.columns_scanned,
                returned: data.data.last_run.returned,
                accepted: data.data.last_run.accepted,
                truncated: data.data.last_run.schema_truncated,
              })}
            </p>
          ) : (
            <p className="text-small text-ink-2">{S.mapping.lastRunMissing}</p>
          )}

          {data.isPending ? (
            <Loading>{S.nav.loading}</Loading>
          ) : data.data && data.data.items.length === 0 ? (
            <div className="py-12">
              <EmptyState icon={<Database size={20} />}>
                {q || status !== "all"
                  ? S.mapping.emptyFiltered
                  : S.mapping.empty}
              </EmptyState>
            </div>
          ) : (
            /* 一个面板装多行,不是一行一张卡片(DESIGN.md 6):这一页是
               一队待表态的口径,同构的一组,跟文库、检索、成员一副样子 */
            <div className="glass rounded-panel divide-y divide-line">
              {data.data?.items.map((m) => (
                <MappingRow
                  key={m.id}
                  kbId={kb.id}
                  mapping={m}
                  picked={selectedIds.includes(m.id)}
                  batchPending={batch.isPending}
                  onDecisionPending={(pending) =>
                    setDeciding((prev) => {
                      const next = new Set(prev);
                      if (pending) next.add(m.id);
                      else next.delete(m.id);
                      return next;
                    })
                  }
                  onPick={(on) =>
                    setPicked((prev) => {
                      const next = new Set(prev);
                      if (on) next.add(m.id);
                      else next.delete(m.id);
                      return next;
                    })
                  }
                  onChanged={refresh}
                />
              ))}
            </div>
          )}
          <Pager
            total={data.data?.total ?? 0}
            pageSize={PAGE}
            page={page}
            onPage={setPage}
          />
        </div>
      )}
      </div>
    </div>
  );
}

/** 一条口径。**未表态的才给确认/拒绝两个按钮**——已表过态的给「编辑」,
 *  因为改口径和第一次拍板是两件事:前者要留痕(revisions),后者不用。 */
function MappingRow({
  kbId,
  mapping: m,
  picked,
  batchPending,
  onDecisionPending,
  onPick,
  onChanged,
}: {
  kbId: string;
  mapping: ConceptMapping;
  picked: boolean;
  batchPending: boolean;
  onDecisionPending: (pending: boolean) => void;
  onPick: (picked: boolean) => void;
  onChanged: () => void;
}) {
  const [editing, setEditing] = useState(false);
  const [showHistory, setShowHistory] = useState(false);

  const decide = useMutation({
    mutationFn: (s: "confirmed" | "rejected") =>
      api.decideMapping(kbId, m.id, s),
    onMutate: () => onDecisionPending(true),
    onSuccess: onChanged,
    onError: (e: unknown) => toast.error((e as Error).message),
    onSettled: () => onDecisionPending(false),
  });

  const how = howComputed(m);
  return (
    <div className={cn("px-4 py-3", picked && "u-picked")}>
      <div className="flex items-baseline gap-2 flex-wrap">
        {m.status === "proposed" && (
          <Checkbox
            className="shrink-0 self-center"
            checked={picked}
            disabled={decide.isPending || batchPending}
            onChange={(v) => onPick(v)}
            label={
              <span className="sr-only">
                {S.mapping.selectMapping(m.concept_name, m.source)}
              </span>
            }
          />
        )}
        <span className="text-body text-ink">{m.concept_name}</span>
        <span className="text-fine text-ink-2">{m.source}</span>
        {m.unit && (
          <span className="text-fine text-ink-2">[{m.unit}]</span>
        )}
        {m.derived && (
          <Chip tone="warn" className="text-fine">
            {S.mapping.derivedBadge}
          </Chip>
        )}
        <span className="flex-1" />
        <Status tone={TONE[m.status]} className="text-fine">
          {statusLabel(m.status)}
        </Status>
      </div>

      <div
        className={cn(
          "mt-1 u-num text-small break-all",
          how ? "text-ink-2" : "text-ink-2",
        )}
      >
        {how ?? S.mapping.noDefinition}
      </div>
      {m.summary && (
        <p className="mt-1 text-small text-ink-2">{m.summary}</p>
      )}

      {editing ? (
        <EditForm
          kbId={kbId}
          mapping={m}
          onDone={() => {
            setEditing(false);
            onChanged();
          }}
          onCancel={() => setEditing(false)}
        />
      ) : (
        /* 行里的动作:**拍板那一下描边,其余是 ghost,都不是实底。**十一行
           十一个实底按钮等于把一整页染成动作,而一屏最多一个 primary。
           但「不是实底」不等于「长成一句话」——从前这三个是 `LinkButton`:
           没有内距、没有 hover 底、颜色就是正文那档灰,跟它们上面那行说明
           一个样,看着不像能点。ghost 补回控件该有的两件事:一圈内距,
           和指针停上去的那块底。静止时仍然轻。
           拒绝**静止时就该是红的**:它是点了就生效的那一下,人要在按之前
           看出来它跟「编辑」不是一类,而不是划过去才发现。 */
        <div className="mt-2 -ml-2 flex items-center gap-1 flex-wrap">
          {m.status === "proposed" && (
            <>
              <Button variant="secondary" size="sm" className="ml-2"
                disabled={decide.isPending || batchPending || picked}
                onClick={() => decide.mutate("confirmed")}
              >
                {S.mapping.approve}
              </Button>
              <Button variant="ghost" size="sm" className="text-danger"
                disabled={batchPending || picked}
                onClick={() =>
                  !picked && !decide.isPending && decide.mutate("rejected")
                }
              >
                {S.mapping.reject}
              </Button>
            </>
          )}
          <Button variant="ghost" size="sm" onClick={() => setEditing(true)}>
            {S.mapping.edit}
          </Button>
          <Button variant="ghost" size="sm" onClick={() => setShowHistory((v) => !v)}>
            {S.mapping.history}
          </Button>
        </div>
      )}

      {showHistory && <RevisionList kbId={kbId} mappingId={m.id} />}
    </div>
  );
}

function EditForm({
  kbId,
  mapping: m,
  onDone,
  onCancel,
}: {
  kbId: string;
  mapping: ConceptMapping;
  onDone: () => void;
  onCancel: () => void;
}) {
  const [table, setTable] = useState(m.table_name ?? "");
  const [expr, setExpr] = useState(m.expr ?? "");
  const [sql, setSql] = useState(m.sql ?? "");
  const [unit, setUnit] = useState(m.unit ?? "");
  const [summary, setSummary] = useState(m.summary ?? "");
  const [derived, setDerived] = useState(m.derived);

  const save = useMutation({
    mutationFn: () =>
      api.reviseMapping(kbId, m.id, {
        table_name: table,
        expr,
        sql,
        unit,
        summary,
        derived,
      }),
    onSuccess: onDone,
    onError: (e: unknown) => toast.error((e as Error).message),
  });

  const nothing = !table.trim() && !expr.trim() && !sql.trim();
  const field = (
    label: string,
    value: string,
    set: (v: string) => void,
    mono = false,
  ) => (
    <label className="block">
      <span className="text-fine text-ink-2">{label}</span>
      <Input
        size="sm"
        className={cn("mt-1 w-full", mono && "u-num")}
        value={value}
        onChange={(e) => set(e.target.value)}
      />
    </label>
  );

  return (
    <div className="mt-3 space-y-2 border-t border-line pt-3">
      <p className="text-fine text-ink-2">{S.mapping.editTitle}</p>
      <div className="grid grid-cols-2 gap-2">
        {field(S.mapping.fieldTable, table, setTable, true)}
        {field(S.mapping.fieldUnit, unit, setUnit)}
      </div>
      {field(S.mapping.fieldExpr, expr, setExpr, true)}
      {field(S.mapping.fieldSql, sql, setSql, true)}
      {field(S.mapping.fieldSummary, summary, setSummary)}
      <Checkbox
        checked={derived}
        onChange={(v) => setDerived(v)}
        label={S.mapping.fieldDerived}
      />
      <span className="hidden">
      </span>
      {nothing && (
        <p className="text-small text-danger">{S.mapping.needOne}</p>
      )}
      <div className="flex gap-2">
        <Button variant="secondary" size="sm"
          onClick={onCancel}
        >
          {S.mapping.cancel}
        </Button>
        <Button variant="primary" size="sm"
          disabled={nothing || save.isPending}
          onClick={() => save.mutate()}
        >
          {S.mapping.save}
        </Button>
      </div>
    </div>
  );
}

/** 改版历史。**留痕表从建表起就没人读过**——0006 说留它是为了答得出
 *  「上季度这个数是怎么算的」,这里是那句话的兑现处。 */
function RevisionList({
  kbId,
  mappingId,
}: {
  kbId: string;
  mappingId: string;
}) {
  const revs = useQuery({
    queryKey: ["mappingRevisions", kbId, mappingId],
    queryFn: () => api.mappingRevisions(kbId, mappingId),
  });

  if (revs.isPending) return <Loading>{S.nav.loading}</Loading>;
  // **取失败要说取失败。** `?? []` 会把一次 500 画成「还没改过」——
  // 一条改过口径的记录被说成从没改过,比报错难查得多
  if (revs.isError)
    return (
      <div className="mt-3 border-t border-line pt-3">
        <ErrorText>{(revs.error as Error).message}</ErrorText>
      </div>
    );
  const list = revs.data?.revisions ?? [];
  return (
    <div className="mt-3 border-t border-line pt-3 space-y-2">
      <p className="text-fine text-ink-2">{S.mapping.historyHint}</p>
      {list.length === 0 ? (
        <p className="text-small text-ink-2">{S.mapping.historyEmpty}</p>
      ) : (
        list.map((r) => {
          const b = r.before;
          const was = (b.sql ?? b.expr ?? b.table_name) as string | null;
          return (
            <div key={r.id} className="text-small">
              <div className="text-ink-2">
                {S.mapping.historyBy(
                  r.changed_by_name ?? S.mapping.historyUnknown,
                )}
                <span className="u-num ml-2 text-ink-2">
                  {r.changed_at.slice(0, 16).replace("T", " ")}
                </span>
              </div>
              <div className="u-num text-ink-2 break-all">
                {was ?? S.mapping.noDefinition}
              </div>
            </div>
          );
        })
      )}
    </div>
  );
}

/** 知识库层的数据源挂载。**从 KB 设置搬来的**——挂哪个库和口径怎么定,
 *  是同一件事的两半:不知道有哪些表,就判断不了口径对不对。
 *  注册新连接仍是部署级动作,管理员给直达入口,其他人指路找管理员。 */
function DataSources({
  kbId,
  onExplored,
}: {
  kbId: string;
  onExplored: () => void;
}) {
  const queryClient = useQueryClient();
  const navigate = useNavigate();
  const me = useQuery({ queryKey: ["me"], queryFn: fetchMe });
  const mounted = useQuery({
    queryKey: ["kbDataSources", kbId],
    queryFn: () => api.kbDataSources(kbId),
  });
  const available = useQuery({
    queryKey: ["kbDataSourcesAvail", kbId],
    queryFn: () => api.kbDataSourcesAvailable(kbId),
  });
  const [picked, setPicked] = useState("");
  const [notice, setNotice] = useState<string | null>(null);
  // 与 notice 分开:一个是「成了」,一个是「成了一半」,配色也不同
  const [warning, setWarning] = useState<string | null>(null);
  const invalidate = () =>
    queryClient.invalidateQueries({ queryKey: ["kbDataSources", kbId] });

  const mount = useMutation({
    mutationFn: (dsId: string) => api.mountDataSource(kbId, dsId),
    // **挂载成了、schema 没成,是两件事。** 服务端此时回的是 ok(源确实挂上了),
    // 所以不能照着 `schema_tables: 0` 说「已摄入 0 张表」——那等于说成功了。
    // 说清楚半成的是哪一半,同一件事也进了告警中心
    onSuccess: (r) => {
      setPicked("");
      setNotice(null);
      setWarning(r.schema_error ? S.mapping.schemaFailed : null);
      if (!r.schema_error) setNotice(S.mapping.schemaSynced(r.schema_tables));
      invalidate();
    },
    onError: (e: unknown) => toast.error((e as Error).message),
  });
  const unmount = useMutation({
    mutationFn: (dsId: string) => api.unmountDataSource(kbId, dsId),
    onSettled: invalidate,
  });
  const sync = useMutation({
    mutationFn: (dsId: string) => api.syncDataSourceSchema(kbId, dsId),
    onSuccess: (r) => setNotice(S.mapping.schemaSynced(r.schema_tables)),
    onError: (e: unknown) => toast.error((e as Error).message),
  });
  const explore = useMutation({
    mutationFn: () => api.exploreMappings(kbId),
    onSuccess: () => {
      setNotice(S.mapping.exploreQueued);
      onExplored();
    },
    onError: (e: unknown) => toast.error((e as Error).message),
  });

  const mountedIds = new Set(
    (mounted.data?.data_sources ?? []).map((d) => d.id),
  );
  const mountable = (available.data?.data_sources ?? []).filter(
    (d) => !mountedIds.has(d.id),
  );
  const hasMounted = (mounted.data?.data_sources.length ?? 0) > 0;

  return (
    <div className="space-y-4">
      <p className="text-small text-ink-2">{S.mapping.sourcesHint}</p>

      <div className="glass rounded-panel divide-y divide-line">
        {(mounted.data?.data_sources ?? []).map((d) => (
          <div key={d.id} className="px-4 py-3 flex items-center gap-3">
            <div className="min-w-0 flex-1">
              <div className="text-body text-ink">{d.name}</div>
              <div className="text-small text-ink-2 u-num truncate">
                {d.summary}
              </div>
            </div>
            <Button variant="secondary" size="sm" className="shrink-0"
              disabled={sync.isPending}
              onClick={() => sync.mutate(d.id)}
            >
              {S.mapping.syncSchema}
            </Button>
            <Button
              variant="ghost"
              size="sm"
              className="shrink-0 text-danger"
              disabled={unmount.isPending}
              onClick={() => unmount.mutate(d.id)}
            >
              {S.mapping.unmount}
            </Button>
          </div>
        ))}
        {!hasMounted && (
          <p className="px-4 py-6 text-body text-ink-2">
            {S.mapping.sourcesEmpty}
          </p>
        )}
      </div>

      {mountable.length > 0 && (
        <div className="flex items-center gap-2">
          <SearchSelect
            className="flex-1"
            value={picked}
            options={mountable.map((d) => ({
              value: d.id,
              label: d.name,
              hint: d.summary,
            }))}
            onChange={setPicked}
            placeholder={S.mapping.mount + "…"}
          />
          <Button variant="primary" size="sm" className="shrink-0"
            disabled={!picked || mount.isPending}
            onClick={() => mount.mutate(picked)}
          >
            {S.mapping.mount}
          </Button>
        </div>
      )}

      {me.data?.is_admin ? (
        <Button
          variant="ghost"
          size="sm"
          className="-ml-2"
          onClick={() =>
            navigate({ to: "/admin", search: { tab: "datasources" } })
          }
        >
          <Plus size={12} />
          {S.mapping.newConn}
        </Button>
      ) : (
        mountable.length === 0 &&
        available.data &&
        !hasMounted && (
          <p className="text-small text-ink-2">
            {S.mapping.sourcesNoneAvailable}
          </p>
        )
      )}

      {hasMounted && (
        <div className="glass rounded-panel px-4 py-3 flex items-center gap-3">
          <p className="text-small text-ink-2 flex-1">
            {S.mapping.exploreHint}
          </p>
          <Button variant="secondary" size="sm" className="shrink-0"
            disabled={explore.isPending}
            onClick={() => explore.mutate()}
          >
            {S.mapping.explore}
          </Button>
        </div>
      )}
      {notice && <p className="text-small text-ok">{notice}</p>}
      {warning && <p className="text-small text-warn">{warning}</p>}
    </div>
  );
}