@shwfed/config 1.0.0

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

@@ -0,0 +1,311 @@
+# Writing CEL Expressions
+
+You are writing expressions in CEL (Common Expression Language). CEL is a small, safe expression language designed for evaluating single expressions — it is NOT a general-purpose programming language. There are no statements, assignments, loops, or function definitions. Every CEL program is a single expression that evaluates to a value.
+
+## Types
+
+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`. |
+| `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. |
+| `null` | `null` | |
+| `list` | `[1, 2, 3]` | Ordered collection. |
+| `map` | `{"key": "value"}` | Key-value pairs. |
+| `Date` | `date("2023-01-15")` | Backed by TZDate. Supports any parseable date string. |
+
+## Operators
+
+### Arithmetic (number only)
+```cel
+1 + 2          // 3
+10 - 3         // 7
+4 * 5          // 20
+10 / 3         // 3.333...
+10 % 3         // 1
+-x             // negation
+```
+
+### Comparison
+```cel
+a == b         // equality (works on all types, deep comparison for lists/maps)
+a != b         // inequality
+a < b          // less than
+a <= b         // less or equal
+a > b          // greater than
+a >= b         // greater or equal
+```
+
+### Logical
+```cel
+a && b         // AND (short-circuits)
+a || b         // OR (short-circuits)
+!a             // NOT
+```
+
+### Ternary
+```cel
+condition ? value_if_true : value_if_false
+```
+
+### Membership
+```cel
+"a" in ["a", "b", "c"]       // true — element in list
+"key" in {"key": "value"}    // true — key in map
+```
+
+### String concatenation
+```cel
+"hello" + " " + "world"    // "hello world"
+```
+
+### List concatenation
+```cel
+[1, 2] + [3, 4]            // [1, 2, 3, 4]
+```
+
+### Field access
+```cel
+obj.field                   // access field on map/object
+obj["field"]                // bracket access (equivalent)
+obj.?field                  // optional field access (returns optional)
+obj[?0]                     // optional index access (returns optional)
+```
+
+## Built-in Functions
+
+### Type conversions
+```cel
+number("42")               // parse string to number
+number(true)               // 1 (false gives 0)
+string(42)                 // "42"
+string(true)               // "true"
+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
+```
+
+### Size
+```cel
+size("hello")              // 5 (Unicode-aware character count)
+size([1, 2, 3])            // 3
+size({"a": 1})             // 1
+size(b"data")              // 4
+// Also available as method:
+"hello".size()             // 5
+[1, 2].size()              // 2
+```
+
+### String methods
+```cel
+"hello".contains("ell")              // true
+"hello".startsWith("hel")            // true
+"hello".endsWith("llo")              // true
+"HELLO".lowerAscii()                 // "hello"
+"hello".upperAscii()                 // "HELLO"
+"  hi  ".trim()                      // "hi"
+"hello".substring(1)                 // "ello"
+"hello".substring(1, 3)              // "el"
+"hello".indexOf("l")                 // 2
+"hello".lastIndexOf("l")             // 3
+"hello".matches("[a-z]+")            // true (regex)
+"a,b,c".split(",")                   // ["a", "b", "c"]
+"a,b,c".split(",", 2)               // ["a", "b,c"]
+["a", "b"].join()                    // "ab"
+["a", "b"].join(", ")               // "a, b"
+```
+
+### Bytes methods
+```cel
+b"hello".string()                    // "hello" (UTF-8 decode)
+b"\xff".hex()                        // "ff"
+b"data".base64()                     // "ZGF0YQ=="
+b'{"a":1}'.json()                    // {"a": 1}
+b"hello".at(0)                       // 104
+size(b"hello")                       // 5
+```
+
+### Dates
+```cel
+date("2023-06-15")                   // create a Date
+date("2023-06-15T10:30:00Z")        // with time component
+
+// Comparisons:
+date("2023-01-01") < date("2024-01-01")   // true
+date("2023-01-01") == date("2023-01-01")  // true
+
+// 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
+
+// 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
+
+// Set specific fields:
+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
+
+// Format:
+d.format("yyyy-MM-dd")              // "2023-06-15"
+d.format("MMMM d, yyyy")           // "June 15, 2023"
+```
+
+## HTTP
+
+Build HTTP requests using the `http` builder. CEL expressions only *describe* a request — the host dispatches it. There is no way to send a request or read a response from CEL.
+
+### Creating requests
+```cel
+http.get("/api/users")           // GET request
+http.post("/api/users")          // POST request
+http.put("/api/users/1")         // PUT request
+http.patch("/api/users/1")       // PATCH request
+http.delete("/api/users/1")      // DELETE request
+```
+
+### Builder methods (chainable)
+```cel
+// Add headers:
+http.get("/api/users")
+  .header("Authorization", "Bearer token")
+  .header("Accept", "application/json")
+
+// Add query parameters:
+http.get("/api/users")
+  .query("page", "1")
+  .query("limit", "10")
+
+// Splat a record (e.g. a form) into query parameters.
+// null, undefined and "" values are skipped; arrays append one entry per item;
+// nested objects throw.
+http.get("/api/users")
+  .query(form)
+  .query("page", string(pageIndex))
+
+// Set request body (auto-serializes to JSON):
+http.post("/api/users")
+  .body({"name": "Alice", "email": "alice@example.com"})
+
+// Full example — the expression returns an HttpRequest; the host sends it:
+http.post("/api/users")
+  .header("Authorization", "Bearer " + token)
+  .body({"name": "Alice"})
+```
+
+## Macros
+
+Macros are special forms — they look like method calls but have special evaluation semantics.
+
+### map — Transform each element
+```cel
+[1, 2, 3].map(x, x * 2)                    // [2, 4, 6]
+[1, 2, 3, 4].map(x, x > 2, x * 10)         // [30, 40] (filter then transform)
+```
+
+### filter — Keep elements matching predicate
+```cel
+[1, 2, 3, 4, 5].filter(x, x > 3)           // [4, 5]
+```
+
+### all — True if ALL elements match
+```cel
+[1, 2, 3].all(x, x > 0)                    // true
+[1, -1, 3].all(x, x > 0)                   // false (short-circuits)
+```
+
+### exists — True if ANY element matches
+```cel
+[1, 2, 3].exists(x, x > 2)                 // true
+[1, 2, 3].exists(x, x > 5)                 // false
+```
+
+### exists_one — True if EXACTLY one element matches
+```cel
+[1, 2, 3].exists_one(x, x > 2)             // true (only 3)
+[1, 2, 3].exists_one(x, x > 1)             // false (2 and 3 both match)
+```
+
+### find — Return first element matching predicate as optional
+```cel
+[1, 2, 3].find(x, x > 1)                   // optional.of(2)
+[1, 2, 3].find(x, x > 5)                   // optional.none()
+[1, 2, 3].find(x, x > 1).orValue(0)        // 2
+[1, 2, 3].find(x, x > 5).orValue(0)        // 0
+```
+
+### has — Check if a field exists
+```cel
+has(obj.field)                               // true if field exists
+has(obj.nested.deep)                         // safe nested check
+```
+
+### cel.bind — Bind a variable to avoid repeated computation
+```cel
+cel.bind(total, price * quantity, total > 100 && total < 1000)
+```
+
+## Common Patterns
+
+### Conditional logic
+```cel
+age >= 18 ? "adult" : "minor"
+```
+
+### Null-safe access
+```cel
+has(user.address) && user.address.city == "NYC"
+```
+
+### List searching
+```cel
+items.exists(item, item.status == "active")
+items.filter(item, item.price > 100).size() > 0
+```
+
+### String matching
+```cel
+email.matches("^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,}$")
+```
+
+### Numeric comparisons
+```cel
+price * quantity >= 100.0
+values.all(v, v >= 0 && v <= 100)
+```
+
+### Map membership
+```cel
+"admin" in user.roles
+```
+
+## Things You Cannot Do
+
+- **No variables or assignments** — `x = 5` is invalid. CEL is a single expression.
+- **No loops** — Use `map`, `filter`, `all`, `exists` instead.
+- **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 imports or modules** — Everything available is already in scope.
+
+## Error Cases to Avoid
+
+- **Division/modulo by zero** — `10 / 0` and `10 % 0` throw errors.
+- **Index out of bounds** — `[1,2,3][5]` throws. Use `has()` or check `size()` first.
+- **Missing fields** — `obj.nonexistent` throws. Use `has(obj.nonexistent)` to check first.
+- **Type mismatches** — `1 + "2"` throws. Types must match for operators.
+- **Invalid regex** — `"x".matches("[invalid")` throws. Ensure regex is valid.

package/dist/runtime/vendor/cel-js/VENDORED

@@ -0,0 +1,3 @@
+Source: https://github.com/marcbachmann/cel-js
+Commit: d600a93110f1bfc63833e39a84de3086b382879b
+Date: 2026-03-31

package/dist/runtime/vendor/cel-js/__tests__/helpers.d.ts

@@ -0,0 +1,8 @@
+import { Environment } from '../lib/evaluator.js.js';
+import { Decimal } from '../lib/decimal.js.js';
+export declare class TestEnvironment extends Environment {
+    evalSync(expr: string, ctx?: Record<string, unknown>): unknown;
+}
+export declare function evalSync(expr: string, ctx?: Record<string, unknown>): unknown;
+export declare function expectDecimal(result: unknown, expected: number | bigint | string | Decimal): void;
+export declare const env: TestEnvironment;

package/dist/runtime/vendor/cel-js/__tests__/helpers.js

@@ -0,0 +1,18 @@
+import { Effect } from "effect";
+import { expect } from "vitest";
+import { Environment, evaluate } from "../lib/evaluator.js";
+import { Decimal } from "../lib/decimal.js";
+export class TestEnvironment extends Environment {
+  evalSync(expr, ctx) {
+    return Effect.runSync(this.evaluate(expr, ctx));
+  }
+}
+export function evalSync(expr, ctx) {
+  return Effect.runSync(evaluate(expr, ctx));
+}
+export function expectDecimal(result, expected) {
+  expect(result).toBeInstanceOf(Decimal);
+  const exp = Decimal.from(expected);
+  expect(result.eq(exp)).toBe(true);
+}
+export const env = new TestEnvironment({ unlistedVariablesAreDyn: true });

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

@@ -0,0 +1,31 @@
+type DecimalInput = number | bigint | string | Decimal;
+export declare class Decimal {
+    readonly sign: 1 | -1;
+    readonly coeff: bigint;
+    readonly exp: number;
+    constructor(sign: 1 | -1, coeff: bigint, exp: number);
+    static from(v: DecimalInput): Decimal;
+    isZero(): boolean;
+    isInteger(): boolean;
+    neg(): Decimal;
+    abs(): Decimal;
+    add(other: DecimalInput): Decimal;
+    sub(other: DecimalInput): Decimal;
+    mul(other: DecimalInput): Decimal;
+    div(other: DecimalInput, precision?: number): Decimal;
+    mod(other: DecimalInput): Decimal;
+    _digits(): number;
+    cmp(other: DecimalInput): -1 | 0 | 1;
+    eq(other: DecimalInput): boolean;
+    lt(other: DecimalInput): boolean;
+    lte(other: DecimalInput): boolean;
+    gt(other: DecimalInput): boolean;
+    gte(other: DecimalInput): boolean;
+    toNumber(): number;
+    valueOf(): number;
+    toString(): string;
+    toJSON(): number;
+    get [Symbol.toStringTag](): string;
+    [Symbol.toPrimitive](hint: string): string | number;
+}
+export {};

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

@@ -0,0 +1,208 @@
+const ZERO = 0n;
+const ONE = 1n;
+const TEN = 10n;
+const POW10 = [1n];
+function pow10(n) {
+  if (n < 0) return ONE;
+  while (POW10.length <= n) POW10.push(POW10[POW10.length - 1] * TEN);
+  return POW10[n];
+}
+function normalize(sign, coeff, exp) {
+  if (coeff === ZERO) return new Decimal(1, ZERO, 0);
+  while (coeff % TEN === ZERO) {
+    coeff /= TEN;
+    exp++;
+  }
+  return new Decimal(sign, coeff, exp);
+}
+function alignExp(a, b) {
+  const diff = a.exp - b.exp;
+  if (diff === 0) return [a.coeff, b.coeff, a.exp];
+  if (diff > 0) return [a.coeff * pow10(diff), b.coeff, b.exp];
+  return [a.coeff, b.coeff * pow10(-diff), a.exp];
+}
+function fromNumberString(s) {
+  if (s === "Infinity" || s === "+Infinity") return new Decimal(1, ZERO, 0);
+  if (s === "-Infinity") return new Decimal(-1, ZERO, 0);
+  if (s === "NaN") return new Decimal(1, ZERO, 0);
+  let sign = 1;
+  let i = 0;
+  if (s[0] === "-") {
+    sign = -1;
+    i = 1;
+  } else if (s[0] === "+") {
+    i = 1;
+  }
+  let mantissa, expPart = 0;
+  const eIdx = s.indexOf("e", i);
+  const EIdx = eIdx === -1 ? s.indexOf("E", i) : eIdx;
+  if (EIdx !== -1) {
+    mantissa = s.substring(i, EIdx);
+    expPart = Number(s.substring(EIdx + 1));
+  } else {
+    mantissa = s.substring(i);
+  }
+  const dotIdx = mantissa.indexOf(".");
+  let coeff, exp;
+  if (dotIdx === -1) {
+    coeff = BigInt(mantissa);
+    exp = expPart;
+  } else {
+    const intPart = mantissa.substring(0, dotIdx);
+    const fracPart = mantissa.substring(dotIdx + 1);
+    coeff = BigInt(intPart + fracPart);
+    exp = expPart - fracPart.length;
+  }
+  if (coeff === ZERO) return new Decimal(1, ZERO, 0);
+  return normalize(sign, coeff, exp);
+}
+export class Decimal {
+  sign;
+  coeff;
+  exp;
+  constructor(sign, coeff, exp) {
+    this.sign = sign;
+    this.coeff = coeff;
+    this.exp = exp;
+  }
+  static from(v) {
+    if (v instanceof Decimal) return v;
+    switch (typeof v) {
+      case "number": {
+        if (v === 0) return new Decimal(1, ZERO, 0);
+        if (!Number.isFinite(v)) return new Decimal(v < 0 ? -1 : 1, ZERO, 0);
+        return fromNumberString(String(v));
+      }
+      case "bigint": {
+        if (v === ZERO) return new Decimal(1, ZERO, 0);
+        const sign = v < ZERO ? -1 : 1;
+        return normalize(sign, v < ZERO ? -v : v, 0);
+      }
+      case "string": {
+        const s = v.trim();
+        if (!s) throw new Error("Cannot convert empty string to Decimal");
+        return fromNumberString(s);
+      }
+      default:
+        throw new Error(`Cannot convert ${typeof v} to Decimal`);
+    }
+  }
+  isZero() {
+    return this.coeff === ZERO;
+  }
+  isInteger() {
+    return this.exp >= 0;
+  }
+  neg() {
+    if (this.coeff === ZERO) return this;
+    return new Decimal(this.sign === 1 ? -1 : 1, this.coeff, this.exp);
+  }
+  abs() {
+    return this.sign === -1 ? this.neg() : this;
+  }
+  add(other) {
+    const o = Decimal.from(other);
+    if (this.isZero()) return o;
+    if (o.isZero()) return this;
+    const [ac, bc, exp] = alignExp(this, o);
+    const a = this.sign === 1 ? ac : -ac;
+    const b = o.sign === 1 ? bc : -bc;
+    const sum = a + b;
+    if (sum === ZERO) return new Decimal(1, ZERO, 0);
+    const sign = sum < ZERO ? -1 : 1;
+    return normalize(sign, sum < ZERO ? -sum : sum, exp);
+  }
+  sub(other) {
+    return this.add(Decimal.from(other).neg());
+  }
+  mul(other) {
+    const o = Decimal.from(other);
+    if (this.isZero() || o.isZero()) return new Decimal(1, ZERO, 0);
+    const sign = this.sign === o.sign ? 1 : -1;
+    return normalize(sign, this.coeff * o.coeff, this.exp + o.exp);
+  }
+  div(other, precision = 20) {
+    const o = Decimal.from(other);
+    if (o.isZero()) throw new Error("Division by zero");
+    if (this.isZero()) return new Decimal(1, ZERO, 0);
+    const sign = this.sign === o.sign ? 1 : -1;
+    const scale = precision + o._digits() - this._digits() + 1;
+    const num = scale > 0 ? this.coeff * pow10(scale) : this.coeff;
+    const quot = num / o.coeff;
+    const exp = this.exp - o.exp - (scale > 0 ? scale : 0);
+    return normalize(sign, quot, exp);
+  }
+  mod(other) {
+    const o = Decimal.from(other);
+    if (o.isZero()) throw new Error("Modulo by zero");
+    if (this.isZero()) return new Decimal(1, ZERO, 0);
+    const [ac, bc, exp] = alignExp(this, o);
+    const sa = this.sign === 1 ? ac : -ac;
+    const sb = o.sign === 1 ? bc : -bc;
+    const rem = sa % sb;
+    if (rem === ZERO) return new Decimal(1, ZERO, 0);
+    const sign = rem < ZERO ? -1 : 1;
+    return normalize(sign, rem < ZERO ? -rem : rem, exp);
+  }
+  _digits() {
+    if (this.coeff === ZERO) return 1;
+    return this.coeff.toString().length;
+  }
+  cmp(other) {
+    const o = Decimal.from(other);
+    if (this.isZero() && o.isZero()) return 0;
+    if (this.sign !== o.sign) return this.sign > o.sign ? 1 : -1;
+    const [ac, bc] = alignExp(this, o);
+    if (ac === bc) return 0;
+    const raw = ac > bc ? 1 : -1;
+    return this.sign === 1 ? raw : -raw;
+  }
+  eq(other) {
+    return this.cmp(other) === 0;
+  }
+  lt(other) {
+    return this.cmp(other) < 0;
+  }
+  lte(other) {
+    return this.cmp(other) <= 0;
+  }
+  gt(other) {
+    return this.cmp(other) > 0;
+  }
+  gte(other) {
+    return this.cmp(other) >= 0;
+  }
+  toNumber() {
+    if (this.isZero()) return 0;
+    return Number(this.toString());
+  }
+  valueOf() {
+    return this.toNumber();
+  }
+  toString() {
+    if (this.isZero()) return "0";
+    const digits = this.coeff.toString();
+    const sign = this.sign === -1 ? "-" : "";
+    if (this.exp >= 0) {
+      return sign + digits + "0".repeat(this.exp);
+    }
+    const decimalPos = digits.length + this.exp;
+    if (decimalPos <= 0) {
+      return sign + "0." + "0".repeat(-decimalPos) + digits;
+    }
+    return sign + digits.substring(0, decimalPos) + "." + digits.substring(decimalPos);
+  }
+  toJSON() {
+    return this.toNumber();
+  }
+  get [Symbol.toStringTag]() {
+    return "Decimal";
+  }
+  [Symbol.for("nodejs.util.inspect.custom")]() {
+    return `Decimal { ${this.toString()} }`;
+  }
+  [Symbol.toPrimitive](hint) {
+    if (hint === "string") return this.toString();
+    return this.toNumber();
+  }
+}

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

@@ -0,0 +1,50 @@
+interface ErrorNode {
+    input?: string;
+    pos?: number;
+    start?: number;
+    end?: number;
+    op?: string;
+    args?: unknown;
+}
+interface SourceRange {
+    start: number;
+    end: number;
+}
+interface CelErrorOptions {
+    name: string;
+    code: string;
+    message: string;
+    node?: ErrorNode;
+    cause?: unknown;
+    range?: SourceRange;
+}
+interface ErrorShorthandOptions {
+    code?: string;
+    message: string;
+    node?: ErrorNode;
+    cause?: unknown;
+    range?: SourceRange;
+}
+export declare class CelError extends Error {
+    #private;
+    constructor({ name, code, message, node, cause, range }: CelErrorOptions);
+    get node(): ErrorNode | undefined;
+    get code(): string;
+    get range(): SourceRange | undefined;
+    get summary(): string;
+    withAst(node: ErrorNode): this;
+}
+export declare class ParseError extends CelError {
+    constructor(message: string | ErrorShorthandOptions, node?: ErrorNode, cause?: unknown);
+}
+export declare class EvaluationError extends CelError {
+    constructor(message: string | ErrorShorthandOptions, node?: ErrorNode, cause?: unknown);
+}
+export declare class TypeError extends CelError {
+    constructor(message: string | ErrorShorthandOptions, node?: ErrorNode, cause?: unknown);
+}
+export declare function parseError(code: string | ErrorShorthandOptions, message?: string, node?: ErrorNode): ParseError;
+export declare function evaluationError(code: string | ErrorShorthandOptions, message?: string, node?: ErrorNode): EvaluationError;
+export declare function typeError(code: string | ErrorShorthandOptions, message?: string, node?: ErrorNode): TypeError;
+export declare function attachErrorAst(error: unknown, node: ErrorNode): unknown;
+export {};