@shwfed/config 2.12.4 → 2.12.6

package/dist/runtime/components/tabs/use-reorder.js

@@ -0,0 +1,90 @@
+import { onBeforeUnmount, ref } from "vue";
+import { combine } from "@atlaskit/pragmatic-drag-and-drop/combine";
+import {
+  draggable,
+  dropTargetForElements
+} from "@atlaskit/pragmatic-drag-and-drop/element/adapter";
+import {
+  attachClosestEdge,
+  extractClosestEdge
+} from "@atlaskit/pragmatic-drag-and-drop-hitbox/closest-edge";
+const SOURCE_KIND = "shwfed-tab";
+export function useTabReorder(options) {
+  const indicator = ref(null);
+  const dragging = ref(null);
+  const regs = /* @__PURE__ */ new Map();
+  function rewire(path, reg) {
+    reg.cleanup?.();
+    if (!reg.el) {
+      reg.cleanup = null;
+      return;
+    }
+    const el = reg.el;
+    reg.cleanup = combine(
+      draggable({
+        element: el,
+        getInitialData: () => ({ kind: SOURCE_KIND, path }),
+        onDragStart: () => {
+          dragging.value = path;
+        },
+        onDrop: () => {
+          dragging.value = null;
+          if (indicator.value) indicator.value = null;
+        }
+      }),
+      dropTargetForElements({
+        element: el,
+        canDrop: ({ source }) => source.data.kind === SOURCE_KIND && source.data.path !== path,
+        getIsSticky: () => true,
+        getData: ({ input, element }) => attachClosestEdge(
+          { kind: `${SOURCE_KIND}-target`, path },
+          { input, element, allowedEdges: ["left", "right"] }
+        ),
+        onDrag: ({ self }) => {
+          const edge = extractClosestEdge(self.data);
+          if (edge === "left" || edge === "right") indicator.value = { path, edge };
+          else if (indicator.value?.path === path) indicator.value = null;
+        },
+        onDragLeave: () => {
+          if (indicator.value?.path === path) indicator.value = null;
+        },
+        onDrop: ({ source, self }) => {
+          indicator.value = null;
+          const edge = extractClosestEdge(self.data);
+          const sourcePath = typeof source.data.path === "string" ? source.data.path : null;
+          if ((edge === "left" || edge === "right") && sourcePath && sourcePath !== path) {
+            options.onReorder(sourcePath, path, edge);
+          }
+        }
+      })
+    );
+  }
+  function setTab(path, el) {
+    let reg = regs.get(path);
+    if (!reg) {
+      reg = { el: null, cleanup: null };
+      regs.set(path, reg);
+    }
+    if (reg.el === el) return;
+    reg.el = el;
+    rewire(path, reg);
+    if (!reg.el && !reg.cleanup) {
+      regs.delete(path);
+      if (indicator.value?.path === path) indicator.value = null;
+      if (dragging.value === path) dragging.value = null;
+    }
+  }
+  function edgeFor(path) {
+    return indicator.value?.path === path ? indicator.value.edge : null;
+  }
+  function isDragging(path) {
+    return dragging.value === path;
+  }
+  onBeforeUnmount(() => {
+    for (const reg of regs.values()) reg.cleanup?.();
+    regs.clear();
+    indicator.value = null;
+    dragging.value = null;
+  });
+  return { setTab, edgeFor, isDragging };
+}

package/dist/runtime/components/tabs/use-tabs.d.ts

@@ -0,0 +1,46 @@
+import { type Ref } from 'vue';
+import { type ReorderInstruction } from '../../share/reorder.js';
+import type { Tab } from './types.js';
+/**
+ * The app-level tab store — a client singleton (per the module's "runtime
+ * singletons, not Nuxt injections" direction). Holds the open tabs (persisted to
+ * `sessionStorage` so they survive a refresh but die with the browser tab) and
+ * the resolved title logic.
+ *
+ * Deliberately framework-free: it never touches the router. Mutations that imply
+ * a navigation RETURN the `fullPath` the caller should navigate to (or `null`
+ * when no navigation is needed); the `ShwfedTabs` strip performs the actual
+ * `navigateTo`. This keeps the store trivially unit-testable and lets other
+ * call sites (the page `close` operation) reuse it without a router in scope.
+ */
+export interface TabStore {
+    tabs: Ref<Tab[]>;
+    activePath: Ref<string | null>;
+    /** Ensure a tab for `path` exists and mark it active (route-change driven). */
+    openOrFocus: (path: string, fullPath: string) => void;
+    /** Remove a tab; returns the fullPath to navigate to when the active tab was closed. */
+    close: (path: string, home?: string) => string | null;
+    /** Keep only `path` (and pinned tabs); returns a nav target if the active tab was closed. */
+    closeOthers: (path: string) => string | null;
+    /** Close non-pinned tabs to the right of `path`; returns a nav target if active was closed. */
+    closeToRight: (path: string) => string | null;
+    reorder: (sourcePath: string, targetPath: string, instruction: ReorderInstruction) => void;
+    /**
+     * Title precedence: page title (by path) → nav label (query-specific by
+     * fullPath, else by path) → raw path. Takes the tab so the title can reflect
+     * the current query variant while identity stays path-only.
+     */
+    resolveTitle: (tab: {
+        path: string;
+        fullPath: string;
+    }, locale: string) => string;
+    hasTab: (path: string) => boolean;
+}
+export declare function createTabStore(storageKey: string): TabStore;
+/**
+ * Access the shared tab store. Created once, in a detached effect scope so its
+ * `sessionStorage` reactivity is not disposed when the first component that
+ * touched it unmounts. `storageKey` only takes effect on first creation (there
+ * is one strip per app).
+ */
+export declare function useTabStore(storageKey?: string): TabStore;

package/dist/runtime/components/tabs/use-tabs.js

@@ -0,0 +1,101 @@
+import { effectScope, ref } from "vue";
+import { useSessionStorage } from "@vueuse/core";
+import { getLocalizedText } from "../../share/locale.js";
+import { readNavLabel } from "../../utils/nav-registry.js";
+import { readPageTitle } from "../../utils/page-title-registry.js";
+import { applyReorder } from "../../share/reorder.js";
+export function createTabStore(storageKey) {
+  const tabs = useSessionStorage(storageKey, []);
+  const activePath = ref(null);
+  function indexOf(path) {
+    return tabs.value.findIndex((t) => t.path === path);
+  }
+  function openOrFocus(path, fullPath) {
+    const existing = tabs.value.find((t) => t.path === path);
+    if (existing) {
+      if (existing.fullPath !== fullPath) {
+        tabs.value = tabs.value.map((t) => t.path === path ? { ...t, fullPath } : t);
+      }
+    } else {
+      tabs.value = [...tabs.value, { path, fullPath }];
+    }
+    activePath.value = path;
+  }
+  function close(path, home) {
+    const idx = indexOf(path);
+    if (idx < 0) return null;
+    const target = tabs.value[idx];
+    if (!target || target.pinned) return null;
+    const wasActive = activePath.value === path;
+    const next = tabs.value.slice(0, idx).concat(tabs.value.slice(idx + 1));
+    tabs.value = next;
+    if (!wasActive) return null;
+    const neighbor = next[idx] ?? next[idx - 1] ?? null;
+    if (neighbor) {
+      activePath.value = neighbor.path;
+      return neighbor.fullPath;
+    }
+    activePath.value = null;
+    return home ?? null;
+  }
+  function closeOthers(path) {
+    tabs.value = tabs.value.filter((t) => t.pinned || t.path === path);
+    if (activePath.value === path) return null;
+    const target = tabs.value.find((t) => t.path === path);
+    if (target) {
+      activePath.value = path;
+      return target.fullPath;
+    }
+    return null;
+  }
+  function closeToRight(path) {
+    const idx = indexOf(path);
+    if (idx < 0) return null;
+    const removed = new Set(
+      tabs.value.slice(idx + 1).filter((t) => !t.pinned).map((t) => t.path)
+    );
+    if (removed.size === 0) return null;
+    tabs.value = tabs.value.filter((t) => !removed.has(t.path));
+    if (activePath.value && removed.has(activePath.value)) {
+      activePath.value = path;
+      return tabs.value.find((t) => t.path === path)?.fullPath ?? null;
+    }
+    return null;
+  }
+  function reorder(sourcePath, targetPath, instruction) {
+    const src = indexOf(sourcePath);
+    const tgt = indexOf(targetPath);
+    if (src < 0 || tgt < 0) return;
+    const next = applyReorder(tabs.value, src, tgt, instruction);
+    if (next !== tabs.value) tabs.value = next;
+  }
+  function resolveTitle(tab, locale) {
+    const fromPage = getLocalizedText(readPageTitle(tab.path), locale);
+    if (fromPage) return fromPage;
+    const fromNav = readNavLabel(tab.fullPath, tab.path)?.label;
+    if (fromNav) return fromNav;
+    return tab.path;
+  }
+  function hasTab(path) {
+    return indexOf(path) >= 0;
+  }
+  return {
+    tabs,
+    activePath,
+    openOrFocus,
+    close,
+    closeOthers,
+    closeToRight,
+    reorder,
+    resolveTitle,
+    hasTab
+  };
+}
+let singleton = null;
+export function useTabStore(storageKey = "shwfed:tabs") {
+  if (!singleton) {
+    const scope = effectScope(true);
+    singleton = scope.run(() => createTabStore(storageKey));
+  }
+  return singleton;
+}

package/dist/runtime/components/ui/date-picker/DatePickerInput.d.vue.ts

@@ -28,8 +28,8 @@ declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {},
     "onUpdate:modelValue"?: ((args_0: Date | undefined) => any) | undefined;
 }>, {
     size: "sm" | "md" | "lg";
-    clearIcon: string;
     clearable: boolean;
+    clearIcon: string;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
 declare const _default: typeof __VLS_export;

package/dist/runtime/components/ui/date-picker/DatePickerInput.vue.d.ts

@@ -28,8 +28,8 @@ declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {},
     "onUpdate:modelValue"?: ((args_0: Date | undefined) => any) | undefined;
 }>, {
     size: "sm" | "md" | "lg";
-    clearIcon: string;
     clearable: boolean;
+    clearIcon: string;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
 declare const _default: typeof __VLS_export;

package/dist/runtime/components/ui/date-picker/DatePickerTimeInput.d.vue.ts

@@ -22,8 +22,8 @@ declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {
     size: "sm" | "md" | "lg";
     granularity: "hour" | "minute" | "second";
     hourCycle: 12 | 24;
-    clearIcon: string;
     clearable: boolean;
+    clearIcon: string;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const _default: typeof __VLS_export;
 export default _default;

package/dist/runtime/components/ui/date-picker/DatePickerTimeInput.vue.d.ts

@@ -22,8 +22,8 @@ declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {
     size: "sm" | "md" | "lg";
     granularity: "hour" | "minute" | "second";
     hourCycle: 12 | 24;
-    clearIcon: string;
     clearable: boolean;
+    clearIcon: string;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const _default: typeof __VLS_export;
 export default _default;

package/dist/runtime/components/ui/date-range-picker/DateRangePickerInput.d.vue.ts

@@ -29,8 +29,8 @@ declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {
     "onUpdate:endValue"?: ((args_0: Date | undefined) => any) | undefined;
 }>, {
     size: "sm" | "md" | "lg";
-    clearIcon: string;
     clearable: boolean;
+    clearIcon: string;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const _default: typeof __VLS_export;
 export default _default;

package/dist/runtime/components/ui/date-range-picker/DateRangePickerInput.vue.d.ts

@@ -29,8 +29,8 @@ declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {
     "onUpdate:endValue"?: ((args_0: Date | undefined) => any) | undefined;
 }>, {
     size: "sm" | "md" | "lg";
-    clearIcon: string;
     clearable: boolean;
+    clearIcon: string;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const _default: typeof __VLS_export;
 export default _default;

package/dist/runtime/components/ui/date-range-picker/DateRangePickerTimeInput.d.vue.ts

@@ -26,9 +26,9 @@ declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {
     size: "sm" | "md" | "lg";
     granularity: "hour" | "minute" | "second";
     hourCycle: 12 | 24;
-    rangeSeparatorIcon: string;
-    clearIcon: string;
     clearable: boolean;
+    clearIcon: string;
+    rangeSeparatorIcon: string;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const _default: typeof __VLS_export;
 export default _default;

package/dist/runtime/components/ui/date-range-picker/DateRangePickerTimeInput.vue.d.ts

@@ -26,9 +26,9 @@ declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {
     size: "sm" | "md" | "lg";
     granularity: "hour" | "minute" | "second";
     hourCycle: 12 | 24;
-    rangeSeparatorIcon: string;
-    clearIcon: string;
     clearable: boolean;
+    clearIcon: string;
+    rangeSeparatorIcon: string;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const _default: typeof __VLS_export;
 export default _default;

package/dist/runtime/components/ui/sidebar/SidebarMenuAction.vue

@@ -14,7 +14,7 @@ const props = defineProps({
     data-slot="sidebar-menu-action"
     data-sidebar="menu-action"
     :class="cn(
-  'text-zinc-500 absolute top-1/2 right-0.5 flex aspect-square w-5 items-center justify-center rounded-md p-0 outline-hidden transition-transform [&>svg]:size-4 [&>svg]:shrink-0 cursor-pointer',
+  'text-zinc-500 absolute top-1/2 right-0.5 flex aspect-square w-5 items-center justify-center rounded-md p-0 outline-hidden transition-transform [&>svg]:size-4 [&>svg]:shrink-0 cursor-default',
   'after:absolute after:-inset-2 md:after:hidden',
   'peer-data-[size=sm]/menu-button:top-1',
   'peer-data-[size=default]/menu-button:top-1.5',

package/dist/runtime/components/ui/sidebar/index.js

@@ -24,11 +24,11 @@ export { default as SidebarSeparator } from "./SidebarSeparator.vue";
 export { default as SidebarTrigger } from "./SidebarTrigger.vue";
 export { useSidebar } from "./utils.js";
 export const sidebarMenuButtonVariants = cva(
-  "peer/menu-button cursor-pointer flex w-full items-center gap-2 overflow-hidden rounded-md p-2 text-left text-sm outline-hidden transition-[width,height,padding,color] duration-180 hover:bg-zinc-100 hover:text-zinc-900 active:bg-zinc-100 active:text-zinc-900 disabled:pointer-events-none disabled:opacity-50 group-has-data-[sidebar=menu-action]/menu-item:pr-8 aria-disabled:pointer-events-none aria-disabled:opacity-50 data-[active=true]:bg-[color-mix(in_srgb,var(--primary)_10%,white)] data-[active=true]:text-(--primary) data-[active=true]:font-mediumdata-[state=open]:hover:bg-zinc-100 data-[state=open]:hover:text-zinc-900 group-data-[collapsible=icon]:size-8! group-data-[collapsible=icon]:p-2! [&>span:last-child]:truncate [&>svg]:size-4 [&>svg]:shrink-0",
+  "peer/menu-button cursor-default flex w-full items-center gap-2 overflow-hidden rounded-md p-2 text-left text-sm outline-hidden transition-[width,height,padding,color] duration-180 hover:bg-zinc-100 hover:text-zinc-900 active:bg-zinc-100 active:text-zinc-900 disabled:pointer-events-none disabled:opacity-50 group-has-[>[data-sidebar=menu-action]]/menu-item:pr-8 aria-disabled:pointer-events-none aria-disabled:opacity-50 data-[active=true]:bg-[color-mix(in_srgb,var(--primary)_10%,white)] data-[active=true]:text-(--primary) data-[active=true]:font-mediumdata-[state=open]:hover:bg-zinc-100 data-[state=open]:hover:text-zinc-900 group-data-[collapsible=icon]:size-8! group-data-[collapsible=icon]:p-2! [&>span:last-child]:truncate [&>svg]:size-4 [&>svg]:shrink-0",
   {
     variants: {
       variant: {
-        default: "group-hover/menu-item:bg-zinc-100 group-hover/menu-item:text-zinc-900 group-focus-within/menu-item:bg-zinc-100 group-focus-within/menu-item:text-zinc-900 text-zinc-800",
+        default: "text-zinc-800",
         outline: "bg-white shadow-[0_0_0_1px_hsl(var(--sidebar-border))] hover:bg-zinc-100 hover:text-zinc-900 hover:shadow-[0_0_0_1px_hsl(var(--sidebar-accent))]"
       },
       size: {

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

@@ -0,0 +1,2 @@
+export type ReorderInstruction = 'reorder-above' | 'reorder-below';
+export declare function applyReorder<T>(items: ReadonlyArray<T>, sourceIndex: number, targetIndex: number, position: ReorderInstruction): ReadonlyArray<T>;

package/dist/runtime/share/reorder.js

@@ -0,0 +1,12 @@
+export function applyReorder(items, sourceIndex, targetIndex, position) {
+  if (sourceIndex === targetIndex) return items;
+  if (sourceIndex < 0 || sourceIndex >= items.length) return items;
+  if (targetIndex < 0 || targetIndex >= items.length) return items;
+  let insertIdx = targetIndex + (position === "reorder-below" ? 1 : 0);
+  if (sourceIndex < targetIndex) insertIdx -= 1;
+  if (insertIdx === sourceIndex) return items;
+  const next = items.slice();
+  const [moved] = next.splice(sourceIndex, 1);
+  next.splice(insertIdx, 0, moved);
+  return next;
+}

package/dist/runtime/utils/nav-registry.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Route → nav-label index, published by the sidebar and read by the tab strip.
+ * A client singleton (not a Nuxt injection). This is title source #2 in the
+ * tab-title precedence chain (page title → nav label → raw path).
+ *
+ * Two indexes so a tab title can be QUERY-AWARE while tab identity stays
+ * path-only: `fullMap` keys by the node's exact route (path + query, hash
+ * stripped) so `/orders?status=open` and `/orders?status=closed` resolve to
+ * their own labels; `pathMap` keys by path (first-wins) as the fallback for a
+ * location that matches no exact node route. The sidebar owns the whole map
+ * (one nav per app), so publishing wholesale-replaces both.
+ */
+export interface NavLabel {
+    label: string;
+    icon?: string;
+}
+export declare function publishNavLabels(full: Map<string, NavLabel>, path: Map<string, NavLabel>): void;
+export declare function clearNavLabels(): void;
+export declare function readNavLabel(fullPath: string, path: string): NavLabel | undefined;

package/dist/runtime/utils/nav-registry.js

@@ -0,0 +1,14 @@
+import { ref } from "vue";
+const fullMap = ref(/* @__PURE__ */ new Map());
+const pathMap = ref(/* @__PURE__ */ new Map());
+export function publishNavLabels(full, path) {
+  fullMap.value = new Map(full);
+  pathMap.value = new Map(path);
+}
+export function clearNavLabels() {
+  if (fullMap.value.size > 0) fullMap.value = /* @__PURE__ */ new Map();
+  if (pathMap.value.size > 0) pathMap.value = /* @__PURE__ */ new Map();
+}
+export function readNavLabel(fullPath, path) {
+  return fullMap.value.get(fullPath.split("#")[0] ?? fullPath) ?? pathMap.value.get(path);
+}

package/dist/runtime/utils/page-title-registry.d.ts

@@ -0,0 +1,3 @@
+import type { LocaleValue } from '../share/locale.js';
+export declare function publishPageTitle(path: string, title: LocaleValue | undefined): void;
+export declare function readPageTitle(path: string): LocaleValue | undefined;

package/dist/runtime/utils/page-title-registry.js

@@ -0,0 +1,11 @@
+import { ref } from "vue";
+const registry = ref(/* @__PURE__ */ new Map());
+export function publishPageTitle(path, title) {
+  const next = new Map(registry.value);
+  if (title && title.length > 0) next.set(path, title);
+  else next.delete(path);
+  registry.value = next;
+}
+export function readPageTitle(path) {
+  return registry.value.get(path);
+}

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

@@ -8,11 +8,11 @@ When modifying this library, keep both `CLAUDE.md` and `PROMPT.md` in sync with
 
 ## Key Modifications
 
-`int` and `uint` types have been removed in favor of a unified `number` type backed by `Decimal` (arbitrary-precision arithmetic via BigInt). All numeric literals, arithmetic results, and size/index returns are `Decimal` instances. The `int()`, `uint()`, and `double()` conversion functions still exist as aliases but all return `number`.
+`int` and `uint` types have been removed in favor of a unified `number` type backed by `Decimal` (arbitrary-precision arithmetic via BigInt). All numeric literals, arithmetic results, and size/index returns are `Decimal` instances. The `int()`, `uint()`, and `double()` conversion functions have been **removed entirely** (calling them is an unknown-function error), the CEL `u`/`U` uint-literal suffix (`123u`, `0xFFu`) is a parse error, and the protobufjs field mapping emits `number` for all numeric/enum fields. Explicit rounding lives in the `math` namespace (`math-builtins.ts`, registered like `JSON`): `math.trunc` / `math.floor` / `math.ceil` / `math.round` (ties away from zero, cel-go style) / `math.abs`, plus `math.min` / `math.max` in `(number, number)` and `(list<number>)` overloads (empty list throws). All are exact — implemented on `Decimal`'s BigInt representation (`decimal.ts` `toInteger`), never via a float round-trip.
 
-`google.protobuf.Timestamp` and `google.protobuf.Duration` have been removed. Replaced with a `Date` type backed by `TZDate` from `@date-fns/tz`, constructed via `date(string)` or `date(number)` (a Unix timestamp — the seconds-vs-milliseconds unit is auto-detected by magnitude: values `< 1e11` are read as seconds, the rest as milliseconds). Date manipulation uses date-fns functions (`startOf`, `endOf`, `offset`, `set`, `format`). `Date.diff(Date, string): number` returns the signed, truncated-toward-zero distance between two dates in a given unit (`millisecond` / `second` / `minute` / `hour` / `day` / `week` / `month` / `year`, plural tolerated) — the receiver is the minuend (`a.diff(b, unit)` = `a − b`, mirroring date-fns `differenceInX(left, right)`); there is no `Date − Date` operator and no duration type, so this is the way to measure elapsed time.
+`google.protobuf.Timestamp` and `google.protobuf.Duration` have been removed. Replaced with a `Date` type backed by `TZDate` from `@date-fns/tz`, constructed via `date(string)` or `date(number)` (a Unix timestamp — the seconds-vs-milliseconds unit is auto-detected by magnitude: values `< 1e11` are read as seconds, the rest as milliseconds). Two-argument forms `date(string, tz)` / `date(number, tz)` anchor an explicit zone (IANA name or fixed offset, validated eagerly via `Intl`): an offset-less wall-clock string (`"2024-06-15T09:00"`, matched by `WALL_CLOCK_STRING`) is interpreted *in that zone* through the TZDate component constructor — NOT via `new TZDate(string, tz)`, whose string path parses machine-local and uses the zone for rendering only — while strings with an explicit offset keep their instant. `Date.tz(string)` re-renders the same instant in another zone. Date manipulation uses date-fns functions, all table-driven through a shared `pickUnit` lookup with a uniform trailing-`s` plural tolerance: `startOf` / `endOf` (`minute` / `hour` / `day` / `week` / `month` / `year`), `offset` and `diff` (`millisecond` … `year`), `set` and the `Date.get(string): number` accessor (`millisecond` … `year`, `month` 1-based, plus `weekday` on `get`, ISO 1 = Monday … 7 = Sunday), and `format`. `Date.diff(Date, string): number` returns the signed, truncated-toward-zero distance between two dates — the receiver is the minuend (`a.diff(b, unit)` = `a − b`, mirroring date-fns `differenceInX(left, right)`); there is no `Date − Date` operator and no duration type, so this is the way to measure elapsed time. Conversions: `number(Date)` is the epoch-millisecond timestamp (round-trips through `date(number)`), `string(Date)` is ISO 8601 rendered with the date's own zone offset.
 
-A `range()` built-in has been added (not from upstream) — `range(number, number)`, `range(number, number, number)` and `range(Date, Date, string)`. It builds an end-exclusive list; the direction follows the operands (counts down when `start > end`); `step` is a positive magnitude; the date unit is `year` / `month` / `day` / `hour` / `minute`. Output length is capped at 100000.
+A `range()` built-in has been added (not from upstream) — `range(number, number)`, `range(number, number, number)` and `range(Date, Date, string)`. It builds an end-exclusive list; the direction follows the operands (counts down when `start > end`); `step` is a positive magnitude; the date unit is `second` / `minute` / `hour` / `day` / `week` / `month` / `year` (plural tolerated). Output length is capped at 100000.
 
 A `list.enumerate(): list<map<string, dyn>>` receiver method has been added (not from upstream, in `functions.ts` beside `list.size()`) — pairs each element with its 0-based index as a plain `{index, value}` record (CEL has no tuple type). It is a plain function, not a macro (no variable binding); the index is a `Decimal` so it stays a CEL `number` for downstream arithmetic. Receiver `list` resolves to `list<dyn>`, so it matches any list.
 
@@ -24,7 +24,7 @@ A `string.replace(string, string): string` / `string.replace(string, string, num
 
 The `homogeneousAggregateLiterals` and `enableOptionalTypes` environment options have been removed. Aggregate data structures (lists, maps) are always heterogeneous — mixed-type literals are inferred as `list<dyn>` or `map<dyn, dyn>`. Optional types (`.?`, `[?]`, `optional.*` helpers) are always enabled.
 
-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).
+The custom `Optional` class has been replaced with Effect's `Option` type (`import { Option } from 'effect'`). Internal helpers `optionalOf(value)` and `optionalValue(opt)` in `optional.js` handle the CEL-specific semantics (treating `undefined` as `None`, throwing `EvaluationError` on missing value access). The optional surface is `optional.of(A): optional<A>` (the lift / `pure` — `of(null)` is `Some(null)`), `optional.ofNullable(A): optional<A>` (the null-tolerant lift, Java-style — `null` becomes `None`), `optional.none()`, `optional.hasValue()`, `optional.value()`, `optional.or(optional)`, `optional.orValue(value)`, plus `optional<A>.flatMap(var, body): optional<B>` (monadic bind), `optional<A>.map(var, body): optional<B>` (the Functor `fmap`), `optional<A>.zip(other, x, y, body): optional<C>` (the applicative `liftA2` / `zipWith`), `optional<A>.filter(var, predicate): optional<A>` (Rust `Option::filter` / Haskell `mfilter`), and the folds `optional<A>.exists(var, predicate): bool` (predicate on `Some`, `false` on `None` — Rust `is_some_and`) and `optional<A>.all(var, predicate): bool` (predicate on `Some`, vacuously `true` on `None` — Scala `forall`) — all local additions (not from upstream). All are variable-binding macros (registered with `ast` arg types so the unbound args stay unevaluated): on `Some` they bind the value(s) and evaluate `body`; on `None` they short-circuit without touching `body`. `flatMap`'s body must itself yield an `optional`; `map`'s body is a plain value that gets re-wrapped in `Some`; `filter` / `exists` / `all` predicates must be `bool` (enforced at type-check when static, at runtime via `invalid_condition_type` otherwise). `map` is the derived `o.flatMap(v, optional.of(body))` promoted to a first-class macro. `zip` is the flattened `a.flatMap(x, b.map(y, body))`: it type-checks `other` in the outer ctx, binds `x` then `y` under two chained overlays, re-wraps the plain body in `Some`, and short-circuits to `None` if either side is `None` (a `None` receiver skips evaluating `other`). Because CEL has no tuple type the transform is fused (there is no useful `optional<pair>` to return), so `zip` is `zipWith`, not Rust/Scala's pair-building `Option.zip`. The short-circuit makes `zip` observationally monadic — harmless for `optional` (a `None` carries no payload) but it would not generalise to an error-accumulating applicative. An `optional.none()` receiver/argument carries a `param` element type; the shared `bindOptionalValueType` helper (exported from `optional.ts`) binds it as `dyn` so a boolean body still type-checks — every binding macro (`map` / `flatMap` / `zip` / `filter` / `exists` / `all`) goes through it (leaking the `param` into the iteration variable was a real bug in `map` / `flatMap`, regression-tested in `optional-extras.test.ts`). `zip` lives in `optional.ts` beside `flatMap`; the two-variable binding is why it is not folded into the shared `map` expander. NOTE: `map`, `filter`, `all`, and `exists` are **registered in `macros.ts`**, not here — the parser resolves a macro by name before types are known, so the optional variants and the list-comprehension variants must share one expander per name that dispatches on the receiver type at type-check (an `optional` receiver → optional semantics; `list`/`map` → comprehension; a `dyn` receiver is deferred to a runtime `Option.isOption` check). `exists_one` and `find` stay list-only.
 
 An `http` built-in has been added (`http-builtins.ts`, `http-builder.ts`) — not from upstream. It registers the `http` constant and the `http` / `HttpRequest` types on `globalRegistry`, so `http.get(url).header(...).body(...)` expressions type-check and evaluate in every `Environment`. A CEL expression only builds an `HttpRequestBuilder` — a pure description of a request; it never issues one. The terminal methods `.json()`, `.file()`, and `.fileOrJson()` are dispatched by the host on the returned builder (none is a CEL method), so expression evaluation stays free of IO. `.fileOrJson()` branches on the response `Content-Type`: a JSON media type (`application/json` or a `+json` suffix) is parsed and returned as `{ _tag: 'json', json }`; anything else is returned as `{ _tag: 'file', file }`. Note the `Fetch` service itself `ensureOk`s (both `FetchLive` and the mock layer), so a non-2xx fails at `Fetch.fetch` before the branch and this only ever distinguishes 2xx bodies — i.e. the HTTP-200-with-error-envelope case. The download operation uses it so a backend that answers a download with a JSON error envelope (commonly `{ code: -1 }` on a 200) is classified rather than saved as the file. Endpoints must be absolute URLs — there is no base-URL resolution. Depends on `fx-fetch`. The host can register process-wide default headers via `HttpRequestBuilder.setDefaultHeader(name, valueOrGetter)` / `clearDefaultHeader(name)`; they are merged in at `#buildRequest()` time, with case-insensitive precedence to an explicit `.header(...)` on the builder. A getter that returns `null` / `undefined` / `''` skips the header for that request, so the host can source values from live refs (e.g. the active i18n locale for `Accept-Language`) without baking in stale snapshots. `.query` accepts `(string, string)` / `(string, number)`, the optional-valued `(string, optional<string>)` / `(string, optional<number>)` (a `None`, e.g. an absent `.?` field, drops the param rather than emitting `key=`; `Some` appends it via the string/number coercion), and the record-splat `(dyn)`.
 
@@ -47,11 +47,12 @@ lib/
 ├── operators.ts      — Binary/unary operator implementations
 ├── overloads.ts      — Operator overload definitions
 ├── functions.ts      — Built-in functions + Date type (TZDate)
-├── macros.ts         — map (list comprehension + optional fmap), filter, all, exists, exists_one, find, has, cel.bind
+├── macros.ts         — map / filter / all / exists (each dispatching list comprehension vs optional receiver), exists_one, find, has, cel.bind
 ├── http-builtins.ts  — `http` constant + http/HttpRequest types (local addition)
 ├── http-builder.ts   — `HttpRequestBuilder` — what an http.* expression returns
 ├── json-builtins.ts  — `JSON` constant + `JSON.parse` / `JSON.stringify` (local addition)
 ├── form-builtins.ts  — `form(map): FormData` global + `FormData` type (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