@platforma-open/milaboratories.immune-assay-data.model 1.3.0 → 1.4.1

package/dist/bundle.js

@@ -1,17 +1,67 @@
 (function(global, factory) {
   typeof exports === "object" && typeof module !== "undefined" ? factory(exports) : typeof define === "function" && define.amd ? define(["exports"], factory) : (global = typeof globalThis !== "undefined" ? globalThis : global || self, factory(global.model = {}));
 })(this, function(exports2) {
-  "use strict";
+  "use strict";var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+  function getImmediate(value) {
+    return { type: "Immediate", value };
+  }
+  function isInUI() {
+    return typeof globalThis.getPlatforma !== "undefined" || typeof globalThis.platforma !== "undefined";
+  }
+  function getPlatformaInstance(config) {
+    if (config && typeof globalThis.getPlatforma === "function")
+      return globalThis.getPlatforma(config);
+    else if (typeof globalThis.platforma !== "undefined")
+      return globalThis.platforma;
+    else
+      throw new Error("Can't get platforma instance.");
+  }
+  function tryGetCfgRenderCtx() {
+    if (typeof globalThis.cfgRenderCtx !== "undefined")
+      return globalThis.cfgRenderCtx;
+    else
+      return void 0;
+  }
+  function getCfgRenderCtx() {
+    if (typeof globalThis.cfgRenderCtx !== "undefined")
+      return globalThis.cfgRenderCtx;
+    else
+      throw new Error("Not in config rendering context");
+  }
+  function tryRegisterCallback(key, callback) {
+    const ctx = tryGetCfgRenderCtx();
+    if (ctx === void 0)
+      return false;
+    if (key in ctx.callbackRegistry)
+      throw new Error(`Callback with key ${key} already registered.`);
+    ctx.callbackRegistry[key] = callback;
+    return true;
+  }
+  const futureResolves = /* @__PURE__ */ new Map();
+  function registerFutureAwait(handle, onResolve) {
+    if (!(handle in getCfgRenderCtx().callbackRegistry)) {
+      getCfgRenderCtx().callbackRegistry[handle] = (value) => {
+        for (const res of futureResolves.get(handle)) {
+          res(value);
+        }
+      };
+      futureResolves.set(handle, []);
+    }
+    futureResolves.get(handle).push(onResolve);
+  }
   var util;
   (function(util2) {
     util2.assertEqual = (val) => val;
     function assertIs(_arg) {
     }
     util2.assertIs = assertIs;
-    function assertNever(_x) {
+    function assertNever2(_x) {
       throw new Error();
     }
-    util2.assertNever = assertNever;
+    util2.assertNever = assertNever2;
     util2.arrayToEnum = (items) => {
       const obj = {};
       for (const item of items) {
@@ -20,10 +70,10 @@
       return obj;
     };
     util2.getValidEnumValues = (obj) => {
-      const validKeys = util2.objectKeys(obj).filter((k2) => typeof obj[obj[k2]] !== "number");
+      const validKeys = util2.objectKeys(obj).filter((k) => typeof obj[obj[k]] !== "number");
       const filtered = {};
-      for (const k2 of validKeys) {
-        filtered[k2] = obj[k2];
+      for (const k of validKeys) {
+        filtered[k] = obj[k];
       }
       return util2.objectValues(filtered);
     };
@@ -368,7 +418,7 @@
       };
     }
     let errorMessage = "";
-    const maps = errorMaps.filter((m2) => !!m2).slice().reverse();
+    const maps = errorMaps.filter((m) => !!m).slice().reverse();
     for (const map of maps) {
       errorMessage = map(fullIssue, { data, defaultError: errorMessage }).message;
     }
@@ -409,12 +459,12 @@
     }
     static mergeArray(status, results) {
       const arrayValue = [];
-      for (const s2 of results) {
-        if (s2.status === "aborted")
+      for (const s of results) {
+        if (s.status === "aborted")
           return INVALID;
-        if (s2.status === "dirty")
+        if (s.status === "dirty")
           status.dirty();
-        arrayValue.push(s2.value);
+        arrayValue.push(s.value);
       }
       return { status: status.value, value: arrayValue };
     }
@@ -458,11 +508,11 @@
   const isDirty = (x) => x.status === "dirty";
   const isValid = (x) => x.status === "valid";
   const isAsync = (x) => typeof Promise !== "undefined" && x instanceof Promise;
-  function __classPrivateFieldGet(receiver, state, kind, f2) {
+  function __classPrivateFieldGet(receiver, state, kind, f) {
     if (typeof state === "function" ? receiver !== state || true : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
     return state.get(receiver);
   }
-  function __classPrivateFieldSet(receiver, state, value, kind, f2) {
+  function __classPrivateFieldSet(receiver, state, value, kind, f) {
     if (typeof state === "function" ? receiver !== state || true : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
     return state.set(receiver, value), value;
   }
@@ -816,11 +866,11 @@
     regex = `${regex}(${opts.join("|")})`;
     return new RegExp(`^${regex}$`);
   }
-  function isValidIP(ip, version) {
-    if ((version === "v4" || !version) && ipv4Regex.test(ip)) {
+  function isValidIP(ip, version2) {
+    if ((version2 === "v4" || !version2) && ipv4Regex.test(ip)) {
       return true;
     }
-    if ((version === "v6" || !version) && ipv6Regex.test(ip)) {
+    if ((version2 === "v6" || !version2) && ipv6Regex.test(ip)) {
       return true;
     }
     return false;
@@ -3069,7 +3119,7 @@
         });
       }
       const params = { errorMap: ctx.common.contextualErrorMap };
-      const fn2 = ctx.data;
+      const fn = ctx.data;
       if (this._def.returns instanceof ZodPromise) {
         const me = this;
         return OK(async function(...args) {
@@ -3078,7 +3128,7 @@
             error.addIssue(makeArgsIssue(args, e));
             throw error;
           });
-          const result = await Reflect.apply(fn2, this, parsedArgs);
+          const result = await Reflect.apply(fn, this, parsedArgs);
           const parsedReturns = await me._def.returns._def.type.parseAsync(result, params).catch((e) => {
             error.addIssue(makeReturnsIssue(result, e));
             throw error;
@@ -3092,7 +3142,7 @@
           if (!parsedArgs.success) {
             throw new ZodError([makeArgsIssue(args, parsedArgs.error)]);
           }
-          const result = Reflect.apply(fn2, this, parsedArgs.data);
+          const result = Reflect.apply(fn, this, parsedArgs.data);
           const parsedReturns = me._def.returns.safeParse(result, params);
           if (!parsedReturns.success) {
             throw new ZodError([makeReturnsIssue(result, parsedReturns.error)]);
@@ -3697,10 +3747,10 @@
       return ZodAny.create().superRefine((data, ctx) => {
         var _a, _b;
         if (!check(data)) {
-          const p2 = typeof params === "function" ? params(data) : typeof params === "string" ? { message: params } : params;
-          const _fatal = (_b = (_a = p2.fatal) !== null && _a !== void 0 ? _a : fatal) !== null && _b !== void 0 ? _b : true;
-          const p22 = typeof p2 === "string" ? { message: p2 } : p2;
-          ctx.addIssue({ code: "custom", ...p22, fatal: _fatal });
+          const p = typeof params === "function" ? params(data) : typeof params === "string" ? { message: params } : params;
+          const _fatal = (_b = (_a = p.fatal) !== null && _a !== void 0 ? _a : fatal) !== null && _b !== void 0 ? _b : true;
+          const p2 = typeof p === "string" ? { message: p } : p;
+          ctx.addIssue({ code: "custom", ...p2, fatal: _fatal });
         }
       });
     return ZodAny.create();
@@ -3798,7 +3848,7 @@
     date: (arg) => ZodDate.create({ ...arg, coerce: true })
   };
   const NEVER = INVALID;
-  var z$1 = /* @__PURE__ */ Object.freeze({
+  var z = /* @__PURE__ */ Object.freeze({
     __proto__: null,
     defaultErrorMap: errorMap,
     setErrorMap,
@@ -3914,281 +3964,439 @@
     quotelessJson,
     ZodError
   });
-  function getDefaultExportFromCjs(x) {
-    return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x;
-  }
-  var canonicalize;
-  var hasRequiredCanonicalize;
-  function requireCanonicalize() {
-    if (hasRequiredCanonicalize) return canonicalize;
-    hasRequiredCanonicalize = 1;
-    canonicalize = function serialize(object) {
-      if (typeof object === "number" && isNaN(object)) {
-        throw new Error("NaN is not allowed");
-      }
-      if (typeof object === "number" && !isFinite(object)) {
-        throw new Error("Infinity is not allowed");
-      }
-      if (object === null || typeof object !== "object") {
-        return JSON.stringify(object);
-      }
-      if (object.toJSON instanceof Function) {
-        return serialize(object.toJSON());
-      }
-      if (Array.isArray(object)) {
-        const values2 = object.reduce((t, cv, ci) => {
-          const comma = ci === 0 ? "" : ",";
-          const value = cv === void 0 || typeof cv === "symbol" ? null : cv;
-          return `${t}${comma}${serialize(value)}`;
-        }, "");
-        return `[${values2}]`;
-      }
-      const values = Object.keys(object).sort().reduce((t, cv) => {
-        if (object[cv] === void 0 || typeof object[cv] === "symbol") {
-          return t;
-        }
-        const comma = t.length === 0 ? "" : ",";
-        return `${t}${comma}${serialize(cv)}:${serialize(object[cv])}`;
-      }, "");
-      return `{${values}}`;
-    };
-    return canonicalize;
-  }
-  var canonicalizeExports = requireCanonicalize();
-  const Re = /* @__PURE__ */ getDefaultExportFromCjs(canonicalizeExports);
-  var B$1 = Object.defineProperty;
-  var j = (n2, e, t) => e in n2 ? B$1(n2, e, { enumerable: true, configurable: true, writable: true, value: t }) : n2[e] = t;
-  var l$1 = (n2, e, t) => j(n2, typeof e != "symbol" ? e + "" : e, t);
-  z$1.object({
+  z.object({
     /** Included left border. */
-    from: z$1.number(),
+    from: z.number().min(0),
     /** Excluded right border. */
-    to: z$1.number()
+    to: z.number().min(1)
   });
-  function w(n2) {
-    throw new Error("Unexpected object: " + n2);
+  function assertNever(x) {
+    throw new Error("Unexpected object: " + x);
+  }
+  function uniqueBy(array, makeId) {
+    return [...new Map(array.map((e) => [makeId(e), e])).values()];
   }
-  function En(n2) {
-    if (!n2 || typeof n2 != "object")
+  function isDataInfo(value) {
+    if (!value || typeof value !== "object") {
       return false;
-    const e = n2;
-    if (!("type" in e))
+    }
+    const data = value;
+    if (!("type" in data)) {
       return false;
-    switch (e.type) {
+    }
+    switch (data.type) {
       case "Json":
-        return typeof e.keyLength == "number" && e.data !== void 0 && typeof e.data == "object";
+        return typeof data.keyLength === "number" && data.data !== void 0 && typeof data.data === "object";
       case "JsonPartitioned":
-        return typeof e.partitionKeyLength == "number" && e.parts !== void 0 && typeof e.parts == "object";
       case "BinaryPartitioned":
-        return typeof e.partitionKeyLength == "number" && e.parts !== void 0 && typeof e.parts == "object";
+      case "ParquetPartitioned":
+        return typeof data.partitionKeyLength === "number" && data.parts !== void 0 && typeof data.parts === "object";
       default:
         return false;
     }
   }
-  function Nn(n2, e) {
-    if (n2 !== void 0)
-      switch (n2.type) {
-        case "Json":
-          return n2;
-        case "JsonPartitioned": {
-          const t = {};
-          for (const [r, o] of Object.entries(n2.parts))
-            t[r] = e(o);
-          return {
-            ...n2,
-            parts: t
-          };
+  function mapDataInfo(dataInfo, mapFn) {
+    if (dataInfo === void 0) {
+      return void 0;
+    }
+    switch (dataInfo.type) {
+      case "Json":
+        return dataInfo;
+      case "JsonPartitioned": {
+        const newParts = {};
+        for (const [key, blob] of Object.entries(dataInfo.parts)) {
+          newParts[key] = mapFn(blob);
         }
-        case "BinaryPartitioned": {
-          const t = {};
-          for (const [r, o] of Object.entries(n2.parts))
-            t[r] = {
-              index: e(o.index),
-              values: e(o.values)
-            };
-          return {
-            ...n2,
-            parts: t
+        return {
+          ...dataInfo,
+          parts: newParts
+        };
+      }
+      case "BinaryPartitioned": {
+        const newParts = {};
+        for (const [key, chunk] of Object.entries(dataInfo.parts)) {
+          newParts[key] = {
+            index: mapFn(chunk.index),
+            values: mapFn(chunk.values)
           };
         }
+        return {
+          ...dataInfo,
+          parts: newParts
+        };
       }
+      case "ParquetPartitioned": {
+        const newParts = {};
+        for (const [key, blob] of Object.entries(dataInfo.parts)) {
+          newParts[key] = mapFn(blob);
+        }
+        return {
+          ...dataInfo,
+          parts: newParts
+        };
+      }
+    }
   }
-  function K(n2) {
-    if (!n2 || typeof n2 != "object")
+  function isDataInfoEntries(value) {
+    if (!value || typeof value !== "object") {
       return false;
-    const e = n2;
-    if (!("type" in e))
+    }
+    const data = value;
+    if (!("type" in data)) {
       return false;
-    switch (e.type) {
+    }
+    switch (data.type) {
       case "Json":
-        return typeof e.keyLength == "number" && Array.isArray(e.data);
+        return typeof data.keyLength === "number" && Array.isArray(data.data);
       case "JsonPartitioned":
-        return typeof e.partitionKeyLength == "number" && Array.isArray(e.parts);
       case "BinaryPartitioned":
-        return typeof e.partitionKeyLength == "number" && Array.isArray(e.parts);
+      case "ParquetPartitioned":
+        return typeof data.partitionKeyLength === "number" && Array.isArray(data.parts);
       default:
         return false;
     }
   }
-  function Sn(n2) {
-    return K(n2) ? n2.type === "JsonPartitioned" || n2.type === "BinaryPartitioned" : false;
+  function isPartitionedDataInfoEntries(value) {
+    if (!isDataInfoEntries(value))
+      return false;
+    switch (value.type) {
+      case "JsonPartitioned":
+      case "BinaryPartitioned":
+      case "ParquetPartitioned":
+        return true;
+      default:
+        return false;
+    }
   }
-  function Cn(n2) {
-    switch (n2.type) {
-      case "Json": {
-        const e = Object.entries(n2.data).map(([t, r]) => ({ key: JSON.parse(t), value: r }));
+  function dataInfoToEntries(dataInfo) {
+    switch (dataInfo.type) {
+      case "Json":
         return {
           type: "Json",
-          keyLength: n2.keyLength,
-          data: e
+          keyLength: dataInfo.keyLength,
+          data: Object.entries(dataInfo.data).map(([keyStr, value]) => {
+            const key = JSON.parse(keyStr);
+            return { key, value };
+          })
         };
-      }
-      case "JsonPartitioned": {
-        const e = Object.entries(n2.parts).map(([t, r]) => ({ key: JSON.parse(t), value: r }));
+      case "JsonPartitioned":
         return {
           type: "JsonPartitioned",
-          partitionKeyLength: n2.partitionKeyLength,
-          parts: e
+          partitionKeyLength: dataInfo.partitionKeyLength,
+          parts: Object.entries(dataInfo.parts).map(([keyStr, blob]) => {
+            const key = JSON.parse(keyStr);
+            return { key, value: blob };
+          })
         };
-      }
-      case "BinaryPartitioned": {
-        const e = Object.entries(n2.parts).map(([t, r]) => ({ key: JSON.parse(t), value: r }));
+      case "BinaryPartitioned":
         return {
           type: "BinaryPartitioned",
-          partitionKeyLength: n2.partitionKeyLength,
-          parts: e
+          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);
     }
   }
-  function Jn(n2) {
-    switch (n2.type) {
-      case "Json": {
-        const e = {};
-        for (const t of n2.data)
-          e[JSON.stringify(t.key)] = t.value;
+  function entriesToDataInfo(dataInfoEntries) {
+    switch (dataInfoEntries.type) {
+      case "Json":
         return {
           type: "Json",
-          keyLength: n2.keyLength,
-          data: e
+          keyLength: dataInfoEntries.keyLength,
+          data: Object.fromEntries(dataInfoEntries.data.map(({ key, value }) => [JSON.stringify(key), value]))
         };
-      }
-      case "JsonPartitioned": {
-        const e = {};
-        for (const t of n2.parts)
-          e[JSON.stringify(t.key)] = t.value;
+      case "JsonPartitioned":
         return {
           type: "JsonPartitioned",
-          partitionKeyLength: n2.partitionKeyLength,
-          parts: e
+          partitionKeyLength: dataInfoEntries.partitionKeyLength,
+          parts: Object.fromEntries(dataInfoEntries.parts.map(({ key, value }) => [JSON.stringify(key), value]))
         };
-      }
-      case "BinaryPartitioned": {
-        const e = {};
-        for (const t of n2.parts)
-          e[JSON.stringify(t.key)] = t.value;
+      case "BinaryPartitioned":
         return {
           type: "BinaryPartitioned",
-          partitionKeyLength: n2.partitionKeyLength,
-          parts: e
+          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);
+    }
+  }
+  function stringifyValue(value) {
+    if (typeof value === "string") {
+      return `String value was thrown: ${value}`;
+    }
+    if (value && typeof value === "object") {
+      try {
+        return `Plain object was thrown: ${JSON.stringify(value)}`;
+      } catch (jsonError) {
+        const errorMessage = jsonError instanceof Error ? jsonError.message : String(jsonError);
+        return `Non-serializable object was thrown (JSON.stringify failed: ${errorMessage}): ${String(value)}`;
       }
     }
+    return String(`Non-Error value (${typeof value}) was thrown: ${value}`);
   }
-  function Fn(n2) {
+  function ensureError(value) {
+    if (value instanceof Error) {
+      return value;
+    }
+    return new Error(stringifyValue(value));
+  }
+  function getDefaultExportFromCjs(x) {
+    return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x;
+  }
+  var canonicalize$1;
+  var hasRequiredCanonicalize;
+  function requireCanonicalize() {
+    if (hasRequiredCanonicalize) return canonicalize$1;
+    hasRequiredCanonicalize = 1;
+    canonicalize$1 = function serialize(object) {
+      if (typeof object === "number" && isNaN(object)) {
+        throw new Error("NaN is not allowed");
+      }
+      if (typeof object === "number" && !isFinite(object)) {
+        throw new Error("Infinity is not allowed");
+      }
+      if (object === null || typeof object !== "object") {
+        return JSON.stringify(object);
+      }
+      if (object.toJSON instanceof Function) {
+        return serialize(object.toJSON());
+      }
+      if (Array.isArray(object)) {
+        const values2 = object.reduce((t, cv, ci) => {
+          const comma = ci === 0 ? "" : ",";
+          const value = cv === void 0 || typeof cv === "symbol" ? null : cv;
+          return `${t}${comma}${serialize(value)}`;
+        }, "");
+        return `[${values2}]`;
+      }
+      const values = Object.keys(object).sort().reduce((t, cv) => {
+        if (object[cv] === void 0 || typeof object[cv] === "symbol") {
+          return t;
+        }
+        const comma = t.length === 0 ? "" : ",";
+        return `${t}${comma}${serialize(cv)}:${serialize(object[cv])}`;
+      }, "");
+      return `{${values}}`;
+    };
+    return canonicalize$1;
+  }
+  var canonicalizeExports = requireCanonicalize();
+  const canonicalize = /* @__PURE__ */ getDefaultExportFromCjs(canonicalizeExports);
+  function canonicalizeJson(value) {
+    return canonicalize(value);
+  }
+  function parseJson(value) {
+    return JSON.parse(value);
+  }
+  function readMetadata(metadata, key) {
+    return metadata == null ? void 0 : metadata[key];
+  }
+  function readMetadataJsonOrThrow(metadata, metadataJson, key, methodNameInError = "readMetadataJsonOrThrow") {
+    const json = readMetadata(metadata, key);
+    if (json === void 0)
+      return void 0;
+    const schema = metadataJson[key];
+    try {
+      const value = JSON.parse(json);
+      return schema.parse(value);
+    } catch (error) {
+      throw new Error(`${methodNameInError} failed, key: ${String(key)}, value: ${json}, error: ${ensureError(error)}`);
+    }
+  }
+  function readMetadataJson(metadata, metadataJson, key) {
+    try {
+      return readMetadataJsonOrThrow(metadata, metadataJson, key);
+    } catch {
+      return void 0;
+    }
+  }
+  const Annotation = {
+    DiscreteValues: "pl7.app/discreteValues",
+    Graph: {
+      IsVirtual: "pl7.app/graph/isVirtual"
+    },
+    HideDataFromUi: "pl7.app/hideDataFromUi",
+    HideDataFromGraphs: "pl7.app/hideDataFromGraphs",
+    IsLinkerColumn: "pl7.app/isLinkerColumn",
+    Label: "pl7.app/label",
+    Max: "pl7.app/max",
+    Min: "pl7.app/min",
+    Parents: "pl7.app/parents",
+    Sequence: {
+      Annotation: {
+        Mapping: "pl7.app/sequence/annotation/mapping"
+      },
+      IsAnnotation: "pl7.app/sequence/isAnnotation"
+    },
+    Table: {
+      OrderPriority: "pl7.app/table/orderPriority",
+      Visibility: "pl7.app/table/visibility"
+    },
+    Trace: "pl7.app/trace"
+  };
+  const AnnotationJson = {
+    [Annotation.DiscreteValues]: z.array(z.string()).or(z.array(z.number())),
+    [Annotation.Graph.IsVirtual]: z.boolean(),
+    [Annotation.HideDataFromUi]: z.boolean(),
+    [Annotation.HideDataFromGraphs]: z.boolean(),
+    [Annotation.IsLinkerColumn]: z.boolean(),
+    [Annotation.Max]: z.number(),
+    [Annotation.Min]: z.number(),
+    [Annotation.Parents]: z.array(z.string()),
+    [Annotation.Sequence.Annotation.Mapping]: z.record(z.string(), z.string()),
+    [Annotation.Sequence.IsAnnotation]: z.boolean(),
+    [Annotation.Table.OrderPriority]: z.number(),
+    [Annotation.Trace]: z.record(z.string(), z.unknown())
+  };
+  function readAnnotation(spec, key) {
+    return readMetadata(spec == null ? void 0 : spec.annotations, key);
+  }
+  function readAnnotationJson(spec, key) {
+    return readMetadataJson(spec == null ? void 0 : spec.annotations, AnnotationJson, key);
+  }
+  const PColumnName = {
+    Label: "pl7.app/label"
+  };
+  function getColumnIdAndSpec(column) {
     return {
-      columnId: n2.id,
-      spec: n2.spec
+      columnId: column.id,
+      spec: column.spec
     };
   }
-  function p$1(n2) {
-    const { type: e, name: t, domain: r } = n2, o = { type: e, name: t };
-    return r && Object.entries(r).length > 0 && Object.assign(o, { domain: r }), o;
+  function getAxisId(spec) {
+    const { type, name, domain } = spec;
+    const result = { type, name };
+    if (domain && Object.entries(domain).length > 0) {
+      Object.assign(result, { domain });
+    }
+    return result;
   }
-  function J(n2) {
-    return n2.map(p$1);
+  function getAxesId(spec) {
+    return spec.map(getAxisId);
   }
-  function Rn(n2) {
-    return Re(p$1(n2));
+  function canonicalizeAxisId(id) {
+    return canonicalizeJson(getAxisId(id));
   }
-  function Y$1(n2, e) {
-    if (n2 === void 0) return e === void 0;
-    if (e === void 0) return true;
-    for (const t in e)
-      if (n2[t] !== e[t]) return false;
+  function matchDomain$1(query, target) {
+    if (query === void 0)
+      return target === void 0;
+    if (target === void 0)
+      return true;
+    for (const k in target) {
+      if (query[k] !== target[k])
+        return false;
+    }
     return true;
   }
-  function Z$1(n2, e) {
-    return n2.name === e.name && Y$1(n2.domain, e.domain);
+  function matchAxisId(query, target) {
+    return query.name === target.name && matchDomain$1(query.domain, target.domain);
   }
-  function Un(n2, e) {
-    return { ...n2, src: h(n2.src, e) };
+  function mapPTableDef(def, cb) {
+    return { ...def, src: mapJoinEntry(def.src, cb) };
   }
-  function h(n2, e) {
-    switch (n2.type) {
+  function mapJoinEntry(entry, cb) {
+    switch (entry.type) {
       case "column":
         return {
           type: "column",
-          column: e(n2.column)
+          column: cb(entry.column)
         };
       case "slicedColumn":
         return {
           type: "slicedColumn",
-          column: e(n2.column),
-          newId: n2.newId,
-          axisFilters: n2.axisFilters
+          column: cb(entry.column),
+          newId: entry.newId,
+          axisFilters: entry.axisFilters
+        };
+      case "artificialColumn":
+        return {
+          type: "artificialColumn",
+          column: cb(entry.column),
+          newId: entry.newId,
+          axesIndices: entry.axesIndices
         };
       case "inlineColumn":
-        return n2;
+        return entry;
       case "inner":
       case "full":
         return {
-          type: n2.type,
-          entries: n2.entries.map((t) => h(t, e))
+          type: entry.type,
+          entries: entry.entries.map((col) => mapJoinEntry(col, cb))
         };
       case "outer":
         return {
           type: "outer",
-          primary: h(n2.primary, e),
-          secondary: n2.secondary.map((t) => h(t, e))
+          primary: mapJoinEntry(entry.primary, cb),
+          secondary: entry.secondary.map((col) => mapJoinEntry(col, cb))
         };
       default:
-        w(n2);
+        assertNever(entry);
     }
   }
-  function nn(n2) {
-    return Re(n2);
+  function stringifyColumnId(id) {
+    return canonicalize(id);
   }
-  function P(n2) {
-    return Re(p$1(n2));
+  function axisKey(axis) {
+    return canonicalize(getAxisId(axis));
   }
-  function k$1(n2, e) {
-    return JSON.stringify([n2, e]);
+  function domainKey(key, value) {
+    return JSON.stringify([key, value]);
   }
-  class _n {
+  class AnchoredIdDeriver {
     /**
      * Creates a new anchor context from a set of anchor column specifications
      * @param anchors Record of anchor column specifications indexed by anchor ID
      */
-    constructor(e) {
-      l$1(this, "domains", /* @__PURE__ */ new Map());
-      l$1(this, "axes", /* @__PURE__ */ new Map());
-      l$1(this, "domainPacks", []);
-      l$1(this, "domainPackToAnchor", /* @__PURE__ */ new Map());
-      this.anchors = e;
-      const t = Object.entries(e);
-      t.sort((r, o) => r[0].localeCompare(o[0]));
-      for (const [r, o] of t) {
-        for (let s2 = 0; s2 < o.axesSpec.length; s2++) {
-          const a = o.axesSpec[s2], i = P(a);
-          this.axes.set(i, { anchor: r, idx: s2 });
+    constructor(anchors) {
+      __publicField(this, "anchors");
+      __publicField(this, "domains", /* @__PURE__ */ new Map());
+      __publicField(this, "axes", /* @__PURE__ */ new Map());
+      /**
+       * Domain packs are used to group domain keys that can be anchored to the same anchor
+       * This is used to optimize the lookup of domain anchors
+       */
+      __publicField(this, "domainPacks", []);
+      /**
+       * Maps domain packs to anchors
+       */
+      __publicField(this, "domainPackToAnchor", /* @__PURE__ */ new Map());
+      this.anchors = anchors;
+      const anchorEntries = Object.entries(anchors);
+      anchorEntries.sort((a, b) => a[0].localeCompare(b[0]));
+      for (const [anchorId, spec] of anchorEntries) {
+        for (let axisIdx = 0; axisIdx < spec.axesSpec.length; axisIdx++) {
+          const axis = spec.axesSpec[axisIdx];
+          const key = axisKey(axis);
+          this.axes.set(key, { anchor: anchorId, idx: axisIdx });
         }
-        if (o.domain !== void 0) {
-          const s2 = Object.entries(o.domain);
-          s2.sort((a, i) => a[0].localeCompare(i[0])), this.domainPackToAnchor.set(JSON.stringify(s2), r), this.domainPacks.push(s2.map(([a]) => a));
-          for (const [a, i] of s2) {
-            const u2 = k$1(a, i);
-            this.domains.set(u2, r);
+        if (spec.domain !== void 0) {
+          const domainEntries = Object.entries(spec.domain);
+          domainEntries.sort((a, b) => a[0].localeCompare(b[0]));
+          this.domainPackToAnchor.set(JSON.stringify(domainEntries), anchorId);
+          this.domainPacks.push(domainEntries.map(([dKey]) => dKey));
+          for (const [dKey, dValue] of domainEntries) {
+            const key = domainKey(dKey, dValue);
+            this.domains.set(key, anchorId);
           }
         }
       }
@@ -4196,57 +4404,69 @@
     /**
      * Implementation of derive method
      */
-    derive(e, t) {
-      const r = {
-        name: e.name,
+    derive(spec, axisFilters) {
+      const result = {
+        name: spec.name,
         axes: []
       };
-      let o;
-      if (e.domain !== void 0)
-        n:
-          for (const a of this.domainPacks) {
-            const i = [];
-            for (const c2 of a) {
-              const m2 = e.domain[c2];
-              if (m2 !== void 0)
-                i.push([c2, m2]);
-              else
-                break n;
-            }
-            const u2 = this.domainPackToAnchor.get(JSON.stringify(i));
-            if (u2 !== void 0) {
-              r.domainAnchor = u2, o = new Set(a);
-              break;
-            }
+      let skipDomains = void 0;
+      if (spec.domain !== void 0) {
+        outer: for (const domainPack of this.domainPacks) {
+          const dAnchor = [];
+          for (const domainKey2 of domainPack) {
+            const dValue = spec.domain[domainKey2];
+            if (dValue !== void 0)
+              dAnchor.push([domainKey2, dValue]);
+            else
+              break outer;
+          }
+          const domainAnchor = this.domainPackToAnchor.get(JSON.stringify(dAnchor));
+          if (domainAnchor !== void 0) {
+            result.domainAnchor = domainAnchor;
+            skipDomains = new Set(domainPack);
+            break;
           }
-      for (const [a, i] of Object.entries(e.domain ?? {})) {
-        if (o !== void 0 && o.has(a))
+        }
+      }
+      for (const [dKey, dValue] of Object.entries(spec.domain ?? {})) {
+        if (skipDomains !== void 0 && skipDomains.has(dKey))
           continue;
-        const u2 = k$1(a, i), c2 = this.domains.get(u2);
-        r.domain ?? (r.domain = {}), r.domain[a] = c2 ? { anchor: c2 } : i;
-      }
-      if (r.axes = e.axesSpec.map((a) => {
-        const i = P(a), u2 = this.axes.get(i);
-        return u2 === void 0 ? p$1(a) : u2;
-      }), !t || t.length === 0)
-        return r;
-      const s2 = [];
-      for (const a of t) {
-        const [i, u2] = a;
-        if (typeof i == "number") {
-          if (i < 0 || i >= e.axesSpec.length)
-            throw new Error(`Axis index ${i} is out of bounds (0-${e.axesSpec.length - 1})`);
-          s2.push([i, u2]);
+        const key = domainKey(dKey, dValue);
+        const anchorId = this.domains.get(key);
+        result.domain ?? (result.domain = {});
+        result.domain[dKey] = anchorId ? { anchor: anchorId } : dValue;
+      }
+      result.axes = spec.axesSpec.map((axis) => {
+        const key = axisKey(axis);
+        const anchorAxisRef = this.axes.get(key);
+        if (anchorAxisRef === void 0)
+          return getAxisId(axis);
+        else
+          return anchorAxisRef;
+      });
+      if (!axisFilters || axisFilters.length === 0) {
+        return result;
+      }
+      const resolvedFilters = [];
+      for (const filter of axisFilters) {
+        const [axisIdOrIndex, value] = filter;
+        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})`);
+          }
+          resolvedFilters.push([axisIdOrIndex, value]);
         } else {
-          const c2 = e.axesSpec.findIndex((m2) => m2.name === i);
-          if (c2 === -1)
-            throw new Error(`Axis with name "${i}" not found in the column specification`);
-          s2.push([c2, u2]);
+          const axisIndex = spec.axesSpec.findIndex((axis) => axis.name === axisIdOrIndex);
+          if (axisIndex === -1) {
+            throw new Error(`Axis with name "${axisIdOrIndex}" not found in the column specification`);
+          }
+          resolvedFilters.push([axisIndex, value]);
         }
       }
-      return s2.sort((a, i) => a[0] - i[0]), {
-        source: r,
-        axisFilters: s2
+      resolvedFilters.sort((a, b) => a[0] - b[0]);
+      return {
+        source: result,
+        axisFilters: resolvedFilters
       };
     }
     /**
@@ -4255,467 +4475,389 @@
      * @param axisFilters Optional axis filters to apply to the column
      * @returns A canonicalized string representation of the anchored column identifier
      */
-    deriveS(e, t) {
-      return nn(this.derive(e, t));
-    }
-  }
-  function Mn(n2, e, t) {
-    const r = { ...e }, o = (t == null ? void 0 : t.ignoreMissingDomains) ?? false;
-    if (r.domainAnchor !== void 0) {
-      const s2 = n2[r.domainAnchor];
-      if (!s2)
-        throw new Error(`Anchor "${r.domainAnchor}" not found`);
-      const a = s2.domain || {};
-      r.domain = { ...a, ...r.domain }, delete r.domainAnchor;
-    }
-    if (r.domain) {
-      const s2 = {};
-      for (const [a, i] of Object.entries(r.domain))
-        if (typeof i == "string")
-          s2[a] = i;
-        else {
-          const u2 = n2[i.anchor];
-          if (!u2)
-            throw new Error(`Anchor "${i.anchor}" not found for domain key "${a}"`);
-          if (!u2.domain || u2.domain[a] === void 0) {
-            if (!o)
-              throw new Error(`Domain key "${a}" not found in anchor "${i.anchor}"`);
+    deriveS(spec, axisFilters) {
+      return stringifyColumnId(this.derive(spec, axisFilters));
+    }
+  }
+  function resolveAnchors(anchors, matcher, options) {
+    const result = { ...matcher };
+    const ignoreMissingDomains = (options == null ? void 0 : options.ignoreMissingDomains) ?? false;
+    if (result.domainAnchor !== void 0) {
+      const anchorSpec = anchors[result.domainAnchor];
+      if (!anchorSpec)
+        throw new Error(`Anchor "${result.domainAnchor}" not found`);
+      const anchorDomains = anchorSpec.domain || {};
+      result.domain = { ...anchorDomains, ...result.domain };
+      delete result.domainAnchor;
+    }
+    if (result.domain) {
+      const resolvedDomain = {};
+      for (const [key, value] of Object.entries(result.domain)) {
+        if (typeof value === "string") {
+          resolvedDomain[key] = value;
+        } else {
+          const anchorSpec = anchors[value.anchor];
+          if (!anchorSpec)
+            throw new Error(`Anchor "${value.anchor}" not found for domain key "${key}"`);
+          if (!anchorSpec.domain || anchorSpec.domain[key] === void 0) {
+            if (!ignoreMissingDomains)
+              throw new Error(`Domain key "${key}" not found in anchor "${value.anchor}"`);
             continue;
           }
-          s2[a] = u2.domain[a];
+          resolvedDomain[key] = anchorSpec.domain[key];
         }
-      r.domain = s2;
-    }
-    return r.axes && (r.axes = r.axes.map((s2) => en(n2, s2))), r;
-  }
-  function en(n2, e) {
-    if (!tn(e))
-      return e;
-    const t = e.anchor, r = n2[t];
-    if (!r)
-      throw new Error(`Anchor "${t}" not found for axis reference`);
-    if ("idx" in e) {
-      if (e.idx < 0 || e.idx >= r.axesSpec.length)
-        throw new Error(`Axis index ${e.idx} out of bounds for anchor "${t}"`);
-      return r.axesSpec[e.idx];
-    } else if ("name" in e) {
-      const o = r.axesSpec.filter((s2) => s2.name === e.name);
-      if (o.length > 1)
-        throw new Error(`Multiple axes with name "${e.name}" found in anchor "${t}"`);
-      if (o.length === 0)
-        throw new Error(`Axis with name "${e.name}" not found in anchor "${t}"`);
-      return o[0];
-    } else if ("id" in e) {
-      const o = r.axesSpec.filter((s2) => Z$1(e.id, p$1(s2)));
-      if (o.length > 1)
-        throw new Error(`Multiple matching axes found for matcher in anchor "${t}"`);
-      if (o.length === 0)
-        throw new Error(`No matching axis found for matcher in anchor "${t}"`);
-      return o[0];
-    }
-    throw new Error("Unsupported axis reference type");
-  }
-  function tn(n2) {
-    return typeof n2 == "object" && "anchor" in n2;
-  }
-  function f(n2) {
-    return n2.kind === "PColumn";
-  }
-  function rn(n2) {
-    return f(n2.spec);
-  }
-  function qn(n2) {
-    if (!rn(n2)) throw new Error(`not a PColumn (kind = ${n2.spec.kind})`);
-    return n2;
-  }
-  function Wn(n2, e) {
-    return n2 === void 0 ? void 0 : {
-      ...n2,
-      data: e(n2.data)
+      }
+      result.domain = resolvedDomain;
+    }
+    if (result.axes)
+      result.axes = result.axes.map((axis) => resolveAxisReference(anchors, axis));
+    return result;
+  }
+  function resolveAxisReference(anchors, axisRef) {
+    if (!isAnchorAxisRef(axisRef))
+      return axisRef;
+    const anchorId = axisRef.anchor;
+    const anchorSpec = anchors[anchorId];
+    if (!anchorSpec)
+      throw new Error(`Anchor "${anchorId}" not found for axis reference`);
+    if ("idx" in axisRef) {
+      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) {
+      const matches = anchorSpec.axesSpec.filter((axis) => axis.name === axisRef.name);
+      if (matches.length > 1)
+        throw new Error(`Multiple axes with name "${axisRef.name}" found in anchor "${anchorId}"`);
+      if (matches.length === 0)
+        throw new Error(`Axis with name "${axisRef.name}" not found in anchor "${anchorId}"`);
+      return matches[0];
+    } else if ("id" in axisRef) {
+      const matches = anchorSpec.axesSpec.filter((axis) => matchAxisId(axisRef.id, getAxisId(axis)));
+      if (matches.length > 1)
+        throw new Error(`Multiple matching axes found for matcher in anchor "${anchorId}"`);
+      if (matches.length === 0)
+        throw new Error(`No matching axis found for matcher in anchor "${anchorId}"`);
+      return matches[0];
+    }
+    throw new Error(`Unsupported axis reference type`);
+  }
+  function isAnchorAxisRef(value) {
+    return typeof value === "object" && "anchor" in value;
+  }
+  function isPColumnSpec(spec) {
+    return spec.kind === "PColumn";
+  }
+  function isPColumn(obj) {
+    return isPColumnSpec(obj.spec);
+  }
+  function ensurePColumn(obj) {
+    if (!isPColumn(obj))
+      throw new Error(`not a PColumn (kind = ${obj.spec.kind})`);
+    return obj;
+  }
+  function mapPObjectData(pObj, cb) {
+    return pObj === void 0 ? void 0 : {
+      ...pObj,
+      data: cb(pObj.data)
     };
   }
-  function Xn(n2) {
-    const e = /* @__PURE__ */ new Map(), t = (r) => {
-      switch (r.type) {
+  function extractAllColumns(entry) {
+    const columns = /* @__PURE__ */ new Map();
+    const addAllColumns = (entry2) => {
+      switch (entry2.type) {
         case "column":
-          e.set(r.column.id, r.column);
+          columns.set(entry2.column.id, entry2.column);
           return;
         case "slicedColumn":
-          e.set(r.column.id, r.column);
+          columns.set(entry2.column.id, entry2.column);
+          return;
+        case "artificialColumn":
+          columns.set(entry2.column.id, entry2.column);
           return;
         case "inlineColumn":
           return;
         case "full":
         case "inner":
-          for (const o of r.entries) t(o);
+          for (const e of entry2.entries)
+            addAllColumns(e);
           return;
         case "outer":
-          t(r.primary);
-          for (const o of r.secondary) t(o);
+          addAllColumns(entry2.primary);
+          for (const e of entry2.secondary)
+            addAllColumns(e);
           return;
         default:
-          w(r);
+          assertNever(entry2);
       }
     };
-    return t(n2), [...e.values()];
+    addAllColumns(entry);
+    return [...columns.values()];
   }
-  function E$1(n2, e) {
-    if (n2.name !== void 0 && n2.name !== e.name)
+  function matchAxis(selector, axis) {
+    if (selector.name !== void 0 && selector.name !== axis.name)
       return false;
-    if (n2.type !== void 0) {
-      if (Array.isArray(n2.type)) {
-        if (!n2.type.includes(e.type))
+    if (selector.type !== void 0) {
+      if (Array.isArray(selector.type)) {
+        if (!selector.type.includes(axis.type))
           return false;
-      } else if (n2.type !== e.type)
+      } else if (selector.type !== axis.type) {
         return false;
+      }
     }
-    if (n2.domain !== void 0) {
-      const t = e.domain || {};
-      for (const [r, o] of Object.entries(n2.domain))
-        if (t[r] !== o)
+    if (selector.domain !== void 0) {
+      const axisDomain = axis.domain || {};
+      for (const [key, value] of Object.entries(selector.domain))
+        if (axisDomain[key] !== value)
           return false;
     }
     return true;
   }
-  function N(n2, e) {
-    if (e.name !== void 0 && n2.name !== e.name || e.namePattern !== void 0 && !new RegExp(e.namePattern).test(n2.name))
+  function matchPColumn(pcolumn, selector) {
+    if (selector.name !== void 0 && pcolumn.name !== selector.name)
       return false;
-    if (e.type !== void 0) {
-      if (Array.isArray(e.type)) {
-        if (!e.type.includes(n2.valueType))
+    if (selector.namePattern !== void 0 && !new RegExp(selector.namePattern).test(pcolumn.name))
+      return false;
+    if (selector.type !== void 0) {
+      if (Array.isArray(selector.type)) {
+        if (!selector.type.includes(pcolumn.valueType))
           return false;
-      } else if (e.type !== n2.valueType)
+      } else if (selector.type !== pcolumn.valueType) {
         return false;
+      }
     }
-    if (e.domain !== void 0) {
-      const t = n2.domain || {};
-      for (const [r, o] of Object.entries(e.domain))
-        if (t[r] !== o)
+    if (selector.domain !== void 0) {
+      const columnDomain = pcolumn.domain || {};
+      for (const [key, value] of Object.entries(selector.domain))
+        if (columnDomain[key] !== value)
           return false;
     }
-    if (e.axes !== void 0) {
-      const t = n2.axesSpec.map(p$1);
-      if (e.partialAxesMatch) {
-        for (const r of e.axes)
-          if (!t.some((o) => E$1(r, o)))
+    if (selector.axes !== void 0) {
+      const pcolumnAxes = pcolumn.axesSpec.map(getAxisId);
+      if (selector.partialAxesMatch) {
+        for (const selectorAxis of selector.axes)
+          if (!pcolumnAxes.some((columnAxis) => matchAxis(selectorAxis, columnAxis)))
             return false;
       } else {
-        if (t.length !== e.axes.length)
+        if (pcolumnAxes.length !== selector.axes.length)
           return false;
-        for (let r = 0; r < e.axes.length; r++)
-          if (!E$1(e.axes[r], t[r]))
+        for (let i = 0; i < selector.axes.length; i++)
+          if (!matchAxis(selector.axes[i], pcolumnAxes[i]))
             return false;
       }
     }
-    if (e.annotations !== void 0) {
-      const t = n2.annotations || {};
-      for (const [r, o] of Object.entries(e.annotations))
-        if (t[r] !== o)
+    if (selector.annotations !== void 0) {
+      const columnAnnotations = pcolumn.annotations || {};
+      for (const [key, value] of Object.entries(selector.annotations))
+        if (columnAnnotations[key] !== value)
           return false;
     }
-    if (e.annotationPatterns !== void 0) {
-      const t = n2.annotations || {};
-      for (const [r, o] of Object.entries(e.annotationPatterns)) {
-        const s2 = t[r];
-        if (s2 === void 0 || !new RegExp(o).test(s2))
+    if (selector.annotationPatterns !== void 0) {
+      const columnAnnotations = pcolumn.annotations || {};
+      for (const [key, pattern] of Object.entries(selector.annotationPatterns)) {
+        const value = columnAnnotations[key];
+        if (value === void 0 || !new RegExp(pattern).test(value))
           return false;
       }
     }
     return true;
   }
-  function Gn(n2) {
-    return Array.isArray(n2) ? (e) => n2.some((t) => f(e) && N(e, t)) : (e) => f(e) && N(e, n2);
+  function selectorsToPredicate(predicateOrSelectors) {
+    if (Array.isArray(predicateOrSelectors))
+      return (spec) => predicateOrSelectors.some((selector) => isPColumnSpec(spec) && matchPColumn(spec, selector));
+    else
+      return (spec) => isPColumnSpec(spec) && matchPColumn(spec, predicateOrSelectors);
   }
-  function Qn(n2) {
-    const e = {
-      kind: n2.kind,
-      name: n2.name
+  function deriveNativeId(spec) {
+    const result = {
+      kind: spec.kind,
+      name: spec.name
     };
-    return n2.domain !== void 0 && (e.domain = n2.domain), f(n2) && (e.axesSpec = J(n2.axesSpec)), Re(e);
-  }
-  z$1.object({
-    __isRef: z$1.literal(true).describe("Crucial marker for the block dependency tree reconstruction"),
-    blockId: z$1.string().describe("Upstream block id"),
-    name: z$1.string().describe("Name of the output provided to the upstream block's output context"),
-    requireEnrichments: z$1.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."
-  ).readonly();
-  function ne(n2) {
-    return typeof n2 == "object" && n2 !== null && "__isRef" in n2 && n2.__isRef === true && "blockId" in n2 && "name" in n2;
-  }
-  function te$1(n2, e = true) {
-    if (e)
+    if (spec.domain !== void 0)
+      result.domain = spec.domain;
+    if (isPColumnSpec(spec))
+      result.axesSpec = getAxesId(spec.axesSpec);
+    return canonicalize(result);
+  }
+  const PlIdLength = 24;
+  z.string().length(PlIdLength).regex(/[ABCDEFGHIJKLMNOPQRSTUVWXYZ234567]/).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("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();
+  function isPlRef(value) {
+    return typeof value === "object" && value !== null && "__isRef" in value && value.__isRef === true && "blockId" in value && "name" in value;
+  }
+  function withEnrichments(ref, requireEnrichments = true) {
+    if (requireEnrichments)
       return {
-        ...n2,
+        ...ref,
         requireEnrichments: true
       };
-    {
-      const { requireEnrichments: t, ...r } = n2;
-      return r;
-    }
-  }
-  function oe$1(n2, e) {
-    return n2.ok ? { ok: true, value: e(n2.value) } : n2;
-  }
-  const fn = 24;
-  z$1.string().length(fn).regex(/[ABCDEFGHIJKLMNOPQRSTUVWXYZ234567]/).brand("PlId");
-  function ue$1(n2) {
-    return Re(n2);
-  }
-  var stringify = { exports: {} };
-  var hasRequiredStringify;
-  function requireStringify() {
-    if (hasRequiredStringify) return stringify.exports;
-    hasRequiredStringify = 1;
-    (function(module2, exports3) {
-      exports3 = module2.exports = stringify2;
-      exports3.getSerialize = serializer;
-      function stringify2(obj, replacer, spaces, cycleReplacer) {
-        return JSON.stringify(obj, serializer(replacer, cycleReplacer), spaces);
-      }
-      function serializer(replacer, cycleReplacer) {
-        var stack = [], keys = [];
-        if (cycleReplacer == null) cycleReplacer = function(key, value) {
-          if (stack[0] === value) return "[Circular ~]";
-          return "[Circular ~." + keys.slice(0, stack.indexOf(value)).join(".") + "]";
-        };
-        return function(key, value) {
-          if (stack.length > 0) {
-            var thisPos = stack.indexOf(this);
-            ~thisPos ? stack.splice(thisPos + 1) : stack.push(this);
-            ~thisPos ? keys.splice(thisPos, Infinity, key) : keys.push(key);
-            if (~stack.indexOf(value)) value = cycleReplacer.call(this, key, value);
-          } else stack.push(value);
-          return replacer == null ? value : replacer.call(this, key, value);
-        };
-      }
-    })(stringify, stringify.exports);
-    return stringify.exports;
-  }
-  requireStringify();
-  const l = z$1.object({
-    type: z$1.literal("PlError"),
-    name: z$1.string(),
-    message: z$1.string(),
-    /** The message with all details needed for SDK developers. */
-    fullMessage: z$1.string().optional(),
-    stack: z$1.string().optional()
-  }), c = l.extend({
-    cause: z$1.lazy(() => s).optional(),
-    errors: z$1.lazy(() => s.array()).optional()
-  }), m = z$1.object({
-    type: z$1.literal("StandardError"),
-    name: z$1.string(),
-    message: z$1.string(),
-    stack: z$1.string().optional()
-  }), p = m.extend({
-    cause: z$1.lazy(() => s).optional(),
-    errors: z$1.lazy(() => s.array()).optional()
-  }), s = z$1.union([p, c]);
-  const u = z$1.object({
-    name: z$1.string(),
-    message: z$1.string(),
-    fullMessage: z$1.string().optional(),
-    stack: z$1.string().optional()
-  }), n = u.extend({
-    cause: z$1.lazy(() => n).optional(),
-    errors: z$1.lazy(() => n.array()).optional()
-  });
-  var Ye = Object.defineProperty;
-  var Xe = (t, e, n2) => e in t ? Ye(t, e, { enumerable: true, configurable: true, writable: true, value: n2 }) : t[e] = n2;
-  var k = (t, e, n2) => Xe(t, typeof e != "symbol" ? e + "" : e, n2);
-  function re(t) {
-    return { type: "Immediate", value: t };
-  }
-  function ht() {
-    return typeof globalThis.getPlatforma < "u" || typeof globalThis.platforma < "u";
-  }
-  function Ke(t) {
-    if (t && typeof globalThis.getPlatforma == "function")
-      return globalThis.getPlatforma(t);
-    if (typeof globalThis.platforma < "u") return globalThis.platforma;
-    throw new Error("Can't get platforma instance.");
-  }
-  function gt() {
-    if (typeof globalThis.cfgRenderCtx < "u") return globalThis.cfgRenderCtx;
-  }
-  function y() {
-    if (typeof globalThis.cfgRenderCtx < "u") return globalThis.cfgRenderCtx;
-    throw new Error("Not in config rendering context");
-  }
-  function H(t, e) {
-    const n2 = gt();
-    if (n2 === void 0) return false;
-    if (t in n2.callbackRegistry) throw new Error(`Callback with key ${t} already registered.`);
-    return n2.callbackRegistry[t] = e, true;
-  }
-  const de = /* @__PURE__ */ new Map();
-  function mt(t, e) {
-    t in y().callbackRegistry || (y().callbackRegistry[t] = (n2) => {
-      for (const r of de.get(t))
-        r(n2);
-    }, de.set(t, [])), de.get(t).push(e);
-  }
-  class I {
-    constructor(e, n2 = (r) => r) {
-      k(this, "isResolved", false);
-      k(this, "resolvedValue");
-      this.handle = e, this.postProcess = n2, mt(e, (r) => {
-        this.resolvedValue = n2(r), this.isResolved = true;
+    else {
+      const { requireEnrichments: _, ...rest } = ref;
+      return rest;
+    }
+  }
+  function mapValueInVOE(voe, cb) {
+    return voe.ok ? { ok: true, value: cb(voe.value) } : voe;
+  }
+  class FutureRef {
+    constructor(handle, postProcess = (v) => v) {
+      __publicField(this, "handle");
+      __publicField(this, "postProcess");
+      __publicField(this, "isResolved", false);
+      __publicField(this, "resolvedValue");
+      this.handle = handle;
+      this.postProcess = postProcess;
+      registerFutureAwait(handle, (value) => {
+        this.resolvedValue = postProcess(value);
+        this.isResolved = true;
       });
     }
-    map(e) {
-      return new I(this.handle, (n2) => e(this.postProcess(n2)));
+    map(mapping) {
+      return new FutureRef(this.handle, (v) => mapping(this.postProcess(v)));
     }
-    mapDefined(e) {
-      return new I(this.handle, (n2) => {
-        const r = this.postProcess(n2);
-        return r ? e(r) : void 0;
+    mapDefined(mapping) {
+      return new FutureRef(this.handle, (v) => {
+        const vv = this.postProcess(v);
+        return vv ? mapping(vv) : void 0;
       });
     }
     toJSON() {
       return this.isResolved ? this.resolvedValue : { __awaited_futures__: [this.handle] };
     }
   }
-  function ge(t, e) {
-    return t === void 0 ? void 0 : e(t);
+  function ifDef(value, cb) {
+    return value === void 0 ? void 0 : cb(value);
   }
-  class E {
-    constructor(e, n2) {
-      this.handle = e, this.resolvePath = n2;
+  class TreeNodeAccessor {
+    constructor(handle, resolvePath) {
+      __publicField(this, "handle");
+      __publicField(this, "resolvePath");
+      this.handle = handle;
+      this.resolvePath = resolvePath;
     }
-    resolve(...e) {
-      const n2 = e.map(
-        (r) => ({
-          assertFieldType: "Input",
-          ...typeof r == "string" ? { field: r } : r
-        })
-      );
-      return this.resolveWithCommon({}, ...n2);
-    }
-    resolveOutput(...e) {
-      const n2 = e.map(
-        (r) => ({
-          assertFieldType: "Output",
-          ...typeof r == "string" ? { field: r } : r
-        })
-      );
-      return this.resolveWithCommon({}, ...n2);
-    }
-    resolveInput(...e) {
-      const n2 = e.map(
-        (r) => ({
-          assertFieldType: "Input",
-          ...typeof r == "string" ? { field: r } : r
-        })
-      );
-      return this.resolveWithCommon({}, ...n2);
+    resolve(...steps) {
+      const transformedSteps = steps.map((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
+      }));
+      return this.resolveWithCommon({}, ...transformedSteps);
     }
-    resolveAny(...e) {
-      return this.resolveWithCommon({}, ...e);
+    resolveInput(...steps) {
+      const transformedSteps = steps.map((s) => ({
+        assertFieldType: "Input",
+        ...typeof s === "string" ? { field: s } : s
+      }));
+      return this.resolveWithCommon({}, ...transformedSteps);
+    }
+    resolveAny(...steps) {
+      return this.resolveWithCommon({}, ...steps);
     }
-    resolveWithCommon(e, ...n2) {
-      const r = [
+    resolveWithCommon(commonOptions, ...steps) {
+      const resolvePath = [
         ...this.resolvePath,
-        ...n2.map((i) => typeof i == "string" ? i : i.field)
+        ...steps.map((step) => typeof step === "string" ? step : step.field)
       ];
-      return ge(
-        y().resolveWithCommon(this.handle, e, ...n2),
-        (i) => new E(i, r)
-      );
+      return ifDef(getCfgRenderCtx().resolveWithCommon(this.handle, commonOptions, ...steps), (accessor) => new TreeNodeAccessor(accessor, resolvePath));
     }
     get resourceType() {
-      return y().getResourceType(this.handle);
+      return getCfgRenderCtx().getResourceType(this.handle);
     }
     getInputsLocked() {
-      return y().getInputsLocked(this.handle);
+      return getCfgRenderCtx().getInputsLocked(this.handle);
     }
     getOutputsLocked() {
-      return y().getOutputsLocked(this.handle);
+      return getCfgRenderCtx().getOutputsLocked(this.handle);
     }
     getIsReadyOrError() {
-      return y().getIsReadyOrError(this.handle);
+      return getCfgRenderCtx().getIsReadyOrError(this.handle);
     }
     getIsFinal() {
-      return y().getIsFinal(this.handle);
+      return getCfgRenderCtx().getIsFinal(this.handle);
     }
     getError() {
-      const e = [...this.resolvePath, "error"];
-      return ge(
-        y().getError(this.handle),
-        (n2) => new E(n2, e)
-      );
+      const resolvePath = [...this.resolvePath, "error"];
+      return ifDef(getCfgRenderCtx().getError(this.handle), (accsessor) => new TreeNodeAccessor(accsessor, resolvePath));
     }
     listInputFields() {
-      return y().listInputFields(this.handle);
+      return getCfgRenderCtx().listInputFields(this.handle);
     }
     listOutputFields() {
-      return y().listOutputFields(this.handle);
+      return getCfgRenderCtx().listOutputFields(this.handle);
     }
     listDynamicFields() {
-      return y().listDynamicFields(this.handle);
+      return getCfgRenderCtx().listDynamicFields(this.handle);
     }
-    getKeyValueBase64(e) {
-      return y().getKeyValueBase64(this.handle, e);
+    getKeyValueBase64(key) {
+      return getCfgRenderCtx().getKeyValueBase64(this.handle, key);
     }
-    getKeyValueAsString(e) {
-      return y().getKeyValueAsString(this.handle, e);
+    getKeyValueAsString(key) {
+      return getCfgRenderCtx().getKeyValueAsString(this.handle, key);
     }
-    getKeyValueAsJson(e) {
-      const n2 = this.getKeyValueAsString(e);
-      if (n2 == null) throw new Error("Resource has no content.");
-      return JSON.parse(n2);
+    getKeyValueAsJson(key) {
+      const content = this.getKeyValueAsString(key);
+      if (content == void 0)
+        throw new Error("Resource has no content.");
+      return JSON.parse(content);
     }
     getDataBase64() {
-      return y().getDataBase64(this.handle);
+      return getCfgRenderCtx().getDataBase64(this.handle);
     }
     getDataAsString() {
-      return y().getDataAsString(this.handle);
+      return getCfgRenderCtx().getDataAsString(this.handle);
     }
     getDataAsJson() {
-      const e = this.getDataAsString();
-      if (e == null) throw new Error("Resource has no content.");
-      return JSON.parse(e);
+      const content = this.getDataAsString();
+      if (content == void 0)
+        throw new Error("Resource has no content.");
+      return JSON.parse(content);
     }
     /**
      *
      */
-    getPColumns(e = false, n2 = "") {
-      const r = this.parsePObjectCollection(e, n2);
-      return r === void 0 ? void 0 : Object.entries(r).map(([, s2]) => {
-        if (!rn(s2)) throw new Error(`not a PColumn (kind = ${s2.spec.kind})`);
-        return s2;
+    getPColumns(errorOnUnknownField = false, prefix = "") {
+      const result = this.parsePObjectCollection(errorOnUnknownField, prefix);
+      if (result === void 0)
+        return void 0;
+      const pf = Object.entries(result).map(([, obj]) => {
+        if (!isPColumn(obj))
+          throw new Error(`not a PColumn (kind = ${obj.spec.kind})`);
+        return obj;
       });
+      return pf;
     }
     /**
      *
      */
-    parsePObjectCollection(e = false, n2 = "") {
-      const r = y().parsePObjectCollection(
-        this.handle,
-        e,
-        n2,
-        ...this.resolvePath
-      );
-      if (r === void 0) return;
-      const i = {};
-      for (const [s2, o] of Object.entries(r)) {
-        const a = [...this.resolvePath, s2];
-        i[s2] = Wn(o, (l2) => new E(l2, a));
-      }
-      return i;
-    }
-    getFileContentAsBase64(e) {
-      return new I(y().getBlobContentAsBase64(this.handle, e));
-    }
-    getFileContentAsString(e) {
-      return new I(y().getBlobContentAsString(this.handle, e));
-    }
-    getFileContentAsJson(e) {
-      return new I(
-        y().getBlobContentAsString(this.handle, e)
-      ).mapDefined((n2) => JSON.parse(n2));
+    parsePObjectCollection(errorOnUnknownField = false, prefix = "") {
+      const pObjects = getCfgRenderCtx().parsePObjectCollection(this.handle, errorOnUnknownField, prefix, ...this.resolvePath);
+      if (pObjects === void 0)
+        return void 0;
+      const result = {};
+      for (const [key, value] of Object.entries(pObjects)) {
+        const resolvePath = [...this.resolvePath, key];
+        result[key] = mapPObjectData(value, (c) => new TreeNodeAccessor(c, resolvePath));
+      }
+      return result;
+    }
+    getFileContentAsBase64(range) {
+      return new FutureRef(getCfgRenderCtx().getBlobContentAsBase64(this.handle, range));
+    }
+    getFileContentAsString(range) {
+      return new FutureRef(getCfgRenderCtx().getBlobContentAsString(this.handle, range));
+    }
+    getFileContentAsJson(range) {
+      return new FutureRef(getCfgRenderCtx().getBlobContentAsString(this.handle, range)).mapDefined((v) => JSON.parse(v));
     }
     /**
      * @deprecated use getFileContentAsBase64
@@ -4733,7 +4875,7 @@
      * @returns downloaded file handle
      */
     getFileHandle() {
-      return new I(y().getDownloadedBlobContentHandle(this.handle));
+      return new FutureRef(getCfgRenderCtx().getDownloadedBlobContentHandle(this.handle));
     }
     /**
      * @deprecated use getFileHandle
@@ -4745,7 +4887,7 @@
      * @returns downloaded file handle
      */
     getRemoteFileHandle() {
-      return new I(y().getOnDemandBlobContentHandle(this.handle));
+      return new FutureRef(getCfgRenderCtx().getOnDemandBlobContentHandle(this.handle));
     }
     /**
      * @deprecated use getRemoteFileHandle
@@ -4756,655 +4898,898 @@
     /**
      * @returns the url to the extracted folder
      */
-    extractArchiveAndGetURL(e) {
-      return new I(y().extractArchiveAndGetURL(this.handle, e));
+    extractArchiveAndGetURL(format) {
+      return new FutureRef(getCfgRenderCtx().extractArchiveAndGetURL(this.handle, format));
     }
     getImportProgress() {
-      return new I(y().getImportProgress(this.handle));
+      return new FutureRef(getCfgRenderCtx().getImportProgress(this.handle));
     }
-    getLastLogs(e) {
-      return new I(y().getLastLogs(this.handle, e));
+    getLastLogs(nLines) {
+      return new FutureRef(getCfgRenderCtx().getLastLogs(this.handle, nLines));
     }
-    getProgressLog(e) {
-      return new I(y().getProgressLog(this.handle, e));
+    getProgressLog(patternToSearch) {
+      return new FutureRef(getCfgRenderCtx().getProgressLog(this.handle, patternToSearch));
     }
-    getProgressLogWithInfo(e) {
-      return new I(y().getProgressLogWithInfo(this.handle, e));
+    getProgressLogWithInfo(patternToSearch) {
+      return new FutureRef(getCfgRenderCtx().getProgressLogWithInfo(this.handle, patternToSearch));
     }
     getLogHandle() {
-      return new I(y().getLogHandle(this.handle));
+      return new FutureRef(getCfgRenderCtx().getLogHandle(this.handle));
     }
-    allFieldsResolved(e = "Input") {
-      switch (e) {
+    allFieldsResolved(fieldType = "Input") {
+      switch (fieldType) {
         case "Input":
-          return this.getInputsLocked() && this.listInputFields().every(
-            (n2) => this.resolve({ field: n2, assertFieldType: "Input" }) !== void 0
-          );
+          return this.getInputsLocked() && this.listInputFields().every((field) => this.resolve({ field, assertFieldType: "Input" }) !== void 0);
         case "Output":
-          return this.getOutputsLocked() && this.listOutputFields().every(
-            (n2) => this.resolve({ field: n2, assertFieldType: "Output" }) !== void 0
-          );
+          return this.getOutputsLocked() && this.listOutputFields().every((field) => this.resolve({ field, assertFieldType: "Output" }) !== void 0);
       }
     }
-    mapFields(e, n2) {
-      const { fieldType: r, requireLocked: i, skipUnresolved: s2 } = {
+    mapFields(_mapping, _ops) {
+      const { fieldType, requireLocked, skipUnresolved } = {
         fieldType: "Input",
         requireLocked: true,
         skipUnresolved: false,
-        ...n2
-      }, o = e;
-      if (i && (r === "Input" && !this.getInputsLocked() || r === "Output" && !this.getOutputsLocked()))
-        return;
-      let l2 = (r === "Input" ? this.listInputFields() : r === "Output" ? this.listOutputFields() : this.listDynamicFields()).map(
-        (u2) => [u2, this.resolve({ field: u2, assertFieldType: r })]
-      );
-      return s2 && (l2 = l2.filter((u2) => u2[1] !== void 0)), l2.map(([u2, c2]) => o(u2, c2));
-    }
-  }
-  const Ve = "staging", je = "main";
-  const bt = "pl7.app/label", wt = "pl7.app/trace", At = z$1.object({
-    type: z$1.string(),
-    importance: z$1.number().optional(),
-    id: z$1.string().optional(),
-    label: z$1.string()
-  }), xt = z$1.array(At), Ct = 1e-3, Pt = "__LABEL__", Te = "__LABEL__@1";
-  function $e(t, e, n2 = {}) {
-    const r = /* @__PURE__ */ new Map(), i = n2.forceTraceElements !== void 0 && n2.forceTraceElements.length > 0 ? new Set(n2.forceTraceElements) : void 0, s2 = /* @__PURE__ */ new Map(), o = t.map((p2) => {
-      var S, F;
-      const m2 = e(p2);
-      let f2, v, b;
-      "spec" in m2 && typeof m2.spec == "object" ? (f2 = m2.spec, v = m2.prefixTrace, b = m2.suffixTrace) : f2 = m2;
-      const g = (S = f2.annotations) == null ? void 0 : S[bt], x = (F = f2.annotations) == null ? void 0 : F[wt], A = (x ? xt.safeParse(JSON.parse(x)).data : void 0) ?? [], C = [
-        ...v ?? [],
-        ...A,
-        ...b ?? []
+        ..._ops
+      };
+      const mapping = _mapping;
+      if (requireLocked) {
+        if (fieldType === "Input" && !this.getInputsLocked())
+          return void 0;
+        if (fieldType === "Output" && !this.getOutputsLocked())
+          return void 0;
+      }
+      const fieldList = fieldType === "Input" ? this.listInputFields() : fieldType === "Output" ? this.listOutputFields() : this.listDynamicFields();
+      let fieldEntries = fieldList.map((field) => [field, this.resolve({ field, assertFieldType: fieldType })]);
+      if (skipUnresolved)
+        fieldEntries = fieldEntries.filter((e) => e[1] !== void 0);
+      return fieldEntries.map(([name, value]) => mapping(name, value));
+    }
+  }
+  const StagingAccessorName = "staging";
+  const MainAccessorName = "main";
+  const TraceEntry = z.object({
+    type: z.string(),
+    importance: z.number().optional(),
+    id: z.string().optional(),
+    label: z.string()
+  });
+  const Trace = z.array(TraceEntry);
+  const DistancePenalty = 1e-3;
+  const LabelType = "__LABEL__";
+  const LabelTypeFull = "__LABEL__@1";
+  function deriveLabels(values, specExtractor, ops = {}) {
+    const importances = /* @__PURE__ */ new Map();
+    const forceTraceElements = ops.forceTraceElements !== void 0 && ops.forceTraceElements.length > 0 ? new Set(ops.forceTraceElements) : void 0;
+    const numberOfRecordsWithType = /* @__PURE__ */ new Map();
+    const enrichedRecords = values.map((value) => {
+      const extractorResult = specExtractor(value);
+      let spec;
+      let prefixTrace;
+      let suffixTrace;
+      if ("spec" in extractorResult && typeof extractorResult.spec === "object") {
+        spec = extractorResult.spec;
+        prefixTrace = extractorResult.prefixTrace;
+        suffixTrace = extractorResult.suffixTrace;
+      } else {
+        spec = extractorResult;
+      }
+      const label = readAnnotation(spec, Annotation.Label);
+      const traceStr = readAnnotation(spec, Annotation.Trace);
+      const baseTrace = (traceStr ? Trace.safeParse(parseJson(traceStr)).data : void 0) ?? [];
+      const trace = [
+        ...prefixTrace ?? [],
+        ...baseTrace,
+        ...suffixTrace ?? []
       ];
-      if (g !== void 0) {
-        const D = { label: g, type: Pt, importance: -2 };
-        n2.addLabelAsSuffix ? C.push(D) : C.splice(0, 0, D);
-      }
-      const w2 = [], T = /* @__PURE__ */ new Map();
-      for (let D = C.length - 1; D >= 0; --D) {
-        const { type: W } = C[D], j2 = C[D].importance ?? 0, $ = (T.get(W) ?? 0) + 1;
-        T.set(W, $);
-        const K2 = `${W}@${$}`;
-        s2.set(K2, (s2.get(K2) ?? 0) + 1), r.set(
-          K2,
-          Math.max(
-            r.get(K2) ?? Number.NEGATIVE_INFINITY,
-            j2 - (C.length - D) * Ct
-          )
-        ), w2.push({ ...C[D], fullType: K2, occurrenceIndex: $ });
-      }
-      return w2.reverse(), {
-        value: p2,
-        spec: f2,
-        label: g,
-        fullTrace: w2
+      if (label !== void 0) {
+        const labelEntry = { label, type: LabelType, importance: -2 };
+        if (ops.addLabelAsSuffix)
+          trace.push(labelEntry);
+        else
+          trace.splice(0, 0, labelEntry);
+      }
+      const fullTrace = [];
+      const occurrences = /* @__PURE__ */ new Map();
+      for (let i = trace.length - 1; i >= 0; --i) {
+        const { type: typeName } = trace[i];
+        const importance = trace[i].importance ?? 0;
+        const occurrenceIndex = (occurrences.get(typeName) ?? 0) + 1;
+        occurrences.set(typeName, occurrenceIndex);
+        const fullType = `${typeName}@${occurrenceIndex}`;
+        numberOfRecordsWithType.set(fullType, (numberOfRecordsWithType.get(fullType) ?? 0) + 1);
+        importances.set(fullType, Math.max(importances.get(fullType) ?? Number.NEGATIVE_INFINITY, importance - (trace.length - i) * DistancePenalty));
+        fullTrace.push({ ...trace[i], fullType, occurrenceIndex });
+      }
+      fullTrace.reverse();
+      return {
+        value,
+        spec,
+        label,
+        fullTrace
       };
-    }), a = [], l2 = [], u2 = [...r];
-    u2.sort(([, p2], [, m2]) => m2 - p2);
-    for (const [p2] of u2)
-      p2.endsWith("@1") || s2.get(p2) === t.length ? a.push(p2) : l2.push(p2);
-    const c2 = (p2, m2 = false) => {
-      const f2 = [];
-      for (let v = 0; v < o.length; v++) {
-        const b = o[v], g = b.fullTrace.filter((C) => p2.has(C.fullType) || i && i.has(C.type));
-        if (g.length === 0)
-          if (m2)
-            f2.push({
+    });
+    const mainTypes = [];
+    const secondaryTypes = [];
+    const allTypeRecords = [...importances];
+    allTypeRecords.sort(([, i1], [, i2]) => i2 - i1);
+    for (const [typeName] of allTypeRecords) {
+      if (typeName.endsWith("@1") || numberOfRecordsWithType.get(typeName) === values.length)
+        mainTypes.push(typeName);
+      else
+        secondaryTypes.push(typeName);
+    }
+    const calculate = (includedTypes2, force = false) => {
+      const result = [];
+      for (let i = 0; i < enrichedRecords.length; i++) {
+        const r = enrichedRecords[i];
+        const includedTrace = r.fullTrace.filter((fm) => includedTypes2.has(fm.fullType) || forceTraceElements && forceTraceElements.has(fm.type));
+        if (includedTrace.length === 0) {
+          if (force)
+            result.push({
               label: "Unlabeled",
-              value: b.value
+              value: r.value
             });
-          else return;
-        const x = g.map((C) => C.label), A = n2.separator ?? " / ";
-        f2.push({
-          label: x.join(A),
-          value: b.value
+          else
+            return void 0;
+        }
+        const labelSet = includedTrace.map((fm) => fm.label);
+        const sep = ops.separator ?? " / ";
+        result.push({
+          label: labelSet.join(sep),
+          value: r.value
         });
       }
-      return f2;
+      return result;
     };
-    if (a.length === 0) {
-      if (l2.length !== 0) throw new Error("Non-empty secondary types list while main types list is empty.");
-      return c2(new Set(Te), true);
-    }
-    let d = 0, h2 = -1;
-    for (; d < a.length; ) {
-      const p2 = /* @__PURE__ */ new Set();
-      n2.includeNativeLabel && p2.add(Te);
-      for (let f2 = 0; f2 < d; ++f2) p2.add(a[f2]);
-      h2 >= 0 && p2.add(a[h2]);
-      const m2 = c2(p2);
-      if (m2 !== void 0 && new Set(m2.map((f2) => f2.label)).size === t.length) return m2;
-      h2++, h2 >= a.length && (d++, h2 = d);
-    }
-    return c2(/* @__PURE__ */ new Set([...a, ...l2]), true);
-  }
-  const Z = "PColumnData/", se = Z + "ResourceMap", oe = Z + "Partitioned/ResourceMap", q = Z + "JsonPartitioned", B = Z + "BinaryPartitioned", Je = Z + "Partitioned/", ae = Je + "JsonPartitioned", z = Je + "BinaryPartitioned";
-  const ye = (t) => {
-    if (t.endsWith(".index"))
-      return { baseKey: t.substring(0, t.length - 6), type: "index" };
-    if (t.endsWith(".values"))
-      return { baseKey: t.substring(0, t.length - 7), type: "values" };
-    throw new Error(`key must ends on .index/.values for binary p-column, got: ${t}`);
+    if (mainTypes.length === 0) {
+      if (secondaryTypes.length !== 0)
+        throw new Error("Non-empty secondary types list while main types list is empty.");
+      return calculate(new Set(LabelTypeFull), true);
+    }
+    let includedTypes = 0;
+    let additionalType = -1;
+    while (includedTypes < mainTypes.length) {
+      const currentSet = /* @__PURE__ */ new Set();
+      if (ops.includeNativeLabel)
+        currentSet.add(LabelTypeFull);
+      for (let i = 0; i < includedTypes; ++i)
+        currentSet.add(mainTypes[i]);
+      if (additionalType >= 0)
+        currentSet.add(mainTypes[additionalType]);
+      const candidateResult = calculate(currentSet);
+      if (candidateResult !== void 0 && new Set(candidateResult.map((c) => c.label)).size === values.length)
+        return candidateResult;
+      additionalType++;
+      if (additionalType >= mainTypes.length) {
+        includedTypes++;
+        additionalType = includedTypes;
+      }
+    }
+    return calculate(/* @__PURE__ */ new Set([...mainTypes, ...secondaryTypes]), 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 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 removeIndexSuffix = (keyStr) => {
+    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 {
+      throw new Error(`key must ends on .index/.values for binary p-column, got: ${keyStr}`);
+    }
   };
-  function St(t) {
-    if (!t) return;
-    const e = t.resourceType.name, n2 = t.getDataAsJson(), r = [];
-    let i = 0;
-    switch (e) {
-      case se:
-        i = n2.keyLength;
+  function getPartitionKeysList(acc) {
+    if (!acc)
+      return void 0;
+    const rt = acc.resourceType.name;
+    const meta = acc.getDataAsJson();
+    const data = [];
+    let keyLength = 0;
+    switch (rt) {
+      case RT_RESOURCE_MAP:
+        keyLength = meta["keyLength"];
         break;
-      case oe:
-        i = n2.partitionKeyLength + n2.keyLength;
+      case RT_RESOURCE_MAP_PARTITIONED:
+        keyLength = meta["partitionKeyLength"] + meta["keyLength"];
         break;
-      case q:
-      case B:
-        i = n2.partitionKeyLength;
+      case RT_JSON_PARTITIONED:
+      case RT_BINARY_PARTITIONED:
+        keyLength = meta["partitionKeyLength"];
         break;
-      case z:
-      case ae:
-        i = n2.superPartitionKeyLength + n2.partitionKeyLength;
+      case RT_BINARY_SUPER_PARTITIONED:
+      case RT_JSON_SUPER_PARTITIONED:
+        keyLength = meta["superPartitionKeyLength"] + meta["partitionKeyLength"];
         break;
     }
-    switch (e) {
-      case se:
-      case q:
-      case B:
-        for (let s2 of t.listInputFields()) {
-          e === B && (s2 = ye(s2).baseKey);
-          const o = [...JSON.parse(s2)];
-          r.push(o);
+    switch (rt) {
+      case RT_RESOURCE_MAP:
+      case RT_JSON_PARTITIONED:
+      case RT_BINARY_PARTITIONED:
+        for (let keyStr of acc.listInputFields()) {
+          if (rt === RT_BINARY_PARTITIONED) {
+            keyStr = removeIndexSuffix(keyStr).baseKey;
+          }
+          const key = [...JSON.parse(keyStr)];
+          data.push(key);
         }
         break;
-      case oe:
-      case z:
-      case ae:
-        for (const s2 of t.listInputFields()) {
-          const o = [...JSON.parse(s2)], a = t.resolve({ field: s2, assertFieldType: "Input" });
-          if (a !== void 0)
-            for (let l2 of a.listInputFields()) {
-              e === z && (l2 = ye(l2).baseKey);
-              const u2 = [...o, ...JSON.parse(l2)];
-              r.push(u2);
+      case RT_RESOURCE_MAP_PARTITIONED:
+      case RT_BINARY_SUPER_PARTITIONED:
+      case RT_JSON_SUPER_PARTITIONED:
+        for (const supKeyStr of acc.listInputFields()) {
+          const keyPrefix = [...JSON.parse(supKeyStr)];
+          const value = acc.resolve({ field: supKeyStr, assertFieldType: "Input" });
+          if (value !== void 0) {
+            for (let keyStr of value.listInputFields()) {
+              if (rt === RT_BINARY_SUPER_PARTITIONED) {
+                keyStr = removeIndexSuffix(keyStr).baseKey;
+              }
+              const key = [...keyPrefix, ...JSON.parse(keyStr)];
+              data.push(key);
             }
+          }
         }
         break;
     }
-    return { data: r, keyLength: i };
-  }
-  function _t(t) {
-    if (t.type !== "JsonPartitioned" && t.type !== "BinaryPartitioned")
-      throw new Error(`Splitting requires Partitioned DataInfoEntries, got ${t.type}`);
-    const { parts: e, partitionKeyLength: n2 } = t, r = [];
-    for (let i = 0; i < n2; ++i)
-      r.push(/* @__PURE__ */ new Set());
-    for (const i of e) {
-      const s2 = i.key;
-      if (s2.length !== n2)
-        throw new Error(
-          `Key length (${s2.length}) does not match partition length (${n2}) for key: ${JSON.stringify(
-            s2
-          )}`
-        );
-      for (let o = 0; o < n2; ++o)
-        r[o].add(s2[o]);
-    }
-    return r.map((i) => Array.from(i.values()));
-  }
-  function It(t) {
-    if (t === void 0) return;
-    if (K(t))
-      return _t(t);
-    const e = St(t);
-    if (!e) return;
-    const { data: n2, keyLength: r } = e, i = [];
-    for (let s2 = 0; s2 < r; ++s2)
-      i.push(/* @__PURE__ */ new Set());
-    for (const s2 of n2) {
-      if (s2.length !== r)
+    return { data, keyLength };
+  }
+  function getUniquePartitionKeysForDataEntries(list) {
+    if (list.type !== "JsonPartitioned" && list.type !== "BinaryPartitioned")
+      throw new Error(`Splitting requires Partitioned DataInfoEntries, got ${list.type}`);
+    const { parts, partitionKeyLength } = list;
+    const result = [];
+    for (let i = 0; i < partitionKeyLength; ++i) {
+      result.push(/* @__PURE__ */ new Set());
+    }
+    for (const part of parts) {
+      const key = part.key;
+      if (key.length !== partitionKeyLength) {
+        throw new Error(`Key length (${key.length}) does not match partition length (${partitionKeyLength}) for key: ${JSON.stringify(key)}`);
+      }
+      for (let i = 0; i < partitionKeyLength; ++i) {
+        result[i].add(key[i]);
+      }
+    }
+    return result.map((s) => Array.from(s.values()));
+  }
+  function getUniquePartitionKeys(acc) {
+    if (acc === void 0)
+      return void 0;
+    if (isDataInfoEntries(acc))
+      return getUniquePartitionKeysForDataEntries(acc);
+    const list = getPartitionKeysList(acc);
+    if (!list)
+      return void 0;
+    const { data, keyLength } = list;
+    const result = [];
+    for (let i = 0; i < keyLength; ++i) {
+      result.push(/* @__PURE__ */ new Set());
+    }
+    for (const l of data) {
+      if (l.length !== keyLength) {
         throw new Error("key length does not match partition length");
-      for (let o = 0; o < r; ++o)
-        i[o].add(s2[o]);
-    }
-    return i.map((s2) => Array.from(s2.values()));
-  }
-  function ve(t, e = []) {
-    if (t === void 0 || !t.getIsReadyOrError()) return;
-    const n2 = t.resourceType.name, r = t.getDataAsJson();
-    if (e.length > 0 && (n2 === ae || n2 === z))
-      throw new Error(`Unexpected nested super-partitioned resource: ${n2}`);
-    switch (n2) {
-      case se:
-      case oe:
-        throw new Error(`Only data columns are supported, got: ${n2}`);
-      case q: {
-        if (typeof (r == null ? void 0 : r.partitionKeyLength) != "number")
-          throw new Error(`Missing partitionKeyLength in metadata for ${n2}`);
-        const i = [];
-        for (const s2 of t.listInputFields()) {
-          const o = t.resolve({ field: s2, assertFieldType: "Input" });
-          if (o === void 0) return;
-          const a = [...e, ...JSON.parse(s2)];
-          i.push({ key: a, value: o });
+      }
+      for (let i = 0; i < keyLength; ++i) {
+        result[i].add(l[i]);
+      }
+    }
+    return result.map((s) => Array.from(s.values()));
+  }
+  function parsePColumnData(acc, keyPrefix = []) {
+    if (acc === void 0)
+      return void 0;
+    if (!acc.getIsReadyOrError())
+      return void 0;
+    const resourceType = acc.resourceType.name;
+    const meta = acc.getDataAsJson();
+    if (keyPrefix.length > 0 && (resourceType === RT_JSON_SUPER_PARTITIONED || resourceType === RT_BINARY_SUPER_PARTITIONED)) {
+      throw new Error(`Unexpected nested super-partitioned resource: ${resourceType}`);
+    }
+    switch (resourceType) {
+      case RT_RESOURCE_MAP:
+      case RT_RESOURCE_MAP_PARTITIONED:
+        throw new Error(`Only data columns are supported, got: ${resourceType}`);
+      case RT_JSON_PARTITIONED: {
+        if (typeof (meta == null ? void 0 : 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" });
+          if (value === void 0)
+            return void 0;
+          const key = [...keyPrefix, ...JSON.parse(keyStr)];
+          parts.push({ key, value });
         }
         return {
           type: "JsonPartitioned",
-          partitionKeyLength: r.partitionKeyLength,
-          parts: i
+          partitionKeyLength: meta.partitionKeyLength,
+          parts
         };
       }
-      case B: {
-        if (typeof (r == null ? void 0 : r.partitionKeyLength) != "number")
-          throw new Error(`Missing partitionKeyLength in metadata for ${n2}`);
-        const i = [], s2 = /* @__PURE__ */ new Map();
-        for (const o of t.listInputFields()) {
-          const a = ye(o), l2 = t.resolve({ field: o, assertFieldType: "Input" });
-          if (l2 === void 0) return;
-          let u2 = s2.get(a.baseKey);
-          u2 || (u2 = {}, s2.set(a.baseKey, u2)), a.type === "index" ? u2.index = l2 : u2.values = l2;
+      case RT_BINARY_PARTITIONED: {
+        if (typeof (meta == null ? void 0 : meta.partitionKeyLength) !== "number") {
+          throw new Error(`Missing partitionKeyLength in metadata for ${resourceType}`);
         }
-        for (const [o, a] of s2.entries()) {
-          if (!a.index || !a.values) return;
-          const l2 = [...e, ...JSON.parse(o)];
-          i.push({
-            key: l2,
+        const parts = [];
+        const baseKeys = /* @__PURE__ */ new Map();
+        for (const keyStr of acc.listInputFields()) {
+          const suffix = removeIndexSuffix(keyStr);
+          const value = acc.resolve({ field: keyStr, assertFieldType: "Input" });
+          if (value === void 0)
+            return void 0;
+          let entry = baseKeys.get(suffix.baseKey);
+          if (!entry) {
+            entry = {};
+            baseKeys.set(suffix.baseKey, entry);
+          }
+          if (suffix.type === "index") {
+            entry.index = value;
+          } else {
+            entry.values = value;
+          }
+        }
+        for (const [baseKeyStr, entry] of baseKeys.entries()) {
+          if (!entry.index || !entry.values)
+            return void 0;
+          const key = [...keyPrefix, ...JSON.parse(baseKeyStr)];
+          parts.push({
+            key,
             value: {
-              index: a.index,
-              values: a.values
+              index: entry.index,
+              values: entry.values
             }
           });
         }
         return {
           type: "BinaryPartitioned",
-          partitionKeyLength: r.partitionKeyLength,
-          parts: i
+          partitionKeyLength: meta.partitionKeyLength,
+          parts
         };
       }
-      case ae: {
-        if (typeof (r == null ? void 0 : r.superPartitionKeyLength) != "number" || typeof (r == null ? void 0 : r.partitionKeyLength) != "number")
-          throw new Error(`Missing superPartitionKeyLength or partitionKeyLength in metadata for ${n2}`);
-        const i = r.superPartitionKeyLength + r.partitionKeyLength, s2 = [];
-        for (const o of t.listInputFields()) {
-          const a = t.resolve({ field: o, assertFieldType: "Input" });
-          if (a === void 0) return;
-          if (a.resourceType.name !== q)
-            throw new Error(`Expected ${q} inside ${n2}, but got ${a.resourceType.name}`);
-          const l2 = ve(a, JSON.parse(o));
-          if (l2 === void 0) return;
-          if (l2.type !== "JsonPartitioned")
-            throw new Error(`Unexpected inner result type for ${n2}: ${l2.type}`);
-          s2.push(...l2.parts);
+      case RT_JSON_SUPER_PARTITIONED: {
+        if (typeof (meta == null ? void 0 : meta.superPartitionKeyLength) !== "number" || typeof (meta == null ? void 0 : meta.partitionKeyLength) !== "number") {
+          throw new Error(`Missing superPartitionKeyLength or partitionKeyLength in metadata for ${resourceType}`);
+        }
+        const totalKeyLength = meta.superPartitionKeyLength + meta.partitionKeyLength;
+        const parts = [];
+        for (const supKeyStr of acc.listInputFields()) {
+          const superPartition = acc.resolve({ field: supKeyStr, assertFieldType: "Input" });
+          if (superPartition === void 0)
+            return void 0;
+          if (superPartition.resourceType.name !== RT_JSON_PARTITIONED) {
+            throw new Error(`Expected ${RT_JSON_PARTITIONED} inside ${resourceType}, but got ${superPartition.resourceType.name}`);
+          }
+          const innerResult = parsePColumnData(superPartition, JSON.parse(supKeyStr));
+          if (innerResult === void 0)
+            return void 0;
+          if (innerResult.type !== "JsonPartitioned")
+            throw new Error(`Unexpected inner result type for ${resourceType}: ${innerResult.type}`);
+          parts.push(...innerResult.parts);
         }
         return {
           type: "JsonPartitioned",
-          partitionKeyLength: i,
-          parts: s2
+          partitionKeyLength: totalKeyLength,
+          parts
         };
       }
-      case z: {
-        if (typeof (r == null ? void 0 : r.superPartitionKeyLength) != "number" || typeof (r == null ? void 0 : r.partitionKeyLength) != "number")
-          throw new Error(`Missing superPartitionKeyLength or partitionKeyLength in metadata for ${n2}`);
-        const i = r.superPartitionKeyLength + r.partitionKeyLength, s2 = [];
-        for (const o of t.listInputFields()) {
-          const a = t.resolve({ field: o, assertFieldType: "Input" });
-          if (a === void 0) return;
-          if (a.resourceType.name !== B)
-            throw new Error(`Expected ${B} inside ${n2}, but got ${a.resourceType.name}`);
-          const l2 = ve(a, JSON.parse(o));
-          if (l2 === void 0) return;
-          if (l2.type !== "BinaryPartitioned")
-            throw new Error(`Unexpected inner result type for ${n2}: ${l2.type}`);
-          s2.push(...l2.parts);
+      case RT_BINARY_SUPER_PARTITIONED: {
+        if (typeof (meta == null ? void 0 : meta.superPartitionKeyLength) !== "number" || typeof (meta == null ? void 0 : meta.partitionKeyLength) !== "number") {
+          throw new Error(`Missing superPartitionKeyLength or partitionKeyLength in metadata for ${resourceType}`);
+        }
+        const totalKeyLength = meta.superPartitionKeyLength + meta.partitionKeyLength;
+        const parts = [];
+        for (const supKeyStr of acc.listInputFields()) {
+          const superPartition = acc.resolve({ field: supKeyStr, assertFieldType: "Input" });
+          if (superPartition === void 0)
+            return void 0;
+          if (superPartition.resourceType.name !== RT_BINARY_PARTITIONED) {
+            throw new Error(`Expected ${RT_BINARY_PARTITIONED} inside ${resourceType}, but got ${superPartition.resourceType.name}`);
+          }
+          const innerResult = parsePColumnData(superPartition, JSON.parse(supKeyStr));
+          if (innerResult === void 0)
+            return void 0;
+          if (innerResult.type !== "BinaryPartitioned")
+            throw new Error(`Unexpected inner result type for ${resourceType}: ${innerResult.type}`);
+          parts.push(...innerResult.parts);
         }
         return {
           type: "BinaryPartitioned",
-          partitionKeyLength: i,
-          parts: s2
+          partitionKeyLength: totalKeyLength,
+          parts
         };
       }
       default:
-        throw new Error(`Unknown resource type: ${n2}`);
-    }
-  }
-  function Tt(t) {
-    if (t !== void 0) {
-      if (K(t)) return t;
-      if (En(t)) return Cn(t);
-      if (t instanceof E) return ve(t);
-      throw new Error(`Unexpected input type: ${typeof t}`);
-    }
-  }
-  function Lt(t, e) {
-    const n2 = [...e].sort((s2, o) => o[0] - s2[0]);
-    if (t.type === "JsonPartitioned" || t.type === "BinaryPartitioned") {
-      const { partitionKeyLength: s2 } = t;
-      for (const [o] of e)
-        if (o >= s2)
-          throw new Error(`Can't filter on non-partitioned axis ${o}. Must be >= ${s2}`);
-    } else if (t.type === "Json") {
-      const { keyLength: s2 } = t;
-      for (const [o] of e)
-        if (o >= s2)
-          throw new Error(`Can't filter on non-data axis ${o}. Must be >= ${s2}`);
-    }
-    const r = (s2) => {
-      for (const [o, a] of n2)
-        if (s2[o] !== a)
+        throw new Error(`Unknown resource type: ${resourceType}`);
+    }
+  }
+  function convertOrParsePColumnData(acc) {
+    if (acc === void 0)
+      return void 0;
+    if (isDataInfoEntries(acc))
+      return acc;
+    if (isDataInfo(acc))
+      return dataInfoToEntries(acc);
+    if (acc instanceof TreeNodeAccessor)
+      return parsePColumnData(acc);
+    throw new Error(`Unexpected input type: ${typeof acc}`);
+  }
+  function filterDataInfoEntries(dataInfoEntries, axisFilters) {
+    const sortedFilters = [...axisFilters].sort((a, b) => b[0] - a[0]);
+    const { type } = dataInfoEntries;
+    switch (type) {
+      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": {
+        const { partitionKeyLength } = dataInfoEntries;
+        for (const [axisIdx] of axisFilters)
+          if (axisIdx >= partitionKeyLength)
+            throw new Error(`Can't filter on non-partitioned axis ${axisIdx}. Must be >= ${partitionKeyLength}`);
+        break;
+      }
+      default:
+        throw new Error(`Unsupported data info type: ${type}`);
+    }
+    const keyMatchesFilters = (key) => {
+      for (const [axisIdx, axisValue] of sortedFilters)
+        if (key[axisIdx] !== axisValue)
           return false;
       return true;
-    }, i = (s2) => {
-      const o = [...s2];
-      for (const [a] of n2)
-        o.splice(a, 1);
-      return o;
     };
-    switch (t.type) {
-      case "Json": {
-        const s2 = t.data.filter((o) => r(o.key)).map((o) => ({
-          key: i(o.key),
-          value: o.value
-        }));
+    const removeFilteredAxes = (key) => {
+      const newKey = [...key];
+      for (const [axisIdx] of sortedFilters)
+        newKey.splice(axisIdx, 1);
+      return newKey;
+    };
+    switch (dataInfoEntries.type) {
+      case "Json":
         return {
           type: "Json",
-          keyLength: t.keyLength - e.length,
-          data: s2
+          keyLength: dataInfoEntries.keyLength - axisFilters.length,
+          data: dataInfoEntries.data.filter((entry) => keyMatchesFilters(entry.key)).map((entry) => ({
+            key: removeFilteredAxes(entry.key),
+            value: entry.value
+          }))
         };
-      }
-      case "JsonPartitioned": {
-        const s2 = t.parts.filter((o) => r(o.key)).map((o) => ({
-          key: i(o.key),
-          value: o.value
-        }));
+      case "JsonPartitioned":
         return {
           type: "JsonPartitioned",
-          partitionKeyLength: t.partitionKeyLength - e.length,
-          parts: s2
+          partitionKeyLength: dataInfoEntries.partitionKeyLength - axisFilters.length,
+          parts: dataInfoEntries.parts.filter((entry) => keyMatchesFilters(entry.key)).map((entry) => ({
+            key: removeFilteredAxes(entry.key),
+            value: entry.value
+          }))
         };
-      }
-      case "BinaryPartitioned": {
-        const s2 = t.parts.filter((o) => r(o.key)).map((o) => ({
-          key: i(o.key),
-          value: o.value
-        }));
+      case "BinaryPartitioned":
         return {
           type: "BinaryPartitioned",
-          partitionKeyLength: t.partitionKeyLength - e.length,
-          parts: s2
+          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
+          }))
         };
-      }
     }
   }
-  function Et(t) {
-    if (!Array.isArray(t)) return false;
-    if (t.length === 0) return true;
-    const e = t[0];
-    return typeof e == "object" && e !== null && "key" in e && "val" in e;
+  function isPColumnValues(value) {
+    if (!Array.isArray(value))
+      return false;
+    if (value.length === 0)
+      return true;
+    const first = value[0];
+    return typeof first === "object" && first !== null && "key" in first && "val" in first;
   }
-  class Dt {
-    constructor(e) {
-      this.columns = e;
+  class ArrayColumnProvider {
+    constructor(columns) {
+      __publicField(this, "columns");
+      this.columns = columns;
     }
-    selectColumns(e) {
-      const n2 = typeof e == "function" ? e : Gn(e);
-      return this.columns.filter((r) => n2(r.spec));
+    selectColumns(selectors) {
+      const predicate = typeof selectors === "function" ? selectors : selectorsToPredicate(selectors);
+      return this.columns.filter((column) => predicate(column.spec));
     }
   }
-  function kt(t) {
-    if (t)
-      return t.map((e) => ({
-        type: `split:${Rn(e.axisId)}`,
-        label: e.label,
-        importance: 1e6
-        // High importance for split filters in labels
-      }));
-  }
-  function Ot(t) {
-    if (t)
-      return t.map((e) => [e.axisIdx, e.value]);
+  function splitFiltersToTrace(splitFilters) {
+    if (!splitFilters)
+      return void 0;
+    return splitFilters.map((filter) => ({
+      type: `split:${canonicalizeAxisId(filter.axisId)}`,
+      label: filter.label,
+      importance: 1e6
+      // High importance for split filters in labels
+    }));
+  }
+  function splitFiltersToAxisFilter(splitFilters) {
+    if (!splitFilters)
+      return void 0;
+    return splitFilters.map((filter) => [filter.axisIdx, filter.value]);
   }
-  function Rt(t, e) {
-    if (!e || e.length === 0) return t;
-    const n2 = [...e].sort((r, i) => r[0] - i[0]);
-    return Re({ id: t, axisFilters: n2 });
+  function fallbackIdDeriver(originalId, axisFilters) {
+    if (!axisFilters || axisFilters.length === 0)
+      return originalId;
+    const filtersToCanonicalize = [...axisFilters].sort((a, b) => a[0] - b[0]);
+    return canonicalize({ id: originalId, axisFilters: filtersToCanonicalize });
   }
-  function Le(t) {
-    if (!t || typeof t != "object") return false;
-    const e = t, n2 = e.domain && typeof e.domain == "object" && Object.values(e.domain).some((i) => typeof i == "object" && i !== null && "anchor" in i), r = e.axes && Array.isArray(e.axes) && e.axes.some((i) => typeof i == "object" && i !== null && "anchor" in i);
-    return !!e.domainAnchor || n2 || r;
+  function hasAnchors(selector) {
+    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;
   }
-  function Ft(t) {
-    if (typeof t != "object" || !("axes" in t) || t.axes === void 0)
+  function getSplitAxisIndices(selector) {
+    if (typeof selector !== "object" || !("axes" in selector) || selector.axes === void 0) {
       return [];
-    const e = t.axes.map((n2, r) => typeof n2 == "object" && "split" in n2 && n2.split === true ? r : -1).filter((n2) => n2 !== -1);
-    if (e.length > 0 && t.partialAxesMatch !== void 0)
+    }
+    const splitIndices = selector.axes.map((axis, index) => typeof axis === "object" && "split" in axis && axis.split === true ? index : -1).filter((index) => index !== -1);
+    if (splitIndices.length > 0 && selector.partialAxesMatch !== void 0) {
       throw new Error("Axis splitting is not supported when `partialAxesMatch` is defined.");
-    return e.sort((n2, r) => n2 - r), e;
+    }
+    splitIndices.sort((a, b) => a - b);
+    return splitIndices;
   }
-  class le {
+  class PColumnCollection {
     constructor() {
-      k(this, "defaultProviderStore", []);
-      k(this, "providers", [new Dt(this.defaultProviderStore)]);
-      k(this, "axisLabelProviders", []);
+      __publicField(this, "defaultProviderStore", []);
+      __publicField(this, "providers", [new ArrayColumnProvider(this.defaultProviderStore)]);
+      __publicField(this, "axisLabelProviders", []);
     }
-    addColumnProvider(e) {
-      return this.providers.push(e), this;
+    addColumnProvider(provider) {
+      this.providers.push(provider);
+      return this;
     }
-    addAxisLabelProvider(e) {
-      return this.axisLabelProviders.push(e), this;
+    addAxisLabelProvider(provider) {
+      this.axisLabelProviders.push(provider);
+      return this;
     }
-    addColumns(e) {
-      return this.defaultProviderStore.push(...e), this;
+    addColumns(columns) {
+      this.defaultProviderStore.push(...columns);
+      return this;
     }
-    addColumn(e) {
-      return this.defaultProviderStore.push(e), this;
+    addColumn(column) {
+      this.defaultProviderStore.push(column);
+      return this;
     }
     /** Fetches labels for a given axis from the registered providers */
-    findLabels(e) {
-      for (const n2 of this.axisLabelProviders) {
-        const r = n2.findLabels(e);
-        if (r) return r;
+    findLabels(axis) {
+      for (const provider of this.axisLabelProviders) {
+        const labels = provider.findLabels(axis);
+        if (labels)
+          return labels;
       }
+      return void 0;
     }
-    getUniversalEntries(e, n2) {
-      const { anchorCtx: r, labelOps: i, dontWaitAllData: s2 = false, overrideLabelAnnotation: o = false, exclude: a } = n2 ?? {}, l2 = {
-        ...o && (i == null ? void 0 : i.includeNativeLabel) !== false ? { includeNativeLabel: true } : {},
-        ...i ?? {}
+    getUniversalEntries(predicateOrSelectors, opts) {
+      const { anchorCtx, labelOps: rawLabelOps, dontWaitAllData = false, overrideLabelAnnotation = false, exclude } = opts ?? {};
+      const labelOps = {
+        ...overrideLabelAnnotation && (rawLabelOps == null ? void 0 : rawLabelOps.includeNativeLabel) !== false ? { includeNativeLabel: true } : {},
+        ...rawLabelOps ?? {}
       };
-      let u2 = () => false;
-      if (a) {
-        const f2 = (Array.isArray(a) ? a : [a]).map((v) => {
-          if (Le(v)) {
-            if (!r)
+      let excludePredicate = () => false;
+      if (exclude) {
+        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.");
-            return Gn(Mn(r.anchors, v, n2));
+            return selectorsToPredicate(resolveAnchors(anchorCtx.anchors, selector, opts));
           } else
-            return Gn(v);
+            return selectorsToPredicate(selector);
         });
-        u2 = (v) => f2.some((b) => b(v));
-      }
-      const c2 = typeof e == "function" ? [e] : Array.isArray(e) ? e : [e], d = [], h2 = /* @__PURE__ */ new Set();
-      for (const f$1 of c2) {
-        const v = Le(f$1);
-        let b;
-        if (v) {
-          if (!r)
+        excludePredicate = (spec) => excludePredicartes.some((predicate) => predicate(spec));
+      }
+      const selectorsArray = typeof predicateOrSelectors === "function" ? [predicateOrSelectors] : Array.isArray(predicateOrSelectors) ? predicateOrSelectors : [predicateOrSelectors];
+      const intermediateResults = [];
+      const selectedNativeIds = /* @__PURE__ */ new Set();
+      for (const rawSelector of selectorsArray) {
+        const usesAnchors = hasAnchors(rawSelector);
+        let currentSelector;
+        if (usesAnchors) {
+          if (!anchorCtx)
             throw new Error("Anchored selectors require an AnchoredIdDeriver to be provided in options.");
-          b = Mn(r.anchors, f$1, n2);
+          currentSelector = resolveAnchors(anchorCtx.anchors, rawSelector, opts);
         } else
-          b = f$1;
-        const g = /* @__PURE__ */ new Set(), x = [];
-        for (const w2 of this.providers) {
-          const T = w2.selectColumns(b);
-          for (const S of T) {
-            if (u2(S.spec)) continue;
-            if (g.has(S.id))
-              throw new Error(`Duplicate column id ${S.id} in provider ${w2.constructor.name}`);
-            const F = Qn(S.spec);
-            h2.has(F) || (g.add(S.id), h2.add(F), x.push(S));
+          currentSelector = rawSelector;
+        const selectedIds = /* @__PURE__ */ new Set();
+        const selectedColumns = [];
+        for (const provider of this.providers) {
+          const providerColumns = provider.selectColumns(currentSelector);
+          for (const col of providerColumns) {
+            if (excludePredicate(col.spec))
+              continue;
+            if (selectedIds.has(col.id))
+              throw new Error(`Duplicate column id ${col.id} in provider ${provider.constructor.name}`);
+            const nativeId = deriveNativeId(col.spec);
+            if (selectedNativeIds.has(nativeId))
+              continue;
+            selectedIds.add(col.id);
+            selectedNativeIds.add(nativeId);
+            selectedColumns.push(col);
           }
         }
-        if (x.length === 0) continue;
-        const A = Ft(f$1), C = A.length > 0;
-        for (const w2 of x) {
-          if (!f(w2.spec)) continue;
-          const T = w2.spec;
-          if (C) {
-            if (Et(w2.data))
-              throw new Error(`Splitting is not supported for PColumns with PColumnValues data format. Column id: ${w2.id}`);
-            const S = Tt(w2.data);
-            if (!S) {
-              if (s2) continue;
-              return;
+        if (selectedColumns.length === 0)
+          continue;
+        const splitAxisIdxs = getSplitAxisIndices(rawSelector);
+        const needsSplitting = splitAxisIdxs.length > 0;
+        for (const column of selectedColumns) {
+          if (!isPColumnSpec(column.spec))
+            continue;
+          const originalSpec = column.spec;
+          if (needsSplitting) {
+            if (isPColumnValues(column.data))
+              throw new Error(`Splitting is not supported for PColumns with PColumnValues data format. Column id: ${column.id}`);
+            const dataEntries = convertOrParsePColumnData(column.data);
+            if (!dataEntries) {
+              if (dontWaitAllData)
+                continue;
+              return void 0;
             }
-            if (!Sn(S))
-              throw new Error(`Splitting requires Partitioned DataInfoEntries, but parsing resulted in ${S.type} for column ${w2.id}`);
-            const F = It(S), D = A[A.length - 1];
-            if (D >= S.partitionKeyLength)
-              throw new Error(`Not enough partition keys (${S.partitionKeyLength}) for requested split axes (max index ${D}) in column ${T.name}`);
-            const W = A.map((_) => this.findLabels(p$1(T.axesSpec[_]))), j2 = [], $ = (_, G) => {
-              if (G >= A.length) {
-                if (j2.push([..._]), j2.length > 1e4)
+            if (!isPartitionedDataInfoEntries(dataEntries))
+              throw new Error(`Splitting requires Partitioned DataInfoEntries, but parsing resulted in ${dataEntries.type} for column ${column.id}`);
+            const uniqueKeys = getUniquePartitionKeys(dataEntries);
+            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 keyCombinations = [];
+            const generateCombinations = (currentCombo, sAxisIdx) => {
+              if (sAxisIdx >= splitAxisIdxs.length) {
+                keyCombinations.push([...currentCombo]);
+                if (keyCombinations.length > 1e4)
                   throw new Error("Too many key combinations, aborting.");
                 return;
               }
-              const N2 = A[G];
-              if (N2 >= F.length)
-                throw new Error(`Axis index ${N2} out of bounds for unique keys array (length ${F.length}) during split key generation for column ${w2.id}`);
-              const J2 = F[N2];
-              if (!J2 || J2.length === 0) {
-                j2.length = 0;
+              const axisIdx = splitAxisIdxs[sAxisIdx];
+              if (axisIdx >= uniqueKeys.length)
+                throw new Error(`Axis index ${axisIdx} out of bounds for unique keys array (length ${uniqueKeys.length}) during split key generation for column ${column.id}`);
+              const axisValues = uniqueKeys[axisIdx];
+              if (!axisValues || axisValues.length === 0) {
+                keyCombinations.length = 0;
                 return;
               }
-              for (const ee of J2)
-                _.push(ee), $(_, G + 1), _.pop();
+              for (const val of axisValues) {
+                currentCombo.push(val);
+                generateCombinations(currentCombo, sAxisIdx + 1);
+                currentCombo.pop();
+              }
             };
-            if ($([], 0), j2.length === 0)
+            generateCombinations([], 0);
+            if (keyCombinations.length === 0)
               continue;
-            const K2 = [...T.axesSpec], Ge = A.map((_) => _);
-            for (let _ = A.length - 1; _ >= 0; _--)
-              K2.splice(A[_], 1);
-            const He = { ...T, axesSpec: K2 };
-            for (const _ of j2) {
-              const G = _.map((N2, J2) => {
-                const ee = Ge[J2], qe = p$1(T.axesSpec[ee]), ce = W[J2], ze = (ce == null ? void 0 : ce[N2]) ?? String(N2);
-                return { axisIdx: ee, axisId: qe, value: N2, label: ze };
+            const newAxesSpec = [...originalSpec.axesSpec];
+            const splitAxisOriginalIdxs = splitAxisIdxs.map((idx) => idx);
+            for (let i = splitAxisIdxs.length - 1; i >= 0; i--) {
+              newAxesSpec.splice(splitAxisIdxs[i], 1);
+            }
+            const adjustedSpec = { ...originalSpec, axesSpec: newAxesSpec };
+            for (const keyCombo of keyCombinations) {
+              const splitFilters = keyCombo.map((value, sAxisIdx) => {
+                const axisIdx = splitAxisOriginalIdxs[sAxisIdx];
+                const axisId = getAxisId(originalSpec.axesSpec[axisIdx]);
+                const axisLabelMap = axesLabels[sAxisIdx];
+                const label = (axisLabelMap == null ? void 0 : axisLabelMap[value]) ?? String(value);
+                return { axisIdx, axisId, value, label };
               });
-              d.push({
+              intermediateResults.push({
                 type: "split",
-                originalColumn: w2,
-                spec: T,
-                adjustedSpec: He,
-                dataEntries: S,
-                axisFilters: G
+                originalColumn: column,
+                spec: originalSpec,
+                adjustedSpec,
+                dataEntries,
+                axisFilters: splitFilters
               });
             }
-          } else
-            d.push({
+          } else {
+            intermediateResults.push({
               type: "direct",
-              originalColumn: w2,
-              spec: T,
-              adjustedSpec: T
+              originalColumn: column,
+              spec: originalSpec,
+              adjustedSpec: originalSpec
             });
+          }
         }
       }
-      if (d.length === 0) return [];
-      const p2 = $e(
-        d,
-        (f2) => ({
-          spec: f2.spec,
-          suffixTrace: f2.type === "split" ? kt(f2.axisFilters) : void 0
-        }),
-        l2
-      ), m2 = [];
-      for (const { value: f2, label: v } of p2) {
-        const { originalColumn: b, spec: g } = f2, x = f2.type === "split" ? f2.axisFilters : void 0, A = Ot(x);
-        let C;
-        r ? C = r.deriveS(g, A) : C = Rt(b.id, A);
-        let w2 = { ...f2.adjustedSpec };
-        o && (w2 = {
-          ...w2,
-          annotations: {
-            ...w2.annotations ?? {},
-            "pl7.app/label": v
-          }
-        }), m2.push({
-          id: C,
-          spec: w2,
-          data: () => f2.type === "split" ? Jn(Lt(f2.dataEntries, A)) : f2.originalColumn.data,
-          label: v
+      if (intermediateResults.length === 0)
+        return [];
+      const labeledResults = deriveLabels(intermediateResults, (entry) => ({
+        spec: entry.spec,
+        suffixTrace: entry.type === "split" ? splitFiltersToTrace(entry.axisFilters) : void 0
+      }), labelOps);
+      const result = [];
+      for (const { value: entry, label } of labeledResults) {
+        const { originalColumn, spec: originalSpec } = entry;
+        const axisFilters = entry.type === "split" ? entry.axisFilters : void 0;
+        const axisFiltersTuple = splitFiltersToAxisFilter(axisFilters);
+        let finalId;
+        if (anchorCtx)
+          finalId = anchorCtx.deriveS(originalSpec, axisFiltersTuple);
+        else
+          finalId = fallbackIdDeriver(originalColumn.id, axisFiltersTuple);
+        let finalSpec = { ...entry.adjustedSpec };
+        if (overrideLabelAnnotation) {
+          finalSpec = {
+            ...finalSpec,
+            annotations: {
+              ...finalSpec.annotations ?? {},
+              [Annotation.Label]: label
+            }
+          };
+        }
+        result.push({
+          id: finalId,
+          spec: finalSpec,
+          data: () => entry.type === "split" ? entriesToDataInfo(filterDataInfoEntries(entry.dataEntries, axisFiltersTuple)) : entry.originalColumn.data,
+          label
         });
       }
-      return m2;
+      return result;
     }
-    getColumns(e, n2) {
-      const r = this.getUniversalEntries(e, {
+    getColumns(predicateOrSelectors, opts) {
+      const entries = this.getUniversalEntries(predicateOrSelectors, {
         overrideLabelAnnotation: true,
         // default for getColumns
-        ...n2 ?? {}
+        ...opts ?? {}
       });
-      if (!r) return;
-      const i = [];
-      for (const s2 of r) {
-        const o = s2.data();
-        if (!o) {
-          if (n2 != null && n2.dontWaitAllData) continue;
-          return;
+      if (!entries)
+        return void 0;
+      const columns = [];
+      for (const entry of entries) {
+        const data = entry.data();
+        if (!data) {
+          if (opts == null ? void 0 : opts.dontWaitAllData)
+            continue;
+          return void 0;
         }
-        i.push({
-          id: s2.id,
-          spec: s2.spec,
-          data: o
+        columns.push({
+          id: entry.id,
+          spec: entry.spec,
+          data
         });
       }
-      return i;
+      return columns;
     }
   }
-  function pe(t, e) {
-    if (t === void 0) return e === void 0;
-    if (e === void 0) return true;
-    for (const n2 in e)
-      if (t[n2] !== e[n2]) return false;
+  function patchInSetFilters(filters) {
+    const inSetToOrEqual = (predicate) => {
+      if (predicate.operator !== "InSet")
+        return predicate;
+      return {
+        operator: "Or",
+        operands: predicate.references.map((reference) => ({
+          operator: "Equal",
+          reference
+        }))
+      };
+    };
+    const mapSingleValuePredicate = (filter, cb) => {
+      const operator = filter.operator;
+      switch (operator) {
+        case "And":
+          return {
+            ...filter,
+            operands: filter.operands.map((operand) => mapSingleValuePredicate(operand, cb))
+          };
+        case "Or":
+          return {
+            ...filter,
+            operands: filter.operands.map((operand) => mapSingleValuePredicate(operand, cb))
+          };
+        case "Not":
+          return {
+            ...filter,
+            operand: mapSingleValuePredicate(filter.operand, cb)
+          };
+        default:
+          return cb(filter);
+      }
+    };
+    const mapFilter = (filter, cb) => {
+      return {
+        ...filter,
+        predicate: mapSingleValuePredicate(filter.predicate, cb)
+      };
+    };
+    return filters.map((filter) => mapFilter(filter, inSetToOrEqual));
+  }
+  function matchDomain(query, target) {
+    if (query === void 0)
+      return target === void 0;
+    if (target === void 0)
+      return true;
+    for (const k in target) {
+      if (query[k] !== target[k])
+        return false;
+    }
     return true;
   }
-  function Ee(t) {
-    return Wn(t, (e) => e instanceof E ? e.handle : En(e) ? Nn(e, (n2) => n2.handle) : e);
+  function transformPColumnData(data) {
+    return mapPObjectData(data, (d) => {
+      if (d instanceof TreeNodeAccessor) {
+        return d.handle;
+      } else if (isDataInfo(d)) {
+        return mapDataInfo(d, (accessor) => accessor.handle);
+      } else {
+        return d;
+      }
+    });
   }
-  class Kt {
+  class ResultPool {
     constructor() {
-      k(this, "ctx", y());
+      __publicField(this, "ctx", getCfgRenderCtx());
     }
     /**
      * @deprecated use getOptions()
      */
-    calculateOptions(e) {
-      return this.ctx.calculateOptions(e);
-    }
-    getOptions(e, n2) {
-      const r = typeof e == "function" ? e : Gn(e), i = this.getSpecs().entries.filter((a) => r(a.obj));
-      let s2 = {}, o = false;
-      return typeof n2 < "u" && (typeof n2 == "function" ? s2 = n2 : typeof n2 == "object" && ("includeNativeLabel" in n2 || "separator" in n2 || "addLabelAsSuffix" in n2 ? s2 = n2 : (n2 = n2, s2 = n2.label ?? {}, o = n2.refsWithEnrichments ?? false))), typeof s2 == "object" ? $e(i, (a) => a.obj, s2 ?? {}).map(({ value: { ref: a }, label: l2 }) => ({
-        ref: te$1(a, o),
-        label: l2
-      })) : i.map(({ ref: a, obj: l2 }) => ({
-        ref: te$1(a, o),
-        label: s2(l2, a)
-      }));
+    calculateOptions(predicate) {
+      return this.ctx.calculateOptions(predicate);
+    }
+    getOptions(predicateOrSelector, opts) {
+      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") {
+          labelOps = opts;
+        } else if (typeof opts === "object") {
+          if ("includeNativeLabel" in opts || "separator" in opts || "addLabelAsSuffix" in opts) {
+            labelOps = opts;
+          } else {
+            opts = opts;
+            labelOps = opts.label ?? {};
+            refsWithEnrichments = opts.refsWithEnrichments ?? false;
+          }
+        }
+      }
+      if (typeof labelOps === "object")
+        return deriveLabels(filtered, (o) => o.obj, labelOps ?? {}).map(({ value: { ref }, label }) => ({
+          ref: withEnrichments(ref, refsWithEnrichments),
+          label
+        }));
+      else
+        return filtered.map(({ ref, obj }) => ({
+          ref: withEnrichments(ref, refsWithEnrichments),
+          label: labelOps(obj, ref)
+        }));
     }
-    resolveAnchorCtx(e) {
-      if (e instanceof _n) return e;
-      const n2 = {};
-      for (const [r, i] of Object.entries(e))
-        if (ne(i)) {
-          const s2 = this.getPColumnSpecByRef(i);
-          if (!s2)
-            return;
-          n2[r] = s2;
-        } else
-          n2[r] = i;
-      return new _n(n2);
+    resolveAnchorCtx(anchorsOrCtx) {
+      if (anchorsOrCtx instanceof AnchoredIdDeriver)
+        return anchorsOrCtx;
+      const resolvedAnchors = {};
+      for (const [key, value] of Object.entries(anchorsOrCtx)) {
+        if (isPlRef(value)) {
+          const resolvedSpec = this.getPColumnSpecByRef(value);
+          if (!resolvedSpec)
+            return void 0;
+          resolvedAnchors[key] = resolvedSpec;
+        } else {
+          resolvedAnchors[key] = value;
+        }
+      }
+      return new AnchoredIdDeriver(resolvedAnchors);
     }
     /**
      * Returns columns that match the provided anchors and selectors. It applies axis filters and label derivation.
@@ -5414,13 +5799,14 @@
      * @param opts - Optional configuration for label generation and data waiting
      * @returns A PFrameHandle for the created PFrame, or undefined if any required data is missing
      */
-    getAnchoredPColumns(e, n2, r) {
-      const i = this.resolveAnchorCtx(e);
-      if (i)
-        return new le().addColumnProvider(this).addAxisLabelProvider(this).getColumns(n2, {
-          ...r,
-          anchorCtx: i
-        });
+    getAnchoredPColumns(anchorsOrCtx, predicateOrSelectors, opts) {
+      const anchorCtx = this.resolveAnchorCtx(anchorsOrCtx);
+      if (!anchorCtx)
+        return void 0;
+      return new PColumnCollection().addColumnProvider(this).addAxisLabelProvider(this).getColumns(predicateOrSelectors, {
+        ...opts,
+        anchorCtx
+      });
     }
     /**
      * Calculates anchored identifier options for columns matching a given predicate and returns their
@@ -5451,18 +5837,20 @@
      * @returns An array of objects with `label` (display text) and `value` (anchored ID string) properties,
      *          or undefined if any PlRef resolution fails.
      */
-    getCanonicalOptions(e, n2, r) {
-      const i = this.resolveAnchorCtx(e);
-      if (!i) return;
-      const s2 = new le().addColumnProvider(this).addAxisLabelProvider(this).getUniversalEntries(n2, {
-        ...r,
-        anchorCtx: i
+    getCanonicalOptions(anchorsOrCtx, predicateOrSelectors, opts) {
+      const anchorCtx = this.resolveAnchorCtx(anchorsOrCtx);
+      if (!anchorCtx)
+        return void 0;
+      const entries = new PColumnCollection().addColumnProvider(this).addAxisLabelProvider(this).getUniversalEntries(predicateOrSelectors, {
+        ...opts,
+        anchorCtx
       });
-      if (s2)
-        return s2.map((o) => ({
-          value: o.id,
-          label: o.label
-        }));
+      if (!entries)
+        return void 0;
+      return entries.map((item) => ({
+        value: item.id,
+        label: item.label
+      }));
     }
     /**
      * @deprecated use getData()
@@ -5471,14 +5859,14 @@
       return this.getData();
     }
     getData() {
-      const e = this.ctx.getDataFromResultPool();
+      const result = this.ctx.getDataFromResultPool();
       return {
-        isComplete: e.isComplete,
-        entries: e.entries.map((n2) => ({
-          ref: n2.ref,
+        isComplete: result.isComplete,
+        entries: result.entries.map((e) => ({
+          ref: e.ref,
           obj: {
-            ...n2.obj,
-            data: new E(n2.obj.data, [n2.ref.blockId, n2.ref.name])
+            ...e.obj,
+            data: new TreeNodeAccessor(e.obj.data, [e.ref.blockId, e.ref.name])
           }
         }))
       };
@@ -5490,17 +5878,14 @@
       return this.getDataWithErrors();
     }
     getDataWithErrors() {
-      const e = this.ctx.getDataWithErrorsFromResultPool();
+      const result = this.ctx.getDataWithErrorsFromResultPool();
       return {
-        isComplete: e.isComplete,
-        entries: e.entries.map((n2) => ({
-          ref: n2.ref,
+        isComplete: result.isComplete,
+        entries: result.entries.map((e) => ({
+          ref: e.ref,
           obj: {
-            ...n2.obj,
-            data: oe$1(
-              n2.obj.data,
-              (r) => new E(r, [n2.ref.blockId, n2.ref.name])
-            )
+            ...e.obj,
+            data: mapValueInVOE(e.obj.data, (handle) => new TreeNodeAccessor(handle, [e.ref.blockId, e.ref.name]))
           }
         }))
       };
@@ -5518,89 +5903,106 @@
      * @param ref a Ref
      * @returns data associated with the ref
      */
-    getDataByRef(e) {
-      var r;
-      if (typeof this.ctx.getDataFromResultPoolByRef > "u")
-        return (r = this.getData().entries.find(
-          (i) => i.ref.blockId === e.blockId && i.ref.name === e.name
-        )) == null ? void 0 : r.obj;
-      const n2 = this.ctx.getDataFromResultPoolByRef(e.blockId, e.name);
-      if (n2)
-        return Wn(
-          n2,
-          (i) => new E(i, [e.blockId, e.name])
-        );
+    getDataByRef(ref) {
+      var _a;
+      if (typeof this.ctx.getDataFromResultPoolByRef === "undefined")
+        return (_a = this.getData().entries.find((f) => f.ref.blockId === ref.blockId && f.ref.name === ref.name)) == null ? void 0 : _a.obj;
+      const data = this.ctx.getDataFromResultPoolByRef(ref.blockId, ref.name);
+      if (!data)
+        return void 0;
+      return mapPObjectData(data, (handle) => new TreeNodeAccessor(handle, [ref.blockId, ref.name]));
     }
     /**
      * Returns data associated with the ref ensuring that it is a p-column.
      * @param ref a Ref
      * @returns p-column associated with the ref
      */
-    getPColumnByRef(e) {
-      const n2 = this.getDataByRef(e);
-      if (n2)
-        return qn(n2);
+    getPColumnByRef(ref) {
+      const data = this.getDataByRef(ref);
+      if (!data)
+        return void 0;
+      return ensurePColumn(data);
     }
     /**
      * Returns spec associated with the ref ensuring that it is a p-column spec.
      * @param ref a Ref
      * @returns p-column spec associated with the ref
      */
-    getPColumnSpecByRef(e) {
-      const n2 = this.getSpecByRef(e);
-      if (n2) {
-        if (!f(n2)) throw new Error(`not a PColumn spec (kind = ${n2.kind})`);
-        return n2;
-      }
+    getPColumnSpecByRef(ref) {
+      const spec = this.getSpecByRef(ref);
+      if (!spec)
+        return void 0;
+      if (!isPColumnSpec(spec))
+        throw new Error(`not a PColumn spec (kind = ${spec.kind})`);
+      return spec;
     }
     /**
      * @param ref a Ref
      * @returns object spec associated with the ref
      */
-    getSpecByRef(e) {
-      return this.ctx.getSpecFromResultPoolByRef(e.blockId, e.name);
+    getSpecByRef(ref) {
+      return this.ctx.getSpecFromResultPoolByRef(ref.blockId, ref.name);
     }
     /**
      * @param spec object specification
      * @returns array of data objects with compatible specs
      * @deprecated delete this method after Jan 1, 2025
      */
-    findDataWithCompatibleSpec(e) {
-      const n2 = [];
-      e: for (const r of this.getData().entries) {
-        if (!f(r.obj.spec))
+    findDataWithCompatibleSpec(spec) {
+      const result = [];
+      out: for (const data of this.getData().entries) {
+        if (!isPColumnSpec(data.obj.spec)) {
           continue;
-        const i = r.obj.spec;
-        if (e.name === i.name && e.valueType === i.valueType && e.axesSpec.length === i.axesSpec.length && pe(e.domain, i.domain)) {
-          for (let s2 = 0; s2 < e.axesSpec.length; ++s2) {
-            const o = e.axesSpec[s2], a = i.axesSpec[s2];
-            if (o.name !== a.name || o.type !== a.type || !pe(o.domain, a.domain))
-              continue e;
+        }
+        const oth = data.obj.spec;
+        if (spec.name !== oth.name) {
+          continue;
+        }
+        if (spec.valueType !== oth.valueType) {
+          continue;
+        }
+        if (spec.axesSpec.length !== oth.axesSpec.length) {
+          continue;
+        }
+        if (!matchDomain(spec.domain, oth.domain)) {
+          continue;
+        }
+        for (let i = 0; i < spec.axesSpec.length; ++i) {
+          const qAx = spec.axesSpec[i];
+          const tAx = oth.axesSpec[i];
+          if (qAx.name !== tAx.name) {
+            continue out;
+          }
+          if (qAx.type !== tAx.type) {
+            continue out;
+          }
+          if (!matchDomain(qAx.domain, tAx.domain)) {
+            continue out;
           }
-          n2.push(r.obj);
         }
+        result.push(data.obj);
       }
-      return n2;
+      return result;
     }
     /**
      * Find labels data for a given axis id. It will search for a label column and return its data as a map.
      * @returns a map of axis value => label
      */
-    findLabels(e) {
-      const n2 = this.getData();
-      for (const r of n2.entries) {
-        if (!rn(r.obj)) continue;
-        const i = r.obj.spec;
-        if (i.name === "pl7.app/label" && i.axesSpec.length === 1 && i.axesSpec[0].name === e.name && i.axesSpec[0].type === e.type && pe(e.domain, i.axesSpec[0].domain)) {
-          if (r.obj.data.resourceType.name !== "PColumnData/Json")
-            throw Error(`Expected JSON column for labels, got: ${r.obj.data.resourceType.name}`);
-          return Object.fromEntries(
-            Object.entries(
-              r.obj.data.getDataAsJson().data
-            ).map((o) => [JSON.parse(o[0])[0], o[1]])
-          );
+    findLabels(axis) {
+      const dataPool = this.getData();
+      for (const column of dataPool.entries) {
+        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") {
+            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]]));
+          return labels;
         }
       }
+      return void 0;
     }
     /**
      * Selects columns based on the provided selectors, returning PColumn objects
@@ -5609,18 +6011,27 @@
      * @param selectors - A predicate function, a single selector, or an array of selectors.
      * @returns An array of PColumn objects matching the selectors. Data is loaded on first access.
      */
-    selectColumns(e) {
-      const n2 = typeof e == "function" ? e : Gn(e);
-      return this.getSpecs().entries.filter(({ obj: i }) => f(i) ? n2(i) : false).map(({ ref: i, obj: s2 }) => {
-        const o = s2;
-        let a = null;
-        const l2 = this;
+    selectColumns(selectors) {
+      const predicate = typeof selectors === "function" ? selectors : selectorsToPredicate(selectors);
+      const matchedSpecs = this.getSpecs().entries.filter(({ obj: spec }) => {
+        if (!isPColumnSpec(spec))
+          return false;
+        return predicate(spec);
+      });
+      return matchedSpecs.map(({ ref, obj: spec }) => {
+        const pcolumnSpec = spec;
+        let _cachedData = null;
+        const self2 = this;
         return {
-          id: Re(i),
-          spec: o,
+          id: canonicalize(ref),
+          spec: pcolumnSpec,
           get data() {
-            var u2;
-            return a !== null || (a = (u2 = l2.getPColumnByRef(i)) == null ? void 0 : u2.data), a;
+            var _a;
+            if (_cachedData !== null) {
+              return _cachedData;
+            }
+            _cachedData = (_a = self2.getPColumnByRef(ref)) == null ? void 0 : _a.data;
+            return _cachedData;
           }
         };
       });
@@ -5629,288 +6040,272 @@
      * Find labels data for a given axis id of a p-column.
      * @returns a map of axis value => label
      */
-    findLabelsForColumnAxis(e, n2) {
-      var s2;
-      const r = this.findLabels(e.axesSpec[n2]);
-      if (!r) return;
-      const i = (s2 = e.annotations) == null ? void 0 : s2["pl7.app/axisKeys/" + n2];
-      if (i !== void 0) {
-        const o = JSON.parse(i);
-        return Object.fromEntries(o.map((a) => [a, r[a] ?? "Unlabelled"]));
-      } else
-        return r;
+    findLabelsForColumnAxis(column, axisIdx) {
+      const labels = this.findLabels(column.axesSpec[axisIdx]);
+      if (!labels)
+        return void 0;
+      const axisKeys = readAnnotation(column, `pl7.app/axisKeys/${axisIdx}`);
+      if (axisKeys !== void 0) {
+        const keys = JSON.parse(axisKeys);
+        return Object.fromEntries(keys.map((key) => {
+          return [key, labels[key] ?? "Unlabelled"];
+        }));
+      } else {
+        return labels;
+      }
     }
   }
-  class te {
+  class RenderCtx {
     constructor() {
-      k(this, "ctx");
-      k(this, "args");
-      k(this, "uiState");
-      k(this, "_activeArgsCache");
-      k(this, "resultPool", new Kt());
-      this.ctx = y(), this.args = JSON.parse(this.ctx.args), this.uiState = this.ctx.uiState !== void 0 ? JSON.parse(this.ctx.uiState) : {};
+      __publicField(this, "ctx");
+      __publicField(this, "_argsCache");
+      __publicField(this, "_uiStateCache");
+      // lazy rendering because this feature is rarely used
+      __publicField(this, "_activeArgsCache");
+      __publicField(this, "resultPool", new ResultPool());
+      this.ctx = getCfgRenderCtx();
+    }
+    get args() {
+      if (this._argsCache === void 0) {
+        const raw = this.ctx.args;
+        const value = typeof raw === "function" ? raw() : raw;
+        this._argsCache = { v: JSON.parse(value) };
+      }
+      return this._argsCache.v;
+    }
+    get uiState() {
+      if (this._uiStateCache === void 0) {
+        const raw = this.ctx.uiState;
+        const value = typeof raw === "function" ? raw() : raw;
+        this._uiStateCache = { v: value ? JSON.parse(value) : {} };
+      }
+      return this._uiStateCache.v;
     }
     /**
      * Returns args snapshot the block was executed for (i.e. when "Run" button was pressed).
      * Returns undefined, if block was never executed or stopped mid-way execution, so that the result was cleared.
      * */
     get activeArgs() {
-      return this._activeArgsCache === void 0 && (this._activeArgsCache = {
-        v: this.ctx.activeArgs ? JSON.parse(this.ctx.activeArgs) : void 0
-      }), this._activeArgsCache.v;
+      if (this._activeArgsCache === void 0) {
+        const raw = this.ctx.activeArgs;
+        const value = typeof raw === "function" ? raw() : raw;
+        this._activeArgsCache = {
+          v: value ? JSON.parse(value) : void 0
+        };
+      }
+      return this._activeArgsCache.v;
     }
     // /** Can be used to determine features provided by the desktop instance. */
     // public get featureFlags() {
     //   return this.ctx.featureFlags;
     // }
-    getNamedAccessor(e) {
-      return ge(
-        this.ctx.getAccessorHandleByName(e),
-        (n2) => new E(n2, [e])
-      );
+    getNamedAccessor(name) {
+      return ifDef(this.ctx.getAccessorHandleByName(name), (accessor) => new TreeNodeAccessor(accessor, [name]));
     }
     get prerun() {
-      return this.getNamedAccessor(Ve);
+      return this.getNamedAccessor(StagingAccessorName);
     }
     get outputs() {
-      return this.getNamedAccessor(je);
+      return this.getNamedAccessor(MainAccessorName);
     }
     /**
      * Find labels data for a given axis id. It will search for a label column and return its data as a map.
      * @returns a map of axis value => label
      * @deprecated Use resultPool.findLabels instead
      */
-    findLabels(e) {
-      return this.resultPool.findLabels(e);
+    findLabels(axis) {
+      return this.resultPool.findLabels(axis);
+    }
+    verifyInlineAndExplicitColumnsSupport(columns) {
+      var _a;
+      const hasInlineColumns = columns.some((c) => !(c.data instanceof TreeNodeAccessor) || isDataInfo(c.data));
+      const inlineColumnsSupport = ((_a = this.ctx.featureFlags) == null ? void 0 : _a.inlineColumnsSupport) === true;
+      if (hasInlineColumns && !inlineColumnsSupport)
+        throw Error(`Inline or explicit columns not supported`);
     }
-    verifyInlineAndExplicitColumnsSupport(e) {
-      var i;
-      const n2 = e.some((s2) => !(s2.data instanceof E) || En(s2.data)), r = ((i = this.ctx.featureFlags) == null ? void 0 : i.inlineColumnsSupport) === true;
-      if (n2 && !r) throw Error("Inline or explicit columns not supported");
+    patchPTableDef(def) {
+      var _a, _b;
+      if (!((_a = this.ctx.featureFlags) == null ? void 0 : _a.pTablePartitionFiltersSupport)) {
+        def = {
+          ...def,
+          partitionFilters: [],
+          filters: [...def.partitionFilters, ...def.filters]
+        };
+      }
+      if (!((_b = this.ctx.featureFlags) == null ? void 0 : _b.pFrameInSetFilterSupport)) {
+        def = {
+          ...def,
+          partitionFilters: patchInSetFilters(def.partitionFilters),
+          filters: patchInSetFilters(def.filters)
+        };
+      }
+      return def;
     }
     // TODO remove all non-PColumn fields
-    createPFrame(e) {
-      return this.verifyInlineAndExplicitColumnsSupport(e), this.ctx.createPFrame(
-        e.map((n2) => Ee(n2))
-      );
-    }
-    createPTable(e) {
-      let n2;
-      return "columns" in e ? n2 = {
-        src: {
-          type: "full",
-          entries: e.columns.map((r) => ({ type: "column", column: r }))
-        },
-        filters: e.filters ?? [],
-        sorting: e.sorting ?? []
-      } : n2 = e, this.verifyInlineAndExplicitColumnsSupport(Xn(n2.src)), this.ctx.createPTable(
-        Un(n2, (r) => Ee(r))
-      );
+    createPFrame(def) {
+      this.verifyInlineAndExplicitColumnsSupport(def);
+      return this.ctx.createPFrame(def.map((c) => transformPColumnData(c)));
+    }
+    createPTable(def) {
+      let rawDef;
+      if ("columns" in def) {
+        rawDef = this.patchPTableDef({
+          src: {
+            type: "full",
+            entries: def.columns.map((c) => ({ type: "column", column: c }))
+          },
+          partitionFilters: def.filters ?? [],
+          filters: [],
+          sorting: def.sorting ?? []
+        });
+      } else {
+        rawDef = this.patchPTableDef(def);
+      }
+      this.verifyInlineAndExplicitColumnsSupport(extractAllColumns(rawDef.src));
+      return this.ctx.createPTable(mapPTableDef(rawDef, (po) => transformPColumnData(po)));
     }
     /** @deprecated scheduled for removal from SDK */
-    getBlockLabel(e) {
-      return this.ctx.getBlockLabel(e);
+    getBlockLabel(blockId) {
+      return this.ctx.getBlockLabel(blockId);
     }
     getCurrentUnstableMarker() {
       return this.ctx.getCurrentUnstableMarker();
     }
-    logInfo(e) {
-      this.ctx.logInfo(e);
-    }
-    logWarn(e) {
-      this.ctx.logWarn(e);
-    }
-    logError(e) {
-      this.ctx.logError(e);
-    }
-  }
-  const Y = "1.37.2";
-  function Vt(t) {
-    return t.__renderLambda === true;
-  }
-  function fe(t) {
-    if (t !== void 0)
-      return Vt(t) ? t.handle : t;
-  }
-  class L {
-    constructor(e, n2, r, i, s2, o, a, l2) {
-      this._renderingMode = e, this._initialArgs = n2, this._initialUiState = r, this._outputs = i, this._inputsValid = s2, this._sections = o, this._title = a, this._enrichmentTargets = l2;
-    }
-    static create(e = "Heavy") {
-      return new L(
-        e,
-        void 0,
-        {},
-        {},
-        re(true),
-        re([]),
-        void 0,
-        void 0
-      );
-    }
-    output(e, n2, r = {}) {
-      if (typeof n2 == "function") {
-        const i = `output#${e}`;
-        return H(i, () => n2(new te())), new L(
-          this._renderingMode,
-          this._initialArgs,
-          this._initialUiState,
-          {
-            ...this._outputs,
-            [e]: {
-              __renderLambda: true,
-              handle: i,
-              ...r
-            }
-          },
-          this._inputsValid,
-          this._sections,
-          this._title,
-          this._enrichmentTargets
-        );
+    logInfo(msg) {
+      this.ctx.logInfo(msg);
+    }
+    logWarn(msg) {
+      this.ctx.logWarn(msg);
+    }
+    logError(msg) {
+      this.ctx.logError(msg);
+    }
+  }
+  var version = "1.43.2";
+  const PlatformaSDKVersion = version;
+  function isConfigLambda(cfgOrFh) {
+    return cfgOrFh.__renderLambda === true;
+  }
+  function downgradeCfgOrLambda(data) {
+    if (data === void 0)
+      return void 0;
+    if (isConfigLambda(data))
+      return data.handle;
+    return data;
+  }
+  const _BlockModel = class _BlockModel {
+    constructor(_renderingMode, _initialArgs, _initialUiState, _outputs, _inputsValid, _sections, _title, _enrichmentTargets, _featureFlags) {
+      __publicField(this, "_renderingMode");
+      __publicField(this, "_initialArgs");
+      __publicField(this, "_initialUiState");
+      __publicField(this, "_outputs");
+      __publicField(this, "_inputsValid");
+      __publicField(this, "_sections");
+      __publicField(this, "_title");
+      __publicField(this, "_enrichmentTargets");
+      __publicField(this, "_featureFlags");
+      this._renderingMode = _renderingMode;
+      this._initialArgs = _initialArgs;
+      this._initialUiState = _initialUiState;
+      this._outputs = _outputs;
+      this._inputsValid = _inputsValid;
+      this._sections = _sections;
+      this._title = _title;
+      this._enrichmentTargets = _enrichmentTargets;
+      this._featureFlags = _featureFlags;
+    }
+    static create(renderingMode = "Heavy") {
+      return new _BlockModel(renderingMode, void 0, {}, {}, getImmediate(true), getImmediate([]), void 0, void 0, { ..._BlockModel.INITIAL_BLOCK_FEATURE_FLAGS });
+    }
+    output(key, cfgOrRf, flags = {}) {
+      if (typeof cfgOrRf === "function") {
+        const handle = `output#${key}`;
+        tryRegisterCallback(handle, () => cfgOrRf(new RenderCtx()));
+        return new _BlockModel(this._renderingMode, this._initialArgs, this._initialUiState, {
+          ...this._outputs,
+          [key]: {
+            __renderLambda: true,
+            handle,
+            ...flags
+          }
+        }, this._inputsValid, this._sections, this._title, this._enrichmentTargets, this._featureFlags);
       } else
-        return new L(
-          this._renderingMode,
-          this._initialArgs,
-          this._initialUiState,
-          {
-            ...this._outputs,
-            [e]: n2
-          },
-          this._inputsValid,
-          this._sections,
-          this._title,
-          this._enrichmentTargets
-        );
+        return new _BlockModel(this._renderingMode, this._initialArgs, this._initialUiState, {
+          ...this._outputs,
+          [key]: cfgOrRf
+        }, this._inputsValid, this._sections, this._title, this._enrichmentTargets, this._featureFlags);
     }
     /** Shortcut for {@link output} with retentive flag set to true. */
-    retentiveOutput(e, n2) {
-      return this.output(e, n2, { retentive: true });
-    }
-    argsValid(e) {
-      return typeof e == "function" ? (H("inputsValid", () => e(new te())), new L(
-        this._renderingMode,
-        this._initialArgs,
-        this._initialUiState,
-        this._outputs,
-        {
+    retentiveOutput(key, rf) {
+      return this.output(key, rf, { retentive: true });
+    }
+    argsValid(cfgOrRf) {
+      if (typeof cfgOrRf === "function") {
+        tryRegisterCallback("inputsValid", () => cfgOrRf(new RenderCtx()));
+        return new _BlockModel(this._renderingMode, this._initialArgs, this._initialUiState, this._outputs, {
           __renderLambda: true,
           handle: "inputsValid"
-        },
-        this._sections,
-        this._title,
-        this._enrichmentTargets
-      )) : new L(
-        this._renderingMode,
-        this._initialArgs,
-        this._initialUiState,
-        this._outputs,
-        e,
-        this._sections,
-        this._title,
-        this._enrichmentTargets
-      );
-    }
-    sections(e) {
-      return Array.isArray(e) ? this.sections(re(e)) : typeof e == "function" ? (H("sections", () => e(new te())), new L(
-        this._renderingMode,
-        this._initialArgs,
-        this._initialUiState,
-        this._outputs,
-        this._inputsValid,
-        { __renderLambda: true, handle: "sections" },
-        this._title,
-        this._enrichmentTargets
-      )) : new L(
-        this._renderingMode,
-        this._initialArgs,
-        this._initialUiState,
-        this._outputs,
-        this._inputsValid,
-        e,
-        this._title,
-        this._enrichmentTargets
-      );
+        }, this._sections, this._title, this._enrichmentTargets, this._featureFlags);
+      } else
+        return new _BlockModel(this._renderingMode, this._initialArgs, this._initialUiState, this._outputs, cfgOrRf, this._sections, this._title, this._enrichmentTargets, this._featureFlags);
+    }
+    sections(arrOrCfgOrRf) {
+      if (Array.isArray(arrOrCfgOrRf)) {
+        return this.sections(getImmediate(arrOrCfgOrRf));
+      } else if (typeof arrOrCfgOrRf === "function") {
+        tryRegisterCallback("sections", () => arrOrCfgOrRf(new RenderCtx()));
+        return new _BlockModel(this._renderingMode, this._initialArgs, this._initialUiState, this._outputs, this._inputsValid, { __renderLambda: true, handle: "sections" }, this._title, this._enrichmentTargets, this._featureFlags);
+      } else
+        return new _BlockModel(this._renderingMode, this._initialArgs, this._initialUiState, this._outputs, this._inputsValid, arrOrCfgOrRf, this._title, this._enrichmentTargets, this._featureFlags);
     }
     /** Sets a rendering function to derive block title, shown for the block in the left blocks-overview panel. */
-    title(e) {
-      return H("title", () => e(new te())), new L(
-        this._renderingMode,
-        this._initialArgs,
-        this._initialUiState,
-        this._outputs,
-        this._inputsValid,
-        this._sections,
-        { __renderLambda: true, handle: "title" },
-        this._enrichmentTargets
-      );
+    title(rf) {
+      tryRegisterCallback("title", () => rf(new RenderCtx()));
+      return new _BlockModel(this._renderingMode, this._initialArgs, this._initialUiState, this._outputs, this._inputsValid, this._sections, { __renderLambda: true, handle: "title" }, this._enrichmentTargets, this._featureFlags);
     }
     /**
      * Sets initial args for the block, this value must be specified.
      * @deprecated use {@link withArgs}
      * */
-    initialArgs(e) {
-      return new L(
-        this._renderingMode,
-        e,
-        this._initialUiState,
-        this._outputs,
-        this._inputsValid,
-        this._sections,
-        this._title,
-        this._enrichmentTargets
-      );
+    initialArgs(value) {
+      return new _BlockModel(this._renderingMode, value, this._initialUiState, this._outputs, this._inputsValid, this._sections, this._title, this._enrichmentTargets, this._featureFlags);
     }
     /** Sets initial args for the block, this value must be specified. */
-    withArgs(e) {
-      return new L(
-        this._renderingMode,
-        e,
-        this._initialUiState,
-        this._outputs,
-        this._inputsValid,
-        this._sections,
-        this._title,
-        this._enrichmentTargets
-      );
+    withArgs(initialValue) {
+      return new _BlockModel(this._renderingMode, initialValue, this._initialUiState, this._outputs, this._inputsValid, this._sections, this._title, this._enrichmentTargets, this._featureFlags);
     }
     /** Defines type and sets initial value for block UiState. */
-    withUiState(e) {
-      return new L(
-        this._renderingMode,
-        this._initialArgs,
-        e,
-        this._outputs,
-        this._inputsValid,
-        this._sections,
-        this._title,
-        this._enrichmentTargets
-      );
+    withUiState(initialValue) {
+      return new _BlockModel(this._renderingMode, this._initialArgs, initialValue, this._outputs, this._inputsValid, this._sections, this._title, this._enrichmentTargets, this._featureFlags);
+    }
+    /** Sets or overrides feature flags for the block. */
+    withFeatureFlags(flags) {
+      return new _BlockModel(this._renderingMode, this._initialArgs, this._initialUiState, this._outputs, this._inputsValid, this._sections, this._title, this._enrichmentTargets, { ...this._featureFlags, ...flags });
     }
     /**
      * Defines how to derive list of upstream references this block is meant to enrich with its exports from block args.
      * Influences dependency graph construction.
      */
-    enriches(e) {
-      return H("enrichmentTargets", e), new L(
-        this._renderingMode,
-        this._initialArgs,
-        this._initialUiState,
-        this._outputs,
-        this._inputsValid,
-        this._sections,
-        this._title,
-        { __renderLambda: true, handle: "enrichmentTargets" }
-      );
+    enriches(lambda) {
+      tryRegisterCallback("enrichmentTargets", lambda);
+      return new _BlockModel(this._renderingMode, this._initialArgs, this._initialUiState, this._outputs, this._inputsValid, this._sections, this._title, { __renderLambda: true, handle: "enrichmentTargets" }, this._featureFlags);
     }
     /** Renders all provided block settings into a pre-configured platforma API
      * instance, that can be used in frontend to interact with block state, and
      * other features provided by the platforma to the block. */
-    done() {
-      if (this._initialArgs === void 0) throw new Error("Initial arguments not set.");
-      const e = {
+    done(apiVersion) {
+      const requiresUIAPIVersion = apiVersion ?? 1;
+      return this.withFeatureFlags({
+        ...this._featureFlags,
+        requiresUIAPIVersion
+      })._done(requiresUIAPIVersion);
+    }
+    _done(apiVersion) {
+      if (this._initialArgs === void 0)
+        throw new Error("Initial arguments not set.");
+      const config = {
         v3: {
-          sdkVersion: Y,
+          sdkVersion: PlatformaSDKVersion,
           renderingMode: this._renderingMode,
           initialArgs: this._initialArgs,
           initialUiState: this._initialUiState,
@@ -5918,152 +6313,340 @@
           sections: this._sections,
           title: this._title,
           outputs: this._outputs,
-          enrichmentTargets: this._enrichmentTargets
+          enrichmentTargets: this._enrichmentTargets,
+          featureFlags: this._featureFlags
         },
         // fields below are added to allow previous desktop versions read generated configs
-        sdkVersion: Y,
+        sdkVersion: PlatformaSDKVersion,
         renderingMode: this._renderingMode,
         initialArgs: this._initialArgs,
-        inputsValid: fe(this._inputsValid),
-        sections: fe(this._sections),
-        outputs: Object.fromEntries(
-          Object.entries(this._outputs).map(([n2, r]) => [n2, fe(r)])
-        )
+        inputsValid: downgradeCfgOrLambda(this._inputsValid),
+        sections: downgradeCfgOrLambda(this._sections),
+        outputs: Object.fromEntries(Object.entries(this._outputs).map(([key, value]) => [key, downgradeCfgOrLambda(value)]))
       };
-      return ht() ? Ke({ sdkVersion: Y }) : { config: e };
+      globalThis.platformaApiVersion = apiVersion;
+      if (!isInUI())
+        return { config };
+      else
+        return getPlatformaInstance({ sdkVersion: PlatformaSDKVersion, apiVersion: platformaApiVersion });
     }
+  };
+  __publicField(_BlockModel, "INITIAL_BLOCK_FEATURE_FLAGS", {
+    supportsLazyState: true,
+    requiresUIAPIVersion: 1,
+    requiresModelAPIVersion: 1
+  });
+  let BlockModel = _BlockModel;
+  function makeDefaultPTableParams() {
+    return {
+      sourceId: null,
+      hiddenColIds: null,
+      partitionFilters: [],
+      filters: [],
+      sorting: []
+    };
   }
-  function Ue() {
+  function createPlDataTableStateV2() {
     return {
-      version: 2,
+      version: 4,
       stateCache: [],
-      pTableParams: {
-        sorting: [],
-        filters: [],
-        hiddenColIds: null
-      }
+      pTableParams: makeDefaultPTableParams()
     };
   }
-  function jt(t) {
-    return "version" in t ? t : Ue();
+  function upgradePlDataTableStateV2(state) {
+    if (!state) {
+      return createPlDataTableStateV2();
+    }
+    if (!("version" in state)) {
+      state = createPlDataTableStateV2();
+    }
+    if (state.version === 2) {
+      state = {
+        version: 3,
+        stateCache: state.stateCache.map((entry) => ({
+          ...entry,
+          filtersState: []
+        })),
+        pTableParams: makeDefaultPTableParams()
+      };
+    }
+    if (state.version === 3) {
+      state = createPlDataTableStateV2();
+    }
+    return state;
   }
-  function be(t) {
-    return t.axesSpec.length === 1 && t.name === "pl7.app/label";
+  function isLabelColumn(column) {
+    return column.axesSpec.length === 1 && column.name === PColumnName.Label;
   }
-  function Be(t) {
-    return new le().addAxisLabelProvider(t).addColumnProvider(t).getColumns({
-      name: "pl7.app/label",
+  function getAllLabelColumns(resultPool) {
+    return new PColumnCollection().addAxisLabelProvider(resultPool).addColumnProvider(resultPool).getColumns({
+      name: PColumnName.Label,
       axes: [{}]
       // exactly one axis
     }, { dontWaitAllData: true });
   }
-  function we(t, e) {
-    const n2 = [], r = [];
-    for (const a of t)
-      be(a.spec) ? n2.push(a) : r.push(a);
-    const i = [];
-    for (const a of r)
-      for (const l2 of a.spec.axesSpec) {
-        const u2 = p$1(l2);
-        i.some((c2) => Z$1(c2, u2)) || i.push(u2);
-      }
-    for (const a of n2) {
-      const l2 = p$1(a.spec.axesSpec[0]), u2 = i.findIndex((c2) => Z$1(c2, l2));
-      u2 !== -1 && i.splice(u2, 1);
-    }
-    const s2 = (a, l2) => {
-      let u2 = a.toString();
-      if (l2)
-        for (const c2 in l2)
-          u2 += c2, u2 += l2[c2];
-      return u2;
-    }, o = [];
-    for (const a of e) {
-      const l2 = a.spec.axesSpec[0], u2 = p$1(l2), c2 = i.findIndex((d) => Z$1(d, u2));
-      if (c2 !== -1) {
-        const d = i[c2], h2 = Object.keys(d.domain ?? {}).length, p2 = Object.keys(l2.domain ?? {}).length;
-        h2 > p2 ? o.push({
-          id: s2(a.id, d.domain),
-          spec: {
-            ...a.spec,
-            axesSpec: [{ ...d, annotations: l2.annotations }]
-          },
-          data: a.data
-        }) : o.push(a), i.splice(c2, 1);
+  function getMatchingLabelColumns(columns, allLabelColumns) {
+    const inputLabelColumns = [];
+    const inputValueColumns = [];
+    for (const column of columns) {
+      if (isLabelColumn(column.spec)) {
+        inputLabelColumns.push(column);
+      } else {
+        inputValueColumns.push(column);
+      }
+    }
+    const unlabeledAxes = [];
+    for (const column of inputValueColumns) {
+      for (const axis of column.spec.axesSpec) {
+        const axisId = getAxisId(axis);
+        if (!unlabeledAxes.some((id) => matchAxisId(id, axisId))) {
+          unlabeledAxes.push(axisId);
+        }
+      }
+    }
+    for (const labelColumn of inputLabelColumns) {
+      const labelAxisId = getAxisId(labelColumn.spec.axesSpec[0]);
+      const labelMatch = unlabeledAxes.findIndex((axisId) => matchAxisId(axisId, labelAxisId));
+      if (labelMatch !== -1) {
+        unlabeledAxes.splice(labelMatch, 1);
+      }
+    }
+    const colId = (id, domain) => {
+      let wid = id.toString();
+      if (domain) {
+        for (const k in domain) {
+          wid += k;
+          wid += domain[k];
+        }
+      }
+      return wid;
+    };
+    const labelColumns = [];
+    for (const labelColumn of allLabelColumns) {
+      const labelAxis = labelColumn.spec.axesSpec[0];
+      const labelAxisId = getAxisId(labelAxis);
+      const labelMatch = unlabeledAxes.findIndex((axisId) => matchAxisId(axisId, labelAxisId));
+      if (labelMatch !== -1) {
+        const axisId = unlabeledAxes[labelMatch];
+        const dataDomainLen = Object.keys(axisId.domain ?? {}).length;
+        const labelDomainLen = Object.keys(labelAxis.domain ?? {}).length;
+        if (dataDomainLen > labelDomainLen) {
+          labelColumns.push({
+            id: colId(labelColumn.id, axisId.domain),
+            spec: {
+              ...labelColumn.spec,
+              axesSpec: [{ ...axisId, annotations: labelAxis.annotations }]
+            },
+            data: labelColumn.data
+          });
+        } else {
+          labelColumns.push(labelColumn);
+        }
+        unlabeledAxes.splice(labelMatch, 1);
       }
     }
-    return o;
+    return labelColumns;
   }
-  function We(t) {
-    const e = (i) => Array.isArray(i), n2 = (i) => i instanceof E, r = (i) => typeof i == "object" && "type" in i;
-    return t.map((i) => i.data).every((i) => {
-      if (e(i))
+  function allColumnsComputed(columns) {
+    const isValues = (d) => Array.isArray(d);
+    const isAccessor = (d) => d instanceof TreeNodeAccessor;
+    const isDataInfo2 = (d) => typeof d === "object" && "type" in d;
+    return columns.map((c) => c.data).every((d) => {
+      if (isValues(d)) {
         return true;
-      if (n2(i))
-        return i.getIsReadyOrError();
-      if (r(i))
-        switch (i.type) {
+      } else if (isAccessor(d)) {
+        return d.getIsReadyOrError();
+      } else if (isDataInfo2(d)) {
+        const type = d.type;
+        switch (type) {
           case "Json":
             return true;
           case "JsonPartitioned":
-            return Object.values(i.parts).every((o) => o.getIsReadyOrError());
+            return Object.values(d.parts).every((p) => p.getIsReadyOrError());
           case "BinaryPartitioned":
-            return Object.values(i.parts).every((o) => o.index.getIsReadyOrError() && o.values.getIsReadyOrError());
+            return Object.values(d.parts).every((p) => p.index.getIsReadyOrError() && p.values.getIsReadyOrError());
+          case "ParquetPartitioned":
+            return Object.values(d.parts).every((p) => p.getIsReadyOrError());
         }
-      else
-        throw Error(`unsupported column data type: ${i}`);
+      } else {
+        throw Error(`unsupported column data type: ${d}`);
+      }
     });
   }
-  function Ae(t, e, n2, r, i, s2) {
-    let o = t;
-    const a = [];
-    return a.push(...e), {
+  function createPTableDef(params) {
+    let coreColumns = params.columns;
+    const secondaryColumns = [];
+    if (params.coreColumnPredicate) {
+      coreColumns = [];
+      for (const c of params.columns)
+        if (params.coreColumnPredicate(c.spec))
+          coreColumns.push(c);
+        else
+          secondaryColumns.push(c);
+    }
+    secondaryColumns.push(...params.labelColumns);
+    return {
       src: {
         type: "outer",
         primary: {
-          type: n2,
-          entries: o.map((l2) => ({ type: "column", column: l2 }))
+          type: params.coreJoinType,
+          entries: coreColumns.map((c) => ({ type: "column", column: c }))
         },
-        secondary: a.map((l2) => ({ type: "column", column: l2 }))
+        secondary: secondaryColumns.map((c) => ({ type: "column", column: c }))
       },
-      filters: r,
-      sorting: i
+      partitionFilters: params.partitionFilters,
+      filters: params.filters,
+      sorting: params.sorting
     };
   }
-  function Nt(t) {
-    var e;
-    return ((e = t.annotations) == null ? void 0 : e["pl7.app/table/visibility"]) === "hidden";
-  }
-  function $t(t) {
-    var e;
-    return ((e = t.annotations) == null ? void 0 : e["pl7.app/table/visibility"]) === "optional";
-  }
-  function ue(t, e) {
-    return [...new Map(t.map((n2) => [e(n2), n2])).values()];
-  }
-  function Kn(t, e, n2, r) {
-    const i = jt(n2 ?? Ue()), s2 = "full", o = ue(
-      [...[], ...i.pTableParams.filters],
-      (g) => ue$1(g.column)
-    ), a = ue(
-      [...[], ...i.pTableParams.sorting],
-      (g) => ue$1(g.column)
-    ), l2 = e.filter((g) => !Nt(g.spec)), u2 = Be(t.resultPool);
-    if (!u2) return;
-    const c2 = we(l2.map(Fn), u2), d = Ae(l2, c2, s2, o, a), h2 = t.createPTable(d), p2 = new Set((() => {
-      const g = i.pTableParams.hiddenColIds;
-      return g || l2.filter((x) => $t(x.spec)).map((x) => x.id);
+  function isColumnHidden(spec) {
+    return readAnnotation(spec, Annotation.Table.Visibility) === "hidden";
+  }
+  function isColumnOptional(spec) {
+    return readAnnotation(spec, Annotation.Table.Visibility) === "optional";
+  }
+  function createPlDataTableV2(ctx, inputColumns, tableState, ops) {
+    if (inputColumns.length === 0)
+      return void 0;
+    const columns = inputColumns.filter((c) => isLinkerColumn(c.spec) || !isColumnHidden(c.spec));
+    const tableStateNormalized = upgradePlDataTableStateV2(tableState);
+    const allLabelColumns = getAllLabelColumns(ctx.resultPool);
+    if (!allLabelColumns)
+      return void 0;
+    const fullLabelColumns = getMatchingLabelColumns(columns.map(getColumnIdAndSpec), allLabelColumns);
+    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 }))
+    ];
+    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 valid = isValidColumnId(f.column);
+      if (!valid)
+        ctx.logWarn(`Partition filter ${JSON.stringify(f)} does not match provided columns, skipping`);
+      return valid;
+    });
+    const filters = uniqueBy([...[], ...tableStateNormalized.pTableParams.filters], (f) => canonicalizeJson(f.column)).filter((f) => {
+      const valid = isValidColumnId(f.column);
+      if (!valid)
+        ctx.logWarn(`Filter ${JSON.stringify(f)} does not match provided columns, skipping`);
+      return valid;
+    });
+    const sorting = uniqueBy([...[], ...tableStateNormalized.pTableParams.sorting], (s) => canonicalizeJson(s.column)).filter((s) => {
+      const valid = isValidColumnId(s.column);
+      if (!valid)
+        ctx.logWarn(`Sorting ${JSON.stringify(s)} does not match provided columns, skipping`);
+      return valid;
+    });
+    const fullDef = createPTableDef({
+      columns,
+      labelColumns: fullLabelColumns,
+      coreJoinType,
+      partitionFilters,
+      filters,
+      sorting,
+      coreColumnPredicate: ops == null ? void 0 : ops.coreColumnPredicate
+    });
+    const fullHandle = ctx.createPTable(fullDef);
+    const hiddenColumns = new Set((() => {
+      const hiddenColIds = tableStateNormalized.pTableParams.hiddenColIds;
+      if (hiddenColIds)
+        return hiddenColIds;
+      return columns.filter((c) => isColumnOptional(c.spec)).map((c) => c.id);
     })());
-    [...o.map((g) => g.column), ...a.map((g) => g.column)].filter((g) => g.type === "column").map((g) => p2.delete(g.id));
-    const m2 = l2.filter((g) => !p2.has(g.id)), f2 = we(m2.map(Fn), u2);
-    if (!We([...m2, ...f2])) return;
-    const v = Ae(m2, f2, s2, o, a), b = t.createPTable(v);
+    columns.filter((c) => isLinkerColumn(c.spec)).forEach((c) => hiddenColumns.delete(c.id));
+    [...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);
+    if (!allColumnsComputed([...visibleColumns, ...visibleLabelColumns]))
+      return void 0;
+    const visibleDef = createPTableDef({
+      columns: visibleColumns,
+      labelColumns: visibleLabelColumns,
+      coreJoinType,
+      partitionFilters,
+      filters,
+      sorting,
+      coreColumnPredicate: ops == null ? void 0 : ops.coreColumnPredicate
+    });
+    const visibleHandle = ctx.createPTable(visibleDef);
     return {
-      fullTableHandle: h2,
-      visibleTableHandle: b
+      sourceId: tableStateNormalized.pTableParams.sourceId,
+      fullTableHandle: fullHandle,
+      visibleTableHandle: visibleHandle
     };
   }
-  const model = L.create().withArgs({
+  function isLinkerColumn(column) {
+    return !!readAnnotationJson(column, Annotation.IsLinkerColumn);
+  }
+  var stringify = { exports: {} };
+  var hasRequiredStringify;
+  function requireStringify() {
+    if (hasRequiredStringify) return stringify.exports;
+    hasRequiredStringify = 1;
+    (function(module2, exports3) {
+      exports3 = module2.exports = stringify2;
+      exports3.getSerialize = serializer;
+      function stringify2(obj, replacer, spaces, cycleReplacer) {
+        return JSON.stringify(obj, serializer(replacer, cycleReplacer), spaces);
+      }
+      function serializer(replacer, cycleReplacer) {
+        var stack = [], keys = [];
+        if (cycleReplacer == null) cycleReplacer = function(key, value) {
+          if (stack[0] === value) return "[Circular ~]";
+          return "[Circular ~." + keys.slice(0, stack.indexOf(value)).join(".") + "]";
+        };
+        return function(key, value) {
+          if (stack.length > 0) {
+            var thisPos = stack.indexOf(this);
+            ~thisPos ? stack.splice(thisPos + 1) : stack.push(this);
+            ~thisPos ? keys.splice(thisPos, Infinity, key) : keys.push(key);
+            if (~stack.indexOf(value)) value = cycleReplacer.call(this, key, value);
+          } else stack.push(value);
+          return replacer == null ? value : replacer.call(this, key, value);
+        };
+      }
+    })(stringify, stringify.exports);
+    return stringify.exports;
+  }
+  requireStringify();
+  const BasePlErrorLike = z.object({
+    type: z.literal("PlError"),
+    name: z.string(),
+    message: z.string(),
+    /** The message with all details needed for SDK developers. */
+    fullMessage: z.string().optional(),
+    stack: z.string().optional()
+  });
+  const PlErrorLike = BasePlErrorLike.extend({
+    cause: z.lazy(() => ErrorLike).optional(),
+    errors: z.lazy(() => ErrorLike.array()).optional()
+  });
+  const BaseStandardErrorLike = z.object({
+    type: z.literal("StandardError"),
+    name: z.string(),
+    message: z.string(),
+    stack: z.string().optional()
+  });
+  const StandardErrorLike = BaseStandardErrorLike.extend({
+    cause: z.lazy(() => ErrorLike).optional(),
+    errors: z.lazy(() => ErrorLike.array()).optional()
+  });
+  const ErrorLike = z.union([StandardErrorLike, PlErrorLike]);
+  const baseErrorShape = z.object({
+    name: z.string(),
+    message: z.string(),
+    fullMessage: z.string().optional(),
+    stack: z.string().optional()
+  });
+  const ErrorShape = baseErrorShape.extend({
+    cause: z.lazy(() => ErrorShape).optional(),
+    errors: z.lazy(() => ErrorShape.array()).optional()
+  });
+  const model = BlockModel.create().withArgs({
     settings: {
       coverageThreshold: 0.95,
       // default value matching MMseqs2 default
@@ -6073,7 +6656,7 @@
     selectedColumns: []
   }).withUiState({
     title: "Immune Assay Data",
-    tableState: Ue()
+    tableState: createPlDataTableStateV2()
   }).argsValid(
     (ctx) => ctx.args.datasetRef !== void 0 && ctx.args.fileHandle !== void 0 && ctx.args.importColumns !== void 0 && ctx.args.sequenceColumnHeader !== void 0 && ctx.args.targetRef !== void 0 && ctx.uiState.fileImportError === void 0
   ).output(
@@ -6140,7 +6723,7 @@
     const cols = (_d = (_c = ctx.outputs) == null ? void 0 : _c.resolve("table")) == null ? void 0 : _d.getPColumns();
     if (cols === void 0)
       return void 0;
-    return Kn(
+    return createPlDataTableV2(
       ctx,
       cols,
       ctx.uiState.tableState
@@ -6150,7 +6733,7 @@
     return ((_a = ctx.outputs) == null ? void 0 : _a.getIsReadyOrError()) === false;
   }).title((ctx) => ctx.uiState.title).sections((_ctx) => [
     { type: "link", href: "/", label: "Main" }
-  ]).done();
+  ]).done(2);
   exports2.model = model;
   Object.defineProperty(exports2, Symbol.toStringTag, { value: "Module" });
 });