@platforma-sdk/model 1.56.0 → 1.57.0

package/src/block_model.ts

@@ -10,7 +10,7 @@ import { getPlatformaInstance, isInUI, createAndRegisterRenderLambda } from "./i
 import type { DataModel } from "./block_migrations";
 import type { PlatformaV3 } from "./platforma";
 import type { InferRenderFunctionReturn, RenderFunction } from "./render";
-import { RenderCtx } from "./render";
+import { BlockRenderCtx, PluginRenderCtx } from "./render";
 import type { PluginModel } from "./plugin_model";
 import type { RenderCtxBase } from "./render";
 import { PlatformaSDKVersion } from "./version";
@@ -192,8 +192,8 @@ export class BlockModelV3<
       outputs: {
         ...this.config.outputs,
         [key]: createAndRegisterRenderLambda({
-          handle: `output#${key}`,
-          lambda: () => cfgOrRf(new RenderCtx<Args, Data>()),
+          handle: `block-output#${key}`,
+          lambda: () => cfgOrRf(new BlockRenderCtx<Args, Data>()),
           ...flags,
         }),
       },
@@ -287,7 +287,7 @@ export class BlockModelV3<
       ...this.config,
       // Replace the default sections callback with the user-provided one
       sections: createAndRegisterRenderLambda(
-        { handle: "sections", lambda: () => rf(new RenderCtx<Args, Data>()) },
+        { handle: "sections", lambda: () => rf(new BlockRenderCtx<Args, Data>()) },
         true,
       ),
     });
@@ -301,7 +301,7 @@ export class BlockModelV3<
       ...this.config,
       title: createAndRegisterRenderLambda({
         handle: "title",
-        lambda: () => rf(new RenderCtx<Args, Data>()),
+        lambda: () => rf(new BlockRenderCtx<Args, Data>()),
       }),
     });
   }
@@ -313,7 +313,7 @@ export class BlockModelV3<
       ...this.config,
       subtitle: createAndRegisterRenderLambda({
         handle: "subtitle",
-        lambda: () => rf(new RenderCtx<Args, Data>()),
+        lambda: () => rf(new BlockRenderCtx<Args, Data>()),
       }),
     });
   }
@@ -325,7 +325,7 @@ export class BlockModelV3<
       ...this.config,
       tags: createAndRegisterRenderLambda({
         handle: "tags",
-        lambda: () => rf(new RenderCtx<Args, Data>()),
+        lambda: () => rf(new BlockRenderCtx<Args, Data>()),
       }),
     });
   }
@@ -458,6 +458,27 @@ export class BlockModelV3<
         derivePrerunArgsFromStorage(storageJson, argsFunction, prerunArgsFunction),
     });
 
+    // Register plugin input and output lambdas
+    const pluginOutputs: Record<string, ConfigRenderLambda> = {};
+    for (const [pluginId, { model, inputs }] of Object.entries(plugins)) {
+      // Wrap plugin param lambdas: close over BlockRenderCtx creation
+      const wrappedInputs: Record<string, () => unknown> = {};
+      for (const [paramKey, paramFn] of Object.entries(inputs)) {
+        wrappedInputs[paramKey] = () => paramFn(new BlockRenderCtx());
+      }
+
+      // Register plugin outputs (in config pack, evaluated by middle layer)
+      const outputs = model.outputs as Record<string, (ctx: PluginRenderCtx) => unknown>;
+      for (const [outputKey, outputFn] of Object.entries(outputs)) {
+        const key = `plugin-output#${pluginId}#${outputKey}`;
+        pluginOutputs[key] = createAndRegisterRenderLambda({
+          handle: key,
+          lambda: () => outputFn(new PluginRenderCtx(pluginId, wrappedInputs)),
+        });
+      }
+    }
+    const allOutputs = { ...this.config.outputs, ...pluginOutputs };
+
     const blockConfig: BlockConfigContainer = {
       v4: {
         configVersion: 4,
@@ -468,7 +489,7 @@ export class BlockModelV3<
         title: this.config.title,
         subtitle: this.config.subtitle,
         tags: this.config.tags,
-        outputs: this.config.outputs,
+        outputs: allOutputs,
         enrichmentTargets: this.config.enrichmentTargets,
         featureFlags: this.config.featureFlags,
         blockLifecycleCallbacks: { ...BlockStorageFacadeHandles },
@@ -500,7 +521,7 @@ export class BlockModelV3<
         }),
         blockModelInfo: {
           outputs: Object.fromEntries(
-            Object.entries(this.config.outputs).map(([key, value]) => [
+            Object.entries(allOutputs).map(([key, value]) => [
               key,
               {
                 withStatus: Boolean(isConfigLambda(value) && value.withStatus),

package/src/block_storage.test.ts

@@ -218,8 +218,10 @@ describe("BlockStorage", () => {
       expect(getPluginData(storage, "chart1")).toEqual({ type: "bar" });
     });
 
-    it("getPluginData should return undefined for missing plugin", () => {
-      expect(getPluginData(baseStorage, "nonexistent")).toBeUndefined();
+    it("getPluginData should throw for missing plugin", () => {
+      expect(() => getPluginData(baseStorage, "nonexistent")).toThrow(
+        "Plugin 'nonexistent' not found in block storage",
+      );
     });
 
     it("should not modify original storage (immutability)", () => {

package/src/block_storage.ts

@@ -381,17 +381,17 @@ export function migrateBlockStorage(
 }
 
 /**
- * Gets plugin-specific data from BlockStorage (for UI)
+ * Gets plugin-specific data from block storage.
+ * Accepts raw storage (any format) and normalizes internally.
  *
- * @param storage - The BlockStorage instance
+ * @param rawStorage - Raw block storage (may be legacy format or BlockStorage)
  * @param pluginId - The plugin instance id
- * @returns The plugin data or undefined if not set
+ * @returns The plugin data
+ * @throws If pluginId is not found in storage
  */
-export function getPluginData<TData = unknown>(
-  storage: BlockStorage,
-  pluginId: string,
-): TData | undefined {
+export function getPluginData<TData = unknown>(rawStorage: unknown, pluginId: string): TData {
+  const storage = normalizeBlockStorage(rawStorage);
   const pluginEntry = storage.__plugins?.[pluginId];
-  if (!pluginEntry) return undefined;
+  if (!pluginEntry) throw new Error(`Plugin '${pluginId}' not found in block storage`);
   return pluginEntry.__data as TData;
 }

package/src/index.ts

@@ -15,7 +15,6 @@ export {
 } from "./block_migrations";
 export type { LegacyV1State } from "./block_migrations";
 export { PluginModel } from "./plugin_model";
-export type { PluginRenderCtx } from "./plugin_model";
 export * from "./bconfig";
 export * from "./components";
 export * from "./config";

package/src/plugin_model.ts

@@ -9,29 +9,11 @@
 
 import type { DataModel } from "./block_migrations";
 import type { PluginName } from "./block_storage";
-import type { ResultPool } from "./render";
+import type { PluginRenderCtx } from "./render";
 
 /** Symbol for internal builder creation method */
 const FROM_BUILDER = Symbol("fromBuilder");
 
-// =============================================================================
-// Plugin Render Context
-// =============================================================================
-
-/**
- * Context passed to plugin output functions.
- * Provides access to plugin's persistent data, params derived from block context,
- * and the result pool for accessing workflow outputs.
- */
-export interface PluginRenderCtx<Data, Params = undefined> {
-  /** Plugin's persistent data */
-  readonly data: Data;
-  /** Params derived from block's RenderCtx */
-  readonly params: Params;
-  /** Result pool for accessing workflow outputs */
-  readonly resultPool: ResultPool;
-}
-
 // =============================================================================
 // Plugin Type
 // =============================================================================

package/src/render/api.ts

@@ -30,6 +30,7 @@ import {
   AnchoredIdDeriver,
   collectSpecQueryColumns,
   ensurePColumn,
+  parseJson,
   extractAllColumns,
   isDataInfo,
   isPColumn,
@@ -48,6 +49,7 @@ import {
 import canonicalize from "canonicalize";
 import type { Optional } from "utility-types";
 import { getCfgRenderCtx } from "../internal";
+import { getPluginData } from "../block_storage";
 import { TreeNodeAccessor, ifDef } from "./accessor";
 import type { FutureRef } from "./future";
 import type { AccessorHandle, GlobalCfgRenderCtx } from "./internal";
@@ -711,7 +713,7 @@ export abstract class RenderCtxBase<Args = unknown, Data = unknown> {
 }
 
 /** Main entry point to the API available within model lambdas (like outputs, sections, etc..) for v3+ blocks */
-export class RenderCtx<Args = unknown, Data = unknown> extends RenderCtxBase<Args, Data> {
+export class BlockRenderCtx<Args = unknown, Data = unknown> extends RenderCtxBase<Args, Data> {
   private argsCache?: { v: Args | undefined };
   public get args(): Args | undefined {
     if (this.argsCache === undefined) {
@@ -751,8 +753,56 @@ export class RenderCtxLegacy<Args = unknown, UiState = unknown> extends RenderCt
   }
 }
 
+/**
+ * Render context for plugin output functions.
+ * Reads plugin data from blockStorage and derives params from pre-wrapped input callbacks.
+ */
+export class PluginRenderCtx<Data = unknown, Params = unknown> {
+  private readonly ctx: GlobalCfgRenderCtx;
+  private readonly pluginId: string;
+  private readonly wrappedInputs: Record<string, () => unknown>;
+
+  constructor(pluginId: string, wrappedInputs: Record<string, () => unknown>) {
+    this.ctx = getCfgRenderCtx();
+    this.pluginId = pluginId;
+    this.wrappedInputs = wrappedInputs;
+  }
+
+  private dataCache?: { v: Data };
+
+  /** Plugin's persistent data from blockStorage.__plugins.{pluginId}.__data */
+  public get data(): Data {
+    if (this.dataCache === undefined) {
+      const raw = this.ctx.blockStorage();
+      const pluginData = getPluginData<Data>(parseJson(raw), this.pluginId);
+      this.dataCache = { v: pluginData };
+    }
+    return this.dataCache.v;
+  }
+
+  private paramsCache?: { v: Params };
+
+  /** Params derived from block context via pre-wrapped input callbacks */
+  public get params(): Params {
+    if (this.paramsCache === undefined) {
+      const result: Record<string, unknown> = {};
+      for (const [key, fn] of Object.entries(this.wrappedInputs)) {
+        result[key] = fn();
+      }
+      this.paramsCache = { v: result as Params };
+    }
+    return this.paramsCache.v;
+  }
+
+  /** Result pool — same as block, from cfgRenderCtx methods */
+  public readonly resultPool = new ResultPool();
+}
+
+/** @deprecated Use BlockRenderCtx instead */
+export type RenderCtx<Args = unknown, Data = unknown> = BlockRenderCtx<Args, Data>;
+
 export type RenderFunction<Args = unknown, State = unknown, Ret = unknown> = (
-  rCtx: RenderCtx<Args, State>,
+  rCtx: BlockRenderCtx<Args, State>,
 ) => Ret;
 
 export type RenderFunctionLegacy<Args = unknown, State = unknown, Ret = unknown> = (