@shwfed/config 3.0.8 → 3.0.10

package/dist/runtime/components/table/columns/2026-06-14/com.shwfed.table.column.tree-combobox-multi/config.vue.d.ts

@@ -36,15 +36,15 @@ declare const __VLS_export: import("vue").DefineComponent<__VLS_ModelProps, {},
         }[]] | undefined;
         readonly keywords?: string | undefined;
         readonly readonly?: string | undefined;
-        readonly dataSource: {
-            readonly data: string;
-            readonly request?: string | undefined;
-        };
         readonly binding: string;
         readonly derived?: {
             readonly mode: "formula" | "prefill";
             readonly expression: string;
         } | undefined;
+        readonly dataSource: {
+            readonly data: string;
+            readonly request?: string | undefined;
+        };
         readonly nodeKey: string;
         readonly nodeChildren: string;
         readonly nodeLabel: string;
@@ -95,15 +95,15 @@ declare const __VLS_export: import("vue").DefineComponent<__VLS_ModelProps, {},
         }[]] | undefined;
         readonly keywords?: string | undefined;
         readonly readonly?: string | undefined;
-        readonly dataSource: {
-            readonly data: string;
-            readonly request?: string | undefined;
-        };
         readonly binding: string;
         readonly derived?: {
             readonly mode: "formula" | "prefill";
             readonly expression: string;
         } | undefined;
+        readonly dataSource: {
+            readonly data: string;
+            readonly request?: string | undefined;
+        };
         readonly nodeKey: string;
         readonly nodeChildren: string;
         readonly nodeLabel: string;

package/dist/runtime/components/table/columns/2026-06-14/com.shwfed.table.column.tree-combobox-single/config.d.vue.ts

@@ -36,15 +36,15 @@ declare const __VLS_export: import("vue").DefineComponent<__VLS_ModelProps, {},
         }[]] | undefined;
         readonly keywords?: string | undefined;
         readonly readonly?: string | undefined;
-        readonly dataSource: {
-            readonly data: string;
-            readonly request?: string | undefined;
-        };
         readonly binding: string;
         readonly derived?: {
             readonly mode: "formula" | "prefill";
             readonly expression: string;
         } | undefined;
+        readonly dataSource: {
+            readonly data: string;
+            readonly request?: string | undefined;
+        };
         readonly nodeKey: string;
         readonly nodeChildren: string;
         readonly nodeLabel: string;
@@ -94,15 +94,15 @@ declare const __VLS_export: import("vue").DefineComponent<__VLS_ModelProps, {},
         }[]] | undefined;
         readonly keywords?: string | undefined;
         readonly readonly?: string | undefined;
-        readonly dataSource: {
-            readonly data: string;
-            readonly request?: string | undefined;
-        };
         readonly binding: string;
         readonly derived?: {
             readonly mode: "formula" | "prefill";
             readonly expression: string;
         } | undefined;
+        readonly dataSource: {
+            readonly data: string;
+            readonly request?: string | undefined;
+        };
         readonly nodeKey: string;
         readonly nodeChildren: string;
         readonly nodeLabel: string;

package/dist/runtime/components/table/columns/2026-06-14/com.shwfed.table.column.tree-combobox-single/config.vue.d.ts

@@ -36,15 +36,15 @@ declare const __VLS_export: import("vue").DefineComponent<__VLS_ModelProps, {},
         }[]] | undefined;
         readonly keywords?: string | undefined;
         readonly readonly?: string | undefined;
-        readonly dataSource: {
-            readonly data: string;
-            readonly request?: string | undefined;
-        };
         readonly binding: string;
         readonly derived?: {
             readonly mode: "formula" | "prefill";
             readonly expression: string;
         } | undefined;
+        readonly dataSource: {
+            readonly data: string;
+            readonly request?: string | undefined;
+        };
         readonly nodeKey: string;
         readonly nodeChildren: string;
         readonly nodeLabel: string;
@@ -94,15 +94,15 @@ declare const __VLS_export: import("vue").DefineComponent<__VLS_ModelProps, {},
         }[]] | undefined;
         readonly keywords?: string | undefined;
         readonly readonly?: string | undefined;
-        readonly dataSource: {
-            readonly data: string;
-            readonly request?: string | undefined;
-        };
         readonly binding: string;
         readonly derived?: {
             readonly mode: "formula" | "prefill";
             readonly expression: string;
         } | undefined;
+        readonly dataSource: {
+            readonly data: string;
+            readonly request?: string | undefined;
+        };
         readonly nodeKey: string;
         readonly nodeChildren: string;
         readonly nodeLabel: string;

package/dist/runtime/components/tabs/index.vue

@@ -22,11 +22,19 @@ useHead(() => {
   const tab = tabs.value.find((t) => t.path === activePath.value);
   return tab ? { title: store.resolveTitle(tab, locale.value) } : {};
 });
+const homePath = props.home.split(/[?#]/, 1)[0];
+function track(path, fullPath) {
+  if (path === homePath) {
+    store.activePath.value = null;
+    return;
+  }
+  store.openOrFocus(path, fullPath);
+}
 let stopAfterEach;
 onMounted(() => {
-  store.openOrFocus(route.path, route.fullPath);
+  track(route.path, route.fullPath);
   stopAfterEach = router.afterEach((to) => {
-    store.openOrFocus(to.path, to.fullPath);
+    track(to.path, to.fullPath);
   });
 });
 onBeforeUnmount(() => stopAfterEach?.());

package/dist/runtime/components/ui/chat/ChatMessages.vue

@@ -1,5 +1,5 @@
 <script setup>
-import { nextTick, ref, watch } from "vue";
+import { nextTick, onBeforeUnmount, onMounted, ref, watch } from "vue";
 import { Icon } from "@iconify/vue";
 import { ScrollArea } from "../scroll-area";
 import ChatMessage from "./ChatMessage.vue";
@@ -9,15 +9,35 @@ const props = defineProps({
   pending: { type: Boolean, required: false }
 });
 const root = ref(null);
-function scrollToBottom() {
-  const viewport = root.value?.$el?.querySelector?.(
+function viewportEl() {
+  return root.value?.$el?.querySelector?.(
     '[data-slot="scroll-area-viewport"]'
-  );
-  if (viewport) viewport.scrollTop = viewport.scrollHeight;
+  ) ?? null;
+}
+const STICK_SLOP = 24;
+const stick = ref(true);
+function onScroll() {
+  const v = viewportEl();
+  if (!v) return;
+  stick.value = v.scrollHeight - v.scrollTop - v.clientHeight <= STICK_SLOP;
+}
+function scrollToBottom() {
+  const v = viewportEl();
+  if (v) v.scrollTop = v.scrollHeight;
 }
+onMounted(() => {
+  const v = viewportEl();
+  v?.addEventListener("scroll", onScroll, { passive: true });
+  nextTick(scrollToBottom);
+});
+onBeforeUnmount(() => {
+  viewportEl()?.removeEventListener("scroll", onScroll);
+});
 watch(
   () => [props.messages, props.pending],
-  () => nextTick(scrollToBottom),
+  () => nextTick(() => {
+    if (stick.value) scrollToBottom();
+  }),
   { flush: "post" }
 );
 </script>
@@ -61,3 +81,7 @@ watch(
     </div>
   </div>
 </template>
+
+<style scoped>
+.relative :deep([data-slot=scroll-area-viewport]>div){display:block!important;width:100%}
+</style>

package/dist/runtime/share/navigation.d.ts

@@ -1 +1,24 @@
 export declare function isAbsoluteUrl(url: string): boolean;
+/**
+ * Demote an absolute href that names OUR OWN origin to a router-ready in-app
+ * path, so `_self` navigation to it is an SPA push rather than a full document
+ * reload. Returns `null` for any other origin — and for opaque-origin schemes
+ * like `mailto:` / `tel:` / custom app schemes — which stay full-page
+ * navigations governed by `isAbsoluteUrl`.
+ *
+ * Why it exists: a CEL author who writes `location.query('tab', 'x')` gets a
+ * `URL` back, and `string(URL)` is the full `.href` — origin and all. Reloading
+ * our own page just to flip a query param is almost never the intent, so a
+ * same-origin absolute is routed internally instead.
+ *
+ * Two subtleties make this more than an `=== origin` check — and are exactly
+ * why it cannot fold back into `isAbsoluteUrl`:
+ *  - The router prepends its history base (`app.baseURL`) to whatever path it
+ *    routes, and a full pathname ALREADY carries that base. Handing it back
+ *    unstripped double-prepends (`/base/x` → `/base/base/x`), so the base is
+ *    peeled off here. Vue Router's `history.base` may or may not carry a
+ *    trailing slash; both normalize.
+ *  - A protocol-relative `//host/x` has no scheme of its own, so it resolves
+ *    against `origin` to inherit ours before the comparison.
+ */
+export declare function sameOriginInternalPath(href: string, origin: string, base: string): string | null;

package/dist/runtime/share/navigation.js

@@ -2,3 +2,18 @@ const ABSOLUTE = /^(?:[a-z][a-z0-9+\-.]*:|\/\/)/i;
 export function isAbsoluteUrl(url) {
   return ABSOLUTE.test(url.trim());
 }
+export function sameOriginInternalPath(href, origin, base) {
+  let url;
+  try {
+    url = new URL(href.trim(), origin);
+  } catch {
+    return null;
+  }
+  if (url.origin !== origin) return null;
+  const path = `${url.pathname}${url.search}${url.hash}`;
+  const prefix = base.replace(/\/+$/, "");
+  if (prefix && (path === prefix || path.startsWith(`${prefix}/`))) {
+    return path.slice(prefix.length) || "/";
+  }
+  return path;
+}

package/dist/runtime/utils/disabled-date.d.ts

@@ -1,12 +1,18 @@
 import type { DateValue } from 'reka-ui';
 /**
  * Convert an `@internationalized/date` `DateValue` (what the picker's
- * `disabledDate` callback receives) to a native JS `Date`, so user expressions
- * see a plain `input: Date`. Mirrors `pickerValueToNative` in
+ * `disabledDate` callback receives) to the CEL `Date` type, so user expressions
+ * see `input: Date`. Mirrors `pickerValueToNative` in
  * `ui/date-picker/DatePicker.vue` (minus the `Time` branch — the per-date
  * predicate never receives a `Time`). For a `CalendarDate` (date/month/year
  * panels) the time fields are absent and default to `0`; for `month` panels the
  * candidate is the first of the month (`day` is `1`).
+ *
+ * MUST be a `TZDate`, not a plain `new Date()`: CEL's registry maps its `Date`
+ * type to the `TZDate` constructor exactly (`registerType('Date', TZDate)`), so
+ * a plain `Date`'s constructor lookup misses and the evaluator throws
+ * `Unsupported type: Date`. Same requirement as the `now` variable in
+ * `form/index.vue`.
  */
 export declare function dateValueToNative(d: DateValue): Date;
 /**

package/dist/runtime/utils/disabled-date.js

@@ -1,5 +1,6 @@
+import { TZDate } from "@date-fns/tz";
 export function dateValueToNative(d) {
-  return new Date(
+  return new TZDate(
     d.year,
     d.month - 1,
     "day" in d ? d.day : 1,

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

@@ -26,6 +26,8 @@ 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). 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.
 
+A `list.filterMap(var, body): list<dyn>` macro has been added (not from upstream, in `macros.ts` beside `find`) — Rust's `Iterator::filter_map`. The body evaluates to an `optional<B>` per element; `Some` values are kept (unwrapped), `None`s dropped, yielding `list<B>`. It fuses the map-then-strip-absent pattern (which would otherwise need `.map(...)` to build a `list<optional>` plus a second pass to drop the `None`s) and is the optional-gated complement to the 3-arg `map(var, filter, transform)`, whose gate is a bool predicate. NOTE: it is **not** a comprehension desugar — the accu/ternary primitives gate on a bool, not on `Option` presence — so unlike the 2/3-arg `map` and `filter` it runs a manual fold like `find` (eval receiver → coerce Set/Map/object to an array → per-element `ev.eval(body)` → `ensureOptional` → push the `Some`s). Type-check: the receiver element type comes from list `valueType` / map `keyType` / `dyn` (same `invalid_comprehension_range` contract as `find`); the body must be `optional<B>` when statically typed (via `ensureOptionalType`), and a `dyn` body defers to the runtime `ensureOptional` (matching `flatMap`); the result is `registry.getListType(bindOptionalValueType(bodyType))`. Because the body already returns an `optional`, `filterMap` needs no receiver-type dispatch (there is no `optional<A>.filterMap` — that role is `flatMap`), so it is a single list-only expander. Tested in `__tests__/filter-map-macro.test.ts`.
+
 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)`.
 
 A `form(dyn): FormData` built-in has been added (`form-builtins.ts`) — not from upstream. It registers the `FormData` type on `globalRegistry` and a global `form` function that turns a CEL map into a native `FormData`, so authors can write `http.post(url).body(form({"file": myFile, "name": "Alice"}))` (`.body()` passes `FormData` through verbatim; `#buildRequest()` serializes it). NOTE: `#buildRequest()` must serialize a `FormData` body itself rather than hand it to fx-fetch — fx-fetch clones bodies via `new Response(body).blob()`, and the File API ASCII-lowercases `Blob#type`, so in Chrome the multipart boundary in the derived `Content-Type` loses its case while the body bytes keep it (boundaries are case-sensitive → every parser sees zero parts). The builder lifts the case-preserved `Content-Type` off the `Response` *header* (header values are never case-normalized), adds it as an explicit header (unless the author set their own `Content-Type`), and passes the bytes as a `Promise<Blob>` (fx-fetch resolves promises verbatim). Value coercion mirrors `.query()`'s flat-record semantics: `null` / `undefined` / `Option.None` skip the key; `Option.Some(x)` recurses on `x`; `File` / `Blob` pass through (preserves the `File` filename); `Decimal` → `.toString()` (preserves precision past safe-integer); `Date` (`TZDate`) → `.toISOString()`; `bool` → `'true'` / `'false'`; arrays append one entry per element; nested objects throw (`multipart/form-data` is flat — same rule as `.query(dyn)`). Top-level input must be a map literal / record (Map or plain object); passing an array or scalar throws.
@@ -51,7 +53,7 @@ lib/
 ├── operators.ts      — Binary/unary operator implementations
 ├── overloads.ts      — Operator overload definitions
 ├── functions.ts      — Built-in functions + Date type (TZDate)
-├── macros.ts         — map / filter / all / exists (each dispatching list comprehension vs optional receiver), exists_one, find, has, cel.bind
+├── macros.ts         — map / filter / all / exists (each dispatching list comprehension vs optional receiver), exists_one, find, filterMap, 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)

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

@@ -505,6 +505,19 @@ Macros are special forms — they look like method calls but have special evalua
 [1, 2, 3, 4, 5].filter(x, x > 3)           // [4, 5]
 ```
 
+### filterMap — Transform-and-keep in one pass (Rust `filter_map`)
+The body returns an `optional<B>` per element; the `Some` values are kept
+(unwrapped) and the `None`s dropped, yielding a `list<B>`. Use it when the
+keep/drop decision *is* the transform — computing the mapped value and its
+presence together — rather than a separate bool predicate. (The 3-arg
+`map(x, filter, transform)` is the bool-predicate form; reach for `filterMap`
+when the gate rides on an `optional`, e.g. a `.?` field or `optional.ofNullable`.)
+```cel
+[1, 2, 3, 4].filterMap(x, x % 2 == 0 ? optional.of(x * 10) : optional.none())  // [20, 40]
+users.filterMap(u, optional.ofNullable(u.email))     // emails of users that have one
+rows.filterMap(r, r.?qty.map(q, q * 2))              // doubled qty, skipping rows without one
+```
+
 ### all — True if ALL elements match
 ```cel
 [1, 2, 3].all(x, x > 0)                    // true

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

@@ -1,7 +1,7 @@
 import { Effect, Option } from "effect";
 import { evaluationError, parseError } from "./errors.js";
 import { OPERATORS as OPS } from "./operators.js";
-import { optionalOf, ensureOptional, bindOptionalValueType } from "./optional.js";
+import { optionalOf, ensureOptional, ensureOptionalType, bindOptionalValueType } from "./optional.js";
 const identity = (x) => x;
 function assertIdentifier(node, message) {
   if (node.op === "id") return node.args;
@@ -294,6 +294,68 @@ function createFindExpander() {
     };
   };
 }
+function createFilterMapExpander() {
+  const functionDesc = "filterMap(var, body)";
+  const invalidMsg = `${functionDesc} invalid iteration variable`;
+  const invalidBody = `${functionDesc} body`;
+  function typeCheck(chk, macro, ctx) {
+    const iterType = chk.check(macro.receiver, ctx);
+    let elemType;
+    if (iterType.kind === "dyn") elemType = iterType;
+    else if (iterType.kind === "list") elemType = iterType.valueType;
+    else if (iterType.kind === "map") elemType = iterType.keyType;
+    else {
+      throw chk.createError(
+        "invalid_comprehension_range",
+        `Expression of type '${iterType}' cannot be range of filterMap (must be list, map, or dynamic).`,
+        macro.receiver
+      );
+    }
+    macro.iterCtx = ctx.forkWithVariable(macro.iterVarName, elemType);
+    const bodyType = ensureOptionalType(chk, macro.body, macro.iterCtx, invalidBody);
+    return chk.registry.getListType(bindOptionalValueType(chk, bodyType));
+  }
+  function evaluate(ev, macro, ctx) {
+    return Effect.gen(function* () {
+      let items = yield* ev.eval(macro.receiver, ctx);
+      if (!Array.isArray(items)) {
+        if (items instanceof Set) items = [...items];
+        else if (items instanceof Map) items = [...items.keys()];
+        else if (items && typeof items === "object") items = Object.keys(items);
+        else {
+          return yield* Effect.fail(
+            ev.createError(
+              "invalid_comprehension_range",
+              `Expression of type '${ev.debugType(items)}' cannot be range of filterMap.`,
+              macro.receiver
+            )
+          );
+        }
+      }
+      const iterCtx = macro.iterCtx.reuse(ctx);
+      const arr = items;
+      const out = [];
+      for (let i = 0; i < arr.length; i++) {
+        const result = yield* ev.eval(macro.body, iterCtx.setIterValue(arr[i], ev));
+        const optional = ensureOptional(result, macro.body, invalidBody);
+        if (Option.isSome(optional)) out.push(optional.value);
+      }
+      return out;
+    });
+  }
+  return (opts) => {
+    const { args, receiver, ast } = opts;
+    return {
+      ast,
+      receiver,
+      iterVarName: assertIdentifier(args[0], invalidMsg),
+      body: args[1],
+      iterCtx: void 0,
+      evaluate,
+      typeCheck
+    };
+  };
+}
 function createHasExpander() {
   const invalidHasArgument = "has() invalid argument";
   function evaluate(ev, macro, ctx) {
@@ -395,6 +457,7 @@ export function registerMacros(registry) {
   functionOverload("list.map(ast, ast, ast): list<dyn>", createMapExpander(true));
   functionOverload("list.filter(ast, ast): list<dyn>", createFilterExpander());
   functionOverload("list.find(ast, ast): optional<dyn>", createFindExpander());
+  functionOverload("list.filterMap(ast, ast): list<dyn>", createFilterMapExpander());
   class CelNamespace {
     #kind = "cel";
     toString() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shwfed/config",
-  "version": "3.0.8",
+  "version": "3.0.10",
   "description": "Configurable UI for SHWFED",
   "type": "module",
   "publishConfig": {
@@ -36,6 +36,7 @@
     "lint": "eslint .",
     "test": "vitest run",
     "test:watch": "vitest watch",
+    "test:ai-eval": "AI_EVAL=1 vitest run --config vitest.eval.config.mjs",
     "test:types": "vue-tsc --noEmit && cd playground && vue-tsc --noEmit"
   },
   "dependencies": {