@milaboratories/milaboratories.ui-examples.model 1.1.29 → 1.1.31

package/dist/bundle.js

@@ -35,7 +35,7 @@
     }, "");
     return `{${values}}`;
   };
-  const k = /* @__PURE__ */ getDefaultExportFromCjs(canonicalize);
+  const g = /* @__PURE__ */ getDefaultExportFromCjs(canonicalize);
   var util;
   (function(util2) {
     util2.assertEqual = (val) => val;
@@ -402,7 +402,7 @@
       };
     }
     let errorMessage = "";
-    const maps = errorMaps.filter((m) => !!m).slice().reverse();
+    const maps = errorMaps.filter((m2) => !!m2).slice().reverse();
     for (const map of maps) {
       errorMessage = map(fullIssue, { data, defaultError: errorMessage }).message;
     }
@@ -3731,10 +3731,10 @@
       return ZodAny.create().superRefine((data, ctx) => {
         var _a, _b;
         if (!check(data)) {
-          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 });
+          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 });
         }
       });
     return ZodAny.create();
@@ -3949,26 +3949,108 @@
     ZodError
   });
   var $ = Object.defineProperty;
-  var F = (n, t, e) => t in n ? $(n, t, { enumerable: true, configurable: true, writable: true, value: e }) : n[t] = e;
-  var d = (n, t, e) => F(n, typeof t != "symbol" ? t + "" : t, e);
-  function g(n) {
+  var L = (n, t, e) => t in n ? $(n, t, { enumerable: true, configurable: true, writable: true, value: e }) : n[t] = e;
+  var p = (n, t, e) => L(n, typeof t != "symbol" ? t + "" : t, e);
+  function w(n) {
     throw new Error("Unexpected object: " + n);
   }
-  function h(n) {
+  function yn(n) {
+    if (!n || typeof n != "object")
+      return false;
+    const t = n;
+    if (!("type" in t))
+      return false;
+    switch (t.type) {
+      case "Json":
+        return typeof t.keyLength == "number" && t.data !== void 0 && typeof t.data == "object";
+      case "JsonPartitioned":
+        return typeof t.partitionKeyLength == "number" && t.parts !== void 0 && typeof t.parts == "object";
+      case "BinaryPartitioned":
+        return typeof t.partitionKeyLength == "number" && t.parts !== void 0 && typeof t.parts == "object";
+      default:
+        return false;
+    }
+  }
+  function mn(n, t) {
+    if (n !== void 0)
+      switch (n.type) {
+        case "Json":
+          return n;
+        case "JsonPartitioned": {
+          const e = {};
+          for (const [r, o] of Object.entries(n.parts))
+            e[r] = t(o);
+          return {
+            ...n,
+            parts: e
+          };
+        }
+        case "BinaryPartitioned": {
+          const e = {};
+          for (const [r, o] of Object.entries(n.parts))
+            e[r] = {
+              index: t(o.index),
+              values: t(o.values)
+            };
+          return {
+            ...n,
+            parts: e
+          };
+        }
+      }
+  }
+  function bn(n) {
+    switch (n.type) {
+      case "Json": {
+        const t = {};
+        for (const e of n.data)
+          t[JSON.stringify(e.key)] = e.value;
+        return {
+          type: "Json",
+          keyLength: n.keyLength,
+          data: t
+        };
+      }
+      case "JsonPartitioned": {
+        const t = {};
+        for (const e of n.parts)
+          t[JSON.stringify(e.key)] = e.value;
+        return {
+          type: "JsonPartitioned",
+          partitionKeyLength: n.partitionKeyLength,
+          parts: t
+        };
+      }
+      case "BinaryPartitioned": {
+        const t = {};
+        for (const e of n.parts)
+          t[JSON.stringify(e.key)] = e.value;
+        return {
+          type: "BinaryPartitioned",
+          partitionKeyLength: n.partitionKeyLength,
+          parts: t
+        };
+      }
+    }
+  }
+  function m(n) {
     const { type: t, name: e, domain: r } = n;
     return { type: t, name: e, ...r && { domain: r } };
   }
-  function Q(n, t) {
+  function Sn(n) {
+    return g(m(n));
+  }
+  function z$1(n, t) {
     if (n === void 0) return t === void 0;
     if (t === void 0) return true;
     for (const e in t)
       if (n[e] !== t[e]) return false;
     return true;
   }
-  function z$1(n, t) {
-    return n.name === t.name && Q(n.domain, t.domain);
+  function G(n, t) {
+    return n.name === t.name && z$1(n.domain, t.domain);
   }
-  function gn(n, t) {
+  function En(n, t) {
     return { ...n, src: l(n.src, t) };
   }
   function l(n, t) {
@@ -3991,94 +4073,113 @@
           secondary: n.secondary.map((e) => l(e, t))
         };
       default:
-        g(n);
+        w(n);
     }
   }
-  function A(n) {
-    return k(h(n));
+  function Q$1(n) {
+    return g(n);
+  }
+  function P(n) {
+    return g(m(n));
   }
   function x(n, t) {
     return JSON.stringify([n, t]);
   }
-  class wn {
+  class On {
     /**
      * Creates a new anchor context from a set of anchor column specifications
      * @param anchors Record of anchor column specifications indexed by anchor ID
      */
     constructor(t) {
-      d(this, "domains", /* @__PURE__ */ new Map());
-      d(this, "axes", /* @__PURE__ */ new Map());
-      d(this, "domainPacks", []);
-      d(this, "domainPackToAnchor", /* @__PURE__ */ new Map());
+      p(this, "domains", /* @__PURE__ */ new Map());
+      p(this, "axes", /* @__PURE__ */ new Map());
+      p(this, "domainPacks", []);
+      p(this, "domainPackToAnchor", /* @__PURE__ */ new Map());
       this.anchors = t;
       const e = Object.entries(t);
       e.sort((r, o) => r[0].localeCompare(o[0]));
       for (const [r, o] of e) {
         for (let i = 0; i < o.axesSpec.length; i++) {
-          const a = o.axesSpec[i], s = A(a);
-          this.axes.set(s, { anchor: r, idx: i });
+          const s = o.axesSpec[i], a = P(s);
+          this.axes.set(a, { anchor: r, idx: i });
         }
         if (o.domain !== void 0) {
           const i = Object.entries(o.domain);
-          i.sort((a, s) => a[0].localeCompare(s[0])), this.domainPackToAnchor.set(JSON.stringify(i), r), this.domainPacks.push(i.map(([a]) => a));
-          for (const [a, s] of i) {
-            const c = x(a, s);
+          i.sort((s, a) => s[0].localeCompare(a[0])), this.domainPackToAnchor.set(JSON.stringify(i), r), this.domainPacks.push(i.map(([s]) => s));
+          for (const [s, a] of i) {
+            const c = x(s, a);
             this.domains.set(c, r);
           }
         }
       }
     }
     /**
-     * Derives an anchored column identifier from a column specification
-     * Replaces domain values and axes with anchored references when possible
-     * @param spec Column specification to anchor
-     * @returns An anchored column identifier that can be used to identify columns similar to the input specification
+     * Implementation of derive method
      */
-    derive(t) {
-      const e = {
+    derive(t, e) {
+      const r = {
         name: t.name,
         axes: []
       };
-      let r;
+      let o;
       if (t.domain !== void 0)
         n:
-          for (const o of this.domainPacks) {
-            const i = [];
-            for (const s of o) {
-              const c = t.domain[s];
-              if (c !== void 0)
-                i.push([s, c]);
+          for (const s of this.domainPacks) {
+            const a = [];
+            for (const u of s) {
+              const d = t.domain[u];
+              if (d !== void 0)
+                a.push([u, d]);
               else
                 break n;
             }
-            const a = this.domainPackToAnchor.get(JSON.stringify(i));
-            if (a !== void 0) {
-              e.domainAnchor = a, r = new Set(o);
+            const c = this.domainPackToAnchor.get(JSON.stringify(a));
+            if (c !== void 0) {
+              r.domainAnchor = c, o = new Set(s);
               break;
             }
           }
-      for (const [o, i] of Object.entries(t.domain ?? {})) {
-        if (r !== void 0 && r.has(o))
+      for (const [s, a] of Object.entries(t.domain ?? {})) {
+        if (o !== void 0 && o.has(s))
           continue;
-        const a = x(o, i), s = this.domains.get(a);
-        e.domain ?? (e.domain = {}), e.domain[o] = s ? { anchor: s } : i;
+        const c = x(s, a), u = this.domains.get(c);
+        r.domain ?? (r.domain = {}), r.domain[s] = u ? { anchor: u } : a;
       }
-      return e.axes = t.axesSpec.map((o) => {
-        const i = A(o);
-        return this.axes.get(i) ?? o;
-      }), e;
+      if (r.axes = t.axesSpec.map((s) => {
+        const a = P(s);
+        return this.axes.get(a) ?? s;
+      }), !e || e.length === 0)
+        return r;
+      const i = [];
+      for (const s of e) {
+        const [a, c] = s;
+        if (typeof a == "number") {
+          if (a < 0 || a >= t.axesSpec.length)
+            throw new Error(`Axis index ${a} is out of bounds (0-${t.axesSpec.length - 1})`);
+          i.push([a, c]);
+        } else {
+          const u = t.axesSpec.findIndex((d) => d.name === a);
+          if (u === -1)
+            throw new Error(`Axis with name "${a}" not found in the column specification`);
+          i.push([u, c]);
+        }
+      }
+      return i.sort((s, a) => s[0] - a[0]), {
+        source: r,
+        axisFilters: i
+      };
     }
     /**
      * Derives a canonicalized string representation of an anchored column identifier, can be used as a unique identifier for the column
      * @param spec Column specification to anchor
+     * @param axisFilters Optional axis filters to apply to the column
      * @returns A canonicalized string representation of the anchored column identifier
      */
-    deriveCanonical(t) {
-      const e = this.derive(t);
-      return k(e);
+    deriveS(t, e) {
+      return Q$1(this.derive(t, e));
     }
   }
-  function An(n, t) {
+  function Jn(n, t) {
     const e = { ...t };
     if (e.domainAnchor !== void 0) {
       const r = n[e.domainAnchor];
@@ -4093,19 +4194,19 @@
         if (typeof i == "string")
           r[o] = i;
         else {
-          const a = n[i.anchor];
-          if (!a)
+          const s = n[i.anchor];
+          if (!s)
             throw new Error(`Anchor "${i.anchor}" not found for domain key "${o}"`);
-          if (!a.domain || a.domain[o] === void 0)
+          if (!s.domain || s.domain[o] === void 0)
             throw new Error(`Domain key "${o}" not found in anchor "${i.anchor}"`);
-          r[o] = a.domain[o];
+          r[o] = s.domain[o];
         }
       e.domain = r;
     }
-    return e.axes && (e.axes = e.axes.map((r) => Y(n, r))), e;
+    return e.axes && (e.axes = e.axes.map((r) => Y$1(n, r))), e;
   }
-  function Y(n, t) {
-    if (!Z(t))
+  function Y$1(n, t) {
+    if (!Z$1(t))
       return t;
     const e = t.anchor, r = n[e];
     if (!r)
@@ -4122,7 +4223,7 @@
         throw new Error(`Axis with name "${t.name}" not found in anchor "${e}"`);
       return o[0];
     } else if ("id" in t) {
-      const o = r.axesSpec.filter((i) => z$1(t.id, h(i)));
+      const o = r.axesSpec.filter((i) => G(t.id, m(i)));
       if (o.length > 1)
         throw new Error(`Multiple matching axes found for matcher in anchor "${e}"`);
       if (o.length === 0)
@@ -4131,26 +4232,26 @@
     }
     throw new Error("Unsupported axis reference type");
   }
-  function Z(n) {
+  function Z$1(n) {
     return typeof n == "object" && "anchor" in n;
   }
-  function f$1(n) {
+  function f(n) {
     return n.kind === "PColumn";
   }
   function q$1(n) {
-    return f$1(n.spec);
+    return f(n.spec);
   }
-  function En(n) {
+  function Dn(n) {
     if (!q$1(n)) throw new Error(`not a PColumn (kind = ${n.spec.kind})`);
     return n;
   }
-  function kn(n, t) {
+  function jn(n, t) {
     return n === void 0 ? void 0 : {
       ...n,
       data: t(n.data)
     };
   }
-  function In(n) {
+  function Bn(n) {
     const t = /* @__PURE__ */ new Map(), e = (r) => {
       switch (r.type) {
         case "column":
@@ -4165,12 +4266,12 @@
           for (const o of r.secondary) e(o);
           return;
         default:
-          g(r);
+          w(r);
       }
     };
     return e(n), [...t.values()];
   }
-  function P$1(n, t) {
+  function k(n, t) {
     if (n.name !== void 0 && n.name !== t.name)
       return false;
     if (n.type !== void 0) {
@@ -4188,7 +4289,7 @@
     }
     return true;
   }
-  function E$1(n, t) {
+  function N$1(n, t) {
     if (t.name !== void 0 && n.name !== t.name || t.namePattern !== void 0 && !new RegExp(t.namePattern).test(n.name))
       return false;
     if (t.type !== void 0) {
@@ -4205,16 +4306,16 @@
           return false;
     }
     if (t.axes !== void 0) {
-      const e = n.axesSpec.map(h);
+      const e = n.axesSpec.map(m);
       if (t.partialAxesMatch) {
         for (const r of t.axes)
-          if (!e.some((o) => P$1(r, o)))
+          if (!e.some((o) => k(r, o)))
             return false;
       } else {
         if (e.length !== t.axes.length)
           return false;
         for (let r = 0; r < t.axes.length; r++)
-          if (!P$1(t.axes[r], e[r]))
+          if (!k(t.axes[r], e[r]))
             return false;
       }
     }
@@ -4234,8 +4335,8 @@
     }
     return true;
   }
-  function Nn(n) {
-    return Array.isArray(n) ? (t) => n.some((e) => f$1(t) && E$1(t, e)) : (t) => f$1(t) && E$1(t, n);
+  function In(n) {
+    return Array.isArray(n) ? (t) => n.some((e) => f(t) && N$1(t, e)) : (t) => f(t) && N$1(t, n);
   }
   z$2.object({
     __isRef: z$2.literal(true).describe("Crucial marker for the block dependency tree reconstruction"),
@@ -4244,100 +4345,100 @@
   }).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."
   ).strict().readonly();
-  function Vn(n) {
+  function Kn(n) {
     return typeof n == "object" && n !== null && "__isRef" in n && n.__isRef === true && "blockId" in n && "name" in n;
   }
-  function Fn(n, t) {
+  function Mn(n, t) {
     return n.ok ? { ok: true, value: t(n.value) } : n;
   }
-  const on = 24;
-  z$2.string().length(on).regex(/[ABCDEFGHIJKLMNOPQRSTUVWXYZ234567]/).brand("PlId");
-  var ve = Object.defineProperty;
-  var _e = (t, e, n) => e in t ? ve(t, e, { enumerable: true, configurable: true, writable: true, value: n }) : t[e] = n;
-  var P = (t, e, n) => _e(t, typeof e != "symbol" ? e + "" : e, n);
-  function j(t) {
+  const an = 24;
+  z$2.string().length(an).regex(/[ABCDEFGHIJKLMNOPQRSTUVWXYZ234567]/).brand("PlId");
+  var _e = Object.defineProperty;
+  var Ie = (t, e, n) => e in t ? _e(t, e, { enumerable: true, configurable: true, writable: true, value: n }) : t[e] = n;
+  var T = (t, e, n) => Ie(t, typeof e != "symbol" ? e + "" : e, n);
+  function Y(t) {
     return { type: "Immediate", value: t };
   }
-  function Fe() {
+  function Ke() {
     return typeof globalThis.getPlatforma < "u" || typeof globalThis.platforma < "u";
   }
-  function de(t) {
+  function be(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 Te() {
+  function $e() {
     if (typeof globalThis.cfgRenderCtx < "u") return globalThis.cfgRenderCtx;
   }
-  function f() {
+  function h() {
     if (typeof globalThis.cfgRenderCtx < "u") return globalThis.cfgRenderCtx;
     throw new Error("Not in config rendering context");
   }
-  function E(t, e) {
-    const n = Te();
+  function q(t, e) {
+    const n = $e();
     if (n === void 0) return false;
     if (t in n.callbackRegistry) throw new Error(`Callback with key ${t} already registered.`);
     return n.callbackRegistry[t] = e, true;
   }
-  const W = /* @__PURE__ */ new Map();
-  function xe(t, e) {
-    t in f().callbackRegistry || (f().callbackRegistry[t] = (n) => {
-      for (const s of W.get(t))
-        s(n);
-    }, W.set(t, [])), W.get(t).push(e);
+  const ne = /* @__PURE__ */ new Map();
+  function Je(t, e) {
+    t in h().callbackRegistry || (h().callbackRegistry[t] = (n) => {
+      for (const r of ne.get(t))
+        r(n);
+    }, ne.set(t, [])), ne.get(t).push(e);
   }
-  class _ {
-    constructor(e, n = (s) => s) {
-      P(this, "isResolved", false);
-      P(this, "resolvedValue");
-      this.handle = e, this.postProcess = n, xe(e, (s) => {
-        this.resolvedValue = n(s), this.isResolved = true;
+  class S {
+    constructor(e, n = (r) => r) {
+      T(this, "isResolved", false);
+      T(this, "resolvedValue");
+      this.handle = e, this.postProcess = n, Je(e, (r) => {
+        this.resolvedValue = n(r), this.isResolved = true;
       });
     }
     map(e) {
-      return new _(this.handle, (n) => e(this.postProcess(n)));
+      return new S(this.handle, (n) => e(this.postProcess(n)));
     }
     mapDefined(e) {
-      return new _(this.handle, (n) => {
-        const s = this.postProcess(n);
-        return s ? e(s) : void 0;
+      return new S(this.handle, (n) => {
+        const r = this.postProcess(n);
+        return r ? e(r) : void 0;
       });
     }
     toJSON() {
       return this.isResolved ? this.resolvedValue : { __awaited_futures__: [this.handle] };
     }
   }
-  function z(t, e) {
+  function ie(t, e) {
     return t === void 0 ? void 0 : e(t);
   }
-  class S {
+  class I {
     constructor(e, n) {
       this.handle = e, this.resolvePath = n;
     }
     resolve(...e) {
       const n = e.map(
-        (s) => ({
+        (r) => ({
           assertFieldType: "Input",
-          ...typeof s == "string" ? { field: s } : s
+          ...typeof r == "string" ? { field: r } : r
         })
       );
       return this.resolveWithCommon({}, ...n);
     }
     resolveOutput(...e) {
       const n = e.map(
-        (s) => ({
+        (r) => ({
           assertFieldType: "Output",
-          ...typeof s == "string" ? { field: s } : s
+          ...typeof r == "string" ? { field: r } : r
         })
       );
       return this.resolveWithCommon({}, ...n);
     }
     resolveInput(...e) {
       const n = e.map(
-        (s) => ({
+        (r) => ({
           assertFieldType: "Input",
-          ...typeof s == "string" ? { field: s } : s
+          ...typeof r == "string" ? { field: r } : r
         })
       );
       return this.resolveWithCommon({}, ...n);
@@ -4346,51 +4447,51 @@
       return this.resolveWithCommon({}, ...e);
     }
     resolveWithCommon(e, ...n) {
-      const s = [
+      const r = [
         ...this.resolvePath,
-        ...n.map((r) => typeof r == "string" ? r : r.field)
+        ...n.map((i) => typeof i == "string" ? i : i.field)
       ];
-      return z(
-        f().resolveWithCommon(this.handle, e, ...n),
-        (r) => new S(r, s)
+      return ie(
+        h().resolveWithCommon(this.handle, e, ...n),
+        (i) => new I(i, r)
       );
     }
     get resourceType() {
-      return f().getResourceType(this.handle);
+      return h().getResourceType(this.handle);
     }
     getInputsLocked() {
-      return f().getInputsLocked(this.handle);
+      return h().getInputsLocked(this.handle);
     }
     getOutputsLocked() {
-      return f().getOutputsLocked(this.handle);
+      return h().getOutputsLocked(this.handle);
     }
     getIsReadyOrError() {
-      return f().getIsReadyOrError(this.handle);
+      return h().getIsReadyOrError(this.handle);
     }
     getIsFinal() {
-      return f().getIsFinal(this.handle);
+      return h().getIsFinal(this.handle);
     }
     getError() {
       const e = [...this.resolvePath, "error"];
-      return z(
-        f().getError(this.handle),
-        (n) => new S(n, e)
+      return ie(
+        h().getError(this.handle),
+        (n) => new I(n, e)
       );
     }
     listInputFields() {
-      return f().listInputFields(this.handle);
+      return h().listInputFields(this.handle);
     }
     listOutputFields() {
-      return f().listOutputFields(this.handle);
+      return h().listOutputFields(this.handle);
     }
     listDynamicFields() {
-      return f().listDynamicFields(this.handle);
+      return h().listDynamicFields(this.handle);
     }
     getKeyValueBase64(e) {
-      return f().getKeyValueBase64(this.handle, e);
+      return h().getKeyValueBase64(this.handle, e);
     }
     getKeyValueAsString(e) {
-      return f().getKeyValueAsString(this.handle, e);
+      return h().getKeyValueAsString(this.handle, e);
     }
     getKeyValueAsJson(e) {
       const n = this.getKeyValueAsString(e);
@@ -4398,10 +4499,10 @@
       return JSON.parse(n);
     }
     getDataBase64() {
-      return f().getDataBase64(this.handle);
+      return h().getDataBase64(this.handle);
     }
     getDataAsString() {
-      return f().getDataAsString(this.handle);
+      return h().getDataAsString(this.handle);
     }
     getDataAsJson() {
       const e = this.getDataAsString();
@@ -4412,39 +4513,39 @@
      *
      */
     getPColumns(e = false, n = "") {
-      const s = this.parsePObjectCollection(e, n);
-      return s === void 0 ? void 0 : Object.entries(s).map(([, i]) => {
-        if (!q$1(i)) throw new Error(`not a PColumn (kind = ${i.spec.kind})`);
-        return i;
+      const r = this.parsePObjectCollection(e, n);
+      return r === void 0 ? void 0 : Object.entries(r).map(([, s]) => {
+        if (!q$1(s)) throw new Error(`not a PColumn (kind = ${s.spec.kind})`);
+        return s;
       });
     }
     /**
      *
      */
     parsePObjectCollection(e = false, n = "") {
-      const s = f().parsePObjectCollection(
+      const r = h().parsePObjectCollection(
         this.handle,
         e,
         n,
         ...this.resolvePath
       );
-      if (s === void 0) return;
-      const r = {};
-      for (const [i, o] of Object.entries(s)) {
-        const l2 = [...this.resolvePath, i];
-        r[i] = kn(o, (a) => new S(a, l2));
+      if (r === void 0) return;
+      const i = {};
+      for (const [s, o] of Object.entries(r)) {
+        const a = [...this.resolvePath, s];
+        i[s] = jn(o, (c) => new I(c, a));
       }
-      return r;
+      return i;
     }
     getFileContentAsBase64() {
-      return new _(f().getBlobContentAsBase64(this.handle));
+      return new S(h().getBlobContentAsBase64(this.handle));
     }
     getFileContentAsString() {
-      return new _(f().getBlobContentAsString(this.handle));
+      return new S(h().getBlobContentAsString(this.handle));
     }
     getFileContentAsJson() {
-      return new _(
-        f().getBlobContentAsString(this.handle)
+      return new S(
+        h().getBlobContentAsString(this.handle)
       ).mapDefined((e) => JSON.parse(e));
     }
     /**
@@ -4463,7 +4564,7 @@
      * @returns downloaded file handle
      */
     getFileHandle() {
-      return new _(f().getDownloadedBlobContentHandle(this.handle));
+      return new S(h().getDownloadedBlobContentHandle(this.handle));
     }
     /**
      * @deprecated use getFileHandle
@@ -4475,7 +4576,7 @@
      * @returns downloaded file handle
      */
     getRemoteFileHandle() {
-      return new _(f().getOnDemandBlobContentHandle(this.handle));
+      return new S(h().getOnDemandBlobContentHandle(this.handle));
     }
     /**
      * @deprecated use getRemoteFileHandle
@@ -4487,22 +4588,22 @@
      * @returns the url to the extracted folder
      */
     extractArchiveAndGetURL(e) {
-      return new _(f().extractArchiveAndGetURL(this.handle, e));
+      return new S(h().extractArchiveAndGetURL(this.handle, e));
     }
     getImportProgress() {
-      return new _(f().getImportProgress(this.handle));
+      return new S(h().getImportProgress(this.handle));
     }
     getLastLogs(e) {
-      return new _(f().getLastLogs(this.handle, e));
+      return new S(h().getLastLogs(this.handle, e));
     }
     getProgressLog(e) {
-      return new _(f().getProgressLog(this.handle, e));
+      return new S(h().getProgressLog(this.handle, e));
     }
     getProgressLogWithInfo(e) {
-      return new _(f().getProgressLogWithInfo(this.handle, e));
+      return new S(h().getProgressLogWithInfo(this.handle, e));
     }
     getLogHandle() {
-      return new _(f().getLogHandle(this.handle));
+      return new S(h().getLogHandle(this.handle));
     }
     allFieldsResolved(e = "Input") {
       switch (e) {
@@ -4517,88 +4618,340 @@
       }
     }
     mapFields(e, n) {
-      const { fieldType: s, requireLocked: r, skipUnresolved: i } = {
+      const { fieldType: r, requireLocked: i, skipUnresolved: s } = {
         fieldType: "Input",
         requireLocked: true,
         skipUnresolved: false,
         ...n
       }, o = e;
-      if (r && (s === "Input" && !this.getInputsLocked() || s === "Output" && !this.getOutputsLocked()))
+      if (i && (r === "Input" && !this.getInputsLocked() || r === "Output" && !this.getOutputsLocked()))
         return;
-      let a = (s === "Input" ? this.listInputFields() : s === "Output" ? this.listOutputFields() : this.listDynamicFields()).map(
-        (u) => [u, this.resolve({ field: u, assertFieldType: s })]
+      let c = (r === "Input" ? this.listInputFields() : r === "Output" ? this.listOutputFields() : this.listDynamicFields()).map(
+        (l2) => [l2, this.resolve({ field: l2, assertFieldType: r })]
       );
-      return i && (a = a.filter((u) => u[1] !== void 0)), a.map(([u, g2]) => o(u, g2));
+      return s && (c = c.filter((l2) => l2[1] !== void 0)), c.map(([l2, m2]) => o(l2, m2));
     }
   }
-  const pe = "staging", fe = "main";
-  const Oe = "pl7.app/label", ke = "pl7.app/trace", Ee = z$2.object({
+  const ve = "staging", we = "main";
+  const Ue = "pl7.app/label", Me = "pl7.app/trace", Ge = z$2.object({
     type: z$2.string(),
     importance: z$2.number().optional(),
     id: z$2.string().optional(),
     label: z$2.string()
-  }), Ve = z$2.array(Ee), je = 1e-3, Ne = "__LABEL__", se = "__LABEL__@1";
-  function re(t, e, n = {}) {
-    const s = /* @__PURE__ */ new Map(), r = /* @__PURE__ */ new Map(), i = t.map((d2) => {
-      var A2, ee;
-      const h2 = e(d2), p = (A2 = h2.annotations) == null ? void 0 : A2[Oe], b = (ee = h2.annotations) == null ? void 0 : ee[ke], m = (b ? Ve.safeParse(JSON.parse(b)).data : void 0) ?? [];
-      if (p) {
-        const C = { label: p, type: Ne, importance: -2 };
-        n.addLabelAsSuffix ? m.push(C) : m.splice(0, 0, C);
-      }
-      const I = [], v = /* @__PURE__ */ new Map();
-      for (let C = m.length - 1; C >= 0; --C) {
-        const { type: J } = m[C], be = m[C].importance ?? 0, M = (v.get(J) ?? 0) + 1;
-        v.set(J, M);
-        const x2 = `${J}@${M}`;
-        r.set(x2, (r.get(x2) ?? 0) + 1), s.set(
-          x2,
+  }), We = z$2.array(Ge), He = 1e-3, qe = "__LABEL__", pe = "__LABEL__@1";
+  function de(t, e, n = {}) {
+    const r = /* @__PURE__ */ new Map(), i = /* @__PURE__ */ new Map(), s = t.map((f2) => {
+      var R, k2;
+      const p2 = e(f2);
+      let d, y, g2;
+      "spec" in p2 && typeof p2.spec == "object" ? (d = p2.spec, y = p2.prefixTrace, g2 = p2.suffixTrace) : d = p2;
+      const v = (R = d.annotations) == null ? void 0 : R[Ue], w2 = (k2 = d.annotations) == null ? void 0 : k2[Me], x2 = (w2 ? We.safeParse(JSON.parse(w2)).data : void 0) ?? [], C = [
+        ...y ?? [],
+        ...x2,
+        ...g2 ?? []
+      ];
+      if (v) {
+        const A = { label: v, type: qe, importance: -2 };
+        n.addLabelAsSuffix ? C.push(A) : C.splice(0, 0, A);
+      }
+      const P2 = [], F = /* @__PURE__ */ new Map();
+      for (let A = C.length - 1; A >= 0; --A) {
+        const { type: j } = C[A], V = C[A].importance ?? 0, K = (F.get(j) ?? 0) + 1;
+        F.set(j, K);
+        const $2 = `${j}@${K}`;
+        i.set($2, (i.get($2) ?? 0) + 1), r.set(
+          $2,
           Math.max(
-            s.get(x2) ?? Number.NEGATIVE_INFINITY,
-            be - (m.length - C) * je
+            r.get($2) ?? Number.NEGATIVE_INFINITY,
+            V - (C.length - A) * He
           )
-        ), I.push({ ...m[C], fullType: x2, occurenceIndex: M });
+        ), P2.push({ ...C[A], fullType: $2, occurenceIndex: K });
       }
-      return I.reverse(), {
-        value: d2,
-        spec: h2,
-        label: p,
-        fullTrace: I
+      return P2.reverse(), {
+        value: f2,
+        spec: d,
+        label: v,
+        fullTrace: P2
       };
-    }), o = [], l2 = [], a = [...s];
-    a.sort(([, d2], [, h2]) => h2 - d2);
-    for (const [d2] of a)
-      d2.endsWith("@1") || r.get(d2) === t.length ? o.push(d2) : l2.push(d2);
-    const u = (d2) => i.map((h2) => {
-      const p = h2.fullTrace.filter((m) => d2.has(m.fullType)).map((m) => m.label), b = n.separator ?? " / ";
+    }), o = [], a = [], c = [...r];
+    c.sort(([, f2], [, p2]) => p2 - f2);
+    for (const [f2] of c)
+      f2.endsWith("@1") || i.get(f2) === t.length ? o.push(f2) : a.push(f2);
+    const l2 = (f2) => s.map((p2) => {
+      const d = p2.fullTrace.filter((g2) => f2.has(g2.fullType)).map((g2) => g2.label), y = n.separator ?? " / ";
       return {
-        label: p.join(b),
-        value: h2.value
+        label: d.join(y),
+        value: p2.value
       };
     });
     if (o.length === 0) {
-      if (l2.length !== 0) throw new Error("Assertion error.");
-      return u(new Set(se));
-    }
-    let g2 = 0, c = 0;
-    for (; g2 < o.length; ) {
-      const d2 = /* @__PURE__ */ new Set();
-      n.includeNativeLabel && d2.add(se);
-      for (let p = 0; p < g2; ++p) d2.add(o[p]);
-      d2.add(o[c]);
-      const h2 = u(d2);
-      if (new Set(h2.map((p) => p.label)).size === t.length) return h2;
-      c++, c == o.length && (g2++, c = g2);
-    }
-    return u(/* @__PURE__ */ new Set([...o, ...l2]));
+      if (a.length !== 0) throw new Error("Assertion error.");
+      return l2(new Set(pe));
+    }
+    let m2 = 0, u = 0;
+    for (; m2 < o.length; ) {
+      const f2 = /* @__PURE__ */ new Set();
+      n.includeNativeLabel && f2.add(pe);
+      for (let d = 0; d < m2; ++d) f2.add(o[d]);
+      f2.add(o[u]);
+      const p2 = l2(f2);
+      if (new Set(p2.map((d) => d.label)).size === t.length) return p2;
+      u++, u == o.length && (m2++, u = m2);
+    }
+    return l2(/* @__PURE__ */ new Set([...o, ...a]));
   }
-  class Ue {
+  const H = "PColumnData/", Q = H + "ResourceMap", Z = H + "Partitioned/ResourceMap", N = H + "JsonPartitioned", O = H + "BinaryPartitioned", Ae = H + "Partitioned/", ee = Ae + "JsonPartitioned", B = Ae + "BinaryPartitioned";
+  const ae = (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}`);
+  };
+  function ze(t) {
+    if (!t) return;
+    const e = t.resourceType.name, n = t.getDataAsJson(), r = [];
+    let i = 0;
+    switch (e) {
+      case Q:
+        i = n.keyLength;
+        break;
+      case Z:
+        i = n.partitionKeyLength + n.keyLength;
+        break;
+      case N:
+      case O:
+        i = n.partitionKeyLength;
+        break;
+      case B:
+      case ee:
+        i = n.superPartitionKeyLength + n.partitionKeyLength;
+        break;
+    }
+    switch (e) {
+      case Q:
+      case N:
+      case O:
+        for (let s of t.listInputFields()) {
+          e === O && (s = ae(s).baseKey);
+          const o = [...JSON.parse(s)];
+          r.push(o);
+        }
+        break;
+      case Z:
+      case B:
+      case ee:
+        for (const s of t.listInputFields()) {
+          const o = [...JSON.parse(s)], a = t.resolve({ field: s, assertFieldType: "Input" });
+          if (a !== void 0)
+            for (let c of a.listInputFields()) {
+              e === B && (c = ae(c).baseKey);
+              const l2 = [...o, ...JSON.parse(c)];
+              r.push(l2);
+            }
+        }
+        break;
+    }
+    return { data: r, keyLength: i };
+  }
+  function Ye(t) {
+    const e = ze(t);
+    if (!e) return;
+    const { data: n, keyLength: r } = e, i = [];
+    for (let s = 0; s < r; ++s)
+      i.push(/* @__PURE__ */ new Set());
+    for (const s of n) {
+      if (s.length !== r)
+        throw new Error("key length does not match partition length");
+      for (let o = 0; o < r; ++o)
+        i[o].add(s[o]);
+    }
+    return i.map((s) => Array.from(s.values()));
+  }
+  function le(t, e = []) {
+    if (t === void 0) return;
+    const n = t.resourceType.name, r = t.getDataAsJson();
+    if (e.length > 0 && (n === ee || n === B))
+      throw new Error(`Unexpected nested super-partitioned resource: ${n}`);
+    switch (n) {
+      case Q:
+      case Z:
+        throw new Error(`Only data columns are supported, got: ${n}`);
+      case N: {
+        if (typeof (r == null ? void 0 : r.partitionKeyLength) != "number")
+          throw new Error(`Missing partitionKeyLength in metadata for ${n}`);
+        const i = [];
+        for (const s of t.listInputFields()) {
+          const o = t.resolve({ field: s, assertFieldType: "Input" });
+          if (o === void 0) return;
+          const a = [...e, ...JSON.parse(s)];
+          i.push({ key: a, value: o });
+        }
+        return {
+          type: "JsonPartitioned",
+          partitionKeyLength: r.partitionKeyLength,
+          parts: i
+        };
+      }
+      case O: {
+        if (typeof (r == null ? void 0 : r.partitionKeyLength) != "number")
+          throw new Error(`Missing partitionKeyLength in metadata for ${n}`);
+        const i = [], s = /* @__PURE__ */ new Map();
+        for (const o of t.listInputFields()) {
+          const a = ae(o), c = t.resolve({ field: o, assertFieldType: "Input" });
+          if (c === void 0) return;
+          let l2 = s.get(a.baseKey);
+          l2 || (l2 = {}, s.set(a.baseKey, l2)), a.type === "index" ? l2.index = c : l2.values = c;
+        }
+        for (const [o, a] of s.entries()) {
+          if (!a.index || !a.values) return;
+          const c = [...e, ...JSON.parse(o)];
+          i.push({
+            key: c,
+            value: {
+              index: a.index,
+              values: a.values
+            }
+          });
+        }
+        return {
+          type: "BinaryPartitioned",
+          partitionKeyLength: r.partitionKeyLength,
+          parts: i
+        };
+      }
+      case ee: {
+        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 ${n}`);
+        const i = r.superPartitionKeyLength + r.partitionKeyLength, s = [];
+        for (const o of t.listInputFields()) {
+          const a = t.resolve({ field: o, assertFieldType: "Input" });
+          if (a === void 0) return;
+          if (a.resourceType.name !== N)
+            throw new Error(`Expected ${N} inside ${n}, but got ${a.resourceType.name}`);
+          const c = le(a, JSON.parse(o));
+          if (c === void 0) return;
+          if (c.type !== "JsonPartitioned")
+            throw new Error(`Unexpected inner result type for ${n}: ${c.type}`);
+          s.push(...c.parts);
+        }
+        return {
+          type: "JsonPartitioned",
+          partitionKeyLength: i,
+          parts: s
+        };
+      }
+      case B: {
+        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 ${n}`);
+        const i = r.superPartitionKeyLength + r.partitionKeyLength, s = [];
+        for (const o of t.listInputFields()) {
+          const a = t.resolve({ field: o, assertFieldType: "Input" });
+          if (a === void 0) return;
+          if (a.resourceType.name !== O)
+            throw new Error(`Expected ${O} inside ${n}, but got ${a.resourceType.name}`);
+          const c = le(a, JSON.parse(o));
+          if (c === void 0) return;
+          if (c.type !== "BinaryPartitioned")
+            throw new Error(`Unexpected inner result type for ${n}: ${c.type}`);
+          s.push(...c.parts);
+        }
+        return {
+          type: "BinaryPartitioned",
+          partitionKeyLength: i,
+          parts: s
+        };
+      }
+      default:
+        throw new Error(`Unknown resource type: ${n}`);
+    }
+  }
+  function Xe(t, e) {
+    const n = [...e].sort((s, o) => o[0] - s[0]);
+    if (t.type === "JsonPartitioned" || t.type === "BinaryPartitioned") {
+      const { partitionKeyLength: s } = t;
+      for (const [o] of e)
+        if (o >= s)
+          throw new Error(`Can't filter on non-partitioned axis ${o}. Must be >= ${s}`);
+    } else if (t.type === "Json") {
+      const { keyLength: s } = t;
+      for (const [o] of e)
+        if (o >= s)
+          throw new Error(`Can't filter on non-data axis ${o}. Must be >= ${s}`);
+    }
+    const r = (s) => {
+      for (const [o, a] of n)
+        if (s[o] !== a)
+          return false;
+      return true;
+    }, i = (s) => {
+      const o = [...s];
+      for (const [a] of n)
+        o.splice(a, 1);
+      return o;
+    };
+    switch (t.type) {
+      case "Json": {
+        const s = t.data.filter((o) => r(o.key)).map((o) => ({
+          key: i(o.key),
+          value: o.value
+        }));
+        return {
+          type: "Json",
+          keyLength: t.keyLength - e.length,
+          data: s
+        };
+      }
+      case "JsonPartitioned": {
+        const s = t.parts.filter((o) => r(o.key)).map((o) => ({
+          key: i(o.key),
+          value: o.value
+        }));
+        return {
+          type: "JsonPartitioned",
+          partitionKeyLength: t.partitionKeyLength - e.length,
+          parts: s
+        };
+      }
+      case "BinaryPartitioned": {
+        const s = t.parts.filter((o) => r(o.key)).map((o) => ({
+          key: i(o.key),
+          value: o.value
+        }));
+        return {
+          type: "BinaryPartitioned",
+          partitionKeyLength: t.partitionKeyLength - e.length,
+          parts: s
+        };
+      }
+    }
+  }
+  function re(t, e) {
+    if (t === void 0) return e === void 0;
+    if (e === void 0) return true;
+    for (const n in e)
+      if (t[n] !== e[n]) return false;
+    return true;
+  }
+  function fe(t) {
+    return jn(t, (e) => e instanceof I ? e.handle : yn(e) ? mn(e, (n) => n.handle) : e);
+  }
+  function Qe(t) {
+    if (t)
+      return t.map((e) => ({
+        type: `split:${Sn(e.axisId)}`,
+        label: e.label,
+        importance: 1e6
+        // High importance for split filters in labels
+      }));
+  }
+  function Ze(t) {
+    if (t)
+      return t.map((e) => [e.axisIdx, e.value]);
+  }
+  class et {
     constructor() {
-      P(this, "ctx", f());
-      P(this, "defaultLabelFn", (e, n) => {
-        var s;
-        return ((s = e.annotations) == null ? void 0 : s["pl7.app/label"]) ?? "Unlabelled";
-      });
+      T(this, "ctx", h());
     }
     /**
      * @deprecated use getOptions()
@@ -4607,35 +4960,199 @@
       return this.ctx.calculateOptions(e);
     }
     getOptions(e, n) {
-      const s = typeof e == "function" ? e : Nn(e), r = this.getSpecs().entries.filter((i) => s(i.obj));
-      return typeof n == "object" || typeof n > "u" ? re(r, (i) => i.obj, n ?? {}).map(({ value: { ref: i }, label: o }) => ({
-        ref: i,
+      const r = typeof e == "function" ? e : In(e), i = this.getSpecs().entries.filter((s) => r(s.obj));
+      return typeof n == "object" || typeof n > "u" ? de(i, (s) => s.obj, n ?? {}).map(({ value: { ref: s }, label: o }) => ({
+        ref: s,
         label: o
-      })) : r.map((i) => ({
-        ref: i.ref,
-        label: n(i.obj, i.ref)
+      })) : i.map((s) => ({
+        ref: s.ref,
+        label: n(s.obj, s.ref)
       }));
     }
-    // Implementation
-    getCanonicalOptions(e, n, s) {
-      const r = {};
-      if (!(e instanceof wn))
-        for (const [a, u] of Object.entries(e))
-          if (Vn(u)) {
-            const g2 = this.getPColumnSpecByRef(u);
-            if (!g2)
+    /**
+     * Internal implementation that generates UniversalPColumnEntry objects from the provided
+     * anchors and selectors.
+     */
+    getUniversalPColumnEntries(e, n, r) {
+      const i = {};
+      if (!(e instanceof On))
+        for (const [l2, m2] of Object.entries(e))
+          if (Kn(m2)) {
+            const u = this.getPColumnSpecByRef(m2);
+            if (!u)
               return;
-            r[a] = g2;
+            i[l2] = u;
           } else
-            r[a] = u;
-      const i = typeof n == "function" ? n : Nn(
-        Array.isArray(n) ? n.map((a) => An(r, a)) : An(r, n)
-      ), o = this.getSpecs().entries.filter(({ obj: a }) => f$1(a) ? i(a) : false), l2 = e instanceof wn ? e : new wn(r);
-      return re(o, (a) => a.obj, s ?? {}).map(({ value: { obj: a }, label: u }) => ({
-        value: l2.deriveCanonical(a),
-        label: u
+            i[l2] = m2;
+      const s = typeof n == "function" ? [n] : Array.isArray(n) ? n : [n], o = e instanceof On ? e : new On(i), a = [];
+      for (const l2 of s) {
+        const m$1 = typeof l2 == "function" ? l2 : In(Jn(i, l2)), u = this.getSpecs().entries.filter(({ obj: p2 }) => f(p2) ? m$1(p2) : false);
+        if (u.length === 0)
+          continue;
+        const f$1 = typeof l2 == "object" && "axes" in l2 && l2.axes !== void 0 && l2.partialAxesMatch === void 0 ? l2.axes.map((p2, d) => "split" in p2 && p2.split === true ? d : -1).filter((p2) => p2 !== -1) : [];
+        if (f$1.sort((p2, d) => p2 - d), f$1.length > 0) {
+          const p2 = f$1[f$1.length - 1];
+          for (const { ref: d, obj: y } of u) {
+            if (!f(y)) throw new Error(`Assertion failed: expected PColumnSpec, got ${y.kind}`);
+            const g2 = this.getDataByRef(d);
+            if (!g2) {
+              if (r != null && r.dontWaitAllData) continue;
+              return;
+            }
+            if (!q$1(g2)) throw new Error(`Assertion failed: expected PColumn, got ${g2.spec.kind}`);
+            const v = Ye(g2.data);
+            if (!v) {
+              if (r != null && r.dontWaitAllData) continue;
+              return;
+            }
+            if (p2 >= v.length)
+              throw new Error(`Not enough partition keys for the requested split axes in column ${y.name}`);
+            const w2 = f$1.map((P2) => this.findLabels(m(y.axesSpec[P2]))), x2 = [], C = (P2, F) => {
+              if (F >= f$1.length) {
+                x2.push([...P2]);
+                return;
+              }
+              const R = f$1[F], k2 = v[R];
+              for (const A of k2)
+                P2.push(A), C(P2, F + 1), P2.pop();
+            };
+            C([], 0);
+            for (const P2 of x2) {
+              const F = P2.map((R, k2) => {
+                const A = f$1[k2], j = m(y.axesSpec[A]), V = w2[k2], K = (V == null ? void 0 : V[R]) ?? String(R);
+                return { axisIdx: A, axisId: j, value: R, label: K };
+              });
+              a.push({
+                obj: y,
+                ref: d,
+                axisFilters: F
+              });
+            }
+          }
+        } else
+          for (const { ref: p2, obj: d } of u)
+            f(d) && a.push({
+              obj: d,
+              ref: p2
+              // No splitFilters needed here
+            });
+      }
+      return a.length === 0 ? [] : de(
+        a,
+        (l2) => ({
+          spec: l2.obj,
+          suffixTrace: Qe(l2.axisFilters)
+          // Use helper function
+        }),
+        (r == null ? void 0 : r.labelOps) ?? {}
+      ).map((l2) => ({
+        id: o.deriveS(
+          l2.value.obj,
+          Ze(l2.value.axisFilters)
+          // Use helper function
+        ),
+        obj: l2.value.obj,
+        ref: l2.value.ref,
+        axisFilters: l2.value.axisFilters,
+        label: l2.label
       }));
     }
+    /**
+     * Returns columns that match the provided anchors and selectors. It applies axis filters and label derivation.
+     *
+     * @param anchorsOrCtx - Anchor context for column selection (same as in getCanonicalOptions)
+     * @param predicateOrSelectors - Predicate or selectors for filtering columns (same as in getCanonicalOptions)
+     * @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, n, r) {
+      const i = {
+        ...r,
+        labelOps: {
+          includeNativeLabel: true,
+          ...(r == null ? void 0 : r.labelOps) || {}
+        }
+      }, s = this.getUniversalPColumnEntries(
+        e,
+        n,
+        i
+      );
+      if (!s || s.length === 0) return;
+      const o = [];
+      for (const a of s) {
+        const c = this.getPColumnByRef(a.ref);
+        if (!c) return;
+        const l2 = le(c.data);
+        if (!l2) return;
+        let m2 = l2, u = { ...c.spec };
+        if (a.axisFilters && a.axisFilters.length > 0) {
+          const p2 = a.axisFilters.map((g2) => [
+            g2.axisIdx,
+            g2.value
+          ]);
+          m2 = Xe(l2, p2);
+          const d = [...a.axisFilters].map((g2) => g2.axisIdx).sort((g2, v) => v - g2), y = [...u.axesSpec];
+          for (const g2 of d)
+            y.splice(g2, 1);
+          u = { ...u, axesSpec: y };
+        }
+        const f2 = bn(m2);
+        u.annotations ? u = {
+          ...u,
+          annotations: {
+            ...u.annotations,
+            "pl7.app/label": a.label
+          }
+        } : u = {
+          ...u,
+          annotations: {
+            "pl7.app/label": a.label
+          }
+        }, o.push({
+          id: a.id,
+          spec: u,
+          data: f2
+        });
+      }
+      return o;
+    }
+    /**
+     * Calculates anchored identifier options for columns matching a given predicate and returns their
+     * canonicalized representations.
+     *
+     * This function filters column specifications from the result pool that match the provided predicate,
+     * creates a standardized AnchorCtx from the provided anchors, and generates a list of label-value
+     * pairs for UI components (like dropdowns).
+     *
+     * @param anchorsOrCtx - Either:
+     *                     - An existing AnchorCtx instance
+     *                     - A record mapping anchor IDs to PColumnSpec objects
+     *                     - A record mapping anchor IDs to PlRef objects (which will be resolved to PColumnSpec)
+     * @param predicateOrSelectors - Either:
+     *                            - A predicate function that takes a PColumnSpec and returns a boolean.
+     *                              Only specs that return true will be included.
+     *                            - An APColumnSelector object for declarative filtering, which will be
+     *                              resolved against the provided anchors and matched using matchPColumn.
+     *                            - An array of APColumnSelector objects - columns matching ANY selector
+     *                              in the array will be included (OR operation).
+     * @param opts - Optional configuration for label generation:
+     *                 - labelOps: Optional configuration for label generation:
+     *                   - includeNativeLabel: Whether to include native column labels
+     *                   - separator: String to use between label parts (defaults to " / ")
+     *                   - addLabelAsSuffix: Whether to add labels as suffix instead of prefix
+     *                 - dontWaitAllData: Whether to skip columns that don't have all data (if not set, will return undefined,
+     *                                    if at least one column that requires splitting is missing data)
+     * @returns An array of objects with `label` (display text) and `value` (anchored ID string) properties,
+     *          or undefined if any PlRef resolution fails.
+     */
+    getCanonicalOptions(e, n, r) {
+      const i = this.getUniversalPColumnEntries(e, n, r);
+      if (i)
+        return i.map((s) => ({
+          value: s.id,
+          label: s.label
+        }));
+    }
     /**
      * @deprecated use getData()
      */
@@ -4650,7 +5167,7 @@
           ref: n.ref,
           obj: {
             ...n.obj,
-            data: new S(n.obj.data, [n.ref.blockId, n.ref.name])
+            data: new I(n.obj.data, [n.ref.blockId, n.ref.name])
           }
         }))
       };
@@ -4669,9 +5186,9 @@
           ref: n.ref,
           obj: {
             ...n.obj,
-            data: Fn(
+            data: Mn(
               n.obj.data,
-              (s) => new S(s, [n.ref.blockId, n.ref.name])
+              (r) => new I(r, [n.ref.blockId, n.ref.name])
             )
           }
         }))
@@ -4691,13 +5208,17 @@
      * @returns data associated with the ref
      */
     getDataByRef(e) {
-      var n;
-      return typeof this.ctx.getDataFromResultPoolByRef > "u" ? (n = this.getData().entries.find(
-        (s) => s.ref.blockId === e.blockId && s.ref.name === e.name
-      )) == null ? void 0 : n.obj : kn(
-        this.ctx.getDataFromResultPoolByRef(e.blockId, e.name),
-        (s) => new S(s, [e.blockId, e.name])
-      );
+      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 n = this.ctx.getDataFromResultPoolByRef(e.blockId, e.name);
+      if (n)
+        return jn(
+          n,
+          (i) => new I(i, [e.blockId, e.name])
+        );
     }
     /**
      * Returns data associated with the ref ensuring that it is a p-column.
@@ -4707,7 +5228,7 @@
     getPColumnByRef(e) {
       const n = this.getDataByRef(e);
       if (n)
-        return En(n);
+        return Dn(n);
     }
     /**
      * Returns spec associated with the ref ensuring that it is a p-column spec.
@@ -4717,7 +5238,7 @@
     getPColumnSpecByRef(e) {
       const n = this.getSpecByRef(e);
       if (n) {
-        if (!f$1(n)) throw new Error(`not a PColumn spec (kind = ${n.kind})`);
+        if (!f(n)) throw new Error(`not a PColumn spec (kind = ${n.kind})`);
         return n;
       }
     }
@@ -4735,37 +5256,50 @@
      */
     findDataWithCompatibleSpec(e) {
       const n = [];
-      e: for (const s of this.getData().entries) {
-        if (!f$1(s.obj.spec))
+      e: for (const r of this.getData().entries) {
+        if (!f(r.obj.spec))
           continue;
-        const r = s.obj.spec;
-        if (e.name === r.name && e.valueType === r.valueType && e.axesSpec.length === r.axesSpec.length && X(e.domain, r.domain)) {
-          for (let i = 0; i < e.axesSpec.length; ++i) {
-            const o = e.axesSpec[i], l2 = r.axesSpec[i];
-            if (o.name !== l2.name || o.type !== l2.type || !X(o.domain, l2.domain))
+        const i = r.obj.spec;
+        if (e.name === i.name && e.valueType === i.valueType && e.axesSpec.length === i.axesSpec.length && re(e.domain, i.domain)) {
+          for (let s = 0; s < e.axesSpec.length; ++s) {
+            const o = e.axesSpec[s], a = i.axesSpec[s];
+            if (o.name !== a.name || o.type !== a.type || !re(o.domain, a.domain))
               continue e;
           }
-          n.push(s.obj);
+          n.push(r.obj);
         }
       }
       return n;
     }
+    /**
+     * 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 n = this.getData();
+      for (const r of n.entries) {
+        if (!q$1(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 && re(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]])
+          );
+        }
+      }
+    }
   }
-  function X(t, e) {
-    if (t === void 0) return e === void 0;
-    if (e === void 0) return true;
-    for (const n in e)
-      if (t[n] !== e[n]) return false;
-    return true;
-  }
-  class V {
+  class z {
     constructor() {
-      P(this, "ctx");
-      P(this, "args");
-      P(this, "uiState");
-      P(this, "_activeArgsCache");
-      P(this, "resultPool", new Ue());
-      this.ctx = f(), this.args = JSON.parse(this.ctx.args), this.uiState = this.ctx.uiState !== void 0 ? JSON.parse(this.ctx.uiState) : {};
+      T(this, "ctx");
+      T(this, "args");
+      T(this, "uiState");
+      T(this, "_activeArgsCache");
+      T(this, "resultPool", new et());
+      this.ctx = h(), this.args = JSON.parse(this.ctx.args), this.uiState = this.ctx.uiState !== void 0 ? JSON.parse(this.ctx.uiState) : {};
     }
     /**
      * Returns args snapshot the block was executed for (i.e. when "Run" button was pressed).
@@ -4781,45 +5315,33 @@
     //   return this.ctx.featureFlags;
     // }
     getNamedAccessor(e) {
-      return z(
+      return ie(
         this.ctx.getAccessorHandleByName(e),
-        (n) => new S(n, [e])
+        (n) => new I(n, [e])
       );
     }
     get prerun() {
-      return this.getNamedAccessor(pe);
+      return this.getNamedAccessor(ve);
     }
     get outputs() {
-      return this.getNamedAccessor(fe);
+      return this.getNamedAccessor(we);
     }
     /**
      * 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) {
-      const n = this.resultPool.getData();
-      for (const s of n.entries) {
-        if (!q$1(s.obj)) continue;
-        const r = s.obj.spec;
-        if (r.name === "pl7.app/label" && r.axesSpec.length === 1 && r.axesSpec[0].name === e.name && r.axesSpec[0].type === e.type && X(e.domain, r.axesSpec[0].domain)) {
-          if (s.obj.data.resourceType.name !== "PColumnData/Json")
-            throw Error(`Expected JSON column for labels, got: ${s.obj.data.resourceType.name}`);
-          return Object.fromEntries(
-            Object.entries(
-              s.obj.data.getDataAsJson().data
-            ).map((o) => [JSON.parse(o[0])[0], o[1]])
-          );
-        }
-      }
+      return this.resultPool.findLabels(e);
     }
-    verifyInlineColumnsSupport(e) {
-      var r;
-      const n = e.some((i) => !(i.data instanceof S)), s = ((r = this.ctx.featureFlags) == null ? void 0 : r.inlineColumnsSupport) === true;
-      if (n && !s) throw Error("inline columns not supported");
+    verifyInlineAndExplicitColumnsSupport(e) {
+      var i;
+      const n = e.some((s) => !(s.data instanceof I) || yn(s.data)), r = ((i = this.ctx.featureFlags) == null ? void 0 : i.inlineColumnsSupport) === true;
+      if (n && !r) throw Error("Inline or explicit columns not supported");
     }
     createPFrame(e) {
-      return this.verifyInlineColumnsSupport(e), this.ctx.createPFrame(
-        e.map((n) => kn(n, (s) => s instanceof S ? s.handle : s))
+      return this.verifyInlineAndExplicitColumnsSupport(e), this.ctx.createPFrame(
+        e.map((n) => fe(n))
       );
     }
     createPTable(e) {
@@ -4827,15 +5349,12 @@
       return "columns" in e ? n = {
         src: {
           type: "full",
-          entries: e.columns.map((s) => ({ type: "column", column: s }))
+          entries: e.columns.map((r) => ({ type: "column", column: r }))
         },
         filters: e.filters ?? [],
         sorting: e.sorting ?? []
-      } : n = e, this.verifyInlineColumnsSupport(In(n.src)), this.ctx.createPTable(
-        gn(
-          n,
-          (s) => kn(s, (r) => r instanceof S ? r.handle : r)
-        )
+      } : n = e, this.verifyInlineAndExplicitColumnsSupport(Bn(n.src)), this.ctx.createPTable(
+        En(n, (r) => fe(r))
       );
     }
     /** @deprecated scheduled for removal from SDK */
@@ -4847,33 +5366,33 @@
         return this.ctx.getCurrentUnstableMarker();
     }
   }
-  const L = "1.24.11";
-  function Je(t) {
+  const U = "1.26.0";
+  function tt(t) {
     return t.__renderLambda === true;
   }
-  function q(t) {
+  function se(t) {
     if (t !== void 0)
-      return Je(t) ? t.handle : t;
+      return tt(t) ? t.handle : t;
   }
-  class w {
-    constructor(e, n, s, r, i, o, l2) {
-      this._renderingMode = e, this._initialArgs = n, this._initialUiState = s, this._outputs = r, this._inputsValid = i, this._sections = o, this._title = l2;
+  class _ {
+    constructor(e, n, r, i, s, o, a) {
+      this._renderingMode = e, this._initialArgs = n, this._initialUiState = r, this._outputs = i, this._inputsValid = s, this._sections = o, this._title = a;
     }
     static create(e = "Heavy") {
-      return new w(
+      return new _(
         e,
         void 0,
         {},
         {},
-        j(true),
-        j([]),
+        Y(true),
+        Y([]),
         void 0
       );
     }
-    output(e, n, s = {}) {
+    output(e, n, r = {}) {
       if (typeof n == "function") {
-        const r = `output#${e}`;
-        return E(r, () => n(new V())), new w(
+        const i = `output#${e}`;
+        return q(i, () => n(new z())), new _(
           this._renderingMode,
           this._initialArgs,
           this._initialUiState,
@@ -4881,8 +5400,8 @@
             ...this._outputs,
             [e]: {
               __renderLambda: true,
-              handle: r,
-              ...s
+              handle: i,
+              ...r
             }
           },
           this._inputsValid,
@@ -4890,7 +5409,7 @@
           this._title
         );
       } else
-        return new w(
+        return new _(
           this._renderingMode,
           this._initialArgs,
           this._initialUiState,
@@ -4908,7 +5427,7 @@
       return this.output(e, n, { retentive: true });
     }
     argsValid(e) {
-      return typeof e == "function" ? (E("inputsValid", () => e(new V())), new w(
+      return typeof e == "function" ? (q("inputsValid", () => e(new z())), new _(
         this._renderingMode,
         this._initialArgs,
         this._initialUiState,
@@ -4919,7 +5438,7 @@
         },
         this._sections,
         this._title
-      )) : new w(
+      )) : new _(
         this._renderingMode,
         this._initialArgs,
         this._initialUiState,
@@ -4930,7 +5449,7 @@
       );
     }
     sections(e) {
-      return Array.isArray(e) ? this.sections(j(e)) : typeof e == "function" ? (E("sections", () => e(new V())), new w(
+      return Array.isArray(e) ? this.sections(Y(e)) : typeof e == "function" ? (q("sections", () => e(new z())), new _(
         this._renderingMode,
         this._initialArgs,
         this._initialUiState,
@@ -4938,7 +5457,7 @@
         this._inputsValid,
         { __renderLambda: true, handle: "sections" },
         this._title
-      )) : new w(
+      )) : new _(
         this._renderingMode,
         this._initialArgs,
         this._initialUiState,
@@ -4950,7 +5469,7 @@
     }
     /** Sets a rendering function to derive block title, shown for the block in the left blocks-overview panel. */
     title(e) {
-      return E("title", () => e(new V())), new w(
+      return q("title", () => e(new z())), new _(
         this._renderingMode,
         this._initialArgs,
         this._initialUiState,
@@ -4965,7 +5484,7 @@
      * @deprecated use {@link withArgs}
      * */
     initialArgs(e) {
-      return new w(
+      return new _(
         this._renderingMode,
         e,
         this._initialUiState,
@@ -4977,7 +5496,7 @@
     }
     /** Sets initial args for the block, this value must be specified. */
     withArgs(e) {
-      return new w(
+      return new _(
         this._renderingMode,
         e,
         this._initialUiState,
@@ -4989,7 +5508,7 @@
     }
     /** Defines type and sets initial value for block UiState. */
     withUiState(e) {
-      return new w(
+      return new _(
         this._renderingMode,
         this._initialArgs,
         e,
@@ -5006,7 +5525,7 @@
       if (this._initialArgs === void 0) throw new Error("Initial arguments not set.");
       const e = {
         v3: {
-          sdkVersion: L,
+          sdkVersion: U,
           renderingMode: this._renderingMode,
           initialArgs: this._initialArgs,
           initialUiState: this._initialUiState,
@@ -5016,72 +5535,72 @@
           outputs: this._outputs
         },
         // fields below are added to allow previous desktop versions read generated configs
-        sdkVersion: L,
+        sdkVersion: U,
         renderingMode: this._renderingMode,
         initialArgs: this._initialArgs,
-        inputsValid: q(this._inputsValid),
-        sections: q(this._sections),
+        inputsValid: se(this._inputsValid),
+        sections: se(this._sections),
         outputs: Object.fromEntries(
-          Object.entries(this._outputs).map(([n, s]) => [n, q(s)])
+          Object.entries(this._outputs).map(([n, r]) => [n, se(r)])
         )
       };
-      return Fe() ? de({ sdkVersion: L }) : { config: e };
+      return Ke() ? be({ sdkVersion: U }) : { config: e };
     }
   }
-  function Dt(t, e, n, s) {
-    var u, g2;
-    Array.isArray(s) && (s = { filters: s });
-    const r = t.resultPool.getData().entries.map((c) => c.obj).filter(q$1).filter((c) => c.spec.name === "pl7.app/label" && c.spec.axesSpec.length === 1), i = (c, d2) => {
-      let h2 = c.toString();
-      if (d2)
-        for (const p in d2)
-          h2 += p, h2 += d2[p];
-      return h2;
+  function Gt(t, e, n, r) {
+    var l2, m$1;
+    Array.isArray(r) && (r = { filters: r });
+    const i = t.resultPool.getData().entries.map((u) => u.obj).filter(q$1).filter((u) => u.spec.name === "pl7.app/label" && u.spec.axesSpec.length === 1), s = (u, f2) => {
+      let p2 = u.toString();
+      if (f2)
+        for (const d in f2)
+          p2 += d, p2 += f2[d];
+      return p2;
     }, o = /* @__PURE__ */ new Map();
-    for (const c of e)
-      for (const d2 of c.spec.axesSpec) {
-        const h$1 = h(d2);
-        for (const p of r) {
-          const b = p.spec.axesSpec[0], m = h(p.spec.axesSpec[0]);
-          if (z$1(h$1, m)) {
-            const I = Object.keys(h$1.domain ?? {}).length, v = Object.keys(m.domain ?? {}).length;
-            if (I > v) {
-              const A2 = i(p.id, h$1.domain);
-              o.set(A2, {
-                id: A2,
+    for (const u of e)
+      for (const f2 of u.spec.axesSpec) {
+        const p2 = m(f2);
+        for (const d of i) {
+          const y = d.spec.axesSpec[0], g2 = m(d.spec.axesSpec[0]);
+          if (G(p2, g2)) {
+            const v = Object.keys(p2.domain ?? {}).length, w2 = Object.keys(g2.domain ?? {}).length;
+            if (v > w2) {
+              const x2 = s(d.id, p2.domain);
+              o.set(x2, {
+                id: x2,
                 spec: {
-                  ...p.spec,
-                  axesSpec: [{ ...h$1, annotations: b.annotations }]
+                  ...d.spec,
+                  axesSpec: [{ ...p2, annotations: y.annotations }]
                 },
-                data: p.data
+                data: d.data
               });
             } else
-              o.set(i(p.id), p);
+              o.set(s(d.id), d);
           }
         }
       }
     if ([...e, ...o.values()].some(
-      (c) => c.data instanceof S && !c.data.getIsReadyOrError()
+      (u) => u.data instanceof I && !u.data.getIsReadyOrError()
     ))
       return;
-    let l2 = e;
-    const a = [];
-    if (s != null && s.coreColumnPredicate) {
-      l2 = [];
-      for (const c of e)
-        s.coreColumnPredicate(c.spec) ? l2.push(c) : a.push(c);
-    }
-    return a.push(...o.values()), t.createPTable({
+    let a = e;
+    const c = [];
+    if (r != null && r.coreColumnPredicate) {
+      a = [];
+      for (const u of e)
+        r.coreColumnPredicate(u.spec) ? a.push(u) : c.push(u);
+    }
+    return c.push(...o.values()), t.createPTable({
       src: {
         type: "outer",
         primary: {
-          type: (s == null ? void 0 : s.coreJoinType) ?? "full",
-          entries: l2.map((c) => ({ type: "column", column: c }))
+          type: (r == null ? void 0 : r.coreJoinType) ?? "full",
+          entries: a.map((u) => ({ type: "column", column: u }))
         },
-        secondary: a.map((c) => ({ type: "column", column: c }))
+        secondary: c.map((u) => ({ type: "column", column: u }))
       },
-      filters: [...(s == null ? void 0 : s.filters) ?? [], ...((u = n == null ? void 0 : n.pTableParams) == null ? void 0 : u.filters) ?? []],
-      sorting: ((g2 = n == null ? void 0 : n.pTableParams) == null ? void 0 : g2.sorting) ?? []
+      filters: [...(r == null ? void 0 : r.filters) ?? [], ...((l2 = n == null ? void 0 : n.pTableParams) == null ? void 0 : l2.filters) ?? []],
+      sorting: ((m$1 = n == null ? void 0 : n.pTableParams) == null ? void 0 : m$1.sorting) ?? []
     });
   }
   function* range(from, to, step = 1) {
@@ -5103,7 +5622,7 @@
     tableNumRows: z$2.number().default(100),
     numbers: z$2.array(z$2.coerce.number())
   });
-  const platforma = w.create("Heavy").withArgs({ numbers: [1, 2, 3, 4], tableNumRows: 100 }).withUiState({ dataTableState: void 0, dynamicSections: [] }).argsValid((ctx) => {
+  const platforma = _.create("Heavy").withArgs({ numbers: [1, 2, 3, 4], tableNumRows: 100 }).withUiState({ dataTableState: void 0, dynamicSections: [] }).argsValid((ctx) => {
     if (ctx.args.numbers.length === 5) {
       throw new Error("argsValid: test error");
     }
@@ -5121,7 +5640,7 @@
         val: v.toString()
       };
     });
-    return Dt(
+    return Gt(
       ctx,
       [
         {