@platforma-open/milaboratories.vj-usage.model 2.1.0 → 2.1.2

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);
     };
@@ -53,7 +103,7 @@
       return array.map((val) => typeof val === "string" ? `'${val}'` : val).join(separator);
     }
     util2.joinValues = joinValues;
-    util2.jsonStringifyReplacer = (_2, value) => {
+    util2.jsonStringifyReplacer = (_, value) => {
       if (typeof value === "bigint") {
         return value.toString();
       }
@@ -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,31 +3119,31 @@
         });
       }
       const params = { errorMap: ctx.common.contextualErrorMap };
-      const fn2 = ctx.data;
+      const fn = ctx.data;
       if (this._def.returns instanceof ZodPromise) {
-        const me2 = this;
+        const me = this;
         return OK(async function(...args) {
           const error = new ZodError([]);
-          const parsedArgs = await me2._def.args.parseAsync(args, params).catch((e) => {
+          const parsedArgs = await me._def.args.parseAsync(args, params).catch((e) => {
             error.addIssue(makeArgsIssue(args, e));
             throw error;
           });
-          const result = await Reflect.apply(fn2, this, parsedArgs);
-          const parsedReturns = await me2._def.returns._def.type.parseAsync(result, params).catch((e) => {
+          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;
           });
           return parsedReturns;
         });
       } else {
-        const me2 = this;
+        const me = this;
         return OK(function(...args) {
-          const parsedArgs = me2._def.args.safeParse(args, params);
+          const parsedArgs = me._def.args.safeParse(args, params);
           if (!parsedArgs.success) {
             throw new ZodError([makeArgsIssue(args, parsedArgs.error)]);
           }
-          const result = Reflect.apply(fn2, this, parsedArgs.data);
-          const parsedReturns = me2._def.returns.safeParse(result, params);
+          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,275 +3964,583 @@
     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 ke = /* @__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 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 visitDataInfo(dataInfo, cb) {
+    switch (dataInfo.type) {
+      case "Json":
+        break;
+      case "JsonPartitioned": {
+        Object.values(dataInfo.parts).forEach(cb);
+        break;
+      }
+      case "BinaryPartitioned": {
+        Object.values(dataInfo.parts).forEach((chunk) => {
+          cb(chunk.index);
+          cb(chunk.values);
+        });
+        break;
+      }
+      case "ParquetPartitioned": {
+        Object.values(dataInfo.parts).forEach(cb);
+        break;
       }
+    }
   }
-  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 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 stringifyJson(value) {
+    return JSON.stringify(value);
+  }
+  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"
+    },
+    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);
+  }
+  function makeAxisTree(axis) {
+    return { axis, children: [] };
+  }
+  function getAxesTree(rootAxis) {
+    const root = makeAxisTree(rootAxis);
+    let nodesQ = [root];
+    while (nodesQ.length) {
+      const nextNodes = [];
+      for (const node of nodesQ) {
+        node.children = node.axis.parentAxesSpec.map(makeAxisTree);
+        nextNodes.push(...node.children);
+      }
+      nodesQ = nextNodes;
+    }
+    return root;
+  }
+  function getArrayFromAxisTree(tree) {
+    const res = [tree.axis];
+    let nodesQ = [tree];
+    while (nodesQ.length) {
+      const nextNodes = [];
+      for (const node of nodesQ) {
+        for (const parent of node.children) {
+          res.push(parent.axis);
+          nextNodes.push(parent);
+        }
+      }
+      nodesQ = nextNodes;
+    }
+    return res;
+  }
+  function canonicalizeAxisWithParents(axis) {
+    return canonicalizeJson(getArrayFromAxisTree(getAxesTree(axis)).map(getAxisId));
+  }
+  function normalizingAxesComparator(axis1, axis2) {
+    if (axis1.name !== axis2.name) {
+      return axis1.name < axis2.name ? 1 : -1;
+    }
+    if (axis1.type !== axis2.type) {
+      return axis1.type < axis2.type ? 1 : -1;
+    }
+    const domain1 = canonicalizeJson(axis1.domain ?? {});
+    const domain2 = canonicalizeJson(axis2.domain ?? {});
+    if (domain1 !== domain2) {
+      return domain1 < domain2 ? 1 : -1;
+    }
+    const parents1 = canonicalizeAxisWithParents(axis1);
+    const parents2 = canonicalizeAxisWithParents(axis2);
+    if (parents1 !== parents2) {
+      return parents1 < parents2 ? 1 : -1;
+    }
+    const annotation1 = canonicalizeJson(axis1.annotations ?? {});
+    const annotation2 = canonicalizeJson(axis2.annotations ?? {});
+    if (annotation1 !== annotation2) {
+      return annotation1 < annotation2 ? 1 : -1;
+    }
+    return 0;
+  }
+  function parseParentsFromAnnotations(axis) {
+    const parentsList = readAnnotationJson(axis, Annotation.Parents);
+    if (parentsList === void 0) {
+      return [];
+    }
+    return parentsList;
+  }
+  function sortParentsDeep(axisSpec) {
+    axisSpec.parentAxesSpec.forEach(sortParentsDeep);
+    axisSpec.parentAxesSpec.sort(normalizingAxesComparator);
+  }
+  function hasCycleOfParents(axisSpec) {
+    const root = makeAxisTree(axisSpec);
+    let nodesQ = [root];
+    const ancestors = new Set(canonicalizeJson(getAxisId(axisSpec)));
+    while (nodesQ.length) {
+      const nextNodes = [];
+      const levelIds = /* @__PURE__ */ new Set();
+      for (const node of nodesQ) {
+        node.children = node.axis.parentAxesSpec.map(makeAxisTree);
+        for (const child of node.children) {
+          const childId = canonicalizeJson(getAxisId(child.axis));
+          if (!levelIds.has(childId)) {
+            nextNodes.push(child);
+            levelIds.add(childId);
+            if (ancestors.has(childId)) {
+              return true;
+            }
+            ancestors.add(childId);
+          }
+        }
       }
+      nodesQ = nextNodes;
     }
+    return false;
+  }
+  function getNormalizedAxesList(axes) {
+    if (!axes.length) {
+      return [];
+    }
+    const modifiedAxes = axes.map((axis) => {
+      const { parentAxes: _, ...copiedRest } = axis;
+      return { ...copiedRest, annotations: { ...copiedRest.annotations }, parentAxesSpec: [] };
+    });
+    axes.forEach((axis, idx) => {
+      var _a;
+      const modifiedAxis = modifiedAxes[idx];
+      if (axis.parentAxes) {
+        modifiedAxis.parentAxesSpec = axis.parentAxes.map((idx2) => modifiedAxes[idx2]);
+      } else {
+        const parents = parseParentsFromAnnotations(axis).map((name) => modifiedAxes.find((axis2) => axis2.name === name));
+        modifiedAxis.parentAxesSpec = parents.some((p) => p === void 0) ? [] : parents;
+        (_a = modifiedAxis.annotations) == null ? true : delete _a[Annotation.Parents];
+      }
+    });
+    if (modifiedAxes.some(hasCycleOfParents)) {
+      modifiedAxes.forEach((axis) => {
+        axis.parentAxesSpec = [];
+      });
+    } else {
+      modifiedAxes.forEach((axis) => {
+        sortParentsDeep(axis);
+      });
+    }
+    return modifiedAxes;
+  }
+  const PColumnName = {
+    Label: "pl7.app/label"
+  };
+  function getColumnIdAndSpec(column) {
+    return {
+      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 ke(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 ke(n2);
+  function stringifyColumnId(id) {
+    return canonicalize(id);
   }
-  function P(n2) {
-    return ke(p$1(n2));
+  function axisKey(axis) {
+    return canonicalize(getAxisId(axis));
   }
-  function k(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(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);
           }
         }
       }
@@ -4190,57 +4548,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(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
       };
     }
     /**
@@ -4249,470 +4619,583 @@
      * @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)), ke(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)
-      return {
-        ...n2,
-        requireEnrichments: true
-      };
-    {
-      const { requireEnrichments: t, ...r } = n2;
-      return r;
-    }
+    if (spec.domain !== void 0)
+      result.domain = spec.domain;
+    if (isPColumnSpec(spec))
+      result.axesSpec = getAxesId(spec.axesSpec);
+    return canonicalize(result);
   }
-  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(n2) {
-    return ke(n2);
-  }
-  function ce$1(n2) {
-    return JSON.parse(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);
-        };
+  class LinkerMap {
+    constructor(linkerMap) {
+      /** Graph of linkers connected by axes (single or grouped by parents) */
+      __publicField(this, "data");
+      this.data = linkerMap;
+    }
+    get keys() {
+      return this.data.keys();
+    }
+    get keyAxesIds() {
+      return [...this.data.keys()].map(parseJson);
+    }
+    static fromColumns(columns) {
+      var _a, _b;
+      const result = /* @__PURE__ */ new Map();
+      for (const linker of columns.filter((l) => !!readAnnotationJson(l.spec, Annotation.IsLinkerColumn))) {
+        const groups = LinkerMap.getAxesGroups(getNormalizedAxesList(linker.spec.axesSpec));
+        if (groups.length !== 2) {
+          continue;
+        }
+        const [left, right] = groups;
+        const leftKeyVariants = LinkerMap.getAxesRoots(left).map((axis) => {
+          const axes = getArrayFromAxisTree(getAxesTree(axis));
+          const key = canonicalizeJson(axes.map(getAxisId));
+          return [key, axes];
+        });
+        const rightKeyVariants = LinkerMap.getAxesRoots(right).map((axis) => {
+          const axes = getArrayFromAxisTree(getAxesTree(axis));
+          const key = canonicalizeJson(axes.map(getAxisId));
+          return [key, axes];
+        });
+        for (const [keyLeft, spec] of leftKeyVariants) {
+          if (!result.has(keyLeft)) {
+            result.set(keyLeft, { keyAxesSpec: spec, linkWith: /* @__PURE__ */ new Map() });
+          }
+        }
+        for (const [keyRight, spec] of rightKeyVariants) {
+          if (!result.has(keyRight)) {
+            result.set(keyRight, { keyAxesSpec: spec, linkWith: /* @__PURE__ */ new Map() });
+          }
+        }
+        for (const [keyLeft] of leftKeyVariants) {
+          for (const [keyRight] of rightKeyVariants) {
+            (_a = result.get(keyLeft)) == null ? void 0 : _a.linkWith.set(keyRight, linker);
+            (_b = result.get(keyRight)) == null ? void 0 : _b.linkWith.set(keyLeft, linker);
+          }
+        }
       }
-    })(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 qe = Object.defineProperty;
-  var ze = (t, e, n2) => e in t ? qe(t, e, { enumerable: true, configurable: true, writable: true, value: n2 }) : t[e] = n2;
-  var O = (t, e, n2) => ze(t, typeof e != "symbol" ? e + "" : e, n2);
-  function re(t) {
-    return { type: "Immediate", value: t };
-  }
-  function pt() {
-    return typeof globalThis.getPlatforma < "u" || typeof globalThis.platforma < "u";
-  }
-  function De(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 ft() {
-    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 = ft();
-    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 ce = /* @__PURE__ */ new Map();
-  function ht(t, e) {
-    t in y().callbackRegistry || (y().callbackRegistry[t] = (n2) => {
-      for (const r of ce.get(t))
-        r(n2);
-    }, ce.set(t, [])), ce.get(t).push(e);
-  }
-  class _ {
-    constructor(e, n2 = (r) => r) {
-      O(this, "isResolved", false);
-      O(this, "resolvedValue");
-      this.handle = e, this.postProcess = n2, ht(e, (r) => {
-        this.resolvedValue = n2(r), this.isResolved = true;
+      return new this(result);
+    }
+    /** Get all available nodes of linker graphs if start from sourceAxesKeys */
+    searchAvailableAxesKeys(sourceAxesKeys) {
+      const startKeys = new Set(sourceAxesKeys);
+      const allAvailableKeys = /* @__PURE__ */ new Set();
+      let nextKeys = sourceAxesKeys;
+      while (nextKeys.length) {
+        const next = [];
+        for (const key of nextKeys) {
+          const node = this.data.get(key);
+          if (!node)
+            continue;
+          for (const availableKey of node.linkWith.keys()) {
+            if (!allAvailableKeys.has(availableKey) && !startKeys.has(availableKey)) {
+              next.push(availableKey);
+              allAvailableKeys.add(availableKey);
+            }
+          }
+        }
+        nextKeys = next;
+      }
+      return allAvailableKeys;
+    }
+    /** Get all linker columns that are necessary to reach endKey from startKey */
+    searchLinkerPath(startKey, endKey) {
+      const previous = {};
+      let nextIds = /* @__PURE__ */ new Set([startKey]);
+      const visited = /* @__PURE__ */ new Set([startKey]);
+      while (nextIds.size) {
+        const next = /* @__PURE__ */ new Set();
+        for (const nextId of nextIds) {
+          const node = this.data.get(nextId);
+          if (!node)
+            continue;
+          for (const availableId of node.linkWith.keys()) {
+            previous[availableId] = nextId;
+            if (availableId === endKey) {
+              const ids = [];
+              let current = endKey;
+              while (previous[current] !== startKey) {
+                ids.push(current);
+                current = previous[current];
+              }
+              ids.push(current);
+              return ids.map((id) => this.data.get(id).linkWith.get(previous[id]));
+            } else if (!visited.has(availableId)) {
+              next.add(availableId);
+              visited.add(availableId);
+            }
+          }
+        }
+        nextIds = next;
+      }
+      return [];
+    }
+    getLinkerColumnsForAxes({ from: sourceAxes, to: targetAxes, throwWhenNoLinkExists = true }) {
+      const startKeys = sourceAxes.map(LinkerMap.getLinkerKeyFromAxisSpec);
+      return Array.from(new Map(LinkerMap.getAxesRoots(targetAxes).map(LinkerMap.getLinkerKeyFromAxisSpec).flatMap((targetKey) => {
+        const linkers = startKeys.map((startKey) => this.searchLinkerPath(startKey, targetKey)).reduce((shortestPath, path) => shortestPath.length && shortestPath.length < path.length || !path.length ? shortestPath : path, []).map((linker) => [linker.columnId, linker]);
+        if (!linkers.length && throwWhenNoLinkExists) {
+          throw Error(`Unable to find linker column for ${targetKey}`);
+        }
+        return linkers;
+      })).values());
+    }
+    /** Get list of axisSpecs from keys of linker columns map  */
+    getAxesListFromKeysList(keys) {
+      return Array.from(new Map(keys.flatMap((key) => {
+        var _a;
+        return ((_a = this.data.get(key)) == null ? void 0 : _a.keyAxesSpec) ?? [];
+      }).map((axis) => [canonicalizeJson(getAxisId(axis)), axis])).values());
+    }
+    /** Get axes of target axes that are impossible to be linked to source axes with current linker map */
+    getNonLinkableAxes(sourceAxes, targetAxes) {
+      const startKeys = sourceAxes.map(LinkerMap.getLinkerKeyFromAxisSpec);
+      const targetKeys = targetAxes.map(LinkerMap.getLinkerKeyFromAxisSpec);
+      const axes = Array.from(new Map(targetAxes.filter((_targetAxis, idx) => {
+        const targetKey = targetKeys[idx];
+        return !startKeys.some((startKey) => this.searchLinkerPath(startKey, targetKey).length);
+      }).flatMap((axis) => getArrayFromAxisTree(getAxesTree(axis)).map((axis2) => [canonicalizeJson(getAxisId(axis2)), axis2]))).values());
+      return axes;
+    }
+    /** Get all axes that can be connected to sourceAxes by linkers */
+    getReachableByLinkersAxesFromAxes(sourceAxes) {
+      const startKeys = sourceAxes.map(LinkerMap.getLinkerKeyFromAxisSpec);
+      const availableKeys = this.searchAvailableAxesKeys(startKeys);
+      return this.getAxesListFromKeysList([...availableKeys]);
+    }
+    static getLinkerKeyFromAxisSpec(axis) {
+      return canonicalizeJson(getArrayFromAxisTree(getAxesTree(axis)).map(getAxisId));
+    }
+    /**  Split array of axes into several arrays by parents: axes of one group are parents for each other.
+       There are no order inside every group. */
+    static getAxesGroups(axesSpec) {
+      switch (axesSpec.length) {
+        case 0:
+          return [];
+        case 1:
+          return [[axesSpec[0]]];
+      }
+      const axisKeys = axesSpec.map((spec) => canonicalizeJson(getAxisId(spec)));
+      const axisParentsIdxs = axesSpec.map((spec) => new Set(spec.parentAxesSpec.map((spec2) => canonicalizeJson(getAxisId(spec2))).map((el) => {
+        const idx = axisKeys.indexOf(el);
+        if (idx === -1) {
+          throw new Error(`malformed axesSpec: ${JSON.stringify(axesSpec)}, unable to locate parent ${el}`);
+        }
+        return idx;
+      })));
+      const allIdxs = [...axesSpec.keys()];
+      const groups = [];
+      const usedIdxs = /* @__PURE__ */ new Set();
+      let nextFreeEl = allIdxs.find((idx) => !usedIdxs.has(idx));
+      while (nextFreeEl !== void 0) {
+        const currentGroup = [nextFreeEl];
+        usedIdxs.add(nextFreeEl);
+        let nextElsOfCurrentGroup = [nextFreeEl];
+        while (nextElsOfCurrentGroup.length) {
+          const next = /* @__PURE__ */ new Set();
+          for (const groupIdx of nextElsOfCurrentGroup) {
+            const groupElementParents = axisParentsIdxs[groupIdx];
+            allIdxs.forEach((idx) => {
+              if (idx === groupIdx || usedIdxs.has(idx)) {
+                return;
+              }
+              const parents = axisParentsIdxs[idx];
+              if (parents.has(groupIdx) || groupElementParents.has(idx)) {
+                currentGroup.push(idx);
+                next.add(idx);
+                usedIdxs.add(idx);
+              }
+            });
+          }
+          nextElsOfCurrentGroup = [...next];
+        }
+        groups.push([...currentGroup]);
+        nextFreeEl = allIdxs.find((idx) => !usedIdxs.has(idx));
+      }
+      return groups.map((group) => group.map((idx) => axesSpec[idx]));
+    }
+    /** Get all axes that are not parents of any other axis */
+    static getAxesRoots(axes) {
+      const parentsSet = new Set(axes.flatMap((axis) => axis.parentAxesSpec).map((spec) => canonicalizeJson(getAxisId(spec))));
+      return axes.filter((axis) => !parentsSet.has(canonicalizeJson(getAxisId(axis))));
+    }
+  }
+  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 {
+        ...ref,
+        requireEnrichments: 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 _(this.handle, (n2) => e(this.postProcess(n2)));
+    map(mapping) {
+      return new FutureRef(this.handle, (v) => mapping(this.postProcess(v)));
     }
-    mapDefined(e) {
-      return new _(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 he(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);
+    }
+    resolveInput(...steps) {
+      const transformedSteps = steps.map((s) => ({
+        assertFieldType: "Input",
+        ...typeof s === "string" ? { field: s } : s
+      }));
+      return this.resolveWithCommon({}, ...transformedSteps);
     }
-    resolveAny(...e) {
-      return this.resolveWithCommon({}, ...e);
+    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 he(
-        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 he(
-        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 _(y().getBlobContentAsBase64(this.handle, e));
-    }
-    getFileContentAsString(e) {
-      return new _(y().getBlobContentAsString(this.handle, e));
-    }
-    getFileContentAsJson(e) {
-      return new _(
-        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
@@ -4730,7 +5213,7 @@
      * @returns downloaded file handle
      */
     getFileHandle() {
-      return new _(y().getDownloadedBlobContentHandle(this.handle));
+      return new FutureRef(getCfgRenderCtx().getDownloadedBlobContentHandle(this.handle));
     }
     /**
      * @deprecated use getFileHandle
@@ -4742,7 +5225,7 @@
      * @returns downloaded file handle
      */
     getRemoteFileHandle() {
-      return new _(y().getOnDemandBlobContentHandle(this.handle));
+      return new FutureRef(getCfgRenderCtx().getOnDemandBlobContentHandle(this.handle));
     }
     /**
      * @deprecated use getRemoteFileHandle
@@ -4753,655 +5236,898 @@
     /**
      * @returns the url to the extracted folder
      */
-    extractArchiveAndGetURL(e) {
-      return new _(y().extractArchiveAndGetURL(this.handle, e));
+    extractArchiveAndGetURL(format) {
+      return new FutureRef(getCfgRenderCtx().extractArchiveAndGetURL(this.handle, format));
     }
     getImportProgress() {
-      return new _(y().getImportProgress(this.handle));
+      return new FutureRef(getCfgRenderCtx().getImportProgress(this.handle));
     }
-    getLastLogs(e) {
-      return new _(y().getLastLogs(this.handle, e));
+    getLastLogs(nLines) {
+      return new FutureRef(getCfgRenderCtx().getLastLogs(this.handle, nLines));
     }
-    getProgressLog(e) {
-      return new _(y().getProgressLog(this.handle, e));
+    getProgressLog(patternToSearch) {
+      return new FutureRef(getCfgRenderCtx().getProgressLog(this.handle, patternToSearch));
     }
-    getProgressLogWithInfo(e) {
-      return new _(y().getProgressLogWithInfo(this.handle, e));
+    getProgressLogWithInfo(patternToSearch) {
+      return new FutureRef(getCfgRenderCtx().getProgressLogWithInfo(this.handle, patternToSearch));
     }
     getLogHandle() {
-      return new _(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 Re = "staging", Fe = "main";
-  const yt = "pl7.app/label", vt = "pl7.app/trace", bt = z$1.object({
-    type: z$1.string(),
-    importance: z$1.number().optional(),
-    id: z$1.string().optional(),
-    label: z$1.string()
-  }), wt = z$1.array(bt), At = 1e-3, xt = "__LABEL__", Pe = "__LABEL__@1";
-  function je(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 P2, R;
-      const v = e(p2);
-      let f2, m2, w2;
-      "spec" in v && typeof v.spec == "object" ? (f2 = v.spec, m2 = v.prefixTrace, w2 = v.suffixTrace) : f2 = v;
-      const h2 = (P2 = f2.annotations) == null ? void 0 : P2[yt], I = (R = f2.annotations) == null ? void 0 : R[vt], x = (I ? wt.safeParse(JSON.parse(I)).data : void 0) ?? [], b = [
-        ...m2 ?? [],
-        ...x,
-        ...w2 ?? []
+        ..._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 (h2 !== void 0) {
-        const k2 = { label: h2, type: xt, importance: -2 };
-        n2.addLabelAsSuffix ? b.push(k2) : b.splice(0, 0, k2);
-      }
-      const A = [], L = /* @__PURE__ */ new Map();
-      for (let k2 = b.length - 1; k2 >= 0; --k2) {
-        const { type: W } = b[k2], V = b[k2].importance ?? 0, N2 = (L.get(W) ?? 0) + 1;
-        L.set(W, N2);
-        const F = `${W}@${N2}`;
-        s2.set(F, (s2.get(F) ?? 0) + 1), r.set(
-          F,
-          Math.max(
-            r.get(F) ?? Number.NEGATIVE_INFINITY,
-            V - (b.length - k2) * At
-          )
-        ), A.push({ ...b[k2], fullType: F, occurrenceIndex: N2 });
-      }
-      return A.reverse(), {
-        value: p2,
-        spec: f2,
-        label: h2,
-        fullTrace: A
+      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], [, v]) => v - p2);
-    for (const [p2] of u2)
-      p2.endsWith("@1") || s2.get(p2) === t.length ? a.push(p2) : l2.push(p2);
-    const c2 = (p2, v = false) => {
-      const f2 = [];
-      for (let m2 = 0; m2 < o.length; m2++) {
-        const w2 = o[m2], h2 = w2.fullTrace.filter((b) => p2.has(b.fullType) || i && i.has(b.type));
-        if (h2.length === 0)
-          if (v)
-            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: w2.value
+              value: r.value
             });
-          else return;
-        const I = h2.map((b) => b.label), x = n2.separator ?? " / ";
-        f2.push({
-          label: I.join(x),
-          value: w2.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(Pe), true);
-    }
-    let d = 0, g = -1;
-    for (; d < a.length; ) {
-      const p2 = /* @__PURE__ */ new Set();
-      n2.includeNativeLabel && p2.add(Pe);
-      for (let f2 = 0; f2 < d; ++f2) p2.add(a[f2]);
-      g >= 0 && p2.add(a[g]);
-      const v = c2(p2);
-      if (v !== void 0 && new Set(v.map((f2) => f2.label)).size === t.length) return v;
-      g++, g >= a.length && (d++, g = 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", Ve = Z + "Partitioned/", ae = Ve + "JsonPartitioned", z = Ve + "BinaryPartitioned";
-  const me = (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 Ct(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 = me(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 = me(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 Pt(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 St(t) {
-    if (t === void 0) return;
-    if (K(t))
-      return Pt(t);
-    const e = Ct(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 ye(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 = me(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}`);
+        }
+        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 [o, a] of s2.entries()) {
-          if (!a.index || !a.values) return;
-          const l2 = [...e, ...JSON.parse(o)];
-          i.push({
-            key: l2,
+        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 = ye(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 = ye(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 _t(t) {
-    if (t !== void 0) {
-      if (K(t)) return t;
-      if (En(t)) return Cn(t);
-      if (t instanceof E) return ye(t);
-      throw new Error(`Unexpected input type: ${typeof t}`);
-    }
-  }
-  function It(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 Lt(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 Tt {
-    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 Et(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 kt(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 Ot(t, e) {
-    if (!e || e.length === 0) return t;
-    const n2 = [...e].sort((r, i) => r[0] - i[0]);
-    return ke({ 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 Se(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 Dt(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() {
-      O(this, "defaultProviderStore", []);
-      O(this, "providers", [new Tt(this.defaultProviderStore)]);
-      O(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((m2) => {
-          if (Se(m2)) {
-            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, m2, n2));
+            return selectorsToPredicate(resolveAnchors(anchorCtx.anchors, selector, opts));
           } else
-            return Gn(m2);
+            return selectorsToPredicate(selector);
         });
-        u2 = (m2) => f2.some((w2) => w2(m2));
-      }
-      const c2 = typeof e == "function" ? [e] : Array.isArray(e) ? e : [e], d = [], g = /* @__PURE__ */ new Set();
-      for (const f$1 of c2) {
-        const m2 = Se(f$1);
-        let w2;
-        if (m2) {
-          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.");
-          w2 = Mn(r.anchors, f$1, n2);
+          currentSelector = resolveAnchors(anchorCtx.anchors, rawSelector, opts);
         } else
-          w2 = f$1;
-        const h2 = /* @__PURE__ */ new Set(), I = [];
-        for (const A of this.providers) {
-          const L = A.selectColumns(w2);
-          for (const P2 of L) {
-            if (u2(P2.spec)) continue;
-            if (h2.has(P2.id))
-              throw new Error(`Duplicate column id ${P2.id} in provider ${A.constructor.name}`);
-            const R = Qn(P2.spec);
-            g.has(R) || (h2.add(P2.id), g.add(R), I.push(P2));
+          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 (I.length === 0) continue;
-        const x = Dt(f$1), b = x.length > 0;
-        for (const A of I) {
-          if (!f(A.spec)) continue;
-          const L = A.spec;
-          if (b) {
-            if (Lt(A.data))
-              throw new Error(`Splitting is not supported for PColumns with PColumnValues data format. Column id: ${A.id}`);
-            const P2 = _t(A.data);
-            if (!P2) {
-              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(P2))
-              throw new Error(`Splitting requires Partitioned DataInfoEntries, but parsing resulted in ${P2.type} for column ${A.id}`);
-            const R = St(P2), k2 = x[x.length - 1];
-            if (k2 >= P2.partitionKeyLength)
-              throw new Error(`Not enough partition keys (${P2.partitionKeyLength}) for requested split axes (max index ${k2}) in column ${L.name}`);
-            const W = x.map((S) => this.findLabels(p$1(L.axesSpec[S]))), V = [], N2 = (S, G) => {
-              if (G >= x.length) {
-                if (V.push([...S]), V.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 $ = x[G];
-              if ($ >= R.length)
-                throw new Error(`Axis index ${$} out of bounds for unique keys array (length ${R.length}) during split key generation for column ${A.id}`);
-              const J2 = R[$];
-              if (!J2 || J2.length === 0) {
-                V.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)
-                S.push(ee), N2(S, G + 1), S.pop();
+              for (const val of axisValues) {
+                currentCombo.push(val);
+                generateCombinations(currentCombo, sAxisIdx + 1);
+                currentCombo.pop();
+              }
             };
-            if (N2([], 0), V.length === 0)
+            generateCombinations([], 0);
+            if (keyCombinations.length === 0)
               continue;
-            const F = [...L.axesSpec], Be = x.map((S) => S);
-            for (let S = x.length - 1; S >= 0; S--)
-              F.splice(x[S], 1);
-            const We = { ...L, axesSpec: F };
-            for (const S of V) {
-              const G = S.map(($, J2) => {
-                const ee = Be[J2], Ge = p$1(L.axesSpec[ee]), ue2 = W[J2], He = (ue2 == null ? void 0 : ue2[$]) ?? String($);
-                return { axisIdx: ee, axisId: Ge, value: $, label: He };
+            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: A,
-                spec: L,
-                adjustedSpec: We,
-                dataEntries: P2,
-                axisFilters: G
+                originalColumn: column,
+                spec: originalSpec,
+                adjustedSpec,
+                dataEntries,
+                axisFilters: splitFilters
               });
             }
-          } else
-            d.push({
+          } else {
+            intermediateResults.push({
               type: "direct",
-              originalColumn: A,
-              spec: L,
-              adjustedSpec: L
+              originalColumn: column,
+              spec: originalSpec,
+              adjustedSpec: originalSpec
             });
+          }
         }
       }
-      if (d.length === 0) return [];
-      const p2 = je(
-        d,
-        (f2) => ({
-          spec: f2.spec,
-          suffixTrace: f2.type === "split" ? Et(f2.axisFilters) : void 0
-        }),
-        l2
-      ), v = [];
-      for (const { value: f2, label: m2 } of p2) {
-        const { originalColumn: w2, spec: h2 } = f2, I = f2.type === "split" ? f2.axisFilters : void 0, x = kt(I);
-        let b;
-        r ? b = r.deriveS(h2, x) : b = Ot(w2.id, x);
-        let A = { ...f2.adjustedSpec };
-        o && (A = {
-          ...A,
-          annotations: {
-            ...A.annotations ?? {},
-            "pl7.app/label": m2
-          }
-        }), v.push({
-          id: b,
-          spec: A,
-          data: () => f2.type === "split" ? Jn(It(f2.dataEntries, x)) : f2.originalColumn.data,
-          label: m2
+      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 v;
+      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 de(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 _e(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 Rt {
+  class ResultPool {
     constructor() {
-      O(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" ? je(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.
@@ -5411,13 +6137,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
@@ -5448,18 +6175,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()
@@ -5468,14 +6197,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])
           }
         }))
       };
@@ -5487,17 +6216,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]))
           }
         }))
       };
@@ -5515,89 +6241,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 oth = data.obj.spec;
+        if (spec.name !== oth.name) {
+          continue;
+        }
+        if (spec.valueType !== oth.valueType) {
+          continue;
+        }
+        if (spec.axesSpec.length !== oth.axesSpec.length) {
           continue;
-        const i = r.obj.spec;
-        if (e.name === i.name && e.valueType === i.valueType && e.axesSpec.length === i.axesSpec.length && de(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 || !de(o.domain, a.domain))
-              continue e;
+        }
+        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 && de(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
@@ -5606,18 +6349,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: ke(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;
           }
         };
       });
@@ -5626,288 +6378,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() {
-      O(this, "ctx");
-      O(this, "args");
-      O(this, "uiState");
-      O(this, "_activeArgsCache");
-      O(this, "resultPool", new Rt());
-      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 he(
-        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(Re);
+      return this.getNamedAccessor(StagingAccessorName);
     }
     get outputs() {
-      return this.getNamedAccessor(Fe);
+      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(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");
+    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`);
+    }
+    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) => _e(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) => _e(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.34.10";
-  function Ft(t) {
-    return t.__renderLambda === true;
-  }
-  function pe(t) {
-    if (t !== void 0)
-      return Ft(t) ? t.handle : t;
-  }
-  class T {
-    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 T(
-        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 T(
-          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 T(
-          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 T(
-        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 T(
-        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 T(
-        this._renderingMode,
-        this._initialArgs,
-        this._initialUiState,
-        this._outputs,
-        this._inputsValid,
-        { __renderLambda: true, handle: "sections" },
-        this._title,
-        this._enrichmentTargets
-      )) : new T(
-        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 T(
-        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 T(
-        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 T(
-        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 T(
-        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 T(
-        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,
@@ -5915,176 +6651,302 @@
           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: pe(this._inputsValid),
-        sections: pe(this._sections),
-        outputs: Object.fromEntries(
-          Object.entries(this._outputs).map(([n2, r]) => [n2, pe(r)])
-        )
+        inputsValid: downgradeCfgOrLambda(this._inputsValid),
+        sections: downgradeCfgOrLambda(this._sections),
+        outputs: Object.fromEntries(Object.entries(this._outputs).map(([key, value]) => [key, downgradeCfgOrLambda(value)]))
       };
-      return pt() ? De({ sdkVersion: Y }) : { config: e };
+      globalThis.platformaApiVersion = apiVersion;
+      if (!isInUI())
+        return { config };
+      else
+        return getPlatformaInstance({ sdkVersion: PlatformaSDKVersion, apiVersion: platformaApiVersion });
     }
-  }
-  function ve(t) {
-    return t.axesSpec.length === 1 && t.name === "pl7.app/label";
-  }
-  const Vt = (t, e) => {
-    let n2 = t.toString();
-    return e == null || e.forEach((r) => {
-      if (r)
-        for (const [i, s2] of Object.entries(r))
-          n2 += i, n2 += s2;
-    }), n2;
   };
-  function $t(t) {
-    if (!t.length)
+  __publicField(_BlockModel, "INITIAL_BLOCK_FEATURE_FLAGS", {
+    supportsLazyState: true,
+    requiresUIAPIVersion: 1,
+    requiresModelAPIVersion: 1
+  });
+  let BlockModel = _BlockModel;
+  function isLabelColumn(column) {
+    return column.axesSpec.length === 1 && column.name === PColumnName.Label;
+  }
+  const colId = (id, domains) => {
+    let wid = id.toString();
+    domains == null ? void 0 : domains.forEach((domain) => {
+      if (domain) {
+        for (const [k, v] of Object.entries(domain)) {
+          wid += k;
+          wid += v;
+        }
+      }
+    });
+    return wid;
+  };
+  function getKeysCombinations(idsLists) {
+    if (!idsLists.length) {
       return [];
-    let e = [[]];
-    return t.forEach((n2) => {
-      const r = [];
-      n2.forEach((i) => {
-        r.push(...e.map((s2) => [...s2, i]));
-      }), e = r;
-    }), e;
-  }
-  function Nt(t) {
-    var e;
-    return t.axesSpec.length === 2 && ((e = t.annotations) == null ? void 0 : e[Mt]) === "true";
-  }
-  const Jt = "pl7.app/graph/isVirtual", Ie = "pl7.app/label", Mt = "pl7.app/isLinkerColumn";
-  function Ut(t) {
-    var n2, r;
-    const e = /* @__PURE__ */ new Map();
-    for (const { spec: i } of t) {
-      const s2 = i.axesSpec.map(p$1).map(ue);
-      s2.forEach((o) => {
-        e.has(o) || e.set(o, /* @__PURE__ */ new Set());
+    }
+    let result = [[]];
+    idsLists.forEach((list) => {
+      const nextResult = [];
+      list.forEach((key) => {
+        nextResult.push(...result.map((resultItem) => [...resultItem, key]));
       });
-      for (let o = 0; o < s2.length - 1; o++)
-        for (let a = o + 1; a < s2.length; a++) {
-          const l2 = s2[o], u2 = s2[a];
-          (n2 = e.get(l2)) == null || n2.add(u2), (r = e.get(u2)) == null || r.add(l2);
+      result = nextResult;
+    });
+    return result;
+  }
+  function isLinkerColumn(column) {
+    return !!readAnnotationJson(column, Annotation.IsLinkerColumn);
+  }
+  function isHiddenFromGraphColumn(column) {
+    return !!readAnnotationJson(column, Annotation.HideDataFromGraphs);
+  }
+  function getAvailableWithLinkersAxes(linkerColumns, blockAxes) {
+    const linkerMap = LinkerMap.fromColumns(linkerColumns.map(getColumnIdAndSpec));
+    const startKeys = [];
+    const blockAxesGrouped = [...blockAxes.values()].map((axis) => getArrayFromAxisTree(getAxesTree(axis)).map(getAxisId));
+    for (const axesGroupBlock of blockAxesGrouped) {
+      const matched = linkerMap.keyAxesIds.find((keyIds) => keyIds.every((keySourceAxis) => axesGroupBlock.find((axisSpecFromBlock) => matchAxisId(axisSpecFromBlock, keySourceAxis))));
+      if (matched) {
+        startKeys.push(canonicalizeJson(matched));
+      }
+    }
+    const availableKeys = linkerMap.searchAvailableAxesKeys(startKeys);
+    const availableAxes = linkerMap.getAxesListFromKeysList([...availableKeys]);
+    return new Map(availableAxes.map((axisSpec) => {
+      const id = getAxisId(axisSpec);
+      return [canonicalizeJson(id), axisSpec];
+    }));
+  }
+  function enrichCompatible(blockAxes, columns) {
+    const result = [];
+    columns.forEach((column) => {
+      result.push(...getAdditionalColumnsForColumn(blockAxes, column));
+    });
+    return result;
+  }
+  function getAdditionalColumnsForColumn(blockAxes, column) {
+    const columnAxesIds = column.spec.axesSpec.map(getAxisId);
+    if (columnAxesIds.every((id) => blockAxes.has(canonicalizeJson(id)))) {
+      return [column];
+    }
+    const secondaryIdsOptions = columnAxesIds.map((id) => {
+      const result = [];
+      for (const [_, mainId] of blockAxes) {
+        if (matchAxisId(mainId, id) && !matchAxisId(id, mainId)) {
+          result.push(mainId);
         }
-    }
-    return e;
-  }
-  function Bt(t, e) {
-    const n2 = Ut(t), r = [...n2.keys()].map(ce$1), i = [];
-    for (const l2 of e.values()) {
-      const u2 = r.find((c2) => Z$1(l2, c2));
-      u2 && i.push(ue(u2));
-    }
-    const s2 = new Set(i), o = /* @__PURE__ */ new Map();
-    let a = [...i];
-    for (; a.length; ) {
-      const l2 = [];
-      for (const u2 of a)
-        for (const c2 of n2.get(u2) ?? [])
-          s2.has(c2) || (l2.push(c2), s2.add(c2), o.set(c2, ce$1(c2)));
-      a = l2;
-    }
-    return o;
-  }
-  function Wt(t, e) {
-    const n2 = [];
-    return e.forEach((r) => {
-      n2.push(...Gt(t, r));
-    }), n2;
-  }
-  function Gt(t, e) {
-    const n2 = e.spec.axesSpec.map(p$1);
-    if (n2.every((u2) => t.has(ue(u2))))
-      return [e];
-    const r = n2.map((u2) => {
-      const c2 = [];
-      for (const [d, g] of t)
-        Z$1(g, u2) && !Z$1(u2, g) && c2.push(g);
-      return c2;
-    }), i = $t(r), s2 = /* @__PURE__ */ new Set(), o = /* @__PURE__ */ new Set(), a = i.map((u2) => {
-      const c2 = /* @__PURE__ */ new Set();
-      return u2.map((d, g) => {
-        const p2 = e.spec.axesSpec[g].domain, v = d.domain;
-        return Object.entries(v ?? {}).forEach(([f2, m2]) => {
-          if ((p2 == null ? void 0 : p2[f2]) === void 0) {
-            const w2 = JSON.stringify([f2, m2]);
-            c2.add(w2), s2.add(w2);
+      }
+      return result;
+    });
+    const secondaryIdsVariants = getKeysCombinations(secondaryIdsOptions);
+    const allAddedDomainValues = /* @__PURE__ */ new Set();
+    const addedNotToAllVariantsDomainValues = /* @__PURE__ */ new Set();
+    const addedByVariantsDomainValues = secondaryIdsVariants.map((idsList) => {
+      const addedSet = /* @__PURE__ */ new Set();
+      idsList.map((axisId, idx) => {
+        const d1 = column.spec.axesSpec[idx].domain;
+        const d2 = axisId.domain;
+        Object.entries(d2 ?? {}).forEach(([key, value]) => {
+          if ((d1 == null ? void 0 : d1[key]) === void 0) {
+            const item = JSON.stringify([key, value]);
+            addedSet.add(item);
+            allAddedDomainValues.add(item);
           }
-        }), {
-          ...d,
-          annotations: e.spec.axesSpec[g].annotations
+        });
+        return {
+          ...axisId,
+          annotations: column.spec.axesSpec[idx].annotations
         };
-      }), c2;
+      });
+      return addedSet;
     });
-    [...s2].forEach((u2) => {
-      a.some((c2) => !c2.has(u2)) && o.add(u2);
+    [...allAddedDomainValues].forEach((addedPart) => {
+      if (addedByVariantsDomainValues.some((s) => !s.has(addedPart))) {
+        addedNotToAllVariantsDomainValues.add(addedPart);
+      }
     });
-    const l2 = i.map((u2, c2) => {
-      var f2;
-      const d = Vt(e.id, u2.map((m2) => m2.domain)), g = ((f2 = e.spec.annotations) == null ? void 0 : f2[Ie]) ?? "", p2 = [...a[c2]].filter((m2) => o.has(m2)).sort().map((m2) => {
-        var w2;
-        return (w2 = JSON.parse(m2)) == null ? void 0 : w2[1];
-      }).join(" / "), v = {
-        ...e.spec.annotations,
-        [Jt]: "true"
+    const additionalColumns = secondaryIdsVariants.map((idsList, idx) => {
+      const id = colId(column.id, idsList.map((id2) => id2.domain));
+      const label = readAnnotation(column.spec, Annotation.Label) ?? "";
+      const labelDomainPart = [...addedByVariantsDomainValues[idx]].filter((str) => addedNotToAllVariantsDomainValues.has(str)).sort().map((v) => {
+        var _a;
+        return (_a = JSON.parse(v)) == null ? void 0 : _a[1];
+      }).join(" / ");
+      const annotations = {
+        ...column.spec.annotations,
+        [Annotation.Graph.IsVirtual]: stringifyJson(true)
       };
-      return (g || p2) && (v[Ie] = g && p2 ? g + " / " + p2 : g + p2), {
-        id: d,
+      if (label || labelDomainPart) {
+        annotations[Annotation.Label] = label && labelDomainPart ? label + " / " + labelDomainPart : label + labelDomainPart;
+      }
+      return {
+        id,
         spec: {
-          ...e.spec,
-          axesSpec: u2.map((m2, w2) => ({
-            ...m2,
-            annotations: e.spec.axesSpec[w2].annotations
+          ...column.spec,
+          axesSpec: idsList.map((axisId, idx2) => ({
+            ...axisId,
+            annotations: column.spec.axesSpec[idx2].annotations
           })),
-          annotations: v
+          annotations
         },
-        data: e.data
+        data: column.data
       };
     });
-    return [e, ...l2];
-  }
-  function Kn(t, e) {
-    if (!e) return;
-    const n2 = new le();
-    n2.addColumnProvider(t.resultPool), n2.addColumns(e);
-    const r = /* @__PURE__ */ new Map(), i = /* @__PURE__ */ new Map();
-    for (const d of e)
-      for (const g of d.spec.axesSpec) {
-        const p2 = p$1(g);
-        r.set(ue(p2), p2), i.set(ue(p2), p2);
-      }
-    const s2 = n2.getColumns((d) => Nt(d)) ?? [], o = Bt(s2, r);
-    for (const d of o)
-      r.set(...d), i.set(...d);
-    const a = (n2.getColumns((d) => d.axesSpec.some((g) => {
-      const p2 = p$1(g);
-      for (const v of r.values())
-        if (Z$1(v, p2))
-          return true;
-      return false;
-    }), { dontWaitAllData: true, overrideLabelAnnotation: false }) ?? []).filter((d) => !ve(d.spec));
-    for (const d of a)
-      for (const g of d.spec.axesSpec) {
-        const p2 = p$1(g);
-        i.set(ue(p2), p2);
-      }
-    const l2 = (n2.getColumns((d) => d.axesSpec.some((g) => {
-      const p2 = p$1(g);
-      for (const v of i.values())
-        if (Z$1(v, p2))
-          return true;
-      return false;
-    }), { dontWaitAllData: true, overrideLabelAnnotation: false }) ?? []).filter((d) => ve(d.spec)), u2 = [...a, ...l2], c2 = Wt(r, u2);
-    if (!c2.some(
-      (d) => d.data instanceof E && !d.data.getIsReadyOrError()
-    ))
-      return t.createPFrame(c2);
+    return [column, ...additionalColumns];
+  }
+  function isColumnReady(c) {
+    let ready = true;
+    if (c.data instanceof TreeNodeAccessor) {
+      ready = ready && c.data.getIsReadyOrError();
+    } else if (isDataInfo(c.data)) {
+      visitDataInfo(c.data, (v) => {
+        ready = ready && v.getIsReadyOrError();
+      });
+    }
+    return ready;
+  }
+  function allColumnsReady(columns) {
+    return columns.every(isColumnReady);
   }
-  const model = T.create().withArgs({
+  function createPFrameForGraphs(ctx, blockColumns) {
+    if (!blockColumns) {
+      const columns2 = new PColumnCollection();
+      columns2.addColumnProvider(ctx.resultPool);
+      const allColumns = columns2.getColumns(() => true, { dontWaitAllData: true, overrideLabelAnnotation: false }) ?? [];
+      if (!allColumnsReady(allColumns)) {
+        return void 0;
+      }
+      const allAxes2 = new Map(allColumns.flatMap((column) => getNormalizedAxesList(column.spec.axesSpec)).map((axisSpec) => {
+        const axisId = getAxisId(axisSpec);
+        return [canonicalizeJson(axisId), axisSpec];
+      }));
+      const extendedColumns2 = enrichCompatible(allAxes2, allColumns);
+      return ctx.createPFrame(extendedColumns2);
+    }
+    if (!allColumnsReady(blockColumns)) {
+      return void 0;
+    }
+    const columns = new PColumnCollection();
+    columns.addColumnProvider(ctx.resultPool);
+    columns.addColumns(blockColumns);
+    const blockAxes = /* @__PURE__ */ new Map();
+    const allAxes = /* @__PURE__ */ new Map();
+    for (const c of blockColumns) {
+      for (const spec of getNormalizedAxesList(c.spec.axesSpec)) {
+        const aid = getAxisId(spec);
+        blockAxes.set(canonicalizeJson(aid), spec);
+        allAxes.set(canonicalizeJson(aid), spec);
+      }
+    }
+    const linkerColumns = columns.getColumns((spec) => isLinkerColumn(spec)) ?? [];
+    const availableWithLinkersAxes = getAvailableWithLinkersAxes(linkerColumns, blockAxes);
+    for (const item of availableWithLinkersAxes) {
+      blockAxes.set(...item);
+      allAxes.set(...item);
+    }
+    let compatibleWithoutLabels = (columns.getColumns((spec) => !isHiddenFromGraphColumn(spec) && spec.axesSpec.some((axisSpec) => {
+      const axisId = getAxisId(axisSpec);
+      return Array.from(blockAxes.values()).some((selectorAxisSpec) => matchAxisId(getAxisId(selectorAxisSpec), axisId));
+    }), { dontWaitAllData: true, overrideLabelAnnotation: false }) ?? []).filter((column) => !isLabelColumn(column.spec));
+    if (!allColumnsReady(compatibleWithoutLabels)) {
+      return void 0;
+    }
+    for (const c of compatibleWithoutLabels) {
+      for (const spec of getNormalizedAxesList(c.spec.axesSpec)) {
+        const aid = getAxisId(spec);
+        allAxes.set(canonicalizeJson(aid), spec);
+      }
+    }
+    compatibleWithoutLabels = (columns.getColumns((spec) => !isHiddenFromGraphColumn(spec) && spec.axesSpec.every((axisSpec) => {
+      const axisId = getAxisId(axisSpec);
+      return Array.from(allAxes.values()).some((selectorAxisSpec) => matchAxisId(getAxisId(selectorAxisSpec), axisId));
+    }), { dontWaitAllData: true, overrideLabelAnnotation: false }) ?? []).filter((column) => !isLabelColumn(column.spec));
+    const compatibleLabels = (columns.getColumns((spec) => !isHiddenFromGraphColumn(spec) && spec.axesSpec.some((axisSpec) => {
+      const axisId = getAxisId(axisSpec);
+      return Array.from(allAxes.values()).some((selectorAxisSpec) => matchAxisId(getAxisId(selectorAxisSpec), axisId));
+    }), { dontWaitAllData: true, overrideLabelAnnotation: false }) ?? []).filter((column) => isLabelColumn(column.spec));
+    if (!allColumnsReady(compatibleLabels)) {
+      return void 0;
+    }
+    const compatible = [...compatibleWithoutLabels, ...compatibleLabels];
+    const extendedColumns = enrichCompatible(blockAxes, compatible);
+    return ctx.createPFrame(extendedColumns);
+  }
+  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({
     scChain: "A",
     allele: false
   }).withUiState({
@@ -6152,18 +7014,18 @@
     if (pCols === void 0) {
       return void 0;
     }
-    return Kn(ctx, pCols);
+    return createPFrameForGraphs(ctx, pCols);
   }).output("isRunning", (ctx) => {
     var _a;
     return ((_a = ctx.outputs) == null ? void 0 : _a.getIsReadyOrError()) === false;
   }).title((ctx) => {
     var _a;
     return ((_a = ctx.uiState) == null ? void 0 : _a.blockTitle) ?? "V/J Usage";
-  }).sections((_2) => [
+  }).sections((_) => [
     { type: "link", href: "/", label: "V Gene Usage" },
     { type: "link", href: "/jUsage", label: "J Gene Usage" },
     { type: "link", href: "/vjUsage", label: "V/J Gene Usage" }
-  ]).done();
+  ]).done(2);
   exports2.model = model;
   Object.defineProperty(exports2, Symbol.toStringTag, { value: "Module" });
 });