@shwfed/config 3.0.6 → 3.0.8

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/share/define-registry.d.ts

@@ -1,4 +1,40 @@
 import type { Component } from 'vue';
+import type { Schema } from 'effect';
+type AnySchema = Schema.Schema<any, any, any>;
+/**
+ * A recursion edge: a schema field on this block/host that embeds ANOTHER
+ * host's config (a table's `TableConfig`, a container's `Slot`, an actions
+ * bar's `ActionsConfig`…). Declared next to the schema — NEVER in a central
+ * table (that switch would be the drift class CLAUDE.md bans) — and aggregated
+ * by the registry so the AI scope cursor can walk them (`config/utils/ai-cursor`).
+ *
+ * - `key` — the schema field holding the embedded config. Validated at registry
+ *   load (see `buildSchemaForEdges`): the declared key MUST be a real top-level
+ *   field on the block's schema, exactly like the type/date drift checks.
+ * - `host` — the host kind whose tool family configures that subtree
+ *   (`table` / `form` / `actions` / `slot`). The cursor maps this to a family;
+ *   hosts with no family yet stay declared-but-not-enterable (Phase C).
+ * - `label` — designer-facing crumb for the edge (breadcrumb / orientation).
+ * - `itemSlot` — set when `key` is an ARRAY of items and the embedded host
+ *   config lives at `item[itemSlot]` on each element (tabs: `key: 'tabs'`,
+ *   `itemSlot: 'slot'`). Absent → `key` holds the embedded config directly.
+ * - `self` — set when the embedded host config is NOT under a sub-field but the
+ *   record ITSELF (its fields spread the embedded host's fields, as `field.actions`
+ *   / `column.actions` spread `ActionSchemaFields` at the top level). `key` still
+ *   names a real field (for the load-time existence check), but the cursor bridges
+ *   the whole record and the family merges its keys back (`config/utils/ai-cursor`).
+ * - `celScope` — names a per-edge CEL scope extension the cursor threads into the
+ *   child frame's `configure` when entering (`loop-item` → `item`/`index`). Absent
+ *   → the child inherits the parent scope unchanged. See design §5.
+ */
+export type RegistryEdge = Readonly<{
+    key: string;
+    host: string;
+    label: string;
+    itemSlot?: string;
+    self?: boolean;
+    celScope?: string;
+}>;
 /**
  * Minimum shape every host's schema module must satisfy. Hosts extend this
  * with their own metadata / capability fields via the generic.
@@ -6,6 +42,13 @@ import type { Component } from 'vue';
 export type RegistryModuleBase = Readonly<{
     type: string;
     compatibilityDate: string;
+    /**
+     * Optional recursion-edge declarations — a block/host embedding another
+     * host's config lists them here (see `RegistryEdge`). Validated at load when
+     * the host supplies `buildSchemaForEdges`; otherwise carried through
+     * unvalidated. Absent for leaf and generator entries.
+     */
+    edges?: ReadonlyArray<RegistryEdge>;
 }>;
 /**
  * Per-entry shape produced by the factory before host-specific extras are
@@ -18,6 +61,8 @@ export type RegistryDraft<TModule extends RegistryModuleBase> = Readonly<{
     config: Component;
     runtime: Component;
     module: TModule;
+    /** The sibling `prompt.md`'s raw text (L2 fragment), when one exists. */
+    prompt?: string;
 }>;
 export type RegistryOptions<TModule extends RegistryModuleBase, TEntryExtras extends object> = Readonly<{
     /** Error-message prefix, e.g. `shwfed-form`. */
@@ -30,12 +75,30 @@ export type RegistryOptions<TModule extends RegistryModuleBase, TEntryExtras ext
     configModules: Record<string, Component>;
     /** Eager `import.meta.glob` over the host's runtime.vue files (default import). */
     runtimeModules: Record<string, Component>;
+    /**
+     * Optional eager `import.meta.glob` over the host's sibling `prompt.md` files
+     * ({ query: '?raw', import: 'default', eager: true }), keyed by path exactly
+     * like `schemaModules`. Each entry's `prompt` is looked up from here by the
+     * same folder-suffix match. `prompt.md` is OPTIONAL per folder — an absent one
+     * leaves `entry.prompt` undefined. No dist extension tolerance is needed
+     * (unlike `schema.{ts,js}`): `@nuxt/module-builder` transpiles `.ts`→`.js` but
+     * copies `.md` verbatim, so the `.md` suffix is stable in source and `dist`.
+     */
+    promptModules?: Record<string, string>;
     /**
      * Optional per-module validation beyond the type/date drift checks. Throw
      * to fail at module load. Used by table to require `toColumnDef`
      * to be a function.
      */
     validateModule?: (mod: TModule, type: string, date: string) => void;
+    /**
+     * Optional builder that constructs a module's schema with INERT args (a
+     * no-op configure, a stand-in `blockRef`) purely so the registry can verify
+     * every declared `edges[].key` is a real top-level field on it — the
+     * edge-declaration analog of the type/date drift check. Only invoked for
+     * modules that declare `edges`. Omit → edges are carried through unvalidated.
+     */
+    buildSchemaForEdges?: (mod: TModule) => AnySchema;
     /**
      * Optional predicate deciding whether a given module may ship WITHOUT a
      * sibling `runtime.vue`. Returns true → the runtime lookup is tolerant and
@@ -60,9 +123,12 @@ export type RegistryEntry<TModule extends RegistryModuleBase, TEntryExtras exten
     config: Component;
     runtime: Component;
     module: TModule;
+    /** The sibling `prompt.md`'s raw text (L2 fragment), when one exists. */
+    prompt?: string;
 } & TEntryExtras>;
 export type Registry<TModule extends RegistryModuleBase, TEntryExtras extends object> = Readonly<{
     ENTRIES: ReadonlyArray<RegistryEntry<TModule, TEntryExtras>>;
     find: (type: string, compatibilityDate: string) => RegistryEntry<TModule, TEntryExtras> | undefined;
 }>;
 export declare function defineRegistry<TModule extends RegistryModuleBase, TEntryExtras extends object = Record<never, never>>(options: RegistryOptions<TModule, TEntryExtras>): Registry<TModule, TEntryExtras>;
+export {};

package/dist/runtime/share/define-registry.js

@@ -1,3 +1,21 @@
+function topLevelFieldNames(schema) {
+  const unwrap = (ast) => {
+    switch (ast._tag) {
+      case "TypeLiteral":
+        return ast;
+      case "Transformation":
+        return unwrap(ast.to);
+      case "Refinement":
+        return unwrap(ast.from);
+      case "Suspend":
+        return unwrap(ast.f());
+      default:
+        return null;
+    }
+  };
+  const tl = unwrap(schema.ast);
+  return tl ? tl.propertySignatures.map((p) => String(p.name)) : [];
+}
 export function defineRegistry(options) {
   const {
     hostName,
@@ -5,7 +23,9 @@ export function defineRegistry(options) {
     schemaModules,
     configModules,
     runtimeModules,
+    promptModules,
     validateModule,
+    buildSchemaForEdges,
     runtimeOptional,
     deriveEntryExtras
   } = options;
@@ -27,6 +47,18 @@ export function defineRegistry(options) {
     if (found === void 0) throw new Error(`[${hostName}] missing ${file} for ${type}@${date}`);
     return found;
   };
+  const validateEdges = (mod, type, date) => {
+    const edges = mod.edges;
+    if (!edges || edges.length === 0 || !buildSchemaForEdges) return;
+    const fields = new Set(topLevelFieldNames(buildSchemaForEdges(mod)));
+    for (const edge of edges) {
+      if (!fields.has(edge.key)) {
+        throw new Error(
+          `[${hostName}] edge key "${edge.key}" declared on "${type}@${date}" is not a field on its schema (has: ${[...fields].join(", ") || "<none>"})`
+        );
+      }
+    }
+  };
   let cached = null;
   const compute = () => {
     if (cached) return cached;
@@ -40,13 +72,16 @@ export function defineRegistry(options) {
         throw new Error(`[${hostName}] compatibilityDate "${mod.compatibilityDate}" does not match folder "${date}"`);
       }
       validateModule?.(mod, type, date);
+      validateEdges(mod, type, date);
       const runtime = runtimeOptional?.(mod) ? findSiblingOptional(runtimeModules, date, type, "runtime.vue") : findSibling(runtimeModules, date, type, "runtime.vue");
       drafts.push({
         type: mod.type,
         compatibilityDate: mod.compatibilityDate,
         config: findSibling(configModules, date, type, "config.vue"),
         runtime,
-        module: mod
+        module: mod,
+        // `prompt.md` is optional per folder; absent → undefined.
+        ...promptModules ? { prompt: findSiblingOptional(promptModules, date, type, "prompt.md") } : {}
       });
     }
     const mapExtras = deriveEntryExtras ? deriveEntryExtras(drafts) : () => ({});
@@ -56,6 +91,7 @@ export function defineRegistry(options) {
       config: draft.config,
       runtime: draft.runtime,
       module: draft.module,
+      ...draft.prompt !== void 0 ? { prompt: draft.prompt } : {},
       ...mapExtras(draft)
     }));
     return cached;

package/dist/runtime/share/use-persisted-chat.d.ts

@@ -1,16 +1,18 @@
 import { type Ref } from 'vue';
 import type { UIMessage } from '../utils/ai/parts.js';
 /**
- * Mirrors a table editor's AI-chat history into `sessionStorage`, keyed on the
- * table's stable `config.id`, so the conversation survives both the chat
- * component unmounting — switching away from the "AI 生成" section `v-if`-
- * unmounts `<TableAiGenerate>`, dropping its local `ref<UIMessage[]>` — and a
- * page reload. It clears when the browser tab is closed (`sessionStorage`
- * lifetime), giving each table a per-instance, session-scoped chat memory.
+ * Mirrors an AI-chat history into `sessionStorage`, keyed on a stable id (the
+ * top-level config panel uses `location.pathname`), so the conversation survives
+ * both the chat component unmounting — switching away from the AI view
+ * `v-if`-unmounts it, dropping its local `ref<UIMessage[]>` — and a page reload.
+ * It clears when the browser tab is closed (`sessionStorage` lifetime), giving a
+ * per-instance, session-scoped chat memory. (Originally built for the table AI
+ * panel, removed in Phase C; now serves the top-level `config/ai-generate.vue`.)
  *
  * Modeled on `usePersistedQuery`: every access is SSR-guarded and guarded
- * against unavailable storage (privacy modes). With no `tableId()` persistence
- * is a no-op (in-memory only) so id-less drafts can't collide on a shared key.
+ * against unavailable storage (privacy modes). With no `tableId()` (the key
+ * getter — a misnomer kept from its table origin) persistence is a no-op
+ * (in-memory only) so id-less drafts can't collide on a shared key.
  *
  * - `restore()` seeds `messages` from the stored snapshot. Call it in
  *   `onMounted`, after the fresh component's empty ref exists, so a remount
@@ -24,7 +26,7 @@ import type { UIMessage } from '../utils/ai/parts.js';
  * replays history as prose only (`partsToText` in `utils/ai`), so a continued
  * conversation never re-sends a dangling tool_use across the restore boundary.
  */
-export declare function usePersistedChat(tableId: () => string | undefined, messages: Ref<UIMessage[]>): {
+export declare function usePersistedChat(tableId: () => string | undefined, messages: Ref<UIMessage[]>, keyPrefix?: string): {
     restore: () => void;
     clear: () => void;
 };

package/dist/runtime/share/use-persisted-chat.js

@@ -1,7 +1,7 @@
 import { watch } from "vue";
 const STORAGE_PREFIX = "shwfed.table.ai-chat.";
-export function usePersistedChat(tableId, messages) {
-  const key = () => `${STORAGE_PREFIX}${tableId()}`;
+export function usePersistedChat(tableId, messages, keyPrefix = STORAGE_PREFIX) {
+  const key = () => `${keyPrefix}${tableId()}`;
   const active = () => Boolean(tableId()) && typeof window !== "undefined";
   function restore() {
     if (!active()) return;
@@ -18,7 +18,7 @@ export function usePersistedChat(tableId, messages) {
     const id = tableId();
     if (!id) return;
     try {
-      window.sessionStorage.removeItem(`${STORAGE_PREFIX}${id}`);
+      window.sessionStorage.removeItem(`${keyPrefix}${id}`);
     } catch {
     }
   }

package/dist/runtime/utils/ai/index.d.ts

@@ -31,7 +31,7 @@ export interface GenerateObjectInput<A, I extends Record<string, unknown>> {
 export interface StreamChatInput {
     readonly messages: ReadonlyArray<UIMessage>;
     readonly system?: string;
-    readonly tools?: ReadonlyArray<AgenticTool>;
+    readonly tools?: ReadonlyArray<AgenticTool> | (() => ReadonlyArray<AgenticTool>);
     readonly signal?: AbortSignal;
     readonly maxTokens?: number;
     readonly onMessageUpdate?: (assistant: UIMessage) => void;

package/dist/runtime/utils/ai/index.js

@@ -257,25 +257,32 @@ function partsToText(parts) {
   return parts.filter((p) => p.type === "text").map((p) => p.text).join("");
 }
 async function streamChat(input) {
-  const helperTools = input.tools ?? [];
-  const helperByName = new Map(helperTools.map((t) => [t.name, t]));
-  const tools = helperTools.length > 0 ? helperTools.map((t) => ({
-    name: t.name,
-    description: t.description,
-    input_schema: t.inputJsonSchema
-  })) : void 0;
+  const readTools = (() => {
+    const t = input.tools;
+    if (typeof t === "function") return t;
+    const arr = t ?? [];
+    return () => arr;
+  })();
   const messages = input.messages.map(
     (m) => ({ role: m.role, content: partsToText(m.parts) })
   );
-  const opts = {
-    ...tools !== void 0 ? { tools } : {},
-    ...input.maxTokens !== void 0 ? { maxTokens: input.maxTokens } : {}
-  };
+  const maxTokensOpt = input.maxTokens !== void 0 ? { maxTokens: input.maxTokens } : {};
   const assistant = { id: createMessageId(), role: "assistant", parts: [] };
   const publish = () => input.onMessageUpdate?.(assistant);
   const MAX_TRUNCATION_STREAK = 3;
   let truncationStreak = 0;
   for (; ; ) {
+    const helperTools = readTools();
+    const helperByName = new Map(helperTools.map((t) => [t.name, t]));
+    const anthropicTools = helperTools.length > 0 ? helperTools.map((t) => ({
+      name: t.name,
+      description: t.description,
+      input_schema: t.inputJsonSchema
+    })) : void 0;
+    const opts = {
+      ...anthropicTools !== void 0 ? { tools: anthropicTools } : {},
+      ...maxTokensOpt
+    };
     const partByIndex = /* @__PURE__ */ new Map();
     const response = await callStream(messages, input.system, opts, input.signal, () => {
     }, {

package/dist/runtime/utils/cel-catalog.d.ts

@@ -0,0 +1 @@
+export declare function getCelCatalog(): string;

package/dist/runtime/utils/cel-catalog.js

@@ -0,0 +1,10 @@
+import rawCatalog from "./cel-catalog.md?raw";
+let catalog = rawCatalog;
+if (import.meta.hot) {
+  import.meta.hot.accept("./cel-catalog.md?raw", (mod) => {
+    if (typeof mod?.default === "string") catalog = mod.default;
+  });
+}
+export function getCelCatalog() {
+  return catalog;
+}

package/dist/runtime/utils/cel-catalog.md

@@ -0,0 +1,42 @@
+CEL（Common Expression Language）是一门小而安全的**单表达式**语言：没有语句、赋值、循环或函数定义，整段表达式求值为一个值。以下是本项目可用的操作符与函数速查（完整语义见字段级注解与实际类型检查报错）。
+
+## 类型
+
+`number`（任意精度小数，无 int/float 之分）、`string`（单双引号，`'''多行'''`，`r'原始'`）、`bool`、`bytes`、`null`、`list`、`map`、`Date`（`date('2023-01-15')` 或 `date(unixSeconds)`）。
+
+## 操作符
+
+- 算术：`+ - * / %`、一元 `-`（仅 `number`；`/` 保留 20 位有效数字，勿用 `==` 直接比较除法结果）。
+- 比较：`== != < <= > >=`（对 list/map 深比较）。
+- 逻辑：`&& || !`（短路）。
+- 三元：`cond ? a : b`。
+- 成员：`x in [列表]`、`key in {映射}`。
+- 拼接：字符串 / 列表用 `+`；`[...a, x]` / `{...a, "k": v}` 展开（后写覆盖先写）。
+- 字段访问：`obj.field`、`obj["field"]`；**可选访问** `obj.?field`、`obj[?0]`（返回 `optional`，字段可能缺失时优先用）。
+
+## Optional（可选值，`.?` 会产生）
+
+`optional.of(x)` / `optional.ofNullable(x)`（null→None）/ `optional.none()`；`o.orValue(默认值)`（取值或默认）、`o.or(其他optional)`、`o.hasValue()`、`o.value()`；`o.map(v, 表达式)`、`o.flatMap(v, optional)`、`o.filter(v, 布尔)`、`o.exists(v, 布尔)`。典型：`row.?amount.orValue(0)`。
+
+## 常用函数
+
+- 类型转换：`number(x)`、`string(x)`、`bool(x)`、`type(x)`、`dyn(x)`。无 `int()`，取整用 `math.trunc/floor/ceil/round`。
+- 数学：`math.trunc/floor/ceil/round/abs(n)`、`math.min/max(a, b)` 或 `math.min/max(list)`。
+- 字符串（方法）：`s.size()`、`s.contains(x)`、`s.startsWith/endsWith(x)`、`s.matches(正则)`、`s.substring(i[, j])`、`s.split(sep)`、`s.trim()`、`s.replace(from, to[, limit])`、`s.lowerAscii()/upperAscii()`。
+- 列表（宏 / 方法）：`l.size()`、`l.map(x, 表达式)`、`l.filter(x, 布尔)`、`l.all(x, 布尔)`、`l.exists(x, 布尔)`、`l.exists_one(x, 布尔)`、`l.enumerate()`（→ `{index, value}` 列表）、`l.slice(i[, j])`（支持负索引）。
+- 映射：`Map.fromList(pairs)` / `Map.toList(m)`（pair 为 `{key, value}`，是从数据构建 map 的唯一方式）。
+- JSON：`JSON.parse(s)`、`JSON.stringify(x)`。
+- 日期：`date(...)`、`d.get('year'|'month'(1基)|'day'|'hour'|...)`、`d.diff(other, unit)`（有符号，受者为被减数）、`d.offset(n, unit)`、`d.startOf/endOf(unit)`、`d.format(...)`、`Date.tz(...)`。
+- 区间：`range(a, b[, step])`、`range(startDate, endDate, unit)`（右开）。
+
+## HTTP（构建请求，不发起）
+
+CEL 只**构建** `HttpRequest`，由宿主发起。链式：
+```cel
+http.get(hostname + '/path')          // 或 .post / .put / .delete；端点须为绝对 URL，用 hostname 变量，勿写 {{env}}
+  .header('Content-Type', 'application/json')
+  .query(query)                        // query = 全部搜索条件；放在最前
+  .query('key', value)                 // 值可为 string | number | optional<...>（None 则不追加该参数）
+  .body({ ... })                       // POST/PUT 请求体
+```
+`form({...})` 构建 `FormData`（文件上传：`.body(form({"file": f, "name": "a"}))`）。

package/dist/runtime/utils/cel-context.d.ts

@@ -6,6 +6,21 @@ export type CELVar = {
     value: unknown;
 };
 export type CELContext = Record<string, CELVar>;
+/**
+ * A compact CEL scope entry for AI tool output — `name` + `type`, plus the
+ * designer-facing `label` / `description` when they add anything. Flattens a
+ * `CELContext` (whose `value` thunks are irrelevant to the model) into the
+ * variable table `describe_*_settings` hands the agent alongside the function
+ * catalog. Same probed source the ExpressionEditor advertises, so the two can't
+ * drift.
+ */
+export type CELScopeEntry = {
+    name: string;
+    type: string;
+    label?: string;
+    description?: string;
+};
+export declare function renderCelScope(context: CELContext): CELScopeEntry[];
 export declare const SCOPE_ADDRESS_VAR = "__scopes__";
 export declare const SELECTIONS_VAR = "selections";
 export declare const OPTIONS_VAR = "options";

package/dist/runtime/utils/cel-context.js

@@ -1,5 +1,13 @@
 import { computed, inject, provide, shallowRef } from "vue";
 import { injectLocal, provideLocal } from "@vueuse/core";
+export function renderCelScope(context) {
+  return Object.entries(context).map(([name, v]) => ({
+    name,
+    type: v.type,
+    ...v.label && v.label !== name ? { label: v.label } : {},
+    ...v.description ? { description: v.description } : {}
+  }));
+}
 export const SCOPE_ADDRESS_VAR = "__scopes__";
 export const SELECTIONS_VAR = "selections";
 export const OPTIONS_VAR = "options";

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;