@blue-labs/document-processor 1.21.0

package/dist/index.mjs

@@ -0,0 +1,1557 @@
+var he = Object.defineProperty;
+var de = (i, e, t) => e in i ? he(i, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : i[e] = t;
+var l = (i, e, t) => de(i, typeof e != "symbol" ? e + "" : e, t);
+import { z as u } from "zod";
+import { withTypeBlueId as m, blueNodeField as k, applyBlueNodePatch as pe, BlueNodeTypeSchema as P, BlueNode as me, isBigNumber as z } from "@blue-labs/language";
+import { deepFreeze as X, isNonNullable as D, deepContains as fe } from "@blue-labs/shared-utils";
+const ge = (i, e) => ({
+  on: (t, n) => ({ end: () => n(null) })
+});
+async function ye(i) {
+  return new Promise((e, t) => {
+    ge().on("error", t).end();
+  });
+}
+const S = (...i) => i.map((e, t) => {
+  if (typeof e != "string") return "";
+  if (t === 0 && e === "/") return "/";
+  const n = t > 0 ? e.replace(/^\/+/, "") : e;
+  return t < i.length - 1 ? n.replace(/\/+$/, "") : n;
+}).filter(Boolean).join("/").replace(/\/{2,}/g, "/");
+class Y {
+  constructor(e, t, n, o) {
+    l(this, "actions", []);
+    this.getDocument = e, this.taskInfo = t, this.blue = n, this.onFlush = o;
+  }
+  get(e) {
+    const t = this.getDocument(), n = S(this.taskInfo.nodePath, e);
+    return t.get(n);
+  }
+  addPatch(e) {
+    this.actions.push({
+      kind: "patch",
+      patch: {
+        ...e,
+        path: S(this.taskInfo.nodePath, e.path)
+      }
+    });
+  }
+  emitEvent(e) {
+    const t = this.taskInfo.event, n = t.trace ?? [], o = {
+      ...e,
+      originNodePath: e.originNodePath ?? this.taskInfo.nodePath,
+      rootEvent: e.rootEvent ?? t.rootEvent ?? t,
+      trace: [...n]
+    };
+    this.actions.push({ kind: "event", event: o });
+  }
+  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 S(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 ye();
+  }
+  loadBlueContent(e) {
+    throw new Error("Not implemented");
+  }
+}
+class G extends Error {
+  constructor(e, t) {
+    super(`Cannot apply patch ${JSON.stringify(e)}`), this.patch = e, this.cause = t, this.name = "PatchApplicationError";
+  }
+}
+class ee extends Error {
+  constructor(e, t, n) {
+    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 @ "${n}")`
+    ), this.patch = e, this.offendingPath = t, this.contractNodePath = n, this.name = "EmbeddedDocumentModificationError";
+  }
+}
+class W extends Error {
+  constructor(e, t) {
+    super(`Failed to evaluate expression "${e}"`), this.code = e, this.cause = t, this.name = "ExpressionEvaluationError";
+  }
+}
+class Q extends Error {
+  constructor(e, t) {
+    super(`Failed to evaluate code block "${e}"`), this.code = e, this.cause = t, this.name = "CodeBlockEvaluationError";
+  }
+}
+const p = {
+  Channel: "2RMkKoutP5qxkh3uDxZ7dr6Eo27B7fuxQCS1VAptiCPc",
+  "Timeline Channel": "RMkKoutP5qxkh3uDxZ7dr6Eo27B7fuxQCS1VAptiCPc2",
+  "Composite Timeline Channel": "qxkh3uMkKoutP5DxZ7dr6Eo27B7fuxQCS1VAptiCPc2R",
+  "Sequential Workflow": "h3uDxZ7dr6Eo27B7fuxMkKoutP5qxkQCS1VAptiCPc2R",
+  "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"
+}, N = m(p.Channel)(
+  u.object({
+    name: u.string().optional(),
+    description: u.string().optional()
+  })
+), Ee = m(
+  p["Composite Timeline Channel"]
+)(
+  N.extend({
+    channels: u.array(u.string()).optional()
+  })
+), Ce = m(
+  p["Document Update Channel"]
+)(
+  N.extend({
+    path: u.string().optional()
+  })
+), K = m(
+  p["Embedded Node Channel"]
+)(
+  N.extend({
+    path: u.string().optional()
+  })
+), M = m(p["JavaScript Code"])(
+  u.object({
+    code: u.string().optional()
+  })
+), we = m(p.Operation)(
+  u.object({
+    request: k().optional(),
+    description: u.string().optional(),
+    channel: u.string().optional()
+  })
+), ve = m(
+  p["Operation Request"]
+)(
+  u.object({
+    operation: u.string().optional(),
+    request: k(),
+    document: u.object({
+      blueId: u.string().optional()
+    }).optional(),
+    allowNewerVersion: u.boolean().optional()
+  })
+), $ = m(
+  p["Process Embedded"]
+)(
+  u.object({
+    paths: u.array(u.string()).optional()
+  })
+), j = m(
+  p["Sequential Workflow"]
+)(
+  u.object({
+    steps: u.array(k()).optional(),
+    channel: u.string().optional()
+  })
+), Se = m(
+  p["Sequential Workflow Operation"]
+)(
+  j.omit({
+    channel: !0
+  }).extend({
+    operation: u.string().optional()
+  })
+), te = m(
+  p["Timeline Channel"]
+)(
+  N.extend({
+    timelineId: u.string().optional()
+  })
+), I = m(p["Timeline Entry"])(
+  u.object({
+    timelineId: u.string().optional(),
+    timelinePrev: u.string().optional(),
+    thread: u.string().optional(),
+    threadPrev: u.string().optional(),
+    message: k().optional(),
+    signature: u.string().optional()
+  })
+), q = m(p["Trigger Event"])(
+  u.object({
+    event: k()
+  })
+), Pe = m(p["Json Patch Entry"])(
+  u.object({
+    name: u.string().optional(),
+    description: u.string().optional(),
+    val: k().optional(),
+    op: u.string().optional(),
+    path: u.string().optional()
+  })
+), A = m(p["Update Document"])(
+  u.object({
+    changeset: u.array(Pe)
+  })
+);
+function V(i, e, t = "/", n = []) {
+  const o = i.getContracts() ?? {};
+  for (const [a, r] of Object.entries(o))
+    if (P.isTypeOf(
+      r,
+      $
+    )) {
+      const h = e.nodeToSchemaOutput(
+        r,
+        $
+      ).paths ?? [];
+      for (const d of h)
+        n.push({
+          absPath: S(t, d),
+          contractPath: S(t, `contracts/${a}`)
+        });
+    }
+  for (const [a, r] of Object.entries(i.getProperties() ?? {}))
+    V(r, e, S(t, a), n);
+  return n;
+}
+function F(i, e) {
+  return i === e || i.startsWith(e.endsWith("/") ? e : e + "/");
+}
+function U(i, e) {
+  if (!e.length) return i;
+  let t = i.clone();
+  for (const n of e)
+    try {
+      t = pe(t, n, !0);
+    } catch (o) {
+      throw new G(n, o);
+    }
+  return X(t);
+}
+function y(i) {
+  return i != null;
+}
+function x(i) {
+  return i instanceof me;
+}
+class ke {
+  constructor(e = [], t = (n, o) => n < o ? -1 : n > o ? 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 n = (this.length >> 1) - 1; n >= 0; n--) this._down(n);
+  }
+  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: n } = this, o = t[e];
+    for (; e > 0; ) {
+      const a = e - 1 >> 1, r = t[a];
+      if (n(o, r) >= 0) break;
+      t[e] = r, e = a;
+    }
+    t[e] = o;
+  }
+  _down(e) {
+    const { data: t, compare: n } = this, o = this.length >> 1, a = t[e];
+    for (; e < o; ) {
+      let r = (e << 1) + 1;
+      const s = r + 1;
+      if (s < this.length && n(t[s], t[r]) < 0 && (r = s), n(t[r], a) >= 0) break;
+      t[e] = t[r], e = r;
+    }
+    t[e] = a;
+  }
+}
+const be = (i, e, t, n, o, a) => [
+  -i,
+  e,
+  t,
+  n,
+  o,
+  a
+], Te = (i, e) => {
+  for (let t = 0; t < i.key.length; t++) {
+    const n = i.key[t], o = e.key[t];
+    if (n !== o)
+      return typeof n == "number" && typeof o == "number" ? n - o : typeof n == "string" && typeof o == "string" ? n.localeCompare(o) : 0;
+  }
+  return 0;
+};
+class Oe {
+  /**
+   * Creates a new task queue with the task key comparator
+   */
+  constructor() {
+    l(this, "queue");
+    this.queue = new ke([], Te);
+  }
+  /**
+   * 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 Be {
+  /**
+   * 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, n) => this.register(t, n));
+  }
+  /**
+   * 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 xe {
+  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, n) {
+    if (!this.shouldTrace())
+      return { ...e };
+    const o = [
+      ...e.trace ?? [],
+      this.makeHop(t, n)
+    ];
+    return {
+      ...e,
+      trace: o
+    };
+  }
+  /**
+   * 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 Ne = 64;
+class Ie {
+  /**
+   * 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, n, o, a) {
+    l(this, "traceManager");
+    this.blue = e, this.registry = t, this.queue = n, this.getNextTaskId = o, this.getNextEventSeq = a, this.traceManager = new xe();
+  }
+  /**
+   * 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, n, o, a = 0) {
+    var c;
+    if (n.seq === void 0 && (n.seq = this.getNextEventSeq()), t.length === 0) {
+      if (n.dispatchPath) {
+        const h = n.dispatchPath.split("/").filter(Boolean), d = { ...n };
+        return delete d.dispatchPath, this.route(e, h, d, o, a);
+      }
+      if (n.source === "channel" && n.originNodePath && n.originNodePath !== "/") {
+        const h = ((c = n.originNodePath) == null ? void 0 : c.split("/").filter(Boolean)) ?? [];
+        return this.route(e, h, n, o, a);
+      }
+    }
+    const r = S("/", t.join("/")), s = e.get(r);
+    x(s) && await this.traverseContracts({
+      doc: e,
+      node: s,
+      nodePath: r,
+      event: n,
+      afterTaskId: o,
+      pathSegments: t,
+      inlineDepth: a
+    });
+  }
+  /**
+   * Traverses contracts at the current node and routes to matching ones
+   */
+  async traverseContracts(e) {
+    const {
+      doc: t,
+      node: n,
+      nodePath: o,
+      event: a,
+      afterTaskId: r,
+      pathSegments: s,
+      inlineDepth: c
+    } = e;
+    if (!this.shouldSkipForChannel(a, o))
+      for (const [h, d] of Object.entries(
+        n.getContracts() ?? {}
+      )) {
+        if (!d.getType()) continue;
+        const f = this.registry.get(d.getType());
+        if (!f) {
+          console.warn(`No processor registered for contract: ${h}`);
+          continue;
+        }
+        const C = {
+          nodePath: o,
+          contractName: h,
+          contractNode: d,
+          event: a
+        }, g = new Y(() => t, C, this.blue);
+        if (f.supports(a, d, g, h))
+          switch (f.role) {
+            case "adapter":
+              await this.processAdapter({
+                cp: f,
+                event: a,
+                contractNode: d,
+                ctx: g,
+                contractName: h,
+                doc: t,
+                afterTaskId: r,
+                inlineDepth: c
+              });
+              break;
+            case "handler":
+              this.scheduleHandler({
+                contractNode: d,
+                contractName: h,
+                nodePath: o,
+                event: a,
+                depth: s.length,
+                afterTaskId: r
+              });
+              break;
+          }
+      }
+  }
+  /**
+   * Processes an adapter contract and routes any emitted events
+   */
+  async processAdapter(e) {
+    var w;
+    const {
+      cp: t,
+      event: n,
+      contractNode: o,
+      ctx: a,
+      contractName: r,
+      doc: s,
+      afterTaskId: c,
+      inlineDepth: h
+    } = e;
+    if (h >= Ne)
+      throw new Error("Adapter recursion limit reached");
+    const d = this.traceManager.addHop(
+      n,
+      ((w = a.getTaskInfo()) == null ? void 0 : w.nodePath) ?? "",
+      r
+    );
+    await t.handle(d, o, a, r);
+    const f = await a.flush();
+    if (f.find((b) => b.kind === "patch"))
+      throw new Error(
+        `Contract "${r}" (adapter) attempted to patch the document`
+      );
+    const g = f.filter((b) => b.kind === "event");
+    for (const b of g)
+      await this.route(s, [], b.event, c, h + 1);
+  }
+  /**
+   * Schedules a handler contract for future execution
+   */
+  scheduleHandler(e) {
+    const { contractNode: t, contractName: n, nodePath: o, event: a, depth: r, afterTaskId: s } = e, c = t.getType();
+    if (!c) {
+      console.warn(`Contract node type is not defined for: ${n}`);
+      return;
+    }
+    const h = this.registry.orderOf(c), d = t.get("/order"), f = z(d) ? d.toNumber() : 0, C = this.getNextTaskId() + s, g = be(
+      r,
+      a.seq,
+      h,
+      f,
+      n,
+      C
+    ), w = this.traceManager.addHop(a, o, n);
+    this.queue.push({
+      key: g,
+      nodePath: o,
+      contractName: n,
+      contractNode: t,
+      event: w
+    });
+  }
+  /**
+   * 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 Me = (i, e, t) => {
+  (t instanceof G || t instanceof ee) && console.error(
+    `[Blue] Failed to apply patches for contract "${i}" on event ${JSON.stringify(e)}`,
+    t
+  );
+};
+function J(i, e) {
+  const t = i.clone(), n = (o) => {
+    var r;
+    if (!x(o)) return;
+    const a = o.getContracts();
+    a && (!a.checkpoint || ((r = a.checkpoint.getType()) == null ? void 0 : r.getBlueId()) !== p["Channel Event Checkpoint"]) && o.addContract(
+      "checkpoint",
+      e.jsonValueToNode({
+        type: {
+          name: "Channel Event Checkpoint",
+          blueId: p["Channel Event Checkpoint"]
+        },
+        lastEvents: {}
+      })
+    );
+  };
+  n(t);
+  for (const { absPath: o } of V(t, e)) {
+    const a = t.get(o);
+    x(a) && n(a);
+  }
+  return X(t);
+}
+class qe {
+  constructor(e) {
+    l(this, "contractType", "Channel Event Checkpoint");
+    l(this, "contractBlueId", p["Channel Event Checkpoint"]);
+    l(this, "role", "handler");
+    this.cache = e;
+  }
+  supports(e) {
+    var t, n;
+    return e.source === "channel" && ((t = e.rootEvent) == null ? void 0 : t.payload) === e.payload && ((n = e.rootEvent) == null ? void 0 : n.source) === "external";
+  }
+  async handle(e, t, n) {
+    var r;
+    if (!e.channelName || !((r = e.rootEvent) != null && r.seq)) return;
+    const o = await n.getBlue().calculateBlueId(e.rootEvent.payload), a = n.getNodePath().replace(/\/contracts\/checkpoint$/, "");
+    this.cache.record(a, e, o);
+  }
+  init() {
+    return [];
+  }
+}
+const Z = (i, e) => i.get(e) !== void 0;
+class Ae {
+  constructor() {
+    l(this, "firstSeen", /* @__PURE__ */ new Map());
+  }
+  record(e, t, n) {
+    const o = e;
+    this.firstSeen.has(o) || this.firstSeen.set(o, { docBase: e, event: t, eventBlueId: n });
+  }
+  /** Turn cached data into JSON-Patch ops */
+  flush(e) {
+    const t = [];
+    for (const { docBase: n, event: o, eventBlueId: a } of this.firstSeen.values()) {
+      if (!o.channelName) continue;
+      const r = S(
+        n,
+        "contracts/checkpoint/lastEvents",
+        o.channelName
+      ), s = `${r}/blueId`;
+      Z(e, r) ? t.push({
+        op: Z(e, s) ? "replace" : "add",
+        path: s,
+        val: a
+      }) : t.push({
+        op: "add",
+        path: r,
+        val: { blueId: a }
+      });
+    }
+    return t;
+  }
+  clear() {
+    this.firstSeen.clear();
+  }
+}
+class B {
+  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 De extends B {
+  constructor() {
+    super(...arguments);
+    l(this, "contractType", "Composite Timeline Channel");
+    l(this, "contractBlueId", p["Composite Timeline Channel"]);
+  }
+  supports(t, n, o) {
+    const a = o.getBlue().nodeToSchemaOutput(n, Ee);
+    return !a.channels || !t.channelName ? !1 : a.channels.includes(t.channelName);
+  }
+  handle(t, n, o, a) {
+    o.emitEvent({
+      payload: t.payload,
+      channelName: a,
+      source: "channel"
+    });
+  }
+}
+class $e extends B {
+  constructor() {
+    super(...arguments);
+    l(this, "contractType", "Document Update Channel");
+    l(this, "contractBlueId", p["Document Update Channel"]);
+  }
+  supports(t, n, o, a) {
+    if (!this.baseSupports(t)) return !1;
+    const r = o.getBlue().nodeToSchemaOutput(n, Ce), s = t.payload.path;
+    if (!s || t.channelName === a) return !1;
+    const c = r.path;
+    return D(c) && s === o.resolvePath(c);
+  }
+  handle(t, n, o, a) {
+    const r = t.payload;
+    r && o.emitEvent({
+      payload: r,
+      channelName: a,
+      source: "channel"
+    });
+  }
+}
+class je extends B {
+  constructor() {
+    super(...arguments);
+    l(this, "contractType", "Embedded Node Channel");
+    l(this, "contractBlueId", p["Embedded Node Channel"]);
+  }
+  supports(t, n, o) {
+    if (!this.baseSupports(t)) return !1;
+    const a = o.getBlue().nodeToSchemaOutput(n, K);
+    return y(t.originNodePath) && y(a.path) && t.originNodePath === o.resolvePath(a.path);
+  }
+  handle(t, n, o, a) {
+    const r = o.getBlue().nodeToSchemaOutput(n, K), { originNodePath: s, payload: c } = t;
+    y(r.path) && s === o.resolvePath(r.path) && o.emitEvent({
+      payload: c,
+      channelName: a,
+      source: "channel"
+    });
+  }
+}
+const T = {
+  "MyOS Timeline Channel": "MkKoutP5qxkh3uDxZ7dr6Eo27B7fuxQCS1VAptiCPc2R",
+  "MyOS Timeline Entry": "uDxZ7dr6Eo2MkKoutP5qxkh3uxQCS1VAptiCPc2R7B7f",
+  "MyOS Agent": "AgentBlu3Id7dr6Eo2MkKoutP5qxkh3uxQCS1V",
+  "MyOS Agent Channel": "AgentCh4nn3lBlu3Id7dr6Eo2MkKoutP5qxkh3uxQCS1V",
+  "MyOS Agent Event": "AgentEv3ntBlu3Id7dr6Eo2MkKoutP5qxkh3uxQCS1V"
+}, Ve = m(
+  T["MyOS Timeline Channel"]
+)(
+  te.extend({
+    account: u.string().optional(),
+    email: u.string().optional()
+  })
+), Re = m(
+  T["MyOS Timeline Entry"]
+)(
+  I.extend({
+    account: u.string().optional(),
+    email: u.string().optional()
+  })
+), We = m(T["MyOS Agent"])(
+  u.object({
+    agentId: u.string().optional()
+  })
+), Qe = m(
+  T["MyOS Agent Channel"]
+)(
+  N.extend({
+    agent: We.optional(),
+    event: k().optional()
+  })
+), Ke = m(T["MyOS Agent Event"])(
+  u.object({
+    agentId: u.string().optional(),
+    id: u.number().optional(),
+    timestamp: u.number().optional(),
+    event: k().optional()
+  })
+), _ = (i) => i.payload.type === "Timeline Entry" || i.payload.type === "MyOS Timeline Entry";
+class Fe extends B {
+  constructor() {
+    super(...arguments);
+    l(this, "contractType", "MyOS Timeline Channel");
+    l(this, "contractBlueId", T["MyOS Timeline Channel"]);
+  }
+  supports(t, n, o) {
+    if (!this.baseSupports(t) || !_(t)) return !1;
+    const a = o.getBlue(), r = a.jsonValueToNode(t.payload), s = a.nodeToSchemaOutput(
+      r,
+      Re
+    ), c = o.getBlue().nodeToSchemaOutput(n, Ve), h = y(c.timelineId) && y(s.timelineId), d = y(c.account) && y(s.account), f = y(c.email) && y(s.email);
+    return h && s.timelineId === c.timelineId || d && s.account === c.account || f && s.email === c.email;
+  }
+  handle(t, n, o, a) {
+    _(t) && o.emitEvent({
+      payload: t.payload,
+      channelName: a,
+      source: "channel"
+    });
+  }
+}
+class Ue extends B {
+  constructor() {
+    super(...arguments);
+    l(this, "contractType", "MyOS Agent Channel");
+    l(this, "contractBlueId", T["MyOS Agent Channel"]);
+  }
+  supports(t, n, o) {
+    if (!this.baseSupports(t)) return !1;
+    try {
+      const { myosAgentEvent: a, myosAgentChannel: r } = this.parseEventAndChannel(
+        t,
+        n,
+        o
+      );
+      return this.isAgentMatch(a, r) && this.isEventPatternMatch(a, r, o);
+    } catch (a) {
+      return console.warn("Error in MyOSAgentChannelProcessor.supports:", a), !1;
+    }
+  }
+  handle(t, n, o, a) {
+    o.emitEvent({
+      payload: t.payload,
+      channelName: a,
+      source: "channel"
+    });
+  }
+  /**
+   * Parses and validates the event payload and channel configuration
+   * @throws {Error} If schema validation fails
+   */
+  parseEventAndChannel(t, n, o) {
+    const a = o.getBlue(), r = a.jsonValueToNode(t.payload), s = a.nodeToSchemaOutput(
+      r,
+      Ke
+    ), c = a.nodeToSchemaOutput(
+      n,
+      Qe
+    );
+    return { myosAgentEvent: s, 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, n) {
+    var r;
+    const o = t.agentId, a = (r = n.agent) == null ? void 0 : r.agentId;
+    return y(o) && y(a) && o === a;
+  }
+  /**
+   * 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, n, o) {
+    const a = n.event;
+    if (!a)
+      return !0;
+    const r = t.event;
+    if (!r)
+      return !1;
+    try {
+      const s = o.getBlue(), c = s.nodeToJson(r), h = s.nodeToJson(a);
+      return fe(c, h);
+    } catch (s) {
+      return console.warn("Error during event pattern matching:", s), !1;
+    }
+  }
+}
+class Je {
+  constructor() {
+    l(this, "contractType", "Operation");
+    l(this, "contractBlueId", p.Operation);
+    l(this, "role", "adapter");
+  }
+  supports(e, t, n, o) {
+    const r = n.getBlue().nodeToSchemaOutput(t, we), s = this.parseEventPayload(e, n);
+    return y(s == null ? void 0 : s.operation) && s.operation === o && e.source === "channel" && e.channelName === r.channel;
+  }
+  async handle(e, t, n, o) {
+    n.emitEvent({
+      payload: e.payload,
+      channelName: o,
+      source: "channel"
+    });
+  }
+  init() {
+    return [];
+  }
+  parseEventPayload(e, t) {
+    const n = t.getBlue(), o = n.jsonValueToNode(e.payload);
+    if (P.isTypeOf(o, I)) {
+      const a = n.nodeToSchemaOutput(
+        o,
+        I
+      );
+      if (a.message)
+        return n.nodeToSchemaOutput(
+          a.message,
+          ve
+        );
+    }
+    return null;
+  }
+}
+class Ze {
+  constructor() {
+    l(this, "contractType", "Process Embedded");
+    l(this, "role", "adapter");
+    l(this, "contractBlueId", p["Process Embedded"]);
+  }
+  supports(e) {
+    return e.source !== "channel";
+  }
+  handle(e, t, n) {
+    const o = n.getBlue().nodeToSchemaOutput(t, $);
+    for (const a of o.paths ?? [])
+      n.emitEvent({
+        ...e,
+        dispatchPath: n.resolvePath(a)
+      });
+  }
+  init() {
+    return [];
+  }
+}
+const ne = !process.env.SKIP_ISOLATED_VM;
+let v = null;
+if (ne)
+  try {
+    v = require("isolated-vm");
+  } catch {
+    console.warn("isolated-vm not available, using fallback evaluation method");
+  }
+function L(i) {
+  return /\bimport\s.+\sfrom\s+['"][^'"]+['"]/.test(i) || /\bexport\s+/.test(i);
+}
+class oe {
+  /**
+   * Main evaluation method - chooses between secure and simple evaluation strategies
+   */
+  static async evaluate({
+    code: e,
+    ctx: t,
+    bindings: n = {},
+    options: o = {}
+  }) {
+    return !v || !ne ? this.evaluateSimple(e, n, o) : this.evaluateSecure(e, n, t, o);
+  }
+  /**
+   * Fallback evaluation using Node's Function constructor
+   * Used when isolated-vm is not available
+   */
+  static async evaluateSimple(e, t, n = {}) {
+    if (L(e))
+      throw new Error(
+        "Static import/export syntax requires isolated-vm – start Node without SKIP_ISOLATED_VM."
+      );
+    try {
+      if (n.isCodeBlock) {
+        const o = Object.keys(t);
+        return await (await new Function(
+          ...o,
+          `return async function codeBlock(${o.join(
+            ", "
+          )}) { ${e} }`
+        )(
+          ...o.map((s) => t[s])
+        ))(...o.map((s) => t[s]));
+      } else
+        return new Function(
+          ...Object.keys(t),
+          `return ${e};`
+        )(...Object.values(t));
+    } catch (o) {
+      throw n.isCodeBlock ? new Q(e, o) : new W(e, o);
+    }
+  }
+  /**
+   * Secure evaluation using isolated-vm with support for ES modules
+   */
+  static async evaluateSecure(e, t, n, o = {}) {
+    if (!v) throw new Error("isolated-vm not available");
+    const a = new v.Isolate({ memoryLimit: 32 }), r = await a.createContext(), s = r.global;
+    try {
+      await this.setupIsolateEnvironment(s, t);
+      const c = /* @__PURE__ */ new Map(), h = this.createModuleResolver(
+        a,
+        r,
+        c,
+        n
+      );
+      return L(e) ? await this.evaluateESModule(
+        a,
+        r,
+        e,
+        o,
+        h
+      ) : await this.evaluateSimpleScript(
+        a,
+        r,
+        e,
+        t,
+        o
+      );
+    } catch (c) {
+      throw o.isCodeBlock ? new Q(e, c) : new W(e, c);
+    } finally {
+      r.release(), a.dispose();
+    }
+  }
+  /**
+   * Setup the isolated VM environment with necessary host functions and data
+   */
+  static async setupIsolateEnvironment(e, t) {
+    if (!v) throw new Error("isolated-vm not available");
+    const n = new v.Callback(
+      (...o) => console.log(...o)
+    );
+    await e.set("log", n);
+    for (const [o, a] of Object.entries(t))
+      typeof a == "function" ? await e.set(
+        o,
+        new v.Callback(a)
+      ) : await e.set(o, new v.ExternalCopy(a).copyInto());
+  }
+  /**
+   * Create module resolver function for handling imports
+   */
+  static createModuleResolver(e, t, n, o) {
+    return async (a) => {
+      if (n.has(a)) return n.get(a);
+      if (a.startsWith("blue:")) {
+        const r = a.slice(5), s = o.loadBlueContent;
+        if (typeof s != "function")
+          throw new Error(
+            `ProcessingContext is missing a loadBlueContent(blueId) implementation (needed for ${a})`
+          );
+        const c = await s(r), h = await e.compileModule(c);
+        return n.set(a, h), await h.instantiate(
+          t,
+          this.createModuleResolver(e, t, n, o)
+        ), h;
+      }
+      if (/^https?:\/\//.test(a)) {
+        let r;
+        if (typeof o.loadExternalModule == "function")
+          r = await o.loadExternalModule(a);
+        else
+          throw new Error(
+            `ProcessingContext is missing a loadExternalModule(url) implementation (needed for ${a})`
+          );
+        const s = await e.compileModule(r);
+        return n.set(a, s), await s.instantiate(
+          t,
+          this.createModuleResolver(e, t, n, o)
+        ), s;
+      }
+      throw new Error(`Unsupported module specifier "${a}"`);
+    };
+  }
+  /**
+   * Evaluate code as a simple script (no imports/exports)
+   */
+  static async evaluateSimpleScript(e, t, n, o, a) {
+    const r = Object.keys(o).join(", "), s = Object.keys(o).map((d) => d), c = `(async (${r}) => { ${a.isCodeBlock ? n : `return (${n});`} })(${s.join(", ")})`;
+    return await (await e.compileScript(c)).run(t, {
+      timeout: a.timeout ?? 500,
+      promise: !0,
+      copy: !0,
+      release: !0
+    });
+  }
+  /**
+   * Evaluate code as an ES module with import/export support
+   */
+  static async evaluateESModule(e, t, n, o, a) {
+    let r = n;
+    if (o.isCodeBlock) {
+      const h = /^\s*(import\s.+?;|export\s.+?;)/gm, d = (n.match(h) || []).join(
+        `
+`
+      ), f = n.replace(h, "").trim();
+      r = `
+      ${d}
+      const run = function() {
+        ${f}
+      };
+      export default run();
+      `;
+    }
+    const s = await e.compileModule(r);
+    return await s.instantiate(t, a), await s.evaluate({
+      timeout: o.timeout ?? 500,
+      promise: !0,
+      reference: !0,
+      release: !0
+    }), await s.namespace.get("default", {
+      timeout: o.timeout ?? 500,
+      promise: !0,
+      copy: !0,
+      release: !0
+    });
+  }
+}
+class ae {
+  /**
+   * Creates standard bindings for workflow step execution
+   */
+  static createStandardBindings(e, t, n) {
+    const o = e.getBlue();
+    return {
+      document: (a) => {
+        const r = e.get(a);
+        return z(r) ? r.toNumber() : x(r) ? o.nodeToJson(r, "original") : r;
+      },
+      event: t.payload,
+      steps: n
+    };
+  }
+}
+class _e {
+  constructor() {
+    l(this, "stepType", "Update Document");
+  }
+  supports(e) {
+    return P.isTypeOf(e, A);
+  }
+  async evaluateChangeValue(e, t, n, o) {
+    const a = e == null ? void 0 : e.getValue();
+    if (typeof a == "string" && a.startsWith("${") && a.endsWith("}")) {
+      const r = a.slice(2, -1);
+      return await oe.evaluate({
+        code: r,
+        ctx: t,
+        bindings: ae.createStandardBindings(
+          t,
+          n,
+          o
+        )
+      });
+    }
+    return e;
+  }
+  async execute(e, t, n, o, a) {
+    if (!P.isTypeOf(e, A)) return;
+    const r = n.getBlue().nodeToSchemaOutput(e, A);
+    for (const s of r.changeset ?? [])
+      if (s.path) {
+        if (s.op === "replace" || s.op === "add") {
+          const c = await this.evaluateChangeValue(
+            s.val,
+            n,
+            t,
+            a
+          );
+          n.addPatch({
+            op: s.op,
+            path: s.path,
+            val: c
+          }), n.emitEvent({
+            payload: {
+              type: "Document Update",
+              op: s.op,
+              path: n.resolvePath(s.path),
+              val: c
+            }
+          });
+        }
+        s.op === "remove" && (n.addPatch({ op: s.op, path: s.path }), n.emitEvent({
+          payload: {
+            type: "Document Update",
+            op: s.op,
+            path: n.resolvePath(s.path),
+            val: null
+          }
+        }));
+      }
+  }
+}
+class Le {
+  constructor() {
+    l(this, "stepType", "Trigger Event");
+  }
+  supports(e) {
+    return P.isTypeOf(e, q);
+  }
+  async execute(e, t, n) {
+    const o = n.getBlue();
+    if (!P.isTypeOf(e, q)) return;
+    const a = o.nodeToSchemaOutput(e, q), r = o.nodeToJson(
+      a.event,
+      "original"
+    );
+    n.emitEvent({
+      payload: r
+    });
+  }
+}
+class He {
+  constructor() {
+    l(this, "stepType", "JavaScript Code");
+  }
+  supports(e) {
+    return P.isTypeOf(e, M);
+  }
+  async execute(e, t, n, o, a) {
+    if (!P.isTypeOf(e, M)) return;
+    const s = n.getBlue().nodeToSchemaOutput(
+      e,
+      M
+    );
+    if (!s.code)
+      throw new Error("JavaScript code is required");
+    const c = await oe.evaluate({
+      code: s.code,
+      ctx: n,
+      bindings: ae.createStandardBindings(n, t, a),
+      options: {
+        isCodeBlock: !0,
+        timeout: 500
+      }
+    });
+    if (c && typeof c == "object" && "events" in c) {
+      const h = c;
+      if (Array.isArray(h.events))
+        for (const d of h.events)
+          n.emitEvent({
+            payload: d
+          });
+    }
+    return c;
+  }
+}
+const ze = [
+  new _e(),
+  new Le(),
+  new He()
+];
+class re {
+  constructor(e = ze) {
+    l(this, "contractType", "Sequential Workflow");
+    l(this, "contractBlueId", p["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, n) {
+    const r = n.getBlue().nodeToSchemaOutput(
+      t,
+      j
+    ).channel;
+    return e.source === "channel" && e.channelName === r;
+  }
+  async handle(e, t, n, o) {
+    const r = n.getBlue().nodeToSchemaOutput(
+      t,
+      j
+    ), s = {}, c = r.steps;
+    for (const [h, d] of (c ?? []).entries()) {
+      const f = this.executors.find((g) => g.supports(d));
+      if (!f)
+        throw new Error(`Unsupported workflow step type "${d.getType()}"`);
+      const C = await f.execute(
+        d,
+        e,
+        n,
+        o,
+        s
+      );
+      if (C !== void 0) {
+        const g = d.getName(), w = typeof g == "string" ? g : `Step${h + 1}`;
+        s[w] = C;
+      }
+      await n.flush();
+    }
+  }
+  init() {
+    return [];
+  }
+}
+class Xe {
+  constructor(e) {
+    l(this, "contractType", "Sequential Workflow Operation");
+    l(this, "contractBlueId", p["Sequential Workflow Operation"]);
+    l(this, "role", "handler");
+    l(this, "sequentialWorkflowProcessor");
+    this.sequentialWorkflowProcessor = e || new re();
+  }
+  supports(e, t, n) {
+    const r = n.getBlue().nodeToSchemaOutput(
+      t,
+      Se
+    ).operation, s = e.channelName;
+    return e.source === "channel" && D(s) && D(r) && s === r;
+  }
+  async handle(e, t, n, o) {
+    try {
+      await this.sequentialWorkflowProcessor.handle(e, t, n, o);
+    } catch (a) {
+      throw console.error(
+        "Error in SequentialWorkflowOperationProcessor.handle:",
+        a
+      ), a;
+    }
+  }
+}
+const H = (i) => i.payload.type === "Timeline Entry";
+class Ye extends B {
+  constructor() {
+    super(...arguments);
+    l(this, "contractType", "Timeline Channel");
+    l(this, "contractBlueId", p["Timeline Channel"]);
+  }
+  supports(t, n, o) {
+    if (!this.baseSupports(t) || !H(t)) return !1;
+    const a = o.getBlue(), r = a.jsonValueToNode(t.payload), s = a.nodeToSchemaOutput(
+      r,
+      I
+    ), c = o.getBlue().nodeToSchemaOutput(n, te);
+    return y(c.timelineId) && y(s.timelineId) && s.timelineId === c.timelineId;
+  }
+  handle(t, n, o, a) {
+    H(t) && o.emitEvent({
+      payload: t.payload,
+      channelName: a,
+      source: "channel"
+    });
+  }
+}
+const Ge = [
+  new Ze(),
+  // channels
+  new je(),
+  new $e(),
+  new Ye(),
+  new Fe(),
+  new Ue(),
+  new De(),
+  new Je(),
+  // sequential workflows
+  new re(),
+  new Xe()
+];
+class rt {
+  /**
+   * Creates a new document processor
+   *
+   * @param processors - Initial list of processors to register
+   */
+  constructor(e, t = Ge) {
+    l(this, "taskCounter", 0);
+    l(this, "eventCounter", 0);
+    l(this, "registry");
+    l(this, "queue");
+    l(this, "router");
+    l(this, "checkpointCache", new Ae());
+    this.blue = e, this.registry = new Be(t), this.queue = new Oe(), this.router = new Ie(
+      this.blue,
+      this.registry,
+      this.queue,
+      () => ++this.taskCounter,
+      () => ++this.eventCounter
+    ), this.register(
+      new qe(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 = J(e, this.blue);
+    const t = await this.bootstrapContracts(e);
+    for (const n of t)
+      await this.router.route(e, [], n, 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 n = J(e, this.blue);
+    const o = [];
+    for (const a of t)
+      try {
+        const r = { payload: a, source: "external" };
+        await this.router.route(n, [], r, 0);
+        const s = await this.drainQueue(n);
+        n = s.state, o.push(...s.emitted);
+        const c = this.checkpointCache.flush(n);
+        c.length && (n = U(n, c));
+      } finally {
+        this.checkpointCache.clear();
+      }
+    return { state: n, emitted: o };
+  }
+  /**
+   * Collects initialization events from contract processors
+   */
+  async bootstrapContracts(e) {
+    const t = [], n = e.getContracts();
+    if (!n)
+      return t;
+    for (const [, o] of Object.entries(n)) {
+      const a = this.registry.get(o.getType());
+      a != null && a.init && t.push(...await a.init(o));
+    }
+    return t;
+  }
+  /**
+   * Drains the task queue and applies all actions
+   */
+  async drainQueue(e) {
+    var r;
+    let t = e;
+    const n = [], o = 1e4;
+    let a = 0;
+    for (; this.queue.length; ) {
+      if (++a > o)
+        throw new Error("Possible cycle – too many iterations");
+      const s = this.queue.pop(), { nodePath: c, contractName: h, contractNode: d, event: f } = s, C = t.get(c);
+      if (!x(C) || !((r = C.getContracts()) != null && r[h]) || !d.getType()) continue;
+      const g = this.registry.get(d.getType());
+      if (!g) {
+        console.warn(`No processor registered for contract: ${h}`);
+        continue;
+      }
+      const w = new Y(
+        () => t,
+        s,
+        this.blue,
+        async (b) => {
+          for (const E of b)
+            if (E.kind === "patch") {
+              const se = V(t, this.blue);
+              for (const O of se) {
+                const ie = E.patch.op === "move" || E.patch.op === "copy" ? [E.patch.from, E.patch.path] : [E.patch.path], R = w.getNodePath(), ce = ie.some(
+                  (ue) => F(ue, O.absPath)
+                ), le = F(
+                  R,
+                  O.absPath
+                );
+                if (ce && !le)
+                  throw new ee(
+                    E.patch,
+                    O.absPath,
+                    R
+                  );
+              }
+              try {
+                t = U(t, [E.patch]);
+              } catch (O) {
+                throw Me(h, f, O), O;
+              }
+            } else E.kind === "event" && (n.push(E.event.payload), await this.router.route(t, [], E.event, s.key[5]));
+        }
+      );
+      await g.handle(f, d, w, h), await w.flush();
+    }
+    return { state: t, emitted: n };
+  }
+}
+export {
+  rt as BlueDocumentProcessor,
+  qe as ChannelEventCheckpointProcessor,
+  De as CompositeTimelineChannelProcessor,
+  $e as DocumentUpdateChannelProcessor,
+  je as EmbeddedNodeChannelProcessor,
+  Ue as MyOSAgentChannelProcessor,
+  Fe as MyOSTimelineChannelProcessor,
+  Je as OperationProcessor,
+  Ze as ProcessEmbeddedProcessor,
+  Xe as SequentialWorkflowOperationProcessor,
+  re as SequentialWorkflowProcessor,
+  Ye as TimelineChannelProcessor
+};