@shwfed/config 2.12.3 → 2.12.5

package/dist/runtime/components/ui/date-range-picker/DateRangePickerInput.vue.d.ts

@@ -29,8 +29,8 @@ declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {
     "onUpdate:endValue"?: ((args_0: Date | undefined) => any) | undefined;
 }>, {
     size: "sm" | "md" | "lg";
-    clearIcon: string;
     clearable: boolean;
+    clearIcon: string;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const _default: typeof __VLS_export;
 export default _default;

package/dist/runtime/components/ui/date-range-picker/DateRangePickerTimeInput.d.vue.ts

@@ -26,9 +26,9 @@ declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {
     size: "sm" | "md" | "lg";
     granularity: "hour" | "minute" | "second";
     hourCycle: 12 | 24;
-    rangeSeparatorIcon: string;
-    clearIcon: string;
     clearable: boolean;
+    clearIcon: string;
+    rangeSeparatorIcon: string;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const _default: typeof __VLS_export;
 export default _default;

package/dist/runtime/components/ui/date-range-picker/DateRangePickerTimeInput.vue.d.ts

@@ -26,9 +26,9 @@ declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {
     size: "sm" | "md" | "lg";
     granularity: "hour" | "minute" | "second";
     hourCycle: 12 | 24;
-    rangeSeparatorIcon: string;
-    clearIcon: string;
     clearable: boolean;
+    clearIcon: string;
+    rangeSeparatorIcon: string;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const _default: typeof __VLS_export;
 export default _default;

package/dist/runtime/vendor/cel-js/CLAUDE.md

@@ -8,11 +8,11 @@ When modifying this library, keep both `CLAUDE.md` and `PROMPT.md` in sync with
 
 ## Key Modifications
 
-`int` and `uint` types have been removed in favor of a unified `number` type backed by `Decimal` (arbitrary-precision arithmetic via BigInt). All numeric literals, arithmetic results, and size/index returns are `Decimal` instances. The `int()`, `uint()`, and `double()` conversion functions still exist as aliases but all return `number`.
+`int` and `uint` types have been removed in favor of a unified `number` type backed by `Decimal` (arbitrary-precision arithmetic via BigInt). All numeric literals, arithmetic results, and size/index returns are `Decimal` instances. The `int()`, `uint()`, and `double()` conversion functions have been **removed entirely** (calling them is an unknown-function error), the CEL `u`/`U` uint-literal suffix (`123u`, `0xFFu`) is a parse error, and the protobufjs field mapping emits `number` for all numeric/enum fields. Explicit rounding lives in the `math` namespace (`math-builtins.ts`, registered like `JSON`): `math.trunc` / `math.floor` / `math.ceil` / `math.round` (ties away from zero, cel-go style) / `math.abs`, plus `math.min` / `math.max` in `(number, number)` and `(list<number>)` overloads (empty list throws). All are exact — implemented on `Decimal`'s BigInt representation (`decimal.ts` `toInteger`), never via a float round-trip.
 
-`google.protobuf.Timestamp` and `google.protobuf.Duration` have been removed. Replaced with a `Date` type backed by `TZDate` from `@date-fns/tz`, constructed via `date(string)` or `date(number)` (a Unix timestamp — the seconds-vs-milliseconds unit is auto-detected by magnitude: values `< 1e11` are read as seconds, the rest as milliseconds). Date manipulation uses date-fns functions (`startOf`, `endOf`, `offset`, `set`, `format`). `Date.diff(Date, string): number` returns the signed, truncated-toward-zero distance between two dates in a given unit (`millisecond` / `second` / `minute` / `hour` / `day` / `week` / `month` / `year`, plural tolerated) — the receiver is the minuend (`a.diff(b, unit)` = `a − b`, mirroring date-fns `differenceInX(left, right)`); there is no `Date − Date` operator and no duration type, so this is the way to measure elapsed time.
+`google.protobuf.Timestamp` and `google.protobuf.Duration` have been removed. Replaced with a `Date` type backed by `TZDate` from `@date-fns/tz`, constructed via `date(string)` or `date(number)` (a Unix timestamp — the seconds-vs-milliseconds unit is auto-detected by magnitude: values `< 1e11` are read as seconds, the rest as milliseconds). Two-argument forms `date(string, tz)` / `date(number, tz)` anchor an explicit zone (IANA name or fixed offset, validated eagerly via `Intl`): an offset-less wall-clock string (`"2024-06-15T09:00"`, matched by `WALL_CLOCK_STRING`) is interpreted *in that zone* through the TZDate component constructor — NOT via `new TZDate(string, tz)`, whose string path parses machine-local and uses the zone for rendering only — while strings with an explicit offset keep their instant. `Date.tz(string)` re-renders the same instant in another zone. Date manipulation uses date-fns functions, all table-driven through a shared `pickUnit` lookup with a uniform trailing-`s` plural tolerance: `startOf` / `endOf` (`minute` / `hour` / `day` / `week` / `month` / `year`), `offset` and `diff` (`millisecond` … `year`), `set` and the `Date.get(string): number` accessor (`millisecond` … `year`, `month` 1-based, plus `weekday` on `get`, ISO 1 = Monday … 7 = Sunday), and `format`. `Date.diff(Date, string): number` returns the signed, truncated-toward-zero distance between two dates — the receiver is the minuend (`a.diff(b, unit)` = `a − b`, mirroring date-fns `differenceInX(left, right)`); there is no `Date − Date` operator and no duration type, so this is the way to measure elapsed time. Conversions: `number(Date)` is the epoch-millisecond timestamp (round-trips through `date(number)`), `string(Date)` is ISO 8601 rendered with the date's own zone offset.
 
-A `range()` built-in has been added (not from upstream) — `range(number, number)`, `range(number, number, number)` and `range(Date, Date, string)`. It builds an end-exclusive list; the direction follows the operands (counts down when `start > end`); `step` is a positive magnitude; the date unit is `year` / `month` / `day` / `hour` / `minute`. Output length is capped at 100000.
+A `range()` built-in has been added (not from upstream) — `range(number, number)`, `range(number, number, number)` and `range(Date, Date, string)`. It builds an end-exclusive list; the direction follows the operands (counts down when `start > end`); `step` is a positive magnitude; the date unit is `second` / `minute` / `hour` / `day` / `week` / `month` / `year` (plural tolerated). Output length is capped at 100000.
 
 A `list.enumerate(): list<map<string, dyn>>` receiver method has been added (not from upstream, in `functions.ts` beside `list.size()`) — pairs each element with its 0-based index as a plain `{index, value}` record (CEL has no tuple type). It is a plain function, not a macro (no variable binding); the index is a `Decimal` so it stays a CEL `number` for downstream arithmetic. Receiver `list` resolves to `list<dyn>`, so it matches any list.
 
@@ -24,7 +24,7 @@ A `string.replace(string, string): string` / `string.replace(string, string, num
 
 The `homogeneousAggregateLiterals` and `enableOptionalTypes` environment options have been removed. Aggregate data structures (lists, maps) are always heterogeneous — mixed-type literals are inferred as `list<dyn>` or `map<dyn, dyn>`. Optional types (`.?`, `[?]`, `optional.*` helpers) are always enabled.
 
-The custom `Optional` class has been replaced with Effect's `Option` type (`import { Option } from 'effect'`). Internal helpers `optionalOf(value)` and `optionalValue(opt)` in `optional.js` handle the CEL-specific semantics (treating `undefined` as `None`, throwing `EvaluationError` on missing value access). The optional surface is `optional.of(A): optional<A>` (the lift / `pure`), `optional.none()`, `optional.hasValue()`, `optional.value()`, `optional.or(optional)`, `optional.orValue(value)`, plus `optional<A>.flatMap(var, body): optional<B>` (monadic bind) and `optional<A>.map(var, body): optional<B>` (the Functor `fmap`) — all local additions (not from upstream). Both are variable-binding macros (registered with `(ast, ast)` arg types so the body stays unevaluated): on `Some` they bind the value and evaluate `body`; on `None` they short-circuit without touching `body`. `flatMap`'s body must itself yield an `optional`; `map`'s body is a plain value that gets re-wrapped in `Some`. `map` is the derived `o.flatMap(v, optional.of(body))` promoted to a first-class macro. NOTE: `map` is **registered in `macros.ts`**, not here — the parser resolves a macro by name before types are known, so the optional `map` and the list-comprehension `map` must share one expander that dispatches on the receiver type at type-check (an `optional` receiver → fmap; `list`/`map` → comprehension; a `dyn` receiver is deferred to a runtime `Option.isOption` check).
+The custom `Optional` class has been replaced with Effect's `Option` type (`import { Option } from 'effect'`). Internal helpers `optionalOf(value)` and `optionalValue(opt)` in `optional.js` handle the CEL-specific semantics (treating `undefined` as `None`, throwing `EvaluationError` on missing value access). The optional surface is `optional.of(A): optional<A>` (the lift / `pure` — `of(null)` is `Some(null)`), `optional.ofNullable(A): optional<A>` (the null-tolerant lift, Java-style — `null` becomes `None`), `optional.none()`, `optional.hasValue()`, `optional.value()`, `optional.or(optional)`, `optional.orValue(value)`, plus `optional<A>.flatMap(var, body): optional<B>` (monadic bind), `optional<A>.map(var, body): optional<B>` (the Functor `fmap`), `optional<A>.zip(other, x, y, body): optional<C>` (the applicative `liftA2` / `zipWith`), `optional<A>.filter(var, predicate): optional<A>` (Rust `Option::filter` / Haskell `mfilter`), and the folds `optional<A>.exists(var, predicate): bool` (predicate on `Some`, `false` on `None` — Rust `is_some_and`) and `optional<A>.all(var, predicate): bool` (predicate on `Some`, vacuously `true` on `None` — Scala `forall`) — all local additions (not from upstream). All are variable-binding macros (registered with `ast` arg types so the unbound args stay unevaluated): on `Some` they bind the value(s) and evaluate `body`; on `None` they short-circuit without touching `body`. `flatMap`'s body must itself yield an `optional`; `map`'s body is a plain value that gets re-wrapped in `Some`; `filter` / `exists` / `all` predicates must be `bool` (enforced at type-check when static, at runtime via `invalid_condition_type` otherwise). `map` is the derived `o.flatMap(v, optional.of(body))` promoted to a first-class macro. `zip` is the flattened `a.flatMap(x, b.map(y, body))`: it type-checks `other` in the outer ctx, binds `x` then `y` under two chained overlays, re-wraps the plain body in `Some`, and short-circuits to `None` if either side is `None` (a `None` receiver skips evaluating `other`). Because CEL has no tuple type the transform is fused (there is no useful `optional<pair>` to return), so `zip` is `zipWith`, not Rust/Scala's pair-building `Option.zip`. The short-circuit makes `zip` observationally monadic — harmless for `optional` (a `None` carries no payload) but it would not generalise to an error-accumulating applicative. An `optional.none()` receiver/argument carries a `param` element type; the shared `bindOptionalValueType` helper (exported from `optional.ts`) binds it as `dyn` so a boolean body still type-checks — every binding macro (`map` / `flatMap` / `zip` / `filter` / `exists` / `all`) goes through it (leaking the `param` into the iteration variable was a real bug in `map` / `flatMap`, regression-tested in `optional-extras.test.ts`). `zip` lives in `optional.ts` beside `flatMap`; the two-variable binding is why it is not folded into the shared `map` expander. NOTE: `map`, `filter`, `all`, and `exists` are **registered in `macros.ts`**, not here — the parser resolves a macro by name before types are known, so the optional variants and the list-comprehension variants must share one expander per name that dispatches on the receiver type at type-check (an `optional` receiver → optional semantics; `list`/`map` → comprehension; a `dyn` receiver is deferred to a runtime `Option.isOption` check). `exists_one` and `find` stay list-only.
 
 An `http` built-in has been added (`http-builtins.ts`, `http-builder.ts`) — not from upstream. It registers the `http` constant and the `http` / `HttpRequest` types on `globalRegistry`, so `http.get(url).header(...).body(...)` expressions type-check and evaluate in every `Environment`. A CEL expression only builds an `HttpRequestBuilder` — a pure description of a request; it never issues one. The terminal methods `.json()`, `.file()`, and `.fileOrJson()` are dispatched by the host on the returned builder (none is a CEL method), so expression evaluation stays free of IO. `.fileOrJson()` branches on the response `Content-Type`: a JSON media type (`application/json` or a `+json` suffix) is parsed and returned as `{ _tag: 'json', json }`; anything else is returned as `{ _tag: 'file', file }`. Note the `Fetch` service itself `ensureOk`s (both `FetchLive` and the mock layer), so a non-2xx fails at `Fetch.fetch` before the branch and this only ever distinguishes 2xx bodies — i.e. the HTTP-200-with-error-envelope case. The download operation uses it so a backend that answers a download with a JSON error envelope (commonly `{ code: -1 }` on a 200) is classified rather than saved as the file. Endpoints must be absolute URLs — there is no base-URL resolution. Depends on `fx-fetch`. The host can register process-wide default headers via `HttpRequestBuilder.setDefaultHeader(name, valueOrGetter)` / `clearDefaultHeader(name)`; they are merged in at `#buildRequest()` time, with case-insensitive precedence to an explicit `.header(...)` on the builder. A getter that returns `null` / `undefined` / `''` skips the header for that request, so the host can source values from live refs (e.g. the active i18n locale for `Accept-Language`) without baking in stale snapshots. `.query` accepts `(string, string)` / `(string, number)`, the optional-valued `(string, optional<string>)` / `(string, optional<number>)` (a `None`, e.g. an absent `.?` field, drops the param rather than emitting `key=`; `Some` appends it via the string/number coercion), and the record-splat `(dyn)`.
 
@@ -47,11 +47,12 @@ lib/
 ├── operators.ts      — Binary/unary operator implementations
 ├── overloads.ts      — Operator overload definitions
 ├── functions.ts      — Built-in functions + Date type (TZDate)
-├── macros.ts         — map (list comprehension + optional fmap), filter, all, exists, exists_one, find, has, cel.bind
+├── macros.ts         — map / filter / all / exists (each dispatching list comprehension vs optional receiver), exists_one, find, has, cel.bind
 ├── http-builtins.ts  — `http` constant + http/HttpRequest types (local addition)
 ├── http-builder.ts   — `HttpRequestBuilder` — what an http.* expression returns
 ├── json-builtins.ts  — `JSON` constant + `JSON.parse` / `JSON.stringify` (local addition)
 ├── form-builtins.ts  — `form(map): FormData` global + `FormData` type (local addition)
+├── math-builtins.ts  — `math` namespace: trunc / floor / ceil / round / abs / min / max (local addition)
 ├── decimal.ts        — Decimal class (arbitrary precision)
 ├── optional.ts       — Optional type support (uses Effect Option)
 ├── serialize.ts      — AST back to CEL string

package/dist/runtime/vendor/cel-js/PROMPT.md

@@ -8,7 +8,7 @@ CEL has these types:
 
 | Type | Examples | Notes |
 |------|----------|-------|
-| `number` | `42`, `3.14`, `0xFF` | All numbers are arbitrary-precision decimals. There is no `int`, `uint`, or `float` distinction — just `number`. `0.1 + 0.2 == 0.3` is `true`. |
+| `number` | `42`, `3.14`, `0xFF` | All numbers are arbitrary-precision decimals. There is no `int`, `uint`, or `float` distinction — just `number`. `0.1 + 0.2 == 0.3` is `true`. Division keeps 20 significant digits, so `10 / 3 * 3 == 10` is `false` — compare against a rounded value instead. |
 | `string` | `"hello"`, `'world'` | Single or double quotes. Triple-quoted for multiline: `"""text"""`. Raw strings: `r"no\escapes"`. |
 | `bool` | `true`, `false` | |
 | `bytes` | `b"data"`, `b'\xff'` | Binary data. |
@@ -101,16 +101,33 @@ obj[?0]                     // optional index access (returns optional)
 ```cel
 number("42")               // parse string to number
 number(true)               // 1 (false gives 0)
+number(d)                  // Date → epoch-millisecond timestamp
 string(42)                 // "42"
 string(true)               // "true"
+string(d)                  // Date → ISO 8601 string
 bool("true")               // true (also accepts "t", "1", "TRUE", "True")
 bool("false")              // false (also accepts "f", "0", "FALSE", "False")
 bytes("text")              // UTF-8 encode to bytes
-int(3.7)                   // 3 (truncates to integer)
-double("3.14")             // alias for number()
 type(x)                    // returns the type of x
 dyn(x)                     // identity, marks as dynamic type
 ```
+There is no `int()`, `uint()`, or `double()` — `number` is the only numeric
+type. To produce an integer, round explicitly with `math.trunc` / `math.floor`
+/ `math.ceil` / `math.round`.
+
+### Math
+```cel
+math.trunc(3.7)            // 3  — drop the fraction (toward zero)
+math.floor(3.7)            // 3  — toward negative infinity (math.floor(-3.1) == -4)
+math.ceil(3.1)             // 4  — toward positive infinity
+math.round(2.5)            // 3  — nearest; ties away from zero (math.round(-2.5) == -3)
+math.abs(-3.5)             // 3.5
+math.min(3, 7)             // 3
+math.max(3, 7)             // 7
+math.min([5, 2, 9])        // 2  — also accepts a list<number> (errors on [])
+math.max(items.map(i, number(i.price)))   // largest mapped value
+```
+All math operations are exact decimal arithmetic — no float rounding error.
 
 ### Size
 ```cel
@@ -213,44 +230,60 @@ Value coercion is flat (same rules as `.query(...)`):
   on the value if you need a structured field)
 
 ### Dates
+Unit and field names accept singular or plural ("day" == "days") everywhere.
+
 ```cel
 date("2023-06-15")                   // create a Date
 date("2023-06-15T10:30:00Z")        // with time component
 date(1718409600)                     // from a Unix timestamp — seconds...
 date(1718409600000)                  // ...or milliseconds (unit auto-detected by magnitude)
 
-// Comparisons:
+// Time zones (IANA name or fixed offset):
+date("2024-06-15T09:00", "Asia/Shanghai")  // 09:00 *in Shanghai* (wall-clock reading)
+date(1718409600, "UTC")              // timestamp, rendered in UTC
+d.tz("America/New_York")            // same instant, rendered in another zone
+// format / get / startOf / set all work in the date's own zone.
+
+// Comparisons (instant-based, zone-independent):
 date("2023-01-01") < date("2024-01-01")   // true
 date("2023-01-01") == date("2023-01-01")  // true
 
+// Read calendar fields (numbers; month is 1-based):
+d.get("year")                        // 2023
+d.get("month")                       // 6 — June
+d.get("day")                         // day of month
+d.get("hour")                        // 0–23
+d.get("minute")  d.get("second")  d.get("millisecond")
+d.get("weekday")                     // ISO: 1 = Monday … 7 = Sunday
+
 // Start/end of period:
-d.startOf("day")                     // start of day
-d.startOf("week")                    // start of week
-d.startOf("month")                   // start of month
-d.startOf("year")                    // start of year
-d.endOf("month")                     // end of month
+d.startOf("day")                     // also: minute / hour / week / month / year
+d.endOf("month")                     // same units as startOf
 
 // Offset (positive or negative):
 d.offset(3, "days")                  // 3 days later
 d.offset(-1, "month")               // 1 month earlier
-d.offset(2, "weeks")                // 2 weeks later
-d.offset(1, "year")                 // 1 year later
+d.offset(90, "minutes")             // sub-day units work too
+// units: millisecond / second / minute / hour / day / week / month / year
 
 // Difference between two dates (signed, truncated toward zero):
 // receiver is the minuend, so `a.diff(b, unit)` == a − b
 d.diff(other, "day")                // whole days from other to d (negative if d is earlier)
 d.diff(other, "hour")              // whole hours
-d.diff(other, "minute")           // whole minutes
-// units: millisecond / second / minute / hour / day / week / month / year (plural ok)
+// units: millisecond / second / minute / hour / day / week / month / year
 
-// Set specific fields:
+// Set specific fields (month is 1-based):
 d.set("day", 15)                     // set day of month to 15
-d.set("month", 6)                    // set to June (1-based)
-d.set("year", 2025)                  // set year to 2025
+d.set("month", 6)                    // set to June
+d.set("hour", 9)                     // also: minute / second / millisecond / year
 
 // Format:
 d.format("yyyy-MM-dd")              // "2023-06-15"
 d.format("MMMM d, yyyy")           // "June 15, 2023"
+
+// Convert:
+number(d)                            // epoch-millisecond timestamp
+string(d)                            // ISO 8601 in the date's own zone
 ```
 
 ### Ranges
@@ -262,7 +295,7 @@ range(0, 10, 2)                      // [0, 2, 4, 6, 8] — with a step
 range(5, 0)                          // [5, 4, 3, 2, 1] — counts down
 range(date("2024-01-01"), date("2024-04-01"), "month")
                                      // [2024-01-01, 2024-02-01, 2024-03-01]
-// Date unit is one of: "year", "month", "day", "hour", "minute".
+// Date unit is one of: second / minute / hour / day / week / month / year (plural ok).
 ```
 
 ### URL
@@ -336,10 +369,13 @@ http.post("https://api.example.com/users")
 
 An `optional<T>` is either present (`Some`) or absent (`None`). They come from
 `.?` / `[?]` access, `find`, and `URL.query`. Build them with `optional.of(x)`
-(the lift — wraps a value as present) and `optional.none()`.
+(the lift — wraps a value as present), `optional.ofNullable(x)` (like `of`, but
+`null` lifts to absent), and `optional.none()`.
 
 ```cel
 optional.of(5)                          // present, holds 5
+optional.of(null)                       // present, holds null (of never inspects the value)
+optional.ofNullable(row.middleName)     // absent when the field is null
 optional.none()                         // absent
 
 o.hasValue()                            // bool — is it present?
@@ -370,6 +406,48 @@ optional.of(2).flatMap(v, optional.none()).hasValue()   // false — body collap
 Together with `optional.of`, `flatMap` is a lawful monad and `map` its derived
 Functor (`o.map(v, body)` == `o.flatMap(v, optional.of(body))`).
 
+### filter — keep a present value only if it qualifies
+`o.filter(v, predicate)` keeps a present value when the predicate holds and
+collapses it to `None` otherwise; an absent `o` stays `None` and the predicate
+is never evaluated. The value is unchanged — `filter` never transforms.
+```cel
+loc.query("tab").filter(v, v != "").orValue("home")
+// drop a present-but-empty ?tab= and fall back to "home"
+
+optional.of(5).filter(v, v > 10).hasValue()   // false — value didn't qualify
+```
+
+### exists / all — test a present value without unwrapping
+`o.exists(v, predicate)` is the predicate when present, `false` when absent.
+`o.all(v, predicate)` is the predicate when present, `true` when absent
+(vacuous truth — "no value violates it"). Both return plain `bool`, so they
+slot directly into conditions.
+```cel
+query.?channel.exists(c, c == "web")     // false when the field is absent
+query.?limit.all(l, l <= 100)            // absent limit is fine; a present one must qualify
+```
+
+### zip — combine two optionals
+`a.zip(b, x, y, body)` binds the present value of `a` to `x`, the present value
+of `b` to `y`, evaluates `body` (a plain value), and re-wraps the result as
+present — but only when **both** are present; if either is absent the result is
+`None` and `body` is never evaluated. It is the flattened form of
+`a.flatMap(x, b.map(y, body))` — use it to apply a two-argument operation
+(logical `&&`/`||`, string concatenation, arithmetic) across two optionals
+without nesting.
+```cel
+// logical AND of two optional booleans
+enabled.zip(allowed, e, a, e && a).orValue(false)
+
+// concatenate two optional strings, with a fallback
+first.zip(last, f, l, f + " " + l).orValue("N/A")
+```
+Note this is applicative, not three-valued: `optional.of(false).zip(none, a, b, a && b)`
+is `None`, not `Some(false)` — a determined operand does not rescue an absent one.
+Only reach for `zip` when **both** operands are optional; if just one is, plain
+`map` suffices (`a.map(x, x && plainBool)`). For three or more, chain it:
+`a.zip(b, x, y, x && y).zip(c, r, z, r && z)`.
+
 ## Macros
 
 Macros are special forms — they look like method calls but have special evaluation semantics.
@@ -463,7 +541,7 @@ values.all(v, v >= 0 && v <= 100)
 - **No function definitions** — You can only call built-in or registered functions.
 - **No statements** — No `if`/`else` blocks, `for`, `while`, `return`. Use the ternary `? :` for conditionals.
 - **No mutation** — You cannot modify values. Every operation produces a new value.
-- **No `int` or `uint` type** — All numbers are just `number`. Write `42`, not `int(42)`. You do not need to worry about integer vs float precision — `0.1 + 0.2 == 0.3` works correctly.
+- **No `int`, `uint`, or `double`** — All numbers are just `number`, and the `int()` / `uint()` / `double()` conversions do not exist (calling them is an error, and a `123u` literal is a parse error). You do not need to worry about integer vs float precision — `0.1 + 0.2 == 0.3` works correctly. To force an integer, round explicitly: `math.trunc(x)`, `math.floor(x)`, `math.ceil(x)`, or `math.round(x)`.
 - **No imports or modules** — Everything available is already in scope.
 
 ## Error Cases to Avoid

package/dist/runtime/vendor/cel-js/lib/decimal.d.ts

@@ -6,6 +6,10 @@ export declare class Decimal {
     constructor(sign: 1 | -1, coeff: bigint, exp: number);
     static from(v: DecimalInput): Decimal;
     isZero(): boolean;
+    trunc(): Decimal;
+    floor(): Decimal;
+    ceil(): Decimal;
+    round(): Decimal;
     isInteger(): boolean;
     neg(): Decimal;
     abs(): Decimal;

package/dist/runtime/vendor/cel-js/lib/decimal.js

@@ -15,6 +15,29 @@ function normalize(sign, coeff, exp) {
   }
   return new Decimal(sign, coeff, exp);
 }
+function toInteger(d, mode) {
+  if (d.exp >= 0) return d;
+  const scale = pow10(-d.exp);
+  const q = d.coeff / scale;
+  const r = d.coeff % scale;
+  let up = false;
+  switch (mode) {
+    case "trunc":
+      break;
+    case "floor":
+      up = d.sign === -1 && r !== ZERO;
+      break;
+    case "ceil":
+      up = d.sign === 1 && r !== ZERO;
+      break;
+    case "round":
+      up = r * 2n >= scale;
+      break;
+  }
+  const coeff = up ? q + ONE : q;
+  if (coeff === ZERO) return new Decimal(1, ZERO, 0);
+  return normalize(d.sign, coeff, 0);
+}
 function alignExp(a, b) {
   const diff = a.exp - b.exp;
   if (diff === 0) return [a.coeff, b.coeff, a.exp];
@@ -90,6 +113,18 @@ export class Decimal {
   isZero() {
     return this.coeff === ZERO;
   }
+  trunc() {
+    return toInteger(this, "trunc");
+  }
+  floor() {
+    return toInteger(this, "floor");
+  }
+  ceil() {
+    return toInteger(this, "ceil");
+  }
+  round() {
+    return toInteger(this, "round");
+  }
   isInteger() {
     return this.exp >= 0;
   }

package/dist/runtime/vendor/cel-js/lib/evaluator.js

@@ -5,6 +5,7 @@ import { registerFunctions } from "./functions.js";
 import { registerHttpBuiltins } from "./http-builtins.js";
 import { registerJSONBuiltins } from "./json-builtins.js";
 import { registerFormBuiltins } from "./form-builtins.js";
+import { registerMathBuiltins } from "./math-builtins.js";
 import { registerMacros } from "./macros.js";
 import { registerOverloads } from "./overloads.js";
 import { TypeChecker } from "./type-checker.js";
@@ -18,6 +19,7 @@ registerMacros(globalRegistry);
 registerHttpBuiltins(globalRegistry);
 registerJSONBuiltins(globalRegistry);
 registerFormBuiltins(globalRegistry);
+registerMathBuiltins(globalRegistry);
 class Environment {
   #registry;
   #evaluator;