@platforma-sdk/model 1.8.19 → 1.9.0

package/src/builder.ts

@@ -4,22 +4,17 @@ import { getPlatformaInstance, isInUI, tryRegisterCallback } from './internal';
 import { Platforma } from './platforma';
 import { InferRenderFunctionReturn, RenderCtx, RenderFunction } from './render';
 import { PlatformaSDKVersion } from './version';
-
-type StdCtxArgsOnly<Args, UiState = undefined> = {
-  readonly $blockId: string;
-  readonly $args: Args;
-  readonly $ui: UiState;
-};
-
-export type StdCtx<Args, UiState = undefined> = StdCtxArgsOnly<Args, UiState> & {
-  readonly $prod: PlResourceEntry;
-  readonly $staging: PlResourceEntry;
-};
-
-export type ResolveCfgType<Cfg extends TypedConfig, Args, UiState = undefined> = ConfigResult<
-  Cfg,
-  StdCtx<Args, UiState>
->;
+import {
+  TypedConfigOrConfigLambda,
+  ConfigRenderLambda,
+  StdCtxArgsOnly,
+  DeriveHref,
+  ResolveCfgType,
+  ExtractFunctionHandleReturn,
+  BlockConfigContainer,
+  downgradeCfgOrLambda,
+  ConfigRenderLambdaFlags
+} from './bconfig';
 
 type SectionsExpectedType = readonly BlockSection[];
 
@@ -45,131 +40,57 @@ type InputsValidRFChecked<RF extends Function> = Checked<
   InferRenderFunctionReturn<RF> extends InputsValidExpectedType ? true : false
 >;
 
-export type Code = {
-  type: 'plain';
-  content: string;
-};
-
-/** Field key to attach ConfAction information to a config type. */
-declare const __function_handle__: unique symbol;
-
-/** Creates branded Cfg type */
-export type FunctionHandle<Return = unknown> = string & { [__function_handle__]: Return };
-
-export type ExtractFunctionHandleReturn<Func extends FunctionHandle> =
-  Func[typeof __function_handle__];
-
-export type TypedConfigOrFunctionHandle = TypedConfig | FunctionHandle;
-
-export function isFunctionHandle(cfgOrFh: TypedConfigOrFunctionHandle): cfgOrFh is FunctionHandle {
-  return typeof cfgOrFh === 'string';
-}
-
-type OnlyString<S> = S extends string ? S : '';
-
-// prettier-ignore
-export type DeriveHref<S> = S extends readonly BlockSection[]
-  ? OnlyString<Extract<S[number], { type: 'link' }>['href']>
-  : never;
-
-/** This structure is rendered from the configuration, type can accommodate any
- * version of config structure. */
-export type BlockConfigUniversal<
-  Args = unknown,
-  Outputs extends Record<string, TypedConfigOrFunctionHandle> = Record<
-    string,
-    TypedConfigOrFunctionHandle
-  >
-> = {
-  /** SDK version used by the block */
-  readonly sdkVersion: string;
-
-  /** Main rendering mode for the block */
-  readonly renderingMode: BlockRenderingMode;
-
-  /** Initial value for the args when block is added to the project */
-  readonly initialArgs: Args;
-
-  /** @deprecated */
-  readonly canRun?: TypedConfigOrFunctionHandle;
-
-  /**
-   * Config to determine whether the block can be executed with current
-   * arguments.
-   *
-   * Optional to support earlier SDK version configs.
-   * */
-  readonly inputsValid?: TypedConfigOrFunctionHandle;
-
-  /** Configuration to derive list of section for the left overview panel */
-  readonly sections: TypedConfigOrFunctionHandle;
-
-  /** Configuration for the output cells */
-  readonly outputs: Outputs;
-
-  /** Config code bundle */
-  readonly code?: Code;
-};
-
-/** This structure is rendered from the configuration */
-export type BlockConfig<
-  Args = unknown,
-  Outputs extends Record<string, TypedConfigOrFunctionHandle> = Record<
-    string,
-    TypedConfigOrFunctionHandle
-  >
-> = Required<Omit<BlockConfigUniversal<Args, Outputs>, 'canRun' | 'code'>> &
-  Pick<BlockConfigUniversal<Args, Outputs>, 'code'>;
-
-/** Takes universal config, and converts it into latest structure */
-export function normalizeBlockConfig<
-  Args,
-  Outputs extends Record<string, TypedConfigOrFunctionHandle>
->(cfg: BlockConfigUniversal<Args, Outputs>): BlockConfig<Args, Outputs> {
-  if (cfg.inputsValid !== undefined) return cfg as BlockConfig<Args, Outputs>;
-  else {
-    if (cfg.canRun === undefined)
-      throw new Error(`Malformed config, SDK version ${cfg.sdkVersion}`);
-    const latest = { ...cfg, inputsValid: cfg.canRun };
-    delete latest['canRun'];
-    return latest;
-  }
-}
+type NoOb = Record<string, never>;
 
 /** Main entry point that each block should use in it's "config" module. Don't forget
  * to call {@link done()} at the end of configuration. Value returned by this builder must be
  * exported as constant with name "platforma" from the "config" module. */
 export class BlockModel<
   Args,
-  OutputsCfg extends Record<string, TypedConfigOrFunctionHandle>,
+  OutputsCfg extends Record<string, TypedConfigOrConfigLambda>,
   UiState,
   Href extends `/${string}` = '/'
 > {
   private constructor(
     private readonly _renderingMode: BlockRenderingMode,
     private readonly _initialArgs: Args | undefined,
+    private readonly _initialUiState: UiState,
     private readonly _outputs: OutputsCfg,
-    private readonly _inputsValid: TypedConfigOrFunctionHandle,
-    private readonly _sections: TypedConfigOrFunctionHandle
-  ) { }
+    private readonly _inputsValid: TypedConfigOrConfigLambda,
+    private readonly _sections: TypedConfigOrConfigLambda,
+    private readonly _title: ConfigRenderLambda | undefined
+  ) {}
 
   /** Initiates configuration builder */
-  public static create<Args, UiState = undefined>(
-    renderingMode: BlockRenderingMode = 'Heavy'
-  ): BlockModel<Args, {}, UiState> {
-    return new BlockModel<Args, {}, UiState>(
+  public static create(renderingMode: BlockRenderingMode): BlockModel<NoOb, {}, NoOb>;
+  /** Initiates configuration builder */
+  public static create(): BlockModel<NoOb, {}, NoOb>;
+  /**
+   * Initiates configuration builder
+   * @deprecated use create method without generic parameter
+   */
+  public static create<Args>(renderingMode: BlockRenderingMode): BlockModel<Args, {}, NoOb>;
+  /**
+   * Initiates configuration builder
+   * @deprecated use create method without generic parameter
+   */
+  public static create<Args>(): BlockModel<Args, {}, NoOb>;
+  public static create(renderingMode: BlockRenderingMode = 'Heavy'): BlockModel<NoOb, {}, NoOb> {
+    return new BlockModel<NoOb, {}, NoOb>(
       renderingMode,
       undefined,
       {},
+      {},
       getImmediate(true),
-      getImmediate([])
+      getImmediate([]),
+      undefined
     );
   }
 
   /**
    * Add output cell to the configuration
    *
-   * @param key cell name, that can be used to retrieve the rendered value
+   * @param key output cell name, that can be later used to retrieve the rendered value
    * @param cfg configuration describing how to render cell value from the blocks
    *            workflow outputs
    * */
@@ -177,45 +98,76 @@ export class BlockModel<
     key: Key,
     cfg: Cfg
   ): BlockModel<Args, OutputsCfg & { [K in Key]: Cfg }, UiState, Href>;
+  /**
+   * Add output cell to the configuration
+   *
+   * @param key output cell name, that can be later used to retrieve the rendered value
+   * @param rf  callback calculating output value using context, that allows to access
+   *            workflows outputs and interact with platforma drivers
+   * @param flags additional flags that may alter lambda rendering procedure
+   * */
   public output<const Key extends string, const RF extends RenderFunction<Args, UiState>>(
     key: Key,
-    rf: RF
+    rf: RF,
+    flags?: ConfigRenderLambdaFlags
   ): BlockModel<
     Args,
-    OutputsCfg & { [K in Key]: FunctionHandle<InferRenderFunctionReturn<RF>> },
+    OutputsCfg & { [K in Key]: ConfigRenderLambda<InferRenderFunctionReturn<RF>> },
     UiState,
     Href
   >;
   public output(
     key: string,
-    cfgOrRf: TypedConfig | Function
+    cfgOrRf: TypedConfig | Function,
+    flags: ConfigRenderLambdaFlags = {}
   ): BlockModel<Args, OutputsCfg, UiState, Href> {
     if (typeof cfgOrRf === 'function') {
-      const functionHandle = `output#${key}` as FunctionHandle;
-      tryRegisterCallback(functionHandle, () => cfgOrRf(new RenderCtx()));
+      const handle = `output#${key}`;
+      tryRegisterCallback(handle, () => cfgOrRf(new RenderCtx()));
       return new BlockModel(
         this._renderingMode,
         this._initialArgs,
+        this._initialUiState,
         {
           ...this._outputs,
-          [key]: functionHandle
+          [key]: {
+            __renderLambda: true,
+            handle,
+            ...flags
+          } satisfies ConfigRenderLambda
         },
         this._inputsValid,
-        this._sections
+        this._sections,
+        this._title
       );
     } else
       return new BlockModel(
         this._renderingMode,
         this._initialArgs,
+        this._initialUiState,
         {
           ...this._outputs,
           [key]: cfgOrRf
         },
         this._inputsValid,
-        this._sections
+        this._sections,
+        this._title
       );
   }
 
+  /** Shortcut for {@link output} with retentive flag set to true. */
+  public retentiveOutput<const Key extends string, const RF extends RenderFunction<Args, UiState>>(
+    key: Key,
+    rf: RF
+  ): BlockModel<
+    Args,
+    OutputsCfg & { [K in Key]: ConfigRenderLambda<InferRenderFunctionReturn<RF>> },
+    UiState,
+    Href
+  > {
+    return this.output(key, rf, { retentive: true });
+  }
+
   /** @deprecated */
   public canRun<Cfg extends TypedConfig>(
     cfg: Cfg & InputsValidCfgChecked<Cfg, Args, UiState>
@@ -239,17 +191,24 @@ export class BlockModel<
       return new BlockModel<Args, OutputsCfg, UiState>(
         this._renderingMode,
         this._initialArgs,
+        this._initialUiState,
         this._outputs,
-        'inputsValid' as FunctionHandle,
-        this._sections
+        {
+          __renderLambda: true,
+          handle: 'inputsValid'
+        } satisfies ConfigRenderLambda,
+        this._sections,
+        this._title
       );
     } else
       return new BlockModel<Args, OutputsCfg, UiState>(
         this._renderingMode,
         this._initialArgs,
+        this._initialUiState,
         this._outputs,
         cfgOrRf,
-        this._sections
+        this._sections,
+        this._title
       );
   }
 
@@ -268,7 +227,9 @@ export class BlockModel<
   }
 
   /** Sets the config to generate list of section in the left block overviews panel */
-  public sections<const S extends SectionsExpectedType,>(rf: S): BlockModel<Args, OutputsCfg, UiState, DeriveHref<S>>;
+  public sections<const S extends SectionsExpectedType>(
+    rf: S
+  ): BlockModel<Args, OutputsCfg, UiState, DeriveHref<S>>;
   public sections<
     const Ret extends SectionsExpectedType,
     const RF extends RenderFunction<Args, UiState, Ret>
@@ -284,36 +245,85 @@ export class BlockModel<
   public sections(
     arrOrCfgOrRf: SectionsExpectedType | TypedConfig | Function
   ): BlockModel<Args, OutputsCfg, UiState, `/${string}`> {
-    if (Array.isArray(arrOrCfgOrRf)){
-      return this.sections(getImmediate(arrOrCfgOrRf))
+    if (Array.isArray(arrOrCfgOrRf)) {
+      return this.sections(getImmediate(arrOrCfgOrRf));
     } else if (typeof arrOrCfgOrRf === 'function') {
       tryRegisterCallback('sections', () => arrOrCfgOrRf(new RenderCtx()));
       return new BlockModel<Args, OutputsCfg, UiState>(
         this._renderingMode,
         this._initialArgs,
+        this._initialUiState,
         this._outputs,
         this._inputsValid,
-        'sections' as FunctionHandle
+        { __renderLambda: true, handle: 'sections' } as ConfigRenderLambda,
+        this._title
       );
     } else
       return new BlockModel<Args, OutputsCfg, UiState>(
         this._renderingMode,
         this._initialArgs,
+        this._initialUiState,
         this._outputs,
         this._inputsValid,
-        arrOrCfgOrRf as TypedConfig
+        arrOrCfgOrRf as TypedConfig,
+        this._title
       );
   }
 
+  public title(
+    rf: RenderFunction<Args, UiState, string>
+  ): BlockModel<Args, OutputsCfg, UiState, Href> {
+    tryRegisterCallback('title', () => rf(new RenderCtx()));
+    return new BlockModel<Args, OutputsCfg, UiState, Href>(
+      this._renderingMode,
+      this._initialArgs,
+      this._initialUiState,
+      this._outputs,
+      this._inputsValid,
+      this._sections,
+      { __renderLambda: true, handle: 'title' } as ConfigRenderLambda
+    );
+  }
 
-  /** Sets initial args for the block, this value must be specified. */
+  /**
+   * Sets initial args for the block, this value must be specified.
+   * @deprecated use {@link withArgs}
+   * */
   public initialArgs(value: Args): BlockModel<Args, OutputsCfg, UiState, Href> {
     return new BlockModel<Args, OutputsCfg, UiState, Href>(
       this._renderingMode,
       value,
+      this._initialUiState,
+      this._outputs,
+      this._inputsValid,
+      this._sections,
+      this._title
+    );
+  }
+
+  /** Sets initial args for the block, this value must be specified. */
+  public withArgs<Args>(initialValue: Args): BlockModel<Args, OutputsCfg, UiState, Href> {
+    return new BlockModel<Args, OutputsCfg, UiState, Href>(
+      this._renderingMode,
+      initialValue,
+      this._initialUiState,
+      this._outputs,
+      this._inputsValid,
+      this._sections,
+      this._title
+    );
+  }
+
+  /** Defines type and sets initial value for block UiState. */
+  public withUiState<UiState>(initialValue: UiState): BlockModel<Args, OutputsCfg, UiState, Href> {
+    return new BlockModel<Args, OutputsCfg, UiState, Href>(
+      this._renderingMode,
+      this._initialArgs,
+      initialValue,
       this._outputs,
       this._inputsValid,
-      this._sections
+      this._sections,
+      this._title
     );
   }
 
@@ -328,32 +338,46 @@ export class BlockModel<
   > {
     if (this._initialArgs === undefined) throw new Error('Initial arguments not set.');
 
-    const config: BlockConfig<Args, OutputsCfg> = {
+    const config: BlockConfigContainer = {
+      v3: {
+        sdkVersion: PlatformaSDKVersion,
+        renderingMode: this._renderingMode,
+        initialArgs: this._initialArgs,
+        initialUiState: this._initialUiState,
+        inputsValid: this._inputsValid,
+        sections: this._sections,
+        title: this._title,
+        outputs: this._outputs
+      },
+
+      // fields below are added to allow previous desktop versions read generated configs
       sdkVersion: PlatformaSDKVersion,
       renderingMode: this._renderingMode,
       initialArgs: this._initialArgs,
-      inputsValid: this._inputsValid,
-      sections: this._sections,
-      outputs: this._outputs
+      inputsValid: downgradeCfgOrLambda(this._inputsValid),
+      sections: downgradeCfgOrLambda(this._sections),
+      outputs: Object.fromEntries(
+        Object.entries(this._outputs).map(([key, value]) => [key, downgradeCfgOrLambda(value)])
+      )
     };
 
     if (!isInUI())
       // we are in the configuration rendering routine, not in actual UI
       return { config } as any;
     // normal operation inside the UI
-    else return getPlatformaInstance(config) as any;
+    else return getPlatformaInstance({ sdkVersion: PlatformaSDKVersion }) as any;
   }
 }
 
 export type InferOutputType<CfgOrFH, Args, UiState> = CfgOrFH extends TypedConfig
   ? ResolveCfgType<CfgOrFH, Args, UiState>
-  : CfgOrFH extends FunctionHandle
+  : CfgOrFH extends ConfigRenderLambda
     ? ExtractFunctionHandleReturn<CfgOrFH>
     : never;
 
 type InferOutputsFromConfigs<
   Args,
-  OutputsCfg extends Record<string, TypedConfigOrFunctionHandle>,
+  OutputsCfg extends Record<string, TypedConfigOrConfigLambda>,
   UiState
 > = {
   [Key in keyof OutputsCfg]: ValueOrErrors<InferOutputType<OutputsCfg[Key], Args, UiState>>;

package/src/global.d.ts

@@ -1,6 +1,6 @@
 declare global {
   /** Global factory method returning platforma instance */
-  var getPlatforma: PlatformaFactory;
+  var getPlatforma: PlatformaSDKVersion;
   var platforma: Platforma;
 
   function getEnvironmentValue(name: string): string | undefined;

package/src/index.ts

@@ -1,6 +1,7 @@
 export * from './block_state_patch';
 export * from './block_state_util';
 export * from './builder';
+export * from './bconfig';
 export * from './components';
 export * from './config';
 export * from './pframe';

package/src/internal.ts

@@ -1,6 +1,5 @@
 import {} from './global';
 import { Platforma, PlatformaFactory } from './platforma';
-import { BlockConfig } from './builder';
 import { FutureHandle, GlobalCfgRenderCtx } from './render/internal';
 
 /** Utility code helping to identify whether the code is running in actual UI environment */
@@ -11,7 +10,7 @@ export function isInUI() {
 }
 
 /** Utility code helping to retrieve a platforma instance form the environment */
-export function getPlatformaInstance(config?: BlockConfig): Platforma {
+export function getPlatformaInstance(config?: {sdkVersion: string}): Platforma {
   if (config && typeof globalThis.getPlatforma === 'function')
     return globalThis.getPlatforma(config);
   else if (typeof globalThis.platforma !== 'undefined') return globalThis.platforma;

package/src/platforma.ts

@@ -1,6 +1,5 @@
 import { BlockApi } from './block_api';
 import { BlockOutputsBase, BlockState, DriverKit, ValueOrErrors } from '@milaboratories/pl-model-common';
-import { BlockConfig } from './builder';
 import { SdkInfo } from './sdk_info';
 import { BlockStatePatch } from './block_state_patch';
 
@@ -29,7 +28,7 @@ export type InferUiState<Pl extends Platforma> =
 export type InferHrefType<Pl extends Platforma> =
   Pl extends Platforma<unknown, BlockOutputsBase, unknown, infer Href> ? Href : never;
 
-export type PlatformaFactory = (config: BlockConfig) => Platforma;
+export type PlatformaFactory = (config: {sdkVersion: string}) => Platforma;
 
 export type InferBlockState<Pl extends Platforma> = BlockState<
   InferArgsType<Pl>,

package/src/raw_globals.ts

@@ -1,7 +1,8 @@
 import {} from './global';
 import { getPlatformaInstance } from './internal';
 import { Platforma } from './platforma';
+import { PlatformaSDKVersion } from './version';
 
 export function getRawPlatformaInstance(): Platforma {
-  return getPlatformaInstance();
+  return getPlatformaInstance({ sdkVersion: PlatformaSDKVersion });
 }

package/src/render/accessor.ts

@@ -25,6 +25,24 @@ function wrapAccessor(handle: AccessorHandle | undefined): TreeNodeAccessor | un
   return handle === undefined ? undefined : new TreeNodeAccessor(handle);
 }
 
+type FieldMapOps = {
+  /**
+   * Type of fields to interate over.
+   * (default 'Input')
+   * */
+  readonly fieldType?: 'Input' | 'Output' | 'Dynamic';
+  /**
+   * If not locked, `undefined` value will be returned. Do nothing if mapping `Dynamic` fields.
+   * (default true)
+   * */
+  readonly requireLocked?: boolean;
+  /**
+   * Will skip unresolved fields.
+   * (default false)
+   * */
+  readonly skipUnresolved?: boolean;
+};
+
 /** Represent resource tree node accessor */
 export class TreeNodeAccessor {
   constructor(public readonly handle: AccessorHandle) {}
@@ -220,4 +238,59 @@ export class TreeNodeAccessor {
   public getLogHandle(): FutureRef<AnyLogHandle | undefined> {
     return new FutureRef(getCfgRenderCtx().getLogHandle(this.handle));
   }
+
+  public allFieldsResolved(fieldType: 'Input' | 'Output' = 'Input'): boolean {
+    switch (fieldType) {
+      case 'Input':
+        return (
+          this.getInputsLocked() &&
+          this.listInputFields().every(
+            (field) => this.resolve({ field, assertFieldType: 'Input' }) !== undefined
+          )
+        );
+      case 'Output':
+        return (
+          this.getOutputsLocked() &&
+          this.listOutputFields().every(
+            (field) => this.resolve({ field, assertFieldType: 'Output' }) !== undefined
+          )
+        );
+    }
+  }
+
+  public mapFields<T>(
+    _mapping: (name: string, value: TreeNodeAccessor) => T,
+    _ops: FieldMapOps & { skipUnresolved: true }
+  ): T[] | undefined;
+  public mapFields<T>(
+    _mapping: (name: string, value: TreeNodeAccessor | undefined) => T,
+    _ops?: FieldMapOps
+  ): T[] | undefined;
+  public mapFields<T>(
+    _mapping: (name: string, value: TreeNodeAccessor) => T,
+    _ops?: FieldMapOps
+  ): T[] | undefined {
+    const { fieldType, requireLocked, skipUnresolved } = {
+      fieldType: 'Input' as const,
+      requireLocked: true,
+      skipUnresolved: false,
+      ..._ops
+    };
+    const mapping = _mapping as (name: string, value: TreeNodeAccessor | undefined) => T;
+    if (requireLocked) {
+      if (fieldType === 'Input' && !this.getInputsLocked()) return undefined;
+      if (fieldType === 'Output' && !this.getOutputsLocked()) return undefined;
+    }
+    const fieldList =
+      fieldType === 'Input'
+        ? this.listInputFields()
+        : fieldType === 'Output'
+          ? this.listOutputFields()
+          : this.listDynamicFields();
+    let fieldEntries = fieldList.map(
+      (field) => [field, this.resolve({ field, assertFieldType: fieldType })] as const
+    );
+    if (skipUnresolved) fieldEntries = fieldEntries.filter((e) => e[1] !== undefined);
+    return fieldEntries.map(([name, value]) => mapping(name, value));
+  }
 }

package/src/render/api.ts

@@ -112,11 +112,15 @@ export class ResultPool {
    * @returns data associated with the ref
    */
   public getDataByRef(ref: Ref): PObject<TreeNodeAccessor> | undefined {
-    // https://github.com/milaboratory/platforma/issues/100
-    // @TODO use native pool method when available
-    return this.getData().entries.find(
-      (f) => f.ref.blockId === ref.blockId && f.ref.name === ref.name
-    )?.obj;
+    // @TODO remove after 1 Jan 2025; forward compatibility
+    if (typeof this.ctx.getDataFromResultPoolByRef === 'undefined')
+      return this.getData().entries.find(
+        (f) => f.ref.blockId === ref.blockId && f.ref.name === ref.name
+      )?.obj;
+    return mapPObjectData(
+      this.ctx.getDataFromResultPoolByRef(ref.blockId, ref.name),
+      (handle) => new TreeNodeAccessor(handle)
+    );
   }
 
   /**
@@ -124,11 +128,12 @@ export class ResultPool {
    * @returns object spec associated with the ref
    */
   public getSpecByRef(ref: Ref): PObjectSpec | undefined {
-    // https://github.com/milaboratory/platforma/issues/100
-    // @TODO use native pool method when available
-    return this.getSpecs().entries.find(
-      (f) => f.ref.blockId === ref.blockId && f.ref.name === ref.name
-    )?.obj;
+    // @TODO remove after 1 Jan 2025; forward compatibility
+    if (typeof this.ctx.getSpecFromResultPoolByRef === 'undefined')
+      return this.getSpecs().entries.find(
+        (f) => f.ref.blockId === ref.blockId && f.ref.name === ref.name
+      )?.obj;
+    return this.ctx.getSpecFromResultPoolByRef(ref.blockId, ref.name);
   }
 
   /**
@@ -275,9 +280,16 @@ export class RenderCtx<Args, UiState> {
     return this.ctx.createPTable(mapPTableDef(rawDef, (po) => mapPObjectData(po, (d) => d.handle)));
   }
 
+  /** @deprecated scheduled for removal from SDK */
   public getBlockLabel(blockId: string): string {
     return this.ctx.getBlockLabel(blockId);
   }
+
+  public getCurrentUnstableMarker(): string | undefined {
+    // @TODO remove after 1 Jan 2025; forward compatibility
+    if (typeof this.ctx.getCurrentUnstableMarker === 'undefined') return undefined;
+    return this.ctx.getCurrentUnstableMarker();
+  }
 }
 
 export type RenderFunction<Args = unknown, UiState = unknown, Ret = unknown> = (