@milaboratories/pl-model-common 1.19.5 → 1.19.7

package/dist/index.mjs

@@ -1,9 +1,9 @@
-var T = Object.defineProperty;
-var I = (e, n, r) => n in e ? T(e, n, { enumerable: !0, configurable: !0, writable: !0, value: r }) : e[n] = r;
-var f = (e, n, r) => I(e, typeof n != "symbol" ? n + "" : n, r);
-import { z as m } from "zod";
-import y from "canonicalize";
-function be(e) {
+var te = Object.defineProperty;
+var re = (e, n, t) => n in e ? te(e, n, { enumerable: !0, configurable: !0, writable: !0, value: t }) : e[n] = t;
+var b = (e, n, t) => re(e, typeof n != "symbol" ? n + "" : n, t);
+import { z as l } from "zod";
+import F from "canonicalize";
+function Me(e) {
   if (e.code !== void 0)
     return {
       code: e.code,
@@ -11,130 +11,130 @@ function be(e) {
       featureFlags: e.featureFlags
     };
 }
-function p(e) {
+function x(e) {
   if (e !== void 0)
     return typeof e == "string" ? { __renderLambda: !0, handle: e, retentive: !1 } : e;
 }
-function ve(e) {
+function Be(e) {
   if (e.v3 !== void 0) {
     const {
       initialArgs: n,
-      initialUiState: r,
-      inputsValid: t,
-      outputs: i,
-      renderingMode: o,
+      initialUiState: t,
+      inputsValid: r,
+      outputs: o,
+      renderingMode: i,
       sdkVersion: s,
       featureFlags: a,
       sections: u,
       title: c,
       enrichmentTargets: d
-    } = e.v3, { code: V } = e;
+    } = e.v3, { code: f } = e;
     return {
       initialArgs: n,
-      initialUiState: r,
-      inputsValid: t,
-      outputs: i,
-      renderingMode: o,
+      initialUiState: t,
+      inputsValid: r,
+      outputs: o,
+      renderingMode: i,
       sdkVersion: s,
       featureFlags: a,
       sections: u,
       title: c,
-      code: V,
+      code: f,
       enrichmentTargets: d
     };
   } else if (e.inputsValid !== void 0) {
-    const { sdkVersion: n, renderingMode: r, outputs: t, inputsValid: i, sections: o, initialArgs: s, code: a } = e, u = Object.keys(e);
-    if (n === void 0 || r === void 0 || t === void 0 || i === void 0 || o === void 0 || s === void 0)
+    const { sdkVersion: n, renderingMode: t, outputs: r, inputsValid: o, sections: i, initialArgs: s, code: a } = e, u = Object.keys(e);
+    if (n === void 0 || t === void 0 || r === void 0 || o === void 0 || i === void 0 || s === void 0)
       throw new Error(
         `Malformed config v2. SDK version ${n}; Fields = ${u.join(", ")}`
       );
     return {
       sdkVersion: n,
-      renderingMode: r,
+      renderingMode: t,
       initialArgs: s,
       outputs: Object.fromEntries(
-        Object.entries(t).map(([c, d]) => [c, p(d)])
+        Object.entries(r).map(([c, d]) => [c, x(d)])
       ),
-      inputsValid: p(i),
-      sections: p(o),
+      inputsValid: x(o),
+      sections: x(i),
       initialUiState: void 0,
       code: a
     };
   } else if (e.renderingMode !== void 0) {
-    const { sdkVersion: n, canRun: r, renderingMode: t, outputs: i, sections: o, initialArgs: s, code: a } = e, u = Object.keys(e);
-    if (t === void 0 || i === void 0 || r === void 0 || o === void 0 || s === void 0)
+    const { sdkVersion: n, canRun: t, renderingMode: r, outputs: o, sections: i, initialArgs: s, code: a } = e, u = Object.keys(e);
+    if (r === void 0 || o === void 0 || t === void 0 || i === void 0 || s === void 0)
       throw new Error(
         `Malformed config v1. SDK version ${n}; Fields = ${u.join(", ")}`
       );
     return {
       sdkVersion: n ?? "unknown",
-      renderingMode: t,
+      renderingMode: r,
       initialArgs: s,
       outputs: Object.fromEntries(
-        Object.entries(i).map(([c, d]) => [c, p(d)])
+        Object.entries(o).map(([c, d]) => [c, x(d)])
       ),
-      inputsValid: p(r),
-      sections: p(o),
+      inputsValid: x(t),
+      sections: x(i),
       initialUiState: void 0,
       code: a
     };
   } else {
-    const { sdkVersion: n } = e, r = Object.keys(e);
+    const { sdkVersion: n } = e, t = Object.keys(e);
     throw new Error(
-      `Config format not supported: SDK = ${n}; Fields = ${r.join(", ")}`
+      `Config format not supported: SDK = ${n}; Fields = ${t.join(", ")}`
     );
   }
 }
-function ge(e) {
+function Ue(e) {
   return new URL(e).protocol == "plblob+folder:";
 }
-function we(e) {
+function qe(e) {
   return new URL(e).protocol == "block-ui:";
 }
-const Pe = m.object({
+const We = l.object({
   /** Included left border. */
-  from: m.number(),
+  from: l.number(),
   /** Excluded right border. */
-  to: m.number()
+  to: l.number()
 });
-function ke(e, n) {
+function ze(e, n) {
   if (!(e == null || n == null))
     return { from: e, to: n };
 }
-function Ae(e, n) {
+function He(e, n) {
   if (e.from < 0 || e.to < 0 || e.from >= e.to)
     throw new Error(`${n}: invalid bytes range: ${e}`);
 }
-function xe(e) {
+function _e(e) {
   return e !== void 0 && e.startsWith("log+live://log/");
 }
-function b(e) {
+function S(e) {
   throw new Error("Unexpected object: " + e);
 }
-const S = "upload://upload/", O = "index://index/";
-function B(e) {
-  return e.startsWith(S);
+const K = "upload://upload/", V = "index://index/";
+function oe(e) {
+  return e.startsWith(K);
 }
-function U(e) {
-  return e.startsWith(O);
+function ie(e) {
+  return e.startsWith(V);
 }
-function q(e) {
-  if (U(e)) {
-    const n = e.slice(O.length);
+function ae(e) {
+  if (ie(e)) {
+    const n = e.slice(V.length);
     return JSON.parse(decodeURIComponent(n)).path;
-  } else if (B(e)) {
-    const n = e.slice(S.length);
+  } else if (oe(e)) {
+    const n = e.slice(K.length);
     return JSON.parse(decodeURIComponent(n)).localPath;
   }
-  b(e);
+  S(e);
 }
-function K(e) {
+function se(e) {
   return e.replace(/^.*[\\/]/, "");
 }
-function Ee(e) {
-  return K(q(e));
+function Ge(e) {
+  return se(ae(e));
 }
-function Se(e) {
+function Qe(e) {
   if (!e || typeof e != "object")
     return !1;
   const n = e;
@@ -151,44 +151,44 @@ function Se(e) {
       return !1;
   }
 }
-function Oe(e, n) {
+function Xe(e, n) {
   if (e !== void 0)
     switch (e.type) {
       case "Json":
         return e;
       case "JsonPartitioned": {
-        const r = {};
-        for (const [t, i] of Object.entries(e.parts))
-          r[t] = n(i);
+        const t = {};
+        for (const [r, o] of Object.entries(e.parts))
+          t[r] = n(o);
         return {
           ...e,
-          parts: r
+          parts: t
         };
       }
       case "BinaryPartitioned": {
-        const r = {};
-        for (const [t, i] of Object.entries(e.parts))
-          r[t] = {
-            index: n(i.index),
-            values: n(i.values)
+        const t = {};
+        for (const [r, o] of Object.entries(e.parts))
+          t[r] = {
+            index: n(o.index),
+            values: n(o.values)
           };
         return {
           ...e,
-          parts: r
+          parts: t
         };
       }
       case "ParquetPartitioned": {
-        const r = {};
-        for (const [t, i] of Object.entries(e.parts))
-          r[t] = n(i);
+        const t = {};
+        for (const [r, o] of Object.entries(e.parts))
+          t[r] = n(o);
         return {
           ...e,
-          parts: r
+          parts: t
         };
       }
     }
 }
-function je(e, n) {
+function Ye(e, n) {
   switch (e.type) {
     case "Json":
       break;
@@ -197,8 +197,8 @@ function je(e, n) {
       break;
     }
     case "BinaryPartitioned": {
-      Object.values(e.parts).forEach((r) => {
-        n(r.index), n(r.values);
+      Object.values(e.parts).forEach((t) => {
+        n(t.index), n(t.values);
       });
       break;
     }
@@ -208,7 +208,7 @@ function je(e, n) {
     }
   }
 }
-function M(e) {
+function ue(e) {
   if (!e || typeof e != "object")
     return !1;
   const n = e;
@@ -225,8 +225,8 @@ function M(e) {
       return !1;
   }
 }
-function Ce(e) {
-  if (!M(e)) return !1;
+function Ze(e) {
+  if (!ue(e)) return !1;
   switch (e.type) {
     case "JsonPartitioned":
     case "BinaryPartitioned":
@@ -236,44 +236,44 @@ function Ce(e) {
       return !1;
   }
 }
-function Fe(e) {
+function en(e) {
   switch (e.type) {
     case "Json":
       return {
         type: "Json",
         keyLength: e.keyLength,
-        data: Object.entries(e.data).map(([n, r]) => ({ key: JSON.parse(n), value: r }))
+        data: Object.entries(e.data).map(([n, t]) => ({ key: JSON.parse(n), value: t }))
       };
     case "JsonPartitioned":
       return {
         type: "JsonPartitioned",
         partitionKeyLength: e.partitionKeyLength,
-        parts: Object.entries(e.parts).map(([n, r]) => ({ key: JSON.parse(n), value: r }))
+        parts: Object.entries(e.parts).map(([n, t]) => ({ key: JSON.parse(n), value: t }))
       };
     case "BinaryPartitioned":
       return {
         type: "BinaryPartitioned",
         partitionKeyLength: e.partitionKeyLength,
-        parts: Object.entries(e.parts).map(([n, r]) => ({ key: JSON.parse(n), value: r }))
+        parts: Object.entries(e.parts).map(([n, t]) => ({ key: JSON.parse(n), value: t }))
       };
     case "ParquetPartitioned":
       return {
         type: "ParquetPartitioned",
         partitionKeyLength: e.partitionKeyLength,
-        parts: Object.entries(e.parts).map(([n, r]) => ({ key: JSON.parse(n), value: r }))
+        parts: Object.entries(e.parts).map(([n, t]) => ({ key: JSON.parse(n), value: t }))
       };
     default:
-      b(e);
+      S(e);
   }
 }
-function Je(e) {
+function nn(e) {
   switch (e.type) {
     case "Json":
       return {
         type: "Json",
         keyLength: e.keyLength,
         data: Object.fromEntries(
-          e.data.map(({ key: n, value: r }) => [JSON.stringify(n), r])
+          e.data.map(({ key: n, value: t }) => [JSON.stringify(n), t])
         )
       };
     case "JsonPartitioned":
@@ -281,7 +281,7 @@ function Je(e) {
         type: "JsonPartitioned",
         partitionKeyLength: e.partitionKeyLength,
         parts: Object.fromEntries(
-          e.parts.map(({ key: n, value: r }) => [JSON.stringify(n), r])
+          e.parts.map(({ key: n, value: t }) => [JSON.stringify(n), t])
         )
       };
     case "BinaryPartitioned":
@@ -289,7 +289,7 @@ function Je(e) {
         type: "BinaryPartitioned",
         partitionKeyLength: e.partitionKeyLength,
         parts: Object.fromEntries(
-          e.parts.map(({ key: n, value: r }) => [JSON.stringify(n), r])
+          e.parts.map(({ key: n, value: t }) => [JSON.stringify(n), t])
         )
       };
     case "ParquetPartitioned":
@@ -297,14 +297,14 @@ function Je(e) {
         type: "ParquetPartitioned",
         partitionKeyLength: e.partitionKeyLength,
         parts: Object.fromEntries(
-          e.parts.map(({ key: n, value: r }) => [JSON.stringify(n), r])
+          e.parts.map(({ key: n, value: t }) => [JSON.stringify(n), t])
         )
       };
     default:
-      b(e);
+      S(e);
   }
 }
-function Ne(e, n) {
+function tn(e, n) {
   if (e !== void 0)
     switch (e.type) {
       case "Json":
@@ -312,140 +312,457 @@ function Ne(e, n) {
       case "JsonPartitioned":
         return {
           ...e,
-          parts: e.parts.map((r) => ({
-            key: r.key,
-            value: n(r.value)
+          parts: e.parts.map((t) => ({
+            key: t.key,
+            value: n(t.value)
           }))
         };
       case "BinaryPartitioned":
         return {
           ...e,
-          parts: e.parts.map((r) => ({
-            key: r.key,
+          parts: e.parts.map((t) => ({
+            key: t.key,
             value: {
-              index: n(r.value.index),
-              values: n(r.value.values)
+              index: n(t.value.index),
+              values: n(t.value.values)
             }
           }))
         };
       case "ParquetPartitioned":
         return {
           ...e,
-          parts: e.parts.map((r) => ({
-            key: r.key,
-            value: n(r.value)
+          parts: e.parts.map((t) => ({
+            key: t.key,
+            value: n(t.value)
           }))
         };
     }
 }
-function j(e, n) {
-  const r = Math.floor(n / 8), t = 1 << 7 - n % 8;
-  return (e[r] & t) > 0;
+class rn extends Error {
+  constructor() {
+    super(...arguments);
+    b(this, "name", "AbortError");
+  }
 }
-function _(e, n) {
-  return j(e.absent, n);
+class on extends Error {
+  constructor() {
+    super(...arguments);
+    b(this, "name", "UiError");
+  }
 }
-function z(e, n) {
-  if (e.isNA) return j(e.isNA, n);
-  const r = e.type, t = e.data[n];
-  switch (r) {
-    case "Int":
-      return t === -2147483648;
-    case "Long":
-      return t === -9007199254740991n;
-    case "Float":
-      return Number.isNaN(t);
-    case "Double":
-      return Number.isNaN(t);
-    case "String":
-      return t === null;
-    case "Bytes":
-      return t === null;
-    default:
-      throw Error(`unsupported data type: ${r}`);
+function an(e) {
+  return e instanceof Error && e.name === "AbortError";
+}
+function ce(e) {
+  return e instanceof Error ? e.name === "AbortError" || ce(e.cause) : !1;
+}
+function sn(e) {
+  return e instanceof Error && e.name === "AggregateError";
+}
+class le extends Error {
+  constructor() {
+    super(...arguments);
+    b(this, "name", "PFrameError");
   }
 }
-const H = { type: "absent" };
-function Re(e) {
-  return typeof e == "object" && e !== null && "type" in e && e.type === "absent";
+function un(e) {
+  return e instanceof Error && e.name === "PFrameError";
 }
-const C = null;
-function W(e) {
-  return e === C;
+class cn extends le {
+  constructor() {
+    super(...arguments);
+    b(this, "name", "PFrameError.Driver");
+  }
 }
-function $e(e, n) {
-  return !(n ? n(e) : W(e));
+function ln(e) {
+  return e instanceof Error && e.name === "PFrameError.Driver";
 }
-function F(e, n, r) {
-  const t = e.type;
-  if (t === "Bytes")
-    throw Error("Bytes not yet supported");
-  if (r && "dataType" in r && r.dataType !== void 0 && r.dataType !== t)
-    throw Error(`expected column of type ${r.dataType}, got ${t}`);
-  if (_(e, n))
-    return (r == null ? void 0 : r.absent) !== void 0 ? r.absent : H;
-  if (z(e, n))
-    return (r == null ? void 0 : r.na) !== void 0 ? r.na : C;
-  const i = e.data[n];
-  switch (t) {
-    case "Int":
-      return i;
-    case "Long":
-      return Number(i);
-    case "Float":
-      return i;
-    case "Double":
-      return i;
-    case "String":
-      return i;
+function de(e) {
+  if (typeof e == "string")
+    return `String value was thrown: ${e}`;
+  if (e && typeof e == "object")
+    try {
+      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 e}) was thrown: ${e}`;
+}
+function C(e) {
+  return e instanceof Error ? e : new Error(de(e));
+}
+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 M(e) {
+  const n = C(e), t = n.cause ? M(n.cause) : void 0;
+  return {
+    name: n.name,
+    message: n.message,
+    stack: n.stack,
+    ...n.cause !== void 0 && { cause: t }
+  };
+}
+function dn(e) {
+  if (e.error)
+    throw e.error instanceof Error ? e.error : J(e.error);
+  return e.value;
+}
+function B(e) {
+  return e.error ? { error: M(e.error) } : { value: e.value };
+}
+function fn(e) {
+  return e.error ? { error: J(e.error) } : { value: e.value };
+}
+function fe(e) {
+  try {
+    return { value: e() };
+  } catch (n) {
+    return { error: C(n) };
+  }
+}
+async function pe(e) {
+  try {
+    return { value: await e() };
+  } catch (n) {
+    return { error: C(n) };
   }
 }
-function De(e, n, r) {
-  return F(e, n, r);
+function pn(e) {
+  const n = fe(e);
+  return B(n);
+}
+async function mn(e) {
+  const n = await pe(e);
+  return B(n);
+}
+function hn(e) {
+  return JSON.stringify(e);
 }
-function Le(e, n, r) {
-  return F(e, n, r);
+function m(e) {
+  return F(e);
+}
+function me(e) {
+  return JSON.parse(e);
+}
+const g = {
+  Int: "Int",
+  Long: "Long",
+  Float: "Float",
+  Double: "Double",
+  String: "String",
+  Bytes: "Bytes"
+};
+function I(e, n) {
+  return e == null ? void 0 : e[n];
+}
+function j(e, n, t, r = "readMetadataJsonOrThrow") {
+  const o = I(e, t);
+  if (o === void 0) return;
+  const i = n[t];
+  try {
+    const s = JSON.parse(o);
+    return i.parse(s);
+  } catch (s) {
+    throw new Error(
+      `${r} failed, key: ${String(t)}, value: ${o}, error: ${C(s)}`
+    );
+  }
+}
+function U(e, n, t) {
+  try {
+    return j(e, n, t);
+  } catch {
+    return;
+  }
 }
-function Ve(e) {
+const yn = {
+  Alphabet: "pl7.app/alphabet",
+  BlockId: "pl7.app/blockId"
+}, q = {};
+function gn(e, n) {
+  return I(e == null ? void 0 : e.domain, n);
+}
+function bn(e, n) {
+  return j(e == null ? void 0 : e.domain, q, n, "readDomainJsonOrThrow");
+}
+function wn(e, n) {
+  return U(e == null ? void 0 : e.domain, q, n);
+}
+const y = {
+  Alphabet: "pl7.app/alphabet",
+  DiscreteValues: "pl7.app/discreteValues",
+  Format: "pl7.app/format",
+  Graph: {
+    IsVirtual: "pl7.app/graph/isVirtual"
+  },
+  HideDataFromUi: "pl7.app/hideDataFromUi",
+  IsLinkerColumn: "pl7.app/isLinkerColumn",
+  Label: "pl7.app/label",
+  Max: "pl7.app/max",
+  Min: "pl7.app/min",
+  Parents: "pl7.app/parents",
+  Sequence: {
+    Annotation: {
+      Mapping: "pl7.app/sequence/annotation/mapping"
+    },
+    IsAnnotation: "pl7.app/sequence/isAnnotation"
+  },
+  Table: {
+    FontFamily: "pl7.app/table/fontFamily",
+    OrderPriority: "pl7.app/table/orderPriority",
+    Visibility: "pl7.app/table/visibility"
+  },
+  Trace: "pl7.app/trace"
+}, he = l.object({
+  type: l.nativeEnum(g),
+  name: l.string(),
+  domain: l.record(l.string(), l.string()).optional(),
+  annotations: l.record(l.string(), l.string()).optional(),
+  parentAxes: l.array(l.number()).optional()
+}).passthrough(), W = {
+  [y.DiscreteValues]: l.array(l.string()).or(l.array(l.number())),
+  [y.Graph.IsVirtual]: l.boolean(),
+  [y.HideDataFromUi]: l.boolean(),
+  [y.IsLinkerColumn]: l.boolean(),
+  [y.Max]: l.number(),
+  [y.Min]: l.number(),
+  [y.Parents]: l.array(he),
+  [y.Sequence.Annotation.Mapping]: l.record(l.string(), l.string()),
+  [y.Sequence.IsAnnotation]: l.boolean(),
+  [y.Table.OrderPriority]: l.number(),
+  [y.Trace]: l.record(l.string(), l.unknown())
+};
+function An(e, n) {
+  return I(e == null ? void 0 : e.annotations, n);
+}
+function vn(e, n) {
+  return j(e == null ? void 0 : e.annotations, W, n, "readAnnotationJsonOrThrow");
+}
+function z(e, n) {
+  return U(e == null ? void 0 : e.annotations, W, n);
+}
+function O(e) {
+  return { axis: e, children: [] };
+}
+function k(e) {
+  const n = O(e);
+  let t = [n];
+  for (; t.length; ) {
+    const r = [];
+    for (const o of t)
+      o.children = o.axis.parentAxesSpec.map(O), r.push(...o.children);
+    t = r;
+  }
+  return n;
+}
+function xn(e) {
+  const n = /* @__PURE__ */ new Set([m(p(e.axis))]);
+  let t = [e];
+  for (; t.length; ) {
+    const r = [];
+    for (const o of t)
+      for (const i of o.children)
+        n.add(m(p(i.axis))), r.push(i);
+    t = r;
+  }
+  return n;
+}
+function P(e) {
+  const n = [e.axis];
+  let t = [e];
+  for (; t.length; ) {
+    const r = [];
+    for (const o of t)
+      for (const i of o.children)
+        n.push(i.axis), r.push(i);
+    t = r;
+  }
+  return n;
+}
+function D(e) {
+  return m(P(k(e)).map(p));
+}
+function ye(e, n) {
+  if (e.name !== n.name)
+    return e.name < n.name ? 1 : -1;
+  if (e.type !== n.type)
+    return e.type < n.type ? 1 : -1;
+  const t = m(e.domain ?? {}), r = m(n.domain ?? {});
+  if (t !== r)
+    return t < r ? 1 : -1;
+  const o = D(e), i = D(n);
+  if (o !== i)
+    return o < i ? 1 : -1;
+  const s = m(e.annotations ?? {}), a = m(n.annotations ?? {});
+  return s !== a ? s < a ? 1 : -1 : 0;
+}
+function ge(e) {
+  const n = z(e, y.Parents);
+  return n === void 0 ? [] : n;
+}
+function H(e) {
+  e.parentAxesSpec.forEach(H), e.parentAxesSpec.sort(ye);
+}
+function be(e) {
+  let t = [O(e)];
+  const r = new Set(m(p(e)));
+  for (; t.length; ) {
+    const o = [], i = /* @__PURE__ */ new Set();
+    for (const s of t) {
+      s.children = s.axis.parentAxesSpec.map(O);
+      for (const a of s.children) {
+        const u = m(p(a.axis));
+        if (!i.has(u)) {
+          if (o.push(a), i.add(u), r.has(u))
+            return !0;
+          r.add(u);
+        }
+      }
+    }
+    t = o;
+  }
+  return !1;
+}
+function _(e) {
+  if (!e.length)
+    return [];
+  const n = e.map((t) => {
+    const { parentAxes: r, ...o } = t;
+    return { ...o, annotations: { ...o.annotations }, parentAxesSpec: [] };
+  });
+  return e.forEach((t, r) => {
+    var i;
+    const o = n[r];
+    t.parentAxes ? o.parentAxesSpec = t.parentAxes.map((s) => n[s]) : (o.parentAxesSpec = _(ge(t)), (i = o.annotations) == null || delete i[y.Parents]);
+  }), n.some(be) ? n.forEach((t) => {
+    t.parentAxesSpec = [];
+  }) : n.forEach((t) => {
+    H(t);
+  }), n;
+}
+function kn(e) {
+  const n = e.map((t) => m(p(t)));
+  return e.map((t) => {
+    const o = t.parentAxesSpec.map((a) => m(p(a))).map((a) => n.indexOf(a)), { parentAxesSpec: i, ...s } = t;
+    return o.length ? { ...s, parentAxes: o } : s;
+  });
+}
+const Pn = {
+  Label: "pl7.app/label",
+  Table: {
+    RowSelection: "pl7.app/table/row-selection"
+  }
+};
+function Sn(e) {
   return {
     kind: e.kind,
     valueType: e.valueType,
     name: e.name,
     domain: e.domain,
     parentAxes: e.parentAxes,
-    axesId: J(e.axesSpec)
+    axesId: G(e.axesSpec)
   };
 }
-function Te(e) {
+function En(e) {
   return {
     columnId: e.id,
     spec: e.spec
   };
 }
-function h(e) {
-  const { type: n, name: r, domain: t } = e, i = { type: n, name: r };
-  return t && Object.entries(t).length > 0 && Object.assign(i, { domain: t }), i;
+function p(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(e) {
-  return e.map(h);
+function G(e) {
+  return e.map(p);
 }
-function Ie(e) {
-  return y(h(e));
+function On(e) {
+  return m(p(e));
 }
-function G(e, n) {
+function we(e, n) {
   if (e === void 0) return n === void 0;
   if (n === void 0) return !0;
-  for (const r in n)
-    if (e[r] !== n[r]) return !1;
+  for (const t in n)
+    if (e[t] !== n[t]) return !1;
   return !0;
 }
-function X(e, n) {
-  return e.name === n.name && G(e.domain, n.domain);
+function Ae(e, n) {
+  return e.name === n.name && we(e.domain, n.domain);
+}
+function Q(e, n) {
+  const t = Math.floor(n / 8), r = 1 << 7 - n % 8;
+  return (e[t] & r) > 0;
+}
+function ve(e, n) {
+  return Q(e.absent, n);
+}
+function xe(e, n) {
+  if (e.isNA) return Q(e.isNA, n);
+  const t = e.type, r = e.data[n];
+  switch (t) {
+    case g.Int:
+      return r === -2147483648;
+    case g.Long:
+      return r === -9007199254740991n;
+    case g.Float:
+      return Number.isNaN(r);
+    case g.Double:
+      return Number.isNaN(r);
+    case g.String:
+      return r === null;
+    case g.Bytes:
+      return r === null;
+    default:
+      throw Error(`unsupported data type: ${t}`);
+  }
+}
+const ke = { type: "absent" };
+function Fn(e) {
+  return typeof e == "object" && e !== null && "type" in e && e.type === "absent";
 }
-function Be(e, n) {
-  return { ...e, src: v(e.src, n) };
+const X = null;
+function Pe(e) {
+  return e === X;
 }
-function v(e, n) {
+function Cn(e, n) {
+  return !(n ? n(e) : Pe(e));
+}
+function Y(e, n, t) {
+  const r = e.type;
+  if (r === g.Bytes)
+    throw Error("Bytes not yet supported");
+  if (t && "dataType" in t && t.dataType !== void 0 && t.dataType !== r)
+    throw Error(`expected column of type ${t.dataType}, got ${r}`);
+  if (ve(e, n))
+    return (t == null ? void 0 : t.absent) !== void 0 ? t.absent : ke;
+  if (xe(e, n))
+    return (t == null ? void 0 : t.na) !== void 0 ? t.na : X;
+  const o = e.data[n];
+  switch (r) {
+    case g.Int:
+      return o;
+    case g.Long:
+      return Number(o);
+    case g.Float:
+      return o;
+    case g.Double:
+      return o;
+    case g.String:
+      return o;
+  }
+}
+function Ln(e, n, t) {
+  return Y(e, n, t);
+}
+function Jn(e, n, t) {
+  return Y(e, n, t);
+}
+function In(e, n) {
+  return { ...e, src: E(e.src, n) };
+}
+function E(e, n) {
   switch (e.type) {
     case "column":
       return {
@@ -465,19 +782,19 @@ function v(e, n) {
     case "full":
       return {
         type: e.type,
-        entries: e.entries.map((r) => v(r, n))
+        entries: e.entries.map((t) => E(t, n))
       };
     case "outer":
       return {
         type: "outer",
-        primary: v(e.primary, n),
-        secondary: e.secondary.map((r) => v(r, n))
+        primary: E(e.primary, n),
+        secondary: e.secondary.map((t) => E(t, n))
       };
     default:
-      b(e);
+      S(e);
   }
 }
-function Ue(e) {
+function jn(e) {
   switch (e.type) {
     case "axis":
       return {
@@ -491,49 +808,49 @@ function Ue(e) {
       };
   }
 }
-function Q(e) {
-  return y(e);
+function Se(e) {
+  return F(e);
 }
-function qe(e) {
+function Dn(e) {
   return JSON.parse(e);
 }
-function k(e) {
-  return y(h(e));
+function N(e) {
+  return F(p(e));
 }
-function A(e, n) {
+function R(e, n) {
   return JSON.stringify([e, n]);
 }
-class Ke {
+class Nn {
   /**
    * Creates a new anchor context from a set of anchor column specifications
    * @param anchors Record of anchor column specifications indexed by anchor ID
    */
   constructor(n) {
-    f(this, "domains", /* @__PURE__ */ new Map());
-    f(this, "axes", /* @__PURE__ */ new Map());
+    b(this, "domains", /* @__PURE__ */ new Map());
+    b(this, "axes", /* @__PURE__ */ new Map());
     /**
      * Domain packs are used to group domain keys that can be anchored to the same anchor
      * This is used to optimize the lookup of domain anchors
      */
-    f(this, "domainPacks", []);
+    b(this, "domainPacks", []);
     /**
      * Maps domain packs to anchors
      */
-    f(this, "domainPackToAnchor", /* @__PURE__ */ new Map());
+    b(this, "domainPackToAnchor", /* @__PURE__ */ new Map());
     this.anchors = n;
-    const r = Object.entries(n);
-    r.sort((t, i) => t[0].localeCompare(i[0]));
-    for (const [t, i] of r) {
-      for (let o = 0; o < i.axesSpec.length; o++) {
-        const s = i.axesSpec[o], a = k(s);
-        this.axes.set(a, { anchor: t, idx: o });
+    const t = Object.entries(n);
+    t.sort((r, o) => r[0].localeCompare(o[0]));
+    for (const [r, o] of t) {
+      for (let i = 0; i < o.axesSpec.length; i++) {
+        const s = o.axesSpec[i], a = N(s);
+        this.axes.set(a, { anchor: r, idx: i });
       }
-      if (i.domain !== void 0) {
-        const o = Object.entries(i.domain);
-        o.sort((s, a) => s[0].localeCompare(a[0])), this.domainPackToAnchor.set(JSON.stringify(o), t), this.domainPacks.push(o.map(([s]) => s));
-        for (const [s, a] of o) {
-          const u = A(s, a);
-          this.domains.set(u, t);
+      if (o.domain !== void 0) {
+        const i = Object.entries(o.domain);
+        i.sort((s, a) => s[0].localeCompare(a[0])), this.domainPackToAnchor.set(JSON.stringify(i), r), this.domainPacks.push(i.map(([s]) => s));
+        for (const [s, a] of i) {
+          const u = R(s, a);
+          this.domains.set(u, r);
         }
       }
     }
@@ -541,12 +858,12 @@ class Ke {
   /**
    * Implementation of derive method
    */
-  derive(n, r) {
-    const t = {
+  derive(n, t) {
+    const r = {
       name: n.name,
       axes: []
     };
-    let i;
+    let o;
     if (n.domain !== void 0)
       e:
         for (const s of this.domainPacks) {
@@ -560,38 +877,38 @@ class Ke {
           }
           const u = this.domainPackToAnchor.get(JSON.stringify(a));
           if (u !== void 0) {
-            t.domainAnchor = u, i = new Set(s);
+            r.domainAnchor = u, o = new Set(s);
             break;
           }
         }
     for (const [s, a] of Object.entries(n.domain ?? {})) {
-      if (i !== void 0 && i.has(s))
+      if (o !== void 0 && o.has(s))
         continue;
-      const u = A(s, a), c = this.domains.get(u);
-      t.domain ?? (t.domain = {}), t.domain[s] = c ? { anchor: c } : a;
+      const u = R(s, a), c = this.domains.get(u);
+      r.domain ?? (r.domain = {}), r.domain[s] = c ? { anchor: c } : a;
     }
-    if (t.axes = n.axesSpec.map((s) => {
-      const a = k(s), u = this.axes.get(a);
-      return u === void 0 ? h(s) : u;
-    }), !r || r.length === 0)
-      return t;
-    const o = [];
-    for (const s of r) {
+    if (r.axes = n.axesSpec.map((s) => {
+      const a = N(s), u = this.axes.get(a);
+      return u === void 0 ? p(s) : u;
+    }), !t || t.length === 0)
+      return r;
+    const i = [];
+    for (const s of t) {
       const [a, u] = s;
       if (typeof a == "number") {
         if (a < 0 || a >= n.axesSpec.length)
           throw new Error(`Axis index ${a} is out of bounds (0-${n.axesSpec.length - 1})`);
-        o.push([a, u]);
+        i.push([a, u]);
       } else {
         const c = n.axesSpec.findIndex((d) => d.name === a);
         if (c === -1)
           throw new Error(`Axis with name "${a}" not found in the column specification`);
-        o.push([c, u]);
+        i.push([c, u]);
       }
     }
-    return o.sort((s, a) => s[0] - a[0]), {
-      source: t,
-      axisFilters: o
+    return i.sort((s, a) => s[0] - a[0]), {
+      source: r,
+      axisFilters: i
     };
   }
   /**
@@ -600,155 +917,155 @@ class Ke {
    * @param axisFilters Optional axis filters to apply to the column
    * @returns A canonicalized string representation of the anchored column identifier
    */
-  deriveS(n, r) {
-    return Q(this.derive(n, r));
+  deriveS(n, t) {
+    return Se(this.derive(n, t));
   }
 }
-function Me(e, n, r) {
-  const t = { ...n }, i = (r == null ? void 0 : r.ignoreMissingDomains) ?? !1;
-  if (t.domainAnchor !== void 0) {
-    const o = e[t.domainAnchor];
-    if (!o)
-      throw new Error(`Anchor "${t.domainAnchor}" not found`);
-    const s = o.domain || {};
-    t.domain = { ...s, ...t.domain }, delete t.domainAnchor;
+function Rn(e, n, t) {
+  const r = { ...n }, o = (t == null ? void 0 : t.ignoreMissingDomains) ?? !1;
+  if (r.domainAnchor !== void 0) {
+    const i = e[r.domainAnchor];
+    if (!i)
+      throw new Error(`Anchor "${r.domainAnchor}" not found`);
+    const s = i.domain || {};
+    r.domain = { ...s, ...r.domain }, delete r.domainAnchor;
   }
-  if (t.domain) {
-    const o = {};
-    for (const [s, a] of Object.entries(t.domain))
+  if (r.domain) {
+    const i = {};
+    for (const [s, a] of Object.entries(r.domain))
       if (typeof a == "string")
-        o[s] = a;
+        i[s] = a;
       else {
         const u = e[a.anchor];
         if (!u)
           throw new Error(`Anchor "${a.anchor}" not found for domain key "${s}"`);
         if (!u.domain || u.domain[s] === void 0) {
-          if (!i)
+          if (!o)
             throw new Error(`Domain key "${s}" not found in anchor "${a.anchor}"`);
           continue;
         }
-        o[s] = u.domain[s];
+        i[s] = u.domain[s];
       }
-    t.domain = o;
+    r.domain = i;
   }
-  return t.axes && (t.axes = t.axes.map((o) => Y(e, o))), t;
+  return r.axes && (r.axes = r.axes.map((i) => Ee(e, i))), r;
 }
-function Y(e, n) {
-  if (!Z(n))
+function Ee(e, n) {
+  if (!Oe(n))
     return n;
-  const r = n.anchor, t = e[r];
-  if (!t)
-    throw new Error(`Anchor "${r}" not found for axis reference`);
+  const t = n.anchor, r = e[t];
+  if (!r)
+    throw new Error(`Anchor "${t}" not found for axis reference`);
   if ("idx" in n) {
-    if (n.idx < 0 || n.idx >= t.axesSpec.length)
-      throw new Error(`Axis index ${n.idx} out of bounds for anchor "${r}"`);
-    return t.axesSpec[n.idx];
+    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 i = t.axesSpec.filter((o) => o.name === n.name);
-    if (i.length > 1)
-      throw new Error(`Multiple axes with name "${n.name}" found in anchor "${r}"`);
-    if (i.length === 0)
-      throw new Error(`Axis with name "${n.name}" not found in anchor "${r}"`);
-    return i[0];
+    const o = r.axesSpec.filter((i) => i.name === n.name);
+    if (o.length > 1)
+      throw new Error(`Multiple axes with name "${n.name}" found in anchor "${t}"`);
+    if (o.length === 0)
+      throw new Error(`Axis with name "${n.name}" not found in anchor "${t}"`);
+    return o[0];
   } else if ("id" in n) {
-    const i = t.axesSpec.filter((o) => X(n.id, h(o)));
-    if (i.length > 1)
-      throw new Error(`Multiple matching axes found for matcher in anchor "${r}"`);
-    if (i.length === 0)
-      throw new Error(`No matching axis found for matcher in anchor "${r}"`);
-    return i[0];
+    const o = r.axesSpec.filter((i) => Ae(n.id, p(i)));
+    if (o.length > 1)
+      throw new Error(`Multiple matching axes found for matcher in anchor "${t}"`);
+    if (o.length === 0)
+      throw new Error(`No matching axis found for matcher in anchor "${t}"`);
+    return o[0];
   }
   throw new Error("Unsupported axis reference type");
 }
-function Z(e) {
+function Oe(e) {
   return typeof e == "object" && "anchor" in e;
 }
-function _e(e) {
+function Tn(e) {
   return typeof e == "object" && e !== null && "source" in e && "axisFilters" in e;
 }
-function l(e) {
+function w(e) {
   return e.kind === "PColumn";
 }
-function ee(e) {
-  return l(e.spec);
+function Fe(e) {
+  return w(e.spec);
 }
-function ze(e) {
-  return l(e.obj);
+function $n(e) {
+  return w(e.obj);
 }
-function He(e) {
-  return l(e.obj.spec);
+function Kn(e) {
+  return w(e.obj.spec);
 }
-function We(e) {
-  if (!ee(e)) throw new Error(`not a PColumn (kind = ${e.spec.kind})`);
+function Vn(e) {
+  if (!Fe(e)) throw new Error(`not a PColumn (kind = ${e.spec.kind})`);
   return e;
 }
-function Ge(e, n) {
+function Mn(e, n) {
   return e === void 0 ? void 0 : {
     ...e,
     data: n(e.data)
   };
 }
-function Xe(e) {
-  const n = /* @__PURE__ */ new Map(), r = (t) => {
-    switch (t.type) {
+function Bn(e) {
+  const n = /* @__PURE__ */ new Map(), t = (r) => {
+    switch (r.type) {
       case "column":
-        n.set(t.column.id, t.column);
+        n.set(r.column.id, r.column);
         return;
       case "slicedColumn":
-        n.set(t.column.id, t.column);
+        n.set(r.column.id, r.column);
         return;
       case "inlineColumn":
         return;
       case "full":
       case "inner":
-        for (const i of t.entries) r(i);
+        for (const o of r.entries) t(o);
         return;
       case "outer":
-        r(t.primary);
-        for (const i of t.secondary) r(i);
+        t(r.primary);
+        for (const o of r.secondary) t(o);
         return;
       default:
-        b(t);
+        S(r);
     }
   };
-  return r(e), [...n.values()];
+  return t(e), [...n.values()];
 }
-function ne(e) {
+function Ce(e) {
   throw new Error("Unexpected object: " + e);
 }
-function g(e, n) {
+function L(e, n) {
   switch (e.type) {
     case "and":
-      for (const r of e.operands)
-        if (!g(r, n)) return !1;
+      for (const t of e.operands)
+        if (!L(t, n)) return !1;
       return !0;
     case "or":
-      for (const r of e.operands)
-        if (g(r, n)) return !0;
+      for (const t of e.operands)
+        if (L(t, n)) return !0;
       return !1;
     case "not":
-      return !g(e.operand, n);
+      return !L(e.operand, n);
     case "name":
-      return l(n) && n.name === e.name;
+      return w(n) && n.name === e.name;
     case "name_pattern":
-      return l(n) && !!n.name.match(e.pattern);
+      return w(n) && !!n.name.match(e.pattern);
     case "annotation":
-      return l(n) && n.annotations !== void 0 && n.annotations[e.annotation] === e.value;
+      return w(n) && n.annotations !== void 0 && n.annotations[e.annotation] === e.value;
     case "annotation_pattern":
-      return l(n) && n.annotations !== void 0 && n.annotations[e.annotation] !== void 0 && !!n.annotations[e.annotation].match(e.pattern);
+      return w(n) && n.annotations !== void 0 && n.annotations[e.annotation] !== void 0 && !!n.annotations[e.annotation].match(e.pattern);
     case "has_axes":
-      return l(n) && e.axes.every(
-        (r) => n.axesSpec.some(
-          (t) => (r.type === void 0 || r.type === t.type) && (r.name === void 0 || r.name === t.name) && (r.domain === void 0 || Object.keys(r.domain).length === 0 || t.domain !== void 0 && Object.entries(r.domain).every(
-            ([i, o]) => t.domain[i] === o
+      return w(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, i]) => r.domain[o] === i
           ))
         )
       );
     default:
-      ne(e);
+      Ce(e);
   }
 }
-function x(e, n) {
+function T(e, n) {
   if (e.name !== void 0 && e.name !== n.name)
     return !1;
   if (e.type !== void 0) {
@@ -759,14 +1076,14 @@ function x(e, n) {
       return !1;
   }
   if (e.domain !== void 0) {
-    const r = n.domain || {};
-    for (const [t, i] of Object.entries(e.domain))
-      if (r[t] !== i)
+    const t = n.domain || {};
+    for (const [r, o] of Object.entries(e.domain))
+      if (t[r] !== o)
         return !1;
   }
   return !0;
 }
-function E(e, n) {
+function $(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 (n.type !== void 0) {
@@ -777,64 +1094,236 @@ function E(e, n) {
       return !1;
   }
   if (n.domain !== void 0) {
-    const r = e.domain || {};
-    for (const [t, i] of Object.entries(n.domain))
-      if (r[t] !== i)
+    const t = e.domain || {};
+    for (const [r, o] of Object.entries(n.domain))
+      if (t[r] !== o)
         return !1;
   }
   if (n.axes !== void 0) {
-    const r = e.axesSpec.map(h);
+    const t = e.axesSpec.map(p);
     if (n.partialAxesMatch) {
-      for (const t of n.axes)
-        if (!r.some((i) => x(t, i)))
+      for (const r of n.axes)
+        if (!t.some((o) => T(r, o)))
           return !1;
     } else {
-      if (r.length !== n.axes.length)
+      if (t.length !== n.axes.length)
         return !1;
-      for (let t = 0; t < n.axes.length; t++)
-        if (!x(n.axes[t], r[t]))
+      for (let r = 0; r < n.axes.length; r++)
+        if (!T(n.axes[r], t[r]))
           return !1;
     }
   }
   if (n.annotations !== void 0) {
-    const r = e.annotations || {};
-    for (const [t, i] of Object.entries(n.annotations))
-      if (r[t] !== i)
+    const t = e.annotations || {};
+    for (const [r, o] of Object.entries(n.annotations))
+      if (t[r] !== o)
         return !1;
   }
   if (n.annotationPatterns !== void 0) {
-    const r = e.annotations || {};
-    for (const [t, i] of Object.entries(n.annotationPatterns)) {
-      const o = r[t];
-      if (o === void 0 || !new RegExp(i).test(o))
+    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 Qe(e) {
-  return Array.isArray(e) ? (n) => e.some((r) => l(n) && E(n, r)) : (n) => l(n) && E(n, e);
+function Un(e) {
+  return Array.isArray(e) ? (n) => e.some((t) => w(n) && $(n, t)) : (n) => w(n) && $(n, e);
 }
-function Ye(e) {
+function qn(e) {
   const n = {
     kind: e.kind,
     name: e.name
   };
-  return e.domain !== void 0 && (n.domain = e.domain), l(e) && (n.axesSpec = J(e.axesSpec)), y(n);
+  return e.domain !== void 0 && (n.domain = e.domain), w(e) && (n.axesSpec = G(e.axesSpec)), F(n);
 }
-const Ze = { href: "/" }, en = m.object({
-  __isRef: m.literal(!0).describe("Crucial marker for the block dependency tree reconstruction"),
-  blockId: m.string().describe("Upstream block id"),
-  name: m.string().describe("Name of the output provided to the upstream block's output context"),
-  requireEnrichments: m.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")
+class A {
+  constructor(n) {
+    /** Graph of linkers connected by axes (single or grouped by parents) */
+    b(this, "data");
+    this.data = n;
+  }
+  get keys() {
+    return this.data.keys();
+  }
+  get keyAxesIds() {
+    return [...this.data.keys()].map(me);
+  }
+  static fromColumns(n) {
+    var r, o;
+    const t = /* @__PURE__ */ new Map();
+    for (const i of n.filter((s) => !!z(s.spec, y.IsLinkerColumn))) {
+      const s = A.getAxesGroups(_(i.spec.axesSpec));
+      if (s.length !== 2)
+        continue;
+      const [a, u] = s, c = A.getAxesRoots(a).map((f) => {
+        const h = P(k(f));
+        return [m(h.map(p)), h];
+      }), d = A.getAxesRoots(u).map((f) => {
+        const h = P(k(f));
+        return [m(h.map(p)), h];
+      });
+      for (const [f, h] of c)
+        t.has(f) || t.set(f, { keyAxesSpec: h, linkWith: /* @__PURE__ */ new Map() });
+      for (const [f, h] of d)
+        t.has(f) || t.set(f, { keyAxesSpec: h, linkWith: /* @__PURE__ */ new Map() });
+      for (const [f] of c)
+        for (const [h] of d)
+          (r = t.get(f)) == null || r.linkWith.set(h, i), (o = t.get(h)) == null || o.linkWith.set(f, i);
+    }
+    return new this(t);
+  }
+  /** Get all available nodes of linker graphs if start from sourceAxesKeys */
+  searchAvailableAxesKeys(n) {
+    const t = new Set(n), r = /* @__PURE__ */ new Set();
+    let o = n;
+    for (; o.length; ) {
+      const i = [];
+      for (const s of o) {
+        const a = this.data.get(s);
+        if (a)
+          for (const u of a.linkWith.keys())
+            !r.has(u) && !t.has(u) && (i.push(u), r.add(u));
+      }
+      o = i;
+    }
+    return r;
+  }
+  /** Get all linker columns that are necessary to reach endKey from startKey */
+  searchLinkerPath(n, t) {
+    const r = {};
+    let o = /* @__PURE__ */ new Set([n]);
+    const i = /* @__PURE__ */ new Set([n]);
+    for (; o.size; ) {
+      const s = /* @__PURE__ */ new Set();
+      for (const a of o) {
+        const u = this.data.get(a);
+        if (u)
+          for (const c of u.linkWith.keys())
+            if (r[c] = a, c === t) {
+              const d = [];
+              let f = t;
+              for (; r[f] !== n; )
+                d.push(f), f = r[f];
+              return d.push(f), d.map((h) => this.data.get(h).linkWith.get(r[h]));
+            } else i.has(c) || (s.add(c), i.add(c));
+      }
+      o = s;
+    }
+    return [];
+  }
+  getLinkerColumnsForAxes({
+    from: n,
+    to: t,
+    throwWhenNoLinkExists: r = !0
+  }) {
+    const o = n.map(A.getLinkerKeyFromAxisSpec);
+    return Array.from(
+      new Map(
+        A.getAxesRoots(t).map(A.getLinkerKeyFromAxisSpec).flatMap((i) => {
+          const s = o.map((a) => this.searchLinkerPath(a, i)).reduce(
+            (a, u) => a.length && a.length < u.length || !u.length ? a : u,
+            []
+          ).map((a) => [a.columnId, a]);
+          if (!s.length && r)
+            throw Error(`Unable to find linker column for ${i}`);
+          return s;
+        })
+      ).values()
+    );
+  }
+  /** Get list of axisSpecs from keys of linker columns map  */
+  getAxesListFromKeysList(n) {
+    return Array.from(
+      new Map(
+        n.flatMap((t) => {
+          var r;
+          return ((r = this.data.get(t)) == null ? void 0 : r.keyAxesSpec) ?? [];
+        }).map((t) => [m(p(t)), t])
+      ).values()
+    );
+  }
+  /** Get axes of target axes that are impossible to be linked to source axes with current linker map */
+  getNonLinkableAxes(n, t) {
+    const r = n.map(A.getLinkerKeyFromAxisSpec), o = t.map(A.getLinkerKeyFromAxisSpec);
+    return Array.from(
+      new Map(
+        t.filter((s, a) => {
+          const u = o[a];
+          return !r.some((c) => this.searchLinkerPath(c, u).length);
+        }).flatMap((s) => P(k(s)).map((a) => [m(p(a)), a]))
+      ).values()
+    );
+  }
+  /** Get all axes that can be connected to sourceAxes by linkers */
+  getReachableByLinkersAxesFromAxes(n) {
+    const t = n.map(A.getLinkerKeyFromAxisSpec), r = this.searchAvailableAxesKeys(t);
+    return this.getAxesListFromKeysList([...r]);
+  }
+  static getLinkerKeyFromAxisSpec(n) {
+    return m(P(k(n)).map(p));
+  }
+  /**  Split array of axes into several arrays by parents: axes of one group are parents for each other.
+     There are no order inside every group. */
+  static getAxesGroups(n) {
+    switch (n.length) {
+      case 0:
+        return [];
+      case 1:
+        return [[n[0]]];
+    }
+    const t = n.map((u) => m(p(u))), r = n.map(
+      (u) => new Set(
+        u.parentAxesSpec.map((c) => m(p(c))).map((c) => {
+          const d = t.indexOf(c);
+          if (d === -1)
+            throw new Error(`malformed axesSpec: ${JSON.stringify(n)}, unable to locate parent ${c}`);
+          return d;
+        })
+      )
+    ), o = [...n.keys()], i = [], s = /* @__PURE__ */ new Set();
+    let a = o.find((u) => !s.has(u));
+    for (; a !== void 0; ) {
+      const u = [a];
+      s.add(a);
+      let c = [a];
+      for (; c.length; ) {
+        const d = /* @__PURE__ */ new Set();
+        for (const f of c) {
+          const h = r[f];
+          o.forEach((v) => {
+            if (v === f || s.has(v))
+              return;
+            (r[v].has(f) || h.has(v)) && (u.push(v), d.add(v), s.add(v));
+          });
+        }
+        c = [...d];
+      }
+      i.push([...u]), a = o.find((d) => !s.has(d));
+    }
+    return i.map((u) => u.map((c) => n[c]));
+  }
+  /** Get all axes that are not parents of any other axis */
+  static getAxesRoots(n) {
+    const t = new Set(n.flatMap((r) => r.parentAxesSpec).map((r) => m(p(r))));
+    return n.filter((r) => !t.has(m(p(r))));
+  }
+}
+const Wn = { href: "/" }, zn = l.object({
+  __isRef: l.literal(!0).describe("Crucial marker for the block dependency tree reconstruction"),
+  blockId: l.string().describe("Upstream block id"),
+  name: l.string().describe("Name of the output provided to the upstream block's output context"),
+  requireEnrichments: l.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 nn(e) {
+function Hn(e) {
   return typeof e == "object" && e !== null && "__isRef" in e && e.__isRef === !0 && "blockId" in e && "name" in e;
 }
-function rn(e, n, r = !1) {
-  return r ? {
+function _n(e, n, t = !1) {
+  return t ? {
     __isRef: !0,
     blockId: e,
     name: n,
@@ -845,24 +1334,24 @@ function rn(e, n, r = !1) {
     name: n
   };
 }
-function tn(e, n = !0) {
+function Gn(e, n = !0) {
   if (n)
     return {
       ...e,
       requireEnrichments: !0
     };
   {
-    const { requireEnrichments: r, ...t } = e;
-    return t;
+    const { requireEnrichments: t, ...r } = e;
+    return r;
   }
 }
-function on(e, n, r = !1) {
-  return e.blockId === n.blockId && e.name === n.name && (r || e.requireEnrichments === n.requireEnrichments);
+function Qn(e, n, t = !1) {
+  return e.blockId === n.blockId && e.name === n.name && (t || e.requireEnrichments === n.requireEnrichments);
 }
-function an(e, n) {
+function Xn(e, n) {
   return e.ok ? { ok: !0, value: n(e.value) } : e;
 }
-function re(e) {
+function Le(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);
@@ -870,183 +1359,75 @@ function re(e) {
     "Expected `data` to be an ArrayBuffer, Buffer, Int8Array, Uint8Array or Uint8ClampedArray"
   );
 }
-const te = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567", ie = "0123456789ABCDEFGHIJKLMNOPQRSTUV", oe = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
-function N(e, n, r) {
-  r = r || {};
-  let t, i;
+const Je = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567", Ie = "0123456789ABCDEFGHIJKLMNOPQRSTUV", je = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
+function Z(e, n, t) {
+  t = t || {};
+  let r, o;
   switch (n) {
     case "RFC3548":
     case "RFC4648":
-      t = te, i = !0;
+      r = Je, o = !0;
       break;
     case "RFC4648-HEX":
-      t = ie, i = !0;
+      r = Ie, o = !0;
       break;
     case "Crockford":
-      t = oe, i = !1;
+      r = je, o = !1;
       break;
     default:
       throw new Error("Unknown base32 variant: " + String(n));
   }
-  const o = r.padding !== void 0 ? r.padding : i, s = re(e);
+  const i = t.padding !== void 0 ? t.padding : o, s = Le(e);
   let a = 0, u = 0, c = "";
   for (let d = 0; d < s.byteLength; d++)
     for (u = u << 8 | s.getUint8(d), a += 8; a >= 5; )
-      c += t[u >>> a - 5 & 31], a -= 5;
-  if (a > 0 && (c += t[u << 5 - a & 31]), o)
+      c += r[u >>> a - 5 & 31], a -= 5;
+  if (a > 0 && (c += r[u << 5 - a & 31]), i)
     for (; c.length % 8 !== 0; )
       c += "=";
   return c;
 }
-const R = 15, ae = 24, $ = m.string().length(ae).regex(/[ABCDEFGHIJKLMNOPQRSTUVWXYZ234567]/).brand("PlId");
-function sn() {
-  const e = new Uint8Array(R);
-  return crypto.getRandomValues(e), $.parse(N(e, "RFC4648"));
-}
-function se(e) {
-  if (e.length !== R) throw new Error(`Wrong number of bytes: ${e.length}`);
-  return $.parse(N(e, "RFC4648"));
-}
-async function un(e) {
-  const n = new TextEncoder(), r = await crypto.subtle.digest("SHA-256", n.encode(e));
-  return se(new Uint8Array(r.slice(0, 15)));
-}
-function cn(e) {
-  return JSON.stringify(e);
-}
-function dn(e) {
-  return y(e);
-}
-function fn(e) {
-  return JSON.parse(e);
-}
-class ln extends Error {
-  constructor() {
-    super(...arguments);
-    f(this, "name", "AbortError");
-  }
-}
-class mn extends Error {
-  constructor() {
-    super(...arguments);
-    f(this, "name", "UiError");
-  }
-}
-function pn(e) {
-  return e instanceof Error && e.name === "AbortError";
-}
-function ue(e) {
-  return e instanceof Error ? e.name === "AbortError" || ue(e.cause) : !1;
-}
-function hn(e) {
-  return e instanceof Error && e.name === "AggregateError";
-}
-class ce extends Error {
-  constructor() {
-    super(...arguments);
-    f(this, "name", "PFrameError");
-  }
+const ee = 15, De = 24, ne = l.string().length(De).regex(/[ABCDEFGHIJKLMNOPQRSTUVWXYZ234567]/).brand("PlId");
+function Yn() {
+  const e = new Uint8Array(ee);
+  return crypto.getRandomValues(e), ne.parse(Z(e, "RFC4648"));
 }
-function yn(e) {
-  return e instanceof Error && e.name === "PFrameError";
+function Ne(e) {
+  if (e.length !== ee) throw new Error(`Wrong number of bytes: ${e.length}`);
+  return ne.parse(Z(e, "RFC4648"));
 }
-class bn extends ce {
-  constructor() {
-    super(...arguments);
-    f(this, "name", "PFrameError.Driver");
-  }
+async function Zn(e) {
+  const n = new TextEncoder(), t = await crypto.subtle.digest("SHA-256", n.encode(e));
+  return Ne(new Uint8Array(t.slice(0, 15)));
 }
-function vn(e) {
-  return e instanceof Error && e.name === "PFrameError.Driver";
+const et = ["supportsLazyState"], nt = ["requiresUIAPIVersion", "requiresModelAPIVersion"];
+function tt(e, n, t = !0) {
+  return e === void 0 ? !1 : e[n] === t;
 }
-function de(e) {
-  if (typeof e == "string")
-    return `String value was thrown: ${e}`;
-  if (e && typeof e == "object")
-    try {
-      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 e}) was thrown: ${e}`;
+function rt(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 w(e) {
-  return e instanceof Error ? e : new Error(de(e));
-}
-function P(e) {
-  const n = e.cause ? P(e.cause) : void 0, r = new Error(e.message, n !== void 0 ? { cause: n } : void 0);
-  return r.name = e.name || "Error", r.stack = e.stack, r;
-}
-function D(e) {
-  const n = w(e), r = n.cause ? D(n.cause) : void 0;
-  return {
-    name: n.name,
-    message: n.message,
-    stack: n.stack,
-    ...n.cause !== void 0 && { cause: r }
-  };
-}
-function gn(e) {
-  if (e.error)
-    throw e.error instanceof Error ? e.error : P(e.error);
-  return e.value;
-}
-function L(e) {
-  return e.error ? { error: D(e.error) } : { value: e.value };
-}
-function wn(e) {
-  return e.error ? { error: P(e.error) } : { value: e.value };
-}
-function fe(e) {
-  try {
-    return { value: e() };
-  } catch (n) {
-    return { error: w(n) };
-  }
-}
-async function le(e) {
-  try {
-    return { value: await e() };
-  } catch (n) {
-    return { error: w(n) };
-  }
-}
-function Pn(e) {
-  const n = fe(e);
-  return L(n);
-}
-async function kn(e) {
-  const n = await le(e);
-  return L(n);
-}
-const An = ["supportsLazyState"], xn = ["requiresUIAPIVersion", "requiresModelAPIVersion"];
-function En(e, n, r = !0) {
-  return e === void 0 ? !1 : e[n] === r;
-}
-function Sn(e) {
-  return e === void 0 ? /* @__PURE__ */ new Set() : new Set(Object.entries(e).filter(([n, r]) => n.startsWith("requires") && r === !0).map(([n]) => n));
-}
-function On(e) {
-  return e === void 0 ? /* @__PURE__ */ new Set() : new Set(Object.entries(e).filter(([n, r]) => n.startsWith("supports") && r === !0).map(([n]) => n));
+function ot(e) {
+  return e === void 0 ? /* @__PURE__ */ new Set() : new Set(Object.entries(e).filter(([n, t]) => n.startsWith("supports") && t === !0).map(([n]) => n));
 }
-class me extends Error {
-  constructor(r) {
-    super(`Some of the block requirements are not supported by the runtime: ${Array.from(r.entries()).map(([t, i]) => `${t}: ${i}`).join(", ")}`);
-    f(this, "name", "IncompatibleFlagsError");
-    this.incompatibleFlags = r;
+class Re 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(", ")}`);
+    b(this, "name", "IncompatibleFlagsError");
+    this.incompatibleFlags = t;
   }
 }
-class jn {
+class it {
   constructor() {
-    f(this, "supportedRequirements", /* @__PURE__ */ new Map());
+    b(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, r = !0) {
-    return this.supportedRequirements.has(n) || this.supportedRequirements.set(n, /* @__PURE__ */ new Set()), this.supportedRequirements.get(n).add(r), this;
+  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.
@@ -1055,14 +1436,14 @@ class jn {
      */
   getIncompatibleFlags(n) {
     if (n === void 0) return;
-    const r = /* @__PURE__ */ new Map();
-    for (const [t, i] of Object.entries(n))
-      if (t.startsWith("requires")) {
-        if (i === void 0) continue;
-        const o = this.supportedRequirements.get(t);
-        (o === void 0 || !o.has(i)) && r.set(t, i);
+    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 r.size === 0 ? void 0 : r;
+    return t.size === 0 ? void 0 : t;
   }
   /**
      * Checks if the block flags are compatible with the runtime capabilities.
@@ -1078,106 +1459,129 @@ class jn {
      * @throws IncompatibleFlagsError if the block flags are incompatible with the runtime capabilities.
      */
   throwIfIncompatible(n) {
-    const r = this.getIncompatibleFlags(n);
-    if (r !== void 0)
-      throw new me(r);
+    const t = this.getIncompatibleFlags(n);
+    if (t !== void 0)
+      throw new Re(t);
   }
 }
 export {
-  ln as AbortError,
-  xn as AllRequiresFeatureFlags,
-  An as AllSupportsFeatureFlags,
-  Ke as AnchoredIdDeriver,
-  Ze as DefaultNavigationState,
-  me as IncompatibleFlagsError,
-  bn as PFrameDriverError,
-  ce as PFrameError,
-  H as PTableAbsent,
-  C as PTableNA,
-  $ as PlId,
-  R as PlIdBytes,
-  ae as PlIdLength,
-  en as PlRef,
-  Pe as RangeBytes,
-  jn as RuntimeCapabilities,
-  mn as UiError,
-  Ie as canonicalizeAxisId,
-  dn as canonicalizeJson,
-  En as checkBlockFlag,
-  rn as createPlRef,
-  Fe as dataInfoToEntries,
-  Ye as deriveNativeId,
-  P as deserializeError,
-  wn as deserializeResult,
-  un as digestPlId,
-  w as ensureError,
-  We as ensurePColumn,
-  Je as entriesToDataInfo,
-  g as executePSpecPredicate,
-  Xe as extractAllColumns,
-  Sn as extractAllRequirements,
-  On as extractAllSupports,
-  be as extractCodeWithInfo,
-  ve as extractConfigGeneric,
-  J as getAxesId,
-  h as getAxisId,
-  Te as getColumnIdAndSpec,
-  Ee as getFileNameFromHandle,
-  q as getFilePathFromHandle,
-  Ve as getPColumnSpecId,
-  Ue as getPTableColumnId,
-  ue as hasAbortError,
-  pn as isAbortError,
-  hn as isAggregateError,
-  we as isBlockUIURL,
-  Se as isDataInfo,
-  M as isDataInfoEntries,
-  _e as isFilteredPColumn,
-  ge as isFolderURL,
-  U as isImportFileHandleIndex,
-  B as isImportFileHandleUpload,
-  xe as isLiveLog,
-  ee as isPColumn,
-  He as isPColumnResult,
-  l as isPColumnSpec,
-  ze as isPColumnSpecResult,
-  vn as isPFrameDriverError,
-  yn as isPFrameError,
-  Re as isPTableAbsent,
-  W as isPTableNA,
-  $e as isPTableValueAxis,
-  Ce as isPartitionedDataInfoEntries,
-  nn as isPlRef,
-  Oe as mapDataInfo,
-  Ne as mapDataInfoEntries,
-  v as mapJoinEntry,
-  Ge as mapPObjectData,
-  Be as mapPTableDef,
-  an as mapValueInVOE,
-  x as matchAxis,
-  X as matchAxisId,
-  E as matchPColumn,
-  ke as newRangeBytesOpt,
-  De as pTableValue,
-  Le as pTableValueBranded,
-  qe as parseColumnId,
-  fn as parseJson,
-  se as plId,
-  on as plRefsEqual,
-  Me as resolveAnchors,
-  Qe as selectorsToPredicate,
-  D as serializeError,
-  L as serializeResult,
-  Q as stringifyColumnId,
-  cn as stringifyJson,
-  sn as uniquePlId,
-  gn as unwrapResult,
-  Ae as validateRangeBytes,
-  je as visitDataInfo,
-  tn as withEnrichments,
-  Pn as wrapAndSerialize,
-  kn as wrapAndSerializeAsync,
-  le as wrapAsyncCallback,
+  rn as AbortError,
+  nt as AllRequiresFeatureFlags,
+  et as AllSupportsFeatureFlags,
+  Nn as AnchoredIdDeriver,
+  y as Annotation,
+  W as AnnotationJson,
+  he as AxisSpec,
+  Wn as DefaultNavigationState,
+  yn as Domain,
+  q as DomainJson,
+  Re as IncompatibleFlagsError,
+  A as LinkerMap,
+  Pn as PColumnName,
+  cn as PFrameDriverError,
+  le as PFrameError,
+  ke as PTableAbsent,
+  X as PTableNA,
+  ne as PlId,
+  ee as PlIdBytes,
+  De as PlIdLength,
+  zn as PlRef,
+  We as RangeBytes,
+  it as RuntimeCapabilities,
+  on as UiError,
+  g as ValueType,
+  On as canonicalizeAxisId,
+  D as canonicalizeAxisWithParents,
+  m as canonicalizeJson,
+  tt as checkBlockFlag,
+  _n as createPlRef,
+  en as dataInfoToEntries,
+  qn as deriveNativeId,
+  J as deserializeError,
+  fn as deserializeResult,
+  Zn as digestPlId,
+  C as ensureError,
+  Vn as ensurePColumn,
+  nn as entriesToDataInfo,
+  L as executePSpecPredicate,
+  Bn as extractAllColumns,
+  rt as extractAllRequirements,
+  ot as extractAllSupports,
+  Me as extractCodeWithInfo,
+  Be as extractConfigGeneric,
+  P as getArrayFromAxisTree,
+  G as getAxesId,
+  k as getAxesTree,
+  p as getAxisId,
+  En as getColumnIdAndSpec,
+  kn as getDenormalizedAxesList,
+  Ge as getFileNameFromHandle,
+  ae as getFilePathFromHandle,
+  _ as getNormalizedAxesList,
+  Sn as getPColumnSpecId,
+  jn as getPTableColumnId,
+  xn as getSetFromAxisTree,
+  ce as hasAbortError,
+  an as isAbortError,
+  sn as isAggregateError,
+  qe as isBlockUIURL,
+  Qe as isDataInfo,
+  ue as isDataInfoEntries,
+  Tn as isFilteredPColumn,
+  Ue as isFolderURL,
+  ie as isImportFileHandleIndex,
+  oe as isImportFileHandleUpload,
+  _e as isLiveLog,
+  Fe as isPColumn,
+  Kn as isPColumnResult,
+  w as isPColumnSpec,
+  $n as isPColumnSpecResult,
+  ln as isPFrameDriverError,
+  un as isPFrameError,
+  Fn as isPTableAbsent,
+  Pe as isPTableNA,
+  Cn as isPTableValueAxis,
+  Ze as isPartitionedDataInfoEntries,
+  Hn as isPlRef,
+  Xe as mapDataInfo,
+  tn as mapDataInfoEntries,
+  E as mapJoinEntry,
+  Mn as mapPObjectData,
+  In as mapPTableDef,
+  Xn as mapValueInVOE,
+  T as matchAxis,
+  Ae as matchAxisId,
+  $ as matchPColumn,
+  ze as newRangeBytesOpt,
+  Ln as pTableValue,
+  Jn as pTableValueBranded,
+  Dn as parseColumnId,
+  me as parseJson,
+  Ne as plId,
+  Qn as plRefsEqual,
+  An as readAnnotation,
+  z as readAnnotationJson,
+  vn as readAnnotationJsonOrThrow,
+  gn as readDomain,
+  wn as readDomainJson,
+  bn as readDomainJsonOrThrow,
+  I as readMetadata,
+  U as readMetadataJson,
+  j as readMetadataJsonOrThrow,
+  Rn as resolveAnchors,
+  Un as selectorsToPredicate,
+  M as serializeError,
+  B as serializeResult,
+  Se as stringifyColumnId,
+  hn as stringifyJson,
+  Yn as uniquePlId,
+  dn as unwrapResult,
+  He as validateRangeBytes,
+  Ye as visitDataInfo,
+  Gn as withEnrichments,
+  pn as wrapAndSerialize,
+  mn as wrapAndSerializeAsync,
+  pe as wrapAsyncCallback,
   fe as wrapCallback
 };
 //# sourceMappingURL=index.mjs.map