@shwfed/config 2.11.5 → 2.12.0

package/dist/runtime/components/table/ai-generate.vue

@@ -0,0 +1,172 @@
+<script setup>
+import { computed, onMounted, ref, shallowRef, toRaw } from "vue";
+import { Icon } from "@iconify/vue";
+import { toast } from "vue-sonner";
+import { ai as $ai } from "../../utils/ai";
+import { createMessageId } from "../../utils/ai/parts";
+import { usePersistedChat } from "../../share/use-persisted-chat";
+import { ChatMessages, ChatPrompt } from "../ui/chat";
+import { Button } from "../ui/button";
+import { getSystemTemplate } from "./ai-generate.system";
+import { createTableAiTools } from "./utils/ai-tools";
+defineOptions({ name: "ShwfedTableAiGenerate" });
+const config = defineModel({ type: Object, ...{ required: true } });
+const props = defineProps({
+  configure: { type: Function, required: false }
+});
+const configure = props.configure ?? (() => {
+});
+const messages = ref([]);
+const streaming = shallowRef(null);
+const input = ref("");
+const busy = ref(false);
+let controller = null;
+const { restore: restoreChat, clear: clearChat } = usePersistedChat(
+  () => config.value.id,
+  messages
+);
+onMounted(restoreChat);
+const working = shallowRef(config.value);
+const tools = createTableAiTools({
+  read: () => working.value,
+  write: (next) => {
+    const fresh = { ...next };
+    working.value = fresh;
+    config.value = fresh;
+  },
+  // `configure` is threaded into each tool's schema factory so the AI sees
+  // the same CEL scope the inline UI validates against. Replaces the old
+  // `schema` field (a full `TableConfig` Schema); per-tool schemas are now
+  // built internally from `configure`.
+  configure,
+  genUuid: () => crypto.randomUUID()
+});
+function buildSystem() {
+  return getSystemTemplate();
+}
+function snapshot(m) {
+  return { id: m.id, role: m.role, parts: m.parts.map((p) => ({ ...p })) };
+}
+const status = computed(() => busy.value ? "streaming" : "ready");
+const displayMessages = computed(
+  () => streaming.value ? [...messages.value, streaming.value] : messages.value
+);
+const pending = computed(() => {
+  if (!busy.value) return false;
+  const s = streaming.value;
+  if (!s) return true;
+  return s.parts.every((p) => p.type === "step-start" || p.type === "text" && !p.text);
+});
+const canSend = computed(() => !busy.value && input.value.trim().length > 0);
+const canClear = computed(() => !busy.value && messages.value.length > 0);
+function newConversation() {
+  if (!canClear.value) return;
+  messages.value = [];
+  clearChat();
+  input.value = "";
+}
+function commitPartial(partial) {
+  if (partial && partial.parts.length > 0) {
+    messages.value = [...messages.value, partial];
+  }
+}
+async function send() {
+  if (!canSend.value) return;
+  const text = input.value.trim();
+  input.value = "";
+  messages.value = [
+    ...messages.value,
+    { id: createMessageId(), role: "user", parts: [{ type: "text", text }] }
+  ];
+  try {
+    working.value = structuredClone(toRaw(config.value));
+  } catch {
+    working.value = config.value;
+  }
+  busy.value = true;
+  streaming.value = null;
+  controller = new AbortController();
+  try {
+    const final = await $ai.streamChat({
+      messages: messages.value,
+      system: buildSystem(),
+      tools,
+      signal: controller.signal,
+      // Re-publish a fresh snapshot per part mutation so the stream renders.
+      onMessageUpdate: (assistant) => {
+        streaming.value = snapshot(assistant);
+      }
+    });
+    messages.value = [...messages.value, final];
+  } catch (err) {
+    if (controller?.signal.aborted) {
+      commitPartial(streaming.value);
+    } else {
+      const message = err instanceof Error ? err.message : String(err);
+      toast.error("\u751F\u6210\u5931\u8D25", { description: message });
+    }
+  } finally {
+    busy.value = false;
+    streaming.value = null;
+    controller = null;
+  }
+}
+function stop() {
+  controller?.abort();
+}
+</script>
+
+<template>
+  <div class="p-3">
+    <!-- Frameless chat: a scrolling message area flows directly in the pane over
+         a floating, shadowed composer — no outer border and no divider line, so
+         nothing visually boxes the conversation (matches the reference composer).
+         Fixed 48rem so the messages scroll internally (auto-scroll-to-bottom)
+         rather than growing the editor pane; the fixed outer height is what lets
+         the inner `flex-1` message area bound and scroll. -->
+    <div class="flex h-[48rem] flex-col bg-transparent">
+      <!-- New-conversation control: a quiet ghost button pinned top-right that
+           clears the dialogue (and its sessionStorage). Disabled while a turn
+           streams or when there's nothing to clear. -->
+      <div class="flex items-center justify-end pb-1">
+        <Button
+          type="button"
+          variant="ghost"
+          size="sm"
+          :disabled="!canClear"
+          @click="newConversation"
+        >
+          <Icon icon="fluent:add-20-regular" />
+          新对话
+        </Button>
+      </div>
+
+      <ChatMessages
+        :messages="displayMessages"
+        :pending="pending"
+        class="min-h-0 flex-1"
+      >
+        <template #empty>
+          <div class="flex flex-col items-center gap-4 text-center text-zinc-400">
+            <Icon
+              icon="fluent:sparkle-20-regular"
+              class="size-24"
+            />
+            <p class="text-xl">
+              对话开始配置
+            </p>
+          </div>
+        </template>
+      </ChatMessages>
+
+      <div class="p-2">
+        <ChatPrompt
+          v-model="input"
+          :status="status"
+          @submit="send"
+          @stop="stop"
+        />
+      </div>
+    </div>
+  </div>
+</template>

package/dist/runtime/components/table/ai-generate.vue.d.ts

@@ -0,0 +1,16 @@
+import type { Environment } from '../../vendor/cel-js/lib/index.js';
+type AnyRecord = Record<string, any>;
+type __VLS_Props = {
+    configure?: (env: Environment) => void;
+};
+type __VLS_ModelProps = {
+    modelValue: AnyRecord;
+};
+type __VLS_PublicProps = __VLS_Props & __VLS_ModelProps;
+declare const __VLS_export: import("vue").DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:modelValue": (value: AnyRecord) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    "onUpdate:modelValue"?: ((value: AnyRecord) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/runtime/components/table/columns/2026-04-14/com.shwfed.table.column.actions/schema.d.ts

@@ -78,7 +78,7 @@ export declare function schema(configure: (env: Environment) => void): Schema.St
         readonly hideTitle?: boolean | undefined;
     }, import("../../../../actions/schema.js").RegistryItemValue | {
         readonly id: string;
-        readonly title: readonly [{
+        readonly title: string | readonly [{
             readonly locale: "zh";
             readonly message: string;
         }, ...{
@@ -89,7 +89,7 @@ export declare function schema(configure: (env: Environment) => void): Schema.St
         readonly disabled?: string | undefined;
         readonly icon?: string | undefined;
         readonly hidden?: string | undefined;
-        readonly tooltip?: readonly [{
+        readonly tooltip?: string | readonly [{
             readonly locale: "zh";
             readonly message: string;
         }, ...{
@@ -101,7 +101,7 @@ export declare function schema(configure: (env: Environment) => void): Schema.St
         readonly hideTitle?: boolean | undefined;
     } | {
         readonly id: string;
-        readonly title: readonly [{
+        readonly title: string | readonly [{
             readonly locale: "zh";
             readonly message: string;
         }, ...{
@@ -110,7 +110,7 @@ export declare function schema(configure: (env: Environment) => void): Schema.St
         }[]];
         readonly items: readonly (import("../../../../actions/schema.js").RegistrySubItemValue | {
             readonly id: string;
-            readonly title: readonly [{
+            readonly title: string | readonly [{
                 readonly locale: "zh";
                 readonly message: string;
             }, ...{
@@ -120,7 +120,7 @@ export declare function schema(configure: (env: Environment) => void): Schema.St
             readonly disabled?: string | undefined;
             readonly icon?: string | undefined;
             readonly hidden?: string | undefined;
-            readonly tooltip?: readonly [{
+            readonly tooltip?: string | readonly [{
                 readonly locale: "zh";
                 readonly message: string;
             }, ...{
@@ -134,13 +134,19 @@ export declare function schema(configure: (env: Environment) => void): Schema.St
         readonly icon?: string | undefined;
         readonly hideTitle?: boolean | undefined;
     }, never>>;
-    title: Schema.optional<Schema.TupleType<readonly [Schema.Struct<{
-        locale: Schema.Literal<["zh"]>;
-        message: Schema.SchemaClass<string, string, never>;
-    }>], [Schema.Struct<{
-        locale: Schema.Literal<["ja", "en", "ko"]>;
-        message: Schema.SchemaClass<string, string, never>;
-    }>]>>;
+    title: Schema.optional<Schema.suspend<readonly [{
+        readonly locale: "zh";
+        readonly message: string;
+    }, ...{
+        readonly locale: "en" | "ja" | "ko";
+        readonly message: string;
+    }[]], string | readonly [{
+        readonly locale: "zh";
+        readonly message: string;
+    }, ...{
+        readonly locale: "en" | "ja" | "ko";
+        readonly message: string;
+    }[]], never>>;
     size: Schema.optional<Schema.refine<number, Schema.filter<typeof Schema.Number>>>;
     grow: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
     id: Schema.refine<string, typeof Schema.String>;

package/dist/runtime/components/table/columns/2026-04-14/com.shwfed.table.column.date/schema.d.ts

@@ -13,25 +13,37 @@ export declare function schema(configure: (env: Environment) => void): Schema.St
         default: () => "left";
     }>;
     format: Schema.SchemaClass<string, string, never>;
-    title: Schema.TupleType<readonly [Schema.Struct<{
-        locale: Schema.Literal<["zh"]>;
-        message: Schema.SchemaClass<string, string, never>;
-    }>], [Schema.Struct<{
-        locale: Schema.Literal<["ja", "en", "ko"]>;
-        message: Schema.SchemaClass<string, string, never>;
-    }>]>;
+    title: Schema.suspend<readonly [{
+        readonly locale: "zh";
+        readonly message: string;
+    }, ...{
+        readonly locale: "en" | "ja" | "ko";
+        readonly message: string;
+    }[]], string | readonly [{
+        readonly locale: "zh";
+        readonly message: string;
+    }, ...{
+        readonly locale: "en" | "ja" | "ko";
+        readonly message: string;
+    }[]], never>;
     accessor: Schema.optional<Schema.Schema<string, string, never>>;
     enableSorting: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
     sortKey: Schema.optional<Schema.refine<string, typeof Schema.String>>;
     size: Schema.optional<Schema.refine<number, Schema.filter<typeof Schema.Number>>>;
     grow: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
-    tooltip: Schema.optional<Schema.TupleType<readonly [Schema.Struct<{
-        locale: Schema.Literal<["zh"]>;
-        message: Schema.SchemaClass<string, string, never>;
-    }>], [Schema.Struct<{
-        locale: Schema.Literal<["ja", "en", "ko"]>;
-        message: Schema.SchemaClass<string, string, never>;
-    }>]>>;
+    tooltip: Schema.optional<Schema.suspend<readonly [{
+        readonly locale: "zh";
+        readonly message: string;
+    }, ...{
+        readonly locale: "en" | "ja" | "ko";
+        readonly message: string;
+    }[]], string | readonly [{
+        readonly locale: "zh";
+        readonly message: string;
+    }, ...{
+        readonly locale: "en" | "ja" | "ko";
+        readonly message: string;
+    }[]], never>>;
     hidden: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
     id: Schema.refine<string, typeof Schema.String>;
     groupId: Schema.optional<typeof Schema.UUID>;

package/dist/runtime/components/table/columns/2026-04-14/com.shwfed.table.column.icon/runtime.vue

@@ -3,7 +3,7 @@ import { computed } from "vue";
 import { Icon } from "@iconify/vue";
 import { Effect } from "effect";
 import { cel as $cel } from "../../../../../utils/cel";
-import { celBindings, injectCELContext } from "../../../../../utils/cel-context";
+import { celScope, injectCELContext } from "../../../../../utils/cel-context";
 import { JUSTIFY_CLASS } from "../../../utils/runtime";
 defineOptions({ name: "ShwfedTableIconRendererRuntime" });
 const props = defineProps({
@@ -18,11 +18,10 @@ const iconName = computed(() => {
 const color = computed(() => {
   if (!props.column.color) return void 0;
   try {
-    const v = Effect.runSync($cel(props.column.color, {
-      ...celBindings(celContext),
+    const v = Effect.runSync($cel(props.column.color, celScope(celContext, {
       row: props.ctx.row?.original,
       index: props.ctx.row?.index
-    }));
+    })));
     return typeof v === "string" && v.length > 0 ? v : void 0;
   } catch (e) {
     console.error("[shwfed-table] icon color expression failed", e);

package/dist/runtime/components/table/columns/2026-04-14/com.shwfed.table.column.icon/schema.d.ts

@@ -14,24 +14,36 @@ export declare function schema(configure: (env: Environment) => void): Schema.St
     align: Schema.optionalWith<Schema.Literal<["left", "center", "right"]>, {
         default: () => "center";
     }>;
-    title: Schema.TupleType<readonly [Schema.Struct<{
-        locale: Schema.Literal<["zh"]>;
-        message: Schema.SchemaClass<string, string, never>;
-    }>], [Schema.Struct<{
-        locale: Schema.Literal<["ja", "en", "ko"]>;
-        message: Schema.SchemaClass<string, string, never>;
-    }>]>;
+    title: Schema.suspend<readonly [{
+        readonly locale: "zh";
+        readonly message: string;
+    }, ...{
+        readonly locale: "en" | "ja" | "ko";
+        readonly message: string;
+    }[]], string | readonly [{
+        readonly locale: "zh";
+        readonly message: string;
+    }, ...{
+        readonly locale: "en" | "ja" | "ko";
+        readonly message: string;
+    }[]], never>;
     enableSorting: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
     sortKey: Schema.optional<Schema.refine<string, typeof Schema.String>>;
     size: Schema.optional<Schema.refine<number, Schema.filter<typeof Schema.Number>>>;
     grow: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
-    tooltip: Schema.optional<Schema.TupleType<readonly [Schema.Struct<{
-        locale: Schema.Literal<["zh"]>;
-        message: Schema.SchemaClass<string, string, never>;
-    }>], [Schema.Struct<{
-        locale: Schema.Literal<["ja", "en", "ko"]>;
-        message: Schema.SchemaClass<string, string, never>;
-    }>]>>;
+    tooltip: Schema.optional<Schema.suspend<readonly [{
+        readonly locale: "zh";
+        readonly message: string;
+    }, ...{
+        readonly locale: "en" | "ja" | "ko";
+        readonly message: string;
+    }[]], string | readonly [{
+        readonly locale: "zh";
+        readonly message: string;
+    }, ...{
+        readonly locale: "en" | "ja" | "ko";
+        readonly message: string;
+    }[]], never>>;
     hidden: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
     id: Schema.refine<string, typeof Schema.String>;
     groupId: Schema.optional<typeof Schema.UUID>;

package/dist/runtime/components/table/columns/2026-04-14/com.shwfed.table.column.markdown/runtime.vue

@@ -8,7 +8,7 @@ import { getLocalizedText } from "../../../../../share/locale";
 import { Button } from "../../../../ui/button";
 import { Markdown } from "../../../../ui/markdown";
 import { JUSTIFY_CLASS, interpolateMarkdown } from "../../../utils/runtime";
-import { celBindings, injectCELContext } from "../../../../../utils/cel-context";
+import { celScope, injectCELContext } from "../../../../../utils/cel-context";
 defineOptions({ name: "ShwfedTableMarkdownRendererRuntime" });
 const props = defineProps({
   column: { type: null, required: true },
@@ -19,7 +19,7 @@ const celContext = injectCELContext();
 const rendered = computed(() => {
   const source = getLocalizedText(props.column.markdown, locale.value) ?? "";
   if (!source) return "";
-  return interpolateMarkdown(source, $cel, celBindings(celContext));
+  return interpolateMarkdown(source, $cel, celScope(celContext));
 });
 const isEmpty = computed(() => rendered.value.trim().length === 0);
 const align = computed(() => isEmpty.value ? "center" : props.column.align ?? "left");
@@ -28,7 +28,7 @@ const copyText = computed(() => {
   const { copyExpression } = props.column;
   if (!copyExpression) return void 0;
   try {
-    const value = Effect.runSync($cel(copyExpression, celBindings(celContext)));
+    const value = Effect.runSync($cel(copyExpression, celScope(celContext)));
     return value === void 0 || value === null ? void 0 : String(value);
   } catch (e) {
     console.error("[shwfed-table] markdown copy expression failed", e);

package/dist/runtime/components/table/columns/2026-04-14/com.shwfed.table.column.markdown/schema.d.ts

@@ -9,38 +9,56 @@ export declare const metadata: {
     readonly icon: "fluent:markdown-20-regular";
 };
 export declare function schema(configure: (env: Environment) => void): Schema.Struct<{
-    title: Schema.TupleType<readonly [Schema.Struct<{
-        locale: Schema.Literal<["zh"]>;
-        message: Schema.SchemaClass<string, string, never>;
-    }>], [Schema.Struct<{
-        locale: Schema.Literal<["ja", "en", "ko"]>;
-        message: Schema.SchemaClass<string, string, never>;
-    }>]>;
+    title: Schema.suspend<readonly [{
+        readonly locale: "zh";
+        readonly message: string;
+    }, ...{
+        readonly locale: "en" | "ja" | "ko";
+        readonly message: string;
+    }[]], string | readonly [{
+        readonly locale: "zh";
+        readonly message: string;
+    }, ...{
+        readonly locale: "en" | "ja" | "ko";
+        readonly message: string;
+    }[]], never>;
     align: Schema.optionalWith<Schema.Literal<["left", "center", "right"]>, {
         default: () => "left";
     }>;
     size: Schema.optional<Schema.refine<number, Schema.filter<typeof Schema.Number>>>;
     grow: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
-    tooltip: Schema.optional<Schema.TupleType<readonly [Schema.Struct<{
-        locale: Schema.Literal<["zh"]>;
-        message: Schema.SchemaClass<string, string, never>;
-    }>], [Schema.Struct<{
-        locale: Schema.Literal<["ja", "en", "ko"]>;
-        message: Schema.SchemaClass<string, string, never>;
-    }>]>>;
+    tooltip: Schema.optional<Schema.suspend<readonly [{
+        readonly locale: "zh";
+        readonly message: string;
+    }, ...{
+        readonly locale: "en" | "ja" | "ko";
+        readonly message: string;
+    }[]], string | readonly [{
+        readonly locale: "zh";
+        readonly message: string;
+    }, ...{
+        readonly locale: "en" | "ja" | "ko";
+        readonly message: string;
+    }[]], never>>;
     markdown: Schema.refine<readonly [{
         readonly locale: "zh";
         readonly message: string;
     }, ...{
         readonly locale: "en" | "ja" | "ko";
         readonly message: string;
-    }[]], Schema.TupleType<readonly [Schema.Struct<{
-        locale: Schema.Literal<["zh"]>;
-        message: Schema.SchemaClass<string, string, never>;
-    }>], [Schema.Struct<{
-        locale: Schema.Literal<["ja", "en", "ko"]>;
-        message: Schema.SchemaClass<string, string, never>;
-    }>]>>;
+    }[]], Schema.suspend<readonly [{
+        readonly locale: "zh";
+        readonly message: string;
+    }, ...{
+        readonly locale: "en" | "ja" | "ko";
+        readonly message: string;
+    }[]], string | readonly [{
+        readonly locale: "zh";
+        readonly message: string;
+    }, ...{
+        readonly locale: "en" | "ja" | "ko";
+        readonly message: string;
+    }[]], never>>;
     copyExpression: Schema.optional<Schema.Schema<string, string, never>>;
     id: Schema.refine<string, typeof Schema.String>;
     groupId: Schema.optional<typeof Schema.UUID>;

package/dist/runtime/components/table/columns/2026-04-14/com.shwfed.table.column.number/schema.d.ts

@@ -17,25 +17,37 @@ export declare function schema(configure: (env: Environment) => void): Schema.St
     }>;
     preserveMode: Schema.optional<Schema.Literal<["round", "floor", "ceil"]>>;
     preserveDigits: Schema.optional<Schema.refine<number, Schema.filter<typeof Schema.Number>>>;
-    title: Schema.TupleType<readonly [Schema.Struct<{
-        locale: Schema.Literal<["zh"]>;
-        message: Schema.SchemaClass<string, string, never>;
-    }>], [Schema.Struct<{
-        locale: Schema.Literal<["ja", "en", "ko"]>;
-        message: Schema.SchemaClass<string, string, never>;
-    }>]>;
+    title: Schema.suspend<readonly [{
+        readonly locale: "zh";
+        readonly message: string;
+    }, ...{
+        readonly locale: "en" | "ja" | "ko";
+        readonly message: string;
+    }[]], string | readonly [{
+        readonly locale: "zh";
+        readonly message: string;
+    }, ...{
+        readonly locale: "en" | "ja" | "ko";
+        readonly message: string;
+    }[]], never>;
     accessor: Schema.optional<Schema.Schema<string, string, never>>;
     enableSorting: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
     sortKey: Schema.optional<Schema.refine<string, typeof Schema.String>>;
     size: Schema.optional<Schema.refine<number, Schema.filter<typeof Schema.Number>>>;
     grow: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
-    tooltip: Schema.optional<Schema.TupleType<readonly [Schema.Struct<{
-        locale: Schema.Literal<["zh"]>;
-        message: Schema.SchemaClass<string, string, never>;
-    }>], [Schema.Struct<{
-        locale: Schema.Literal<["ja", "en", "ko"]>;
-        message: Schema.SchemaClass<string, string, never>;
-    }>]>>;
+    tooltip: Schema.optional<Schema.suspend<readonly [{
+        readonly locale: "zh";
+        readonly message: string;
+    }, ...{
+        readonly locale: "en" | "ja" | "ko";
+        readonly message: string;
+    }[]], string | readonly [{
+        readonly locale: "zh";
+        readonly message: string;
+    }, ...{
+        readonly locale: "en" | "ja" | "ko";
+        readonly message: string;
+    }[]], never>>;
     hidden: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
     id: Schema.refine<string, typeof Schema.String>;
     groupId: Schema.optional<typeof Schema.UUID>;

package/dist/runtime/components/table/columns/2026-04-14/com.shwfed.table.column.select/runtime.vue

@@ -3,7 +3,7 @@ import { computed } from "vue";
 import { Effect } from "effect";
 import { Icon } from "@iconify/vue";
 import { cel as $cel } from "../../../../../utils/cel";
-import { celBindings, injectCELContext } from "../../../../../utils/cel-context";
+import { celScope, injectCELContext } from "../../../../../utils/cel-context";
 import { cn } from "../../../../../utils/cn";
 defineOptions({ name: "ShwfedTableSelectRendererRuntime" });
 const props = defineProps({
@@ -13,7 +13,7 @@ const props = defineProps({
 const celContext = injectCELContext();
 function evalPredicate(expression, fallback) {
   try {
-    return Boolean(Effect.runSync($cel(expression, celBindings(celContext))));
+    return Boolean(Effect.runSync($cel(expression, celScope(celContext))));
   } catch (e) {
     console.error("[shwfed-table] row-selection predicate failed", e);
     return fallback;

package/dist/runtime/components/table/columns/2026-04-14/com.shwfed.table.column.text/runtime.vue

@@ -5,7 +5,7 @@ import { Effect } from "effect";
 import { cel as $cel } from "../../../../../utils/cel";
 import { Button } from "../../../../ui/button";
 import { JUSTIFY_CLASS } from "../../../utils/runtime";
-import { celBindings, injectCELContext } from "../../../../../utils/cel-context";
+import { celScope, injectCELContext } from "../../../../../utils/cel-context";
 defineOptions({ name: "ShwfedTableTextRendererRuntime" });
 const props = defineProps({
   column: { type: null, required: true },
@@ -20,7 +20,7 @@ const copyText = computed(() => {
   const { copyExpression } = props.column;
   if (!copyExpression) return void 0;
   try {
-    const value = Effect.runSync($cel(copyExpression, celBindings(celContext)));
+    const value = Effect.runSync($cel(copyExpression, celScope(celContext)));
     return value === void 0 || value === null ? void 0 : String(value);
   } catch (e) {
     console.error("[shwfed-table] text copy expression failed", e);

package/dist/runtime/components/table/columns/2026-04-14/com.shwfed.table.column.text/schema.d.ts

@@ -16,25 +16,37 @@ export declare function schema(configure: (env: Environment) => void): Schema.St
         default: () => "plain";
     }>;
     copyExpression: Schema.optional<Schema.Schema<string, string, never>>;
-    title: Schema.TupleType<readonly [Schema.Struct<{
-        locale: Schema.Literal<["zh"]>;
-        message: Schema.SchemaClass<string, string, never>;
-    }>], [Schema.Struct<{
-        locale: Schema.Literal<["ja", "en", "ko"]>;
-        message: Schema.SchemaClass<string, string, never>;
-    }>]>;
+    title: Schema.suspend<readonly [{
+        readonly locale: "zh";
+        readonly message: string;
+    }, ...{
+        readonly locale: "en" | "ja" | "ko";
+        readonly message: string;
+    }[]], string | readonly [{
+        readonly locale: "zh";
+        readonly message: string;
+    }, ...{
+        readonly locale: "en" | "ja" | "ko";
+        readonly message: string;
+    }[]], never>;
     accessor: Schema.optional<Schema.Schema<string, string, never>>;
     enableSorting: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
     sortKey: Schema.optional<Schema.refine<string, typeof Schema.String>>;
     size: Schema.optional<Schema.refine<number, Schema.filter<typeof Schema.Number>>>;
     grow: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
-    tooltip: Schema.optional<Schema.TupleType<readonly [Schema.Struct<{
-        locale: Schema.Literal<["zh"]>;
-        message: Schema.SchemaClass<string, string, never>;
-    }>], [Schema.Struct<{
-        locale: Schema.Literal<["ja", "en", "ko"]>;
-        message: Schema.SchemaClass<string, string, never>;
-    }>]>>;
+    tooltip: Schema.optional<Schema.suspend<readonly [{
+        readonly locale: "zh";
+        readonly message: string;
+    }, ...{
+        readonly locale: "en" | "ja" | "ko";
+        readonly message: string;
+    }[]], string | readonly [{
+        readonly locale: "zh";
+        readonly message: string;
+    }, ...{
+        readonly locale: "en" | "ja" | "ko";
+        readonly message: string;
+    }[]], never>>;
     hidden: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
     id: Schema.refine<string, typeof Schema.String>;
     groupId: Schema.optional<typeof Schema.UUID>;