@elaraai/east-ui-components 0.0.1-beta.13 → 0.0.1-beta.15

package/dist/index.cjs

@@ -53768,8 +53768,8 @@ const EastChakraTable = React.memo(function EastChakraTable2({
   const columnHelper = createColumnHelper();
   const columns = React.useMemo(() => {
     return value.columns.map((col) => {
-      const print2 = col.type.type === "Array" ? east.printFor(east.ArrayType(east.StringType)) : east.printFor(col.type);
-      const compare = col.type.type === "Array" ? east.compareFor(east.ArrayType(east.StringType)) : east.compareFor(col.type);
+      const print2 = east.printFor(col.valueType);
+      const compare = east.compareFor(col.valueType);
       const width = getSomeorUndefined(col.width);
       const minWidth = getSomeorUndefined(col.minWidth);
       const maxWidth = getSomeorUndefined(col.maxWidth);
@@ -55072,8 +55072,8 @@ const EastChakraGantt = React.memo(function EastChakraGantt2({
   const columnHelper = createColumnHelper();
   const columns = React.useMemo(() => {
     return value.columns.map((col) => {
-      const print2 = east.printFor(col.type);
-      const compare = east.compareFor(col.type);
+      const print2 = east.printFor(col.valueType);
+      const compare = east.compareFor(col.valueType);
       const width = getSomeorUndefined(col.width);
       const minWidth = getSomeorUndefined(col.minWidth);
       const maxWidth = getSomeorUndefined(col.maxWidth);
@@ -55777,6 +55777,7 @@ const PlannerEvent = ({
   const label = React.useMemo(() => getSomeorUndefined(value.label), [value.label]);
   const textColor = React.useMemo(() => getSomeorUndefined(value.color), [value.color]);
   const backgroundColor = React.useMemo(() => getSomeorUndefined(value.background), [value.background]);
+  const customStrokeColor = React.useMemo(() => getSomeorUndefined(value.stroke), [value.stroke]);
   const eventOpacity = React.useMemo(() => getSomeorUndefined(value.opacity), [value.opacity]);
   const fontWeight = React.useMemo(() => {
     var _a2;
@@ -55794,8 +55795,9 @@ const PlannerEvent = ({
     var _a2;
     return (_a2 = getSomeorUndefined(value.textAlign)) == null ? void 0 : _a2.type;
   }, [value.textAlign]);
-  const [fillColor, strokeColor] = react.useToken("colors", [`${colorPalette}.500`, `${colorPalette}.600`]);
+  const [fillColor, paletteStrokeColor] = react.useToken("colors", [`${colorPalette}.500`, `${colorPalette}.600`]);
   const actualFillColor = backgroundColor ?? fillColor;
+  const actualStrokeColor = customStrokeColor ?? paletteStrokeColor;
   const { baseX, baseWidth } = React.useMemo(() => {
     const { start, end: end3 } = localSlots;
     const slotIndex = Number(start - slotRangeStart);
@@ -55946,7 +55948,7 @@ const PlannerEvent = ({
         width: eventWidth,
         height,
         fill: actualFillColor,
-        stroke: strokeColor,
+        stroke: actualStrokeColor,
         strokeWidth: isActive ? 3 : 2,
         opacity: baseOpacity,
         rx: 4,
@@ -56389,8 +56391,8 @@ const EastChakraPlanner = React.memo(function EastChakraPlanner2({
   const columnHelper = createColumnHelper();
   const columns = React.useMemo(() => {
     return value.columns.map((col) => {
-      const print2 = east.printFor(col.type);
-      const compare = east.compareFor(col.type);
+      const print2 = east.printFor(col.valueType);
+      const compare = east.compareFor(col.valueType);
       const width = getSomeorUndefined(col.width);
       const minWidth = getSomeorUndefined(col.minWidth);
       const maxWidth = getSomeorUndefined(col.maxWidth);
@@ -70571,6 +70573,46 @@ class BooleanExpr extends Expr {
       else_body: false_expr[AstSymbol]
     });
   }
+  /**
+   * Checks if this boolean equals another value.
+   *
+   * @param other - The value to compare against
+   * @returns A BooleanExpr that is true if the values are equal
+   *
+   * @example
+   * ```ts
+   * const isEqual = East.function([BooleanType, BooleanType], BooleanType, ($, a, b) => {
+   *   $.return(a.equals(b));
+   * });
+   * const compiled = East.compile(isEqual.toIR(), []);
+   * compiled(true, true);     // true
+   * compiled(false, false);   // true
+   * compiled(true, false);    // false
+   * ```
+   */
+  equals(other) {
+    return equal(this, other);
+  }
+  /**
+   * Checks if this boolean does not equal another value.
+   *
+   * @param other - The value to compare against
+   * @returns A BooleanExpr that is true if the values are not equal
+   *
+   * @example
+   * ```ts
+   * const isNotEqual = East.function([BooleanType, BooleanType], BooleanType, ($, a, b) => {
+   *   $.return(a.notEquals(b));
+   * });
+   * const compiled = East.compile(isNotEqual.toIR(), []);
+   * compiled(true, false);    // true
+   * compiled(false, true);    // true
+   * compiled(true, true);     // false
+   * ```
+   */
+  notEquals(other) {
+    return notEqual(this, other);
+  }
 }
 class IntegerExpr extends Expr {
   constructor(ast, createExpr) {
@@ -70844,6 +70886,124 @@ class IntegerExpr extends Expr {
       arguments: [this[AstSymbol]]
     });
   }
+  /**
+   * Checks if this integer equals another value.
+   *
+   * @param other - The value to compare against
+   * @returns A BooleanExpr that is true if the values are equal
+   *
+   * @example
+   * ```ts
+   * const isEqual = East.function([IntegerType, IntegerType], BooleanType, ($, a, b) => {
+   *   $.return(a.equals(b));
+   * });
+   * const compiled = East.compile(isEqual.toIR(), []);
+   * compiled(5n, 5n);   // true
+   * compiled(5n, 3n);   // false
+   * ```
+   */
+  equals(other) {
+    return equal(this, other);
+  }
+  /**
+   * Checks if this integer does not equal another value.
+   *
+   * @param other - The value to compare against
+   * @returns A BooleanExpr that is true if the values are not equal
+   *
+   * @example
+   * ```ts
+   * const isNotEqual = East.function([IntegerType, IntegerType], BooleanType, ($, a, b) => {
+   *   $.return(a.notEquals(b));
+   * });
+   * const compiled = East.compile(isNotEqual.toIR(), []);
+   * compiled(5n, 3n);   // true
+   * compiled(5n, 5n);   // false
+   * ```
+   */
+  notEquals(other) {
+    return notEqual(this, other);
+  }
+  /**
+   * Checks if this integer is greater than another value.
+   *
+   * @param other - The value to compare against
+   * @returns A BooleanExpr that is true if this value is greater
+   *
+   * @example
+   * ```ts
+   * const isGreater = East.function([IntegerType, IntegerType], BooleanType, ($, a, b) => {
+   *   $.return(a.greaterThan(b));
+   * });
+   * const compiled = East.compile(isGreater.toIR(), []);
+   * compiled(5n, 3n);   // true
+   * compiled(3n, 5n);   // false
+   * compiled(5n, 5n);   // false
+   * ```
+   */
+  greaterThan(other) {
+    return greater(this, other);
+  }
+  /**
+   * Checks if this integer is less than another value.
+   *
+   * @param other - The value to compare against
+   * @returns A BooleanExpr that is true if this value is less
+   *
+   * @example
+   * ```ts
+   * const isLess = East.function([IntegerType, IntegerType], BooleanType, ($, a, b) => {
+   *   $.return(a.lessThan(b));
+   * });
+   * const compiled = East.compile(isLess.toIR(), []);
+   * compiled(3n, 5n);   // true
+   * compiled(5n, 3n);   // false
+   * compiled(5n, 5n);   // false
+   * ```
+   */
+  lessThan(other) {
+    return less(this, other);
+  }
+  /**
+   * Checks if this integer is greater than or equal to another value.
+   *
+   * @param other - The value to compare against
+   * @returns A BooleanExpr that is true if this value is greater than or equal
+   *
+   * @example
+   * ```ts
+   * const isGreaterOrEqual = East.function([IntegerType, IntegerType], BooleanType, ($, a, b) => {
+   *   $.return(a.greaterThanOrEqual(b));
+   * });
+   * const compiled = East.compile(isGreaterOrEqual.toIR(), []);
+   * compiled(5n, 3n);   // true
+   * compiled(5n, 5n);   // true
+   * compiled(3n, 5n);   // false
+   * ```
+   */
+  greaterThanOrEqual(other) {
+    return greaterEqual(this, other);
+  }
+  /**
+   * Checks if this integer is less than or equal to another value.
+   *
+   * @param other - The value to compare against
+   * @returns A BooleanExpr that is true if this value is less than or equal
+   *
+   * @example
+   * ```ts
+   * const isLessOrEqual = East.function([IntegerType, IntegerType], BooleanType, ($, a, b) => {
+   *   $.return(a.lessThanOrEqual(b));
+   * });
+   * const compiled = East.compile(isLessOrEqual.toIR(), []);
+   * compiled(3n, 5n);   // true
+   * compiled(5n, 5n);   // true
+   * compiled(5n, 3n);   // false
+   * ```
+   */
+  lessThanOrEqual(other) {
+    return lessEqual(this, other);
+  }
 }
 class FloatExpr extends Expr {
   constructor(ast, createExpr) {
@@ -71407,6 +71567,127 @@ class FloatExpr extends Expr {
       arguments: [this[AstSymbol]]
     });
   }
+  // ─────────────────────────────────────────────────────────────────────────────
+  // Comparison methods
+  // ─────────────────────────────────────────────────────────────────────────────
+  /**
+   * Checks if this float equals another value.
+   *
+   * @param other - The value to compare against
+   * @returns A BooleanExpr that is true if the values are equal
+   *
+   * @example
+   * ```ts
+   * const checkEqual = East.function([FloatType, FloatType], BooleanType, ($, x, y) => {
+   *   $.return(x.equals(y));
+   * });
+   * const compiled = East.compile(checkEqual.toIR(), []);
+   * compiled(3.14, 3.14);  // true
+   * compiled(3.14, 2.0);   // false
+   * ```
+   */
+  equals(other) {
+    return equal(this, other);
+  }
+  /**
+   * Checks if this float does not equal another value.
+   *
+   * @param other - The value to compare against
+   * @returns A BooleanExpr that is true if the values are not equal
+   *
+   * @example
+   * ```ts
+   * const checkNotEqual = East.function([FloatType, FloatType], BooleanType, ($, x, y) => {
+   *   $.return(x.notEquals(y));
+   * });
+   * const compiled = East.compile(checkNotEqual.toIR(), []);
+   * compiled(3.14, 2.0);   // true
+   * compiled(3.14, 3.14);  // false
+   * ```
+   */
+  notEquals(other) {
+    return notEqual(this, other);
+  }
+  /**
+   * Checks if this float is greater than another value.
+   *
+   * @param other - The value to compare against
+   * @returns A BooleanExpr that is true if this value is greater
+   *
+   * @example
+   * ```ts
+   * const checkGreater = East.function([FloatType, FloatType], BooleanType, ($, x, y) => {
+   *   $.return(x.greaterThan(y));
+   * });
+   * const compiled = East.compile(checkGreater.toIR(), []);
+   * compiled(3.14, 2.0);   // true
+   * compiled(2.0, 3.14);   // false
+   * compiled(3.14, 3.14);  // false
+   * ```
+   */
+  greaterThan(other) {
+    return greater(this, other);
+  }
+  /**
+   * Checks if this float is less than another value.
+   *
+   * @param other - The value to compare against
+   * @returns A BooleanExpr that is true if this value is less
+   *
+   * @example
+   * ```ts
+   * const checkLess = East.function([FloatType, FloatType], BooleanType, ($, x, y) => {
+   *   $.return(x.lessThan(y));
+   * });
+   * const compiled = East.compile(checkLess.toIR(), []);
+   * compiled(2.0, 3.14);   // true
+   * compiled(3.14, 2.0);   // false
+   * compiled(3.14, 3.14);  // false
+   * ```
+   */
+  lessThan(other) {
+    return less(this, other);
+  }
+  /**
+   * Checks if this float is greater than or equal to another value.
+   *
+   * @param other - The value to compare against
+   * @returns A BooleanExpr that is true if this value is greater than or equal
+   *
+   * @example
+   * ```ts
+   * const checkGte = East.function([FloatType, FloatType], BooleanType, ($, x, y) => {
+   *   $.return(x.greaterThanOrEqual(y));
+   * });
+   * const compiled = East.compile(checkGte.toIR(), []);
+   * compiled(3.14, 2.0);   // true
+   * compiled(3.14, 3.14);  // true
+   * compiled(2.0, 3.14);   // false
+   * ```
+   */
+  greaterThanOrEqual(other) {
+    return greaterEqual(this, other);
+  }
+  /**
+   * Checks if this float is less than or equal to another value.
+   *
+   * @param other - The value to compare against
+   * @returns A BooleanExpr that is true if this value is less than or equal
+   *
+   * @example
+   * ```ts
+   * const checkLte = East.function([FloatType, FloatType], BooleanType, ($, x, y) => {
+   *   $.return(x.lessThanOrEqual(y));
+   * });
+   * const compiled = East.compile(checkLte.toIR(), []);
+   * compiled(2.0, 3.14);   // true
+   * compiled(3.14, 3.14);  // true
+   * compiled(3.14, 2.0);   // false
+   * ```
+   */
+  lessThanOrEqual(other) {
+    return lessEqual(this, other);
+  }
 }
 function validateCrossPlatformCompatible(regex) {
   const result = {
@@ -72154,6 +72435,124 @@ class StringExpr extends Expr {
       arguments: [this[AstSymbol]]
     });
   }
+  /**
+   * Checks if this string equals another value.
+   *
+   * @param other - The value to compare against
+   * @returns A BooleanExpr that is true if the values are equal
+   *
+   * @example
+   * ```ts
+   * const isEqual = East.function([StringType, StringType], BooleanType, ($, a, b) => {
+   *   $.return(a.equals(b));
+   * });
+   * const compiled = East.compile(isEqual.toIR(), []);
+   * compiled("hello", "hello");   // true
+   * compiled("hello", "world");   // false
+   * ```
+   */
+  equals(other) {
+    return equal(this, other);
+  }
+  /**
+   * Checks if this string does not equal another value.
+   *
+   * @param other - The value to compare against
+   * @returns A BooleanExpr that is true if the values are not equal
+   *
+   * @example
+   * ```ts
+   * const isNotEqual = East.function([StringType, StringType], BooleanType, ($, a, b) => {
+   *   $.return(a.notEquals(b));
+   * });
+   * const compiled = East.compile(isNotEqual.toIR(), []);
+   * compiled("hello", "world");   // true
+   * compiled("hello", "hello");   // false
+   * ```
+   */
+  notEquals(other) {
+    return notEqual(this, other);
+  }
+  /**
+   * Checks if this string is greater than another value (lexicographically).
+   *
+   * @param other - The value to compare against
+   * @returns A BooleanExpr that is true if this string is greater
+   *
+   * @example
+   * ```ts
+   * const isGreater = East.function([StringType, StringType], BooleanType, ($, a, b) => {
+   *   $.return(a.greaterThan(b));
+   * });
+   * const compiled = East.compile(isGreater.toIR(), []);
+   * compiled("b", "a");     // true
+   * compiled("a", "b");     // false
+   * compiled("a", "a");     // false
+   * ```
+   */
+  greaterThan(other) {
+    return greater(this, other);
+  }
+  /**
+   * Checks if this string is less than another value (lexicographically).
+   *
+   * @param other - The value to compare against
+   * @returns A BooleanExpr that is true if this string is less
+   *
+   * @example
+   * ```ts
+   * const isLess = East.function([StringType, StringType], BooleanType, ($, a, b) => {
+   *   $.return(a.lessThan(b));
+   * });
+   * const compiled = East.compile(isLess.toIR(), []);
+   * compiled("a", "b");     // true
+   * compiled("b", "a");     // false
+   * compiled("a", "a");     // false
+   * ```
+   */
+  lessThan(other) {
+    return less(this, other);
+  }
+  /**
+   * Checks if this string is greater than or equal to another value (lexicographically).
+   *
+   * @param other - The value to compare against
+   * @returns A BooleanExpr that is true if this string is greater than or equal
+   *
+   * @example
+   * ```ts
+   * const isGreaterOrEqual = East.function([StringType, StringType], BooleanType, ($, a, b) => {
+   *   $.return(a.greaterThanOrEqual(b));
+   * });
+   * const compiled = East.compile(isGreaterOrEqual.toIR(), []);
+   * compiled("b", "a");     // true
+   * compiled("a", "a");     // true
+   * compiled("a", "b");     // false
+   * ```
+   */
+  greaterThanOrEqual(other) {
+    return greaterEqual(this, other);
+  }
+  /**
+   * Checks if this string is less than or equal to another value (lexicographically).
+   *
+   * @param other - The value to compare against
+   * @returns A BooleanExpr that is true if this string is less than or equal
+   *
+   * @example
+   * ```ts
+   * const isLessOrEqual = East.function([StringType, StringType], BooleanType, ($, a, b) => {
+   *   $.return(a.lessThanOrEqual(b));
+   * });
+   * const compiled = East.compile(isLessOrEqual.toIR(), []);
+   * compiled("a", "b");     // true
+   * compiled("a", "a");     // true
+   * compiled("b", "a");     // false
+   * ```
+   */
+  lessThanOrEqual(other) {
+    return lessEqual(this, other);
+  }
 }
 function tokenizeDateTimeFormat(format2) {
   const tokens = [];
@@ -73026,6 +73425,124 @@ class DateTimeExpr extends Expr {
       arguments: [this[AstSymbol], tokensArray[AstSymbol]]
     });
   }
+  /**
+   * Checks if this DateTime equals another value.
+   *
+   * @param other - The value to compare against
+   * @returns A BooleanExpr that is true if the values are equal
+   *
+   * @example
+   * ```ts
+   * const isEqual = East.function([DateTimeType, DateTimeType], BooleanType, ($, a, b) => {
+   *   $.return(a.equals(b));
+   * });
+   * const compiled = East.compile(isEqual.toIR(), []);
+   * compiled(new Date("2025-01-15T00:00:00.000Z"), new Date("2025-01-15T00:00:00.000Z"));  // true
+   * compiled(new Date("2025-01-15T00:00:00.000Z"), new Date("2025-01-16T00:00:00.000Z"));  // false
+   * ```
+   */
+  equals(other) {
+    return equal(this, other);
+  }
+  /**
+   * Checks if this DateTime does not equal another value.
+   *
+   * @param other - The value to compare against
+   * @returns A BooleanExpr that is true if the values are not equal
+   *
+   * @example
+   * ```ts
+   * const isNotEqual = East.function([DateTimeType, DateTimeType], BooleanType, ($, a, b) => {
+   *   $.return(a.notEquals(b));
+   * });
+   * const compiled = East.compile(isNotEqual.toIR(), []);
+   * compiled(new Date("2025-01-15T00:00:00.000Z"), new Date("2025-01-16T00:00:00.000Z"));  // true
+   * compiled(new Date("2025-01-15T00:00:00.000Z"), new Date("2025-01-15T00:00:00.000Z"));  // false
+   * ```
+   */
+  notEquals(other) {
+    return notEqual(this, other);
+  }
+  /**
+   * Checks if this DateTime is after another value.
+   *
+   * @param other - The value to compare against
+   * @returns A BooleanExpr that is true if this DateTime is after the other
+   *
+   * @example
+   * ```ts
+   * const isAfter = East.function([DateTimeType, DateTimeType], BooleanType, ($, a, b) => {
+   *   $.return(a.greaterThan(b));
+   * });
+   * const compiled = East.compile(isAfter.toIR(), []);
+   * compiled(new Date("2025-01-16T00:00:00.000Z"), new Date("2025-01-15T00:00:00.000Z"));  // true
+   * compiled(new Date("2025-01-15T00:00:00.000Z"), new Date("2025-01-16T00:00:00.000Z"));  // false
+   * compiled(new Date("2025-01-15T00:00:00.000Z"), new Date("2025-01-15T00:00:00.000Z"));  // false
+   * ```
+   */
+  greaterThan(other) {
+    return greater(this, other);
+  }
+  /**
+   * Checks if this DateTime is before another value.
+   *
+   * @param other - The value to compare against
+   * @returns A BooleanExpr that is true if this DateTime is before the other
+   *
+   * @example
+   * ```ts
+   * const isBefore = East.function([DateTimeType, DateTimeType], BooleanType, ($, a, b) => {
+   *   $.return(a.lessThan(b));
+   * });
+   * const compiled = East.compile(isBefore.toIR(), []);
+   * compiled(new Date("2025-01-15T00:00:00.000Z"), new Date("2025-01-16T00:00:00.000Z"));  // true
+   * compiled(new Date("2025-01-16T00:00:00.000Z"), new Date("2025-01-15T00:00:00.000Z"));  // false
+   * compiled(new Date("2025-01-15T00:00:00.000Z"), new Date("2025-01-15T00:00:00.000Z"));  // false
+   * ```
+   */
+  lessThan(other) {
+    return less(this, other);
+  }
+  /**
+   * Checks if this DateTime is after or equal to another value.
+   *
+   * @param other - The value to compare against
+   * @returns A BooleanExpr that is true if this DateTime is after or equal to the other
+   *
+   * @example
+   * ```ts
+   * const isAfterOrEqual = East.function([DateTimeType, DateTimeType], BooleanType, ($, a, b) => {
+   *   $.return(a.greaterThanOrEqual(b));
+   * });
+   * const compiled = East.compile(isAfterOrEqual.toIR(), []);
+   * compiled(new Date("2025-01-16T00:00:00.000Z"), new Date("2025-01-15T00:00:00.000Z"));  // true
+   * compiled(new Date("2025-01-15T00:00:00.000Z"), new Date("2025-01-15T00:00:00.000Z"));  // true
+   * compiled(new Date("2025-01-15T00:00:00.000Z"), new Date("2025-01-16T00:00:00.000Z"));  // false
+   * ```
+   */
+  greaterThanOrEqual(other) {
+    return greaterEqual(this, other);
+  }
+  /**
+   * Checks if this DateTime is before or equal to another value.
+   *
+   * @param other - The value to compare against
+   * @returns A BooleanExpr that is true if this DateTime is before or equal to the other
+   *
+   * @example
+   * ```ts
+   * const isBeforeOrEqual = East.function([DateTimeType, DateTimeType], BooleanType, ($, a, b) => {
+   *   $.return(a.lessThanOrEqual(b));
+   * });
+   * const compiled = East.compile(isBeforeOrEqual.toIR(), []);
+   * compiled(new Date("2025-01-15T00:00:00.000Z"), new Date("2025-01-16T00:00:00.000Z"));  // true
+   * compiled(new Date("2025-01-15T00:00:00.000Z"), new Date("2025-01-15T00:00:00.000Z"));  // true
+   * compiled(new Date("2025-01-16T00:00:00.000Z"), new Date("2025-01-15T00:00:00.000Z"));  // false
+   * ```
+   */
+  lessThanOrEqual(other) {
+    return lessEqual(this, other);
+  }
 }
 function isFor(type, typeCtx = []) {
   if (!isVariant(type)) {
@@ -74556,6 +75073,49 @@ class BlobExpr extends Expr {
       arguments: [this[AstSymbol], configAst]
     });
   }
+  /**
+   * Checks if this blob equals another blob (byte-by-byte comparison).
+   *
+   * @param other - The blob to compare against
+   * @returns A BooleanExpr that is true if the blobs are identical
+   *
+   * @example
+   * ```ts
+   * const isEqual = East.function([BlobType, BlobType], BooleanType, ($, a, b) => {
+   *   $.return(a.equals(b));
+   * });
+   * const compiled = East.compile(isEqual.toIR(), []);
+   * const blob1 = new Uint8Array([1, 2, 3]);
+   * const blob2 = new Uint8Array([1, 2, 3]);
+   * const blob3 = new Uint8Array([1, 2, 4]);
+   * compiled(blob1, blob2);  // true
+   * compiled(blob1, blob3);  // false
+   * ```
+   */
+  equals(other) {
+    return equal(this, other);
+  }
+  /**
+   * Checks if this blob does not equal another blob.
+   *
+   * @param other - The blob to compare against
+   * @returns A BooleanExpr that is true if the blobs are different
+   *
+   * @example
+   * ```ts
+   * const isNotEqual = East.function([BlobType, BlobType], BooleanType, ($, a, b) => {
+   *   $.return(a.notEquals(b));
+   * });
+   * const compiled = East.compile(isNotEqual.toIR(), []);
+   * const blob1 = new Uint8Array([1, 2, 3]);
+   * const blob2 = new Uint8Array([1, 2, 4]);
+   * compiled(blob1, blob2);  // true
+   * compiled(blob1, blob1);  // false
+   * ```
+   */
+  notEquals(other) {
+    return notEqual(this, other);
+  }
 }
 class ArrayExpr extends Expr {
   constructor(value_type, ast, createExpr) {
@@ -76363,6 +76923,44 @@ class ArrayExpr extends Expr {
       arguments: [this[AstSymbol], configAst]
     });
   }
+  /**
+   * Checks if this array equals another array (deep comparison).
+   *
+   * @param other - The array to compare against
+   * @returns A BooleanExpr that is true if the arrays are deeply equal
+   *
+   * @example
+   * ```ts
+   * const isEqual = East.function([ArrayType(IntegerType), ArrayType(IntegerType)], BooleanType, ($, a, b) => {
+   *   $.return(a.equals(b));
+   * });
+   * const compiled = East.compile(isEqual.toIR(), []);
+   * compiled([1n, 2n, 3n], [1n, 2n, 3n]);  // true
+   * compiled([1n, 2n], [1n, 2n, 3n]);      // false
+   * ```
+   */
+  equals(other) {
+    return equal(this, other);
+  }
+  /**
+   * Checks if this array does not equal another array.
+   *
+   * @param other - The array to compare against
+   * @returns A BooleanExpr that is true if the arrays are not equal
+   *
+   * @example
+   * ```ts
+   * const isNotEqual = East.function([ArrayType(IntegerType), ArrayType(IntegerType)], BooleanType, ($, a, b) => {
+   *   $.return(a.notEquals(b));
+   * });
+   * const compiled = East.compile(isNotEqual.toIR(), []);
+   * compiled([1n, 2n], [1n, 2n, 3n]);      // true
+   * compiled([1n, 2n, 3n], [1n, 2n, 3n]);  // false
+   * ```
+   */
+  notEquals(other) {
+    return notEqual(this, other);
+  }
 }
 class SetExpr extends Expr {
   constructor(key_type, ast, createExpr) {
@@ -77436,6 +78034,44 @@ class SetExpr extends Expr {
       }
     }
   }
+  /**
+   * Checks if this set equals another set (same elements).
+   *
+   * @param other - The set to compare against
+   * @returns A BooleanExpr that is true if the sets are equal
+   *
+   * @example
+   * ```ts
+   * const isEqual = East.function([SetType(IntegerType), SetType(IntegerType)], BooleanType, ($, a, b) => {
+   *   $.return(a.equals(b));
+   * });
+   * const compiled = East.compile(isEqual.toIR(), []);
+   * compiled(new Set([1n, 2n, 3n]), new Set([1n, 2n, 3n]));  // true
+   * compiled(new Set([1n, 2n]), new Set([1n, 2n, 3n]));      // false
+   * ```
+   */
+  equals(other) {
+    return equal(this, other);
+  }
+  /**
+   * Checks if this set does not equal another set.
+   *
+   * @param other - The set to compare against
+   * @returns A BooleanExpr that is true if the sets are not equal
+   *
+   * @example
+   * ```ts
+   * const isNotEqual = East.function([SetType(IntegerType), SetType(IntegerType)], BooleanType, ($, a, b) => {
+   *   $.return(a.notEquals(b));
+   * });
+   * const compiled = East.compile(isNotEqual.toIR(), []);
+   * compiled(new Set([1n, 2n]), new Set([1n, 2n, 3n]));      // true
+   * compiled(new Set([1n, 2n, 3n]), new Set([1n, 2n, 3n]));  // false
+   * ```
+   */
+  notEquals(other) {
+    return notEqual(this, other);
+  }
 }
 class DictExpr extends Expr {
   constructor(key_type, value_type, ast, createExpr) {
@@ -78856,6 +79492,44 @@ class DictExpr extends Expr {
       }
     }
   }
+  /**
+   * Checks if this dictionary equals another dictionary (same key-value pairs).
+   *
+   * @param other - The dictionary to compare against
+   * @returns A BooleanExpr that is true if the dictionaries are equal
+   *
+   * @example
+   * ```ts
+   * const isEqual = East.function([DictType(StringType, IntegerType), DictType(StringType, IntegerType)], BooleanType, ($, a, b) => {
+   *   $.return(a.equals(b));
+   * });
+   * const compiled = East.compile(isEqual.toIR(), []);
+   * compiled(new Map([["a", 1n], ["b", 2n]]), new Map([["a", 1n], ["b", 2n]]));  // true
+   * compiled(new Map([["a", 1n]]), new Map([["a", 1n], ["b", 2n]]));            // false
+   * ```
+   */
+  equals(other) {
+    return equal(this, other);
+  }
+  /**
+   * Checks if this dictionary does not equal another dictionary.
+   *
+   * @param other - The dictionary to compare against
+   * @returns A BooleanExpr that is true if the dictionaries are not equal
+   *
+   * @example
+   * ```ts
+   * const isNotEqual = East.function([DictType(StringType, IntegerType), DictType(StringType, IntegerType)], BooleanType, ($, a, b) => {
+   *   $.return(a.notEquals(b));
+   * });
+   * const compiled = East.compile(isNotEqual.toIR(), []);
+   * compiled(new Map([["a", 1n]]), new Map([["a", 1n], ["b", 2n]]));            // true
+   * compiled(new Map([["a", 1n], ["b", 2n]]), new Map([["a", 1n], ["b", 2n]]));  // false
+   * ```
+   */
+  notEquals(other) {
+    return notEqual(this, other);
+  }
 }
 const _StructExpr = class StructExpr extends Expr {
   constructor(field_types, ast, factory) {
@@ -78934,60 +79608,56 @@ class VariantExpr extends Expr {
     const handlers = Object.fromEntries(Object.keys(this.cases).map((caseName) => [caseName, caseName === name ? (_$, data) => data : ($, _data) => onOther($)]));
     return Expr.match(this, handlers);
   }
+  // Implementation
+  match(handlers, defaultHandler) {
+    const completeHandlers = Object.fromEntries(Object.keys(this.cases).map((caseName) => [
+      caseName,
+      handlers[caseName] ?? (defaultHandler ? (($, _data) => defaultHandler($)) : void 0)
+    ]));
+    return Expr.match(this, completeHandlers);
+  }
   /**
-   * Pattern match on this variant, handling specific cases with a default fallback.
-   *
-   * This method allows partial matching where you only need to handle the cases you care about,
-   * with a required default handler for any unmatched cases. This is more ergonomic than
-   * exhaustive matching when you only need to handle a subset of cases.
+   * Checks if this variant equals another variant (same tag and value).
    *
-   * @typeParam Handlers - Partial record of case handlers
-   * @typeParam Default - Type of the default handler function
-   * @param handlers - Object mapping case names to handler functions (not all cases required)
-   * @param defaultHandler - Required handler for any unmatched cases
-   * @returns Expression of the union type of all handler return types and default return type
-   *
-   * @see {@link Expr.match} for exhaustive pattern matching requiring all cases
-   * @see {@link unwrap} for extracting a single case value
+   * @param other - The variant to compare against
+   * @returns A BooleanExpr that is true if the variants are equal
    *
    * @example
    * ```ts
    * const OptionType = VariantType({ some: IntegerType, none: NullType });
    *
-   * // Handle only the 'some' case, use default for 'none'
-   * const getOrZero = East.function([OptionType], IntegerType, ($, opt) => {
-   *   $.return(opt.match({
-   *     some: ($, val) => val
-   *   }, ($) => 0n));
+   * const isEqual = East.function([OptionType, OptionType], BooleanType, ($, a, b) => {
+   *   $.return(a.equals(b));
    * });
-   * const compiled = East.compile(getOrZero.toIR(), []);
-   * compiled(Expr.variant("some", 42n));   // 42n
-   * compiled(Expr.variant("none", null));  // 0n
+   * const compiled = East.compile(isEqual.toIR(), []);
+   * compiled(variant("some", 42n), variant("some", 42n));  // true
+   * compiled(variant("some", 42n), variant("some", 0n));   // false
+   * compiled(variant("some", 42n), variant("none", null)); // false
    * ```
+   */
+  equals(other) {
+    return equal(this, other);
+  }
+  /**
+   * Checks if this variant does not equal another variant.
+   *
+   * @param other - The variant to compare against
+   * @returns A BooleanExpr that is true if the variants are not equal
    *
    * @example
    * ```ts
-   * const ResultType = VariantType({ ok: IntegerType, error: StringType, pending: NullType });
-   *
-   * // Handle multiple cases with a default for the rest
-   * const handleResult = East.function([ResultType], IntegerType, ($, result) => {
-   *   $.return(result.match({
-   *     ok: ($, val) => val,
-   *     error: ($, _msg) => -1n
-   *   }, ($) => 0n));  // pending -> 0
+   * const OptionType = VariantType({ some: IntegerType, none: NullType });
+   *
+   * const isNotEqual = East.function([OptionType, OptionType], BooleanType, ($, a, b) => {
+   *   $.return(a.notEquals(b));
    * });
-   * const compiled = East.compile(handleResult.toIR(), []);
-   * compiled(Expr.variant("ok", 100n));       // 100n
-   * compiled(Expr.variant("error", "fail"));  // -1n
-   * compiled(Expr.variant("pending", null));  // 0n
+   * const compiled = East.compile(isNotEqual.toIR(), []);
+   * compiled(variant("some", 42n), variant("some", 0n));   // true
+   * compiled(variant("some", 42n), variant("some", 42n));  // false
    * ```
    */
-  match(handlers, defaultHandler) {
-    const completeHandlers = Object.fromEntries(Object.keys(this.cases).map((caseName) => [
-      caseName,
-      handlers[caseName] ?? (($, _data) => defaultHandler($))
-    ]));
-    return Expr.match(this, completeHandlers);
+  notEquals(other) {
+    return notEqual(this, other);
   }
 }
 function printLocationValue(location) {
@@ -80961,8 +81631,27 @@ class EastError extends Error {
   constructor(message, options) {
     super(message, options.cause === void 0 ? void 0 : { cause: options.cause });
     __publicField(this, "location");
+    __publicField(this, "eastMessage");
+    this.eastMessage = message;
     this.location = [options.location];
   }
+  toString() {
+    const loc = this.location[0];
+    const header = `${loc.filename}:${loc.line}:${loc.column}: ${this.eastMessage}`;
+    if (this.location.length <= 1) {
+      return header;
+    }
+    const lines = [header, "Stack trace:"];
+    for (let i2 = this.location.length - 1; i2 >= 1; i2--) {
+      const frame = this.location[i2];
+      lines.push(`  at ${frame.filename}:${frame.line}:${frame.column}`);
+    }
+    return lines.join("\n");
+  }
+  /** Format for use with Error.message */
+  get formattedMessage() {
+    return this.toString();
+  }
 }
 const _BufferWriter = class _BufferWriter {
   constructor(initialCapacity = 16384) {