@milaboratories/milaboratories.monetization-test.model 1.0.4 → 1.0.5

package/dist/bundle.js

@@ -2,6 +2,40 @@
   typeof exports === "object" && typeof module !== "undefined" ? factory(exports) : typeof define === "function" && define.amd ? define(["exports"], factory) : (global = typeof globalThis !== "undefined" ? globalThis : global || self, factory(global.model = {}));
 })(this, function(exports2) {
   "use strict";
+  function getDefaultExportFromCjs(x2) {
+    return x2 && x2.__esModule && Object.prototype.hasOwnProperty.call(x2, "default") ? x2["default"] : x2;
+  }
+  var canonicalize = function serialize(object) {
+    if (typeof object === "number" && isNaN(object)) {
+      throw new Error("NaN is not allowed");
+    }
+    if (typeof object === "number" && !isFinite(object)) {
+      throw new Error("Infinity is not allowed");
+    }
+    if (object === null || typeof object !== "object") {
+      return JSON.stringify(object);
+    }
+    if (object.toJSON instanceof Function) {
+      return serialize(object.toJSON());
+    }
+    if (Array.isArray(object)) {
+      const values2 = object.reduce((t, cv, ci) => {
+        const comma = ci === 0 ? "" : ",";
+        const value = cv === void 0 || typeof cv === "symbol" ? null : cv;
+        return `${t}${comma}${serialize(value)}`;
+      }, "");
+      return `[${values2}]`;
+    }
+    const values = Object.keys(object).sort().reduce((t, cv) => {
+      if (object[cv] === void 0 || typeof object[cv] === "symbol") {
+        return t;
+      }
+      const comma = t.length === 0 ? "" : ",";
+      return `${t}${comma}${serialize(cv)}:${serialize(object[cv])}`;
+    }, "");
+    return `{${values}}`;
+  };
+  const Pe = /* @__PURE__ */ getDefaultExportFromCjs(canonicalize);
   var util;
   (function(util2) {
     util2.assertEqual = (val) => val;
@@ -20,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);
     };
@@ -194,10 +228,10 @@
             fieldErrors._errors.push(mapper(issue));
           } else {
             let curr = fieldErrors;
-            let i2 = 0;
-            while (i2 < issue.path.length) {
-              const el = issue.path[i2];
-              const terminal = i2 === issue.path.length - 1;
+            let i = 0;
+            while (i < issue.path.length) {
+              const el = issue.path[i];
+              const terminal = i === issue.path.length - 1;
               if (!terminal) {
                 curr[el] = curr[el] || { _errors: [] };
               } else {
@@ -205,7 +239,7 @@
                 curr[el]._errors.push(mapper(issue));
               }
               curr = curr[el];
-              i2++;
+              i++;
             }
           }
         }
@@ -368,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;
     }
@@ -391,7 +425,7 @@
         overrideMap,
         overrideMap === errorMap ? void 0 : errorMap
         // then global default map
-      ].filter((x) => !!x)
+      ].filter((x2) => !!x2)
     });
     ctx.common.issues.push(issue);
   }
@@ -409,12 +443,12 @@
     }
     static mergeArray(status, results) {
       const arrayValue = [];
-      for (const s of results) {
-        if (s.status === "aborted")
+      for (const s2 of results) {
+        if (s2.status === "aborted")
           return INVALID;
-        if (s.status === "dirty")
+        if (s2.status === "dirty")
           status.dirty();
-        arrayValue.push(s.value);
+        arrayValue.push(s2.value);
       }
       return { status: status.value, value: arrayValue };
     }
@@ -454,10 +488,10 @@
   });
   const DIRTY = (value) => ({ status: "dirty", value });
   const OK = (value) => ({ status: "valid", value });
-  const isAborted = (x) => x.status === "aborted";
-  const isDirty = (x) => x.status === "dirty";
-  const isValid = (x) => x.status === "valid";
-  const isAsync = (x) => typeof Promise !== "undefined" && x instanceof Promise;
+  const isAborted = (x2) => x2.status === "aborted";
+  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, 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);
@@ -2051,14 +2085,14 @@
         }
       }
       if (ctx.common.async) {
-        return Promise.all([...ctx.data].map((item, i2) => {
-          return def.type._parseAsync(new ParseInputLazyPath(ctx, item, ctx.path, i2));
+        return Promise.all([...ctx.data].map((item, i) => {
+          return def.type._parseAsync(new ParseInputLazyPath(ctx, item, ctx.path, i));
         })).then((result2) => {
           return ParseStatus.mergeArray(status, result2);
         });
       }
-      const result = [...ctx.data].map((item, i2) => {
-        return def.type._parseSync(new ParseInputLazyPath(ctx, item, ctx.path, i2));
+      const result = [...ctx.data].map((item, i) => {
+        return def.type._parseSync(new ParseInputLazyPath(ctx, item, ctx.path, i));
       });
       return ParseStatus.mergeArray(status, result);
     }
@@ -2659,17 +2693,17 @@
       });
     }
   }
-  function mergeValues(a, b2) {
+  function mergeValues(a, b) {
     const aType = getParsedType(a);
-    const bType = getParsedType(b2);
-    if (a === b2) {
+    const bType = getParsedType(b);
+    if (a === b) {
       return { valid: true, data: a };
     } else if (aType === ZodParsedType.object && bType === ZodParsedType.object) {
-      const bKeys = util.objectKeys(b2);
+      const bKeys = util.objectKeys(b);
       const sharedKeys = util.objectKeys(a).filter((key) => bKeys.indexOf(key) !== -1);
-      const newObj = { ...a, ...b2 };
+      const newObj = { ...a, ...b };
       for (const key of sharedKeys) {
-        const sharedValue = mergeValues(a[key], b2[key]);
+        const sharedValue = mergeValues(a[key], b[key]);
         if (!sharedValue.valid) {
           return { valid: false };
         }
@@ -2677,13 +2711,13 @@
       }
       return { valid: true, data: newObj };
     } else if (aType === ZodParsedType.array && bType === ZodParsedType.array) {
-      if (a.length !== b2.length) {
+      if (a.length !== b.length) {
         return { valid: false };
       }
       const newArray = [];
       for (let index = 0; index < a.length; index++) {
         const itemA = a[index];
-        const itemB = b2[index];
+        const itemB = b[index];
         const sharedValue = mergeValues(itemA, itemB);
         if (!sharedValue.valid) {
           return { valid: false };
@@ -2691,7 +2725,7 @@
         newArray.push(sharedValue.data);
       }
       return { valid: true, data: newArray };
-    } else if (aType === ZodParsedType.date && bType === ZodParsedType.date && +a === +b2) {
+    } else if (aType === ZodParsedType.date && bType === ZodParsedType.date && +a === +b) {
       return { valid: true, data: a };
     } else {
       return { valid: false };
@@ -2787,7 +2821,7 @@
         if (!schema)
           return null;
         return schema._parse(new ParseInputLazyPath(ctx, item, ctx.path, itemIndex));
-      }).filter((x) => !!x);
+      }).filter((x2) => !!x2);
       if (ctx.common.async) {
         return Promise.all(items).then((results) => {
           return ParseStatus.mergeArray(status, results);
@@ -2986,7 +3020,7 @@
         }
         return { status: status.value, value: parsedSet };
       }
-      const elements = [...ctx.data.values()].map((item, i2) => valueType._parse(new ParseInputLazyPath(ctx, item, ctx.path, i2)));
+      const elements = [...ctx.data.values()].map((item, i) => valueType._parse(new ParseInputLazyPath(ctx, item, ctx.path, i)));
       if (ctx.common.async) {
         return Promise.all(elements).then((elements2) => finalizeSet(elements2));
       } else {
@@ -3045,7 +3079,7 @@
             ctx.schemaErrorMap,
             getErrorMap(),
             errorMap
-          ].filter((x) => !!x),
+          ].filter((x2) => !!x2),
           issueData: {
             code: ZodIssueCode.invalid_arguments,
             argumentsError: error
@@ -3061,7 +3095,7 @@
             ctx.schemaErrorMap,
             getErrorMap(),
             errorMap
-          ].filter((x) => !!x),
+          ].filter((x2) => !!x2),
           issueData: {
             code: ZodIssueCode.invalid_return_type,
             returnTypeError: error
@@ -3662,10 +3696,10 @@
         }
       }
     }
-    static create(a, b2) {
+    static create(a, b) {
       return new ZodPipeline({
         in: a,
-        out: b2,
+        out: b,
         typeName: ZodFirstPartyTypeKind.ZodPipeline
       });
     }
@@ -3697,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();
@@ -3914,63 +3948,375 @@
     quotelessJson,
     ZodError
   });
-  function b$1(t) {
-    throw new Error("Unexpected object: " + t);
+  var $ = Object.defineProperty;
+  var D = (n2, t, e) => t in n2 ? $(n2, t, { enumerable: true, configurable: true, writable: true, value: e }) : n2[t] = e;
+  var m$2 = (n2, t, e) => D(n2, typeof t != "symbol" ? t + "" : t, e);
+  function w(n2) {
+    throw new Error("Unexpected object: " + n2);
   }
-  function it(t, n) {
-    return { ...t, src: f(t.src, n) };
+  function pn(n2) {
+    if (!n2 || typeof n2 != "object")
+      return false;
+    const t = n2;
+    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 f(t, n) {
+  function mn(n2, t) {
+    if (n2 !== void 0)
+      switch (n2.type) {
+        case "Json":
+          return n2;
+        case "JsonPartitioned": {
+          const e = {};
+          for (const [r, o] of Object.entries(n2.parts))
+            e[r] = t(o);
+          return {
+            ...n2,
+            parts: e
+          };
+        }
+        case "BinaryPartitioned": {
+          const e = {};
+          for (const [r, o] of Object.entries(n2.parts))
+            e[r] = {
+              index: t(o.index),
+              values: t(o.values)
+            };
+          return {
+            ...n2,
+            parts: e
+          };
+        }
+      }
+  }
+  function j(n2) {
+    if (!n2 || typeof n2 != "object")
+      return false;
+    const t = n2;
+    if (!("type" in t))
+      return false;
     switch (t.type) {
+      case "Json":
+        return typeof t.keyLength == "number" && Array.isArray(t.data);
+      case "JsonPartitioned":
+        return typeof t.partitionKeyLength == "number" && Array.isArray(t.parts);
+      case "BinaryPartitioned":
+        return typeof t.partitionKeyLength == "number" && Array.isArray(t.parts);
+      default:
+        return false;
+    }
+  }
+  function yn(n2) {
+    return j(n2) ? n2.type === "JsonPartitioned" || n2.type === "BinaryPartitioned" : false;
+  }
+  function ln(n2) {
+    switch (n2.type) {
+      case "Json": {
+        const t = Object.entries(n2.data).map(([e, r]) => ({ key: JSON.parse(e), value: r }));
+        return {
+          type: "Json",
+          keyLength: n2.keyLength,
+          data: t
+        };
+      }
+      case "JsonPartitioned": {
+        const t = Object.entries(n2.parts).map(([e, r]) => ({ key: JSON.parse(e), value: r }));
+        return {
+          type: "JsonPartitioned",
+          partitionKeyLength: n2.partitionKeyLength,
+          parts: t
+        };
+      }
+      case "BinaryPartitioned": {
+        const t = Object.entries(n2.parts).map(([e, r]) => ({ key: JSON.parse(e), value: r }));
+        return {
+          type: "BinaryPartitioned",
+          partitionKeyLength: n2.partitionKeyLength,
+          parts: t
+        };
+      }
+    }
+  }
+  function hn(n2) {
+    switch (n2.type) {
+      case "Json": {
+        const t = {};
+        for (const e of n2.data)
+          t[JSON.stringify(e.key)] = e.value;
+        return {
+          type: "Json",
+          keyLength: n2.keyLength,
+          data: t
+        };
+      }
+      case "JsonPartitioned": {
+        const t = {};
+        for (const e of n2.parts)
+          t[JSON.stringify(e.key)] = e.value;
+        return {
+          type: "JsonPartitioned",
+          partitionKeyLength: n2.partitionKeyLength,
+          parts: t
+        };
+      }
+      case "BinaryPartitioned": {
+        const t = {};
+        for (const e of n2.parts)
+          t[JSON.stringify(e.key)] = e.value;
+        return {
+          type: "BinaryPartitioned",
+          partitionKeyLength: n2.partitionKeyLength,
+          parts: t
+        };
+      }
+    }
+  }
+  function p$1(n2) {
+    const { type: t, name: e, domain: r } = n2;
+    return { type: t, name: e, ...r && { domain: r } };
+  }
+  function En(n2) {
+    return Pe(p$1(n2));
+  }
+  function X$1(n2, t) {
+    if (n2 === void 0) return t === void 0;
+    if (t === void 0) return true;
+    for (const e in t)
+      if (n2[e] !== t[e]) return false;
+    return true;
+  }
+  function z(n2, t) {
+    return n2.name === t.name && X$1(n2.domain, t.domain);
+  }
+  function Cn(n2, t) {
+    return { ...n2, src: l$1(n2.src, t) };
+  }
+  function l$1(n2, t) {
+    switch (n2.type) {
       case "column":
         return {
           type: "column",
-          column: n(t.column)
+          column: t(n2.column)
+        };
+      case "slicedColumn":
+        return {
+          type: "slicedColumn",
+          column: t(n2.column),
+          newId: n2.newId,
+          axisFilters: n2.axisFilters
         };
       case "inner":
       case "full":
         return {
-          type: t.type,
-          entries: t.entries.map((e) => f(e, n))
+          type: n2.type,
+          entries: n2.entries.map((e) => l$1(e, t))
         };
       case "outer":
         return {
           type: "outer",
-          primary: f(t.primary, n),
-          secondary: t.secondary.map((e) => f(e, n))
+          primary: l$1(n2.primary, t),
+          secondary: n2.secondary.map((e) => l$1(e, t))
         };
       default:
-        b$1(t);
+        w(n2);
     }
   }
-  z$1.object({
-    __isRef: z$1.literal(true).describe("Crucial marker for the block dependency tree reconstruction"),
-    blockId: z$1.string().describe("Upstream block id"),
-    name: z$1.string().describe("Name of the output provided to the upstream block's output context")
-  }).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 i(t) {
-    return t.kind === "PColumn";
+  function G(n2) {
+    return Pe(n2);
   }
-  function W(t) {
-    return i(t.spec);
+  function A(n2) {
+    return Pe(p$1(n2));
   }
-  function dt(t) {
-    if (!W(t)) throw new Error(`not a PColumn (kind = ${t.spec.kind})`);
-    return t;
+  function x(n2, t) {
+    return JSON.stringify([n2, t]);
   }
-  function lt(t, n) {
-    return t === void 0 ? void 0 : {
-      ...t,
-      data: n(t.data)
+  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$2(this, "domains", /* @__PURE__ */ new Map());
+      m$2(this, "axes", /* @__PURE__ */ new Map());
+      m$2(this, "domainPacks", []);
+      m$2(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 s2 = 0; s2 < o.axesSpec.length; s2++) {
+          const a = o.axesSpec[s2], i = A(a);
+          this.axes.set(i, { anchor: r, idx: s2 });
+        }
+        if (o.domain !== void 0) {
+          const s2 = Object.entries(o.domain);
+          s2.sort((a, i) => a[0].localeCompare(i[0])), this.domainPackToAnchor.set(JSON.stringify(s2), r), this.domainPacks.push(s2.map(([a]) => a));
+          for (const [a, i] of s2) {
+            const u2 = x(a, i);
+            this.domains.set(u2, r);
+          }
+        }
+      }
+    }
+    /**
+     * Implementation of derive method
+     */
+    derive(t, e) {
+      const r = {
+        name: t.name,
+        axes: []
+      };
+      let o;
+      if (t.domain !== void 0)
+        n:
+          for (const a of this.domainPacks) {
+            const i = [];
+            for (const c2 of a) {
+              const d = t.domain[c2];
+              if (d !== void 0)
+                i.push([c2, d]);
+              else
+                break n;
+            }
+            const u2 = this.domainPackToAnchor.get(JSON.stringify(i));
+            if (u2 !== void 0) {
+              r.domainAnchor = u2, o = new Set(a);
+              break;
+            }
+          }
+      for (const [a, i] of Object.entries(t.domain ?? {})) {
+        if (o !== void 0 && o.has(a))
+          continue;
+        const u2 = x(a, i), c2 = this.domains.get(u2);
+        r.domain ?? (r.domain = {}), r.domain[a] = c2 ? { anchor: c2 } : i;
+      }
+      if (r.axes = t.axesSpec.map((a) => {
+        const i = A(a), u2 = this.axes.get(i);
+        return u2 === void 0 ? p$1(a) : u2;
+      }), !e || e.length === 0)
+        return r;
+      const s2 = [];
+      for (const a of e) {
+        const [i, u2] = a;
+        if (typeof i == "number") {
+          if (i < 0 || i >= t.axesSpec.length)
+            throw new Error(`Axis index ${i} is out of bounds (0-${t.axesSpec.length - 1})`);
+          s2.push([i, u2]);
+        } else {
+          const c2 = t.axesSpec.findIndex((d) => d.name === i);
+          if (c2 === -1)
+            throw new Error(`Axis with name "${i}" not found in the column specification`);
+          s2.push([c2, u2]);
+        }
+      }
+      return s2.sort((a, i) => a[0] - i[0]), {
+        source: r,
+        axisFilters: s2
+      };
+    }
+    /**
+     * 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
+     */
+    deriveS(t, e) {
+      return G(this.derive(t, e));
+    }
+  }
+  function $n(n2, t, e) {
+    const r = { ...t }, o = (e == null ? void 0 : e.ignoreMissingDomains) ?? false;
+    if (r.domainAnchor !== void 0) {
+      const s2 = n2[r.domainAnchor];
+      if (!s2)
+        throw new Error(`Anchor "${r.domainAnchor}" not found`);
+      const a = s2.domain || {};
+      r.domain = { ...a, ...r.domain }, delete r.domainAnchor;
+    }
+    if (r.domain) {
+      const s2 = {};
+      for (const [a, i] of Object.entries(r.domain))
+        if (typeof i == "string")
+          s2[a] = i;
+        else {
+          const u2 = n2[i.anchor];
+          if (!u2)
+            throw new Error(`Anchor "${i.anchor}" not found for domain key "${a}"`);
+          if (!u2.domain || u2.domain[a] === void 0) {
+            if (!o)
+              throw new Error(`Domain key "${a}" not found in anchor "${i.anchor}"`);
+            continue;
+          }
+          s2[a] = u2.domain[a];
+        }
+      r.domain = s2;
+    }
+    return r.axes && (r.axes = r.axes.map((s2) => Q(n2, s2))), r;
+  }
+  function Q(n2, t) {
+    if (!Y$1(t))
+      return t;
+    const e = t.anchor, r = n2[e];
+    if (!r)
+      throw new Error(`Anchor "${e}" not found for axis reference`);
+    if ("idx" in t) {
+      if (t.idx < 0 || t.idx >= r.axesSpec.length)
+        throw new Error(`Axis index ${t.idx} out of bounds for anchor "${e}"`);
+      return r.axesSpec[t.idx];
+    } else if ("name" in t) {
+      const o = r.axesSpec.filter((s2) => s2.name === t.name);
+      if (o.length > 1)
+        throw new Error(`Multiple axes with name "${t.name}" found in anchor "${e}"`);
+      if (o.length === 0)
+        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((s2) => z(t.id, p$1(s2)));
+      if (o.length > 1)
+        throw new Error(`Multiple matching axes found for matcher in anchor "${e}"`);
+      if (o.length === 0)
+        throw new Error(`No matching axis found for matcher in anchor "${e}"`);
+      return o[0];
+    }
+    throw new Error("Unsupported axis reference type");
+  }
+  function Y$1(n2) {
+    return typeof n2 == "object" && "anchor" in n2;
+  }
+  function f(n2) {
+    return n2.kind === "PColumn";
+  }
+  function Z$1(n2) {
+    return f(n2.spec);
+  }
+  function In(n2) {
+    if (!Z$1(n2)) throw new Error(`not a PColumn (kind = ${n2.spec.kind})`);
+    return n2;
+  }
+  function Bn(n2, t) {
+    return n2 === void 0 ? void 0 : {
+      ...n2,
+      data: t(n2.data)
     };
   }
-  function pt(t) {
-    const n = /* @__PURE__ */ new Map(), e = (r) => {
+  function jn(n2) {
+    const t = /* @__PURE__ */ new Map(), e = (r) => {
       switch (r.type) {
         case "column":
-          n.set(r.column.id, r.column);
+          t.set(r.column.id, r.column);
+          return;
+        case "slicedColumn":
+          t.set(r.column.id, r.column);
           return;
         case "full":
         case "inner":
@@ -3981,65 +4327,194 @@
           for (const o of r.secondary) e(o);
           return;
         default:
-          b$1(r);
+          w(r);
       }
     };
-    return e(t), [...n.values()];
+    return e(n2), [...t.values()];
+  }
+  function k(n2, t) {
+    if (n2.name !== void 0 && n2.name !== t.name)
+      return false;
+    if (n2.type !== void 0) {
+      if (Array.isArray(n2.type)) {
+        if (!n2.type.includes(t.type))
+          return false;
+      } else if (n2.type !== t.type)
+        return false;
+    }
+    if (n2.domain !== void 0) {
+      const e = t.domain || {};
+      for (const [r, o] of Object.entries(n2.domain))
+        if (e[r] !== o)
+          return false;
+    }
+    return true;
   }
-  function mt(t, n) {
-    return t.ok ? { ok: true, value: n(t.value) } : t;
+  function N(n2, t) {
+    if (t.name !== void 0 && n2.name !== t.name || t.namePattern !== void 0 && !new RegExp(t.namePattern).test(n2.name))
+      return false;
+    if (t.type !== void 0) {
+      if (Array.isArray(t.type)) {
+        if (!t.type.includes(n2.valueType))
+          return false;
+      } else if (t.type !== n2.valueType)
+        return false;
+    }
+    if (t.domain !== void 0) {
+      const e = n2.domain || {};
+      for (const [r, o] of Object.entries(t.domain))
+        if (e[r] !== o)
+          return false;
+    }
+    if (t.axes !== void 0) {
+      const e = n2.axesSpec.map(p$1);
+      if (t.partialAxesMatch) {
+        for (const r of t.axes)
+          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 (!k(t.axes[r], e[r]))
+            return false;
+      }
+    }
+    if (t.annotations !== void 0) {
+      const e = n2.annotations || {};
+      for (const [r, o] of Object.entries(t.annotations))
+        if (e[r] !== o)
+          return false;
+    }
+    if (t.annotationPatterns !== void 0) {
+      const e = n2.annotations || {};
+      for (const [r, o] of Object.entries(t.annotationPatterns)) {
+        const s2 = e[r];
+        if (s2 === void 0 || !new RegExp(o).test(s2))
+          return false;
+      }
+    }
+    return true;
   }
-  const Q = 24;
-  z$1.string().length(Q).regex(/[ABCDEFGHIJKLMNOPQRSTUVWXYZ234567]/).brand("PlId");
-  var he = Object.defineProperty;
-  var ge = (t, e, n) => e in t ? he(t, e, { enumerable: true, configurable: true, writable: true, value: n }) : t[e] = n;
-  var S = (t, e, n) => ge(t, typeof e != "symbol" ? e + "" : e, n);
-  function j(t) {
+  function Fn(n2) {
+    return Array.isArray(n2) ? (t) => n2.some((e) => f(t) && N(t, e)) : (t) => f(t) && N(t, n2);
+  }
+  z$1.object({
+    __isRef: z$1.literal(true).describe("Crucial marker for the block dependency tree reconstruction"),
+    blockId: z$1.string().describe("Upstream block id"),
+    name: z$1.string().describe("Name of the output provided to the upstream block's output context")
+  }).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 Rn(n2) {
+    return typeof n2 == "object" && n2 !== null && "__isRef" in n2 && n2.__isRef === true && "blockId" in n2 && "name" in n2;
+  }
+  function _n(n2, t) {
+    return n2.ok ? { ok: true, value: t(n2.value) } : n2;
+  }
+  const on = 24;
+  z$1.string().length(on).regex(/[ABCDEFGHIJKLMNOPQRSTUVWXYZ234567]/).brand("PlId");
+  var stringify = { exports: {} };
+  (function(module2, exports3) {
+    exports3 = module2.exports = stringify2;
+    exports3.getSerialize = serializer;
+    function stringify2(obj, replacer, spaces, cycleReplacer) {
+      return JSON.stringify(obj, serializer(replacer, cycleReplacer), spaces);
+    }
+    function serializer(replacer, cycleReplacer) {
+      var stack = [], keys = [];
+      if (cycleReplacer == null) cycleReplacer = function(key, value) {
+        if (stack[0] === value) return "[Circular ~]";
+        return "[Circular ~." + keys.slice(0, stack.indexOf(value)).join(".") + "]";
+      };
+      return function(key, value) {
+        if (stack.length > 0) {
+          var thisPos = stack.indexOf(this);
+          ~thisPos ? stack.splice(thisPos + 1) : stack.push(this);
+          ~thisPos ? keys.splice(thisPos, Infinity, key) : keys.push(key);
+          if (~stack.indexOf(value)) value = cycleReplacer.call(this, key, value);
+        } else stack.push(value);
+        return replacer == null ? value : replacer.call(this, key, value);
+      };
+    }
+  })(stringify, stringify.exports);
+  const l = z$1.object({
+    type: z$1.literal("PlError"),
+    name: z$1.string(),
+    message: z$1.string(),
+    /** The message with all details needed for SDK developers. */
+    fullMessage: z$1.string().optional(),
+    stack: z$1.string().optional()
+  }), c = l.extend({
+    cause: z$1.lazy(() => s).optional(),
+    errors: z$1.lazy(() => s.array()).optional()
+  }), m$1 = z$1.object({
+    type: z$1.literal("StandardError"),
+    name: z$1.string(),
+    message: z$1.string(),
+    stack: z$1.string().optional()
+  }), p = m$1.extend({
+    cause: z$1.lazy(() => s).optional(),
+    errors: z$1.lazy(() => s.array()).optional()
+  }), s = z$1.union([p, c]);
+  const u = z$1.object({
+    name: z$1.string(),
+    message: z$1.string(),
+    fullMessage: z$1.string().optional(),
+    stack: z$1.string().optional()
+  }), n = u.extend({
+    cause: z$1.lazy(() => n).optional(),
+    errors: z$1.lazy(() => n.array()).optional()
+  });
+  var je = Object.defineProperty;
+  var Ke = (t, e, n2) => e in t ? je(t, e, { enumerable: true, configurable: true, writable: true, value: n2 }) : t[e] = n2;
+  var L = (t, e, n2) => Ke(t, typeof e != "symbol" ? e + "" : e, n2);
+  function Z(t) {
     return { type: "Immediate", value: t };
   }
-  function Ae() {
+  function Xe() {
     return typeof globalThis.getPlatforma < "u" || typeof globalThis.platforma < "u";
   }
-  function oe(t) {
+  function _e(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 we() {
+  function Qe() {
     if (typeof globalThis.cfgRenderCtx < "u") return globalThis.cfgRenderCtx;
   }
-  function c() {
+  function m() {
     if (typeof globalThis.cfgRenderCtx < "u") return globalThis.cfgRenderCtx;
     throw new Error("Not in config rendering context");
   }
-  function E(t, e) {
-    const n = we();
-    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;
+  function Y(t, e) {
+    const n2 = Qe();
+    if (n2 === void 0) return false;
+    if (t in n2.callbackRegistry) throw new Error(`Callback with key ${t} already registered.`);
+    return n2.callbackRegistry[t] = e, true;
   }
-  const $ = /* @__PURE__ */ new Map();
-  function Ie(t, e) {
-    t in c().callbackRegistry || (c().callbackRegistry[t] = (n) => {
-      for (const r of $.get(t))
-        r(n);
-    }, $.set(t, [])), $.get(t).push(e);
+  const ae = /* @__PURE__ */ new Map();
+  function Ze(t, e) {
+    t in m().callbackRegistry || (m().callbackRegistry[t] = (n2) => {
+      for (const r of ae.get(t))
+        r(n2);
+    }, ae.set(t, [])), ae.get(t).push(e);
   }
-  class b {
-    constructor(e, n = (r) => r) {
-      S(this, "isResolved", false);
-      S(this, "resolvedValue");
-      this.handle = e, this.postProcess = n, Ie(e, (r) => {
-        this.resolvedValue = n(r), this.isResolved = true;
+  class C {
+    constructor(e, n2 = (r) => r) {
+      L(this, "isResolved", false);
+      L(this, "resolvedValue");
+      this.handle = e, this.postProcess = n2, Ze(e, (r) => {
+        this.resolvedValue = n2(r), this.isResolved = true;
       });
     }
     map(e) {
-      return new b(this.handle, (n) => e(this.postProcess(n)));
+      return new C(this.handle, (n2) => e(this.postProcess(n2)));
     }
     mapDefined(e) {
-      return new b(this.handle, (n) => {
-        const r = this.postProcess(n);
+      return new C(this.handle, (n2) => {
+        const r = this.postProcess(n2);
         return r ? e(r) : void 0;
       });
     }
@@ -4047,100 +4522,100 @@
       return this.isResolved ? this.resolvedValue : { __awaited_futures__: [this.handle] };
     }
   }
-  function H(t, e) {
+  function pe(t, e) {
     return t === void 0 ? void 0 : e(t);
   }
-  class v {
-    constructor(e, n) {
-      this.handle = e, this.resolvePath = n;
+  class _ {
+    constructor(e, n2) {
+      this.handle = e, this.resolvePath = n2;
     }
     resolve(...e) {
-      const n = e.map(
+      const n2 = e.map(
         (r) => ({
           assertFieldType: "Input",
           ...typeof r == "string" ? { field: r } : r
         })
       );
-      return this.resolveWithCommon({}, ...n);
+      return this.resolveWithCommon({}, ...n2);
     }
     resolveOutput(...e) {
-      const n = e.map(
+      const n2 = e.map(
         (r) => ({
           assertFieldType: "Output",
           ...typeof r == "string" ? { field: r } : r
         })
       );
-      return this.resolveWithCommon({}, ...n);
+      return this.resolveWithCommon({}, ...n2);
     }
     resolveInput(...e) {
-      const n = e.map(
+      const n2 = e.map(
         (r) => ({
           assertFieldType: "Input",
           ...typeof r == "string" ? { field: r } : r
         })
       );
-      return this.resolveWithCommon({}, ...n);
+      return this.resolveWithCommon({}, ...n2);
     }
     resolveAny(...e) {
       return this.resolveWithCommon({}, ...e);
     }
-    resolveWithCommon(e, ...n) {
+    resolveWithCommon(e, ...n2) {
       const r = [
         ...this.resolvePath,
-        ...n.map((s) => typeof s == "string" ? s : s.field)
+        ...n2.map((i) => typeof i == "string" ? i : i.field)
       ];
-      return H(
-        c().resolveWithCommon(this.handle, e, ...n),
-        (s) => new v(s, r)
+      return pe(
+        m().resolveWithCommon(this.handle, e, ...n2),
+        (i) => new _(i, r)
       );
     }
     get resourceType() {
-      return c().getResourceType(this.handle);
+      return m().getResourceType(this.handle);
     }
     getInputsLocked() {
-      return c().getInputsLocked(this.handle);
+      return m().getInputsLocked(this.handle);
     }
     getOutputsLocked() {
-      return c().getOutputsLocked(this.handle);
+      return m().getOutputsLocked(this.handle);
     }
     getIsReadyOrError() {
-      return c().getIsReadyOrError(this.handle);
+      return m().getIsReadyOrError(this.handle);
     }
     getIsFinal() {
-      return c().getIsFinal(this.handle);
+      return m().getIsFinal(this.handle);
     }
     getError() {
       const e = [...this.resolvePath, "error"];
-      return H(
-        c().getError(this.handle),
-        (n) => new v(n, e)
+      return pe(
+        m().getError(this.handle),
+        (n2) => new _(n2, e)
       );
     }
     listInputFields() {
-      return c().listInputFields(this.handle);
+      return m().listInputFields(this.handle);
     }
     listOutputFields() {
-      return c().listOutputFields(this.handle);
+      return m().listOutputFields(this.handle);
     }
     listDynamicFields() {
-      return c().listDynamicFields(this.handle);
+      return m().listDynamicFields(this.handle);
     }
     getKeyValueBase64(e) {
-      return c().getKeyValueBase64(this.handle, e);
+      return m().getKeyValueBase64(this.handle, e);
     }
     getKeyValueAsString(e) {
-      return c().getKeyValueAsString(this.handle, e);
+      return m().getKeyValueAsString(this.handle, e);
     }
     getKeyValueAsJson(e) {
-      const n = this.getKeyValueAsString(e);
-      if (n == null) throw new Error("Resource has no content.");
-      return JSON.parse(n);
+      const n2 = this.getKeyValueAsString(e);
+      if (n2 == null) throw new Error("Resource has no content.");
+      return JSON.parse(n2);
     }
     getDataBase64() {
-      return c().getDataBase64(this.handle);
+      return m().getDataBase64(this.handle);
     }
     getDataAsString() {
-      return c().getDataAsString(this.handle);
+      return m().getDataAsString(this.handle);
     }
     getDataAsJson() {
       const e = this.getDataAsString();
@@ -4150,40 +4625,40 @@
     /**
      *
      */
-    getPColumns(e = false, n = "") {
-      const r = this.parsePObjectCollection(e, n);
-      return r === void 0 ? void 0 : Object.entries(r).map(([, i2]) => {
-        if (!W(i2)) throw new Error(`not a PColumn (kind = ${i2.spec.kind})`);
-        return i2;
+    getPColumns(e = false, n2 = "") {
+      const r = this.parsePObjectCollection(e, n2);
+      return r === void 0 ? void 0 : Object.entries(r).map(([, s2]) => {
+        if (!Z$1(s2)) throw new Error(`not a PColumn (kind = ${s2.spec.kind})`);
+        return s2;
       });
     }
     /**
      *
      */
-    parsePObjectCollection(e = false, n = "") {
-      const r = c().parsePObjectCollection(
+    parsePObjectCollection(e = false, n2 = "") {
+      const r = m().parsePObjectCollection(
         this.handle,
         e,
-        n,
+        n2,
         ...this.resolvePath
       );
       if (r === void 0) return;
-      const s = {};
-      for (const [i2, o] of Object.entries(r)) {
-        const a = [...this.resolvePath, i2];
-        s[i2] = lt(o, (l) => new v(l, a));
+      const i = {};
+      for (const [s2, o] of Object.entries(r)) {
+        const a = [...this.resolvePath, s2];
+        i[s2] = Bn(o, (l2) => new _(l2, a));
       }
-      return s;
+      return i;
     }
     getFileContentAsBase64() {
-      return new b(c().getBlobContentAsBase64(this.handle));
+      return new C(m().getBlobContentAsBase64(this.handle));
     }
     getFileContentAsString() {
-      return new b(c().getBlobContentAsString(this.handle));
+      return new C(m().getBlobContentAsString(this.handle));
     }
     getFileContentAsJson() {
-      return new b(
-        c().getBlobContentAsString(this.handle)
+      return new C(
+        m().getBlobContentAsString(this.handle)
       ).mapDefined((e) => JSON.parse(e));
     }
     /**
@@ -4202,7 +4677,7 @@
      * @returns downloaded file handle
      */
     getFileHandle() {
-      return new b(c().getDownloadedBlobContentHandle(this.handle));
+      return new C(m().getDownloadedBlobContentHandle(this.handle));
     }
     /**
      * @deprecated use getFileHandle
@@ -4214,7 +4689,7 @@
      * @returns downloaded file handle
      */
     getRemoteFileHandle() {
-      return new b(c().getOnDemandBlobContentHandle(this.handle));
+      return new C(m().getOnDemandBlobContentHandle(this.handle));
     }
     /**
      * @deprecated use getRemoteFileHandle
@@ -4226,118 +4701,599 @@
      * @returns the url to the extracted folder
      */
     extractArchiveAndGetURL(e) {
-      return new b(c().extractArchiveAndGetURL(this.handle, e));
+      return new C(m().extractArchiveAndGetURL(this.handle, e));
     }
     getImportProgress() {
-      return new b(c().getImportProgress(this.handle));
+      return new C(m().getImportProgress(this.handle));
     }
     getLastLogs(e) {
-      return new b(c().getLastLogs(this.handle, e));
+      return new C(m().getLastLogs(this.handle, e));
     }
     getProgressLog(e) {
-      return new b(c().getProgressLog(this.handle, e));
+      return new C(m().getProgressLog(this.handle, e));
     }
     getProgressLogWithInfo(e) {
-      return new b(c().getProgressLogWithInfo(this.handle, e));
+      return new C(m().getProgressLogWithInfo(this.handle, e));
     }
     getLogHandle() {
-      return new b(c().getLogHandle(this.handle));
+      return new C(m().getLogHandle(this.handle));
     }
     allFieldsResolved(e = "Input") {
       switch (e) {
         case "Input":
           return this.getInputsLocked() && this.listInputFields().every(
-            (n) => this.resolve({ field: n, assertFieldType: "Input" }) !== void 0
+            (n2) => this.resolve({ field: n2, assertFieldType: "Input" }) !== void 0
           );
         case "Output":
           return this.getOutputsLocked() && this.listOutputFields().every(
-            (n) => this.resolve({ field: n, assertFieldType: "Output" }) !== void 0
+            (n2) => this.resolve({ field: n2, assertFieldType: "Output" }) !== void 0
           );
       }
     }
-    mapFields(e, n) {
-      const { fieldType: r, requireLocked: s, skipUnresolved: i2 } = {
+    mapFields(e, n2) {
+      const { fieldType: r, requireLocked: i, skipUnresolved: s2 } = {
         fieldType: "Input",
         requireLocked: true,
         skipUnresolved: false,
-        ...n
+        ...n2
       }, o = e;
-      if (s && (r === "Input" && !this.getInputsLocked() || r === "Output" && !this.getOutputsLocked()))
+      if (i && (r === "Input" && !this.getInputsLocked() || r === "Output" && !this.getOutputsLocked()))
         return;
-      let l = (r === "Input" ? this.listInputFields() : r === "Output" ? this.listOutputFields() : this.listDynamicFields()).map(
-        (u) => [u, this.resolve({ field: u, assertFieldType: r })]
+      let l2 = (r === "Input" ? this.listInputFields() : r === "Output" ? this.listOutputFields() : this.listDynamicFields()).map(
+        (u2) => [u2, this.resolve({ field: u2, assertFieldType: r })]
       );
-      return i2 && (l = l.filter((u) => u[1] !== void 0)), l.map(([u, h]) => o(u, h));
+      return s2 && (l2 = l2.filter((u2) => u2[1] !== void 0)), l2.map(([u2, S]) => o(u2, S));
     }
   }
-  const ae = "staging", le = "main";
-  const Fe = "pl7.app/label", Re = "pl7.app/trace", xe = z$1.object({
+  const Ie = "staging", Le = "main";
+  const nt = "pl7.app/label", rt = "pl7.app/trace", it = z$1.object({
     type: z$1.string(),
     importance: z$1.number().optional(),
     id: z$1.string().optional(),
     label: z$1.string()
-  }), Te = z$1.array(xe), Oe = 1e-3, ke = "__LABEL__", ee = "__LABEL__@1";
-  function Le(t, e, n = {}) {
-    const r = /* @__PURE__ */ new Map(), s = /* @__PURE__ */ new Map(), i2 = t.map((p) => {
-      var R, Q2;
-      const g = e(p), f2 = (R = g.annotations) == null ? void 0 : R[Fe], I = (Q2 = g.annotations) == null ? void 0 : Q2[Re], y = (I ? Te.safeParse(JSON.parse(I)).data : void 0) ?? [];
-      if (f2) {
-        const A = { label: f2, type: ke, importance: -2 };
-        n.addLabelAsSuffix ? y.push(A) : y.splice(0, 0, A);
-      }
-      const F = [], D = /* @__PURE__ */ new Map();
-      for (let A = y.length - 1; A >= 0; --A) {
-        const { type: M } = y[A], fe = y[A].importance ?? 0, J = (D.get(M) ?? 0) + 1;
-        D.set(M, J);
-        const x = `${M}@${J}`;
-        s.set(x, (s.get(x) ?? 0) + 1), r.set(
-          x,
+  }), st = z$1.array(it), ot = 1e-3, at = "__LABEL__", ve = "__LABEL__@1";
+  function Ee(t, e, n2 = {}) {
+    const r = /* @__PURE__ */ new Map(), i = /* @__PURE__ */ new Map(), s2 = t.map((p2) => {
+      var q, F;
+      const c2 = e(p2);
+      let h, A2, y;
+      "spec" in c2 && typeof c2.spec == "object" ? (h = c2.spec, A2 = c2.prefixTrace, y = c2.suffixTrace) : h = c2;
+      const v = (q = h.annotations) == null ? void 0 : q[nt], g = (F = h.annotations) == null ? void 0 : F[rt], P = (g ? st.safeParse(JSON.parse(g)).data : void 0) ?? [], b = [
+        ...A2 ?? [],
+        ...P,
+        ...y ?? []
+      ];
+      if (v) {
+        const I = { label: v, type: at, importance: -2 };
+        n2.addLabelAsSuffix ? b.push(I) : b.splice(0, 0, I);
+      }
+      const k2 = [], $2 = /* @__PURE__ */ new Map();
+      for (let I = b.length - 1; I >= 0; --I) {
+        const { type: R } = b[I], se = b[I].importance ?? 0, J = ($2.get(R) ?? 0) + 1;
+        $2.set(R, J);
+        const w2 = `${R}@${J}`;
+        i.set(w2, (i.get(w2) ?? 0) + 1), r.set(
+          w2,
           Math.max(
-            r.get(x) ?? Number.NEGATIVE_INFINITY,
-            fe - (y.length - A) * Oe
+            r.get(w2) ?? Number.NEGATIVE_INFINITY,
+            se - (b.length - I) * ot
           )
-        ), F.push({ ...y[A], fullType: x, occurenceIndex: J });
+        ), k2.push({ ...b[I], fullType: w2, occurenceIndex: J });
       }
-      return F.reverse(), {
-        value: p,
-        spec: g,
-        label: f2,
-        fullTrace: F
+      return k2.reverse(), {
+        value: p2,
+        spec: h,
+        label: v,
+        fullTrace: k2
       };
-    }), o = [], a = [], l = [...r];
-    l.sort(([, p], [, g]) => g - p);
-    for (const [p] of l)
-      p.endsWith("@1") || s.get(p) === t.length ? o.push(p) : a.push(p);
-    const u = (p) => i2.map((g) => {
-      const f2 = g.fullTrace.filter((y) => p.has(y.fullType)).map((y) => y.label), I = n.separator ?? " / ";
-      return {
-        label: f2.join(I),
-        value: g.value
-      };
-    });
+    }), o = [], a = [], l2 = [...r];
+    l2.sort(([, p2], [, c2]) => c2 - p2);
+    for (const [p2] of l2)
+      p2.endsWith("@1") || i.get(p2) === t.length ? o.push(p2) : a.push(p2);
+    const u2 = (p2) => {
+      const c2 = [];
+      for (let h = 0; h < s2.length; h++) {
+        const A2 = s2[h], y = A2.fullTrace.filter((P) => p2.has(P.fullType));
+        if (y.length === 0)
+          return;
+        const v = y.map((P) => P.label), g = n2.separator ?? " / ";
+        c2.push({
+          label: v.join(g),
+          value: A2.value
+        });
+      }
+      return c2;
+    };
     if (o.length === 0) {
       if (a.length !== 0) throw new Error("Assertion error.");
-      return u(new Set(ee));
-    }
-    let h = 0, d = 0;
-    for (; h < o.length; ) {
-      const p = /* @__PURE__ */ new Set();
-      n.includeNativeLabel && p.add(ee);
-      for (let f2 = 0; f2 < h; ++f2) p.add(o[f2]);
-      p.add(o[d]);
-      const g = u(p);
-      if (new Set(g.map((f2) => f2.label)).size === t.length) return g;
-      d++, d == o.length && (h++, d = h);
-    }
-    return u(/* @__PURE__ */ new Set([...o, ...a]));
+      const p2 = u2(new Set(ve));
+      if (p2 === void 0) throw new Error("Assertion error.");
+      return p2;
+    }
+    let S = 0, d = 0;
+    for (; S < o.length; ) {
+      const p2 = /* @__PURE__ */ new Set();
+      n2.includeNativeLabel && p2.add(ve);
+      for (let h = 0; h < S; ++h) p2.add(o[h]);
+      p2.add(o[d]);
+      const c2 = u2(p2);
+      if (c2 !== void 0 && new Set(c2.map((h) => h.label)).size === t.length) return c2;
+      d++, d >= o.length && (S++, d = S);
+    }
+    const f2 = u2(/* @__PURE__ */ new Set([...o, ...a]));
+    if (f2 === void 0) throw new Error("Assertion error.");
+    return f2;
+  }
+  const H = "PColumnData/", te = H + "ResourceMap", ne = H + "Partitioned/ResourceMap", U = H + "JsonPartitioned", V = H + "BinaryPartitioned", Fe = H + "Partitioned/", re = Fe + "JsonPartitioned", B = Fe + "BinaryPartitioned";
+  const fe = (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 lt(t) {
+    if (!t) return;
+    const e = t.resourceType.name, n2 = t.getDataAsJson(), r = [];
+    let i = 0;
+    switch (e) {
+      case te:
+        i = n2.keyLength;
+        break;
+      case ne:
+        i = n2.partitionKeyLength + n2.keyLength;
+        break;
+      case U:
+      case V:
+        i = n2.partitionKeyLength;
+        break;
+      case B:
+      case re:
+        i = n2.superPartitionKeyLength + n2.partitionKeyLength;
+        break;
+    }
+    switch (e) {
+      case te:
+      case U:
+      case V:
+        for (let s2 of t.listInputFields()) {
+          e === V && (s2 = fe(s2).baseKey);
+          const o = [...JSON.parse(s2)];
+          r.push(o);
+        }
+        break;
+      case ne:
+      case B:
+      case re:
+        for (const s2 of t.listInputFields()) {
+          const o = [...JSON.parse(s2)], a = t.resolve({ field: s2, assertFieldType: "Input" });
+          if (a !== void 0)
+            for (let l2 of a.listInputFields()) {
+              e === B && (l2 = fe(l2).baseKey);
+              const u2 = [...o, ...JSON.parse(l2)];
+              r.push(u2);
+            }
+        }
+        break;
+    }
+    return { data: r, keyLength: i };
   }
-  class De {
+  function ut(t) {
+    if (t.type !== "JsonPartitioned" && t.type !== "BinaryPartitioned")
+      throw new Error(`Splitting requires Partitioned DataInfoEntries, got ${t.type}`);
+    const { parts: e, partitionKeyLength: n2 } = t, r = [];
+    for (let i = 0; i < n2; ++i)
+      r.push(/* @__PURE__ */ new Set());
+    for (const i of e) {
+      const s2 = i.key;
+      if (s2.length !== n2)
+        throw new Error(
+          `Key length (${s2.length}) does not match partition length (${n2}) for key: ${JSON.stringify(
+            s2
+          )}`
+        );
+      for (let o = 0; o < n2; ++o)
+        r[o].add(s2[o]);
+    }
+    return r.map((i) => Array.from(i.values()));
+  }
+  function ct(t) {
+    if (t === void 0) return;
+    if (j(t))
+      return ut(t);
+    const e = lt(t);
+    if (!e) return;
+    const { data: n2, keyLength: r } = e, i = [];
+    for (let s2 = 0; s2 < r; ++s2)
+      i.push(/* @__PURE__ */ new Set());
+    for (const s2 of n2) {
+      if (s2.length !== r)
+        throw new Error("key length does not match partition length");
+      for (let o = 0; o < r; ++o)
+        i[o].add(s2[o]);
+    }
+    return i.map((s2) => Array.from(s2.values()));
+  }
+  function he(t, e = []) {
+    if (t === void 0 || !t.getIsReadyOrError()) return;
+    const n2 = t.resourceType.name, r = t.getDataAsJson();
+    if (e.length > 0 && (n2 === re || n2 === B))
+      throw new Error(`Unexpected nested super-partitioned resource: ${n2}`);
+    switch (n2) {
+      case te:
+      case ne:
+        throw new Error(`Only data columns are supported, got: ${n2}`);
+      case U: {
+        if (typeof (r == null ? void 0 : r.partitionKeyLength) != "number")
+          throw new Error(`Missing partitionKeyLength in metadata for ${n2}`);
+        const i = [];
+        for (const s2 of t.listInputFields()) {
+          const o = t.resolve({ field: s2, assertFieldType: "Input" });
+          if (o === void 0) return;
+          const a = [...e, ...JSON.parse(s2)];
+          i.push({ key: a, value: o });
+        }
+        return {
+          type: "JsonPartitioned",
+          partitionKeyLength: r.partitionKeyLength,
+          parts: i
+        };
+      }
+      case V: {
+        if (typeof (r == null ? void 0 : r.partitionKeyLength) != "number")
+          throw new Error(`Missing partitionKeyLength in metadata for ${n2}`);
+        const i = [], s2 = /* @__PURE__ */ new Map();
+        for (const o of t.listInputFields()) {
+          const a = fe(o), l2 = t.resolve({ field: o, assertFieldType: "Input" });
+          if (l2 === void 0) return;
+          let u2 = s2.get(a.baseKey);
+          u2 || (u2 = {}, s2.set(a.baseKey, u2)), a.type === "index" ? u2.index = l2 : u2.values = l2;
+        }
+        for (const [o, a] of s2.entries()) {
+          if (!a.index || !a.values) return;
+          const l2 = [...e, ...JSON.parse(o)];
+          i.push({
+            key: l2,
+            value: {
+              index: a.index,
+              values: a.values
+            }
+          });
+        }
+        return {
+          type: "BinaryPartitioned",
+          partitionKeyLength: r.partitionKeyLength,
+          parts: i
+        };
+      }
+      case re: {
+        if (typeof (r == null ? void 0 : r.superPartitionKeyLength) != "number" || typeof (r == null ? void 0 : r.partitionKeyLength) != "number")
+          throw new Error(`Missing superPartitionKeyLength or partitionKeyLength in metadata for ${n2}`);
+        const i = r.superPartitionKeyLength + r.partitionKeyLength, s2 = [];
+        for (const o of t.listInputFields()) {
+          const a = t.resolve({ field: o, assertFieldType: "Input" });
+          if (a === void 0) return;
+          if (a.resourceType.name !== U)
+            throw new Error(`Expected ${U} inside ${n2}, but got ${a.resourceType.name}`);
+          const l2 = he(a, JSON.parse(o));
+          if (l2 === void 0) return;
+          if (l2.type !== "JsonPartitioned")
+            throw new Error(`Unexpected inner result type for ${n2}: ${l2.type}`);
+          s2.push(...l2.parts);
+        }
+        return {
+          type: "JsonPartitioned",
+          partitionKeyLength: i,
+          parts: s2
+        };
+      }
+      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 ${n2}`);
+        const i = r.superPartitionKeyLength + r.partitionKeyLength, s2 = [];
+        for (const o of t.listInputFields()) {
+          const a = t.resolve({ field: o, assertFieldType: "Input" });
+          if (a === void 0) return;
+          if (a.resourceType.name !== V)
+            throw new Error(`Expected ${V} inside ${n2}, but got ${a.resourceType.name}`);
+          const l2 = he(a, JSON.parse(o));
+          if (l2 === void 0) return;
+          if (l2.type !== "BinaryPartitioned")
+            throw new Error(`Unexpected inner result type for ${n2}: ${l2.type}`);
+          s2.push(...l2.parts);
+        }
+        return {
+          type: "BinaryPartitioned",
+          partitionKeyLength: i,
+          parts: s2
+        };
+      }
+      default:
+        throw new Error(`Unknown resource type: ${n2}`);
+    }
+  }
+  function pt(t) {
+    if (t !== void 0) {
+      if (j(t)) return t;
+      if (pn(t)) return ln(t);
+      if (t instanceof _) return he(t);
+      throw new Error(`Unexpected input type: ${typeof t}`);
+    }
+  }
+  function dt(t, e) {
+    const n2 = [...e].sort((s2, o) => o[0] - s2[0]);
+    if (t.type === "JsonPartitioned" || t.type === "BinaryPartitioned") {
+      const { partitionKeyLength: s2 } = t;
+      for (const [o] of e)
+        if (o >= s2)
+          throw new Error(`Can't filter on non-partitioned axis ${o}. Must be >= ${s2}`);
+    } else if (t.type === "Json") {
+      const { keyLength: s2 } = t;
+      for (const [o] of e)
+        if (o >= s2)
+          throw new Error(`Can't filter on non-data axis ${o}. Must be >= ${s2}`);
+    }
+    const r = (s2) => {
+      for (const [o, a] of n2)
+        if (s2[o] !== a)
+          return false;
+      return true;
+    }, i = (s2) => {
+      const o = [...s2];
+      for (const [a] of n2)
+        o.splice(a, 1);
+      return o;
+    };
+    switch (t.type) {
+      case "Json": {
+        const s2 = t.data.filter((o) => r(o.key)).map((o) => ({
+          key: i(o.key),
+          value: o.value
+        }));
+        return {
+          type: "Json",
+          keyLength: t.keyLength - e.length,
+          data: s2
+        };
+      }
+      case "JsonPartitioned": {
+        const s2 = 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: s2
+        };
+      }
+      case "BinaryPartitioned": {
+        const s2 = 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: s2
+        };
+      }
+    }
+  }
+  class ft {
+    constructor(e) {
+      this.columns = e;
+    }
+    selectColumns(e) {
+      const n2 = typeof e == "function" ? e : Fn(e);
+      return this.columns.filter((r) => n2(r.spec));
+    }
+  }
+  function ht(t) {
+    if (t)
+      return t.map((e) => ({
+        type: `split:${En(e.axisId)}`,
+        label: e.label,
+        importance: 1e6
+        // High importance for split filters in labels
+      }));
+  }
+  function gt(t) {
+    if (t)
+      return t.map((e) => [e.axisIdx, e.value]);
+  }
+  function mt(t, e) {
+    if (!e || e.length === 0) return t;
+    const n2 = [...e].sort((r, i) => r[0] - i[0]);
+    return Pe({ id: t, axisFilters: n2 });
+  }
+  function yt(t) {
+    if (!t || typeof t != "object") return false;
+    const e = t, n2 = e.domain && typeof e.domain == "object" && Object.values(e.domain).some((i) => typeof i == "object" && i !== null && "anchor" in i), r = e.axes && Array.isArray(e.axes) && e.axes.some((i) => typeof i == "object" && i !== null && "anchor" in i);
+    return !!e.domainAnchor || n2 || r;
+  }
+  function vt(t) {
+    if (typeof t != "object" || !("axes" in t) || t.axes === void 0)
+      return [];
+    const e = t.axes.map((n2, r) => typeof n2 == "object" && "split" in n2 && n2.split === true ? r : -1).filter((n2) => n2 !== -1);
+    if (e.length > 0 && t.partialAxesMatch !== void 0)
+      throw new Error("Axis splitting is not supported when `partialAxesMatch` is defined.");
+    return e.sort((n2, r) => n2 - r), e;
+  }
+  class be {
     constructor() {
-      S(this, "ctx", c());
-      S(this, "defaultLabelFn", (e, n) => {
-        var r;
-        return ((r = e.annotations) == null ? void 0 : r["pl7.app/label"]) ?? "Unlabelled";
+      L(this, "defaultProviderStore", []);
+      L(this, "providers", [new ft(this.defaultProviderStore)]);
+      L(this, "axisLabelProviders", []);
+    }
+    addColumnProvider(e) {
+      return this.providers.push(e), this;
+    }
+    addAxisLabelProvider(e) {
+      return this.axisLabelProviders.push(e), this;
+    }
+    addColumns(e) {
+      return this.defaultProviderStore.push(...e), this;
+    }
+    addColumn(e) {
+      return this.defaultProviderStore.push(e), this;
+    }
+    /** Fetches labels for a given axis from the registered providers */
+    findLabels(e) {
+      for (const n2 of this.axisLabelProviders) {
+        const r = n2.findLabels(e);
+        if (r) return r;
+      }
+    }
+    getUniversalEntries(e, n2) {
+      const { anchorCtx: r, labelOps: i, dontWaitAllData: s2 = false, overrideLabelAnnotation: o = false } = n2 ?? {}, a = {
+        ...o && (i == null ? void 0 : i.includeNativeLabel) !== false ? { includeNativeLabel: true } : {},
+        ...i ?? {}
+      }, l2 = typeof e == "function" ? [e] : Array.isArray(e) ? e : [e], u2 = [];
+      for (const f$1 of l2) {
+        const p2 = yt(f$1);
+        let c2;
+        if (p2) {
+          if (!r)
+            throw new Error("Anchored selectors require an AnchoredIdDeriver to be provided in options.");
+          c2 = $n(r.anchors, f$1, n2);
+        } else
+          c2 = f$1;
+        const h = /* @__PURE__ */ new Set(), A2 = [];
+        for (const g of this.providers) {
+          const P = g.selectColumns(c2);
+          for (const b of P) {
+            if (h.has(b.id)) throw new Error(`Duplicate column id ${b.id} in provider ${g.constructor.name}`);
+            h.add(b.id), A2.push(b);
+          }
+        }
+        if (A2.length === 0) continue;
+        const y = vt(f$1), v = y.length > 0;
+        for (const g of A2) {
+          if (!f(g.spec)) continue;
+          const P = g.spec;
+          if (v) {
+            const b = pt(g.data);
+            if (!b) {
+              if (s2) continue;
+              return;
+            }
+            if (!yn(b))
+              throw new Error(`Splitting requires Partitioned DataInfoEntries, but parsing resulted in ${b.type} for column ${g.id}`);
+            const k2 = ct(b), $2 = y[y.length - 1];
+            if ($2 >= b.partitionKeyLength)
+              throw new Error(`Not enough partition keys (${b.partitionKeyLength}) for requested split axes (max index ${$2}) in column ${P.name}`);
+            const q = y.map((w2) => this.findLabels(p$1(P.axesSpec[w2]))), F = [], I = (w2, N2) => {
+              if (N2 >= y.length) {
+                if (F.push([...w2]), F.length > 1e4)
+                  throw new Error("Too many key combinations, aborting.");
+                return;
+              }
+              const D2 = y[N2];
+              if (D2 >= k2.length)
+                throw new Error(`Axis index ${D2} out of bounds for unique keys array (length ${k2.length}) during split key generation for column ${g.id}`);
+              const O = k2[D2];
+              if (!O || O.length === 0) {
+                F.length = 0;
+                return;
+              }
+              for (const z2 of O)
+                w2.push(z2), I(w2, N2 + 1), w2.pop();
+            };
+            if (I([], 0), F.length === 0)
+              continue;
+            const R = [...P.axesSpec], se = y.map((w2) => w2);
+            for (let w2 = y.length - 1; w2 >= 0; w2--)
+              R.splice(y[w2], 1);
+            const J = { ...P, axesSpec: R };
+            for (const w2 of F) {
+              const N2 = w2.map((D2, O) => {
+                const z2 = se[O], Re = p$1(P.axesSpec[z2]), oe = q[O], Oe = (oe == null ? void 0 : oe[D2]) ?? String(D2);
+                return { axisIdx: z2, axisId: Re, value: D2, label: Oe };
+              });
+              u2.push({
+                type: "split",
+                originalColumn: g,
+                spec: P,
+                adjustedSpec: J,
+                dataEntries: b,
+                axisFilters: N2
+              });
+            }
+          } else
+            u2.push({
+              type: "direct",
+              originalColumn: g,
+              spec: P,
+              adjustedSpec: P
+            });
+        }
+      }
+      if (u2.length === 0) return [];
+      const S = Ee(
+        u2,
+        (f2) => ({
+          spec: f2.spec,
+          suffixTrace: f2.type === "split" ? ht(f2.axisFilters) : void 0
+        }),
+        a
+      ), d = [];
+      for (const { value: f2, label: p2 } of S) {
+        const { originalColumn: c2, spec: h } = f2, A2 = f2.type === "split" ? f2.axisFilters : void 0, y = gt(A2);
+        let v;
+        r ? v = r.deriveS(h, y) : v = mt(c2.id, y);
+        let g = { ...f2.adjustedSpec };
+        o && (g = {
+          ...g,
+          annotations: {
+            ...g.annotations ?? {},
+            "pl7.app/label": p2
+          }
+        }), d.push({
+          id: v,
+          spec: g,
+          data: () => f2.type === "split" ? hn(dt(f2.dataEntries, y)) : f2.originalColumn.data,
+          label: p2
+        });
+      }
+      return d;
+    }
+    getColumns(e, n2) {
+      const r = this.getUniversalEntries(e, {
+        overrideLabelAnnotation: true,
+        // default for getColumns
+        ...n2 ?? {}
       });
+      if (!r) return;
+      const i = [];
+      for (const s2 of r) {
+        const o = s2.data();
+        if (!o) {
+          if (n2 != null && n2.dontWaitAllData) continue;
+          return;
+        }
+        i.push({
+          id: s2.id,
+          spec: s2.spec,
+          data: o
+        });
+      }
+      return i;
+    }
+  }
+  function le(t, e) {
+    if (t === void 0) return e === void 0;
+    if (e === void 0) return true;
+    for (const n2 in e)
+      if (t[n2] !== e[n2]) return false;
+    return true;
+  }
+  function we(t) {
+    return Bn(t, (e) => e instanceof _ ? e.handle : pn(e) ? mn(e, (n2) => n2.handle) : e);
+  }
+  class bt {
+    constructor() {
+      L(this, "ctx", m());
     }
     /**
      * @deprecated use getOptions()
@@ -4345,16 +5301,87 @@
     calculateOptions(e) {
       return this.ctx.calculateOptions(e);
     }
-    getOptions(e, n) {
-      const r = this.getSpecs().entries.filter((s) => e(s.obj));
-      return typeof n == "object" || typeof n > "u" ? Le(r, (s) => s.obj, n ?? {}).map(({ value: { ref: s }, label: i2 }) => ({
-        ref: s,
-        label: i2
-      })) : r.map((s) => ({
-        ref: s.ref,
-        label: n(s.obj, s.ref)
+    getOptions(e, n2) {
+      const r = typeof e == "function" ? e : Fn(e), i = this.getSpecs().entries.filter((s2) => r(s2.obj));
+      return typeof n2 == "object" || typeof n2 > "u" ? Ee(i, (s2) => s2.obj, n2 ?? {}).map(({ value: { ref: s2 }, label: o }) => ({
+        ref: s2,
+        label: o
+      })) : i.map((s2) => ({
+        ref: s2.ref,
+        label: n2(s2.obj, s2.ref)
       }));
     }
+    resolveAnchorCtx(e) {
+      if (e instanceof On) return e;
+      const n2 = {};
+      for (const [r, i] of Object.entries(e))
+        if (Rn(i)) {
+          const s2 = this.getPColumnSpecByRef(i);
+          if (!s2)
+            return;
+          n2[r] = s2;
+        } else
+          n2[r] = i;
+      return new On(n2);
+    }
+    /**
+     * 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, n2, r) {
+      const i = this.resolveAnchorCtx(e);
+      if (i)
+        return new be().addColumnProvider(this).addAxisLabelProvider(this).getColumns(n2, {
+          ...r,
+          anchorCtx: i
+        });
+    }
+    /**
+     * 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, n2, r) {
+      const i = this.resolveAnchorCtx(e);
+      if (!i) return;
+      const s2 = new be().addColumnProvider(this).addAxisLabelProvider(this).getUniversalEntries(n2, {
+        ...r,
+        anchorCtx: i
+      });
+      if (s2)
+        return s2.map((o) => ({
+          value: o.id,
+          label: o.label
+        }));
+    }
     /**
      * @deprecated use getData()
      */
@@ -4365,11 +5392,11 @@
       const e = this.ctx.getDataFromResultPool();
       return {
         isComplete: e.isComplete,
-        entries: e.entries.map((n) => ({
-          ref: n.ref,
+        entries: e.entries.map((n2) => ({
+          ref: n2.ref,
           obj: {
-            ...n.obj,
-            data: new v(n.obj.data, [n.ref.blockId, n.ref.name])
+            ...n2.obj,
+            data: new _(n2.obj.data, [n2.ref.blockId, n2.ref.name])
           }
         }))
       };
@@ -4384,13 +5411,13 @@
       const e = this.ctx.getDataWithErrorsFromResultPool();
       return {
         isComplete: e.isComplete,
-        entries: e.entries.map((n) => ({
-          ref: n.ref,
+        entries: e.entries.map((n2) => ({
+          ref: n2.ref,
           obj: {
-            ...n.obj,
-            data: mt(
-              n.obj.data,
-              (r) => new v(r, [n.ref.blockId, n.ref.name])
+            ...n2.obj,
+            data: _n(
+              n2.obj.data,
+              (r) => new _(r, [n2.ref.blockId, n2.ref.name])
             )
           }
         }))
@@ -4410,13 +5437,17 @@
      * @returns data associated with the ref
      */
     getDataByRef(e) {
-      var n;
-      return typeof this.ctx.getDataFromResultPoolByRef > "u" ? (n = this.getData().entries.find(
-        (r) => r.ref.blockId === e.blockId && r.ref.name === e.name
-      )) == null ? void 0 : n.obj : lt(
-        this.ctx.getDataFromResultPoolByRef(e.blockId, e.name),
-        (r) => new v(r, [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 n2 = this.ctx.getDataFromResultPoolByRef(e.blockId, e.name);
+      if (n2)
+        return Bn(
+          n2,
+          (i) => new _(i, [e.blockId, e.name])
+        );
     }
     /**
      * Returns data associated with the ref ensuring that it is a p-column.
@@ -4424,9 +5455,9 @@
      * @returns p-column associated with the ref
      */
     getPColumnByRef(e) {
-      const n = this.getDataByRef(e);
-      if (n)
-        return dt(n);
+      const n2 = this.getDataByRef(e);
+      if (n2)
+        return In(n2);
     }
     /**
      * Returns spec associated with the ref ensuring that it is a p-column spec.
@@ -4434,10 +5465,10 @@
      * @returns p-column spec associated with the ref
      */
     getPColumnSpecByRef(e) {
-      const n = this.getSpecByRef(e);
-      if (n) {
-        if (!i(n)) throw new Error(`not a PColumn spec (kind = ${n.kind})`);
-        return n;
+      const n2 = this.getSpecByRef(e);
+      if (n2) {
+        if (!f(n2)) throw new Error(`not a PColumn spec (kind = ${n2.kind})`);
+        return n2;
       }
     }
     /**
@@ -4445,10 +5476,7 @@
      * @returns object spec associated with the ref
      */
     getSpecByRef(e) {
-      var n;
-      return typeof this.ctx.getSpecFromResultPoolByRef > "u" ? (n = this.getSpecs().entries.find(
-        (r) => r.ref.blockId === e.blockId && r.ref.name === e.name
-      )) == null ? void 0 : n.obj : this.ctx.getSpecFromResultPoolByRef(e.blockId, e.name);
+      return this.ctx.getSpecFromResultPoolByRef(e.blockId, e.name);
     }
     /**
      * @param spec object specification
@@ -4456,38 +5484,89 @@
      * @deprecated delete this method after Jan 1, 2025
      */
     findDataWithCompatibleSpec(e) {
-      const n = [];
+      const n2 = [];
       e: for (const r of this.getData().entries) {
-        if (!i(r.obj.spec))
+        if (!f(r.obj.spec))
           continue;
-        const s = r.obj.spec;
-        if (e.name === s.name && e.valueType === s.valueType && e.axesSpec.length === s.axesSpec.length && z(e.domain, s.domain)) {
-          for (let i2 = 0; i2 < e.axesSpec.length; ++i2) {
-            const o = e.axesSpec[i2], a = s.axesSpec[i2];
-            if (o.name !== a.name || o.type !== a.type || !z(o.domain, a.domain))
+        const i = r.obj.spec;
+        if (e.name === i.name && e.valueType === i.valueType && e.axesSpec.length === i.axesSpec.length && le(e.domain, i.domain)) {
+          for (let s2 = 0; s2 < e.axesSpec.length; ++s2) {
+            const o = e.axesSpec[s2], a = i.axesSpec[s2];
+            if (o.name !== a.name || o.type !== a.type || !le(o.domain, a.domain))
               continue e;
           }
-          n.push(r.obj);
+          n2.push(r.obj);
         }
       }
-      return n;
+      return n2;
+    }
+    /**
+     * Find labels data for a given axis id. It will search for a label column and return its data as a map.
+     * @returns a map of axis value => label
+     */
+    findLabels(e) {
+      const n2 = this.getData();
+      for (const r of n2.entries) {
+        if (!Z$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 && le(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]])
+          );
+        }
+      }
+    }
+    /**
+     * Selects columns based on the provided selectors, returning PColumn objects
+     * with lazily loaded data.
+     *
+     * @param selectors - A predicate function, a single selector, or an array of selectors.
+     * @returns An array of PColumn objects matching the selectors. Data is loaded on first access.
+     */
+    selectColumns(e) {
+      const n2 = typeof e == "function" ? e : Fn(e);
+      return this.getSpecs().entries.filter(({ obj: i }) => f(i) ? n2(i) : false).map(({ ref: i, obj: s2 }) => {
+        const o = s2;
+        let a = null;
+        const l2 = this;
+        return {
+          id: Pe(i),
+          spec: o,
+          get data() {
+            var u2;
+            return a !== null || (a = (u2 = l2.getPColumnByRef(i)) == null ? void 0 : u2.data), a;
+          }
+        };
+      });
+    }
+    /**
+     * Find labels data for a given axis id of a p-column.
+     * @returns a map of axis value => label
+     */
+    findLabelsForColumnAxis(e, n2) {
+      var s2;
+      const r = this.findLabels(e.axesSpec[n2]);
+      if (!r) return;
+      const i = (s2 = e.annotations) == null ? void 0 : s2["pl7.app/axisKeys/" + n2];
+      if (i !== void 0) {
+        const o = JSON.parse(i);
+        return Object.fromEntries(o.map((a) => [a, r[a] ?? "Unlabelled"]));
+      } else
+        return r;
     }
   }
-  function z(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 X {
     constructor() {
-      S(this, "ctx");
-      S(this, "args");
-      S(this, "uiState");
-      S(this, "_activeArgsCache");
-      S(this, "resultPool", new De());
-      this.ctx = c(), this.args = JSON.parse(this.ctx.args), this.uiState = this.ctx.uiState !== void 0 ? JSON.parse(this.ctx.uiState) : {};
+      L(this, "ctx");
+      L(this, "args");
+      L(this, "uiState");
+      L(this, "_activeArgsCache");
+      L(this, "resultPool", new bt());
+      this.ctx = m(), 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).
@@ -4503,61 +5582,47 @@
     //   return this.ctx.featureFlags;
     // }
     getNamedAccessor(e) {
-      return H(
+      return pe(
         this.ctx.getAccessorHandleByName(e),
-        (n) => new v(n, [e])
+        (n2) => new _(n2, [e])
       );
     }
     get prerun() {
-      return this.getNamedAccessor(ae);
+      return this.getNamedAccessor(Ie);
     }
     get outputs() {
-      return this.getNamedAccessor(le);
+      return this.getNamedAccessor(Le);
     }
     /**
      * 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 r of n.entries) {
-        if (!W(r.obj)) continue;
-        const s = r.obj.spec;
-        if (s.name === "pl7.app/label" && s.axesSpec.length === 1 && s.axesSpec[0].name === e.name && s.axesSpec[0].type === e.type && z(e.domain, s.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]])
-          );
-        }
-      }
+      return this.resultPool.findLabels(e);
     }
-    verifyInlineColumnsSupport(e) {
-      var s;
-      const n = e.some((i2) => !(i2.data instanceof v)), r = ((s = this.ctx.featureFlags) == null ? void 0 : s.inlineColumnsSupport) === true;
-      if (n && !r) throw Error("inline columns not supported");
+    verifyInlineAndExplicitColumnsSupport(e) {
+      var i;
+      const n2 = e.some((s2) => !(s2.data instanceof _) || pn(s2.data)), r = ((i = this.ctx.featureFlags) == null ? void 0 : i.inlineColumnsSupport) === true;
+      if (n2 && !r) throw Error("Inline or explicit columns not supported");
     }
+    // TODO remove all non-PColumn fields
     createPFrame(e) {
-      return this.verifyInlineColumnsSupport(e), this.ctx.createPFrame(
-        e.map((n) => lt(n, (r) => r instanceof v ? r.handle : r))
+      return this.verifyInlineAndExplicitColumnsSupport(e), this.ctx.createPFrame(
+        e.map((n2) => we(n2))
       );
     }
     createPTable(e) {
-      var n;
-      return "columns" in e ? n = {
+      let n2;
+      return "columns" in e ? n2 = {
         src: {
           type: "full",
           entries: e.columns.map((r) => ({ type: "column", column: r }))
         },
         filters: e.filters ?? [],
         sorting: e.sorting ?? []
-      } : n = e, this.verifyInlineColumnsSupport(pt(n.src)), this.ctx.createPTable(
-        it(
-          n,
-          (r) => lt(r, (s) => s instanceof v ? s.handle : s)
-        )
+      } : n2 = e, this.verifyInlineAndExplicitColumnsSupport(jn(n2.src)), this.ctx.createPTable(
+        Cn(n2, (r) => we(r))
       );
     }
     /** @deprecated scheduled for removal from SDK */
@@ -4569,33 +5634,33 @@
         return this.ctx.getCurrentUnstableMarker();
     }
   }
-  const T = "1.22.97";
-  function Ve(t) {
+  const M = "1.29.2";
+  function wt(t) {
     return t.__renderLambda === true;
   }
-  function K(t) {
+  function ue(t) {
     if (t !== void 0)
-      return Ve(t) ? t.handle : t;
+      return wt(t) ? t.handle : t;
   }
-  class _ {
-    constructor(e, n, r, s, i2, o, a) {
-      this._renderingMode = e, this._initialArgs = n, this._initialUiState = r, this._outputs = s, this._inputsValid = i2, this._sections = o, this._title = a;
+  class T {
+    constructor(e, n2, r, i, s2, o, a) {
+      this._renderingMode = e, this._initialArgs = n2, this._initialUiState = r, this._outputs = i, this._inputsValid = s2, this._sections = o, this._title = a;
     }
     static create(e = "Heavy") {
-      return new _(
+      return new T(
         e,
         void 0,
         {},
         {},
-        j(true),
-        j([]),
+        Z(true),
+        Z([]),
         void 0
       );
     }
-    output(e, n, r = {}) {
-      if (typeof n == "function") {
-        const s = `output#${e}`;
-        return E(s, () => n(new V())), new _(
+    output(e, n2, r = {}) {
+      if (typeof n2 == "function") {
+        const i = `output#${e}`;
+        return Y(i, () => n2(new X())), new T(
           this._renderingMode,
           this._initialArgs,
           this._initialUiState,
@@ -4603,7 +5668,7 @@
             ...this._outputs,
             [e]: {
               __renderLambda: true,
-              handle: s,
+              handle: i,
               ...r
             }
           },
@@ -4612,13 +5677,13 @@
           this._title
         );
       } else
-        return new _(
+        return new T(
           this._renderingMode,
           this._initialArgs,
           this._initialUiState,
           {
             ...this._outputs,
-            [e]: n
+            [e]: n2
           },
           this._inputsValid,
           this._sections,
@@ -4626,11 +5691,11 @@
         );
     }
     /** Shortcut for {@link output} with retentive flag set to true. */
-    retentiveOutput(e, n) {
-      return this.output(e, n, { retentive: true });
+    retentiveOutput(e, n2) {
+      return this.output(e, n2, { retentive: true });
     }
     argsValid(e) {
-      return typeof e == "function" ? (E("inputsValid", () => e(new V())), new _(
+      return typeof e == "function" ? (Y("inputsValid", () => e(new X())), new T(
         this._renderingMode,
         this._initialArgs,
         this._initialUiState,
@@ -4641,7 +5706,7 @@
         },
         this._sections,
         this._title
-      )) : new _(
+      )) : new T(
         this._renderingMode,
         this._initialArgs,
         this._initialUiState,
@@ -4652,7 +5717,7 @@
       );
     }
     sections(e) {
-      return Array.isArray(e) ? this.sections(j(e)) : typeof e == "function" ? (E("sections", () => e(new V())), new _(
+      return Array.isArray(e) ? this.sections(Z(e)) : typeof e == "function" ? (Y("sections", () => e(new X())), new T(
         this._renderingMode,
         this._initialArgs,
         this._initialUiState,
@@ -4660,7 +5725,7 @@
         this._inputsValid,
         { __renderLambda: true, handle: "sections" },
         this._title
-      )) : new _(
+      )) : new T(
         this._renderingMode,
         this._initialArgs,
         this._initialUiState,
@@ -4672,7 +5737,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 _(
+      return Y("title", () => e(new X())), new T(
         this._renderingMode,
         this._initialArgs,
         this._initialUiState,
@@ -4687,7 +5752,7 @@
      * @deprecated use {@link withArgs}
      * */
     initialArgs(e) {
-      return new _(
+      return new T(
         this._renderingMode,
         e,
         this._initialUiState,
@@ -4699,7 +5764,7 @@
     }
     /** Sets initial args for the block, this value must be specified. */
     withArgs(e) {
-      return new _(
+      return new T(
         this._renderingMode,
         e,
         this._initialUiState,
@@ -4711,7 +5776,7 @@
     }
     /** Defines type and sets initial value for block UiState. */
     withUiState(e) {
-      return new _(
+      return new T(
         this._renderingMode,
         this._initialArgs,
         e,
@@ -4728,7 +5793,7 @@
       if (this._initialArgs === void 0) throw new Error("Initial arguments not set.");
       const e = {
         v3: {
-          sdkVersion: T,
+          sdkVersion: M,
           renderingMode: this._renderingMode,
           initialArgs: this._initialArgs,
           initialUiState: this._initialUiState,
@@ -4738,19 +5803,19 @@
           outputs: this._outputs
         },
         // fields below are added to allow previous desktop versions read generated configs
-        sdkVersion: T,
+        sdkVersion: M,
         renderingMode: this._renderingMode,
         initialArgs: this._initialArgs,
-        inputsValid: K(this._inputsValid),
-        sections: K(this._sections),
+        inputsValid: ue(this._inputsValid),
+        sections: ue(this._sections),
         outputs: Object.fromEntries(
-          Object.entries(this._outputs).map(([n, r]) => [n, K(r)])
+          Object.entries(this._outputs).map(([n2, r]) => [n2, ue(r)])
         )
       };
-      return Ae() ? oe({ sdkVersion: T }) : { config: e };
+      return Xe() ? _e({ sdkVersion: M }) : { config: e };
     }
   }
-  const model = _.create().withArgs({
+  const model = T.create().withArgs({
     // a fake product key so our mnz client response with a fake response without changing prod db.
     productKey: "MIFAKEMIFAKEMIFAKE",
     inputHandles: [],
@@ -4758,6 +5823,8 @@
     __mnzDate: (/* @__PURE__ */ new Date()).toISOString(),
     // It's OK
     __mnzCanRun: false
+  }).argsValid((ctx) => {
+    return ctx.args.__mnzCanRun;
   }).output("__mnzInfo", (ctx) => {
     var _a, _b;
     return (_b = (_a = ctx.prerun) == null ? void 0 : _a.resolve("info")) == null ? void 0 : _b.getDataAsJson();
@@ -4766,13 +5833,13 @@
     return (_b = (_a = ctx.outputs) == null ? void 0 : _a.resolve("token")) == null ? void 0 : _b.getDataAsString();
   }).output("progresses", (ctx) => {
     var _a;
-    const m = (_a = ctx.prerun) == null ? void 0 : _a.resolve("progresses");
-    const progresses = m == null ? void 0 : m.mapFields((name, val) => [name, val == null ? void 0 : val.getImportProgress()]);
+    const m2 = (_a = ctx.prerun) == null ? void 0 : _a.resolve("progresses");
+    const progresses = m2 == null ? void 0 : m2.mapFields((name, val) => [name, val == null ? void 0 : val.getImportProgress()]);
     return Object.fromEntries(progresses ?? []);
   }).output("mainProgresses", (ctx) => {
     var _a;
-    const m = (_a = ctx.outputs) == null ? void 0 : _a.resolve("progresses");
-    const progresses = m == null ? void 0 : m.mapFields((name, val) => [name, val == null ? void 0 : val.getImportProgress()]);
+    const m2 = (_a = ctx.outputs) == null ? void 0 : _a.resolve("progresses");
+    const progresses = m2 == null ? void 0 : m2.mapFields((name, val) => [name, val == null ? void 0 : val.getImportProgress()]);
     return Object.fromEntries(progresses ?? []);
   }).sections((_2) => [{ type: "link", href: "/", label: "Main" }]).done();
   exports2.model = model;