@shwfed/config 3.0.4 → 3.0.7

package/dist/runtime/components/form/fields/2026-07-13/com.shwfed.form.field.dynamic/runtime.d.vue.ts

@@ -0,0 +1,8 @@
+import type { Value } from './schema.js';
+type __VLS_Props = {
+    fieldId: string;
+    config: Value;
+};
+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/form/fields/2026-07-13/com.shwfed.form.field.dynamic/runtime.vue

@@ -0,0 +1,72 @@
+<script setup>
+import { Effect, Option } from "effect";
+import { Fetch } from "fx-fetch";
+import { onMounted, shallowRef } from "vue";
+import { cel as _rawCel } from "../../../../../utils/cel";
+import { celBindings, injectCELContext } from "../../../../../utils/cel-context";
+import { fetchJsonOption } from "../../../../../share/request";
+import FormUnitRenderer from "../../../FormUnitRenderer.vue";
+import { findField } from "../../../utils/resolve";
+import { useDerivedQuiescence } from "../../../utils/derived";
+import { useFormState } from "../../../utils/state";
+import { emptyUnit, expandDynFields } from "./expand";
+defineOptions({ name: "ShwfedDynamicFieldRuntime" });
+const props = defineProps({
+  fieldId: { type: String, required: true },
+  config: { type: null, required: true }
+});
+const inherited = injectCELContext();
+const $cel = (expression, context) => _rawCel(expression, { ...celBindings(inherited), ...context });
+const formState = useFormState();
+const quiescence = useDerivedQuiescence();
+const unit = shallowRef(emptyUnit(props.config));
+const defaultsOf = (type, compatibilityDate) => findField(type, compatibilityDate)?.defaults?.();
+async function loadDescriptors() {
+  quiescence.begin();
+  try {
+    const transform = props.config.transform;
+    if (!transform || transform.trim().length === 0) return;
+    const program = Effect.gen(function* () {
+      let json = Option.none();
+      const request = props.config.request;
+      if (request && request.trim().length > 0) {
+        json = yield* fetchJsonOption(yield* $cel(request));
+      }
+      return yield* $cel(transform, { json });
+    });
+    let list;
+    try {
+      list = await Effect.runPromise(Effect.provide(program, Fetch.layer));
+    } catch (err) {
+      console.warn(`[shwfed-form] dynamic fields ${props.fieldId}: request/transform failed`, err);
+      unit.value = emptyUnit(props.config);
+      return;
+    }
+    const result = expandDynFields(list, props.config, defaultsOf);
+    for (const { binding, value } of result.seeds) {
+      if (formState.getAt(binding) === void 0) formState.setAtSilent(binding, value);
+    }
+    unit.value = { fields: result.fields, layouts: result.layouts };
+  } finally {
+    quiescence.end();
+  }
+}
+onMounted(() => {
+  void loadDescriptors();
+});
+function evaluateMedia(expression) {
+  return Effect.runSync($cel(expression));
+}
+</script>
+
+<template>
+  <div
+    data-slot="dynamic-fields"
+    class="min-w-0"
+  >
+    <FormUnitRenderer
+      :unit="unit"
+      :evaluate-media="evaluateMedia"
+    />
+  </div>
+</template>

package/dist/runtime/components/form/fields/2026-07-13/com.shwfed.form.field.dynamic/runtime.vue.d.ts

@@ -0,0 +1,8 @@
+import type { Value } from './schema.js';
+type __VLS_Props = {
+    fieldId: string;
+    config: Value;
+};
+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/form/fields/2026-07-13/com.shwfed.form.field.dynamic/schema.d.ts

@@ -0,0 +1,59 @@
+import { Schema } from 'effect';
+import type { Environment } from '../../../../../vendor/cel-js/lib/index.js';
+export declare const type: "com.shwfed.form.field.dynamic";
+export declare const compatibilityDate: "2026-07-13";
+export declare const metadata: {
+    readonly name: "动态字段";
+    readonly icon: "fluent:form-multiple-20-regular";
+    readonly w: {
+        readonly initial: 12;
+        readonly min: 4;
+        readonly max: number;
+    };
+    readonly h: {
+        readonly initial: 4;
+        readonly min: 2;
+        readonly max: number;
+        readonly grow: true;
+    };
+};
+declare const DynFieldKind: Schema.Literal<["text", "number", "date", "daterange", "dropdown"]>;
+export type DynFieldKindValue = Schema.Schema.Type<typeof DynFieldKind>;
+export declare const KIND_TO_FIELD: Record<DynFieldKindValue, {
+    type: string;
+    compatibilityDate: string;
+}>;
+export declare const CHOICE_KINDS: ReadonlySet<DynFieldKindValue>;
+/**
+ * The narrow, module-owned DTO the `transform` must emit per field. Wider than
+ * the column DTO because these are *edit* definitions — they carry requiredness,
+ * options, and default values. Each list element is decoded against this at
+ * runtime (partial-drop, loud); the strongest static guarantee is only that
+ * `transform` returns `list<dyn>`.
+ */
+export declare const DynFieldDescriptor: Schema.Struct<{
+    binding: Schema.filter<typeof Schema.String>;
+    label: typeof Schema.String;
+    kind: Schema.Literal<["text", "number", "date", "daterange", "dropdown"]>;
+    required: Schema.optional<typeof Schema.Boolean>;
+    options: Schema.optional<Schema.Array$<Schema.Struct<{
+        value: Schema.Union<[typeof Schema.String, typeof Schema.Number]>;
+        label: typeof Schema.String;
+    }>>>;
+    default: Schema.optional<typeof Schema.Unknown>;
+}>;
+export type DynFieldDescriptorValue = Schema.Schema.Type<typeof DynFieldDescriptor>;
+export declare function schema(configure: (env: Environment) => void): Schema.Struct<{
+    type: Schema.Literal<["com.shwfed.form.field.dynamic"]>;
+    compatibilityDate: Schema.Literal<["2026-07-13"]>;
+    id: Schema.refine<string, typeof Schema.String>;
+    displayName: Schema.optional<Schema.SchemaClass<string, string, never>>;
+    hidden: Schema.optional<Schema.Schema<string, string, never>>;
+    request: Schema.Schema<string, string, never>;
+    transform: Schema.Schema<string, string, never>;
+    columns: Schema.optional<Schema.refine<number, Schema.filter<typeof Schema.Number>>>;
+    orientation: Schema.optional<Schema.Literal<["vertical", "floating"]>>;
+}>;
+export type Value = Schema.Schema.Type<ReturnType<typeof schema>>;
+export declare function defaults(): Partial<Value>;
+export {};

package/dist/runtime/components/form/fields/2026-07-13/com.shwfed.form.field.dynamic/schema.js

@@ -0,0 +1,139 @@
+import { Schema } from "effect";
+import { Expression, HttpRequestResult } from "../../../../../share/expression.js";
+import { md } from "../../../../../share/markdown.js";
+import { FieldOrientationSchema } from "../../../utils/common.js";
+import { FORM_VARIABLE_NAMES } from "../../../utils/form-vars.js";
+export const type = "com.shwfed.form.field.dynamic";
+export const compatibilityDate = "2026-07-13";
+export const metadata = {
+  name: "\u52A8\u6001\u5B57\u6BB5",
+  icon: "fluent:form-multiple-20-regular",
+  w: { initial: 12, min: 4, max: Infinity },
+  h: { initial: 4, min: 2, max: Infinity, grow: true }
+  // Hosts a runtime-generated sub-form; its config (two expressions + two
+  // inputs) is small enough for the docked inline pane, so leave `inlineConfig`
+  // at its default (supported).
+};
+const DynFieldKind = Schema.Literal(
+  "text",
+  "number",
+  "date",
+  "daterange",
+  "dropdown"
+);
+export const KIND_TO_FIELD = {
+  text: { type: "com.shwfed.form.field.text", compatibilityDate: "2026-04-22" },
+  number: { type: "com.shwfed.form.field.number", compatibilityDate: "2026-04-28" },
+  date: { type: "com.shwfed.form.field.date", compatibilityDate: "2026-04-27" },
+  daterange: { type: "com.shwfed.form.field.daterange", compatibilityDate: "2026-04-27" },
+  dropdown: { type: "com.shwfed.form.field.combobox.single", compatibilityDate: "2026-06-14" }
+};
+export const CHOICE_KINDS = /* @__PURE__ */ new Set(["dropdown"]);
+const DynFieldOption = Schema.Struct({
+  // The value bound when this option is chosen. A number maps to the leaves'
+  // `{ kind: 'number', value }` item shape, a string to `{ kind: 'text', value }`.
+  value: Schema.Union(Schema.String, Schema.Number),
+  // Plain string, no i18n (confirmed requirement); `expand` wraps it into a zh
+  // `Locale` via the dyn-cols `wrapLocale` idiom.
+  label: Schema.String
+});
+export const DynFieldDescriptor = Schema.Struct({
+  // dot-prop path like any field's binding; for the legacy app = `parameter_name`.
+  // Child `id` is namespaced `<blockId>::<binding>`, so it can never collide
+  // with a static field or another block in the form-wide validation /
+  // selections registries. First-wins on duplicate bindings within one block.
+  binding: Schema.String.pipe(Schema.minLength(1)),
+  // Plain string, no i18n (confirmed requirement); wrapped into a zh `Locale`.
+  label: Schema.String,
+  // Selects the pinned leaf (closed vocabulary).
+  kind: DynFieldKind,
+  // `true` → the child gets `required: 'true'` (the CEL literal), which is both
+  // the required star and the non-empty gate.
+  required: Schema.optional(Schema.Boolean),
+  // Choice kinds' static options. A choice-kind descriptor without `options` is
+  // dropped (loud). Legacy idiom:
+  // `f.optional_values.split('\n').map(v, {'value': v, 'label': v})`.
+  options: Schema.optional(Schema.Array(DynFieldOption)),
+  // Initial-value seed: written into form state at `binding` iff that path
+  // currently resolves to `undefined` (never clobbering the form-level `initial`
+  // seed or user input).
+  default: Schema.optional(Schema.Unknown)
+});
+function withoutFormVariables(configure) {
+  return (env) => {
+    const proxy = new Proxy(env, {
+      get(target, prop) {
+        if (prop === "registerVariable") {
+          return (name, ...rest) => {
+            if (FORM_VARIABLE_NAMES.has(name)) return;
+            return target.registerVariable(name, ...rest);
+          };
+        }
+        const v = Reflect.get(target, prop, target);
+        return typeof v === "function" ? v.bind(target) : v;
+      }
+    });
+    configure(proxy);
+  };
+}
+export function schema(configure) {
+  const frozenConfigure = withoutFormVariables(configure);
+  const CelRequest = Expression({ configure: frozenConfigure, resultType: HttpRequestResult });
+  const CelTransform = Expression({
+    configure: (env) => {
+      frozenConfigure(env);
+      const declared = new Set(env.getDefinitions().variables.map((v) => v.name));
+      if (!declared.has("json")) {
+        env.registerVariable("json", "optional<dyn>", {
+          label: "HTTP \u54CD\u5E94\u4F53",
+          description: "\u5B57\u6BB5\u5B9A\u4E49\u63A5\u53E3\u7684\u54CD\u5E94\u4F53\uFF08\u5DF2\u89E3\u6790 JSON\uFF09\uFF1B\u672A\u83B7\u53D6\u5230\u65F6\u4E3A none\uFF0C\u901A\u8FC7 `json.orValue(...)` \u89E3\u5305"
+        });
+      }
+    },
+    resultType: (t) => t.startsWith("list") || t === "dyn" || t.startsWith("optional")
+  });
+  const CelBool = Expression({ configure, resultType: "bool" });
+  return Schema.Struct({
+    type: Schema.Literal(type),
+    compatibilityDate: Schema.Literal(compatibilityDate),
+    // Design-time identity; placements reference it. The block carries NO
+    // `binding` / `required` / `validations` of its own — it has no value.
+    id: Schema.UUID.annotations({ description: "\u5B57\u6BB5\u552F\u4E00\u6807\u8BC6\uFF1B\u5E03\u5C40\u901A\u8FC7\u8BE5 id \u5F15\u7528\u8BE5\u52A8\u6001\u533A\u57DF" }),
+    displayName: Schema.optional(Schema.String.annotations({
+      title: "\u5185\u90E8\u540D\u79F0",
+      description: "\u4EC5\u5728\u7F16\u8F91\u5668\u5185\u53EF\u89C1\u7684\u540D\u79F0\uFF0C\u7528\u4E8E\u5728\u4FA7\u8FB9\u680F\u548C\u5E03\u5C40\u7F16\u8F91\u5668\u4E2D\u8BC6\u522B\u8BE5\u52A8\u6001\u533A\u57DF\uFF1B\u8FD0\u884C\u65F6\u4E0D\u5C55\u793A"
+    })),
+    hidden: Schema.optional(CelBool.annotations({
+      title: "\u9690\u85CF\u6761\u4EF6",
+      description: "\u8FD4\u56DE `true` \u65F6\u6574\u4E2A\u52A8\u6001\u533A\u57DF\u5728\u6240\u6709\u5E03\u5C40\u4E2D\u90FD\u4E0D\u6E32\u67D3\uFF08\u5E76\u89E6\u53D1\u8F68\u9053\u538B\u7F29\u6536\u8D77\u8BE5\u533A\u57DF\uFF09"
+    })),
+    request: CelRequest.annotations({
+      title: "\u5B57\u6BB5\u5B9A\u4E49\u8BF7\u6C42",
+      description: md`
+        获取字段定义列表的 HTTP 请求表达式（与数据源 \`request\` 同为 \`HttpRequest\` 形状）。
+        字段集合在挂载时**一次性**获取，**不随表单状态变化** —— 作用域内没有 \`form\` 等表单运行时变量。
+      `
+    }),
+    transform: CelTransform.annotations({
+      title: "\u5B57\u6BB5\u5B9A\u4E49\u6620\u5C04",
+      description: md`
+        将 \`json\`（字段定义响应体，用 \`json.orValue([])\` 解包）映射为一组字段描述（\`list\`）。
+        每个元素需符合固定字段（注意 CEL 映射字面量的键要加引号）：\`binding\`（写入路径 / 唯一标识）、
+        \`label\`（标签，纯文本无 i18n）、\`kind\`（\`text\`/\`number\`/\`date\`/\`daterange\`/\`dropdown\`）；
+        可选 \`required\`（布尔）、\`options\`（\`list<{value, label}>\`，\`dropdown\` 必填）、
+        \`default\`（初始值）。**所有与后端数据契约相关的知识都在这里**。
+      `
+    }),
+    columns: Schema.optional(Schema.Number.pipe(Schema.int(), Schema.positive()).annotations({
+      title: "\u5217\u6570",
+      description: "\u6BCF\u884C\u6392\u5E03\u7684\u5B50\u5B57\u6BB5\u6570\uFF1A\u6BCF\u4E2A\u5B50\u5B57\u6BB5\u6070\u597D\u5360\u4E00\u683C\uFF0C\u6309\u5B9A\u4E49\u987A\u5E8F\u884C\u4F18\u5148\u6392\u5E03\u3001\u6EE1\u884C\u6362\u884C\u3002\u9ED8\u8BA4 1\uFF08\u6BCF\u4E2A\u5B57\u6BB5\u5360\u6EE1\u6574\u884C\uFF09"
+    })),
+    orientation: Schema.optional(FieldOrientationSchema.annotations({
+      title: "\u65B9\u5411",
+      description: "\u7EDF\u4E00\u65BD\u52A0\u5230\u6BCF\u4E2A\u52A8\u6001\u5B50\u5B57\u6BB5\u7684\u6807\u7B7E\u6392\u5217\u65B9\u5411\uFF08`orientation` \u662F\u914D\u7F6E\u6570\u636E\uFF0C\u8FD0\u884C\u65F6\u6CA1\u6709\u65B9\u5411\u63D0\u4F9B\u8005\uFF09\uFF1B\u641C\u7D22\u8868\u5355\u573A\u666F\u901A\u5E38\u7528 `floating`"
+    }))
+  }).annotations({ title: "DynamicFields", description: "\u8FD0\u884C\u65F6\u52A8\u6001\u5B57\u6BB5\uFF08\u7531\u670D\u52A1\u7AEF\u5B57\u6BB5\u5B9A\u4E49\u751F\u6210\uFF09" });
+}
+export function defaults() {
+  return { request: "", transform: "" };
+}

package/dist/runtime/components/form/unit-config.vue

@@ -199,7 +199,7 @@ async function copyFields(ids) {
       if (p) placements[id] = p;
     }
   }
-  if (!await writeClip("form", items, placements)) {
+  if (!await writeClip("form", { items, placements })) {
     toast.error("\u590D\u5236\u5931\u8D25");
     return;
   }
@@ -208,7 +208,7 @@ async function copyFields(ids) {
 async function pasteFields(target) {
   const payload = await readClip();
   if (!payload || payload.surface !== "form") return;
-  const { items, placements } = reidFragment(payload.items, payload.placements);
+  const { items, placements } = reidFragment(payload);
   const pasted = items;
   if (pasted.length === 0) return;
   const place = placements;

package/dist/runtime/components/form/utils/form-vars.d.ts

@@ -1,19 +1,9 @@
 import type { Environment } from '../../../vendor/cel-js/lib/index.js';
 /**
- * Register the form-wide `now` / `form` live variables on `env`, skipping any
- * already declared. Idempotent so it composes safely from either side: a
- * `FormConfig` nested inside another (the `table` form field embeds a table
- * whose `query` is its own sub-form, and the embedding `configure` advertises
- * the same pair) would otherwise register `form` twice on one env and the CEL
- * registry throws `'form' is already registered`. Mirrors
- * `registerRowVariablesIfAbsent`.
- *
- * This is the single source of truth for the `form` / `now` metadata: the
- * schema's expression validators register it here, the designer-time picker
- * probes it (`buildFormCelScope`), and the runtime scope derives its
- * type/label/description from it too (`buildFormRuntimeScope`). Lives in this
- * dependency-light module — not `schema.ts` — so the scope helpers can import it
- * without pulling `utils/resolve` (and its `import.meta.glob`) into per-folder
- * unit tests. `schema.ts` re-exports it for existing call sites.
+ * The names the form registrar owns — the form-runtime state a schema can
+ * subtract from an expression scope when its semantics forbid depending on the
+ * live form (the dynamic-fields block's `request` / `transform`: the field set
+ * is frozen at mount and must not read `form`).
  */
+export declare const FORM_VARIABLE_NAMES: ReadonlySet<string>;
 export declare function registerFormVariablesIfAbsent(env: Environment): void;

package/dist/runtime/components/form/utils/form-vars.js

@@ -1,10 +1,16 @@
 import { OPTIONS_VAR, SELECTIONS_VAR } from "../../../utils/cel-context.js";
+const FORM_VARIABLE_DEFS = [
+  { name: "now", type: "Date", meta: { label: "\u5F53\u524D\u65F6\u95F4", description: "\u5F53\u524D\u65E5\u671F/\u65F6\u95F4" } },
+  { name: "form", type: "dyn", meta: { label: "\u8868\u5355\u503C", description: "\u5F53\u524D\u8868\u5355\u72B6\u6001" } },
+  { name: "undoable", type: "bool", meta: { label: "\u53EF\u64A4\u9500", description: "\u5F53\u524D\u662F\u5426\u6709\u53EF\u64A4\u9500\u7684\u4FEE\u6539" } },
+  { name: "redoable", type: "bool", meta: { label: "\u53EF\u91CD\u505A", description: "\u5F53\u524D\u662F\u5426\u6709\u53EF\u91CD\u505A\u7684\u4FEE\u6539" } },
+  { name: SELECTIONS_VAR, type: "dyn", meta: { label: "\u9009\u4E2D\u9879", description: "\u5404\u9009\u62E9\u5B57\u6BB5\u5F53\u524D\u9009\u4E2D\u9879\u7684\u5B8C\u6574\u5BF9\u8C61\uFF08\u6309\u5B57\u6BB5\u6807\u8BC6\uFF09" } },
+  { name: OPTIONS_VAR, type: "dyn", meta: { label: "\u5168\u90E8\u9009\u9879", description: "\u5404\u9009\u62E9\u5B57\u6BB5\u5F53\u524D\u5DF2\u52A0\u8F7D\u7684\u5168\u90E8\u9009\u9879\uFF08\u6309\u5B57\u6BB5\u6807\u8BC6\uFF0C\u5143\u7D20\u4E3A\u9009\u9879\u5B8C\u6574\u5BF9\u8C61\uFF09" } }
+];
+export const FORM_VARIABLE_NAMES = new Set(FORM_VARIABLE_DEFS.map((d) => d.name));
 export function registerFormVariablesIfAbsent(env) {
   const declared = new Set(env.getDefinitions().variables.map((v) => v.name));
-  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" });
-  if (!declared.has("undoable")) env.registerVariable("undoable", "bool", { label: "\u53EF\u64A4\u9500", description: "\u5F53\u524D\u662F\u5426\u6709\u53EF\u64A4\u9500\u7684\u4FEE\u6539" });
-  if (!declared.has("redoable")) env.registerVariable("redoable", "bool", { label: "\u53EF\u91CD\u505A", description: "\u5F53\u524D\u662F\u5426\u6709\u53EF\u91CD\u505A\u7684\u4FEE\u6539" });
-  if (!declared.has(SELECTIONS_VAR)) env.registerVariable(SELECTIONS_VAR, "dyn", { label: "\u9009\u4E2D\u9879", description: "\u5404\u9009\u62E9\u5B57\u6BB5\u5F53\u524D\u9009\u4E2D\u9879\u7684\u5B8C\u6574\u5BF9\u8C61\uFF08\u6309\u5B57\u6BB5\u6807\u8BC6\uFF09" });
-  if (!declared.has(OPTIONS_VAR)) env.registerVariable(OPTIONS_VAR, "dyn", { label: "\u5168\u90E8\u9009\u9879", description: "\u5404\u9009\u62E9\u5B57\u6BB5\u5F53\u524D\u5DF2\u52A0\u8F7D\u7684\u5168\u90E8\u9009\u9879\uFF08\u6309\u5B57\u6BB5\u6807\u8BC6\uFF0C\u5143\u7D20\u4E3A\u9009\u9879\u5B8C\u6574\u5BF9\u8C61\uFF09" });
+  for (const d of FORM_VARIABLE_DEFS) {
+    if (!declared.has(d.name)) env.registerVariable(d.name, d.type, d.meta);
+  }
 }

package/dist/runtime/components/operations/2026-06-11/com.shwfed.operation.http.request.json/schema.js

@@ -8,7 +8,7 @@ export const metadata = {
   name: "\u53D1\u9001\u8BF7\u6C42",
   icon: "fluent:cloud-arrow-up-20-regular",
   // This op publishes its parsed response as a chain-step output, so later
-  // trigger rows can reference it via `steps["<row-id>"]`.
+  // trigger rows can reference it via `steps[?"<row-id>"]`.
   output: "HTTP \u54CD\u5E94\uFF08\u89E3\u6790\u540E\u7684 JSON\uFF09"
 };
 export function schema(configure) {
@@ -69,7 +69,7 @@ export function schema(configure) {
     description: md`
       发起一次 HTTP 请求（响应解析为 JSON）。请求失败（网络错误 / 非 2xx / 响应不可解析）
       或「执行结果」为 \`error\` 时中止本次触发链。在触发列表中串联多个本操作即可按顺序
-      调用多个接口——前一个失败后，后续操作不再执行。后面的步骤可经 \`steps["<步骤标识>"]\`
+      调用多个接口——前一个失败后，后续操作不再执行。后面的步骤可经 \`steps[?"<步骤标识>"]\`
       引用前面步骤的响应。
 
       toast 完全由「提示标题」「提示内容」决定（含失败场景）；不配置标题、或标题求值为空字符串则静默。

package/dist/runtime/components/operations/2026-06-15/com.shwfed.operation.http.download/schema.js

@@ -39,7 +39,7 @@ export function schema(configure) {
       title: "\u8BF7\u6C42",
       description: md`
         构造一个请求，其响应将被取回并保存为文件。
-        可经 \`steps["<步骤标识>"]\` 引用前序步骤的输出——把先前
+        可经 \`steps[?"<步骤标识>"]\` 引用前序步骤的输出——把先前
         \`发送请求\` 行取得的凭据用于构造真正的下载请求。
       `
     }),
@@ -75,7 +75,7 @@ export function schema(configure) {
       发起一次 HTTP 请求：若响应是二进制（非 JSON）则保存为本地文件；若响应是 JSON，
       则视为后端返回的状态信封，经「执行结果」裁定成败而**不**保存。下载失败（网络错误 / 非 2xx）
       或「执行结果」为 \`error\` 会中止本次触发链——其后排队的操作不再执行。把本操作接在一个
-      \`发送请求\` 行之后、并经 \`steps["<步骤标识>"]\` 引用其响应，即可实现
+      \`发送请求\` 行之后、并经 \`steps[?"<步骤标识>"]\` 引用其响应，即可实现
       “先取凭据再下载”的两步式。toast 完全由「提示标题」「提示内容」决定（含失败场景）；
       不配置标题、或标题求值为空字符串则静默。
     `

package/dist/runtime/components/operations/2026-06-15/com.shwfed.operation.navigation/runtime.js

@@ -1,12 +1,6 @@
 import { Effect } from "effect";
 import { navigateTo, useRouter } from "#app";
-function isExternal(url) {
-  try {
-    return new URL(url, window.location.href).origin !== window.location.origin;
-  } catch {
-    return false;
-  }
-}
+import { isAbsoluteUrl } from "../../../../share/navigation.js";
 export const handler = (params, ctx) => {
   const { url, mode } = params ?? {};
   if (!url || url.trim().length === 0) return Effect.void;
@@ -14,13 +8,13 @@ export const handler = (params, ctx) => {
     const steps = ctx.step?.outputs() ?? {};
     const resolved = yield* ctx.cel(url, { steps });
     const router = useRouter();
-    const external = isExternal(resolved);
-    yield* Effect.promise(async () => {
+    const absolute = isAbsoluteUrl(resolved);
+    yield* Effect.tryPromise(async () => {
       if (mode === "_blank") {
-        window.open(external ? resolved : router.resolve(resolved).href, "_blank");
+        window.open(absolute ? resolved : router.resolve(resolved).href, "_blank");
         return;
       }
-      await navigateTo(resolved, { external });
+      await navigateTo(resolved, { external: absolute });
     });
   });
   return program.pipe(

package/dist/runtime/components/operations/2026-06-15/com.shwfed.operation.navigation/schema.js

@@ -28,7 +28,7 @@ export function schema(configure) {
   }).annotations({
     title: "NavigationOperation",
     description: md`
-      按所选方式打开一个链接。链接表达式可经 \`steps["<步骤标识>"]\` 引用前序步骤的输出，
+      按所选方式打开一个链接。链接表达式可经 \`steps[?"<步骤标识>"]\` 引用前序步骤的输出，
       因此可由先前请求的响应拼接目标地址。导航失败不中止本次触发链。
     `
   });

package/dist/runtime/components/operations/utils/resolve.d.ts

@@ -30,7 +30,7 @@ export type OperationMetadata = Readonly<{
     icon: string;
     /**
      * Present iff this operation publishes a chain-step output (`ctx.step.publish`)
-     * for later trigger rows to read via `steps["<row-id>"]` — the value is the
+     * for later trigger rows to read via `steps[?"<row-id>"]` — the value is the
      * designer-facing label of what gets published (e.g. 'HTTP 响应'). The trigger
      * editor reads it to decide which rows to offer as step references, so a
      * non-publishing op never advertises a reference that resolves to nothing.

package/dist/runtime/components/operations/utils/step-vars.d.ts

@@ -6,10 +6,12 @@ import { type CELVar } from '../../../utils/cel-context.js';
  * an op schema may be embedded under a host whose `configure` already
  * advertises it, and double registration throws.
  *
- * `dyn` (not `map<string, dyn>`) so `steps["<id>"].data.code` type-checks the
+ * `dyn` (not `map<string, dyn>`) so `steps[?"<id>"].data.code` type-checks the
  * same way `form.foo.bar` does — what a step publishes is backend-defined and
  * unknowable at design time. Keyed by trigger-row uuid; the picker renders
- * each key as its「第 N 步」position.
+ * each key as its「第 N 步」position, and writes the OPTIONAL lookup (`[?]`), so
+ * a step that published nothing evaluates to `undefined` instead of throwing
+ * `No such key`.
  */
 export declare function registerStepsVariableIfAbsent(env: Environment): void;
 /**

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

@@ -1,33 +1,13 @@
 <script setup>
 import { computed } from "vue";
-import { Effect } from "effect";
 import { Icon } from "@iconify/vue";
-import { cel as $cel } from "../../../../../utils/cel";
-import { celScope, injectCELContext } from "../../../../../utils/cel-context";
 import { cn } from "../../../../../utils/cn";
 defineOptions({ name: "ShwfedTableSelectRendererRuntime" });
 const props = defineProps({
   column: { type: null, required: true },
   ctx: { type: Object, required: true }
 });
-const celContext = injectCELContext();
-function evalPredicate(expression, fallback) {
-  try {
-    return Boolean(Effect.runSync($cel(expression, celScope(celContext))));
-  } catch (e) {
-    console.error("[shwfed-table] row-selection predicate failed", e);
-    return fallback;
-  }
-}
-const canSelect = computed(() => {
-  if (props.column.enableRowSelection && !evalPredicate(props.column.enableRowSelection, true)) {
-    return false;
-  }
-  if (props.column.mode === "checkbox" && props.column.enableMultiRowSelection && !evalPredicate(props.column.enableMultiRowSelection, true)) {
-    return false;
-  }
-  return true;
-});
+const canSelect = computed(() => props.ctx.row.getCanSelect());
 function onCheckboxClick(e) {
   if (!canSelect.value) return;
   const { row, table } = props.ctx;

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

@@ -1,6 +1,7 @@
 import { Schema } from 'effect';
 import type { ColumnDef } from '@tanstack/vue-table';
 import type { Environment } from '../../../../../vendor/cel-js/lib/index.js';
+import type { ColumnRowSelection } from '../../../utils/resolve.js';
 export declare const type: "com.shwfed.table.column.select";
 export declare const compatibilityDate: "2026-04-14";
 export declare const metadata: {
@@ -20,4 +21,5 @@ export declare function schema(configure: (env: Environment) => void): Schema.St
 }>;
 export type Value = Schema.Schema.Type<ReturnType<typeof schema>>;
 export declare function defaults(): Partial<Value>;
+export declare const rowSelection: ColumnRowSelection;
 export declare function toColumnDef(value: Value): Partial<ColumnDef<unknown, unknown>>;

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

@@ -1,4 +1,4 @@
-import { Schema } from "effect";
+import { Effect, Schema } from "effect";
 import { h } from "vue";
 import { Expression } from "../../../../../share/expression.js";
 import { columnIdentityFields, registerRowVariablesIfAbsent } from "../../../utils/shared.js";
@@ -40,6 +40,21 @@ export function defaults() {
     mode: "checkbox"
   };
 }
+export const rowSelection = (value, deps) => {
+  const predicates = [
+    value.enableRowSelection,
+    value.mode === "checkbox" ? value.enableMultiRowSelection : void 0
+  ].filter((e) => typeof e === "string" && e.trim() !== "");
+  if (predicates.length === 0) return () => true;
+  return (row, index) => predicates.every((expression) => {
+    try {
+      return Boolean(Effect.runSync(deps.$cel(expression, deps.rowScope(row, index))));
+    } catch (e) {
+      console.error("[shwfed-table] row-selection predicate failed", e);
+      return true;
+    }
+  });
+};
 export function toColumnDef(value) {
   return {
     header: (ctx) => h(Header, { column: value, ctx }),

package/dist/runtime/components/table/columns/2026-05-27/com.shwfed.table.column.tree-combobox-multi/config.d.vue.ts

@@ -43,6 +43,7 @@ declare const __VLS_export: import("vue").DefineComponent<__VLS_ModelProps, {},
             readonly data: string;
             readonly request?: string | undefined;
         };
+        readonly enableSorting?: boolean | undefined;
         readonly nodeKey: string;
         readonly nodeChildren: string;
         readonly nodeLabel: readonly [{
@@ -52,7 +53,6 @@ declare const __VLS_export: import("vue").DefineComponent<__VLS_ModelProps, {},
             readonly locale: "en" | "ja" | "ko";
             readonly message: string;
         }[]];
-        readonly enableSorting?: boolean | undefined;
         readonly cascade: "independent" | "cascade-down" | "cascade-both";
         readonly nodeTooltip?: readonly [{
             readonly locale: "zh";
@@ -106,6 +106,7 @@ declare const __VLS_export: import("vue").DefineComponent<__VLS_ModelProps, {},
             readonly data: string;
             readonly request?: string | undefined;
         };
+        readonly enableSorting?: boolean | undefined;
         readonly nodeKey: string;
         readonly nodeChildren: string;
         readonly nodeLabel: readonly [{
@@ -115,7 +116,6 @@ declare const __VLS_export: import("vue").DefineComponent<__VLS_ModelProps, {},
             readonly locale: "en" | "ja" | "ko";
             readonly message: string;
         }[]];
-        readonly enableSorting?: boolean | undefined;
         readonly cascade: "independent" | "cascade-down" | "cascade-both";
         readonly nodeTooltip?: readonly [{
             readonly locale: "zh";

package/dist/runtime/components/table/columns/2026-05-27/com.shwfed.table.column.tree-combobox-multi/config.vue.d.ts

@@ -43,6 +43,7 @@ declare const __VLS_export: import("vue").DefineComponent<__VLS_ModelProps, {},
             readonly data: string;
             readonly request?: string | undefined;
         };
+        readonly enableSorting?: boolean | undefined;
         readonly nodeKey: string;
         readonly nodeChildren: string;
         readonly nodeLabel: readonly [{
@@ -52,7 +53,6 @@ declare const __VLS_export: import("vue").DefineComponent<__VLS_ModelProps, {},
             readonly locale: "en" | "ja" | "ko";
             readonly message: string;
         }[]];
-        readonly enableSorting?: boolean | undefined;
         readonly cascade: "independent" | "cascade-down" | "cascade-both";
         readonly nodeTooltip?: readonly [{
             readonly locale: "zh";
@@ -106,6 +106,7 @@ declare const __VLS_export: import("vue").DefineComponent<__VLS_ModelProps, {},
             readonly data: string;
             readonly request?: string | undefined;
         };
+        readonly enableSorting?: boolean | undefined;
         readonly nodeKey: string;
         readonly nodeChildren: string;
         readonly nodeLabel: readonly [{
@@ -115,7 +116,6 @@ declare const __VLS_export: import("vue").DefineComponent<__VLS_ModelProps, {},
             readonly locale: "en" | "ja" | "ko";
             readonly message: string;
         }[]];
-        readonly enableSorting?: boolean | undefined;
         readonly cascade: "independent" | "cascade-down" | "cascade-both";
         readonly nodeTooltip?: readonly [{
             readonly locale: "zh";

package/dist/runtime/components/table/columns/2026-05-27/com.shwfed.table.column.tree-combobox-single/config.d.vue.ts

@@ -43,6 +43,7 @@ declare const __VLS_export: import("vue").DefineComponent<__VLS_ModelProps, {},
             readonly data: string;
             readonly request?: string | undefined;
         };
+        readonly enableSorting?: boolean | undefined;
         readonly nodeKey: string;
         readonly nodeChildren: string;
         readonly nodeLabel: readonly [{
@@ -52,7 +53,6 @@ declare const __VLS_export: import("vue").DefineComponent<__VLS_ModelProps, {},
             readonly locale: "en" | "ja" | "ko";
             readonly message: string;
         }[]];
-        readonly enableSorting?: boolean | undefined;
         readonly nodeTooltip?: readonly [{
             readonly locale: "zh";
             readonly message: string;
@@ -105,6 +105,7 @@ declare const __VLS_export: import("vue").DefineComponent<__VLS_ModelProps, {},
             readonly data: string;
             readonly request?: string | undefined;
         };
+        readonly enableSorting?: boolean | undefined;
         readonly nodeKey: string;
         readonly nodeChildren: string;
         readonly nodeLabel: readonly [{
@@ -114,7 +115,6 @@ declare const __VLS_export: import("vue").DefineComponent<__VLS_ModelProps, {},
             readonly locale: "en" | "ja" | "ko";
             readonly message: string;
         }[]];
-        readonly enableSorting?: boolean | undefined;
         readonly nodeTooltip?: readonly [{
             readonly locale: "zh";
             readonly message: string;