@anchrd/intel-ui 0.33.0 → 0.35.0

package/src/resource-menu/resource-menu.tsx

@@ -18,7 +18,7 @@ import {
   ShieldCheck,
 } from "lucide-react";
 import type * as React from "react";
-import { useState } from "react";
+import { useId, useState } from "react";
 import { AccessSummary } from "@/access-summary/access-summary.tsx";
 import { allTreeLevelsKey, moveErrorKey, useTreeMove } from "@/app/tree-move/tree-move.tsx";
 import {
@@ -154,6 +154,11 @@ export function ResourceMenu({
   // nowhere else: a person had strictly less reach on their own table than a model did.
   const isTable = node !== null && node.kind === "table";
   const bundleImport = useBundleImport({ where: title });
+  // ⚠️ Per instance, not a constant: the folder table renders one menu PER ROW, so a fixed id would
+  // put the same `id` in the document twenty times and every entry's name would resolve to the
+  // first one's.
+  const exportLabelId = useId();
+  const exportHintId = useId();
 
   // Everything a change here can make stale. The row sits in one level of the tree, the open screen
   // reads the record, and the flat collections behind the search, the link picker and the relation
@@ -316,10 +321,40 @@ export function ResourceMenu({
               ⚠️ The one case where they differed is the table that has no header yet: `downloadCsv`
               refused it out loud, `tableCsv` joins no segments and writes a file of zero bytes
               (#534). That is the export's gap on every kind it can hit, not something this entry
-              was covering — which is why it is fixed there and not by keeping a second entry. */}
-          <DropdownMenuItem onSelect={() => exportBundle.mutate()}>
-            <FolderDown aria-hidden="true" />
-            {i18n.t("resource.export")}
+              was covering — which is why it is fixed there and not by keeping a second entry.
+
+              ⚠️ The second line is not decoration and it belongs HERE rather than after the click
+              (#433, ADR-0006). A bundle carries one version per node; whoever moves an installation
+              this way loses every earlier one, and until now the only place that said so was
+              `excluded` in a `manifest.json` inside the zip — read, if ever, long after the source
+              installation is gone. A loss that cannot be undone has to be readable BEFORE the
+              gesture, and a menu item is where this gesture is chosen.
+
+              ⚠️ Its third clause is the flow half (#585), and it is a DIFFERENT loss from the first
+              two rather than an example of them: a published flow travels as its published graph,
+              so edits drafted since do not travel at all. Those edits are not an earlier version —
+              they are the newest state there is, and somebody reading only "earlier versions stay
+              behind" would expect the opposite of what happens. `Excluded` in `bundle.ts` names it
+              with a word of its own for the same reason.
+
+              ⚠️ It is the entry's DESCRIPTION, not part of its name: `aria-labelledby` keeps the
+              name at the one word every other entry here uses, and `aria-describedby` is what a
+              screen reader reads after it. Folding a whole sentence into the name would make this
+              the only entry in the menu somebody has to listen through to know what it does — and
+              the sentence is a condition of the action, which is what a description is for. */}
+          <DropdownMenuItem
+            className="items-start"
+            aria-labelledby={exportLabelId}
+            aria-describedby={exportHintId}
+            onSelect={() => exportBundle.mutate()}
+          >
+            <FolderDown aria-hidden="true" className="mt-0.5" />
+            <span className="flex flex-col gap-0.5">
+              <span id={exportLabelId}>{i18n.t("resource.export")}</span>
+              <span id={exportHintId} className="text-xs text-muted-foreground">
+                {i18n.t("resource.exportExcludes")}
+              </span>
+            </span>
           </DropdownMenuItem>
           {/* The other half of the same round trip, next to it rather than in the tree's plus
               (#346): one word in the menu, both sources under it. */}
@@ -411,19 +446,30 @@ export function ResourceMenu({
                   (`flows.problem.<code>` is one string) and repeating it under itself says nothing
                   the reader did not just read. What differs is the detail, and every detail is
                   still here — which is the promise the comment above makes: somebody with two
-                  missing tools should not have to ask twice. */}
+                  missing tools should not have to ask twice.
+
+                  ⚠️ What identifies a detail is its POSITION in `problems`, not its text (#461).
+                  Two details of one code are routinely the same sentence: `collectRunProblems`
+                  files one problem per sub-flow NODE and words it with that node's label
+                  (`packages/api/src/flows/flows.ts`), and calling the same flow twice is the normal
+                  case. Under `key={detail}` those two collided on one key, and React does not
+                  answer that with a console warning alone — it drops one of the siblings on the
+                  next render, so the reader sees ONE entry where there are two causes. */}
               {[
                 ...validation.problems
-                  .reduce((byCode, problem) => {
-                    byCode.set(problem.code, [...(byCode.get(problem.code) ?? []), problem.detail]);
+                  .reduce((byCode, problem, at) => {
+                    byCode.set(problem.code, [
+                      ...(byCode.get(problem.code) ?? []),
+                      { at, detail: problem.detail },
+                    ]);
                     return byCode;
-                  }, new Map<string, string[]>())
+                  }, new Map<string, { at: number; detail: string }[]>())
                   .entries(),
               ].map(([code, details]) => (
                 <li key={code} className="rounded-md border p-3 text-sm">
                   <span className="block font-medium">{i18n.t(`flows.problem.${code}`)}</span>
-                  {details.map((detail) => (
-                    <span key={detail} className="mt-1 block text-xs text-muted-foreground">
+                  {details.map(({ at, detail }) => (
+                    <span key={at} className="mt-1 block text-xs text-muted-foreground">
                       {detail}
                     </span>
                   ))}
@@ -776,27 +822,41 @@ function SharePanel({ target, close }: { target: ResourceTarget; close(): void }
    *
    * ⚠️ Taking back `organization` + `execute` on a folder is refused with `409
    * folder_execute_in_use` while flows from outside still call into it (`nodes.ts`,
-   * `revokeGrant`) — and the refusal's `detail` is the only place the CALLERS are named. Rendering
-   * it as the generic "access was not changed" threw exactly that away and left the reader with a
-   * dialog that refuses and will not say why, for the one grant that is hardest to undo.
+   * `revokeGrant`), and the CALLERS are what makes that refusal actionable. Rendering it as the
+   * generic "access was not changed" threw exactly that away and left the reader with a dialog that
+   * refuses and will not say why, for the one grant that is hardest to undo.
    *
-   * ⚠️ The server's own words, on purpose. `callersDetail` names the flows this actor may see and
-   * only COUNTS the rest, so it is actionable without becoming a directory of the tree — a
-   * translated stand-in would either lose the names or need them separately, and the wire carries
-   * prose rather than a list (#448). The lead-in sentence above it is translated; this line is the
-   * evidence under it.
+   * ⚠️ Since #448 they arrive as data — the flows this actor may see by name, the rest as a count —
+   * so the sentence is written here, in the reader's language, exactly like the `shareUnreadable`
+   * warning below it. The server still decides WHICH of them may be named; that is an authorization
+   * answer and nothing on this side recomputes it.
    */
-  const revokeInUse =
-    revoke.error instanceof IntelRequestError && revoke.error.code === "folder_execute_in_use"
-      ? revoke.error.message
-      : null;
+  const revokeError = revoke.error instanceof IntelRequestError ? revoke.error : null;
+  const revokeInUse = revokeError?.code === "folder_execute_in_use" ? revokeError : null;
 
   return (
     <Modal title={i18n.t("node.share")} close={close}>
       {revokeInUse ? (
         <div role="alert" className="mb-4 space-y-1 text-sm text-destructive">
           <p>{i18n.t("node.revokeInUse")}</p>
-          <p className="text-xs">{revokeInUse}</p>
+          {/* An API that predates #448 sends no `callers`, and its sentence is then the only place
+              the names exist at all. Showing it beats showing nothing — losing the titles is the
+              failure this ticket is about. */}
+          {revokeInUse.callers === null ? (
+            <p className="text-xs">{revokeInUse.message}</p>
+          ) : (
+            <p className="text-xs">
+              {revokeInUse.callers.titles.length > 0
+                ? i18n.t("node.revokeInUseCallers", {
+                    titles: revokeInUse.callers.titles.join(", "),
+                  })
+                : i18n.t("node.revokeInUseCallersHidden", { count: revokeInUse.callers.hidden })}
+              {revokeInUse.callers.titles.length > 0 && revokeInUse.callers.hidden > 0
+                ? ` ${i18n.t("node.revokeInUseCallersMore", { count: revokeInUse.callers.hidden })}`
+                : ""}
+              {` ${i18n.t("node.revokeInUseHint")}`}
+            </p>
+          )}
         </div>
       ) : (
         (share.isError || revoke.isError || grants.isError) && (

package/src/tools/tools.tsx

@@ -415,10 +415,11 @@ function ServerGroup({
   // with it — otherwise Enter on a hit lands on a screen where nothing happened.
   const holdsRequested = group.items.some((item) => item.name === requested);
   const destructive = group.items.filter((item) => item.annotations.destructiveHint).length;
-  const count =
-    group.items.length === 1
-      ? i18n.t("tools.toolCountOne")
-      : i18n.t("tools.toolCount", { count: group.items.length });
+  // ⚠️ One key, not a `…One` beside a `…Many` (#605): the catalog carries a wording that fits every
+  // number, so nothing here branches on the count. The branch that used to stand here is what the
+  // rule in `packages/ui/CLAUDE.md` forbids — it puts the inflection into the component and into
+  // every future language.
+  const count = i18n.t("tools.toolCount", { count: group.items.length });
   // The badges beside the name read as one run-on word when a screen reader concatenates them
   // ("wiki1 tool"), so the control says its own name instead of being read off its contents.
   const spoken = [`${i18n.t("tools.origin")}: ${group.label}`, count];