@platforma-sdk/ui-vue 1.54.13 → 1.55.0

package/src/defineApp.ts

@@ -9,10 +9,9 @@ import {
   getPlatformaApiVersion,
   unwrapResult,
   type BlockOutputsBase,
-  type Platforma,
   type BlockModelInfo,
 } from "@platforma-sdk/model";
-import type { Component, Reactive } from "vue";
+import type { App as VueApp, Component, Reactive } from "vue";
 import { inject, markRaw, reactive } from "vue";
 import { createAppV1, type BaseAppV1 } from "./internal/createAppV1";
 import { createAppV2, type BaseAppV2 } from "./internal/createAppV2";
@@ -21,6 +20,7 @@ import type { AppSettings, ExtendSettings, Routes } from "./types";
 import { activateAgGrid } from "./aggrid";
 
 const pluginKey = Symbol("sdk-vue");
+export const pluginDataKey = Symbol("plugin-data-access");
 
 export function useSdkPlugin(): SdkPlugin {
   return inject(pluginKey)!;
@@ -57,39 +57,28 @@ export function defineApp<
 export function defineApp<
   Args = unknown,
   Outputs extends BlockOutputsBase = BlockOutputsBase,
-  Data = unknown,
+  UiState = unknown,
   Href extends `/${string}` = `/${string}`,
   Extend extends ExtendSettings<Href> = ExtendSettings<Href>,
 >(
-  platforma: PlatformaV3<Args, Outputs, Data, Href> & {
-    blockModelInfo: BlockModelInfo;
-  },
-  extendApp: (app: BaseAppV3<Args, Outputs, Data, Href>) => Extend,
-  settings?: AppSettings,
-): SdkPluginV3<Args, Outputs, Data, Href, Extend>;
+  platforma: PlatformaExtended<
+    PlatformaV1<Args, Outputs, UiState, Href> | PlatformaV2<Args, Outputs, UiState, Href>
+  >,
 
-export function defineApp<
-  Args = unknown,
-  Outputs extends BlockOutputsBase = BlockOutputsBase,
-  UiStateOrData = unknown,
-  Href extends `/${string}` = `/${string}`,
-  Extend extends ExtendSettings<Href> = ExtendSettings<Href>,
->(
-  platforma: PlatformaExtended<Platforma<Args, Outputs, UiStateOrData, Href>>,
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   extendApp: (app: any) => Extend,
   settings: AppSettings = {},
-): SdkPlugin<Args, Outputs, UiStateOrData, Href, Extend> {
+):
+  | SdkPluginV1<Args, Outputs, UiState, Href, Extend>
+  | SdkPluginV2<Args, Outputs, UiState, Href, Extend> {
   let app:
-    | undefined
-    | AppV1<Args, Outputs, UiStateOrData, Href, Extend>
-    | AppV2<Args, Outputs, UiStateOrData, Href, Extend>
-    | AppV3<Args, Outputs, UiStateOrData, Href, Extend> = undefined;
+    | AppV1<Args, Outputs, UiState, Href, Extend>
+    | AppV2<Args, Outputs, UiState, Href, Extend>
+    | undefined = undefined;
 
   activateAgGrid();
 
   const runtimeApiVersion = platforma.apiVersion ?? 1; // undefined means 1 (backward compatibility)
-
   const blockRequestedApiVersion = getPlatformaApiVersion();
 
   const loadApp = async () => {
@@ -101,7 +90,7 @@ export function defineApp<
     if (platforma.apiVersion === undefined || platforma.apiVersion === 1) {
       await platforma.loadBlockState().then((state) => {
         plugin.loaded = true;
-        const baseApp = createAppV1<Args, Outputs, UiStateOrData, Href>(state, platforma, settings);
+        const baseApp = createAppV1<Args, Outputs, UiState, Href>(state, platforma, settings);
 
         const localState = extendApp(baseApp);
 
@@ -117,13 +106,13 @@ export function defineApp<
           getRoute(href: Href): Component | undefined {
             return routes[href];
           },
-        } as unknown as AppV1<Args, Outputs, UiStateOrData, Href, Extend>);
+        } as unknown as AppV1<Args, Outputs, UiState, Href, Extend>);
       });
     } else if (platforma.apiVersion === 2) {
       await platforma.loadBlockState().then((stateOrError) => {
         const state = unwrapResult(stateOrError);
         plugin.loaded = true;
-        const baseApp = createAppV2<Args, Outputs, UiStateOrData, Href>(state, platforma, settings);
+        const baseApp = createAppV2<Args, Outputs, UiState, Href>(state, platforma, settings);
 
         const localState = extendApp(baseApp);
 
@@ -139,50 +128,106 @@ export function defineApp<
           getRoute(href: Href): Component | undefined {
             return routes[href];
           },
-        } as unknown as AppV2<Args, Outputs, UiStateOrData, Href, Extend>);
+        } as unknown as AppV2<Args, Outputs, UiState, Href, Extend>);
       });
-    } else if (platforma.apiVersion === 3) {
-      await platforma.loadBlockState().then((stateOrError) => {
-        const state = unwrapResult(stateOrError);
-        plugin.loaded = true;
-        const baseApp = createAppV3<Args, Outputs, UiStateOrData, Href>(state, platforma, settings);
+    }
+  };
 
-        const localState = extendApp(baseApp);
+  const plugin = reactive({
+    apiVersion: platforma.apiVersion ?? 1,
+    loaded: false,
+    error: undefined as unknown,
+    useApp<PageHref extends Href = Href>() {
+      return notEmpty(app, "App is not loaded") as
+        | AppV1<Args, Outputs, UiState, PageHref, Extend>
+        | AppV2<Args, Outputs, UiState, PageHref, Extend>;
+    },
+    install(app: VueApp) {
+      app.provide(pluginKey, this);
+      loadApp().catch((err) => {
+        console.error("load initial state error", err);
+        plugin.error = err;
+      });
+    },
+  });
 
-        const routes = Object.fromEntries(
-          Object.entries(localState.routes as Routes<Href>).map(([href, component]) => {
-            const c = typeof component === "function" ? component() : component;
-            return [href, markRaw(c as Component)];
-          }),
-        );
+  return plugin as
+    | SdkPluginV1<Args, Outputs, UiState, Href, Extend>
+    | SdkPluginV2<Args, Outputs, UiState, Href, Extend>;
+}
 
-        app = Object.assign(baseApp, {
-          ...localState,
-          getRoute(href: Href): Component | undefined {
-            return routes[href];
-          },
-        } as unknown as AppV3<Args, Outputs, UiStateOrData, Href, Extend>);
-      });
+export function defineAppV3<
+  Data = unknown,
+  Args = unknown,
+  Outputs extends BlockOutputsBase = BlockOutputsBase,
+  Href extends `/${string}` = `/${string}`,
+  Extend extends ExtendSettings<Href> = ExtendSettings<Href>,
+>(
+  platforma: PlatformaV3<Data, Args, Outputs, Href> & {
+    blockModelInfo: BlockModelInfo;
+  },
+  extendApp: (app: BaseAppV3<Data, Args, Outputs, Href>) => Extend,
+  settings: AppSettings = {},
+): SdkPluginV3<Data, Args, Outputs, Href, Extend> {
+  let app: AppV3<Data, Args, Outputs, Href, Extend> | undefined = undefined;
+
+  // Captured during install() so V3 can provide plugin data access after async load
+  let vueAppInstance: VueApp | undefined;
+
+  activateAgGrid();
+
+  const runtimeApiVersion = 3;
+  const blockRequestedApiVersion = getPlatformaApiVersion();
+
+  const loadApp = async () => {
+    if (blockRequestedApiVersion !== runtimeApiVersion) {
+      throw new Error(`Block requested API version ${blockRequestedApiVersion} but runtime API version is ${runtimeApiVersion}.
+      Please update the desktop app to use the latest API version.`);
     }
+
+    await platforma.loadBlockState().then((stateOrError) => {
+      const state = unwrapResult(stateOrError);
+      plugin.loaded = true;
+      const { app: baseApp, pluginAccess } = createAppV3<Data, Args, Outputs, Href>(
+        state,
+        platforma,
+        settings,
+      );
+
+      if (!vueAppInstance) {
+        throw new Error(
+          "Plugin data injection failed: Vue app instance not captured during install()",
+        );
+      }
+      vueAppInstance.provide(pluginDataKey, pluginAccess);
+
+      const localState = extendApp(baseApp);
+
+      const routes = Object.fromEntries(
+        Object.entries(localState.routes as Routes<Href>).map(([href, component]) => {
+          const c = typeof component === "function" ? component() : component;
+          return [href, markRaw(c as Component)];
+        }),
+      );
+
+      app = Object.assign(baseApp, {
+        ...localState,
+        getRoute(href: Href): Component | undefined {
+          return routes[href];
+        },
+      } as unknown as AppV3<Data, Args, Outputs, Href, Extend>);
+    });
   };
 
   const plugin = reactive({
-    apiVersion: platforma.apiVersion ?? 1,
+    apiVersion: 3,
     loaded: false,
     error: undefined as unknown,
-    // Href to get typed query parameters for a specific route
     useApp<PageHref extends Href = Href>() {
-      return notEmpty(app, "App is not loaded") as App<
-        Args,
-        Outputs,
-        UiStateOrData,
-        PageHref,
-        Extend
-      >;
+      return notEmpty(app, "App is not loaded") as AppV3<Data, Args, Outputs, PageHref, Extend>;
     },
-    // @todo type portability issue with Vue
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    install(app: any) {
+    install(app: VueApp) {
+      vueAppInstance = app;
       app.provide(pluginKey, this);
       loadApp().catch((err) => {
         console.error("load initial state error", err);
@@ -191,7 +236,7 @@ export function defineApp<
     },
   });
 
-  return plugin as SdkPlugin<Args, Outputs, UiStateOrData, Href, Extend>;
+  return plugin as SdkPluginV3<Data, Args, Outputs, Href, Extend>;
 }
 
 export type AppV1<
@@ -213,24 +258,17 @@ export type AppV2<
   Reactive<Omit<Local, "routes">> & { getRoute(href: Href): Component | undefined };
 
 export type AppV3<
-  Args = unknown,
-  Outputs extends BlockOutputsBase = BlockOutputsBase,
   Data = unknown,
+  Args = unknown,
+  Outputs extends BlockOutputsBase = NonNullable<unknown>,
   Href extends `/${string}` = `/${string}`,
   Local extends ExtendSettings<Href> = ExtendSettings<Href>,
-> = BaseAppV3<Args, Outputs, Data, Href> &
+> = BaseAppV3<Data, Args, Outputs, Href> &
   Reactive<Omit<Local, "routes">> & { getRoute(href: Href): Component | undefined };
 
-export type App<
-  Args = unknown,
-  Outputs extends BlockOutputsBase = BlockOutputsBase,
-  UiState = unknown,
-  Href extends `/${string}` = `/${string}`,
-  Local extends ExtendSettings<Href> = ExtendSettings<Href>,
-> =
-  | AppV1<Args, Outputs, UiState, Href, Local>
-  | AppV2<Args, Outputs, UiState, Href, Local>
-  | AppV3<Args, Outputs, UiState, Href, Local>;
+// ---------------------------------------------------------------------------
+// SdkPlugin types
+// ---------------------------------------------------------------------------
 
 export type SdkPluginV1<
   Args = unknown,
@@ -243,7 +281,7 @@ export type SdkPluginV1<
   loaded: boolean;
   error: unknown;
   useApp<PageHref extends Href = Href>(): AppV1<Args, Outputs, UiState, PageHref, Local>;
-  install(app: unknown): void;
+  install(app: VueApp): void;
 };
 
 export type SdkPluginV2<
@@ -257,30 +295,21 @@ export type SdkPluginV2<
   loaded: boolean;
   error: unknown;
   useApp<PageHref extends Href = Href>(): AppV2<Args, Outputs, UiState, PageHref, Local>;
-  install(app: unknown): void;
+  install(app: VueApp): void;
 };
 
 export type SdkPluginV3<
+  Data = unknown,
   Args = unknown,
   Outputs extends BlockOutputsBase = BlockOutputsBase,
-  Data = unknown,
   Href extends `/${string}` = `/${string}`,
   Local extends ExtendSettings<Href> = ExtendSettings<Href>,
 > = {
   apiVersion: 3;
   loaded: boolean;
   error: unknown;
-  useApp<PageHref extends Href = Href>(): AppV3<Args, Outputs, Data, PageHref, Local>;
-  install(app: unknown): void;
+  useApp<PageHref extends Href = Href>(): AppV3<Data, Args, Outputs, PageHref, Local>;
+  install(app: VueApp): void;
 };
 
-export type SdkPlugin<
-  Args = unknown,
-  Outputs extends BlockOutputsBase = BlockOutputsBase,
-  UiState = unknown,
-  Href extends `/${string}` = `/${string}`,
-  Local extends ExtendSettings<Href> = ExtendSettings<Href>,
-> =
-  | SdkPluginV1<Args, Outputs, UiState, Href, Local>
-  | SdkPluginV2<Args, Outputs, UiState, Href, Local>
-  | SdkPluginV3<Args, Outputs, UiState, Href, Local>;
+export type SdkPlugin = SdkPluginV1 | SdkPluginV2 | SdkPluginV3;

package/src/internal/createAppV3.ts

@@ -7,19 +7,33 @@ import type {
   PlatformaV3,
   ValueWithUTag,
   AuthorMarker,
+  PlatformaExtended,
+} from "@platforma-sdk/model";
+import {
+  hasAbortError,
+  unwrapResult,
+  deriveDataFromStorage,
+  getPluginData,
+  normalizeBlockStorage,
 } from "@platforma-sdk/model";
-import { hasAbortError, unwrapResult, deriveDataFromStorage } from "@platforma-sdk/model";
 import type { Ref } from "vue";
 import { reactive, computed, ref } from "vue";
 import type { OutputValues, OutputErrors, AppSettings } from "../types";
 import { parseQuery } from "../urls";
-import { MultiError } from "../utils";
+import { ensureOutputHasStableFlag, MultiError } from "../utils";
 import { applyPatch } from "fast-json-patch";
 import { UpdateSerializer } from "./UpdateSerializer";
 import { watchIgnorable } from "@vueuse/core";
 
 export const patchPoolingDelay = 150;
 
+/** Internal interface for plugin data access — injected separately from the app. */
+export interface PluginDataAccess {
+  readonly pluginDataMap: Record<string, unknown>;
+  setPluginData(pluginId: string, value: unknown): Promise<boolean>;
+  initPluginDataSlot(pluginId: string): void;
+}
+
 export const createNextAuthorMarker = (marker: AuthorMarker | undefined): AuthorMarker => ({
   authorId: marker?.authorId ?? uniqueId(),
   localVersion: (marker?.localVersion ?? 0) + 1,
@@ -48,13 +62,13 @@ const stringifyForDebug = (v: unknown) => {
  * @returns A reactive application object with methods, getters, and state.
  */
 export function createAppV3<
+  Data = unknown,
   Args = unknown,
   Outputs extends BlockOutputsBase = BlockOutputsBase,
-  Data = unknown,
   Href extends `/${string}` = `/${string}`,
 >(
-  state: ValueWithUTag<BlockStateV3<Outputs, Data, Href>>,
-  platforma: PlatformaV3<Args, Outputs, Data, Href>,
+  state: ValueWithUTag<BlockStateV3<Data, Outputs, Href>>,
+  platforma: PlatformaExtended<PlatformaV3<Data, Args, Outputs, Href>>,
   settings: AppSettings,
 ) {
   const debug = (msg: string, ...rest: unknown[]) => {
@@ -98,7 +112,19 @@ export function createAppV3<
   const debounceSpan = settings.debounceSpan ?? 200;
 
   const setDataQueue = new UpdateSerializer({ debounceSpan });
+  const pluginDataQueues = new Map<string, UpdateSerializer>();
+  const getPluginDataQueue = (pluginId: string): UpdateSerializer => {
+    let queue = pluginDataQueues.get(pluginId);
+    if (!queue) {
+      queue = new UpdateSerializer({ debounceSpan });
+      pluginDataQueues.set(pluginId, queue);
+    }
+    return queue;
+  };
   const setNavigationStateQueue = new UpdateSerializer({ debounceSpan });
+
+  /** Reactive map of plugin data keyed by pluginId. Optimistic state for plugin components. */
+  const pluginDataMap = reactive<Record<string, unknown>>({});
   /**
    * Reactive snapshot of the application state, including args, outputs, UI state, and navigation state.
    */
@@ -113,7 +139,20 @@ export function createAppV3<
   }>;
 
   const updateData = async (value: Data) => {
-    return platforma.mutateStorage({ operation: "update-data", value }, nextAuthorMarker());
+    return platforma.mutateStorage({ operation: "update-block-data", value }, nextAuthorMarker());
+  };
+
+  const updatePluginData = async (pluginId: string, value: unknown) => {
+    return platforma.mutateStorage(
+      { operation: "update-plugin-data", pluginId, value },
+      nextAuthorMarker(),
+    );
+  };
+
+  /** Derives plugin data for a given pluginId from the current snapshot. */
+  const derivePluginDataFromSnapshot = (pluginId: string): unknown => {
+    const storage = normalizeBlockStorage(snapshot.value.blockStorage);
+    return getPluginData(storage, pluginId);
   };
 
   const setNavigationState = async (state: NavigationState<Href>) => {
@@ -122,7 +161,15 @@ export function createAppV3<
 
   const outputs = computed<OutputValues<Outputs>>(() => {
     const entries = Object.entries(snapshot.value.outputs as Partial<Readonly<Outputs>>).map(
-      ([k, vOrErr]) => [k, vOrErr.ok && vOrErr.value !== undefined ? vOrErr.value : undefined],
+      ([k, outputWithStatus]) =>
+        platforma.blockModelInfo.outputs[k]?.withStatus
+          ? [k, ensureOutputHasStableFlag(outputWithStatus)]
+          : [
+              k,
+              outputWithStatus.ok && outputWithStatus.value !== undefined
+                ? outputWithStatus.value
+                : undefined,
+            ],
     );
     return Object.fromEntries(entries);
   });
@@ -205,6 +252,10 @@ export function createAppV3<
           ignoreUpdates(() => {
             snapshot.value = applyPatch(snapshot.value, patches.value, false, false).newDocument;
             updateAppModel({ data: deriveDataFromStorage<Data>(snapshot.value.blockStorage) });
+            // Reconcile plugin data from external source
+            for (const pluginId of Object.keys(pluginDataMap)) {
+              pluginDataMap[pluginId] = derivePluginDataFromSnapshot(pluginId);
+            }
             data.isExternalSnapshot = isAuthorChanged;
           });
         } else {
@@ -261,7 +312,28 @@ export function createAppV3<
     },
     async allSettled() {
       await delay(0);
-      return setDataQueue.allSettled();
+      const allQueues = [
+        setDataQueue.allSettled(),
+        ...Array.from(pluginDataQueues.values()).map((q) => q.allSettled()),
+      ];
+      await Promise.all(allQueues);
+    },
+  };
+
+  /** Plugin internals — provided via separate injection key, not exposed on useApp(). */
+  const pluginAccess: PluginDataAccess = {
+    pluginDataMap,
+    setPluginData(pluginId: string, value: unknown): Promise<boolean> {
+      pluginDataMap[pluginId] = value;
+      debug("setPluginData", pluginId, value);
+      return getPluginDataQueue(pluginId).run(() =>
+        updatePluginData(pluginId, value).then(unwrapResult),
+      );
+    },
+    initPluginDataSlot(pluginId: string): void {
+      if (!(pluginId in pluginDataMap)) {
+        pluginDataMap[pluginId] = derivePluginDataFromSnapshot(pluginId);
+      }
     },
   };
 
@@ -275,19 +347,19 @@ export function createAppV3<
     ),
   };
 
-  const app = reactive(Object.assign(appModel, methods, getters));
+  const app = Object.assign(reactive(Object.assign(appModel, getters)), methods);
 
   if (settings.debug) {
     // @ts-expect-error (to inspect in console in debug mode)
     globalThis.__block_app__ = app;
   }
 
-  return app;
+  return { app, pluginAccess };
 }
 
 export type BaseAppV3<
+  Data = unknown,
   Args = unknown,
   Outputs extends BlockOutputsBase = BlockOutputsBase,
-  Data = unknown,
   Href extends `/${string}` = `/${string}`,
-> = ReturnType<typeof createAppV3<Args, Outputs, Data, Href>>;
+> = ReturnType<typeof createAppV3<Data, Args, Outputs, Href>>["app"];

package/src/internal/v1.static-test.ts

@@ -9,7 +9,7 @@ import type {
   Platforma,
 } from "@platforma-sdk/model";
 import type { BaseAppV1, createAppV1 } from "./createAppV1";
-import { type App } from "../defineApp";
+import { type AppV1 } from "../defineApp";
 import { computed, type Component } from "vue";
 
 declare function __createModel<M, V = unknown>(options: ModelOptions<M, V>): Model<M>;
@@ -84,7 +84,7 @@ const _local = () => {
   };
 };
 
-type ExtApp = App<1, BlockOutputsBase, unknown, "/", ReturnType<typeof _local>>;
+type ExtApp = AppV1<1, BlockOutputsBase, unknown, "/", ReturnType<typeof _local>>;
 
 type _UpdateArgsParams = Parameters<Parameters<_App1["updateArgs"]>[0]>[0];
 

package/src/internal/v2.static-test.ts

@@ -9,7 +9,7 @@ import type {
   Platforma,
 } from "@platforma-sdk/model";
 import type { BaseAppV2, createAppV2 } from "./createAppV2";
-import { type App } from "../defineApp";
+import { type AppV2 } from "../defineApp";
 import { computed, type Component } from "vue";
 
 declare function __createModel<M, V = unknown>(options: ModelOptions<M, V>): Model<M>;
@@ -84,7 +84,7 @@ const _local = () => {
   };
 };
 
-type ExtApp = App<1, BlockOutputsBase, unknown, "/", ReturnType<typeof _local>>;
+type ExtApp = AppV2<1, BlockOutputsBase, unknown, "/", ReturnType<typeof _local>>;
 
 type _UpdateArgsParams = Parameters<Parameters<_App1["updateArgs"]>[0]>[0];
 

package/src/lib.ts

@@ -35,6 +35,8 @@ export * from "./components/PlAdvancedFilter";
 
 export * from "./defineApp";
 
+export { usePluginData } from "./usePluginData";
+
 export * from "./createModel";
 
 export * from "./types";

package/src/types.ts

@@ -68,7 +68,7 @@ export type AppSettings = {
    */
   debug?: boolean;
   /**
-   * Debounce span in ms (default is 100ms)
+   * Debounce span in ms (default is 200ms)
    */
   debounceSpan?: number;
   /**

package/src/usePluginData.ts

@@ -0,0 +1,63 @@
+import { computed, inject } from "vue";
+import { deepClone } from "@milaboratories/helpers";
+import { pluginDataKey } from "./defineApp";
+import type { PluginDataAccess } from "./internal/createAppV3";
+
+/**
+ * Composable for accessing and updating plugin-specific data.
+ *
+ * Plugin components are self-contained: they use this composable to read/write
+ * their own data slice from BlockStorage without knowing about the parent block's data.
+ *
+ * Requires a V3 block (BlockModelV3). Throws if used in a V1/V2 block.
+ *
+ * @param pluginId - The plugin instance ID (must match the ID used in BlockModelV3.plugin()).
+ *   Must be a static value; changing it after mount will not re-bind the composable.
+ * @returns `{ data, updateData }` where `data` is a reactive ref to the plugin's data,
+ *   and `updateData` returns a promise resolving to `true` if the mutation was sent,
+ *   or `false` if data is not yet available.
+ *
+ * @example
+ * ```vue
+ * <script setup lang="ts">
+ * const { data, updateData } = usePluginData<CounterData>('counter');
+ *
+ * function increment() {
+ *   updateData((d) => ({ ...d, count: d.count + 1 }));
+ * }
+ * </script>
+ * ```
+ */
+export function usePluginData<Data>(pluginId: string) {
+  const access = inject<PluginDataAccess>(pluginDataKey);
+
+  if (!access) {
+    throw new Error(
+      "usePluginData requires a V3 block (BlockModelV3). " +
+        "Make sure the block uses apiVersion 3 and the plugin is installed.",
+    );
+  }
+
+  // Initialize the plugin data slot from snapshot if not already done
+  access.initPluginDataSlot(pluginId);
+
+  // Reactive reference to the plugin's data in the shared optimistic map
+  const data = computed<Data | undefined>(() => {
+    return access.pluginDataMap[pluginId] as Data | undefined;
+  });
+
+  /**
+   * Update plugin data with optimistic feedback.
+   *
+   * @param cb - Callback that receives a deep clone of current data and returns new data.
+   * @returns Promise that resolves to true when the mutation is sent
+   */
+  const updateData = (cb: (current: Data) => Data): Promise<boolean> => {
+    const current = data.value;
+    if (current === undefined) return Promise.resolve(false);
+    const newValue = cb(deepClone(current));
+    return access.setPluginData(pluginId, newValue);
+  };
+
+  return { data, updateData };
+}