@shwfed/config 1.1.5 → 2.0.1

package/dist/runtime/components/ui/radio-group/RadioGroup.vue

@@ -0,0 +1,32 @@
+<script setup>
+import { reactiveOmit } from "@vueuse/core";
+import { RadioGroupRoot, useForwardPropsEmits } from "reka-ui";
+import { cn } from "../../../utils/cn";
+defineOptions({ name: "UiRadioGroup" });
+const props = defineProps({
+  modelValue: { type: null, required: false },
+  defaultValue: { type: null, required: false },
+  disabled: { type: Boolean, required: false },
+  orientation: { type: String, required: false },
+  dir: { type: String, required: false },
+  loop: { type: Boolean, required: false },
+  asChild: { type: Boolean, required: false },
+  as: { type: null, required: false },
+  name: { type: String, required: false },
+  required: { type: Boolean, required: false },
+  class: { type: [Boolean, null, String, Object, Array], required: false, skipCheck: true }
+});
+const emits = defineEmits(["update:modelValue"]);
+const delegatedProps = reactiveOmit(props, "class");
+const forwarded = useForwardPropsEmits(delegatedProps, emits);
+</script>
+
+<template>
+  <RadioGroupRoot
+    data-slot="radio-group"
+    v-bind="forwarded"
+    :class="cn('grid gap-3', props.class)"
+  >
+    <slot />
+  </RadioGroupRoot>
+</template>

package/dist/runtime/components/ui/radio-group/RadioGroup.vue.d.ts

@@ -0,0 +1,22 @@
+import type { RadioGroupRootProps } from 'reka-ui';
+import type { HTMLAttributes } from 'vue';
+type __VLS_Props = RadioGroupRootProps & {
+    class?: HTMLAttributes['class'];
+};
+declare var __VLS_8: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_8) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:modelValue": (payload: import("reka-ui").AcceptableValue) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    "onUpdate:modelValue"?: ((payload: import("reka-ui").AcceptableValue) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/runtime/components/ui/radio-group/RadioGroupItem.d.vue.ts

@@ -0,0 +1,8 @@
+import type { RadioGroupItemProps } from 'reka-ui';
+import type { HTMLAttributes } from 'vue';
+type __VLS_Props = RadioGroupItemProps & {
+    class?: HTMLAttributes['class'];
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/runtime/components/ui/radio-group/RadioGroupItem.vue

@@ -0,0 +1,36 @@
+<script setup>
+import { reactiveOmit } from "@vueuse/core";
+import { RadioGroupIndicator, RadioGroupItem, useForwardProps } from "reka-ui";
+import { cn } from "../../../utils/cn";
+defineOptions({ name: "UiRadioGroupItem" });
+const props = defineProps({
+  id: { type: String, required: false },
+  value: { type: null, required: false },
+  disabled: { type: Boolean, required: false },
+  asChild: { type: Boolean, required: false },
+  as: { type: null, required: false },
+  name: { type: String, required: false },
+  required: { type: Boolean, required: false },
+  class: { type: [Boolean, null, String, Object, Array], required: false, skipCheck: true }
+});
+const delegatedProps = reactiveOmit(props, "class");
+const forwarded = useForwardProps(delegatedProps);
+</script>
+
+<template>
+  <RadioGroupItem
+    data-slot="radio-group-item"
+    v-bind="forwarded"
+    :class="cn(
+  'peer cursor-pointer flex items-center justify-center border-zinc-200 data-[state=checked]:border-(--primary) aria-invalid:border-red-400 size-4 shrink-0 rounded-full border shadow-xs hover:shadow transition-shadow outline-none disabled:cursor-not-allowed disabled:opacity-50',
+  props.class
+)"
+  >
+    <RadioGroupIndicator
+      data-slot="radio-group-indicator"
+      class="grid h-full w-full place-content-center"
+    >
+      <span class="size-2 rounded-full bg-(--primary)" />
+    </RadioGroupIndicator>
+  </RadioGroupItem>
+</template>

package/dist/runtime/components/ui/radio-group/RadioGroupItem.vue.d.ts

@@ -0,0 +1,8 @@
+import type { RadioGroupItemProps } from 'reka-ui';
+import type { HTMLAttributes } from 'vue';
+type __VLS_Props = RadioGroupItemProps & {
+    class?: HTMLAttributes['class'];
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/runtime/components/ui/radio-group/index.d.ts

@@ -0,0 +1,2 @@
+export { default as RadioGroup } from './RadioGroup.vue.js';
+export { default as RadioGroupItem } from './RadioGroupItem.vue.js';

package/dist/runtime/components/ui/radio-group/index.js

@@ -0,0 +1,2 @@
+export { default as RadioGroup } from "./RadioGroup.vue";
+export { default as RadioGroupItem } from "./RadioGroupItem.vue";

package/dist/runtime/composables/useOverlay.d.ts

@@ -96,13 +96,9 @@ export declare function openModal<T = unknown>(options: {
     props?: Record<string, unknown>;
 }): Effect.Effect<{
     patch: (props: Record<string, unknown>) => Effect.Effect<void>;
+    close: () => Effect.Effect<void>;
     modal: Effect.Effect<OverlayResult<T>>;
 }, OverlayDefinitionNotFoundError, ActionContext | Scope.Scope>;
-export declare function confirm(input: {
-    content: string;
-    icon?: string;
-    color?: string;
-}): Effect.Effect<boolean>;
 export declare function reject(input: {
     content: string;
     icon?: string;

package/dist/runtime/composables/useOverlay.js

@@ -256,13 +256,14 @@ export function openModal(options) {
     }
     return {
       patch: (props) => handle.patch({ props }),
+      // Lets the modal body request its own dismissal (e.g. an in-modal
+      // close button reached via a bubbled op-request). Idempotent — a
+      // no-op once the session has already been closed.
+      close: () => handle.close(),
       modal: handle.result
     };
   });
 }
-export function confirm(input) {
-  return overlayRuntime.openAlert(input);
-}
 export function reject(input) {
   return Effect.map(overlayRuntime.openAlert(input), (confirmed) => !confirmed);
 }

package/dist/runtime/composables/useTranslateLocale.js

@@ -1,6 +1,6 @@
 import { ref } from "vue";
 import { Schema } from "effect";
-import { useNuxtApp } from "#app";
+import { ai as $ai } from "../utils/ai/index.js";
 const SingleTranslation = Schema.Struct({
   message: Schema.String
 }).annotations({ identifier: "LocaleSingleTranslation" });
@@ -21,7 +21,6 @@ function buildSystem(target, hint) {
   ].join(" ");
 }
 export function useTranslateLocale(options = {}) {
-  const { $ai } = useNuxtApp();
   const inFlight = ref(/* @__PURE__ */ new Set());
   function isTranslating(target) {
     return inFlight.value.has(target);

package/dist/runtime/share/event-bus.d.ts

@@ -0,0 +1,118 @@
+import { Effect, Schema } from 'effect';
+import type { InjectionKey, Ref } from 'vue';
+/** A descendant button asking an ancestor instance to run an operation. */
+export type OpRequest = Readonly<{
+    /** Instance id of the ancestor that should handle this request. */
+    target: string;
+    /** Operation id from that component type's capability manifest. */
+    operation: string;
+}>;
+/**
+ * The persisted form of a trigger — one stored row addressing an ancestor
+ * instance's operation. At runtime each row is dispatched verbatim as an
+ * `OpRequest`.
+ */
+export declare const Trigger: Schema.Struct<{
+    target: Schema.refine<string, typeof Schema.String>;
+    operation: Schema.SchemaClass<string, string, never>;
+}>;
+/**
+ * An ordered list of triggers. A button that fires triggers embeds this as
+ * one of its own config fields — re-annotated for that button's own
+ * semantics (e.g. a network button's "请求成功后" / "请求失败后"). There is no
+ * host-level trigger field; what triggers a button carries, and when they
+ * fire, is decided by the button type. List order is execution order.
+ */
+export declare const Triggers: Schema.Array$<Schema.Struct<{
+    target: Schema.refine<string, typeof Schema.String>;
+    operation: Schema.SchemaClass<string, string, never>;
+}>>;
+/** One stored trigger row. */
+export type TriggerValue = Schema.Schema.Type<typeof Trigger>;
+/**
+ * One node of the bubbling channel. `dispatch` runs the matching operation
+ * when a request targets this node's instance, then always forwards to the
+ * parent — requests bubble to the tree root with no interception. It returns
+ * an Effect (the handler then the bubble) instead of running eagerly, so
+ * callers can sequence requests.
+ */
+export type EventChannel = Readonly<{
+    dispatch: (request: OpRequest) => Effect.Effect<void>;
+}>;
+/**
+ * Operation id → handler, for one operation-exposing instance. Handlers
+ * return an Effect so the bus can run them serially and in order. They are
+ * infallible by contract: an operation that can fail must swallow/log
+ * internally (mirrors the table's fetch-error contract) so a serial trigger
+ * chain never aborts halfway because one trigger quietly failed.
+ */
+export type OperationHandlers = Readonly<Record<string, () => Effect.Effect<void>>>;
+export declare const EVENT_CHANNEL_KEY: InjectionKey<EventChannel>;
+/**
+ * Build a channel node for an operation-exposing instance. `dispatch` runs
+ * the handler for requests addressed to `instanceId`, then bubbles every
+ * request — handled or not — up to `parent`. Handler-then-bubble is one
+ * Effect, so the whole delivery is sequenced.
+ */
+export declare function createEventChannel(instanceId: string, operations: OperationHandlers, parent: EventChannel | undefined): EventChannel;
+/**
+ * Register the current component as an operation target for its descendants.
+ * Only works across the normal Vue inject tree — detached subtrees (a modal
+ * slot rendered in an overlay container) must bridge explicitly with
+ * `createEventChannel` + a manual `provide(EVENT_CHANNEL_KEY, …)`.
+ */
+export declare function provideEventTarget(instanceId: string, operations: OperationHandlers): void;
+/**
+ * Inject the nearest channel, for emitters (button hosts). `undefined` when
+ * no operation-exposing ancestor exists — dispatching is then a no-op.
+ */
+export declare function useEventChannel(): EventChannel | undefined;
+/**
+ * Bubble a list of triggers through `channel`, one after another — list
+ * order is execution order and each request's Effect is awaited before the
+ * next, so async handlers (e.g. a table refetch) stay sequenced. A no-op
+ * when there is no channel (no operation-exposing ancestor) or the list is
+ * empty.
+ *
+ * A button that fires triggers composes this into its runtime effect at the
+ * lifecycle point the triggers should fire — the bus no longer runs them.
+ */
+export declare function dispatchTriggers(channel: EventChannel | undefined, triggers: ReadonlyArray<TriggerValue> | undefined): Effect.Effect<void>;
+/**
+ * One operation a component type exposes. `id` is what the trigger stores;
+ * `name`/`icon` are display only.
+ */
+export type OperationDescriptor = Readonly<{
+    id: string;
+    name: string;
+    icon?: string;
+}>;
+/** An operation-exposing ancestor instance, as seen by the trigger config UI. */
+export type EventAncestor = Readonly<{
+    /** Instance id stored as the trigger `target`. */
+    instanceId: string;
+    /**
+     * Instance display name from config — a table's 内部名称, a button's title.
+     * `undefined` when the configurer left it blank; the trigger UI then shows
+     * the type name alone instead of an empty `「」`.
+     */
+    name?: string;
+    /** Component type display name (from type metadata). */
+    typeName: string;
+    /** Component type icon (from type metadata). */
+    typeIcon?: string;
+    /** Operations this instance exposes. */
+    operations: ReadonlyArray<OperationDescriptor>;
+}>;
+/**
+ * Contribute one ancestor frame. Descendant editors see it prepended
+ * (nearest first) to whatever chain was inherited from further up. A `null`
+ * value contributes nothing — for editors whose current selection may or
+ * may not expose operations.
+ */
+export declare function provideEventAncestor(ancestor: Ref<EventAncestor | null>): void;
+/**
+ * The operation-exposing ancestors of the current editing position, nearest
+ * first. Empty when nothing up the tree exposes operations.
+ */
+export declare function useEventAncestry(): Ref<ReadonlyArray<EventAncestor>>;

package/dist/runtime/share/event-bus.js

@@ -0,0 +1,55 @@
+import { computed, inject, provide, shallowRef } from "vue";
+import { Effect, Schema } from "effect";
+export const Trigger = Schema.Struct({
+  target: Schema.UUID.annotations({
+    description: "\u76EE\u6807\u7956\u5148\u5B9E\u4F8B\u7684 ID"
+  }),
+  operation: Schema.String.annotations({
+    description: "\u76EE\u6807\u7EC4\u4EF6\u80FD\u529B\u6E05\u5355\u4E2D\u7684\u64CD\u4F5C ID"
+  })
+}).annotations({
+  title: "Trigger",
+  description: "\u4E00\u6761\u5411\u4E0A\u5192\u6CE1\u7684\u64CD\u4F5C\u8BF7\u6C42"
+});
+export const Triggers = Schema.Array(Trigger).annotations({
+  title: "\u89E6\u53D1\u64CD\u4F5C",
+  description: "\u6309\u5217\u8868\u987A\u5E8F\u6267\u884C"
+});
+export const EVENT_CHANNEL_KEY = Symbol("shwfed/event-channel");
+export function createEventChannel(instanceId, operations, parent) {
+  return {
+    dispatch(request) {
+      const handled = request.target === instanceId ? operations[request.operation]?.() ?? Effect.void : Effect.void;
+      return parent ? Effect.andThen(handled, parent.dispatch(request)) : handled;
+    }
+  };
+}
+export function provideEventTarget(instanceId, operations) {
+  const parent = inject(EVENT_CHANNEL_KEY, void 0);
+  provide(EVENT_CHANNEL_KEY, createEventChannel(instanceId, operations, parent));
+}
+export function useEventChannel() {
+  return inject(EVENT_CHANNEL_KEY, void 0);
+}
+export function dispatchTriggers(channel, triggers) {
+  if (!channel || !triggers || triggers.length === 0) return Effect.void;
+  return Effect.forEach(
+    triggers,
+    (trigger) => channel.dispatch({ target: trigger.target, operation: trigger.operation }),
+    { discard: true }
+  );
+}
+const EVENT_ANCESTRY_KEY = Symbol("shwfed/event-ancestry");
+export function provideEventAncestor(ancestor) {
+  const parent = inject(EVENT_ANCESTRY_KEY, void 0);
+  provide(
+    EVENT_ANCESTRY_KEY,
+    computed(() => {
+      const chain = parent?.value ?? [];
+      return ancestor.value ? [ancestor.value, ...chain] : chain;
+    })
+  );
+}
+export function useEventAncestry() {
+  return inject(EVENT_ANCESTRY_KEY, void 0) ?? shallowRef([]);
+}

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

@@ -5,6 +5,13 @@ type ResultType = string | string[] | ((type: string) => boolean);
 export declare function Expression(options: {
     configure: (env: Environment) => void;
     resultType?: ResultType;
+    /**
+     * Treat identifiers not registered by `configure` as `dyn` instead of
+     * rejecting them. Needed when an expression references variables whose
+     * names are user-defined and unknowable at schema-construction time
+     * (e.g. the chart block's named data sources).
+     */
+    unlistedVariablesAreDyn?: boolean;
 }): Schema.Schema<string, string>;
 export declare function Markdown(options: {
     configure: (env: Environment) => void;

package/dist/runtime/share/expression.js

@@ -36,7 +36,9 @@ function buildDescription(baseline, env, resultType) {
   return parts.join(" ");
 }
 export function Expression(options) {
-  const env = new Environment({ unlistedVariablesAreDyn: false });
+  const env = new Environment({
+    unlistedVariablesAreDyn: options.unlistedVariablesAreDyn ?? false
+  });
   const baseline = env.getDefinitions();
   options.configure(env);
   const description = buildDescription(baseline, env, options.resultType);

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

@@ -9,6 +9,7 @@ export declare const Placement: Schema.Struct<{
     h: Schema.optional<Schema.Literal<["start", "center", "end", "stretch"]>>;
     v: Schema.optional<Schema.Literal<["start", "center", "end", "stretch"]>>;
 }>;
+export declare const DEFAULT_GAP = 4;
 export declare const Layout: Schema.Struct<{
     columns: Schema.refine<number, Schema.filter<typeof Schema.Number>>;
     rows: Schema.optional<Schema.refine<number, Schema.filter<typeof Schema.Number>>>;

package/dist/runtime/share/layout.js

@@ -26,6 +26,7 @@ export const Placement = Schema.Struct({
   title: "Placement",
   description: "\u5757\u5728\u67D0\u4E00\u5E03\u5C40\u4E2D\u7684\u4F4D\u7F6E\u4E0E\u5BF9\u9F50"
 });
+export const DEFAULT_GAP = 4;
 export const Layout = Schema.Struct({
   columns: TrackCount.annotations({
     title: "\u5217\u6570",
@@ -35,9 +36,9 @@ export const Layout = Schema.Struct({
     title: "\u884C\u6570",
     description: "\u603B\u884C\u6570\u3002\u6BCF\u884C\u7B49\u6743\uFF0C\u6E32\u67D3\u65F6\u5C55\u5F00\u4E3A `repeat(N, minmax(0, 1fr))` \u2014 \u5728\u81EA\u7136\u9AD8\u5EA6\u5BB9\u5668\u5185\u7B49\u540C\u4E8E `auto`"
   })),
-  gap: Schema.optional(Schema.Number.pipe(Schema.int(), Schema.positive()).annotations({
+  gap: Schema.optional(Schema.Number.pipe(Schema.int(), Schema.nonNegative()).annotations({
     title: "\u7F51\u683C\u95F4\u8DDD",
-    description: "\u6B63\u6574\u6570\uFF1B\u5B9E\u9645 CSS gap \u4E3A `calc(n * 0.25rem)`\u3002\u672A\u8BBE\u7F6E\u5373\u65E0\u95F4\u8DDD"
+    description: "\u975E\u8D1F\u6574\u6570\uFF1B\u5B9E\u9645 CSS gap \u4E3A `calc(n * 0.25rem)`\u3002\u663E\u5F0F `0` \u8868\u793A\u65E0\u95F4\u8DDD\uFF0C\u672A\u8BBE\u7F6E\u5219\u53D6\u9ED8\u8BA4\u95F4\u8DDD 4\uFF08\u5373 `1rem`\uFF09"
   })),
   style: Schema.optional(Schema.String.annotations({
     title: "\u5BB9\u5668\u6837\u5F0F",

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

@@ -1,8 +1,9 @@
 <script setup>
-import { useNuxtApp } from "#app";
 import { Effect } from "effect";
 import { computed, onMounted, ref, watch } from "vue";
-import { celBindings, injectCELContext } from "../plugins/cel/context";
+import { cel as _rawCel } from "../utils/cel";
+import { celBindings, injectCELContext } from "../utils/cel-context";
+import { DEFAULT_GAP } from "./layout";
 defineOptions({ name: "ShwfedSlotRenderer" });
 const props = defineProps({
   slotValue: { type: Object, required: true },
@@ -10,7 +11,6 @@ const props = defineProps({
   findEntry: { type: Function, required: true }
 });
 const emit = defineEmits(["update:slotValue"]);
-const { $cel: _rawCel } = useNuxtApp();
 const inherited = injectCELContext();
 const $cel = (expression, context) => _rawCel(expression, { ...celBindings(inherited), ...context });
 function pickLayout(sets) {
@@ -40,7 +40,9 @@ const gridStyle = computed(() => {
     "display: grid",
     `grid-template-columns: ${tracks(l.columns)}`,
     l.rows ? `grid-template-rows: ${tracks(l.rows)}` : "",
-    l.gap ? `gap: calc(${l.gap} * 0.25rem)` : "",
+    // Missing `gap` resolves to `DEFAULT_GAP` — the layout editor's fallback —
+    // so the editor and the rendered slot agree. `gap: 0` stays 0.
+    `gap: calc(${l.gap ?? DEFAULT_GAP} * 0.25rem)`,
     l.style ?? ""
   ].filter(Boolean);
   return parts.join("; ");

package/dist/runtime/{plugins → utils}/ai/cel-prompt.d.ts

@@ -1,4 +1,4 @@
-import type { CELContext } from '../cel/context.js';
+import type { CELContext } from '../cel-context.js';
 import celSyntaxGuide from '../../vendor/cel-js/PROMPT.md?raw.js';
 export { celSyntaxGuide };
 export interface ComposeCelPromptInput {

package/dist/runtime/{plugins → utils}/ai/index.d.ts

@@ -36,9 +36,4 @@ export declare class StructuredOutputDecodeError extends Error {
     readonly rawOutput: unknown;
     constructor(rawOutput: unknown, cause: unknown);
 }
-declare const _default: import("#app").Plugin<{
-    ai: Ai;
-}> & import("#app").ObjectPlugin<{
-    ai: Ai;
-}>;
-export default _default;
+export declare const ai: Ai;

package/dist/runtime/{plugins → utils}/ai/index.js

@@ -1,4 +1,3 @@
-import { defineNuxtPlugin } from "#app";
 import { computed } from "vue";
 import { JSONSchema, Schema } from "effect";
 const ENDPOINT = "http://192.168.168.10/anthropic/v1/messages";
@@ -251,16 +250,8 @@ async function generateObject(input) {
     messages.push({ role: "user", content: results });
   }
 }
-export default defineNuxtPlugin({
-  name: "shwfed:ai",
-  setup: () => {
-    const ai = {
-      available: computed(() => true),
-      generateText,
-      generateObject
-    };
-    return {
-      provide: { ai }
-    };
-  }
-});
+export const ai = {
+  available: computed(() => true),
+  generateText,
+  generateObject
+};

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

@@ -0,0 +1,5 @@
+import type { Either } from 'effect';
+import { Effect } from 'effect';
+import type { ParseError, TypeError, EvaluationError } from '../vendor/cel-js/lib/errors.js';
+export declare function cel<T>(expression: string, context?: Record<string, unknown>): Effect.Effect<T, ParseError | TypeError | EvaluationError>;
+export declare function celCheck(expression: string): Either.Either<string, ParseError | TypeError>;

package/dist/runtime/utils/cel.js

@@ -0,0 +1,42 @@
+import { Effect, Option } from "effect";
+import { Decimal } from "../vendor/cel-js/lib/decimal.js";
+import { Environment } from "../vendor/cel-js/lib/index.js";
+function unwrapCelValue(value) {
+  if (value === null || value === void 0) return value;
+  if (value instanceof Decimal) return value.toNumber();
+  if (Option.isOption(value)) {
+    return Option.isSome(value) ? unwrapCelValue(value.value) : void 0;
+  }
+  if (Array.isArray(value)) return value.map(unwrapCelValue);
+  if (typeof value === "object") {
+    const proto = Object.getPrototypeOf(value);
+    if (proto !== Object.prototype && proto !== null) return value;
+    const out = {};
+    for (const key of Object.keys(value)) {
+      out[key] = unwrapCelValue(value[key]);
+    }
+    return out;
+  }
+  return value;
+}
+const env = new Environment({ unlistedVariablesAreDyn: true });
+env.registerFunction(
+  "media(string): bool",
+  (_self, q) => typeof window !== "undefined" && window.matchMedia(q).matches
+);
+env.registerFunction(
+  "list<number>.sum(): number",
+  (list) => list.reduce(
+    (acc, n) => acc.add(n),
+    Decimal.from(0)
+  )
+);
+export function cel(expression, context) {
+  return Effect.map(
+    env.evaluate(expression, context),
+    (v) => unwrapCelValue(v)
+  );
+}
+export function celCheck(expression) {
+  return env.check(expression);
+}

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

@@ -10,7 +10,9 @@ When modifying this library, keep both `CLAUDE.md` and `PROMPT.md` in sync with
 
 `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`.
 
-`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)`. Date manipulation uses date-fns functions (`startOf`, `endOf`, `offset`, `set`, `format`).
+`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`).
+
+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.
 
 `evaluate` now returns `Effect<T, ParseError | EvaluationError | TypeError>` instead of a plain value. The entire evaluation pipeline is Effect-based — every AST node's `evaluate` function returns an Effect, and sub-expressions are composed via `Effect.gen` / `yield*`. Promise-based async handling has been removed. User-registered functions may return `Effect` values, which are automatically flatMapped into the evaluation pipeline. Import `Effect` from `effect` and use `Effect.runSync` or `Effect.runPromise` to execute the returned Effect.
 
@@ -18,6 +20,8 @@ The `homogeneousAggregateLiterals` and `enableOptionalTypes` environment options
 
 The custom `Optional` class has been replaced with Effect's `Option` type (`import { Option } from 'effect'`). Internal helpers `optionalOf(value)` and `optionalValue(opt)` in `optional.js` handle the CEL-specific semantics (treating `undefined` as `None`, throwing `EvaluationError` on missing value access).
 
+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 *describes* a request; it evaluates to an `HttpRequestBuilder`, and the host dispatches it via `.json()` / `.file()`. Endpoints must be absolute URLs — there is no base-URL resolution. Depends on `fx-fetch`.
+
 ## Architecture
 
 ```
@@ -31,6 +35,8 @@ lib/
 ├── overloads.ts      — Operator overload definitions
 ├── functions.ts      — Built-in functions + Date type (TZDate)
 ├── macros.ts         — map, filter, all, exists, 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
 ├── decimal.ts        — Decimal class (arbitrary precision)
 ├── optional.ts       — Optional type support (uses Effect Option)
 ├── serialize.ts      — AST back to CEL string
@@ -62,7 +68,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`)
+Custom: `Date` (backed by `TZDate` from `@date-fns/tz`), `URL` (backed by the native `URL`; method `URL.param(string): string` reads a search param), `File` (native), `http` / `HttpRequest` (local addition — see `http-builtins.ts`)
 
 ## Function Signature Format