@shwfed/config 2.0.0 → 2.0.1

package/dist/runtime/share/use-active-tab-id.js

@@ -0,0 +1,34 @@
+import { onMounted, ref, watch } from "vue";
+const STORAGE_PREFIX = "shwfed.tabs.";
+export function useActiveTabId(blockId, tabIds) {
+  const active = ref(tabIds.value[0] ?? "");
+  const key = () => `${STORAGE_PREFIX}${blockId}`;
+  onMounted(() => {
+    if (typeof window === "undefined") return;
+    try {
+      const stored = window.sessionStorage.getItem(key());
+      if (stored && tabIds.value.includes(stored)) {
+        active.value = stored;
+      }
+    } catch {
+    }
+  });
+  watch(tabIds, (next) => {
+    if (next.includes(active.value)) return;
+    active.value = next[0] ?? "";
+    if (typeof window === "undefined") return;
+    try {
+      window.sessionStorage.removeItem(key());
+    } catch {
+    }
+  });
+  watch(active, (next) => {
+    if (typeof window === "undefined") return;
+    if (!next) return;
+    try {
+      window.sessionStorage.setItem(key(), next);
+    } catch {
+    }
+  });
+  return active;
+}

package/dist/runtime/shims.d.ts

@@ -0,0 +1,4 @@
+declare module '*.md?raw' {
+  const content: string
+  export default content
+}

package/dist/runtime/style.css

@@ -0,0 +1 @@
+@import "tailwindcss";@plugin "@tailwindcss/typography";@source "components";@utility prose-xs{font-size:.75rem;line-height:1.6666667}@theme{--font-sans:"Noto Sans","Noto Sans SC","Noto Sans JP","sans-serif";--font-mono:"Berkeley Mono","Fira Mono","monospace"}

package/dist/runtime/utils/ai/cel-prompt.d.ts

@@ -0,0 +1,11 @@
+import type { CELContext } from '../cel-context.js';
+import celSyntaxGuide from '../../vendor/cel-js/PROMPT.md?raw.js';
+export { celSyntaxGuide };
+export interface ComposeCelPromptInput {
+    readonly scope?: ReadonlyArray<{
+        readonly name: string;
+        readonly context: CELContext;
+    }>;
+    readonly task: string;
+}
+export declare function composeCelPrompt(input: ComposeCelPromptInput): string;

package/dist/runtime/utils/ai/cel-prompt.js

@@ -0,0 +1,27 @@
+import celSyntaxGuide from "../../vendor/cel-js/PROMPT.md?raw";
+export { celSyntaxGuide };
+function renderScope(scope) {
+  const lines = [];
+  for (const { name, context } of scope) {
+    const entries = Object.entries(context);
+    if (entries.length === 0) continue;
+    lines.push(`### ${name}`);
+    lines.push("");
+    lines.push("| Variable | Type | Description |");
+    lines.push("|----------|------|-------------|");
+    for (const [varName, entry] of entries) {
+      const desc = (entry.description ?? entry.label).replace(/\|/g, "\\|").replace(/\n/g, " ");
+      lines.push(`| \`${varName}\` | \`${entry.type}\` | ${desc} |`);
+    }
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+export function composeCelPrompt(input) {
+  const parts = [celSyntaxGuide];
+  if (input.scope && input.scope.length > 0) {
+    parts.push("# Variables In Scope", "", renderScope(input.scope));
+  }
+  parts.push("# Task", "", input.task);
+  return parts.join("\n");
+}

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

@@ -0,0 +1,39 @@
+import { type ComputedRef } from 'vue';
+import { Schema } from 'effect';
+export interface GenerateTextInput {
+    readonly prompt: string;
+    readonly system?: string;
+    readonly signal?: AbortSignal;
+    readonly maxTokens?: number;
+    readonly onProgress?: () => void;
+}
+export interface AgenticTool {
+    readonly name: string;
+    readonly description: string;
+    readonly inputJsonSchema: unknown;
+    readonly execute: (input: unknown) => unknown | Promise<unknown>;
+}
+export interface GenerateObjectInput<A, I extends Record<string, unknown>> {
+    readonly prompt: string;
+    readonly system?: string;
+    readonly schema: Schema.Schema<A, I>;
+    readonly signal?: AbortSignal;
+    readonly objectName?: string;
+    readonly maxTokens?: number;
+    readonly onProgress?: () => void;
+    readonly tools?: ReadonlyArray<AgenticTool>;
+    readonly retry?: {
+        readonly previousOutput: unknown;
+        readonly feedback: string;
+    };
+}
+export interface Ai {
+    readonly available: ComputedRef<boolean>;
+    readonly generateText: (input: GenerateTextInput) => Promise<string>;
+    readonly generateObject: <A, I extends Record<string, unknown>>(input: GenerateObjectInput<A, I>) => Promise<A>;
+}
+export declare class StructuredOutputDecodeError extends Error {
+    readonly rawOutput: unknown;
+    constructor(rawOutput: unknown, cause: unknown);
+}
+export declare const ai: Ai;

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

@@ -0,0 +1,257 @@
+import { computed } from "vue";
+import { JSONSchema, Schema } from "effect";
+const ENDPOINT = "http://192.168.168.10/anthropic/v1/messages";
+const MODEL = "MiniMax-M2.7";
+const ANTHROPIC_VERSION = "2023-06-01";
+const DEFAULT_MAX_TOKENS = 8192;
+export class StructuredOutputDecodeError extends Error {
+  rawOutput;
+  constructor(rawOutput, cause) {
+    super(cause instanceof Error ? cause.message : String(cause));
+    this.name = "StructuredOutputDecodeError";
+    this.rawOutput = rawOutput;
+    if (cause !== void 0) this.cause = cause;
+  }
+}
+async function readError(res) {
+  try {
+    const body = await res.json();
+    if (typeof body.error === "string") return body.error;
+    return body.error?.message ?? "";
+  } catch {
+    return await res.text().catch(() => "");
+  }
+}
+async function* readSSE(res) {
+  if (!res.body) return;
+  const reader = res.body.getReader();
+  const decoder = new TextDecoder();
+  let buf = "";
+  for (; ; ) {
+    const { value, done } = await reader.read();
+    if (done) break;
+    buf += decoder.decode(value, { stream: true });
+    buf = buf.replace(/\r\n/g, "\n");
+    let idx;
+    while ((idx = buf.indexOf("\n\n")) !== -1) {
+      const block = buf.slice(0, idx);
+      buf = buf.slice(idx + 2);
+      let event;
+      const dataLines = [];
+      for (const line of block.split("\n")) {
+        if (line.startsWith("event:")) event = line.slice(6).trim();
+        else if (line.startsWith("data:")) dataLines.push(line.slice(5).replace(/^ /, ""));
+      }
+      if (dataLines.length === 0) continue;
+      yield { event, data: dataLines.join("\n") };
+    }
+  }
+}
+function buildBody(messages, system, options) {
+  return {
+    model: MODEL,
+    messages,
+    max_tokens: options.maxTokens ?? DEFAULT_MAX_TOKENS,
+    ...system !== void 0 ? { system } : {},
+    ...options.tools !== void 0 ? { tools: options.tools } : {},
+    ...options.toolChoice !== void 0 ? { tool_choice: options.toolChoice } : {}
+  };
+}
+function buildInit(body, signal) {
+  return {
+    method: "POST",
+    headers: {
+      "content-type": "application/json",
+      "anthropic-version": ANTHROPIC_VERSION,
+      "anthropic-dangerous-direct-browser-access": "true"
+    },
+    body: JSON.stringify(body),
+    ...signal ? { signal } : {}
+  };
+}
+async function call(messages, system, options, signal) {
+  const res = await fetch(ENDPOINT, buildInit(buildBody(messages, system, options), signal));
+  if (!res.ok) {
+    throw new Error(`Anthropic ${res.status}: ${await readError(res) || res.statusText}`);
+  }
+  return await res.json();
+}
+async function callStream(messages, system, options, signal, onProgress) {
+  const body = { ...buildBody(messages, system, options), stream: true };
+  const res = await fetch(ENDPOINT, buildInit(body, signal));
+  if (!res.ok) {
+    throw new Error(`Anthropic ${res.status}: ${await readError(res) || res.statusText}`);
+  }
+  const blocks = /* @__PURE__ */ new Map();
+  let stopReason;
+  for await (const ev of readSSE(res)) {
+    if (!ev.event || !ev.data) continue;
+    let payload;
+    try {
+      payload = JSON.parse(ev.data);
+    } catch {
+      continue;
+    }
+    const p = payload;
+    if (p.type === "content_block_start" && typeof p.index === "number" && p.content_block) {
+      const cb = p.content_block;
+      blocks.set(p.index, {
+        type: cb.type === "tool_use" ? "tool_use" : "text",
+        text: "",
+        toolId: cb.id,
+        toolName: cb.name,
+        inputJson: ""
+      });
+    } else if (p.type === "content_block_delta" && typeof p.index === "number" && p.delta) {
+      const cur = blocks.get(p.index);
+      if (!cur) continue;
+      if (p.delta.type === "text_delta" && p.delta.text) {
+        cur.text += p.delta.text;
+        onProgress();
+      } else if (p.delta.type === "input_json_delta" && p.delta.partial_json) {
+        cur.inputJson += p.delta.partial_json;
+        onProgress();
+      }
+    } else if (p.type === "message_delta" && p.delta?.stop_reason) {
+      stopReason = p.delta.stop_reason;
+    } else if (p.type === "message_stop") {
+      break;
+    }
+  }
+  const content = [...blocks.entries()].sort(([a], [b]) => a - b).map(([, v]) => {
+    if (v.type === "tool_use") {
+      let input = {};
+      if (v.inputJson) {
+        try {
+          input = JSON.parse(v.inputJson);
+        } catch {
+          input = {};
+        }
+      }
+      return {
+        type: "tool_use",
+        id: v.toolId ?? "",
+        name: v.toolName ?? "",
+        input
+      };
+    }
+    return { type: "text", text: v.text };
+  });
+  return { content, stop_reason: stopReason };
+}
+const RETRY_TOOL_USE_ID = "retry_call_0";
+function buildUserMessages(prompt) {
+  return [{ role: "user", content: prompt }];
+}
+function appendRetry(messages, retry, toolName) {
+  messages.push({
+    role: "assistant",
+    content: [{
+      type: "tool_use",
+      id: RETRY_TOOL_USE_ID,
+      name: toolName,
+      input: retry.previousOutput
+    }]
+  });
+  messages.push({
+    role: "user",
+    content: [{
+      type: "tool_result",
+      tool_use_id: RETRY_TOOL_USE_ID,
+      content: retry.feedback
+    }]
+  });
+}
+async function generateText(input) {
+  const messages = buildUserMessages(input.prompt);
+  const opts = input.maxTokens !== void 0 ? { maxTokens: input.maxTokens } : {};
+  const response = input.onProgress ? await callStream(messages, input.system, opts, input.signal, input.onProgress) : await call(messages, input.system, opts, input.signal);
+  return response.content.filter((b) => b.type === "text").map((b) => b.text).join("");
+}
+async function generateObject(input) {
+  const toolName = input.objectName ?? "structured_output";
+  const structuredParams = JSONSchema.make(input.schema);
+  const helperTools = input.tools ?? [];
+  const helperByName = new Map(helperTools.map((t) => [t.name, t]));
+  const tools = [
+    ...helperTools.map((t) => ({
+      name: t.name,
+      description: t.description,
+      input_schema: t.inputJsonSchema
+    })),
+    {
+      name: toolName,
+      description: "Return the structured output as the tool input.",
+      input_schema: structuredParams
+    }
+  ];
+  const toolChoice = helperTools.length > 0 ? { type: "any" } : { type: "tool", name: toolName };
+  const messages = buildUserMessages(input.prompt);
+  if (input.retry) appendRetry(messages, input.retry, toolName);
+  const opts = {
+    tools,
+    toolChoice,
+    ...input.maxTokens !== void 0 ? { maxTokens: input.maxTokens } : {}
+  };
+  const decode = (raw) => {
+    try {
+      return Schema.decodeUnknownSync(input.schema)(raw);
+    } catch (cause) {
+      throw new StructuredOutputDecodeError(raw, cause);
+    }
+  };
+  for (; ; ) {
+    const response = input.onProgress ? await callStream(messages, input.system, opts, input.signal, input.onProgress) : await call(messages, input.system, opts, input.signal);
+    const toolUses = response.content.filter(
+      (b) => b.type === "tool_use"
+    );
+    const structured = toolUses.find((c) => c.name === toolName);
+    if (structured) {
+      return decode(structured.input);
+    }
+    if (toolUses.length === 0) {
+      if (response.stop_reason === "max_tokens") {
+        throw new Error("\u6A21\u578B\u5728\u4EA7\u51FA\u7ED3\u6784\u5316\u7ED3\u679C\u524D\u7528\u5C3D\u4E86 token \u9884\u7B97\uFF08stop_reason=max_tokens\uFF09\u3002\u8BF7\u63D0\u9AD8 maxTokens\uFF0C\u6216\u6362\u7528\u975E\u63A8\u7406\u6A21\u578B\u3002");
+      }
+      const text = response.content.filter((b) => b.type === "text").map((b) => b.text).join("");
+      const reason = response.stop_reason ? `\uFF08stop_reason=${response.stop_reason}\uFF09` : "";
+      throw new Error(`\u6A21\u578B\u672A\u8FD4\u56DE\u7ED3\u6784\u5316\u8F93\u51FA${reason}${text ? `: ${text.slice(0, 200)}` : ""}`);
+    }
+    messages.push({
+      role: "assistant",
+      content: toolUses
+    });
+    const results = [];
+    for (const useBlock of toolUses) {
+      const tool = helperByName.get(useBlock.name);
+      if (!tool) {
+        results.push({
+          type: "tool_result",
+          tool_use_id: useBlock.id,
+          content: `Unknown tool: ${useBlock.name}`
+        });
+        continue;
+      }
+      try {
+        const result = await tool.execute(useBlock.input ?? {});
+        results.push({
+          type: "tool_result",
+          tool_use_id: useBlock.id,
+          content: typeof result === "string" ? result : JSON.stringify(result)
+        });
+      } catch (err) {
+        results.push({
+          type: "tool_result",
+          tool_use_id: useBlock.id,
+          content: err instanceof Error ? err.message : String(err)
+        });
+      }
+    }
+    messages.push({ role: "user", content: results });
+  }
+}
+export const ai = {
+  available: computed(() => true),
+  generateText,
+  generateObject
+};

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

@@ -0,0 +1,10 @@
+export type CELVar = {
+    type: string;
+    label: string;
+    description?: string;
+    value: unknown;
+};
+export type CELContext = Record<string, CELVar>;
+export declare function provideCELContext(context: CELContext): void;
+export declare function injectCELContext(): CELContext;
+export declare function celBindings(context: CELContext): Record<string, unknown>;

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

@@ -0,0 +1,16 @@
+import { injectLocal, provideLocal } from "@vueuse/core";
+const CEL_CONTEXT_KEY = Symbol("cel-context");
+export function provideCELContext(context) {
+  const parent = injectLocal(CEL_CONTEXT_KEY, {});
+  provideLocal(CEL_CONTEXT_KEY, { ...parent, ...context });
+}
+export function injectCELContext() {
+  return injectLocal(CEL_CONTEXT_KEY, {});
+}
+export function celBindings(context) {
+  const out = {};
+  for (const [name, entry] of Object.entries(context)) {
+    out[name] = typeof entry.value === "function" ? entry.value() : entry.value;
+  }
+  return out;
+}

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/utils/cn.d.ts

@@ -0,0 +1,2 @@
+import type { ClassValue } from 'clsx';
+export declare const cn: (...classes: ReadonlyArray<ClassValue>) => string;

package/dist/runtime/utils/cn.js

@@ -0,0 +1,3 @@
+import { clsx } from "clsx";
+import { twMerge } from "tailwind-merge";
+export const cn = (...classes) => twMerge(clsx(...classes));

package/dist/runtime/utils/config-clipboard.d.ts

@@ -0,0 +1,4 @@
+import type { Schema } from 'effect';
+export declare const DOC_PROMPT_PREFIX = "\u6211\u6B63\u5728\u914D\u7F6E\u4E00\u4E2A\u7BA1\u7406\u754C\u9762\u7684\u7EC4\u4EF6\uFF0C\u4EE5\u4E0B\u662F\u8BE5\u914D\u7F6E\u7684 JSON Schema\u3002\u8BF7\u6839\u636E\u6211\u7684\u540E\u7EED\u63CF\u8FF0\u5E2E\u6211\u751F\u6210\u4E00\u4EFD\u7B26\u5408\u8BE5 Schema \u7684 JSON \u914D\u7F6E\uFF0C\u53EA\u8F93\u51FA JSON\uFF0C\u4E0D\u8981\u989D\u5916\u7684\u89E3\u91CA\u3002";
+export declare function schemaToJsonMarkdown(schema: Schema.Schema.Any): string;
+export declare function buildLlmUrl(provider: 'claude' | 'chatgpt', prompt: string): string;

package/dist/runtime/utils/config-clipboard.js

@@ -0,0 +1,12 @@
+import { JSONSchema } from "effect";
+export const DOC_PROMPT_PREFIX = "\u6211\u6B63\u5728\u914D\u7F6E\u4E00\u4E2A\u7BA1\u7406\u754C\u9762\u7684\u7EC4\u4EF6\uFF0C\u4EE5\u4E0B\u662F\u8BE5\u914D\u7F6E\u7684 JSON Schema\u3002\u8BF7\u6839\u636E\u6211\u7684\u540E\u7EED\u63CF\u8FF0\u5E2E\u6211\u751F\u6210\u4E00\u4EFD\u7B26\u5408\u8BE5 Schema \u7684 JSON \u914D\u7F6E\uFF0C\u53EA\u8F93\u51FA JSON\uFF0C\u4E0D\u8981\u989D\u5916\u7684\u89E3\u91CA\u3002";
+export function schemaToJsonMarkdown(schema) {
+  const json = JSONSchema.make(schema);
+  return `\`\`\`json
+${JSON.stringify(json)}
+\`\`\``;
+}
+export function buildLlmUrl(provider, prompt) {
+  const q = encodeURIComponent(prompt);
+  return provider === "claude" ? `https://claude.ai/new?q=${q}` : `https://chatgpt.com/?q=${q}`;
+}

package/dist/runtime/utils/markdown-tooltip.d.ts

@@ -0,0 +1,4 @@
+import type MarkdownIt from 'markdown-it';
+declare const TRIGGER_CLASS = "decoration-dashed underline decoration-(--primary) underline-offset-4 cursor-help";
+export default function tooltipPlugin(md: MarkdownIt): void;
+export { TRIGGER_CLASS };

package/dist/runtime/utils/markdown-tooltip.js

@@ -0,0 +1,55 @@
+const OPEN = 123;
+const CLOSE = 125;
+const BACKSLASH = 92;
+const TRIGGER_CLASS = "decoration-dashed underline decoration-(--primary) underline-offset-4 cursor-help";
+function readSegment(src, start, max) {
+  if (start >= max || src.charCodeAt(start) !== OPEN) return null;
+  let pos = start + 1;
+  let out = "";
+  while (pos < max) {
+    const code = src.charCodeAt(pos);
+    if (code === BACKSLASH && pos + 1 < max) {
+      const next = src.charCodeAt(pos + 1);
+      if (next === OPEN || next === CLOSE || next === BACKSLASH) {
+        out += src[pos + 1];
+        pos += 2;
+        continue;
+      }
+      out += src[pos];
+      pos += 1;
+      continue;
+    }
+    if (code === OPEN) return null;
+    if (code === CLOSE) return { end: pos + 1, value: out };
+    out += src[pos];
+    pos += 1;
+  }
+  return null;
+}
+function tooltipRule(state, silent) {
+  const start = state.pos;
+  if (state.src.charCodeAt(start) !== OPEN) return false;
+  const trigger = readSegment(state.src, start, state.posMax);
+  if (!trigger) return false;
+  const content = readSegment(state.src, trigger.end, state.posMax);
+  if (!content) return false;
+  if (!silent) {
+    const token = state.push("tooltip", "", 0);
+    token.markup = "{}{}";
+    token.meta = { trigger: trigger.value, content: content.value };
+  }
+  state.pos = content.end;
+  return true;
+}
+export default function tooltipPlugin(md) {
+  md.inline.ruler.before("emphasis", "tooltip", tooltipRule);
+  md.renderer.rules.tooltip = (tokens, idx) => {
+    const token = tokens[idx];
+    const meta = token?.meta;
+    if (!meta) return "";
+    const trigger = md.renderInline(meta.trigger);
+    const title = md.utils.escapeHtml(meta.content);
+    return `<span class="${TRIGGER_CLASS}" title="${title}">${trigger}</span>`;
+  };
+}
+export { TRIGGER_CLASS };

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

@@ -0,0 +1,5 @@
+import MarkdownIt from 'markdown-it';
+export declare const md: MarkdownIt;
+export declare function renderMarkdown(source: string, options?: {
+    block?: boolean;
+}): string;

package/dist/runtime/utils/markdown.js

@@ -0,0 +1,6 @@
+import MarkdownIt from "markdown-it";
+import tooltipPlugin from "./markdown-tooltip.js";
+export const md = new MarkdownIt({ html: true, linkify: false, breaks: true }).use(tooltipPlugin);
+export function renderMarkdown(source, options) {
+  return options?.block ? md.render(source) : md.renderInline(source);
+}

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

@@ -0,0 +1,80 @@
+# Vendored cel-js
+
+Vendored from `@marcbachmann/cel-js` — a JavaScript implementation of Google's Common Expression Language (CEL).
+
+See `VENDORED` for commit hash and date.
+
+When modifying this library, keep both `CLAUDE.md` and `PROMPT.md` in sync with your changes. `CLAUDE.md` is the developer reference for future agents working on the code; `PROMPT.md` is the user-facing guide for agents writing CEL expressions.
+
+## 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`.
+
+`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.
+
+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).
+
+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
+
+```
+lib/
+├── index.ts          — Public exports
+├── parser.ts         — Lexer + recursive descent parser
+├── evaluator.ts      — Expression evaluation engine + Environment class
+├── type-checker.ts   — Static type analysis
+├── registry.ts       — Type system, operator/function registration
+├── operators.ts      — Binary/unary operator implementations
+├── 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
+├── errors.ts         — ParseError, TypeError, EvaluationError
+├── globals.ts        — Shared utilities
+├── types.ts          — Type definitions
+└── options.ts        — Configuration management
+```
+
+## Public API
+
+```js
+import { Environment, ParseError, TypeError, EvaluationError } from './lib/index.js'
+```
+
+- `new Environment(options?)` — Create a configured environment
+  - `.check(expr)` — Returns `Either<string, ParseError | TypeError>` (success = type name string)
+  - `.evaluate<T>(expr, ctx?)` — Returns `Effect<T, ParseError | TypeError | EvaluationError>`
+  - `.registerVariable(name, type, options?)`
+  - `.registerConstant(name, type, value)`
+  - `.registerFunction(signature, handler, options?)`
+  - `.registerOperator(signature, handler)`
+  - `.registerType(typename, definition)`
+  - `.clone(options?)` — Copy with overrides
+
+Internal-only (not re-exported from `index.js`): `parse`, standalone `evaluate`/`check`, `serialize`, `Decimal`, `CelError`.
+
+## Type System
+
+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`; method `URL.param(string): string` reads a search param), `File` (native), `http` / `HttpRequest` (local addition — see `http-builtins.ts`)
+
+## Function Signature Format
+
+```
+name(argType1, argType2): returnType     — global function
+Type.method(argTypes): returnType        — method on type
+```
+
+Handler receives `(arg1, arg2, ..., ast, evaluator, context)`. Macros receive AST nodes instead of evaluated values.

package/dist/runtime/vendor/cel-js/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Marc Bachmann
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.