@shwfed/config 2.0.0 → 2.0.1

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

@@ -0,0 +1,402 @@
+import { evaluationError } from "./errors.js";
+import { Decimal } from "./decimal.js";
+import { TYPES, Type } from "./registry.js";
+import { register as registerOptional } from "./optional.js";
+import { objKeys, arrayFrom } from "./globals.js";
+import { TZDate } from "@date-fns/tz";
+import { startOfDay, startOfWeek, startOfMonth, startOfYear, endOfDay, endOfWeek, endOfMonth, endOfYear, addDays, addWeeks, addMonths, addYears, addHours, addMinutes, setDate as setDayOfMonth, setMonth, setYear, format as formatDate } from "date-fns";
+function toNum(v) {
+  if (v instanceof Decimal) return v.toNumber();
+  if (typeof v === "bigint") return Number(v);
+  return v;
+}
+export function registerFunctions(registry) {
+  const sync = { async: false };
+  const functionOverload = (sig, handler) => registry.registerFunctionOverload(sig, handler, sync);
+  const identity = (v) => v;
+  functionOverload("dyn(dyn): dyn", identity);
+  for (const _t in TYPES) {
+    const type = TYPES[_t];
+    if (!(type instanceof Type)) continue;
+    functionOverload(`type(${type.name}): type`, () => type);
+  }
+  functionOverload("bool(bool): bool", identity);
+  functionOverload("bool(string): bool", (v) => {
+    switch (v) {
+      case "1":
+      case "t":
+      case "true":
+      case "TRUE":
+      case "True":
+        return true;
+      case "0":
+      case "f":
+      case "false":
+      case "FALSE":
+      case "False":
+        return false;
+      default:
+        throw evaluationError(
+          "bool_conversion_error",
+          `bool() conversion error: invalid string value "${v}"`
+        );
+    }
+  });
+  functionOverload("size(string): number", (v) => Decimal.from(stringSize(v)));
+  functionOverload("size(bytes): number", (v) => Decimal.from(v.length));
+  functionOverload("size(list): number", (v) => Decimal.from(v.length ?? v.size));
+  functionOverload("size(map): number", (v) => Decimal.from(v instanceof Map ? v.size : objKeys(v).length));
+  functionOverload("string.size(): number", (v) => Decimal.from(stringSize(v)));
+  functionOverload("bytes.size(): number", (v) => Decimal.from(v.length));
+  functionOverload("list.size(): number", (v) => Decimal.from(v.length ?? v.size));
+  functionOverload("map.size(): number", (v) => Decimal.from(v instanceof Map ? v.size : objKeys(v).length));
+  functionOverload("bytes(string): bytes", (v) => ByteOpts.fromString(v));
+  functionOverload("bytes(bytes): bytes", identity);
+  functionOverload("number(number): number", (v) => Decimal.from(v));
+  functionOverload("number(string): number", (v) => {
+    const s = v;
+    if (!s || s !== s.trim())
+      throw evaluationError(
+        "number_conversion_error",
+        "number() type error: cannot convert to number"
+      );
+    try {
+      return Decimal.from(s);
+    } catch {
+      throw evaluationError(
+        "number_conversion_error",
+        "number() type error: cannot convert to number"
+      );
+    }
+  });
+  functionOverload("number(bool): number", (v) => Decimal.from(v ? 1 : 0));
+  functionOverload("int(number): number", (v) => {
+    const d = Decimal.from(v);
+    if (d.isInteger()) return d;
+    const n = d.toNumber();
+    if (!Number.isFinite(n)) throw evaluationError("numeric_overflow", "int() type error: integer overflow");
+    return Decimal.from(BigInt(Math.trunc(n)));
+  });
+  functionOverload("int(string): number", (v) => {
+    const s = v;
+    if (s !== s.trim() || s.length > 20 || s.includes("0x")) {
+      throw evaluationError("int_conversion_error", "int() type error: cannot convert to int");
+    }
+    try {
+      return Decimal.from(s);
+    } catch {
+      throw evaluationError("int_conversion_error", "int() type error: cannot convert to int");
+    }
+  });
+  functionOverload("double(number): number", (v) => Decimal.from(v));
+  functionOverload("double(string): number", (v) => {
+    const s = v;
+    if (!s || s !== s.trim())
+      throw evaluationError(
+        "double_conversion_error",
+        "double() type error: cannot convert to double"
+      );
+    try {
+      return Decimal.from(s);
+    } catch {
+      throw evaluationError(
+        "double_conversion_error",
+        "double() type error: cannot convert to double"
+      );
+    }
+  });
+  functionOverload("uint(number): number", (v) => Decimal.from(v));
+  functionOverload("uint(string): number", (v) => {
+    const s = v;
+    if (s !== s.trim() || s.length > 20 || s.includes("0x")) {
+      throw evaluationError("uint_conversion_error", "uint() type error: cannot convert to uint");
+    }
+    try {
+      return Decimal.from(s);
+    } catch {
+      throw evaluationError("uint_conversion_error", "uint() type error: cannot convert to uint");
+    }
+  });
+  functionOverload("string(string): string", identity);
+  functionOverload("string(bool): string", (v) => `${v}`);
+  functionOverload("string(number): string", (v) => Decimal.from(v).toString());
+  functionOverload("string(bytes): string", (v) => ByteOpts.toUtf8(v));
+  functionOverload("string.startsWith(string): bool", (a, b) => a.startsWith(b));
+  functionOverload("string.endsWith(string): bool", (a, b) => a.endsWith(b));
+  functionOverload("string.contains(string): bool", (a, b) => a.includes(b));
+  functionOverload("string.lowerAscii(): string", (a) => a.toLowerCase());
+  functionOverload("string.upperAscii(): string", (a) => a.toUpperCase());
+  functionOverload("string.trim(): string", (a) => a.trim());
+  functionOverload(
+    "string.indexOf(string): number",
+    (string, search) => Decimal.from(string.indexOf(search))
+  );
+  functionOverload("string.indexOf(string, number): number", (string, search, fromIndex) => {
+    if (search === "") return fromIndex;
+    const from = toNum(fromIndex);
+    const str = string;
+    if (from < 0 || from >= str.length) {
+      throw evaluationError(
+        "index_out_of_range",
+        "string.indexOf(search, fromIndex): fromIndex out of range"
+      );
+    }
+    return Decimal.from(str.indexOf(search, from));
+  });
+  functionOverload(
+    "string.lastIndexOf(string): number",
+    (string, search) => Decimal.from(string.lastIndexOf(search))
+  );
+  functionOverload("string.lastIndexOf(string, number): number", (string, search, fromIndex) => {
+    if (search === "") return fromIndex;
+    const from = toNum(fromIndex);
+    const str = string;
+    if (from < 0 || from >= str.length) {
+      throw evaluationError(
+        "index_out_of_range",
+        "string.lastIndexOf(search, fromIndex): fromIndex out of range"
+      );
+    }
+    return Decimal.from(str.lastIndexOf(search, from));
+  });
+  functionOverload("string.substring(number): string", (string, start) => {
+    const startNum = toNum(start);
+    const str = string;
+    if (startNum < 0 || startNum > str.length) {
+      throw evaluationError(
+        "index_out_of_range",
+        "string.substring(start, end): start index out of range"
+      );
+    }
+    return str.substring(startNum);
+  });
+  functionOverload("string.substring(number, number): string", (string, start, end) => {
+    const startNum = toNum(start);
+    const str = string;
+    if (startNum < 0 || startNum > str.length) {
+      throw evaluationError(
+        "index_out_of_range",
+        "string.substring(start, end): start index out of range"
+      );
+    }
+    const endNum = toNum(end);
+    if (endNum < startNum || endNum > str.length) {
+      throw evaluationError(
+        "index_out_of_range",
+        "string.substring(start, end): end index out of range"
+      );
+    }
+    return str.substring(startNum, endNum);
+  });
+  functionOverload("string.matches(string): bool", (a, b) => {
+    try {
+      return new RegExp(b).test(a);
+    } catch {
+      throw evaluationError("invalid_regular_expression", `Invalid regular expression: ${b}`);
+    }
+  });
+  functionOverload("string.split(string): list<string>", (s, sep) => s.split(sep));
+  functionOverload("string.split(string, number): list<string>", (s, sep, l) => {
+    const limit = toNum(l);
+    if (limit === 0) return [];
+    const parts = s.split(sep);
+    if (limit < 0 || parts.length <= limit) return parts;
+    const limited = parts.slice(0, limit - 1);
+    limited.push(parts.slice(limit - 1).join(sep));
+    return limited;
+  });
+  functionOverload("list<string>.join(): string", (v) => {
+    const arr = v;
+    for (let i = 0; i < arr.length; i++) {
+      if (typeof arr[i] !== "string") {
+        throw evaluationError(
+          "invalid_list_element_type",
+          "string.join(): list must contain only strings"
+        );
+      }
+    }
+    return arr.join("");
+  });
+  functionOverload("list<string>.join(string): string", (v, sep) => {
+    const arr = v;
+    for (let i = 0; i < arr.length; i++) {
+      if (typeof arr[i] !== "string") {
+        throw evaluationError(
+          "invalid_list_element_type",
+          "string.join(separator): list must contain only strings"
+        );
+      }
+    }
+    return arr.join(sep);
+  });
+  const textEncoder = new TextEncoder();
+  const textDecoder = new TextDecoder("utf8");
+  const ByteOpts = typeof Buffer !== "undefined" ? {
+    byteLength: (v) => Buffer.byteLength(v),
+    fromString: (str) => Buffer.from(str, "utf8"),
+    toHex: (b) => Buffer.prototype.hexSlice.call(b, 0, b.length),
+    toBase64: (b) => Buffer.prototype.base64Slice.call(b, 0, b.length),
+    toUtf8: (b) => Buffer.prototype.utf8Slice.call(b, 0, b.length),
+    jsonParse: (b) => JSON.parse(b)
+  } : {
+    textEncoder: new TextEncoder(),
+    byteLength: (v) => textEncoder.encode(v).length,
+    fromString: (str) => textEncoder.encode(str),
+    toHex: typeof Uint8Array.prototype.toHex === "function" ? (b) => b.toHex() : (b) => arrayFrom(b, (i) => i.toString(16).padStart(2, "0")).join(""),
+    toBase64: typeof Uint8Array.prototype.toBase64 === "function" ? (b) => b.toBase64() : (b) => btoa(arrayFrom(b, (i) => String.fromCodePoint(i)).join("")),
+    toUtf8: (b) => textDecoder.decode(b),
+    jsonParse: (b) => JSON.parse(textDecoder.decode(b))
+  };
+  functionOverload("bytes.json(): map", ByteOpts.jsonParse);
+  functionOverload("bytes.hex(): string", ByteOpts.toHex);
+  functionOverload("bytes.string(): string", ByteOpts.toUtf8);
+  functionOverload("bytes.base64(): string", ByteOpts.toBase64);
+  functionOverload("bytes.at(number): number", (b, index) => {
+    const idx = toNum(index);
+    const buf = b;
+    if (idx < 0 || idx >= buf.length) {
+      throw evaluationError("index_out_of_range", "Bytes index out of range");
+    }
+    return Decimal.from(buf[idx]);
+  });
+  function wrapTZ(result, source) {
+    if (result instanceof TZDate) return result;
+    return new TZDate(result.getTime(), source.timeZone);
+  }
+  registry.registerType("Date", TZDate);
+  functionOverload("date(string): Date", (v) => {
+    const d = new TZDate(v);
+    if (Number.isNaN(d.getTime())) throw evaluationError("invalid_date", `date() requires a valid date string, got "${v}"`);
+    return d;
+  });
+  functionOverload("date(number): Date", (v) => {
+    const n = toNum(v);
+    if (!Number.isFinite(n)) {
+      throw evaluationError("invalid_date", `date() requires a finite timestamp, got ${v}`);
+    }
+    const ms = Math.abs(n) < 1e11 ? n * 1e3 : n;
+    const d = new TZDate(ms);
+    if (Number.isNaN(d.getTime())) {
+      throw evaluationError("invalid_date", `date() got an out-of-range timestamp: ${v}`);
+    }
+    return d;
+  });
+  const RANGE_LIMIT = 1e5;
+  function numericRange(startD, endD, stepD) {
+    const step = stepD.toNumber();
+    if (!(step > 0)) {
+      throw evaluationError("invalid_range", `range(): step must be greater than 0, got ${step}`);
+    }
+    const end = endD.toNumber();
+    const ascending = startD.toNumber() < end;
+    const delta = ascending ? stepD : stepD.neg();
+    const out = [];
+    let cur = startD;
+    while (ascending ? cur.toNumber() < end : cur.toNumber() > end) {
+      out.push(cur);
+      if (out.length > RANGE_LIMIT) {
+        throw evaluationError("range_too_large", `range(): exceeded the ${RANGE_LIMIT}-item limit`);
+      }
+      cur = cur.add(delta);
+    }
+    return out;
+  }
+  functionOverload("range(number, number): list<dyn>", (start, end) => numericRange(start, end, Decimal.from(1)));
+  functionOverload("range(number, number, number): list<dyn>", (start, end, step) => numericRange(start, end, step));
+  const rangeSteppers = {
+    year: addYears,
+    month: addMonths,
+    day: addDays,
+    hour: addHours,
+    minute: addMinutes
+  };
+  functionOverload("range(Date, Date, string): list<dyn>", (startV, endV, unitV) => {
+    const start = startV;
+    const stepFn = rangeSteppers[unitV];
+    if (!stepFn) {
+      throw evaluationError("invalid_unit", `range(): unknown unit "${unitV}" (expected year / month / day / hour / minute)`);
+    }
+    const endMs = endV.getTime();
+    const ascending = start.getTime() < endMs;
+    const out = [];
+    let cur = start;
+    while (ascending ? cur.getTime() < endMs : cur.getTime() > endMs) {
+      out.push(cur);
+      if (out.length > RANGE_LIMIT) {
+        throw evaluationError("range_too_large", `range(): exceeded the ${RANGE_LIMIT}-item limit`);
+      }
+      cur = wrapTZ(stepFn(cur, ascending ? 1 : -1), start);
+    }
+    return out;
+  });
+  functionOverload("Date.startOf(string): Date", (d, unit) => {
+    const date = d;
+    switch (unit) {
+      case "day":
+        return wrapTZ(startOfDay(date), date);
+      case "week":
+        return wrapTZ(startOfWeek(date), date);
+      case "month":
+        return wrapTZ(startOfMonth(date), date);
+      case "year":
+        return wrapTZ(startOfYear(date), date);
+      default:
+        throw evaluationError("invalid_unit", `startOf(): unknown unit "${unit}"`);
+    }
+  });
+  functionOverload("Date.endOf(string): Date", (d, unit) => {
+    const date = d;
+    switch (unit) {
+      case "day":
+        return wrapTZ(endOfDay(date), date);
+      case "week":
+        return wrapTZ(endOfWeek(date), date);
+      case "month":
+        return wrapTZ(endOfMonth(date), date);
+      case "year":
+        return wrapTZ(endOfYear(date), date);
+      default:
+        throw evaluationError("invalid_unit", `endOf(): unknown unit "${unit}"`);
+    }
+  });
+  functionOverload("Date.offset(number, string): Date", (d, n, unit) => {
+    const date = d;
+    const num = toNum(n);
+    switch (unit.replace(/s$/, "")) {
+      case "day":
+        return wrapTZ(addDays(date, num), date);
+      case "week":
+        return wrapTZ(addWeeks(date, num), date);
+      case "month":
+        return wrapTZ(addMonths(date, num), date);
+      case "year":
+        return wrapTZ(addYears(date, num), date);
+      default:
+        throw evaluationError("invalid_unit", `offset(): unknown unit "${unit}"`);
+    }
+  });
+  functionOverload("Date.set(string, number): Date", (d, field, value) => {
+    const date = d;
+    const val = toNum(value);
+    switch (field) {
+      case "day":
+        return wrapTZ(setDayOfMonth(date, val), date);
+      case "month":
+        return wrapTZ(setMonth(date, val - 1), date);
+      case "year":
+        return wrapTZ(setYear(date, val), date);
+      default:
+        throw evaluationError("invalid_field", `set(): unknown field "${field}"`);
+    }
+  });
+  functionOverload("Date.format(string): string", (d, fmt) => formatDate(d, fmt));
+  registry.registerType("File", File);
+  registry.registerType("URL", URL);
+  functionOverload("URL.param(string): string", (url, key) => url.searchParams.get(key) ?? "");
+  registerOptional(registry);
+}
+function stringSize(str) {
+  let count = 0;
+  for (const _ of str) count++;
+  return count;
+}

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

@@ -0,0 +1,27 @@
+export declare const hasOwn: (o: object, v: PropertyKey) => boolean;
+export declare const objKeys: {
+    (o: object): string[];
+    (o: {}): string[];
+};
+export declare const objFreeze: {
+    <T extends Function>(f: T): T;
+    <T extends {
+        [idx: string]: U | null | undefined | object;
+    }, U extends string | bigint | number | boolean | symbol>(o: T): Readonly<T>;
+    <T>(o: T): Readonly<T>;
+};
+export declare const objEntries: {
+    <T>(o: {
+        [s: string]: T;
+    } | ArrayLike<T>): [string, T][];
+    (o: {}): [string, any][];
+};
+export declare const isArray: (arg: any) => arg is any[];
+export declare const arrayFrom: {
+    <T>(arrayLike: ArrayLike<T>): T[];
+    <T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+    <T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+    <T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+};
+export declare function isAsync(fn: Function | undefined | null, fallback?: boolean): boolean;
+export declare const RESERVED: Set<string>;

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

@@ -0,0 +1,31 @@
+export const hasOwn = Object.hasOwn;
+export const objKeys = Object.keys;
+export const objFreeze = Object.freeze;
+export const objEntries = Object.entries;
+export const isArray = Array.isArray;
+export const arrayFrom = Array.from;
+export function isAsync(fn, fallback) {
+  if (fn?.[Symbol.toStringTag] === "AsyncFunction") return true;
+  return typeof fallback === "boolean" ? fallback : true;
+}
+export const RESERVED = /* @__PURE__ */ new Set([
+  "as",
+  "break",
+  "const",
+  "continue",
+  "else",
+  "for",
+  "function",
+  "if",
+  "import",
+  "let",
+  "loop",
+  "package",
+  "namespace",
+  "return",
+  "var",
+  "void",
+  "while",
+  "__proto__",
+  "prototype"
+]);

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

@@ -0,0 +1,35 @@
+/**
+ * `HttpRequestBuilder` — the value an `http.*` CEL expression evaluates to.
+ *
+ * A local (non-upstream) extension. CEL only *describes* a request; the host
+ * dispatches it by calling `.json()` / `.file()` on the returned builder.
+ *
+ * Endpoints are used verbatim — there is no base-URL resolution, so callers
+ * must pass absolute URLs.
+ */
+import { Effect } from 'effect';
+import { Fetch } from 'fx-fetch';
+export declare class HttpRequestBuilder {
+    #private;
+    constructor(url: string, method: string);
+    header(name: string, value: string): this;
+    query(key: string, value: string | number): this;
+    query(record: Record<string, unknown>): this;
+    body(data: FormData | unknown): this;
+    /**
+     * A structural snapshot of the request this builder will issue — an equal
+     * snapshot means an equal HTTP request. Handy for change-detection, e.g.
+     * deciding whether a refetch is warranted. Non-string bodies (`FormData`,
+     * `Blob`, `ArrayBuffer`) collapse to a `'[binary]'` marker, so equal
+     * snapshots do not guarantee equal bodies in that case.
+     */
+    describe(): {
+        url: string;
+        method: string;
+        headers: ReadonlyArray<readonly [string, string]>;
+        queries: ReadonlyArray<readonly [string, string]>;
+        body: string | null;
+    };
+    json(): Effect.Effect<unknown, import("fx-fetch/Cause").MalformedJsonError | Fetch.Fetch.ErrorType, Fetch.Fetch>;
+    file(): Effect.Effect<File, Fetch.Fetch.ErrorType | import("fx-fetch/Cause").MalformedBlobError, Fetch.Fetch>;
+}

package/dist/runtime/vendor/cel-js/lib/http-builder.js

@@ -0,0 +1,111 @@
+import { Effect } from "effect";
+import {
+  Fetch,
+  Request as FxRequest,
+  Response as FxResponse
+} from "fx-fetch";
+function extractFilename(response, url) {
+  const disposition = FxResponse.getHeader(response, "content-disposition");
+  if (disposition) {
+    const match = disposition[0]?.match(/filename\*?=(?:UTF-8''|")?([^";]+)"?/i);
+    if (match?.[1]) return decodeURIComponent(match[1]);
+  }
+  const path = new URL(url).pathname;
+  return path.slice(path.lastIndexOf("/") + 1) || "download";
+}
+export class HttpRequestBuilder {
+  #url;
+  #method;
+  #headers = [];
+  #queries = [];
+  #body;
+  constructor(url, method) {
+    this.#url = url;
+    this.#method = method;
+  }
+  header(name, value) {
+    this.#headers.push([name, value]);
+    return this;
+  }
+  query(keyOrRecord, value) {
+    if (typeof keyOrRecord === "string") {
+      this.#queries.push([keyOrRecord, String(value)]);
+      return this;
+    }
+    for (const [k, v] of Object.entries(keyOrRecord)) {
+      this.#appendQueryValue(k, v);
+    }
+    return this;
+  }
+  #appendQueryValue(key, value) {
+    if (value === null || value === void 0 || value === "") return;
+    if (typeof value === "string") {
+      this.#queries.push([key, value]);
+      return;
+    }
+    if (typeof value === "number" || typeof value === "boolean" || typeof value === "bigint") {
+      this.#queries.push([key, String(value)]);
+      return;
+    }
+    if (Array.isArray(value)) {
+      for (const item of value) this.#appendQueryValue(key, item);
+      return;
+    }
+    throw new Error(`query: nested object values are not supported (key: "${key}")`);
+  }
+  body(data) {
+    this.#body = data instanceof FormData || data instanceof Blob || data instanceof ArrayBuffer || typeof data === "string" ? data : JSON.stringify(data);
+    if (!(data instanceof FormData || data instanceof Blob || data instanceof ArrayBuffer || typeof data === "string")) {
+      this.#headers.push(["Content-Type", "application/json"]);
+    }
+    return this;
+  }
+  /**
+   * A structural snapshot of the request this builder will issue — an equal
+   * snapshot means an equal HTTP request. Handy for change-detection, e.g.
+   * deciding whether a refetch is warranted. Non-string bodies (`FormData`,
+   * `Blob`, `ArrayBuffer`) collapse to a `'[binary]'` marker, so equal
+   * snapshots do not guarantee equal bodies in that case.
+   */
+  describe() {
+    return {
+      url: this.#url,
+      method: this.#method,
+      headers: this.#headers.map(([k, v]) => [k, v]),
+      queries: this.#queries.map(([k, v]) => [k, v]),
+      body: typeof this.#body === "string" ? this.#body : this.#body === void 0 ? null : "[binary]"
+    };
+  }
+  json() {
+    return Fetch.fetchJson(this.#buildRequest());
+  }
+  file() {
+    const url = this.#url;
+    const request = this.#buildRequest();
+    return Effect.gen(function* () {
+      const response = yield* Fetch.fetch(request);
+      yield* FxResponse.ensureOk(response);
+      const blob = yield* FxResponse.readBlob(response);
+      return new File([blob], extractFilename(response, url));
+    });
+  }
+  #buildRequest() {
+    const parts = {
+      url: this.#url,
+      method: this.#method
+    };
+    if (this.#headers.length > 0) {
+      const headers = {};
+      for (const [k, v] of this.#headers) headers[k] = v;
+      parts.headers = headers;
+    }
+    if (this.#body !== void 0) {
+      parts.body = this.#body;
+    }
+    let request = FxRequest.unsafeMake(parts);
+    for (const [k, v] of this.#queries) {
+      request = FxRequest.appendUrlSearchParam(request, k, v);
+    }
+    return request;
+  }
+}

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

@@ -0,0 +1,15 @@
+/**
+ * HTTP built-ins for CEL — a local (non-upstream) extension.
+ *
+ * Registers the `http` / `HttpRequest` types, the `http` constant, and the
+ * request-builder functions on the registry. A CEL expression only *describes*
+ * a request — `http.get(url).header(...).body(...)` evaluates to an
+ * `HttpRequestBuilder`; the host dispatches it via `.json()` / `.file()`.
+ *
+ * Wired into `globalRegistry` at module load (see `evaluator.ts`), so every
+ * `Environment` gets HTTP for free — both type-checking and evaluation.
+ *
+ * Endpoints must be absolute URLs; there is no base-URL resolution.
+ */
+import type { Registry } from './registry.js.js';
+export declare function registerHttpBuiltins(registry: Registry): void;

package/dist/runtime/vendor/cel-js/lib/http-builtins.js

@@ -0,0 +1,55 @@
+import { HttpRequestBuilder } from "./http-builder.js";
+class Http {
+  brand = "http";
+}
+const HTTP_INSTANCE = new Http();
+export function registerHttpBuiltins(registry) {
+  registry.registerType("http", Http);
+  registry.registerType("HttpRequest", HttpRequestBuilder);
+  registry.registerVariable({
+    name: "http",
+    type: "http",
+    value: HTTP_INSTANCE,
+    description: "HTTP \u5BA2\u6237\u7AEF"
+  });
+  registry.registerFunctionOverload(
+    "http.get(string): HttpRequest",
+    (_r, url) => new HttpRequestBuilder(url, "GET")
+  );
+  registry.registerFunctionOverload(
+    "http.post(string): HttpRequest",
+    (_r, url) => new HttpRequestBuilder(url, "POST")
+  );
+  registry.registerFunctionOverload(
+    "http.put(string): HttpRequest",
+    (_r, url) => new HttpRequestBuilder(url, "PUT")
+  );
+  registry.registerFunctionOverload(
+    "http.patch(string): HttpRequest",
+    (_r, url) => new HttpRequestBuilder(url, "PATCH")
+  );
+  registry.registerFunctionOverload(
+    "http.delete(string): HttpRequest",
+    (_r, url) => new HttpRequestBuilder(url, "DELETE")
+  );
+  registry.registerFunctionOverload(
+    "HttpRequest.header(string, string): HttpRequest",
+    (b, k, v) => b.header(k, v)
+  );
+  registry.registerFunctionOverload(
+    "HttpRequest.query(string, string): HttpRequest",
+    (b, k, v) => b.query(k, v)
+  );
+  registry.registerFunctionOverload(
+    "HttpRequest.query(string, number): HttpRequest",
+    (b, k, v) => b.query(k, Number(v))
+  );
+  registry.registerFunctionOverload(
+    "HttpRequest.query(dyn): HttpRequest",
+    (b, record) => b.query(record)
+  );
+  registry.registerFunctionOverload(
+    "HttpRequest.body(dyn): HttpRequest",
+    (b, data) => b.body(data)
+  );
+}

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

@@ -0,0 +1,3 @@
+import { Environment } from './evaluator.js.js';
+import { ParseError, EvaluationError, TypeError } from './errors.js.js';
+export { Environment, ParseError, EvaluationError, TypeError };

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

@@ -0,0 +1,3 @@
+import { Environment } from "./evaluator.js";
+import { ParseError, EvaluationError, TypeError } from "./errors.js";
+export { Environment, ParseError, EvaluationError, TypeError };