@shwfed/config 3.0.13 → 3.0.15

package/dist/runtime/components/ui/date-range-picker/DateRangePicker.vue

@@ -129,11 +129,15 @@ function emitRange(start, end) {
   stringValue.value = next;
   emits("change", next);
 }
-function setStart(date) {
-  emitRange(date, endNative.value);
-}
-function setEnd(date) {
-  emitRange(startNative.value, date);
+function commitFromInput(start, end) {
+  const isRefused = (d) => props.disabledDate?.(nativeToDateValue(d, props.type)) ?? false;
+  if (start && isRefused(start)) return;
+  if (end && isRefused(end)) return;
+  if (start && end && start > end) {
+    emitRange(end, start);
+    return;
+  }
+  emitRange(start, end);
 }
 function setStartTime(time) {
   emitRange(time ? timeToNative(time) : void 0, endNative.value);
@@ -250,8 +254,7 @@ function onInputBlur(event, side) {
           :open="open"
           :size="props.size"
           :class="props.inputClass"
-          @update:start-value="setStart"
-          @update:end-value="setEnd"
+          @commit="commitFromInput"
           @focus="onInputFocus"
           @blur="onInputBlur"
           @clear="clearAll"

package/dist/runtime/components/ui/date-range-picker/DateRangePickerInput.d.vue.ts

@@ -19,18 +19,16 @@ declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {
     clear: () => any;
     blur: (args_0: FocusEvent, args_1: "end" | "start") => any;
     focus: (args_0: FocusEvent, args_1: "end" | "start") => any;
-    "update:startValue": (args_0: Date | undefined) => any;
-    "update:endValue": (args_0: Date | undefined) => any;
+    commit: (args_0: Date | undefined, args_1: Date | undefined) => any;
 }, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
     onClear?: (() => any) | undefined;
     onBlur?: ((args_0: FocusEvent, args_1: "end" | "start") => any) | undefined;
     onFocus?: ((args_0: FocusEvent, args_1: "end" | "start") => any) | undefined;
-    "onUpdate:startValue"?: ((args_0: Date | undefined) => any) | undefined;
-    "onUpdate:endValue"?: ((args_0: Date | undefined) => any) | undefined;
+    onCommit?: ((args_0: Date | undefined, args_1: Date | undefined) => any) | undefined;
 }>, {
     size: "sm" | "md" | "lg";
-    clearable: boolean;
     clearIcon: string;
+    clearable: boolean;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const _default: typeof __VLS_export;
 export default _default;

package/dist/runtime/components/ui/date-range-picker/DateRangePickerInput.vue

@@ -1,7 +1,7 @@
 <script setup>
 import { Icon } from "@iconify/vue";
 import { format as formatDate, isValid, parse as parseDate } from "date-fns";
-import { computed, ref, watch } from "vue";
+import { computed, nextTick, ref, useTemplateRef, watch } from "vue";
 import { cn } from "../../../utils/cn";
 import { InputGroupButton } from "../input-group";
 defineOptions({ name: "UiDateRangePickerInput", inheritAttrs: false });
@@ -29,7 +29,8 @@ const sizeClass = computed(() => ({
 const inputTextClass = computed(() => ({ sm: "text-xs", md: "text-sm", lg: "text-base" })[props.size]);
 const clearButtonSizeClass = computed(() => props.size === "sm" ? "size-4" : "");
 const clearIconSizeClass = computed(() => props.size === "sm" ? "size-3" : "");
-const emits = defineEmits(["update:startValue", "update:endValue", "focus", "blur", "clear"]);
+const emits = defineEmits(["commit", "focus", "blur", "clear"]);
+const rootEl = useTemplateRef("root-el");
 const startDraft = ref("");
 const endDraft = ref("");
 const focusedSide = ref(null);
@@ -53,25 +54,21 @@ watch(
   },
   { immediate: true }
 );
-function commit(side) {
-  const draft = side === "start" ? startDraft : endDraft;
-  const current = side === "start" ? props.startValue : props.endValue;
-  const sync = side === "start" ? syncStart : syncEnd;
-  const text = draft.value.trim();
-  if (!text) {
-    if (current !== void 0) {
-      if (side === "start") emits("update:startValue", void 0);
-      else emits("update:endValue", void 0);
-    }
-    return;
-  }
-  const parsed = parseDate(text, props.format, current ?? /* @__PURE__ */ new Date());
-  if (!isValid(parsed)) {
-    sync();
-    return;
-  }
-  if (side === "start") emits("update:startValue", parsed);
-  else emits("update:endValue", parsed);
+function parseDraft(text, fallback) {
+  const trimmed = text.trim();
+  if (!trimmed) return void 0;
+  const parsed = parseDate(trimmed, props.format, fallback ?? /* @__PURE__ */ new Date());
+  return isValid(parsed) ? parsed : void 0;
+}
+async function commit() {
+  emits(
+    "commit",
+    parseDraft(startDraft.value, props.startValue),
+    parseDraft(endDraft.value, props.endValue)
+  );
+  await nextTick();
+  syncStart();
+  syncEnd();
 }
 function onFocus(event, side) {
   focusedSide.value = side;
@@ -79,14 +76,17 @@ function onFocus(event, side) {
 }
 function onBlur(event, side) {
   focusedSide.value = null;
-  commit(side);
   emits("blur", event, side);
 }
+function onFocusOut(event) {
+  const next = event.relatedTarget;
+  if (next instanceof Node && rootEl.value?.contains(next)) return;
+  void commit();
+}
 function onClear() {
   startDraft.value = "";
   endDraft.value = "";
-  emits("update:startValue", void 0);
-  emits("update:endValue", void 0);
+  emits("commit", void 0, void 0);
   emits("clear");
 }
 const showClear = computed(
@@ -97,6 +97,7 @@ const hasValue = computed(() => props.startValue !== void 0 || props.endValue !=
 
 <template>
   <div
+    ref="root-el"
     v-bind="$attrs"
     data-slot="date-range-picker-input"
     :data-disabled="props.disabled ? 'true' : void 0"
@@ -111,6 +112,7 @@ const hasValue = computed(() => props.startValue !== void 0 || props.endValue !=
   sizeClass,
   props.class
 )"
+    @focusout="onFocusOut"
   >
     <Icon
       v-if="props.prefixIcon"
@@ -131,7 +133,7 @@ const hasValue = computed(() => props.startValue !== void 0 || props.endValue !=
 )"
       @focus="(e) => onFocus(e, 'start')"
       @blur="(e) => onBlur(e, 'start')"
-      @keydown.enter.prevent="commit('start')"
+      @keydown.enter.prevent="commit()"
     >
     <Icon
       v-if="props.rangeSeparatorIcon"
@@ -153,7 +155,7 @@ const hasValue = computed(() => props.startValue !== void 0 || props.endValue !=
 )"
       @focus="(e) => onFocus(e, 'end')"
       @blur="(e) => onBlur(e, 'end')"
-      @keydown.enter.prevent="commit('end')"
+      @keydown.enter.prevent="commit()"
     >
     <InputGroupButton
       v-if="showClear"

package/dist/runtime/components/ui/date-range-picker/DateRangePickerInput.vue.d.ts

@@ -19,18 +19,16 @@ declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {
     clear: () => any;
     blur: (args_0: FocusEvent, args_1: "end" | "start") => any;
     focus: (args_0: FocusEvent, args_1: "end" | "start") => any;
-    "update:startValue": (args_0: Date | undefined) => any;
-    "update:endValue": (args_0: Date | undefined) => any;
+    commit: (args_0: Date | undefined, args_1: Date | undefined) => any;
 }, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
     onClear?: (() => any) | undefined;
     onBlur?: ((args_0: FocusEvent, args_1: "end" | "start") => any) | undefined;
     onFocus?: ((args_0: FocusEvent, args_1: "end" | "start") => any) | undefined;
-    "onUpdate:startValue"?: ((args_0: Date | undefined) => any) | undefined;
-    "onUpdate:endValue"?: ((args_0: Date | undefined) => any) | undefined;
+    onCommit?: ((args_0: Date | undefined, args_1: Date | undefined) => any) | undefined;
 }>, {
     size: "sm" | "md" | "lg";
-    clearable: boolean;
     clearIcon: string;
+    clearable: boolean;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const _default: typeof __VLS_export;
 export default _default;

package/dist/runtime/components/ui/date-range-picker/DateRangePickerTimeInput.d.vue.ts

@@ -26,9 +26,9 @@ declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {
     size: "sm" | "md" | "lg";
     granularity: "hour" | "minute" | "second";
     hourCycle: 12 | 24;
-    clearable: boolean;
-    clearIcon: string;
     rangeSeparatorIcon: string;
+    clearIcon: string;
+    clearable: boolean;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const _default: typeof __VLS_export;
 export default _default;

package/dist/runtime/components/ui/date-range-picker/DateRangePickerTimeInput.vue.d.ts

@@ -26,9 +26,9 @@ declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {
     size: "sm" | "md" | "lg";
     granularity: "hour" | "minute" | "second";
     hourCycle: 12 | 24;
-    clearable: boolean;
-    clearIcon: string;
     rangeSeparatorIcon: string;
+    clearIcon: string;
+    clearable: boolean;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const _default: typeof __VLS_export;
 export default _default;

package/dist/runtime/components/ui/expression-editor/picker-entries.js

@@ -39,7 +39,7 @@ export function buildStepEntries(roster) {
   return roster.filter((step) => step.valid).map((step) => ({
     id: `step:${step.id}`,
     group: "step",
-    insert: `${STEPS_VAR}[?${JSON.stringify(step.id)}]`,
+    insert: `${STEPS_VAR}[${JSON.stringify(step.id)}]`,
     display: step.label,
     label: "\u524D\u5E8F\u6B65\u9AA4",
     type: "dyn",

package/dist/runtime/components/ui/expression-editor/step-chip-extension.js

@@ -76,7 +76,7 @@ const chipPlugin = ViewPlugin.fromClass(
   {
     decorations: (plugin) => plugin.decorations,
     // Atomic so the caret steps over a chip and Backspace removes the whole
-    // `steps[?"id"]` at once — matching the scope/selection chips' feel.
+    // `steps["id"]` at once — matching the scope/selection chips' feel.
     provide: (plugin) => EditorView.atomicRanges.of((view) => view.plugin(plugin)?.decorations ?? Decoration.none)
   }
 );

package/dist/runtime/components/ui/expression-editor/step-refs.js

@@ -1,6 +1,6 @@
 import { STEPS_VAR } from "../../../utils/cel-context.js";
 const STEP_REF_RE = new RegExp(
-  `(?<![\\w$.])${STEPS_VAR}\\[\\??("(?:[^"\\\\]|\\\\.)*")\\]`,
+  `(?<![\\w$.])${STEPS_VAR}\\[("(?:[^"\\\\]|\\\\.)*")\\]`,
   "g"
 );
 export function scanStepRefs(text) {

package/dist/runtime/components/ui/range-calendar/RangeCalendar.d.vue.ts

@@ -1,18 +1,18 @@
-import type { RangeCalendarRootProps } from 'reka-ui';
+import type { DateValue, RangeCalendarRootProps } from 'reka-ui';
 import type { HTMLAttributes } from 'vue';
 type __VLS_Props = RangeCalendarRootProps & {
     class?: HTMLAttributes['class'];
 };
 declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
     "update:modelValue": (date: import("reka-ui").DateRange) => any;
-    "update:placeholder": (date: import("reka-ui").DateValue) => any;
+    "update:placeholder": (date: DateValue) => any;
     "update:validModelValue": (date: import("reka-ui").DateRange) => any;
-    "update:startValue": (date: import("reka-ui").DateValue | undefined) => any;
+    "update:startValue": (date: DateValue | undefined) => any;
 }, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
     "onUpdate:modelValue"?: ((date: import("reka-ui").DateRange) => any) | undefined;
-    "onUpdate:placeholder"?: ((date: import("reka-ui").DateValue) => any) | undefined;
+    "onUpdate:placeholder"?: ((date: DateValue) => any) | undefined;
     "onUpdate:validModelValue"?: ((date: import("reka-ui").DateRange) => any) | undefined;
-    "onUpdate:startValue"?: ((date: import("reka-ui").DateValue | undefined) => any) | undefined;
+    "onUpdate:startValue"?: ((date: DateValue | undefined) => any) | undefined;
 }>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const _default: typeof __VLS_export;
 export default _default;

package/dist/runtime/components/ui/range-calendar/RangeCalendar.vue

@@ -1,4 +1,5 @@
 <script setup>
+import { Icon } from "@iconify/vue";
 import { reactiveOmit, useNavigatorLanguage } from "@vueuse/core";
 import { RangeCalendarRoot, useForwardPropsEmits } from "reka-ui";
 import { computed } from "vue";
@@ -55,12 +56,28 @@ const locale = computed(() => props.locale ?? i18nLocale.value ?? navLocale.lang
     :locale="locale"
   >
     <RangeCalendarHeader>
-      <RangeCalendarHeading />
+      <nav class="w-full flex items-center gap-1 absolute top-1/2 -translate-y-1/2 transform-gpu inset-x-0 justify-between z-10">
+        <div class="flex items-center gap-0.5">
+          <RangeCalendarPrevButton
+            :prev-page="(d) => d.subtract({ years: 1 })"
+            data-slot="range-calendar-prev-year-button"
+          >
+            <Icon icon="fluent:chevron-double-left-20-regular" />
+          </RangeCalendarPrevButton>
+          <RangeCalendarPrevButton />
+        </div>
+        <div class="flex items-center gap-0.5">
+          <RangeCalendarNextButton />
+          <RangeCalendarNextButton
+            :next-page="(d) => d.add({ years: 1 })"
+            data-slot="range-calendar-next-year-button"
+          >
+            <Icon icon="fluent:chevron-double-right-20-regular" />
+          </RangeCalendarNextButton>
+        </div>
+      </nav>
 
-      <div class="flex items-center gap-1">
-        <RangeCalendarPrevButton />
-        <RangeCalendarNextButton />
-      </div>
+      <RangeCalendarHeading />
     </RangeCalendarHeader>
 
     <div class="flex flex-col gap-y-4 mt-4 sm:flex-row sm:gap-x-4 sm:gap-y-0">

package/dist/runtime/components/ui/range-calendar/RangeCalendar.vue.d.ts

@@ -1,18 +1,18 @@
-import type { RangeCalendarRootProps } from 'reka-ui';
+import type { DateValue, RangeCalendarRootProps } from 'reka-ui';
 import type { HTMLAttributes } from 'vue';
 type __VLS_Props = RangeCalendarRootProps & {
     class?: HTMLAttributes['class'];
 };
 declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
     "update:modelValue": (date: import("reka-ui").DateRange) => any;
-    "update:placeholder": (date: import("reka-ui").DateValue) => any;
+    "update:placeholder": (date: DateValue) => any;
     "update:validModelValue": (date: import("reka-ui").DateRange) => any;
-    "update:startValue": (date: import("reka-ui").DateValue | undefined) => any;
+    "update:startValue": (date: DateValue | undefined) => any;
 }, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
     "onUpdate:modelValue"?: ((date: import("reka-ui").DateRange) => any) | undefined;
-    "onUpdate:placeholder"?: ((date: import("reka-ui").DateValue) => any) | undefined;
+    "onUpdate:placeholder"?: ((date: DateValue) => any) | undefined;
     "onUpdate:validModelValue"?: ((date: import("reka-ui").DateRange) => any) | undefined;
-    "onUpdate:startValue"?: ((date: import("reka-ui").DateValue | undefined) => any) | undefined;
+    "onUpdate:startValue"?: ((date: DateValue | undefined) => any) | undefined;
 }>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const _default: typeof __VLS_export;
 export default _default;

package/dist/runtime/components/ui/range-calendar/RangeCalendarNextButton.vue

@@ -19,7 +19,6 @@ const forwardedProps = useForwardProps(delegatedProps);
     data-slot="range-calendar-next-button"
     :class="cn(
   buttonVariants({ variant: 'ghost' }),
-  'absolute right-1',
   'size-7 bg-transparent p-0 opacity-50 hover:opacity-100',
   props.class
 )"

package/dist/runtime/components/ui/range-calendar/RangeCalendarPrevButton.vue

@@ -19,7 +19,6 @@ const forwardedProps = useForwardProps(delegatedProps);
     data-slot="range-calendar-prev-button"
     :class="cn(
   buttonVariants({ variant: 'ghost' }),
-  'absolute left-1',
   'size-7 bg-transparent p-0 opacity-50 hover:opacity-100',
   props.class
 )"

package/dist/runtime/share/event-bus.d.ts

@@ -25,6 +25,22 @@ export type ChainStep = Readonly<{
      * address a later expression could reference it by.
      */
     publish: (output: unknown) => void;
+    /**
+     * This step's idempotency key for THIS run — lazily minted, then memoized.
+     *
+     * The coordinate is (run × step), not run alone: a chain may hold several
+     * request steps hitting different endpoints, and a server that dedupes on
+     * the key would answer request 2 with request 1's cached response — silently,
+     * with a 200 and a plausible body. Each `ChainStep` is already built per
+     * (run, trigger) inside `dispatchTriggers`, so per-instance minting IS that
+     * coordinate. Note this needs no `trigger.id`, so unlike `publish` it works
+     * on legacy rows too.
+     *
+     * Memoized so a step that reads the key twice — once into a CEL expression,
+     * once onto the request header — sends one value, not two. Lazy so a step
+     * that never asks costs nothing.
+     */
+    idempotencyKey: () => string;
 }>;
 /** A descendant button asking an ancestor instance to run an operation. */
 export type OpRequest = Readonly<{

package/dist/runtime/share/event-bus.js

@@ -1,13 +1,14 @@
 import { computed, inject, provide, shallowRef } from "vue";
 import { Effect, Schema } from "effect";
+import { mintIdempotencyKey } from "./idempotency-key.js";
 export const Trigger = Schema.Struct({
   // Additive + optional like `compatibilityDate`/`params` below, so every
   // pre-existing `{ target, operation }` trigger keeps loading. Minted by the
   // trigger editor on add; it is the address under which this step's output is
-  // published for later steps (`steps[?"<id>"]`), so it must survive reorders —
+  // published for later steps (`steps["<id>"]`), so it must survive reorders —
   // which the list index, the only other row identity, does not.
   id: Schema.optional(Schema.UUID.annotations({
-    description: '\u89E6\u53D1\u884C\u7684\u7A33\u5B9A\u6807\u8BC6\uFF0C\u540E\u7EED\u6B65\u9AA4\u7ECF steps[?"<id>"] \u5F15\u7528\u672C\u6B65\u8F93\u51FA'
+    description: '\u89E6\u53D1\u884C\u7684\u7A33\u5B9A\u6807\u8BC6\uFF0C\u540E\u7EED\u6B65\u9AA4\u7ECF steps["<id>"] \u5F15\u7528\u672C\u6B65\u8F93\u51FA'
   })),
   target: Schema.UUID.annotations({
     description: "\u76EE\u6807\u7956\u5148\u5B9E\u4F8B\u7684 ID"
@@ -59,18 +60,22 @@ export function dispatchTriggers(channel, triggers, cel, outputs) {
     const chainOutputs = outputs ?? {};
     return Effect.forEach(
       triggers,
-      (trigger) => channel.dispatch({
-        target: trigger.target,
-        operation: trigger.operation,
-        params: trigger.params,
-        cel,
-        step: {
-          outputs: () => chainOutputs,
-          publish: (output) => {
-            if (trigger.id) chainOutputs[trigger.id] = output;
+      (trigger) => {
+        let key;
+        return channel.dispatch({
+          target: trigger.target,
+          operation: trigger.operation,
+          params: trigger.params,
+          cel,
+          step: {
+            outputs: () => chainOutputs,
+            publish: (output) => {
+              if (trigger.id) chainOutputs[trigger.id] = output;
+            },
+            idempotencyKey: () => key ??= mintIdempotencyKey()
           }
-        }
-      }),
+        });
+      },
       { discard: true }
     );
   });

package/dist/runtime/share/idempotency-key.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Mint a fresh idempotency key — one opaque UUID identifying a single logical
+ * request intent, carried to the server as `Idempotency-Key`.
+ *
+ * `crypto.randomUUID()` is a **secure-context-only** API: on a plain-HTTP LAN
+ * deployment it is `undefined`. `crypto.getRandomValues` carries no such
+ * restriction, so it backs the fallback — 16 random bytes rendered in the
+ * canonical 8-4-4-4-12 layout with the v4 version/variant bits set, because a
+ * server that accepts an `Idempotency-Key` commonly validates the shape.
+ *
+ * `Math.random()` is deliberately NOT a fallback: two tabs seeded alike would
+ * mint the same key, and a repeated key silently merges two distinct intents —
+ * the exact failure this whole mechanism exists to prevent. If neither crypto
+ * API is present we would rather throw than hand out a weak key.
+ */
+export declare function mintIdempotencyKey(): string;
+/** The header under which a request carries its idempotency key. */
+export declare const IDEMPOTENCY_KEY_HEADER = "Idempotency-Key";

package/dist/runtime/share/idempotency-key.js

@@ -0,0 +1,9 @@
+export function mintIdempotencyKey() {
+  if (typeof crypto.randomUUID === "function") return crypto.randomUUID();
+  const bytes = crypto.getRandomValues(new Uint8Array(16));
+  bytes[6] = bytes[6] & 15 | 64;
+  bytes[8] = bytes[8] & 63 | 128;
+  const hex = Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
+  return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+}
+export const IDEMPOTENCY_KEY_HEADER = "Idempotency-Key";

package/dist/runtime/share/slot-renderer.vue

@@ -14,6 +14,16 @@ const props = defineProps({
 const emit = defineEmits(["update:slotValue"]);
 const inherited = injectCELContext();
 const $cel = (expression, context) => _rawCel(expression, { ...celBindings(inherited), ...context });
+function isHidden(block) {
+  const expr = block.hidden;
+  if (typeof expr !== "string" || expr.length === 0) return false;
+  try {
+    return Effect.runSync($cel(expr));
+  } catch (err) {
+    console.error(`[shwfed-slot-renderer] failed to evaluate hidden for ${block.id}:`, err);
+    return false;
+  }
+}
 function pickLayout(sets) {
   if (sets.length === 0) return void 0;
   for (const set of sets) {
@@ -40,6 +50,7 @@ const placedBlocks = computed(() => {
     const block = b;
     const placement = layout.placements[block.id];
     if (!placement) continue;
+    if (isHidden(block)) continue;
     const entry = props.findEntry(block.type, block.compatibilityDate);
     if (!entry) {
       const key = `${block.type}@${block.compatibilityDate}`;
@@ -53,37 +64,83 @@ const placedBlocks = computed(() => {
   }
   return out;
 });
+const authoredAreas = computed(() => {
+  const layout = activeLayout.value?.layout;
+  if (!layout) return [];
+  const out = [];
+  for (const b of props.slotValue.blocks) {
+    const block = b;
+    const placement = layout.placements[block.id];
+    if (!placement) continue;
+    if (!props.findEntry(block.type, block.compatibilityDate)) continue;
+    out.push(placement.area);
+  }
+  return out;
+});
+function buildRemap(count, keep) {
+  const line = Array.from({ length: count + 2 });
+  const keptFlags = [];
+  let acc = 1;
+  for (let L = 1; L <= count + 1; L++) {
+    line[L] = acc;
+    if (L <= count) {
+      const k = keep(L);
+      keptFlags.push(k);
+      if (k) acc++;
+    }
+  }
+  return { line, keptFlags, kept: acc - 1 };
+}
+const compaction = computed(() => {
+  const l = activeLayout.value?.layout;
+  if (!l) return null;
+  const authored = authoredAreas.value;
+  const visible = placedBlocks.value.map((p) => p.placement.area);
+  const coversCol = (a, c) => a[0][0] <= c && c < a[1][0];
+  const coversRow = (a, r) => a[0][1] <= r && r < a[1][1];
+  const rowCount = l.rows ?? authored.reduce((m, a) => Math.max(m, a[1][1] - 1), 0);
+  const grows = Array.from({ length: rowCount }, () => false);
+  for (const p of placedBlocks.value) {
+    if (!p.entry.metadata?.h?.grow) continue;
+    const [[, y1], [, y2]] = p.placement.area;
+    const lo = Math.max(1, y1);
+    const hi = Math.min(rowCount, y2 - 1);
+    for (let r = lo; r <= hi; r++) grows[r - 1] = true;
+  }
+  const col = buildRemap(l.columns, (c) => visible.some((a) => coversCol(a, c)) || !authored.some((a) => coversCol(a, c)));
+  const row = buildRemap(rowCount, (r) => visible.some((a) => coversRow(a, r)) || !authored.some((a) => coversRow(a, r)));
+  const rowTemplate = l.rows ? row.keptFlags.map((keep, i) => keep ? grows[i] ? "auto" : "minmax(auto, 1fr)" : null).filter(Boolean).join(" ") : "";
+  return {
+    colLine: col.line,
+    rowLine: row.line,
+    keptColumns: Math.max(1, col.kept),
+    rowTemplate
+  };
+});
 const gridStyle = computed(() => {
   const l = activeLayout.value?.layout;
-  if (!l) return "";
-  const tracks = (n, min) => `repeat(${n}, minmax(${min}, 1fr))`;
+  const comp = compaction.value;
+  if (!l || !comp) return "";
+  const colTemplate = `repeat(${comp.keptColumns}, minmax(0, 1fr))`;
   const gap = `calc(${l.gap ?? DEFAULT_GAP} * 0.25rem)`;
-  const colGap = l.columns > 1 ? `min(${gap}, calc(100% / ${l.columns - 1}))` : gap;
-  let rowTemplate = "";
-  if (l.rows) {
-    const grows = Array.from({ length: l.rows }, () => false);
-    for (const p of placedBlocks.value) {
-      if (!p.entry.metadata?.h?.grow) continue;
-      const [[, y1], [, y2]] = p.placement.area;
-      const lo = Math.max(1, y1);
-      const hi = Math.min(l.rows, y2 - 1);
-      for (let r = lo; r <= hi; r++) grows[r - 1] = true;
-    }
-    rowTemplate = grows.map((g) => g ? "auto" : "minmax(auto, 1fr)").join(" ");
-  }
+  const colGap = comp.keptColumns > 1 ? `min(${gap}, calc(100% / ${comp.keptColumns - 1}))` : gap;
   const parts = [
     "display: grid",
-    `grid-template-columns: ${tracks(l.columns, "0")}`,
-    rowTemplate ? `grid-template-rows: ${rowTemplate}` : "",
+    `grid-template-columns: ${colTemplate}`,
+    comp.rowTemplate ? `grid-template-rows: ${comp.rowTemplate}` : "",
     `column-gap: ${colGap}`,
     `row-gap: ${gap}`,
     l.style ?? ""
   ].filter(Boolean);
   return parts.join("; ");
 });
-function cellStyle(placement) {
+function cellStyle(placement, comp) {
   const [[x1, y1], [x2, y2]] = placement.area;
-  const parts = [`grid-column: ${x1} / ${x2}`, `grid-row: ${y1} / ${y2}`, "min-width: 0"];
+  const parts = [
+    `grid-column: ${comp.colLine[x1]} / ${comp.colLine[x2]}`,
+    `grid-row: ${comp.rowLine[y1]} / ${comp.rowLine[y2]}`,
+    "min-width: 0"
+  ];
   const h = placement.h && placement.h !== "stretch" ? placement.h : null;
   const v = placement.v && placement.v !== "stretch" ? placement.v : null;
   if (h || v) {
@@ -94,14 +151,16 @@ function cellStyle(placement) {
   }
   return parts.join("; ");
 }
-const rendered = computed(
-  () => placedBlocks.value.map((p) => ({
+const rendered = computed(() => {
+  const comp = compaction.value;
+  if (!comp) return [];
+  return placedBlocks.value.map((p) => ({
     key: p.block.id,
-    style: cellStyle(p.placement),
+    style: cellStyle(p.placement, comp),
     component: p.entry.runtime,
     block: p.block
-  }))
-);
+  }));
+});
 function updateBlock(id, next) {
   const blocks = props.slotValue.blocks.map((b) => b.id === id ? next : b);
   emit("update:slotValue", { ...props.slotValue, blocks });

package/dist/runtime/utils/cel-context.d.ts

@@ -25,6 +25,7 @@ export declare const SCOPE_ADDRESS_VAR = "__scopes__";
 export declare const SELECTIONS_VAR = "selections";
 export declare const OPTIONS_VAR = "options";
 export declare const STEPS_VAR = "steps";
+export declare const IDEMPOTENCY_KEY_VAR = "idempotencyKey";
 export type ScopeAccessor = Record<string, () => unknown>;
 export declare function provideCELContext(context: CELContext): void;
 export declare function injectCELContext(): CELContext;
@@ -123,10 +124,10 @@ export declare function useSelectionRoster(): Ref<ReadonlyArray<SelectionFieldRe
  * surfaces it. Unlike a selection field a trigger row has no designer-given
  * name, so `label` is its position —「第 N 步」— computed live from the row's
  * current index and thus following drag-and-drop reorders for free (the
- * persisted reference is `steps[?"<id>"]`; the label is never stored).
+ * persisted reference is `steps["<id>"]`; the label is never stored).
  */
 export type StepRef = Readonly<{
-    /** Trigger-row uuid keyed into `steps[?"<id>"]` — the publish address. */
+    /** Trigger-row uuid keyed into `steps["<id>"]` — the publish address. */
     id: string;
     /** Position label,「第 N 步」, derived from the row's current index. */
     label: string;

package/dist/runtime/utils/cel-context.js

@@ -12,6 +12,7 @@ export const SCOPE_ADDRESS_VAR = "__scopes__";
 export const SELECTIONS_VAR = "selections";
 export const OPTIONS_VAR = "options";
 export const STEPS_VAR = "steps";
+export const IDEMPOTENCY_KEY_VAR = "idempotencyKey";
 const CEL_CONTEXT_KEY = Symbol("cel-context");
 export function provideCELContext(context) {
   const parent = injectLocal(CEL_CONTEXT_KEY, {});