@shwfed/config 3.0.4 → 3.0.7

package/dist/runtime/components/config/blocks/2026-05-06/com.shwfed.block.table/schema.d.ts

@@ -47,40 +47,6 @@ export declare function schema(configure: (env: Environment) => void, _blockRef:
                 readonly message: string;
             }[]] | undefined;
         }[];
-        readonly query?: {
-            readonly style?: string | undefined;
-            readonly id?: string | undefined;
-            readonly initial?: {
-                readonly data: string;
-                readonly request?: string | undefined;
-            } | undefined;
-            readonly displayName?: string | undefined;
-            readonly kind: "shwfed.component.form";
-            readonly fields: readonly any[];
-            readonly layouts: readonly {
-                readonly name: string;
-                readonly layout: {
-                    readonly style?: string | undefined;
-                    readonly columns: number;
-                    readonly gap?: number | undefined;
-                    readonly rows?: number | undefined;
-                    readonly placements: {
-                        readonly [x: string]: {
-                            readonly area: readonly [readonly [number, number], readonly [number, number]];
-                            readonly v?: "stretch" | "center" | "end" | "start" | undefined;
-                            readonly h?: "stretch" | "center" | "end" | "start" | undefined;
-                        };
-                    };
-                };
-                readonly media?: string | undefined;
-            }[];
-            readonly readonly?: string | undefined;
-        } | undefined;
-        readonly dataSource?: {
-            readonly data: string;
-            readonly total?: string | undefined;
-            readonly request?: string | undefined;
-        } | undefined;
         readonly actions?: {
             readonly size: "default" | "sm" | "xs";
             readonly style?: string | undefined;
@@ -148,6 +114,40 @@ export declare function schema(configure: (env: Environment) => void, _blockRef:
                 readonly variant?: "default" | "link" | "destructive" | "primary" | "ghost" | undefined;
             }[];
         } | undefined;
+        readonly query?: {
+            readonly style?: string | undefined;
+            readonly id?: string | undefined;
+            readonly initial?: {
+                readonly data: string;
+                readonly request?: string | undefined;
+            } | undefined;
+            readonly displayName?: string | undefined;
+            readonly kind: "shwfed.component.form";
+            readonly fields: readonly any[];
+            readonly layouts: readonly {
+                readonly name: string;
+                readonly layout: {
+                    readonly style?: string | undefined;
+                    readonly columns: number;
+                    readonly gap?: number | undefined;
+                    readonly rows?: number | undefined;
+                    readonly placements: {
+                        readonly [x: string]: {
+                            readonly area: readonly [readonly [number, number], readonly [number, number]];
+                            readonly v?: "stretch" | "center" | "end" | "start" | undefined;
+                            readonly h?: "stretch" | "center" | "end" | "start" | undefined;
+                        };
+                    };
+                };
+                readonly media?: string | undefined;
+            }[];
+            readonly readonly?: string | undefined;
+        } | undefined;
+        readonly dataSource?: {
+            readonly data: string;
+            readonly total?: string | undefined;
+            readonly request?: string | undefined;
+        } | undefined;
         readonly bottomActions?: {
             readonly size: "default" | "sm" | "xs";
             readonly style?: string | undefined;
@@ -241,6 +241,9 @@ export declare function schema(configure: (env: Environment) => void, _blockRef:
             readonly expanded?: boolean | {
                 readonly [x: string]: boolean;
             } | undefined;
+            readonly rowSelection?: {
+                readonly [x: string]: boolean;
+            } | undefined;
             readonly columnVisibility?: {
                 readonly [x: string]: boolean;
             } | undefined;
@@ -261,9 +264,6 @@ export declare function schema(configure: (env: Environment) => void, _blockRef:
             readonly columnSizing?: {
                 readonly [x: string]: number;
             } | undefined;
-            readonly rowSelection?: {
-                readonly [x: string]: boolean;
-            } | undefined;
         } | undefined;
     }, Schema.Struct<{
         kind: Schema.tag<"shwfed.component.table">;

package/dist/runtime/components/config/history-picker.vue

@@ -14,7 +14,6 @@ import {
 } from "../ui/command";
 import {
   AlertDialog,
-  AlertDialogAction,
   AlertDialogCancel,
   AlertDialogContent,
   AlertDialogDescription,
@@ -140,14 +139,17 @@ function onCancel() {
           {{ t("history-confirm-body") }}
         </p>
         <AlertDialogFooter>
-          <AlertDialogCancel @click="onCancel">
+          <AlertDialogCancel>
             <Icon icon="fluent:dismiss-20-regular" />
             {{ t("history-cancel") }}
           </AlertDialogCancel>
-          <AlertDialogAction @click="onConfirm">
+          <Button
+            variant="primary"
+            @click="onConfirm"
+          >
             <Icon icon="fluent:checkmark-20-regular" />
             {{ t("history-confirm") }}
-          </AlertDialogAction>
+          </Button>
         </AlertDialogFooter>
       </AlertDialogContent>
     </AlertDialog>

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

@@ -13,6 +13,7 @@ import ShwfedModal from "../modal.vue";
 import EditorBody from "./config.vue";
 import EditorBreadcrumb from "./breadcrumb.vue";
 import EditorFooter from "./footer.vue";
+import PruneDialog from "./prune-dialog.vue";
 import { provideEventTarget } from "../../share/event-bus";
 import { operationHandlers } from "../operations/utils/resolve";
 import * as alertOperation from "../operations/2026-06-09/com.shwfed.operation.alert/schema";
@@ -95,12 +96,31 @@ provideEventTarget(PAGE_TARGET_ID, {
   )
 });
 const editorOpen = ref(false);
+const pendingPrune = ref(null);
+let settlePrune = null;
+function confirmPrune(items) {
+  resolvePrune(false);
+  pendingPrune.value = items;
+  return new Promise((resolve) => {
+    settlePrune = resolve;
+  });
+}
+function resolvePrune(proceed) {
+  pendingPrune.value = null;
+  const settle = settlePrune;
+  settlePrune = null;
+  settle?.(proceed);
+}
+onBeforeUnmount(() => {
+  if (settlePrune) resolvePrune(false);
+});
 const editorState = useConfigEditor(config, {
   configure: mergedConfigure,
   // Presence is decided once at setup (a host toggling the prop's existence
   // at runtime is not supported); the wrapper reads the current prop per
   // call so a rebound handler identity stays honored.
   save: props.save ? (cfg) => props.save(cfg) : void 0,
+  confirmPrune,
   onClose: () => {
     editorOpen.value = false;
   }
@@ -243,6 +263,11 @@ const isMac = computed(
           />
         </div>
       </div>
+      <PruneDialog
+        :items="pendingPrune"
+        @confirm="resolvePrune(true)"
+        @cancel="resolvePrune(false)"
+      />
       <template #footer>
         <EditorFooter
           :state="editorState"

package/dist/runtime/components/config/prune-dialog.d.vue.ts

@@ -0,0 +1,14 @@
+import { type PruneSummary } from './utils/prune.js';
+type __VLS_Props = {
+    /** Non-null while the gate is open; one entry per item about to be dropped. */
+    items: ReadonlyArray<PruneSummary> | null;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    cancel: () => any;
+    confirm: () => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onCancel?: (() => any) | undefined;
+    onConfirm?: (() => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/runtime/components/config/prune-dialog.vue

@@ -0,0 +1,83 @@
+<script setup>
+import { computed } from "vue";
+import { Icon } from "@iconify/vue";
+import {
+  AlertDialog,
+  AlertDialogCancel,
+  AlertDialogContent,
+  AlertDialogDescription,
+  AlertDialogFooter,
+  AlertDialogHeader,
+  AlertDialogTitle
+} from "../ui/alert-dialog";
+import { Button } from "../ui/button";
+import { pruneKindNoun } from "./utils/prune";
+defineOptions({ name: "ShwfedConfigPruneDialog" });
+const props = defineProps({
+  items: { type: [Array, null], required: true }
+});
+const emit = defineEmits(["confirm", "cancel"]);
+const open = computed(() => props.items !== null);
+function onOpenChange(next) {
+  if (!next) emit("cancel");
+}
+</script>
+
+<template>
+  <AlertDialog
+    :open="open"
+    @update:open="onOpenChange"
+  >
+    <AlertDialogContent class="sm:px-12 sm:py-8 flex flex-col gap-8">
+      <AlertDialogHeader class="sr-only">
+        <AlertDialogTitle>清理未使用的内容</AlertDialogTitle>
+        <AlertDialogDescription>Confirmation dialog</AlertDialogDescription>
+      </AlertDialogHeader>
+      <Icon
+        icon="fluent:broom-20-filled"
+        class="text-6xl mx-auto text-yellow-500"
+      />
+      <div class="flex flex-col gap-3">
+        <p class="text-sm text-zinc-900">
+          以下内容未放入任何布局，不会在页面上显示。保存时将一并删除：
+        </p>
+        <ul class="max-h-60 overflow-y-auto flex flex-col gap-1 rounded border border-zinc-200 bg-zinc-50 p-3">
+          <li
+            v-for="(item, i) in props.items ?? []"
+            :key="i"
+            class="flex items-baseline gap-2 text-sm text-zinc-700"
+          >
+            <span class="shrink-0 rounded bg-zinc-200 px-1.5 py-0.5 text-xs text-zinc-600">
+              {{ pruneKindNoun(item.kind) }}
+            </span>
+            <span class="break-all">{{ item.label }}</span>
+          </li>
+        </ul>
+        <p class="text-xs text-zinc-500">
+          若仍需保留，请点击取消，并将其放入布局。
+        </p>
+      </div>
+      <AlertDialogFooter>
+        <!-- Closes itself, which `onOpenChange` reads as the 取消. -->
+        <AlertDialogCancel>
+          <Icon icon="fluent:dismiss-20-regular" />
+          取消
+        </AlertDialogCancel>
+        <!-- A plain Button, NOT an AlertDialogAction: reka's action IS a
+             DialogClose, and its built-in close handler — bound in reka's own
+             template — runs BEFORE a `@click` we hang on it, which arrives as a
+             fallthrough attr and merges after. The close would reach
+             `onOpenChange` first and cancel the very save this button
+             authorizes. The dialog shuts anyway: the host drops `items` the
+             moment it takes the verdict. -->
+        <Button
+          variant="primary"
+          @click="emit('confirm')"
+        >
+          <Icon icon="fluent:checkmark-20-regular" />
+          删除并保存
+        </Button>
+      </AlertDialogFooter>
+    </AlertDialogContent>
+  </AlertDialog>
+</template>

package/dist/runtime/components/config/prune-dialog.vue.d.ts

@@ -0,0 +1,14 @@
+import { type PruneSummary } from './utils/prune.js';
+type __VLS_Props = {
+    /** Non-null while the gate is open; one entry per item about to be dropped. */
+    items: ReadonlyArray<PruneSummary> | null;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    cancel: () => any;
+    confirm: () => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onCancel?: (() => any) | undefined;
+    onConfirm?: (() => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

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

@@ -33,7 +33,7 @@ export const metadata = {
       icon: httpRequestOperation.metadata.icon
     },
     // Navigation as an op (replaces the standalone navigation *button*): its URL
-    // expression can reference `steps["<id>"]`, so a chain can navigate using an
+    // expression can reference `steps[?"<id>"]`, so a chain can navigate using an
     // earlier request's response. The page hosts it for the same reason as the
     // request op — navigation acts on nothing instance-specific.
     {
@@ -43,7 +43,7 @@ export const metadata = {
       icon: navigationOperation.metadata.icon
     },
     // Download as an op (replaces the standalone download *button*): its request
-    // expression can reference `steps["<id>"]`, so the old two-step「先取凭据再下载」
+    // expression can reference `steps[?"<id>"]`, so the old two-step「先取凭据再下载」
     // becomes a 发送请求 row followed by this download row. The page hosts it for
     // the same reason as the request op — the download acts on nothing
     // instance-specific.

package/dist/runtime/components/config/use-editor.d.ts

@@ -4,6 +4,7 @@ import { type LayoutSetValue, type PlacementValue, type SlotValue } from '../../
 import type { BreadcrumbCrumb, BreadcrumbParentSuffix } from './breadcrumb-extension.js';
 import { type BlockValue, type PageConfigValue } from './schema.js';
 import { type BlockEntry } from './utils/resolve.js';
+import { type PruneSummary } from './utils/prune.js';
 export type PickerEntry = {
     type: string;
     compatibilityDate: string;
@@ -133,6 +134,14 @@ export interface UseConfigEditorOptions {
      * the editor guarantees the session is never lost to a failed save.
      */
     save?: (config: PageConfigValue) => void | Promise<void>;
+    /**
+     * Consent gate for the save-time prune of unplaced items (utils/prune.ts).
+     * Called only when 确认 would actually drop something, with a breadcrumb per
+     * removal; resolving `false` aborts the save with the draft untouched. Hosts
+     * wire this to a confirmation dialog — `ShwfedConfig` does. Left unwired, the
+     * prune is silent.
+     */
+    confirmPrune?: (items: ReadonlyArray<PruneSummary>) => boolean | Promise<boolean>;
     /**
      * Called after a successful 确认 commits the draft to the outer model.
      * Hosts wire this to close the modal; legacy mode emits `close`.

package/dist/runtime/components/config/use-editor.js

@@ -7,6 +7,12 @@ import { PageConfig } from "./schema.js";
 import { BLOCKS, findBlock } from "./utils/resolve.js";
 import { formatValidationError } from "./utils/validation-error.js";
 import { findDanglingLinkages, formatDanglingLinkages } from "./utils/linkage.js";
+import {
+  findPruneConflicts,
+  formatPruneConflicts,
+  pruneUnplaced,
+  summarizePrune
+} from "./utils/prune.js";
 import { createExpressionValidityRegistry, provideExpressionValidity } from "../ui/expression-editor/index.js";
 function deepClone(value) {
   return JSON.parse(JSON.stringify(value));
@@ -199,7 +205,7 @@ export function useSlotClipboard(target) {
         if (p) placements[id] = p;
       }
     }
-    if (!await writeClip("block", items, placements)) {
+    if (!await writeClip("block", { items, placements })) {
       toast.error("\u590D\u5236\u5931\u8D25");
       return;
     }
@@ -208,7 +214,7 @@ export function useSlotClipboard(target) {
   async function paste(anchor) {
     const payload = await readClip();
     if (!payload || payload.surface !== "block") return;
-    const { items, placements } = reidFragment(payload.items, payload.placements);
+    const { items, placements } = reidFragment(payload);
     const pasted = items;
     if (pasted.length === 0) return;
     if (placements && Object.keys(placements).length > 0) {
@@ -396,20 +402,42 @@ export function useConfigEditor(model, options = {}) {
       validationError.value = "\u5B58\u5728\u65E0\u6548\u7684\u8DE8\u5C42\u4F5C\u7528\u57DF\u5F15\u7528\uFF0C\u8BF7\u4FEE\u6B63\u6807\u7EA2\u7684\u8868\u8FBE\u5F0F\u540E\u518D\u4FDD\u5B58";
       return false;
     }
-    const dangling = findDanglingLinkages(decoded);
-    if (dangling.length > 0) {
-      validationError.value = formatDanglingLinkages(dangling, decoded, (i) => {
-        const b = topSlotEditor.blocks.value[i];
-        return b ? topSlotEditor.getBlockLabel(b) : void 0;
+    const { config: pruned, removed } = pruneUnplaced(decoded);
+    const draftBlockLabelAt = (i) => {
+      const b = topSlotEditor.blocks.value[i];
+      return b ? topSlotEditor.getBlockLabel(b) : void 0;
+    };
+    const prunedBlockLabelAt = (i) => {
+      const b = pruned.slot.blocks[i];
+      return b ? topSlotEditor.getBlockLabel(b) : void 0;
+    };
+    const conflicts = findPruneConflicts(pruned, removed);
+    if (conflicts.length > 0) {
+      validationError.value = formatPruneConflicts(conflicts, {
+        prunedRoot: pruned,
+        originalRoot: decoded,
+        prunedBlockLabelAt,
+        originalBlockLabelAt: draftBlockLabelAt
       });
       return false;
     }
+    const dangling = findDanglingLinkages(pruned);
+    if (dangling.length > 0) {
+      validationError.value = formatDanglingLinkages(dangling, pruned, prunedBlockLabelAt);
+      return false;
+    }
     validationError.value = null;
+    if (removed.length > 0 && options.confirmPrune) {
+      const proceed = await options.confirmPrune(
+        summarizePrune(removed, decoded, draftBlockLabelAt)
+      );
+      if (!proceed) return false;
+    }
     if (options.save) {
       saving.value = true;
       saveError.value = null;
       try {
-        await options.save(deepClone(decoded));
+        await options.save(deepClone(pruned));
       } catch (err) {
         saveError.value = `\u4FDD\u5B58\u5931\u8D25\uFF1A${err instanceof Error ? err.message : String(err)}`;
         return false;
@@ -417,9 +445,9 @@ export function useConfigEditor(model, options = {}) {
         saving.value = false;
       }
     }
-    model.value = decoded;
-    baseline.value = deepClone(decoded);
-    draft.value = deepClone(decoded);
+    model.value = pruned;
+    baseline.value = deepClone(pruned);
+    draft.value = deepClone(pruned);
     stack.value = [{ kind: "layout" }];
     topSlotEditor.selectedBlockIds.value = [];
     topSlotEditor.activeLayoutIndex.value = 0;

package/dist/runtime/components/config/utils/linkage.d.ts

@@ -11,6 +11,13 @@ export type DanglingLinkage = Readonly<{
      */
     path: ReadonlyArray<PropertyKey>;
 }>;
+/**
+ * Every uuid `id` defined under `node`. Exported so the save-time prune
+ * (utils/prune.ts) asks what a to-be-removed subtree *defines* with the very
+ * same rule this gate uses to decide what is *defined* — the two must agree, or
+ * a prune would strand a linkage this walker then fails to flag.
+ */
+export declare function definedIds(node: unknown): Set<string>;
 /**
  * Find every linkage in `config` whose target uuid is not defined anywhere in
  * the tree. `PAGE_TARGET_ID` (the singleton page target sentinel) is always
@@ -19,6 +26,7 @@ export type DanglingLinkage = Readonly<{
  * the caller can render a field-level breadcrumb (see `describePath`).
  */
 export declare function findDanglingLinkages(config: unknown): DanglingLinkage[];
+export declare const LINKAGE_KIND_LABEL: Record<LinkageKind, string>;
 /**
  * One-line save-footer message for a non-empty dangling list. Renders the
  * breadcrumb to the first offending reference (`「表单 › 确定 › value」`) via the

package/dist/runtime/components/config/utils/linkage.js

@@ -17,6 +17,11 @@ function collectDefinedIds(node, into) {
     collectDefinedIds(v, into);
   }
 }
+export function definedIds(node) {
+  const out = /* @__PURE__ */ new Set();
+  collectDefinedIds(node, out);
+  return out;
+}
 function collectRefs(node, path, into) {
   if (Array.isArray(node)) {
     node.forEach((v, i) => collectRefs(v, [...path, i], into));
@@ -41,7 +46,7 @@ export function findDanglingLinkages(config) {
   collectRefs(config, [], refs);
   return refs.filter((r) => r.id !== PAGE_TARGET_ID && !defined.has(r.id));
 }
-const KIND_LABEL = {
+export const LINKAGE_KIND_LABEL = {
   operation: "\u89E6\u53D1\u64CD\u4F5C",
   step: "\u6B65\u9AA4\u5F15\u7528",
   scope: "\u8DE8\u5C42\u4F5C\u7528\u57DF\u5F15\u7528"
@@ -49,7 +54,7 @@ const KIND_LABEL = {
 export function formatDanglingLinkages(dangling, rootData, blockLabelAt) {
   const first = dangling[0];
   if (!first) return "";
-  const kind = KIND_LABEL[first.kind];
+  const kind = LINKAGE_KIND_LABEL[first.kind];
   const segs = describePath(first.path, rootData, blockLabelAt);
   const where = segs.length > 0 ? `\u300C${segs.join(" \u203A ")}\u300D\u7684${kind}` : kind;
   const suffix = dangling.length > 1 ? `\uFF08\u8FD8\u6709 ${dangling.length - 1} \u4E2A\uFF09` : "";

package/dist/runtime/components/config/utils/prune.d.ts

@@ -0,0 +1,68 @@
+import { type DanglingLinkage } from './linkage.js';
+/** Which pool an item came out of — drives the noun in user-facing copy. */
+export type PruneKind = 'block' | 'field';
+export declare function pruneKindNoun(kind: PruneKind): string;
+export type UnplacedItem = Readonly<{
+    kind: PruneKind;
+    id: string;
+    /**
+     * Property path from the ORIGINAL config root to the removed item
+     * (`['slot','blocks',2]`). Fed to `describePath` against that same root.
+     */
+    path: ReadonlyArray<PropertyKey>;
+    /**
+     * Every uuid defined anywhere in this item's subtree — the item's own id plus
+     * its trigger rows, nested blocks, nested fields, … Dropping the item
+     * un-defines all of them at once, so this is the set a surviving reference
+     * must not point into.
+     */
+    ids: ReadonlySet<string>;
+}>;
+/** A pruned item's label, pre-rendered for the confirmation dialog. */
+export type PruneSummary = Readonly<{
+    kind: PruneKind;
+    /** Breadcrumb to the item in the pre-prune config (`标签页 › 表格`). */
+    label: string;
+}>;
+export type PruneConflict = Readonly<{
+    /** The surviving reference left pointing at nothing. */
+    ref: DanglingLinkage;
+    /** The item whose removal stranded it. */
+    owner: UnplacedItem;
+}>;
+/**
+ * Drop every item that no layout in its own pool places, at every depth.
+ * Returns the rewritten config plus the removals, outermost-first.
+ */
+export declare function pruneUnplaced<T>(config: T): {
+    config: T;
+    removed: UnplacedItem[];
+};
+/**
+ * References held by SURVIVORS that point into a removed subtree. Non-empty
+ * means the prune would strand a linkage, and the save must be refused rather
+ * than quietly persisting a config whose trigger targets nothing.
+ *
+ * Runs the existing dangling-linkage walker over the PRUNED tree and keeps only
+ * the danglers the prune itself caused — a linkage that was already dangling
+ * before the prune is not our problem and stays with `findDanglingLinkages`.
+ */
+export declare function findPruneConflicts(pruned: unknown, removed: ReadonlyArray<UnplacedItem>): PruneConflict[];
+/**
+ * Pre-render each removal as a breadcrumb for the confirmation dialog.
+ * `root` must be the pre-prune config the paths index into.
+ */
+export declare function summarizePrune(removed: ReadonlyArray<UnplacedItem>, root: unknown, blockLabelAt: (index: number) => string | undefined): PruneSummary[];
+/**
+ * Save-footer message for a non-empty conflict list. Names both ends — the item
+ * about to be dropped and the surviving reference that still needs it — because
+ * the raw dangling message ("引用了已失效的资源") would point at the reference
+ * and leave the designer hunting for a block that looks perfectly fine sitting
+ * in the unplaced tray.
+ */
+export declare function formatPruneConflicts(conflicts: ReadonlyArray<PruneConflict>, ctx: {
+    prunedRoot: unknown;
+    originalRoot: unknown;
+    prunedBlockLabelAt: (index: number) => string | undefined;
+    originalBlockLabelAt: (index: number) => string | undefined;
+}): string;

package/dist/runtime/components/config/utils/prune.js

@@ -0,0 +1,92 @@
+import { definedIds, findDanglingLinkages, LINKAGE_KIND_LABEL } from "./linkage.js";
+import { describePath } from "./validation-error.js";
+const KIND_NOUN = {
+  block: "\u5757",
+  field: "\u5B57\u6BB5"
+};
+export function pruneKindNoun(kind) {
+  return KIND_NOUN[kind];
+}
+function isObject(v) {
+  return v !== null && typeof v === "object" && !Array.isArray(v);
+}
+const POOLS = [
+  { key: "blocks", kind: "block" },
+  { key: "fields", kind: "field" }
+];
+function poolOf(node) {
+  if (!Array.isArray(node.layouts)) return void 0;
+  return POOLS.find((p) => Array.isArray(node[p.key]));
+}
+function placedIds(layouts) {
+  const out = /* @__PURE__ */ new Set();
+  for (const set of layouts) {
+    if (!isObject(set) || !isObject(set.layout)) continue;
+    const placements = set.layout.placements;
+    if (isObject(placements)) {
+      for (const id of Object.keys(placements)) out.add(id);
+    }
+  }
+  return out;
+}
+function walk(node, path, removed) {
+  if (Array.isArray(node)) return node.map((v, i) => walk(v, [...path, i], removed));
+  if (!isObject(node)) return node;
+  const pool = poolOf(node);
+  const out = {};
+  for (const [key, value] of Object.entries(node)) {
+    if (pool && key === pool.key) {
+      const placed = placedIds(node.layouts);
+      const kept = [];
+      for (const [i, item] of value.entries()) {
+        const id = isObject(item) && typeof item.id === "string" ? item.id : void 0;
+        if (id !== void 0 && !placed.has(id)) {
+          removed.push({ kind: pool.kind, id, path: [...path, key, i], ids: definedIds(item) });
+          continue;
+        }
+        kept.push(walk(item, [...path, key, i], removed));
+      }
+      out[key] = kept;
+      continue;
+    }
+    out[key] = walk(value, [...path, key], removed);
+  }
+  return out;
+}
+export function pruneUnplaced(config) {
+  const removed = [];
+  const next = walk(config, [], removed);
+  return { config: next, removed };
+}
+export function findPruneConflicts(pruned, removed) {
+  if (removed.length === 0) return [];
+  const owner = /* @__PURE__ */ new Map();
+  for (const item of removed) {
+    for (const id of item.ids) {
+      if (!owner.has(id)) owner.set(id, item);
+    }
+  }
+  const out = [];
+  for (const ref of findDanglingLinkages(pruned)) {
+    const o = owner.get(ref.id);
+    if (o) out.push({ ref, owner: o });
+  }
+  return out;
+}
+export function summarizePrune(removed, root, blockLabelAt) {
+  return removed.map((item) => ({
+    kind: item.kind,
+    label: describePath(item.path, root, blockLabelAt).join(" \u203A ") || pruneKindNoun(item.kind)
+  }));
+}
+export function formatPruneConflicts(conflicts, ctx) {
+  const first = conflicts[0];
+  if (!first) return "";
+  const ownerSegs = describePath(first.owner.path, ctx.originalRoot, ctx.originalBlockLabelAt);
+  const owner = ownerSegs.length > 0 ? ownerSegs.join(" \u203A ") : pruneKindNoun(first.owner.kind);
+  const refSegs = describePath(first.ref.path, ctx.prunedRoot, ctx.prunedBlockLabelAt);
+  const kind = LINKAGE_KIND_LABEL[first.ref.kind];
+  const where = refSegs.length > 0 ? `\u300C${refSegs.join(" \u203A ")}\u300D\u7684${kind}` : kind;
+  const suffix = conflicts.length > 1 ? `\uFF08\u8FD8\u6709 ${conflicts.length - 1} \u4E2A\uFF09` : "";
+  return `${pruneKindNoun(first.owner.kind)}\u300C${owner}\u300D\u672A\u653E\u5165\u4EFB\u4F55\u5E03\u5C40\uFF0C\u4FDD\u5B58\u65F6\u4F1A\u88AB\u6E05\u7406\uFF0C\u4F46${where}\u4ECD\u5728\u5F15\u7528\u5B83\u3002\u8BF7\u5148\u5C06\u5B83\u653E\u5165\u5E03\u5C40\uFF0C\u6216\u79FB\u9664\u8BE5\u5F15\u7528${suffix}`;
+}