@blue-labs/language 1.20.0

package/dist/index.mjs

@@ -0,0 +1,4476 @@
+var yn = Object.defineProperty;
+var mn = (n, e, t) => e in n ? yn(n, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : n[e] = t;
+var l = (n, e, t) => mn(n, typeof e != "symbol" ? e + "" : e, t);
+import { isNullable as D, isNonNullable as y, jsonPrimitiveSchema as gn, isReadonlyArray as ce, isJsonPrimitive as st, isPreciseNumberString as Vt, deepContains as wn } from "@blue-labs/shared-utils";
+import { z as u, ZodString as Q, ZodEnum as Tn, ZodNativeEnum as bn, ZodNumber as G, ZodBoolean as Ee, ZodBigInt as Ie, ZodAny as Ft, ZodObject as Je, ZodRecord as Ke, ZodMap as Mt, ZodUnknown as jt, ZodIntersection as En, ZodUnion as In, ZodOptional as Rt, ZodNullable as $t, ZodReadonly as Ut, ZodBranded as Zt, ZodEffects as Pe, ZodLazy as Be } from "zod";
+import le from "bs58";
+import Z from "big.js";
+import { isObject as Ye, isArray as Ve, isString as ot, omit as qt, pascal as vn, map as Pn } from "radash";
+import { sha256 as Bn } from "js-sha256";
+import mt from "crypto";
+import Cn from "base32.js";
+import z from "js-yaml";
+class Sn {
+  static get(e, t, r, s = !0) {
+    if (D(t) || !t.startsWith("/"))
+      throw new Error(`Invalid path: ${t}`);
+    if (t === "/") {
+      const i = e.getValue();
+      return s && i !== void 0 ? i : e;
+    }
+    const o = t.substring(1).split("/");
+    return this.getRecursive(
+      e,
+      o,
+      0,
+      r,
+      s
+    );
+  }
+  static getRecursive(e, t, r, s, o) {
+    if (r === t.length - 1 && !o)
+      return this.getNodeForSegment(
+        e,
+        t[r],
+        s,
+        !1
+      );
+    if (r === t.length) {
+      const c = e.getValue();
+      return o && c !== void 0 ? c : e;
+    }
+    const i = t[r], a = this.getNodeForSegment(
+      e,
+      i,
+      s,
+      !0
+    );
+    if (a)
+      return this.getRecursive(
+        a,
+        t,
+        r + 1,
+        s,
+        o
+      );
+  }
+  static getNodeForSegment(e, t, r, s) {
+    let o;
+    const i = e.getProperties();
+    if (i && t in i)
+      o = i[t];
+    else
+      switch (t) {
+        case "name": {
+          const a = e.getName();
+          o = y(a) ? new d().setValue(a) : new d();
+          break;
+        }
+        case "description": {
+          const a = e.getDescription();
+          o = y(a) ? new d().setValue(a) : new d();
+          break;
+        }
+        case "type":
+          o = e.getType() ?? new d();
+          break;
+        case "itemType":
+          o = e.getItemType() ?? new d();
+          break;
+        case "keyType":
+          o = e.getKeyType() ?? new d();
+          break;
+        case "valueType":
+          o = e.getValueType() ?? new d();
+          break;
+        case "value": {
+          const a = e.getValue();
+          o = new d().setValue(a ?? null);
+          break;
+        }
+        case "blueId": {
+          const a = e.getBlueId();
+          o = y(a) ? new d().setValue(a) : new d();
+          break;
+        }
+        case "blue":
+          o = e.getBlue();
+          break;
+        case "items": {
+          const a = e.getItems();
+          o = new d().setItems(a);
+          break;
+        }
+        case "properties": {
+          const a = e.getProperties();
+          o = new d().setProperties(a);
+          break;
+        }
+        case "contracts": {
+          const a = e.getContracts();
+          o = new d().setContracts(a);
+          break;
+        }
+        default: {
+          if (/^\d+$/.test(t)) {
+            const a = parseInt(t, 10), c = e.getItems();
+            c && a >= 0 && a < c.length ? o = c[a] : o = void 0;
+          } else
+            o = void 0;
+          break;
+        }
+      }
+    if (o)
+      return s && r ? this.link(o, r) : o;
+  }
+  static link(e, t) {
+    const r = t(e);
+    return y(r) ? r : e;
+  }
+}
+class N extends Z {
+  constructor(e) {
+    super(e);
+  }
+}
+class k extends Z {
+  constructor(e) {
+    super(e);
+  }
+}
+const X = "name", ee = "description", Ce = "type", it = "itemType", at = "keyType", ct = "valueType", Fe = "value", lt = "items", Y = "blueId", ut = "blue", Me = "contracts", Nn = [
+  X,
+  ee,
+  Ce,
+  it,
+  at,
+  ct,
+  Fe,
+  lt,
+  Y,
+  ut,
+  Me
+], An = "Text", On = "Double", kn = "Integer", xn = "Boolean", Dn = "List", Vn = "Dictionary", Fn = [
+  An,
+  On,
+  kn,
+  xn
+], Lt = [...Fn, Dn, Vn], ye = "F92yo19rCcbBoBSpUA5LRxpfDejJDAaP1PRxxbWAraVP", me = "68ryJtnmui4j5rCZWUnkZ3DChtmEb7Z9F8atn1mBSM3L", ge = "DHmxTkFbXePZHCHCYmQr2dSzcNLcryFVjXVHkdQrrZr8", we = "EL6AjrbJsxTWRTPzY8WR8Y2zAMXRbydQj83PcZwuAHbo", Mn = "G8wmfjEqugPEEXByMYWJXiEdbLToPRWNQEekNxrxfQWB", jn = "294NBTj2mFRL3RB4kDRUSckwGg7Kzj6T8CTAFeR1kcSA", Rn = [
+  ye,
+  me,
+  ge,
+  we
+], ht = [
+  ...Rn,
+  Mn,
+  jn
+];
+Object.fromEntries(
+  Lt.map((n, e) => [n, ht[e]])
+);
+Object.fromEntries(
+  ht.map((n, e) => [n, Lt[e]])
+);
+const F = class F {
+  constructor(e) {
+    l(this, "name");
+    l(this, "description");
+    l(this, "type");
+    l(this, "itemType");
+    l(this, "keyType");
+    l(this, "valueType");
+    l(this, "value");
+    l(this, "items");
+    l(this, "properties");
+    l(this, "contracts");
+    l(this, "blueId");
+    l(this, "blue");
+    l(this, "inlineValue", !1);
+    this.name = e;
+  }
+  getName() {
+    return this.name;
+  }
+  setName(e) {
+    return this.name = e, this;
+  }
+  getDescription() {
+    return this.description;
+  }
+  setDescription(e) {
+    return this.description = e, this;
+  }
+  getType() {
+    return this.type;
+  }
+  setType(e) {
+    return typeof e == "string" ? this.type = new F().setValue(e).setInlineValue(!0) : this.type = e, this;
+  }
+  getItemType() {
+    return this.itemType;
+  }
+  setItemType(e) {
+    return typeof e == "string" ? this.itemType = new F().setValue(e).setInlineValue(!0) : this.itemType = e, this;
+  }
+  getKeyType() {
+    return this.keyType;
+  }
+  setKeyType(e) {
+    return typeof e == "string" ? this.keyType = new F().setValue(e).setInlineValue(!0) : this.keyType = e, this;
+  }
+  getValueType() {
+    return this.valueType;
+  }
+  setValueType(e) {
+    return typeof e == "string" ? this.valueType = new F().setValue(e).setInlineValue(!0) : this.valueType = e, this;
+  }
+  getValue() {
+    var t;
+    const e = (t = this.type) == null ? void 0 : t.getBlueId();
+    if (y(e) && y(this.value)) {
+      if (e === ge && typeof this.value == "string")
+        return new N(this.value);
+      if (e === me && typeof this.value == "string") {
+        const r = new k(this.value), s = parseFloat(r.toString());
+        return new k(s.toString());
+      } else if (e === we && typeof this.value == "string")
+        return this.value.toLowerCase() === "true";
+    }
+    return this.value;
+  }
+  setValue(e) {
+    return typeof e == "number" ? e % 1 === 0 ? this.value = new N(e.toString()) : this.value = new k(e.toString()) : this.value = e, this;
+  }
+  getItems() {
+    return this.items;
+  }
+  setItems(e) {
+    return this.items = e, this;
+  }
+  addItems(...e) {
+    return this.items || (this.items = []), this.items.push(...e), this;
+  }
+  getProperties() {
+    return this.properties;
+  }
+  setProperties(e) {
+    return this.properties = e, this;
+  }
+  addProperty(e, t) {
+    return this.properties || (this.properties = {}), this.properties[e] = t, this;
+  }
+  getContracts() {
+    return this.contracts;
+  }
+  setContracts(e) {
+    return this.contracts = e, this;
+  }
+  addContract(e, t) {
+    return this.contracts || (this.contracts = {}), this.contracts[e] = t, this;
+  }
+  getBlueId() {
+    return this.blueId;
+  }
+  setBlueId(e) {
+    return this.blueId = e, this;
+  }
+  getBlue() {
+    return this.blue;
+  }
+  setBlue(e) {
+    return this.blue = e, this;
+  }
+  isInlineValue() {
+    return this.inlineValue;
+  }
+  setInlineValue(e) {
+    return this.inlineValue = e, this;
+  }
+  get(e, t) {
+    return Sn.get(this, e, t);
+  }
+  clone() {
+    var t, r, s, o, i, a;
+    const e = new F(this.name);
+    return e.description = this.description, e.type = (t = this.type) == null ? void 0 : t.clone(), e.itemType = (r = this.itemType) == null ? void 0 : r.clone(), e.keyType = (s = this.keyType) == null ? void 0 : s.clone(), e.valueType = (o = this.valueType) == null ? void 0 : o.clone(), e.value = this.value, e.items = (i = this.items) == null ? void 0 : i.map((c) => c.clone()), this.properties && (e.properties = Object.fromEntries(
+      Object.entries(this.properties).map(([c, h]) => [c, h.clone()])
+    )), this.contracts && (e.contracts = Object.fromEntries(
+      Object.entries(this.contracts).map(([c, h]) => [c, h.clone()])
+    )), e.blueId = this.blueId, e.blue = (a = this.blue) == null ? void 0 : a.clone(), e.inlineValue = this.inlineValue, e;
+  }
+  toString() {
+    return `BlueNode{name='${this.name}', description='${this.description}', type=${this.type}, itemType=${this.itemType}, keyType=${this.keyType}, valueType=${this.valueType}, value=${this.value}, items=${this.items}, properties=${this.properties}, contracts=${this.contracts}, blueId='${this.blueId}', blue=${this.blue}, inlineValue=${this.inlineValue}}`;
+  }
+};
+l(F, "INTEGER", new F("Integer"));
+let d = F;
+class K {
+  static isPotentialBlueId(e) {
+    if (!e || e.length === 0 || !this.BLUE_ID_PATTERN.test(e))
+      return !1;
+    const t = e.split("#"), r = t[0], s = r.length;
+    if (s < this.MIN_BLUE_ID_LENGTH || s > this.MAX_BLUE_ID_LENGTH)
+      return !1;
+    try {
+      if (le.decode(r).length !== 32)
+        return !1;
+    } catch {
+      return !1;
+    }
+    if (t.length > 1)
+      try {
+        if (Number(t[1]) < 0)
+          return !1;
+      } catch {
+        return !1;
+      }
+    return !0;
+  }
+}
+l(K, "MIN_BLUE_ID_LENGTH", 41), l(K, "MAX_BLUE_ID_LENGTH", 45), l(K, "BLUE_ID_PATTERN", /^[1-9A-HJ-NP-Za-km-z]{41,45}(?:#\d+)?$/);
+const zs = u.string().max(K.MAX_BLUE_ID_LENGTH, {
+  message: "Blue Id has a maximum length of 45 characters"
+}).min(K.MIN_BLUE_ID_LENGTH, {
+  message: "Blue Id has a minimum length of 41 characters"
+}).refine(
+  (n) => {
+    try {
+      return le.decode(n), !0;
+    } catch {
+      return !1;
+    }
+  },
+  {
+    message: "Blue Id must be a valid Base58 string"
+  }
+), ue = u.lazy(
+  () => u.record(u.unknown()).and(
+    u.object({
+      blueId: u.string().optional(),
+      name: u.string().optional(),
+      description: u.string().optional(),
+      type: ue.optional(),
+      value: u.union([u.string(), u.number(), u.boolean()]).optional().nullable(),
+      items: u.array(ue).optional()
+    })
+  )
+), je = u.object({
+  blueId: u.string().optional(),
+  name: u.string().optional(),
+  description: u.string().optional(),
+  type: ue.optional()
+}), Hs = je.extend({
+  value: u.string().optional()
+}), Qs = je.extend({
+  value: u.number().optional()
+}), Gs = je.extend({
+  value: u.boolean().optional()
+}), Xs = je.extend({
+  items: u.array(u.string()).optional()
+}), eo = (n) => ue.safeParse(n).success, $n = (n) => y(n) && "blueId" in n && y(n.blueId), to = (n) => y(n) && "name" in n && y(n.name), Un = (n) => y(n) && "items" in n && y(n.items), Zn = (n) => y(n) && "type" in n && y(n.type), qn = (n) => y(n) && "value" in n && y(n.value), no = (n, e) => n.required({ type: !0 }).safeParse(e).success, A = (n) => n instanceof Z, he = (n) => A(n) && n instanceof N, Ln = (n) => A(n) && n instanceof k, _n = u.lazy(
+  () => u.record(Se)
+), Wn = u.lazy(
+  () => u.union([
+    u.array(Se),
+    u.array(Se).readonly()
+  ])
+), Se = u.lazy(
+  () => u.union([
+    gn,
+    _n,
+    Wn,
+    u.instanceof(Z)
+  ])
+), _t = (n) => Ye(n) && !Ve(n) && !ce(n) && !A(n), Wt = (n) => Ve(n) || ce(n), ro = (n) => Wt(n) || _t(n) || A(n) || st(n);
+class T {
+  static deserialize(e) {
+    return T.handleNode(e);
+  }
+  static handleNode(e) {
+    if (e === void 0)
+      throw new Error(
+        "This is not a valid JSON-like value. Found 'undefined' as a value."
+      );
+    if (_t(e)) {
+      const t = new d(), r = {}, s = {};
+      return Object.entries(e).forEach(([o, i]) => {
+        switch (o) {
+          case X:
+            if (i == null)
+              t.setName(void 0);
+            else {
+              if (typeof i != "string")
+                throw new Error(`The ${X} field must be a string.`);
+              t.setName(i);
+            }
+            break;
+          case ee:
+            if (i == null)
+              t.setDescription(void 0);
+            else {
+              if (typeof i != "string")
+                throw new Error(
+                  `The ${ee} field must be a string.`
+                );
+              t.setDescription(i);
+            }
+            break;
+          case Ce:
+            t.setType(T.handleNode(i));
+            break;
+          case it:
+            t.setItemType(T.handleNode(i));
+            break;
+          case at:
+            t.setKeyType(T.handleNode(i));
+            break;
+          case ct:
+            t.setValueType(T.handleNode(i));
+            break;
+          case Fe:
+            t.setValue(T.handleValue(i));
+            break;
+          case Y:
+            if (typeof i != "string")
+              throw new Error(`The ${Y} field must be a string.`);
+            t.setBlueId(i);
+            break;
+          case lt:
+            t.setItems(T.handleArray(i));
+            break;
+          case ut:
+            t.setBlue(T.handleNode(i));
+            break;
+          case Me:
+            Ye(i) && !Ve(i) && !ce(i) && Object.entries(i).forEach(([a, c]) => {
+              s[a] = T.handleNode(c);
+            });
+            break;
+          default:
+            r[o] = T.handleNode(i);
+            break;
+        }
+      }), Object.keys(r).length > 0 && t.setProperties(r), Object.keys(s).length > 0 && t.setContracts(s), t;
+    } else {
+      if (Wt(e))
+        return new d().setItems(T.handleArray(e));
+      {
+        const t = e;
+        return new d().setValue(T.handleValue(t)).setInlineValue(!0);
+      }
+    }
+  }
+  static handleValue(e) {
+    if (e == null)
+      return null;
+    if (typeof e == "string")
+      return e;
+    if (typeof e == "number" || A(e))
+      if (he(e) || Number.isSafeInteger(e)) {
+        const t = new N(e.toString()), r = Number.MIN_SAFE_INTEGER, s = Number.MAX_SAFE_INTEGER;
+        return t.lt(r) ? new N(r.toString()) : t.gt(s) ? new N(s.toString()) : t;
+      } else {
+        const t = parseFloat(e.toString());
+        return new k(t.toString());
+      }
+    else if (typeof e == "boolean")
+      return e;
+    throw new Error(`Can't handle node: ${JSON.stringify(e)}`);
+  }
+  static handleArray(e) {
+    if (e != null) {
+      if (Ye(e) && !Array.isArray(e))
+        return [T.handleNode(e)];
+      if (Array.isArray(e))
+        return e.map(T.handleNode);
+      throw new Error("Expected an array node");
+    }
+  }
+}
+function Jn(n) {
+  return n && n.__esModule && Object.prototype.hasOwnProperty.call(n, "default") ? n.default : n;
+}
+var Ue, gt;
+function Kn() {
+  return gt || (gt = 1, Ue = function n(e) {
+    if (typeof e == "number" && isNaN(e))
+      throw new Error("NaN is not allowed");
+    if (typeof e == "number" && !isFinite(e))
+      throw new Error("Infinity is not allowed");
+    return e === null || typeof e != "object" ? JSON.stringify(e) : e.toJSON instanceof Function ? n(e.toJSON()) : Array.isArray(e) ? `[${e.reduce((s, o, i) => `${s}${i === 0 ? "" : ","}${n(o === void 0 || typeof o == "symbol" ? null : o)}`, "")}]` : `{${Object.keys(e).sort().reduce((r, s) => {
+      if (e[s] === void 0 || typeof e[s] == "symbol")
+        return r;
+      const o = r.length === 0 ? "" : ",";
+      return `${r}${o}${n(s)}:${n(e[s])}`;
+    }, "")}}`;
+  }), Ue;
+}
+var Yn = Kn();
+const zn = /* @__PURE__ */ Jn(Yn);
+class Hn {
+  static canonicalize(e) {
+    return zn(e);
+  }
+}
+const Qn = typeof process < "u" && process.versions != null && process.versions.node != null, ke = class ke {
+  constructor() {
+    l(this, "browserCrypto");
+    this.browserCrypto = this.initBrowserCrypto();
+  }
+  static getInstance() {
+    return this.instance || (this.instance = new ke()), this.instance;
+  }
+  initBrowserCrypto() {
+    return Qn ? null : "crypto" in globalThis ? globalThis.crypto : null;
+  }
+  hasNodeCrypto() {
+    return !!mt.createHash;
+  }
+  getBrowserCrypto() {
+    return this.browserCrypto;
+  }
+  getNodeCrypto() {
+    return mt;
+  }
+};
+l(ke, "instance");
+let ze = ke;
+class Gn {
+  constructor() {
+    l(this, "cryptoEnv", ze.getInstance());
+  }
+  applySync(e) {
+    const t = this.canonicalizeInput(e), r = this.cryptoEnv.hasNodeCrypto() ? this.sha256Sync(t) : this.sha256SyncBrowser(t);
+    return le.encode(new Uint8Array(r));
+  }
+  async apply(e) {
+    const t = this.canonicalizeInput(e), r = this.cryptoEnv.hasNodeCrypto() ? this.sha256Sync(t) : await this.sha256Async(t);
+    return le.encode(new Uint8Array(r));
+  }
+  canonicalizeInput(e) {
+    const t = Hn.canonicalize(e);
+    if (typeof t != "string")
+      throw new Error("Canonized value must be a string");
+    return t;
+  }
+  sha256Sync(e) {
+    const t = this.cryptoEnv.getNodeCrypto();
+    if (!t)
+      throw new Error(
+        "Synchronous SHA-256 is not available in this environment"
+      );
+    return t.createHash("sha256").update(e).digest();
+  }
+  sha256SyncBrowser(e) {
+    return Bn.arrayBuffer(e);
+  }
+  async sha256Async(e) {
+    if (this.cryptoEnv.hasNodeCrypto())
+      return this.sha256Sync(e);
+    const t = this.cryptoEnv.getBrowserCrypto();
+    if (!t)
+      throw new Error("crypto is not available in this environment");
+    const s = new TextEncoder().encode(e);
+    return t.subtle.digest("SHA-256", s);
+  }
+}
+class P {
+  /**
+   * Converts a BlueNode to a JSON representation based on the specified strategy.
+   *
+   * @param node - The BlueNode to convert.
+   * @param strategy - The conversion strategy to use. Defaults to 'official'.
+   *   - `'official'`: Always returns complete objects with type information and metadata
+   *   - `'simple'`: Returns unwrapped values/arrays when possible, objects when metadata exists
+   *   - `'original'`: Returns simple values when no name/description, otherwise full objects
+   * @returns A JSON representation of the node.
+   */
+  static get(e, t = "official") {
+    var H;
+    const r = e.getValue(), s = this.handleValue(r);
+    if (s !== void 0 && t === "simple")
+      return s;
+    const o = (H = e.getItems()) == null ? void 0 : H.map((B) => P.get(B, t));
+    if (o !== void 0 && t === "simple")
+      return o;
+    const i = e.getName(), a = e.getDescription();
+    if (t === "original" && i === void 0 && a === void 0) {
+      if (s !== void 0)
+        return s;
+      if (o !== void 0)
+        return o;
+    }
+    const c = {};
+    i !== void 0 && (c[X] = i), a !== void 0 && (c[ee] = a);
+    const h = e.getType();
+    if (t === "official" && r !== void 0 && h === void 0) {
+      const B = this.inferTypeBlueId(r);
+      B !== null && (c[Ce] = { [Y]: B });
+    } else h !== void 0 && (c[Ce] = P.get(h, t));
+    const p = e.getItemType();
+    p !== void 0 && (c[it] = P.get(p, t));
+    const g = e.getKeyType();
+    g !== void 0 && (c[at] = P.get(g, t));
+    const w = e.getValueType();
+    w !== void 0 && (c[ct] = P.get(w, t)), s !== void 0 && (c[Fe] = s), o !== void 0 && (c[lt] = o);
+    const f = e.getBlueId();
+    f !== void 0 && (c[Y] = f);
+    const m = e.getBlue();
+    m !== void 0 && (c[ut] = m);
+    const E = e.getContracts();
+    if (E !== void 0) {
+      const B = {};
+      Object.entries(E).forEach(([ie, be]) => {
+        B[ie] = P.get(be, t);
+      }), c[Me] = B;
+    }
+    const I = e.getProperties();
+    return I !== void 0 && Object.entries(I).forEach(([B, ie]) => {
+      c[B] = P.get(ie, t);
+    }), c;
+  }
+  static handleValue(e) {
+    if (A(e)) {
+      if (he(e)) {
+        const t = new Z(Number.MIN_SAFE_INTEGER.toString()), r = new Z(Number.MAX_SAFE_INTEGER.toString());
+        if (e.lt(t) || e.gt(r))
+          return e.toString();
+      }
+      return e.toNumber();
+    }
+    return e;
+  }
+  static inferTypeBlueId(e) {
+    return typeof e == "string" ? ye : A(e) ? he(e) ? ge : me : typeof e == "boolean" ? we : null;
+  }
+}
+const Xn = (n) => st(n) && y(n), $ = class $ {
+  constructor(e) {
+    l(this, "hashProvider");
+    this.hashProvider = e;
+  }
+  static calculateBlueId(e) {
+    if (Array.isArray(e)) {
+      const r = e.map((s) => P.get(s));
+      return $.INSTANCE.calculate(r);
+    }
+    const t = P.get(e);
+    return $.INSTANCE.calculate(t);
+  }
+  static calculateBlueIdSync(e) {
+    if (Array.isArray(e)) {
+      const r = e.map((s) => P.get(s));
+      return $.INSTANCE.calculateSync(r);
+    }
+    const t = P.get(e);
+    return $.INSTANCE.calculateSync(t);
+  }
+  // public static calculateBlueIdForNodes(nodes: BlueNode[]) {
+  //   const objects = nodes.map((node) => NodeToMapListOrValue.get(node));
+  //   return BlueIdCalculator.INSTANCE.calculate(objects);
+  // }
+  // public static calculateBlueIdSyncForNodes(nodes: BlueNode[]) {
+  //   const objects = nodes.map((node) => NodeToMapListOrValue.get(node));
+  //   return BlueIdCalculator.INSTANCE.calculateSync(objects);
+  // }
+  calculate(e) {
+    const t = this.cleanStructure(e);
+    if (t === void 0)
+      throw new Error("Object after cleaning cannot be null or undefined.");
+    return this.internalCalculate(t, !1);
+  }
+  calculateSync(e) {
+    const t = this.cleanStructure(e);
+    if (t === void 0)
+      throw new Error("Object after cleaning cannot be null or undefined.");
+    return this.internalCalculate(t, !0);
+  }
+  // Internal method to calculate BlueId recursively
+  internalCalculate(e, t) {
+    return Xn(e) || A(e) ? this.applyHash(e.toString(), t) : Array.isArray(e) || ce(e) ? this.calculateList(e, t) : this.calculateMap(e, t);
+  }
+  calculateMap(e, t) {
+    if (e[Y] !== void 0)
+      return e[Y];
+    const s = Object.keys(e).map((i) => {
+      const a = e[i];
+      if ([X, Fe, ee].includes(i))
+        return t ? [i, a] : Promise.resolve([i, a]);
+      {
+        const c = this.internalCalculate(a, t);
+        return t ? [i, { blueId: c }] : Promise.resolve(c).then((h) => [
+          i,
+          { blueId: h }
+        ]);
+      }
+    }), o = (i) => {
+      const a = {};
+      for (const [c, h] of i)
+        a[c] = h;
+      return this.applyHash(a, t);
+    };
+    return t ? o(s) : Promise.all(s).then(o);
+  }
+  calculateList(e, t) {
+    if (e.length === 0)
+      throw new Error("Cannot calculate BlueId for an empty list.");
+    let r = this.internalCalculate(
+      e[0],
+      t
+    );
+    const s = (o, i) => t ? this.applyHash(
+      [{ blueId: o }, { blueId: i }],
+      !0
+    ) : Promise.all([o, i]).then(
+      ([a, c]) => this.applyHash([{ blueId: a }, { blueId: c }], !1)
+    );
+    for (let o = 1; o < e.length; o++) {
+      const i = this.internalCalculate(e[o], t);
+      r = s(r, i);
+    }
+    return r;
+  }
+  // Method to apply the hash provider to a value
+  applyHash(e, t) {
+    return t ? this.hashProvider.applySync(e) : this.hashProvider.apply(e);
+  }
+  // Method to clean the input structure by removing null or undefined values
+  cleanStructure(e) {
+    if (e != null) {
+      if (st(e) || A(e))
+        return e;
+      if (Array.isArray(e) || ce(e)) {
+        const t = e.map((r) => this.cleanStructure(r)).filter(y);
+        return t.length > 0 ? t : void 0;
+      } else if (typeof e == "object") {
+        const t = {};
+        for (const r in e) {
+          const s = this.cleanStructure(e[r]);
+          s != null && (t[r] = s);
+        }
+        return Object.keys(t).length > 0 ? t : void 0;
+      } else
+        return e;
+    }
+  }
+};
+l($, "INSTANCE", new $(new Gn()));
+let V = $;
+class so {
+  static convert(e) {
+    const t = le.decode(e), r = new Uint8Array(2 + t.length);
+    r[0] = 18, r[1] = 32, r.set(t, 2);
+    const s = new Uint8Array(2 + r.length);
+    return s[0] = 1, s[1] = 85, s.set(r, 2), "b" + new Cn.Encoder({ type: "rfc4648", lc: !0 }).write(s).finalize().replace(/=/g, "");
+  }
+}
+const He = /* @__PURE__ */ new WeakMap();
+function ne(n, e) {
+  const t = He.get(n) || {};
+  return He.set(n, { ...t, ...e }), n;
+}
+const O = (n) => He.get(n), er = (n) => (e) => {
+  const t = O(e);
+  return ne(e, {
+    ...t,
+    blueDescription: n
+  });
+}, tr = (n) => {
+  const e = O(n);
+  return y(e) && ot(e.blueDescription) ? e.blueDescription : null;
+}, oo = (n) => er(n)(u.string().optional()), nr = u.union([u.string(), u.boolean()]), rr = (n) => (e) => {
+  const t = O(e);
+  return ne(e, {
+    ...t,
+    blueId: n
+  });
+}, sr = (n) => {
+  const e = O(n), t = nr.safeParse(e == null ? void 0 : e.blueId);
+  return t.success ? t.data : null;
+}, io = (n) => rr(n ?? !0)(u.string()), or = (n) => (e) => {
+  const t = O(e);
+  return ne(e, {
+    ...t,
+    blueName: n
+  });
+}, ir = (n) => {
+  const e = O(n);
+  return y(e) && ot(e.blueName) ? e.blueName : null;
+}, ao = (n) => {
+  const e = u.string().optional();
+  return or(n)(e);
+}, ar = () => (n) => {
+  const e = O(n);
+  return ne(n, {
+    ...e,
+    blueNode: !0
+  });
+}, cr = (n) => {
+  const e = O(n);
+  return y(e) && y(e.blueNode) && e.blueNode === !0 ? e.blueNode : null;
+}, wt = (n) => !!cr(n), _ = () => {
+  const n = u.instanceof(d);
+  return ar()(n);
+}, Qe = "extendedFrom", lr = ({
+  schema: n,
+  baseSchema: e
+}) => {
+  const t = O(n) || {};
+  return ne(n, {
+    ...t,
+    [Qe]: e
+  });
+}, ur = (n) => {
+  const e = O(n);
+  return y(e) && e[Qe] ? e[Qe] : null;
+}, Jt = (n, e) => {
+  const t = ur(n);
+  return D(t) ? !1 : (t == null ? void 0 : t._def) === (e == null ? void 0 : e._def) ? !0 : Jt(t, e);
+}, hr = (n) => new Proxy(n, {
+  get(e, t, r) {
+    return t === "extend" ? function(...s) {
+      const o = e.extend(...s);
+      return lr({
+        schema: o,
+        baseSchema: e
+      });
+    } : Reflect.get(e, t, r);
+  }
+}), dr = u.object({
+  value: u.array(u.string()).optional(),
+  defaultValue: u.string().optional()
+}), pr = (n) => {
+  const e = O(n), t = dr.passthrough().safeParse(e == null ? void 0 : e.typeBlueId);
+  return t.success ? t.data : null;
+}, v = (n) => (e) => {
+  const t = O(e), r = typeof n == "string" ? { value: [n] } : n, s = hr(e);
+  return ne(s, {
+    ...t,
+    typeBlueId: {
+      ...(t == null ? void 0 : t.typeBlueId) || {},
+      ...r
+    }
+  });
+};
+class Re {
+  static resolveBlueId(e) {
+    var o;
+    const t = pr(e);
+    if (D(t))
+      return null;
+    const r = t.defaultValue;
+    if (y(r))
+      return r;
+    const s = (o = t.value) == null ? void 0 : o[0];
+    return y(s) ? s : Re.getRepositoryBlueId(t, e);
+  }
+  static getRepositoryBlueId(e, t) {
+    throw new Error("Not implemented");
+  }
+}
+class co {
+  constructor(e) {
+    l(this, "blueIdMap", /* @__PURE__ */ new Map());
+    for (const t of e)
+      this.registerSchema(t);
+  }
+  registerSchema(e) {
+    const t = Re.resolveBlueId(e);
+    if (y(t)) {
+      if (this.blueIdMap.has(t))
+        throw new Error(`Duplicate BlueId value: ${t}`);
+      this.blueIdMap.set(t, e);
+    }
+  }
+  resolveSchema(e) {
+    const t = this.getEffectiveBlueId(e);
+    return D(t) ? null : this.blueIdMap.get(t);
+  }
+  getEffectiveBlueId(e) {
+    const t = e.getType();
+    return y(t) && y(t.getBlueId()) ? t.getBlueId() : y(t) ? V.calculateBlueIdSync(t) : null;
+  }
+  getBlueIdMap() {
+    return new Map(this.blueIdMap);
+  }
+}
+class x {
+  /**
+   * Transforms a node and all its child nodes using the provided transformer function
+   * @param node - The node to transform
+   * @param transformer - The transformer function to apply to each node
+   * @returns The transformed node
+   */
+  static transform(e, t) {
+    const r = t(e.clone()), s = r.getType();
+    s !== void 0 && r.setType(x.transform(s, t));
+    const o = r.getItemType();
+    o !== void 0 && r.setItemType(
+      x.transform(o, t)
+    );
+    const i = r.getKeyType();
+    i !== void 0 && r.setKeyType(
+      x.transform(i, t)
+    );
+    const a = r.getValueType();
+    a !== void 0 && r.setValueType(
+      x.transform(a, t)
+    );
+    const c = r.getItems();
+    if (c !== void 0) {
+      const g = c.map(
+        (w) => x.transform(w, t)
+      );
+      r.setItems(g);
+    }
+    const h = r.getProperties();
+    if (h !== void 0) {
+      const g = Object.keys(h).reduce(
+        (w, f) => (w[f] = x.transform(h[f], t), w),
+        {}
+      );
+      r.setProperties(g);
+    }
+    const p = r.getContracts();
+    if (p !== void 0) {
+      const g = Object.keys(p).reduce((w, f) => (w[f] = x.transform(p[f], t), w), {});
+      r.setContracts(g);
+    }
+    return r;
+  }
+}
+class Kt {
+  static convertValue(e, t) {
+    var o;
+    const r = (o = e.getType()) == null ? void 0 : o.getBlueId(), s = e.getValue();
+    return D(s) ? this.isPrimitive(t) ? this.getDefaultPrimitiveValue(t) : s : ye === r ? this.convertFromString(String(s), t) : me === r || s instanceof k ? this.convertFromBigDecimal(
+      new k(s == null ? void 0 : s.toString()),
+      t
+    ) : ge === r || s instanceof N ? this.convertFromBigInteger(
+      new N(s == null ? void 0 : s.toString()),
+      t
+    ) : we === r || typeof s == "boolean" ? this.convertFromBoolean(!!s, t) : this.convertFromString(String(s), t);
+  }
+  static convertFromString(e, t) {
+    if (!t || t instanceof Q || t instanceof Tn || t instanceof bn)
+      return e;
+    if (t instanceof G)
+      return Number(e);
+    if (t instanceof Ee)
+      return e.toLowerCase() === "true";
+    if (t instanceof Ie)
+      return BigInt(e);
+    throw new Error(
+      `Cannot convert String to ${t.constructor.name}`
+    );
+  }
+  static convertFromBigDecimal(e, t) {
+    if (t instanceof G)
+      return e.toNumber();
+    if (t instanceof Q)
+      return e.toString();
+    throw new Error(
+      `Cannot convert Number to ${t.constructor.name}`
+    );
+  }
+  static convertFromBigInteger(e, t) {
+    if (t instanceof G)
+      return e.toNumber();
+    if (t instanceof Ie)
+      return BigInt(e.toString());
+    if (t instanceof Q)
+      return e.toString();
+    throw new Error(
+      `Cannot convert Number to ${t.constructor.name}`
+    );
+  }
+  static convertFromBoolean(e, t) {
+    if (!t || t instanceof Ee)
+      return e;
+    if (t instanceof Q)
+      return e.toString();
+    if (t instanceof G)
+      return Number(e);
+    if (t instanceof Ie)
+      return BigInt(e);
+    throw new Error(
+      `Cannot convert Boolean to ${t.constructor.name}`
+    );
+  }
+  static isPrimitive(e) {
+    return e ? e instanceof Q || e instanceof G || e instanceof Ee || e instanceof Ie : !1;
+  }
+  static getDefaultPrimitiveValue(e) {
+    if (!e) return null;
+    if (e instanceof G)
+      return 0;
+    if (e instanceof Ee)
+      return !1;
+    if (e instanceof Q)
+      return "";
+    throw new Error(
+      `Unsupported primitive type: ${e.constructor.name}`
+    );
+  }
+}
+class fr {
+  convert(e, t) {
+    return Kt.convertValue(e, t);
+  }
+}
+class yr {
+  constructor(e) {
+    this.nodeToObjectConverter = e;
+  }
+  /**
+   * Check if the valueSchema can handle structured data (contracts should be processed specially)
+   */
+  canHandleStructuredData(e) {
+    return e instanceof Ft || e instanceof Je || e instanceof Ke || e instanceof Mt || e instanceof jt;
+  }
+  convert(e, t) {
+    return this.convertFields(e, t);
+  }
+  convertFields(e, t) {
+    if (t instanceof En) {
+      const r = t._def.left, s = t._def.right, o = this.convert(e, r), i = this.convert(e, s);
+      return { ...o, ...i };
+    }
+    if (t instanceof In)
+      throw new Error("Union not supported");
+    if (t instanceof Je)
+      return Object.keys(t.shape).reduce((s, o) => {
+        const i = e.getProperties(), a = t.shape[o], c = sr(a);
+        if (y(c)) {
+          const m = ot(c) ? c : o, E = i == null ? void 0 : i[m], I = E ? V.calculateBlueIdSync(E) : void 0;
+          return s[o] = I, s;
+        }
+        const h = ir(a);
+        if (y(h)) {
+          const m = i == null ? void 0 : i[h];
+          return s[o] = m == null ? void 0 : m.getName(), s;
+        }
+        const p = tr(a);
+        if (y(p)) {
+          const m = i == null ? void 0 : i[p];
+          return s[o] = m == null ? void 0 : m.getDescription(), s;
+        }
+        if (o === "name") {
+          const m = e.getName();
+          return s[o] = m, s;
+        }
+        if (o === "description") {
+          const m = e.getDescription();
+          return s[o] = m, s;
+        }
+        const g = e.getContracts();
+        if (o === "contracts" && y(g) && this.canHandleStructuredData(a)) {
+          const m = Object.fromEntries(
+            Object.entries(g).map(([I, H]) => [
+              I,
+              P.get(H)
+            ])
+          ), E = T.deserialize(m);
+          s[o] = this.nodeToObjectConverter.convert(
+            E,
+            a
+          );
+        }
+        const w = i == null ? void 0 : i[o];
+        if (D(w))
+          return s;
+        const f = this.nodeToObjectConverter.convert(
+          w,
+          a
+        );
+        return s[o] = f, s;
+      }, {});
+    throw new Error("Unknown schema type, " + t.constructor.name);
+  }
+}
+class mr {
+  constructor(e) {
+    this.nodeToObjectConverter = e;
+  }
+  convert(e, t) {
+    const r = e.getItems();
+    if (!r)
+      return;
+    const s = t.element;
+    return r.map(
+      (i) => this.nodeToObjectConverter.convert(i, s)
+    );
+  }
+}
+class gr {
+  constructor(e) {
+    this.nodeToObjectConverter = e;
+  }
+  convert(e, t) {
+    const r = e.getItems();
+    if (!r)
+      return;
+    const s = t._def.valueType, o = r.map(
+      (i) => this.nodeToObjectConverter.convert(i, s)
+    );
+    return new Set(o);
+  }
+}
+class wr {
+  constructor(e) {
+    this.nodeToObjectConverter = e;
+  }
+  /**
+   * Check if the valueSchema can handle structured data (contracts should be processed specially)
+   */
+  canHandleStructuredData(e) {
+    return e instanceof Ft || e instanceof Je || e instanceof Ke || e instanceof Mt || e instanceof jt;
+  }
+  convert(e, t) {
+    const r = t.keySchema, s = t.valueSchema, o = /* @__PURE__ */ new Map(), i = e.getName();
+    y(i) && o.set(X, i);
+    const a = e.getDescription();
+    y(a) && o.set(ee, a);
+    const c = e.getContracts();
+    if (y(c) && this.canHandleStructuredData(s)) {
+      let p = !1;
+      const g = Object.entries(c).reduce(
+        (w, [f, m]) => {
+          try {
+            const E = this.nodeToObjectConverter.convert(
+              m,
+              s
+            );
+            E != null && !Number.isNaN(E) && (w[f] = E, p = !0);
+          } catch {
+          }
+          return w;
+        },
+        {}
+      );
+      p && o.set(Me, g);
+    }
+    const h = e.getProperties();
+    return y(h) && Object.entries(h).forEach(([p, g]) => {
+      const w = new d().setValue(p);
+      w.setType(new d().setBlueId(ye));
+      const f = Kt.convertValue(w, r), m = this.nodeToObjectConverter.convert(g, s);
+      o.set(f, m);
+    }), t instanceof Ke ? Object.fromEntries(o) : o;
+  }
+}
+class Tr {
+  convert(e) {
+    return P.get(e);
+  }
+}
+class br {
+  convert(e) {
+    return P.get(e);
+  }
+}
+class Er {
+  constructor(e) {
+    this.nodeToObjectConverter = e;
+  }
+  convert(e, t) {
+    const r = e.getItems();
+    if (!r)
+      return;
+    const s = t.items;
+    return r.map(
+      (i, a) => this.nodeToObjectConverter.convert(i, s[a])
+    );
+  }
+}
+const Ir = u.union([
+  u.literal("ZodString"),
+  u.literal("ZodNumber"),
+  u.literal("ZodBoolean"),
+  u.literal("ZodBigInt"),
+  u.literal("ZodArray"),
+  u.literal("ZodSet"),
+  u.literal("ZodMap"),
+  u.literal("ZodRecord"),
+  u.literal("ZodObject"),
+  u.literal("ZodEnum"),
+  u.literal("ZodNativeEnum"),
+  u.literal("ZodUnknown"),
+  u.literal("ZodAny"),
+  u.literal("ZodTuple")
+]);
+class vr {
+  constructor(e) {
+    l(this, "converters", /* @__PURE__ */ new Map());
+    l(this, "complexObjectConverter");
+    this.nodeToObjectConverter = e, this.registerConverters(), this.complexObjectConverter = new yr(
+      this.nodeToObjectConverter
+    );
+  }
+  registerConverters() {
+    const e = new fr(), t = new mr(this.nodeToObjectConverter), r = new Er(this.nodeToObjectConverter), s = new gr(this.nodeToObjectConverter), o = new wr(this.nodeToObjectConverter);
+    this.converters.set("ZodString", e), this.converters.set("ZodNumber", e), this.converters.set("ZodBoolean", e), this.converters.set("ZodBigInt", e), this.converters.set("ZodEnum", e), this.converters.set("ZodNativeEnum", e), this.converters.set("ZodUnknown", new Tr()), this.converters.set("ZodAny", new br()), this.converters.set("ZodArray", t), this.converters.set("ZodTuple", r), this.converters.set("ZodSet", s), this.converters.set("ZodMap", o), this.converters.set("ZodRecord", o), this.converters.set("ZodObject", this.complexObjectConverter);
+  }
+  getConverter(e) {
+    const t = this.getSchemaTypeName(e);
+    return this.converters.get(t) ?? this.complexObjectConverter;
+  }
+  isWrapperType(e) {
+    return e instanceof Rt || e instanceof $t || e instanceof Ut || e instanceof Zt || e instanceof Pe || e instanceof Be;
+  }
+  getSchemaTypeName(e) {
+    if (this.isWrapperType(e))
+      return e instanceof Pe ? this.getSchemaTypeName(e.innerType()) : e instanceof Be ? this.getSchemaTypeName(e.schema) : this.getSchemaTypeName(e.unwrap());
+    const t = e.constructor.name;
+    try {
+      return Ir.parse(t);
+    } catch {
+      throw new Error(`Schema type name ${t} is not supported`);
+    }
+  }
+}
+class Yt {
+  constructor(e) {
+    l(this, "converterFactory");
+    this.typeSchemaResolver = e, this.converterFactory = new vr(this);
+  }
+  convert(e, t) {
+    var i;
+    const r = (i = this.typeSchemaResolver) == null ? void 0 : i.resolveSchema(e), s = this.unwrapSchema(t);
+    if (wt(s))
+      return e;
+    let o = s;
+    return y(r) && Jt(r, s) && (o = r), this.convertWithType(e, o);
+  }
+  convertWithType(e, t) {
+    return this.converterFactory.getConverter(t).convert(e, t);
+  }
+  isWrapperType(e) {
+    return e instanceof Rt || e instanceof $t || e instanceof Ut || e instanceof Zt || e instanceof Pe || e instanceof Be;
+  }
+  unwrapSchema(e) {
+    return wt(e) ? e : this.isWrapperType(e) ? e instanceof Pe ? this.unwrapSchema(e.innerType()) : e instanceof Be ? this.unwrapSchema(e.schema) : this.unwrapSchema(e.unwrap()) : e;
+  }
+}
+class $e {
+  /**
+   * Fetches the first node associated with the given Blue ID
+   * Default implementation that takes the first node from fetchByBlueId result
+   *
+   * @param blueId - The Blue ID to fetch nodes for
+   * @returns The first node found for the Blue ID, or null if none exist
+   */
+  fetchFirstByBlueId(e) {
+    const t = this.fetchByBlueId(e);
+    return t && t.length > 0 ? t[0] : null;
+  }
+}
+function Pr(n) {
+  return new class extends $e {
+    fetchByBlueId(e) {
+      return n(e);
+    }
+  }();
+}
+class Br extends $e {
+  constructor(t) {
+    super();
+    l(this, "nodeProviders");
+    this.nodeProviders = t;
+  }
+  fetchByBlueId(t) {
+    for (const r of this.nodeProviders) {
+      const s = r.fetchByBlueId(t);
+      if (s && s.length > 0)
+        return s;
+    }
+    return [];
+  }
+  // Override fetchFirstByBlueId for more efficient implementation
+  // In Java, this would call the default implementation, but we optimize here
+  fetchFirstByBlueId(t) {
+    for (const r of this.nodeProviders) {
+      const s = r.fetchFirstByBlueId(t);
+      if (s)
+        return s;
+    }
+    return null;
+  }
+  getNodeProviders() {
+    return this.nodeProviders;
+  }
+}
+const Ze = z.types.float.options, Cr = {
+  ...Ze,
+  construct: (n) => {
+    const e = n.replace(/_/g, "").toLowerCase();
+    if (!Vt(e))
+      return new k(e);
+    if (Ze.construct)
+      return Ze.construct(n);
+  }
+}, Sr = new z.Type("tag:yaml.org,2002:float", Cr), qe = z.types.int.options, Nr = {
+  ...qe,
+  construct: (n) => {
+    let e = n;
+    if (e.indexOf("_") !== -1 && (e = e.replace(/_/g, "")), !Vt(e))
+      return new N(e);
+    if (qe.construct)
+      return qe.construct(n);
+  }
+}, Ar = new z.Type("tag:yaml.org,2002:int", Nr), zt = z.CORE_SCHEMA.extend({
+  implicit: [Sr, Ar]
+}), de = (n) => {
+  const e = z.load(n, { schema: zt });
+  return e === void 0 ? void 0 : e;
+}, lo = (n) => z.dump(n, {
+  schema: zt,
+  replacer: (e, t) => {
+    if (A(t)) {
+      if (he(t)) {
+        const r = new Z(Number.MIN_SAFE_INTEGER.toString()), s = new Z(Number.MAX_SAFE_INTEGER.toString());
+        if (t.lt(r) || t.gt(s))
+          return t.toString();
+      }
+      return t.toNumber();
+    }
+    return t;
+  }
+}), Ht = `- type:
+    blueId: 27B7fuxQCS1VAptiCPc2RMkKoutP5qxkh3uDxZ7dr6Eo
+  mappings:
+    Text: F92yo19rCcbBoBSpUA5LRxpfDejJDAaP1PRxxbWAraVP
+    Double: 68ryJtnmui4j5rCZWUnkZ3DChtmEb7Z9F8atn1mBSM3L
+    Integer: DHmxTkFbXePZHCHCYmQr2dSzcNLcryFVjXVHkdQrrZr8
+    Boolean: EL6AjrbJsxTWRTPzY8WR8Y2zAMXRbydQj83PcZwuAHbo
+    List: G8wmfjEqugPEEXByMYWJXiEdbLToPRWNQEekNxrxfQWB
+    Dictionary: 294NBTj2mFRL3RB4kDRUSckwGg7Kzj6T8CTAFeR1kcSA
+- type:
+    blueId: FGYuTXwaoSKfZmpTysLTLsb8WzSqf43384rKZDkXhxD4
+`, Or = `name: Transformation
+description: TODO`, kr = `name: Infer Basic Types For Untyped Values
+type:
+  blueId: Ct1SGRGw1i47qjzm1ruiUdSZofeV6WevPTGuieVvbRS4
+description: This transformation infers type details for Text, Integer, Number and Boolean.`, xr = `name: Replace Inline Types with BlueIds
+type:
+  blueId: Ct1SGRGw1i47qjzm1ruiUdSZofeV6WevPTGuieVvbRS4
+description: This transformation replaces`, Dr = [
+  Ht,
+  Or,
+  kr,
+  xr
+];
+class Vr extends $e {
+  constructor() {
+    super();
+    l(this, "blueIdToNodesMap", /* @__PURE__ */ new Map());
+    this.load();
+  }
+  fetchByBlueId(t) {
+    return this.blueIdToNodesMap.get(t) || [];
+  }
+  load() {
+    for (const t of Dr) {
+      const r = de(t);
+      if (r === void 0) {
+        console.error(`This content file is not valid YAML: ${t}`);
+        continue;
+      }
+      if (Array.isArray(r)) {
+        const s = r.map(
+          (i) => T.deserialize(i)
+        ), o = V.calculateBlueIdSync(s);
+        this.blueIdToNodesMap.set(o, s);
+      } else {
+        const s = T.deserialize(r), o = V.calculateBlueIdSync(s);
+        this.blueIdToNodesMap.set(o, [s]);
+      }
+    }
+  }
+}
+const xe = class xe extends $e {
+  constructor() {
+    super();
+    l(this, "nodeProvider");
+    this.nodeProvider = new Vr();
+  }
+  fetchByBlueId(t) {
+    return this.nodeProvider.fetchByBlueId(t);
+  }
+};
+l(xe, "INSTANCE", new xe());
+let Ge = xe;
+class pe {
+  /**
+   * Wraps a NodeProvider with a SequentialNodeProvider that includes bootstrap providers
+   * @param originalProvider - The original NodeProvider to wrap
+   * @returns A wrapped NodeProvider that includes bootstrap providers
+   */
+  static wrap(e) {
+    return new Br([
+      Ge.INSTANCE,
+      e
+    ]);
+  }
+}
+const Qt = (n) => n instanceof d || Array.isArray(n) && n.every((e) => e instanceof d) ? n : Ve(n) ? n.map((e) => T.deserialize(e)) : T.deserialize(n), Fr = async (n) => {
+  const e = Qt(n);
+  return V.calculateBlueId(e);
+}, uo = (n) => {
+  const e = Qt(n);
+  return V.calculateBlueIdSync(e);
+}, Tt = async (n) => {
+  if ($n(n))
+    return n;
+  try {
+    const e = Se.parse(n), t = await Fr(e);
+    return {
+      ...n,
+      blueId: t
+    };
+  } catch (e) {
+    throw new Error(`Failed enriching object with Blue ID: ${e}`);
+  }
+}, ho = (n) => n == null ? void 0 : n.items, po = (n) => n == null ? void 0 : n.value, fo = (n) => D(n) ? {} : qt(
+  n,
+  Nn
+), yo = (n) => Zn(n) ? n.type.name ?? null : qn(n) ? vn(typeof n.value) : Un(n) ? "List" : null, Mr = (n) => y(n) && Object.keys(qt(n, ["blueId"])).length > 0, mo = (n) => {
+  try {
+    const e = T.deserialize(n), t = P.get(e);
+    return ue.parse(t);
+  } catch (e) {
+    throw new Error(
+      `Failed transforming JSON-like value to BlueObject: ${e}`
+    );
+  }
+}, bt = async (n) => {
+  const {
+    resolveFunction: e,
+    signal: t = new AbortController().signal,
+    omitItems: r
+  } = n, s = n.count ?? n.items.length;
+  let o = await Pn(n.items, async (a) => await Tt(a));
+  const i = Math.max((o == null ? void 0 : o.length) - s, 0);
+  for (let a = o.length - 1; a >= i; a--)
+    if (!Mr(o[a])) {
+      const c = await e(o[a], { signal: t });
+      if (Array.isArray(c))
+        return bt({
+          ...n,
+          items: [
+            ...o.slice(0, a),
+            ...c,
+            ...o.slice(a + 1)
+          ]
+        });
+      const h = await Tt(c);
+      if (r != null && r.includes(h.blueId))
+        return bt({
+          ...n,
+          items: [...o.slice(0, a), ...o.slice(a + 1)]
+        });
+      o = [
+        ...o.slice(0, a),
+        h,
+        ...o.slice(a + 1)
+      ];
+    }
+  return o;
+};
+function ve(n) {
+  try {
+    const e = new URL(n);
+    return e.protocol === "http:" || e.protocol === "https:";
+  } catch {
+    return !1;
+  }
+}
+class jr {
+  /**
+   * Process a document node to infer basic types for untyped values
+   * @param document - The document to process
+   * @returns The processed document
+   */
+  process(e) {
+    return x.transform(e, this.inferType.bind(this));
+  }
+  /**
+   * Infer a basic type for a node
+   * @param node - The node to infer a type for
+   * @returns The node with the inferred type
+   */
+  inferType(e) {
+    const t = e.getType(), r = e.getValue();
+    return D(t) && y(r) && (typeof r == "string" ? e.setType(new d().setBlueId(ye)) : typeof r == "bigint" || he(r) ? e.setType(new d().setBlueId(ge)) : Ln(r) ? e.setType(new d().setBlueId(me)) : typeof r == "boolean" && e.setType(new d().setBlueId(we))), e;
+  }
+}
+const ae = class ae {
+  /**
+   * Creates a new processor with the given transformation node or mappings
+   * @param transformationOrMappings - The transformation node or mappings to use
+   */
+  constructor(e) {
+    l(this, "mappings", /* @__PURE__ */ new Map());
+    if (e instanceof d) {
+      const r = e.getProperties();
+      if (r && r[ae.MAPPINGS]) {
+        const o = r[ae.MAPPINGS].getProperties();
+        o && Object.entries(o).forEach(([i, a]) => {
+          const c = a.getValue();
+          typeof c == "string" && this.mappings.set(i, c);
+        });
+      }
+    } else
+      this.mappings = e;
+  }
+  /**
+   * Process a document node to replace inline values for type attributes with imports
+   * @param document - The document to process
+   * @returns The processed document
+   */
+  process(e) {
+    return x.transform(e, this.transformNode.bind(this));
+  }
+  transformNode(e) {
+    const t = e.clone();
+    return this.transformTypeField(t, t.getType()), this.transformTypeField(t, t.getItemType()), this.transformTypeField(t, t.getKeyType()), this.transformTypeField(t, t.getValueType()), t;
+  }
+  transformTypeField(e, t) {
+    if (t && t.isInlineValue() && t.getValue() !== void 0) {
+      const r = String(t.getValue());
+      if (this.mappings.has(r)) {
+        const s = this.mappings.get(r);
+        if (s) {
+          const o = new d().setBlueId(s);
+          t === e.getType() ? e.setType(o) : t === e.getItemType() ? e.setItemType(o) : t === e.getKeyType() ? e.setKeyType(o) : t === e.getValueType() && e.setValueType(o);
+        }
+      }
+    }
+  }
+};
+l(ae, "MAPPINGS", "mappings");
+let Xe = ae;
+class Rr {
+  /**
+   * Creates a new NodeExtender with the specified NodeProvider and optional strategy
+   * @param nodeProvider - The NodeProvider to use for resolving nodes
+   * @param strategy - The strategy to use for missing elements (defaults to THROW_EXCEPTION)
+   */
+  constructor(e, t) {
+    l(this, "nodeProvider");
+    l(this, "strategy");
+    this.nodeProvider = pe.wrap(e), this.strategy = t || "THROW_EXCEPTION";
+  }
+  /**
+   * Extends a node with its resolved references
+   * @param node - The node to extend
+   * @param limits - The limits to apply when extending
+   */
+  extend(e, t) {
+    this.extendNode(e, t, "");
+  }
+  extendNode(e, t, r, s = !1) {
+    if (!s) {
+      if (!t.shouldExtendPathSegment(r, e))
+        return;
+      t.enterPathSegment(r, e);
+    }
+    try {
+      const o = e.getBlueId();
+      if (o && !(o in ht)) {
+        const f = this.fetchNode(e);
+        if (f && f.length > 0)
+          if (f.length === 1) {
+            const m = f[0];
+            this.mergeNodes(e, m);
+          } else {
+            const m = f.map((I) => I.clone()), E = new d().setItems(m);
+            this.mergeNodes(e, E);
+          }
+      }
+      const i = e.getType();
+      i && this.extendNode(i, t, "type", !0);
+      const a = e.getItemType();
+      a && this.extendNode(a, t, "itemType", !0);
+      const c = e.getKeyType();
+      c && this.extendNode(c, t, "keyType", !0);
+      const h = e.getValueType();
+      h && this.extendNode(h, t, "valueType", !0);
+      const p = e.getProperties();
+      p && Object.entries(p).forEach(([f, m]) => {
+        this.extendNode(m, t, f, !1);
+      });
+      const g = e.getContracts();
+      g && Object.entries(g).forEach(([f, m]) => {
+        this.extendNode(m, t, f, !1);
+      });
+      const w = e.getItems();
+      if (w && w.length > 0) {
+        this.reconstructList(w);
+        for (let f = 0; f < w.length; f++)
+          this.extendNode(w[f], t, String(f), !1);
+      }
+    } finally {
+      s || t.exitPathSegment();
+    }
+  }
+  reconstructList(e) {
+    for (; e.length > 0; ) {
+      const t = e[0], r = t == null ? void 0 : t.getBlueId();
+      if (!r)
+        break;
+      const s = this.nodeProvider.fetchByBlueId(r);
+      if (!s || s.length === 1)
+        break;
+      e.shift(), e.unshift(...s);
+    }
+  }
+  fetchNode(e) {
+    const t = e.getBlueId();
+    if (!t) {
+      if (this.strategy === "RETURN_EMPTY")
+        return null;
+      throw new Error(`No blueId found for node: ${e.getName()}`);
+    }
+    const r = this.nodeProvider.fetchByBlueId(t);
+    if (!r || r.length === 0) {
+      if (this.strategy === "RETURN_EMPTY")
+        return null;
+      throw new Error(`No content found for blueId: ${e.getBlueId()}`);
+    }
+    return r;
+  }
+  mergeNodes(e, t) {
+    e.setName(t.getName()), e.setDescription(t.getDescription()), e.setType(t.getType()), e.setItemType(t.getItemType()), e.setKeyType(t.getKeyType()), e.setValueType(t.getValueType()), e.setValue(t.getValue() ?? null), e.setItems(t.getItems()), e.setProperties(t.getProperties()), e.setContracts(t.getContracts());
+  }
+}
+class $r {
+}
+function Et(n, e) {
+  const t = n.split(e), r = [...t].reverse().findIndex((o) => o !== ""), s = r === -1 ? 0 : t.length - r;
+  return t.slice(0, s);
+}
+class Gt extends $r {
+  /**
+   * Creates path limits with the specified paths and max depth
+   * @param allowedPaths - The paths to limit extension to
+   * @param maxDepth - The maximum depth of paths to allow
+   */
+  constructor(t, r) {
+    super();
+    l(this, "allowedPaths");
+    l(this, "maxDepth");
+    l(this, "currentPath", []);
+    this.allowedPaths = t, this.maxDepth = r;
+  }
+  /**
+   * Determines if a path segment should be extended
+   * @param pathSegment - The path segment
+   * @returns True if the segment should be extended, false otherwise
+   */
+  shouldExtendPathSegment(t) {
+    if (this.currentPath.length >= this.maxDepth)
+      return !1;
+    const r = this.normalizePath(
+      this.getCurrentFullPath() + "/" + t
+    );
+    return this.isAllowedPath(r);
+  }
+  /**
+   * Determines if a path segment should be merged
+   * @param pathSegment - The path segment
+   * @returns True if the segment should be merged, false otherwise
+   */
+  shouldMergePathSegment(t) {
+    return this.shouldExtendPathSegment(t);
+  }
+  /**
+   * Checks if a path is allowed
+   * @param path - The path to check
+   * @returns True if the path is allowed, false otherwise
+   */
+  isAllowedPath(t) {
+    for (const r of this.allowedPaths)
+      if (this.matchesAllowedPath(r, t))
+        return !0;
+    return !1;
+  }
+  /**
+   * Checks if a path matches an allowed path pattern
+   * @param allowedPath - The allowed path pattern
+   * @param path - The path to check
+   * @returns True if the path matches the allowed path pattern, false otherwise
+   */
+  matchesAllowedPath(t, r) {
+    const s = Et(t, "/"), o = Et(r, "/");
+    if (o.length > s.length)
+      return !1;
+    for (let i = 1; i < o.length; i++)
+      if (s[i] !== "*" && s[i] !== o[i])
+        return !1;
+    return !0;
+  }
+  /**
+   * Enters a path segment
+   * @param pathSegment - The path segment
+   */
+  enterPathSegment(t) {
+    this.currentPath.push(t);
+  }
+  /**
+   * Exits a path segment
+   */
+  exitPathSegment() {
+    this.currentPath.length > 0 && this.currentPath.pop();
+  }
+  /**
+   * Gets the current full path
+   * @returns The current full path
+   */
+  getCurrentFullPath() {
+    return "/" + this.currentPath.join("/");
+  }
+  /**
+   * Normalizes a path
+   * @param path - The path to normalize
+   * @returns The normalized path
+   */
+  normalizePath(t) {
+    return "/" + t.split("/").filter((r) => r !== "").join("/");
+  }
+  /**
+   * Creates path limits with a maximum depth
+   * @param maxDepth - The maximum depth
+   * @returns The path limits
+   */
+  static withMaxDepth(t) {
+    return new It().setMaxDepth(t).addPath("*").build();
+  }
+  /**
+   * Creates path limits with a single path
+   * @param path - The path to limit extension to
+   * @returns The path limits
+   */
+  static withSinglePath(t) {
+    return new It().addPath(t).build();
+  }
+}
+class It {
+  constructor() {
+    l(this, "allowedPaths", /* @__PURE__ */ new Set());
+    l(this, "maxDepth", Number.MAX_SAFE_INTEGER);
+  }
+  /**
+   * Adds a path to the allowed paths
+   * @param path - The path to add
+   * @returns The builder
+   */
+  addPath(e) {
+    return this.allowedPaths.add(e), this;
+  }
+  /**
+   * Sets the maximum depth
+   * @param maxDepth - The maximum depth
+   * @returns The builder
+   */
+  setMaxDepth(e) {
+    return this.maxDepth = e, this;
+  }
+  /**
+   * Builds the PathLimits
+   * @returns The built PathLimits
+   */
+  build() {
+    return new Gt(this.allowedPaths, this.maxDepth);
+  }
+}
+const j = {
+  "MyOS Timeline Channel": "MkKoutP5qxkh3uDxZ7dr6Eo27B7fuxQCS1VAptiCPc2R",
+  "MyOS Timeline Entry": "uDxZ7dr6Eo2MkKoutP5qxkh3uxQCS1VAptiCPc2R7B7f",
+  "MyOS Agent": "AgentBlu3Id7dr6Eo2MkKoutP5qxkh3uxQCS1V",
+  "MyOS Agent Channel": "AgentCh4nn3lBlu3Id7dr6Eo2MkKoutP5qxkh3uxQCS1V",
+  "MyOS Agent Event": "AgentEv3ntBlu3Id7dr6Eo2MkKoutP5qxkh3uxQCS1V"
+}, b = {
+  Channel: "2RMkKoutP5qxkh3uDxZ7dr6Eo27B7fuxQCS1VAptiCPc",
+  "Timeline Channel": "RMkKoutP5qxkh3uDxZ7dr6Eo27B7fuxQCS1VAptiCPc2",
+  "Composite Timeline Channel": "qxkh3uMkKoutP5DxZ7dr6Eo27B7fuxQCS1VAptiCPc2R",
+  "MyOS Timeline Channel": "MkKoutP5qxkh3uDxZ7dr6Eo27B7fuxQCS1VAptiCPc2R",
+  "Sequential Workflow": "h3uDxZ7dr6Eo27B7fuxMkKoutP5qxkQCS1VAptiCPc2R",
+  "Sequential Workflow Step": "6EoMkKoutP5DxZ7drqxkh3u27B7fuxQCS1VAptiCPc2R",
+  "Process Embedded": "DxZ7dr6EoMkKoutP5qxkh3u27B7fuxQCS1VAptiCPc2R",
+  "Embedded Node Channel": "MkKoutP5qxkh3uDxZ7dr6Eo27B7fuxQCS1VAptiCPc2",
+  "Document Update Channel": "MkKoutP5qxkh3uDQCS1VAptiCPc2xZ7dr6Eo27B7fux",
+  "Channel Event Checkpoint": "o27B7fuxMkKoutPh3uDxZ7dr6E5qxkQCS1VAptiCPc2R",
+  "Update Document": "7fuxMkKoutPh3uDxZ7dr6E5qxkQCS1VAptiCPc2R",
+  "Trigger Event": "kQCS1VAp7fuxMkKoutPh3uDxZ7dr6E5qxtiCPc2R",
+  "Json Patch Entry": "EnUQeMiMa2wHFW3JbeSPvdgfpL6qZYCR29m3SfeHsKSY",
+  "JavaScript Code": "MkKoutPDxZ7dr6Eo5qxkh3u27B7fuxQCS1VAptiCPc2R",
+  "Timeline Entry": "uDxZ7dr6Eo27B7fMkKoutP5qxkh3uxQCS1VAptiCPc2R",
+  Operation: "OpKoutP5qxkh3uDxZ7dr6Eo27B7fuxQCS1VAptiCPc2R",
+  "Sequential Workflow Operation": "SeqOpKoutP5qxkh3uDxZ7dr6Eo27B7fuxQCS1VAptiC",
+  "Operation Request": "OpReqKoutP5qxkh3uDxZ7dr6Eo27B7fuxQCS1VAptiC"
+}, Te = v(b.Channel)(
+  u.object({
+    name: u.string().optional(),
+    description: u.string().optional()
+  })
+), Ur = v(
+  b["Composite Timeline Channel"]
+)(
+  Te.extend({
+    channels: u.array(u.string()).optional()
+  })
+), Zr = v(
+  b["Document Update Channel"]
+)(
+  Te.extend({
+    path: u.string().optional()
+  })
+), vt = v(
+  b["Embedded Node Channel"]
+)(
+  Te.extend({
+    path: u.string().optional()
+  })
+), qr = v(b.Operation)(
+  u.object({
+    request: _().optional(),
+    description: u.string().optional(),
+    channel: u.string().optional()
+  })
+), Lr = v(
+  b["Operation Request"]
+)(
+  u.object({
+    operation: u.string().optional(),
+    request: _(),
+    document: u.object({
+      blueId: u.string().optional()
+    }).optional(),
+    allowNewerVersion: u.boolean().optional()
+  })
+), et = v(
+  b["Process Embedded"]
+)(
+  u.object({
+    paths: u.array(u.string()).optional()
+  })
+), tt = v(
+  b["Sequential Workflow"]
+)(
+  u.object({
+    steps: u.array(_()).optional(),
+    channel: u.string().optional()
+  })
+), _r = v(
+  b["Sequential Workflow Operation"]
+)(
+  tt.omit({
+    channel: !0
+  }).extend({
+    operation: u.string().optional()
+  })
+), Xt = v(
+  b["Timeline Channel"]
+)(
+  Te.extend({
+    timelineId: u.string().optional()
+  })
+), Ne = v(b["Timeline Entry"])(
+  u.object({
+    timelineId: u.string().optional(),
+    timelinePrev: u.string().optional(),
+    thread: u.string().optional(),
+    threadPrev: u.string().optional(),
+    message: _(),
+    signature: u.string().optional()
+  })
+), Le = v(b["Trigger Event"])(
+  u.object({
+    event: _()
+  })
+), Wr = v(b["Json Patch Entry"])(
+  u.object({
+    name: u.string().optional(),
+    description: u.string().optional(),
+    val: _().optional(),
+    op: u.string().optional(),
+    path: u.string().optional()
+  })
+), _e = v(b["Update Document"])(
+  u.object({
+    changeset: u.array(Wr)
+  })
+), Jr = v(
+  j["MyOS Timeline Channel"]
+)(
+  Xt.extend({
+    account: u.string().optional(),
+    email: u.string().optional()
+  })
+), Kr = v(
+  j["MyOS Timeline Entry"]
+)(
+  Ne.extend({
+    account: u.string().optional(),
+    email: u.string().optional()
+  })
+), Yr = v(j["MyOS Agent"])(
+  u.object({
+    agentId: u.string().optional()
+  })
+), zr = v(
+  j["MyOS Agent Channel"]
+)(
+  Te.extend({
+    agent: Yr.optional(),
+    event: _().optional()
+  })
+), Hr = v(j["MyOS Agent Event"])(
+  u.object({
+    agentId: u.string().optional(),
+    id: u.number().optional(),
+    timestamp: u.number().optional(),
+    event: _().optional()
+  })
+);
+class W {
+  /**
+   * Initializes the generator with default BlueIds collections
+   * @param defaultCollections - Array of default BlueIds objects to initialize with
+   */
+  static initialize(...e) {
+    this.blueIdsCollections = [...e];
+  }
+  /**
+   * Registers additional BlueIds collections for mapping generation
+   * @param blueIdsCollections - Array of BlueIds objects to register
+   */
+  static registerBlueIds(...e) {
+    this.blueIdsCollections.push(...e);
+  }
+  /**
+   * Generates YAML mappings section from all registered BlueIds collections
+   * @param transformationBlueId - The BlueId for the transformation type (defaults to the standard one)
+   * @returns YAML string with mappings for all BlueIds
+   */
+  static generateMappingsYaml(e = "27B7fuxQCS1VAptiCPc2RMkKoutP5qxkh3uDxZ7dr6Eo") {
+    const t = {};
+    for (const s of this.blueIdsCollections)
+      Object.assign(t, s);
+    const r = Object.entries(t).map(([s, o]) => `    ${s}: ${o}`).join(`
+`);
+    return `- type:
+    blueId: ${e}
+  mappings:
+${r}`;
+  }
+  /**
+   * Gets all currently registered BlueIds as a merged object
+   * @returns Merged object containing all BlueIds from all collections
+   */
+  static getAllBlueIds() {
+    const e = {};
+    for (const t of this.blueIdsCollections)
+      Object.assign(e, t);
+    return e;
+  }
+  /**
+   * Gets the names of all registered BlueIds
+   * @returns Array of all BlueId names
+   */
+  static getAllBlueIdNames() {
+    return Object.keys(this.getAllBlueIds());
+  }
+  /**
+   * Clears all registered BlueIds collections
+   */
+  static clear() {
+    this.blueIdsCollections = [];
+  }
+  /**
+   * Gets the count of registered BlueIds collections
+   * @returns Number of registered collections
+   */
+  static getCollectionCount() {
+    return this.blueIdsCollections.length;
+  }
+  /**
+   * Gets the total count of unique BlueIds across all collections
+   * @returns Number of unique BlueIds
+   */
+  static getTotalBlueIdCount() {
+    return Object.keys(this.getAllBlueIds()).length;
+  }
+}
+l(W, "blueIdsCollections", []);
+const De = class De {
+  /**
+   * Creates a new Preprocessor with the specified provider and NodeProvider or just NodeProvider
+   * @param processorProviderOrNodeProvider - The TransformationProcessorProvider or NodeProvider to use
+   * @param nodeProvider - The NodeProvider to use for resolving nodes (optional)
+   */
+  constructor(e, t) {
+    l(this, "processorProvider");
+    l(this, "nodeProvider");
+    l(this, "defaultSimpleBlue", null);
+    t ? (this.processorProvider = e, this.nodeProvider = pe.wrap(t)) : (this.processorProvider = De.getStandardProvider(), this.nodeProvider = pe.wrap(
+      e
+    )), W.initialize(b, j), this.loadDefaultSimpleBlue();
+  }
+  /**
+   * Registers additional BlueIds collections for dynamic mapping generation
+   * @param blueIdsCollections - Array of BlueIds objects to register
+   */
+  static registerBlueIds(...e) {
+    W.registerBlueIds(...e);
+  }
+  /**
+   * Resets BlueIds collections to defaults (core and myos only)
+   */
+  static resetBlueIdsToDefaults() {
+    W.clear(), W.initialize(b, j);
+  }
+  /**
+   * Gets all currently registered BlueIds
+   * @returns Merged object containing all BlueIds from all collections
+   */
+  static getAllRegisteredBlueIds() {
+    return W.getAllBlueIds();
+  }
+  /**
+   * Preprocesses a document node
+   * @param document - The document node to preprocess
+   * @returns The preprocessed document
+   */
+  preprocess(e) {
+    return this.preprocessWithOptions(e, null);
+  }
+  /**
+   * Preprocesses a document node using the default Blue node
+   * @param document - The document node to preprocess
+   * @returns The preprocessed document
+   */
+  preprocessWithDefaultBlue(e) {
+    return this.preprocessWithOptions(e, this.defaultSimpleBlue);
+  }
+  /**
+   * Preprocesses a document node with the specified default Blue node
+   * @param document - The document node to preprocess
+   * @param defaultBlue - The default Blue node to use if the document doesn't have one
+   * @returns The preprocessed document
+   */
+  preprocessWithOptions(e, t) {
+    let r = e.clone(), s = r.getBlue();
+    if (!s && t && (s = t.clone()), s) {
+      new Rr(this.nodeProvider).extend(
+        s,
+        Gt.withSinglePath("/*")
+      );
+      const o = s.getItems();
+      if (o && o.length > 0) {
+        for (const i of o) {
+          const a = this.processorProvider.getProcessor(i);
+          if (a)
+            r = a.process(r);
+          else
+            throw new Error(
+              `No processor found for transformation: ${i}`
+            );
+        }
+        r.setBlue(void 0);
+      }
+    }
+    return r;
+  }
+  /**
+   * Gets the standard transformation processor provider
+   * @returns The standard provider
+   */
+  static getStandardProvider() {
+    return {
+      getProcessor(e) {
+        var o;
+        const t = "27B7fuxQCS1VAptiCPc2RMkKoutP5qxkh3uDxZ7dr6Eo", r = "FGYuTXwaoSKfZmpTysLTLsb8WzSqf43384rKZDkXhxD4", s = (o = e.getType()) == null ? void 0 : o.getBlueId();
+        if (t === s)
+          return new Xe(
+            e
+          );
+        if (r === s)
+          return new jr();
+      }
+    };
+  }
+  /**
+   * Enriches the default Blue YAML with dynamic BlueIds mappings
+   * @param defaultBlue - The base default Blue YAML content
+   * @returns Enriched YAML content with dynamic mappings
+   */
+  enrichDefaultBlue(e) {
+    const t = W.generateMappingsYaml();
+    return `
+${e}
+${t}
+    `;
+  }
+  /**
+   * Loads the default simple Blue node
+   */
+  loadDefaultSimpleBlue() {
+    const e = this.enrichDefaultBlue(Ht);
+    try {
+      const t = de(e);
+      if (t)
+        this.defaultSimpleBlue = T.deserialize(t);
+      else
+        throw new Error("Failed to parse default Blue content");
+    } catch (t) {
+      throw new Error(`Error loading default Blue: ${t}`);
+    }
+  }
+};
+l(De, "DEFAULT_BLUE_BLUE_ID", "FREHAAGDZSzpnoTUoCQ86bBmxbVCULMjvx9JZM6fyqT1");
+let Ae = De;
+class Qr {
+  /**
+   * Creates a new BlueDirectivePreprocessor
+   *
+   * @param preprocessingAliases - Map of alias values to BlueIds (optional)
+   * @param urlContentFetcher - UrlContentFetcher for fetching URL content
+   */
+  constructor(e, t) {
+    l(this, "preprocessingAliases", /* @__PURE__ */ new Map());
+    l(this, "urlContentFetcher");
+    e && (this.preprocessingAliases = new Map(e)), this.urlContentFetcher = t;
+  }
+  /**
+   * Processes a node's blue directive synchronously
+   *
+   * @param node - The node to process
+   * @returns The node with processed blue directive
+   */
+  process(e) {
+    const t = this.getBlueNodeValue(e);
+    if (t) {
+      const r = e.clone();
+      if (this.preprocessingAliases.has(t))
+        return this.handleAliasValue(r, t);
+      if (K.isPotentialBlueId(t))
+        return this.handleBlueId(r, t);
+      throw ve(t) ? new Error(
+        `URL '${t}' detected. Use the async version of this method to fetch the content.`
+      ) : new Error(`Invalid blue value: ${t}`);
+    }
+    return e;
+  }
+  /**
+   * Processes a node's blue directive asynchronously, with support for URL fetching
+   *
+   * @param node - The node to process
+   * @returns Promise that resolves to the node with processed blue directive
+   */
+  async processAsync(e) {
+    const t = this.getBlueNodeValue(e);
+    if (t) {
+      const r = e.clone();
+      if (this.preprocessingAliases.has(t))
+        return this.handleAliasValue(r, t);
+      if (K.isPotentialBlueId(t))
+        return this.handleBlueId(r, t);
+      if (ve(t) && this.urlContentFetcher)
+        try {
+          const s = await this.fetchFromUrl(t);
+          return s && r.setBlue(new d().setItems(s)), r;
+        } catch (s) {
+          throw s instanceof Error ? new Error(
+            `Failed to fetch from URL '${t}'.
+${s.message}`
+          ) : s;
+        }
+      else throw ve(t) ? new Error(
+        `UrlContentFetcher not provided for URL: ${t}`
+      ) : new Error(`Invalid blue value: ${t}`);
+    }
+    return e;
+  }
+  /**
+   * Gets the blue node value if it exists and is a string
+   * @param node - The node to get the blue value from
+   * @returns The blue node value or null if it doesn't exist or isn't a string
+   */
+  getBlueNodeValue(e) {
+    const t = e.getBlue(), r = t == null ? void 0 : t.getValue();
+    return r && typeof r == "string" ? r : null;
+  }
+  /**
+   * Handles a blue value that is an alias
+   * @param node - The cloned node to modify
+   * @param value - The alias value
+   * @returns The modified node
+   */
+  handleAliasValue(e, t) {
+    return e.setBlue(
+      new d().setBlueId(this.preprocessingAliases.get(t))
+    ), e;
+  }
+  /**
+   * Handles a blue value that is a potential BlueId
+   * @param node - The cloned node to modify
+   * @param value - The BlueId value
+   * @returns The modified node
+   */
+  handleBlueId(e, t) {
+    return e.setBlue(new d().setBlueId(t)), e;
+  }
+  /**
+   * Fetches content from a URL
+   * @param url - The URL to fetch from
+   * @returns Promise that resolves to the fetched BlueNodes or null if fetch fails
+   */
+  async fetchFromUrl(e) {
+    if (!this.urlContentFetcher)
+      throw new Error(`UrlContentFetcher not provided for URL: ${e}`);
+    return await this.urlContentFetcher.fetchAndCache(e);
+  }
+  /**
+   * Gets the current preprocessing aliases
+   * @returns Map of aliases to BlueIds
+   */
+  getPreprocessingAliases() {
+    return new Map(this.preprocessingAliases);
+  }
+  /**
+   * Sets the preprocessing aliases
+   * @param aliases - Map of aliases to set
+   * @returns this instance for chaining
+   */
+  setPreprocessingAliases(e) {
+    return this.preprocessingAliases = new Map(e), this;
+  }
+  /**
+   * Adds preprocessing aliases to the map
+   * @param aliases - Map of aliases to add
+   * @returns this instance for chaining
+   */
+  addPreprocessingAliases(e) {
+    return e.forEach((t, r) => {
+      this.preprocessingAliases.set(r, t);
+    }), this;
+  }
+  /**
+   * Updates the URL content fetcher
+   * @param urlContentFetcher - The UrlContentFetcher to use
+   * @returns this instance for chaining
+   */
+  setUrlContentFetcher(e) {
+    return this.urlContentFetcher = e, this;
+  }
+  /**
+   * Gets the current URL content fetcher
+   * @returns The current UrlContentFetcher or undefined
+   */
+  getUrlContentFetcher() {
+    return this.urlContentFetcher;
+  }
+}
+const Gr = {
+  fetchUrl: async (n) => {
+    throw new Error(
+      `You must provide a custom UrlFetchStrategy to fetch content from URL: ${n}`
+    );
+  }
+};
+class Xr {
+  constructor(e) {
+    // Cache to avoid repeated network requests for the same URL
+    l(this, "cache", /* @__PURE__ */ new Map());
+    l(this, "fetchStrategy");
+    l(this, "enabled", !1);
+    l(this, "allowedDomains", []);
+    this.fetchStrategy = e || Gr;
+  }
+  validateUrl(e) {
+    if (!ve(e))
+      throw new Error(`Invalid URL: ${e}`);
+    return !0;
+  }
+  isDomainAllowed(e) {
+    if (this.allowedDomains.length === 0)
+      return !0;
+    try {
+      const t = new URL(e);
+      return this.allowedDomains.some(
+        (r) => t.hostname === r || t.hostname.endsWith(`.${r}`)
+      );
+    } catch {
+      return !1;
+    }
+  }
+  getFromCache(e) {
+    try {
+      return this.validateUrl(e), this.cache.get(e) || [];
+    } catch {
+      return [];
+    }
+  }
+  async fetchAndCache(e) {
+    if (this.validateUrl(e), !this.enabled)
+      throw new Error(
+        "URL fetching is disabled. Enable it using the enableFetching method."
+      );
+    if (!this.isDomainAllowed(e))
+      throw new Error(`Domain not allowed for URL: ${e}.`);
+    let t;
+    try {
+      t = await this.fetchStrategy.fetchUrl(e);
+    } catch (a) {
+      throw new Error(`Error fetching from URL: ${e}`, { cause: a });
+    }
+    const { data: r, contentType: s } = t;
+    let o;
+    if (s.includes("application/json") || s.includes("text/yaml") || s.includes("application/yaml") || s.includes("text/plain"))
+      o = de(r);
+    else
+      throw new Error(`Unsupported content type from URL: ${s}`);
+    if (o === void 0)
+      throw new Error(`Failed to parse content from URL: ${e}`);
+    let i;
+    return Array.isArray(o) ? i = o.map((a) => T.deserialize(a)) : i = [T.deserialize(o)], this.cache.set(e, i), i;
+  }
+  prefetchUrl(e, t) {
+    try {
+      this.validateUrl(e), this.cache.set(e, t);
+    } catch {
+    }
+  }
+  clearCache() {
+    this.cache.clear();
+  }
+  setFetchStrategy(e) {
+    return this.fetchStrategy = e, this;
+  }
+  getFetchStrategy() {
+    return this.fetchStrategy;
+  }
+  /**
+   * Enables fetching for all URLs
+   * @returns This instance for chaining
+   */
+  enableFetching() {
+    return this.enabled = !0, this.allowedDomains = [], this;
+  }
+  /**
+   * Enables fetching for specific domains only
+   * @param domains Array of allowed domains
+   * @returns This instance for chaining
+   */
+  enableFetchingForDomains(e) {
+    return this.enabled = !0, this.allowedDomains = [...e], this;
+  }
+  /**
+   * Disables all URL fetching
+   * @returns This instance for chaining
+   */
+  disableFetching() {
+    return this.enabled = !1, this;
+  }
+  isFetchingEnabled() {
+    return this.enabled;
+  }
+  /**
+   * Gets the list of allowed domains
+   * An empty list means all domains are allowed when fetching is enabled
+   * @returns Array of allowed domains
+   */
+  getAllowedDomains() {
+    return [...this.allowedDomains];
+  }
+  /**
+   * Adds a domain to the allowed domains list
+   * @param domain Domain to allow
+   * @returns This instance for chaining
+   */
+  allowDomain(e) {
+    return this.allowedDomains.includes(e) || this.allowedDomains.push(e), this;
+  }
+  /**
+   * Removes a domain from the allowed domains list
+   * @param domain Domain to disallow
+   * @returns This instance for chaining
+   */
+  disallowDomain(e) {
+    return this.allowedDomains = this.allowedDomains.filter((t) => t !== e), this;
+  }
+  /**
+   * Clears all allowed domains, meaning all domains will be allowed when fetching is enabled
+   * @returns This instance for chaining
+   */
+  clearAllowedDomains() {
+    return this.allowedDomains = [], this;
+  }
+}
+const es = (n, e) => ({
+  on: (t, r) => ({ end: () => r(null) })
+});
+async function ts(n) {
+  return new Promise((e, t) => {
+    es().on("error", t).end();
+  });
+}
+const U = (...n) => n.map((e, t) => {
+  if (typeof e != "string") return "";
+  if (t === 0 && e === "/") return "/";
+  const r = t > 0 ? e.replace(/^\/+/, "") : e;
+  return t < n.length - 1 ? r.replace(/\/+$/, "") : r;
+}).filter(Boolean).join("/").replace(/\/{2,}/g, "/");
+class en {
+  constructor(e, t, r, s) {
+    l(this, "actions", []);
+    this.getDocument = e, this.taskInfo = t, this.blue = r, this.onFlush = s;
+  }
+  get(e) {
+    const t = this.getDocument(), r = U(this.taskInfo.nodePath, e);
+    return t.get(r);
+  }
+  addPatch(e) {
+    this.actions.push({
+      kind: "patch",
+      patch: {
+        ...e,
+        path: U(this.taskInfo.nodePath, e.path)
+      }
+    });
+  }
+  emitEvent(e) {
+    const t = this.taskInfo.event, r = t.trace ?? [], s = {
+      ...e,
+      originNodePath: e.originNodePath ?? this.taskInfo.nodePath,
+      rootEvent: e.rootEvent ?? t.rootEvent ?? t,
+      trace: [...r]
+    };
+    this.actions.push({ kind: "event", event: s });
+  }
+  async flush() {
+    var t;
+    if (!this.actions.length) return [];
+    const e = [...this.actions];
+    return this.actions.length = 0, await ((t = this.onFlush) == null ? void 0 : t.call(this, e)), e;
+  }
+  getNodePath() {
+    return this.taskInfo.nodePath;
+  }
+  resolvePath(e) {
+    return U(this.taskInfo.nodePath, e);
+  }
+  getTaskInfo() {
+    return this.taskInfo;
+  }
+  getBlue() {
+    return this.blue;
+  }
+  /* TODO: Move to a separate interface */
+  loadExternalModule(e) {
+    if (!/^https?:\/\//.test(e))
+      throw new Error("Only http/https URLs are allowed");
+    return ts();
+  }
+  loadBlueContent(e) {
+    throw new Error("Not implemented");
+  }
+}
+class tn extends Error {
+  constructor(e, t) {
+    super(`Cannot apply patch ${JSON.stringify(e)}`), this.patch = e, this.cause = t, this.name = "PatchApplicationError";
+  }
+}
+class nn extends Error {
+  constructor(e, t, r) {
+    super(
+      `Patch ${JSON.stringify(e)} touches "${e.op === "move" || e.op === "copy" ? `${e.from} → ${e.path}` : e.path}" which is inside embedded document "${t}" (Process Embedded @ "${r}")`
+    ), this.patch = e, this.offendingPath = t, this.contractNodePath = r, this.name = "EmbeddedDocumentModificationError";
+  }
+}
+class Pt extends Error {
+  constructor(e, t) {
+    super(`Failed to evaluate expression "${e}"`), this.code = e, this.cause = t, this.name = "ExpressionEvaluationError";
+  }
+}
+class Bt extends Error {
+  constructor(e, t) {
+    super(`Failed to evaluate code block "${e}"`), this.code = e, this.cause = t, this.name = "CodeBlockEvaluationError";
+  }
+}
+class q {
+  static isTypeOf(e, t) {
+    var o;
+    const r = Re.resolveBlueId(t), s = (o = e.getType()) == null ? void 0 : o.getBlueId();
+    return D(r) || D(s) ? !1 : r === s;
+  }
+}
+const L = (n) => !!n && typeof n == "object" && !Array.isArray(n) && !(n instanceof d), M = (n) => n instanceof N || n instanceof k, ns = (n) => n.replace(/~1/g, "/").replace(/~0/g, "~");
+function re(n) {
+  if (n === "/") return [];
+  if (!n.startsWith("/"))
+    throw new Error(`Path must start with '/': ${n}`);
+  return n.split("/").slice(1).map(ns);
+}
+function te(n) {
+  if (n === "-") return -1;
+  const e = typeof n == "number" ? n : parseInt(n, 10);
+  if (isNaN(e))
+    throw new Error(`Invalid array index (NaN) from '${n}'`);
+  if (!Number.isFinite(e))
+    throw new Error(
+      `Invalid array index '${n}' results in non-finite number ${e}`
+    );
+  return e;
+}
+function rn(n, e, t, r = !0) {
+  switch (e) {
+    case "name":
+      return t ? r ? n.getName() ?? null : n : n.getName();
+    case "description":
+      return t ? r ? n.getDescription() : n : n.getDescription();
+    case "type":
+      return n.getType();
+    case "itemType":
+      return n.getItemType();
+    case "keyType":
+      return n.getKeyType();
+    case "valueType":
+      return n.getValueType();
+    case "value":
+      return t ? r ? n.getValue() ?? null : n : n.getValue();
+    case "blueId":
+      return t ? r ? n.getBlueId() ?? null : n : n.getBlueId();
+    case "blue":
+      return n.getBlue();
+    case "items":
+      return n.getItems();
+    case "properties":
+      return n.getProperties();
+    case "contracts":
+      return n.getContracts();
+    default:
+      return;
+  }
+}
+function Ct(n, e, t = !0) {
+  if (n instanceof d) {
+    const r = rn(
+      n,
+      e,
+      !0,
+      t
+    );
+    if (r !== void 0 || [
+      "name",
+      "description",
+      "type",
+      "itemType",
+      "keyType",
+      "valueType",
+      "value",
+      "blueId",
+      "blue",
+      "items",
+      "properties",
+      "contracts"
+    ].includes(e))
+      return r;
+    if (/^-?\d+$/.test(e) && e !== "-") {
+      const o = n.getItems(), i = parseInt(e, 10);
+      return o && i >= 0 && i < o.length ? o[i] : void 0;
+    }
+    const s = n.getProperties();
+    return s && e in s ? s[e] : void 0;
+  }
+  if (Array.isArray(n)) {
+    if (e === "-") return;
+    const r = te(e);
+    return r >= 0 && r < n.length ? n[r] : void 0;
+  }
+  if (L(n)) return n[e];
+}
+function se(n, e) {
+  if (e.length === 0)
+    return {
+      parent: n,
+      key: "value",
+      actualTarget: n.getValue() ?? n
+    };
+  let t = n;
+  for (let s = 0; s < e.length - 1; ++s) {
+    const o = e[s], i = Ct(t, o);
+    if (i === void 0)
+      throw new Error(`Cannot resolve '/${e.slice(0, s + 1).join("/")}'`);
+    t = i;
+  }
+  const r = e[e.length - 1];
+  if (t instanceof d) {
+    const s = Ct(t, r, !1);
+    if ((typeof s != "object" || s === null || M(s)) && !(s instanceof d) && !Array.isArray(s) && ["name", "description", "value", "blueId"].includes(r))
+      return {
+        parent: t,
+        key: r,
+        actualTarget: s
+      };
+  }
+  return Array.isArray(t) && r === "-" ? { parent: t, key: "-" } : t instanceof d && t.getItems() && r === "-" ? { parent: t, key: "-" } : {
+    parent: t,
+    key: Array.isArray(t) ? te(r) : r
+  };
+}
+function dt(n, e) {
+  var t;
+  if (n instanceof d) {
+    const r = e, s = rn(n, r, !1);
+    if (s !== void 0 || [
+      "name",
+      "description",
+      "type",
+      "itemType",
+      "keyType",
+      "valueType",
+      "value",
+      "blueId",
+      "blue",
+      "items",
+      "properties",
+      "contracts"
+    ].includes(r))
+      return s;
+    if (typeof e == "number" || typeof e == "string" && /^\d+$/.test(e)) {
+      const o = n.getItems(), i = typeof e == "number" ? e : parseInt(e, 10);
+      if (o && i >= 0 && i < o.length) return o[i];
+    }
+    return (t = n.getProperties()) == null ? void 0 : t[r];
+  }
+  return Array.isArray(n) || L(n) ? n[e] : n;
+}
+function C(n) {
+  if (n instanceof d) return n;
+  if (n === null || typeof n == "string" || typeof n == "number" || typeof n == "boolean" || M(n))
+    return T.deserialize(n);
+  const e = nt(n);
+  return T.deserialize(e);
+}
+function nt(n) {
+  if (n === void 0) return null;
+  if (n === null || typeof n != "object") return n;
+  if (Array.isArray(n)) return n.map(nt);
+  const e = {};
+  for (const [t, r] of Object.entries(n))
+    e[t] = nt(r);
+  return e;
+}
+function pt(n, e, t) {
+  if (n instanceof d) {
+    const r = e;
+    switch (r) {
+      case "name":
+        n.setName(t);
+        return;
+      case "description":
+        n.setDescription(t);
+        return;
+      case "type":
+        n.setType(
+          t instanceof d || typeof t == "string" || t === void 0 ? t : C(t)
+        );
+        return;
+      case "itemType":
+        n.setItemType(
+          t instanceof d || typeof t == "string" || t === void 0 ? t : C(t)
+        );
+        return;
+      case "keyType":
+        n.setKeyType(
+          t instanceof d || typeof t == "string" || t === void 0 ? t : C(t)
+        );
+        return;
+      case "valueType":
+        n.setValueType(
+          t instanceof d || typeof t == "string" || t === void 0 ? t : C(t)
+        );
+        return;
+      case "value": {
+        const s = t;
+        n.setValue(s === void 0 ? null : s);
+        return;
+      }
+      case "blueId":
+        n.setBlueId(t);
+        return;
+      case "blue":
+        n.setBlue(
+          t instanceof d || t === void 0 ? t : C(t)
+        );
+        return;
+      case "items":
+        n.setItems(t);
+        return;
+      case "properties":
+        n.setProperties(t);
+        return;
+      case "contracts":
+        n.setContracts(t);
+        return;
+      default: {
+        if (t === void 0) {
+          const s = n.getProperties();
+          s && r in s && delete s[r];
+        } else
+          n.getProperties() || n.setProperties({}), n.addProperty(r, t instanceof d ? t : C(t));
+        return;
+      }
+    }
+  }
+  Array.isArray(n) ? n.splice(te(e), 1) : L(n) && (t === void 0 ? delete n[e] : n[e] = t);
+}
+function rs(n, e, t, r) {
+  let s = -1;
+  if (e !== "-" && (s = typeof e == "number" ? e : parseInt(e, 10), isNaN(s)))
+    throw new Error(
+      `Invalid numeric key for BlueNode item operation: ${e}`
+    );
+  if (s < -1)
+    throw new Error(`Invalid array index for BlueNode items: ${s}`);
+  let o = n.getItems();
+  if (o || (o = [], n.setItems(o)), !r && s !== -1 && s > o.length)
+    throw new Error(
+      `ADD operation failed: Target array index '${s}' is greater than array length ${o.length}.`
+    );
+  if (e === "-")
+    o.push(t);
+  else if (r) {
+    if (s >= 0)
+      if (s < o.length) o[s] = t;
+      else {
+        for (let i = o.length; i < s; i++)
+          o.push(T.deserialize(null));
+        o.push(t);
+      }
+  } else
+    o.splice(s, 0, t);
+}
+function Oe(n, e, t, r) {
+  if (Array.isArray(n)) {
+    const s = e === "-" ? n.length : te(e);
+    if (!r && s > n.length)
+      throw new Error(
+        `ADD operation failed: Target array index '${s}' is greater than array length ${n.length}. Path involving key '${e}'.`
+      );
+    if (s < 0 && e !== "-")
+      throw new Error(`Invalid negative array index: ${e}`);
+    const o = C(t);
+    if (r) {
+      if (s >= 0 && s < n.length) n[s] = o;
+      else if (s >= n.length) {
+        for (let i = n.length; i < s; i++)
+          n.push(T.deserialize(null));
+        n.push(o);
+      }
+    } else
+      n.splice(s, 0, o);
+    return;
+  }
+  if (n instanceof d) {
+    e === "-" || typeof e == "number" && !isNaN(e) || typeof e == "string" && /^\d+$/.test(e) ? rs(n, e, C(t), r) : pt(n, e, t);
+    return;
+  }
+  if (L(n)) {
+    n[e] = C(t);
+    return;
+  }
+  throw new Error(`Cannot insert into parent of type ${typeof n}`);
+}
+function ss(n, e) {
+  if (Array.isArray(n)) {
+    const t = te(e);
+    t === -1 && e === "-" ? n.length > 0 && n.pop() : t >= 0 && t < n.length && n.splice(t, 1);
+    return;
+  }
+  if (n instanceof d) {
+    if (typeof e == "number" || typeof e == "string" && /^-?\d+$/.test(e)) {
+      const t = n.getItems();
+      if (t) {
+        const r = te(e);
+        r === -1 && e === "-" ? t.length > 0 && t.pop() : r >= 0 && r < t.length && t.splice(r, 1), t.length === 0 && n.setItems(void 0);
+        return;
+      }
+    }
+    pt(n, e, void 0);
+  } else L(n) && delete n[e];
+}
+function rt(n) {
+  if (n instanceof d) return n.clone();
+  if (Array.isArray(n))
+    return n.map((t) => rt(t));
+  if (L(n)) {
+    const e = {};
+    return Object.keys(n).forEach((t) => {
+      e[t] = rt(n[t]);
+    }), e;
+  }
+  return n;
+}
+function J(n, e) {
+  if (n === e || n instanceof d && (n.isInlineValue() || n.getValue() !== void 0) && J(n.getValue() ?? null, e) || e instanceof d && (e.isInlineValue() || e.getValue() !== void 0) && J(n, e.getValue() ?? null))
+    return !0;
+  if (n instanceof d && e instanceof d || M(n) && M(e) || M(n) && typeof e == "number" || typeof n == "number" && M(e))
+    return n.toString() === e.toString();
+  if (Array.isArray(n) && Array.isArray(e))
+    return n.length === e.length && n.every((t, r) => J(t, e[r]));
+  if (L(n) && L(e)) {
+    const t = Object.keys(n), r = Object.keys(e);
+    return t.length === r.length && t.every((s) => J(n[s], e[s]));
+  }
+  return !1;
+}
+function sn(n, e) {
+  const { parent: t, key: r } = se(n, re(e));
+  return dt(t, r);
+}
+function on(n, e, t) {
+  const r = re(e);
+  if (r.length === 0 && e === "/") {
+    const i = C(t);
+    n.setValue(i.getValue() ?? null), i.getItems() ? n.setItems(i.getItems()) : n.setItems(void 0);
+    return;
+  }
+  const { parent: s, key: o } = se(n, r);
+  Oe(s, o, t, !0);
+}
+function os(n, e, t) {
+  const r = re(e);
+  if (r.length === 0 && e === "/") {
+    if (n.getItems() && Array.isArray(t)) {
+      const i = C(t);
+      i.getItems() ? (n.setItems(i.getItems()), n.setValue(null)) : (n.setValue(i.getValue() ?? null), n.setItems(void 0));
+    } else {
+      const i = C(t);
+      n.setValue(i.getValue() ?? null), i.getItems() && n.setItems(i.getItems());
+    }
+    return !0;
+  }
+  const { parent: s, key: o } = se(n, r);
+  return Oe(s, o, t, !1), !0;
+}
+function is(n, e, t) {
+  const r = re(e);
+  if (r.length === 0 && e === "/") {
+    const a = C(t);
+    return n.setValue(a.getValue() ?? null), a.getItems() ? n.setItems(a.getItems()) : n.setItems(void 0), !0;
+  }
+  const { parent: s, key: o, actualTarget: i } = se(n, r);
+  if (i !== void 0 && s instanceof d)
+    pt(s, o, t);
+  else {
+    const a = dt(s, o), c = Array.isArray(s) || s instanceof d && s.getItems() && (typeof o == "number" || typeof o == "string" && /^\d+$/.test(o));
+    if (a === void 0) {
+      if (c)
+        throw new Error(
+          `REPLACE failed: Target array index '${o.toString()}' is out of bounds or does not exist at path '${e}'.`
+        );
+      Oe(s, o, t, !0);
+    } else
+      Oe(s, o, t, !0);
+  }
+  return !0;
+}
+function an(n, e) {
+  const t = re(e);
+  if (t.length === 0 && e === "/")
+    return n.setValue(null), n.setItems(void 0), n.setProperties(void 0), !0;
+  const { parent: r, key: s } = se(n, t);
+  return ss(r, s), !0;
+}
+function as(n, e, t) {
+  const r = rt(sn(n, e));
+  return on(n, t, r), !0;
+}
+function cs(n, e, t) {
+  const r = re(e), { parent: s, key: o } = se(n, r), i = dt(s, o);
+  if (i === void 0)
+    throw new Error(`MOVE failed: 'from' location '${e}' does not exist.`);
+  return an(n, e) ? (on(n, t, i), !0) : !1;
+}
+function ls(n, e, t) {
+  const r = sn(n, e);
+  let s = t;
+  if (r instanceof d)
+    if ((t === null || typeof t == "string" || typeof t == "number" || typeof t == "boolean" || M(t)) && (r.isInlineValue() || r.getValue() !== void 0)) {
+      if (!J(r.getValue() ?? null, t))
+        throw new Error(
+          `TEST failed at '${e}': Expected ${JSON.stringify(
+            t
+          )}, got ${JSON.stringify(r.getValue() ?? null)}`
+        );
+      return !0;
+    } else typeof t == "object" && !(t instanceof d) && (s = C(t));
+  else if (M(r) && typeof t == "number")
+    r instanceof N ? s = new N(t.toString()) : r instanceof k && (s = new k(t.toString()));
+  else if ((r === null || typeof r == "string" || typeof r == "number" || typeof r == "boolean") && M(t)) {
+    const o = t;
+    !J(r, o.toString()) && (typeof r == "number" && parseFloat(o.toString()));
+  }
+  if (!J(r, s)) {
+    const o = r instanceof d ? r.toString() : JSON.stringify(r), i = s instanceof d ? s.toString() : JSON.stringify(s);
+    throw new Error(
+      `TEST failed at '${e}': Expected ${i}, got ${o}`
+    );
+  }
+  return !0;
+}
+function us(n, e) {
+  switch (e.op) {
+    case "add":
+      return os(n, e.path, e.val);
+    case "replace":
+      return is(n, e.path, e.val);
+    case "remove":
+      return an(n, e.path);
+    case "copy":
+      return as(n, e.from, e.path);
+    case "move":
+      return cs(n, e.from, e.path);
+    case "test":
+      return ls(n, e.path, e.val);
+  }
+}
+function hs(n, e, t = !1) {
+  const r = t ? n : n.clone();
+  return us(r, e), r;
+}
+function ft(n) {
+  if (Object.isFrozen(n))
+    return n;
+  Object.freeze(n);
+  for (const e of Object.getOwnPropertyNames(n)) {
+    const t = n[e];
+    y(t) && typeof t == "object" && ft(t);
+  }
+  return n;
+}
+const ds = new Yt();
+function yt(n, e = "/", t = []) {
+  const r = n.getContracts() ?? {};
+  for (const [s, o] of Object.entries(r))
+    if (q.isTypeOf(
+      o,
+      et
+    )) {
+      const c = ds.convert(o, et).paths ?? [];
+      for (const h of c)
+        t.push({
+          absPath: U(e, h),
+          contractPath: U(e, `contracts/${s}`)
+        });
+    }
+  for (const [s, o] of Object.entries(n.getProperties() ?? {}))
+    yt(o, U(e, s), t);
+  return t;
+}
+function St(n, e) {
+  return n === e || n.startsWith(e.endsWith("/") ? e : e + "/");
+}
+function Nt(n, e) {
+  if (!e.length) return n;
+  let t = n.clone();
+  for (const r of e)
+    try {
+      t = hs(t, r, !0);
+    } catch (s) {
+      throw new tn(r, s);
+    }
+  return ft(t);
+}
+function S(n) {
+  return n != null;
+}
+function fe(n) {
+  return n instanceof d;
+}
+class ps {
+  constructor(e = [], t = (r, s) => r < s ? -1 : r > s ? 1 : 0) {
+    l(this, "data");
+    l(this, "length");
+    l(this, "compare");
+    if (this.data = e, this.length = this.data.length, this.compare = t, this.length > 0)
+      for (let r = (this.length >> 1) - 1; r >= 0; r--) this._down(r);
+  }
+  push(e) {
+    this.data.push(e), this._up(this.length++);
+  }
+  pop() {
+    if (this.length === 0) return;
+    const e = this.data[0], t = this.data.pop();
+    return --this.length > 0 && (this.data[0] = t, this._down(0)), e;
+  }
+  peek() {
+    return this.data[0];
+  }
+  _up(e) {
+    const { data: t, compare: r } = this, s = t[e];
+    for (; e > 0; ) {
+      const o = e - 1 >> 1, i = t[o];
+      if (r(s, i) >= 0) break;
+      t[e] = i, e = o;
+    }
+    t[e] = s;
+  }
+  _down(e) {
+    const { data: t, compare: r } = this, s = this.length >> 1, o = t[e];
+    for (; e < s; ) {
+      let i = (e << 1) + 1;
+      const a = i + 1;
+      if (a < this.length && r(t[a], t[i]) < 0 && (i = a), r(t[i], o) >= 0) break;
+      t[e] = t[i], e = i;
+    }
+    t[e] = o;
+  }
+}
+const fs = (n, e, t, r, s, o) => [
+  -n,
+  e,
+  t,
+  r,
+  s,
+  o
+], ys = (n, e) => {
+  for (let t = 0; t < n.key.length; t++) {
+    const r = n.key[t], s = e.key[t];
+    if (r !== s)
+      return typeof r == "number" && typeof s == "number" ? r - s : typeof r == "string" && typeof s == "string" ? r.localeCompare(s) : 0;
+  }
+  return 0;
+};
+class ms {
+  /**
+   * Creates a new task queue with the task key comparator
+   */
+  constructor() {
+    l(this, "queue");
+    this.queue = new ps([], ys);
+  }
+  /**
+   * Adds a task to the queue
+   *
+   * @param task - The task to add
+   */
+  push(e) {
+    this.queue.push(e);
+  }
+  /**
+   * Removes and returns the highest priority task
+   *
+   * @returns The highest priority task or undefined if queue is empty
+   */
+  pop() {
+    return this.queue.pop();
+  }
+  /**
+   * Gets the number of tasks in the queue
+   */
+  get length() {
+    return this.queue.length;
+  }
+}
+class gs {
+  /**
+   * Creates a new contract registry
+   *
+   * @param list - Initial list of processors to register
+   */
+  constructor(e = []) {
+    l(this, "processors", /* @__PURE__ */ new Map());
+    l(this, "typeOrder", /* @__PURE__ */ new Map());
+    e.forEach((t, r) => this.register(t, r));
+  }
+  /**
+   * Registers a new contract processor
+   *
+   * @param proc - The processor to register
+   * @param orderHint - Optional priority value for execution order
+   * @throws Error if a processor for the same contract type is already registered
+   */
+  register(e, t) {
+    if (this.processors.has(e.contractBlueId))
+      throw new Error(`Processor for ${e.contractType} already registered`);
+    this.processors.set(e.contractBlueId, e), this.typeOrder.has(e.contractBlueId) || this.typeOrder.set(e.contractBlueId, t ?? this.typeOrder.size);
+  }
+  /**
+   * Gets a processor by contract type node
+   *
+   * @param typeNode - The contract type node
+   * @returns The associated processor or undefined
+   */
+  get(e) {
+    if (!e) return;
+    const t = e.getBlueId();
+    if (t)
+      return this.processors.get(t);
+  }
+  /**
+   * Gets the order priority for a contract type node
+   *
+   * @param typeNode - The contract type node
+   * @returns The priority value (0 if not found)
+   */
+  orderOf(e) {
+    if (!e) return 0;
+    const t = e.getBlueId();
+    return t ? this.typeOrder.get(t) ?? 0 : 0;
+  }
+  /**
+   * Gets all registered processors
+   *
+   * @returns Iterator of all registered processors
+   */
+  values() {
+    return this.processors.values();
+  }
+}
+class ws {
+  constructor() {
+    l(this, "isEnabled");
+    this.isEnabled = process.env.TRACE_BLUE_ENABLED === "true";
+  }
+  /**
+   * Creates a hop entry for the trace
+   * @param nodePath - The path to the node
+   * @param contractName - The name of the contract
+   * @returns A formatted hop string
+   */
+  makeHop(e, t) {
+    return `${e}#${t}`;
+  }
+  /**
+   * Checks if tracing is enabled
+   * @returns Whether tracing is enabled
+   */
+  shouldTrace() {
+    return this.isEnabled;
+  }
+  /**
+   * Adds a hop to the event's trace if tracing is enabled
+   * @param event - The event to add the trace to
+   * @param nodePath - The path to the node
+   * @param contractName - The name of the contract
+   * @returns A new event with the updated trace
+   */
+  addHop(e, t, r) {
+    if (!this.shouldTrace())
+      return { ...e };
+    const s = [
+      ...e.trace ?? [],
+      this.makeHop(t, r)
+    ];
+    return {
+      ...e,
+      trace: s
+    };
+  }
+  /**
+   * Gets the current trace for an event
+   * @param event - The event to get the trace for
+   * @returns The current trace array or an empty array if none exists
+   */
+  getTrace(e) {
+    return e.trace ?? [];
+  }
+  /**
+   * Clears the trace for an event
+   * @param event - The event to clear the trace for
+   * @returns A new event with an empty trace
+   */
+  clearTrace(e) {
+    return {
+      ...e,
+      trace: []
+    };
+  }
+  /**
+   * Checks if tracing is enabled globally
+   * @returns Whether tracing is enabled
+   */
+  isTracingEnabled() {
+    return this.isEnabled;
+  }
+}
+const Ts = 64;
+class bs {
+  /**
+   * Creates a new event router
+   *
+   * @param registry - Contract registry for looking up processors
+   * @param queue - Task queue for scheduling handlers
+   * @param getNextTaskId - Function to get the next task ID
+   * @param getNextEventSeq - Function to get the next event sequence number
+   */
+  constructor(e, t, r, s, o) {
+    l(this, "traceManager");
+    this.blue = e, this.registry = t, this.queue = r, this.getNextTaskId = s, this.getNextEventSeq = o, this.traceManager = new ws();
+  }
+  /**
+   * Routes an event to matching contracts in the document
+   *
+   * @param doc - The document to route events in
+   * @param pathSegments - Path segments to the current node
+   * @param event - The event to route
+   * @param afterTaskId - Minimum task ID to use
+   * @param inlineDepth - Current adapter recursion depth
+   */
+  async route(e, t, r, s, o = 0) {
+    var c;
+    if (r.seq === void 0 && (r.seq = this.getNextEventSeq()), t.length === 0) {
+      if (r.dispatchPath) {
+        const h = r.dispatchPath.split("/").filter(Boolean), p = { ...r };
+        return delete p.dispatchPath, this.route(e, h, p, s, o);
+      }
+      if (r.source === "channel" && r.originNodePath && r.originNodePath !== "/") {
+        const h = ((c = r.originNodePath) == null ? void 0 : c.split("/").filter(Boolean)) ?? [];
+        return this.route(e, h, r, s, o);
+      }
+    }
+    const i = U("/", t.join("/")), a = e.get(i);
+    fe(a) && await this.traverseContracts({
+      doc: e,
+      node: a,
+      nodePath: i,
+      event: r,
+      afterTaskId: s,
+      pathSegments: t,
+      inlineDepth: o
+    });
+  }
+  /**
+   * Traverses contracts at the current node and routes to matching ones
+   */
+  async traverseContracts(e) {
+    const {
+      doc: t,
+      node: r,
+      nodePath: s,
+      event: o,
+      afterTaskId: i,
+      pathSegments: a,
+      inlineDepth: c
+    } = e;
+    if (!this.shouldSkipForChannel(o, s))
+      for (const [h, p] of Object.entries(
+        r.getContracts() ?? {}
+      )) {
+        if (!p.getType()) continue;
+        const g = this.registry.get(p.getType());
+        if (!g) {
+          console.warn(`No processor registered for contract: ${h}`);
+          continue;
+        }
+        const w = {
+          nodePath: s,
+          contractName: h,
+          contractNode: p,
+          event: o
+        }, f = new en(() => t, w, this.blue);
+        if (g.supports(o, p, f, h))
+          switch (g.role) {
+            case "adapter":
+              await this.processAdapter({
+                cp: g,
+                event: o,
+                contractNode: p,
+                ctx: f,
+                contractName: h,
+                doc: t,
+                afterTaskId: i,
+                inlineDepth: c
+              });
+              break;
+            case "handler":
+              this.scheduleHandler({
+                contractNode: p,
+                contractName: h,
+                nodePath: s,
+                event: o,
+                depth: a.length,
+                afterTaskId: i
+              });
+              break;
+          }
+      }
+  }
+  /**
+   * Processes an adapter contract and routes any emitted events
+   */
+  async processAdapter(e) {
+    var m;
+    const {
+      cp: t,
+      event: r,
+      contractNode: s,
+      ctx: o,
+      contractName: i,
+      doc: a,
+      afterTaskId: c,
+      inlineDepth: h
+    } = e;
+    if (h >= Ts)
+      throw new Error("Adapter recursion limit reached");
+    const p = this.traceManager.addHop(
+      r,
+      ((m = o.getTaskInfo()) == null ? void 0 : m.nodePath) ?? "",
+      i
+    );
+    await t.handle(p, s, o, i);
+    const g = await o.flush();
+    if (g.find((E) => E.kind === "patch"))
+      throw new Error(
+        `Contract "${i}" (adapter) attempted to patch the document`
+      );
+    const f = g.filter((E) => E.kind === "event");
+    for (const E of f)
+      await this.route(a, [], E.event, c, h + 1);
+  }
+  /**
+   * Schedules a handler contract for future execution
+   */
+  scheduleHandler(e) {
+    const { contractNode: t, contractName: r, nodePath: s, event: o, depth: i, afterTaskId: a } = e, c = t.getType();
+    if (!c) {
+      console.warn(`Contract node type is not defined for: ${r}`);
+      return;
+    }
+    const h = this.registry.orderOf(c), p = t.get("/order"), g = A(p) ? p.toNumber() : 0, w = this.getNextTaskId() + a, f = fs(
+      i,
+      o.seq,
+      h,
+      g,
+      r,
+      w
+    ), m = this.traceManager.addHop(o, s, r);
+    this.queue.push({
+      key: f,
+      nodePath: s,
+      contractName: r,
+      contractNode: t,
+      event: m
+    });
+  }
+  /**
+   * Checks if an event should be skipped because it came from another channel node
+   */
+  shouldSkipForChannel(e, t) {
+    return e.source === "channel" && !!e.originNodePath && e.originNodePath !== t;
+  }
+}
+const Es = (n, e, t) => {
+  (t instanceof tn || t instanceof nn) && console.error(
+    `[Blue] Failed to apply patches for contract "${n}" on event ${JSON.stringify(e)}`,
+    t
+  );
+};
+function At(n) {
+  const e = n.clone(), t = (r) => {
+    var o;
+    if (!fe(r)) return;
+    const s = r.getContracts();
+    s && (!s.checkpoint || ((o = s.checkpoint.getType()) == null ? void 0 : o.getBlueId()) !== b["Channel Event Checkpoint"]) && r.addContract(
+      "checkpoint",
+      T.deserialize({
+        type: {
+          name: "Channel Event Checkpoint",
+          blueId: b["Channel Event Checkpoint"]
+        },
+        lastEvents: {}
+      })
+    );
+  };
+  t(e);
+  for (const { absPath: r } of yt(e)) {
+    const s = e.get(r);
+    fe(s) && t(s);
+  }
+  return ft(e);
+}
+class Is {
+  constructor(e) {
+    l(this, "contractType", "Channel Event Checkpoint");
+    l(this, "contractBlueId", b["Channel Event Checkpoint"]);
+    l(this, "role", "handler");
+    this.cache = e;
+  }
+  supports(e) {
+    var t, r;
+    return e.source === "channel" && ((t = e.rootEvent) == null ? void 0 : t.payload) === e.payload && ((r = e.rootEvent) == null ? void 0 : r.source) === "external";
+  }
+  async handle(e, t, r) {
+    var i;
+    if (!e.channelName || !((i = e.rootEvent) != null && i.seq)) return;
+    const s = await r.getBlue().calculateBlueId(e.rootEvent.payload), o = r.getNodePath().replace(/\/contracts\/checkpoint$/, "");
+    this.cache.record(o, e, s);
+  }
+  init() {
+    return [];
+  }
+}
+const Ot = (n, e) => n.get(e) !== void 0;
+class vs {
+  constructor() {
+    l(this, "firstSeen", /* @__PURE__ */ new Map());
+  }
+  record(e, t, r) {
+    const s = e;
+    this.firstSeen.has(s) || this.firstSeen.set(s, { docBase: e, event: t, eventBlueId: r });
+  }
+  /** Turn cached data into JSON-Patch ops */
+  flush(e) {
+    const t = [];
+    for (const { docBase: r, event: s, eventBlueId: o } of this.firstSeen.values()) {
+      if (!s.channelName) continue;
+      const i = U(
+        r,
+        "contracts/checkpoint/lastEvents",
+        s.channelName
+      ), a = `${i}/blueId`;
+      Ot(e, i) ? t.push({
+        op: Ot(e, a) ? "replace" : "add",
+        path: a,
+        val: o
+      }) : t.push({
+        op: "add",
+        path: i,
+        val: { blueId: o }
+      });
+    }
+    return t;
+  }
+  clear() {
+    this.firstSeen.clear();
+  }
+}
+class Ps {
+  /**
+   * Creates a new document processor
+   *
+   * @param processors - Initial list of processors to register
+   */
+  constructor(e, t = []) {
+    l(this, "taskCounter", 0);
+    l(this, "eventCounter", 0);
+    l(this, "registry");
+    l(this, "queue");
+    l(this, "router");
+    l(this, "checkpointCache", new vs());
+    this.blue = e, this.registry = new gs(t), this.queue = new ms(), this.router = new bs(
+      this.blue,
+      this.registry,
+      this.queue,
+      () => ++this.taskCounter,
+      () => ++this.eventCounter
+    ), this.register(
+      new Is(this.checkpointCache),
+      9999
+    );
+  }
+  /**
+   * Registers a new contract processor
+   *
+   * @param cp - The processor to register
+   * @param orderHint - Optional priority value for execution order
+   */
+  register(e, t) {
+    this.registry.register(e, t);
+  }
+  /**
+   * Initializes a document and runs all init events
+   *
+   * @param document - The document to initialize
+   * @returns Processing result with final state and emitted events
+   */
+  async initialise(e) {
+    e = At(e);
+    const t = await this.bootstrapContracts(e);
+    for (const r of t)
+      await this.router.route(e, [], r, 0);
+    return this.drainQueue(e);
+  }
+  /**
+   * Processes a batch of events against the document
+   *
+   * @param document - The document to process events against
+   * @param incoming - List of event payloads to process
+   * @returns Processing result with final state and emitted events
+   */
+  async processEvents(e, t) {
+    let r = At(e);
+    const s = [];
+    for (const o of t)
+      try {
+        const i = { payload: o, source: "external" };
+        await this.router.route(r, [], i, 0);
+        const a = await this.drainQueue(r);
+        r = a.state, s.push(...a.emitted);
+        const c = this.checkpointCache.flush(r);
+        c.length && (r = Nt(r, c));
+      } finally {
+        this.checkpointCache.clear();
+      }
+    return { state: r, emitted: s };
+  }
+  /**
+   * Collects initialization events from contract processors
+   */
+  async bootstrapContracts(e) {
+    const t = [], r = e.getContracts();
+    if (!r)
+      return t;
+    for (const [, s] of Object.entries(r)) {
+      const o = this.registry.get(s.getType());
+      o != null && o.init && t.push(...await o.init(s));
+    }
+    return t;
+  }
+  /**
+   * Drains the task queue and applies all actions
+   */
+  async drainQueue(e) {
+    var i;
+    let t = e;
+    const r = [], s = 1e4;
+    let o = 0;
+    for (; this.queue.length; ) {
+      if (++o > s)
+        throw new Error("Possible cycle – too many iterations");
+      const a = this.queue.pop(), { nodePath: c, contractName: h, contractNode: p, event: g } = a, w = t.get(c);
+      if (!fe(w) || !((i = w.getContracts()) != null && i[h]) || !p.getType()) continue;
+      const f = this.registry.get(p.getType());
+      if (!f) {
+        console.warn(`No processor registered for contract: ${h}`);
+        continue;
+      }
+      const m = new en(
+        () => t,
+        a,
+        this.blue,
+        async (E) => {
+          for (const I of E)
+            if (I.kind === "patch") {
+              const H = yt(t);
+              for (const B of H) {
+                const ie = I.patch.op === "move" || I.patch.op === "copy" ? [I.patch.from, I.patch.path] : [I.patch.path], be = m.getNodePath(), dn = ie.some(
+                  (fn) => St(fn, B.absPath)
+                ), pn = St(
+                  be,
+                  B.absPath
+                );
+                if (dn && !pn)
+                  throw new nn(
+                    I.patch,
+                    B.absPath,
+                    be
+                  );
+              }
+              try {
+                t = Nt(t, [I.patch]);
+              } catch (B) {
+                throw Es(h, g, B), B;
+              }
+            } else I.kind === "event" && (r.push(I.event.payload), await this.router.route(t, [], I.event, a.key[5]));
+        }
+      );
+      await f.handle(g, p, m, h), await m.flush();
+    }
+    return { state: t, emitted: r };
+  }
+}
+class oe {
+  constructor() {
+    l(this, "role", "adapter");
+  }
+  /**
+   * Base implementation of supports that checks if the event is not from a channel
+   * Derived classes should call this method first in their supports implementation
+   */
+  baseSupports(e) {
+    return e.source !== "channel";
+  }
+  /**
+   * Base implementation that returns empty array
+   * Can be overridden by derived classes if needed
+   */
+  init() {
+    return [];
+  }
+}
+class Bs extends oe {
+  constructor() {
+    super(...arguments);
+    l(this, "contractType", "Composite Timeline Channel");
+    l(this, "contractBlueId", b["Composite Timeline Channel"]);
+  }
+  supports(t, r, s) {
+    const o = s.getBlue().nodeToSchemaOutput(r, Ur);
+    return !o.channels || !t.channelName ? !1 : o.channels.includes(t.channelName);
+  }
+  handle(t, r, s, o) {
+    s.emitEvent({
+      payload: t.payload,
+      channelName: o,
+      source: "channel"
+    });
+  }
+}
+class Cs extends oe {
+  constructor() {
+    super(...arguments);
+    l(this, "contractType", "Document Update Channel");
+    l(this, "contractBlueId", b["Document Update Channel"]);
+  }
+  supports(t, r, s, o) {
+    if (!this.baseSupports(t)) return !1;
+    const i = s.getBlue().nodeToSchemaOutput(r, Zr), a = t.payload.path;
+    if (!a || t.channelName === o) return !1;
+    const c = i.path;
+    return y(c) && a === s.resolvePath(c);
+  }
+  handle(t, r, s, o) {
+    const i = t.payload;
+    i && s.emitEvent({
+      payload: i,
+      channelName: o,
+      source: "channel"
+    });
+  }
+}
+class Ss extends oe {
+  constructor() {
+    super(...arguments);
+    l(this, "contractType", "Embedded Node Channel");
+    l(this, "contractBlueId", b["Embedded Node Channel"]);
+  }
+  supports(t, r, s) {
+    if (!this.baseSupports(t)) return !1;
+    const o = s.getBlue().nodeToSchemaOutput(r, vt);
+    return S(t.originNodePath) && S(o.path) && t.originNodePath === s.resolvePath(o.path);
+  }
+  handle(t, r, s, o) {
+    const i = s.getBlue().nodeToSchemaOutput(r, vt), { originNodePath: a, payload: c } = t;
+    S(i.path) && a === s.resolvePath(i.path) && s.emitEvent({
+      payload: c,
+      channelName: o,
+      source: "channel"
+    });
+  }
+}
+const kt = (n) => n.payload.type === "Timeline Entry" || n.payload.type === "MyOS Timeline Entry";
+class Ns extends oe {
+  constructor() {
+    super(...arguments);
+    l(this, "contractType", "MyOS Timeline Channel");
+    l(this, "contractBlueId", j["MyOS Timeline Channel"]);
+  }
+  supports(t, r, s) {
+    if (!this.baseSupports(t) || !kt(t)) return !1;
+    const o = s.getBlue(), i = o.jsonValueToNode(t.payload), a = o.nodeToSchemaOutput(
+      i,
+      Kr
+    ), c = s.getBlue().nodeToSchemaOutput(r, Jr), h = S(c.timelineId) && S(a.timelineId), p = S(c.account) && S(a.account), g = S(c.email) && S(a.email);
+    return h && a.timelineId === c.timelineId || p && a.account === c.account || g && a.email === c.email;
+  }
+  handle(t, r, s, o) {
+    kt(t) && s.emitEvent({
+      payload: t.payload,
+      channelName: o,
+      source: "channel"
+    });
+  }
+}
+class As extends oe {
+  constructor() {
+    super(...arguments);
+    l(this, "contractType", "MyOS Agent Channel");
+    l(this, "contractBlueId", j["MyOS Agent Channel"]);
+  }
+  supports(t, r, s) {
+    if (!this.baseSupports(t)) return !1;
+    try {
+      const { myosAgentEvent: o, myosAgentChannel: i } = this.parseEventAndChannel(
+        t,
+        r,
+        s
+      );
+      return this.isAgentMatch(o, i) && this.isEventPatternMatch(o, i, s);
+    } catch (o) {
+      return console.warn("Error in MyOSAgentChannelProcessor.supports:", o), !1;
+    }
+  }
+  handle(t, r, s, o) {
+    s.emitEvent({
+      payload: t.payload,
+      channelName: o,
+      source: "channel"
+    });
+  }
+  /**
+   * Parses and validates the event payload and channel configuration
+   * @throws {Error} If schema validation fails
+   */
+  parseEventAndChannel(t, r, s) {
+    const o = s.getBlue(), i = o.jsonValueToNode(t.payload), a = o.nodeToSchemaOutput(
+      i,
+      Hr
+    ), c = o.nodeToSchemaOutput(
+      r,
+      zr
+    );
+    return { myosAgentEvent: a, myosAgentChannel: c };
+  }
+  /**
+   * Checks if the agent IDs match between event and channel
+   * @param myosAgentEvent - The parsed agent event
+   * @param myosAgentChannel - The parsed agent channel configuration
+   * @returns true if both have valid agent IDs and they match
+   */
+  isAgentMatch(t, r) {
+    var i;
+    const s = t.agentId, o = (i = r.agent) == null ? void 0 : i.agentId;
+    return S(s) && S(o) && s === o;
+  }
+  /**
+   * Checks if the event pattern matches the channel's event filter
+   *
+   * @param myosAgentEvent - The parsed agent event
+   * @param myosAgentChannel - The parsed agent channel configuration
+   * @param ctx - Processing context for Blue instance access
+   * @returns true if the event matches the channel's filter criteria
+   *
+   * **Matching Logic:**
+   * - If no event pattern is specified in channel → matches all events
+   * - If channel has event pattern but incoming event has no event data → no match
+   * - Otherwise → uses deep containment matching (event must contain all channel pattern fields)
+   */
+  isEventPatternMatch(t, r, s) {
+    const o = r.event;
+    if (!o)
+      return !0;
+    const i = t.event;
+    if (!i)
+      return !1;
+    try {
+      const a = s.getBlue(), c = a.nodeToJson(i), h = a.nodeToJson(o);
+      return wn(c, h);
+    } catch (a) {
+      return console.warn("Error during event pattern matching:", a), !1;
+    }
+  }
+}
+class Os {
+  constructor() {
+    l(this, "contractType", "Operation");
+    l(this, "contractBlueId", b.Operation);
+    l(this, "role", "adapter");
+  }
+  supports(e, t, r, s) {
+    const i = r.getBlue().nodeToSchemaOutput(t, qr), a = this.parseEventPayload(e, r);
+    return S(a == null ? void 0 : a.operation) && a.operation === s && e.source === "channel" && e.channelName === i.channel;
+  }
+  async handle(e, t, r, s) {
+    r.emitEvent({
+      payload: e.payload,
+      channelName: s,
+      source: "channel"
+    });
+  }
+  init() {
+    return [];
+  }
+  parseEventPayload(e, t) {
+    const r = t.getBlue(), s = r.jsonValueToNode(e.payload);
+    if (q.isTypeOf(s, Ne)) {
+      const o = r.nodeToSchemaOutput(
+        s,
+        Ne
+      );
+      return r.nodeToSchemaOutput(
+        o.message,
+        Lr
+      );
+    }
+    return null;
+  }
+}
+class ks {
+  constructor() {
+    l(this, "contractType", "Process Embedded");
+    l(this, "role", "adapter");
+    l(this, "contractBlueId", b["Process Embedded"]);
+  }
+  supports(e) {
+    return e.source !== "channel";
+  }
+  handle(e, t, r) {
+    const s = r.getBlue().nodeToSchemaOutput(t, et);
+    for (const o of s.paths ?? [])
+      r.emitEvent({
+        ...e,
+        dispatchPath: r.resolvePath(o)
+      });
+  }
+  init() {
+    return [];
+  }
+}
+const cn = !process.env.SKIP_ISOLATED_VM;
+let R = null;
+if (cn)
+  try {
+    R = require("isolated-vm");
+  } catch {
+    console.warn("isolated-vm not available, using fallback evaluation method");
+  }
+function xt(n) {
+  return /\bimport\s.+\sfrom\s+['"][^'"]+['"]/.test(n) || /\bexport\s+/.test(n);
+}
+class ln {
+  /**
+   * Main evaluation method - chooses between secure and simple evaluation strategies
+   */
+  static async evaluate({
+    code: e,
+    ctx: t,
+    bindings: r = {},
+    options: s = {}
+  }) {
+    return !R || !cn ? this.evaluateSimple(e, r, s) : this.evaluateSecure(e, r, t, s);
+  }
+  /**
+   * Fallback evaluation using Node's Function constructor
+   * Used when isolated-vm is not available
+   */
+  static async evaluateSimple(e, t, r = {}) {
+    if (xt(e))
+      throw new Error(
+        "Static import/export syntax requires isolated-vm – start Node without SKIP_ISOLATED_VM."
+      );
+    try {
+      if (r.isCodeBlock) {
+        const s = Object.keys(t);
+        return await (await new Function(
+          ...s,
+          `return async function codeBlock(${s.join(
+            ", "
+          )}) { ${e} }`
+        )(
+          ...s.map((a) => t[a])
+        ))(...s.map((a) => t[a]));
+      } else
+        return new Function(
+          ...Object.keys(t),
+          `return ${e};`
+        )(...Object.values(t));
+    } catch (s) {
+      throw r.isCodeBlock ? new Bt(e, s) : new Pt(e, s);
+    }
+  }
+  /**
+   * Secure evaluation using isolated-vm with support for ES modules
+   */
+  static async evaluateSecure(e, t, r, s = {}) {
+    if (!R) throw new Error("isolated-vm not available");
+    const o = new R.Isolate({ memoryLimit: 32 }), i = await o.createContext(), a = i.global;
+    try {
+      await this.setupIsolateEnvironment(a, t);
+      const c = /* @__PURE__ */ new Map(), h = this.createModuleResolver(
+        o,
+        i,
+        c,
+        r
+      );
+      return xt(e) ? await this.evaluateESModule(
+        o,
+        i,
+        e,
+        s,
+        h
+      ) : await this.evaluateSimpleScript(
+        o,
+        i,
+        e,
+        t,
+        s
+      );
+    } catch (c) {
+      throw s.isCodeBlock ? new Bt(e, c) : new Pt(e, c);
+    } finally {
+      i.release(), o.dispose();
+    }
+  }
+  /**
+   * Setup the isolated VM environment with necessary host functions and data
+   */
+  static async setupIsolateEnvironment(e, t) {
+    if (!R) throw new Error("isolated-vm not available");
+    const r = new R.Callback(
+      (...s) => console.log(...s)
+    );
+    await e.set("log", r);
+    for (const [s, o] of Object.entries(t))
+      typeof o == "function" ? await e.set(
+        s,
+        new R.Callback(o)
+      ) : await e.set(s, new R.ExternalCopy(o).copyInto());
+  }
+  /**
+   * Create module resolver function for handling imports
+   */
+  static createModuleResolver(e, t, r, s) {
+    return async (o) => {
+      if (r.has(o)) return r.get(o);
+      if (o.startsWith("blue:")) {
+        const i = o.slice(5), a = s.loadBlueContent;
+        if (typeof a != "function")
+          throw new Error(
+            `ProcessingContext is missing a loadBlueContent(blueId) implementation (needed for ${o})`
+          );
+        const c = await a(i), h = await e.compileModule(c);
+        return r.set(o, h), await h.instantiate(
+          t,
+          this.createModuleResolver(e, t, r, s)
+        ), h;
+      }
+      if (/^https?:\/\//.test(o)) {
+        let i;
+        if (typeof s.loadExternalModule == "function")
+          i = await s.loadExternalModule(o);
+        else
+          throw new Error(
+            `ProcessingContext is missing a loadExternalModule(url) implementation (needed for ${o})`
+          );
+        const a = await e.compileModule(i);
+        return r.set(o, a), await a.instantiate(
+          t,
+          this.createModuleResolver(e, t, r, s)
+        ), a;
+      }
+      throw new Error(`Unsupported module specifier "${o}"`);
+    };
+  }
+  /**
+   * Evaluate code as a simple script (no imports/exports)
+   */
+  static async evaluateSimpleScript(e, t, r, s, o) {
+    const i = Object.keys(s).join(", "), a = Object.keys(s).map((p) => p), c = `(async (${i}) => { ${o.isCodeBlock ? r : `return (${r});`} })(${a.join(", ")})`;
+    return await (await e.compileScript(c)).run(t, {
+      timeout: o.timeout ?? 500,
+      promise: !0,
+      copy: !0,
+      release: !0
+    });
+  }
+  /**
+   * Evaluate code as an ES module with import/export support
+   */
+  static async evaluateESModule(e, t, r, s, o) {
+    let i = r;
+    if (s.isCodeBlock) {
+      const h = /^\s*(import\s.+?;|export\s.+?;)/gm, p = (r.match(h) || []).join(
+        `
+`
+      ), g = r.replace(h, "").trim();
+      i = `
+      ${p}
+      const run = function() {
+        ${g}
+      };
+      export default run();
+      `;
+    }
+    const a = await e.compileModule(i);
+    return await a.instantiate(t, o), await a.evaluate({
+      timeout: s.timeout ?? 500,
+      promise: !0,
+      reference: !0,
+      release: !0
+    }), await a.namespace.get("default", {
+      timeout: s.timeout ?? 500,
+      promise: !0,
+      copy: !0,
+      release: !0
+    });
+  }
+}
+class un {
+  /**
+   * Creates standard bindings for workflow step execution
+   */
+  static createStandardBindings(e, t, r) {
+    const s = e.getBlue();
+    return {
+      document: (o) => {
+        const i = e.get(o);
+        return A(i) ? i.toNumber() : fe(i) ? s.nodeToJson(i, "original") : i;
+      },
+      event: t.payload,
+      steps: r
+    };
+  }
+}
+class xs {
+  constructor() {
+    l(this, "stepType", "Update Document");
+  }
+  supports(e) {
+    return q.isTypeOf(e, _e);
+  }
+  async evaluateChangeValue(e, t, r, s) {
+    const o = e == null ? void 0 : e.getValue();
+    if (typeof o == "string" && o.startsWith("${") && o.endsWith("}")) {
+      const i = o.slice(2, -1);
+      return await ln.evaluate({
+        code: i,
+        ctx: t,
+        bindings: un.createStandardBindings(
+          t,
+          r,
+          s
+        )
+      });
+    }
+    return e;
+  }
+  async execute(e, t, r, s, o) {
+    if (!q.isTypeOf(e, _e)) return;
+    const i = r.getBlue().nodeToSchemaOutput(e, _e);
+    for (const a of i.changeset ?? [])
+      if (a.path) {
+        if (a.op === "replace" || a.op === "add") {
+          const c = await this.evaluateChangeValue(
+            a.val,
+            r,
+            t,
+            o
+          );
+          r.addPatch({
+            op: a.op,
+            path: a.path,
+            val: c
+          }), r.emitEvent({
+            payload: {
+              type: "Document Update",
+              op: a.op,
+              path: r.resolvePath(a.path),
+              val: c
+            }
+          });
+        }
+        a.op === "remove" && (r.addPatch({ op: a.op, path: a.path }), r.emitEvent({
+          payload: {
+            type: "Document Update",
+            op: a.op,
+            path: r.resolvePath(a.path),
+            val: null
+          }
+        }));
+      }
+  }
+}
+class Ds {
+  constructor() {
+    l(this, "stepType", "Trigger Event");
+  }
+  supports(e) {
+    return q.isTypeOf(e, Le);
+  }
+  async execute(e, t, r) {
+    if (!q.isTypeOf(e, Le)) return;
+    const s = r.getBlue().nodeToSchemaOutput(e, Le), o = P.get(
+      s.event,
+      "simple"
+    );
+    r.emitEvent({
+      payload: o
+    });
+  }
+}
+const We = v(b["JavaScript Code"])(
+  u.object({
+    code: u.string().optional()
+  })
+);
+class Vs {
+  constructor() {
+    l(this, "stepType", "JavaScript Code");
+  }
+  supports(e) {
+    return q.isTypeOf(e, We);
+  }
+  async execute(e, t, r, s, o) {
+    if (!q.isTypeOf(e, We)) return;
+    const a = r.getBlue().nodeToSchemaOutput(
+      e,
+      We
+    );
+    if (!a.code)
+      throw new Error("JavaScript code is required");
+    const c = await ln.evaluate({
+      code: a.code,
+      ctx: r,
+      bindings: un.createStandardBindings(r, t, o),
+      options: {
+        isCodeBlock: !0,
+        timeout: 500
+      }
+    });
+    if (c && typeof c == "object" && "events" in c) {
+      const h = c;
+      if (Array.isArray(h.events))
+        for (const p of h.events)
+          r.emitEvent({
+            payload: p
+          });
+    }
+    return c;
+  }
+}
+const Fs = [
+  new xs(),
+  new Ds(),
+  new Vs()
+];
+class hn {
+  constructor(e = Fs) {
+    l(this, "contractType", "Sequential Workflow");
+    l(this, "contractBlueId", b["Sequential Workflow"]);
+    l(this, "role", "handler");
+    l(this, "executors", []);
+    this.executors = e;
+  }
+  /** allow registering custom step executors */
+  registerExecutor(e) {
+    this.executors.push(e);
+  }
+  supports(e, t, r) {
+    const i = r.getBlue().nodeToSchemaOutput(
+      t,
+      tt
+    ).channel;
+    return e.source === "channel" && e.channelName === i;
+  }
+  async handle(e, t, r, s) {
+    const i = r.getBlue().nodeToSchemaOutput(
+      t,
+      tt
+    ), a = {}, c = i.steps;
+    for (const [h, p] of (c ?? []).entries()) {
+      const g = this.executors.find((f) => f.supports(p));
+      if (!g)
+        throw new Error(`Unsupported workflow step type "${p.getType()}"`);
+      const w = await g.execute(
+        p,
+        e,
+        r,
+        s,
+        a
+      );
+      if (w !== void 0) {
+        const f = p.getName(), m = typeof f == "string" ? f : `Step${h + 1}`;
+        a[m] = w;
+      }
+      await r.flush();
+    }
+  }
+  init() {
+    return [];
+  }
+}
+class Ms {
+  constructor(e) {
+    l(this, "contractType", "Sequential Workflow Operation");
+    l(this, "contractBlueId", b["Sequential Workflow Operation"]);
+    l(this, "role", "handler");
+    l(this, "sequentialWorkflowProcessor");
+    this.sequentialWorkflowProcessor = e || new hn();
+  }
+  supports(e, t, r) {
+    const i = r.getBlue().nodeToSchemaOutput(
+      t,
+      _r
+    ).operation, a = e.channelName;
+    return e.source === "channel" && y(a) && y(i) && a === i;
+  }
+  async handle(e, t, r, s) {
+    try {
+      await this.sequentialWorkflowProcessor.handle(e, t, r, s);
+    } catch (o) {
+      throw console.error(
+        "Error in SequentialWorkflowOperationProcessor.handle:",
+        o
+      ), o;
+    }
+  }
+}
+const Dt = (n) => n.payload.type === "Timeline Entry";
+class js extends oe {
+  constructor() {
+    super(...arguments);
+    l(this, "contractType", "Timeline Channel");
+    l(this, "contractBlueId", b["Timeline Channel"]);
+  }
+  supports(t, r, s) {
+    if (!this.baseSupports(t) || !Dt(t)) return !1;
+    const o = s.getBlue(), i = o.jsonValueToNode(t.payload), a = o.nodeToSchemaOutput(
+      i,
+      Ne
+    ), c = s.getBlue().nodeToSchemaOutput(r, Xt);
+    return S(c.timelineId) && S(a.timelineId) && a.timelineId === c.timelineId;
+  }
+  handle(t, r, s, o) {
+    Dt(t) && s.emitEvent({
+      payload: t.payload,
+      channelName: o,
+      source: "channel"
+    });
+  }
+}
+class go {
+  constructor(e = {}) {
+    l(this, "nodeProvider");
+    l(this, "typeSchemaResolver");
+    l(this, "blueDirectivePreprocessor");
+    l(this, "urlContentFetcher");
+    l(this, "documentProcessor");
+    l(this, "prepareForBlueIdCalculation", async (e) => e instanceof d || Array.isArray(e) && e.every((t) => t instanceof d) ? e : Array.isArray(e) ? await Promise.all(
+      e.map((r) => this.jsonValueToNodeAsync(r))
+    ) : this.jsonValueToNodeAsync(e));
+    l(this, "calculateBlueId", async (e) => {
+      const t = await this.prepareForBlueIdCalculation(e);
+      return V.calculateBlueId(t);
+    });
+    l(this, "prepareForBlueIdCalculationSync", (e) => e instanceof d || Array.isArray(e) && e.every((t) => t instanceof d) ? e : Array.isArray(e) ? e.map((t) => this.jsonValueToNode(t)) : this.jsonValueToNode(e));
+    const {
+      nodeProvider: t,
+      typeSchemaResolver: r = null,
+      urlFetchStrategy: s
+    } = e, o = Pr(() => []);
+    this.nodeProvider = pe.wrap(
+      t || o
+    ), this.typeSchemaResolver = r, this.urlContentFetcher = new Xr(s), this.blueDirectivePreprocessor = new Qr(
+      void 0,
+      this.urlContentFetcher
+    ), this.documentProcessor = new Ps(this, [
+      new ks(),
+      // channels
+      new Ss(),
+      new Cs(),
+      new js(),
+      new Ns(),
+      new As(),
+      new Bs(),
+      new Os(),
+      // sequential workflows
+      new hn(),
+      new Ms()
+    ]);
+  }
+  /**
+   * Converts a BlueNode to a JSON representation based on the specified strategy.
+   *
+   * @param node - The BlueNode to convert.
+   * @param strategy - The conversion strategy to use. See {@link NodeToMapListOrValue.get} for detailed strategy descriptions.
+   * @returns A JSON representation of the node.
+   */
+  nodeToJson(e, t = "official") {
+    return P.get(e, t);
+  }
+  nodeToSchemaOutput(e, t) {
+    return new Yt(this.typeSchemaResolver).convert(e, t);
+  }
+  async process(e, t) {
+    return await this.documentProcessor.initialise(e), this.documentProcessor.processEvents(e, t);
+  }
+  jsonValueToNode(e) {
+    return this.preprocess(T.deserialize(e));
+  }
+  async jsonValueToNodeAsync(e) {
+    return this.preprocessAsync(T.deserialize(e));
+  }
+  yamlToNode(e) {
+    const t = de(e);
+    if (!t)
+      throw new Error("Failed to parse YAML to JSON");
+    return this.jsonValueToNode(t);
+  }
+  async yamlToNodeAsync(e) {
+    const t = de(e);
+    if (!t)
+      throw new Error("Failed to parse YAML to JSON");
+    return this.jsonValueToNodeAsync(t);
+  }
+  calculateBlueIdSync(e) {
+    const t = this.prepareForBlueIdCalculationSync(e);
+    return V.calculateBlueIdSync(t);
+  }
+  addPreprocessingAliases(e) {
+    this.blueDirectivePreprocessor.addPreprocessingAliases(e);
+  }
+  preprocess(e) {
+    const t = this.blueDirectivePreprocessor.process(e);
+    return new Ae(this.nodeProvider).preprocessWithDefaultBlue(
+      t
+    );
+  }
+  async preprocessAsync(e) {
+    const t = await this.blueDirectivePreprocessor.processAsync(
+      e
+    );
+    return new Ae(this.nodeProvider).preprocessWithDefaultBlue(
+      t
+    );
+  }
+  getNodeProvider() {
+    return this.nodeProvider;
+  }
+  setNodeProvider(e) {
+    return this.nodeProvider = pe.wrap(e), this;
+  }
+  getTypeSchemaResolver() {
+    return this.typeSchemaResolver;
+  }
+  setTypeSchemaResolver(e) {
+    return this.typeSchemaResolver = e, this;
+  }
+  getUrlContentFetcher() {
+    return this.urlContentFetcher;
+  }
+  setUrlFetchStrategy(e) {
+    return this.urlContentFetcher.setFetchStrategy(e), this;
+  }
+  /**
+   * Enables fetching content from URLs in blue directives for all domains.
+   * By default, URL fetching is disabled for security reasons.
+   * This clears any domain restrictions that may have been set.
+   *
+   * @returns This instance for chaining
+   */
+  enablePreprocessingDirectivesFetchForUrls() {
+    return this.urlContentFetcher.enableFetching(), this;
+  }
+  /**
+   * Enables fetching content from URLs in blue directives only for specified domains.
+   * By default, URL fetching is disabled for security reasons.
+   *
+   * @param domains Array of domains to allow (e.g. ['example.com', 'api.github.com'])
+   * @returns This instance for chaining
+   */
+  enablePreprocessingDirectivesFetchForDomains(e) {
+    return this.urlContentFetcher.enableFetchingForDomains(e), this;
+  }
+  /**
+   * Adds a domain to the list of allowed domains for URL fetching.
+   *
+   * @param domain Domain to allow (e.g. 'example.com')
+   * @returns This instance for chaining
+   */
+  allowUrlFetchingForDomain(e) {
+    return this.urlContentFetcher.allowDomain(e), this;
+  }
+  /**
+   * Removes a domain from the list of allowed domains for URL fetching.
+   *
+   * @param domain Domain to disallow
+   * @returns This instance for chaining
+   */
+  disallowUrlFetchingForDomain(e) {
+    return this.urlContentFetcher.disallowDomain(e), this;
+  }
+  /**
+   * Gets the list of domains allowed for URL fetching.
+   * An empty list means all domains are allowed when fetching is enabled.
+   *
+   * @returns Array of allowed domains
+   */
+  getAllowedUrlFetchingDomains() {
+    return this.urlContentFetcher.getAllowedDomains();
+  }
+  /**
+   * Disables fetching content from URLs in blue directives.
+   *
+   * @returns This instance for chaining
+   */
+  disablePreprocessingDirectivesFetchForUrls() {
+    return this.urlContentFetcher.disableFetching(), this;
+  }
+  /**
+   * Checks if URL fetching is enabled for blue directives
+   *
+   * @returns true if URL fetching is enabled, false otherwise
+   */
+  isPreprocessingDirectivesFetchForUrlsEnabled() {
+    return this.urlContentFetcher.isFetchingEnabled();
+  }
+  getPreprocessingAliases() {
+    return this.blueDirectivePreprocessor.getPreprocessingAliases();
+  }
+  setPreprocessingAliases(e) {
+    return this.blueDirectivePreprocessor.setPreprocessingAliases(e), this;
+  }
+}
+export {
+  Gn as Base58Sha256Provider,
+  go as Blue,
+  V as BlueIdCalculator,
+  so as BlueIdToCid,
+  Hn as JsonCanonicalizer,
+  co as TypeSchemaResolver,
+  je as baseBlueObjectSchema,
+  oo as blueDescriptionField,
+  io as blueIdField,
+  zs as blueIdSchema,
+  ao as blueNameField,
+  _ as blueNodeField,
+  Gs as blueObjectBooleanValueSchema,
+  Qs as blueObjectNumberValueSchema,
+  ue as blueObjectSchema,
+  Xs as blueObjectStringListItemsSchema,
+  Hs as blueObjectStringValueSchema,
+  Fr as calculateBlueId,
+  uo as calculateBlueIdSync,
+  Tt as enrichWithBlueId,
+  tr as getBlueDescriptionAnnotation,
+  sr as getBlueIdAnnotation,
+  ir as getBlueNameAnnotation,
+  cr as getBlueNodeAnnotation,
+  ho as getBlueObjectItems,
+  fo as getBlueObjectProperties,
+  yo as getBlueObjectTypeLabel,
+  po as getBlueObjectValue,
+  ur as getExtendedFromSchemaAnnotation,
+  pr as getTypeBlueIdAnnotation,
+  $n as hasBlueObjectBlueIdDefined,
+  Un as hasBlueObjectItemsDefined,
+  to as hasBlueObjectNameDefined,
+  Zn as hasBlueObjectTypeDefined,
+  qn as hasBlueObjectValueDefined,
+  wt as isBlueNodeSchema,
+  eo as isBlueObject,
+  Mr as isBlueObjectResolved,
+  no as isGivenBlueObjectTypeSchema,
+  Wt as isJsonBlueArray,
+  _t as isJsonBlueObject,
+  ro as isJsonBlueValue,
+  Jt as isSchemaExtendedFrom,
+  ve as isUrl,
+  Se as jsonBlueValueSchema,
+  mo as normalizeToBlueObject,
+  bt as resolveBlueObjectItems,
+  er as withBlueDescription,
+  rr as withBlueId,
+  or as withBlueName,
+  ar as withBlueNode,
+  lr as withExtendedFromSchema,
+  v as withTypeBlueId,
+  lo as yamlBlueDump,
+  de as yamlBlueParse
+};