@anchrd/intel-ui 0.32.0 → 0.34.0

package/src/flows/flows.tsx

@@ -24,15 +24,19 @@ import {
   useReactFlow,
 } from "@xyflow/react";
 import { FileSearch, Info, Send, Wrench } from "lucide-react";
-import { useEffect, useId, useMemo, useState } from "react";
+import { createContext, useContext, useEffect, useId, useMemo, useState } from "react";
 import { TreeEntryMediaType } from "@/app/app-tree/app-tree.tsx";
 import { ViewToggle } from "@/app/view-toggle/view-toggle.tsx";
 import { Tooltip, TooltipContent, TooltipProvider, TooltipTrigger } from "@/components/ui/tooltip";
+import { IntelRequestError } from "@/data/intel-data-provider/intel-data-provider.ts";
+import { RefusalNotice } from "@/data/request-refusal/refusal-notice.tsx";
+import { refusalOf } from "@/data/request-refusal/request-refusal.ts";
 import { EntryPicker } from "@/entry-picker/entry-picker.tsx";
 import { FlowRuns } from "@/flow-runs/flow-runs.tsx";
 import { nodeIcon } from "@/flows/node-icon/node-icon.ts";
 import { NodePalette, usePaletteOpen } from "@/flows/node-palette/node-palette.tsx";
 import { GraphPane } from "@/graph-pane/graph-pane.tsx";
+import type { I18n } from "@/i18n/i18n.types.ts";
 import { useI18n } from "@/i18n/i18n-context.tsx";
 import { Modal } from "@/modal/modal.tsx";
 import { useIntelRouterContext } from "@/router/router-context.ts";
@@ -90,9 +94,24 @@ const flowKindOfEntry: Record<string, FlowNode["kind"] | undefined> = {
   flow: "subflow",
 };
 
+/**
+ * The tree links of this flow that name nothing any more, by resource id (#509).
+ *
+ * ⚠️ A context rather than a field on the node's `data`, because the canvas nodes are React state
+ * that the loaded version owns: writing the answer of a query into them would put a second writer
+ * on that state and let a background refetch land in the middle of an edit. The set is read where
+ * it is drawn and nowhere else.
+ */
+const InvalidLinks = createContext<ReadonlySet<string>>(new Set());
+
 function FlowCard({ data, selected }: NodeProps<CanvasNode>) {
   const i18n = useI18n();
   const contract = data.node;
+  const invalidLinks = useContext(InvalidLinks);
+  // ⚠️ Said in a WORD, not by colour alone. A card that only turned red would say nothing to a
+  // colour-blind reader and nothing at all to a screen reader — and this is the one state on the
+  // canvas that stops the flow from running (#509).
+  const broken = isLinkNode(contract) && invalidLinks.has(contract.configuration.resourceId);
   const Icon = nodeIcon[contract.kind];
   const branching = contract.kind === "condition";
   // ⚠️ The start is told apart by silhouette first (#39): a pill among rectangles, in the primary
@@ -117,9 +136,14 @@ function FlowCard({ data, selected }: NodeProps<CanvasNode>) {
         <span className="min-w-0">
           <span className="block truncate text-sm font-medium">{contract.label}</span>
           {/* The kind through the catalog, not the raw key: the start node is called Start on the
-              canvas as well, and `trigger` would name an event that no longer exists (#39). */}
-          <span className="block text-xs text-muted-foreground">
-            {i18n.t(`flows.node.${contract.kind}`)}
+              canvas as well, and `trigger` would name an event that no longer exists (#39).
+              ⚠️ A broken link says so INSTEAD of naming its kind, because "Document" beside a
+              reference that names nothing is the sentence #509 is about: the card looked like every
+              valid link on the canvas. */}
+          <span
+            className={`block text-xs ${broken ? "text-destructive" : "text-muted-foreground"}`}
+          >
+            {broken ? i18n.t("flows.nodeInvalid") : i18n.t(`flows.node.${contract.kind}`)}
           </span>
         </span>
         {riding === "follows" || riding === "pinned" ? (
@@ -348,6 +372,31 @@ function newNode(
   }
 }
 
+/**
+ * Which sentence a refused SAVE is told with.
+ *
+ * ⚠️ `400 flow_graph_invalid` and `409` are two different answers, and until #508 they shared one
+ * sentence — the conflict one. For a rejected graph that advice is not merely useless but
+ * destructive: reloading discards the unsaved canvas, and the next attempt is refused for exactly
+ * the same reason, so following it costs the work and changes nothing.
+ *
+ * The graph rule therefore shows the API's OWN sentence: only the server knows which step broke
+ * which rule, and it names that step by its label since #508. A conflict keeps the reload sentence,
+ * because there reloading IS the way out. Everything else gets neither — a timeout or a `502` is
+ * worth repeating, and nothing about it says the loaded version is stale.
+ *
+ * ⚠️ Not `resourceErrorKey`: that maps a code onto a catalog key, and this case has no key to map
+ * onto — its whole content is the server's sentence.
+ */
+function saveRefusalText(error: unknown, i18n: I18n): string {
+  const refusal = error instanceof IntelRequestError ? error : null;
+  if (refusal?.status === 400 && refusal.code === "flow_graph_invalid") {
+    return i18n.t("flows.saveInvalid", { detail: refusal.message });
+  }
+  if (refusal?.status === 409) return i18n.t("flows.saveConflict");
+  return i18n.t("flows.saveFailed");
+}
+
 // ⚠️ The provider wraps the editor rather than sitting inside it: `useReactFlow` — which is how the
 // drop turns a screen point into a graph point — has to be called from a component UNDER it, and
 // the hook lives in the same component that renders the canvas.
@@ -401,6 +450,21 @@ function FlowsEditor() {
     queryKey: ["flows"],
     queryFn: () => data.listFlows(),
   });
+  /**
+   * The refusal of the top level, read off the query the picker already holds.
+   *
+   * ⚠️ No second query, and that is the whole difference to #445 next door: `["flows"]` is asked
+   * with or without a selection, so the answer for the empty screen is already in the cache. What
+   * the screen did was throw it away — `listTreeChildren` fails whole once `flows/read` is missing,
+   * the sidebar has said so since #430, and the main area beside it went on inviting the reader to
+   * pick a flow they cannot see (#557).
+   *
+   * ⚠️ Off the ERROR rather than off a missing answer. A sentence about a permission, shown while
+   * the request is still travelling, claims a refusal nobody has spoken yet — the mistake from #350,
+   * and `packages/ui/CLAUDE.md` has the rule: a missing answer is a reason to say less, never to
+   * refuse more. Until a refusal arrives, what stands is the invitation, which claims nothing.
+   */
+  const rootRefusal = refusalOf(callable.error);
   // The tree in the sidebar and the header search both name the flow to open through `?select=`;
   // `?view=` says how it is shown — the editor, the relation graph (#19) or the runs (#35).
   const selection = useRouterState({
@@ -426,6 +490,10 @@ function FlowsEditor() {
     queryFn: () => data.getFlow(selectedFlowId ?? ""),
     enabled: Boolean(selectedFlowId),
   });
+  // ⚠️ A refusal is not a failure. "Reload the latest version and try again." is advice for a
+  // network that came back; against a `403` or a `404` it sends somebody to reload a screen that
+  // will answer the same thing forever, and it hides that the answer was final (#430).
+  const documentRefusal = refusalOf(document.error);
   const initial = useMemo(() => canvas(defaultGraph()), []);
   const [nodes, setNodes] = useState<CanvasNode[]>(initial.nodes);
   const [edges, setEdges] = useState<CanvasEdge[]>(initial.edges);
@@ -450,6 +518,19 @@ function FlowsEditor() {
     setDirty(false);
   }, [document.data, selectedFlowId]);
   const selectedNode = nodes.find((node) => node.id === selectedNodeId) ?? null;
+  // ⚠️ The same query `FlowNeeds` asks, under the same key: TanStack answers both from one cache
+  // entry, so the canvas and the panel cannot end up disagreeing about which link is dead. A second
+  // key would be a second answer to one question, and the one people would trust is the one they
+  // happen to be looking at (#509).
+  const needs = useQuery({
+    queryKey: ["flow-requirements", selectedFlowId],
+    queryFn: () => data.getFlowRequirements(selectedFlowId ?? ""),
+    enabled: Boolean(selectedFlowId),
+  });
+  const invalidLinks = useMemo(
+    () => new Set(needs.data?.invalidNodes ?? []),
+    [needs.data?.invalidNodes],
+  );
 
   const save = useMutation({
     mutationFn: () =>
@@ -496,9 +577,25 @@ function FlowsEditor() {
       ) : null}
       <UnsavedChangesGuard dirty={dirty} />
       <div className="flex min-h-0 flex-1">
-        {selectedFlowId && selection.view === "runs" ? (
+        {!selectedFlowId ? (
+          rootRefusal ? (
+            <RefusalNotice refusal={rootRefusal} />
+          ) : (
+            <div className="grid flex-1 place-items-center p-8 text-sm text-muted-foreground">
+              {i18n.t("flows.select")}
+            </div>
+          )
+        ) : /* ⚠️ The refusal comes BEFORE the view switch, and that placement is the whole of #568.
+               `?view=graph` and `?view=runs` used to be read first, so a flow the reader may not
+               open still rendered its two side views — each with a failure sentence and a "Try
+               again" button on an answer that will not change (#430). Whether the reader may see
+               this flow at all is answered by `getFlow`, once, for every view of it; asking it
+               after the switch means asking it three times and getting two of them wrong. */
+        documentRefusal ? (
+          <RefusalNotice refusal={documentRefusal} />
+        ) : selection.view === "runs" ? (
           <FlowRuns flowId={selectedFlowId} />
-        ) : selectedFlowId && selection.view === "graph" ? (
+        ) : selection.view === "graph" ? (
           <GraphPane
             query={relations}
             select={(node) =>
@@ -508,10 +605,6 @@ function FlowsEditor() {
               })
             }
           />
-        ) : !selectedFlowId ? (
-          <div className="grid flex-1 place-items-center p-8 text-sm text-muted-foreground">
-            {i18n.t("flows.select")}
-          </div>
         ) : document.isError ? (
           <div
             role="alert"
@@ -566,102 +659,104 @@ function FlowsEditor() {
                   media query that sets the class, so both turn together and mid-session. What the
                   surfaces are actually coloured with is in `styles.css`, through the library's own
                   theming variables — for the same reason `.react-sigma` is there. */}
-              <ReactFlow<CanvasNode, CanvasEdge>
-                colorMode={theme}
-                nodes={nodes}
-                edges={edges}
-                nodeTypes={nodeTypes}
-                fitView
-                onNodesChange={(changes: NodeChange<CanvasNode>[]) => {
-                  if (editsNodes(changes)) setDirty(true);
-                  setNodes((current) => applyNodeChanges(changes, current));
-                }}
-                onEdgesChange={(changes: EdgeChange<CanvasEdge>[]) => {
-                  if (editsEdges(changes)) setDirty(true);
-                  setEdges((current) => applyEdgeChanges(changes, current));
-                }}
-                // ⚠️ The two meanings cannot be mixed on one edge: a line from a context point into
-                // a flow input would be stored as context and drawn as an attachment, while the
-                // author meant "and then". Refused at the point where it is still visible.
-                isValidConnection={(connection) =>
-                  (connection.sourceHandle === ContextHandle) ===
-                  (connection.targetHandle === ContextHandle)
-                }
-                onConnect={(connection: Connection) => {
-                  setDirty(true);
-                  setEdges((current) =>
-                    addEdge(
+              <InvalidLinks.Provider value={invalidLinks}>
+                <ReactFlow<CanvasNode, CanvasEdge>
+                  colorMode={theme}
+                  nodes={nodes}
+                  edges={edges}
+                  nodeTypes={nodeTypes}
+                  fitView
+                  onNodesChange={(changes: NodeChange<CanvasNode>[]) => {
+                    if (editsNodes(changes)) setDirty(true);
+                    setNodes((current) => applyNodeChanges(changes, current));
+                  }}
+                  onEdgesChange={(changes: EdgeChange<CanvasEdge>[]) => {
+                    if (editsEdges(changes)) setDirty(true);
+                    setEdges((current) => applyEdgeChanges(changes, current));
+                  }}
+                  // ⚠️ The two meanings cannot be mixed on one edge: a line from a context point into
+                  // a flow input would be stored as context and drawn as an attachment, while the
+                  // author meant "and then". Refused at the point where it is still visible.
+                  isValidConnection={(connection) =>
+                    (connection.sourceHandle === ContextHandle) ===
+                    (connection.targetHandle === ContextHandle)
+                  }
+                  onConnect={(connection: Connection) => {
+                    setDirty(true);
+                    setEdges((current) =>
+                      addEdge(
+                        {
+                          ...connection,
+                          id: crypto.randomUUID(),
+                          ...contextEdgeStyle(connection.sourceHandle === ContextHandle),
+                        },
+                        current,
+                      ),
+                    );
+                  }}
+                  onNodeClick={(_event, node) => setSelectedNodeId(node.id)}
+                  onPaneClick={() => {
+                    setSelectedNodeId(null);
+                    setPaletteOpen(false);
+                  }}
+                  // ⚠️ `copy`, not `move` (#75). The tree's own drop targets say `move`, and the two
+                  // have to feel different while the pointer is still travelling: dropping here makes
+                  // a node that POINTS at the row, it does not take the row out of its folder.
+                  onDragOver={(event) => {
+                    if (!event.dataTransfer.types.includes(TreeEntryMediaType)) return;
+                    event.preventDefault();
+                    event.dataTransfer.dropEffect = "copy";
+                  }}
+                  onDrop={(event) => {
+                    const payload = event.dataTransfer.getData(TreeEntryMediaType);
+                    if (!payload) return;
+                    event.preventDefault();
+                    const dropped = droppedEntry(payload);
+                    if (!dropped) return;
+                    const kind = flowKindOfEntry[dropped.kind];
+                    if (!kind) return;
+                    // Where the pointer let go, in the graph's own coordinates — not the screen's, or
+                    // the node would land somewhere else at every zoom level.
+                    const position = flow.screenToFlowPosition({
+                      x: event.clientX,
+                      y: event.clientY,
+                    });
+                    setDirty(true);
+                    setNodes((current) => [
+                      ...current,
                       {
-                        ...connection,
-                        id: crypto.randomUUID(),
-                        ...contextEdgeStyle(connection.sourceHandle === ContextHandle),
-                      },
-                      current,
-                    ),
-                  );
-                }}
-                onNodeClick={(_event, node) => setSelectedNodeId(node.id)}
-                onPaneClick={() => {
-                  setSelectedNodeId(null);
-                  setPaletteOpen(false);
-                }}
-                // ⚠️ `copy`, not `move` (#75). The tree's own drop targets say `move`, and the two
-                // have to feel different while the pointer is still travelling: dropping here makes
-                // a node that POINTS at the row, it does not take the row out of its folder.
-                onDragOver={(event) => {
-                  if (!event.dataTransfer.types.includes(TreeEntryMediaType)) return;
-                  event.preventDefault();
-                  event.dataTransfer.dropEffect = "copy";
-                }}
-                onDrop={(event) => {
-                  const payload = event.dataTransfer.getData(TreeEntryMediaType);
-                  if (!payload) return;
-                  event.preventDefault();
-                  const dropped = droppedEntry(payload);
-                  if (!dropped) return;
-                  const kind = flowKindOfEntry[dropped.kind];
-                  if (!kind) return;
-                  // Where the pointer let go, in the graph's own coordinates — not the screen's, or
-                  // the node would land somewhere else at every zoom level.
-                  const position = flow.screenToFlowPosition({
-                    x: event.clientX,
-                    y: event.clientY,
-                  });
-                  setDirty(true);
-                  setNodes((current) => [
-                    ...current,
-                    {
-                      id: `${kind}-${crypto.randomUUID()}`,
-                      type: "intel" as const,
-                      position,
-                      data: {
-                        node: {
-                          id: `${kind}-${crypto.randomUUID()}`,
-                          kind,
-                          label: dropped.title,
-                          position,
-                          configuration:
-                            kind === "subflow"
-                              ? { flowId: dropped.id, version: { mode: "latest" as const } }
-                              : { resourceId: dropped.id },
-                        } as FlowNode,
+                        id: `${kind}-${crypto.randomUUID()}`,
+                        type: "intel" as const,
+                        position,
+                        data: {
+                          node: {
+                            id: `${kind}-${crypto.randomUUID()}`,
+                            kind,
+                            label: dropped.title,
+                            position,
+                            configuration:
+                              kind === "subflow"
+                                ? { flowId: dropped.id, version: { mode: "latest" as const } }
+                                : { resourceId: dropped.id },
+                          } as FlowNode,
+                        },
                       },
-                    },
-                  ]);
-                }}
-              >
-                <Background />
-                {/* The overview map has no room for a label, so the start is marked there the only
+                    ]);
+                  }}
+                >
+                  <Background />
+                  {/* The overview map has no room for a label, so the start is marked there the only
                     way that is left: its own colour, from the tokens rather than a fixed value. */}
-                <MiniMap
-                  pannable
-                  zoomable
-                  nodeClassName={(node) =>
-                    (node as CanvasNode).data.node.kind === "trigger" ? "intel-minimap-start" : ""
-                  }
-                />
-                <Controls />
-              </ReactFlow>
+                  <MiniMap
+                    pannable
+                    zoomable
+                    nodeClassName={(node) =>
+                      (node as CanvasNode).data.node.kind === "trigger" ? "intel-minimap-start" : ""
+                    }
+                  />
+                  <Controls />
+                </ReactFlow>
+              </InvalidLinks.Provider>
             </section>
             <aside className="flex w-80 shrink-0 flex-col border-l bg-card">
               <TitleRowScrollArea className="min-h-0 flex-1 overflow-y-auto">
@@ -696,7 +791,7 @@ function FlowsEditor() {
           role="alert"
           className="fixed bottom-5 left-[18rem] z-20 rounded-lg border border-destructive/30 bg-card px-4 py-3 text-sm text-destructive shadow-xl"
         >
-          {i18n.t("flows.operationFailed")}
+          {saveRefusalText(save.error, i18n)}
         </p>
       )}
       {publishing && selectedFlowId && document.data?.flow.currentVersionId ? (
@@ -712,7 +807,9 @@ function FlowsEditor() {
             // graph that just changed.
             await Promise.all([
               queryClient.invalidateQueries({ queryKey: ["flow", selectedFlowId] }),
-              queryClient.invalidateQueries({ queryKey: ["flow-publish-preview", selectedFlowId] }),
+              queryClient.invalidateQueries({
+                queryKey: ["flow-publish-preview", selectedFlowId],
+              }),
               queryClient.invalidateQueries({ queryKey: ["relation-graph"] }),
             ]);
           }}
@@ -1249,11 +1346,13 @@ function FlowNeeds({ flowId }: { flowId: string }) {
     queryKey: ["flow-requirements", flowId],
     queryFn: () => data.getFlowRequirements(flowId),
   });
-  // ⚠️ A flow that touches nothing and a flow whose every reference is hidden are two different
-  // answers, so the counted ones keep the panel from claiming the first when it means the second.
+  // ⚠️ A flow that touches nothing and a flow whose every reference is hidden or dead are three
+  // different answers, so neither the counted nor the broken ones may fall out of this condition —
+  // otherwise the panel claims the first when it means one of the others.
   const empty =
     needs.data !== undefined &&
     needs.data.nodes.length === 0 &&
+    needs.data.invalidNodes.length === 0 &&
     needs.data.hiddenNodes === 0 &&
     needs.data.servers.length === 0;
   return (
@@ -1270,7 +1369,9 @@ function FlowNeeds({ flowId }: { flowId: string }) {
       {empty && <p className="mt-2 text-sm text-muted-foreground">{i18n.t("flows.needsEmpty")}</p>}
       {needs.data && !empty && (
         <>
-          {(needs.data.nodes.length > 0 || needs.data.hiddenNodes > 0) && (
+          {(needs.data.nodes.length > 0 ||
+            needs.data.invalidNodes.length > 0 ||
+            needs.data.hiddenNodes > 0) && (
             <>
               <h3 className="mt-4 text-xs font-medium uppercase tracking-wide text-muted-foreground">
                 {i18n.t("flows.needsNodes")}
@@ -1282,6 +1383,16 @@ function FlowNeeds({ flowId }: { flowId: string }) {
                     <span className="min-w-0 truncate">{reference.title}</span>
                   </li>
                 ))}
+                {/* ⚠️ A dead reference and an unreachable one are two entries, not one (#509).
+                    They used to share the counted line, which said "you cannot see it" about a
+                    document that is gone — a sentence about a permission, in front of something no
+                    permission can fix. This one says what to do instead, because there is exactly
+                    one thing to do: replace the step or take it out. */}
+                {needs.data.invalidNodes.length > 0 && (
+                  <li className="text-destructive">
+                    {i18n.t("flows.needsInvalid", { count: needs.data.invalidNodes.length })}
+                  </li>
+                )}
                 {/* ⚠️ Counted, never named. A title is exactly what someone without access to the
                     document may not learn from a list about it. */}
                 {needs.data.hiddenNodes > 0 && (

package/src/graph-pane/graph-pane.tsx

@@ -1,6 +1,8 @@
 import type { RelationGraph } from "@anchrd/intel-contract/flow";
 import type { UseQueryResult } from "@tanstack/react-query";
 import { lazy, Suspense } from "react";
+import { RefusalNotice } from "@/data/request-refusal/refusal-notice.tsx";
+import { refusalOf } from "@/data/request-refusal/request-refusal.ts";
 import { useI18n } from "@/i18n/i18n-context.tsx";
 
 const RelationGraphView = lazy(async () => ({
@@ -20,6 +22,13 @@ export function GraphPane({
   const i18n = useI18n();
   const loading = <p className="p-6 text-sm text-muted-foreground">{i18n.t("common.loading")}</p>;
   if (query.isPending) return loading;
+  // ⚠️ Read off this pane's OWN error, not handed down from the screen around it (#568). The screen
+  // above answers whether the flow or folder may be opened at all; this answers whether its
+  // relations may be read, and the graph endpoint can refuse on its own — an authorized folder
+  // whose graph is not shared. Two questions, so two places, and the one that is refused says so
+  // where it happened.
+  const refusal = refusalOf(query.error);
+  if (refusal) return <RefusalNotice refusal={refusal} />;
   if (query.isError || !query.data) {
     return (
       <div role="alert" className="grid flex-1 place-items-center p-8 text-center text-sm">

package/src/i18n/de.json

@@ -74,6 +74,7 @@
   "resource.move": "Verschieben",
   "resource.renameTitle": "{title} umbenennen",
   "resource.archive": "Archivieren",
+  "resource.columns": "Spalten",
   "resource.export": "Export",
   "resource.import": "Import",
   "resource.validate": "Prüfen",
@@ -117,6 +118,23 @@
   "node.table.summary": "{rows} Zeilen, {columns} Spalten",
   "node.table.empty": "Noch keine Zeilen. Zeilen werden von Flows angehängt.",
   "node.table.undefined": "Diese Tabelle hat noch keine Spalten.",
+  "node.table.columnsTitle": "Spalten von {title}",
+  "node.table.columnName": "Name der Spalte „{column}“",
+  "node.table.columnNewName": "Name der neuen Spalte",
+  "node.table.columnAdd": "Spalte hinzufügen",
+  "node.table.columnDrop": "Die Spalte „{column}“ entfernen",
+  "node.table.columnDropNew": "Die neue Spalte entfernen",
+  "node.table.columnsDistinct": "Zwei Spalten können nicht denselben Namen tragen.",
+  "node.table.columnsNamed": "Jede Spalte braucht einen Namen.",
+  "node.table.columnsAtLeastOne": "Eine Tabelle braucht mindestens eine Spalte.",
+  "node.table.columnsTooLong": "Ein Spaltenname darf höchstens 120 Zeichen lang sein.",
+  "node.table.columnsTooMany": "Eine Tabelle kann höchstens 64 Spalten haben.",
+  "node.table.columnsDropWarning.one": "Diese Spalte wird mitsamt allen Zellen darin entfernt: {columns}",
+  "node.table.columnsDropWarning.many": "Diese Spalten werden mitsamt allen Zellen darin entfernt: {columns}",
+  "node.table.columnsDropRows.none": "Keine Zeile trägt dort Inhalt, es geht also nichts mit ihnen verloren.",
+  "node.table.columnsDropRows.one": "Eine Zeile trägt dort Inhalt. Er bleibt im Versionsverlauf lesbar und sonst nirgends.",
+  "node.table.columnsDropRows.many": "{count} Zeilen tragen dort Inhalt. Er bleibt im Versionsverlauf lesbar und sonst nirgends.",
+  "node.table.columnsDropConfirm": "Entfernen und speichern",
   "node.select": "Wähle ein Dokument oder einen Ordner, um damit zu arbeiten.",
   "node.folderEmpty": "In diesem Ordner ist noch nichts. Lege etwas über das Plus in der Seitenleiste an.",
   "node.folderFailed": "Dieser Ordner konnte nicht gelesen werden.",
@@ -241,6 +259,7 @@
   "flows.node.condition": "Bedingung",
   "flows.node.subflow": "Flow",
   "flows.node.output": "Ende",
+  "flows.nodeInvalid": "Gibt es nicht mehr — ersetze oder entferne diesen Schritt",
   "flows.instruction": "Anweisung für die KI oder die Person",
   "flows.instructionHint": "Bedingungen, Prüfungen und Verzweigungen lassen sich hier in Worten beschreiben. Für jede kleine Entscheidung braucht es keinen eigenen Schritt.",
   "flows.linkEmpty": "Noch nichts gewählt",
@@ -275,9 +294,13 @@
   "flows.tool": "MCP-Server",
   "flows.selectTool": "Server auswählen",
   "flows.operationFailed": "Der Flow-Vorgang ist fehlgeschlagen. Lade die neueste Fassung und versuche es erneut.",
+  "flows.saveInvalid": "Nicht gespeichert: {detail}",
+  "flows.saveConflict": "Nicht gespeichert: Jemand anderes hat diesen Flow zuerst geändert. Lade die neueste Fassung und versuche es erneut.",
+  "flows.saveFailed": "Der Flow wurde nicht gespeichert. Versuche es erneut.",
   "flows.needs": "Was dieser Flow braucht",
   "flows.needsNodes": "Dokumente",
   "flows.needsTools": "Werkzeuge",
+  "flows.needsInvalid": "{count} weitere, die es nicht mehr gibt — ersetze oder entferne diese Schritte",
   "flows.needsHidden": "{count} weitere, die du nicht sehen kannst",
   "flows.needsEmpty": "Dieser Flow liest keine Dokumente und ruft keine Werkzeuge auf.",
   "flows.needsFailed": "Was dieser Flow braucht, konnte nicht geladen werden.",
@@ -344,6 +367,7 @@
   "common.loading": "Wird geladen …",
   "common.retry": "Erneut versuchen",
   "common.close": "Schließen",
+  "common.cancel": "Abbrechen",
   "common.unavailable": "Intel ist derzeit nicht verfügbar.",
   "common.noAccess": "Das ist für dich nicht verfügbar. Es existiert nicht, oder es ist nicht mehr für dich freigegeben.",
   "common.noPermission": "Dir fehlt die Berechtigung, das zu sehen.",

package/src/i18n/en.json

@@ -74,6 +74,7 @@
   "resource.move": "Move",
   "resource.renameTitle": "Rename {title}",
   "resource.archive": "Archive",
+  "resource.columns": "Columns",
   "resource.export": "Export",
   "resource.import": "Import",
   "resource.validate": "Check",
@@ -117,6 +118,23 @@
   "node.table.summary": "{rows} rows, {columns} columns",
   "node.table.empty": "No rows yet. Rows are appended by flows.",
   "node.table.undefined": "This table has no columns yet.",
+  "node.table.columnsTitle": "Columns of {title}",
+  "node.table.columnName": "Name of the column “{column}”",
+  "node.table.columnNewName": "Name of the new column",
+  "node.table.columnAdd": "Add column",
+  "node.table.columnDrop": "Remove the column “{column}”",
+  "node.table.columnDropNew": "Remove the new column",
+  "node.table.columnsDistinct": "Two columns cannot carry the same name.",
+  "node.table.columnsNamed": "Every column needs a name.",
+  "node.table.columnsAtLeastOne": "A table needs at least one column.",
+  "node.table.columnsTooLong": "A column name can be at most 120 characters long.",
+  "node.table.columnsTooMany": "A table can have at most 64 columns.",
+  "node.table.columnsDropWarning.one": "This column is removed with every cell in it: {columns}",
+  "node.table.columnsDropWarning.many": "These columns are removed with every cell in them: {columns}",
+  "node.table.columnsDropRows.none": "No row carries content there, so nothing is lost with them.",
+  "node.table.columnsDropRows.one": "One row carries content there. It stays readable in the version history and nowhere else.",
+  "node.table.columnsDropRows.many": "{count} rows carry content there. It stays readable in the version history and nowhere else.",
+  "node.table.columnsDropConfirm": "Remove and save",
   "node.select": "Select a document or folder to work with it.",
   "node.folderEmpty": "Nothing in this folder yet. Create something with the plus in the sidebar.",
   "node.folderFailed": "This folder could not be read.",
@@ -241,6 +259,7 @@
   "flows.node.condition": "Condition",
   "flows.node.subflow": "Flow",
   "flows.node.output": "End",
+  "flows.nodeInvalid": "Gone — replace or remove this step",
   "flows.instruction": "Instruction for the AI or person",
   "flows.instructionHint": "Conditions, checks and branches can be described here in words. You do not need a separate node for every small decision.",
   "flows.linkEmpty": "Nothing chosen yet",
@@ -275,9 +294,13 @@
   "flows.tool": "MCP server",
   "flows.selectTool": "Select a server",
   "flows.operationFailed": "The flow operation failed. Reload the latest version and try again.",
+  "flows.saveInvalid": "Not saved: {detail}",
+  "flows.saveConflict": "Not saved: somebody else changed this flow first. Reload the latest version and try again.",
+  "flows.saveFailed": "The flow was not saved. Try again.",
   "flows.needs": "What this flow needs",
   "flows.needsNodes": "Documents",
   "flows.needsTools": "Tools",
+  "flows.needsInvalid": "{count} more that no longer exist — replace or remove those steps",
   "flows.needsHidden": "{count} more you cannot see",
   "flows.needsEmpty": "This flow reads no documents and calls no tools.",
   "flows.needsFailed": "What this flow needs could not be loaded.",
@@ -344,6 +367,7 @@
   "common.loading": "Loading…",
   "common.retry": "Try again",
   "common.close": "Close",
+  "common.cancel": "Cancel",
   "common.unavailable": "Intel is currently unavailable.",
   "common.noAccess": "This is not available to you. It may not exist, or it may no longer be shared with you.",
   "common.noPermission": "You do not have permission to see this.",