@shwfed/config 3.0.6 → 3.0.7

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

@@ -45,10 +45,10 @@ declare const __VLS_export: import("vue").DefineComponent<__VLS_ModelProps, {},
             readonly data: string;
             readonly request?: string | undefined;
         };
+        readonly enableSorting?: boolean | undefined;
         readonly nodeKey: string;
         readonly nodeChildren: string;
         readonly nodeLabel: string;
-        readonly enableSorting?: boolean | undefined;
         readonly nodeTooltip?: readonly [{
             readonly locale: "zh";
             readonly message: string;
@@ -103,10 +103,10 @@ declare const __VLS_export: import("vue").DefineComponent<__VLS_ModelProps, {},
             readonly data: string;
             readonly request?: string | undefined;
         };
+        readonly enableSorting?: boolean | undefined;
         readonly nodeKey: string;
         readonly nodeChildren: string;
         readonly nodeLabel: string;
-        readonly enableSorting?: boolean | undefined;
         readonly nodeTooltip?: readonly [{
             readonly locale: "zh";
             readonly message: string;

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

@@ -45,10 +45,10 @@ declare const __VLS_export: import("vue").DefineComponent<__VLS_ModelProps, {},
             readonly data: string;
             readonly request?: string | undefined;
         };
+        readonly enableSorting?: boolean | undefined;
         readonly nodeKey: string;
         readonly nodeChildren: string;
         readonly nodeLabel: string;
-        readonly enableSorting?: boolean | undefined;
         readonly nodeTooltip?: readonly [{
             readonly locale: "zh";
             readonly message: string;
@@ -103,10 +103,10 @@ declare const __VLS_export: import("vue").DefineComponent<__VLS_ModelProps, {},
             readonly data: string;
             readonly request?: string | undefined;
         };
+        readonly enableSorting?: boolean | undefined;
         readonly nodeKey: string;
         readonly nodeChildren: string;
         readonly nodeLabel: string;
-        readonly enableSorting?: boolean | undefined;
         readonly nodeTooltip?: readonly [{
             readonly locale: "zh";
             readonly message: string;

package/dist/runtime/components/table/config.vue

@@ -610,14 +610,14 @@ async function copyColumns() {
   const set = pickedColumnIdSet.value;
   const cols = orderedColumnIds.value.filter((id) => set.has(id)).map((id) => editingColumns.value.find((c) => c.id === id)).filter((c) => !!c).map(({ groupId: _g, ...rest }) => rest);
   if (cols.length === 0) return;
-  const ok = await writeClip("table", cols);
+  const ok = await writeClip("table", { items: cols });
   if (ok) toast.success(`\u5DF2\u590D\u5236 ${cols.length} \u5217`);
   else toast.error("\u590D\u5236\u5931\u8D25");
 }
 async function pasteColumns() {
   const clip = await readClip();
   if (!clip || clip.surface !== "table") return;
-  const { items } = reidFragment(clip.items);
+  const { items } = reidFragment(clip);
   const pasted = items.map(({ groupId: _g, ...rest }) => rest);
   if (pasted.length === 0) return;
   editingColumns.value = [...editingColumns.value, ...pasted];

package/dist/runtime/components/table/schema.d.ts

@@ -158,40 +158,6 @@ export declare function TableConfig(configure: (env: Environment) => void): Sche
             readonly message: string;
         }[]] | undefined;
     }[];
-    readonly query?: {
-        readonly style?: string | undefined;
-        readonly id?: string | undefined;
-        readonly initial?: {
-            readonly data: string;
-            readonly request?: string | undefined;
-        } | undefined;
-        readonly displayName?: string | undefined;
-        readonly kind: "shwfed.component.form";
-        readonly fields: readonly any[];
-        readonly layouts: readonly {
-            readonly name: string;
-            readonly layout: {
-                readonly style?: string | undefined;
-                readonly columns: number;
-                readonly gap?: number | undefined;
-                readonly rows?: number | undefined;
-                readonly placements: {
-                    readonly [x: string]: {
-                        readonly area: readonly [readonly [number, number], readonly [number, number]];
-                        readonly v?: "stretch" | "center" | "end" | "start" | undefined;
-                        readonly h?: "stretch" | "center" | "end" | "start" | undefined;
-                    };
-                };
-            };
-            readonly media?: string | undefined;
-        }[];
-        readonly readonly?: string | undefined;
-    } | undefined;
-    readonly dataSource?: {
-        readonly data: string;
-        readonly total?: string | undefined;
-        readonly request?: string | undefined;
-    } | undefined;
     readonly actions?: {
         readonly size: "default" | "sm" | "xs";
         readonly style?: string | undefined;
@@ -259,6 +225,40 @@ export declare function TableConfig(configure: (env: Environment) => void): Sche
             readonly variant?: "default" | "link" | "destructive" | "primary" | "ghost" | undefined;
         }[];
     } | undefined;
+    readonly query?: {
+        readonly style?: string | undefined;
+        readonly id?: string | undefined;
+        readonly initial?: {
+            readonly data: string;
+            readonly request?: string | undefined;
+        } | undefined;
+        readonly displayName?: string | undefined;
+        readonly kind: "shwfed.component.form";
+        readonly fields: readonly any[];
+        readonly layouts: readonly {
+            readonly name: string;
+            readonly layout: {
+                readonly style?: string | undefined;
+                readonly columns: number;
+                readonly gap?: number | undefined;
+                readonly rows?: number | undefined;
+                readonly placements: {
+                    readonly [x: string]: {
+                        readonly area: readonly [readonly [number, number], readonly [number, number]];
+                        readonly v?: "stretch" | "center" | "end" | "start" | undefined;
+                        readonly h?: "stretch" | "center" | "end" | "start" | undefined;
+                    };
+                };
+            };
+            readonly media?: string | undefined;
+        }[];
+        readonly readonly?: string | undefined;
+    } | undefined;
+    readonly dataSource?: {
+        readonly data: string;
+        readonly total?: string | undefined;
+        readonly request?: string | undefined;
+    } | undefined;
     readonly bottomActions?: {
         readonly size: "default" | "sm" | "xs";
         readonly style?: string | undefined;
@@ -827,40 +827,6 @@ export declare function createTableConfig(body: Omit<Schema.Schema.Type<ReturnTy
             readonly message: string;
         }[]] | undefined;
     }[];
-    query?: {
-        readonly style?: string | undefined;
-        readonly id?: string | undefined;
-        readonly initial?: {
-            readonly data: string;
-            readonly request?: string | undefined;
-        } | undefined;
-        readonly displayName?: string | undefined;
-        readonly kind: "shwfed.component.form";
-        readonly fields: readonly any[];
-        readonly layouts: readonly {
-            readonly name: string;
-            readonly layout: {
-                readonly style?: string | undefined;
-                readonly columns: number;
-                readonly gap?: number | undefined;
-                readonly rows?: number | undefined;
-                readonly placements: {
-                    readonly [x: string]: {
-                        readonly area: readonly [readonly [number, number], readonly [number, number]];
-                        readonly v?: "stretch" | "center" | "end" | "start" | undefined;
-                        readonly h?: "stretch" | "center" | "end" | "start" | undefined;
-                    };
-                };
-            };
-            readonly media?: string | undefined;
-        }[];
-        readonly readonly?: string | undefined;
-    } | undefined;
-    dataSource?: {
-        readonly data: string;
-        readonly total?: string | undefined;
-        readonly request?: string | undefined;
-    } | undefined;
     actions?: {
         readonly size: "default" | "sm" | "xs";
         readonly style?: string | undefined;
@@ -928,6 +894,40 @@ export declare function createTableConfig(body: Omit<Schema.Schema.Type<ReturnTy
             readonly variant?: "default" | "link" | "destructive" | "primary" | "ghost" | undefined;
         }[];
     } | undefined;
+    query?: {
+        readonly style?: string | undefined;
+        readonly id?: string | undefined;
+        readonly initial?: {
+            readonly data: string;
+            readonly request?: string | undefined;
+        } | undefined;
+        readonly displayName?: string | undefined;
+        readonly kind: "shwfed.component.form";
+        readonly fields: readonly any[];
+        readonly layouts: readonly {
+            readonly name: string;
+            readonly layout: {
+                readonly style?: string | undefined;
+                readonly columns: number;
+                readonly gap?: number | undefined;
+                readonly rows?: number | undefined;
+                readonly placements: {
+                    readonly [x: string]: {
+                        readonly area: readonly [readonly [number, number], readonly [number, number]];
+                        readonly v?: "stretch" | "center" | "end" | "start" | undefined;
+                        readonly h?: "stretch" | "center" | "end" | "start" | undefined;
+                    };
+                };
+            };
+            readonly media?: string | undefined;
+        }[];
+        readonly readonly?: string | undefined;
+    } | undefined;
+    dataSource?: {
+        readonly data: string;
+        readonly total?: string | undefined;
+        readonly request?: string | undefined;
+    } | undefined;
     bottomActions?: {
         readonly size: "default" | "sm" | "xs";
         readonly style?: string | undefined;

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

@@ -1,8 +1,11 @@
-export type ClipSurface = 'form' | 'block' | 'table';
-export type ClipPayload = Readonly<{
-    surface: ClipSurface;
+export type ClipSurface = 'form' | 'block' | 'table' | 'actions';
+export type ClipFragment = Readonly<{
     items: ReadonlyArray<unknown>;
     placements?: Readonly<Record<string, unknown>>;
+    groups?: ReadonlyArray<unknown>;
+}>;
+export type ClipPayload = ClipFragment & Readonly<{
+    surface: ClipSurface;
 }>;
 /**
  * Deep-clone the fragment with every id (and every reference to a copied id)
@@ -11,16 +14,19 @@ export type ClipPayload = Readonly<{
  */
 export declare function reidItems<T>(items: ReadonlyArray<T>): T[];
 /**
- * Reid items and their placements through one shared map, so the placement keys
- * (which are item ids) and the items' own `id`s land on the same fresh UUIDs.
+ * Reid a whole fragment through one shared map, so every id definition and every
+ * reference to one lands on the same fresh UUID: the placement keys (which are
+ * item ids), an action item's `groupId` and the group's own `id`, and the items'
+ * own `id`s all stay wired to each other.
  */
-export declare function reidFragment<T>(items: ReadonlyArray<T>, placements?: Readonly<Record<string, unknown>>): {
-    items: T[];
+export declare function reidFragment(fragment: ClipFragment): {
+    items: unknown[];
     placements?: Record<string, unknown>;
+    groups?: unknown[];
 };
-export declare function serializeClip(surface: ClipSurface, items: ReadonlyArray<unknown>, placements?: Readonly<Record<string, unknown>>): string;
+export declare function serializeClip(surface: ClipSurface, fragment: ClipFragment): string;
 export declare function parseClip(text: string): ClipPayload | null;
 /** Write a fragment to the system clipboard. Resolves `false` on any failure. */
-export declare function writeClip(surface: ClipSurface, items: ReadonlyArray<unknown>, placements?: Readonly<Record<string, unknown>>): Promise<boolean>;
+export declare function writeClip(surface: ClipSurface, fragment: ClipFragment): Promise<boolean>;
 /** Read a fragment from the system clipboard, or `null` if absent/unreadable. */
 export declare function readClip(): Promise<ClipPayload | null>;

package/dist/runtime/share/clipboard.js

@@ -40,34 +40,46 @@ function buildIdMap(items) {
 export function reidItems(items) {
   return remap(items, buildIdMap(items));
 }
-export function reidFragment(items, placements) {
-  const map = buildIdMap(items);
+export function reidFragment(fragment) {
+  const map = buildIdMap([...fragment.items, ...fragment.groups ?? []]);
   return {
-    items: remap(items, map),
-    placements: placements ? remap(placements, map) : void 0
+    items: remap(fragment.items, map),
+    placements: fragment.placements ? remap(fragment.placements, map) : void 0,
+    groups: fragment.groups ? remap(fragment.groups, map) : void 0
   };
 }
-export function serializeClip(surface, items, placements) {
-  return JSON.stringify({ [CLIP_KEY]: CLIP_VERSION, surface, items, placements });
+export function serializeClip(surface, fragment) {
+  return JSON.stringify({
+    [CLIP_KEY]: CLIP_VERSION,
+    surface,
+    items: fragment.items,
+    placements: fragment.placements,
+    groups: fragment.groups
+  });
 }
 function isPlainObject(v) {
   return v !== null && typeof v === "object" && !Array.isArray(v);
 }
+const SURFACES = ["form", "block", "table", "actions"];
+function isSurface(v) {
+  return typeof v === "string" && SURFACES.includes(v);
+}
 export function parseClip(text) {
   try {
     const o = JSON.parse(text);
     if (!o || o[CLIP_KEY] !== CLIP_VERSION) return null;
-    if (o.surface !== "form" && o.surface !== "block" && o.surface !== "table") return null;
+    if (!isSurface(o.surface)) return null;
     if (!Array.isArray(o.items)) return null;
     const placements = isPlainObject(o.placements) ? o.placements : void 0;
-    return { surface: o.surface, items: o.items, placements };
+    const groups = Array.isArray(o.groups) ? o.groups : void 0;
+    return { surface: o.surface, items: o.items, placements, groups };
   } catch {
     return null;
   }
 }
-export async function writeClip(surface, items, placements) {
+export async function writeClip(surface, fragment) {
   try {
-    await navigator.clipboard.writeText(serializeClip(surface, items, placements));
+    await navigator.clipboard.writeText(serializeClip(surface, fragment));
     return true;
   } catch {
     return false;

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

@@ -33,6 +33,10 @@ The `__proto__` / `constructor` / `prototype` keys are skipped on the top-level
 
 A `JSON` built-in namespace has been added (`json-builtins.ts`) — not from upstream. It registers a `JSON` brand class and a same-named constant on `globalRegistry`, so `JSON.parse(string): dyn` and `JSON.stringify(dyn): string` resolve in every `Environment`. The CEL-side surface mirrors the JS globals deliberately. `JSON.parse` is a thin wrapper over `globalThis.JSON.parse` — numbers come back as plain JS `number` (the evaluator coerces via `Decimal.from` at use time). `JSON.stringify` pre-walks the value via `normalizeForJSON` before handing it to `globalThis.JSON.stringify`: `Decimal` → JS number (via `.toNumber()` — loses precision past safe-integer range, deliberate trade-off for idiomatic JSON output), `Option.Some(x)` → `x`, `Option.None` → `null`, `Map` → plain object, `Date`/`TZDate` passes through so its built-in `toJSON` emits ISO 8601. The pre-walk is required because Effect's `Option` defines its own `toJSON()` that runs before any replacer would see it.
 
+A `Map` built-in namespace has been added (`map-builtins.ts`) — not from upstream. It registers a `Map` brand class and a same-named constant on `globalRegistry`, so `Map.fromList(list<dyn>): map<dyn, dyn>` and `Map.toList(map<dyn, dyn>): list<map<string, dyn>>` resolve in every `Environment`. This is the only way to *build* a map from data: the `map` macro always yields a list, and spread only accepts a map source, so before this there was no fold from list to map (the JSON round-trip `JSON.parse("{" + rows.map(...).join(",") + "}")` was the only workaround, and it flattens `Decimal` and `Date`). The naming follows Haskell's `Data.Map.fromList` / `toList` rather than a bespoke `toMap` binding macro, because the transform half already exists — `Map.fromList(rows.map(r, {"key": r.name, "value": r.qty}))` composes it. Capitalized to stay clear of the `map` type name and the `map` macro, following `JSON`. A pair is a `{key, value}` record (CEL has no tuple type — the same convention as `list.enumerate()`'s `{index, value}`). Both are plain functions, not macros, so there is no comprehension/accumulator surgery: `fromList` validates each entry and funnels the pairs through the shared `safeFromEntries`, which is what makes a number key stringify *identically* to a map literal's (the plain-object write is the same one `#getMapField` reads back). Both fields are required per entry — a half-pair `{"key": "a"}` throws `invalid_map_entry` rather than storing `undefined` (an explicit `null` value stays legal, via `hasOwn`); keys must be string / number / bool, since `fromList` is the one place a *dyn* key can be checked at all, and an object key would otherwise silently stringify to `"[object Object]"`; duplicate keys are last-wins, which falls out of `safeFromEntries` and coincides with `Data.Map.fromList`'s `foldl insert`. `isRecord` must check the prototype (plain object or `Map`), not just `typeof === 'object'` — `Decimal` / `Date` / `File` are all objects, and without it `Map.fromList([1, 2])` would report a missing `key` field instead of a non-record entry. The handlers' non-list / non-map guards are defensive: overload resolution runs on the *runtime* type, so a non-map reaches neither handler even through a `dyn` expression.
+
+`safeFromEntries` and the `__proto__` / `constructor` / `prototype` skip set (`FORBIDDEN_KEYS`) live in `globals.ts`, not `operators.ts` — `map-builtins.ts` needs them and `globals.ts` is the leaf module, so importing from `operators.ts` would have created a cycle. Map literals, map spread (which had its own copy of the set, `SPREAD_SKIP_KEYS`) and `Map.fromList` all funnel through them.
+
 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
@@ -52,12 +56,13 @@ lib/
 ├── 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)
+├── map-builtins.ts   — `Map` namespace: fromList / toList — list<{key, value}> ⇄ map (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
 ├── errors.ts         — ParseError, TypeError, EvaluationError
-├── globals.ts        — Shared utilities
+├── globals.ts        — Shared utilities + `safeFromEntries` / `FORBIDDEN_KEYS`
 ├── types.ts          — Type definitions
 └── options.ts        — Configuration management
 ```
@@ -85,7 +90,7 @@ Internal-only (not re-exported from `index.js`): `parse`, standalone `evaluate`/
 
 Primitives: `string`, `bool`, `number`, `bytes`, `null_type`, `type`
 Composites: `list<T>`, `map<K, V>`, `optional<T>`, `dyn`, `message`
-Custom: `Date` (backed by `TZDate` from `@date-fns/tz`), `URL` (backed by the native `URL`; host-supplied only — no CEL constructor. Reader `URL.query(string): optional<string>` returns the *first* value of a search param — `None` when absent, distinguishing it from a present-but-empty value. Writers return a **copy**, never mutating the receiver (a `URL` is host-injected shared state, unlike a fresh-per-expression `HttpRequestBuilder`): the set/replace `URL.query(string, string | number | optional<string> | optional<number>): URL` collapses repeated entries and on `None` *deletes* the key (the result mirrors the optional's state — deliberately unlike `HttpRequest.query`, whose `None` is a drop/no-op), while `URL.appendQuery(...)` with the same four value overloads appends an entry and no-ops on `None`. Number values render Decimal-exact, like `string(number)`. `string(URL)` is the full `href`.), `File` (native), `FormData` (native — see `form-builtins.ts`), `http` / `HttpRequest` (local addition — see `http-builtins.ts`)
+Custom: `Date` (backed by `TZDate` from `@date-fns/tz`), `URL` (backed by the native `URL`; host-supplied only — no CEL constructor. Reader `URL.query(string): optional<string>` returns the *first* value of a search param — `None` when absent, distinguishing it from a present-but-empty value. Writers return a **copy**, never mutating the receiver (a `URL` is host-injected shared state, unlike a fresh-per-expression `HttpRequestBuilder`): the set/replace `URL.query(string, string | number | optional<string> | optional<number>): URL` collapses repeated entries and on `None` *deletes* the key (the result mirrors the optional's state — deliberately unlike `HttpRequest.query`, whose `None` is a drop/no-op), while `URL.appendQuery(...)` with the same four value overloads appends an entry and no-ops on `None`. Number values render Decimal-exact, like `string(number)`. `string(URL)` is the full `href`.), `File` (native), `FormData` (native — see `form-builtins.ts`), `http` / `HttpRequest` (local addition — see `http-builtins.ts`), `Map` (local addition — the `fromList` / `toList` namespace brand, see `map-builtins.ts`; unrelated to the `map<K, V>` composite)
 
 ## Function Signature Format
 

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

@@ -211,6 +211,33 @@ unwrapped first so the output is plain JSON — numbers (CEL's `Decimal`) become
 JS numbers, optionals become their value (or `null` when empty), and `Date`
 values become ISO 8601 strings.
 
+### Map
+```cel
+// Build a map from a list — the only way to do it, since `map(...)` yields a list:
+Map.fromList([{"key": "a", "value": 1}, {"key": "b", "value": 2}])   // {"a": 1, "b": 2}
+
+// Usually you transform a list into pairs first:
+rows.map(r, {"key": r.name, "value": r.qty})                         // [{key: "a", value: 1}, ...]
+Map.fromList(rows.map(r, {"key": r.name, "value": r.qty}))           // {"a": 1, "b": 2}
+
+// Rows already shaped {key, value} go in bare:
+Map.fromList(kvRows)
+
+// The inverse — explode a map into pairs so the list macros can reach it:
+Map.toList({"a": 1, "b": 2})                                         // [{key: "a", value: 1}, {key: "b", value: 2}]
+Map.toList(m).filter(e, e.value > 1).map(e, e.key)                   // keys whose value > 1
+Map.fromList(Map.toList(m).filter(e, e.value != null))               // drop empty entries, back to a map
+```
+`Map` is a built-in namespace — always available, like `JSON`. Note the capital
+`M`: lowercase `map` is the list macro, and they are unrelated.
+
+A pair is a `{key, value}` record, because CEL has no tuple type — the same
+convention `enumerate()` uses. `Map.fromList(list<dyn>)` requires both fields on
+every entry (a `{"key": "a"}` half-pair is an error; `"value": null` is fine).
+Keys must be `string` / `number` / `bool`. Duplicate keys: the last one wins.
+Values keep their type — numbers stay exact, `Date` stays a `Date` — so prefer
+this over a `JSON.parse`/`JSON.stringify` round-trip, which flattens both.
+
 ### FormData
 ```cel
 // Build multipart/form-data for an upload:

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 { registerMapBuiltins } from "./map-builtins.js";
 import { registerMathBuiltins } from "./math-builtins.js";
 import { registerMacros } from "./macros.js";
 import { registerOverloads } from "./overloads.js";
@@ -19,6 +20,7 @@ registerMacros(globalRegistry);
 registerHttpBuiltins(globalRegistry);
 registerJSONBuiltins(globalRegistry);
 registerFormBuiltins(globalRegistry);
+registerMapBuiltins(globalRegistry);
 registerMathBuiltins(globalRegistry);
 class Environment {
   #registry;

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

@@ -23,5 +23,7 @@ export declare const arrayFrom: {
     <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 const FORBIDDEN_KEYS: Set<string>;
+export declare function safeFromEntries(entries: [unknown, unknown][]): Record<string, unknown>;
 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

@@ -4,6 +4,16 @@ export const objFreeze = Object.freeze;
 export const objEntries = Object.entries;
 export const isArray = Array.isArray;
 export const arrayFrom = Array.from;
+export const FORBIDDEN_KEYS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
+export function safeFromEntries(entries) {
+  const obj = {};
+  for (let i = 0; i < entries.length; i++) {
+    const [k, v] = entries[i];
+    if (FORBIDDEN_KEYS.has(k)) continue;
+    obj[k] = v;
+  }
+  return obj;
+}
 export function isAsync(fn, fallback) {
   if (fn?.[Symbol.toStringTag] === "AsyncFunction") return true;
   return typeof fallback === "boolean" ? fallback : true;

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

@@ -0,0 +1,2 @@
+import type { Registry } from './registry.js.js';
+export declare function registerMapBuiltins(registry: Registry): void;

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

@@ -0,0 +1,80 @@
+import { evaluationError } from "./errors.js";
+import { Decimal } from "./decimal.js";
+import { hasOwn, isArray, objKeys, safeFromEntries } from "./globals.js";
+class MapNamespace {
+  brand = "Map";
+}
+const MAP_INSTANCE = new MapNamespace();
+function isRecord(v) {
+  if (v === null || typeof v !== "object" || isArray(v)) return false;
+  if (v instanceof Map) return true;
+  const proto = Object.getPrototypeOf(v);
+  return proto === Object.prototype || proto === null;
+}
+function hasField(entry, name) {
+  return entry instanceof Map ? entry.has(name) : hasOwn(entry, name);
+}
+function readField(entry, name) {
+  return entry instanceof Map ? entry.get(name) : entry[name];
+}
+function assertKey(key, index) {
+  const ok = typeof key === "string" || typeof key === "boolean" || typeof key === "number" || typeof key === "bigint" || key instanceof Decimal;
+  if (!ok) {
+    throw evaluationError(
+      "invalid_map_key",
+      `Map.fromList(): entry ${index} has a '${key === null ? "null" : typeof key}' key (expected string / number / bool)`
+    );
+  }
+  return key;
+}
+export function registerMapBuiltins(registry) {
+  registry.registerType("Map", MapNamespace);
+  registry.registerVariable({
+    name: "Map",
+    type: "Map",
+    value: MAP_INSTANCE,
+    description: "\u6620\u5C04\u6784\u9020\u4E0E\u89E3\u6784"
+  });
+  registry.registerFunctionOverload(
+    "Map.fromList(list<dyn>): map<dyn, dyn>",
+    (_r, entries) => {
+      if (!isArray(entries)) {
+        throw evaluationError(
+          "invalid_argument",
+          `Map.fromList(): expects a list of {key, value} records`
+        );
+      }
+      const pairs = entries.map((entry, i) => {
+        if (!isRecord(entry)) {
+          throw evaluationError(
+            "invalid_map_entry",
+            `Map.fromList(): entry ${i} is not a {key, value} record`
+          );
+        }
+        for (const field of ["key", "value"]) {
+          if (!hasField(entry, field)) {
+            throw evaluationError(
+              "invalid_map_entry",
+              `Map.fromList(): entry ${i} has no '${field}' field`
+            );
+          }
+        }
+        return [assertKey(readField(entry, "key"), i), readField(entry, "value")];
+      });
+      return safeFromEntries(pairs);
+    }
+  );
+  registry.registerFunctionOverload(
+    "Map.toList(map<dyn, dyn>): list<map<string, dyn>>",
+    (_r, m) => {
+      if (!isRecord(m)) {
+        throw evaluationError("invalid_argument", `Map.toList(): expects a map`);
+      }
+      if (m instanceof Map) {
+        return Array.from(m, ([key, value]) => ({ key, value }));
+      }
+      const obj = m;
+      return objKeys(obj).map((key) => ({ key, value: obj[key] }));
+    }
+  );
+}

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

@@ -1,7 +1,7 @@
 import { Effect, Either, Option } from "effect";
 import { celTypes } from "./registry.js";
 import { Decimal } from "./decimal.js";
-import { objKeys, isArray, hasOwn } from "./globals.js";
+import { objKeys, isArray, hasOwn, FORBIDDEN_KEYS, safeFromEntries } from "./globals.js";
 import { attachErrorAst } from "./errors.js";
 const dynType = celTypes.dyn;
 export class Base {
@@ -101,10 +101,9 @@ function spreadMapEntryTypes(chk, ctx, node) {
     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;
+  if (FORBIDDEN_KEYS.has(key)) return;
   obj[key] = v;
 }
 function mergeMapFragments(ev, frags) {
@@ -354,15 +353,6 @@ function resolveAstArray(ev, astArray, ctx) {
   if (astArray.length === 0) return Effect.succeed([]);
   return Effect.all(astArray.map((a) => ev.eval(a, ctx)));
 }
-function safeFromEntries(entries) {
-  const obj = {};
-  for (let i = 0; i < entries.length; i++) {
-    const [k, v] = entries[i];
-    if (k === "__proto__" || k === "constructor" || k === "prototype") continue;
-    obj[k] = v;
-  }
-  return obj;
-}
 function comprehensionElementType(chk, iterable, ctx) {
   const iterType = chk.check(iterable, ctx);
   if (iterType.kind === "dyn") return iterType;

package/package.json

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