@shwfed/config 2.11.6 → 2.12.1

package/dist/runtime/components/ui/chat/ChatReasoning.vue

@@ -0,0 +1,33 @@
+<script setup>
+import { computed } from "vue";
+import { Icon } from "@iconify/vue";
+import { Collapsible, CollapsibleContent, CollapsibleTrigger } from "../collapsible";
+defineOptions({ name: "UiChatReasoning" });
+const props = defineProps({
+  part: { type: Object, required: true }
+});
+const streaming = computed(() => props.part.state === "streaming");
+</script>
+
+<template>
+  <Collapsible
+    data-slot="chat-reasoning"
+    class="text-xs text-zinc-400"
+  >
+    <CollapsibleTrigger class="group/reason flex items-center gap-1">
+      <Icon
+        :icon="streaming ? 'fluent:spinner-ios-20-regular' : 'fluent:brain-circuit-20-regular'"
+        class="size-3.5"
+        :class="streaming ? 'animate-spin' : ''"
+      />
+      <span>{{ streaming ? "\u601D\u8003\u4E2D\u2026" : "\u5DF2\u601D\u8003" }}</span>
+      <Icon
+        icon="fluent:chevron-down-20-regular"
+        class="size-3.5 transition-transform duration-180 group-data-[state=open]/reason:rotate-180"
+      />
+    </CollapsibleTrigger>
+    <CollapsibleContent class="mt-1 whitespace-pre-wrap border-l-2 border-zinc-100 pl-2">
+      {{ part.text }}
+    </CollapsibleContent>
+  </Collapsible>
+</template>

package/dist/runtime/components/ui/chat/ChatReasoning.vue.d.ts

@@ -0,0 +1,7 @@
+import type { ReasoningUIPart } from '../../../utils/ai/parts.js';
+type __VLS_Props = {
+    part: ReasoningUIPart;
+};
+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/chat/ChatToolCall.d.vue.ts

@@ -0,0 +1,10 @@
+import type { ToolUIPart } from '../../../utils/ai/parts.js';
+type __VLS_Props = {
+    part: ToolUIPart;
+    defaultOpen?: boolean;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    defaultOpen: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/runtime/components/ui/chat/ChatToolCall.vue

@@ -0,0 +1,92 @@
+<script setup>
+import { computed } from "vue";
+import { Icon } from "@iconify/vue";
+import { toolNameOf } from "../../../utils/ai/parts";
+import { Badge } from "../badge";
+import { Collapsible, CollapsibleContent, CollapsibleTrigger } from "../collapsible";
+defineOptions({ name: "UiChatToolCall" });
+const props = defineProps({
+  part: { type: Object, required: true },
+  defaultOpen: { type: Boolean, required: false, default: false }
+});
+const name = computed(() => toolNameOf(props.part));
+const badge = computed(() => {
+  switch (props.part.state) {
+    case "output-available":
+      return { label: "\u5B8C\u6210", variant: "secondary", spin: false };
+    case "output-error":
+      return { label: "\u5931\u8D25", variant: "destructive", spin: false };
+    default:
+      return { label: "\u8FD0\u884C\u4E2D", variant: "outline", spin: true };
+  }
+});
+function pretty(v) {
+  if (v === void 0) return "";
+  if (typeof v === "string") return v;
+  try {
+    return JSON.stringify(v, null, 2);
+  } catch {
+    return String(v);
+  }
+}
+const inputText = computed(() => pretty(props.part.input));
+const isError = computed(() => props.part.state === "output-error");
+const bodyText = computed(
+  () => isError.value ? props.part.errorText ?? "" : pretty(props.part.output)
+);
+</script>
+
+<template>
+  <Collapsible
+    :default-open="defaultOpen"
+    data-slot="chat-tool-call"
+    class="w-full overflow-hidden rounded-lg border border-zinc-200 bg-white"
+  >
+    <CollapsibleTrigger
+      class="group/tool flex w-full items-center gap-2 px-3 py-2 text-left"
+    >
+      <Icon
+        icon="fluent:wrench-screwdriver-20-regular"
+        class="size-4 shrink-0 text-zinc-400"
+      />
+      <span class="font-mono text-xs text-zinc-600">{{ name }}</span>
+      <Badge
+        :variant="badge.variant"
+        class="ml-auto"
+        data-slot="chat-tool-call-badge"
+      >
+        <Icon
+          v-if="badge.spin"
+          icon="fluent:spinner-ios-20-regular"
+          class="animate-spin"
+        />
+        {{ badge.label }}
+      </Badge>
+      <Icon
+        icon="fluent:chevron-down-20-regular"
+        class="size-4 shrink-0 text-zinc-400 transition-transform duration-180 group-data-[state=open]/tool:rotate-180"
+      />
+    </CollapsibleTrigger>
+    <CollapsibleContent class="space-y-2 border-t border-zinc-100 px-3 py-2 text-xs">
+      <div v-if="inputText">
+        <p class="mb-1 text-zinc-400">
+          输入
+        </p>
+        <pre
+          class="whitespace-pre-wrap break-words rounded bg-zinc-50 p-2 text-zinc-600"
+          data-slot="chat-tool-call-input"
+        >{{ inputText }}</pre>
+      </div>
+      <div v-if="bodyText">
+        <p class="mb-1 text-zinc-400">
+          {{ isError ? "\u9519\u8BEF" : "\u7ED3\u679C" }}
+        </p>
+        <pre
+          class="whitespace-pre-wrap break-words rounded p-2"
+          :class="isError ? 'bg-red-50 text-red-600' : 'bg-zinc-50 text-zinc-600'"
+          data-slot="chat-tool-call-output"
+        >{{ bodyText }}</pre>
+      </div>
+    </CollapsibleContent>
+  </Collapsible>
+</template>

package/dist/runtime/components/ui/chat/ChatToolCall.vue.d.ts

@@ -0,0 +1,10 @@
+import type { ToolUIPart } from '../../../utils/ai/parts.js';
+type __VLS_Props = {
+    part: ToolUIPart;
+    defaultOpen?: boolean;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    defaultOpen: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/runtime/components/ui/chat/index.d.ts

@@ -0,0 +1,9 @@
+export type ChatStatus = 'ready' | 'streaming' | 'error';
+export { default as ChatMessages } from './ChatMessages.vue.js';
+export { default as ChatMessage } from './ChatMessage.vue.js';
+export { default as ChatMessagePart } from './ChatMessagePart.vue.js';
+export { default as ChatToolCall } from './ChatToolCall.vue.js';
+export { default as ChatReasoning } from './ChatReasoning.vue.js';
+export { default as ChatPrompt } from './ChatPrompt.vue.js';
+export { default as ChatPromptSubmit } from './ChatPromptSubmit.vue.js';
+export { StreamMarkdown as ChatMarkdown } from '../stream-markdown/index.js';

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

@@ -0,0 +1,8 @@
+export { default as ChatMessages } from "./ChatMessages.vue";
+export { default as ChatMessage } from "./ChatMessage.vue";
+export { default as ChatMessagePart } from "./ChatMessagePart.vue";
+export { default as ChatToolCall } from "./ChatToolCall.vue";
+export { default as ChatReasoning } from "./ChatReasoning.vue";
+export { default as ChatPrompt } from "./ChatPrompt.vue";
+export { default as ChatPromptSubmit } from "./ChatPromptSubmit.vue";
+export { StreamMarkdown as ChatMarkdown } from "../stream-markdown/index.js";

package/dist/runtime/components/ui/stream-markdown/StreamMarkdown.d.vue.ts

@@ -0,0 +1,15 @@
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    source: {
+        type: StringConstructor;
+        required: true;
+    };
+}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    source: {
+        type: StringConstructor;
+        required: true;
+    };
+}>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

package/dist/runtime/components/ui/stream-markdown/StreamMarkdown.vue

@@ -0,0 +1,22 @@
+<script>
+import { useRuntimeConfig } from "#app";
+import remend from "remend";
+import { computed, defineComponent, h } from "vue";
+import { md } from "../../../utils/markdown";
+const REMEND_OPTIONS = {
+  linkMode: "text-only",
+  katex: false,
+  inlineKatex: false
+};
+export default defineComponent({
+  name: "UiStreamMarkdown",
+  props: {
+    source: { type: String, required: true }
+  },
+  setup(props) {
+    const env = { base: useRuntimeConfig().app.baseURL || "/" };
+    const html = computed(() => md.render(remend(props.source, REMEND_OPTIONS), env));
+    return () => h("div", { "data-slot": "stream-markdown", "innerHTML": html.value });
+  }
+});
+</script>

package/dist/runtime/components/ui/stream-markdown/StreamMarkdown.vue.d.ts

@@ -0,0 +1,15 @@
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    source: {
+        type: StringConstructor;
+        required: true;
+    };
+}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    source: {
+        type: StringConstructor;
+        required: true;
+    };
+}>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

package/dist/runtime/components/ui/stream-markdown/index.d.ts

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

package/dist/runtime/components/ui/stream-markdown/index.js

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

package/dist/runtime/share/coerce-from-string.d.ts

@@ -0,0 +1,62 @@
+import { SchemaAST } from 'effect';
+/**
+ * Coerce AI tool-call outputs that the model accidentally stringified.
+ *
+ * The AI tool-call loop accumulates `partial_json` deltas and concatenates them
+ * into one JSON string, then `JSON.parse`s it. When the model is unsure about a
+ * field's wire shape — does `size` want a number or a string? — it sometimes
+ * stringifies the value, so the parser hands us e.g. `size: "120"` while the
+ * column schema declares `Schema.Number.pipe(Schema.finite(), Schema.positive())`.
+ *
+ * `Schema.decodeUnknownSync` then rejects with `Expected number, actual string`,
+ * the chat loop can't recover, and the user sees the "改写配置中…" card spin
+ * forever. The same bug also affects `grow` (Boolean), `gap` (Number),
+ * `expandAll` (Boolean), every column/button/block schema's primitive fields —
+ * per-schema `Schema.transform` workarounds would touch dozens of files and
+ * pollute the JSON Schema we hand back to the model (it would advertise
+ * `oneOf: [number, string]` and tell the model "strings are OK", which they
+ * aren't).
+ *
+ * This helper takes a different path: walk the raw value in parallel with the
+ * schema's AST, and silently coerce string → number / boolean based on what the
+ * schema expects. The schema is never modified, so:
+ *
+ *   - `JSONSchema.make(schema)` still emits `type: number` / `type: boolean`
+ *     for the model (it sees the canonical types and is asked to honor them).
+ *   - Existing `Schema.suspend(Schema.transform(...))` wrappers (e.g. `Locale`,
+ *     which already forgives stringified tuples) keep working — this preprocessor
+ *     passes strings through for fields whose schema accepts strings.
+ *   - Effect 3.21.2's `Schema.optionalWith` quirk (it strips peer property
+ *     Transformation wrappers — see the `Locale` fix) cannot fire, because we
+ *     never add a Transformation anywhere.
+ *
+ * Apply this at the AI decode chokepoint, BEFORE `Schema.decodeUnknownSync`.
+ * After preprocessing, the raw value is structurally compatible with the
+ * schema, and the schema's own validators (finite/positive/etc.) still run.
+ */
+/**
+ * Pre-process `raw` so it decodes cleanly against `schema`. The schema is read
+ * but never modified — this is a pure transformation of the value side.
+ *
+ * Safe to call on already-typed values (numbers stay numbers, etc.); the only
+ * change is `string → number` when the schema expects a number, and the
+ * equivalent for booleans. JSON-stringified object/array payloads are also
+ * parsed once, mirroring the `Locale` tuple fix at the general level.
+ *
+ * `S` is inferred from the call site. We don't pin it to one of Effect's
+ * bundled `Schema.Any` / `Schema.All` aliases because their third type
+ * parameter (Context / R) collides between `never` and `unknown` under
+ * strict mode, making any of them reject callers that pass the other.
+ */
+export declare function coerceFromString<S extends {
+    readonly ast: SchemaAST.AST;
+}>(raw: unknown, schema: S): unknown;
+/**
+ * Build a JSON Schema with the same shape as `JSONSchema.make(schema)` —
+ * exposed only for the test suite to lock in the "no JSONSchema pollution"
+ * guarantee. If this drifts from `JSONSchema.make`, the implementation
+ * accidentally changed the schema and the model will be misled.
+ */
+export declare function peekJsonSchema<S extends {
+    ast: SchemaAST.AST;
+}>(schema: S): unknown;

package/dist/runtime/share/coerce-from-string.js

@@ -0,0 +1,154 @@
+import { JSONSchema, SchemaAST } from "effect";
+export function coerceFromString(raw, schema) {
+  return preprocess(raw, schema.ast);
+}
+function preprocess(value, ast) {
+  const shape = unwrap(ast);
+  if (value === null || value === void 0) return value;
+  if (typeof value !== "object") return value;
+  if (Array.isArray(value)) {
+    if (shape._tag === "TupleType") {
+      const elements = shape.elements;
+      const restAst = shape.rest[0]?.type ?? SchemaAST.unknownKeyword;
+      return value.map((v, i) => {
+        const elementType = i < elements.length ? elements[i].type : restAst;
+        return preprocessField(v, elementType);
+      });
+    }
+    return value.map((v) => preprocessField(v, shape));
+  }
+  if (shape._tag === "TypeLiteral") {
+    return preprocessStruct(value, shape);
+  }
+  return value;
+}
+function preprocessStruct(value, ast) {
+  const result = {};
+  for (const ps of ast.propertySignatures) {
+    const key = ps.name;
+    if (!(key in value)) continue;
+    result[key] = preprocessField(value[key], ps.type);
+  }
+  for (const key of Object.keys(value)) {
+    if (!(key in result)) result[key] = value[key];
+  }
+  return result;
+}
+function preprocessField(value, ast) {
+  if (typeof value === "string") {
+    const parsedJson = tryParseJson(value, ast);
+    if (parsedJson !== void 0) return preprocess(parsedJson, ast);
+  }
+  if (typeof value === "string") {
+    if (expectsNumber(ast)) {
+      if (value.trim() !== "") return Number(value);
+      return value;
+    }
+    if (expectsBoolean(ast)) {
+      if (value === "true") return true;
+      if (value === "false") return false;
+      return value;
+    }
+  }
+  if (ast._tag === "TypeLiteral" && isPlainObject(value)) {
+    return preprocessStruct(value, ast);
+  }
+  if (ast._tag === "TupleType" && Array.isArray(value)) {
+    const elements = ast.elements;
+    const restAst = ast.rest[0]?.type ?? SchemaAST.unknownKeyword;
+    return value.map((v, i) => {
+      const elementType = i < elements.length ? elements[i].type : restAst;
+      return preprocessField(v, elementType);
+    });
+  }
+  if (ast._tag === "Union") {
+    if (typeof value === "string") {
+      const wantsNumber = ast.types.some(expectsNumber);
+      const wantsBoolean = ast.types.some(expectsBoolean);
+      if (wantsNumber && !wantsBoolean) {
+        if (value.trim() !== "") return Number(value);
+        return value;
+      }
+      if (wantsBoolean && !wantsNumber) {
+        return value === "true";
+      }
+    }
+    return value;
+  }
+  if (ast._tag === "Refinement") return preprocessField(value, ast.from);
+  if (ast._tag === "Suspend") return preprocessField(value, ast.f());
+  if (ast._tag === "Declaration") {
+    return preprocessField(value, ast.typeParameters[0] ?? ast);
+  }
+  if (ast._tag === "Transformation") {
+    return preprocessField(value, ast.from);
+  }
+  return value;
+}
+function unwrap(ast) {
+  switch (ast._tag) {
+    case "Suspend":
+      return unwrap(ast.f());
+    case "Refinement":
+      return unwrap(ast.from);
+    case "Declaration":
+      return unwrap(ast.typeParameters[0] ?? ast);
+    case "Transformation":
+      return unwrap(ast.from);
+    default:
+      return ast;
+  }
+}
+function expectsNumber(ast) {
+  switch (ast._tag) {
+    case "NumberKeyword":
+      return true;
+    case "Refinement":
+      return expectsNumber(ast.from);
+    case "Suspend":
+      return expectsNumber(ast.f());
+    case "Declaration":
+      return expectsNumber(ast.typeParameters[0] ?? ast);
+    case "Union":
+      return ast.types.some(expectsNumber);
+    case "Transformation":
+      return expectsNumber(ast.from);
+    default:
+      return false;
+  }
+}
+function expectsBoolean(ast) {
+  switch (ast._tag) {
+    case "BooleanKeyword":
+      return true;
+    case "Refinement":
+      return expectsBoolean(ast.from);
+    case "Suspend":
+      return expectsBoolean(ast.f());
+    case "Declaration":
+      return expectsBoolean(ast.typeParameters[0] ?? ast);
+    case "Union":
+      return ast.types.some(expectsBoolean);
+    case "Transformation":
+      return expectsBoolean(ast.from);
+    default:
+      return false;
+  }
+}
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function tryParseJson(value, ast) {
+  const unwrapped = unwrap(ast);
+  if (unwrapped._tag !== "TypeLiteral" && unwrapped._tag !== "TupleType") return void 0;
+  const trimmed = value.trimStart();
+  if (!trimmed.startsWith("{") && !trimmed.startsWith("[")) return void 0;
+  try {
+    return JSON.parse(value);
+  } catch {
+    return void 0;
+  }
+}
+export function peekJsonSchema(schema) {
+  return JSONSchema.make(schema);
+}

package/dist/runtime/share/disabled-date.d.ts

@@ -0,0 +1,34 @@
+import type { Environment } from '../vendor/cel-js/lib/index.js';
+import type { ResultType } from './expression.js';
+/**
+ * Result-type matcher for a per-date "should this date be disabled" expression.
+ * The expression returns `true` to disable the candidate date; `false`/none/
+ * absent leave it enabled (matching reka-ui's native `isDateDisabled`). Accepts
+ * a bare `bool` (`input >= now`) as well as `optional<bool>`
+ * (`cond ? optional.of(true) : optional.none()`) — same leniency as
+ * `HttpRequestResult` in `share/expression.ts`. At runtime `cel()` unwraps
+ * `optional.none()` to `undefined`, which the predicate treats as "no opinion,
+ * keep the date enabled". `dyn`/`optional<dyn>` ride along for gradual typing.
+ */
+export declare const DISABLE_DATE_RESULT: ResultType;
+/**
+ * Register the `input` (Date) CEL variable — the candidate date the calendar is
+ * rendering — only when an enclosing `configure` hasn't already declared it. The
+ * CEL registry throws `'input' is already registered` on a duplicate, so the
+ * guard mirrors `registerRowVariablesIfAbsent` / `registerLoopVariablesIfAbsent`.
+ */
+export declare function registerInputDateIfAbsent(env: Environment): void;
+/**
+ * The `input` variable advertised to `ExpressionEditor` via its `extra-vars`
+ * prop, so completion offers it at design time. Pair with
+ * `DISABLE_DATE_EDITOR_RESULT` for the editor's `result-type` — the editor prop
+ * can't take a function matcher, so the array form mirrors `DISABLE_DATE_RESULT`.
+ */
+export declare const INPUT_DATE_VARS: {
+    readonly input: {
+        readonly type: "Date";
+        readonly label: "候选日期";
+        readonly description: "日历中待判定是否可选的日期";
+    };
+};
+export declare const DISABLE_DATE_EDITOR_RESULT: readonly ["bool", "optional<bool>"];

package/dist/runtime/share/disabled-date.js

@@ -0,0 +1,13 @@
+export const DISABLE_DATE_RESULT = (t) => t === "bool" || t === "optional<bool>" || t === "optional<dyn>" || t === "dyn";
+const INPUT_VAR_LABEL = "\u5019\u9009\u65E5\u671F";
+const INPUT_VAR_DESCRIPTION = "\u65E5\u5386\u4E2D\u5F85\u5224\u5B9A\u662F\u5426\u53EF\u9009\u7684\u65E5\u671F";
+export function registerInputDateIfAbsent(env) {
+  const declared = new Set(env.getDefinitions().variables.map((v) => v.name));
+  if (!declared.has("input")) {
+    env.registerVariable("input", "Date", { label: INPUT_VAR_LABEL, description: INPUT_VAR_DESCRIPTION });
+  }
+}
+export const INPUT_DATE_VARS = {
+  input: { type: "Date", label: INPUT_VAR_LABEL, description: INPUT_VAR_DESCRIPTION }
+};
+export const DISABLE_DATE_EDITOR_RESULT = ["bool", "optional<bool>"];

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

@@ -1,11 +1,17 @@
 import { Schema } from 'effect';
-export declare const Locale: 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>;
-}>]>;
+export declare const Locale: 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>;
 export type LocaleValue = Schema.Schema.Type<typeof Locale>;
 export declare function hasVisibleLocaleValue(value: LocaleValue | undefined): boolean;
 export declare function getLocalizedText(messages: LocaleValue | undefined, locale: string): string | undefined;

package/dist/runtime/share/locale.js

@@ -15,13 +15,35 @@ const OtherLocaleItem = Schema.Struct({
     description: "\u9488\u5BF9\u8BE5\u8BED\u8A00\u7684 UI \u6587\u672C"
   })
 });
-export const Locale = Schema.Tuple(
+const LocaleTuple = Schema.Tuple(
   [ZhLocaleItem],
   OtherLocaleItem
-).annotations({
-  title: "Locale",
-  description: "\u672C\u5730\u5316\u6587\u672C\u5217\u8868\uFF0Czh \u5FC5\u987B\u4E3A\u9996\u9879"
-});
+);
+function coerceStringToLocale(input) {
+  if (input.trimStart().startsWith("[")) {
+    try {
+      const parsed = JSON.parse(input);
+      if (Array.isArray(parsed)) return parsed;
+    } catch {
+    }
+  }
+  return [{ locale: "zh", message: input }];
+}
+export const Locale = Schema.suspend(
+  () => Schema.transform(
+    Schema.Union(LocaleTuple, Schema.String),
+    LocaleTuple,
+    {
+      strict: true,
+      decode: (input) => typeof input === "string" ? coerceStringToLocale(input) : input,
+      encode: (input) => input
+    }
+  ).annotations({
+    identifier: "Locale",
+    title: "Locale",
+    description: "\u672C\u5730\u5316\u6587\u672C\u5217\u8868\uFF0Czh \u5FC5\u987B\u4E3A\u9996\u9879\uFF1B\u63A5\u53D7\u7EAF\u5B57\u7B26\u4E32\uFF08\u82E5\u662F JSON-encoded tuple \u5219\u89E3\u6790\u5B83\uFF0C\u5426\u5219\u5F53\u4F5C zh \u6587\u672C\u6765\u7528\uFF09"
+  })
+);
 export function hasVisibleLocaleValue(value) {
   return value?.some((item) => item.message.trim().length > 0) ?? false;
 }

package/dist/runtime/share/use-persisted-chat.d.ts

@@ -0,0 +1,30 @@
+import { type Ref } from 'vue';
+import type { UIMessage } from '../utils/ai/parts.js';
+/**
+ * Mirrors a table editor's AI-chat history into `sessionStorage`, keyed on the
+ * table's stable `config.id`, so the conversation survives both the chat
+ * component unmounting — switching away from the "AI 生成" section `v-if`-
+ * unmounts `<TableAiGenerate>`, dropping its local `ref<UIMessage[]>` — and a
+ * page reload. It clears when the browser tab is closed (`sessionStorage`
+ * lifetime), giving each table a per-instance, session-scoped chat memory.
+ *
+ * Modeled on `usePersistedQuery`: every access is SSR-guarded and guarded
+ * against unavailable storage (privacy modes). With no `tableId()` persistence
+ * is a no-op (in-memory only) so id-less drafts can't collide on a shared key.
+ *
+ * - `restore()` seeds `messages` from the stored snapshot. Call it in
+ *   `onMounted`, after the fresh component's empty ref exists, so a remount
+ *   rehydrates the prior conversation.
+ * - `clear()` drops the stored snapshot (for a future "new conversation"
+ *   affordance / a hard reset).
+ * - A deep watch persists committed turns; an emptied history removes the key
+ *   rather than storing `"[]"`.
+ *
+ * Restored turns keep their tool-call parts for display, but `streamChat`
+ * replays history as prose only (`partsToText` in `utils/ai`), so a continued
+ * conversation never re-sends a dangling tool_use across the restore boundary.
+ */
+export declare function usePersistedChat(tableId: () => string | undefined, messages: Ref<UIMessage[]>): {
+    restore: () => void;
+    clear: () => void;
+};

package/dist/runtime/share/use-persisted-chat.js

@@ -0,0 +1,34 @@
+import { watch } from "vue";
+const STORAGE_PREFIX = "shwfed.table.ai-chat.";
+export function usePersistedChat(tableId, messages) {
+  const key = () => `${STORAGE_PREFIX}${tableId()}`;
+  const active = () => Boolean(tableId()) && typeof window !== "undefined";
+  function restore() {
+    if (!active()) return;
+    try {
+      const raw = window.sessionStorage.getItem(key());
+      if (!raw) return;
+      const parsed = JSON.parse(raw);
+      if (Array.isArray(parsed)) messages.value = parsed;
+    } catch {
+    }
+  }
+  function clear() {
+    if (typeof window === "undefined") return;
+    const id = tableId();
+    if (!id) return;
+    try {
+      window.sessionStorage.removeItem(`${STORAGE_PREFIX}${id}`);
+    } catch {
+    }
+  }
+  watch(messages, (next) => {
+    if (!active()) return;
+    try {
+      if (next.length === 0) window.sessionStorage.removeItem(key());
+      else window.sessionStorage.setItem(key(), JSON.stringify(next));
+    } catch {
+    }
+  }, { deep: true });
+  return { restore, clear };
+}