@multiplatform.one/backoffice 6.7.0 → 7.0.0

package/src/form/FormToolbar.tsx

@@ -32,6 +32,9 @@ import {
 import { useLayoutSizeClass, useResolvedKnobs } from "@multiplatform.one/theme";
 import {
   ArrowCounterClockwiseIcon,
+  ArrowSquareOutIcon,
+  CaretLeftIcon,
+  CaretRightIcon,
   CheckCircleIcon,
   CopyIcon,
   DotsThreeIcon,
@@ -39,6 +42,7 @@ import {
   FloppyDiskIcon,
   LinkIcon,
   ListBulletsIcon,
+  MagnifyingGlassIcon,
   PencilSimpleIcon,
   PlusIcon,
   PrinterIcon,
@@ -197,7 +201,9 @@ export interface FormToolbarMenuItem {
     | "email"
     | "links"
     | "new"
-    | "list";
+    | "list"
+    | "desk"
+    | "jump";
   destructive?: boolean;
   disabled?: boolean;
   disabledReason?: string;
@@ -233,6 +239,23 @@ export interface FormToolbarProps {
    * menu item's action so existing consumers get the button for free.
    */
   onReload?: () => void;
+  /**
+   * "Open in Desk" hop — the document's native desk counterpart. Renders a
+   * standalone icon button on wide viewports (narrow keeps the ⋯ menu's
+   * `desk` entry as the only affordance, like Refresh).
+   */
+  onOpenDesk?: () => void;
+  /**
+   * Prev/next document pager (desk ‹ › parity) — pages through the list
+   * order the user came from. The pair renders only when the composing
+   * screen resolved a list context (no dead arrows on deep links); a
+   * boundary endpoint renders disabled instead of hiding (LC-40 honest
+   * disabled chrome keeps the pair spatially stable).
+   */
+  onPrevDoc?: () => void;
+  onNextDoc?: () => void;
+  prevDocDisabled?: boolean;
+  nextDocDisabled?: boolean;
 }
 
 const MENU_ICONS = {
@@ -245,6 +268,8 @@ const MENU_ICONS = {
   links: LinkIcon,
   new: PlusIcon,
   list: ListBulletsIcon,
+  desk: ArrowSquareOutIcon,
+  jump: MagnifyingGlassIcon,
 } as const;
 
 type LifecycleAction = "save" | "submit" | "cancel" | "amend";
@@ -267,6 +292,11 @@ export function FormToolbar({
   onAmend,
   menuItems,
   onReload,
+  onOpenDesk,
+  onPrevDoc,
+  onNextDoc,
+  prevDocDisabled,
+  nextDocDisabled,
 }: FormToolbarProps) {
   const { t } = useTranslation(BACKOFFICE_I18N_NAMESPACE);
   const { knobProps } = useResolvedKnobs();
@@ -360,7 +390,7 @@ export function FormToolbar({
           <Text
             role="heading"
             aria-level={1}
-            fontSize="$7"
+            fontSize="$6"
             fontWeight="700"
             color="$color12"
             numberOfLines={1}
@@ -377,6 +407,47 @@ export function FormToolbar({
         </XStack>
 
         <XStack alignItems="center" gap="$2" flexShrink={0}>
+          {(onPrevDoc || onNextDoc) && !isNarrow && (
+            <XStack
+              overflow="hidden"
+              {...knobProps.borderRadius}
+              borderWidth={1}
+              borderColor="$borderColor"
+            >
+              <Button
+                size={knobProps.sizeToken}
+                outlined
+                borderWidth={0}
+                borderRadius={0}
+                icon={<CaretLeftIcon size={16} />}
+                aria-label={t("prevDoc", "Previous document")}
+                disabled={prevDocDisabled}
+                onPress={onPrevDoc}
+                testID="form-toolbar-prev"
+              />
+              <Button
+                size={knobProps.sizeToken}
+                outlined
+                borderWidth={0}
+                borderRadius={0}
+                icon={<CaretRightIcon size={16} />}
+                aria-label={t("nextDoc", "Next document")}
+                disabled={nextDocDisabled}
+                onPress={onNextDoc}
+                testID="form-toolbar-next"
+              />
+            </XStack>
+          )}
+          {onOpenDesk && !isNarrow && (
+            <Button
+              size={knobProps.sizeToken}
+              outlined
+              icon={<ArrowSquareOutIcon size={16} />}
+              aria-label={t("openInDesk", "Open in Desk")}
+              onPress={onOpenDesk}
+              testID="form-toolbar-desk"
+            />
+          )}
           {reload && !isNarrow && (
             <Button
               size={knobProps.sizeToken}

package/src/form/formActions.ts

@@ -37,6 +37,10 @@ import type { FixtureProvider } from "@multiplatform.one/frappe";
 export interface FrappeConnection {
   baseURL: string;
   socketPort?: number;
+  /** Same-origin socket override (see FrappeConfig.socketBaseURL). */
+  socketBaseURL?: string;
+  /** Frappe site name — the realtime Socket.IO namespace. */
+  siteName?: string;
   auth?: {
     useToken?: boolean;
     token?: string | (() => string | Promise<string>);

package/src/form/formLayout.ts

@@ -29,6 +29,7 @@
  * empty card.
  */
 
+import { formatCalendarDate } from "@multiplatform.one/theme";
 import type { FieldSchema, FormSchema, FormSection } from "@multiplatform.one/frappe-ui";
 import { evaluateDependsOn } from "./dependsOn";
 import { canReadLevel, canWriteLevel, type PermLevelMatrix } from "./fieldPermissions";
@@ -289,20 +290,8 @@ export function buildFormTabs(options: BuildTabsOptions): FormTab[] {
 const LAYOUT_TYPES = new Set(["Section Break", "Column Break", "Tab Break", "Fold"]);
 const NUMERIC_TYPES = new Set(["Int", "Float", "Currency", "Percent", "Check", "Rating"]);
 
-function todayISO(): string {
-  const now = new Date();
-  const month = String(now.getMonth() + 1).padStart(2, "0");
-  const day = String(now.getDate()).padStart(2, "0");
-  return `${now.getFullYear()}-${month}-${day}`;
-}
-
-function nowTime(): string {
-  const now = new Date();
-  const hours = String(now.getHours()).padStart(2, "0");
-  const minutes = String(now.getMinutes()).padStart(2, "0");
-  const seconds = String(now.getSeconds()).padStart(2, "0");
-  return `${hours}:${minutes}:${seconds}`;
-}
+const todayISO = () => formatCalendarDate(new Date());
+const nowTime = () => formatCalendarDate(new Date(), "time");
 
 /**
  * Seed a create-mode doc from meta field defaults — desk parity with

package/src/form/platformHooks.ts

@@ -33,6 +33,39 @@ export function useSaveShortcut(enabled: boolean, onSave: () => void): void {
   }, [enabled]);
 }
 
+/**
+ * Ctrl/Cmd+↑ / Ctrl/Cmd+↓ → previous / next document (web only — desk's
+ * form pager shortcuts). Enabled only while the pager has list context, so
+ * the browser's default scroll behavior survives everywhere else.
+ */
+export function useDocPagerShortcuts(
+  enabled: boolean,
+  onPrev: () => void,
+  onNext: () => void,
+): void {
+  const handlersRef = useRef({ onPrev, onNext });
+  handlersRef.current = { onPrev, onNext };
+
+  useEffect(() => {
+    if (!enabled) return;
+    if (typeof document === "undefined" || typeof document.addEventListener !== "function") {
+      return;
+    }
+    const handler = (event: KeyboardEvent) => {
+      if (!(event.metaKey || event.ctrlKey) || event.shiftKey || event.altKey) return;
+      if (event.key === "ArrowUp") {
+        event.preventDefault();
+        handlersRef.current.onPrev();
+      } else if (event.key === "ArrowDown") {
+        event.preventDefault();
+        handlersRef.current.onNext();
+      }
+    };
+    document.addEventListener("keydown", handler);
+    return () => document.removeEventListener("keydown", handler);
+  }, [enabled]);
+}
+
 const NOOP_BLOCKER: BackofficeNavigationBlocker = {
   blocked: false,
   proceed: () => {},
@@ -90,3 +123,27 @@ export function openInNewTab(url: string): boolean {
 export function canOpenNewTab(): boolean {
   return true;
 }
+
+/**
+ * Ctrl/Cmd+J → Jump to field (web only — desk's form shortcut). Disabled
+ * while the jump dialog is already open so the search field can type "j".
+ */
+export function useJumpToFieldShortcut(enabled: boolean, onJump: () => void): void {
+  const jumpRef = useRef(onJump);
+  jumpRef.current = onJump;
+
+  useEffect(() => {
+    if (!enabled) return;
+    if (typeof document === "undefined" || typeof document.addEventListener !== "function") {
+      return;
+    }
+    const handler = (event: KeyboardEvent) => {
+      if (!(event.metaKey || event.ctrlKey) || event.shiftKey || event.altKey) return;
+      if (event.key.toLowerCase() !== "j") return;
+      event.preventDefault();
+      jumpRef.current();
+    };
+    document.addEventListener("keydown", handler);
+    return () => document.removeEventListener("keydown", handler);
+  }, [enabled]);
+}

package/src/form/timeline-entries.spec.ts

@@ -0,0 +1,180 @@
+// Pins the timeline's version-diff contract (desk parity: edits show
+// `field: old → new`): parseVersionData extracts display-safe from/to values
+// (HTML stripped, long values truncated, rich-only markup flagged) and
+// versionSummary renders them for single AND multi-field changes with
+// honest placeholders — never raw markup, never a bare field-name list
+// that hides the values.
+import { describe, expect, it } from "vitest";
+import {
+  buildTimelineFeed,
+  parseVersionData,
+  versionSummary,
+  type TimelineTranslate,
+} from "./timeline-entries";
+
+/** Interpolating fake translate — applies the defaultValue template. */
+const translate: TimelineTranslate = (_key, options) => {
+  let out = options.defaultValue;
+  for (const [key, value] of Object.entries(options)) {
+    if (key === "defaultValue") continue;
+    out = out.split(`{{${key}}}`).join(String(value));
+  }
+  return out;
+};
+
+const data = (payload: unknown) => JSON.stringify(payload);
+
+describe("parseVersionData", () => {
+  it("extracts from/to for changed fields", () => {
+    const parsed = parseVersionData(data({ changed: [["status", "Open", "Closed"]] }));
+    expect(parsed?.changed).toEqual([{ field: "status", from: "Open", to: "Closed" }]);
+  });
+
+  it("strips HTML markup from rich-text values (never raw tags in the feed)", () => {
+    const parsed = parseVersionData(
+      data({ changed: [["description", "<p>old copy</p>", "<div>new <b>copy</b></div>"]] }),
+    );
+    expect(parsed?.changed).toEqual([{ field: "description", from: "old copy", to: "new copy" }]);
+  });
+
+  it("flags rich markup with no extractable text instead of faking empty", () => {
+    const parsed = parseVersionData(
+      data({ changed: [["description", '<img src="x.png">', "<p>now text</p>"]] }),
+    );
+    expect(parsed?.changed).toEqual([{ field: "description", fromRich: true, to: "now text" }]);
+  });
+
+  it("truncates long values with an ellipsis", () => {
+    const long = "x".repeat(80);
+    const parsed = parseVersionData(data({ changed: [["subject", long, "short"]] }));
+    const from = parsed?.changed[0]?.from ?? "";
+    expect(from.length).toBe(50);
+    expect(from.endsWith("…")).toBe(true);
+  });
+
+  it("treats null/undefined/empty as absent values", () => {
+    const parsed = parseVersionData(data({ changed: [["middle_name", "", null]] }));
+    expect(parsed?.changed).toEqual([{ field: "middle_name" }]);
+  });
+
+  it("keeps numeric and object values displayable", () => {
+    const parsed = parseVersionData(
+      data({
+        changed: [
+          ["priority", 0, 1],
+          ["meta", { a: 1 }, "b"],
+        ],
+      }),
+    );
+    expect(parsed?.changed[0]).toEqual({ field: "priority", from: "0", to: "1" });
+    expect(parsed?.changed[1]).toEqual({ field: "meta", from: '{"a":1}', to: "b" });
+  });
+
+  it("collects child-table field lists (deduped)", () => {
+    const parsed = parseVersionData(
+      data({
+        changed: [],
+        added: [
+          ["items", {}],
+          ["items", {}],
+          ["taxes", {}],
+        ],
+        removed: [["items", {}]],
+        row_changed: [["taxes", 0, "x", []]],
+      }),
+    );
+    expect(parsed?.added).toEqual(["items", "taxes"]);
+    expect(parsed?.removed).toEqual(["items"]);
+    expect(parsed?.rowChanged).toEqual(["taxes"]);
+  });
+
+  it("returns undefined for malformed or empty payloads", () => {
+    expect(parseVersionData(undefined)).toBeUndefined();
+    expect(parseVersionData("")).toBeUndefined();
+    expect(parseVersionData("{not json")).toBeUndefined();
+    expect(parseVersionData(data(["array-root"]))).toBeUndefined();
+    expect(parseVersionData(data({ changed: [] }))).toBeUndefined();
+    expect(parseVersionData(data({ changed: [["", "a", "b"]] }))).toBeUndefined();
+  });
+});
+
+describe("versionSummary", () => {
+  it("renders a single change as field from → to", () => {
+    const parsed = parseVersionData(data({ changed: [["status", "Open", "Closed"]] }));
+    expect(versionSummary(parsed!, translate)).toBe("changed value of Status from Open to Closed");
+  });
+
+  it("renders (empty) placeholders for absent sides", () => {
+    const parsed = parseVersionData(data({ changed: [["middle_name", "", "ParityAudit"]] }));
+    expect(versionSummary(parsed!, translate)).toBe(
+      "changed value of Middle Name from (empty) to ParityAudit",
+    );
+  });
+
+  it("renders every field's old → new in multi-field changes (desk parity)", () => {
+    const parsed = parseVersionData(
+      data({
+        changed: [
+          ["description", "<p>alpha</p>", "<p>beta</p>"],
+          ["status", "Open", "Closed"],
+        ],
+      }),
+    );
+    expect(versionSummary(parsed!, translate)).toBe(
+      "changed values for Description from alpha to beta, Status from Open to Closed",
+    );
+  });
+
+  it("renders the rich-content placeholder instead of raw markup", () => {
+    const parsed = parseVersionData(
+      data({ changed: [["description", '<img src="a.png">', "<p>text now</p>"]] }),
+    );
+    expect(versionSummary(parsed!, translate)).toBe(
+      "changed value of Description from (formatted content) to text now",
+    );
+  });
+
+  it("appends child-table sentences after value changes", () => {
+    const parsed = parseVersionData(
+      data({
+        changed: [["status", "Open", "Closed"]],
+        added: [["items", {}]],
+        removed: [["taxes", {}]],
+        row_changed: [["items", 0, "qty", []]],
+      }),
+    );
+    expect(versionSummary(parsed!, translate)).toBe(
+      "changed value of Status from Open to Closed, added rows for Items, " +
+        "removed rows for Taxes, changed rows for Items",
+    );
+  });
+});
+
+describe("buildTimelineFeed pending (optimistic) comments", () => {
+  it("marks __optimistic overlay rows as pending; server rows stay unmarked", () => {
+    const feed = buildTimelineFeed({
+      comments: [
+        {
+          name: "SRV-1",
+          creation: "2026-08-13 10:00:00",
+          content: "<div>confirmed</div>",
+          owner: "a@example.com",
+        },
+        {
+          name: "tmp_abc",
+          creation: "2026-08-13 11:00:00",
+          content: "<div>optimistic</div>",
+          owner: "a@example.com",
+          __optimistic: true,
+        },
+      ],
+    });
+    expect(feed).toHaveLength(2);
+    // Newest first: the pending row sorts by its client timestamp.
+    expect(feed[0].docname).toBe("tmp_abc");
+    expect(feed[0].pending).toBe(true);
+    expect(feed[0].content).toBe("optimistic");
+    expect(feed[1].docname).toBe("SRV-1");
+    expect(feed[1].pending).toBeUndefined();
+  });
+});

package/src/form/timeline-entries.tsx

@@ -24,6 +24,8 @@ export interface TimelineRowLike {
   sender_full_name?: unknown;
   subject?: unknown;
   communication_date?: unknown;
+  /** Optimistic overlay rows: applied locally, awaiting server ack */
+  __optimistic?: unknown;
 }
 
 export interface TimelineUserInfoLike {
@@ -63,6 +65,13 @@ export interface VersionFieldChange {
   field: string;
   from?: string;
   to?: string;
+  /**
+   * The raw value was rich markup with no extractable text (an image-only
+   * Text Editor value, say) — render an honest "(formatted content)"
+   * placeholder instead of pretending the value was empty or dumping tags.
+   */
+  fromRich?: boolean;
+  toRich?: boolean;
 }
 
 export interface ParsedVersionData {
@@ -91,6 +100,11 @@ export interface TimelineFeedEntry extends TimelineEntry {
   version?: ParsedVersionData;
   /** Epoch millis used for the newest-first sort */
   epoch: number;
+  /**
+   * Applied locally, awaiting server ack (Axiom 6 HONEST STATE: renders
+   * visible but distinct; row actions are withheld until identity is real).
+   */
+  pending?: boolean;
 }
 
 interface BuildOptions {
@@ -144,17 +158,37 @@ function timestampFields(raw: unknown): TimestampFields {
   };
 }
 
-function displayValue(value: unknown): string | undefined {
-  if (value === null || value === undefined) return undefined;
+interface DisplayValue {
+  text?: string;
+  /** Non-empty rich markup that strips to no text (image-only HTML etc.) */
+  rich?: boolean;
+}
+
+/** Looks like markup (an opening/closing tag) — worth an htmlToText pass. */
+const HTML_TAG = /<[a-z!/][^>]*>/i;
+
+/**
+ * Display form of a version diff value: objects JSON-stringify, HTML strips
+ * to its text (Text Editor / HTML fields must never leak raw markup into
+ * the feed), and everything truncates. Markup with no extractable text
+ * flags `rich` so the renderer can show an honest placeholder.
+ */
+function displayValue(value: unknown): DisplayValue {
+  if (value === null || value === undefined) return {};
   if (typeof value === "object") {
     try {
-      return truncateText(JSON.stringify(value));
+      return { text: truncateText(JSON.stringify(value)) };
     } catch {
-      return undefined;
+      return {};
     }
   }
   const text = String(value).trim();
-  return text ? truncateText(text) : undefined;
+  if (!text) return {};
+  if (HTML_TAG.test(text)) {
+    const stripped = htmlToText(text);
+    return stripped ? { text: truncateText(stripped) } : { rich: true };
+  }
+  return { text: truncateText(text) };
 }
 
 // ── version data parsing ───────────────────────────────────────────────────
@@ -179,7 +213,15 @@ export function parseVersionData(data: unknown): ParsedVersionData | undefined {
       if (!Array.isArray(row) || row.length === 0) continue;
       const field = str(row[0]);
       if (!field) continue;
-      changed.push({ field, from: displayValue(row[1]), to: displayValue(row[2]) });
+      const from = displayValue(row[1]);
+      const to = displayValue(row[2]);
+      changed.push({
+        field,
+        ...(from.text !== undefined ? { from: from.text } : {}),
+        ...(to.text !== undefined ? { to: to.text } : {}),
+        ...(from.rich ? { fromRich: true } : {}),
+        ...(to.rich ? { toRich: true } : {}),
+      });
     }
   }
   const tableFields = (value: unknown): string[] => {
@@ -205,31 +247,57 @@ export type TimelineTranslate = (
 ) => string;
 
 /**
- * Desk-parity version sentence: single field change reads
- * "changed value of X from a to b"; multi-field and child-table changes
- * collapse to field lists ("changed values for X, Y" / "added rows for Z").
+ * Display form of one side of a field change: value text, or an honest
+ * placeholder — "(empty)" for a truly empty value, "(formatted content)"
+ * for rich markup that strips to no text (never the raw tags).
+ */
+function changeSideLabel(
+  text: string | undefined,
+  rich: boolean | undefined,
+  translate: TimelineTranslate,
+): string {
+  if (text !== undefined) return text;
+  if (rich) {
+    return translate("timeline.richContent", { defaultValue: "(formatted content)" });
+  }
+  return translate("timeline.emptyValue", { defaultValue: "(empty)" });
+}
+
+/**
+ * Desk-parity version sentence: every changed field renders its old → new
+ * values ("changed value of X from a to b"; multi-field changes list each
+ * field's from/to). Child-table changes stay field lists ("added rows for
+ * Z"). Values arrive pre-truncated and markup-stripped from
+ * parseVersionData.
  */
 export function versionSummary(version: ParsedVersionData, translate: TimelineTranslate): string {
   const parts: string[] = [];
   const fieldList = (fields: string[]) => fields.map(humanizeFieldname).join(", ");
   if (version.changed.length === 1) {
     const change = version.changed[0];
-    const empty = translate("timeline.emptyValue", {
-      defaultValue: "(empty)",
-    });
     parts.push(
       translate("timeline.changedValue", {
         defaultValue: "changed value of {{field}} from {{from}} to {{to}}",
         field: humanizeFieldname(change.field),
-        from: change.from ?? empty,
-        to: change.to ?? empty,
+        from: changeSideLabel(change.from, change.fromRich, translate),
+        to: changeSideLabel(change.to, change.toRich, translate),
       }),
     );
   } else if (version.changed.length > 1) {
+    // Desk shows each field's from → to; keep that honesty here instead of
+    // collapsing to bare field names.
+    const fragments = version.changed.map((change) =>
+      translate("timeline.changedValueItem", {
+        defaultValue: "{{field}} from {{from}} to {{to}}",
+        field: humanizeFieldname(change.field),
+        from: changeSideLabel(change.from, change.fromRich, translate),
+        to: changeSideLabel(change.to, change.toRich, translate),
+      }),
+    );
     parts.push(
       translate("timeline.changedValues", {
         defaultValue: "changed values for {{fields}}",
-        fields: fieldList(version.changed.map((change) => change.field)),
+        fields: fragments.join(", "),
       }),
     );
   }
@@ -276,6 +344,7 @@ function commentEntry(row: TimelineRowLike, options: BuildOptions): TimelineFeed
     ...timestampFields(row.creation),
     content: htmlToText(html),
     html,
+    ...(row.__optimistic === true ? { pending: true } : {}),
   };
 }
 

package/src/i18n/en.ts

@@ -87,11 +87,25 @@ export const en = {
   workspaceEmpty: "This workspace is empty",
   workspaceEmptyDescription: "No blocks have been added to {{workspace}} yet",
   workspaceShortcuts: "Shortcuts",
+  // Form surface (flat keys — DocFormScreen/FormToolbar vocabulary).
+  savedToast: "Saved",
+  submittedToast: "Submitted",
+  cancelledToast: "Cancelled",
+  prevDoc: "Previous document",
+  nextDoc: "Next document",
+  validationSummary_one: "Cannot save — {{count}} required field is missing.",
+  validationSummary_other: "Cannot save — {{count}} required fields are missing.",
+  timeline: {
+    changedValueItem: "{{field}} from {{from}} to {{to}}",
+    richContent: "(formatted content)",
+  },
   list: {
-    assignBody: "Assign {{count}} selected document(s)",
+    assignBody_one: "Assign {{count}} selected document",
+    assignBody_other: "Assign {{count}} selected documents",
     assignComment: "Comment",
     assignConfirm: "Assign",
-    assignDone: "Assigned {{count}} document(s) to {{user}}",
+    assignDone_one: "Assigned {{count}} document to {{user}}",
+    assignDone_other: "Assigned {{count}} documents to {{user}}",
     assignFailed: "Assignment failed",
     assignTitle: "Assign To",
     assignUser: "Assign to user",
@@ -118,13 +132,16 @@ export const en = {
     docstatusPartial: "Processed {{count}} of {{total}} documents; failed: {{names}}",
     docstatusQueued_one: "{{action}} of {{count}} document queued in the background",
     docstatusQueued_other: "{{action}} of {{count}} documents queued in the background",
-    editBody: "Set one field on {{count}} selected document(s)",
+    editBody_one: "Set one field on {{count}} selected document",
+    editBody_other: "Set one field on {{count}} selected documents",
     editConfirm: "Update",
-    editDone: "Updated {{field}} on {{count}} document(s)",
+    editDone_one: "Updated {{field}} on {{count}} document",
+    editDone_other: "Updated {{field}} on {{count}} documents",
     editFailed: "Bulk edit failed",
     editField: "Field",
     editFieldPlaceholder: "Select a field",
-    editPartial: "Updated {{ok}} document(s); {{failed}} failed ({{names}})",
+    editPartial_one: "Updated {{count}} document; {{failed}} failed ({{names}})",
+    editPartial_other: "Updated {{count}} documents; {{failed}} failed ({{names}})",
     editPickField: "Pick a field to update",
     editSelectPlaceholder: "Select a value",
     editTitle: "Bulk Edit",
@@ -213,12 +230,15 @@ export const en = {
     submitDone_one: "Submitted {{count}} document",
     submitDone_other: "Submitted {{count}} documents",
     submitTitle: "Submit documents",
-    tagBody: "Tag {{count}} selected document(s)",
+    tagBody_one: "Tag {{count}} selected document",
+    tagBody_other: "Tag {{count}} selected documents",
     tagConfirm: "Add Tag",
-    tagDone: 'Added tag "{{tag}}" to {{count}} document(s)',
+    tagDone_one: 'Added tag "{{tag}}" to {{count}} document',
+    tagDone_other: 'Added tag "{{tag}}" to {{count}} documents',
     tagFailed: "Tagging failed",
     tagField: "Tag",
-    tagPartial: "Tagged {{ok}} document(s); {{failed}} failed ({{names}})",
+    tagPartial_one: "Tagged {{count}} document; {{failed}} failed ({{names}})",
+    tagPartial_other: "Tagged {{count}} documents; {{failed}} failed ({{names}})",
     tagPlaceholder: "New or existing tag name",
     tagTitle: "Add Tags",
     tagging: "Tagging…",
@@ -244,6 +264,7 @@ export const en = {
   },
   queryReport: {
     apply: "Apply",
+    clearFilter: "Clear {{label}}",
     disabledDescription: "Enable the report from its Report document to run it",
     disabledTitle: '"{{report}}" is disabled',
     emptyDescription: "The report ran but returned no rows",
@@ -255,8 +276,10 @@ export const en = {
     retry: "Retry",
     rowCount: "{{count}} row(s)",
     runError: 'Could not run "{{report}}"',
+    scriptFiltersGap:
+      "Some of this report's filters are defined in code and aren't supported here yet",
     scriptFiltersHint:
-      "Some reports require filters that are declared in desk-side scripts and cannot be derived here yet",
+      "Some of this report's filters are declared in desk-side scripts and could not be derived here",
     selectValue: "Select...",
   },
   report: {