@platforma-open/milaboratories.immune-assay-data.model 1.5.1 → 1.5.3

package/dist/bundle.js

@@ -4,6 +4,113 @@
     (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global["block-model"] = {}));
 })(this, (function (exports) { 'use strict';
 
+    /**
+     * BlockStorage - Typed storage abstraction for block persistent data.
+     *
+     * This module provides:
+     * - A typed structure for block storage with versioning and plugin support
+     * - Utility functions for manipulating storage
+     * - Handler interfaces for model-level customization
+     *
+     * @module block_storage
+     */
+    // =============================================================================
+    // Core Types
+    // =============================================================================
+    /**
+     * Discriminator key for BlockStorage format detection.
+     * This unique hash-based key identifies data as BlockStorage vs legacy formats.
+     */
+    const BLOCK_STORAGE_KEY = '__pl_a7f3e2b9__';
+    /**
+     * Current BlockStorage schema version.
+     * Increment this when the storage structure itself changes (not block state migrations).
+     */
+    const BLOCK_STORAGE_SCHEMA_VERSION = 'v1';
+    /**
+     * Default data version for new blocks without migrations.
+     * Unique identifier ensures blocks are created via DataModel API.
+     */
+    const DATA_MODEL_DEFAULT_VERSION = '__pl_v1_d4e8f2a1__';
+    /**
+     * Type guard to check if a value is a valid BlockStorage object.
+     * Checks for the discriminator key and valid schema version.
+     */
+    function isBlockStorage(value) {
+        if (value === null || typeof value !== 'object')
+            return false;
+        const obj = value;
+        const schemaVersion = obj[BLOCK_STORAGE_KEY];
+        // Currently only 'v1' is valid, but this allows future versions
+        return schemaVersion === 'v1'; // Add more versions as schema evolves
+    }
+    // =============================================================================
+    // Factory Functions
+    // =============================================================================
+    /**
+     * Creates a BlockStorage with the given initial data
+     *
+     * @param initialData - The initial data value (defaults to empty object)
+     * @param version - The initial data version key (defaults to DATA_MODEL_DEFAULT_VERSION)
+     * @returns A new BlockStorage instance with discriminator key
+     */
+    function createBlockStorage(initialData = {}, version = DATA_MODEL_DEFAULT_VERSION) {
+        return {
+            [BLOCK_STORAGE_KEY]: BLOCK_STORAGE_SCHEMA_VERSION,
+            __dataVersion: version,
+            __data: initialData,
+        };
+    }
+    /**
+     * Normalizes raw storage data to BlockStorage format.
+     * If the input is already a BlockStorage, returns it as-is.
+     * If the input is legacy format (raw state), wraps it in BlockStorage structure.
+     *
+     * @param raw - Raw storage data (may be legacy format or BlockStorage)
+     * @returns Normalized BlockStorage
+     */
+    function normalizeBlockStorage(raw) {
+        if (isBlockStorage(raw)) {
+            const storage = raw;
+            return {
+                ...storage,
+                // Fix for early released version where __dataVersion was a number
+                __dataVersion: typeof storage.__dataVersion === 'number'
+                    ? DATA_MODEL_DEFAULT_VERSION
+                    : storage.__dataVersion,
+            };
+        }
+        // Legacy format: raw is the state directly
+        return createBlockStorage(raw);
+    }
+    // =============================================================================
+    // Data Access & Update Functions
+    // =============================================================================
+    /**
+     * Gets the data from BlockStorage
+     *
+     * @param storage - The BlockStorage instance
+     * @returns The data value
+     */
+    function getStorageData(storage) {
+        return storage.__data;
+    }
+    /**
+     * Updates the data in BlockStorage (immutable)
+     *
+     * @param storage - The current BlockStorage
+     * @param payload - The update payload with operation and value
+     * @returns A new BlockStorage with updated data
+     */
+    function updateStorageData(storage, payload) {
+        switch (payload.operation) {
+            case 'update-data':
+                return { ...storage, __data: payload.value };
+            default:
+                throw new Error(`Unknown storage operation: ${payload.operation}`);
+        }
+    }
+
     //
     // Helpers
     //
@@ -4625,6 +4732,9 @@
     var canonicalizeExports = requireCanonicalize();
     var canonicalize = /*@__PURE__*/getDefaultExportFromCjs(canonicalizeExports);
 
+    function stringifyJson(value) {
+        return JSON.stringify(value);
+    }
     function canonicalizeJson(value) {
         return canonicalize(value);
     }
@@ -4696,6 +4806,9 @@
             Visibility: 'pl7.app/table/visibility',
         },
         Trace: 'pl7.app/trace',
+        VDJ: {
+            IsAssemblingFeature: 'pl7.app/vdj/isAssemblingFeature',
+        },
     };
     const ValueTypeSchema = z.enum(['Int', 'Long', 'Float', 'Double', 'String']);
     const AnnotationJson = {
@@ -4725,6 +4838,7 @@
         [Annotation.Sequence.IsAnnotation]: z.boolean(),
         [Annotation.Table.OrderPriority]: z.number(),
         [Annotation.Trace]: z.record(z.string(), z.unknown()),
+        [Annotation.VDJ.IsAssemblingFeature]: z.boolean(),
     };
     /// Helper function for reading plain annotation values
     function readAnnotation(spec, key) {
@@ -6100,10 +6214,15 @@
             }
             return result;
         };
-        // Checks if a result has all unique labels
-        const hasUniqueLabels = (result) => result !== undefined && new Set(result.map((c) => c.label)).size === values.length;
+        const countUniqueLabels = (result) => result === undefined ? 0 : new Set(result.map((c) => c.label)).size;
         // Post-processing: try removing types one by one (lowest importance first) to minimize the label set
+        // Accepts removal if it doesn't decrease the number of unique labels (cardinality)
         const minimizeTypeSet = (typeSet) => {
+            const initialResult = calculate(typeSet);
+            if (initialResult === undefined) {
+                return typeSet;
+            }
+            const currentCardinality = countUniqueLabels(initialResult);
             // Get types sorted by importance ascending (lowest first), excluding forced elements
             const removableSorted = [...typeSet]
                 .filter((t) => !forceTraceElements?.has(t.split('@')[0])
@@ -6113,7 +6232,7 @@
                 const reducedSet = new Set(typeSet);
                 reducedSet.delete(typeToRemove);
                 const candidateResult = calculate(reducedSet);
-                if (hasUniqueLabels(candidateResult)) {
+                if (candidateResult !== undefined && countUniqueLabels(candidateResult) >= currentCardinality) {
                     typeSet.delete(typeToRemove);
                 }
             }
@@ -6144,7 +6263,7 @@
             if (additionalType >= 0)
                 currentSet.add(mainTypes[additionalType]);
             const candidateResult = calculate(currentSet);
-            if (hasUniqueLabels(candidateResult)) {
+            if (candidateResult !== undefined && countUniqueLabels(candidateResult) === values.length) {
                 minimizeTypeSet(currentSet);
                 return calculate(currentSet);
             }
@@ -7260,28 +7379,19 @@
         }
     }
     /** Main entry point to the API available within model lambdas (like outputs, sections, etc..) */
-    class RenderCtx {
+    class RenderCtxBase {
         ctx;
         constructor() {
             this.ctx = getCfgRenderCtx();
         }
-        _argsCache;
-        get args() {
-            if (this._argsCache === undefined) {
-                const raw = this.ctx.args;
-                const value = typeof raw === 'function' ? raw() : raw;
-                this._argsCache = { v: JSON.parse(value) };
-            }
-            return this._argsCache.v;
-        }
-        _uiStateCache;
-        get uiState() {
-            if (this._uiStateCache === undefined) {
-                const raw = this.ctx.uiState;
+        _dataCache;
+        get data() {
+            if (this._dataCache === undefined) {
+                const raw = this.ctx.data;
                 const value = typeof raw === 'function' ? raw() : raw;
-                this._uiStateCache = { v: value ? JSON.parse(value) : {} };
+                this._dataCache = { v: value ? JSON.parse(value) : {} };
             }
-            return this._uiStateCache.v;
+            return this._dataCache.v;
         }
         // lazy rendering because this feature is rarely used
         _activeArgsCache;
@@ -7392,8 +7502,29 @@
             this.ctx.logError(msg);
         }
     }
+    /** Render context for legacy v1/v2 blocks - provides backward compatibility */
+    class RenderCtxLegacy extends RenderCtxBase {
+        _argsCache;
+        get args() {
+            if (this._argsCache === undefined) {
+                const raw = this.ctx.args;
+                const value = typeof raw === 'function' ? raw() : raw;
+                this._argsCache = { v: JSON.parse(value) };
+            }
+            return this._argsCache.v;
+        }
+        _uiStateCache;
+        get uiState() {
+            if (this._uiStateCache === undefined) {
+                const raw = this.ctx.uiState;
+                const value = typeof raw === 'function' ? raw() : raw;
+                this._uiStateCache = { v: value ? JSON.parse(value) : {} };
+            }
+            return this._uiStateCache.v;
+        }
+    }
 
-    var version = "1.51.6";
+    var version = "1.53.3";
 
     const PlatformaSDKVersion = version;
 
@@ -7437,7 +7568,7 @@
         output(key, cfgOrRf, flags = {}) {
             if (typeof cfgOrRf === 'function') {
                 const handle = `output#${key}`;
-                tryRegisterCallback(handle, () => cfgOrRf(new RenderCtx()));
+                tryRegisterCallback(handle, () => cfgOrRf(new RenderCtxLegacy()));
                 return new BlockModel({
                     ...this.config,
                     outputs: {
@@ -7474,7 +7605,7 @@
         }
         argsValid(cfgOrRf) {
             if (typeof cfgOrRf === 'function') {
-                tryRegisterCallback('inputsValid', () => cfgOrRf(new RenderCtx()));
+                tryRegisterCallback('inputsValid', () => cfgOrRf(new RenderCtxLegacy()));
                 return new BlockModel({
                     ...this.config,
                     inputsValid: {
@@ -7495,7 +7626,7 @@
                 return this.sections(getImmediate(arrOrCfgOrRf));
             }
             else if (typeof arrOrCfgOrRf === 'function') {
-                tryRegisterCallback('sections', () => arrOrCfgOrRf(new RenderCtx()));
+                tryRegisterCallback('sections', () => arrOrCfgOrRf(new RenderCtxLegacy()));
                 return new BlockModel({
                     ...this.config,
                     sections: {
@@ -7513,7 +7644,7 @@
         }
         /** Sets a rendering function to derive block title, shown for the block in the left blocks-overview panel. */
         title(rf) {
-            tryRegisterCallback('title', () => rf(new RenderCtx()));
+            tryRegisterCallback('title', () => rf(new RenderCtxLegacy()));
             return new BlockModel({
                 ...this.config,
                 title: {
@@ -7523,7 +7654,7 @@
             });
         }
         subtitle(rf) {
-            tryRegisterCallback('subtitle', () => rf(new RenderCtx()));
+            tryRegisterCallback('subtitle', () => rf(new RenderCtxLegacy()));
             return new BlockModel({
                 ...this.config,
                 subtitle: {
@@ -7533,7 +7664,7 @@
             });
         }
         tags(rf) {
-            tryRegisterCallback('tags', () => rf(new RenderCtx()));
+            tryRegisterCallback('tags', () => rf(new RenderCtxLegacy()));
             return new BlockModel({
                 ...this.config,
                 tags: {
@@ -7600,7 +7731,10 @@
             if (this.config.initialArgs === undefined)
                 throw new Error('Initial arguments not set.');
             const config = {
+                v4: undefined,
                 v3: {
+                    configVersion: 3,
+                    modelAPIVersion: 1,
                     sdkVersion: PlatformaSDKVersion,
                     renderingMode: this.config.renderingMode,
                     initialArgs: this.config.initialArgs,
@@ -7640,10 +7774,473 @@
         }
     }
 
+    /**
+     * BlockStorage VM Integration - Internal module for VM-based storage operations.
+     *
+     * This module auto-registers internal callbacks that the middle layer can invoke
+     * to perform storage transformations. Block developers never interact with these
+     * directly - they only see `state`.
+     *
+     * Registered callbacks (all prefixed with `__pl_` for internal SDK use):
+     * - `__pl_storage_applyUpdate`: (currentStorageJson, payload) => updatedStorageJson
+     * - `__pl_storage_debugView`: (rawStorage) => JSON string with storage debug view
+     * - `__pl_storage_migrate`: (currentStorageJson) => MigrationResult
+     * - `__pl_args_derive`: (storageJson) => ArgsDeriveResult
+     * - `__pl_prerunArgs_derive`: (storageJson) => ArgsDeriveResult
+     *
+     * Callbacks registered by DataModel.registerCallbacks():
+     * - `__pl_data_initial`: () => initial data
+     * - `__pl_data_upgrade`: (versioned) => DataMigrationResult
+     * - `__pl_storage_initial`: () => initial BlockStorage as JSON string
+     *
+     * @module block_storage_vm
+     * @internal
+     */
+    /**
+     * Normalizes raw storage data and extracts state.
+     * Handles all formats:
+     * - New BlockStorage format (has discriminator)
+     * - Legacy V1/V2 format ({ args, uiState })
+     * - Raw V3 state (any other format)
+     *
+     * @param rawStorage - Raw data from blockStorage field (may be JSON string or object)
+     * @returns Object with normalized storage and extracted state
+     */
+    function normalizeStorage(rawStorage) {
+        // Handle undefined/null
+        if (rawStorage === undefined || rawStorage === null) {
+            const storage = createBlockStorage({});
+            return { storage, data: {} };
+        }
+        // Parse JSON string if needed
+        let parsed = rawStorage;
+        if (typeof rawStorage === 'string') {
+            try {
+                parsed = JSON.parse(rawStorage);
+            }
+            catch {
+                // If parsing fails, treat string as the data
+                const storage = createBlockStorage(rawStorage);
+                return { storage, data: rawStorage };
+            }
+        }
+        // Check for BlockStorage format (has discriminator)
+        if (isBlockStorage(parsed)) {
+            const storage = normalizeBlockStorage(parsed);
+            return { storage, data: getStorageData(storage) };
+        }
+        // Check for legacy V1/V2 format: { args, uiState }
+        if (isLegacyModelV1ApiFormat(parsed)) {
+            // For legacy format, the whole object IS the data
+            const storage = createBlockStorage(parsed);
+            return { storage, data: parsed };
+        }
+        // Raw V3 data - wrap it
+        const storage = createBlockStorage(parsed);
+        return { storage, data: parsed };
+    }
+    /**
+     * Applies a state update to existing storage.
+     * Used when setData is called from the frontend.
+     *
+     * @param currentStorageJson - Current storage as JSON string (must be defined)
+     * @param newData - New data from application
+     * @returns Updated storage as JSON string
+     */
+    function applyStorageUpdate(currentStorageJson, payload) {
+        const { storage: currentStorage } = normalizeStorage(currentStorageJson);
+        // Update data while preserving other storage fields (version, plugins)
+        const updatedStorage = updateStorageData(currentStorage, payload);
+        return JSON.stringify(updatedStorage);
+    }
+    /**
+     * Checks if data is in legacy Model API v1 format.
+     * Legacy format has { args, uiState? } at top level without the BlockStorage discriminator.
+     */
+    function isLegacyModelV1ApiFormat(data) {
+        if (data === null || typeof data !== 'object')
+            return false;
+        if (isBlockStorage(data))
+            return false;
+        const obj = data;
+        return 'args' in obj;
+    }
+    // =============================================================================
+    // Auto-register internal callbacks when module is loaded in VM
+    // =============================================================================
+    // Register apply update callback (requires existing storage)
+    tryRegisterCallback('__pl_storage_applyUpdate', (currentStorageJson, payload) => {
+        return applyStorageUpdate(currentStorageJson, payload);
+    });
+    /**
+     * Gets storage debug view from raw storage data.
+     * Returns structured debug info about the storage state.
+     *
+     * @param rawStorage - Raw data from blockStorage field (may be JSON string or object)
+     * @returns JSON string with storage debug view
+     */
+    function getStorageDebugView(rawStorage) {
+        const { storage } = normalizeStorage(rawStorage);
+        const debugView = {
+            dataVersion: storage.__dataVersion,
+            data: storage.__data,
+        };
+        return stringifyJson(debugView);
+    }
+    // Register debug view callback
+    tryRegisterCallback('__pl_storage_debugView', (rawStorage) => {
+        return getStorageDebugView(rawStorage);
+    });
+    /**
+     * Runs storage migration using the DataModel's migrate callback.
+     * This is the main entry point for the middle layer to trigger migrations.
+     *
+     * Uses the '__pl_data_upgrade' callback registered by DataModel.registerCallbacks() which:
+     * - Handles all migration logic internally
+     * - Returns { version, data, warning? } - warning present if reset to initial data
+     *
+     * @param currentStorageJson - Current storage as JSON string (or undefined)
+     * @returns MigrationResult
+     */
+    function migrateStorage(currentStorageJson) {
+        // Get the callback registry context
+        const ctx = tryGetCfgRenderCtx();
+        if (ctx === undefined) {
+            return { error: 'Not in config rendering context' };
+        }
+        // Normalize storage to get current data and version
+        const { storage: currentStorage, data: currentData } = normalizeStorage(currentStorageJson);
+        const currentVersion = currentStorage.__dataVersion;
+        // Helper to create storage with given data and version
+        const createStorageJson = (data, version) => {
+            return JSON.stringify({
+                ...currentStorage,
+                __dataVersion: version,
+                __data: data,
+            });
+        };
+        // Get the migrate callback (registered by DataModel.registerCallbacks())
+        const migrateCallback = ctx.callbackRegistry['__pl_data_upgrade'];
+        if (typeof migrateCallback !== 'function') {
+            return { error: '__pl_data_upgrade callback not found (DataModel not registered)' };
+        }
+        // Call the migrator's migrate function
+        let result;
+        try {
+            result = migrateCallback({ version: currentVersion, data: currentData });
+        }
+        catch (e) {
+            const errorMsg = e instanceof Error ? e.message : String(e);
+            return { error: `migrate() threw: ${errorMsg}` };
+        }
+        // Build info message
+        const info = result.version === currentVersion
+            ? `No migration needed (${currentVersion})`
+            : result.warning
+                ? `Reset to initial data (${result.version})`
+                : `Migrated ${currentVersion}→${result.version}`;
+        return {
+            newStorageJson: createStorageJson(result.data, result.version),
+            info,
+            warn: result.warning,
+        };
+    }
+    // Register migrate callback
+    tryRegisterCallback('__pl_storage_migrate', (currentStorageJson) => {
+        return migrateStorage(currentStorageJson);
+    });
+    /**
+     * Derives args from storage using the registered 'args' callback.
+     * This extracts data from storage and passes it to the block's args() function.
+     *
+     * @param storageJson - Storage as JSON string
+     * @returns ArgsDeriveResult with derived args or error
+     */
+    function deriveArgsFromStorage(storageJson) {
+        const ctx = tryGetCfgRenderCtx();
+        if (ctx === undefined) {
+            return { error: 'Not in config rendering context' };
+        }
+        // Extract data from storage
+        const { data } = normalizeStorage(storageJson);
+        // Get the args callback (registered by BlockModelV3.args())
+        const argsCallback = ctx.callbackRegistry['args'];
+        if (typeof argsCallback !== 'function') {
+            return { error: 'args callback not found' };
+        }
+        // Call the args callback with extracted data
+        try {
+            const result = argsCallback(data);
+            return { value: result };
+        }
+        catch (e) {
+            const errorMsg = e instanceof Error ? e.message : String(e);
+            return { error: `args() threw: ${errorMsg}` };
+        }
+    }
+    // Register args derivation callback
+    tryRegisterCallback('__pl_args_derive', (storageJson) => {
+        return deriveArgsFromStorage(storageJson);
+    });
+    /**
+     * Derives prerunArgs from storage using the registered 'prerunArgs' callback.
+     * Falls back to 'args' callback if 'prerunArgs' is not defined.
+     *
+     * @param storageJson - Storage as JSON string
+     * @returns ArgsDeriveResult with derived prerunArgs or error
+     */
+    function derivePrerunArgsFromStorage(storageJson) {
+        const ctx = tryGetCfgRenderCtx();
+        if (ctx === undefined) {
+            return { error: 'Not in config rendering context' };
+        }
+        // Extract data from storage
+        const { data } = normalizeStorage(storageJson);
+        // Try prerunArgs callback first
+        const prerunArgsCallback = ctx.callbackRegistry['prerunArgs'];
+        if (typeof prerunArgsCallback === 'function') {
+            try {
+                const result = prerunArgsCallback(data);
+                return { value: result };
+            }
+            catch (e) {
+                const errorMsg = e instanceof Error ? e.message : String(e);
+                return { error: `prerunArgs() threw: ${errorMsg}` };
+            }
+        }
+        // Fall back to args callback
+        const argsCallback = ctx.callbackRegistry['args'];
+        if (typeof argsCallback !== 'function') {
+            return { error: 'args callback not found (fallback from missing prerunArgs)' };
+        }
+        try {
+            const result = argsCallback(data);
+            return { value: result };
+        }
+        catch (e) {
+            const errorMsg = e instanceof Error ? e.message : String(e);
+            return { error: `args() threw (fallback): ${errorMsg}` };
+        }
+    }
+    // Register prerunArgs derivation callback
+    tryRegisterCallback('__pl_prerunArgs_derive', (storageJson) => {
+        return derivePrerunArgsFromStorage(storageJson);
+    });
+
     function identity(x) {
         return x;
     }
 
+    function getAllRelatedColumns(ctx, predicate) {
+        // if current block doesn't produce own columns then use all columns from result pool
+        const columns = new PColumnCollection();
+        columns.addColumnProvider(ctx.resultPool);
+        const allColumns = columns.getUniversalEntries(predicate, { dontWaitAllData: true, overrideLabelAnnotation: false }) ?? [];
+        const allAxes = new Map(allColumns
+            .flatMap((column) => getNormalizedAxesList(column.spec.axesSpec))
+            .map((axisSpec) => {
+            const axisId = getAxisId(axisSpec);
+            return [canonicalizeJson(axisId), axisSpec];
+        }));
+        // additional columns are duplicates with extra fields in domains for compatibility if there are ones with partial match
+        const extendedColumns = enrichCompatible(allAxes, allColumns);
+        return extendedColumns;
+    }
+    function getRelatedColumns(ctx, { columns: rootColumns, predicate }) {
+        // if current block has its own columns then take from result pool only compatible with them
+        const columns = new PColumnCollection();
+        columns.addColumnProvider(ctx.resultPool);
+        columns.addColumns(rootColumns);
+        // all possible axes from block columns
+        const blockAxes = new Map();
+        // axes from block columns and compatible result pool columns
+        const allAxes = new Map();
+        for (const c of rootColumns) {
+            for (const spec of getNormalizedAxesList(c.spec.axesSpec)) {
+                const aid = getAxisId(spec);
+                blockAxes.set(canonicalizeJson(aid), spec);
+                allAxes.set(canonicalizeJson(aid), spec);
+            }
+        }
+        // all linker columns always go to pFrame - even it's impossible to use some of them they all are hidden
+        const linkerColumns = columns.getUniversalEntries((spec) => predicate(spec) && isLinkerColumn(spec)) ?? [];
+        const availableWithLinkersAxes = getAvailableWithLinkersAxes(linkerColumns, blockAxes);
+        // all possible axes from connected linkers
+        for (const item of availableWithLinkersAxes) {
+            blockAxes.set(...item);
+            allAxes.set(...item);
+        }
+        const blockAxesArr = Array.from(blockAxes.values());
+        // all compatible with block columns but without label columns
+        let compatibleWithoutLabels = (columns.getUniversalEntries((spec) => predicate(spec) && spec.axesSpec.some((axisSpec) => {
+            const axisId = getAxisId(axisSpec);
+            return blockAxesArr.some((selectorAxisSpec) => matchAxisId(getAxisId(selectorAxisSpec), axisId));
+        }), { dontWaitAllData: true, overrideLabelAnnotation: false }) ?? []).filter((column) => !isLabelColumn(column.spec));
+        // extend axes set for label columns request
+        for (const c of compatibleWithoutLabels) {
+            for (const spec of getNormalizedAxesList(c.spec.axesSpec)) {
+                const aid = getAxisId(spec);
+                allAxes.set(canonicalizeJson(aid), spec);
+            }
+        }
+        const allAxesArr = Array.from(allAxes.values());
+        // extend allowed columns - add columns thad doesn't have axes from block, but have all axes in 'allAxes' list (that means all axes from linkers or from 'hanging' of other selected columns)
+        compatibleWithoutLabels = (columns.getUniversalEntries((spec) => predicate(spec) && spec.axesSpec.every((axisSpec) => {
+            const axisId = getAxisId(axisSpec);
+            return allAxesArr.some((selectorAxisSpec) => matchAxisId(getAxisId(selectorAxisSpec), axisId));
+        }), { dontWaitAllData: true, overrideLabelAnnotation: false }) ?? []).filter((column) => !isLabelColumn(column.spec));
+        // label columns must be compatible with full set of axes - block axes and axes from compatible columns from result pool
+        const compatibleLabels = (columns.getUniversalEntries((spec) => predicate(spec) && spec.axesSpec.some((axisSpec) => {
+            const axisId = getAxisId(axisSpec);
+            return allAxesArr.some((selectorAxisSpec) => matchAxisId(getAxisId(selectorAxisSpec), axisId));
+        }), { dontWaitAllData: true, overrideLabelAnnotation: false }) ?? []).filter((column) => isLabelColumn(column.spec));
+        const compatible = [...compatibleWithoutLabels, ...compatibleLabels];
+        // additional columns are duplicates with extra fields in domains for compatibility if there are ones with partial match
+        const extendedColumns = enrichCompatible(blockAxes, compatible);
+        return extendedColumns;
+    }
+
+    /** Create id for column copy with added keys in axes domains */
+    const colId = (id, domains) => {
+        let wid = id.toString();
+        domains?.forEach((domain) => {
+            if (domain) {
+                for (const [k, v] of Object.entries(domain)) {
+                    wid += k;
+                    wid += v;
+                }
+            }
+        });
+        return wid;
+    };
+    /** All combinations with 1 key from each list */
+    function getKeysCombinations(idsLists) {
+        if (!idsLists.length) {
+            return [];
+        }
+        let result = [[]];
+        idsLists.forEach((list) => {
+            const nextResult = [];
+            list.forEach((key) => {
+                nextResult.push(...result.map((resultItem) => [...resultItem, key]));
+            });
+            result = nextResult;
+        });
+        return result;
+    }
+    function isHiddenFromGraphColumn(column) {
+        return !!readAnnotationJson(column, Annotation.HideDataFromGraphs);
+    }
+    function isHiddenFromUIColumn(column) {
+        return !!readAnnotationJson(column, Annotation.HideDataFromUi);
+    }
+    function getAvailableWithLinkersAxes(linkerColumns, blockAxes) {
+        const linkerMap = LinkerMap.fromColumns(linkerColumns.map(getColumnIdAndSpec));
+        const availableAxes = linkerMap.getReachableByLinkersAxesFromAxesNormalized([...blockAxes.values()], (linkerKeyId, sourceAxisId) => matchAxisId(sourceAxisId, linkerKeyId));
+        return new Map(availableAxes.map((axisSpec) => {
+            const id = getAxisId(axisSpec);
+            return [canonicalizeJson(id), axisSpec];
+        }));
+    }
+    /** Add columns with fully compatible axes created from partial compatible ones */
+    function enrichCompatible(blockAxes, columns) {
+        return columns.flatMap((column) => getAdditionalColumnsForColumn(blockAxes, column));
+    }
+    function getAdditionalColumnsForColumn(blockAxes, column) {
+        const columnAxesIds = column.spec.axesSpec.map(getAxisId);
+        if (columnAxesIds.every((id) => blockAxes.has(canonicalizeJson(id)))) {
+            return [column]; // the column is compatible with its own domains without modifications
+        }
+        // options with different possible domains for every axis of secondary column
+        const secondaryIdsOptions = columnAxesIds.map((id) => {
+            const result = [];
+            for (const [_, mainId] of blockAxes) {
+                if (matchAxisId(mainId, id) && !matchAxisId(id, mainId)) {
+                    result.push(mainId);
+                }
+            }
+            return result;
+        });
+        // all possible combinations of axes with added domains
+        const secondaryIdsVariants = getKeysCombinations(secondaryIdsOptions);
+        // sets of added to column domain fields
+        const allAddedDomainValues = new Set();
+        const addedNotToAllVariantsDomainValues = new Set();
+        const addedByVariantsDomainValues = secondaryIdsVariants.map((idsList) => {
+            const addedSet = new Set();
+            idsList.map((axisId, idx) => {
+                const d1 = column.spec.axesSpec[idx].domain;
+                const d2 = axisId.domain;
+                Object.entries(d2 ?? {}).forEach(([key, value]) => {
+                    if (d1?.[key] === undefined) {
+                        const item = JSON.stringify([key, value]);
+                        addedSet.add(item);
+                        allAddedDomainValues.add(item);
+                    }
+                });
+                return ({
+                    ...axisId,
+                    annotations: column.spec.axesSpec[idx].annotations,
+                });
+            });
+            return addedSet;
+        });
+        [...allAddedDomainValues].forEach((addedPart) => {
+            if (addedByVariantsDomainValues.some((s) => !s.has(addedPart))) {
+                addedNotToAllVariantsDomainValues.add(addedPart);
+            }
+        });
+        const additionalColumns = secondaryIdsVariants.map((idsList, idx) => {
+            const id = colId(column.id, idsList.map((id) => id.domain));
+            const label = readAnnotation(column.spec, Annotation.Label) ?? '';
+            const labelDomainPart = ([...addedByVariantsDomainValues[idx]])
+                .filter((str) => addedNotToAllVariantsDomainValues.has(str))
+                .sort()
+                .map((v) => JSON.parse(v)?.[1]) // use in labels only domain values, but sort them by key to save the same order in all column variants
+                .join(' / ');
+            const annotations = {
+                ...column.spec.annotations,
+                [Annotation.Graph.IsVirtual]: stringifyJson(true),
+            };
+            if (label || labelDomainPart) {
+                annotations[Annotation.Label] = label && labelDomainPart ? label + ' / ' + labelDomainPart : label + labelDomainPart;
+            }
+            return {
+                ...column,
+                id: id,
+                spec: {
+                    ...column.spec,
+                    axesSpec: idsList.map((axisId, idx) => ({
+                        ...axisId,
+                        annotations: column.spec.axesSpec[idx].annotations,
+                    })),
+                    annotations,
+                },
+            };
+        });
+        return [column, ...additionalColumns];
+    }
+    /**
+     The aim of createPFrameForGraphs: to create pframe with block’s columns and all compatible columns from result pool
+     (including linker columns and all label columns).
+     Block’s columns are added to pframe as is.
+     Other columns are added basing on set of axes of block’s columns, considering available with linker columns.
+     Compatible columns must have at least one axis from block’s axes set. This axis of the compatible column from
+     result pool must satisfy matchAxisId (it can have less domain keys than in block’s axis, but without conflicting values
+     among existing ones).
+     In requests to pframe (calculateTableData) columns must have strictly the same axes. For compatibility in case
+     of partially matched axis we add to pframe a copy of this column with modified axis (with filled missed domains)
+     and modified label (with added domain values in case if more than one copy with different domains exist).
+     */
+    function createPFrameForGraphs(ctx, blockColumns) {
+        const suitableSpec = (spec) => !isHiddenFromUIColumn(spec) && !isHiddenFromGraphColumn(spec);
+        // if current block doesn't produce own columns then use all columns from result pool
+        if (!blockColumns) {
+            return ctx.createPFrame(getAllRelatedColumns(ctx, suitableSpec));
+        }
+        return ctx.createPFrame(getRelatedColumns(ctx, { columns: blockColumns, predicate: suitableSpec }));
+    }
+
     function makeDefaultPTableParams() {
         return {
             sourceId: null,
@@ -7990,9 +8587,49 @@
         errors: z.lazy(() => ErrorShape.array()).optional(),
     });
 
+    function getDefaultBlockLabel(data) {
+        const parts = [];
+        // Add file name if available
+        if (data.fileName) {
+            parts.push(data.fileName);
+        }
+        // Add similarity type label
+        const similarityLabel = data.similarityType === 'alignment-score' ? 'BLOSUM' : 'Exact Match';
+        if (similarityLabel) {
+            parts.push(similarityLabel);
+        }
+        // Add identity threshold
+        parts.push(`ident:${data.identity}`);
+        // Add coverage threshold
+        parts.push(`cov:${data.coverageThreshold}`);
+        return parts.filter(Boolean).join(', ');
+    }
+
+    function getColumns(ctx) {
+        const anchor = ctx.args.datasetRef;
+        if (anchor === undefined)
+            return undefined;
+        const anchorSpec = ctx.resultPool.getPColumnSpecByRef(anchor);
+        if (anchorSpec === undefined)
+            return undefined;
+        // all clone properties
+        const props = (ctx.resultPool.getAnchoredPColumns({ main: anchor }, [
+            {
+                axes: [{ anchor: 'main', idx: 1 }],
+            },
+        ]) ?? [])
+            .filter((p) => p.spec.annotations?.['pl7.app/sequence/isAnnotation'] !== 'true');
+        return {
+            props: props,
+        };
+    }
     const model = BlockModel.create()
         .withArgs({
-        defaultBlockLabel: '',
+        defaultBlockLabel: getDefaultBlockLabel({
+            similarityType: 'alignment-score',
+            identity: 0.9,
+            coverageThreshold: 0.95,
+        }),
         customBlockLabel: '',
         settings: {
             coverageThreshold: 0.95, // default value matching MMseqs2 default
@@ -8003,6 +8640,7 @@
     })
         .withUiState({
         tableState: createPlDataTableStateV2(),
+        alignmentModel: {},
     })
         .argsValid((ctx) => ctx.args.datasetRef !== undefined
         && ctx.args.fileHandle !== undefined
@@ -8067,6 +8705,42 @@
         if (cols === undefined)
             return undefined;
         return createPlDataTableV2(ctx, cols, ctx.uiState.tableState);
+    })
+        .output('pf', (ctx) => {
+        if (ctx.outputs?.resolve('emptyResults')?.getDataAsJson()) {
+            return undefined;
+        }
+        const cols = ctx.outputs?.resolve('table')?.getPColumns();
+        if (cols === undefined)
+            return undefined;
+        return createPFrameForGraphs(ctx, cols);
+    })
+        .output('assaySequenceSpec', (ctx) => {
+        if (ctx.outputs?.resolve('emptyResults')?.getDataAsJson()) {
+            return undefined;
+        }
+        const cols = ctx.outputs?.resolve('table')?.getPColumns();
+        if (cols === undefined)
+            return undefined;
+        // Return only sequence column
+        return cols.find((c) => c.spec.name === 'pl7.app/vdj/sequence'
+            && c.spec.axesSpec[0].name === 'pl7.app/vdj/assay/sequenceId')?.spec;
+    })
+        .output('msaPf', (ctx) => {
+        if (ctx.outputs?.resolve('emptyResults')?.getDataAsJson()) {
+            return undefined;
+        }
+        const cols = ctx.outputs?.resolve('table')?.getPColumns();
+        if (cols === undefined)
+            return undefined;
+        const msaCols = ctx.outputs?.resolve('assayLinkerPframe')?.getPColumns();
+        if (!msaCols)
+            return undefined;
+        const columns = getColumns(ctx);
+        if (columns === undefined) {
+            return undefined;
+        }
+        return createPFrameForGraphs(ctx, [...msaCols, ...cols, ...columns.props]);
     })
         .output('isRunning', (ctx) => ctx.outputs?.getIsReadyOrError() === false)
         .title(() => 'Immune Assay Data')
@@ -8076,6 +8750,7 @@
     ]))
         .done(2);
 
+    exports.getDefaultBlockLabel = getDefaultBlockLabel;
     exports.model = model;
 
 }));