@shwfed/config 2.2.0 → 2.2.2

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

@@ -20,7 +20,9 @@ The `homogeneousAggregateLiterals` and `enableOptionalTypes` environment options
 
 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).
 
-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. Both terminal methods, `.json()` and `.file()`, are dispatched by the host on the returned builder (neither is a CEL method), so expression evaluation stays free of IO. Endpoints must be absolute URLs — there is no base-URL resolution. Depends on `fx-fetch`.
+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. Both terminal methods, `.json()` and `.file()`, are dispatched by the host on the returned builder (neither is a CEL method), so expression evaluation stays free of IO. 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.
+
+Spread syntax (`...expr`) inside list and map literals — not from upstream. A new `ELLIPSIS` token (3-char lookahead in the lexer) and a `spread` AST op let `[1, ...a, 4]` and `{...a, "x": 1, ...b}` desugar inside the parent literal. The spread node's own `check`/`evaluate` are defensive stubs — `parsePrimary` never produces one, so `...` outside a list/map is an "unexpected token" parse error. List `args` shape is unchanged (`IASTNode[]`, with spread elements detected via `op === 'spread'`); map `args` becomes `([IASTNode, IASTNode] | [IASTNode])[]` — a length-1 tuple represents a spread entry, preserving positional ordering for override semantics (later writes win). The fast path is preserved: the `list`/`map` `check` swaps `evaluate` meta to `evaluateSpreadList`/`evaluateSpreadMap` only when a spread child is present; literals without spreads run the original `resolveAstArray`/`safeFromEntries` paths byte-for-byte. Spread map sources may be plain objects, `Map` instances, or registered message types (typed as `map<string, dyn>`); the `__proto__`/`constructor`/`prototype` skip from `safeFromEntries` is applied to spread sources too. Runtime errors fire on non-list/non-map sources (including `null`). `maxListElements` / `maxMapEntries` count a spread as one entry — runtime expansion bypasses those caps (deliberate trade-off). Call-argument spread (`f(...args)`) is **not** supported.
 
 ## Architecture
 

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

@@ -67,6 +67,26 @@ condition ? value_if_true : value_if_false
 [1, 2] + [3, 4]            // [1, 2, 3, 4]
 ```
 
+### Spread (`...expr`)
+A spread inlines another list inside a list literal or another map inside a
+map literal. Order is preserved — a later entry (including a later spread)
+overrides an earlier one when keys collide.
+```cel
+[1, ...a, 4]                 // a flattens in position
+[...a, ...b]                 // equivalent to a + b
+
+{...a, "x": 1}               // copy a, then set x to 1
+{"x": 1, ...a}               // set x, then let a override
+{...a, ...b}                 // b overrides a on overlapping keys
+{...a, "x": 1, ...b}         // a, then x, then b — last write wins
+
+[...[1, 2], 3, ...[4]]       // [1, 2, 3, 4]
+```
+Spread is only valid as a list element or map entry — `f(...args)` is not
+supported (CEL resolves overloads by fixed arity). Spreading a non-list into
+a list, or a non-map into a map (including `null`), is an error — at compile
+time when statically known, at runtime when the source is `dyn`.
+
 ### Field access
 ```cel
 obj.field                   // access field on map/object

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

@@ -13,6 +13,8 @@ import { Effect } from 'effect';
 import { Fetch } from 'fx-fetch';
 export declare class HttpRequestBuilder {
     #private;
+    static setDefaultHeader(name: string, value: string | (() => string | null | undefined)): void;
+    static clearDefaultHeader(name: string): void;
     constructor(url: string, method: string);
     header(name: string, value: string): this;
     query(key: string, value: string | number): this;

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

@@ -38,6 +38,20 @@ export class HttpRequestBuilder {
   #headers = [];
   #queries = [];
   #body;
+  // Process-wide defaults applied at `#buildRequest()` time. Each entry is
+  // keyed by lowercased header name so an explicit `.header('X', …)` on the
+  // builder wins regardless of casing. A getter returning `null` / `undefined`
+  // / `''` skips the header for that request — lets the host source values
+  // from a live ref (e.g. the current i18n locale) without baking in stale
+  // snapshots.
+  static #defaultHeaders = /* @__PURE__ */ new Map();
+  static setDefaultHeader(name, value) {
+    const get = typeof value === "function" ? value : () => value;
+    HttpRequestBuilder.#defaultHeaders.set(name.toLowerCase(), { name, get });
+  }
+  static clearDefaultHeader(name) {
+    HttpRequestBuilder.#defaultHeaders.delete(name.toLowerCase());
+  }
   constructor(url, method) {
     this.#url = url;
     this.#method = method;
@@ -117,9 +131,16 @@ export class HttpRequestBuilder {
       url: this.#url,
       method: this.#method
     };
-    if (this.#headers.length > 0) {
-      const headers = {};
-      for (const [k, v] of this.#headers) headers[k] = v;
+    const explicit = new Set(this.#headers.map(([k]) => k.toLowerCase()));
+    const headers = {};
+    for (const [k, v] of this.#headers) headers[k] = v;
+    for (const [key, { name, get }] of HttpRequestBuilder.#defaultHeaders) {
+      if (explicit.has(key)) continue;
+      const v = get();
+      if (v == null || v === "") continue;
+      headers[name] = v;
+    }
+    if (Object.keys(headers).length > 0) {
       parts.headers = headers;
     }
     if (this.#body !== void 0) {

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

@@ -74,8 +74,106 @@ function checkOptionalAccessNode(chk, ast, ctx) {
   const actualType = leftType.kind === "optional" ? leftType.valueType : leftType;
   return chk.registry.getOptionalType(chk.checkAccessOnType(ast, ctx, actualType, true));
 }
-function checkElement(chk, ctx, expected, el) {
-  return expected.unify(chk.registry, chk.check(el, ctx)) ?? dynType;
+function spreadInner(node) {
+  return node.args;
+}
+function spreadListElementType(chk, ctx, node) {
+  const t = chk.check(spreadInner(node), ctx);
+  if (t.kind === "dyn") return chk.dynType;
+  if (t.kind === "list") return t.valueType;
+  throw chk.createError(
+    "invalid_spread",
+    `Cannot spread '${chk.formatType(t)}' into a list (expected a list)`,
+    node
+  );
+}
+function spreadMapEntryTypes(chk, ctx, node) {
+  const t = chk.check(spreadInner(node), ctx);
+  if (t.kind === "dyn") return [chk.dynType, chk.dynType];
+  if (t.kind === "map") return [t.keyType, t.valueType];
+  if (t.kind === "message") {
+    const Base2 = chk;
+    return [Base2.stringType, chk.dynType];
+  }
+  throw chk.createError(
+    "invalid_spread",
+    `Cannot spread '${chk.formatType(t)}' into a map (expected a map)`,
+    node
+  );
+}
+const SPREAD_SKIP_KEYS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
+function assignFragmentEntry(obj, k, v) {
+  const key = k;
+  if (SPREAD_SKIP_KEYS.has(key)) return;
+  obj[key] = v;
+}
+function mergeMapFragments(ev, frags) {
+  const obj = {};
+  for (const f of frags) {
+    if ("kv" in f) {
+      assignFragmentEntry(obj, f.kv[0], f.kv[1]);
+      continue;
+    }
+    const src = f.spread;
+    if (src instanceof Map) {
+      for (const [k, v] of src) assignFragmentEntry(obj, k, v);
+      continue;
+    }
+    if (src !== null && typeof src === "object" && !isArray(src)) {
+      for (const k in src) {
+        if (hasOwn(src, k)) assignFragmentEntry(obj, k, src[k]);
+      }
+      continue;
+    }
+    throw ev.createError(
+      "invalid_spread",
+      `Cannot spread a non-map value into a map`,
+      f.node
+    );
+  }
+  return obj;
+}
+function evaluateSpreadList(ev, ast, ctx) {
+  const arr = ast.args;
+  return Effect.all(
+    arr.map(
+      (el) => el.op === "spread" ? ev.eval(spreadInner(el), ctx).pipe(
+        Effect.flatMap(
+          (v) => isArray(v) ? Effect.succeed(v) : Effect.fail(
+            ev.createError(
+              "invalid_spread",
+              `Cannot spread a non-list value into a list`,
+              el
+            )
+          )
+        )
+      ) : ev.eval(el, ctx).pipe(Effect.map((v) => [v]))
+    )
+  ).pipe(Effect.map((parts) => parts.flat()));
+}
+function evaluateSpreadMap(ev, ast, ctx) {
+  const arr = ast.args;
+  return Effect.all(
+    arr.map((e) => {
+      if (e.length === 1 || e[0].op === "spread") {
+        const node = e[0];
+        return ev.eval(spreadInner(node), ctx).pipe(
+          Effect.map((src) => ({ spread: src, node }))
+        );
+      }
+      const pair = e;
+      return Effect.all([ev.eval(pair[0], ctx), ev.eval(pair[1], ctx)]).pipe(
+        Effect.map(([k, v]) => ({ kv: [k, v] }))
+      );
+    })
+  ).pipe(
+    Effect.flatMap(
+      (frags) => Effect.try({
+        try: () => mergeMapFragments(ev, frags),
+        catch: (e) => e
+      })
+    )
+  );
 }
 function ternaryConditionError(ev, value, node) {
   const type = ev.debugRuntimeType(value);
@@ -481,9 +579,19 @@ const OPERATORS_MAP = {
       const arr = ast.args;
       const arrLen = arr.length;
       if (arrLen === 0) return ast.setMeta("evaluate", emptyList) && chk.getType("list<T>");
-      let valueType = chk.check(arr[0], ctx);
-      for (let i = 1; i < arrLen; i++)
-        valueType = checkElement(chk, ctx, valueType, arr[i]);
+      let hasSpread = false;
+      let valueType;
+      for (const el of arr) {
+        let t;
+        if (el.op === "spread") {
+          hasSpread = true;
+          t = spreadListElementType(chk, ctx, el);
+        } else {
+          t = chk.check(el, ctx);
+        }
+        valueType = valueType === void 0 ? t : valueType.unify(chk.registry, t) ?? dynType;
+      }
+      if (hasSpread) ast.setMeta("evaluate", evaluateSpreadList);
       return chk.registry.getListType(valueType);
     },
     evaluate(ev, ast, ctx) {
@@ -495,13 +603,23 @@ const OPERATORS_MAP = {
       const arr = ast.args;
       const arrLen = arr.length;
       if (arrLen === 0) return ast.setMeta("evaluate", emptyMap) && chk.getType("map<K, V>");
-      let keyType = chk.check(arr[0][0], ctx);
-      let valueType = chk.check(arr[0][1], ctx);
-      for (let i = 1; i < arrLen; i++) {
-        const e = arr[i];
-        keyType = checkElement(chk, ctx, keyType, e[0]);
-        valueType = checkElement(chk, ctx, valueType, e[1]);
+      let hasSpread = false;
+      let keyType;
+      let valueType;
+      for (const e of arr) {
+        let k;
+        let v;
+        if (e.length === 1 || e[0].op === "spread") {
+          hasSpread = true;
+          [k, v] = spreadMapEntryTypes(chk, ctx, e[0]);
+        } else {
+          k = chk.check(e[0], ctx);
+          v = chk.check(e[1], ctx);
+        }
+        keyType = keyType === void 0 ? k : keyType.unify(chk.registry, k) ?? dynType;
+        valueType = valueType === void 0 ? v : valueType.unify(chk.registry, v) ?? dynType;
       }
+      if (hasSpread) ast.setMeta("evaluate", evaluateSpreadMap);
       return chk.registry.getMapType(keyType, valueType);
     },
     evaluate(ev, ast, ctx) {
@@ -513,6 +631,16 @@ const OPERATORS_MAP = {
       ).pipe(Effect.map(safeFromEntries));
     }
   },
+  "spread": {
+    // Reached only via direct `ast.check`/`ast.evaluate` — parents consume the
+    // node inline, so these are defensive guards.
+    check(chk, ast) {
+      throw chk.createError("misplaced_spread", `'...' is only valid inside a list or map literal`, ast);
+    },
+    evaluate(ev, ast) {
+      return Effect.fail(ev.createError("misplaced_spread", `'...' is only valid inside a list or map literal`, ast));
+    }
+  },
   "comprehension": {
     check(chk, ast, ctx) {
       const args = ast.args;

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

@@ -76,8 +76,9 @@ export declare class Parser {
     parsePostfix(): ASTNode;
     parsePrimary(): ASTNode;
     parseList(): ASTNode;
+    parseListElement(): ASTNode;
     parseMap(): ASTNode;
-    parseProperty(): [ASTNode, ASTNode];
+    parseProperty(): [ASTNode, ASTNode] | [ASTNode];
     parseArgumentList(): ASTNode[];
 }
 export {};

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

@@ -34,7 +34,8 @@ const TOKEN = {
   COMMA: 28,
   COLON: 29,
   QUESTION: 30,
-  BYTES: 31
+  BYTES: 31,
+  ELLIPSIS: 32
 };
 const OP_FOR_TOKEN = {
   [TOKEN.EQ]: OPS["=="],
@@ -208,6 +209,8 @@ class Lexer {
         case "}":
           return this.token(this.pos++, TOKEN.RBRACE);
         case ".":
+          if (input[pos + 1] === "." && input[pos + 2] === ".")
+            return this.token((this.pos += 3) - 3, TOKEN.ELLIPSIS);
           return this.token(this.pos++, TOKEN.DOT);
         case ",":
           return this.token(this.pos++, TOKEN.COMMA);
@@ -735,12 +738,12 @@ export class Parser {
     const elements = [];
     let remainingElements = this.limits.maxListElements;
     if (!this.match(TOKEN.RBRACKET)) {
-      elements.push(this.parseExpression());
+      elements.push(this.parseListElement());
       if (!remainingElements--) this.#limitExceeded("maxListElements", elements.at(-1).pos);
       while (this.match(TOKEN.COMMA)) {
         this.#advanceToken();
         if (this.match(TOKEN.RBRACKET)) break;
-        elements.push(this.parseExpression());
+        elements.push(this.parseListElement());
         if (!remainingElements--) this.#limitExceeded("maxListElements", elements.at(-1).pos);
       }
     }
@@ -748,6 +751,10 @@ export class Parser {
     this.consume(TOKEN.RBRACKET);
     return this.#node(start, closeEnd, OPS.list, elements);
   }
+  parseListElement() {
+    if (this.match(TOKEN.ELLIPSIS)) return this.#parseSpread();
+    return this.parseExpression();
+  }
   parseMap() {
     const start = this.consume(TOKEN.LBRACE);
     const props = [];
@@ -767,8 +774,18 @@ export class Parser {
     return this.#node(start, closeEnd, OPS.map, props);
   }
   parseProperty() {
+    if (this.match(TOKEN.ELLIPSIS)) return [this.#parseSpread()];
     return [this.parseExpression(), (this.consume(TOKEN.COLON), this.parseExpression())];
   }
+  // `...expr` — only valid as a list element or map entry; the parent literal
+  // consumes the node and `parsePrimary` never sees ELLIPSIS, so a stray `...`
+  // surfaces as a normal "unexpected token" parse error.
+  #parseSpread() {
+    const start = this.pos;
+    this.#advanceToken();
+    const inner = this.parseExpression();
+    return this.#node(start, inner.end, OPS.spread, inner);
+  }
   parseArgumentList() {
     const args = [];
     let remainingArgs = this.limits.maxCallArguments;

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

@@ -79,7 +79,11 @@ export function serialize(ast) {
     case "list":
       return `[${args.map(serialize).join(", ")}]`;
     case "map":
-      return `{${args.map(([k, v]) => `${serialize(k)}: ${serialize(v)}`).join(", ")}}`;
+      return `{${args.map(
+        (e) => e.length === 1 || e[0].op === "spread" ? serialize(e[0]) : `${serialize(e[0])}: ${serialize(e[1])}`
+      ).join(", ")}}`;
+    case "spread":
+      return `...${serialize(args)}`;
     case "?:": {
       const ternArgs = args;
       return `${wrap(ternArgs[0], op)} ? ${wrap(ternArgs[1], op)} : ${serialize(ternArgs[2])}`;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shwfed/config",
-  "version": "2.2.0",
+  "version": "2.2.2",
   "description": "Configurable UI for SHWFED",
   "type": "module",
   "publishConfig": {