@shwfed/config 1.0.0

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

@@ -0,0 +1,116 @@
+<script setup>
+import { useNuxtApp } from "#app";
+import { Effect } from "effect";
+import { computed, onMounted, ref, watch } from "vue";
+import { celBindings, injectCELContext } from "../plugins/cel/context";
+defineOptions({ name: "ShwfedSlotRenderer" });
+const props = defineProps({
+  slotValue: { type: Object, required: true },
+  configure: { type: Function, required: true },
+  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) {
+  if (sets.length === 0) return void 0;
+  for (const set of sets) {
+    if (!set.media) return set;
+    try {
+      if (Effect.runSync($cel(set.media))) return set;
+    } catch (err) {
+      console.error(`[shwfed-slot-renderer] failed to evaluate layout media for ${set.name}:`, err);
+    }
+  }
+  return sets[sets.length - 1];
+}
+const activeLayout = ref();
+onMounted(() => {
+  activeLayout.value = pickLayout(props.slotValue.layouts);
+});
+watch(() => props.slotValue.layouts, (sets) => {
+  activeLayout.value = pickLayout(sets);
+}, { deep: false });
+const gridStyle = computed(() => {
+  const l = activeLayout.value?.layout;
+  if (!l) return "";
+  const tracks = (n) => `repeat(${n}, minmax(auto, 1fr))`;
+  const parts = [
+    "display: grid",
+    `grid-template-columns: ${tracks(l.columns)}`,
+    l.rows ? `grid-template-rows: ${tracks(l.rows)}` : "",
+    l.gap ? `gap: calc(${l.gap} * 0.25rem)` : "",
+    l.style ?? ""
+  ].filter(Boolean);
+  return parts.join("; ");
+});
+function cellStyle(placement) {
+  const [[x1, y1], [x2, y2]] = placement.area;
+  const parts = [`grid-column: ${x1} / ${x2}`, `grid-row: ${y1} / ${y2}`];
+  const h = placement.h && placement.h !== "stretch" ? placement.h : null;
+  const v = placement.v && placement.v !== "stretch" ? placement.v : null;
+  if (h || v) {
+    parts.push("display: flex");
+    const toFlex = (a) => a === "start" ? "flex-start" : a === "end" ? "flex-end" : "center";
+    if (h) parts.push(`justify-content: ${toFlex(h)}`);
+    if (v) parts.push(`align-items: ${toFlex(v)}`);
+  }
+  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;
+});
+function updateBlock(id, next) {
+  const blocks = props.slotValue.blocks.map((b) => b.id === id ? next : b);
+  emit("update:slotValue", { ...props.slotValue, blocks });
+}
+</script>
+
+<template>
+  <div
+    :style="gridStyle"
+    :class="rendered.length === 0 && $slots.empty ? 'min-h-32 grid place-items-center text-xs text-zinc-400 select-none' : ''"
+  >
+    <slot
+      v-if="rendered.length === 0"
+      name="empty"
+    />
+    <div
+      v-for="r in rendered"
+      :key="r.key"
+      :style="r.style"
+    >
+      <component
+        :is="r.component"
+        :block="r.block"
+        :configure="configure"
+        @update:block="(next) => updateBlock(r.block.id, next)"
+      />
+    </div>
+  </div>
+</template>

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

@@ -0,0 +1,50 @@
+import type { Component } from 'vue';
+import type { Environment } from '../vendor/cel-js/lib/index.js';
+import type { SlotValue } from './layout.js';
+type EntryLike = Readonly<{
+    runtime: Component;
+}>;
+type __VLS_Props = {
+    slotValue: SlotValue;
+    configure: (env: Environment) => void;
+    /**
+     * Registry lookup. Returns `undefined` when the block type/date pair is
+     * not registered — the renderer skips those cells and logs once.
+     */
+    findEntry: (type: string, compatibilityDate: string) => EntryLike | undefined;
+};
+declare var __VLS_1: {};
+type __VLS_Slots = {} & {
+    empty?: (props: typeof __VLS_1) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:slotValue": (next: Readonly<{
+        blocks: ReadonlyArray<Readonly<{
+            id: string;
+        } & Record<string, unknown>>>;
+        layouts: readonly Readonly<{
+            name: string;
+            media?: string;
+            layout: import("./layout.js").LayoutValue;
+        }>[];
+    }>) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    "onUpdate:slotValue"?: ((next: Readonly<{
+        blocks: ReadonlyArray<Readonly<{
+            id: string;
+        } & Record<string, unknown>>>;
+        layouts: readonly Readonly<{
+            name: string;
+            media?: string;
+            layout: import("./layout.js").LayoutValue;
+        }>[];
+    }>) => 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/share/use-active-tab-id.d.ts

@@ -0,0 +1,13 @@
+import { type ComputedRef, type Ref } from 'vue';
+/**
+ * Tracks the currently-active tab id for a tabs block.
+ *
+ * - Initial value is `tabIds.value[0]` so SSR and first client render agree
+ *   (no hydration mismatch). The stored id from `sessionStorage` is applied
+ *   in `onMounted`, after hydration completes.
+ * - When `tabIds` changes and the active id is no longer present, fall back
+ *   to the first tab and clear the stored value — otherwise a later re-add
+ *   of the same id would silently re-stick the old selection.
+ * - All writes are guarded against unavailable storage (privacy modes, SSR).
+ */
+export declare function useActiveTabId(blockId: string, tabIds: ComputedRef<string[]>): Ref<string>;

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

@@ -0,0 +1,23 @@
+import type { HttpRequestBuilder } from './plugins/http/builder'
+import type { Effect, Either } from 'effect'
+import type { toast } from 'vue-sonner'
+import type { ParseError, TypeError, EvaluationError } from './vendor/cel-js/lib/errors'
+
+interface HttpService {
+  get: (endpoint: string) => HttpRequestBuilder
+  post: (endpoint: string) => HttpRequestBuilder
+  put: (endpoint: string) => HttpRequestBuilder
+  patch: (endpoint: string) => HttpRequestBuilder
+  delete: (endpoint: string) => HttpRequestBuilder
+}
+
+declare module '#app' {
+  interface NuxtApp {
+    $http: HttpService
+    $cel: <T>(expression: string, context?: Record<string, unknown>) => Effect.Effect<T, ParseError | TypeError | EvaluationError>
+    $celCheck: (expression: string) => Either.Either<string, ParseError | TypeError>
+    $toast: typeof toast
+  }
+}
+
+export {}

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,74 @@
+# 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)`. Date manipulation uses date-fns functions (`startOf`, `endOf`, `offset`, `set`, `format`).
+
+`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).
+
+## 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
+├── 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`)
+
+## 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.