@milaboratories/pl-model-common 1.15.8 → 1.16.0

package/dist/index.mjs

@@ -1,319 +1,401 @@
-var B = Object.defineProperty;
-var j = (n, e, t) => e in n ? B(n, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : n[e] = t;
-var l = (n, e, t) => j(n, typeof e != "symbol" ? e + "" : e, t);
-import { z as d } from "zod";
-import y from "canonicalize";
-const wn = d.object({
+var D = Object.defineProperty;
+var L = (e, n, t) => n in e ? D(e, n, { enumerable: !0, configurable: !0, writable: !0, value: t }) : e[n] = t;
+var l = (e, n, t) => L(e, typeof n != "symbol" ? n + "" : n, t);
+import { z as p } from "zod";
+import h from "canonicalize";
+function ke(e) {
+  if (e.code !== void 0)
+    return {
+      code: e.code,
+      sdkVersion: e.sdkVersion,
+      featureFlags: e.featureFlags
+    };
+}
+function m(e) {
+  if (e !== void 0)
+    return typeof e == "string" ? { __renderLambda: !0, handle: e, retentive: !1 } : e;
+}
+function xe(e) {
+  if (e.v3 !== void 0) {
+    const {
+      initialArgs: n,
+      initialUiState: t,
+      inputsValid: r,
+      outputs: o,
+      renderingMode: i,
+      sdkVersion: a,
+      featureFlags: s,
+      sections: u,
+      title: c,
+      enrichmentTargets: f
+    } = e.v3, { code: R } = e;
+    return {
+      initialArgs: n,
+      initialUiState: t,
+      inputsValid: r,
+      outputs: o,
+      renderingMode: i,
+      sdkVersion: a,
+      featureFlags: s,
+      sections: u,
+      title: c,
+      code: R,
+      enrichmentTargets: f
+    };
+  } else if (e.inputsValid !== void 0) {
+    const { sdkVersion: n, renderingMode: t, outputs: r, inputsValid: o, sections: i, initialArgs: a, code: s } = e, u = Object.keys(e);
+    if (n === void 0 || t === void 0 || r === void 0 || o === void 0 || i === void 0 || a === void 0)
+      throw new Error(
+        `Malformed config v2. SDK version ${n}; Fields = ${u.join(", ")}`
+      );
+    return {
+      sdkVersion: n,
+      renderingMode: t,
+      initialArgs: a,
+      outputs: Object.fromEntries(
+        Object.entries(r).map(([c, f]) => [c, m(f)])
+      ),
+      inputsValid: m(o),
+      sections: m(i),
+      initialUiState: void 0,
+      code: s
+    };
+  } else if (e.renderingMode !== void 0) {
+    const { sdkVersion: n, canRun: t, renderingMode: r, outputs: o, sections: i, initialArgs: a, code: s } = e, u = Object.keys(e);
+    if (r === void 0 || o === void 0 || t === void 0 || i === void 0 || a === void 0)
+      throw new Error(
+        `Malformed config v1. SDK version ${n}; Fields = ${u.join(", ")}`
+      );
+    return {
+      sdkVersion: n ?? "unknown",
+      renderingMode: r,
+      initialArgs: a,
+      outputs: Object.fromEntries(
+        Object.entries(o).map(([c, f]) => [c, m(f)])
+      ),
+      inputsValid: m(t),
+      sections: m(i),
+      initialUiState: void 0,
+      code: s
+    };
+  } else {
+    const { sdkVersion: n } = e, t = Object.keys(e);
+    throw new Error(
+      `Config format not supported: SDK = ${n}; Fields = ${t.join(", ")}`
+    );
+  }
+}
+const Pe = p.object({
   /** Included left border. */
-  from: d.number(),
+  from: p.number(),
   /** Excluded right border. */
-  to: d.number()
+  to: p.number()
 });
-function An(n, e) {
-  if (!(n == null || e == null))
-    return { from: n, to: e };
-}
-function xn(n, e) {
-  if (n.from < 0 || n.to < 0 || n.from >= n.to)
-    throw new Error(`${e}: invalid bytes range: ${n}`);
-}
-function Pn(n) {
-  return n !== void 0 && n.startsWith("log+live://log/");
-}
-function w(n) {
-  throw new Error("Unexpected object: " + n);
-}
-const S = "upload://upload/", C = "index://index/";
-function v(n) {
-  return n.startsWith(S);
-}
-function F(n) {
-  return n.startsWith(C);
-}
-function R(n) {
-  if (F(n)) {
-    const e = n.slice(C.length);
-    return JSON.parse(decodeURIComponent(e)).path;
-  } else if (v(n)) {
-    const e = n.slice(S.length);
-    return JSON.parse(decodeURIComponent(e)).localPath;
+function Ee(e, n) {
+  if (!(e == null || n == null))
+    return { from: e, to: n };
+}
+function Se(e, n) {
+  if (e.from < 0 || e.to < 0 || e.from >= e.to)
+    throw new Error(`${n}: invalid bytes range: ${e}`);
+}
+function ve(e) {
+  return e !== void 0 && e.startsWith("log+live://log/");
+}
+function A(e) {
+  throw new Error("Unexpected object: " + e);
+}
+const N = "upload://upload/", O = "index://index/";
+function B(e) {
+  return e.startsWith(N);
+}
+function U(e) {
+  return e.startsWith(O);
+}
+function K(e) {
+  if (U(e)) {
+    const n = e.slice(O.length);
+    return JSON.parse(decodeURIComponent(n)).path;
+  } else if (B(e)) {
+    const n = e.slice(N.length);
+    return JSON.parse(decodeURIComponent(n)).localPath;
   }
-  w(n);
+  A(e);
 }
-function U(n) {
-  return n.replace(/^.*[\\/]/, "");
+function M(e) {
+  return e.replace(/^.*[\\/]/, "");
 }
-function kn(n) {
-  return U(R(n));
+function Ne(e) {
+  return M(K(e));
 }
-function En(n) {
-  if (!n || typeof n != "object")
+function Oe(e) {
+  if (!e || typeof e != "object")
     return !1;
-  const e = n;
-  if (!("type" in e))
+  const n = e;
+  if (!("type" in n))
     return !1;
-  switch (e.type) {
+  switch (n.type) {
     case "Json":
-      return typeof e.keyLength == "number" && e.data !== void 0 && typeof e.data == "object";
+      return typeof n.keyLength == "number" && n.data !== void 0 && typeof n.data == "object";
     case "JsonPartitioned":
-      return typeof e.partitionKeyLength == "number" && e.parts !== void 0 && typeof e.parts == "object";
+      return typeof n.partitionKeyLength == "number" && n.parts !== void 0 && typeof n.parts == "object";
     case "BinaryPartitioned":
-      return typeof e.partitionKeyLength == "number" && e.parts !== void 0 && typeof e.parts == "object";
+      return typeof n.partitionKeyLength == "number" && n.parts !== void 0 && typeof n.parts == "object";
     default:
       return !1;
   }
 }
-function Nn(n, e) {
-  if (n !== void 0)
-    switch (n.type) {
+function Ce(e, n) {
+  if (e !== void 0)
+    switch (e.type) {
       case "Json":
-        return n;
+        return e;
       case "JsonPartitioned": {
         const t = {};
-        for (const [r, o] of Object.entries(n.parts))
-          t[r] = e(o);
+        for (const [r, o] of Object.entries(e.parts))
+          t[r] = n(o);
         return {
-          ...n,
+          ...e,
           parts: t
         };
       }
       case "BinaryPartitioned": {
         const t = {};
-        for (const [r, o] of Object.entries(n.parts))
+        for (const [r, o] of Object.entries(e.parts))
           t[r] = {
-            index: e(o.index),
-            values: e(o.values)
+            index: n(o.index),
+            values: n(o.values)
           };
         return {
-          ...n,
+          ...e,
           parts: t
         };
       }
     }
 }
-function K(n) {
-  if (!n || typeof n != "object")
+function _(e) {
+  if (!e || typeof e != "object")
     return !1;
-  const e = n;
-  if (!("type" in e))
+  const n = e;
+  if (!("type" in n))
     return !1;
-  switch (e.type) {
+  switch (n.type) {
     case "Json":
-      return typeof e.keyLength == "number" && Array.isArray(e.data);
+      return typeof n.keyLength == "number" && Array.isArray(n.data);
     case "JsonPartitioned":
-      return typeof e.partitionKeyLength == "number" && Array.isArray(e.parts);
+      return typeof n.partitionKeyLength == "number" && Array.isArray(n.parts);
     case "BinaryPartitioned":
-      return typeof e.partitionKeyLength == "number" && Array.isArray(e.parts);
+      return typeof n.partitionKeyLength == "number" && Array.isArray(n.parts);
     default:
       return !1;
   }
 }
-function Sn(n) {
-  return K(n) ? n.type === "JsonPartitioned" || n.type === "BinaryPartitioned" : !1;
+function $e(e) {
+  return _(e) ? e.type === "JsonPartitioned" || e.type === "BinaryPartitioned" : !1;
 }
-function Cn(n) {
-  switch (n.type) {
+function Ve(e) {
+  switch (e.type) {
     case "Json": {
-      const e = Object.entries(n.data).map(([t, r]) => ({ key: JSON.parse(t), value: r }));
+      const n = Object.entries(e.data).map(([t, r]) => ({ key: JSON.parse(t), value: r }));
       return {
         type: "Json",
-        keyLength: n.keyLength,
-        data: e
+        keyLength: e.keyLength,
+        data: n
       };
     }
     case "JsonPartitioned": {
-      const e = Object.entries(n.parts).map(([t, r]) => ({ key: JSON.parse(t), value: r }));
+      const n = Object.entries(e.parts).map(([t, r]) => ({ key: JSON.parse(t), value: r }));
       return {
         type: "JsonPartitioned",
-        partitionKeyLength: n.partitionKeyLength,
-        parts: e
+        partitionKeyLength: e.partitionKeyLength,
+        parts: n
       };
     }
     case "BinaryPartitioned": {
-      const e = Object.entries(n.parts).map(([t, r]) => ({ key: JSON.parse(t), value: r }));
+      const n = Object.entries(e.parts).map(([t, r]) => ({ key: JSON.parse(t), value: r }));
       return {
         type: "BinaryPartitioned",
-        partitionKeyLength: n.partitionKeyLength,
-        parts: e
+        partitionKeyLength: e.partitionKeyLength,
+        parts: n
       };
     }
   }
 }
-function Jn(n) {
-  switch (n.type) {
+function Ie(e) {
+  switch (e.type) {
     case "Json": {
-      const e = {};
-      for (const t of n.data)
-        e[JSON.stringify(t.key)] = t.value;
+      const n = {};
+      for (const t of e.data)
+        n[JSON.stringify(t.key)] = t.value;
       return {
         type: "Json",
-        keyLength: n.keyLength,
-        data: e
+        keyLength: e.keyLength,
+        data: n
       };
     }
     case "JsonPartitioned": {
-      const e = {};
-      for (const t of n.parts)
-        e[JSON.stringify(t.key)] = t.value;
+      const n = {};
+      for (const t of e.parts)
+        n[JSON.stringify(t.key)] = t.value;
       return {
         type: "JsonPartitioned",
-        partitionKeyLength: n.partitionKeyLength,
-        parts: e
+        partitionKeyLength: e.partitionKeyLength,
+        parts: n
       };
     }
     case "BinaryPartitioned": {
-      const e = {};
-      for (const t of n.parts)
-        e[JSON.stringify(t.key)] = t.value;
+      const n = {};
+      for (const t of e.parts)
+        n[JSON.stringify(t.key)] = t.value;
       return {
         type: "BinaryPartitioned",
-        partitionKeyLength: n.partitionKeyLength,
-        parts: e
+        partitionKeyLength: e.partitionKeyLength,
+        parts: n
       };
     }
   }
 }
-function On(n, e) {
-  if (n !== void 0)
-    switch (n.type) {
+function je(e, n) {
+  if (e !== void 0)
+    switch (e.type) {
       case "Json":
-        return n;
+        return e;
       case "JsonPartitioned": {
-        const t = n.parts.map((r) => ({
+        const t = e.parts.map((r) => ({
           key: r.key,
-          value: e(r.value)
+          value: n(r.value)
         }));
         return {
-          ...n,
+          ...e,
           parts: t
         };
       }
       case "BinaryPartitioned": {
-        const t = n.parts.map((r) => ({
+        const t = e.parts.map((r) => ({
           key: r.key,
           value: {
-            index: e(r.value.index),
-            values: e(r.value.values)
+            index: n(r.value.index),
+            values: n(r.value.values)
           }
         }));
         return {
-          ...n,
+          ...e,
           parts: t
         };
       }
     }
 }
-const _ = -2147483648, x = -9007199254740991n, $n = NaN, In = NaN, M = null, T = null;
-function g(n, e) {
-  switch (e) {
+const q = -2147483648, x = -9007199254740991n, Fe = NaN, Je = NaN, T = null, z = null;
+function b(e, n) {
+  switch (n) {
     case "Int":
-      return n === _;
+      return e === q;
     case "Long":
-      return n === Number(x) || n === x;
+      return e === Number(x) || e === x;
     case "Float":
-      return Number.isNaN(n);
+      return Number.isNaN(e);
     case "Double":
-      return Number.isNaN(n);
+      return Number.isNaN(e);
     case "String":
-      return n === M;
+      return e === T;
     case "Bytes":
-      return n === T;
+      return e === z;
     default:
-      throw Error(`unsupported data type: ${e}`);
+      throw Error(`unsupported data type: ${n}`);
   }
 }
-function Vn(n) {
-  if (!z(n)) throw new Error(`Expected not-NA PValue, got ${n}`);
-  return n;
+function Re(e) {
+  if (!H(e)) throw new Error(`Expected not-NA PValue, got ${e}`);
+  return e;
 }
-function z(n, e) {
-  if (!e)
-    return typeof n == "string" || typeof n == "number" && isFinite(n) || typeof n == "bigint";
-  if (g(n, e)) return !1;
-  switch (e) {
+function H(e, n) {
+  if (!n)
+    return typeof e == "string" || typeof e == "number" && isFinite(e) || typeof e == "bigint";
+  if (b(e, n)) return !1;
+  switch (n) {
     case "Int":
-      return typeof n == "number";
+      return typeof e == "number";
     case "Long":
-      return typeof n == "number" || typeof n == "bigint";
+      return typeof e == "number" || typeof e == "bigint";
     case "Float":
-      return typeof n == "number";
+      return typeof e == "number";
     case "Double":
-      return typeof n == "number";
+      return typeof e == "number";
     case "String":
-      return typeof n == "string";
+      return typeof e == "string";
     case "Bytes":
       throw Error("Bytes not yet supported");
     default:
-      throw Error(`unsupported data type: ${e}`);
+      throw Error(`unsupported data type: ${n}`);
   }
 }
-function H(n, e) {
-  if (!e)
-    return n === null || typeof n == "string" || typeof n == "number" || typeof n == "bigint";
-  if (g(n, e)) return !0;
-  switch (e) {
+function W(e, n) {
+  if (!n)
+    return e === null || typeof e == "string" || typeof e == "number" || typeof e == "bigint";
+  if (b(e, n)) return !0;
+  switch (n) {
     case "Int":
-      return typeof n == "number";
+      return typeof e == "number";
     case "Long":
-      return typeof n == "number" || typeof n == "bigint";
+      return typeof e == "number" || typeof e == "bigint";
     case "Float":
-      return typeof n == "number";
+      return typeof e == "number";
     case "Double":
-      return typeof n == "number";
+      return typeof e == "number";
     case "String":
-      return typeof n == "string";
+      return typeof e == "string";
     case "Bytes":
       throw Error("Bytes not yet supported");
     default:
-      throw Error(`unsupported data type: ${e}`);
+      throw Error(`unsupported data type: ${n}`);
   }
 }
-function Dn(n) {
-  if (n === null || typeof n == "string" || typeof n == "number") return n;
-  if (typeof n == "bigint") return { bigint: n.toString() };
-  throw new Error(`Type ${typeof n} (value ${n}) not yet supported.`);
+function De(e) {
+  if (e === null || typeof e == "string" || typeof e == "number") return e;
+  if (typeof e == "bigint") return { bigint: e.toString() };
+  throw new Error(`Type ${typeof e} (value ${e}) not yet supported.`);
 }
-function q(n, e) {
-  if (n === null || typeof n == "string" || typeof n == "number" || typeof n == "bigint") {
-    if (e && !g(n, e) && !H(n, e))
-      throw new Error(`Unexpected value type, got ${typeof n}, expected ${e}`);
-    return n;
+function G(e, n) {
+  if (e === null || typeof e == "string" || typeof e == "number" || typeof e == "bigint") {
+    if (n && !b(e, n) && !W(e, n))
+      throw new Error(`Unexpected value type, got ${typeof e}, expected ${n}`);
+    return e;
   }
-  if (typeof n == "object" && n !== null && "bigint" in n && typeof n.bigint == "string") {
-    if (e && e !== "Long")
-      throw new Error(`Unexpected value type, got serialized bigint, expected ${e}`);
-    return BigInt(n.bigint);
+  if (typeof e == "object" && e !== null && "bigint" in e && typeof e.bigint == "string") {
+    if (n && n !== "Long")
+      throw new Error(`Unexpected value type, got serialized bigint, expected ${n}`);
+    return BigInt(e.bigint);
   }
-  throw new Error(`Unsupported type ${typeof n} (value ${n}).`);
+  throw new Error(`Unsupported type ${typeof e} (value ${e}).`);
 }
-function Ln(n) {
-  if (n = W(n), n === null) throw new Error("Value is null");
-  return n;
+function Le(e) {
+  if (e = X(e), e === null) throw new Error("Value is null");
+  return e;
 }
-function W(n) {
-  if (n = q(n), n === null) return null;
-  if (typeof n == "string") return n;
-  if (typeof n == "number") {
-    if (!isFinite(n)) throw new Error(`Value is not finite (${n})`);
-    return n;
+function X(e) {
+  if (e = G(e), e === null) return null;
+  if (typeof e == "string") return e;
+  if (typeof e == "number") {
+    if (!isFinite(e)) throw new Error(`Value is not finite (${e})`);
+    return e;
   }
-  if (typeof n == "bigint")
-    return Number(n);
-  throw new Error(`Unexpected value type: ${typeof n}`);
-}
-function X(n, e) {
-  const t = Math.floor(e / 8), r = 1 << 7 - e % 8;
-  return (n[t] & r) > 0;
-}
-const G = { type: "absent" }, Q = null;
-function Bn(n) {
-  return typeof n == "object" && n !== null && n.type === "absent";
-}
-function jn(n, e, t = {}) {
-  if (X(n.absent, e))
-    return t.absent === void 0 ? G : t.absent;
-  const r = n.data[e], o = n.type;
-  if (g(r, o)) return t.na === void 0 ? Q : t.na;
+  if (typeof e == "bigint")
+    return Number(e);
+  throw new Error(`Unexpected value type: ${typeof e}`);
+}
+function Q(e, n) {
+  const t = Math.floor(n / 8), r = 1 << 7 - n % 8;
+  return (e[t] & r) > 0;
+}
+const Y = { type: "absent" }, Z = null;
+function Be(e) {
+  return typeof e == "object" && e !== null && e.type === "absent";
+}
+function Ue(e, n, t = {}) {
+  if (Q(e.absent, n))
+    return t.absent === void 0 ? Y : t.absent;
+  const r = e.data[n], o = e.type;
+  if (b(r, o)) return t.na === void 0 ? Z : t.na;
   switch (o) {
     case "Int":
       return r;
@@ -331,95 +413,109 @@ function jn(n, e, t = {}) {
       throw Error(`unsupported data type: ${o}`);
   }
 }
-function vn(n) {
+function Ke(e) {
   return {
-    kind: n.kind,
-    valueType: n.valueType,
-    name: n.name,
-    domain: n.domain,
-    parentAxes: n.parentAxes,
-    axesId: J(n.axesSpec)
+    kind: e.kind,
+    valueType: e.valueType,
+    name: e.name,
+    domain: e.domain,
+    parentAxes: e.parentAxes,
+    axesId: C(e.axesSpec)
   };
 }
-function Fn(n) {
+function Me(e) {
   return {
-    columnId: n.id,
-    spec: n.spec
+    columnId: e.id,
+    spec: e.spec
   };
 }
-function p(n) {
-  const { type: e, name: t, domain: r } = n, o = { type: e, name: t };
+function y(e) {
+  const { type: n, name: t, domain: r } = e, o = { type: n, name: t };
   return r && Object.entries(r).length > 0 && Object.assign(o, { domain: r }), o;
 }
-function J(n) {
-  return n.map(p);
+function C(e) {
+  return e.map(y);
 }
-function Rn(n) {
-  return y(p(n));
+function _e(e) {
+  return h(y(e));
 }
-function Y(n, e) {
-  if (n === void 0) return e === void 0;
-  if (e === void 0) return !0;
-  for (const t in e)
-    if (n[t] !== e[t]) return !1;
+function ee(e, n) {
+  if (e === void 0) return n === void 0;
+  if (n === void 0) return !0;
+  for (const t in n)
+    if (e[t] !== n[t]) return !1;
   return !0;
 }
-function Z(n, e) {
-  return n.name === e.name && Y(n.domain, e.domain);
+function ne(e, n) {
+  return e.name === n.name && ee(e.domain, n.domain);
 }
-function Un(n, e) {
-  return { ...n, src: h(n.src, e) };
+function qe(e, n) {
+  return { ...e, src: g(e.src, n) };
 }
-function h(n, e) {
-  switch (n.type) {
+function g(e, n) {
+  switch (e.type) {
     case "column":
       return {
         type: "column",
-        column: e(n.column)
+        column: n(e.column)
       };
     case "slicedColumn":
       return {
         type: "slicedColumn",
-        column: e(n.column),
-        newId: n.newId,
-        axisFilters: n.axisFilters
+        column: n(e.column),
+        newId: e.newId,
+        axisFilters: e.axisFilters
       };
     case "inlineColumn":
-      return n;
+      return e;
     case "inner":
     case "full":
       return {
-        type: n.type,
-        entries: n.entries.map((t) => h(t, e))
+        type: e.type,
+        entries: e.entries.map((t) => g(t, n))
       };
     case "outer":
       return {
         type: "outer",
-        primary: h(n.primary, e),
-        secondary: n.secondary.map((t) => h(t, e))
+        primary: g(e.primary, n),
+        secondary: e.secondary.map((t) => g(t, n))
       };
     default:
-      w(n);
+      A(e);
+  }
+}
+function Te(e) {
+  switch (e.type) {
+    case "axis":
+      return {
+        type: "axis",
+        id: e.id
+      };
+    case "column":
+      return {
+        type: "column",
+        id: e.id
+      };
   }
 }
-function nn(n) {
-  return y(n);
+function te(e) {
+  return h(e);
 }
-function Kn(n) {
-  return JSON.parse(n);
+function ze(e) {
+  return JSON.parse(e);
 }
-function P(n) {
-  return y(p(n));
+function P(e) {
+  return h(y(e));
 }
-function k(n, e) {
-  return JSON.stringify([n, e]);
+function E(e, n) {
+  return JSON.stringify([e, n]);
 }
-class _n {
+class He {
   /**
    * Creates a new anchor context from a set of anchor column specifications
    * @param anchors Record of anchor column specifications indexed by anchor ID
    */
-  constructor(e) {
+  constructor(n) {
     l(this, "domains", /* @__PURE__ */ new Map());
     l(this, "axes", /* @__PURE__ */ new Map());
     /**
@@ -431,19 +527,19 @@ class _n {
      * Maps domain packs to anchors
      */
     l(this, "domainPackToAnchor", /* @__PURE__ */ new Map());
-    this.anchors = e;
-    const t = Object.entries(e);
+    this.anchors = n;
+    const t = Object.entries(n);
     t.sort((r, o) => r[0].localeCompare(o[0]));
     for (const [r, o] of t) {
-      for (let s = 0; s < o.axesSpec.length; s++) {
-        const a = o.axesSpec[s], i = P(a);
-        this.axes.set(i, { anchor: r, idx: s });
+      for (let i = 0; i < o.axesSpec.length; i++) {
+        const a = o.axesSpec[i], s = P(a);
+        this.axes.set(s, { anchor: r, idx: i });
       }
       if (o.domain !== void 0) {
-        const s = Object.entries(o.domain);
-        s.sort((a, i) => a[0].localeCompare(i[0])), this.domainPackToAnchor.set(JSON.stringify(s), r), this.domainPacks.push(s.map(([a]) => a));
-        for (const [a, i] of s) {
-          const u = k(a, i);
+        const i = Object.entries(o.domain);
+        i.sort((a, s) => a[0].localeCompare(s[0])), this.domainPackToAnchor.set(JSON.stringify(i), r), this.domainPacks.push(i.map(([a]) => a));
+        for (const [a, s] of i) {
+          const u = E(a, s);
           this.domains.set(u, r);
         }
       }
@@ -452,57 +548,57 @@ class _n {
   /**
    * Implementation of derive method
    */
-  derive(e, t) {
+  derive(n, t) {
     const r = {
-      name: e.name,
+      name: n.name,
       axes: []
     };
     let o;
-    if (e.domain !== void 0)
-      n:
+    if (n.domain !== void 0)
+      e:
         for (const a of this.domainPacks) {
-          const i = [];
+          const s = [];
           for (const c of a) {
-            const m = e.domain[c];
-            if (m !== void 0)
-              i.push([c, m]);
+            const f = n.domain[c];
+            if (f !== void 0)
+              s.push([c, f]);
             else
-              break n;
+              break e;
           }
-          const u = this.domainPackToAnchor.get(JSON.stringify(i));
+          const u = this.domainPackToAnchor.get(JSON.stringify(s));
           if (u !== void 0) {
             r.domainAnchor = u, o = new Set(a);
             break;
           }
         }
-    for (const [a, i] of Object.entries(e.domain ?? {})) {
+    for (const [a, s] of Object.entries(n.domain ?? {})) {
       if (o !== void 0 && o.has(a))
         continue;
-      const u = k(a, i), c = this.domains.get(u);
-      r.domain ?? (r.domain = {}), r.domain[a] = c ? { anchor: c } : i;
+      const u = E(a, s), c = this.domains.get(u);
+      r.domain ?? (r.domain = {}), r.domain[a] = c ? { anchor: c } : s;
     }
-    if (r.axes = e.axesSpec.map((a) => {
-      const i = P(a), u = this.axes.get(i);
-      return u === void 0 ? p(a) : u;
+    if (r.axes = n.axesSpec.map((a) => {
+      const s = P(a), u = this.axes.get(s);
+      return u === void 0 ? y(a) : u;
     }), !t || t.length === 0)
       return r;
-    const s = [];
+    const i = [];
     for (const a of t) {
-      const [i, u] = a;
-      if (typeof i == "number") {
-        if (i < 0 || i >= e.axesSpec.length)
-          throw new Error(`Axis index ${i} is out of bounds (0-${e.axesSpec.length - 1})`);
-        s.push([i, u]);
+      const [s, u] = a;
+      if (typeof s == "number") {
+        if (s < 0 || s >= n.axesSpec.length)
+          throw new Error(`Axis index ${s} is out of bounds (0-${n.axesSpec.length - 1})`);
+        i.push([s, u]);
       } else {
-        const c = e.axesSpec.findIndex((m) => m.name === i);
+        const c = n.axesSpec.findIndex((f) => f.name === s);
         if (c === -1)
-          throw new Error(`Axis with name "${i}" not found in the column specification`);
-        s.push([c, u]);
+          throw new Error(`Axis with name "${s}" not found in the column specification`);
+        i.push([c, u]);
       }
     }
-    return s.sort((a, i) => a[0] - i[0]), {
+    return i.sort((a, s) => a[0] - s[0]), {
       source: r,
-      axisFilters: s
+      axisFilters: i
     };
   }
   /**
@@ -511,58 +607,58 @@ class _n {
    * @param axisFilters Optional axis filters to apply to the column
    * @returns A canonicalized string representation of the anchored column identifier
    */
-  deriveS(e, t) {
-    return nn(this.derive(e, t));
+  deriveS(n, t) {
+    return te(this.derive(n, t));
   }
 }
-function Mn(n, e, t) {
-  const r = { ...e }, o = (t == null ? void 0 : t.ignoreMissingDomains) ?? !1;
+function We(e, n, t) {
+  const r = { ...n }, o = (t == null ? void 0 : t.ignoreMissingDomains) ?? !1;
   if (r.domainAnchor !== void 0) {
-    const s = n[r.domainAnchor];
-    if (!s)
+    const i = e[r.domainAnchor];
+    if (!i)
       throw new Error(`Anchor "${r.domainAnchor}" not found`);
-    const a = s.domain || {};
+    const a = i.domain || {};
     r.domain = { ...a, ...r.domain }, delete r.domainAnchor;
   }
   if (r.domain) {
-    const s = {};
-    for (const [a, i] of Object.entries(r.domain))
-      if (typeof i == "string")
-        s[a] = i;
+    const i = {};
+    for (const [a, s] of Object.entries(r.domain))
+      if (typeof s == "string")
+        i[a] = s;
       else {
-        const u = n[i.anchor];
+        const u = e[s.anchor];
         if (!u)
-          throw new Error(`Anchor "${i.anchor}" not found for domain key "${a}"`);
+          throw new Error(`Anchor "${s.anchor}" not found for domain key "${a}"`);
         if (!u.domain || u.domain[a] === void 0) {
           if (!o)
-            throw new Error(`Domain key "${a}" not found in anchor "${i.anchor}"`);
+            throw new Error(`Domain key "${a}" not found in anchor "${s.anchor}"`);
           continue;
         }
-        s[a] = u.domain[a];
+        i[a] = u.domain[a];
       }
-    r.domain = s;
+    r.domain = i;
   }
-  return r.axes && (r.axes = r.axes.map((s) => en(n, s))), r;
+  return r.axes && (r.axes = r.axes.map((i) => re(e, i))), r;
 }
-function en(n, e) {
-  if (!tn(e))
-    return e;
-  const t = e.anchor, r = n[t];
+function re(e, n) {
+  if (!oe(n))
+    return n;
+  const t = n.anchor, r = e[t];
   if (!r)
     throw new Error(`Anchor "${t}" not found for axis reference`);
-  if ("idx" in e) {
-    if (e.idx < 0 || e.idx >= r.axesSpec.length)
-      throw new Error(`Axis index ${e.idx} out of bounds for anchor "${t}"`);
-    return r.axesSpec[e.idx];
-  } else if ("name" in e) {
-    const o = r.axesSpec.filter((s) => s.name === e.name);
+  if ("idx" in n) {
+    if (n.idx < 0 || n.idx >= r.axesSpec.length)
+      throw new Error(`Axis index ${n.idx} out of bounds for anchor "${t}"`);
+    return r.axesSpec[n.idx];
+  } else if ("name" in n) {
+    const o = r.axesSpec.filter((i) => i.name === n.name);
     if (o.length > 1)
-      throw new Error(`Multiple axes with name "${e.name}" found in anchor "${t}"`);
+      throw new Error(`Multiple axes with name "${n.name}" found in anchor "${t}"`);
     if (o.length === 0)
-      throw new Error(`Axis with name "${e.name}" not found in anchor "${t}"`);
+      throw new Error(`Axis with name "${n.name}" not found in anchor "${t}"`);
     return o[0];
-  } else if ("id" in e) {
-    const o = r.axesSpec.filter((s) => Z(e.id, p(s)));
+  } else if ("id" in n) {
+    const o = r.axesSpec.filter((i) => ne(n.id, y(i)));
     if (o.length > 1)
       throw new Error(`Multiple matching axes found for matcher in anchor "${t}"`);
     if (o.length === 0)
@@ -571,42 +667,42 @@ function en(n, e) {
   }
   throw new Error("Unsupported axis reference type");
 }
-function tn(n) {
-  return typeof n == "object" && "anchor" in n;
+function oe(e) {
+  return typeof e == "object" && "anchor" in e;
 }
-function Tn(n) {
-  return typeof n == "object" && n !== null && "source" in n && "axisFilters" in n;
+function Ge(e) {
+  return typeof e == "object" && e !== null && "source" in e && "axisFilters" in e;
 }
-function f(n) {
-  return n.kind === "PColumn";
+function d(e) {
+  return e.kind === "PColumn";
 }
-function rn(n) {
-  return f(n.spec);
+function ie(e) {
+  return d(e.spec);
 }
-function zn(n) {
-  return f(n.obj);
+function Xe(e) {
+  return d(e.obj);
 }
-function Hn(n) {
-  return f(n.obj.spec);
+function Qe(e) {
+  return d(e.obj.spec);
 }
-function qn(n) {
-  if (!rn(n)) throw new Error(`not a PColumn (kind = ${n.spec.kind})`);
-  return n;
+function Ye(e) {
+  if (!ie(e)) throw new Error(`not a PColumn (kind = ${e.spec.kind})`);
+  return e;
 }
-function Wn(n, e) {
-  return n === void 0 ? void 0 : {
-    ...n,
-    data: e(n.data)
+function Ze(e, n) {
+  return e === void 0 ? void 0 : {
+    ...e,
+    data: n(e.data)
   };
 }
-function Xn(n) {
-  const e = /* @__PURE__ */ new Map(), t = (r) => {
+function en(e) {
+  const n = /* @__PURE__ */ new Map(), t = (r) => {
     switch (r.type) {
       case "column":
-        e.set(r.column.id, r.column);
+        n.set(r.column.id, r.column);
         return;
       case "slicedColumn":
-        e.set(r.column.id, r.column);
+        n.set(r.column.id, r.column);
         return;
       case "inlineColumn":
         return;
@@ -619,389 +715,463 @@ function Xn(n) {
         for (const o of r.secondary) t(o);
         return;
       default:
-        w(r);
+        A(r);
     }
   };
-  return t(n), [...e.values()];
+  return t(e), [...n.values()];
 }
-function on(n) {
-  throw new Error("Unexpected object: " + n);
+function se(e) {
+  throw new Error("Unexpected object: " + e);
 }
-function b(n, e) {
-  switch (n.type) {
+function w(e, n) {
+  switch (e.type) {
     case "and":
-      for (const t of n.operands)
-        if (!b(t, e)) return !1;
+      for (const t of e.operands)
+        if (!w(t, n)) return !1;
       return !0;
     case "or":
-      for (const t of n.operands)
-        if (b(t, e)) return !0;
+      for (const t of e.operands)
+        if (w(t, n)) return !0;
       return !1;
     case "not":
-      return !b(n.operand, e);
+      return !w(e.operand, n);
     case "name":
-      return f(e) && e.name === n.name;
+      return d(n) && n.name === e.name;
     case "name_pattern":
-      return f(e) && !!e.name.match(n.pattern);
+      return d(n) && !!n.name.match(e.pattern);
     case "annotation":
-      return f(e) && e.annotations !== void 0 && e.annotations[n.annotation] === n.value;
+      return d(n) && n.annotations !== void 0 && n.annotations[e.annotation] === e.value;
     case "annotation_pattern":
-      return f(e) && e.annotations !== void 0 && e.annotations[n.annotation] !== void 0 && !!e.annotations[n.annotation].match(n.pattern);
+      return d(n) && n.annotations !== void 0 && n.annotations[e.annotation] !== void 0 && !!n.annotations[e.annotation].match(e.pattern);
     case "has_axes":
-      return f(e) && n.axes.every(
-        (t) => e.axesSpec.some(
+      return d(n) && e.axes.every(
+        (t) => n.axesSpec.some(
           (r) => (t.type === void 0 || t.type === r.type) && (t.name === void 0 || t.name === r.name) && (t.domain === void 0 || Object.keys(t.domain).length === 0 || r.domain !== void 0 && Object.entries(t.domain).every(
-            ([o, s]) => r.domain[o] === s
+            ([o, i]) => r.domain[o] === i
           ))
         )
       );
     default:
-      on(n);
+      se(e);
   }
 }
-function E(n, e) {
-  if (n.name !== void 0 && n.name !== e.name)
+function S(e, n) {
+  if (e.name !== void 0 && e.name !== n.name)
     return !1;
-  if (n.type !== void 0) {
-    if (Array.isArray(n.type)) {
-      if (!n.type.includes(e.type))
+  if (e.type !== void 0) {
+    if (Array.isArray(e.type)) {
+      if (!e.type.includes(n.type))
         return !1;
-    } else if (n.type !== e.type)
+    } else if (e.type !== n.type)
       return !1;
   }
-  if (n.domain !== void 0) {
-    const t = e.domain || {};
-    for (const [r, o] of Object.entries(n.domain))
+  if (e.domain !== void 0) {
+    const t = n.domain || {};
+    for (const [r, o] of Object.entries(e.domain))
       if (t[r] !== o)
         return !1;
   }
   return !0;
 }
-function N(n, e) {
-  if (e.name !== void 0 && n.name !== e.name || e.namePattern !== void 0 && !new RegExp(e.namePattern).test(n.name))
+function v(e, n) {
+  if (n.name !== void 0 && e.name !== n.name || n.namePattern !== void 0 && !new RegExp(n.namePattern).test(e.name))
     return !1;
-  if (e.type !== void 0) {
-    if (Array.isArray(e.type)) {
-      if (!e.type.includes(n.valueType))
+  if (n.type !== void 0) {
+    if (Array.isArray(n.type)) {
+      if (!n.type.includes(e.valueType))
         return !1;
-    } else if (e.type !== n.valueType)
+    } else if (n.type !== e.valueType)
       return !1;
   }
-  if (e.domain !== void 0) {
-    const t = n.domain || {};
-    for (const [r, o] of Object.entries(e.domain))
+  if (n.domain !== void 0) {
+    const t = e.domain || {};
+    for (const [r, o] of Object.entries(n.domain))
       if (t[r] !== o)
         return !1;
   }
-  if (e.axes !== void 0) {
-    const t = n.axesSpec.map(p);
-    if (e.partialAxesMatch) {
-      for (const r of e.axes)
-        if (!t.some((o) => E(r, o)))
+  if (n.axes !== void 0) {
+    const t = e.axesSpec.map(y);
+    if (n.partialAxesMatch) {
+      for (const r of n.axes)
+        if (!t.some((o) => S(r, o)))
           return !1;
     } else {
-      if (t.length !== e.axes.length)
+      if (t.length !== n.axes.length)
         return !1;
-      for (let r = 0; r < e.axes.length; r++)
-        if (!E(e.axes[r], t[r]))
+      for (let r = 0; r < n.axes.length; r++)
+        if (!S(n.axes[r], t[r]))
           return !1;
     }
   }
-  if (e.annotations !== void 0) {
-    const t = n.annotations || {};
-    for (const [r, o] of Object.entries(e.annotations))
+  if (n.annotations !== void 0) {
+    const t = e.annotations || {};
+    for (const [r, o] of Object.entries(n.annotations))
       if (t[r] !== o)
         return !1;
   }
-  if (e.annotationPatterns !== void 0) {
-    const t = n.annotations || {};
-    for (const [r, o] of Object.entries(e.annotationPatterns)) {
-      const s = t[r];
-      if (s === void 0 || !new RegExp(o).test(s))
+  if (n.annotationPatterns !== void 0) {
+    const t = e.annotations || {};
+    for (const [r, o] of Object.entries(n.annotationPatterns)) {
+      const i = t[r];
+      if (i === void 0 || !new RegExp(o).test(i))
         return !1;
     }
   }
   return !0;
 }
-function Gn(n) {
-  return Array.isArray(n) ? (e) => n.some((t) => f(e) && N(e, t)) : (e) => f(e) && N(e, n);
+function nn(e) {
+  return Array.isArray(e) ? (n) => e.some((t) => d(n) && v(n, t)) : (n) => d(n) && v(n, e);
 }
-function Qn(n) {
-  const e = {
-    kind: n.kind,
-    name: n.name
+function tn(e) {
+  const n = {
+    kind: e.kind,
+    name: e.name
   };
-  return n.domain !== void 0 && (e.domain = n.domain), f(n) && (e.axesSpec = J(n.axesSpec)), y(e);
+  return e.domain !== void 0 && (n.domain = e.domain), d(e) && (n.axesSpec = C(e.axesSpec)), h(n);
 }
-const Yn = { href: "/" }, Zn = d.object({
-  __isRef: d.literal(!0).describe("Crucial marker for the block dependency tree reconstruction"),
-  blockId: d.string().describe("Upstream block id"),
-  name: d.string().describe("Name of the output provided to the upstream block's output context"),
-  requireEnrichments: d.literal(!0).optional().describe("True if current block that stores this reference in its args, may need enrichments for the references value originating from the blocks in between current and referenced block")
+const rn = { href: "/" }, on = p.object({
+  __isRef: p.literal(!0).describe("Crucial marker for the block dependency tree reconstruction"),
+  blockId: p.string().describe("Upstream block id"),
+  name: p.string().describe("Name of the output provided to the upstream block's output context"),
+  requireEnrichments: p.literal(!0).optional().describe("True if current block that stores this reference in its args, may need enrichments for the references value originating from the blocks in between current and referenced block")
 }).describe(
   "Universal reference type, allowing to set block connections. It is crucial that {@link __isRef} is present and equal to true, internal logic relies on this marker to build block dependency trees."
 ).readonly();
-function ne(n) {
-  return typeof n == "object" && n !== null && "__isRef" in n && n.__isRef === !0 && "blockId" in n && "name" in n;
+function sn(e) {
+  return typeof e == "object" && e !== null && "__isRef" in e && e.__isRef === !0 && "blockId" in e && "name" in e;
 }
-function ee(n, e, t = !1) {
+function an(e, n, t = !1) {
   return t ? {
     __isRef: !0,
-    blockId: n,
-    name: e,
+    blockId: e,
+    name: n,
     requireEnrichments: !0
   } : {
     __isRef: !0,
-    blockId: n,
-    name: e
+    blockId: e,
+    name: n
   };
 }
-function te(n, e = !0) {
-  if (e)
+function un(e, n = !0) {
+  if (n)
     return {
-      ...n,
+      ...e,
       requireEnrichments: !0
     };
   {
-    const { requireEnrichments: t, ...r } = n;
+    const { requireEnrichments: t, ...r } = e;
     return r;
   }
 }
-function re(n, e, t = !1) {
-  return n.blockId === e.blockId && n.name === e.name && (t || n.requireEnrichments === e.requireEnrichments);
+function cn(e, n, t = !1) {
+  return e.blockId === n.blockId && e.name === n.name && (t || e.requireEnrichments === n.requireEnrichments);
 }
-function oe(n, e) {
-  return n.ok ? { ok: !0, value: e(n.value) } : n;
+function fn(e, n) {
+  return e.ok ? { ok: !0, value: n(e.value) } : e;
 }
-function sn(n) {
-  if (n instanceof Int8Array || n instanceof Uint8Array || n instanceof Uint8ClampedArray)
-    return new DataView(n.buffer, n.byteOffset, n.byteLength);
-  if (n instanceof ArrayBuffer) return new DataView(n);
+function ae(e) {
+  if (e instanceof Int8Array || e instanceof Uint8Array || e instanceof Uint8ClampedArray)
+    return new DataView(e.buffer, e.byteOffset, e.byteLength);
+  if (e instanceof ArrayBuffer) return new DataView(e);
   throw new TypeError(
     "Expected `data` to be an ArrayBuffer, Buffer, Int8Array, Uint8Array or Uint8ClampedArray"
   );
 }
-const an = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567", un = "0123456789ABCDEFGHIJKLMNOPQRSTUV", cn = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
-function O(n, e, t) {
+const ue = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567", ce = "0123456789ABCDEFGHIJKLMNOPQRSTUV", fe = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
+function $(e, n, t) {
   t = t || {};
   let r, o;
-  switch (e) {
+  switch (n) {
     case "RFC3548":
     case "RFC4648":
-      r = an, o = !0;
+      r = ue, o = !0;
       break;
     case "RFC4648-HEX":
-      r = un, o = !0;
+      r = ce, o = !0;
       break;
     case "Crockford":
-      r = cn, o = !1;
+      r = fe, o = !1;
       break;
     default:
-      throw new Error("Unknown base32 variant: " + String(e));
-  }
-  const s = t.padding !== void 0 ? t.padding : o, a = sn(n);
-  let i = 0, u = 0, c = "";
-  for (let m = 0; m < a.byteLength; m++)
-    for (u = u << 8 | a.getUint8(m), i += 8; i >= 5; )
-      c += r[u >>> i - 5 & 31], i -= 5;
-  if (i > 0 && (c += r[u << 5 - i & 31]), s)
+      throw new Error("Unknown base32 variant: " + String(n));
+  }
+  const i = t.padding !== void 0 ? t.padding : o, a = ae(e);
+  let s = 0, u = 0, c = "";
+  for (let f = 0; f < a.byteLength; f++)
+    for (u = u << 8 | a.getUint8(f), s += 8; s >= 5; )
+      c += r[u >>> s - 5 & 31], s -= 5;
+  if (s > 0 && (c += r[u << 5 - s & 31]), i)
     for (; c.length % 8 !== 0; )
       c += "=";
   return c;
 }
-const $ = 15, fn = 24, I = d.string().length(fn).regex(/[ABCDEFGHIJKLMNOPQRSTUVWXYZ234567]/).brand("PlId");
-function ie() {
-  const n = new Uint8Array($);
-  return crypto.getRandomValues(n), I.parse(O(n, "RFC4648"));
+const V = 15, de = 24, I = p.string().length(de).regex(/[ABCDEFGHIJKLMNOPQRSTUVWXYZ234567]/).brand("PlId");
+function dn() {
+  const e = new Uint8Array(V);
+  return crypto.getRandomValues(e), I.parse($(e, "RFC4648"));
 }
-function dn(n) {
-  if (n.length !== $) throw new Error(`Wrong number of bytes: ${n.length}`);
-  return I.parse(O(n, "RFC4648"));
+function le(e) {
+  if (e.length !== V) throw new Error(`Wrong number of bytes: ${e.length}`);
+  return I.parse($(e, "RFC4648"));
 }
-async function se(n) {
-  const e = new TextEncoder(), t = await crypto.subtle.digest("SHA-256", e.encode(n));
-  return dn(new Uint8Array(t.slice(0, 15)));
+async function ln(e) {
+  const n = new TextEncoder(), t = await crypto.subtle.digest("SHA-256", n.encode(e));
+  return le(new Uint8Array(t.slice(0, 15)));
 }
-function ae(n) {
-  return JSON.stringify(n);
+function pn(e) {
+  return JSON.stringify(e);
 }
-function ue(n) {
-  return y(n);
+function mn(e) {
+  return h(e);
 }
-function ce(n) {
-  return JSON.parse(n);
+function yn(e) {
+  return JSON.parse(e);
 }
-class fe extends Error {
+class hn extends Error {
   constructor() {
     super(...arguments);
     l(this, "name", "AbortError");
   }
 }
-class de extends Error {
+class gn extends Error {
   constructor() {
     super(...arguments);
     l(this, "name", "UiError");
   }
 }
-function me(n) {
-  return n instanceof Error && n.name === "AbortError";
+function bn(e) {
+  return e instanceof Error && e.name === "AbortError";
 }
-function mn(n) {
-  return n instanceof Error ? n.name === "AbortError" || mn(n.cause) : !1;
+function pe(e) {
+  return e instanceof Error ? e.name === "AbortError" || pe(e.cause) : !1;
 }
-function le(n) {
-  return n instanceof Error && n.name === "AggregateError";
+function wn(e) {
+  return e instanceof Error && e.name === "AggregateError";
 }
-function ln(n) {
-  if (typeof n == "string")
-    return `String value was thrown: ${n}`;
-  if (n && typeof n == "object")
+function me(e) {
+  if (typeof e == "string")
+    return `String value was thrown: ${e}`;
+  if (e && typeof e == "object")
     try {
-      return `Plain object was thrown: ${JSON.stringify(n)}`;
-    } catch (e) {
-      return `Non-serializable object was thrown (JSON.stringify failed: ${e instanceof Error ? e.message : String(e)}): ${String(n)}`;
+      return `Plain object was thrown: ${JSON.stringify(e)}`;
+    } catch (n) {
+      return `Non-serializable object was thrown (JSON.stringify failed: ${n instanceof Error ? n.message : String(n)}): ${String(e)}`;
     }
-  return `Non-Error value (${typeof n}) was thrown: ${n}`;
+  return `Non-Error value (${typeof e}) was thrown: ${e}`;
 }
-function A(n) {
-  return n instanceof Error ? n : new Error(ln(n));
+function k(e) {
+  return e instanceof Error ? e : new Error(me(e));
 }
-function V(n) {
-  const e = n.cause ? V(n.cause) : void 0, t = new Error(n.message, e !== void 0 ? { cause: e } : void 0);
-  return t.name = n.name || "Error", t.stack = n.stack, t;
+function j(e) {
+  const n = e.cause ? j(e.cause) : void 0, t = new Error(e.message, n !== void 0 ? { cause: n } : void 0);
+  return t.name = e.name || "Error", t.stack = e.stack, t;
 }
-function D(n) {
-  const e = A(n), t = e.cause ? D(e.cause) : void 0;
+function F(e) {
+  const n = k(e), t = n.cause ? F(n.cause) : void 0;
   return {
-    name: e.name,
-    message: e.message,
-    stack: e.stack,
-    ...e.cause !== void 0 && { cause: t }
+    name: n.name,
+    message: n.message,
+    stack: n.stack,
+    ...n.cause !== void 0 && { cause: t }
   };
 }
-function pe(n) {
-  if (n.error)
-    throw n.error;
-  return n.value;
+function An(e) {
+  if (e.error)
+    throw e.error;
+  return e.value;
 }
-function L(n) {
-  return n.error ? { error: D(n.error) } : { value: n.value };
+function J(e) {
+  return e.error ? { error: F(e.error) } : { value: e.value };
 }
-function ye(n) {
-  return n.error ? { error: V(n.error) } : { value: n.value };
+function kn(e) {
+  return e.error ? { error: j(e.error) } : { value: e.value };
 }
-function pn(n) {
+function ye(e) {
   try {
-    return { value: n() };
-  } catch (e) {
-    return { error: A(e) };
+    return { value: e() };
+  } catch (n) {
+    return { error: k(n) };
   }
 }
-async function yn(n) {
+async function he(e) {
   try {
-    return { value: await n() };
-  } catch (e) {
-    return { error: A(e) };
+    return { value: await e() };
+  } catch (n) {
+    return { error: k(n) };
   }
 }
-function he(n) {
-  const e = pn(n);
-  return L(e);
+function xn(e) {
+  const n = ye(e);
+  return J(n);
+}
+async function Pn(e) {
+  const n = await he(e);
+  return J(n);
+}
+const En = ["supportsLazyState"], Sn = ["requiresUIAPIVersion", "requiresModelAPIVersion"];
+function vn(e, n, t = !0) {
+  return e === void 0 ? !1 : e[n] === t;
+}
+function Nn(e) {
+  return e === void 0 ? /* @__PURE__ */ new Set() : new Set(Object.entries(e).filter(([n, t]) => n.startsWith("requires") && t === !0).map(([n]) => n));
+}
+function On(e) {
+  return e === void 0 ? /* @__PURE__ */ new Set() : new Set(Object.entries(e).filter(([n, t]) => n.startsWith("supports") && t === !0).map(([n]) => n));
 }
-async function ge(n) {
-  const e = await yn(n);
-  return L(e);
+class ge extends Error {
+  constructor(t) {
+    super(`Some of the block requirements are not supported by the runtime: ${Array.from(t.entries()).map(([r, o]) => `${r}: ${o}`).join(", ")}`);
+    l(this, "name", "IncompatibleFlagsError");
+    this.incompatibleFlags = t;
+  }
+}
+class Cn {
+  constructor() {
+    l(this, "supportedRequirements", /* @__PURE__ */ new Map());
+  }
+  /**
+     * Adds a supported requirement to the runtime capabilities.
+     * @param requirement - The requirement.
+     * @param value - The value of the requirement. If not provided, defaults to true.
+     */
+  addSupportedRequirement(n, t = !0) {
+    return this.supportedRequirements.has(n) || this.supportedRequirements.set(n, /* @__PURE__ */ new Set()), this.supportedRequirements.get(n).add(t), this;
+  }
+  /**
+     * Returns a map of incompatible flags. If the block flags are compatible, returns undefined.
+     * @param blockFlags - The block flags.
+     * @returns A map of incompatible flags, or undefined if the block flags are compatible.
+     */
+  getIncompatibleFlags(n) {
+    if (n === void 0) return;
+    const t = /* @__PURE__ */ new Map();
+    for (const [r, o] of Object.entries(n))
+      if (r.startsWith("requires")) {
+        if (o === void 0) continue;
+        const i = this.supportedRequirements.get(r);
+        (i === void 0 || !i.has(o)) && t.set(r, o);
+      }
+    return t.size === 0 ? void 0 : t;
+  }
+  /**
+     * Checks if the block flags are compatible with the runtime capabilities.
+     * @param blockFlags - The block flags.
+     * @returns True if the block flags are compatible, false otherwise.
+     */
+  checkCompatibility(n) {
+    return this.getIncompatibleFlags(n) === void 0;
+  }
+  /**
+     * Throws an error if the block flags are incompatible with the runtime capabilities.
+     * @param blockFlags - The block flags.
+     * @throws IncompatibleFlagsError if the block flags are incompatible with the runtime capabilities.
+     */
+  throwIfIncompatible(n) {
+    const t = this.getIncompatibleFlags(n);
+    if (t !== void 0)
+      throw new ge(t);
+  }
 }
 export {
-  fe as AbortError,
-  _n as AnchoredIdDeriver,
-  Yn as DefaultNavigationState,
-  G as PTableAbsent,
-  Q as PTableNA,
-  T as PValueBytesNA,
-  In as PValueDoubleNA,
-  $n as PValueFloatNA,
-  _ as PValueIntNA,
+  hn as AbortError,
+  Sn as AllRequiresFeatureFlags,
+  En as AllSupportsFeatureFlags,
+  He as AnchoredIdDeriver,
+  rn as DefaultNavigationState,
+  ge as IncompatibleFlagsError,
+  Y as PTableAbsent,
+  Z as PTableNA,
+  z as PValueBytesNA,
+  Je as PValueDoubleNA,
+  Fe as PValueFloatNA,
+  q as PValueIntNA,
   x as PValueLongNA,
-  M as PValueStringNA,
+  T as PValueStringNA,
   I as PlId,
-  $ as PlIdBytes,
-  fn as PlIdLength,
-  Zn as PlRef,
-  wn as RangeBytes,
-  de as UiError,
-  Rn as canonicalizeAxisId,
-  ue as canonicalizeJson,
-  ee as createPlRef,
-  Cn as dataInfoToEntries,
-  Qn as deriveNativeId,
-  V as deserializeError,
-  ye as deserializeResult,
-  se as digestPlId,
-  A as ensureError,
-  Vn as ensureNotNAPValue,
-  qn as ensurePColumn,
-  Jn as entriesToDataInfo,
-  b as executePSpecPredicate,
-  Xn as extractAllColumns,
-  J as getAxesId,
-  p as getAxisId,
-  Fn as getColumnIdAndSpec,
-  kn as getFileNameFromHandle,
-  R as getFilePathFromHandle,
-  vn as getPColumnSpecId,
-  mn as hasAbortError,
-  me as isAbortError,
-  le as isAggregateError,
-  En as isDataInfo,
-  K as isDataInfoEntries,
-  Tn as isFilteredPColumn,
-  F as isImportFileHandleIndex,
-  v as isImportFileHandleUpload,
-  Pn as isLiveLog,
-  z as isNotNAPValue,
-  rn as isPColumn,
-  Hn as isPColumnResult,
-  f as isPColumnSpec,
-  zn as isPColumnSpecResult,
-  Bn as isPTableAbsent,
-  H as isPValue,
-  Sn as isPartitionedDataInfoEntries,
-  ne as isPlRef,
-  X as isValueAbsent,
-  g as isValueNA,
-  Nn as mapDataInfo,
-  On as mapDataInfoEntries,
-  h as mapJoinEntry,
-  Wn as mapPObjectData,
-  Un as mapPTableDef,
-  oe as mapValueInVOE,
-  E as matchAxis,
-  Z as matchAxisId,
-  N as matchPColumn,
-  An as newRangeBytesOpt,
-  jn as pTableValue,
-  Ln as pValueToStringOrNumber,
-  W as pValueToStringOrNumberOrNull,
-  Kn as parseColumnId,
-  ce as parseJson,
-  dn as plId,
-  re as plRefsEqual,
-  Mn as resolveAnchors,
-  q as safeConvertToPValue,
-  Gn as selectorsToPredicate,
-  D as serializeError,
-  L as serializeResult,
-  nn as stringifyColumnId,
-  ae as stringifyJson,
-  Dn as toJsonSafePValue,
-  ie as uniquePlId,
-  pe as unwrapResult,
-  xn as validateRangeBytes,
-  te as withEnrichments,
-  he as wrapAndSerialize,
-  ge as wrapAndSerializeAsync,
-  yn as wrapAsyncCallback,
-  pn as wrapCallback
+  V as PlIdBytes,
+  de as PlIdLength,
+  on as PlRef,
+  Pe as RangeBytes,
+  Cn as RuntimeCapabilities,
+  gn as UiError,
+  _e as canonicalizeAxisId,
+  mn as canonicalizeJson,
+  vn as checkBlockFlag,
+  an as createPlRef,
+  Ve as dataInfoToEntries,
+  tn as deriveNativeId,
+  j as deserializeError,
+  kn as deserializeResult,
+  ln as digestPlId,
+  k as ensureError,
+  Re as ensureNotNAPValue,
+  Ye as ensurePColumn,
+  Ie as entriesToDataInfo,
+  w as executePSpecPredicate,
+  en as extractAllColumns,
+  Nn as extractAllRequirements,
+  On as extractAllSupports,
+  ke as extractCodeWithInfo,
+  xe as extractConfigGeneric,
+  C as getAxesId,
+  y as getAxisId,
+  Me as getColumnIdAndSpec,
+  Ne as getFileNameFromHandle,
+  K as getFilePathFromHandle,
+  Ke as getPColumnSpecId,
+  Te as getPTableColumnId,
+  pe as hasAbortError,
+  bn as isAbortError,
+  wn as isAggregateError,
+  Oe as isDataInfo,
+  _ as isDataInfoEntries,
+  Ge as isFilteredPColumn,
+  U as isImportFileHandleIndex,
+  B as isImportFileHandleUpload,
+  ve as isLiveLog,
+  H as isNotNAPValue,
+  ie as isPColumn,
+  Qe as isPColumnResult,
+  d as isPColumnSpec,
+  Xe as isPColumnSpecResult,
+  Be as isPTableAbsent,
+  W as isPValue,
+  $e as isPartitionedDataInfoEntries,
+  sn as isPlRef,
+  Q as isValueAbsent,
+  b as isValueNA,
+  Ce as mapDataInfo,
+  je as mapDataInfoEntries,
+  g as mapJoinEntry,
+  Ze as mapPObjectData,
+  qe as mapPTableDef,
+  fn as mapValueInVOE,
+  S as matchAxis,
+  ne as matchAxisId,
+  v as matchPColumn,
+  Ee as newRangeBytesOpt,
+  Ue as pTableValue,
+  Le as pValueToStringOrNumber,
+  X as pValueToStringOrNumberOrNull,
+  ze as parseColumnId,
+  yn as parseJson,
+  le as plId,
+  cn as plRefsEqual,
+  We as resolveAnchors,
+  G as safeConvertToPValue,
+  nn as selectorsToPredicate,
+  F as serializeError,
+  J as serializeResult,
+  te as stringifyColumnId,
+  pn as stringifyJson,
+  De as toJsonSafePValue,
+  dn as uniquePlId,
+  An as unwrapResult,
+  Se as validateRangeBytes,
+  un as withEnrichments,
+  xn as wrapAndSerialize,
+  Pn as wrapAndSerializeAsync,
+  he as wrapAsyncCallback,
+  ye as wrapCallback
 };
 //# sourceMappingURL=index.mjs.map