@milaboratories/milaboratories.ui-examples.model 1.4.9 → 1.4.11

package/dist/bundle.js

@@ -21,28 +21,28 @@
      * Discriminator key for BlockStorage format detection.
      * This unique hash-based key identifies data as BlockStorage vs legacy formats.
      */
-    const BLOCK_STORAGE_KEY = '__pl_a7f3e2b9__';
+    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';
+    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__';
+    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')
+        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
+        return schemaVersion === "v1"; // Add more versions as schema evolves
     }
     // =============================================================================
     // Factory Functions
@@ -75,7 +75,7 @@
             return {
                 ...storage,
                 // Fix for early released version where __dataVersion was a number
-                __dataVersion: typeof storage.__dataVersion === 'number'
+                __dataVersion: typeof storage.__dataVersion === "number"
                     ? DATA_MODEL_DEFAULT_VERSION
                     : storage.__dataVersion,
             };
@@ -104,7 +104,7 @@
      */
     function updateStorageData(storage, payload) {
         switch (payload.operation) {
-            case 'update-data':
+            case "update-data":
                 return { ...storage, __data: payload.value };
             default:
                 throw new Error(`Unknown storage operation: ${payload.operation}`);
@@ -118,33 +118,33 @@
     // Json
     //
     function getImmediate(value) {
-        return { type: 'Immediate', value };
+        return { type: "Immediate", value };
     }
 
     /** Utility code helping to identify whether the code is running in actual UI environment */
     function isInUI() {
-        return (typeof globalThis.getPlatforma !== 'undefined' || typeof globalThis.platforma !== 'undefined');
+        return (typeof globalThis.getPlatforma !== "undefined" || typeof globalThis.platforma !== "undefined");
     }
     /** Utility code helping to retrieve a platforma instance form the environment */
     function getPlatformaInstance(config) {
-        if (config && typeof globalThis.getPlatforma === 'function')
+        if (config && typeof globalThis.getPlatforma === "function")
             return globalThis.getPlatforma(config);
-        else if (typeof globalThis.platforma !== 'undefined')
+        else if (typeof globalThis.platforma !== "undefined")
             return globalThis.platforma;
         else
-            throw new Error('Can\'t get platforma instance.');
+            throw new Error("Can't get platforma instance.");
     }
     function tryGetCfgRenderCtx() {
-        if (typeof globalThis.cfgRenderCtx !== 'undefined')
+        if (typeof globalThis.cfgRenderCtx !== "undefined")
             return globalThis.cfgRenderCtx;
         else
             return undefined;
     }
     function getCfgRenderCtx() {
-        if (typeof globalThis.cfgRenderCtx !== 'undefined')
+        if (typeof globalThis.cfgRenderCtx !== "undefined")
             return globalThis.cfgRenderCtx;
         else
-            throw new Error('Not in config rendering context');
+            throw new Error("Not in config rendering context");
     }
     function tryRegisterCallback(key, callback) {
         const ctx = tryGetCfgRenderCtx();
@@ -4401,7 +4401,7 @@
     });
 
     z.object({
-        type: z.literal('plain'),
+        type: z.literal("plain"),
         content: z.string(),
     });
 
@@ -4414,7 +4414,7 @@
     });
 
     function assertNever(x) {
-        throw new Error('Unexpected object: ' + x); // This is ok, because this is a possible runtime error
+        throw new Error("Unexpected object: " + x); // This is ok, because this is a possible runtime error
     }
     /**
      * Return unique entries of the array by the provided id
@@ -4431,24 +4431,24 @@
      * @returns True if the value is a valid DataInfo, false otherwise
      */
     function isDataInfo(value) {
-        if (!value || typeof value !== 'object') {
+        if (!value || typeof value !== "object") {
             return false;
         }
         const data = value;
-        if (!('type' in data)) {
+        if (!("type" in data)) {
             return false;
         }
         switch (data.type) {
-            case 'Json':
-                return (typeof data.keyLength === 'number'
-                    && data.data !== undefined
-                    && typeof data.data === 'object');
-            case 'JsonPartitioned':
-            case 'BinaryPartitioned':
-            case 'ParquetPartitioned':
-                return (typeof data.partitionKeyLength === 'number'
-                    && data.parts !== undefined
-                    && typeof data.parts === 'object');
+            case "Json":
+                return (typeof data.keyLength === "number" &&
+                    data.data !== undefined &&
+                    typeof data.data === "object");
+            case "JsonPartitioned":
+            case "BinaryPartitioned":
+            case "ParquetPartitioned":
+                return (typeof data.partitionKeyLength === "number" &&
+                    data.parts !== undefined &&
+                    typeof data.parts === "object");
             default:
                 return false;
         }
@@ -4458,10 +4458,10 @@
             return undefined;
         }
         switch (dataInfo.type) {
-            case 'Json':
+            case "Json":
                 // Json type doesn't contain blobs, so return as is
                 return dataInfo;
-            case 'JsonPartitioned': {
+            case "JsonPartitioned": {
                 // Map each blob in parts
                 const newParts = {};
                 for (const [key, blob] of Object.entries(dataInfo.parts)) {
@@ -4472,7 +4472,7 @@
                     parts: newParts,
                 };
             }
-            case 'BinaryPartitioned': {
+            case "BinaryPartitioned": {
                 // Map each index and values blob in parts
                 const newParts = {};
                 for (const [key, chunk] of Object.entries(dataInfo.parts)) {
@@ -4486,7 +4486,7 @@
                     parts: newParts,
                 };
             }
-            case 'ParquetPartitioned': {
+            case "ParquetPartitioned": {
                 // Map each blob in parts
                 const newParts = {};
                 for (const [key, blob] of Object.entries(dataInfo.parts)) {
@@ -4506,15 +4506,15 @@
      */
     function visitDataInfo(dataInfo, cb) {
         switch (dataInfo.type) {
-            case 'Json':
+            case "Json":
                 // Json type doesn't contain blobs, so return as is
                 break;
-            case 'JsonPartitioned': {
+            case "JsonPartitioned": {
                 // Visit each blob in parts
                 Object.values(dataInfo.parts).forEach(cb);
                 break;
             }
-            case 'BinaryPartitioned': {
+            case "BinaryPartitioned": {
                 // Visit each index and values blob in parts
                 Object.values(dataInfo.parts).forEach((chunk) => {
                     cb(chunk.index);
@@ -4522,7 +4522,7 @@
                 });
                 break;
             }
-            case 'ParquetPartitioned': {
+            case "ParquetPartitioned": {
                 // Visit each blob in parts
                 Object.values(dataInfo.parts).forEach(cb);
                 break;
@@ -4536,22 +4536,20 @@
      * @returns True if the value is a valid DataInfoEntries, false otherwise
      */
     function isDataInfoEntries(value) {
-        if (!value || typeof value !== 'object') {
+        if (!value || typeof value !== "object") {
             return false;
         }
         const data = value;
-        if (!('type' in data)) {
+        if (!("type" in data)) {
             return false;
         }
         switch (data.type) {
-            case 'Json':
-                return (typeof data.keyLength === 'number'
-                    && Array.isArray(data.data));
-            case 'JsonPartitioned':
-            case 'BinaryPartitioned':
-            case 'ParquetPartitioned':
-                return (typeof data.partitionKeyLength === 'number'
-                    && Array.isArray(data.parts));
+            case "Json":
+                return typeof data.keyLength === "number" && Array.isArray(data.data);
+            case "JsonPartitioned":
+            case "BinaryPartitioned":
+            case "ParquetPartitioned":
+                return typeof data.partitionKeyLength === "number" && Array.isArray(data.parts);
             default:
                 return false;
         }
@@ -4567,9 +4565,9 @@
         if (!isDataInfoEntries(value))
             return false;
         switch (value.type) {
-            case 'JsonPartitioned':
-            case 'BinaryPartitioned':
-            case 'ParquetPartitioned':
+            case "JsonPartitioned":
+            case "BinaryPartitioned":
+            case "ParquetPartitioned":
                 return true;
             default:
                 return false;
@@ -4583,38 +4581,42 @@
      */
     function dataInfoToEntries(dataInfo) {
         switch (dataInfo.type) {
-            case 'Json': return {
-                type: 'Json',
-                keyLength: dataInfo.keyLength,
-                data: Object.entries(dataInfo.data).map(([keyStr, value]) => {
-                    const key = JSON.parse(keyStr);
-                    return { key, value };
-                }),
-            };
-            case 'JsonPartitioned': return {
-                type: 'JsonPartitioned',
-                partitionKeyLength: dataInfo.partitionKeyLength,
-                parts: Object.entries(dataInfo.parts).map(([keyStr, blob]) => {
-                    const key = JSON.parse(keyStr);
-                    return { key, value: blob };
-                }),
-            };
-            case 'BinaryPartitioned': return {
-                type: 'BinaryPartitioned',
-                partitionKeyLength: dataInfo.partitionKeyLength,
-                parts: Object.entries(dataInfo.parts).map(([keyStr, chunk]) => {
-                    const key = JSON.parse(keyStr);
-                    return { key, value: chunk };
-                }),
-            };
-            case 'ParquetPartitioned': return {
-                type: 'ParquetPartitioned',
-                partitionKeyLength: dataInfo.partitionKeyLength,
-                parts: Object.entries(dataInfo.parts).map(([keyStr, blob]) => {
-                    const key = JSON.parse(keyStr);
-                    return { key, value: blob };
-                }),
-            };
+            case "Json":
+                return {
+                    type: "Json",
+                    keyLength: dataInfo.keyLength,
+                    data: Object.entries(dataInfo.data).map(([keyStr, value]) => {
+                        const key = JSON.parse(keyStr);
+                        return { key, value };
+                    }),
+                };
+            case "JsonPartitioned":
+                return {
+                    type: "JsonPartitioned",
+                    partitionKeyLength: dataInfo.partitionKeyLength,
+                    parts: Object.entries(dataInfo.parts).map(([keyStr, blob]) => {
+                        const key = JSON.parse(keyStr);
+                        return { key, value: blob };
+                    }),
+                };
+            case "BinaryPartitioned":
+                return {
+                    type: "BinaryPartitioned",
+                    partitionKeyLength: dataInfo.partitionKeyLength,
+                    parts: Object.entries(dataInfo.parts).map(([keyStr, chunk]) => {
+                        const key = JSON.parse(keyStr);
+                        return { key, value: chunk };
+                    }),
+                };
+            case "ParquetPartitioned":
+                return {
+                    type: "ParquetPartitioned",
+                    partitionKeyLength: dataInfo.partitionKeyLength,
+                    parts: Object.entries(dataInfo.parts).map(([keyStr, blob]) => {
+                        const key = JSON.parse(keyStr);
+                        return { key, value: blob };
+                    }),
+                };
             default:
                 assertNever(dataInfo);
         }
@@ -4627,26 +4629,30 @@
      */
     function entriesToDataInfo(dataInfoEntries) {
         switch (dataInfoEntries.type) {
-            case 'Json': return {
-                type: 'Json',
-                keyLength: dataInfoEntries.keyLength,
-                data: Object.fromEntries(dataInfoEntries.data.map(({ key, value }) => [JSON.stringify(key), value])),
-            };
-            case 'JsonPartitioned': return {
-                type: 'JsonPartitioned',
-                partitionKeyLength: dataInfoEntries.partitionKeyLength,
-                parts: Object.fromEntries(dataInfoEntries.parts.map(({ key, value }) => [JSON.stringify(key), value])),
-            };
-            case 'BinaryPartitioned': return {
-                type: 'BinaryPartitioned',
-                partitionKeyLength: dataInfoEntries.partitionKeyLength,
-                parts: Object.fromEntries(dataInfoEntries.parts.map(({ key, value }) => [JSON.stringify(key), value])),
-            };
-            case 'ParquetPartitioned': return {
-                type: 'ParquetPartitioned',
-                partitionKeyLength: dataInfoEntries.partitionKeyLength,
-                parts: Object.fromEntries(dataInfoEntries.parts.map(({ key, value }) => [JSON.stringify(key), value])),
-            };
+            case "Json":
+                return {
+                    type: "Json",
+                    keyLength: dataInfoEntries.keyLength,
+                    data: Object.fromEntries(dataInfoEntries.data.map(({ key, value }) => [JSON.stringify(key), value])),
+                };
+            case "JsonPartitioned":
+                return {
+                    type: "JsonPartitioned",
+                    partitionKeyLength: dataInfoEntries.partitionKeyLength,
+                    parts: Object.fromEntries(dataInfoEntries.parts.map(({ key, value }) => [JSON.stringify(key), value])),
+                };
+            case "BinaryPartitioned":
+                return {
+                    type: "BinaryPartitioned",
+                    partitionKeyLength: dataInfoEntries.partitionKeyLength,
+                    parts: Object.fromEntries(dataInfoEntries.parts.map(({ key, value }) => [JSON.stringify(key), value])),
+                };
+            case "ParquetPartitioned":
+                return {
+                    type: "ParquetPartitioned",
+                    partitionKeyLength: dataInfoEntries.partitionKeyLength,
+                    parts: Object.fromEntries(dataInfoEntries.parts.map(({ key, value }) => [JSON.stringify(key), value])),
+                };
             default:
                 assertNever(dataInfoEntries);
         }
@@ -4656,10 +4662,10 @@
      * Just for convenience, usually it is an Error with name 'AbortError'
      */
     function stringifyValue(value) {
-        if (typeof value === 'string') {
+        if (typeof value === "string") {
             return `String value was thrown: ${value}`;
         }
-        if (value && typeof value === 'object') {
+        if (value && typeof value === "object") {
             try {
                 return `Plain object was thrown: ${JSON.stringify(value)}`;
             }
@@ -4743,13 +4749,13 @@
     }
 
     const ValueType = {
-        Int: 'Int',
-        Float: 'Float',
-        String: 'String'};
+        Int: "Int",
+        Float: "Float",
+        String: "String"};
     function readMetadata(metadata, key) {
         return metadata?.[key];
     }
-    function readMetadataJsonOrThrow(metadata, metadataJson, key, methodNameInError = 'readMetadataJsonOrThrow') {
+    function readMetadataJsonOrThrow(metadata, metadataJson, key, methodNameInError = "readMetadataJsonOrThrow") {
         const json = readMetadata(metadata, key);
         if (json === undefined)
             return undefined;
@@ -4759,10 +4765,10 @@
             return schema.parse(value);
         }
         catch (error) {
-            throw new Error(`${methodNameInError} failed, `
-                + `key: ${String(key)}, `
-                + `value: ${json}, `
-                + `error: ${ensureError(error)}`);
+            throw new Error(`${methodNameInError} failed, ` +
+                `key: ${String(key)}, ` +
+                `value: ${json}, ` +
+                `error: ${ensureError(error)}`);
         }
     }
     function readMetadataJson(metadata, metadataJson, key) {
@@ -4775,47 +4781,47 @@
     }
     /// Well-known annotations
     const Annotation = {
-        Description: 'pl7.app/description',
-        DiscreteValues: 'pl7.app/discreteValues',
+        Description: "pl7.app/description",
+        DiscreteValues: "pl7.app/discreteValues",
         Graph: {
             Axis: {
-                HighCardinality: 'pl7.app/graph/axis/highCardinality',
-                LowerLimit: 'pl7.app/graph/axis/lowerLimit',
-                SymmetricRange: 'pl7.app/graph/axis/symmetricRange',
-                UpperLimit: 'pl7.app/graph/axis/upperLimit',
+                HighCardinality: "pl7.app/graph/axis/highCardinality",
+                LowerLimit: "pl7.app/graph/axis/lowerLimit",
+                SymmetricRange: "pl7.app/graph/axis/symmetricRange",
+                UpperLimit: "pl7.app/graph/axis/upperLimit",
             },
-            IsDenseAxis: 'pl7.app/graph/isDenseAxis',
-            IsVirtual: 'pl7.app/graph/isVirtual',
-            Palette: 'pl7.app/graph/palette',
-            Thresholds: 'pl7.app/graph/thresholds',
-            TreatAbsentValuesAs: 'pl7.app/graph/treatAbsentValuesAs',
+            IsDenseAxis: "pl7.app/graph/isDenseAxis",
+            IsVirtual: "pl7.app/graph/isVirtual",
+            Palette: "pl7.app/graph/palette",
+            Thresholds: "pl7.app/graph/thresholds",
+            TreatAbsentValuesAs: "pl7.app/graph/treatAbsentValuesAs",
         },
-        HideDataFromUi: 'pl7.app/hideDataFromUi',
-        HideDataFromGraphs: 'pl7.app/hideDataFromGraphs',
-        IsDiscreteFilter: 'pl7.app/isDiscreteFilter',
-        IsLinkerColumn: 'pl7.app/isLinkerColumn',
-        IsSubset: 'pl7.app/isSubset',
-        Label: 'pl7.app/label',
-        Max: 'pl7.app/max',
-        Min: 'pl7.app/min',
-        MultipliesBy: 'pl7.app/multipliesBy',
-        Parents: 'pl7.app/parents',
+        HideDataFromUi: "pl7.app/hideDataFromUi",
+        HideDataFromGraphs: "pl7.app/hideDataFromGraphs",
+        IsDiscreteFilter: "pl7.app/isDiscreteFilter",
+        IsLinkerColumn: "pl7.app/isLinkerColumn",
+        IsSubset: "pl7.app/isSubset",
+        Label: "pl7.app/label",
+        Max: "pl7.app/max",
+        Min: "pl7.app/min",
+        MultipliesBy: "pl7.app/multipliesBy",
+        Parents: "pl7.app/parents",
         Sequence: {
             Annotation: {
-                Mapping: 'pl7.app/sequence/annotation/mapping',
+                Mapping: "pl7.app/sequence/annotation/mapping",
             },
-            IsAnnotation: 'pl7.app/sequence/isAnnotation',
+            IsAnnotation: "pl7.app/sequence/isAnnotation",
         },
         Table: {
-            OrderPriority: 'pl7.app/table/orderPriority',
-            Visibility: 'pl7.app/table/visibility',
+            OrderPriority: "pl7.app/table/orderPriority",
+            Visibility: "pl7.app/table/visibility",
         },
-        Trace: 'pl7.app/trace',
+        Trace: "pl7.app/trace",
         VDJ: {
-            IsAssemblingFeature: 'pl7.app/vdj/isAssemblingFeature',
+            IsAssemblingFeature: "pl7.app/vdj/isAssemblingFeature",
         },
     };
-    const ValueTypeSchema = z.enum(['Int', 'Long', 'Float', 'Double', 'String']);
+    const ValueTypeSchema = z.enum(["Int", "Long", "Float", "Double", "String"]);
     const AnnotationJson = {
         [Annotation.DiscreteValues]: z.array(z.string()).or(z.array(z.number())),
         [Annotation.Graph.Axis.HighCardinality]: z.boolean(),
@@ -4963,16 +4969,21 @@
         });
         axes.forEach((axis, idx) => {
             const modifiedAxis = modifiedAxes[idx];
-            if (axis.parentAxes) { // if we have parents by indexes then take from the list
+            if (axis.parentAxes) {
+                // if we have parents by indexes then take from the list
                 modifiedAxis.parentAxesSpec = axis.parentAxes.map((idx) => modifiedAxes[idx]);
             }
-            else { // else try to parse from annotation name
+            else {
+                // else try to parse from annotation name
                 const parents = parseParentsFromAnnotations(axis).map((name) => modifiedAxes.find((axis) => axis.name === name));
-                modifiedAxis.parentAxesSpec = parents.some((p) => p === undefined) ? [] : parents;
+                modifiedAxis.parentAxesSpec = parents.some((p) => p === undefined)
+                    ? []
+                    : parents;
                 delete modifiedAxis.annotations?.[Annotation.Parents];
             }
         });
-        if (modifiedAxes.some(hasCycleOfParents)) { // Axes list is broken
+        if (modifiedAxes.some(hasCycleOfParents)) {
+            // Axes list is broken
             modifiedAxes.forEach((axis) => {
                 axis.parentAxesSpec = [];
             });
@@ -4986,7 +4997,7 @@
     }
     /// Well-known column names
     const PColumnName = {
-        Label: 'pl7.app/label'};
+        Label: "pl7.app/label"};
     function isLabelColumn(column) {
         return column.axesSpec.length === 1 && column.name === PColumnName.Label;
     }
@@ -5036,36 +5047,36 @@
     }
     function mapJoinEntry(entry, cb) {
         switch (entry.type) {
-            case 'column':
+            case "column":
                 return {
-                    type: 'column',
+                    type: "column",
                     column: cb(entry.column),
                 };
-            case 'slicedColumn':
+            case "slicedColumn":
                 return {
-                    type: 'slicedColumn',
+                    type: "slicedColumn",
                     column: cb(entry.column),
                     newId: entry.newId,
                     axisFilters: entry.axisFilters,
                 };
-            case 'artificialColumn':
+            case "artificialColumn":
                 return {
-                    type: 'artificialColumn',
+                    type: "artificialColumn",
                     column: cb(entry.column),
                     newId: entry.newId,
                     axesIndices: entry.axesIndices,
                 };
-            case 'inlineColumn':
+            case "inlineColumn":
                 return entry;
-            case 'inner':
-            case 'full':
+            case "inner":
+            case "full":
                 return {
                     type: entry.type,
                     entries: entry.entries.map((col) => mapJoinEntry(col, cb)),
                 };
-            case 'outer':
+            case "outer":
                 return {
-                    type: 'outer',
+                    type: "outer",
                     primary: mapJoinEntry(entry.primary, cb),
                     secondary: entry.secondary.map((col) => mapJoinEntry(col, cb)),
                 };
@@ -5187,7 +5198,7 @@
             for (const filter of axisFilters) {
                 const [axisIdOrIndex, value] = filter;
                 // If it's already a numeric index, validate it
-                if (typeof axisIdOrIndex === 'number') {
+                if (typeof axisIdOrIndex === "number") {
                     if (axisIdOrIndex < 0 || axisIdOrIndex >= spec.axesSpec.length) {
                         throw new Error(`Axis index ${axisIdOrIndex} is out of bounds (0-${spec.axesSpec.length - 1})`);
                     }
@@ -5242,7 +5253,7 @@
         if (result.domain) {
             const resolvedDomain = {};
             for (const [key, value] of Object.entries(result.domain)) {
-                if (typeof value === 'string') {
+                if (typeof value === "string") {
                     resolvedDomain[key] = value;
                 }
                 else {
@@ -5275,13 +5286,13 @@
         const anchorSpec = anchors[anchorId];
         if (!anchorSpec)
             throw new Error(`Anchor "${anchorId}" not found for axis reference`);
-        if ('idx' in axisRef) {
+        if ("idx" in axisRef) {
             // AnchorAxisRefByIdx
             if (axisRef.idx < 0 || axisRef.idx >= anchorSpec.axesSpec.length)
                 throw new Error(`Axis index ${axisRef.idx} out of bounds for anchor "${anchorId}"`);
             return anchorSpec.axesSpec[axisRef.idx];
         }
-        else if ('name' in axisRef) {
+        else if ("name" in axisRef) {
             // AnchorAxisRefByName
             const matches = anchorSpec.axesSpec.filter((axis) => axis.name === axisRef.name);
             if (matches.length > 1)
@@ -5290,7 +5301,7 @@
                 throw new Error(`Axis with name "${axisRef.name}" not found in anchor "${anchorId}"`);
             return matches[0];
         }
-        else if ('id' in axisRef) {
+        else if ("id" in axisRef) {
             // AnchorAxisRefByMatcher
             const matches = anchorSpec.axesSpec.filter((axis) => matchAxisId(axisRef.id, getAxisId(axis)));
             if (matches.length > 1)
@@ -5305,11 +5316,11 @@
      * Type guard to check if a value is an anchored axis reference
      */
     function isAnchorAxisRef(value) {
-        return typeof value === 'object' && 'anchor' in value;
+        return typeof value === "object" && "anchor" in value;
     }
 
     function isPColumnSpec(spec) {
-        return spec.kind === 'PColumn';
+        return spec.kind === "PColumn";
     }
     function isPColumn(obj) {
         return isPColumnSpec(obj.spec);
@@ -5324,30 +5335,30 @@
             ? undefined
             : {
                 ...pObj,
-                data: cb(typeof pObj.data === 'function' ? pObj.data() : pObj.data),
+                data: cb(typeof pObj.data === "function" ? pObj.data() : pObj.data),
             };
     }
     function extractAllColumns(entry) {
         const columns = new Map();
         const addAllColumns = (entry) => {
             switch (entry.type) {
-                case 'column':
+                case "column":
                     columns.set(entry.column.id, entry.column);
                     return;
-                case 'slicedColumn':
+                case "slicedColumn":
                     columns.set(entry.column.id, entry.column);
                     return;
-                case 'artificialColumn':
+                case "artificialColumn":
                     columns.set(entry.column.id, entry.column);
                     return;
-                case 'inlineColumn':
+                case "inlineColumn":
                     return;
-                case 'full':
-                case 'inner':
+                case "full":
+                case "inner":
                     for (const e of entry.entries)
                         addAllColumns(e);
                     return;
-                case 'outer':
+                case "outer":
                     addAllColumns(entry.primary);
                     for (const e of entry.secondary)
                         addAllColumns(e);
@@ -5604,7 +5615,9 @@
                 .flatMap((targetKey) => {
                 const linkers = startKeys
                     .map((startKey) => this.searchLinkerPath(startKey, targetKey))
-                    .reduce((shortestPath, path) => (shortestPath.length && shortestPath.length < path.length) || !path.length ? shortestPath : path, [])
+                    .reduce((shortestPath, path) => (shortestPath.length && shortestPath.length < path.length) || !path.length
+                    ? shortestPath
+                    : path, [])
                     .map((linker) => [linker.columnId, linker]);
                 if (!linkers.length && throwWhenNoLinkExists) {
                     throw Error(`Unable to find linker column for ${targetKey}`);
@@ -5614,7 +5627,8 @@
         }
         /** Get list of axisSpecs from keys of linker columns map  */
         getAxesListFromKeysList(keys) {
-            return Array.from(new Map(keys.flatMap((key) => this.data.get(key)?.keyAxesSpec ?? [])
+            return Array.from(new Map(keys
+                .flatMap((key) => this.data.get(key)?.keyAxesSpec ?? [])
                 .map((axis) => [canonicalizeJson(getAxisId(axis)), axis])).values());
         }
         /** Get axes of target axes that are impossible to be linked to source axes with current linker map */
@@ -5627,7 +5641,10 @@
                 const targetKey = targetKeys[idx];
                 return !startKeys.some((startKey) => this.searchLinkerPath(startKey, targetKey).length);
             })
-                .flatMap((axis) => getArrayFromAxisTree(getAxesTree(axis)).map((axis) => [canonicalizeJson(getAxisId(axis)), axis]))).values());
+                .flatMap((axis) => getArrayFromAxisTree(getAxesTree(axis)).map((axis) => [
+                canonicalizeJson(getAxisId(axis)),
+                axis,
+            ]))).values());
             return axes;
         }
         /** Get all axes that can be connected to sourceAxes by linkers */
@@ -5658,8 +5675,10 @@
            There are no order inside every group. */
         static getAxesGroups(axesSpec) {
             switch (axesSpec.length) {
-                case 0: return [];
-                case 1: return [[axesSpec[0]]];
+                case 0:
+                    return [];
+                case 1:
+                    return [[axesSpec[0]]];
             }
             const axisKeys = axesSpec.map((spec) => canonicalizeJson(getAxisId(spec)));
             const axisParentsIdxs = axesSpec.map((spec) => new Set(spec.parentAxesSpec
@@ -5715,24 +5734,24 @@
         .string()
         .length(PlIdLength)
         .regex(/[ABCDEFGHIJKLMNOPQRSTUVWXYZ234567]/) // RFC4648
-        .brand('PlId');
+        .brand("PlId");
 
     z
         .object({
         __isRef: z
             .literal(true)
-            .describe('Crucial marker for the block dependency tree reconstruction'),
-        blockId: z.string()
-            .describe('Upstream block id'),
-        name: z.string()
-            .describe('Name of the output provided to the upstream block\'s output context'),
-        requireEnrichments: z.literal(true).optional()
-            .describe('True if current block that stores this reference in its args, may need enrichments '
-            + 'for the references value originating from the blocks in between current and referenced block'),
+            .describe("Crucial marker for the block dependency tree reconstruction"),
+        blockId: z.string().describe("Upstream block id"),
+        name: z.string().describe("Name of the output provided to the upstream block's output context"),
+        requireEnrichments: z
+            .literal(true)
+            .optional()
+            .describe("True if current block that stores this reference in its args, may need enrichments " +
+            "for the references value originating from the blocks in between current and referenced block"),
     })
-        .describe('Universal reference type, allowing to set block connections. It is crucial that '
-        + '{@link __isRef} is present and equal to true, internal logic relies on this marker '
-        + 'to build block dependency trees.')
+        .describe("Universal reference type, allowing to set block connections. It is crucial that " +
+        "{@link __isRef} is present and equal to true, internal logic relies on this marker " +
+        "to build block dependency trees.")
         .readonly();
     /**
      * Type guard to check if a value is a PlRef.
@@ -5741,12 +5760,12 @@
      * @returns True if the value is a PlRef, false otherwise.
      */
     function isPlRef(value) {
-        return (typeof value === 'object'
-            && value !== null
-            && '__isRef' in value
-            && value.__isRef === true
-            && 'blockId' in value
-            && 'name' in value);
+        return (typeof value === "object" &&
+            value !== null &&
+            "__isRef" in value &&
+            value.__isRef === true &&
+            "blockId" in value &&
+            "name" in value);
     }
     /**
      * Creates a new PlRef based on an existing one, explicitly setting (default) or removing the
@@ -5815,22 +5834,22 @@
         }
         resolve(...steps) {
             const transformedSteps = steps.map((s) => ({
-                assertFieldType: 'Input',
-                ...(typeof s === 'string' ? { field: s } : s),
+                assertFieldType: "Input",
+                ...(typeof s === "string" ? { field: s } : s),
             }));
             return this.resolveWithCommon({}, ...transformedSteps);
         }
         resolveOutput(...steps) {
             const transformedSteps = steps.map((s) => ({
-                assertFieldType: 'Output',
-                ...(typeof s === 'string' ? { field: s } : s),
+                assertFieldType: "Output",
+                ...(typeof s === "string" ? { field: s } : s),
             }));
             return this.resolveWithCommon({}, ...transformedSteps);
         }
         resolveInput(...steps) {
             const transformedSteps = steps.map((s) => ({
-                assertFieldType: 'Input',
-                ...(typeof s === 'string' ? { field: s } : s),
+                assertFieldType: "Input",
+                ...(typeof s === "string" ? { field: s } : s),
             }));
             return this.resolveWithCommon({}, ...transformedSteps);
         }
@@ -5840,7 +5859,7 @@
         resolveWithCommon(commonOptions, ...steps) {
             const resolvePath = [
                 ...this.resolvePath,
-                ...steps.map((step) => typeof step === 'string' ? step : step.field),
+                ...steps.map((step) => (typeof step === "string" ? step : step.field)),
             ];
             return ifDef(getCfgRenderCtx().resolveWithCommon(this.handle, commonOptions, ...steps), (accessor) => new TreeNodeAccessor(accessor, resolvePath));
         }
@@ -5860,7 +5879,7 @@
             return getCfgRenderCtx().getIsFinal(this.handle);
         }
         getError() {
-            const resolvePath = [...this.resolvePath, 'error'];
+            const resolvePath = [...this.resolvePath, "error"];
             return ifDef(getCfgRenderCtx().getError(this.handle), (accsessor) => new TreeNodeAccessor(accsessor, resolvePath));
         }
         listInputFields() {
@@ -5881,7 +5900,7 @@
         getKeyValueAsJson(key) {
             const content = this.getKeyValueAsString(key);
             if (content == undefined)
-                throw new Error('Resource has no content.');
+                throw new Error("Resource has no content.");
             return JSON.parse(content);
         }
         getDataBase64() {
@@ -5893,13 +5912,13 @@
         getDataAsJson() {
             const content = this.getDataAsString();
             if (content == undefined)
-                throw new Error('Resource has no content.');
+                throw new Error("Resource has no content.");
             return JSON.parse(content);
         }
         /**
          *
          */
-        getPColumns(errorOnUnknownField = false, prefix = '') {
+        getPColumns(errorOnUnknownField = false, prefix = "") {
             const result = this.parsePObjectCollection(errorOnUnknownField, prefix);
             if (result === undefined)
                 return undefined;
@@ -5913,7 +5932,7 @@
         /**
          *
          */
-        parsePObjectCollection(errorOnUnknownField = false, prefix = '') {
+        parsePObjectCollection(errorOnUnknownField = false, prefix = "") {
             const pObjects = getCfgRenderCtx().parsePObjectCollection(this.handle, errorOnUnknownField, prefix, ...this.resolvePath);
             if (pObjects === undefined)
                 return undefined;
@@ -5990,33 +6009,33 @@
         getLogHandle() {
             return new FutureRef(getCfgRenderCtx().getLogHandle(this.handle));
         }
-        allFieldsResolved(fieldType = 'Input') {
+        allFieldsResolved(fieldType = "Input") {
             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));
+                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));
             }
         }
         mapFields(_mapping, _ops) {
             const { fieldType, requireLocked, skipUnresolved } = {
-                fieldType: 'Input',
+                fieldType: "Input",
                 requireLocked: true,
                 skipUnresolved: false,
                 ..._ops,
             };
             const mapping = _mapping;
             if (requireLocked) {
-                if (fieldType === 'Input' && !this.getInputsLocked())
+                if (fieldType === "Input" && !this.getInputsLocked())
                     return undefined;
-                if (fieldType === 'Output' && !this.getOutputsLocked())
+                if (fieldType === "Output" && !this.getOutputsLocked())
                     return undefined;
             }
-            const fieldList = fieldType === 'Input'
+            const fieldList = fieldType === "Input"
                 ? this.listInputFields()
-                : fieldType === 'Output'
+                : fieldType === "Output"
                     ? this.listOutputFields()
                     : this.listDynamicFields();
             let fieldEntries = fieldList.map((field) => [field, this.resolve({ field, assertFieldType: fieldType })]);
@@ -6026,8 +6045,8 @@
         }
     }
 
-    const StagingAccessorName = 'staging';
-    const MainAccessorName = 'main';
+    const StagingAccessorName = "staging";
+    const MainAccessorName = "main";
 
     function filterDataInfoEntries(dataInfoEntries, axisFilters) {
         // Sort filters by axis index in descending order to safely remove elements from arrays
@@ -6035,16 +6054,16 @@
         // Check for invalid filter axes
         const { type } = dataInfoEntries;
         switch (type) {
-            case 'Json': {
+            case "Json": {
                 const { keyLength } = dataInfoEntries;
                 for (const [axisIdx] of axisFilters)
                     if (axisIdx >= keyLength)
                         throw new Error(`Can't filter on non-data axis ${axisIdx}. Must be >= ${keyLength}`);
                 break;
             }
-            case 'JsonPartitioned':
-            case 'BinaryPartitioned':
-            case 'ParquetPartitioned': {
+            case "JsonPartitioned":
+            case "BinaryPartitioned":
+            case "ParquetPartitioned": {
                 const { partitionKeyLength } = dataInfoEntries;
                 for (const [axisIdx] of axisFilters)
                     if (axisIdx >= partitionKeyLength)
@@ -6069,46 +6088,50 @@
             return newKey;
         };
         switch (dataInfoEntries.type) {
-            case 'Json': return {
-                type: 'Json',
-                keyLength: dataInfoEntries.keyLength - axisFilters.length,
-                data: dataInfoEntries.data
-                    .filter((entry) => keyMatchesFilters(entry.key))
-                    .map((entry) => ({
-                    key: removeFilteredAxes(entry.key),
-                    value: entry.value,
-                })),
-            };
-            case 'JsonPartitioned': return {
-                type: 'JsonPartitioned',
-                partitionKeyLength: dataInfoEntries.partitionKeyLength - axisFilters.length,
-                parts: dataInfoEntries.parts
-                    .filter((entry) => keyMatchesFilters(entry.key))
-                    .map((entry) => ({
-                    key: removeFilteredAxes(entry.key),
-                    value: entry.value,
-                })),
-            };
-            case 'BinaryPartitioned': return {
-                type: 'BinaryPartitioned',
-                partitionKeyLength: dataInfoEntries.partitionKeyLength - axisFilters.length,
-                parts: dataInfoEntries.parts
-                    .filter((entry) => keyMatchesFilters(entry.key))
-                    .map((entry) => ({
-                    key: removeFilteredAxes(entry.key),
-                    value: entry.value,
-                })),
-            };
-            case 'ParquetPartitioned': return {
-                type: 'ParquetPartitioned',
-                partitionKeyLength: dataInfoEntries.partitionKeyLength - axisFilters.length,
-                parts: dataInfoEntries.parts
-                    .filter((entry) => keyMatchesFilters(entry.key))
-                    .map((entry) => ({
-                    key: removeFilteredAxes(entry.key),
-                    value: entry.value,
-                })),
-            };
+            case "Json":
+                return {
+                    type: "Json",
+                    keyLength: dataInfoEntries.keyLength - axisFilters.length,
+                    data: dataInfoEntries.data
+                        .filter((entry) => keyMatchesFilters(entry.key))
+                        .map((entry) => ({
+                        key: removeFilteredAxes(entry.key),
+                        value: entry.value,
+                    })),
+                };
+            case "JsonPartitioned":
+                return {
+                    type: "JsonPartitioned",
+                    partitionKeyLength: dataInfoEntries.partitionKeyLength - axisFilters.length,
+                    parts: dataInfoEntries.parts
+                        .filter((entry) => keyMatchesFilters(entry.key))
+                        .map((entry) => ({
+                        key: removeFilteredAxes(entry.key),
+                        value: entry.value,
+                    })),
+                };
+            case "BinaryPartitioned":
+                return {
+                    type: "BinaryPartitioned",
+                    partitionKeyLength: dataInfoEntries.partitionKeyLength - axisFilters.length,
+                    parts: dataInfoEntries.parts
+                        .filter((entry) => keyMatchesFilters(entry.key))
+                        .map((entry) => ({
+                        key: removeFilteredAxes(entry.key),
+                        value: entry.value,
+                    })),
+                };
+            case "ParquetPartitioned":
+                return {
+                    type: "ParquetPartitioned",
+                    partitionKeyLength: dataInfoEntries.partitionKeyLength - axisFilters.length,
+                    parts: dataInfoEntries.parts
+                        .filter((entry) => keyMatchesFilters(entry.key))
+                        .map((entry) => ({
+                        key: removeFilteredAxes(entry.key),
+                        value: entry.value,
+                    })),
+                };
         }
     }
 
@@ -6120,11 +6143,11 @@
     });
     const Trace = z.array(TraceEntry);
     const DistancePenalty = 0.001;
-    const LabelType = '__LABEL__';
-    const LabelTypeFull = '__LABEL__@1';
+    const LabelType = "__LABEL__";
+    const LabelTypeFull = "__LABEL__@1";
     function deriveLabels(values, specExtractor, ops = {}) {
         const importances = new Map();
-        const forceTraceElements = (ops.forceTraceElements !== undefined && ops.forceTraceElements.length > 0)
+        const forceTraceElements = ops.forceTraceElements !== undefined && ops.forceTraceElements.length > 0
             ? new Set(ops.forceTraceElements)
             : undefined;
         // number of times certain type occurred among all of the
@@ -6135,7 +6158,7 @@
             let prefixTrace;
             let suffixTrace;
             // Check if the result is the new structure or just PObjectSpec
-            if ('spec' in extractorResult && typeof extractorResult.spec === 'object') {
+            if ("spec" in extractorResult && typeof extractorResult.spec === "object") {
                 // It's the new structure { spec, prefixTrace?, suffixTrace? }
                 spec = extractorResult.spec;
                 prefixTrace = extractorResult.prefixTrace;
@@ -6148,11 +6171,7 @@
             const label = readAnnotation(spec, Annotation.Label);
             const traceStr = readAnnotation(spec, Annotation.Trace);
             const baseTrace = (traceStr ? Trace.safeParse(parseJson(traceStr)).data : undefined) ?? [];
-            const trace = [
-                ...(prefixTrace ?? []),
-                ...baseTrace,
-                ...(suffixTrace ?? []),
-            ];
+            const trace = [...(prefixTrace ?? []), ...baseTrace, ...(suffixTrace ?? [])];
             if (label !== undefined) {
                 const labelEntry = { label, type: LabelType, importance: -2 };
                 if (ops.addLabelAsSuffix)
@@ -6188,7 +6207,7 @@
         // sorting: most important types go first
         allTypeRecords.sort(([, i1], [, i2]) => i2 - i1);
         for (const [typeName] of allTypeRecords) {
-            if (typeName.endsWith('@1') || numberOfRecordsWithType.get(typeName) === values.length)
+            if (typeName.endsWith("@1") || numberOfRecordsWithType.get(typeName) === values.length)
                 mainTypes.push(typeName);
             else
                 secondaryTypes.push(typeName);
@@ -6197,21 +6216,18 @@
             const result = [];
             for (let i = 0; i < enrichedRecords.length; i++) {
                 const r = enrichedRecords[i];
-                const includedTrace = r.fullTrace
-                    .filter((fm) => includedTypes.has(fm.fullType)
-                    || (forceTraceElements && forceTraceElements.has(fm.type)));
+                const includedTrace = r.fullTrace.filter((fm) => includedTypes.has(fm.fullType) || (forceTraceElements && forceTraceElements.has(fm.type)));
                 if (includedTrace.length === 0) {
                     if (force)
                         result.push({
-                            label: 'Unlabeled',
+                            label: "Unlabeled",
                             value: r.value,
                         });
                     else
                         return undefined;
                 }
-                const labelSet = includedTrace
-                    .map((fm) => fm.label);
-                const sep = ops.separator ?? ' / ';
+                const labelSet = includedTrace.map((fm) => fm.label);
+                const sep = ops.separator ?? " / ";
                 result.push({
                     label: labelSet.join(sep),
                     value: r.value,
@@ -6230,14 +6246,15 @@
             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])
-                && !(ops.includeNativeLabel && t === LabelTypeFull))
+                .filter((t) => !forceTraceElements?.has(t.split("@")[0]) &&
+                !(ops.includeNativeLabel && t === LabelTypeFull))
                 .sort((a, b) => (importances.get(a) ?? 0) - (importances.get(b) ?? 0));
             for (const typeToRemove of removableSorted) {
                 const reducedSet = new Set(typeSet);
                 reducedSet.delete(typeToRemove);
                 const candidateResult = calculate(reducedSet);
-                if (candidateResult !== undefined && countUniqueLabels(candidateResult) >= currentCardinality) {
+                if (candidateResult !== undefined &&
+                    countUniqueLabels(candidateResult) >= currentCardinality) {
                     typeSet.delete(typeToRemove);
                 }
             }
@@ -6245,7 +6262,7 @@
         };
         if (mainTypes.length === 0) {
             if (secondaryTypes.length !== 0)
-                throw new Error('Non-empty secondary types list while main types list is empty.');
+                throw new Error("Non-empty secondary types list while main types list is empty.");
             return calculate(new Set(LabelTypeFull), true);
         }
         //
@@ -6284,22 +6301,22 @@
         return calculate(fallbackSet, true);
     }
 
-    const PCD_PREFIX = 'PColumnData/';
-    const RT_RESOURCE_MAP = PCD_PREFIX + 'ResourceMap';
-    const RT_RESOURCE_MAP_PARTITIONED = PCD_PREFIX + 'Partitioned/ResourceMap';
-    const RT_JSON_PARTITIONED = PCD_PREFIX + 'JsonPartitioned';
-    const RT_BINARY_PARTITIONED = PCD_PREFIX + 'BinaryPartitioned';
-    const RT_PARQUET_PARTITIONED = PCD_PREFIX + 'ParquetPartitioned';
-    const PCD_SUP_PREFIX = PCD_PREFIX + 'Partitioned/';
-    const RT_JSON_SUPER_PARTITIONED = PCD_SUP_PREFIX + 'JsonPartitioned';
-    const RT_BINARY_SUPER_PARTITIONED = PCD_SUP_PREFIX + 'BinaryPartitioned';
-    const RT_PARQUET_SUPER_PARTITIONED = PCD_SUP_PREFIX + 'ParquetPartitioned';
+    const PCD_PREFIX = "PColumnData/";
+    const RT_RESOURCE_MAP = PCD_PREFIX + "ResourceMap";
+    const RT_RESOURCE_MAP_PARTITIONED = PCD_PREFIX + "Partitioned/ResourceMap";
+    const RT_JSON_PARTITIONED = PCD_PREFIX + "JsonPartitioned";
+    const RT_BINARY_PARTITIONED = PCD_PREFIX + "BinaryPartitioned";
+    const RT_PARQUET_PARTITIONED = PCD_PREFIX + "ParquetPartitioned";
+    const PCD_SUP_PREFIX = PCD_PREFIX + "Partitioned/";
+    const RT_JSON_SUPER_PARTITIONED = PCD_SUP_PREFIX + "JsonPartitioned";
+    const RT_BINARY_SUPER_PARTITIONED = PCD_SUP_PREFIX + "BinaryPartitioned";
+    const RT_PARQUET_SUPER_PARTITIONED = PCD_SUP_PREFIX + "ParquetPartitioned";
     const removeIndexSuffix = (keyStr) => {
-        if (keyStr.endsWith('.index')) {
-            return { baseKey: keyStr.substring(0, keyStr.length - 6), type: 'index' };
+        if (keyStr.endsWith(".index")) {
+            return { baseKey: keyStr.substring(0, keyStr.length - 6), type: "index" };
         }
-        else if (keyStr.endsWith('.values')) {
-            return { baseKey: keyStr.substring(0, keyStr.length - 7), type: 'values' };
+        else if (keyStr.endsWith(".values")) {
+            return { baseKey: keyStr.substring(0, keyStr.length - 7), type: "values" };
         }
         else {
             throw new Error(`key must ends on .index/.values for binary p-column, got: ${keyStr}`);
@@ -6317,20 +6334,20 @@
         // @TODO validate meta shape
         switch (rt) {
             case RT_RESOURCE_MAP:
-                keyLength = meta['keyLength'];
+                keyLength = meta["keyLength"];
                 break;
             case RT_RESOURCE_MAP_PARTITIONED:
-                keyLength = meta['partitionKeyLength'] + meta['keyLength'];
+                keyLength = meta["partitionKeyLength"] + meta["keyLength"];
                 break;
             case RT_JSON_PARTITIONED:
             case RT_BINARY_PARTITIONED:
             case RT_PARQUET_PARTITIONED:
-                keyLength = meta['partitionKeyLength'];
+                keyLength = meta["partitionKeyLength"];
                 break;
             case RT_BINARY_SUPER_PARTITIONED:
             case RT_JSON_SUPER_PARTITIONED:
             case RT_PARQUET_SUPER_PARTITIONED:
-                keyLength = meta['superPartitionKeyLength'] + meta['partitionKeyLength'];
+                keyLength = meta["superPartitionKeyLength"] + meta["partitionKeyLength"];
                 break;
         }
         switch (rt) {
@@ -6352,7 +6369,7 @@
             case RT_PARQUET_SUPER_PARTITIONED:
                 for (const supKeyStr of acc.listInputFields()) {
                     const keyPrefix = [...JSON.parse(supKeyStr)];
-                    const value = acc.resolve({ field: supKeyStr, assertFieldType: 'Input' });
+                    const value = acc.resolve({ field: supKeyStr, assertFieldType: "Input" });
                     if (value !== undefined) {
                         for (let keyStr of value.listInputFields()) {
                             if (rt === RT_BINARY_SUPER_PARTITIONED) {
@@ -6368,7 +6385,9 @@
         return { data, keyLength };
     }
     function getUniquePartitionKeysForDataEntries(list) {
-        if (list.type !== 'JsonPartitioned' && list.type !== 'BinaryPartitioned' && list.type !== 'ParquetPartitioned')
+        if (list.type !== "JsonPartitioned" &&
+            list.type !== "BinaryPartitioned" &&
+            list.type !== "ParquetPartitioned")
             throw new Error(`Splitting requires Partitioned DataInfoEntries, got ${list.type}`);
         const { parts, partitionKeyLength } = list;
         const result = [];
@@ -6401,7 +6420,7 @@
         }
         for (const l of data) {
             if (l.length !== keyLength) {
-                throw new Error('key length does not match partition length');
+                throw new Error("key length does not match partition length");
             }
             for (let i = 0; i < keyLength; ++i) {
                 result[i].add(l[i]);
@@ -6426,10 +6445,10 @@
         const resourceType = acc.resourceType.name;
         const meta = acc.getDataAsJson();
         // Prevent recursive super-partitioned resources
-        if (keyPrefix.length > 0
-            && (resourceType === RT_JSON_SUPER_PARTITIONED
-                || resourceType === RT_BINARY_SUPER_PARTITIONED
-                || resourceType === RT_PARQUET_SUPER_PARTITIONED)) {
+        if (keyPrefix.length > 0 &&
+            (resourceType === RT_JSON_SUPER_PARTITIONED ||
+                resourceType === RT_BINARY_SUPER_PARTITIONED ||
+                resourceType === RT_PARQUET_SUPER_PARTITIONED)) {
             throw new Error(`Unexpected nested super-partitioned resource: ${resourceType}`);
         }
         switch (resourceType) {
@@ -6437,25 +6456,25 @@
             case RT_RESOURCE_MAP_PARTITIONED:
                 throw new Error(`Only data columns are supported, got: ${resourceType}`);
             case RT_JSON_PARTITIONED: {
-                if (typeof meta?.partitionKeyLength !== 'number') {
+                if (typeof meta?.partitionKeyLength !== "number") {
                     throw new Error(`Missing partitionKeyLength in metadata for ${resourceType}`);
                 }
                 const parts = [];
                 for (const keyStr of acc.listInputFields()) {
-                    const value = acc.resolve({ field: keyStr, assertFieldType: 'Input' });
+                    const value = acc.resolve({ field: keyStr, assertFieldType: "Input" });
                     if (value === undefined)
                         return undefined;
                     const key = [...keyPrefix, ...JSON.parse(keyStr)];
                     parts.push({ key, value });
                 }
                 return {
-                    type: 'JsonPartitioned',
+                    type: "JsonPartitioned",
                     partitionKeyLength: meta.partitionKeyLength,
                     parts,
                 };
             }
             case RT_BINARY_PARTITIONED: {
-                if (typeof meta?.partitionKeyLength !== 'number') {
+                if (typeof meta?.partitionKeyLength !== "number") {
                     throw new Error(`Missing partitionKeyLength in metadata for ${resourceType}`);
                 }
                 const parts = [];
@@ -6463,7 +6482,7 @@
                 // Group fields by base key (without .index/.values suffix)
                 for (const keyStr of acc.listInputFields()) {
                     const suffix = removeIndexSuffix(keyStr);
-                    const value = acc.resolve({ field: keyStr, assertFieldType: 'Input' });
+                    const value = acc.resolve({ field: keyStr, assertFieldType: "Input" });
                     if (value === undefined)
                         return undefined;
                     let entry = baseKeys.get(suffix.baseKey);
@@ -6471,7 +6490,7 @@
                         entry = {};
                         baseKeys.set(suffix.baseKey, entry);
                     }
-                    if (suffix.type === 'index') {
+                    if (suffix.type === "index") {
                         entry.index = value;
                     }
                     else {
@@ -6492,39 +6511,39 @@
                     });
                 }
                 return {
-                    type: 'BinaryPartitioned',
+                    type: "BinaryPartitioned",
                     partitionKeyLength: meta.partitionKeyLength,
                     parts,
                 };
             }
             case RT_PARQUET_PARTITIONED: {
-                if (typeof meta?.partitionKeyLength !== 'number') {
+                if (typeof meta?.partitionKeyLength !== "number") {
                     throw new Error(`Missing partitionKeyLength in metadata for ${resourceType}`);
                 }
                 const parts = [];
                 for (const keyStr of acc.listInputFields()) {
-                    const value = acc.resolve({ field: keyStr, assertFieldType: 'Input' });
+                    const value = acc.resolve({ field: keyStr, assertFieldType: "Input" });
                     if (value === undefined)
                         return undefined;
                     const key = [...keyPrefix, ...JSON.parse(keyStr)];
                     parts.push({ key, value });
                 }
                 return {
-                    type: 'ParquetPartitioned',
+                    type: "ParquetPartitioned",
                     partitionKeyLength: meta.partitionKeyLength,
                     parts,
                 };
             }
             case RT_JSON_SUPER_PARTITIONED: {
-                if (typeof meta?.superPartitionKeyLength !== 'number'
-                    || typeof meta?.partitionKeyLength !== 'number') {
+                if (typeof meta?.superPartitionKeyLength !== "number" ||
+                    typeof meta?.partitionKeyLength !== "number") {
                     throw new Error(`Missing superPartitionKeyLength or partitionKeyLength in metadata for ${resourceType}`);
                 }
                 const totalKeyLength = meta.superPartitionKeyLength + meta.partitionKeyLength;
                 const parts = [];
                 // Process all super partitions
                 for (const supKeyStr of acc.listInputFields()) {
-                    const superPartition = acc.resolve({ field: supKeyStr, assertFieldType: 'Input' });
+                    const superPartition = acc.resolve({ field: supKeyStr, assertFieldType: "Input" });
                     if (superPartition === undefined)
                         return undefined;
                     // Validate inner type
@@ -6534,26 +6553,26 @@
                     const innerResult = parsePColumnData(superPartition, JSON.parse(supKeyStr));
                     if (innerResult === undefined)
                         return undefined;
-                    if (innerResult.type !== 'JsonPartitioned')
+                    if (innerResult.type !== "JsonPartitioned")
                         throw new Error(`Unexpected inner result type for ${resourceType}: ${innerResult.type}`);
                     parts.push(...innerResult.parts);
                 }
                 return {
-                    type: 'JsonPartitioned',
+                    type: "JsonPartitioned",
                     partitionKeyLength: totalKeyLength,
                     parts,
                 };
             }
             case RT_BINARY_SUPER_PARTITIONED: {
-                if (typeof meta?.superPartitionKeyLength !== 'number'
-                    || typeof meta?.partitionKeyLength !== 'number') {
+                if (typeof meta?.superPartitionKeyLength !== "number" ||
+                    typeof meta?.partitionKeyLength !== "number") {
                     throw new Error(`Missing superPartitionKeyLength or partitionKeyLength in metadata for ${resourceType}`);
                 }
                 const totalKeyLength = meta.superPartitionKeyLength + meta.partitionKeyLength;
                 const parts = [];
                 // Process all super partitions
                 for (const supKeyStr of acc.listInputFields()) {
-                    const superPartition = acc.resolve({ field: supKeyStr, assertFieldType: 'Input' });
+                    const superPartition = acc.resolve({ field: supKeyStr, assertFieldType: "Input" });
                     if (superPartition === undefined)
                         return undefined;
                     // Validate inner type
@@ -6563,26 +6582,26 @@
                     const innerResult = parsePColumnData(superPartition, JSON.parse(supKeyStr));
                     if (innerResult === undefined)
                         return undefined;
-                    if (innerResult.type !== 'BinaryPartitioned')
+                    if (innerResult.type !== "BinaryPartitioned")
                         throw new Error(`Unexpected inner result type for ${resourceType}: ${innerResult.type}`);
                     parts.push(...innerResult.parts);
                 }
                 return {
-                    type: 'BinaryPartitioned',
+                    type: "BinaryPartitioned",
                     partitionKeyLength: totalKeyLength,
                     parts,
                 };
             }
             case RT_PARQUET_SUPER_PARTITIONED: {
-                if (typeof meta?.superPartitionKeyLength !== 'number'
-                    || typeof meta?.partitionKeyLength !== 'number') {
+                if (typeof meta?.superPartitionKeyLength !== "number" ||
+                    typeof meta?.partitionKeyLength !== "number") {
                     throw new Error(`Missing superPartitionKeyLength or partitionKeyLength in metadata for ${resourceType}`);
                 }
                 const totalKeyLength = meta.superPartitionKeyLength + meta.partitionKeyLength;
                 const parts = [];
                 // Process all super partitions
                 for (const supKeyStr of acc.listInputFields()) {
-                    const superPartition = acc.resolve({ field: supKeyStr, assertFieldType: 'Input' });
+                    const superPartition = acc.resolve({ field: supKeyStr, assertFieldType: "Input" });
                     if (superPartition === undefined)
                         return undefined;
                     // Validate inner type
@@ -6592,12 +6611,12 @@
                     const innerResult = parsePColumnData(superPartition, JSON.parse(supKeyStr));
                     if (innerResult === undefined)
                         return undefined;
-                    if (innerResult.type !== 'ParquetPartitioned')
+                    if (innerResult.type !== "ParquetPartitioned")
                         throw new Error(`Unexpected inner result type for ${resourceType}: ${innerResult.type}`);
                     parts.push(...innerResult.parts);
                 }
                 return {
-                    type: 'ParquetPartitioned',
+                    type: "ParquetPartitioned",
                     partitionKeyLength: totalKeyLength,
                     parts,
                 };
@@ -6627,7 +6646,7 @@
         const isValues = (d) => Array.isArray(d);
         const isAccessor = (d) => d instanceof TreeNodeAccessor;
         let ready = true;
-        const data = typeof c.data === 'function' ? c.data() : c.data;
+        const data = typeof c.data === "function" ? c.data() : c.data;
         if (data == null) {
             return false;
         }
@@ -6635,7 +6654,7 @@
             ready &&= data.getIsReadyOrError();
         }
         else if (isDataInfo(data)) {
-            visitDataInfo(data, (v) => ready &&= v.getIsReadyOrError());
+            visitDataInfo(data, (v) => (ready &&= v.getIsReadyOrError()));
         }
         else if (!isValues(data)) {
             // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
@@ -6653,7 +6672,7 @@
         if (value.length === 0)
             return true;
         const first = value[0];
-        return typeof first === 'object' && first !== null && 'key' in first && 'val' in first;
+        return typeof first === "object" && first !== null && "key" in first && "val" in first;
     }
     /**
      * A simple implementation of {@link ColumnProvider} backed by a pre-defined array of columns.
@@ -6664,7 +6683,7 @@
             this.columns = columns;
         }
         selectColumns(selectors) {
-            const predicate = typeof selectors === 'function' ? selectors : selectorsToPredicate(selectors);
+            const predicate = typeof selectors === "function" ? selectors : selectorsToPredicate(selectors);
             // Filter based on spec, ignoring data type for now
             return this.columns.filter((column) => predicate(column.spec));
         }
@@ -6691,33 +6710,39 @@
     }
     /** Checks if a selector object uses any anchor properties */
     function hasAnchors(selector) {
-        if (!selector || typeof selector !== 'object')
+        if (!selector || typeof selector !== "object")
             return false;
         const potentialAnchored = selector;
-        const domainHasAnchors = potentialAnchored['domain'] && typeof potentialAnchored['domain'] === 'object' && Object.values(potentialAnchored['domain']).some((v) => typeof v === 'object' && v !== null && 'anchor' in v);
-        const axesHaveAnchors = potentialAnchored['axes'] && Array.isArray(potentialAnchored['axes']) && potentialAnchored['axes'].some((a) => typeof a === 'object' && a !== null && 'anchor' in a);
-        return !!potentialAnchored['domainAnchor'] || domainHasAnchors || axesHaveAnchors;
+        const domainHasAnchors = potentialAnchored["domain"] &&
+            typeof potentialAnchored["domain"] === "object" &&
+            Object.values(potentialAnchored["domain"]).some((v) => typeof v === "object" && v !== null && "anchor" in v);
+        const axesHaveAnchors = potentialAnchored["axes"] &&
+            Array.isArray(potentialAnchored["axes"]) &&
+            potentialAnchored["axes"].some((a) => typeof a === "object" && a !== null && "anchor" in a);
+        return !!potentialAnchored["domainAnchor"] || domainHasAnchors || axesHaveAnchors;
     }
     /**
-       * Derives the indices of axes marked for splitting based on the selector.
-       * Throws an error if splitting is requested alongside `partialAxesMatch`.
-       */
+     * Derives the indices of axes marked for splitting based on the selector.
+     * Throws an error if splitting is requested alongside `partialAxesMatch`.
+     */
     function getSplitAxisIndices(selector) {
-        if (typeof selector !== 'object' || !('axes' in selector) || selector.axes === undefined) {
+        if (typeof selector !== "object" || !("axes" in selector) || selector.axes === undefined) {
             return []; // No axes specified or not an object selector, no splitting
         }
         const splitIndices = selector.axes
-            .map((axis, index) => (typeof axis === 'object' && 'split' in axis && axis.split === true) ? index : -1)
+            .map((axis, index) => typeof axis === "object" && "split" in axis && axis.split === true ? index : -1)
             .filter((index) => index !== -1);
         if (splitIndices.length > 0 && selector.partialAxesMatch !== undefined) {
-            throw new Error('Axis splitting is not supported when `partialAxesMatch` is defined.');
+            throw new Error("Axis splitting is not supported when `partialAxesMatch` is defined.");
         }
         splitIndices.sort((a, b) => a - b);
         return splitIndices;
     }
     class PColumnCollection {
         defaultProviderStore = [];
-        providers = [new ArrayColumnProvider(this.defaultProviderStore)];
+        providers = [
+            new ArrayColumnProvider(this.defaultProviderStore),
+        ];
         axisLabelProviders = [];
         constructor() { }
         addColumnProvider(provider) {
@@ -6746,18 +6771,19 @@
             return undefined;
         }
         getUniversalEntries(predicateOrSelectors, opts) {
-            const { anchorCtx, labelOps: rawLabelOps, dontWaitAllData = false, overrideLabelAnnotation = false, exclude, enrichByLinkers = false } = opts ?? {};
+            const { anchorCtx, labelOps: rawLabelOps, dontWaitAllData = false, overrideLabelAnnotation = false, exclude, enrichByLinkers = false, } = opts ?? {};
             const labelOps = {
-                ...(overrideLabelAnnotation && rawLabelOps?.includeNativeLabel !== false ? { includeNativeLabel: true } : {}),
-                ...(rawLabelOps ?? {}),
+                ...(overrideLabelAnnotation && rawLabelOps?.includeNativeLabel !== false
+                    ? { includeNativeLabel: true }
+                    : {}),
+                ...rawLabelOps,
             };
             let excludePredicate = () => false;
             if (exclude) {
-                const excludePredicartes = (Array.isArray(exclude) ? exclude : [exclude])
-                    .map((selector) => {
+                const excludePredicartes = (Array.isArray(exclude) ? exclude : [exclude]).map((selector) => {
                     if (hasAnchors(selector)) {
                         if (!anchorCtx)
-                            throw new Error('Anchored selectors in exclude require an AnchoredIdDeriver to be provided in options.');
+                            throw new Error("Anchored selectors in exclude require an AnchoredIdDeriver to be provided in options.");
                         return selectorsToPredicate(resolveAnchors(anchorCtx.anchors, selector, opts));
                     }
                     else
@@ -6765,7 +6791,7 @@
                 });
                 excludePredicate = (spec) => excludePredicartes.some((predicate) => predicate(spec));
             }
-            const selectorsArray = typeof predicateOrSelectors === 'function'
+            const selectorsArray = typeof predicateOrSelectors === "function"
                 ? [predicateOrSelectors]
                 : Array.isArray(predicateOrSelectors)
                     ? predicateOrSelectors
@@ -6777,7 +6803,7 @@
                 let currentSelector;
                 if (usesAnchors) {
                     if (!anchorCtx)
-                        throw new Error('Anchored selectors require an AnchoredIdDeriver to be provided in options.');
+                        throw new Error("Anchored selectors require an AnchoredIdDeriver to be provided in options.");
                     currentSelector = resolveAnchors(anchorCtx.anchors, rawSelector, opts);
                 }
                 else
@@ -6822,14 +6848,13 @@
                         const maxSplitIdx = splitAxisIdxs[splitAxisIdxs.length - 1];
                         if (maxSplitIdx >= dataEntries.partitionKeyLength)
                             throw new Error(`Not enough partition keys (${dataEntries.partitionKeyLength}) for requested split axes (max index ${maxSplitIdx}) in column ${originalSpec.name}`);
-                        const axesLabels = splitAxisIdxs
-                            .map((idx) => this.findLabels(getAxisId(originalSpec.axesSpec[idx])));
+                        const axesLabels = splitAxisIdxs.map((idx) => this.findLabels(getAxisId(originalSpec.axesSpec[idx])));
                         const keyCombinations = [];
                         const generateCombinations = (currentCombo, sAxisIdx) => {
                             if (sAxisIdx >= splitAxisIdxs.length) {
                                 keyCombinations.push([...currentCombo]);
                                 if (keyCombinations.length > 10000)
-                                    throw new Error('Too many key combinations, aborting.');
+                                    throw new Error("Too many key combinations, aborting.");
                                 return;
                             }
                             const axisIdx = splitAxisIdxs[sAxisIdx];
@@ -6865,7 +6890,7 @@
                                 return { axisIdx, axisId, value: value, label };
                             });
                             intermediateResults.push({
-                                type: 'split',
+                                type: "split",
                                 originalColumn: column,
                                 spec: originalSpec,
                                 adjustedSpec,
@@ -6876,7 +6901,7 @@
                     }
                     else {
                         intermediateResults.push({
-                            type: 'direct',
+                            type: "direct",
                             originalColumn: column,
                             spec: originalSpec,
                             adjustedSpec: originalSpec,
@@ -6888,12 +6913,12 @@
                 return [];
             const labeledResults = deriveLabels(intermediateResults, (entry) => ({
                 spec: entry.spec,
-                suffixTrace: entry.type === 'split' ? splitFiltersToTrace(entry.axisFilters) : undefined,
+                suffixTrace: entry.type === "split" ? splitFiltersToTrace(entry.axisFilters) : undefined,
             }), labelOps);
             const result = [];
             for (const { value: entry, label } of labeledResults) {
                 const { originalColumn, spec: originalSpec } = entry;
-                const axisFilters = entry.type === 'split' ? entry.axisFilters : undefined;
+                const axisFilters = entry.type === "split" ? entry.axisFilters : undefined;
                 const axisFiltersTuple = splitFiltersToAxisFilter(axisFilters);
                 let finalId;
                 if (anchorCtx)
@@ -6905,7 +6930,7 @@
                     finalSpec = {
                         ...finalSpec,
                         annotations: {
-                            ...(finalSpec.annotations ?? {}),
+                            ...finalSpec.annotations,
                             [Annotation.Label]: label,
                         },
                     };
@@ -6913,7 +6938,7 @@
                 result.push({
                     id: finalId,
                     spec: finalSpec,
-                    data: () => entry.type === 'split'
+                    data: () => entry.type === "split"
                         ? entriesToDataInfo(filterDataInfoEntries(entry.dataEntries, axisFiltersTuple))
                         : entry.originalColumn.data,
                     label: label,
@@ -6934,10 +6959,11 @@
                 // search all axes that can be reached by linkers from anchor axes; anchor axes are not in this list;
                 const availableByLinkersAxes = linkerMap.getReachableByLinkersAxesFromAxes(anchorAxes, matchAxisIdFn);
                 // search all columns that includes at least one of additional axes;
-                const availableByLinkersColumns = this.getUniversalEntries((spec) => !isLinkerColumn(spec) && spec.axesSpec.some((columnAxisSpec) => {
-                    const columnAxisId = getAxisId(columnAxisSpec);
-                    return availableByLinkersAxes.some((axis) => matchAxisIdFn(getAxisId(axis), columnAxisId));
-                }), { anchorCtx, labelOps, dontWaitAllData, overrideLabelAnnotation, exclude });
+                const availableByLinkersColumns = this.getUniversalEntries((spec) => !isLinkerColumn(spec) &&
+                    spec.axesSpec.some((columnAxisSpec) => {
+                        const columnAxisId = getAxisId(columnAxisSpec);
+                        return availableByLinkersAxes.some((axis) => matchAxisIdFn(getAxisId(axis), columnAxisId));
+                    }), { anchorCtx, labelOps, dontWaitAllData, overrideLabelAnnotation, exclude });
                 if (availableByLinkersColumns) {
                     result.push(...availableByLinkersColumns.filter((entry) => !ids.has(entry.id)));
                 }
@@ -6947,7 +6973,7 @@
         getColumns(predicateOrSelectors, opts) {
             const entries = this.getUniversalEntries(predicateOrSelectors, {
                 overrideLabelAnnotation: true, // default for getColumns
-                ...(opts ?? {}),
+                ...opts,
             });
             if (!entries)
                 return undefined;
@@ -6971,12 +6997,12 @@
 
     function patchInSetFilters(filters) {
         const inSetToOrEqual = (predicate) => {
-            if (predicate.operator !== 'InSet')
+            if (predicate.operator !== "InSet")
                 return predicate;
             return {
-                operator: 'Or',
+                operator: "Or",
                 operands: predicate.references.map((reference) => ({
-                    operator: 'Equal',
+                    operator: "Equal",
                     reference,
                 })),
             };
@@ -6984,17 +7010,17 @@
         const mapSingleValuePredicate = (filter, cb) => {
             const operator = filter.operator;
             switch (operator) {
-                case 'And':
+                case "And":
                     return {
                         ...filter,
                         operands: filter.operands.map((operand) => mapSingleValuePredicate(operand, cb)),
                     };
-                case 'Or':
+                case "Or":
                     return {
                         ...filter,
                         operands: filter.operands.map((operand) => mapSingleValuePredicate(operand, cb)),
                     };
-                case 'Not':
+                case "Not":
                     return {
                         ...filter,
                         operand: mapSingleValuePredicate(filter.operand, cb),
@@ -7056,18 +7082,18 @@
             return this.ctx.calculateOptions(predicate);
         }
         getOptions(predicateOrSelector, opts) {
-            const predicate = typeof predicateOrSelector === 'function'
+            const predicate = typeof predicateOrSelector === "function"
                 ? predicateOrSelector
                 : selectorsToPredicate(predicateOrSelector);
             const filtered = this.getSpecs().entries.filter((s) => predicate(s.obj));
             let labelOps = {};
             let refsWithEnrichments = false;
-            if (typeof opts !== 'undefined') {
-                if (typeof opts === 'function') {
+            if (typeof opts !== "undefined") {
+                if (typeof opts === "function") {
                     labelOps = opts;
                 }
-                else if (typeof opts === 'object') {
-                    if ('includeNativeLabel' in opts || 'separator' in opts || 'addLabelAsSuffix' in opts) {
+                else if (typeof opts === "object") {
+                    if ("includeNativeLabel" in opts || "separator" in opts || "addLabelAsSuffix" in opts) {
                         labelOps = opts;
                     }
                     else {
@@ -7077,7 +7103,7 @@
                     }
                 }
             }
-            if (typeof labelOps === 'object')
+            if (typeof labelOps === "object")
                 return deriveLabels(filtered, (o) => o.obj, labelOps ?? {}).map(({ value: { ref }, label }) => ({
                     ref: withEnrichments(ref, refsWithEnrichments),
                     label,
@@ -7225,7 +7251,7 @@
          */
         getDataByRef(ref) {
             // @TODO remove after 1 Jan 2025; forward compatibility
-            if (typeof this.ctx.getDataFromResultPoolByRef === 'undefined')
+            if (typeof this.ctx.getDataFromResultPoolByRef === "undefined")
                 return this.getData().entries.find((f) => f.ref.blockId === ref.blockId && f.ref.name === ref.name)?.obj;
             const data = this.ctx.getDataFromResultPoolByRef(ref.blockId, ref.name); // Keep original call
             // Need to handle undefined case before mapping
@@ -7315,12 +7341,12 @@
                 if (!isPColumn(column.obj))
                     continue;
                 const spec = column.obj.spec;
-                if (spec.name === PColumnName.Label
-                    && spec.axesSpec.length === 1
-                    && spec.axesSpec[0].name === axis.name
-                    && spec.axesSpec[0].type === axis.type
-                    && matchDomain(axis.domain, spec.axesSpec[0].domain)) {
-                    if (column.obj.data.resourceType.name !== 'PColumnData/Json') {
+                if (spec.name === PColumnName.Label &&
+                    spec.axesSpec.length === 1 &&
+                    spec.axesSpec[0].name === axis.name &&
+                    spec.axesSpec[0].type === axis.type &&
+                    matchDomain(axis.domain, spec.axesSpec[0].domain)) {
+                    if (column.obj.data.resourceType.name !== "PColumnData/Json") {
                         throw Error(`Expected JSON column for labels, got: ${column.obj.data.resourceType.name}`);
                     }
                     const labels = Object.fromEntries(Object.entries(column.obj.data.getDataAsJson().data).map((e) => [JSON.parse(e[0])[0], e[1]]));
@@ -7337,7 +7363,7 @@
          * @returns An array of PColumn objects matching the selectors. Data is loaded on first access.
          */
         selectColumns(selectors) {
-            const predicate = typeof selectors === 'function' ? selectors : selectorsToPredicate(selectors);
+            const predicate = typeof selectors === "function" ? selectors : selectorsToPredicate(selectors);
             const matchedSpecs = this.getSpecs().entries.filter(({ obj: spec }) => {
                 if (!isPColumnSpec(spec))
                     return false;
@@ -7375,7 +7401,7 @@
             if (axisKeys !== undefined) {
                 const keys = JSON.parse(axisKeys);
                 return Object.fromEntries(keys.map((key) => {
-                    return [key, labels[key] ?? 'Unlabelled'];
+                    return [key, labels[key] ?? "Unlabelled"];
                 }));
             }
             else {
@@ -7393,7 +7419,7 @@
         get data() {
             if (this._dataCache === undefined) {
                 const raw = this.ctx.data;
-                const value = typeof raw === 'function' ? raw() : raw;
+                const value = typeof raw === "function" ? raw() : raw;
                 this._dataCache = { v: value ? JSON.parse(value) : {} };
             }
             return this._dataCache.v;
@@ -7407,7 +7433,7 @@
         get activeArgs() {
             if (this._activeArgsCache === undefined) {
                 const raw = this.ctx.activeArgs;
-                const value = typeof raw === 'function' ? raw() : raw;
+                const value = typeof raw === "function" ? raw() : raw;
                 this._activeArgsCache = {
                     v: value ? JSON.parse(value) : undefined,
                 };
@@ -7470,11 +7496,11 @@
         }
         createPTable(def) {
             let rawDef;
-            if ('columns' in def) {
+            if ("columns" in def) {
                 rawDef = this.patchPTableDef({
                     src: {
-                        type: 'full',
-                        entries: def.columns.map((c) => ({ type: 'column', column: c })),
+                        type: "full",
+                        entries: def.columns.map((c) => ({ type: "column", column: c })),
                     },
                     partitionFilters: def.filters ?? [],
                     filters: [],
@@ -7513,7 +7539,7 @@
         get args() {
             if (this._argsCache === undefined) {
                 const raw = this.ctx.args;
-                const value = typeof raw === 'function' ? raw() : raw;
+                const value = typeof raw === "function" ? raw() : raw;
                 this._argsCache = { v: JSON.parse(value) };
             }
             return this._argsCache.v;
@@ -7522,14 +7548,14 @@
         get uiState() {
             if (this._uiStateCache === undefined) {
                 const raw = this.ctx.uiState;
-                const value = typeof raw === 'function' ? raw() : raw;
+                const value = typeof raw === "function" ? raw() : raw;
                 this._uiStateCache = { v: value ? JSON.parse(value) : {} };
             }
             return this._uiStateCache.v;
         }
     }
 
-    var version = "1.53.10";
+    var version = "1.53.13";
 
     const PlatformaSDKVersion = version;
 
@@ -7560,7 +7586,7 @@
                 requiresModelAPIVersion: 1,
             };
         }
-        static create(renderingMode = 'Heavy') {
+        static create(renderingMode = "Heavy") {
             return new BlockModel({
                 renderingMode,
                 initialUiState: {},
@@ -7571,7 +7597,7 @@
             });
         }
         output(key, cfgOrRf, flags = {}) {
-            if (typeof cfgOrRf === 'function') {
+            if (typeof cfgOrRf === "function") {
                 const handle = `output#${key}`;
                 tryRegisterCallback(handle, () => cfgOrRf(new RenderCtxLegacy()));
                 return new BlockModel({
@@ -7609,13 +7635,13 @@
             return this.output(key, rf, { retentive: true, withStatus: true });
         }
         argsValid(cfgOrRf) {
-            if (typeof cfgOrRf === 'function') {
-                tryRegisterCallback('inputsValid', () => cfgOrRf(new RenderCtxLegacy()));
+            if (typeof cfgOrRf === "function") {
+                tryRegisterCallback("inputsValid", () => cfgOrRf(new RenderCtxLegacy()));
                 return new BlockModel({
                     ...this.config,
                     inputsValid: {
                         __renderLambda: true,
-                        handle: 'inputsValid',
+                        handle: "inputsValid",
                     },
                 });
             }
@@ -7630,13 +7656,13 @@
             if (Array.isArray(arrOrCfgOrRf)) {
                 return this.sections(getImmediate(arrOrCfgOrRf));
             }
-            else if (typeof arrOrCfgOrRf === 'function') {
-                tryRegisterCallback('sections', () => arrOrCfgOrRf(new RenderCtxLegacy()));
+            else if (typeof arrOrCfgOrRf === "function") {
+                tryRegisterCallback("sections", () => arrOrCfgOrRf(new RenderCtxLegacy()));
                 return new BlockModel({
                     ...this.config,
                     sections: {
                         __renderLambda: true,
-                        handle: 'sections',
+                        handle: "sections",
                     },
                 });
             }
@@ -7649,32 +7675,32 @@
         }
         /** Sets a rendering function to derive block title, shown for the block in the left blocks-overview panel. */
         title(rf) {
-            tryRegisterCallback('title', () => rf(new RenderCtxLegacy()));
+            tryRegisterCallback("title", () => rf(new RenderCtxLegacy()));
             return new BlockModel({
                 ...this.config,
                 title: {
                     __renderLambda: true,
-                    handle: 'title',
+                    handle: "title",
                 },
             });
         }
         subtitle(rf) {
-            tryRegisterCallback('subtitle', () => rf(new RenderCtxLegacy()));
+            tryRegisterCallback("subtitle", () => rf(new RenderCtxLegacy()));
             return new BlockModel({
                 ...this.config,
                 subtitle: {
                     __renderLambda: true,
-                    handle: 'subtitle',
+                    handle: "subtitle",
                 },
             });
         }
         tags(rf) {
-            tryRegisterCallback('tags', () => rf(new RenderCtxLegacy()));
+            tryRegisterCallback("tags", () => rf(new RenderCtxLegacy()));
             return new BlockModel({
                 ...this.config,
                 tags: {
                     __renderLambda: true,
-                    handle: 'tags',
+                    handle: "tags",
                 },
             });
         }
@@ -7714,12 +7740,12 @@
          * Influences dependency graph construction.
          */
         enriches(lambda) {
-            tryRegisterCallback('enrichmentTargets', lambda);
+            tryRegisterCallback("enrichmentTargets", lambda);
             return new BlockModel({
                 ...this.config,
                 enrichmentTargets: {
                     __renderLambda: true,
-                    handle: 'enrichmentTargets',
+                    handle: "enrichmentTargets",
                 },
             });
         }
@@ -7734,7 +7760,7 @@
         }
         #done() {
             if (this.config.initialArgs === undefined)
-                throw new Error('Initial arguments not set.');
+                throw new Error("Initial arguments not set.");
             const config = {
                 v4: undefined,
                 v3: {
@@ -7759,21 +7785,30 @@
                 initialArgs: this.config.initialArgs,
                 inputsValid: downgradeCfgOrLambda(this.config.inputsValid),
                 sections: downgradeCfgOrLambda(this.config.sections),
-                outputs: Object.fromEntries(Object.entries(this.config.outputs).map(([key, value]) => [key, downgradeCfgOrLambda(value)])),
+                outputs: Object.fromEntries(Object.entries(this.config.outputs).map(([key, value]) => [
+                    key,
+                    downgradeCfgOrLambda(value),
+                ])),
             };
-            globalThis.platformaApiVersion = this.config.featureFlags.requiresUIAPIVersion;
+            globalThis.platformaApiVersion = this.config.featureFlags
+                .requiresUIAPIVersion;
             if (!isInUI())
                 // we are in the configuration rendering routine, not in actual UI
                 return { config };
             // normal operation inside the UI
             else
                 return {
-                    ...getPlatformaInstance({ sdkVersion: PlatformaSDKVersion, apiVersion: platformaApiVersion }),
+                    ...getPlatformaInstance({
+                        sdkVersion: PlatformaSDKVersion,
+                        apiVersion: platformaApiVersion,
+                    }),
                     blockModelInfo: {
-                        outputs: Object.fromEntries(Object.entries(this.config.outputs)
-                            .map(([key, value]) => [key, {
+                        outputs: Object.fromEntries(Object.entries(this.config.outputs).map(([key, value]) => [
+                            key,
+                            {
                                 withStatus: Boolean(isConfigLambda(value) && value.withStatus),
-                            }])),
+                            },
+                        ])),
                     },
                 };
         }
@@ -7819,7 +7854,7 @@
         }
         // Parse JSON string if needed
         let parsed = rawStorage;
-        if (typeof rawStorage === 'string') {
+        if (typeof rawStorage === "string") {
             try {
                 parsed = JSON.parse(rawStorage);
             }
@@ -7863,18 +7898,18 @@
      * Legacy format has { args, uiState? } at top level without the BlockStorage discriminator.
      */
     function isLegacyModelV1ApiFormat(data) {
-        if (data === null || typeof data !== 'object')
+        if (data === null || typeof data !== "object")
             return false;
         if (isBlockStorage(data))
             return false;
         const obj = data;
-        return 'args' in obj;
+        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) => {
+    tryRegisterCallback("__pl_storage_applyUpdate", (currentStorageJson, payload) => {
         return applyStorageUpdate(currentStorageJson, payload);
     });
     /**
@@ -7893,7 +7928,7 @@
         return stringifyJson(debugView);
     }
     // Register debug view callback
-    tryRegisterCallback('__pl_storage_debugView', (rawStorage) => {
+    tryRegisterCallback("__pl_storage_debugView", (rawStorage) => {
         return getStorageDebugView(rawStorage);
     });
     /**
@@ -7911,7 +7946,7 @@
         // Get the callback registry context
         const ctx = tryGetCfgRenderCtx();
         if (ctx === undefined) {
-            return { error: 'Not in config rendering context' };
+            return { error: "Not in config rendering context" };
         }
         // Normalize storage to get current data and version
         const { storage: currentStorage, data: currentData } = normalizeStorage(currentStorageJson);
@@ -7925,9 +7960,9 @@
             });
         };
         // 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)' };
+        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;
@@ -7951,7 +7986,7 @@
         };
     }
     // Register migrate callback
-    tryRegisterCallback('__pl_storage_migrate', (currentStorageJson) => {
+    tryRegisterCallback("__pl_storage_migrate", (currentStorageJson) => {
         return migrateStorage(currentStorageJson);
     });
     /**
@@ -7964,14 +7999,14 @@
     function deriveArgsFromStorage(storageJson) {
         const ctx = tryGetCfgRenderCtx();
         if (ctx === undefined) {
-            return { error: 'Not in config rendering context' };
+            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' };
+        const argsCallback = ctx.callbackRegistry["args"];
+        if (typeof argsCallback !== "function") {
+            return { error: "args callback not found" };
         }
         // Call the args callback with extracted data
         try {
@@ -7984,7 +8019,7 @@
         }
     }
     // Register args derivation callback
-    tryRegisterCallback('__pl_args_derive', (storageJson) => {
+    tryRegisterCallback("__pl_args_derive", (storageJson) => {
         return deriveArgsFromStorage(storageJson);
     });
     /**
@@ -7997,13 +8032,13 @@
     function derivePrerunArgsFromStorage(storageJson) {
         const ctx = tryGetCfgRenderCtx();
         if (ctx === undefined) {
-            return { error: 'Not in config rendering context' };
+            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') {
+        const prerunArgsCallback = ctx.callbackRegistry["prerunArgs"];
+        if (typeof prerunArgsCallback === "function") {
             try {
                 const result = prerunArgsCallback(data);
                 return { value: result };
@@ -8014,9 +8049,9 @@
             }
         }
         // Fall back to args callback
-        const argsCallback = ctx.callbackRegistry['args'];
-        if (typeof argsCallback !== 'function') {
-            return { error: 'args callback not found (fallback from missing prerunArgs)' };
+        const argsCallback = ctx.callbackRegistry["args"];
+        if (typeof argsCallback !== "function") {
+            return { error: "args callback not found (fallback from missing prerunArgs)" };
         }
         try {
             const result = argsCallback(data);
@@ -8028,7 +8063,7 @@
         }
     }
     // Register prerunArgs derivation callback
-    tryRegisterCallback('__pl_prerunArgs_derive', (storageJson) => {
+    tryRegisterCallback("__pl_prerunArgs_derive", (storageJson) => {
         return derivePrerunArgsFromStorage(storageJson);
     });
 
@@ -8060,7 +8095,7 @@
             return createPlDataTableStateV2();
         }
         // v1 -> v2
-        if (!('version' in state)) {
+        if (!("version" in state)) {
             // Non upgradeable as sourceId calculation algorithm has changed, resetting state to default
             state = createPlDataTableStateV2();
         }
@@ -8176,12 +8211,12 @@
         secondaryColumns.push(...params.labelColumns);
         return {
             src: {
-                type: 'outer',
+                type: "outer",
                 primary: {
                     type: params.coreJoinType,
-                    entries: coreColumns.map((c) => ({ type: 'column', column: c })),
+                    entries: coreColumns.map((c) => ({ type: "column", column: c })),
                 },
-                secondary: secondaryColumns.map((c) => ({ type: 'column', column: c })),
+                secondary: secondaryColumns.map((c) => ({ type: "column", column: c })),
             },
             partitionFilters: params.partitionFilters,
             filters: params.filters,
@@ -8190,7 +8225,7 @@
     }
     /** Check if column is hidden by default */
     function isColumnOptional(spec) {
-        return readAnnotation(spec, Annotation.Table.Visibility) === 'optional';
+        return readAnnotation(spec, Annotation.Table.Visibility) === "optional";
     }
     /**
      * Create p-table spec and handle given ui table state
@@ -8223,14 +8258,13 @@
         const fullColumns = [...columns, ...fullLabelColumns];
         const fullColumnsAxes = uniqueBy(fullColumns.flatMap((c) => c.spec.axesSpec.map((a) => getAxisId(a))), (a) => canonicalizeJson(a));
         const fullColumnsIds = [
-            ...fullColumnsAxes.map((a) => ({ type: 'axis', id: a })),
-            ...fullColumns.map((c) => ({ type: 'column', id: c.id })),
+            ...fullColumnsAxes.map((a) => ({ type: "axis", id: a })),
+            ...fullColumns.map((c) => ({ type: "column", id: c.id })),
         ];
         const fullColumnsIdsSet = new Set(fullColumnsIds.map((c) => canonicalizeJson(c)));
         const isValidColumnId = (id) => fullColumnsIdsSet.has(canonicalizeJson(id));
-        const coreJoinType = 'full';
-        const partitionFilters = tableStateNormalized.pTableParams.partitionFilters
-            .filter((f) => {
+        const coreJoinType = "full";
+        const partitionFilters = tableStateNormalized.pTableParams.partitionFilters.filter((f) => {
             const valid = isValidColumnId(f.column);
             if (!valid)
                 ctx.logWarn(`Partition filter ${JSON.stringify(f)} does not match provided columns, skipping`);
@@ -8264,19 +8298,19 @@
             const hiddenColIds = tableStateNormalized.pTableParams.hiddenColIds;
             if (hiddenColIds)
                 return hiddenColIds;
-            return columns
-                .filter((c) => isColumnOptional(c.spec))
-                .map((c) => c.id);
+            return columns.filter((c) => isColumnOptional(c.spec)).map((c) => c.id);
         })());
         // Preserve linker columns
-        columns
-            .filter((c) => isLinkerColumn(c.spec))
-            .forEach((c) => hiddenColumns.delete(c.id));
+        columns.filter((c) => isLinkerColumn(c.spec)).forEach((c) => hiddenColumns.delete(c.id));
         // Preserve core columns as they change the shape of join.
         const coreColumnPredicate = ops?.coreColumnPredicate;
         // Filters decrease the number of result rows, sorting changes the order of result rows
-        [...partitionFilters.map((f) => f.column), ...filters.map((f) => f.column), ...sorting.map((s) => s.column)]
-            .filter((c) => c.type === 'column')
+        [
+            ...partitionFilters.map((f) => f.column),
+            ...filters.map((f) => f.column),
+            ...sorting.map((s) => s.column),
+        ]
+            .filter((c) => c.type === "column")
             .forEach((c) => hiddenColumns.delete(c.id));
         const visibleColumns = columns.filter((c) => !hiddenColumns.has(c.id));
         const visibleLabelColumns = getMatchingLabelColumns(visibleColumns.map(getColumnIdAndSpec), allLabelColumns);
@@ -8347,7 +8381,7 @@
     // https://zod.dev/?id=recursive-types
     // We need zod to parse error strings into these objects for keeping new UI and old blocks compatible.
     const BasePlErrorLike = z.object({
-        type: z.literal('PlError'),
+        type: z.literal("PlError"),
         name: z.string(),
         message: z.string(),
         /** The message with all details needed for SDK developers. */
@@ -8359,7 +8393,7 @@
         errors: z.lazy(() => ErrorLike.array()).optional(),
     });
     const BaseStandardErrorLike = z.object({
-        type: z.literal('StandardError'),
+        type: z.literal("StandardError"),
         name: z.string(),
         message: z.string(),
         stack: z.string().optional(),
@@ -8405,11 +8439,11 @@
         numbers: z.array(z.coerce.number()),
         handles: z.array(ImportFileHandleSchema),
     });
-    const platforma = BlockModel.create('Heavy')
+    const platforma = BlockModel.create("Heavy")
         .withArgs({ numbers: [1, 2, 3, 4], handles: [] })
         .withUiState({
         dataTableV2: {
-            sourceId: 'source_1',
+            sourceId: "source_1",
             numRows: 200,
             state: createPlDataTableStateV2(),
         },
@@ -8418,66 +8452,66 @@
     })
         .argsValid((ctx) => {
         if (ctx.args.numbers.length === 5) {
-            throw new Error('argsValid: test error');
+            throw new Error("argsValid: test error");
         }
         return ctx.args.numbers.length > 0;
     })
-        .output('numbers', (ctx) => ctx.outputs?.resolve('numbers')?.getDataAsJson())
-        .output('progresses', (ctx) => {
-        const m = ctx.outputs?.resolve('progresses');
+        .output("numbers", (ctx) => ctx.outputs?.resolve("numbers")?.getDataAsJson())
+        .output("progresses", (ctx) => {
+        const m = ctx.outputs?.resolve("progresses");
         const progresses = m?.mapFields((name, val) => [name, val?.getImportProgress()]);
         return Object.fromEntries(progresses ?? []);
     })
-        .output('ptV2Sheets', (ctx) => {
+        .output("ptV2Sheets", (ctx) => {
         const rowCount = ctx.uiState.dataTableV2.numRows ?? 0;
         const sheets = [
             {
                 axis: {
                     type: ValueType.Int,
-                    name: 'part',
+                    name: "part",
                     annotations: {
-                        [Annotation.Label]: 'Partitioned axis',
+                        [Annotation.Label]: "Partitioned axis",
                         [Annotation.DiscreteValues]: stringifyJson([0, 1]),
                     },
                 },
                 options: [
-                    { value: 0, label: 'Partition 1' },
-                    { value: 1, label: 'Partition 2' },
+                    { value: 0, label: "Partition 1" },
+                    { value: 1, label: "Partition 2" },
                 ],
             },
         ];
         return rowCount > 0 ? sheets : [];
     })
-        .outputWithStatus('ptV2', (ctx) => {
+        .outputWithStatus("ptV2", (ctx) => {
         const rowCount = ctx.uiState.dataTableV2.numRows ?? 0;
         const makePartitionId = (rowCount, i) => Math.floor((2 * i) / (rowCount + 1));
         const columns = [
             {
-                id: 'column1',
+                id: "column1",
                 spec: {
-                    kind: 'PColumn',
+                    kind: "PColumn",
                     valueType: ValueType.String,
-                    name: 'example',
+                    name: "example",
                     annotations: {
-                        [Annotation.Label]: 'String column',
-                        [Annotation.DiscreteValues]: stringifyJson(['up', 'down']),
+                        [Annotation.Label]: "String column",
+                        [Annotation.DiscreteValues]: stringifyJson(["up", "down"]),
                         [Annotation.Table.OrderPriority]: stringifyJson(101),
-                        [Annotation.Description]: 'String column description',
+                        [Annotation.Description]: "String column description",
                     },
                     axesSpec: [
                         {
                             type: ValueType.Int,
-                            name: 'part',
+                            name: "part",
                             annotations: {
-                                [Annotation.Label]: 'Partitioned axis',
+                                [Annotation.Label]: "Partitioned axis",
                                 [Annotation.DiscreteValues]: stringifyJson([0, 1]),
                             },
                         },
                         {
                             type: ValueType.Int,
-                            name: 'index',
+                            name: "index",
                             annotations: {
-                                [Annotation.Label]: 'Int axis',
+                                [Annotation.Label]: "Int axis",
                             },
                         },
                     ],
@@ -8491,31 +8525,31 @@
                 }),
             },
             {
-                id: 'column2',
+                id: "column2",
                 spec: {
-                    kind: 'PColumn',
+                    kind: "PColumn",
                     valueType: ValueType.Float,
-                    name: 'value',
+                    name: "value",
                     annotations: {
-                        [Annotation.Label]: 'Float column',
-                        [Annotation.Table.Visibility]: 'optional',
+                        [Annotation.Label]: "Float column",
+                        [Annotation.Table.Visibility]: "optional",
                         [Annotation.Table.OrderPriority]: stringifyJson(100),
-                        [Annotation.Description]: 'Float column description',
+                        [Annotation.Description]: "Float column description",
                     },
                     axesSpec: [
                         {
                             type: ValueType.Int,
-                            name: 'part',
+                            name: "part",
                             annotations: {
-                                [Annotation.Label]: 'Partitioned axis',
+                                [Annotation.Label]: "Partitioned axis",
                                 [Annotation.DiscreteValues]: stringifyJson([0, 1]),
                             },
                         },
                         {
                             type: ValueType.Int,
-                            name: 'index',
+                            name: "index",
                             annotations: {
-                                [Annotation.Label]: 'Int axis',
+                                [Annotation.Label]: "Int axis",
                             },
                         },
                     ],
@@ -8529,20 +8563,20 @@
                 }),
             },
             {
-                id: 'labelColumn',
+                id: "labelColumn",
                 spec: {
-                    kind: 'PColumn',
+                    kind: "PColumn",
                     valueType: ValueType.Int,
                     name: PColumnName.Label,
                     annotations: {
-                        [Annotation.Label]: 'Int axis labels',
+                        [Annotation.Label]: "Int axis labels",
                     },
                     axesSpec: [
                         {
                             type: ValueType.Int,
-                            name: 'index',
+                            name: "index",
                             annotations: {
-                                [Annotation.Label]: 'Int axis',
+                                [Annotation.Label]: "Int axis",
                             },
                         },
                     ],
@@ -8556,29 +8590,29 @@
                 }),
             },
             {
-                id: 'linkerColumn',
+                id: "linkerColumn",
                 spec: {
-                    kind: 'PColumn',
+                    kind: "PColumn",
                     valueType: ValueType.Int,
-                    name: 'linker',
+                    name: "linker",
                     annotations: {
-                        [Annotation.Label]: 'Index axis linker',
+                        [Annotation.Label]: "Index axis linker",
                         [Annotation.IsLinkerColumn]: stringifyJson(true),
-                        [Annotation.Table.Visibility]: 'hidden',
+                        [Annotation.Table.Visibility]: "hidden",
                     },
                     axesSpec: [
                         {
                             type: ValueType.Int,
-                            name: 'index',
+                            name: "index",
                             annotations: {
-                                [Annotation.Label]: 'Int axis',
+                                [Annotation.Label]: "Int axis",
                             },
                         },
                         {
                             type: ValueType.Int,
-                            name: 'linkedIndex',
+                            name: "linkedIndex",
                             annotations: {
-                                [Annotation.Label]: 'Linked int axis',
+                                [Annotation.Label]: "Linked int axis",
                             },
                         },
                     ],
@@ -8596,20 +8630,20 @@
             columns.push({
                 id: `alphabeticalColumn${j}`,
                 spec: {
-                    kind: 'PColumn',
+                    kind: "PColumn",
                     valueType: ValueType.String,
-                    name: 'value',
+                    name: "value",
                     annotations: {
                         [Annotation.Label]: `Alphabetical column ${j}`,
-                        [Annotation.Table.Visibility]: 'optional',
+                        [Annotation.Table.Visibility]: "optional",
                         [Annotation.Table.OrderPriority]: stringifyJson(10 - j),
                     },
                     axesSpec: [
                         {
                             type: ValueType.Int,
-                            name: 'linkedIndex',
+                            name: "linkedIndex",
                             annotations: {
-                                [Annotation.Label]: 'Linked int axis',
+                                [Annotation.Label]: "Linked int axis",
                             },
                         },
                     ],
@@ -8627,67 +8661,63 @@
     })
         .title((ctx) => {
         if (ctx.args.numbers.length === 5) {
-            throw new Error('block title: test error');
+            throw new Error("block title: test error");
         }
-        return 'Ui Examples';
+        return "Ui Examples";
     })
         .sections((ctx) => {
         const dynamicSections = (ctx.uiState.dynamicSections ?? []).map((it) => ({
-            type: 'link',
+            type: "link",
             href: `/section?id=${it.id}`,
             label: it.label,
         }));
-        if (dynamicSections.some((it) => it.label === 'Error')) {
-            throw new Error('sections: test error');
+        if (dynamicSections.some((it) => it.label === "Error")) {
+            throw new Error("sections: test error");
         }
         return [
-            { type: 'link', href: '/loaders', label: 'Loaders' },
-            { type: 'link', href: '/', label: 'Icons/Masks' },
-            { type: 'link', href: '/state', label: 'State' },
-            { type: 'link', href: '/layout', label: 'Layout' },
-            { type: 'link', href: '/form-components', label: 'Form Components' },
-            { type: 'link', href: '/log-view', label: 'PlLogView' },
-            { type: 'link', href: '/modals', label: 'Modals' },
-            { type: 'link', href: '/select-files', label: 'Select Files' },
-            { type: 'link', href: '/inject-env', label: 'Inject env' },
-            { type: 'link', href: '/use-watch-fetch', label: 'useWatchFetch' },
-            { type: 'link', href: '/typography', label: 'Typography' },
-            { type: 'link', href: '/ag-grid-vue', label: 'AgGridVue' },
-            { type: 'link', href: '/ag-grid-vue-with-builder', label: 'AgGridVue with builder' },
-            { type: 'link', href: '/pl-annotations', label: 'PlAnnotations' },
-            { type: 'link', href: '/pl-ag-data-table-v2', label: 'PlAgDataTableV2' },
-            { type: 'link', href: '/pl-splash-page', label: 'PlSplashPage' },
-            { type: 'link', href: '/pl-file-input-page', label: 'PlFileInputPage' },
-            { type: 'link', href: '/pl-number-field-page', label: 'PlNumberFieldPage' },
-            { type: 'link', href: '/pl-error-boundary-page', label: 'PlErrorBoundaryPage' },
-            { type: 'link', href: '/pl-element-list-page', label: 'PlElementList' },
-            { type: 'link', href: '/text-fields', label: 'PlTextField' },
-            { type: 'link', href: '/tabs', label: 'PlTabs' },
-            { type: 'link', href: '/pl-autocomplete', label: 'PlAutocomplete' },
-            { type: 'link', href: '/radio', label: 'PlRadio' },
-            { type: 'link', href: '/stacked-bar', label: 'PlChartStackedBar' },
-            { type: 'link', href: '/histogram', label: 'PlChartHistogram' },
-            { type: 'link', href: '/buttons', label: 'ButtonsPage' },
-            { type: 'link', href: '/errors', label: 'Errors' },
-            { type: 'link', href: '/downloads', label: 'Downloads' },
-            { type: 'link', href: '/notifications', label: 'Notifications' },
-            { type: 'link', href: '/drafts', label: 'Drafts' },
-            { type: 'link', href: '/pl-autocomplete', label: 'PlAutocomplete' },
-            { type: 'link', href: '/pl-autocomplete-multi', label: 'PlAutocompleteMulti' },
-            { type: 'link', href: '/radio', label: 'PlRadio' },
-            { type: 'link', href: '/advanced-filter', label: 'PlAdvancedFilter' },
+            { type: "link", href: "/loaders", label: "Loaders" },
+            { type: "link", href: "/", label: "Icons/Masks" },
+            { type: "link", href: "/state", label: "State" },
+            { type: "link", href: "/layout", label: "Layout" },
+            { type: "link", href: "/form-components", label: "Form Components" },
+            { type: "link", href: "/log-view", label: "PlLogView" },
+            { type: "link", href: "/modals", label: "Modals" },
+            { type: "link", href: "/select-files", label: "Select Files" },
+            { type: "link", href: "/inject-env", label: "Inject env" },
+            { type: "link", href: "/use-watch-fetch", label: "useWatchFetch" },
+            { type: "link", href: "/typography", label: "Typography" },
+            { type: "link", href: "/ag-grid-vue", label: "AgGridVue" },
+            { type: "link", href: "/ag-grid-vue-with-builder", label: "AgGridVue with builder" },
+            { type: "link", href: "/pl-annotations", label: "PlAnnotations" },
+            { type: "link", href: "/pl-ag-data-table-v2", label: "PlAgDataTableV2" },
+            { type: "link", href: "/pl-splash-page", label: "PlSplashPage" },
+            { type: "link", href: "/pl-file-input-page", label: "PlFileInputPage" },
+            { type: "link", href: "/pl-number-field-page", label: "PlNumberFieldPage" },
+            { type: "link", href: "/pl-error-boundary-page", label: "PlErrorBoundaryPage" },
+            { type: "link", href: "/pl-element-list-page", label: "PlElementList" },
+            { type: "link", href: "/text-fields", label: "PlTextField" },
+            { type: "link", href: "/tabs", label: "PlTabs" },
+            { type: "link", href: "/pl-autocomplete", label: "PlAutocomplete" },
+            { type: "link", href: "/radio", label: "PlRadio" },
+            { type: "link", href: "/stacked-bar", label: "PlChartStackedBar" },
+            { type: "link", href: "/histogram", label: "PlChartHistogram" },
+            { type: "link", href: "/buttons", label: "ButtonsPage" },
+            { type: "link", href: "/errors", label: "Errors" },
+            { type: "link", href: "/downloads", label: "Downloads" },
+            { type: "link", href: "/notifications", label: "Notifications" },
+            { type: "link", href: "/drafts", label: "Drafts" },
+            { type: "link", href: "/pl-autocomplete", label: "PlAutocomplete" },
+            { type: "link", href: "/pl-autocomplete-multi", label: "PlAutocompleteMulti" },
+            { type: "link", href: "/radio", label: "PlRadio" },
+            { type: "link", href: "/advanced-filter", label: "PlAdvancedFilter" },
             ...(dynamicSections.length
-                ? [
-                    { type: 'delimiter' },
-                    ...dynamicSections,
-                    { type: 'delimiter' },
-                ]
+                ? [{ type: "delimiter" }, ...dynamicSections, { type: "delimiter" }]
                 : []),
             {
-                type: 'link',
-                href: '/add-section',
-                appearance: 'add-section',
-                label: 'New Dynamic section',
+                type: "link",
+                href: "/add-section",
+                appearance: "add-section",
+                label: "New Dynamic section",
             },
         ];
     })