@shwfed/config 3.0.1 → 3.0.3

package/dist/module.json

@@ -1,7 +1,7 @@
 {
   "name": "shwfed",
   "configKey": "shwfed",
-  "version": "3.0.1",
+  "version": "3.0.3",
   "builder": {
     "@nuxt/module-builder": "1.0.2",
     "unbuild": "unknown"

package/dist/runtime/components/actions/buttons/2026-07-13/com.shwfed.actions.button.state.write/config.d.vue.ts

@@ -0,0 +1,53 @@
+import { type Value } from './schema.js';
+type __VLS_ModelProps = {
+    modelValue: Value;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_ModelProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:modelValue": (value: {
+        readonly type: "com.shwfed.actions.button.state.write";
+        readonly compatibilityDate: "2026-07-13";
+        readonly before?: readonly {
+            readonly id?: string | undefined;
+            readonly params?: unknown;
+            readonly compatibilityDate?: string | undefined;
+            readonly target: string;
+            readonly operation: string;
+        }[] | undefined;
+        readonly onSuccess?: readonly {
+            readonly id?: string | undefined;
+            readonly params?: unknown;
+            readonly compatibilityDate?: string | undefined;
+            readonly target: string;
+            readonly operation: string;
+        }[] | undefined;
+        readonly writes: readonly {
+            readonly path: string;
+            readonly value: string;
+        }[];
+    }) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_ModelProps> & Readonly<{
+    "onUpdate:modelValue"?: ((value: {
+        readonly type: "com.shwfed.actions.button.state.write";
+        readonly compatibilityDate: "2026-07-13";
+        readonly before?: readonly {
+            readonly id?: string | undefined;
+            readonly params?: unknown;
+            readonly compatibilityDate?: string | undefined;
+            readonly target: string;
+            readonly operation: string;
+        }[] | undefined;
+        readonly onSuccess?: readonly {
+            readonly id?: string | undefined;
+            readonly params?: unknown;
+            readonly compatibilityDate?: string | undefined;
+            readonly target: string;
+            readonly operation: string;
+        }[] | undefined;
+        readonly writes: readonly {
+            readonly path: string;
+            readonly value: string;
+        }[];
+    }) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/runtime/components/actions/buttons/2026-07-13/com.shwfed.actions.button.state.write/config.vue

@@ -0,0 +1,174 @@
+<script setup>
+import { computed } from "vue";
+import { Icon } from "@iconify/vue";
+import { Button } from "../../../../ui/button";
+import { Field, FieldLabel } from "../../../../ui/field";
+import { ExpressionEditor } from "../../../../ui/expression-editor";
+import { Markdown } from "../../../../ui/markdown";
+import { InputGroupButton } from "../../../../ui/input-group";
+import { getStructFieldDescription, getStructFieldTitle } from "../../../schema";
+import TriggersField from "../../../components/triggers-field.vue";
+import TriggerRowScope from "../../../components/trigger-row-scope.vue";
+import { publishingSteps } from "../../../utils/steps";
+import { schema } from "./schema";
+defineOptions({ name: "ShwfedStateWriteActionConfig" });
+const value = defineModel({ type: null, ...{ required: true } });
+const actionSchema = schema(() => {
+});
+const fieldTitle = (f) => getStructFieldTitle(actionSchema, f) ?? f;
+const fieldDescription = (f) => getStructFieldDescription(actionSchema, f);
+const writes = computed(() => value.value.writes ?? []);
+const beforeSteps = computed(() => publishingSteps(value.value.before));
+const writeRoster = computed(
+  () => beforeSteps.value.map((step) => ({
+    id: step.id,
+    label: `\u7B2C ${step.index + 1} \u6B65`,
+    valid: true,
+    description: step.output
+  }))
+);
+const afterInherited = computed(
+  () => beforeSteps.value.map((step) => ({
+    id: step.id,
+    label: `\u5199\u5165\u524D \u7B2C ${step.index + 1} \u6B65`,
+    valid: true,
+    description: step.output
+  }))
+);
+function patchWrites(next) {
+  value.value = { ...value.value, writes: next };
+}
+function updateRow(index, patch) {
+  patchWrites(writes.value.map((w, i) => i === index ? { ...w, ...patch } : w));
+}
+function addRow() {
+  patchWrites([...writes.value, { path: "", value: "" }]);
+}
+function removeRow(index) {
+  patchWrites(writes.value.filter((_, i) => i !== index));
+}
+function updateTriggers(key, next) {
+  const draft = { ...value.value };
+  if (next.length === 0) Reflect.deleteProperty(draft, key);
+  else draft[key] = next;
+  value.value = draft;
+}
+</script>
+
+<template>
+  <div class="flex flex-col gap-3">
+    <Field orientation="vertical">
+      <FieldLabel class="text-xs text-zinc-500">
+        <template
+          v-if="fieldDescription('before')"
+          #tooltip
+        >
+          <Markdown
+            :source="fieldDescription('before')"
+            block
+            class="prose prose-sm prose-zinc"
+          />
+        </template>
+        {{ fieldTitle("before") }}
+      </FieldLabel>
+      <TriggersField
+        :triggers="value.before ?? []"
+        @update:triggers="(next) => updateTriggers('before', next)"
+      />
+    </Field>
+
+    <Field orientation="vertical">
+      <FieldLabel class="text-xs text-zinc-500">
+        <template
+          v-if="fieldDescription('writes')"
+          #tooltip
+        >
+          <Markdown
+            :source="fieldDescription('writes')"
+            block
+            class="prose prose-sm prose-zinc"
+          />
+        </template>
+        {{ fieldTitle("writes") }}
+      </FieldLabel>
+
+      <!-- Advertise the「写入前」steps to the value editors: they get the
+          「第 N 步」picker chips + `steps` inline validation. -->
+      <TriggerRowScope :roster="writeRoster">
+        <div class="flex flex-col gap-3">
+          <!-- One write item per multiline editor: the monofont binding path as
+               a full-width `leading` header row, the value expression wrapping
+               below (its own `{x}` badge), and a destructive delete in the
+               `trailing` bottom row. Reuses the ExpressionEditor's own
+               InputGroup. -->
+          <ExpressionEditor
+            v-for="(row, index) in writes"
+            :key="index"
+            :model-value="row.value"
+            multiline
+            placeholder="值，如 selected[?0].?exchangeRate"
+            class="min-h-16"
+            @update:model-value="(v) => updateRow(index, { value: v })"
+          >
+            <template #leading>
+              <input
+                type="text"
+                data-slot="state-write-path"
+                :value="row.path"
+                placeholder="路径"
+                class="w-full min-w-0 bg-transparent font-mono text-sm text-zinc-700 outline-none placeholder:text-zinc-300"
+                :aria-label="`\u5199\u5165\u8DEF\u5F84 ${index + 1}`"
+                @input="updateRow(index, { path: $event.target.value })"
+              >
+            </template>
+            <template #trailing>
+              <InputGroupButton
+                variant="destructive"
+                size="icon-xs"
+                as-child
+              >
+                <button
+                  type="button"
+                  :aria-label="`\u79FB\u9664\u5199\u5165\u9879 ${index + 1}`"
+                  @click="removeRow(index)"
+                >
+                  <Icon icon="fluent:delete-20-regular" />
+                </button>
+              </InputGroupButton>
+            </template>
+          </ExpressionEditor>
+
+          <Button
+            type="button"
+            class="justify-center"
+            @click="addRow"
+          >
+            <Icon icon="fluent:add-20-regular" />
+            <span>添加写入项</span>
+          </Button>
+        </div>
+      </TriggerRowScope>
+    </Field>
+
+    <Field orientation="vertical">
+      <FieldLabel class="text-xs text-zinc-500">
+        <template
+          v-if="fieldDescription('onSuccess')"
+          #tooltip
+        >
+          <Markdown
+            :source="fieldDescription('onSuccess')"
+            block
+            class="prose prose-sm prose-zinc"
+          />
+        </template>
+        {{ fieldTitle("onSuccess") }}
+      </FieldLabel>
+      <TriggersField
+        :triggers="value.onSuccess ?? []"
+        :inherited="afterInherited"
+        @update:triggers="(next) => updateTriggers('onSuccess', next)"
+      />
+    </Field>
+  </div>
+</template>

package/dist/runtime/components/actions/buttons/2026-07-13/com.shwfed.actions.button.state.write/config.vue.d.ts

@@ -0,0 +1,53 @@
+import { type Value } from './schema.js';
+type __VLS_ModelProps = {
+    modelValue: Value;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_ModelProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:modelValue": (value: {
+        readonly type: "com.shwfed.actions.button.state.write";
+        readonly compatibilityDate: "2026-07-13";
+        readonly before?: readonly {
+            readonly id?: string | undefined;
+            readonly params?: unknown;
+            readonly compatibilityDate?: string | undefined;
+            readonly target: string;
+            readonly operation: string;
+        }[] | undefined;
+        readonly onSuccess?: readonly {
+            readonly id?: string | undefined;
+            readonly params?: unknown;
+            readonly compatibilityDate?: string | undefined;
+            readonly target: string;
+            readonly operation: string;
+        }[] | undefined;
+        readonly writes: readonly {
+            readonly path: string;
+            readonly value: string;
+        }[];
+    }) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_ModelProps> & Readonly<{
+    "onUpdate:modelValue"?: ((value: {
+        readonly type: "com.shwfed.actions.button.state.write";
+        readonly compatibilityDate: "2026-07-13";
+        readonly before?: readonly {
+            readonly id?: string | undefined;
+            readonly params?: unknown;
+            readonly compatibilityDate?: string | undefined;
+            readonly target: string;
+            readonly operation: string;
+        }[] | undefined;
+        readonly onSuccess?: readonly {
+            readonly id?: string | undefined;
+            readonly params?: unknown;
+            readonly compatibilityDate?: string | undefined;
+            readonly target: string;
+            readonly operation: string;
+        }[] | undefined;
+        readonly writes: readonly {
+            readonly path: string;
+            readonly value: string;
+        }[];
+    }) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/runtime/components/actions/buttons/2026-07-13/com.shwfed.actions.button.state.write/runtime.d.vue.ts

@@ -0,0 +1,8 @@
+import type { Value } from './schema.js';
+type __VLS_Props = {
+    buttonId: 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/actions/buttons/2026-07-13/com.shwfed.actions.button.state.write/runtime.vue

@@ -0,0 +1,70 @@
+<script setup>
+import { Effect } from "effect";
+import { createDefu } from "defu";
+import { cel as _rawCel } from "../../../../../utils/cel";
+import { celBindings, injectCELContext } from "../../../../../utils/cel-context";
+import { dispatchTriggers, useEventChannel } from "../../../../../share/event-bus";
+import { useFormState } from "../../../../form/utils/state";
+import ShwfedActionDefinition from "../../../components/definition.vue";
+defineOptions({ name: "ShwfedStateWriteActionRuntime" });
+const props = defineProps({
+  buttonId: { type: String, required: true },
+  config: { type: null, required: true }
+});
+const inherited = injectCELContext();
+const $cel = (expression, context) => _rawCel(expression, { ...celBindings(inherited), ...context });
+const nearestFormState = useFormState();
+const formState = nearestFormState.kind === "form" && nearestFormState.parent ? nearestFormState.parent : nearestFormState;
+const channel = useEventChannel();
+const mergeObjects = createDefu((obj, key, value) => {
+  if (Array.isArray(obj[key]) && Array.isArray(value)) {
+    obj[key] = value;
+    return true;
+  }
+});
+function isPlainObject(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function mergeAtPath(current, next) {
+  if (isPlainObject(current) && isPlainObject(next)) {
+    return mergeObjects({ ...next }, current);
+  }
+  return next;
+}
+const effect = Effect.suspend(() => {
+  const steps = {};
+  return dispatchTriggers(channel, props.config.before, $cel, steps).pipe(
+    // 写入前 halts (a failed request, a form 「校验」 that found errors) abort the
+    // whole click via a defect, so no write below runs — same guarantee the
+    // inline 2026-06-25 requests gave, now shared with every other op.
+    Effect.flatMap(
+      () => (
+        // Evaluate every row's `value` in list order. A row with a blank `path` is
+        // skipped (a half-authored row writes nowhere) but its value is never
+        // evaluated — `Effect.forEach` keeps the click sequential and short-circuits
+        // on the first failing expression.
+        Effect.forEach(
+          props.config.writes ?? [],
+          (write) => {
+            const path = write.path?.trim() ?? "";
+            if (path.length === 0) return Effect.void;
+            return Effect.map($cel(write.value, { steps }), (result) => {
+              const merged = mergeAtPath(formState.getAt(path), result);
+              formState.setAt(path, merged);
+            });
+          },
+          { discard: true }
+        )
+      )
+    ),
+    Effect.flatMap(() => dispatchTriggers(channel, props.config.onSuccess, $cel, steps))
+  );
+});
+</script>
+
+<template>
+  <ShwfedActionDefinition
+    :action-id="buttonId"
+    :effect="effect"
+  />
+</template>

package/dist/runtime/components/actions/buttons/2026-07-13/com.shwfed.actions.button.state.write/runtime.vue.d.ts

@@ -0,0 +1,8 @@
+import type { Value } from './schema.js';
+type __VLS_Props = {
+    buttonId: 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/actions/buttons/2026-07-13/com.shwfed.actions.button.state.write/schema.d.ts

@@ -0,0 +1,49 @@
+import { Schema } from 'effect';
+import type { Environment } from '../../../../../vendor/cel-js/lib/index.js';
+import type { MigrateFn } from '../../../utils/resolve.js';
+export declare const type: "com.shwfed.actions.button.state.write";
+export declare const compatibilityDate: "2026-07-13";
+export declare const metadata: {
+    readonly name: "写入表单状态";
+    readonly icon: "fluent:document-edit-20-regular";
+};
+export declare function schema(configure: (env: Environment) => void): Schema.Struct<{
+    type: Schema.Literal<["com.shwfed.actions.button.state.write"]>;
+    compatibilityDate: Schema.Literal<["2026-07-13"]>;
+    before: Schema.optional<Schema.Array$<Schema.Struct<{
+        id: Schema.optional<Schema.refine<string, typeof Schema.String>>;
+        target: Schema.refine<string, typeof Schema.String>;
+        operation: Schema.SchemaClass<string, string, never>;
+        compatibilityDate: Schema.optional<Schema.SchemaClass<string, string, never>>;
+        params: Schema.optional<Schema.SchemaClass<unknown, unknown, never>>;
+    }>>>;
+    writes: Schema.Array$<Schema.Struct<{
+        path: Schema.SchemaClass<string, string, never>;
+        value: Schema.Schema<string, string, never>;
+    }>>;
+    onSuccess: Schema.optional<Schema.Array$<Schema.Struct<{
+        id: Schema.optional<Schema.refine<string, typeof Schema.String>>;
+        target: Schema.refine<string, typeof Schema.String>;
+        operation: Schema.SchemaClass<string, string, never>;
+        compatibilityDate: Schema.optional<Schema.SchemaClass<string, string, never>>;
+        params: Schema.optional<Schema.SchemaClass<unknown, unknown, never>>;
+    }>>>;
+}>;
+export type Value = Schema.Schema.Type<ReturnType<typeof schema>>;
+export type WriteValue = Value['writes'][number];
+/**
+ * Adopts 2026-06-25 values, whose「写入前」was a `requests` list of bare
+ * HTTP-request expressions. Each row becomes one「发送请求」op trigger on the
+ * page target — the op the button now dispatches instead of fetching itself.
+ * The row's `id` is carried over verbatim, so every `steps["<id>"]` already
+ * written into a write value keeps resolving; the op publishes its parsed
+ * response under that same id and halts the chain on failure, which is what the
+ * old inline requests did.
+ *
+ * The date rule (same type, newest date) also points 2026-05-24 values here.
+ * Those store a single map `expression` instead of `writes` rows, and splitting
+ * an arbitrary map expression back into rows needs human judgement — the 2026-
+ * 06-25 entry deliberately shipped no migration for it, and this one keeps that
+ * call, failing with guidance rather than guessing.
+ */
+export declare const migrate: MigrateFn;

package/dist/runtime/components/actions/buttons/2026-07-13/com.shwfed.actions.button.state.write/schema.js

@@ -0,0 +1,90 @@
+import { Effect, Schema } from "effect";
+import { Expression } from "../../../../../share/expression.js";
+import { Triggers } from "../../../../../share/event-bus.js";
+import { PAGE_TARGET_ID } from "../../../../../share/page-target.js";
+import { md } from "../../../../../share/markdown.js";
+import { registerStepsVariableIfAbsent } from "../../../../operations/utils/step-vars.js";
+import * as httpRequestOperation from "../../../../operations/2026-06-11/com.shwfed.operation.http.request.json/schema.js";
+export const type = "com.shwfed.actions.button.state.write";
+export const compatibilityDate = "2026-07-13";
+export const metadata = {
+  name: "\u5199\u5165\u8868\u5355\u72B6\u6001",
+  icon: "fluent:document-edit-20-regular"
+};
+export function schema(configure) {
+  const withSteps = (env) => {
+    configure(env);
+    registerStepsVariableIfAbsent(env);
+  };
+  const Write = Schema.Struct({
+    path: Schema.String.annotations({
+      title: "\u8DEF\u5F84",
+      description: "\u5199\u5165\u7684\u7ED1\u5B9A\u8DEF\u5F84\uFF0C\u5982 `dataJson.cus_currency`"
+    }),
+    value: Expression({ configure: withSteps }).annotations({
+      title: "\u503C",
+      description: "\u70B9\u51FB\u540E\u6C42\u503C\uFF0C\u7ED3\u679C\u5199\u5165\u8BE5\u8DEF\u5F84"
+    })
+  });
+  return Schema.Struct({
+    type: Schema.Literal(type),
+    compatibilityDate: Schema.Literal(compatibilityDate),
+    before: Schema.optional(Triggers.annotations({
+      title: "\u5199\u5165\u524D",
+      description: md`
+        写入前按列表顺序执行的操作。任一操作中止（例如请求失败、表单校验未通过）
+        将取消本次写入。
+
+        发布输出的操作（如「发送请求」）可在「写入值」与「写入后」中经
+        \`steps["<第 N 步>"]\` 引用其输出。
+      `
+    })),
+    writes: Schema.Array(Write).annotations({
+      title: "\u5199\u5165\u503C",
+      description: md`
+        点击后按列表顺序逐行求值并写入到最近祖先的表单状态：每行的 \`值\`
+        表达式结果写入其 \`路径\`。对象值与当前值深合并（数组整体替换），
+        其他类型直接替换。留空表示不进行任何写入。
+      `
+    }),
+    onSuccess: Schema.optional(Triggers.annotations({
+      title: "\u5199\u5165\u540E",
+      description: "\u5199\u5165\u5B8C\u6210\u540E\u6267\u884C\u7684\u64CD\u4F5C"
+    }))
+  }).annotations({
+    title: "StateWriteAction",
+    description: "\u70B9\u51FB\u540E\u6309\u987A\u5E8F\u5C06\u6BCF\u4E2A CEL \u8868\u8FBE\u5F0F\u7684\u7ED3\u679C\u5199\u56DE\u6700\u8FD1\u7956\u5148\u8868\u5355\u72B6\u6001\u7684\u5BF9\u5E94\u8DEF\u5F84"
+  });
+}
+export const migrate = (prev) => Effect.try({
+  try: () => {
+    if (!prev || typeof prev !== "object") {
+      throw new Error("\u5199\u5165\u8868\u5355\u72B6\u6001\u8FC1\u79FB\u5931\u8D25\uFF1A\u539F\u503C\u4E0D\u662F\u5BF9\u8C61");
+    }
+    const { type: _t, compatibilityDate: _c, requests, ...rest } = prev;
+    if (!Array.isArray(rest.writes)) {
+      throw new TypeError(
+        "\u5199\u5165\u8868\u5355\u72B6\u6001\u8FC1\u79FB\u5931\u8D25\uFF1A2026-05-24 \u7684\u300C\u5199\u5165\u503C\u300D\u662F\u5355\u4E2A map \u8868\u8FBE\u5F0F\uFF0C\u9700\u6309\u5199\u5165\u8DEF\u5F84\u4EBA\u5DE5\u62C6\u5206\u4E3A\u5199\u5165\u884C\uFF0C\u65E0\u6CD5\u81EA\u52A8\u8FC1\u79FB"
+      );
+    }
+    const before = (Array.isArray(requests) ? requests : []).map((row) => {
+      const { id, request } = row ?? {};
+      return {
+        id,
+        target: PAGE_TARGET_ID,
+        operation: httpRequestOperation.type,
+        compatibilityDate: httpRequestOperation.compatibilityDate,
+        params: { expression: request ?? "" }
+      };
+    });
+    return {
+      ...rest,
+      type,
+      compatibilityDate,
+      // Stay optional-absent when there was nothing to migrate, so an
+      // untouched button migrates to a config with no `before` key at all.
+      ...before.length > 0 ? { before } : {}
+    };
+  },
+  catch: (e) => e instanceof Error ? e : new Error(String(e))
+});

package/dist/runtime/components/actions/components/triggers-field.d.vue.ts

@@ -1,6 +1,15 @@
 import { type TriggerValue } from '../../../share/event-bus.js';
+import type { StepRef } from '../../../utils/cel-context.js';
 type __VLS_Props = {
     triggers: ReadonlyArray<TriggerValue>;
+    /**
+     * Steps published BEFORE this list runs, from a chain the host already
+     * dispatched — state.write's 写入前 rows, as seen by its 写入后 list. Prefixed
+     * (always valid — they ran before every row here) into every row's roster, so
+     * an op param can reference them. Omitted by every other host: a lone trigger
+     * list has nothing upstream of it.
+     */
+    inherited?: ReadonlyArray<StepRef>;
 };
 declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
     "update:triggers": (triggers: readonly {

package/dist/runtime/components/actions/components/triggers-field.vue

@@ -3,6 +3,7 @@ import { computed, ref } from "vue";
 import { Icon } from "@iconify/vue";
 import { useEventAncestry } from "../../../share/event-bus";
 import { findOperation } from "../../operations/utils/resolve";
+import { publishingSteps } from "../utils/steps";
 import TriggerRowScope from "./trigger-row-scope.vue";
 import {
   useTreeDnd
@@ -17,7 +18,8 @@ import {
 import { CommandGroup, CommandItem } from "../../ui/command";
 defineOptions({ name: "ShwfedTriggersField" });
 const props = defineProps({
-  triggers: { type: Array, required: true }
+  triggers: { type: Array, required: true },
+  inherited: { type: Array, required: false }
 });
 const emit = defineEmits(["update:triggers"]);
 function keyOf(target, operation) {
@@ -90,21 +92,17 @@ function opConfigFor(trigger) {
 function removeTrigger(index) {
   emit("update:triggers", props.triggers.filter((_, i) => i !== index));
 }
-const publishingSteps = computed(
-  () => props.triggers.flatMap((trigger, index) => {
-    if (!trigger.id || !trigger.compatibilityDate) return [];
-    const output = findOperation(trigger.operation, trigger.compatibilityDate)?.metadata.output;
-    if (!output) return [];
-    return [{ id: trigger.id, index, output }];
-  })
-);
+const ownSteps = computed(() => publishingSteps(props.triggers));
 function stepRosterFor(index) {
-  return publishingSteps.value.map((step) => ({
-    id: step.id,
-    label: `\u7B2C ${step.index + 1} \u6B65`,
-    valid: step.index < index,
-    description: step.output
-  }));
+  return [
+    ...props.inherited ?? [],
+    ...ownSteps.value.map((step) => ({
+      id: step.id,
+      label: `\u7B2C ${step.index + 1} \u6B65`,
+      valid: step.index < index,
+      description: step.output
+    }))
+  ];
 }
 const ROW_KIND = "shwfed-trigger-row";
 function moveTrigger(from, to) {

package/dist/runtime/components/actions/components/triggers-field.vue.d.ts

@@ -1,6 +1,15 @@
 import { type TriggerValue } from '../../../share/event-bus.js';
+import type { StepRef } from '../../../utils/cel-context.js';
 type __VLS_Props = {
     triggers: ReadonlyArray<TriggerValue>;
+    /**
+     * Steps published BEFORE this list runs, from a chain the host already
+     * dispatched — state.write's 写入前 rows, as seen by its 写入后 list. Prefixed
+     * (always valid — they ran before every row here) into every row's roster, so
+     * an op param can reference them. Omitted by every other host: a lone trigger
+     * list has nothing upstream of it.
+     */
+    inherited?: ReadonlyArray<StepRef>;
 };
 declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
     "update:triggers": (triggers: readonly {

package/dist/runtime/components/actions/utils/steps.d.ts

@@ -0,0 +1,26 @@
+import type { TriggerValue } from '../../../share/event-bus.js';
+/**
+ * One row of a trigger list that publishes a chain-step output — the rows a
+ * later expression can address as `steps["<id>"]`.
+ *
+ * A row qualifies on two counts, neither of them a type check: its operation's
+ * registry `metadata.output` marks it as publishing (so a new publishing op
+ * needs no edit here), and it carries a persisted `id` to publish under (rows
+ * authored before ids were minted simply can't be referenced). `index` is the
+ * row's CURRENT position, which is what the「第 N 步」labels are built from —
+ * so labels follow a dnd reorder.
+ */
+export type PublishingStep = Readonly<{
+    id: string;
+    index: number;
+    /** Designer-facing label of what the op publishes (`metadata.output`). */
+    output: string;
+}>;
+/**
+ * The publishing rows of one trigger list. Shared by every step-roster builder
+ * — the trigger editor's per-row roster (earlier rows of the same list) and a
+ * button advertising a whole finished chain to a later field (state.write's
+ * 写入前 → 写入值 / 写入后) — so "which rows are referenceable" is decided in
+ * exactly one place.
+ */
+export declare function publishingSteps(triggers: ReadonlyArray<TriggerValue> | undefined): ReadonlyArray<PublishingStep>;

package/dist/runtime/components/actions/utils/steps.js

@@ -0,0 +1,9 @@
+import { findOperation } from "../../operations/utils/resolve.js";
+export function publishingSteps(triggers) {
+  return (triggers ?? []).flatMap((trigger, index) => {
+    if (!trigger.id || !trigger.compatibilityDate) return [];
+    const output = findOperation(trigger.operation, trigger.compatibilityDate)?.metadata.output;
+    if (!output) return [];
+    return [{ id: trigger.id, index, output }];
+  });
+}