@shwfed/config 2.10.3 → 2.10.5

package/dist/runtime/components/table/columns/2026-06-17/com.shwfed.table.column.date-input/schema.d.ts

@@ -0,0 +1,76 @@
+import { Schema } from 'effect';
+import type { ColumnDef } from '@tanstack/vue-table';
+import type { Environment } from '../../../../../vendor/cel-js/lib/index.js';
+import type { ColumnDefDeps } from '../../../utils/resolve.js';
+export declare const type: "com.shwfed.table.column.date-input";
+export declare const compatibilityDate: "2026-06-17";
+export declare const metadata: {
+    readonly name: "日期输入";
+    readonly icon: "fluent:calendar-ltr-20-regular";
+};
+export declare function presetSchema(configure: (env: Environment) => void): Schema.Struct<{
+    id: Schema.refine<string, typeof Schema.String>;
+    label: Schema.TupleType<readonly [Schema.Struct<{
+        locale: Schema.Literal<["zh"]>;
+        message: Schema.SchemaClass<string, string, never>;
+    }>], [Schema.Struct<{
+        locale: Schema.Literal<["ja", "en", "ko"]>;
+        message: Schema.SchemaClass<string, string, never>;
+    }>]>;
+    value: Schema.Schema<string, string, never>;
+}>;
+export declare function schema(configure: (env: Environment) => void): Schema.Struct<{
+    placeholder: Schema.optional<Schema.TupleType<readonly [Schema.Struct<{
+        locale: Schema.Literal<["zh"]>;
+        message: Schema.SchemaClass<string, string, never>;
+    }>], [Schema.Struct<{
+        locale: Schema.Literal<["ja", "en", "ko"]>;
+        message: Schema.SchemaClass<string, string, never>;
+    }>]>>;
+    hidden: Schema.optional<Schema.Schema<string, string, never>>;
+    disabled: Schema.optional<Schema.Schema<string, string, never>>;
+    readonly: Schema.optional<Schema.Schema<string, string, never>>;
+    derived: Schema.optional<Schema.Struct<{
+        mode: Schema.Literal<["formula", "prefill"]>;
+        expression: Schema.Schema<string, string, never>;
+    }>>;
+    format: Schema.optional<Schema.refine<string, typeof Schema.String>>;
+    valueFormat: Schema.optional<Schema.refine<string, typeof Schema.String>>;
+    presets: Schema.optional<Schema.Array$<Schema.Struct<{
+        id: Schema.refine<string, typeof Schema.String>;
+        label: Schema.TupleType<readonly [Schema.Struct<{
+            locale: Schema.Literal<["zh"]>;
+            message: Schema.SchemaClass<string, string, never>;
+        }>], [Schema.Struct<{
+            locale: Schema.Literal<["ja", "en", "ko"]>;
+            message: Schema.SchemaClass<string, string, never>;
+        }>]>;
+        value: Schema.Schema<string, string, never>;
+    }>>>;
+    title: Schema.TupleType<readonly [Schema.Struct<{
+        locale: Schema.Literal<["zh"]>;
+        message: Schema.SchemaClass<string, string, never>;
+    }>], [Schema.Struct<{
+        locale: Schema.Literal<["ja", "en", "ko"]>;
+        message: Schema.SchemaClass<string, string, never>;
+    }>]>;
+    binding: Schema.refine<string, typeof Schema.String>;
+    enableSorting: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
+    sortKey: Schema.optional<Schema.refine<string, typeof Schema.String>>;
+    size: Schema.optional<Schema.refine<number, Schema.filter<typeof Schema.Number>>>;
+    grow: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
+    tooltip: Schema.optional<Schema.TupleType<readonly [Schema.Struct<{
+        locale: Schema.Literal<["zh"]>;
+        message: Schema.SchemaClass<string, string, never>;
+    }>], [Schema.Struct<{
+        locale: Schema.Literal<["ja", "en", "ko"]>;
+        message: Schema.SchemaClass<string, string, never>;
+    }>]>>;
+    id: Schema.refine<string, typeof Schema.String>;
+    groupId: Schema.optional<typeof Schema.UUID>;
+    type: Schema.Literal<["com.shwfed.table.column.date-input"]>;
+    compatibilityDate: Schema.Literal<["2026-06-17"]>;
+}>;
+export type Value = Schema.Schema.Type<ReturnType<typeof schema>>;
+export declare function defaults(): Partial<Value>;
+export declare function toColumnDef(value: Value, { getLocaleText }: ColumnDefDeps): Partial<ColumnDef<unknown, unknown>>;

package/dist/runtime/components/table/columns/2026-06-17/com.shwfed.table.column.date-input/schema.js

@@ -0,0 +1,89 @@
+import { Schema } from "effect";
+import { getProperty } from "dot-prop";
+import { Locale } from "../../../../../share/locale.js";
+import { CelRowAccess, derivedRowField, editableColumnFields, editableHeader } from "../../../utils/shared.js";
+export const type = "com.shwfed.table.column.date-input";
+export const compatibilityDate = "2026-06-17";
+export const metadata = {
+  name: "\u65E5\u671F\u8F93\u5165",
+  icon: "fluent:calendar-ltr-20-regular"
+};
+export function presetSchema(configure) {
+  const CelDate = CelRowAccess(configure, { resultType: "Date" });
+  return Schema.Struct({
+    id: Schema.UUID.annotations({ description: "\u9884\u8BBE\u552F\u4E00\u6807\u8BC6\uFF0C\u7528\u4E8E\u7A33\u5B9A\u7684 v-for key" }),
+    label: Locale.annotations({
+      title: "\u6807\u7B7E",
+      description: "\u5FEB\u6377\u9009\u9879\u5C55\u793A\u7684\u672C\u5730\u5316\u6587\u672C"
+    }),
+    value: CelDate.annotations({
+      title: "\u503C",
+      description: '\u70B9\u51FB\u8BE5\u9884\u8BBE\u65F6\u8BA1\u7B97\u51FA\u7684\u65E5\u671F\uFF0C\u4F8B\u5982 `now.offset(-7, "days")`'
+    })
+  }).annotations({
+    title: "DateInputPreset"
+  });
+}
+export function schema(configure) {
+  const CelBool = CelRowAccess(configure, { resultType: "bool" });
+  const Preset = presetSchema(configure);
+  return Schema.Struct({
+    type: Schema.Literal(type),
+    compatibilityDate: Schema.Literal(compatibilityDate),
+    ...editableColumnFields(),
+    placeholder: Schema.optional(Locale.annotations({
+      title: "\u5360\u4F4D\u7B26",
+      description: "\u672A\u9009\u4E2D\u65E5\u671F\u65F6\u8F93\u5165\u6846\u4E2D\u7684\u5360\u4F4D\u6587\u672C"
+    })),
+    hidden: Schema.optional(CelBool.annotations({
+      title: "\u9690\u85CF\u6761\u4EF6",
+      description: "\u8FD4\u56DE `true` \u65F6\u8BE5\u884C\u7684\u8F93\u5165\u6846\u4E0D\u6E32\u67D3\uFF08\u5176\u4F59\u884C\u4E0D\u53D7\u5F71\u54CD\uFF09"
+    })),
+    disabled: Schema.optional(CelBool.annotations({
+      title: "\u7981\u7528\u6761\u4EF6",
+      description: "\u8FD4\u56DE `true` \u65F6\u8F93\u5165\u6846\u4ECD\u7136\u6E32\u67D3\u4F46\u4E0D\u53EF\u7F16\u8F91"
+    })),
+    readonly: Schema.optional(CelBool.annotations({
+      title: "\u53EA\u8BFB\u6761\u4EF6",
+      description: "\u8FD4\u56DE `true` \u65F6\u4EC5\u4EE5\u7EAF\u6587\u672C\u5C55\u793A\u5F53\u524D\u503C"
+    })),
+    derived: derivedRowField(configure, "string"),
+    format: Schema.optional(Schema.String.pipe(Schema.minLength(1)).annotations({
+      title: "\u5C55\u793A\u683C\u5F0F",
+      description: "\u8F93\u5165\u6846\u4E2D\u5C55\u793A\u65E5\u671F\u7684 `date-fns` \u683C\u5F0F\u4E32\uFF1B\u7559\u7A7A\u65F6\u4F7F\u7528\u9ED8\u8BA4 `yyyy-MM-dd`"
+    })),
+    valueFormat: Schema.optional(Schema.String.pipe(Schema.minLength(1)).annotations({
+      title: "\u5B58\u50A8\u683C\u5F0F",
+      description: "\u5199\u5165\u884C\u6570\u636E\u7684 `date-fns` \u683C\u5F0F\u4E32\uFF1B\u7559\u7A7A\u65F6\u4F7F\u7528\u9ED8\u8BA4 `yyyy-MM-dd`"
+    })),
+    presets: Schema.optional(Schema.Array(Preset).annotations({
+      title: "\u5FEB\u6377\u9009\u9879",
+      description: "\u5728\u9009\u62E9\u5668\u4FA7\u680F\u5C55\u793A\u7684\u5FEB\u6377\u9884\u8BBE\uFF1B\u7559\u7A7A\u5219\u4E0D\u6E32\u67D3\u4FA7\u680F"
+    }))
+  }).annotations({ title: "DateInputRenderer", description: "\u65E5\u671F\u8F93\u5165\u6E32\u67D3\u5668\uFF08\u53EF\u7F16\u8F91\uFF09" });
+}
+export function defaults() {
+  return {
+    title: [{ locale: "zh", message: "" }],
+    binding: "",
+    size: 120
+  };
+}
+export function toColumnDef(value, { getLocaleText }) {
+  return {
+    header: editableHeader(getLocaleText(value.title)),
+    // `binding` is a dot-prop path (validated non-empty); the cell renderer
+    // reads through the same path it writes to. No CEL — accessor is literal.
+    accessorFn: (row) => {
+      if (!row || typeof row !== "object") return void 0;
+      return getProperty(row, value.binding);
+    },
+    enableSorting: value.enableSorting ?? false,
+    sortingFn: "alphanumeric",
+    size: value.size,
+    meta: {
+      grow: value.grow ?? false,
+      tooltip: getLocaleText(value.tooltip)
+    }
+  };
+}

package/dist/runtime/components/ui/tree/Tree.d.vue.ts

@@ -30,6 +30,19 @@ declare const __VLS_export: <Node>(__VLS_props: NonNullable<Awaited<typeof __VLS
          * it off so a stray click doesn't leave a permanent highlight.
          */
         showFocusedRow?: boolean;
+        /**
+         * Cursor shown over a selectable row. Defaults to `'pointer'` (a row is
+         * clickable to select); `'default'` opts out for surfaces that prefer the
+         * arrow cursor while still selecting on click.
+         */
+        selectCursor?: "pointer" | "default";
+        /**
+         * `single` mode only. When `true`, clicking the already-selected node
+         * clears the selection (toggle); when `false` (default), a click always
+         * picks and never toggles off — the right default for a required form
+         * field. A navigator that uses selection as a filter opts in.
+         */
+        singleToggle?: boolean;
     } & {
         onMove?: ((payload: MoveEventPayload) => any) | undefined;
         "onUpdate:modelValue"?: ((value: string | string[] | undefined) => any) | undefined;

package/dist/runtime/components/ui/tree/Tree.vue

@@ -17,7 +17,9 @@ const props = defineProps({
   filterPredicate: { type: Function, required: false, default: void 0 },
   filterQuery: { type: String, required: false, default: "" },
   initialExpanded: { type: Array, required: false, default: () => [] },
-  showFocusedRow: { type: Boolean, required: false, default: true }
+  showFocusedRow: { type: Boolean, required: false, default: true },
+  selectCursor: { type: String, required: false, default: "pointer" },
+  singleToggle: { type: Boolean, required: false, default: false }
 });
 const emit = defineEmits(["update:modelValue", "update:roots", "update:expanded", "move"]);
 defineSlots();
@@ -121,6 +123,10 @@ function handleToggleSelect(key) {
   if (props.selectionMode === "single") {
     const loc = state.locate(key);
     if (!loc || !props.selectable(loc.node, loc.depth)) return;
+    if (props.singleToggle && state.selected.has(key)) {
+      state.deselectKey(key);
+      return;
+    }
     state.selectKey(key);
     return;
   }
@@ -282,6 +288,7 @@ const selectedPanePayload = computed(() => ({
           :tree="tree"
           :focused-key="state.focusedKey.value"
           :show-focused-row="showFocusedRow"
+          :select-cursor="selectCursor"
           @toggle-expand="handleToggleExpand"
           @toggle-select="handleToggleSelect"
           @focus-row="handleFocusRow"

package/dist/runtime/components/ui/tree/Tree.vue.d.ts

@@ -30,6 +30,19 @@ declare const __VLS_export: <Node>(__VLS_props: NonNullable<Awaited<typeof __VLS
          * it off so a stray click doesn't leave a permanent highlight.
          */
         showFocusedRow?: boolean;
+        /**
+         * Cursor shown over a selectable row. Defaults to `'pointer'` (a row is
+         * clickable to select); `'default'` opts out for surfaces that prefer the
+         * arrow cursor while still selecting on click.
+         */
+        selectCursor?: "pointer" | "default";
+        /**
+         * `single` mode only. When `true`, clicking the already-selected node
+         * clears the selection (toggle); when `false` (default), a click always
+         * picks and never toggles off — the right default for a required form
+         * field. A navigator that uses selection as a filter opts in.
+         */
+        singleToggle?: boolean;
     } & {
         onMove?: ((payload: MoveEventPayload) => any) | undefined;
         "onUpdate:modelValue"?: ((value: string | string[] | undefined) => any) | undefined;

package/dist/runtime/components/ui/tree/TreeNode.d.vue.ts

@@ -26,6 +26,8 @@ declare const __VLS_export: <Node>(__VLS_props: NonNullable<Awaited<typeof __VLS
         tree: TreeHandle<Node>;
         focusedKey: NodeKey | null;
         showFocusedRow: boolean;
+        /** Cursor over a selectable row. `'default'` opts out of the pointer. */
+        selectCursor: "pointer" | "default";
     } & {
         "onToggle-expand"?: ((key: string) => any) | undefined;
         "onToggle-select"?: ((key: string) => any) | undefined;

package/dist/runtime/components/ui/tree/TreeNode.vue

@@ -27,7 +27,8 @@ const props = defineProps({
   isExpandable: { type: Function, required: true },
   tree: { type: Object, required: true },
   focusedKey: { type: [String, null], required: true },
-  showFocusedRow: { type: Boolean, required: true }
+  showFocusedRow: { type: Boolean, required: true },
+  selectCursor: { type: String, required: true }
 });
 const emit = defineEmits(["toggle-expand", "toggle-select", "focus-row"]);
 defineSlots();
@@ -115,7 +116,8 @@ const showChildren = computed(
       v-if="subtreeMatches"
       :class="cn(
   'group flex items-center justify-between gap-2 rounded px-1 py-1 outline-none transition-colors',
-  selectionMode !== 'none' && userSelectable && 'cursor-pointer hover:bg-zinc-100/70',
+  selectionMode !== 'none' && userSelectable && 'hover:bg-zinc-100/70',
+  selectionMode !== 'none' && userSelectable && (selectCursor === 'default' ? 'cursor-default' : 'cursor-pointer'),
   selectedFlag && !indeterminateFlag && 'bg-(--primary)/10 hover:bg-(--primary)/15',
   showFocusedRow && focusedKey === key && 'bg-(--primary)/10'
 )"
@@ -242,6 +244,7 @@ const showChildren = computed(
           :tree="tree"
           :focused-key="focusedKey"
           :show-focused-row="showFocusedRow"
+          :select-cursor="selectCursor"
           @toggle-expand="(k) => emit('toggle-expand', k)"
           @toggle-select="(k) => emit('toggle-select', k)"
           @focus-row="(k) => emit('focus-row', k)"

package/dist/runtime/components/ui/tree/TreeNode.vue.d.ts

@@ -26,6 +26,8 @@ declare const __VLS_export: <Node>(__VLS_props: NonNullable<Awaited<typeof __VLS
         tree: TreeHandle<Node>;
         focusedKey: NodeKey | null;
         showFocusedRow: boolean;
+        /** Cursor over a selectable row. `'default'` opts out of the pointer. */
+        selectCursor: "pointer" | "default";
     } & {
         "onToggle-expand"?: ((key: string) => any) | undefined;
         "onToggle-select"?: ((key: string) => any) | undefined;

package/dist/runtime/share/slot-renderer.d.vue.ts

@@ -3,6 +3,11 @@ import type { Environment } from '../vendor/cel-js/lib/index.js';
 import type { SlotValue } from './layout.js';
 type EntryLike = Readonly<{
     runtime: Component;
+    metadata?: Readonly<{
+        h?: Readonly<{
+            grow?: boolean;
+        }>;
+    }>;
 }>;
 type __VLS_Props = {
     slotValue: SlotValue;

package/dist/runtime/share/slot-renderer.vue

@@ -26,16 +26,50 @@ function pickLayout(sets) {
   return sets[sets.length - 1];
 }
 const activeLayout = computed(() => pickLayout(props.slotValue.layouts));
+const warnedMissing = /* @__PURE__ */ new Set();
+const placedBlocks = computed(() => {
+  const layout = activeLayout.value?.layout;
+  if (!layout) return [];
+  const out = [];
+  for (const b of props.slotValue.blocks) {
+    const block = b;
+    const placement = layout.placements[block.id];
+    if (!placement) continue;
+    const entry = props.findEntry(block.type, block.compatibilityDate);
+    if (!entry) {
+      const key = `${block.type}@${block.compatibilityDate}`;
+      if (!warnedMissing.has(key)) {
+        warnedMissing.add(key);
+        console.warn(`[shwfed-slot-renderer] no registered block type for ${key}`);
+      }
+      continue;
+    }
+    out.push({ block, placement, entry });
+  }
+  return out;
+});
 const gridStyle = computed(() => {
   const l = activeLayout.value?.layout;
   if (!l) return "";
   const tracks = (n, min) => `repeat(${n}, minmax(${min}, 1fr))`;
   const gap = `calc(${l.gap ?? DEFAULT_GAP} * 0.25rem)`;
   const colGap = l.columns > 1 ? `min(${gap}, calc(100% / ${l.columns - 1}))` : gap;
+  let rowTemplate = "";
+  if (l.rows) {
+    const grows = Array.from({ length: l.rows }, () => false);
+    for (const p of placedBlocks.value) {
+      if (!p.entry.metadata?.h?.grow) continue;
+      const [[, y1], [, y2]] = p.placement.area;
+      const lo = Math.max(1, y1);
+      const hi = Math.min(l.rows, y2 - 1);
+      for (let r = lo; r <= hi; r++) grows[r - 1] = true;
+    }
+    rowTemplate = grows.map((g) => g ? "auto" : "minmax(auto, 1fr)").join(" ");
+  }
   const parts = [
     "display: grid",
     `grid-template-columns: ${tracks(l.columns, "0")}`,
-    l.rows ? `grid-template-rows: ${tracks(l.rows, "auto")}` : "",
+    rowTemplate ? `grid-template-rows: ${rowTemplate}` : "",
     `column-gap: ${colGap}`,
     `row-gap: ${gap}`,
     l.style ?? ""
@@ -55,33 +89,14 @@ function cellStyle(placement) {
   }
   return parts.join("; ");
 }
-const warnedMissing = /* @__PURE__ */ new Set();
-const rendered = computed(() => {
-  const layout = activeLayout.value?.layout;
-  if (!layout) return [];
-  const out = [];
-  for (const b of props.slotValue.blocks) {
-    const block = b;
-    const placement = layout.placements[block.id];
-    if (!placement) continue;
-    const entry = props.findEntry(block.type, block.compatibilityDate);
-    if (!entry) {
-      const key = `${block.type}@${block.compatibilityDate}`;
-      if (!warnedMissing.has(key)) {
-        warnedMissing.add(key);
-        console.warn(`[shwfed-slot-renderer] no registered block type for ${key}`);
-      }
-      continue;
-    }
-    out.push({
-      key: block.id,
-      style: cellStyle(placement),
-      component: entry.runtime,
-      block
-    });
-  }
-  return out;
-});
+const rendered = computed(
+  () => placedBlocks.value.map((p) => ({
+    key: p.block.id,
+    style: cellStyle(p.placement),
+    component: p.entry.runtime,
+    block: p.block
+  }))
+);
 function updateBlock(id, next) {
   const blocks = props.slotValue.blocks.map((b) => b.id === id ? next : b);
   emit("update:slotValue", { ...props.slotValue, blocks });

package/dist/runtime/share/slot-renderer.vue.d.ts

@@ -3,6 +3,11 @@ import type { Environment } from '../vendor/cel-js/lib/index.js';
 import type { SlotValue } from './layout.js';
 type EntryLike = Readonly<{
     runtime: Component;
+    metadata?: Readonly<{
+        h?: Readonly<{
+            grow?: boolean;
+        }>;
+    }>;
 }>;
 type __VLS_Props = {
     slotValue: SlotValue;

package/dist/runtime/share/tree-node-var.d.ts

@@ -0,0 +1,25 @@
+import type { Environment } from '../vendor/cel-js/lib/index.js';
+/**
+ * The per-node `node` CEL variable shared by every tree surface — the tree form
+ * fields, the tree-combobox table columns, and the `tree.single` config block.
+ * Always `dyn`: the node payload shape is backend-defined and unknowable at
+ * design time. The description varies a little per surface, so it is a
+ * parameter rather than baked in here.
+ */
+export declare const NODE_VAR_TYPE = "dyn";
+export declare const NODE_VAR_DESCRIPTION = "\u5F53\u524D\u8282\u70B9\uFF1B\u7531 `\u6570\u636E` \u8868\u8FBE\u5F0F\u8FD4\u56DE\u7684\u6BCF\u4E00\u9879";
+/**
+ * Register the per-node `node` (dyn) CEL variable, skipping it when an enclosing
+ * `configure` already declared it. Idempotent so a tree field/column/block
+ * nested inside a `configure` that already exposes `node` doesn't re-register
+ * it — the CEL registry throws `'node' is already registered` on the second
+ * declaration. This is the case the `tree.single` config block hits: it threads
+ * `node` into its per-node Actions, whose modal-layout button may host a form
+ * (or table) containing another tree surface, so building that nested schema
+ * would otherwise declare `node` twice on one env. Mirrors
+ * `registerRowVariablesIfAbsent` / `registerFormVariablesIfAbsent`.
+ */
+export declare function registerNodeVariableIfAbsent(env: Environment, meta?: {
+    label?: string;
+    description?: string;
+}): void;

package/dist/runtime/share/tree-node-var.js

@@ -0,0 +1,10 @@
+export const NODE_VAR_TYPE = "dyn";
+export const NODE_VAR_DESCRIPTION = "\u5F53\u524D\u8282\u70B9\uFF1B\u7531 `\u6570\u636E` \u8868\u8FBE\u5F0F\u8FD4\u56DE\u7684\u6BCF\u4E00\u9879";
+export function registerNodeVariableIfAbsent(env, meta = {}) {
+  const declared = new Set(env.getDefinitions().variables.map((v) => v.name));
+  if (declared.has("node")) return;
+  env.registerVariable("node", NODE_VAR_TYPE, {
+    ...meta.label !== void 0 ? { label: meta.label } : {},
+    description: meta.description ?? NODE_VAR_DESCRIPTION
+  });
+}

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

@@ -24,7 +24,7 @@ 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`), `optional.none()`, `optional.hasValue()`, `optional.value()`, `optional.or(optional)`, `optional.orValue(value)`, plus `optional<A>.flatMap(var, body): optional<B>` (monadic bind) and `optional<A>.map(var, body): optional<B>` (the Functor `fmap`) — all local additions (not from upstream). Both are variable-binding macros (registered with `(ast, ast)` arg types so the body stays unevaluated): on `Some` they bind the value 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`. `map` is the derived `o.flatMap(v, optional.of(body))` promoted to a first-class macro. NOTE: `map` is **registered in `macros.ts`**, not here — the parser resolves a macro by name before types are known, so the optional `map` and the list-comprehension `map` must share one expander that dispatches on the receiver type at type-check (an `optional` receiver → fmap; `list`/`map` → comprehension; a `dyn` receiver is deferred to a runtime `Option.isOption` check).
 
-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.
+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. `.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.
 The `__proto__` / `constructor` / `prototype` keys are skipped on the top-level record, mirroring `safeFromEntries`.

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

@@ -302,6 +302,12 @@ http.get("https://api.example.com/users")
   .query(form)
   .query("page", string(pageIndex))
 
+// An optional value is unwrapped — `Some` appends the param, `None` drops it
+// entirely (no `key=`). Handy for forwarding an optional `.?` field or filter:
+http.get("https://api.example.com/users")
+  .query("channel", query.?channel)
+  .query("page", optional.of(pageIndex))
+
 // Set request body. An object serializes to JSON; set the Content-Type
 // header yourself. Optional values are unwrapped — a present `.?` field
 // keeps its value, an absent one becomes `null` (the key is kept):

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

@@ -1,16 +1,2 @@
-/**
- * HTTP built-ins for CEL — a local (non-upstream) extension.
- *
- * Registers the `http` / `HttpRequest` types, the `http` constant, and the
- * request-builder functions on the registry. `http.get(url).header(...).body(...)`
- * builds an `HttpRequestBuilder` — a pure *description* of a request. CEL never
- * issues it: both `.json()` and `.file()` are dispatched by the host on the
- * returned builder, so expression evaluation stays free of IO.
- *
- * Wired into `globalRegistry` at module load (see `evaluator.ts`), so every
- * `Environment` gets HTTP for free — both type-checking and evaluation.
- *
- * Endpoints must be absolute URLs; there is no base-URL resolution.
- */
 import type { Registry } from './registry.js.js';
 export declare function registerHttpBuiltins(registry: Registry): void;

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

@@ -1,3 +1,4 @@
+import { Option } from "effect";
 import { HttpRequestBuilder } from "./http-builder.js";
 class Http {
   brand = "http";
@@ -44,6 +45,22 @@ export function registerHttpBuiltins(registry) {
     "HttpRequest.query(string, number): HttpRequest",
     (b, k, v) => b.query(k, Number(v))
   );
+  registry.registerFunctionOverload(
+    "HttpRequest.query(string, optional<string>): HttpRequest",
+    (b, k, v) => {
+      const builder = b;
+      const value = v;
+      return Option.isSome(value) ? builder.query(k, value.value) : builder;
+    }
+  );
+  registry.registerFunctionOverload(
+    "HttpRequest.query(string, optional<number>): HttpRequest",
+    (b, k, v) => {
+      const builder = b;
+      const value = v;
+      return Option.isSome(value) ? builder.query(k, Number(value.value)) : builder;
+    }
+  );
   registry.registerFunctionOverload(
     "HttpRequest.query(dyn): HttpRequest",
     (b, record) => b.query(record)

package/package.json

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