@shwfed/config 2.4.0 → 2.4.1

package/dist/runtime/components/form/fields/2026-05-28/com.shwfed.form.field.tree.multi/config.vue.d.ts

@@ -33,6 +33,7 @@ declare const __VLS_export: import("vue").DefineComponent<__VLS_ModelProps, {},
             readonly locale: "en" | "ja" | "ko";
             readonly message: string;
         }[]] | undefined;
+        readonly required?: string | undefined;
         readonly displayName?: string | undefined;
         readonly compatibilityDate: "2026-05-28";
         readonly readonly?: string | undefined;
@@ -56,6 +57,17 @@ declare const __VLS_export: import("vue").DefineComponent<__VLS_ModelProps, {},
         }[]];
         readonly expandAll: boolean;
         readonly cascade: "independent" | "cascade-down" | "cascade-both";
+        readonly validations?: readonly {
+            readonly message: readonly [{
+                readonly locale: "zh";
+                readonly message: string;
+            }, ...{
+                readonly locale: "en" | "ja" | "ko";
+                readonly message: string;
+            }[]];
+            readonly warning?: boolean | undefined;
+            readonly when: string;
+        }[] | undefined;
         readonly nodeTooltip?: readonly [{
             readonly locale: "zh";
             readonly message: string;
@@ -96,6 +108,7 @@ declare const __VLS_export: import("vue").DefineComponent<__VLS_ModelProps, {},
             readonly locale: "en" | "ja" | "ko";
             readonly message: string;
         }[]] | undefined;
+        readonly required?: string | undefined;
         readonly displayName?: string | undefined;
         readonly compatibilityDate: "2026-05-28";
         readonly readonly?: string | undefined;
@@ -119,6 +132,17 @@ declare const __VLS_export: import("vue").DefineComponent<__VLS_ModelProps, {},
         }[]];
         readonly expandAll: boolean;
         readonly cascade: "independent" | "cascade-down" | "cascade-both";
+        readonly validations?: readonly {
+            readonly message: readonly [{
+                readonly locale: "zh";
+                readonly message: string;
+            }, ...{
+                readonly locale: "en" | "ja" | "ko";
+                readonly message: string;
+            }[]];
+            readonly warning?: boolean | undefined;
+            readonly when: string;
+        }[] | undefined;
         readonly nodeTooltip?: readonly [{
             readonly locale: "zh";
             readonly message: string;

package/dist/runtime/components/form/fields/2026-05-28/com.shwfed.form.field.tree.multi/runtime.vue

@@ -8,7 +8,7 @@ import { cel as _rawCel } from "../../../../../utils/cel";
 import { celBindings, injectCELContext } from "../../../../../utils/cel-context";
 import { getLocalizedText } from "../../../../../share/locale";
 import { Checkbox } from "../../../../ui/checkbox";
-import { Field, FieldLabel } from "../../../../ui/field";
+import { Field, FieldLabel, FieldMessages } from "../../../../ui/field";
 import { InputGroup, InputGroupAddon, InputGroupButton, InputGroupInput } from "../../../../ui/input-group";
 import { Markdown } from "../../../../ui/markdown";
 import { Skeleton } from "../../../../ui/skeleton";
@@ -16,6 +16,7 @@ import { Tree as UiTree } from "../../../../ui/tree";
 import { interpolateMarkdown } from "../../../../table/utils/runtime";
 import { useFormReadonly } from "../../../utils/readonly";
 import { useFormState } from "../../../utils/state";
+import { useFieldValidation } from "../../../utils/validation";
 defineOptions({ name: "ShwfedTreeMultiFieldRuntime" });
 const props = defineProps({
   fieldId: { type: String, required: true },
@@ -72,6 +73,12 @@ const isReadonly = computed(
   () => props.config.readonly != null ? evalBool(props.config.readonly, "readonly") : formReadonly.value
 );
 const effectiveReadonly = computed(() => isReadonly.value || props.config.derived?.mode === "formula");
+const { isRequired, errors, warnings, visible } = useFieldValidation({
+  fieldId: () => props.fieldId,
+  config: () => props.config,
+  $cel,
+  locale: () => locale.value
+});
 const uncontrolled = ref([]);
 const model = computed({
   get: () => {
@@ -292,7 +299,11 @@ const readonlyText = computed(() => {
           class="prose prose-xs prose-zinc"
         />
       </template>
-      {{ labelText }}
+      {{ labelText }}<span
+        v-if="isRequired"
+        aria-hidden="true"
+        class="text-red-600"
+      > *</span>
     </FieldLabel>
 
     <div
@@ -397,5 +408,10 @@ const readonlyText = computed(() => {
         </template>
       </UiTree>
     </template>
+    <FieldMessages
+      v-if="visible"
+      :errors="errors"
+      :warnings="warnings"
+    />
   </Field>
 </template>

package/dist/runtime/components/form/fields/2026-05-28/com.shwfed.form.field.tree.multi/schema.d.ts

@@ -93,6 +93,24 @@ export declare function schema(configure: (env: Environment) => void): Schema.St
     id: Schema.refine<string, typeof Schema.String>;
     displayName: Schema.optional<Schema.SchemaClass<string, string, never>>;
     hidden: Schema.optional<Schema.Schema<string, string, never>>;
+    required: Schema.optional<Schema.Schema<string, string, never>>;
+    validations: Schema.optional<Schema.Array$<Schema.Struct<{
+        when: Schema.Schema<string, string, never>;
+        warning: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
+        message: 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>;
+        }>]>>;
+    }>>>;
     type: Schema.Literal<["com.shwfed.form.field.tree.multi"]>;
     compatibilityDate: Schema.Literal<["2026-05-28"]>;
 }>;

package/dist/runtime/components/form/fields/2026-05-28/com.shwfed.form.field.tree.single/config.d.vue.ts

@@ -33,6 +33,7 @@ declare const __VLS_export: import("vue").DefineComponent<__VLS_ModelProps, {},
             readonly locale: "en" | "ja" | "ko";
             readonly message: string;
         }[]] | undefined;
+        readonly required?: string | undefined;
         readonly displayName?: string | undefined;
         readonly compatibilityDate: "2026-05-28";
         readonly readonly?: string | undefined;
@@ -55,6 +56,17 @@ declare const __VLS_export: import("vue").DefineComponent<__VLS_ModelProps, {},
             readonly message: string;
         }[]];
         readonly expandAll: boolean;
+        readonly validations?: readonly {
+            readonly message: readonly [{
+                readonly locale: "zh";
+                readonly message: string;
+            }, ...{
+                readonly locale: "en" | "ja" | "ko";
+                readonly message: string;
+            }[]];
+            readonly warning?: boolean | undefined;
+            readonly when: string;
+        }[] | undefined;
         readonly nodeTooltip?: readonly [{
             readonly locale: "zh";
             readonly message: string;
@@ -95,6 +107,7 @@ declare const __VLS_export: import("vue").DefineComponent<__VLS_ModelProps, {},
             readonly locale: "en" | "ja" | "ko";
             readonly message: string;
         }[]] | undefined;
+        readonly required?: string | undefined;
         readonly displayName?: string | undefined;
         readonly compatibilityDate: "2026-05-28";
         readonly readonly?: string | undefined;
@@ -117,6 +130,17 @@ declare const __VLS_export: import("vue").DefineComponent<__VLS_ModelProps, {},
             readonly message: string;
         }[]];
         readonly expandAll: boolean;
+        readonly validations?: readonly {
+            readonly message: readonly [{
+                readonly locale: "zh";
+                readonly message: string;
+            }, ...{
+                readonly locale: "en" | "ja" | "ko";
+                readonly message: string;
+            }[]];
+            readonly warning?: boolean | undefined;
+            readonly when: string;
+        }[] | undefined;
         readonly nodeTooltip?: readonly [{
             readonly locale: "zh";
             readonly message: string;

package/dist/runtime/components/form/fields/2026-05-28/com.shwfed.form.field.tree.single/config.vue

@@ -2,6 +2,7 @@
 import { computed } from "vue";
 import { ExpressionEditor } from "../../../../ui/expression-editor";
 import DerivedValueEditor from "../../../DerivedValueEditor.vue";
+import ValidationRulesField from "../../../ValidationRulesField.vue";
 import { Field, FieldLabel } from "../../../../ui/field";
 import { InputGroup, InputGroupInput } from "../../../../ui/input-group";
 import { Locale as LocaleField } from "../../../../ui/locale";
@@ -477,6 +478,26 @@ function setFilterKeywords(next) {
 
     <!-- 通用：隐藏 / 禁用 / 只读 + 派生值 — conventionally last -->
     <div class="grid grid-cols-3 gap-3">
+      <Field orientation="vertical">
+        <FieldLabel class="text-xs text-zinc-500">
+          <template #tooltip>
+            <Markdown
+              :source="fieldDescription('required') ?? '\u8FD4\u56DE `true` \u65F6\u663E\u793A\u5FC5\u586B\u661F\u53F7\u5E76\u8981\u6C42\u975E\u7A7A'"
+              block
+              class="prose prose-sm prose-zinc"
+            />
+          </template>
+          {{ fieldTitle("required") }}
+        </FieldLabel>
+        <ExpressionEditor
+          :model-value="value.required ?? ''"
+          placeholder="例：form.type == 'company'"
+          result-type="bool"
+          class="min-h-10"
+          @update:model-value="(v) => value = { ...value, required: v.length > 0 ? v : void 0 }"
+        />
+      </Field>
+
       <Field orientation="vertical">
         <FieldLabel class="text-xs text-zinc-500">
           <template #tooltip>
@@ -556,5 +577,22 @@ function setFilterKeywords(next) {
         @update:model-value="(v) => value = { ...value, derived: v }"
       />
     </Field>
+
+    <Field orientation="vertical">
+      <FieldLabel class="text-xs text-zinc-500">
+        <template #tooltip>
+          <Markdown
+            :source="fieldDescription('validations')"
+            block
+            class="prose prose-sm prose-zinc"
+          />
+        </template>
+        {{ fieldTitle("validations") }}
+      </FieldLabel>
+      <ValidationRulesField
+        :model-value="value.validations"
+        @update:model-value="(v) => value = { ...value, validations: v.length > 0 ? v : void 0 }"
+      />
+    </Field>
   </div>
 </template>

package/dist/runtime/components/form/fields/2026-05-28/com.shwfed.form.field.tree.single/config.vue.d.ts

@@ -33,6 +33,7 @@ declare const __VLS_export: import("vue").DefineComponent<__VLS_ModelProps, {},
             readonly locale: "en" | "ja" | "ko";
             readonly message: string;
         }[]] | undefined;
+        readonly required?: string | undefined;
         readonly displayName?: string | undefined;
         readonly compatibilityDate: "2026-05-28";
         readonly readonly?: string | undefined;
@@ -55,6 +56,17 @@ declare const __VLS_export: import("vue").DefineComponent<__VLS_ModelProps, {},
             readonly message: string;
         }[]];
         readonly expandAll: boolean;
+        readonly validations?: readonly {
+            readonly message: readonly [{
+                readonly locale: "zh";
+                readonly message: string;
+            }, ...{
+                readonly locale: "en" | "ja" | "ko";
+                readonly message: string;
+            }[]];
+            readonly warning?: boolean | undefined;
+            readonly when: string;
+        }[] | undefined;
         readonly nodeTooltip?: readonly [{
             readonly locale: "zh";
             readonly message: string;
@@ -95,6 +107,7 @@ declare const __VLS_export: import("vue").DefineComponent<__VLS_ModelProps, {},
             readonly locale: "en" | "ja" | "ko";
             readonly message: string;
         }[]] | undefined;
+        readonly required?: string | undefined;
         readonly displayName?: string | undefined;
         readonly compatibilityDate: "2026-05-28";
         readonly readonly?: string | undefined;
@@ -117,6 +130,17 @@ declare const __VLS_export: import("vue").DefineComponent<__VLS_ModelProps, {},
             readonly message: string;
         }[]];
         readonly expandAll: boolean;
+        readonly validations?: readonly {
+            readonly message: readonly [{
+                readonly locale: "zh";
+                readonly message: string;
+            }, ...{
+                readonly locale: "en" | "ja" | "ko";
+                readonly message: string;
+            }[]];
+            readonly warning?: boolean | undefined;
+            readonly when: string;
+        }[] | undefined;
         readonly nodeTooltip?: readonly [{
             readonly locale: "zh";
             readonly message: string;

package/dist/runtime/components/form/fields/2026-05-28/com.shwfed.form.field.tree.single/runtime.vue

@@ -7,7 +7,7 @@ import { useI18n } from "vue-i18n";
 import { cel as _rawCel } from "../../../../../utils/cel";
 import { celBindings, injectCELContext } from "../../../../../utils/cel-context";
 import { getLocalizedText } from "../../../../../share/locale";
-import { Field, FieldLabel } from "../../../../ui/field";
+import { Field, FieldLabel, FieldMessages } from "../../../../ui/field";
 import { InputGroup, InputGroupAddon, InputGroupButton, InputGroupInput } from "../../../../ui/input-group";
 import { Markdown } from "../../../../ui/markdown";
 import { Skeleton } from "../../../../ui/skeleton";
@@ -15,6 +15,7 @@ import { Tree as UiTree } from "../../../../ui/tree";
 import { interpolateMarkdown } from "../../../../table/utils/runtime";
 import { useFormReadonly } from "../../../utils/readonly";
 import { useFormState } from "../../../utils/state";
+import { useFieldValidation } from "../../../utils/validation";
 defineOptions({ name: "ShwfedTreeSingleFieldRuntime" });
 const props = defineProps({
   fieldId: { type: String, required: true },
@@ -68,6 +69,12 @@ const isReadonly = computed(
   () => props.config.readonly != null ? evalBool(props.config.readonly, "readonly") : formReadonly.value
 );
 const effectiveReadonly = computed(() => isReadonly.value || props.config.derived?.mode === "formula");
+const { isRequired, errors, warnings, visible } = useFieldValidation({
+  fieldId: () => props.fieldId,
+  config: () => props.config,
+  $cel,
+  locale: () => locale.value
+});
 const uncontrolled = ref(void 0);
 const model = computed({
   get: () => {
@@ -288,7 +295,11 @@ const readonlyText = computed(() => {
           class="prose prose-xs prose-zinc"
         />
       </template>
-      {{ labelText }}
+      {{ labelText }}<span
+        v-if="isRequired"
+        aria-hidden="true"
+        class="text-red-600"
+      > *</span>
     </FieldLabel>
 
     <div
@@ -391,5 +402,10 @@ const readonlyText = computed(() => {
         </template>
       </UiTree>
     </template>
+    <FieldMessages
+      v-if="visible"
+      :errors="errors"
+      :warnings="warnings"
+    />
   </Field>
 </template>

package/dist/runtime/components/form/fields/2026-05-28/com.shwfed.form.field.tree.single/schema.d.ts

@@ -89,6 +89,24 @@ export declare function schema(configure: (env: Environment) => void): Schema.St
     id: Schema.refine<string, typeof Schema.String>;
     displayName: Schema.optional<Schema.SchemaClass<string, string, never>>;
     hidden: Schema.optional<Schema.Schema<string, string, never>>;
+    required: Schema.optional<Schema.Schema<string, string, never>>;
+    validations: Schema.optional<Schema.Array$<Schema.Struct<{
+        when: Schema.Schema<string, string, never>;
+        warning: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
+        message: 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>;
+        }>]>>;
+    }>>>;
     type: Schema.Literal<["com.shwfed.form.field.tree.single"]>;
     compatibilityDate: Schema.Literal<["2026-05-28"]>;
 }>;

package/dist/runtime/components/form/index.d.vue.ts

@@ -13,6 +13,7 @@ declare const __VLS_export: import("vue").DefineComponent<__VLS_PublicProps, {
     seeded: Promise<void>;
     flush: () => void;
     settled: () => Promise<void>;
+    validate: () => Promise<boolean>;
     undo: () => void;
     redo: () => void;
     canUndo: import("vue").Ref<boolean, boolean>;

package/dist/runtime/components/form/index.vue

@@ -14,8 +14,10 @@ import { provideCommitBus } from "./utils/commit-bus";
 import { provideDerivedQuiescence, useDerived } from "./utils/derived";
 import { useFormHistory } from "./utils/history";
 import { evaluateInitial } from "./utils/initial";
+import { provideFormValidate } from "../../share/form-validate";
 import { provideFormReadonly } from "./utils/readonly";
 import { provideFormState } from "./utils/state";
+import { provideValidation } from "./utils/validation";
 defineOptions({ name: "ShwfedForm" });
 const state = defineModel({ type: Object, ...{ default: () => ({}) } });
 const config = defineModel("config", { type: Object, ...{ required: true } });
@@ -82,11 +84,18 @@ useDerived({
   formState,
   quiescence
 });
+const validation = provideValidation({
+  flush: commitBus.flushAll,
+  seeded,
+  settled: quiescence.settled
+});
+provideFormValidate(validation.validate);
 const formHistory = useFormHistory(state, { quiescence, seeded, dirty: formState.dirty });
 defineExpose({
   seeded,
   flush: commitBus.flushAll,
   settled: quiescence.settled,
+  validate: validation.validate,
   undo: formHistory.undo,
   redo: formHistory.redo,
   canUndo: formHistory.canUndo,

package/dist/runtime/components/form/index.vue.d.ts

@@ -13,6 +13,7 @@ declare const __VLS_export: import("vue").DefineComponent<__VLS_PublicProps, {
     seeded: Promise<void>;
     flush: () => void;
     settled: () => Promise<void>;
+    validate: () => Promise<boolean>;
     undo: () => void;
     redo: () => void;
     canUndo: import("vue").Ref<boolean, boolean>;

package/dist/runtime/components/form/schema.js

@@ -39,8 +39,8 @@ export function FormUnit(configure) {
 }
 export function registerFormVariablesIfAbsent(env) {
   const declared = new Set(env.getDefinitions().variables.map((v) => v.name));
-  if (!declared.has("now")) env.registerVariable("now", "Date", { description: "\u5F53\u524D\u65E5\u671F/\u65F6\u95F4" });
-  if (!declared.has("form")) env.registerVariable("form", "dyn", { description: "\u5F53\u524D\u8868\u5355\u72B6\u6001" });
+  if (!declared.has("now")) env.registerVariable("now", "Date", { label: "\u5F53\u524D\u65F6\u95F4", description: "\u5F53\u524D\u65E5\u671F/\u65F6\u95F4" });
+  if (!declared.has("form")) env.registerVariable("form", "dyn", { label: "\u8868\u5355\u503C", description: "\u5F53\u524D\u8868\u5355\u72B6\u6001" });
 }
 export function FormConfig(configure) {
   const formConfigure = (env) => {

package/dist/runtime/components/form/utils/common.d.ts

@@ -1,9 +1,51 @@
 import { Schema } from 'effect';
 import type { Environment } from '../../../vendor/cel-js/lib/index.js';
+/**
+ * One field-owned validation rule. Extracted so the config editor
+ * (`ValidationRulesField`) can read the `when` / `message` `@title` +
+ * `@description` straight off this struct — single source of truth, no
+ * duplicated label/tooltip copy. `configure` only shapes the CEL environment;
+ * the annotations are static, so a no-op `configure` is fine for metadata.
+ */
+export declare function validationRuleStruct(configure: (env: Environment) => void): Schema.Struct<{
+    when: Schema.Schema<string, string, never>;
+    warning: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
+    message: 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>;
+    }>]>>;
+}>;
 export declare function commonFieldFields(configure: (env: Environment) => void): {
     id: Schema.refine<string, typeof Schema.String>;
     displayName: Schema.optional<Schema.SchemaClass<string, string, never>>;
     hidden: Schema.optional<Schema.Schema<string, string, never>>;
+    required: Schema.optional<Schema.Schema<string, string, never>>;
+    validations: Schema.optional<Schema.Array$<Schema.Struct<{
+        when: Schema.Schema<string, string, never>;
+        warning: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
+        message: 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>;
+        }>]>>;
+    }>>>;
 };
 export declare const FIELD_ORIENTATIONS: readonly ["vertical", "floating"];
 export type FieldOrientation = typeof FIELD_ORIENTATIONS[number];

package/dist/runtime/components/form/utils/common.js

@@ -1,6 +1,27 @@
 import { Schema } from "effect";
-import { Expression } from "../../../share/expression.js";
+import { Expression, LocaleMarkdown } from "../../../share/expression.js";
 import { md } from "../../../share/markdown.js";
+export function validationRuleStruct(configure) {
+  const CelBool = Expression({ configure, resultType: "bool" });
+  return Schema.Struct({
+    when: CelBool.annotations({
+      title: "\u89C4\u5219",
+      description: md`
+        返回 \`true\` 时视为校验**未**通过，返回 \`false\` 视为通过
+      `
+    }),
+    // Severity toggle. Off (default / absent) ⇒ error: standard blocks submit
+    // and reds the field. On ⇒ warning: yellow hint only, never blocks submit.
+    warning: Schema.optional(Schema.Boolean.annotations({
+      title: "\u4EC5\u8B66\u544A",
+      description: "\u5F00\u542F\u540E\u8BE5\u89C4\u5219\u4EC5\u9EC4\u8272\u63D0\u793A\u3001\u4E0D\u963B\u6B62\u63D0\u4EA4"
+    })),
+    message: LocaleMarkdown({ configure }).annotations({
+      title: "\u6D88\u606F",
+      description: "\u6821\u9A8C\u672A\u901A\u8FC7\u65F6\u5C55\u793A\u7684\u672C\u5730\u5316\u6D88\u606F\uFF0C\u652F\u6301 inline Markdown \u4E0E `{{ \u8868\u8FBE\u5F0F }}` \u63D2\u503C"
+    })
+  });
+}
 export function commonFieldFields(configure) {
   const CelBool = Expression({ configure, resultType: "bool" });
   return {
@@ -12,7 +33,24 @@ export function commonFieldFields(configure) {
     hidden: Schema.optional(CelBool.annotations({
       title: "\u9690\u85CF\u6761\u4EF6",
       description: "\u8FD4\u56DE `true` \u65F6\u5B57\u6BB5\u5728\u6240\u6709\u5E03\u5C40\u4E2D\u90FD\u4E0D\u6E32\u67D3"
-    }))
+    })),
+    // Required marker + non-empty check share one expression — no drift
+    // between the star the user sees and the rule that gates submit.
+    required: Schema.optional(CelBool.annotations({
+      title: "\u5FC5\u586B\u6761\u4EF6",
+      description: "\u8FD4\u56DE `true` \u65F6\u663E\u793A\u5FC5\u586B\u661F\u53F7\u5E76\u8981\u6C42\u975E\u7A7A\uFF0C\u7559\u7A7A\u8868\u793A\u4E0D\u5FC5\u586B"
+    })),
+    // Field-owned rules. `when` returns a bool — `true` triggers the rule; the
+    // per-rule `warning` switch picks the severity (error by default, warning
+    // when on). The message is a localized Markdown template with `{{ 表达式 }}`
+    // interpolation. Cross-field rules read `form.*` and live on the field where
+    // the error should appear.
+    validations: Schema.optional(
+      Schema.Array(validationRuleStruct(configure)).annotations({
+        title: "\u6821\u9A8C\u89C4\u5219",
+        description: "\u53CD\u9988\u6D88\u606F\u5C06\u6309\u7167\u6821\u9A8C\u89C4\u5219\u5217\u8868\u987A\u5E8F\u5C55\u793A"
+      })
+    )
   };
 }
 export const FIELD_ORIENTATIONS = ["vertical", "floating"];

package/dist/runtime/components/form/utils/validation.d.ts

@@ -0,0 +1,85 @@
+import { Effect } from 'effect';
+import type { ComputedRef, Ref } from 'vue';
+import { type LocaleValue } from '../../../share/locale.js';
+export type Severity = 'error' | 'warning';
+export type FieldValidationResult = {
+    severity: Severity;
+    /** Already i18n-resolved and `{{ }}`-interpolated — ready to render. */
+    message: string;
+    /** Index in the field's `validations[]`; `-1` for the implicit required rule. */
+    ruleIndex: number;
+};
+/** The slice of a field's config the validation engine reads. */
+export type ValidatableConfig = {
+    required?: string;
+    validations?: ReadonlyArray<{
+        when: string;
+        warning?: boolean;
+        message: LocaleValue;
+    }>;
+    binding?: string | readonly [string, string];
+};
+type Registration = () => ReadonlyArray<FieldValidationResult>;
+export type ValidationProvider = {
+    /**
+     * Global reveal gate. Errors on a pristine field stay hidden until that
+     * field's binding is dirtied (first blur) or `reveal()` flips this true.
+     * Once true it never retracts during the form's life — only a full unmount
+     * resets it. `undo`/`redo` do not touch it (they roll back state, not the
+     * gate).
+     */
+    revealed: Ref<boolean>;
+    reveal: () => void;
+    /** Register a mounted field's id + live results thunk; returns an unregister fn. */
+    register: (fieldId: () => string, results: Registration) => () => void;
+    /**
+     * Drain pending drafts, await the seed and derived-value settlement, then
+     * read every registered field's results. `true` ⇒ no `error`-severity
+     * result anywhere. Always calls `reveal()` so the failing fields surface.
+     */
+    validate: () => Promise<boolean>;
+    /** Union of results across the given field ids — used by collapsible aggregation. */
+    resultsFor: (fieldIds: ReadonlyArray<string>) => ReadonlyArray<FieldValidationResult>;
+};
+export type ValidationHost = {
+    /** Drain pending field commits (the form's commit bus). */
+    flush: () => void;
+    /** Resolves once the initial seed has landed. */
+    seeded: Promise<void>;
+    /** Resolves once every derived value — cascades included — has settled. */
+    settled: () => Promise<void>;
+};
+/**
+ * Provide the form-wide validation registry. Called once at the top-level form
+ * host, after the commit bus / quiescence are available; nested list rows
+ * inherit it through `inject`, so every field in the form — at any nesting
+ * depth — registers into this single provider.
+ */
+export declare function provideValidation(host: ValidationHost): ValidationProvider;
+/**
+ * Inject the form's validation provider. Returns `undefined` when used outside
+ * a `<Form>` host (e.g. a submit button placed on a bare page) — callers treat
+ * that as "no validation".
+ */
+export declare function useValidationProvider(): ValidationProvider | undefined;
+/**
+ * Field-level validation. Called inside an input field's `runtime.vue`. Reads
+ * the field's `required` / `validations` config, evaluates them synchronously
+ * against the field's CEL context (`form`, plus a list row's `item`/`index`),
+ * registers the live results into the form-wide provider for as long as the
+ * field is mounted, and returns the bits the field renders: the required star,
+ * the error/warning message lists, and the dirty-gated `visible` flag.
+ */
+export declare function useFieldValidation(options: {
+    fieldId: () => string;
+    config: () => ValidatableConfig;
+    $cel: <T>(expression: string, context?: Record<string, unknown>) => Effect.Effect<T, any>;
+    /** Current i18n locale, for resolving the message `Locale`. */
+    locale: () => string;
+}): {
+    isRequired: ComputedRef<boolean>;
+    errors: ComputedRef<ReadonlyArray<string>>;
+    warnings: ComputedRef<ReadonlyArray<string>>;
+    visible: ComputedRef<boolean>;
+};
+export {};