@platforma-sdk/ui-vue 1.61.2 → 1.62.0

package/src/internal/createAppV3.test.ts

@@ -165,6 +165,11 @@ function createMockApiV3<
     async dispose(): Promise<ResultOrError<void>> {
       return { value: undefined };
     },
+    serviceDispatch: {
+      getServiceNames: () => [],
+      getServiceMethods: () => [],
+      callServiceMethod: () => undefined,
+    },
     //
     blobDriver: undefined as any,
     //
@@ -521,6 +526,96 @@ describe("createAppV3", { timeout: 20_000 }, () => {
     app.closedRef = true;
   });
 
+  it("should default stable to true on plugin withStatus outputs when stable is absent", async () => {
+    type F = PluginFactory<PluginData, undefined, { pFrame: OutputWithStatus<string | undefined> }>;
+    const pluginId = "graphMaker" as PluginHandle<F>;
+    const pluginOutputName = pluginOutputKey(pluginId, "pFrame");
+
+    const outputsWithoutStable = {
+      ...defaultOutputs(),
+      [pluginOutputName]: { ok: true, value: undefined } as OutputWithStatus<string | undefined>,
+    } as Outputs;
+
+    const state = new BlockStateV3Mock<Data, Outputs>(defaultData(), outputsWithoutStable, "/", {
+      [pluginId]: defaultPluginData(),
+    });
+
+    const blockModelInfo: BlockModelInfo = {
+      outputs: {
+        doubled: { withStatus: false },
+        [pluginOutputName]: { withStatus: true },
+      },
+      pluginIds: [pluginId],
+      featureFlags: {},
+    };
+
+    const platforma = createMockApiV3<Data, Args, Outputs>(state, blockModelInfo);
+    const initialState = await platforma.loadBlockState();
+    if ("error" in initialState) throw initialState.error;
+
+    const { pluginAccess } = createAppV3<Data, Args, Outputs>(initialState.value!, platforma, {
+      debug: false,
+      debounceSpan: 10,
+    });
+
+    const pluginState = pluginAccess.getOrCreatePluginState(pluginId);
+
+    const pFrame = pluginState.model.outputs["pFrame"] as Extract<
+      OutputWithStatus<string | undefined>,
+      { ok: true }
+    >;
+    expect(pFrame).toBeDefined();
+    expect(pFrame.ok).toBe(true);
+    expect(pFrame.stable).toBe(true);
+    expect(pFrame.value).toBeUndefined();
+  });
+
+  it("should preserve stable=false on plugin withStatus outputs when explicitly set", async () => {
+    type F = PluginFactory<PluginData, undefined, { pFrame: OutputWithStatus<string | undefined> }>;
+    const pluginId = "graphMaker" as PluginHandle<F>;
+    const pluginOutputName = pluginOutputKey(pluginId, "pFrame");
+
+    const outputsUnstable = {
+      ...defaultOutputs(),
+      [pluginOutputName]: { ok: true, value: undefined, stable: false } as OutputWithStatus<
+        string | undefined
+      >,
+    } as Outputs;
+
+    const state = new BlockStateV3Mock<Data, Outputs>(defaultData(), outputsUnstable, "/", {
+      [pluginId]: defaultPluginData(),
+    });
+
+    const blockModelInfo: BlockModelInfo = {
+      outputs: {
+        doubled: { withStatus: false },
+        [pluginOutputName]: { withStatus: true },
+      },
+      pluginIds: [pluginId],
+      featureFlags: {},
+    };
+
+    const platforma = createMockApiV3<Data, Args, Outputs>(state, blockModelInfo);
+    const initialState = await platforma.loadBlockState();
+    if ("error" in initialState) throw initialState.error;
+
+    const { pluginAccess } = createAppV3<Data, Args, Outputs>(initialState.value!, platforma, {
+      debug: false,
+      debounceSpan: 10,
+    });
+
+    const pluginState = pluginAccess.getOrCreatePluginState(pluginId);
+
+    const pFrame = pluginState.model.outputs["pFrame"] as Extract<
+      OutputWithStatus<string | undefined>,
+      { ok: true }
+    >;
+    expect(pFrame).toBeDefined();
+    expect(pFrame.ok).toBe(true);
+    expect(pFrame.stable).toBe(false);
+    expect(pFrame.value).toBeUndefined();
+  });
+
   it("should navigate to href", async () => {
     const state = createDefaultState();
     const platforma = createMockApiV3<Data, Args, Outputs>(state, defaultBlockModelInfo());

package/src/internal/createAppV3.ts

@@ -12,6 +12,7 @@ import type {
   PluginHandle,
   InferFactoryData,
   InferFactoryOutputs,
+  InferFactoryUiServices,
   PluginFactoryLike,
 } from "@platforma-sdk/model";
 import {
@@ -21,9 +22,13 @@ import {
   getPluginData,
   isPluginOutputKey,
   pluginOutputPrefix,
+  createNodeServiceProxy,
+  buildServices,
 } from "@platforma-sdk/model";
+import { type UiServices as AllUiServices } from "@milaboratories/pl-model-common";
+import { createUiServiceRegistry } from "./service_factories";
 import type { Ref } from "vue";
-import { reactive, computed, ref } from "vue";
+import { reactive, computed, ref, markRaw } from "vue";
 import type { OutputValues, OutputErrors, AppSettings } from "../types";
 import { parseQuery } from "../urls";
 import { ensureOutputHasStableFlag, MultiError } from "../utils";
@@ -35,10 +40,11 @@ import type { PluginState, PluginAccess } from "../usePlugin";
 export const patchPoolingDelay = 150;
 
 /** Internal per-plugin state with reconciliation support. */
-interface InternalPluginState<Data = unknown, Outputs = unknown> extends PluginState<
-  Data,
-  Outputs
-> {
+interface InternalPluginState<
+  Data = unknown,
+  Outputs = unknown,
+  Services = Record<string, unknown>,
+> extends PluginState<Data, Outputs, Services> {
   readonly ignoreUpdates: (fn: () => void) => void;
 }
 
@@ -75,9 +81,10 @@ export function createAppV3<
   Outputs extends BlockOutputsBase = BlockOutputsBase,
   Href extends `/${string}` = `/${string}`,
   Plugins extends Record<string, unknown> = Record<string, unknown>,
+  UiServices extends Partial<AllUiServices> = Partial<AllUiServices>,
 >(
   state: ValueWithUTag<BlockStateV3<Data, Outputs, Href>>,
-  platforma: PlatformaExtended<PlatformaV3<Data, Args, Outputs, Href, Plugins>>,
+  platforma: PlatformaExtended<PlatformaV3<Data, Args, Outputs, Href, Plugins, UiServices>>,
   settings: AppSettings,
 ) {
   const debug = (msg: string, ...rest: unknown[]) => {
@@ -223,12 +230,11 @@ export function createAppV3<
   (async () => {
     window.addEventListener("beforeunload", () => {
       closedRef.value = true;
-      platforma
-        .dispose()
-        .then(unwrapResult)
-        .catch((err) => {
+      Promise.allSettled([uiRegistry.dispose(), platforma.dispose().then(unwrapResult)]).catch(
+        (err) => {
           error("error in dispose", err);
-        });
+        },
+      );
     });
 
     while (!closedRef.value) {
@@ -328,6 +334,10 @@ export function createAppV3<
     },
   };
 
+  const proxy = createNodeServiceProxy(platforma.serviceDispatch);
+  const uiRegistry = createUiServiceRegistry({ proxy });
+  const services = buildServices<UiServices>(platforma.serviceDispatch, uiRegistry);
+
   /** Creates a lazily-cached per-plugin reactive state. */
   const createPluginState = <F extends PluginFactoryLike>(
     handle: PluginHandle<F>,
@@ -342,7 +352,9 @@ export function createAppV3<
         if (!key.startsWith(prefix)) continue;
         const outputKey = key.slice(prefix.length);
         if (platforma.blockModelInfo.outputs[key]?.withStatus) {
-          result[outputKey] = outputWithStatus ?? undefined;
+          result[outputKey] = outputWithStatus
+            ? ensureOutputHasStableFlag(outputWithStatus)
+            : undefined;
         } else {
           result[outputKey] =
             outputWithStatus.ok && outputWithStatus.value !== undefined
@@ -385,6 +397,7 @@ export function createAppV3<
 
     return {
       model: pluginModel,
+      services: markRaw(services),
       ignoreUpdates,
     };
   };
@@ -394,11 +407,19 @@ export function createAppV3<
     getOrCreatePluginState<F extends PluginFactoryLike>(handle: PluginHandle<F>) {
       const existing = pluginStates.get(handle);
       if (existing) {
-        return existing as unknown as PluginState<InferFactoryData<F>, InferFactoryOutputs<F>>;
+        return existing as unknown as PluginState<
+          InferFactoryData<F>,
+          InferFactoryOutputs<F>,
+          InferFactoryUiServices<F>
+        >;
       }
       const state = createPluginState(handle);
       pluginStates.set(handle, state);
-      return state;
+      return state as unknown as PluginState<
+        InferFactoryData<F>,
+        InferFactoryOutputs<F>,
+        InferFactoryUiServices<F>
+      >;
     },
   };
 
@@ -410,6 +431,7 @@ export function createAppV3<
     closedRef,
     snapshot,
     plugins,
+    services: markRaw(services),
     queryParams: computed(() => parseQuery<Href>(snapshot.value.navigationState.href as Href)),
     href: computed(() => snapshot.value.navigationState.href),
     hasErrors: computed(() =>
@@ -433,4 +455,5 @@ export type BaseAppV3<
   Outputs extends BlockOutputsBase = BlockOutputsBase,
   Href extends `/${string}` = `/${string}`,
   Plugins extends Record<string, unknown> = Record<string, unknown>,
-> = ReturnType<typeof createAppV3<Data, Args, Outputs, Href, Plugins>>["app"];
+  UiServices extends Partial<AllUiServices> = Partial<AllUiServices>,
+> = ReturnType<typeof createAppV3<Data, Args, Outputs, Href, Plugins, UiServices>>["app"];

package/src/internal/service_factories.ts

@@ -0,0 +1,23 @@
+/**
+ * UI service factories — add a factory for each new service here.
+ *
+ * Each entry maps a Services key to a factory function that creates the
+ * UI-side driver instance:
+ * - WASM services: instantiated directly (e.g. SpecDriver)
+ * - Node services: proxied via IPC using NodeServiceProxy
+ */
+
+import { Services, UiServiceRegistry } from "@milaboratories/pl-model-common";
+import { SpecDriver } from "@milaboratories/pf-spec-driver";
+import type { NodeServiceProxy } from "@platforma-sdk/model";
+
+export type UiServiceOptions = {
+  proxy: NodeServiceProxy;
+};
+
+export function createUiServiceRegistry(options: UiServiceOptions) {
+  return new UiServiceRegistry(Services, {
+    PFrameSpec: () => new SpecDriver(),
+    PFrame: () => options.proxy(Services.PFrame),
+  });
+}

package/src/usePlugin.ts

@@ -4,11 +4,16 @@ import type {
   PluginHandle,
   InferFactoryData,
   InferFactoryOutputs,
+  InferFactoryUiServices,
   PluginFactoryLike,
 } from "@platforma-sdk/model";
 
 /** Per-plugin reactive model exposed to consumers via usePlugin(). */
-export interface PluginState<Data = unknown, Outputs = unknown> {
+export interface PluginState<
+  Data = unknown,
+  Outputs = unknown,
+  Services = Record<string, unknown>,
+> {
   readonly model: Reactive<{
     data: Data;
     outputs: Outputs extends Record<string, unknown>
@@ -18,13 +23,14 @@ export interface PluginState<Data = unknown, Outputs = unknown> {
       ? { [K in keyof Outputs]?: Error }
       : Record<string, Error | undefined>;
   }>;
+  readonly services: Services;
 }
 
 /** Internal interface for plugin access — provided via Vue injection to usePlugin(). */
 export interface PluginAccess {
   getOrCreatePluginState<F extends PluginFactoryLike>(
     handle: PluginHandle<F>,
-  ): PluginState<InferFactoryData<F>, InferFactoryOutputs<F>>;
+  ): PluginState<InferFactoryData<F>, InferFactoryOutputs<F>, InferFactoryUiServices<F>>;
 }
 
 /**