@multiplatform.one/backoffice 6.7.0 → 7.0.0

package/src/report/useQueryReport.ts

@@ -1,16 +1,24 @@
 // Data hook for frappe Query / Script Reports (the desk
 // /app/query-report/<name> surface): loads the Report doc (title,
-// ref_doctype, doc-level filters) and runs frappe.desk.query_report.run.
-// Wire-shape normalization (and the probed response documentation) lives in
-// reportShapes.ts; this file owns fetch/state.
+// ref_doctype, doc-level filters) plus the desk-side script module
+// (frappe.desk.query_report.get_script) and runs
+// frappe.desk.query_report.run. Wire-shape normalization (and the probed
+// response documentation) lives in reportShapes.ts; this file owns
+// fetch/state.
 //
 //   GET /api/method/frappe.client.get {doctype:"Report", name}
 //   → {message: {report_name, ref_doctype, report_type, disabled,
 //      prepared_report, add_total_row, filters: [...], ...}}
+//   GET /api/method/frappe.desk.query_report.get_script {report_name}
+//   → {message: {script, html_format, execution_time, filters}}
 //
-// Doc-level filters (the Report `filters` child table) are the only filter
-// meta derivable via the API; standard reports declare filters in desk-side
-// JS files instead, so a failed run surfaces a hint rather than blocking.
+// Filter meta sources (desk precedence, query_report.js setup): the script
+// module's declarative `filters` win when the script declares any; the
+// Report doc `filters` child table applies only when it doesn't. Script
+// filters are extracted from the raw JS text without eval
+// (reportShapes.extractScriptFilters) — entries beyond the declarative
+// subset (get_query functions, dynamic defaults, desk-only fieldtypes)
+// surface as `scriptFilterGap` so the screen can render an honest note.
 // `ignore_prepared_report` forces a synchronous run for prepared reports
 // (desk's background Prepared Report queue is out of scope here).
 import type { FrappeApp } from "@multiplatform.one/frappe";
@@ -24,6 +32,9 @@ import {
   type QueryReportMeta,
   type QueryReportRow,
   type QueryReportRunMessage,
+  buildRunFilters,
+  defaultFilterValues,
+  extractScriptFilters,
   humanizeFrappeError,
   isEmptyFilterValue,
   normalizeFilterMeta,
@@ -32,6 +43,11 @@ import {
 } from "./reportShapes";
 
 export {
+  buildRunFilters,
+  compactQueryReportFilters,
+  defaultFilterValues,
+  extractScriptFilters,
+  isEmptyFilterValue,
   normalizeQueryReportColumns,
   normalizeQueryReportRows,
   scrubFieldname,
@@ -44,9 +60,11 @@ export type {
   QueryReportFixture,
   QueryReportMeta,
   QueryReportRow,
+  ScriptFilterExtraction,
 } from "./reportShapes";
 
 const RUN_METHOD = "frappe.desk.query_report.run";
+const SCRIPT_METHOD = "frappe.desk.query_report.get_script";
 
 export interface UseQueryReportOptions {
   fixture?: QueryReportFixture;
@@ -58,7 +76,7 @@ export interface UseQueryReportResult {
   meta?: QueryReportMeta;
   columns: QueryReportColumn[];
   rows: QueryReportRow[];
-  /** True until the first meta+run cycle settles. */
+  /** True until the first meta+script+run cycle settles. */
   loading: boolean;
   /** True while a (re)run is in flight. */
   running: boolean;
@@ -67,9 +85,14 @@ export interface UseQueryReportResult {
   serverMessage?: string;
   /** Server-reported run time in seconds. */
   executionTime?: number;
-  /** Doc-level filter meta (empty for reports with desk-JS filters). */
+  /** Merged filter meta: script-declared filters, else doc-level rows. */
   filterMeta: QueryReportFilterMeta[];
-  /** Mandatory doc-level filters currently unfilled — the run is skipped while non-empty. */
+  /**
+   * True when the desk script declares filters this surface could not
+   * derive (non-declarative entries) — the honest "defined in code" note.
+   */
+  scriptFilterGap: boolean;
+  /** Mandatory filters currently unfilled — the run is skipped while non-empty. */
   missingRequired: QueryReportFilterMeta[];
   filters: QueryReportFilters;
   setFilters: (next: QueryReportFilters) => void;
@@ -86,6 +109,14 @@ async function fetchReportMeta(app: FrappeApp, reportName: string): Promise<Quer
   return doc;
 }
 
+async function fetchReportScript(app: FrappeApp, reportName: string): Promise<string | undefined> {
+  const res = await app.call().get<{ message?: { script?: string | null } }>(SCRIPT_METHOD, {
+    report_name: reportName,
+  });
+  const script = res.payload?.message?.script;
+  return typeof script === "string" ? script : undefined;
+}
+
 export function useQueryReport(
   reportName: string,
   options: UseQueryReportOptions = {},
@@ -98,7 +129,8 @@ export function useQueryReport(
   initialFiltersRef.current = options.initialFilters;
 
   const [meta, setMeta] = useState<QueryReportMeta | undefined>(undefined);
-  const [metaSettled, setMetaSettled] = useState(false);
+  const [script, setScript] = useState<string | undefined>(undefined);
+  const [sourcesSettled, setSourcesSettled] = useState(false);
   const [filters, setFiltersState] = useState<QueryReportFilters>(() => ({
     ...initialFiltersRef.current,
   }));
@@ -120,7 +152,8 @@ export function useQueryReport(
     lastReport.current = reportName;
     setFiltersState({ ...initialFiltersRef.current });
     setMeta(undefined);
-    setMetaSettled(false);
+    setScript(undefined);
+    setSourcesSettled(false);
     setColumns([]);
     setRows([]);
     setError(undefined);
@@ -129,53 +162,79 @@ export function useQueryReport(
     setLoading(true);
   }, [reportName]);
 
-  // Report doc meta (title, ref_doctype, doc-level filters). Failure is
-  // non-fatal — the run below is still attempted.
+  // Report doc meta (title, ref_doctype, doc filters) + the desk script
+  // module, fetched together. Both are non-fatal niceties — the run below
+  // reports the real errors — but the run waits for them so declared
+  // defaults are seeded into the FIRST run (desk parity).
   useEffect(() => {
     if (fixture) return;
     if (!app) {
-      setMetaSettled(true);
+      setSourcesSettled(true);
       return;
     }
     let cancelled = false;
-    setMetaSettled(false);
-    fetchReportMeta(app, reportName)
-      .then((doc) => {
+    setSourcesSettled(false);
+    Promise.allSettled([fetchReportMeta(app, reportName), fetchReportScript(app, reportName)]).then(
+      ([metaResult, scriptResult]) => {
         if (cancelled) return;
-        setMeta(doc);
-        // Seed doc-level filter defaults once per report; user edits win.
+        const doc = metaResult.status === "fulfilled" ? metaResult.value : undefined;
+        const scriptText = scriptResult.status === "fulfilled" ? scriptResult.value : undefined;
+        if (doc) setMeta(doc);
+        if (scriptText) setScript(scriptText);
+        // Seed filter defaults once per report; user edits (and deep-link
+        // initialFilters, already in state) win over defaults.
         if (seededFor.current !== reportName) {
           seededFor.current = reportName;
-          const defaults: QueryReportFilters = {};
-          for (const filter of normalizeFilterMeta(doc.filters)) {
-            if (filter.default !== undefined && filter.default !== "")
-              defaults[filter.fieldname] = filter.default;
-          }
+          const extraction = extractScriptFilters(scriptText);
+          const merged = extraction.declared
+            ? extraction.filters
+            : normalizeFilterMeta(doc?.filters);
+          const defaults = defaultFilterValues(merged);
           if (Object.keys(defaults).length > 0)
             setFiltersState((previous) => ({ ...defaults, ...previous }));
         }
-      })
-      .catch(() => {
-        // meta is a nicety (title/filters); the run reports real errors
-      })
-      .finally(() => {
-        if (!cancelled) setMetaSettled(true);
-      });
+        setSourcesSettled(true);
+      },
+    );
     return () => {
       cancelled = true;
     };
   }, [app, fixture, reportName]);
 
-  const filterMeta = useMemo(
+  const scriptExtraction = useMemo(
+    () => extractScriptFilters(fixture ? fixture.script : script),
+    [fixture, script],
+  );
+  const docFilterMeta = useMemo(
     () => normalizeFilterMeta(fixture ? fixture.meta?.filters : meta?.filters),
     [fixture, meta],
   );
+  // Desk precedence (query_report.js): the script module's filters apply
+  // when the script declares the key at all; doc rows only otherwise.
+  const filterMeta = useMemo(
+    () => (scriptExtraction.declared ? scriptExtraction.filters : docFilterMeta),
+    [scriptExtraction, docFilterMeta],
+  );
+  const scriptFilterGap = scriptExtraction.declaredCount > scriptExtraction.filters.length;
 
+  // Fixture branch seeds defaults too (no fetch effect runs for fixtures).
+  useEffect(() => {
+    if (!fixture) return;
+    if (seededFor.current === reportName) return;
+    seededFor.current = reportName;
+    const defaults = defaultFilterValues(filterMeta);
+    if (Object.keys(defaults).length > 0)
+      setFiltersState((previous) => ({ ...defaults, ...previous }));
+  }, [fixture, reportName, filterMeta]);
+
+  // Desk parity: defaults SEED the controls (state) once; after that the
+  // gate reads the live values only — clearing a defaulted mandatory filter
+  // re-gates instead of firing a doomed run (desk's get_filter_values reads
+  // control values, not declarations).
   const missingRequired = useMemo(
     () =>
       filterMeta.filter(
-        (filter) =>
-          filter.mandatory === 1 && isEmptyFilterValue(filters[filter.fieldname] ?? filter.default),
+        (filter) => filter.mandatory === 1 && isEmptyFilterValue(filters[filter.fieldname]),
       ),
     [filterMeta, filters],
   );
@@ -184,7 +243,7 @@ export function useQueryReport(
 
   useEffect(() => {
     if (fixture) return;
-    if (!metaSettled) return;
+    if (!sourcesSettled) return;
     if (metaDisabled) {
       setLoading(false);
       return;
@@ -207,7 +266,7 @@ export function useQueryReport(
       .call()
       .post<{ message?: QueryReportRunMessage }>(RUN_METHOD, {
         report_name: reportName,
-        filters,
+        filters: buildRunFilters(filterMeta, filters),
         ignore_prepared_report: 1,
       })
       .then((res) => {
@@ -241,8 +300,9 @@ export function useQueryReport(
     fixture,
     reportName,
     filters,
+    filterMeta,
     generation,
-    metaSettled,
+    sourcesSettled,
     metaDisabled,
     hasMissingRequired,
   ]);
@@ -277,6 +337,7 @@ export function useQueryReport(
       serverMessage: fixture?.message,
       executionTime: undefined,
       filterMeta,
+      scriptFilterGap,
       missingRequired,
       filters,
       setFilters,
@@ -294,6 +355,7 @@ export function useQueryReport(
     serverMessage,
     executionTime,
     filterMeta,
+    scriptFilterGap,
     missingRequired,
     filters,
     setFilters,

package/src/shared/deskLinks.spec.ts

@@ -0,0 +1,38 @@
+import { describe, expect, it } from "vitest";
+import { deskDocUrl, deskViewUrl } from "./deskLinks";
+
+const BASE = "http://127.0.0.1:8000";
+
+describe("deskDocUrl", () => {
+  it("builds the desk form route from doctype + name", () => {
+    expect(deskDocUrl(BASE, "Pokemon", "pikachu")).toBe(`${BASE}/app/pokemon/pikachu`);
+  });
+
+  it("slugs multi-word doctypes like frappe.router.slug", () => {
+    expect(deskDocUrl(BASE, "Kanban Board", "Test Board")).toBe(
+      `${BASE}/app/kanban-board/Test%20Board`,
+    );
+  });
+
+  it("encodes reserved characters in doc names", () => {
+    expect(deskDocUrl(BASE, "ToDo", "a/b?c#d")).toBe(`${BASE}/app/todo/a%2Fb%3Fc%23d`);
+  });
+
+  it("trims trailing slashes off the base URL", () => {
+    expect(deskDocUrl(`${BASE}/`, "User", "test@example.com")).toBe(
+      `${BASE}/app/user/test%40example.com`,
+    );
+  });
+});
+
+describe("deskViewUrl", () => {
+  it("list view is desk's bare slug route", () => {
+    expect(deskViewUrl(BASE, "ToDo")).toBe(`${BASE}/app/todo`);
+    expect(deskViewUrl(BASE, "ToDo", "list")).toBe(`${BASE}/app/todo`);
+  });
+
+  it("alternate views ride /view/<view>", () => {
+    expect(deskViewUrl(BASE, "ToDo", "kanban")).toBe(`${BASE}/app/todo/view/kanban`);
+    expect(deskViewUrl(BASE, "Sales Order", "report")).toBe(`${BASE}/app/sales-order/view/report`);
+  });
+});

package/src/shared/deskLinks.ts

@@ -0,0 +1,31 @@
+/**
+ * Desk deep links: backoffice surfaces always offer an "Open in Desk" hop to
+ * their native frappe/desk counterpart (`…/app/<slug>[/<name>|/view/<view>]`),
+ * the mirror of feature screens deep-linking INTO the backoffice. URL shapes
+ * follow desk's router: `frappe.router.slug` doctype slugs, encoded doc
+ * names, and bare-slug list routes.
+ */
+
+import { toSlug, type BackofficeView } from "../navigation/paths";
+
+function trimBase(baseURL: string): string {
+  return baseURL.replace(/\/+$/, "");
+}
+
+/** Desk form page for one document: `<base>/app/<slug>/<encoded name>`. */
+export function deskDocUrl(baseURL: string, doctype: string, name: string): string {
+  return `${trimBase(baseURL)}/app/${toSlug(doctype)}/${encodeURIComponent(name)}`;
+}
+
+/**
+ * Desk view page for a doctype. List is desk's bare slug route; every other
+ * view rides `/view/<view>` (desk and backoffice share the view vocabulary).
+ */
+export function deskViewUrl(
+  baseURL: string,
+  doctype: string,
+  view: BackofficeView = "list",
+): string {
+  const base = `${trimBase(baseURL)}/app/${toSlug(doctype)}`;
+  return view === "list" ? base : `${base}/view/${view}`;
+}

package/src/shared/listNavContext.spec.ts

@@ -0,0 +1,83 @@
+// The prev/next pager's context channel: DoctypeListScreen writes the last
+// list order, DocFormScreen reads neighbors. Pins the honest-affordance
+// contract — no context (deep link) resolves to inList=false so the pager
+// hides instead of rendering dead arrows.
+import { beforeEach, describe, expect, it } from "vitest";
+import {
+  getListNavContext,
+  getListNavNeighbors,
+  resetListNavContext,
+  setListNavContext,
+} from "./listNavContext";
+
+describe("listNavContext", () => {
+  beforeEach(() => {
+    resetListNavContext();
+    sessionStorage.clear();
+  });
+
+  it("round-trips the list order per doctype", () => {
+    setListNavContext("ToDo", ["a", "b", "c"]);
+    setListNavContext("User", ["x", "y"]);
+    expect(getListNavContext("ToDo")).toEqual(["a", "b", "c"]);
+    expect(getListNavContext("User")).toEqual(["x", "y"]);
+  });
+
+  it("returns undefined when no context was ever written", () => {
+    expect(getListNavContext("ToDo")).toBeUndefined();
+  });
+
+  it("ignores empty writes so fetch-in-flight renders keep the last order", () => {
+    setListNavContext("ToDo", ["a", "b"]);
+    setListNavContext("ToDo", []);
+    expect(getListNavContext("ToDo")).toEqual(["a", "b"]);
+  });
+
+  it("drops non-string and empty names from writes", () => {
+    setListNavContext("ToDo", ["a", "", "b"]);
+    expect(getListNavContext("ToDo")).toEqual(["a", "b"]);
+  });
+
+  it("computes neighbors at the middle of the order", () => {
+    setListNavContext("ToDo", ["a", "b", "c"]);
+    expect(getListNavNeighbors("ToDo", "b")).toEqual({ inList: true, prev: "a", next: "c" });
+  });
+
+  it("omits prev at the first entry and next at the last (boundary honesty)", () => {
+    setListNavContext("ToDo", ["a", "b", "c"]);
+    expect(getListNavNeighbors("ToDo", "a")).toEqual({ inList: true, next: "b" });
+    expect(getListNavNeighbors("ToDo", "c")).toEqual({ inList: true, prev: "b" });
+  });
+
+  it("reports inList=false for a document outside the last order (deep link)", () => {
+    setListNavContext("ToDo", ["a", "b"]);
+    expect(getListNavNeighbors("ToDo", "zz")).toEqual({ inList: false });
+    expect(getListNavNeighbors("Role", "a")).toEqual({ inList: false });
+  });
+
+  it("survives a reload through the sessionStorage mirror", () => {
+    setListNavContext("ToDo", ["a", "b", "c"]);
+    // Simulate a reload: module memory is gone, sessionStorage persists.
+    const stored = sessionStorage.getItem("backoffice:listNav:ToDo");
+    resetListNavContext();
+    expect(stored).not.toBeNull();
+    sessionStorage.setItem("backoffice:listNav:ToDo", stored as string);
+    expect(getListNavContext("ToDo")).toEqual(["a", "b", "c"]);
+    expect(getListNavNeighbors("ToDo", "b")).toEqual({ inList: true, prev: "a", next: "c" });
+  });
+
+  it("ignores a corrupted sessionStorage mirror", () => {
+    sessionStorage.setItem("backoffice:listNav:ToDo", "{not json");
+    expect(getListNavContext("ToDo")).toBeUndefined();
+    sessionStorage.setItem("backoffice:listNav:ToDo", JSON.stringify({ nope: true }));
+    expect(getListNavContext("ToDo")).toBeUndefined();
+  });
+
+  it("skips identical rewrites (table state fires every render)", () => {
+    setListNavContext("ToDo", ["a", "b"]);
+    const first = getListNavContext("ToDo");
+    setListNavContext("ToDo", ["a", "b"]);
+    // Same array identity — the write bailed instead of re-mirroring.
+    expect(getListNavContext("ToDo")).toBe(first);
+  });
+});

package/src/shared/listNavContext.ts

@@ -0,0 +1,115 @@
+/**
+ * Last list-result order per doctype — the prev/next document pager's
+ * context channel (desk parity: a form opened FROM a list pages through
+ * that list's neighbors in the same order).
+ *
+ * Write side: DoctypeListScreen mirrors each resolved table page here
+ * (display order, current page). Read side: DocFormScreen looks the open
+ * document up and pages through its neighbors. The store is module-level
+ * (writer and reader never co-mount, so React state buys nothing) with a
+ * sessionStorage mirror on web so the context survives a reload honestly —
+ * a deep link with no context renders no pager at all (LC-40: no dead
+ * arrows).
+ */
+
+/** Cap stored context so a huge page size cannot bloat sessionStorage. */
+const MAX_NAMES = 1000;
+
+const memory = new Map<string, string[]>();
+
+function storageKey(doctype: string): string {
+  return `backoffice:listNav:${doctype}`;
+}
+
+function readStorage(doctype: string): string[] | undefined {
+  try {
+    if (typeof sessionStorage === "undefined") return undefined;
+    const raw = sessionStorage.getItem(storageKey(doctype));
+    if (!raw) return undefined;
+    const parsed: unknown = JSON.parse(raw);
+    if (!Array.isArray(parsed)) return undefined;
+    const names = parsed.filter(
+      (name): name is string => typeof name === "string" && name.length > 0,
+    );
+    return names.length > 0 ? names : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+function writeStorage(doctype: string, names: string[]): void {
+  try {
+    if (typeof sessionStorage === "undefined") return;
+    sessionStorage.setItem(storageKey(doctype), JSON.stringify(names));
+  } catch {
+    // Quota / private-mode failures degrade to in-memory context.
+  }
+}
+
+/**
+ * Record the doctype's current list order. Empty writes are ignored on
+ * purpose: the table reports state on every render, including the
+ * fetch-in-flight passes where `data` is still `[]` — wiping the context
+ * there would kill the pager whenever the list remounts.
+ */
+export function setListNavContext(doctype: string, names: readonly string[]): void {
+  const cleaned = names
+    .filter((name): name is string => typeof name === "string" && name.length > 0)
+    .slice(0, MAX_NAMES);
+  if (cleaned.length === 0) return;
+  const existing = memory.get(doctype);
+  if (
+    existing &&
+    existing.length === cleaned.length &&
+    existing.every((name, index) => name === cleaned[index])
+  ) {
+    return;
+  }
+  memory.set(doctype, cleaned);
+  writeStorage(doctype, cleaned);
+}
+
+/** The last recorded list order for a doctype (memory, then reload mirror). */
+export function getListNavContext(doctype: string): readonly string[] | undefined {
+  const inMemory = memory.get(doctype);
+  if (inMemory) return inMemory;
+  const stored = readStorage(doctype);
+  if (stored) memory.set(doctype, stored);
+  return stored;
+}
+
+export interface ListNavNeighbors {
+  /** True when `name` is part of the doctype's last list result. */
+  inList: boolean;
+  prev?: string;
+  next?: string;
+}
+
+/** Neighbors of `name` in the doctype's last list order. */
+export function getListNavNeighbors(doctype: string, name: string): ListNavNeighbors {
+  const names = getListNavContext(doctype);
+  if (!names) return { inList: false };
+  const index = names.indexOf(name);
+  if (index < 0) return { inList: false };
+  const prev = index > 0 ? names[index - 1] : undefined;
+  const next = index < names.length - 1 ? names[index + 1] : undefined;
+  return {
+    inList: true,
+    ...(prev !== undefined ? { prev } : {}),
+    ...(next !== undefined ? { next } : {}),
+  };
+}
+
+/** Hard-reset (tests). Clears memory and the sessionStorage mirror. */
+export function resetListNavContext(): void {
+  try {
+    if (typeof sessionStorage !== "undefined") {
+      for (const doctype of memory.keys()) {
+        sessionStorage.removeItem(storageKey(doctype));
+      }
+    }
+  } catch {
+    // storage unavailable — memory reset below still applies
+  }
+  memory.clear();
+}

package/src/shared/useDocinfo.ts

@@ -67,6 +67,83 @@ function cacheKey(doctype: string, name: string) {
   return `${doctype}\u0000${name}`;
 }
 
+// ---------------------------------------------------------------------------
+// Optimistic overlays (the docinfo arm of the ONE optimistic pattern)
+// ---------------------------------------------------------------------------
+//
+// An overlay is a pure patch composed ON TOP of the fetched docinfo every
+// time subscribers read it. Optimistic mutations (add comment, assign, tag…)
+// apply as overlays instead of editing the base value, so:
+//   - a racing full refetch replaces the BASE and the pending record
+//     survives (overlays re-compose on the new base);
+//   - rollback is exact — remove the overlay, the base was never touched;
+//   - reconcile promotes the ack payload into the base (authoritative
+//     server identity) and drops the overlay in one notification, so the
+//     optimistic record and the server record converge instead of
+//     duplicating.
+// Overlay records should carry a pending marker (e.g. `__optimistic: true`)
+// so surfaces render them visible-but-distinct (Axiom 6 HONEST STATE).
+
+interface DocinfoOverlay {
+  key: string;
+  patch: (info: DocInfo) => DocInfo;
+}
+
+let overlaySeq = 0;
+const docinfoOverlays = new Map<string, DocinfoOverlay>();
+
+function composeDocinfo(key: string, base: DocInfo | undefined): DocInfo | undefined {
+  if (!base) return base;
+  let composed = base;
+  for (const overlay of docinfoOverlays.values()) {
+    if (overlay.key === key) composed = overlay.patch(composed);
+  }
+  return composed;
+}
+
+function notifyDocinfo(key: string) {
+  const entry = docinfoCache.get(key);
+  if (entry) for (const listener of entry.listeners) listener();
+}
+
+/**
+ * Adds an optimistic overlay to a document's docinfo and wakes subscribers.
+ * Returns the overlay id for {@link removeDocinfoOverlay}. The patch must be
+ * pure — it re-runs on every read, including on refetched bases.
+ */
+export function addDocinfoOverlay(
+  doctype: string,
+  name: string,
+  patch: (info: DocInfo) => DocInfo,
+): string {
+  const key = cacheKey(doctype, name);
+  const id = `overlay_${++overlaySeq}`;
+  docinfoOverlays.set(id, { key, patch });
+  notifyDocinfo(key);
+  return id;
+}
+
+/** Removes an optimistic overlay (rollback or post-reconcile) and wakes subscribers. */
+export function removeDocinfoOverlay(id: string) {
+  const overlay = docinfoOverlays.get(id);
+  if (!overlay) return;
+  docinfoOverlays.delete(id);
+  notifyDocinfo(overlay.key);
+}
+
+/**
+ * Permanently patches the fetched docinfo base (reconcile step — promote a
+ * server ack into the shared store without a refetch). No-ops when the base
+ * has not resolved yet; the in-flight fetch will include the change.
+ */
+export function patchDocinfoBase(doctype: string, name: string, patch: (info: DocInfo) => DocInfo) {
+  const key = cacheKey(doctype, name);
+  const entry = docinfoCache.get(key);
+  if (!entry?.value) return;
+  entry.value = patch(entry.value);
+  notifyDocinfo(key);
+}
+
 /**
  * Shared, deduped fetch of frappe's docinfo for a document. Multiple panels
  * (sidebar, timeline, connections) share one fetch; `reload()` from any of
@@ -123,14 +200,14 @@ export function useDocinfo(
     const currentEntry = entry;
     const sync = () => {
       if (!cancelled && currentEntry.value) {
-        setDocinfo(currentEntry.value);
+        setDocinfo(composeDocinfo(key, currentEntry.value));
         setLoading(false);
       }
     };
     currentEntry.listeners.add(sync);
     setLoading(!currentEntry.value);
     setError(undefined);
-    if (currentEntry.value) setDocinfo(currentEntry.value);
+    if (currentEntry.value) setDocinfo(composeDocinfo(key, currentEntry.value));
     currentEntry.promise.catch((err: Error) => {
       if (!cancelled) {
         setError(err);

package/src/shared/useDoctypeMeta.ts

@@ -80,6 +80,10 @@ export interface DoctypeMeta {
   istable?: 0 | 1;
   is_submittable?: 0 | 1;
   is_tree?: 0 | 1;
+  /** Desk treeview_settings asset (`{doctype}_tree.js`) — gates Tree. */
+  __tree_js?: string;
+  /** Desk calendar_settings asset (`{doctype}_calendar.js`) — gates Calendar. */
+  __calendar_js?: string;
   is_virtual?: 0 | 1;
   editable_grid?: 0 | 1;
   track_changes?: 0 | 1;