@elaraai/east-ui-components 0.0.1-beta.17 → 0.0.1-beta.18

package/dist/index.js

@@ -525,7 +525,7 @@ var q = {
 }, Q = ["fa-classic", "fa-duotone", "fa-sharp", "fa-sharp-duotone", "fa-thumbprint", "fa-whiteboard", "fa-notdog", "fa-notdog-duo", "fa-chisel", "fa-etch", "fa-jelly", "fa-jelly-fill", "fa-jelly-duo", "fa-slab", "fa-slab-press", "fa-utility", "fa-utility-duo", "fa-utility-fill"];
 var i = "classic", t = "duotone", d = "sharp", l = "sharp-duotone", f = "chisel", n = "etch", h = "jelly", o = "jelly-duo", u = "jelly-fill", g = "notdog", s$1 = "notdog-duo", y$1 = "slab", m = "slab-press", e = "thumbprint", p = "utility", a$1 = "utility-duo", w = "utility-fill", x$1 = "whiteboard", b = "Classic", c$1 = "Duotone", I = "Sharp", F = "Sharp Duotone", v = "Chisel", S = "Etch", A = "Jelly", P$1 = "Jelly Duo", j = "Jelly Fill", B = "Notdog", N = "Notdog Duo", k$1 = "Slab", D = "Slab Press", T = "Thumbprint", C = "Utility", W = "Utility Duo", K = "Utility Fill", R = "Whiteboard", rt = [i, t, d, l, f, n, h, o, u, g, s$1, y$1, m, e, p, a$1, w, x$1];
 _dt = {}, _defineProperty$V(_defineProperty$V(_defineProperty$V(_defineProperty$V(_defineProperty$V(_defineProperty$V(_defineProperty$V(_defineProperty$V(_defineProperty$V(_defineProperty$V(_dt, i, b), t, c$1), d, I), l, F), f, v), n, S), h, A), o, P$1), u, j), g, B), _defineProperty$V(_defineProperty$V(_defineProperty$V(_defineProperty$V(_defineProperty$V(_defineProperty$V(_defineProperty$V(_defineProperty$V(_dt, s$1, N), y$1, k$1), m, D), e, T), p, C), a$1, W), w, K), x$1, R);
-var gt = {
+var gt$1 = {
   classic: {
     900: "fas",
     400: "far",
@@ -1140,7 +1140,7 @@ familyProxy(_LONG_STYLE_TO_PREFIX);
 var ICON_SELECTION_SYNTAX_PATTERN = E;
 var LAYERS_TEXT_CLASSNAME = "fa-layers-text";
 var FONT_FAMILY_PATTERN = _;
-var _FONT_WEIGHT_TO_PREFIX = _objectSpread2({}, gt);
+var _FONT_WEIGHT_TO_PREFIX = _objectSpread2({}, gt$1);
 familyProxy(_FONT_WEIGHT_TO_PREFIX);
 var ATTRIBUTES_WATCHED_FOR_MUTATION = ["class", "data-prefix", "data-icon", "data-fa-transform", "data-fa-mask"];
 var DUOTONE_CLASSES = H;
@@ -20831,10 +20831,10 @@ function requireIsPrimitive() {
   })(isPrimitive);
   return isPrimitive;
 }
-var eq = {};
+var eq$1 = {};
 var hasRequiredEq;
 function requireEq() {
-  if (hasRequiredEq) return eq;
+  if (hasRequiredEq) return eq$1;
   hasRequiredEq = 1;
   (function(exports$1) {
     Object.defineProperty(exports$1, Symbol.toStringTag, { value: "Module" });
@@ -20842,8 +20842,8 @@ function requireEq() {
       return value === other || Number.isNaN(value) && Number.isNaN(other);
     }
     exports$1.eq = eq2;
-  })(eq);
-  return eq;
+  })(eq$1);
+  return eq$1;
 }
 var hasRequiredIsMatchWith;
 function requireIsMatchWith() {
@@ -33989,15 +33989,15 @@ var selectSmallestDistanceBetweenValues = createSelector(selectAllAppliedValues,
   if (sortedValues.length < 2) {
     return Infinity;
   }
-  var diff = sortedValues[sortedValues.length - 1] - sortedValues[0];
-  if (diff === 0) {
+  var diff2 = sortedValues[sortedValues.length - 1] - sortedValues[0];
+  if (diff2 === 0) {
     return Infinity;
   }
   for (var i2 = 0; i2 < sortedValues.length - 1; i2++) {
     var distance = sortedValues[i2 + 1] - sortedValues[i2];
     smallestDistanceBetweenValues = Math.min(smallestDistanceBetweenValues, distance);
   }
-  return smallestDistanceBetweenValues / diff;
+  return smallestDistanceBetweenValues / diff2;
 });
 var selectCalculatedPadding = createSelector(selectSmallestDistanceBetweenValues, selectChartLayout, selectBarCategoryGap, selectChartOffsetInternal, (_1, _2, _3, padding) => padding, (smallestDistanceInPercent, layout, barCategoryGap, offset, padding) => {
   if (!isWellBehavedNumber(smallestDistanceInPercent)) {
@@ -53698,10 +53698,10 @@ const arrIncludesSome = (row, columnId, filterValue) => {
   });
 };
 arrIncludesSome.autoRemove = (val) => testFalsey(val) || !(val != null && val.length);
-const equals = (row, columnId, filterValue) => {
+const equals$1 = (row, columnId, filterValue) => {
   return row.getValue(columnId) === filterValue;
 };
-equals.autoRemove = (val) => testFalsey(val);
+equals$1.autoRemove = (val) => testFalsey(val);
 const weakEquals = (row, columnId, filterValue) => {
   return row.getValue(columnId) == filterValue;
 };
@@ -53732,7 +53732,7 @@ const filterFns = {
   arrIncludes,
   arrIncludesAll,
   arrIncludesSome,
-  equals,
+  equals: equals$1,
   weakEquals,
   inNumberRange
 };
@@ -71229,6 +71229,28 @@ const Builtins = {
     inputs: ["T", "T"],
     output: BooleanType
   },
+  // Patch operations - P is the computed PatchType passed from expression building
+  // We use two type parameters because the patch type structure varies based on T
+  Diff: {
+    type_parameters: ["T", "P"],
+    inputs: ["T", "T"],
+    output: "P"
+  },
+  ApplyPatch: {
+    type_parameters: ["T", "P"],
+    inputs: ["T", "P"],
+    output: "T"
+  },
+  ComposePatch: {
+    type_parameters: ["T", "P"],
+    inputs: ["P", "P"],
+    output: "P"
+  },
+  InvertPatch: {
+    type_parameters: ["T", "P"],
+    inputs: ["P"],
+    output: "P"
+  },
   BooleanNot: {
     type_parameters: [],
     inputs: [BooleanType],
@@ -72705,6 +72727,17 @@ function valueOrExprToAstTyped(value, type, visited, location = get_location(2))
 class BooleanExpr extends Expr {
   constructor(ast, createExpr) {
     super(BooleanType, ast, createExpr);
+    // ============================================================================
+    // Aliases for comparison operations
+    // ============================================================================
+    /** Alias for {@link equals} */
+    __publicField(this, "eq", this.equals);
+    /** Alias for {@link equals} */
+    __publicField(this, "equal", this.equals);
+    /** Alias for {@link notEquals} */
+    __publicField(this, "ne", this.notEquals);
+    /** Alias for {@link notEquals} */
+    __publicField(this, "notEqual", this.notEquals);
   }
   /**
    * Performs logical NOT operation (!x).
@@ -72975,6 +73008,58 @@ class BooleanExpr extends Expr {
 class IntegerExpr extends Expr {
   constructor(ast, createExpr) {
     super(IntegerType, ast, createExpr);
+    // ============================================================================
+    // Aliases for comparison operations
+    // ============================================================================
+    /** Alias for {@link equals} */
+    __publicField(this, "eq", this.equals);
+    /** Alias for {@link equals} */
+    __publicField(this, "equal", this.equals);
+    /** Alias for {@link notEquals} */
+    __publicField(this, "ne", this.notEquals);
+    /** Alias for {@link notEquals} */
+    __publicField(this, "notEqual", this.notEquals);
+    /** Alias for {@link greaterThan} */
+    __publicField(this, "gt", this.greaterThan);
+    /** Alias for {@link greaterThan} */
+    __publicField(this, "greater", this.greaterThan);
+    /** Alias for {@link lessThan} */
+    __publicField(this, "lt", this.lessThan);
+    /** Alias for {@link lessThan} */
+    __publicField(this, "less", this.lessThan);
+    /** Alias for {@link greaterThanOrEqual} */
+    __publicField(this, "gte", this.greaterThanOrEqual);
+    /** Alias for {@link greaterThanOrEqual} */
+    __publicField(this, "ge", this.greaterThanOrEqual);
+    /** Alias for {@link greaterThanOrEqual} */
+    __publicField(this, "greaterEqual", this.greaterThanOrEqual);
+    /** Alias for {@link lessThanOrEqual} */
+    __publicField(this, "lte", this.lessThanOrEqual);
+    /** Alias for {@link lessThanOrEqual} */
+    __publicField(this, "le", this.lessThanOrEqual);
+    /** Alias for {@link lessThanOrEqual} */
+    __publicField(this, "lessEqual", this.lessThanOrEqual);
+    // ============================================================================
+    // Aliases for arithmetic operations
+    // ============================================================================
+    /** Alias for {@link add} */
+    __publicField(this, "plus", this.add);
+    /** Alias for {@link subtract} */
+    __publicField(this, "sub", this.subtract);
+    /** Alias for {@link subtract} */
+    __publicField(this, "minus", this.subtract);
+    /** Alias for {@link multiply} */
+    __publicField(this, "mul", this.multiply);
+    /** Alias for {@link multiply} */
+    __publicField(this, "times", this.multiply);
+    /** Alias for {@link divide} */
+    __publicField(this, "div", this.divide);
+    /** Alias for {@link remainder} */
+    __publicField(this, "mod", this.remainder);
+    /** Alias for {@link remainder} */
+    __publicField(this, "rem", this.remainder);
+    /** Alias for {@link remainder} */
+    __publicField(this, "modulo", this.remainder);
   }
   /**
    * Negates an integer value (-x).
@@ -73366,6 +73451,58 @@ class IntegerExpr extends Expr {
 class FloatExpr extends Expr {
   constructor(ast, createExpr) {
     super(FloatType, ast, createExpr);
+    // ============================================================================
+    // Aliases for comparison operations
+    // ============================================================================
+    /** Alias for {@link equals} */
+    __publicField(this, "eq", this.equals);
+    /** Alias for {@link equals} */
+    __publicField(this, "equal", this.equals);
+    /** Alias for {@link notEquals} */
+    __publicField(this, "ne", this.notEquals);
+    /** Alias for {@link notEquals} */
+    __publicField(this, "notEqual", this.notEquals);
+    /** Alias for {@link greaterThan} */
+    __publicField(this, "gt", this.greaterThan);
+    /** Alias for {@link greaterThan} */
+    __publicField(this, "greater", this.greaterThan);
+    /** Alias for {@link lessThan} */
+    __publicField(this, "lt", this.lessThan);
+    /** Alias for {@link lessThan} */
+    __publicField(this, "less", this.lessThan);
+    /** Alias for {@link greaterThanOrEqual} */
+    __publicField(this, "gte", this.greaterThanOrEqual);
+    /** Alias for {@link greaterThanOrEqual} */
+    __publicField(this, "ge", this.greaterThanOrEqual);
+    /** Alias for {@link greaterThanOrEqual} */
+    __publicField(this, "greaterEqual", this.greaterThanOrEqual);
+    /** Alias for {@link lessThanOrEqual} */
+    __publicField(this, "lte", this.lessThanOrEqual);
+    /** Alias for {@link lessThanOrEqual} */
+    __publicField(this, "le", this.lessThanOrEqual);
+    /** Alias for {@link lessThanOrEqual} */
+    __publicField(this, "lessEqual", this.lessThanOrEqual);
+    // ============================================================================
+    // Aliases for arithmetic operations
+    // ============================================================================
+    /** Alias for {@link add} */
+    __publicField(this, "plus", this.add);
+    /** Alias for {@link subtract} */
+    __publicField(this, "sub", this.subtract);
+    /** Alias for {@link subtract} */
+    __publicField(this, "minus", this.subtract);
+    /** Alias for {@link multiply} */
+    __publicField(this, "mul", this.multiply);
+    /** Alias for {@link multiply} */
+    __publicField(this, "times", this.multiply);
+    /** Alias for {@link divide} */
+    __publicField(this, "div", this.divide);
+    /** Alias for {@link remainder} */
+    __publicField(this, "mod", this.remainder);
+    /** Alias for {@link remainder} */
+    __publicField(this, "rem", this.remainder);
+    /** Alias for {@link remainder} */
+    __publicField(this, "modulo", this.remainder);
   }
   /**
    * Negates a floating-point number (-x).
@@ -74151,6 +74288,37 @@ if (import.meta.url === `file://${process.argv[1]}`) {
 class StringExpr extends Expr {
   constructor(ast, createExpr) {
     super(StringType, ast, createExpr);
+    // ============================================================================
+    // Aliases for comparison operations
+    // ============================================================================
+    /** Alias for {@link equals} */
+    __publicField(this, "eq", this.equals);
+    /** Alias for {@link equals} */
+    __publicField(this, "equal", this.equals);
+    /** Alias for {@link notEquals} */
+    __publicField(this, "ne", this.notEquals);
+    /** Alias for {@link notEquals} */
+    __publicField(this, "notEqual", this.notEquals);
+    /** Alias for {@link greaterThan} */
+    __publicField(this, "gt", this.greaterThan);
+    /** Alias for {@link greaterThan} */
+    __publicField(this, "greater", this.greaterThan);
+    /** Alias for {@link lessThan} */
+    __publicField(this, "lt", this.lessThan);
+    /** Alias for {@link lessThan} */
+    __publicField(this, "less", this.lessThan);
+    /** Alias for {@link greaterThanOrEqual} */
+    __publicField(this, "gte", this.greaterThanOrEqual);
+    /** Alias for {@link greaterThanOrEqual} */
+    __publicField(this, "ge", this.greaterThanOrEqual);
+    /** Alias for {@link greaterThanOrEqual} */
+    __publicField(this, "greaterEqual", this.greaterThanOrEqual);
+    /** Alias for {@link lessThanOrEqual} */
+    __publicField(this, "lte", this.lessThanOrEqual);
+    /** Alias for {@link lessThanOrEqual} */
+    __publicField(this, "le", this.lessThanOrEqual);
+    /** Alias for {@link lessThanOrEqual} */
+    __publicField(this, "lessEqual", this.lessThanOrEqual);
   }
   /**
    * Parses a value of the given type from the string using East's canonical text format.
@@ -74988,6 +75156,37 @@ function tokenizeDateTimeFormat(format2) {
 class DateTimeExpr extends Expr {
   constructor(ast, createExpr) {
     super(DateTimeType, ast, createExpr);
+    // ============================================================================
+    // Aliases for comparison operations
+    // ============================================================================
+    /** Alias for {@link equals} */
+    __publicField(this, "eq", this.equals);
+    /** Alias for {@link equals} */
+    __publicField(this, "equal", this.equals);
+    /** Alias for {@link notEquals} */
+    __publicField(this, "ne", this.notEquals);
+    /** Alias for {@link notEquals} */
+    __publicField(this, "notEqual", this.notEquals);
+    /** Alias for {@link greaterThan} */
+    __publicField(this, "gt", this.greaterThan);
+    /** Alias for {@link greaterThan} */
+    __publicField(this, "greater", this.greaterThan);
+    /** Alias for {@link lessThan} */
+    __publicField(this, "lt", this.lessThan);
+    /** Alias for {@link lessThan} */
+    __publicField(this, "less", this.lessThan);
+    /** Alias for {@link greaterThanOrEqual} */
+    __publicField(this, "gte", this.greaterThanOrEqual);
+    /** Alias for {@link greaterThanOrEqual} */
+    __publicField(this, "ge", this.greaterThanOrEqual);
+    /** Alias for {@link greaterThanOrEqual} */
+    __publicField(this, "greaterEqual", this.greaterThanOrEqual);
+    /** Alias for {@link lessThanOrEqual} */
+    __publicField(this, "lte", this.lessThanOrEqual);
+    /** Alias for {@link lessThanOrEqual} */
+    __publicField(this, "le", this.lessThanOrEqual);
+    /** Alias for {@link lessThanOrEqual} */
+    __publicField(this, "lessEqual", this.lessThanOrEqual);
   }
   /**
    * Extracts the year component from the DateTime.
@@ -77235,6 +77434,17 @@ function encodeCsvFor(structType, config2) {
 class BlobExpr extends Expr {
   constructor(ast, createExpr) {
     super(ast.type, ast, createExpr);
+    // ============================================================================
+    // Aliases for comparison operations
+    // ============================================================================
+    /** Alias for {@link equals} */
+    __publicField(this, "eq", this.equals);
+    /** Alias for {@link equals} */
+    __publicField(this, "equal", this.equals);
+    /** Alias for {@link notEquals} */
+    __publicField(this, "ne", this.notEquals);
+    /** Alias for {@link notEquals} */
+    __publicField(this, "notEqual", this.notEquals);
   }
   /**
    * Returns the size of the blob in bytes.
@@ -77479,6 +77689,17 @@ class ArrayExpr extends Expr {
   constructor(value_type, ast, createExpr) {
     super(ast.type, ast, createExpr);
     __publicField(this, "value_type");
+    // ============================================================================
+    // Aliases for comparison operations
+    // ============================================================================
+    /** Alias for {@link equals} */
+    __publicField(this, "eq", this.equals);
+    /** Alias for {@link equals} */
+    __publicField(this, "equal", this.equals);
+    /** Alias for {@link notEquals} */
+    __publicField(this, "ne", this.notEquals);
+    /** Alias for {@link notEquals} */
+    __publicField(this, "notEqual", this.notEquals);
     this.value_type = value_type;
   }
   /**
@@ -79324,6 +79545,17 @@ class SetExpr extends Expr {
   constructor(key_type, ast, createExpr) {
     super(ast.type, ast, createExpr);
     __publicField(this, "key_type");
+    // ============================================================================
+    // Aliases for comparison operations
+    // ============================================================================
+    /** Alias for {@link equals} */
+    __publicField(this, "eq", this.equals);
+    /** Alias for {@link equals} */
+    __publicField(this, "equal", this.equals);
+    /** Alias for {@link notEquals} */
+    __publicField(this, "ne", this.notEquals);
+    /** Alias for {@link notEquals} */
+    __publicField(this, "notEqual", this.notEquals);
     this.key_type = key_type;
   }
   /**
@@ -80436,6 +80668,17 @@ class DictExpr extends Expr {
     super(ast.type, ast, createExpr);
     __publicField(this, "key_type");
     __publicField(this, "value_type");
+    // ============================================================================
+    // Aliases for comparison operations
+    // ============================================================================
+    /** Alias for {@link equals} */
+    __publicField(this, "eq", this.equals);
+    /** Alias for {@link equals} */
+    __publicField(this, "equal", this.equals);
+    /** Alias for {@link notEquals} */
+    __publicField(this, "ne", this.notEquals);
+    /** Alias for {@link notEquals} */
+    __publicField(this, "notEqual", this.notEquals);
     this.key_type = key_type;
     this.value_type = value_type;
   }
@@ -81911,6 +82154,17 @@ class VariantExpr extends Expr {
   constructor(cases, ast, factory) {
     super(ast.type, ast, factory);
     __publicField(this, "cases");
+    // ============================================================================
+    // Aliases for comparison operations
+    // ============================================================================
+    /** Alias for {@link equals} */
+    __publicField(this, "eq", this.equals);
+    /** Alias for {@link equals} */
+    __publicField(this, "equal", this.equals);
+    /** Alias for {@link notEquals} */
+    __publicField(this, "ne", this.notEquals);
+    /** Alias for {@link notEquals} */
+    __publicField(this, "notEqual", this.notEquals);
     this.cases = cases;
   }
   /**
@@ -82249,7 +82503,7 @@ function ast_to_ir(ast, ctx = { local_ctx: /* @__PURE__ */ new Map(), parent_ctx
               throw new Error(`Builtin ${builtin_name} with type parameters [${ast.type_parameters.map((tp) => printType(tp)).join(", ")}] argument ${i2} of type ${printType(arg.type)} is not compatible with expected type ${printType(expectedType)} at ${printLocation(ast.location)}`);
             }
             arg_ir = variant("As", {
-              type: toEastTypeValue(arg.type),
+              type: toEastTypeValue(expectedType),
               value: arg_ir,
               location: toLocationValue(ast.location)
             });
@@ -82981,6 +83235,318 @@ function ast_to_ir(ast, ctx = { local_ctx: /* @__PURE__ */ new Map(), parent_ctx
     throw e3;
   }
 }
+class ConflictError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ConflictError";
+  }
+}
+function computeLCS(before, after, equal2) {
+  const m2 = before.length;
+  const n2 = after.length;
+  const dp = Array.from({ length: m2 + 1 }, () => Array(n2 + 1).fill(0));
+  for (let i3 = 1; i3 <= m2; i3++) {
+    for (let j3 = 1; j3 <= n2; j3++) {
+      if (equal2(before[i3 - 1], after[j3 - 1])) {
+        dp[i3][j3] = dp[i3 - 1][j3 - 1] + 1;
+      } else {
+        dp[i3][j3] = Math.max(dp[i3 - 1][j3], dp[i3][j3 - 1]);
+      }
+    }
+  }
+  const beforeIndices = [];
+  const afterIndices = [];
+  let i2 = m2;
+  let j2 = n2;
+  while (i2 > 0 && j2 > 0) {
+    if (equal2(before[i2 - 1], after[j2 - 1])) {
+      beforeIndices.unshift(i2 - 1);
+      afterIndices.unshift(j2 - 1);
+      i2--;
+      j2--;
+    } else if (dp[i2 - 1][j2] > dp[i2][j2 - 1]) {
+      i2--;
+    } else {
+      j2--;
+    }
+  }
+  return { beforeIndices, afterIndices };
+}
+function diffFor(type, ctx = { diff: [], types: [], equal: [] }) {
+  const t2 = isVariant(type) ? type : toEastTypeValue(type);
+  if (t2.type === "Never") {
+    return (_before, _after) => {
+      throw new Error("Cannot diff values of type Never");
+    };
+  } else if (t2.type === "Null" || t2.type === "Boolean" || t2.type === "Integer" || t2.type === "Float" || t2.type === "String" || t2.type === "DateTime" || t2.type === "Blob") {
+    const equal2 = equalFor(t2);
+    return (before, after) => {
+      if (equal2(before, after)) {
+        return variant("unchanged", null);
+      }
+      return variant("replace", { before, after });
+    };
+  } else if (t2.type === "Array") {
+    let elementEqual;
+    let is2;
+    const ret = (before, after) => {
+      if (is2(before, after)) {
+        return variant("unchanged", null);
+      }
+      const { beforeIndices, afterIndices } = computeLCS(before, after, elementEqual);
+      const operations = [];
+      let beforePtr = 0;
+      let afterPtr = 0;
+      let lcsPtr = 0;
+      let deleteCount = 0;
+      let insertCount = 0;
+      while (beforePtr < before.length || afterPtr < after.length) {
+        const nextBeforeLCS = lcsPtr < beforeIndices.length ? beforeIndices[lcsPtr] : before.length;
+        const nextAfterLCS = lcsPtr < afterIndices.length ? afterIndices[lcsPtr] : after.length;
+        while (beforePtr < nextBeforeLCS) {
+          const actualPosition = beforePtr - deleteCount + insertCount;
+          operations.push({
+            key: BigInt(actualPosition),
+            offset: 0n,
+            operation: variant("delete", before[beforePtr])
+          });
+          deleteCount++;
+          beforePtr++;
+        }
+        while (afterPtr < nextAfterLCS) {
+          operations.push({
+            key: BigInt(afterPtr),
+            offset: 0n,
+            operation: variant("insert", after[afterPtr])
+          });
+          insertCount++;
+          afterPtr++;
+        }
+        if (lcsPtr < beforeIndices.length) {
+          beforePtr++;
+          afterPtr++;
+          lcsPtr++;
+        }
+      }
+      if (operations.length === 0) {
+        return variant("unchanged", null);
+      }
+      return variant("patch", operations);
+    };
+    const arrayEqual = equalFor(t2, ctx.equal);
+    ctx.diff.push(ret);
+    ctx.types.push(t2);
+    ctx.equal.push(arrayEqual);
+    is2 = isFor(t2, ctx.equal);
+    elementEqual = equalFor(t2.value, ctx.equal);
+    ctx.diff.pop();
+    ctx.types.pop();
+    ctx.equal.pop();
+    return ret;
+  } else if (t2.type === "Set") {
+    const is2 = isFor(t2);
+    const keyCompare = compareFor(t2.value);
+    return (before, after) => {
+      if (is2(before, after)) {
+        return variant("unchanged", null);
+      }
+      const operations = new SortedMap(void 0, keyCompare);
+      for (const key of before) {
+        if (!after.has(key)) {
+          operations.set(key, variant("delete", null));
+        }
+      }
+      for (const key of after) {
+        if (!before.has(key)) {
+          operations.set(key, variant("insert", null));
+        }
+      }
+      if (operations.size === 0) {
+        return variant("unchanged", null);
+      }
+      let deleteCount = 0;
+      let insertCount = 0;
+      for (const op of operations.values()) {
+        if (op.type === "delete")
+          deleteCount++;
+        if (op.type === "insert")
+          insertCount++;
+      }
+      if (deleteCount === before.size && insertCount === after.size && before.size > 0) {
+        return variant("replace", { before, after });
+      }
+      return variant("patch", operations);
+    };
+  } else if (t2.type === "Dict") {
+    let valueDiff;
+    let valueEqual;
+    let is2;
+    const keyCompare = compareFor(t2.value.key);
+    const ret = (before, after) => {
+      if (is2(before, after)) {
+        return variant("unchanged", null);
+      }
+      const operations = new SortedMap(void 0, keyCompare);
+      for (const [key, beforeValue] of before) {
+        if (!after.has(key)) {
+          operations.set(key, variant("delete", beforeValue));
+        } else {
+          const afterValue = after.get(key);
+          if (!valueEqual(beforeValue, afterValue)) {
+            const patch = valueDiff(beforeValue, afterValue);
+            operations.set(key, variant("update", patch));
+          }
+        }
+      }
+      for (const [key, afterValue] of after) {
+        if (!before.has(key)) {
+          operations.set(key, variant("insert", afterValue));
+        }
+      }
+      if (operations.size === 0) {
+        return variant("unchanged", null);
+      }
+      let insertCount = 0;
+      let deleteCount = 0;
+      for (const op of operations.values()) {
+        if (op.type === "insert")
+          insertCount++;
+        if (op.type === "delete")
+          deleteCount++;
+      }
+      if (insertCount === after.size && deleteCount === before.size && before.size > 0) {
+        return variant("replace", { before, after });
+      }
+      return variant("patch", operations);
+    };
+    const dictEqual = equalFor(t2, ctx.equal);
+    ctx.diff.push(ret);
+    ctx.types.push(t2);
+    ctx.equal.push(dictEqual);
+    is2 = isFor(t2, ctx.equal);
+    valueDiff = diffFor(t2.value.value, ctx);
+    valueEqual = equalFor(t2.value.value, ctx.equal);
+    ctx.diff.pop();
+    ctx.types.pop();
+    ctx.equal.pop();
+    return ret;
+  } else if (t2.type === "Struct") {
+    const fieldDiffs = {};
+    const fieldEquals = {};
+    const ret = (before, after) => {
+      if (before === after) {
+        return variant("unchanged", null);
+      }
+      const patchFields = {};
+      let allUnchanged = true;
+      for (const { name } of t2.value) {
+        const beforeValue = before[name];
+        const afterValue = after[name];
+        if (fieldEquals[name](beforeValue, afterValue)) {
+          patchFields[name] = variant("unchanged", null);
+        } else {
+          patchFields[name] = fieldDiffs[name](beforeValue, afterValue);
+          allUnchanged = false;
+        }
+      }
+      if (allUnchanged) {
+        return variant("unchanged", null);
+      }
+      return variant("patch", patchFields);
+    };
+    const structEqual = equalFor(t2, ctx.equal);
+    ctx.diff.push(ret);
+    ctx.types.push(t2);
+    ctx.equal.push(structEqual);
+    for (const { name, type: fieldType } of t2.value) {
+      fieldDiffs[name] = diffFor(fieldType, ctx);
+      fieldEquals[name] = equalFor(fieldType, ctx.equal);
+    }
+    ctx.diff.pop();
+    ctx.types.pop();
+    ctx.equal.pop();
+    return ret;
+  } else if (t2.type === "Variant") {
+    const caseDiffs = {};
+    const caseEquals = {};
+    const ret = (before, after) => {
+      if (before === after) {
+        return variant("unchanged", null);
+      }
+      if (before.type !== after.type) {
+        return variant("replace", { before, after });
+      }
+      const caseName = before.type;
+      if (caseEquals[caseName](before.value, after.value)) {
+        return variant("unchanged", null);
+      }
+      const casePatch = caseDiffs[caseName](before.value, after.value);
+      if (casePatch.type === "unchanged") {
+        return variant("unchanged", null);
+      }
+      return variant("patch", variant(caseName, casePatch));
+    };
+    const variantEqual = equalFor(t2, ctx.equal);
+    ctx.diff.push(ret);
+    ctx.types.push(t2);
+    ctx.equal.push(variantEqual);
+    for (const { name, type: caseType } of t2.value) {
+      caseDiffs[name] = diffFor(caseType, ctx);
+      caseEquals[name] = equalFor(caseType, ctx.equal);
+    }
+    ctx.diff.pop();
+    ctx.types.pop();
+    ctx.equal.pop();
+    return ret;
+  } else if (t2.type === "Ref") {
+    let innerDiff;
+    let innerEqual;
+    let is2;
+    const ret = (before, after) => {
+      if (is2(before, after)) {
+        return variant("unchanged", null);
+      }
+      if (innerEqual(before.value, after.value)) {
+        return variant("unchanged", null);
+      }
+      const innerPatch = innerDiff(before.value, after.value);
+      if (innerPatch.type === "unchanged") {
+        return variant("unchanged", null);
+      }
+      return variant("patch", innerPatch);
+    };
+    const refEqual = equalFor(t2, ctx.equal);
+    ctx.diff.push(ret);
+    ctx.types.push(t2);
+    ctx.equal.push(refEqual);
+    is2 = isFor(t2, ctx.equal);
+    innerDiff = diffFor(t2.value, ctx);
+    innerEqual = equalFor(t2.value, ctx.equal);
+    ctx.diff.pop();
+    ctx.types.pop();
+    ctx.equal.pop();
+    return ret;
+  } else if (t2.type === "Recursive") {
+    const resolvedType = ctx.types[ctx.types.length - Number(t2.value)];
+    if (resolvedType === void 0) {
+      throw new Error(`Internal error: Recursive type context not found in diffFor`);
+    }
+    const equal2 = ctx.equal[ctx.equal.length - Number(t2.value)];
+    if (equal2 === void 0) {
+      throw new Error(`Internal error: Recursive equal context not found in diffFor`);
+    }
+    return (before, after) => {
+      if (equal2(before, after)) {
+        return variant("unchanged", null);
+      }
+      return variant("replace", { before, after });
+    };
+  } else if (t2.type === "Function" || t2.type === "AsyncFunction") {
+    return (_before, _after) => variant("unchanged", null);
+  } else {
+    throw new Error(`Unhandled type in diffFor: ${t2.type}`);
+  }
+}
 class ParseError extends Error {
   constructor(message, position, path = "") {
     super(message);
@@ -84047,6 +84613,1007 @@ const createVariantParser = (cases, frozen, typeCtx) => {
   typeCtx.pop();
   return ret;
 };
+function applyFor(type, ctx = { apply: [], types: [], equal: [], print: [] }) {
+  const t2 = isVariant(type) ? type : toEastTypeValue(type);
+  if (t2.type === "Never") {
+    return (_base, _patch) => {
+      throw new Error("Cannot apply patch to values of type Never");
+    };
+  } else if (t2.type === "Null" || t2.type === "Boolean" || t2.type === "Integer" || t2.type === "Float" || t2.type === "String" || t2.type === "DateTime" || t2.type === "Blob") {
+    const equal2 = equalFor(t2);
+    const print2 = printFor(t2);
+    return (base, patch) => {
+      if (patch.type === "unchanged") {
+        return base;
+      } else if (patch.type === "replace") {
+        if (!equal2(base, patch.value.before)) {
+          throw new ConflictError(`Cannot apply replace - expected ${print2(patch.value.before)}, found ${print2(base)}`);
+        }
+        return patch.value.after;
+      } else {
+        throw new Error(`Invalid patch type for primitive: ${patch.type}`);
+      }
+    };
+  } else if (t2.type === "Array") {
+    let elementApply;
+    let elementEqual;
+    let elementPrint;
+    let arrayEqual;
+    const ret = (base, patch) => {
+      if (patch.type === "unchanged") {
+        return base;
+      } else if (patch.type === "replace") {
+        if (!arrayEqual(base, patch.value.before)) {
+          throw new ConflictError("Cannot apply replace - base array does not match expected");
+        }
+        return [...patch.value.after];
+      } else if (patch.type === "patch") {
+        const result = [...base];
+        const operations = patch.value;
+        for (const op of operations) {
+          const key = Number(op.key);
+          const offset = Number(op.offset);
+          const oldKey = key + offset;
+          if (op.operation.type === "delete") {
+            if (oldKey < 0 || oldKey >= result.length) {
+              throw new ConflictError(`Cannot delete at index ${oldKey} - array length is ${result.length}`);
+            }
+            if (!elementEqual(result[oldKey], op.operation.value)) {
+              throw new ConflictError(`Cannot delete at index ${oldKey} - expected ${elementPrint(op.operation.value)}, found ${elementPrint(result[oldKey])}`);
+            }
+            result.splice(oldKey, 1);
+          } else if (op.operation.type === "insert") {
+            if (key < 0 || key > result.length) {
+              throw new ConflictError(`Cannot insert at index ${key} - array length is ${result.length}`);
+            }
+            result.splice(key, 0, op.operation.value);
+          } else if (op.operation.type === "update") {
+            if (oldKey < 0 || oldKey >= result.length) {
+              throw new ConflictError(`Cannot update at index ${oldKey} - array length is ${result.length}`);
+            }
+            result[oldKey] = elementApply(result[oldKey], op.operation.value);
+          }
+        }
+        return result;
+      } else {
+        throw new Error(`Invalid patch type for array: ${patch.type}`);
+      }
+    };
+    const arrayPrint = printFor(t2, ctx.print);
+    arrayEqual = equalFor(t2, ctx.equal);
+    ctx.apply.push(ret);
+    ctx.types.push(t2);
+    ctx.equal.push(arrayEqual);
+    ctx.print.push(arrayPrint);
+    elementApply = applyFor(t2.value, ctx);
+    elementEqual = equalFor(t2.value, ctx.equal);
+    elementPrint = printFor(t2.value, ctx.print);
+    ctx.apply.pop();
+    ctx.types.pop();
+    ctx.equal.pop();
+    ctx.print.pop();
+    return ret;
+  } else if (t2.type === "Set") {
+    const keyPrint = printFor(t2.value);
+    const setEqual = equalFor(t2, ctx.equal);
+    const keyCompare = compareFor(t2.value);
+    return (base, patch) => {
+      if (patch.type === "unchanged") {
+        return base;
+      } else if (patch.type === "replace") {
+        if (!setEqual(base, patch.value.before)) {
+          throw new ConflictError("Cannot apply replace - base set does not match expected");
+        }
+        return new SortedSet(patch.value.after, keyCompare);
+      } else if (patch.type === "patch") {
+        const result = new SortedSet(base, keyCompare);
+        const operations = patch.value;
+        for (const [key, op] of operations) {
+          if (op.type === "delete") {
+            if (!result.has(key)) {
+              throw new ConflictError(`Cannot delete key ${keyPrint(key)} - key does not exist`);
+            }
+            result.delete(key);
+          } else if (op.type === "insert") {
+            if (result.has(key)) {
+              throw new ConflictError(`Cannot insert key ${keyPrint(key)} - key already exists`);
+            }
+            result.add(key);
+          }
+        }
+        return result;
+      } else {
+        throw new Error(`Invalid patch type for set: ${patch.type}`);
+      }
+    };
+  } else if (t2.type === "Dict") {
+    let valueApply;
+    let valueEqual;
+    let dictEqual;
+    let keyPrint;
+    let valuePrint;
+    const keyCompare = compareFor(t2.value.key);
+    const ret = (base, patch) => {
+      if (patch.type === "unchanged") {
+        return base;
+      } else if (patch.type === "replace") {
+        if (!dictEqual(base, patch.value.before)) {
+          throw new ConflictError("Cannot apply replace - base dict does not match expected");
+        }
+        return new SortedMap(patch.value.after, keyCompare);
+      } else if (patch.type === "patch") {
+        const result = new SortedMap(base, keyCompare);
+        const operations = patch.value;
+        for (const [key, op] of operations) {
+          if (op.type === "delete") {
+            if (!result.has(key)) {
+              throw new ConflictError(`Cannot delete key ${keyPrint(key)} - key does not exist`);
+            }
+            if (!valueEqual(result.get(key), op.value)) {
+              throw new ConflictError(`Cannot delete key ${keyPrint(key)} - expected value ${valuePrint(op.value)}, found ${valuePrint(result.get(key))}`);
+            }
+            result.delete(key);
+          } else if (op.type === "insert") {
+            if (result.has(key)) {
+              throw new ConflictError(`Cannot insert key ${keyPrint(key)} - key already exists with value ${valuePrint(result.get(key))}`);
+            }
+            result.set(key, op.value);
+          } else if (op.type === "update") {
+            if (!result.has(key)) {
+              throw new ConflictError(`Cannot update key ${keyPrint(key)} - key does not exist`);
+            }
+            result.set(key, valueApply(result.get(key), op.value));
+          }
+        }
+        return result;
+      } else {
+        throw new Error(`Invalid patch type for dict: ${patch.type}`);
+      }
+    };
+    const dictPrint = printFor(t2, ctx.print);
+    dictEqual = equalFor(t2, ctx.equal);
+    ctx.apply.push(ret);
+    ctx.types.push(t2);
+    ctx.equal.push(dictEqual);
+    ctx.print.push(dictPrint);
+    valueApply = applyFor(t2.value.value, ctx);
+    valueEqual = equalFor(t2.value.value, ctx.equal);
+    keyPrint = printFor(t2.value.key);
+    valuePrint = printFor(t2.value.value, ctx.print);
+    ctx.apply.pop();
+    ctx.types.pop();
+    ctx.equal.pop();
+    ctx.print.pop();
+    return ret;
+  } else if (t2.type === "Struct") {
+    const fieldApplies = {};
+    let equal2;
+    const ret = (base, patch) => {
+      if (patch.type === "unchanged") {
+        return base;
+      } else if (patch.type === "replace") {
+        if (!equal2(base, patch.value.before)) {
+          throw new ConflictError("Cannot apply replace - base struct does not match expected");
+        }
+        return { ...patch.value.after };
+      } else if (patch.type === "patch") {
+        const result = {};
+        for (const { name } of t2.value) {
+          const fieldPatch = patch.value[name];
+          result[name] = fieldApplies[name](base[name], fieldPatch);
+        }
+        return result;
+      } else {
+        throw new Error(`Invalid patch type for struct: ${patch.type}`);
+      }
+    };
+    const structPrint = printFor(t2, ctx.print);
+    equal2 = equalFor(t2, ctx.equal);
+    ctx.apply.push(ret);
+    ctx.types.push(t2);
+    ctx.equal.push(equal2);
+    ctx.print.push(structPrint);
+    for (const { name, type: fieldType } of t2.value) {
+      fieldApplies[name] = applyFor(fieldType, ctx);
+    }
+    ctx.apply.pop();
+    ctx.types.pop();
+    ctx.equal.pop();
+    ctx.print.pop();
+    return ret;
+  } else if (t2.type === "Variant") {
+    const caseApplies = {};
+    let equal2;
+    const ret = (base, patch) => {
+      if (patch.type === "unchanged") {
+        return base;
+      } else if (patch.type === "replace") {
+        if (!equal2(base, patch.value.before)) {
+          throw new ConflictError("Cannot apply replace - base variant does not match expected");
+        }
+        return patch.value.after;
+      } else if (patch.type === "patch") {
+        const caseName = patch.value.type;
+        if (base.type !== caseName) {
+          throw new ConflictError(`Cannot apply patch for case ${caseName} to variant with case ${base.type}`);
+        }
+        const casePatch = patch.value.value;
+        const newValue = caseApplies[caseName](base.value, casePatch);
+        return variant(caseName, newValue);
+      } else {
+        throw new Error(`Invalid patch type for variant: ${patch.type}`);
+      }
+    };
+    const variantPrint = printFor(t2, ctx.print);
+    equal2 = equalFor(t2, ctx.equal);
+    ctx.apply.push(ret);
+    ctx.types.push(t2);
+    ctx.equal.push(equal2);
+    ctx.print.push(variantPrint);
+    for (const { name, type: caseType } of t2.value) {
+      caseApplies[name] = applyFor(caseType, ctx);
+    }
+    ctx.apply.pop();
+    ctx.types.pop();
+    ctx.equal.pop();
+    ctx.print.pop();
+    return ret;
+  } else if (t2.type === "Ref") {
+    let innerApply;
+    let equal2;
+    const ret = (base, patch) => {
+      if (patch.type === "unchanged") {
+        return base;
+      } else if (patch.type === "replace") {
+        if (!equal2(base, patch.value.before)) {
+          throw new ConflictError("Cannot apply replace - base ref does not match expected");
+        }
+        return { value: patch.value.after.value };
+      } else if (patch.type === "patch") {
+        const newValue = innerApply(base.value, patch.value);
+        return { value: newValue };
+      } else {
+        throw new Error(`Invalid patch type for ref: ${patch.type}`);
+      }
+    };
+    const refPrint = printFor(t2, ctx.print);
+    equal2 = equalFor(t2, ctx.equal);
+    ctx.apply.push(ret);
+    ctx.types.push(t2);
+    ctx.equal.push(equal2);
+    ctx.print.push(refPrint);
+    innerApply = applyFor(t2.value, ctx);
+    ctx.apply.pop();
+    ctx.types.pop();
+    ctx.equal.pop();
+    ctx.print.pop();
+    return ret;
+  } else if (t2.type === "Recursive") {
+    return (base, patch) => {
+      if (patch.type === "unchanged") {
+        return base;
+      } else if (patch.type === "replace") {
+        return patch.value.after;
+      } else {
+        throw new Error(`Invalid patch type for recursive type: ${patch.type}`);
+      }
+    };
+  } else if (t2.type === "Function" || t2.type === "AsyncFunction") {
+    return (base, patch) => {
+      if (patch.type === "unchanged") {
+        return base;
+      } else if (patch.type === "replace") {
+        return patch.value.after;
+      } else {
+        throw new Error(`Invalid patch type for function: ${patch.type}`);
+      }
+    };
+  } else {
+    throw new Error(`Unhandled type in applyFor: ${t2.type}`);
+  }
+}
+function invertFor(type, ctx = { invert: [], types: [], equal: [] }) {
+  const t2 = isVariant(type) ? type : toEastTypeValue(type);
+  if (t2.type === "Never") {
+    return (_patch) => {
+      throw new Error("Cannot invert patches for type Never");
+    };
+  } else if (t2.type === "Null" || t2.type === "Boolean" || t2.type === "Integer" || t2.type === "Float" || t2.type === "String" || t2.type === "DateTime" || t2.type === "Blob") {
+    return (patch) => {
+      if (patch.type === "unchanged") {
+        return patch;
+      } else if (patch.type === "replace") {
+        return variant("replace", { before: patch.value.after, after: patch.value.before });
+      } else {
+        throw new Error(`Invalid patch type for primitive inversion: ${patch.type}`);
+      }
+    };
+  } else if (t2.type === "Array") {
+    let elementInvert;
+    const ret = (patch) => {
+      if (patch.type === "unchanged") {
+        return patch;
+      } else if (patch.type === "replace") {
+        return variant("replace", { before: patch.value.after, after: patch.value.before });
+      } else if (patch.type === "patch") {
+        const operations = patch.value;
+        const inverted = [];
+        for (let i2 = operations.length - 1; i2 >= 0; i2--) {
+          const op = operations[i2];
+          if (op.operation.type === "delete") {
+            inverted.push({
+              key: op.key,
+              offset: 0n,
+              operation: variant("insert", op.operation.value)
+            });
+          } else if (op.operation.type === "insert") {
+            inverted.push({
+              key: op.key,
+              offset: 0n,
+              operation: variant("delete", op.operation.value)
+            });
+          } else if (op.operation.type === "update") {
+            inverted.push({
+              key: op.key,
+              offset: 0n,
+              operation: variant("update", elementInvert(op.operation.value))
+            });
+          }
+        }
+        return variant("patch", inverted);
+      } else {
+        throw new Error(`Invalid patch type for array inversion: ${patch.type}`);
+      }
+    };
+    const arrayEqual = equalFor(t2, ctx.equal);
+    ctx.invert.push(ret);
+    ctx.types.push(t2);
+    ctx.equal.push(arrayEqual);
+    elementInvert = invertFor(t2.value, ctx);
+    ctx.invert.pop();
+    ctx.types.pop();
+    ctx.equal.pop();
+    return ret;
+  } else if (t2.type === "Set") {
+    const keyCompare = compareFor(t2.value);
+    return (patch) => {
+      if (patch.type === "unchanged") {
+        return patch;
+      } else if (patch.type === "replace") {
+        return variant("replace", { before: patch.value.after, after: patch.value.before });
+      } else if (patch.type === "patch") {
+        const operations = patch.value;
+        const inverted = new SortedMap(void 0, keyCompare);
+        for (const [key, op] of operations) {
+          if (op.type === "delete") {
+            inverted.set(key, variant("insert", null));
+          } else if (op.type === "insert") {
+            inverted.set(key, variant("delete", null));
+          }
+        }
+        return variant("patch", inverted);
+      } else {
+        throw new Error(`Invalid patch type for set inversion: ${patch.type}`);
+      }
+    };
+  } else if (t2.type === "Dict") {
+    let valueInvert;
+    const keyCompare = compareFor(t2.value.key);
+    const ret = (patch) => {
+      if (patch.type === "unchanged") {
+        return patch;
+      } else if (patch.type === "replace") {
+        return variant("replace", { before: patch.value.after, after: patch.value.before });
+      } else if (patch.type === "patch") {
+        const operations = patch.value;
+        const inverted = new SortedMap(void 0, keyCompare);
+        for (const [key, op] of operations) {
+          if (op.type === "delete") {
+            inverted.set(key, variant("insert", op.value));
+          } else if (op.type === "insert") {
+            inverted.set(key, variant("delete", op.value));
+          } else if (op.type === "update") {
+            inverted.set(key, variant("update", valueInvert(op.value)));
+          }
+        }
+        return variant("patch", inverted);
+      } else {
+        throw new Error(`Invalid patch type for dict inversion: ${patch.type}`);
+      }
+    };
+    const dictEqual = equalFor(t2, ctx.equal);
+    ctx.invert.push(ret);
+    ctx.types.push(t2);
+    ctx.equal.push(dictEqual);
+    valueInvert = invertFor(t2.value.value, ctx);
+    ctx.invert.pop();
+    ctx.types.pop();
+    ctx.equal.pop();
+    return ret;
+  } else if (t2.type === "Struct") {
+    const fieldInverts = {};
+    const ret = (patch) => {
+      if (patch.type === "unchanged") {
+        return patch;
+      } else if (patch.type === "replace") {
+        return variant("replace", { before: patch.value.after, after: patch.value.before });
+      } else if (patch.type === "patch") {
+        const result = {};
+        let allUnchanged = true;
+        for (const { name } of t2.value) {
+          const inverted = fieldInverts[name](patch.value[name]);
+          result[name] = inverted;
+          if (inverted.type !== "unchanged") {
+            allUnchanged = false;
+          }
+        }
+        if (allUnchanged) {
+          return variant("unchanged", null);
+        }
+        return variant("patch", result);
+      } else {
+        throw new Error(`Invalid patch type for struct inversion: ${patch.type}`);
+      }
+    };
+    const structEqual = equalFor(t2, ctx.equal);
+    ctx.invert.push(ret);
+    ctx.types.push(t2);
+    ctx.equal.push(structEqual);
+    for (const { name, type: fieldType } of t2.value) {
+      fieldInverts[name] = invertFor(fieldType, ctx);
+    }
+    ctx.invert.pop();
+    ctx.types.pop();
+    ctx.equal.pop();
+    return ret;
+  } else if (t2.type === "Variant") {
+    const caseInverts = {};
+    const ret = (patch) => {
+      if (patch.type === "unchanged") {
+        return patch;
+      } else if (patch.type === "replace") {
+        return variant("replace", { before: patch.value.after, after: patch.value.before });
+      } else if (patch.type === "patch") {
+        const caseName = patch.value.type;
+        const inverted = caseInverts[caseName](patch.value.value);
+        if (inverted.type === "unchanged") {
+          return variant("unchanged", null);
+        }
+        return variant("patch", variant(caseName, inverted));
+      } else {
+        throw new Error(`Invalid patch type for variant inversion: ${patch.type}`);
+      }
+    };
+    const variantEqual = equalFor(t2, ctx.equal);
+    ctx.invert.push(ret);
+    ctx.types.push(t2);
+    ctx.equal.push(variantEqual);
+    for (const { name, type: caseType } of t2.value) {
+      caseInverts[name] = invertFor(caseType, ctx);
+    }
+    ctx.invert.pop();
+    ctx.types.pop();
+    ctx.equal.pop();
+    return ret;
+  } else if (t2.type === "Ref") {
+    let innerInvert;
+    const ret = (patch) => {
+      if (patch.type === "unchanged") {
+        return patch;
+      } else if (patch.type === "replace") {
+        return variant("replace", { before: patch.value.after, after: patch.value.before });
+      } else if (patch.type === "patch") {
+        const inverted = innerInvert(patch.value);
+        if (inverted.type === "unchanged") {
+          return variant("unchanged", null);
+        }
+        return variant("patch", inverted);
+      } else {
+        throw new Error(`Invalid patch type for ref inversion: ${patch.type}`);
+      }
+    };
+    const refEqual = equalFor(t2, ctx.equal);
+    ctx.invert.push(ret);
+    ctx.types.push(t2);
+    ctx.equal.push(refEqual);
+    innerInvert = invertFor(t2.value, ctx);
+    ctx.invert.pop();
+    ctx.types.pop();
+    ctx.equal.pop();
+    return ret;
+  } else if (t2.type === "Recursive") {
+    return (patch) => {
+      if (patch.type === "unchanged") {
+        return patch;
+      } else if (patch.type === "replace") {
+        return variant("replace", { before: patch.value.after, after: patch.value.before });
+      } else {
+        throw new Error(`Invalid patch type for recursive type inversion: ${patch.type}`);
+      }
+    };
+  } else if (t2.type === "Function" || t2.type === "AsyncFunction") {
+    return (patch) => {
+      if (patch.type === "unchanged") {
+        return patch;
+      } else if (patch.type === "replace") {
+        return variant("replace", { before: patch.value.after, after: patch.value.before });
+      } else {
+        throw new Error(`Invalid patch type for function inversion: ${patch.type}`);
+      }
+    };
+  } else {
+    throw new Error(`Unhandled type in invertFor: ${t2.type}`);
+  }
+}
+function composeFor(type, ctx = { compose: [], apply: [], invert: [], types: [], equal: [], print: [] }) {
+  const t2 = isVariant(type) ? type : toEastTypeValue(type);
+  if (t2.type === "Never") {
+    return (_first, _second) => {
+      throw new Error("Cannot compose patches for type Never");
+    };
+  } else if (t2.type === "Null" || t2.type === "Boolean" || t2.type === "Integer" || t2.type === "Float" || t2.type === "String" || t2.type === "DateTime" || t2.type === "Blob") {
+    return (first, second2) => {
+      if (first.type === "unchanged") {
+        return second2;
+      } else if (second2.type === "unchanged") {
+        return first;
+      } else if (first.type === "replace" && second2.type === "replace") {
+        return variant("replace", { before: first.value.before, after: second2.value.after });
+      } else {
+        throw new Error("Invalid patch composition for primitive");
+      }
+    };
+  } else if (t2.type === "Array") {
+    let applyRet;
+    let invertRet;
+    const composeRet = (first, second2) => {
+      if (first.type === "unchanged") {
+        return second2;
+      } else if (second2.type === "unchanged") {
+        return first;
+      } else if (first.type === "replace" && second2.type === "replace") {
+        return variant("replace", { before: first.value.before, after: second2.value.after });
+      } else if (first.type === "replace" && second2.type === "patch") {
+        const afterSecond = applyRet(first.value.after, second2);
+        return variant("replace", { before: first.value.before, after: afterSecond });
+      } else if (first.type === "patch" && second2.type === "replace") {
+        const invertedFirst = invertRet(first);
+        const originalBefore = applyRet(second2.value.before, invertedFirst);
+        return variant("replace", { before: originalBefore, after: second2.value.after });
+      } else {
+        const p1Ops = first.value;
+        const p2Ops = second2.value;
+        const result = [...p1Ops, ...p2Ops];
+        if (result.length === 0) {
+          return variant("unchanged", null);
+        }
+        return variant("patch", result);
+      }
+    };
+    const arrayEqual = equalFor(t2, ctx.equal);
+    const arrayPrint = printFor(t2, ctx.print);
+    ctx.compose.push(composeRet);
+    ctx.types.push(t2);
+    ctx.equal.push(arrayEqual);
+    ctx.print.push(arrayPrint);
+    applyRet = applyFor(t2, { apply: ctx.apply, types: ctx.types, equal: ctx.equal, print: ctx.print });
+    invertRet = invertFor(t2, { invert: ctx.invert, types: ctx.types, equal: ctx.equal });
+    ctx.apply.push(applyRet);
+    ctx.invert.push(invertRet);
+    composeFor(t2.value, ctx);
+    ctx.compose.pop();
+    ctx.apply.pop();
+    ctx.invert.pop();
+    ctx.types.pop();
+    ctx.equal.pop();
+    ctx.print.pop();
+    return composeRet;
+  } else if (t2.type === "Set") {
+    const keyPrint = printFor(t2.value);
+    const keyCompare = compareFor(t2.value);
+    const apply = applyFor(t2, { apply: ctx.apply, types: ctx.types, equal: ctx.equal, print: ctx.print });
+    const invert = invertFor(t2, { invert: ctx.invert, types: ctx.types, equal: ctx.equal });
+    return (first, second2) => {
+      if (first.type === "unchanged") {
+        return second2;
+      } else if (second2.type === "unchanged") {
+        return first;
+      } else if (first.type === "replace" && second2.type === "replace") {
+        return variant("replace", { before: first.value.before, after: second2.value.after });
+      } else if (first.type === "patch" && second2.type === "patch") {
+        const result = new SortedMap(void 0, keyCompare);
+        for (const [key, op] of first.value) {
+          result.set(key, op);
+        }
+        for (const [key, op] of second2.value) {
+          if (result.has(key)) {
+            const firstOp = result.get(key);
+            if (firstOp.type === "insert" && op.type === "delete") {
+              result.delete(key);
+            } else if (firstOp.type === "delete" && op.type === "insert") {
+              result.delete(key);
+            } else {
+              throw new ConflictError(`Cannot compose patches - conflicting operations on key ${keyPrint(key)}`);
+            }
+          } else {
+            result.set(key, op);
+          }
+        }
+        if (result.size === 0) {
+          return variant("unchanged", null);
+        }
+        return variant("patch", result);
+      } else {
+        if (first.type === "replace") {
+          const afterSecond = apply(first.value.after, second2);
+          return variant("replace", { before: first.value.before, after: afterSecond });
+        } else {
+          const invertedFirst = invert(first);
+          const originalBefore = apply(second2.value.before, invertedFirst);
+          return variant("replace", { before: originalBefore, after: second2.value.after });
+        }
+      }
+    };
+  } else if (t2.type === "Dict") {
+    let valueCompose;
+    let valueApply;
+    let applyRet;
+    let invertRet;
+    const keyPrint = printFor(t2.value.key);
+    const keyCompare = compareFor(t2.value.key);
+    const composeRet = (first, second2) => {
+      if (first.type === "unchanged") {
+        return second2;
+      } else if (second2.type === "unchanged") {
+        return first;
+      } else if (first.type === "replace" && second2.type === "replace") {
+        return variant("replace", { before: first.value.before, after: second2.value.after });
+      } else if (first.type === "patch" && second2.type === "patch") {
+        const result = new SortedMap(void 0, keyCompare);
+        for (const [key, op] of first.value) {
+          result.set(key, op);
+        }
+        for (const [key, op] of second2.value) {
+          if (result.has(key)) {
+            const firstOp = result.get(key);
+            if (firstOp.type === "insert" && op.type === "delete") {
+              result.delete(key);
+            } else if (firstOp.type === "insert" && op.type === "update") {
+              const newValue = valueApply(firstOp.value, op.value);
+              result.set(key, variant("insert", newValue));
+            } else if (firstOp.type === "delete" && op.type === "insert") {
+              result.set(key, variant("update", variant("replace", { before: firstOp.value, after: op.value })));
+            } else if (firstOp.type === "update" && op.type === "delete") {
+              throw new ConflictError(`Cannot compose patches - update then delete on key ${keyPrint(key)}`);
+            } else if (firstOp.type === "update" && op.type === "update") {
+              const composed = valueCompose(firstOp.value, op.value);
+              result.set(key, variant("update", composed));
+            } else {
+              throw new ConflictError(`Cannot compose patches - conflicting operations on key ${keyPrint(key)}`);
+            }
+          } else {
+            result.set(key, op);
+          }
+        }
+        if (result.size === 0) {
+          return variant("unchanged", null);
+        }
+        return variant("patch", result);
+      } else {
+        if (first.type === "replace") {
+          const afterSecond = applyRet(first.value.after, second2);
+          return variant("replace", { before: first.value.before, after: afterSecond });
+        } else {
+          const invertedFirst = invertRet(first);
+          const originalBefore = applyRet(second2.value.before, invertedFirst);
+          return variant("replace", { before: originalBefore, after: second2.value.after });
+        }
+      }
+    };
+    const dictPrint = printFor(t2, ctx.print);
+    const dictEqual = equalFor(t2, ctx.equal);
+    ctx.compose.push(composeRet);
+    ctx.types.push(t2);
+    ctx.equal.push(dictEqual);
+    ctx.print.push(dictPrint);
+    applyRet = applyFor(t2, { apply: ctx.apply, types: ctx.types, equal: ctx.equal, print: ctx.print });
+    invertRet = invertFor(t2, { invert: ctx.invert, types: ctx.types, equal: ctx.equal });
+    ctx.apply.push(applyRet);
+    ctx.invert.push(invertRet);
+    valueCompose = composeFor(t2.value.value, ctx);
+    valueApply = applyFor(t2.value.value, { apply: ctx.apply, types: ctx.types, equal: ctx.equal, print: ctx.print });
+    ctx.compose.pop();
+    ctx.apply.pop();
+    ctx.invert.pop();
+    ctx.types.pop();
+    ctx.equal.pop();
+    ctx.print.pop();
+    return composeRet;
+  } else if (t2.type === "Struct") {
+    const fieldComposes = {};
+    let applyRet;
+    let invertRet;
+    const composeRet = (first, second2) => {
+      if (first.type === "unchanged") {
+        return second2;
+      } else if (second2.type === "unchanged") {
+        return first;
+      } else if (first.type === "replace" && second2.type === "replace") {
+        return variant("replace", { before: first.value.before, after: second2.value.after });
+      } else if (first.type === "patch" && second2.type === "patch") {
+        const result = {};
+        let allUnchanged = true;
+        for (const { name } of t2.value) {
+          const composed = fieldComposes[name](first.value[name], second2.value[name]);
+          result[name] = composed;
+          if (composed.type !== "unchanged") {
+            allUnchanged = false;
+          }
+        }
+        if (allUnchanged) {
+          return variant("unchanged", null);
+        }
+        return variant("patch", result);
+      } else {
+        if (first.type === "replace") {
+          const afterSecond = applyRet(first.value.after, second2);
+          return variant("replace", { before: first.value.before, after: afterSecond });
+        } else {
+          const invertedFirst = invertRet(first);
+          const originalBefore = applyRet(second2.value.before, invertedFirst);
+          return variant("replace", { before: originalBefore, after: second2.value.after });
+        }
+      }
+    };
+    const structEqual = equalFor(t2, ctx.equal);
+    const structPrint = printFor(t2, ctx.print);
+    ctx.compose.push(composeRet);
+    ctx.types.push(t2);
+    ctx.equal.push(structEqual);
+    ctx.print.push(structPrint);
+    applyRet = applyFor(t2, { apply: ctx.apply, types: ctx.types, equal: ctx.equal, print: ctx.print });
+    invertRet = invertFor(t2, { invert: ctx.invert, types: ctx.types, equal: ctx.equal });
+    ctx.apply.push(applyRet);
+    ctx.invert.push(invertRet);
+    for (const { name, type: fieldType } of t2.value) {
+      fieldComposes[name] = composeFor(fieldType, ctx);
+    }
+    ctx.compose.pop();
+    ctx.apply.pop();
+    ctx.invert.pop();
+    ctx.types.pop();
+    ctx.equal.pop();
+    ctx.print.pop();
+    return composeRet;
+  } else if (t2.type === "Variant") {
+    const caseComposes = {};
+    let applyRet;
+    let invertRet;
+    const composeRet = (first, second2) => {
+      if (first.type === "unchanged") {
+        return second2;
+      } else if (second2.type === "unchanged") {
+        return first;
+      } else if (first.type === "replace" && second2.type === "replace") {
+        return variant("replace", { before: first.value.before, after: second2.value.after });
+      } else if (first.type === "patch" && second2.type === "patch") {
+        if (first.value.type !== second2.value.type) {
+          throw new ConflictError(`Cannot compose variant patches for different cases: ${first.value.type} and ${second2.value.type}`);
+        }
+        const caseName = first.value.type;
+        const composed = caseComposes[caseName](first.value.value, second2.value.value);
+        if (composed.type === "unchanged") {
+          return variant("unchanged", null);
+        }
+        return variant("patch", variant(caseName, composed));
+      } else {
+        if (first.type === "replace") {
+          const afterSecond = applyRet(first.value.after, second2);
+          return variant("replace", { before: first.value.before, after: afterSecond });
+        } else {
+          const invertedFirst = invertRet(first);
+          const originalBefore = applyRet(second2.value.before, invertedFirst);
+          return variant("replace", { before: originalBefore, after: second2.value.after });
+        }
+      }
+    };
+    const variantEqual = equalFor(t2, ctx.equal);
+    const variantPrint = printFor(t2, ctx.print);
+    ctx.compose.push(composeRet);
+    ctx.types.push(t2);
+    ctx.equal.push(variantEqual);
+    ctx.print.push(variantPrint);
+    applyRet = applyFor(t2, { apply: ctx.apply, types: ctx.types, equal: ctx.equal, print: ctx.print });
+    invertRet = invertFor(t2, { invert: ctx.invert, types: ctx.types, equal: ctx.equal });
+    ctx.apply.push(applyRet);
+    ctx.invert.push(invertRet);
+    for (const { name, type: caseType } of t2.value) {
+      caseComposes[name] = composeFor(caseType, ctx);
+    }
+    ctx.compose.pop();
+    ctx.apply.pop();
+    ctx.invert.pop();
+    ctx.types.pop();
+    ctx.equal.pop();
+    ctx.print.pop();
+    return composeRet;
+  } else if (t2.type === "Ref") {
+    let innerCompose;
+    let applyRet;
+    let invertRet;
+    const composeRet = (first, second2) => {
+      if (first.type === "unchanged") {
+        return second2;
+      } else if (second2.type === "unchanged") {
+        return first;
+      } else if (first.type === "replace" && second2.type === "replace") {
+        return variant("replace", { before: first.value.before, after: second2.value.after });
+      } else if (first.type === "patch" && second2.type === "patch") {
+        const composed = innerCompose(first.value, second2.value);
+        if (composed.type === "unchanged") {
+          return variant("unchanged", null);
+        }
+        return variant("patch", composed);
+      } else {
+        if (first.type === "replace") {
+          const afterSecond = applyRet(first.value.after, second2);
+          return variant("replace", { before: first.value.before, after: afterSecond });
+        } else {
+          const invertedFirst = invertRet(first);
+          const originalBefore = applyRet(second2.value.before, invertedFirst);
+          return variant("replace", { before: originalBefore, after: second2.value.after });
+        }
+      }
+    };
+    const refPrint = printFor(t2, ctx.print);
+    const refEqual = equalFor(t2, ctx.equal);
+    ctx.compose.push(composeRet);
+    ctx.types.push(t2);
+    ctx.equal.push(refEqual);
+    ctx.print.push(refPrint);
+    applyRet = applyFor(t2, { apply: ctx.apply, types: ctx.types, equal: ctx.equal, print: ctx.print });
+    invertRet = invertFor(t2, { invert: ctx.invert, types: ctx.types, equal: ctx.equal });
+    ctx.apply.push(applyRet);
+    ctx.invert.push(invertRet);
+    innerCompose = composeFor(t2.value, ctx);
+    ctx.compose.pop();
+    ctx.apply.pop();
+    ctx.invert.pop();
+    ctx.types.pop();
+    ctx.equal.pop();
+    ctx.print.pop();
+    return composeRet;
+  } else if (t2.type === "Recursive") {
+    return (first, second2) => {
+      if (first.type === "unchanged") {
+        return second2;
+      } else if (second2.type === "unchanged") {
+        return first;
+      } else if (first.type === "replace" && second2.type === "replace") {
+        return variant("replace", { before: first.value.before, after: second2.value.after });
+      } else {
+        throw new Error(`Invalid patch types for recursive type composition: ${first.type}, ${second2.type}`);
+      }
+    };
+  } else if (t2.type === "Function" || t2.type === "AsyncFunction") {
+    return (first, second2) => {
+      if (first.type === "unchanged") {
+        return second2;
+      } else if (second2.type === "unchanged") {
+        return first;
+      } else {
+        return variant("replace", { before: first.value.before, after: second2.value.after });
+      }
+    };
+  } else {
+    throw new Error(`Unhandled type in composeFor: ${t2.type}`);
+  }
+}
+function PatchType(type, ctx) {
+  const context = ctx ?? /* @__PURE__ */ new Map();
+  const cached = context.get(type);
+  if (cached !== void 0) {
+    return cached;
+  }
+  const t2 = type;
+  if (t2.type === "Never" || t2.type === "Null" || t2.type === "Boolean" || t2.type === "Integer" || t2.type === "Float" || t2.type === "String" || t2.type === "DateTime" || t2.type === "Blob") {
+    return VariantType({
+      unchanged: NullType,
+      replace: StructType({ before: type, after: type })
+    });
+  } else if (t2.type === "Array") {
+    const elementType = t2.value;
+    const elementPatchType = PatchType(elementType, context);
+    const operationType = VariantType({
+      delete: elementType,
+      insert: elementType,
+      update: elementPatchType
+    });
+    const entryType = StructType({
+      key: IntegerType,
+      offset: IntegerType,
+      operation: operationType
+    });
+    return VariantType({
+      unchanged: NullType,
+      replace: StructType({ before: type, after: type }),
+      patch: ArrayType(entryType)
+    });
+  } else if (t2.type === "Set") {
+    const keyType = t2.key;
+    const operationType = VariantType({
+      delete: NullType,
+      insert: NullType
+    });
+    return VariantType({
+      unchanged: NullType,
+      replace: StructType({ before: type, after: type }),
+      patch: DictType(keyType, operationType)
+    });
+  } else if (t2.type === "Dict") {
+    const keyType = t2.key;
+    const valueType = t2.value;
+    const valuePatchType = PatchType(valueType, context);
+    const operationType = VariantType({
+      delete: valueType,
+      insert: valueType,
+      update: valuePatchType
+    });
+    return VariantType({
+      unchanged: NullType,
+      replace: StructType({ before: type, after: type }),
+      patch: DictType(keyType, operationType)
+    });
+  } else if (t2.type === "Struct") {
+    const fieldTypes = t2.fields;
+    const patchFields = {};
+    for (const [name, fieldType] of Object.entries(fieldTypes)) {
+      patchFields[name] = PatchType(fieldType, context);
+    }
+    return VariantType({
+      unchanged: NullType,
+      replace: StructType({ before: type, after: type }),
+      patch: StructType(patchFields)
+    });
+  } else if (t2.type === "Variant") {
+    const caseTypes = t2.cases;
+    const patchCases = {};
+    for (const [name, caseType] of Object.entries(caseTypes)) {
+      patchCases[name] = PatchType(caseType, context);
+    }
+    return VariantType({
+      unchanged: NullType,
+      replace: StructType({ before: type, after: type }),
+      patch: VariantType(patchCases)
+    });
+  } else if (t2.type === "Ref") {
+    const innerType = t2.value;
+    const innerPatchType = PatchType(innerType, context);
+    return VariantType({
+      unchanged: NullType,
+      replace: StructType({ before: type, after: type }),
+      patch: innerPatchType
+    });
+  } else if (t2.type === "Recursive") {
+    const cached2 = context.get(type);
+    if (cached2 !== void 0) {
+      return cached2;
+    }
+    const replaceOnlyType = VariantType({
+      unchanged: NullType,
+      replace: StructType({ before: type, after: type })
+    });
+    context.set(type, replaceOnlyType);
+    return PatchType(t2.node, context);
+  } else if (t2.type === "Function" || t2.type === "AsyncFunction") {
+    return VariantType({
+      unchanged: NullType,
+      replace: StructType({ before: type, after: type })
+    });
+  } else {
+    throw new Error(`Unhandled type in PatchType: ${t2.type}`);
+  }
+}
 class EastError extends Error {
   constructor(message, options) {
     super(message, options.cause === void 0 ? void 0 : { cause: options.cause });
@@ -88967,6 +90534,34 @@ const builtin_evaluators = {
   LessEqual: (_location, _platformDef, T2) => lessEqualFor(T2),
   Greater: (_location, _platformDef, T2) => greaterFor(T2),
   GreaterEqual: (_location, _platformDef, T2) => greaterEqualFor(T2),
+  Diff: (_location, _platformDef, T2) => diffFor(T2),
+  ApplyPatch: (location, _platformDef, T2) => {
+    const apply = applyFor(T2);
+    return (base, patch) => {
+      try {
+        return apply(base, patch);
+      } catch (e3) {
+        if (e3 instanceof ConflictError) {
+          throw new EastError(e3.message, { location });
+        }
+        throw e3;
+      }
+    };
+  },
+  ComposePatch: (location, _platformDef, T2) => {
+    const compose3 = composeFor(T2);
+    return (first, second2) => {
+      try {
+        return compose3(first, second2);
+      } catch (e3) {
+        if (e3 instanceof ConflictError) {
+          throw new EastError(e3.message, { location });
+        }
+        throw e3;
+      }
+    };
+  },
+  InvertPatch: (_location, _platformDef, T2) => invertFor(T2),
   BooleanNot: (_location) => (x2) => !x2,
   BooleanOr: (_location) => (x2, y2) => x2 || y2,
   BooleanAnd: (_location) => (x2, y2) => x2 && y2,
@@ -91716,6 +93311,20 @@ function greaterEqual(left, right) {
     arguments: [Expr.ast(left), rightAst]
   });
 }
+const equals = equal;
+const eq = equal;
+const notEquals = notEqual;
+const ne = notEqual;
+const lessThan = less;
+const lt = less;
+const lessThanOrEqual = lessEqual;
+const lte = lessEqual;
+const le = lessEqual;
+const greaterThan = greater;
+const gt = greater;
+const greaterThanOrEqual = greaterEqual;
+const gte = greaterEqual;
+const ge = greaterEqual;
 function is(left, right) {
   const rightAst = valueOrExprToAstTyped(right, Expr.type(left));
   return fromAst({
@@ -91738,6 +93347,61 @@ function print(value) {
     arguments: [valueAst]
   });
 }
+function diff(before, after) {
+  const beforeAst = Expr.ast(before);
+  const afterAst = Expr.ast(after);
+  const valueType = beforeAst.type;
+  const patchType = PatchType(valueType);
+  return fromAst({
+    ast_type: "Builtin",
+    type: patchType,
+    location: get_location(2),
+    builtin: "Diff",
+    type_parameters: [valueType, patchType],
+    arguments: [beforeAst, afterAst]
+  });
+}
+function applyPatch(value, patch) {
+  const valueAst = Expr.ast(value);
+  const patchAst = Expr.ast(patch);
+  const valueType = valueAst.type;
+  const patchType = patchAst.type;
+  return fromAst({
+    ast_type: "Builtin",
+    type: valueType,
+    location: get_location(2),
+    builtin: "ApplyPatch",
+    type_parameters: [valueType, patchType],
+    arguments: [valueAst, patchAst]
+  });
+}
+function composePatch(first, second2, type) {
+  const firstAst = Expr.ast(first);
+  const secondAst = Expr.ast(second2);
+  const valueType = type;
+  const patchType = PatchType(valueType);
+  return fromAst({
+    ast_type: "Builtin",
+    type: patchType,
+    location: get_location(2),
+    builtin: "ComposePatch",
+    type_parameters: [valueType, patchType],
+    arguments: [firstAst, secondAst]
+  });
+}
+function invertPatch(patch, type) {
+  const patchAst = Expr.ast(patch);
+  const valueType = type;
+  const patchType = PatchType(valueType);
+  return fromAst({
+    ast_type: "Builtin",
+    type: patchType,
+    location: get_location(2),
+    builtin: "InvertPatch",
+    type_parameters: [valueType, patchType],
+    arguments: [patchAst]
+  });
+}
 const BlockBuilder = (return_type) => {
   const statements = [];
   const $ = ((expr) => {
@@ -92418,7 +94082,27 @@ Object.assign(Expr, {
   greater,
   greaterEqual,
   is,
-  match: matchExpr
+  match: matchExpr,
+  // Comparison aliases
+  equals,
+  eq,
+  notEquals,
+  ne,
+  lessThan,
+  lt,
+  lessThanOrEqual,
+  lte,
+  le,
+  greaterThan,
+  gt,
+  greaterThanOrEqual,
+  gte,
+  ge,
+  // Patch operations
+  diff,
+  applyPatch,
+  composePatch,
+  invertPatch
 });
 const OverlayManagerContext = createContext(null);
 let globalOverlayManager = null;