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

package/dist/bundle.js

@@ -35,7 +35,7 @@
     }, "");
     return `{${values}}`;
   };
-  const g$1 = /* @__PURE__ */ getDefaultExportFromCjs(canonicalize);
+  const g = /* @__PURE__ */ getDefaultExportFromCjs(canonicalize);
   var util;
   (function(util2) {
     util2.assertEqual = (val) => val;
@@ -54,10 +54,10 @@
       return obj;
     };
     util2.getValidEnumValues = (obj) => {
-      const validKeys = util2.objectKeys(obj).filter((k) => typeof obj[obj[k]] !== "number");
+      const validKeys = util2.objectKeys(obj).filter((k2) => typeof obj[obj[k2]] !== "number");
       const filtered = {};
-      for (const k of validKeys) {
-        filtered[k] = obj[k];
+      for (const k2 of validKeys) {
+        filtered[k2] = obj[k2];
       }
       return util2.objectValues(filtered);
     };
@@ -87,7 +87,7 @@
       return array.map((val) => typeof val === "string" ? `'${val}'` : val).join(separator);
     }
     util2.joinValues = joinValues;
-    util2.jsonStringifyReplacer = (_, value) => {
+    util2.jsonStringifyReplacer = (_2, value) => {
       if (typeof value === "bigint") {
         return value.toString();
       }
@@ -492,12 +492,12 @@
   const isDirty = (x2) => x2.status === "dirty";
   const isValid = (x2) => x2.status === "valid";
   const isAsync = (x2) => typeof Promise !== "undefined" && x2 instanceof Promise;
-  function __classPrivateFieldGet(receiver, state, kind, f) {
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+  function __classPrivateFieldGet(receiver, state, kind, f2) {
+    if (typeof state === "function" ? receiver !== state || !f2 : !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, f) {
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+  function __classPrivateFieldSet(receiver, state, value, kind, f2) {
+    if (typeof state === "function" ? receiver !== state || !f2 : !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;
   }
   typeof SuppressedError === "function" ? SuppressedError : function(error, suppressed, message) {
@@ -3105,29 +3105,29 @@
       const params = { errorMap: ctx.common.contextualErrorMap };
       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(fn, this, parsedArgs);
-          const parsedReturns = await me2._def.returns._def.type.parseAsync(result, params).catch((e) => {
+          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(fn, this, parsedArgs.data);
-          const parsedReturns = me2._def.returns.safeParse(result, params);
+          const parsedReturns = me._def.returns.safeParse(result, params);
           if (!parsedReturns.success) {
             throw new ZodError([makeReturnsIssue(result, parsedReturns.error)]);
           }
@@ -3832,7 +3832,7 @@
     date: (arg) => ZodDate.create({ ...arg, coerce: true })
   };
   const NEVER = INVALID;
-  var z = /* @__PURE__ */ Object.freeze({
+  var z$2 = /* @__PURE__ */ Object.freeze({
     __proto__: null,
     defaultErrorMap: errorMap,
     setErrorMap,
@@ -3948,33 +3948,112 @@
     quotelessJson,
     ZodError
   });
-  var V = Object.defineProperty;
-  var F = (n, t, e) => t in n ? V(n, t, { enumerable: true, configurable: true, writable: true, value: e }) : n[t] = e;
-  var m = (n, t, e) => F(n, typeof t != "symbol" ? t + "" : t, e);
+  var $ = Object.defineProperty;
+  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 p(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 wn(n) {
-    return g$1(p(n));
+  function Sn(n) {
+    return g(m(n));
   }
-  function G$1(n, t) {
+  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 Q$1(n, t) {
-    return n.name === t.name && G$1(n.domain, t.domain);
+  function G(n, t) {
+    return n.name === t.name && z$1(n.domain, t.domain);
   }
-  function An(n, t) {
-    return { ...n, src: h(n.src, t) };
+  function En(n, t) {
+    return { ...n, src: l(n.src, t) };
   }
-  function h(n, t) {
+  function l(n, t) {
     switch (n.type) {
       case "column":
         return {
@@ -3985,51 +4064,51 @@
       case "full":
         return {
           type: n.type,
-          entries: n.entries.map((e) => h(e, t))
+          entries: n.entries.map((e) => l(e, t))
         };
       case "outer":
         return {
           type: "outer",
-          primary: h(n.primary, t),
-          secondary: n.secondary.map((e) => h(e, t))
+          primary: l(n.primary, t),
+          secondary: n.secondary.map((e) => l(e, t))
         };
       default:
         w(n);
     }
   }
-  function Y(n) {
-    return g$1(n);
+  function Q$1(n) {
+    return g(n);
   }
-  function x$1(n) {
-    return g$1(p(n));
+  function P(n) {
+    return g(m(n));
   }
-  function P$1(n, t) {
+  function x(n, t) {
     return JSON.stringify([n, t]);
   }
-  class Pn {
+  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) {
-      m(this, "domains", /* @__PURE__ */ new Map());
-      m(this, "axes", /* @__PURE__ */ new Map());
-      m(this, "domainPacks", []);
-      m(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 s = o.axesSpec[i], a = x$1(s);
+          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((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 f = P$1(s, a);
-            this.domains.set(f, r);
+            const c = x(s, a);
+            this.domains.set(c, r);
           }
         }
       }
@@ -4054,35 +4133,35 @@
               else
                 break n;
             }
-            const f = this.domainPackToAnchor.get(JSON.stringify(a));
-            if (f !== void 0) {
-              r.domainAnchor = f, o = new Set(s);
+            const c = this.domainPackToAnchor.get(JSON.stringify(a));
+            if (c !== void 0) {
+              r.domainAnchor = c, o = new Set(s);
               break;
             }
           }
       for (const [s, a] of Object.entries(t.domain ?? {})) {
         if (o !== void 0 && o.has(s))
           continue;
-        const f = P$1(s, a), u = this.domains.get(f);
+        const c = x(s, a), u = this.domains.get(c);
         r.domain ?? (r.domain = {}), r.domain[s] = u ? { anchor: u } : a;
       }
       if (r.axes = t.axesSpec.map((s) => {
-        const a = x$1(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, f] = s;
+        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, f]);
+          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, f]);
+          i.push([u, c]);
         }
       }
       return i.sort((s, a) => s[0] - a[0]), {
@@ -4097,10 +4176,10 @@
      * @returns A canonicalized string representation of the anchored column identifier
      */
     deriveS(t, e) {
-      return Y(this.derive(t, e));
+      return Q$1(this.derive(t, e));
     }
   }
-  function En(n, t) {
+  function Jn(n, t) {
     const e = { ...t };
     if (e.domainAnchor !== void 0) {
       const r = n[e.domainAnchor];
@@ -4124,10 +4203,10 @@
         }
       e.domain = r;
     }
-    return e.axes && (e.axes = e.axes.map((r) => Z$1(n, r))), e;
+    return e.axes && (e.axes = e.axes.map((r) => Y$1(n, r))), e;
   }
-  function Z$1(n, t) {
-    if (!q(t))
+  function Y$1(n, t) {
+    if (!Z$1(t))
       return t;
     const e = t.anchor, r = n[e];
     if (!r)
@@ -4144,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) => Q$1(t.id, p(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)
@@ -4153,26 +4232,26 @@
     }
     throw new Error("Unsupported axis reference type");
   }
-  function q(n) {
+  function Z$1(n) {
     return typeof n == "object" && "anchor" in n;
   }
-  function c(n) {
+  function f(n) {
     return n.kind === "PColumn";
   }
-  function v(n) {
-    return c(n.spec);
+  function q$1(n) {
+    return f(n.spec);
   }
-  function Sn(n) {
-    if (!v(n)) throw new Error(`not a PColumn (kind = ${n.spec.kind})`);
+  function Dn(n) {
+    if (!q$1(n)) throw new Error(`not a PColumn (kind = ${n.spec.kind})`);
     return n;
   }
-  function Cn(n, t) {
+  function jn(n, t) {
     return n === void 0 ? void 0 : {
       ...n,
       data: t(n.data)
     };
   }
-  function $n(n) {
+  function Bn(n) {
     const t = /* @__PURE__ */ new Map(), e = (r) => {
       switch (r.type) {
         case "column":
@@ -4192,7 +4271,7 @@
     };
     return e(n), [...t.values()];
   }
-  function E(n, t) {
+  function k(n, t) {
     if (n.name !== void 0 && n.name !== t.name)
       return false;
     if (n.type !== void 0) {
@@ -4210,7 +4289,7 @@
     }
     return true;
   }
-  function I$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) {
@@ -4227,16 +4306,16 @@
           return false;
     }
     if (t.axes !== void 0) {
-      const e = n.axesSpec.map(p);
+      const e = n.axesSpec.map(m);
       if (t.partialAxesMatch) {
         for (const r of t.axes)
-          if (!e.some((o) => E(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 (!E(t.axes[r], e[r]))
+          if (!k(t.axes[r], e[r]))
             return false;
       }
     }
@@ -4256,65 +4335,65 @@
     }
     return true;
   }
-  function Vn(n) {
-    return Array.isArray(n) ? (t) => n.some((e) => c(t) && I$1(t, e)) : (t) => c(t) && I$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.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")
+  z$2.object({
+    __isRef: z$2.literal(true).describe("Crucial marker for the block dependency tree reconstruction"),
+    blockId: z$2.string().describe("Upstream block id"),
+    name: z$2.string().describe("Name of the output provided to the upstream block's output context")
   }).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 On(n) {
+  function Kn(n) {
     return typeof n == "object" && n !== null && "__isRef" in n && n.__isRef === true && "blockId" in n && "name" in n;
   }
-  function Bn(n, t) {
+  function Mn(n, t) {
     return n.ok ? { ok: true, value: t(n.value) } : n;
   }
   const an = 24;
-  z.string().length(an).regex(/[ABCDEFGHIJKLMNOPQRSTUVWXYZ234567]/).brand("PlId");
-  var we = Object.defineProperty;
-  var Ie = (t, e, n) => e in t ? we(t, e, { enumerable: true, configurable: true, writable: true, value: n }) : t[e] = n;
-  var x = (t, e, n) => Ie(t, typeof e != "symbol" ? e + "" : e, n);
-  function W(t) {
+  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 ke() {
+  function Ke() {
     return typeof globalThis.getPlatforma < "u" || typeof globalThis.platforma < "u";
   }
-  function me(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 Ee() {
+  function $e() {
     if (typeof globalThis.cfgRenderCtx < "u") return globalThis.cfgRenderCtx;
   }
-  function g() {
+  function h() {
     if (typeof globalThis.cfgRenderCtx < "u") return globalThis.cfgRenderCtx;
     throw new Error("Not in config rendering context");
   }
-  function $(t, e) {
-    const n = Ee();
+  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 X = /* @__PURE__ */ new Map();
-  function Oe(t, e) {
-    t in g().callbackRegistry || (g().callbackRegistry[t] = (n) => {
-      for (const s of X.get(t))
-        s(n);
-    }, X.set(t, [])), X.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 S {
-    constructor(e, n = (s) => s) {
-      x(this, "isResolved", false);
-      x(this, "resolvedValue");
-      this.handle = e, this.postProcess = n, Oe(e, (s) => {
-        this.resolvedValue = n(s), this.isResolved = true;
+    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) {
@@ -4322,15 +4401,15 @@
     }
     mapDefined(e) {
       return new S(this.handle, (n) => {
-        const s = this.postProcess(n);
-        return s ? e(s) : void 0;
+        const r = this.postProcess(n);
+        return r ? e(r) : void 0;
       });
     }
     toJSON() {
       return this.isResolved ? this.resolvedValue : { __awaited_futures__: [this.handle] };
     }
   }
-  function se(t, e) {
+  function ie(t, e) {
     return t === void 0 ? void 0 : e(t);
   }
   class I {
@@ -4339,27 +4418,27 @@
     }
     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);
@@ -4368,51 +4447,51 @@
       return this.resolveWithCommon({}, ...e);
     }
     resolveWithCommon(e, ...n) {
-      const s = [
+      const r = [
         ...this.resolvePath,
         ...n.map((i) => typeof i == "string" ? i : i.field)
       ];
-      return se(
-        g().resolveWithCommon(this.handle, e, ...n),
-        (i) => new I(i, s)
+      return ie(
+        h().resolveWithCommon(this.handle, e, ...n),
+        (i) => new I(i, r)
       );
     }
     get resourceType() {
-      return g().getResourceType(this.handle);
+      return h().getResourceType(this.handle);
     }
     getInputsLocked() {
-      return g().getInputsLocked(this.handle);
+      return h().getInputsLocked(this.handle);
     }
     getOutputsLocked() {
-      return g().getOutputsLocked(this.handle);
+      return h().getOutputsLocked(this.handle);
     }
     getIsReadyOrError() {
-      return g().getIsReadyOrError(this.handle);
+      return h().getIsReadyOrError(this.handle);
     }
     getIsFinal() {
-      return g().getIsFinal(this.handle);
+      return h().getIsFinal(this.handle);
     }
     getError() {
       const e = [...this.resolvePath, "error"];
-      return se(
-        g().getError(this.handle),
+      return ie(
+        h().getError(this.handle),
         (n) => new I(n, e)
       );
     }
     listInputFields() {
-      return g().listInputFields(this.handle);
+      return h().listInputFields(this.handle);
     }
     listOutputFields() {
-      return g().listOutputFields(this.handle);
+      return h().listOutputFields(this.handle);
     }
     listDynamicFields() {
-      return g().listDynamicFields(this.handle);
+      return h().listDynamicFields(this.handle);
     }
     getKeyValueBase64(e) {
-      return g().getKeyValueBase64(this.handle, e);
+      return h().getKeyValueBase64(this.handle, e);
     }
     getKeyValueAsString(e) {
-      return g().getKeyValueAsString(this.handle, e);
+      return h().getKeyValueAsString(this.handle, e);
     }
     getKeyValueAsJson(e) {
       const n = this.getKeyValueAsString(e);
@@ -4420,10 +4499,10 @@
       return JSON.parse(n);
     }
     getDataBase64() {
-      return g().getDataBase64(this.handle);
+      return h().getDataBase64(this.handle);
     }
     getDataAsString() {
-      return g().getDataAsString(this.handle);
+      return h().getDataAsString(this.handle);
     }
     getDataAsJson() {
       const e = this.getDataAsString();
@@ -4434,39 +4513,39 @@
      *
      */
     getPColumns(e = false, n = "") {
-      const s = this.parsePObjectCollection(e, n);
-      return s === void 0 ? void 0 : Object.entries(s).map(([, r]) => {
-        if (!v(r)) throw new Error(`not a PColumn (kind = ${r.spec.kind})`);
-        return r;
+      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 = g().parsePObjectCollection(
+      const r = h().parsePObjectCollection(
         this.handle,
         e,
         n,
         ...this.resolvePath
       );
-      if (s === void 0) return;
+      if (r === void 0) return;
       const i = {};
-      for (const [r, o] of Object.entries(s)) {
-        const u = [...this.resolvePath, r];
-        i[r] = Cn(o, (c2) => new I(c2, u));
+      for (const [s, o] of Object.entries(r)) {
+        const a = [...this.resolvePath, s];
+        i[s] = jn(o, (c) => new I(c, a));
       }
       return i;
     }
     getFileContentAsBase64() {
-      return new S(g().getBlobContentAsBase64(this.handle));
+      return new S(h().getBlobContentAsBase64(this.handle));
     }
     getFileContentAsString() {
-      return new S(g().getBlobContentAsString(this.handle));
+      return new S(h().getBlobContentAsString(this.handle));
     }
     getFileContentAsJson() {
       return new S(
-        g().getBlobContentAsString(this.handle)
+        h().getBlobContentAsString(this.handle)
       ).mapDefined((e) => JSON.parse(e));
     }
     /**
@@ -4485,7 +4564,7 @@
      * @returns downloaded file handle
      */
     getFileHandle() {
-      return new S(g().getDownloadedBlobContentHandle(this.handle));
+      return new S(h().getDownloadedBlobContentHandle(this.handle));
     }
     /**
      * @deprecated use getFileHandle
@@ -4497,7 +4576,7 @@
      * @returns downloaded file handle
      */
     getRemoteFileHandle() {
-      return new S(g().getOnDemandBlobContentHandle(this.handle));
+      return new S(h().getOnDemandBlobContentHandle(this.handle));
     }
     /**
      * @deprecated use getRemoteFileHandle
@@ -4509,22 +4588,22 @@
      * @returns the url to the extracted folder
      */
     extractArchiveAndGetURL(e) {
-      return new S(g().extractArchiveAndGetURL(this.handle, e));
+      return new S(h().extractArchiveAndGetURL(this.handle, e));
     }
     getImportProgress() {
-      return new S(g().getImportProgress(this.handle));
+      return new S(h().getImportProgress(this.handle));
     }
     getLastLogs(e) {
-      return new S(g().getLastLogs(this.handle, e));
+      return new S(h().getLastLogs(this.handle, e));
     }
     getProgressLog(e) {
-      return new S(g().getProgressLog(this.handle, e));
+      return new S(h().getProgressLog(this.handle, e));
     }
     getProgressLogWithInfo(e) {
-      return new S(g().getProgressLogWithInfo(this.handle, e));
+      return new S(h().getProgressLogWithInfo(this.handle, e));
     }
     getLogHandle() {
-      return new S(g().getLogHandle(this.handle));
+      return new S(h().getLogHandle(this.handle));
     }
     allFieldsResolved(e = "Input") {
       switch (e) {
@@ -4539,178 +4618,340 @@
       }
     }
     mapFields(e, n) {
-      const { fieldType: s, requireLocked: i, skipUnresolved: r } = {
+      const { fieldType: r, requireLocked: i, skipUnresolved: s } = {
         fieldType: "Input",
         requireLocked: true,
         skipUnresolved: false,
         ...n
       }, o = e;
-      if (i && (s === "Input" && !this.getInputsLocked() || s === "Output" && !this.getOutputsLocked()))
+      if (i && (r === "Input" && !this.getInputsLocked() || r === "Output" && !this.getOutputsLocked()))
         return;
-      let c2 = (s === "Input" ? this.listInputFields() : s === "Output" ? this.listOutputFields() : this.listDynamicFields()).map(
-        (a) => [a, this.resolve({ field: a, assertFieldType: s })]
+      let c = (r === "Input" ? this.listInputFields() : r === "Output" ? this.listOutputFields() : this.listDynamicFields()).map(
+        (l2) => [l2, this.resolve({ field: l2, assertFieldType: r })]
       );
-      return r && (c2 = c2.filter((a) => a[1] !== void 0)), c2.map(([a, h2]) => o(a, h2));
+      return s && (c = c.filter((l2) => l2[1] !== void 0)), c.map(([l2, m2]) => o(l2, m2));
     }
   }
-  const ye = "staging", be = "main";
-  const Ne = "pl7.app/label", Ue = "pl7.app/trace", Be = z.object({
-    type: z.string(),
-    importance: z.number().optional(),
-    id: z.string().optional(),
-    label: z.string()
-  }), Me = z.array(Be), Je = 1e-3, $e = "__LABEL__", ue = "__LABEL__@1";
-  function Q(t, e, n = {}) {
-    const s = /* @__PURE__ */ new Map(), i = /* @__PURE__ */ new Map(), r = t.map((l) => {
-      var F2, M;
-      const f = e(l);
-      let d, y, _;
-      "spec" in f && typeof f.spec == "object" ? (d = f.spec, y = f.prefixTrace, _ = f.suffixTrace) : d = f;
-      const A = (F2 = d.annotations) == null ? void 0 : F2[Ne], v2 = (M = d.annotations) == null ? void 0 : M[Ue], m2 = (v2 ? Me.safeParse(JSON.parse(v2)).data : void 0) ?? [], w2 = [
+  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()
+  }), 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 ?? [],
-        ...m2,
-        ..._ ?? []
+        ...x2,
+        ...g2 ?? []
       ];
-      if (A) {
-        const C = { label: A, type: $e, importance: -2 };
-        n.addLabelAsSuffix ? w2.push(C) : w2.splice(0, 0, C);
-      }
-      const L = [], R = /* @__PURE__ */ new Map();
-      for (let C = w2.length - 1; C >= 0; --C) {
-        const { type: D } = w2[C], q2 = w2[C].importance ?? 0, z2 = (R.get(D) ?? 0) + 1;
-        R.set(D, z2);
-        const O = `${D}@${z2}`;
-        i.set(O, (i.get(O) ?? 0) + 1), s.set(
-          O,
+      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(O) ?? Number.NEGATIVE_INFINITY,
-            q2 - (w2.length - C) * Je
+            r.get($2) ?? Number.NEGATIVE_INFINITY,
+            V - (C.length - A) * He
           )
-        ), L.push({ ...w2[C], fullType: O, occurenceIndex: z2 });
+        ), P2.push({ ...C[A], fullType: $2, occurenceIndex: K });
       }
-      return L.reverse(), {
-        value: l,
+      return P2.reverse(), {
+        value: f2,
         spec: d,
-        label: A,
-        fullTrace: L
+        label: v,
+        fullTrace: P2
       };
-    }), o = [], u = [], c2 = [...s];
-    c2.sort(([, l], [, f]) => f - l);
-    for (const [l] of c2)
-      l.endsWith("@1") || i.get(l) === t.length ? o.push(l) : u.push(l);
-    const a = (l) => r.map((f) => {
-      const d = f.fullTrace.filter((_) => l.has(_.fullType)).map((_) => _.label), y = 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: d.join(y),
-        value: f.value
+        value: p2.value
       };
     });
     if (o.length === 0) {
-      if (u.length !== 0) throw new Error("Assertion error.");
-      return a(new Set(ue));
-    }
-    let h2 = 0, p2 = 0;
-    for (; h2 < o.length; ) {
-      const l = /* @__PURE__ */ new Set();
-      n.includeNativeLabel && l.add(ue);
-      for (let d = 0; d < h2; ++d) l.add(o[d]);
-      l.add(o[p2]);
-      const f = a(l);
-      if (new Set(f.map((d) => d.label)).size === t.length) return f;
-      p2++, p2 == o.length && (h2++, p2 = h2);
-    }
-    return a(/* @__PURE__ */ new Set([...o, ...u]));
+      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]));
   }
-  const B = "PColumnData/", re = B + "ResourceMap", oe = B + "Partitioned/ResourceMap", ce = B + "JsonPartitioned", Z = B + "BinaryPartitioned", _e = B + "Partitioned/", pe = _e + "JsonPartitioned", ee = _e + "BinaryPartitioned";
-  const de = (t) => {
-    if (!t.endsWith(".index")) {
-      if (t.endsWith(".values"))
-        return t.substring(0, t.length - 7);
-      throw Error(`key must ends on .index/.values for binary p-column, got: ${t}`);
-    }
+  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 Ge(t) {
+  function ze(t) {
     if (!t) return;
-    const e = t.resourceType.name, n = t.getDataAsJson(), s = [];
+    const e = t.resourceType.name, n = t.getDataAsJson(), r = [];
     let i = 0;
     switch (e) {
-      case re:
+      case Q:
         i = n.keyLength;
         break;
-      case oe:
+      case Z:
         i = n.partitionKeyLength + n.keyLength;
         break;
-      case ce:
-      case Z:
+      case N:
+      case O:
         i = n.partitionKeyLength;
         break;
+      case B:
       case ee:
-      case pe:
         i = n.superPartitionKeyLength + n.partitionKeyLength;
         break;
     }
     switch (e) {
-      case re:
-      case ce:
-      case Z:
-        for (let r of t.listInputFields()) {
-          if (e === Z) {
-            const u = de(r);
-            if (u) r = u;
-            else continue;
-          }
-          const o = [...JSON.parse(r)];
-          s.push(o);
+      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 oe:
+      case Z:
+      case B:
       case ee:
-      case pe:
-        for (const r of t.listInputFields()) {
-          const o = [...JSON.parse(r)], u = t.resolve({ field: r, assertFieldType: "Input" });
-          if (u !== void 0)
-            for (let c2 of u.listInputFields()) {
-              if (e === ee) {
-                const h2 = de(c2);
-                if (h2) c2 = h2;
-                else continue;
-              }
-              const a = [...o, ...JSON.parse(c2)];
-              s.push(a);
+        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: s, keyLength: i };
+    return { data: r, keyLength: i };
   }
-  function We(t) {
-    const e = Ge(t);
+  function Ye(t) {
+    const e = ze(t);
     if (!e) return;
-    const { data: n, keyLength: s } = e, i = [];
-    for (let r = 0; r < s; ++r)
+    const { data: n, keyLength: r } = e, i = [];
+    for (let s = 0; s < r; ++s)
       i.push(/* @__PURE__ */ new Set());
-    for (const r of n) {
-      if (r.length !== s)
+    for (const s of n) {
+      if (s.length !== r)
         throw new Error("key length does not match partition length");
-      for (let o = 0; o < s; ++o)
-        i[o].add(r[o]);
+      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
+        };
+      }
     }
-    return i.map((r) => Array.from(r.values()));
   }
-  function te(t, e) {
+  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;
   }
-  class Ke {
+  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() {
-      x(this, "ctx", g());
-      x(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()
@@ -4719,87 +4960,199 @@
       return this.ctx.calculateOptions(e);
     }
     getOptions(e, n) {
-      const s = typeof e == "function" ? e : Vn(e), i = this.getSpecs().entries.filter((r) => s(r.obj));
-      return typeof n == "object" || typeof n > "u" ? Q(i, (r) => r.obj, n ?? {}).map(({ value: { ref: r }, label: o }) => ({
-        ref: r,
+      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
-      })) : i.map((r) => ({
-        ref: r.ref,
-        label: n(r.obj, r.ref)
+      })) : i.map((s) => ({
+        ref: s.ref,
+        label: n(s.obj, s.ref)
       }));
     }
-    // Implementation
-    getCanonicalOptions(e, n, s) {
+    /**
+     * Internal implementation that generates UniversalPColumnEntry objects from the provided
+     * anchors and selectors.
+     */
+    getUniversalPColumnEntries(e, n, r) {
       const i = {};
-      if (!(e instanceof Pn))
-        for (const [a, h2] of Object.entries(e))
-          if (On(h2)) {
-            const p2 = this.getPColumnSpecByRef(h2);
-            if (!p2)
+      if (!(e instanceof On))
+        for (const [l2, m2] of Object.entries(e))
+          if (Kn(m2)) {
+            const u = this.getPColumnSpecByRef(m2);
+            if (!u)
               return;
-            i[a] = p2;
+            i[l2] = u;
           } else
-            i[a] = h2;
-      const r = typeof n == "function" ? n : Vn(
-        Array.isArray(n) ? n.map((a) => En(i, a)) : En(i, n)
-      ), o = this.getSpecs().entries.filter(({ obj: a }) => c(a) ? r(a) : false);
-      if (o.length === 0)
-        return [];
-      const u = e instanceof Pn ? e : new Pn(i), c$1 = typeof n == "object" && !Array.isArray(n) && "axes" in n && n.axes !== void 0 && n.partialAxesMatch === void 0 ? n.axes.map((a, h2) => "split" in a && a.split === true ? h2 : -1).filter((a) => a !== -1) : [];
-      if (c$1.sort((a, h2) => a - h2), c$1.length > 0) {
-        const a = [], h2 = c$1[c$1.length - 1];
-        for (const { ref: l, obj: f } of o) {
-          if (!c(f)) continue;
-          const d = this.getDataByRef(l);
-          if (!d || !v(d)) continue;
-          const y = We(d.data);
-          if (!y) continue;
-          if (h2 >= y.length)
-            throw new Error(`Not enough partition keys for the requested split axes in column ${f.name}`);
-          const _ = c$1.map((m2) => this.findLabels(p(f.axesSpec[m2]))), A = [], v$1 = (m2, w2) => {
-            if (w2 >= c$1.length) {
-              A.push([...m2]);
+            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;
             }
-            const L = c$1[w2], R = y[L];
-            for (const F2 of R)
-              m2.push(F2), v$1(m2, w2 + 1), m2.pop();
-          };
-          v$1([], 0);
-          for (const m2 of A) {
-            const w2 = m2.map((R, F2) => {
-              const M = c$1[F2], C = wn(p(f.axesSpec[M])), D = _[F2], q2 = (D == null ? void 0 : D[R]) ?? String(R);
-              return {
-                type: `split:${C}`,
-                label: q2,
-                importance: 1e6
-              };
-            }), L = c$1.map((R, F2) => [R, m2[F2]]);
-            a.push({
-              obj: f,
-              ref: l,
-              filteringTrace: w2,
-              filters: L
-            });
+            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
+              });
+            }
           }
-        }
-        return Q(
-          a,
-          (l) => ({
-            spec: l.obj,
-            suffixTrace: l.filteringTrace
-          }),
-          s ?? {}
-        ).map((l) => ({
-          value: u.deriveS(l.value.obj, l.value.filters),
-          label: l.label
-        }));
+        } else
+          for (const { ref: p2, obj: d } of u)
+            f(d) && a.push({
+              obj: d,
+              ref: p2
+              // No splitFilters needed here
+            });
       }
-      return Q(o, (a) => a.obj, s ?? {}).map(({ value: { obj: a }, label: h2 }) => ({
-        value: u.deriveS(a),
-        label: h2
+      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()
      */
@@ -4833,9 +5186,9 @@
           ref: n.ref,
           obj: {
             ...n.obj,
-            data: Bn(
+            data: Mn(
               n.obj.data,
-              (s) => new I(s, [n.ref.blockId, n.ref.name])
+              (r) => new I(r, [n.ref.blockId, n.ref.name])
             )
           }
         }))
@@ -4855,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 : Cn(
-        this.ctx.getDataFromResultPoolByRef(e.blockId, e.name),
-        (s) => new I(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.
@@ -4871,7 +5228,7 @@
     getPColumnByRef(e) {
       const n = this.getDataByRef(e);
       if (n)
-        return Sn(n);
+        return Dn(n);
     }
     /**
      * Returns spec associated with the ref ensuring that it is a p-column spec.
@@ -4881,7 +5238,7 @@
     getPColumnSpecByRef(e) {
       const n = this.getSpecByRef(e);
       if (n) {
-        if (!c(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;
       }
     }
@@ -4899,17 +5256,17 @@
      */
     findDataWithCompatibleSpec(e) {
       const n = [];
-      e: for (const s of this.getData().entries) {
-        if (!c(s.obj.spec))
+      e: for (const r of this.getData().entries) {
+        if (!f(r.obj.spec))
           continue;
-        const i = s.obj.spec;
-        if (e.name === i.name && e.valueType === i.valueType && e.axesSpec.length === i.axesSpec.length && te(e.domain, i.domain)) {
-          for (let r = 0; r < e.axesSpec.length; ++r) {
-            const o = e.axesSpec[r], u = i.axesSpec[r];
-            if (o.name !== u.name || o.type !== u.type || !te(o.domain, u.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;
@@ -4920,29 +5277,29 @@
      */
     findLabels(e) {
       const n = this.getData();
-      for (const s of n.entries) {
-        if (!v(s.obj)) continue;
-        const i = s.obj.spec;
-        if (i.name === "pl7.app/label" && i.axesSpec.length === 1 && i.axesSpec[0].name === e.name && i.axesSpec[0].type === e.type && te(e.domain, i.axesSpec[0].domain)) {
-          if (s.obj.data.resourceType.name !== "PColumnData/Json")
-            throw Error(`Expected JSON column for labels, got: ${s.obj.data.resourceType.name}`);
+      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(
-              s.obj.data.getDataAsJson().data
+              r.obj.data.getDataAsJson().data
             ).map((o) => [JSON.parse(o[0])[0], o[1]])
           );
         }
       }
     }
   }
-  class G {
+  class z {
     constructor() {
-      x(this, "ctx");
-      x(this, "args");
-      x(this, "uiState");
-      x(this, "_activeArgsCache");
-      x(this, "resultPool", new Ke());
-      this.ctx = g(), 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).
@@ -4958,16 +5315,16 @@
     //   return this.ctx.featureFlags;
     // }
     getNamedAccessor(e) {
-      return se(
+      return ie(
         this.ctx.getAccessorHandleByName(e),
         (n) => new I(n, [e])
       );
     }
     get prerun() {
-      return this.getNamedAccessor(ye);
+      return this.getNamedAccessor(ve);
     }
     get outputs() {
-      return this.getNamedAccessor(be);
+      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.
@@ -4977,14 +5334,14 @@
     findLabels(e) {
       return this.resultPool.findLabels(e);
     }
-    verifyInlineColumnsSupport(e) {
+    verifyInlineAndExplicitColumnsSupport(e) {
       var i;
-      const n = e.some((r) => !(r.data instanceof I)), s = ((i = this.ctx.featureFlags) == null ? void 0 : i.inlineColumnsSupport) === true;
-      if (n && !s) throw Error("inline columns not supported");
+      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) => Cn(n, (s) => s instanceof I ? s.handle : s))
+      return this.verifyInlineAndExplicitColumnsSupport(e), this.ctx.createPFrame(
+        e.map((n) => fe(n))
       );
     }
     createPTable(e) {
@@ -4992,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($n(n.src)), this.ctx.createPTable(
-        An(
-          n,
-          (s) => Cn(s, (i) => i instanceof I ? i.handle : i)
-        )
+      } : n = e, this.verifyInlineAndExplicitColumnsSupport(Bn(n.src)), this.ctx.createPTable(
+        En(n, (r) => fe(r))
       );
     }
     /** @deprecated scheduled for removal from SDK */
@@ -5012,33 +5366,33 @@
         return this.ctx.getCurrentUnstableMarker();
     }
   }
-  const j = "1.25.0";
-  function He(t) {
+  const U = "1.26.0";
+  function tt(t) {
     return t.__renderLambda === true;
   }
-  function ne(t) {
+  function se(t) {
     if (t !== void 0)
-      return He(t) ? t.handle : t;
+      return tt(t) ? t.handle : t;
   }
-  class P {
-    constructor(e, n, s, i, r, o, u) {
-      this._renderingMode = e, this._initialArgs = n, this._initialUiState = s, this._outputs = i, this._inputsValid = r, this._sections = o, this._title = u;
+  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 P(
+      return new _(
         e,
         void 0,
         {},
         {},
-        W(true),
-        W([]),
+        Y(true),
+        Y([]),
         void 0
       );
     }
-    output(e, n, s = {}) {
+    output(e, n, r = {}) {
       if (typeof n == "function") {
         const i = `output#${e}`;
-        return $(i, () => n(new G())), new P(
+        return q(i, () => n(new z())), new _(
           this._renderingMode,
           this._initialArgs,
           this._initialUiState,
@@ -5047,7 +5401,7 @@
             [e]: {
               __renderLambda: true,
               handle: i,
-              ...s
+              ...r
             }
           },
           this._inputsValid,
@@ -5055,7 +5409,7 @@
           this._title
         );
       } else
-        return new P(
+        return new _(
           this._renderingMode,
           this._initialArgs,
           this._initialUiState,
@@ -5073,7 +5427,7 @@
       return this.output(e, n, { retentive: true });
     }
     argsValid(e) {
-      return typeof e == "function" ? ($("inputsValid", () => e(new G())), new P(
+      return typeof e == "function" ? (q("inputsValid", () => e(new z())), new _(
         this._renderingMode,
         this._initialArgs,
         this._initialUiState,
@@ -5084,7 +5438,7 @@
         },
         this._sections,
         this._title
-      )) : new P(
+      )) : new _(
         this._renderingMode,
         this._initialArgs,
         this._initialUiState,
@@ -5095,7 +5449,7 @@
       );
     }
     sections(e) {
-      return Array.isArray(e) ? this.sections(W(e)) : typeof e == "function" ? ($("sections", () => e(new G())), new P(
+      return Array.isArray(e) ? this.sections(Y(e)) : typeof e == "function" ? (q("sections", () => e(new z())), new _(
         this._renderingMode,
         this._initialArgs,
         this._initialUiState,
@@ -5103,7 +5457,7 @@
         this._inputsValid,
         { __renderLambda: true, handle: "sections" },
         this._title
-      )) : new P(
+      )) : new _(
         this._renderingMode,
         this._initialArgs,
         this._initialUiState,
@@ -5115,7 +5469,7 @@
     }
     /** Sets a rendering function to derive block title, shown for the block in the left blocks-overview panel. */
     title(e) {
-      return $("title", () => e(new G())), new P(
+      return q("title", () => e(new z())), new _(
         this._renderingMode,
         this._initialArgs,
         this._initialUiState,
@@ -5130,7 +5484,7 @@
      * @deprecated use {@link withArgs}
      * */
     initialArgs(e) {
-      return new P(
+      return new _(
         this._renderingMode,
         e,
         this._initialUiState,
@@ -5142,7 +5496,7 @@
     }
     /** Sets initial args for the block, this value must be specified. */
     withArgs(e) {
-      return new P(
+      return new _(
         this._renderingMode,
         e,
         this._initialUiState,
@@ -5154,7 +5508,7 @@
     }
     /** Defines type and sets initial value for block UiState. */
     withUiState(e) {
-      return new P(
+      return new _(
         this._renderingMode,
         this._initialArgs,
         e,
@@ -5171,7 +5525,7 @@
       if (this._initialArgs === void 0) throw new Error("Initial arguments not set.");
       const e = {
         v3: {
-          sdkVersion: j,
+          sdkVersion: U,
           renderingMode: this._renderingMode,
           initialArgs: this._initialArgs,
           initialUiState: this._initialUiState,
@@ -5181,72 +5535,72 @@
           outputs: this._outputs
         },
         // fields below are added to allow previous desktop versions read generated configs
-        sdkVersion: j,
+        sdkVersion: U,
         renderingMode: this._renderingMode,
         initialArgs: this._initialArgs,
-        inputsValid: ne(this._inputsValid),
-        sections: ne(this._sections),
+        inputsValid: se(this._inputsValid),
+        sections: se(this._sections),
         outputs: Object.fromEntries(
-          Object.entries(this._outputs).map(([n, s]) => [n, ne(s)])
+          Object.entries(this._outputs).map(([n, r]) => [n, se(r)])
         )
       };
-      return ke() ? me({ sdkVersion: j }) : { config: e };
+      return Ke() ? be({ sdkVersion: U }) : { config: e };
     }
   }
-  function Vt(t, e, n, s) {
-    var a, h2;
-    Array.isArray(s) && (s = { filters: s });
-    const i = t.resultPool.getData().entries.map((p2) => p2.obj).filter(v).filter((p2) => p2.spec.name === "pl7.app/label" && p2.spec.axesSpec.length === 1), r = (p2, l) => {
-      let f = p2.toString();
-      if (l)
-        for (const d in l)
-          f += d, f += l[d];
-      return f;
+  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 p$1 of e)
-      for (const l of p$1.spec.axesSpec) {
-        const f = p(l);
+    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], _ = p(d.spec.axesSpec[0]);
-          if (Q$1(f, _)) {
-            const A = Object.keys(f.domain ?? {}).length, v2 = Object.keys(_.domain ?? {}).length;
-            if (A > v2) {
-              const m2 = r(d.id, f.domain);
-              o.set(m2, {
-                id: m2,
+          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: {
                   ...d.spec,
-                  axesSpec: [{ ...f, annotations: y.annotations }]
+                  axesSpec: [{ ...p2, annotations: y.annotations }]
                 },
                 data: d.data
               });
             } else
-              o.set(r(d.id), d);
+              o.set(s(d.id), d);
           }
         }
       }
     if ([...e, ...o.values()].some(
-      (p2) => p2.data instanceof I && !p2.data.getIsReadyOrError()
+      (u) => u.data instanceof I && !u.data.getIsReadyOrError()
     ))
       return;
-    let u = e;
-    const c2 = [];
-    if (s != null && s.coreColumnPredicate) {
-      u = [];
-      for (const p2 of e)
-        s.coreColumnPredicate(p2.spec) ? u.push(p2) : c2.push(p2);
-    }
-    return c2.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: u.map((p2) => ({ type: "column", column: p2 }))
+          type: (r == null ? void 0 : r.coreJoinType) ?? "full",
+          entries: a.map((u) => ({ type: "column", column: u }))
         },
-        secondary: c2.map((p2) => ({ type: "column", column: p2 }))
+        secondary: c.map((u) => ({ type: "column", column: u }))
       },
-      filters: [...(s == null ? void 0 : s.filters) ?? [], ...((a = n == null ? void 0 : n.pTableParams) == null ? void 0 : a.filters) ?? []],
-      sorting: ((h2 = n == null ? void 0 : n.pTableParams) == null ? void 0 : h2.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) {
@@ -5264,11 +5618,11 @@
   function times(n, cb) {
     return toList(range(0, n)).map(cb);
   }
-  const $BlockArgs = z.object({
-    tableNumRows: z.number().default(100),
-    numbers: z.array(z.coerce.number())
+  const $BlockArgs = z$2.object({
+    tableNumRows: z$2.number().default(100),
+    numbers: z$2.array(z$2.coerce.number())
   });
-  const platforma = P.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");
     }
@@ -5280,13 +5634,13 @@
     var _a, _b, _c, _d, _e2;
     if (!((_c = (_b = (_a = ctx.uiState) == null ? void 0 : _a.dataTableState) == null ? void 0 : _b.tableState.pTableParams) == null ? void 0 : _c.filters)) return void 0;
     const data = times(ctx.args.tableNumRows ?? 0, (i) => {
-      const v2 = i + 1;
+      const v = i + 1;
       return {
-        key: [v2, v2 + 0.1],
-        val: v2.toString()
+        key: [v, v + 0.1],
+        val: v.toString()
       };
     });
-    return Vt(
+    return Gt(
       ctx,
       [
         {