@platforma-sdk/model 1.58.3 → 1.58.9

package/dist/block_model.cjs

@@ -1,350 +1,319 @@
-'use strict';
-
-var internal = require('./internal.cjs');
-var api = require('./render/api.cjs');
-require('@milaboratories/pl-model-common');
-require('./render/util/label.cjs');
-require('canonicalize');
-var plugin_handle = require('./plugin_handle.cjs');
-var version = require('./version.cjs');
-var block_storage_callbacks = require('./block_storage_callbacks.cjs');
-var normalization = require('./bconfig/normalization.cjs');
-var types = require('./bconfig/types.cjs');
-var block_storage_facade = require('./block_storage_facade.cjs');
+const require_plugin_handle = require('./plugin_handle.cjs');
+const require_internal = require('./internal.cjs');
+const require_block_storage_facade = require('./block_storage_facade.cjs');
+const require_api = require('./render/api.cjs');
+require('./render/index.cjs');
+const require_version = require('./version.cjs');
+const require_types = require('./bconfig/types.cjs');
+const require_normalization = require('./bconfig/normalization.cjs');
+require('./bconfig/index.cjs');
+const require_plugin_model = require('./plugin_model.cjs');
+const require_block_storage_callbacks = require('./block_storage_callbacks.cjs');
 
+//#region src/block_model.ts
 /**
- * Merges two feature flag objects with type-aware logic:
- * - `supports*` (boolean): OR — `true` if either side is `true`
- * - `requires*` (numeric): MAX — take the higher version requirement
- */
+* Merges two feature flag objects with type-aware logic:
+* - `supports*` (boolean): OR — `true` if either side is `true`
+* - `requires*` (numeric): MAX — take the higher version requirement
+*/
 function mergeFeatureFlags(base, override) {
-    const result = { ...base };
-    for (const [key, value] of Object.entries(override)) {
-        if (value === undefined)
-            continue;
-        const existing = result[key];
-        if (typeof value === "boolean") {
-            result[key] = (typeof existing === "boolean" && existing) || value;
-        }
-        else if (typeof value === "number") {
-            result[key] = Math.max(typeof existing === "number" ? existing : 0, value);
-        }
-    }
-    return result;
+	const result = { ...base };
+	for (const [key, value] of Object.entries(override)) {
+		if (value === void 0) continue;
+		const existing = result[key];
+		if (typeof value === "boolean") result[key] = typeof existing === "boolean" && existing || value;
+		else if (typeof value === "number") result[key] = Math.max(typeof existing === "number" ? existing : 0, value);
+	}
+	return result;
 }
 /** 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.
- * API version is 3 (for UI) and 2 (for model) */
-class BlockModelV3 {
-    config;
-    constructor(config) {
-        this.config = config;
-    }
-    static INITIAL_BLOCK_FEATURE_FLAGS = {
-        supportsLazyState: true,
-        requiresUIAPIVersion: 3,
-        requiresModelAPIVersion: block_storage_facade.BLOCK_STORAGE_FACADE_VERSION,
-        requiresCreatePTable: 2,
-    };
-    /**
-     * Creates a new BlockModelV3 builder with the specified data model.
-     *
-     * @example
-     * const dataModel = new DataModelBuilder()
-     *   .from<BlockData>("v1")
-     *   .init(() => ({ numbers: [], labels: [] }));
-     *
-     * BlockModelV3.create(dataModel)
-     *   .args((data) => ({ numbers: data.numbers }))
-     *   .sections(() => [{ type: 'link', href: '/', label: 'Main' }])
-     *   .done();
-     *
-     * @param dataModel The data model that defines initial data and migrations
-     */
-    static create(dataModel) {
-        return new BlockModelV3({
-            renderingMode: "Heavy",
-            dataModel,
-            outputs: {},
-            sections: internal.createAndRegisterRenderLambda({ handle: "sections", lambda: () => [] }, true),
-            title: undefined,
-            subtitle: undefined,
-            tags: undefined,
-            enrichmentTargets: undefined,
-            featureFlags: { ...BlockModelV3.INITIAL_BLOCK_FEATURE_FLAGS },
-            argsFunction: undefined,
-            prerunArgsFunction: undefined,
-            plugins: {},
-        });
-    }
-    output(key, cfgOrRf, flags = {}) {
-        return new BlockModelV3({
-            ...this.config,
-            outputs: {
-                ...this.config.outputs,
-                [key]: internal.createAndRegisterRenderLambda({
-                    handle: `block-output#${key}`,
-                    lambda: () => cfgOrRf(new api.BlockRenderCtx()),
-                    ...flags,
-                }),
-            },
-        });
-    }
-    /** Shortcut for {@link output} with retentive flag set to true. */
-    retentiveOutput(key, rf) {
-        return this.output(key, rf, { retentive: true });
-    }
-    /** Shortcut for {@link output} with withStatus flag set to true. */
-    outputWithStatus(key, rf) {
-        return this.output(key, rf, { withStatus: true });
-    }
-    /**
-     * Sets a function to derive block args from data.
-     * This is called during setData to compute the args that will be used for block execution.
-     *
-     * @example
-     * .args<BlockArgs>((data) => ({ numbers: data.numbers }))
-     *
-     * @example
-     * .args<BlockArgs>((data) => {
-     *   if (data.numbers.length === 0) throw new Error('Numbers required'); // block not ready
-     *   return { numbers: data.numbers };
-     * })
-     */
-    args(lambda) {
-        return new BlockModelV3({
-            ...this.config,
-            argsFunction: lambda,
-        });
-    }
-    /**
-     * Sets a function to derive pre-run args from data (optional).
-     * This is called during setData to compute the args that will be used for staging/pre-run phase.
-     *
-     * If not defined, defaults to using the args() function result.
-     * If defined, uses its return value for the staging / prerun phase.
-     *
-     * The staging / prerun phase runs only if currentPrerunArgs differs from the executed
-     * version of prerunArgs (same comparison logic as currentArgs vs prodArgs).
-     *
-     * @example
-     * .prerunArgs((data) => ({ numbers: data.numbers }))
-     *
-     * @example
-     * .prerunArgs((data) => {
-     *   // Return undefined to skip staging for this block
-     *   if (!data.isReady) return undefined;
-     *   return { numbers: data.numbers };
-     * })
-     */
-    prerunArgs(fn) {
-        return new BlockModelV3({
-            ...this.config,
-            prerunArgsFunction: fn,
-        });
-    }
-    /** Sets the lambda to generate list of sections in the left block overviews panel. */
-    sections(rf) {
-        return new BlockModelV3({
-            ...this.config,
-            // Replace the default sections callback with the user-provided one
-            sections: internal.createAndRegisterRenderLambda({ handle: "sections", lambda: () => rf(new api.BlockRenderCtx()) }, true),
-        });
-    }
-    /** Sets a rendering function to derive block title, shown for the block in the left blocks-overview panel. */
-    title(rf) {
-        return new BlockModelV3({
-            ...this.config,
-            title: internal.createAndRegisterRenderLambda({
-                handle: "title",
-                lambda: () => rf(new api.BlockRenderCtx()),
-            }),
-        });
-    }
-    subtitle(rf) {
-        return new BlockModelV3({
-            ...this.config,
-            subtitle: internal.createAndRegisterRenderLambda({
-                handle: "subtitle",
-                lambda: () => rf(new api.BlockRenderCtx()),
-            }),
-        });
-    }
-    tags(rf) {
-        return new BlockModelV3({
-            ...this.config,
-            tags: internal.createAndRegisterRenderLambda({
-                handle: "tags",
-                lambda: () => rf(new api.BlockRenderCtx()),
-            }),
-        });
-    }
-    /** Sets or overrides feature flags for the block. */
-    withFeatureFlags(flags) {
-        return new BlockModelV3({
-            ...this.config,
-            featureFlags: { ...this.config.featureFlags, ...flags },
-        });
-    }
-    /**
-     * Defines how to derive list of upstream references this block is meant to enrich with its exports from block args.
-     * Influences dependency graph construction.
-     */
-    enriches(lambda) {
-        return new BlockModelV3({
-            ...this.config,
-            enrichmentTargets: internal.createAndRegisterRenderLambda({
-                handle: "enrichmentTargets",
-                lambda: lambda,
-            }),
-        });
-    }
-    /**
-     * Registers a plugin instance with the block.
-     *
-     * Plugins are UI components with their own model logic and persistent state.
-     * Each plugin must have a unique pluginId within the block.
-     *
-     * @param pluginId - Unique identifier for this plugin instance within the block
-     * @param plugin - Configured PluginModel instance (created via factory.create(config))
-     * @param params - Per-property lambdas deriving plugin params from block RenderCtx
-     *
-     * @example
-     * .plugin('mainTable', dataTablePlugin.create({ defaultOps: {...} }), {
-     *   columns: (ctx) => ctx.outputs?.resolve("data")?.getPColumns(),
-     *   sourceId: (ctx) => ctx.data.selectedSource,
-     * })
-     */
-    plugin(pluginId, plugin, params) {
-        // Validate pluginId uniqueness
-        if (pluginId in this.config.plugins) {
-            throw new Error(`Plugin '${pluginId}' already registered`);
-        }
-        const instance = {
-            model: plugin,
-            inputs: (params ?? {}),
-        };
-        return new BlockModelV3({
-            ...this.config,
-            plugins: {
-                ...this.config.plugins,
-                [pluginId]: instance,
-            },
-            featureFlags: mergeFeatureFlags(this.config.featureFlags, plugin.featureFlags ?? {}),
-        });
-    }
-    /** Renders all provided block settings into a pre-configured platforma API
-     * instance, that can be used in frontend to interact with block data, and
-     * other features provided by the platforma to the block. */
-    done() {
-        return this.withFeatureFlags({
-            ...this.config.featureFlags,
-        })._done();
-    }
-    _done() {
-        if (this.config.argsFunction === undefined)
-            throw new Error("Args rendering function not set.");
-        const apiVersion = 3;
-        // Build plugin registry
-        const { plugins } = this.config;
-        const pluginRegistry = {};
-        const pluginHandles = Object.keys(plugins);
-        for (const handle of pluginHandles) {
-            pluginRegistry[handle] = plugins[handle].model.name;
-        }
-        const { dataModel, argsFunction, prerunArgsFunction } = this.config;
-        function getPlugin(handle) {
-            const plugin = plugins[handle];
-            if (!plugin)
-                throw new Error(`Plugin model not found for '${handle}'`);
-            return plugin;
-        }
-        // Register ALL facade callbacks here, with dependencies captured via closures
-        block_storage_facade.registerFacadeCallbacks({
-            [block_storage_facade.BlockStorageFacadeCallbacks.StorageApplyUpdate]: block_storage_callbacks.applyStorageUpdate,
-            [block_storage_facade.BlockStorageFacadeCallbacks.StorageDebugView]: block_storage_callbacks.getStorageDebugView,
-            [block_storage_facade.BlockStorageFacadeCallbacks.StorageMigrate]: (currentStorageJson) => block_storage_callbacks.migrateStorage(currentStorageJson, {
-                migrateBlockData: (v) => dataModel.migrate(v),
-                getPluginRegistry: () => pluginRegistry,
-                migratePluginData: (handle, v) => getPlugin(handle).model.dataModel.migrate(v),
-                createPluginData: (handle) => getPlugin(handle).model.dataModel.getDefaultData(),
-            }),
-            [block_storage_facade.BlockStorageFacadeCallbacks.StorageInitial]: () => block_storage_callbacks.createInitialStorage({
-                getDefaultBlockData: () => dataModel.getDefaultData(),
-                getPluginRegistry: () => pluginRegistry,
-                createPluginData: (handle) => getPlugin(handle).model.dataModel.getDefaultData(),
-            }),
-            [block_storage_facade.BlockStorageFacadeCallbacks.ArgsDerive]: (storageJson) => block_storage_callbacks.deriveArgsFromStorage(storageJson, argsFunction),
-            [block_storage_facade.BlockStorageFacadeCallbacks.PrerunArgsDerive]: (storageJson) => block_storage_callbacks.derivePrerunArgsFromStorage(storageJson, argsFunction, prerunArgsFunction),
-        });
-        // Register plugin input and output lambdas
-        const pluginOutputs = {};
-        for (const handle of pluginHandles) {
-            const { model, inputs } = plugins[handle];
-            // Wrap plugin param lambdas: close over BlockRenderCtx creation
-            const wrappedInputs = {};
-            for (const [paramKey, paramFn] of Object.entries(inputs)) {
-                wrappedInputs[paramKey] = () => paramFn(new api.BlockRenderCtx());
-            }
-            // Register plugin outputs (in config pack, evaluated by middle layer)
-            const outputs = model.outputs;
-            for (const [outputKey, outputFn] of Object.entries(outputs)) {
-                const key = plugin_handle.pluginOutputKey(handle, outputKey);
-                pluginOutputs[key] = internal.createAndRegisterRenderLambda({
-                    handle: key,
-                    lambda: () => outputFn(new api.PluginRenderCtx(handle, wrappedInputs)),
-                });
-            }
-        }
-        const allOutputs = { ...this.config.outputs, ...pluginOutputs };
-        const blockConfig = {
-            v4: {
-                configVersion: 4,
-                modelAPIVersion: block_storage_facade.BLOCK_STORAGE_FACADE_VERSION,
-                sdkVersion: version.PlatformaSDKVersion,
-                renderingMode: this.config.renderingMode,
-                sections: this.config.sections,
-                title: this.config.title,
-                subtitle: this.config.subtitle,
-                tags: this.config.tags,
-                outputs: allOutputs,
-                enrichmentTargets: this.config.enrichmentTargets,
-                featureFlags: this.config.featureFlags,
-                blockLifecycleCallbacks: { ...block_storage_facade.BlockStorageFacadeHandles },
-            },
-            // fields below are added to allow previous desktop versions read generated configs
-            sdkVersion: version.PlatformaSDKVersion,
-            renderingMode: this.config.renderingMode,
-            sections: this.config.sections,
-            outputs: Object.fromEntries(Object.entries(this.config.outputs).map(([key, value]) => [
-                key,
-                normalization.downgradeCfgOrLambda(value),
-            ])),
-        };
-        globalThis.platformaApiVersion = apiVersion;
-        if (!internal.isInUI())
-            // we are in the configuration rendering routine, not in actual UI
-            return { config: blockConfig };
-        // normal operation inside the UI
-        else
-            return {
-                ...internal.getPlatformaInstance({
-                    sdkVersion: version.PlatformaSDKVersion,
-                    apiVersion,
-                }),
-                blockModelInfo: {
-                    outputs: Object.fromEntries(Object.entries(allOutputs).map(([key, value]) => [
-                        key,
-                        {
-                            withStatus: Boolean(types.isConfigLambda(value) && value.withStatus),
-                        },
-                    ])),
-                    pluginIds: pluginHandles,
-                },
-            };
-    }
-}
+* 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.
+* API version is 3 (for UI) and 2 (for model) */
+var BlockModelV3 = class BlockModelV3 {
+	constructor(config) {
+		this.config = config;
+	}
+	static INITIAL_BLOCK_FEATURE_FLAGS = {
+		supportsLazyState: true,
+		requiresUIAPIVersion: 3,
+		requiresModelAPIVersion: require_block_storage_facade.BLOCK_STORAGE_FACADE_VERSION,
+		requiresCreatePTable: 2
+	};
+	/**
+	* Creates a new BlockModelV3 builder with the specified data model.
+	*
+	* @example
+	* const dataModel = new DataModelBuilder()
+	*   .from<BlockData>("v1")
+	*   .init(() => ({ numbers: [], labels: [] }));
+	*
+	* BlockModelV3.create(dataModel)
+	*   .args((data) => ({ numbers: data.numbers }))
+	*   .sections(() => [{ type: 'link', href: '/', label: 'Main' }])
+	*   .done();
+	*
+	* @param dataModel The data model that defines initial data and migrations
+	*/
+	static create(dataModel) {
+		return new BlockModelV3({
+			renderingMode: "Heavy",
+			dataModel,
+			outputs: {},
+			sections: require_internal.createAndRegisterRenderLambda({
+				handle: "sections",
+				lambda: () => []
+			}, true),
+			title: void 0,
+			subtitle: void 0,
+			tags: void 0,
+			enrichmentTargets: void 0,
+			featureFlags: { ...BlockModelV3.INITIAL_BLOCK_FEATURE_FLAGS },
+			argsFunction: void 0,
+			prerunArgsFunction: void 0,
+			plugins: {}
+		});
+	}
+	output(key, cfgOrRf, flags = {}) {
+		return new BlockModelV3({
+			...this.config,
+			outputs: {
+				...this.config.outputs,
+				[key]: require_internal.createAndRegisterRenderLambda({
+					handle: `block-output#${key}`,
+					lambda: () => cfgOrRf(new require_api.BlockRenderCtx()),
+					...flags
+				})
+			}
+		});
+	}
+	/** Shortcut for {@link output} with retentive flag set to true. */
+	retentiveOutput(key, rf) {
+		return this.output(key, rf, { retentive: true });
+	}
+	/** Shortcut for {@link output} with withStatus flag set to true. */
+	outputWithStatus(key, rf) {
+		return this.output(key, rf, { withStatus: true });
+	}
+	/**
+	* Sets a function to derive block args from data.
+	* This is called during setData to compute the args that will be used for block execution.
+	*
+	* @example
+	* .args<BlockArgs>((data) => ({ numbers: data.numbers }))
+	*
+	* @example
+	* .args<BlockArgs>((data) => {
+	*   if (data.numbers.length === 0) throw new Error('Numbers required'); // block not ready
+	*   return { numbers: data.numbers };
+	* })
+	*/
+	args(lambda) {
+		return new BlockModelV3({
+			...this.config,
+			argsFunction: lambda
+		});
+	}
+	/**
+	* Sets a function to derive pre-run args from data (optional).
+	* This is called during setData to compute the args that will be used for staging/pre-run phase.
+	*
+	* If not defined, defaults to using the args() function result.
+	* If defined, uses its return value for the staging / prerun phase.
+	*
+	* The staging / prerun phase runs only if currentPrerunArgs differs from the executed
+	* version of prerunArgs (same comparison logic as currentArgs vs prodArgs).
+	*
+	* @example
+	* .prerunArgs((data) => ({ numbers: data.numbers }))
+	*
+	* @example
+	* .prerunArgs((data) => {
+	*   // Return undefined to skip staging for this block
+	*   if (!data.isReady) return undefined;
+	*   return { numbers: data.numbers };
+	* })
+	*/
+	prerunArgs(fn) {
+		return new BlockModelV3({
+			...this.config,
+			prerunArgsFunction: fn
+		});
+	}
+	/** Sets the lambda to generate list of sections in the left block overviews panel. */
+	sections(rf) {
+		return new BlockModelV3({
+			...this.config,
+			sections: require_internal.createAndRegisterRenderLambda({
+				handle: "sections",
+				lambda: () => rf(new require_api.BlockRenderCtx())
+			}, true)
+		});
+	}
+	/** Sets a rendering function to derive block title, shown for the block in the left blocks-overview panel. */
+	title(rf) {
+		return new BlockModelV3({
+			...this.config,
+			title: require_internal.createAndRegisterRenderLambda({
+				handle: "title",
+				lambda: () => rf(new require_api.BlockRenderCtx())
+			})
+		});
+	}
+	subtitle(rf) {
+		return new BlockModelV3({
+			...this.config,
+			subtitle: require_internal.createAndRegisterRenderLambda({
+				handle: "subtitle",
+				lambda: () => rf(new require_api.BlockRenderCtx())
+			})
+		});
+	}
+	tags(rf) {
+		return new BlockModelV3({
+			...this.config,
+			tags: require_internal.createAndRegisterRenderLambda({
+				handle: "tags",
+				lambda: () => rf(new require_api.BlockRenderCtx())
+			})
+		});
+	}
+	/** Sets or overrides feature flags for the block. */
+	withFeatureFlags(flags) {
+		return new BlockModelV3({
+			...this.config,
+			featureFlags: {
+				...this.config.featureFlags,
+				...flags
+			}
+		});
+	}
+	/**
+	* Defines how to derive list of upstream references this block is meant to enrich with its exports from block args.
+	* Influences dependency graph construction.
+	*/
+	enriches(lambda) {
+		return new BlockModelV3({
+			...this.config,
+			enrichmentTargets: require_internal.createAndRegisterRenderLambda({
+				handle: "enrichmentTargets",
+				lambda
+			})
+		});
+	}
+	plugin(instance, params) {
+		const pluginId = instance.id;
+		const plugin = instance[require_plugin_model.CREATE_PLUGIN_MODEL]();
+		const resolvedParams = params ?? {};
+		if (pluginId in this.config.plugins) throw new Error(`Plugin '${pluginId}' already registered`);
+		const registered = {
+			model: plugin,
+			inputs: resolvedParams
+		};
+		return new BlockModelV3({
+			...this.config,
+			plugins: {
+				...this.config.plugins,
+				[pluginId]: registered
+			},
+			featureFlags: mergeFeatureFlags(this.config.featureFlags, plugin.featureFlags ?? {})
+		});
+	}
+	/** Renders all provided block settings into a pre-configured platforma API
+	* instance, that can be used in frontend to interact with block data, and
+	* other features provided by the platforma to the block.
+	*
+	* Type-level check: if there are unconsumed transfers (from `.transfer()` calls
+	* in the migration chain), this method requires an impossible `never` argument,
+	* producing a compile error. Register all transferred plugins via `.plugin(instance)`
+	* before calling `.done()`.
+	*/
+	done(..._) {
+		if (this.config.argsFunction === void 0) throw new Error("Args rendering function not set.");
+		const apiVersion = 3;
+		const { plugins } = this.config;
+		const pluginRegistry = {};
+		const pluginHandles = Object.keys(plugins);
+		for (const handle of pluginHandles) pluginRegistry[handle] = plugins[handle].model.name;
+		const { dataModel, argsFunction, prerunArgsFunction } = this.config;
+		function getPlugin(handle) {
+			const plugin = plugins[handle];
+			if (!plugin) throw new Error(`Plugin model not found for '${handle}'`);
+			return plugin;
+		}
+		require_block_storage_facade.registerFacadeCallbacks({
+			[require_block_storage_facade.BlockStorageFacadeCallbacks.StorageApplyUpdate]: require_block_storage_callbacks.applyStorageUpdate,
+			[require_block_storage_facade.BlockStorageFacadeCallbacks.StorageDebugView]: require_block_storage_callbacks.getStorageDebugView,
+			[require_block_storage_facade.BlockStorageFacadeCallbacks.StorageMigrate]: (currentStorageJson) => require_block_storage_callbacks.migrateStorage(currentStorageJson, {
+				migrateBlockData: (v) => dataModel.migrate(v),
+				getPluginRegistry: () => pluginRegistry,
+				migratePluginData: (handle, v) => getPlugin(handle).model.dataModel.migrate(v),
+				createPluginData: (handle, transfer) => {
+					if (transfer) return transfer;
+					return getPlugin(handle).model.getDefaultData();
+				}
+			}),
+			[require_block_storage_facade.BlockStorageFacadeCallbacks.StorageInitial]: () => require_block_storage_callbacks.createInitialStorage({
+				getDefaultBlockData: () => dataModel.getDefaultData(),
+				getPluginRegistry: () => pluginRegistry,
+				createPluginData: (handle) => getPlugin(handle).model.getDefaultData()
+			}),
+			[require_block_storage_facade.BlockStorageFacadeCallbacks.ArgsDerive]: (storageJson) => require_block_storage_callbacks.deriveArgsFromStorage(storageJson, argsFunction),
+			[require_block_storage_facade.BlockStorageFacadeCallbacks.PrerunArgsDerive]: (storageJson) => require_block_storage_callbacks.derivePrerunArgsFromStorage(storageJson, argsFunction, prerunArgsFunction)
+		});
+		const pluginOutputs = {};
+		for (const handle of pluginHandles) {
+			const { model, inputs } = plugins[handle];
+			const wrappedInputs = {};
+			for (const [paramKey, paramFn] of Object.entries(inputs)) wrappedInputs[paramKey] = () => paramFn(new require_api.BlockRenderCtx());
+			const outputs = model.outputs;
+			for (const [outputKey, outputFn] of Object.entries(outputs)) {
+				const key = require_plugin_handle.pluginOutputKey(handle, outputKey);
+				pluginOutputs[key] = require_internal.createAndRegisterRenderLambda({
+					handle: key,
+					lambda: () => outputFn(new require_api.PluginRenderCtx(handle, wrappedInputs))
+				});
+			}
+		}
+		const allOutputs = {
+			...this.config.outputs,
+			...pluginOutputs
+		};
+		const blockConfig = {
+			v4: {
+				configVersion: 4,
+				modelAPIVersion: require_block_storage_facade.BLOCK_STORAGE_FACADE_VERSION,
+				sdkVersion: require_version.PlatformaSDKVersion,
+				renderingMode: this.config.renderingMode,
+				sections: this.config.sections,
+				title: this.config.title,
+				subtitle: this.config.subtitle,
+				tags: this.config.tags,
+				outputs: allOutputs,
+				enrichmentTargets: this.config.enrichmentTargets,
+				featureFlags: this.config.featureFlags,
+				blockLifecycleCallbacks: { ...require_block_storage_facade.BlockStorageFacadeHandles }
+			},
+			sdkVersion: require_version.PlatformaSDKVersion,
+			renderingMode: this.config.renderingMode,
+			sections: this.config.sections,
+			outputs: Object.fromEntries(Object.entries(this.config.outputs).map(([key, value]) => [key, require_normalization.downgradeCfgOrLambda(value)]))
+		};
+		globalThis.platformaApiVersion = apiVersion;
+		if (!require_internal.isInUI()) return { config: blockConfig };
+		else return {
+			...require_internal.getPlatformaInstance({
+				sdkVersion: require_version.PlatformaSDKVersion,
+				apiVersion
+			}),
+			blockModelInfo: {
+				outputs: Object.fromEntries(Object.entries(allOutputs).map(([key, value]) => [key, { withStatus: Boolean(require_types.isConfigLambda(value) && value.withStatus) }])),
+				pluginIds: pluginHandles
+			}
+		};
+	}
+};
 
+//#endregion
 exports.BlockModelV3 = BlockModelV3;
-//# sourceMappingURL=block_model.cjs.map
+//# sourceMappingURL=block_model.cjs.map