fix: preserve PSD super lock mask editing

app/(admin)/settings/agent-workflow/psd-templates/psd-templates-settings-client.tsx

@@ -1780,7 +1780,7 @@ export function PsdTemplatesSettingsClient({
                                             超级锁
                                           </div>
                                           <div className="text-xs text-muted-foreground">
-                                            开启后用户前台无法选中、编辑、拖动或临时删除该图层，鼠标点击会自动穿透到下方图层。
+                                            开启后锁定目标图层的位置、层级和删除操作；图片槽位仍可替换图片，并只能在蒙版内拖动替换图。
                                           </div>
                                         </div>
                                         <Switch
@@ -1792,11 +1792,8 @@ export function PsdTemplatesSettingsClient({
                                                   ...current,
                                                   isSuperLocked: checked,
                                                   isRequired: checked ? false : current.isRequired,
-                                                  isDefaultResultSource: checked
-                                                    ? false
-                                                    : current.isDefaultResultSource,
                                                   allowUserUploadOverride: checked
-                                                    ? false
+                                                    ? true
                                                     : current.allowUserUploadOverride,
                                                 };
                                               }

components/agents/AgentPsdTemplateEditorDialog.tsx

@@ -872,9 +872,7 @@ function getDefaultSourceImageLayer(
 ): AgentPsdTemplateImageLayerSlot | null {
   const editableImageLayers = layers.filter(
     (layer): layer is AgentPsdTemplateImageLayerSlot =>
-      layer.isEditable &&
+      layer.isEditable && isAgentPsdImageLayerSlot(layer)
-      !isAgentPsdLayerSuperLocked(layer) &&
-      isAgentPsdImageLayerSlot(layer)
   );
 
   return (
@@ -912,9 +910,6 @@ function createInitialState(
 
   for (const layer of template.layers) {
     layerOrderIds.push(layer.id);
-    if (isAgentPsdLayerSuperLocked(layer)) {
-      continue;
-    }
     if (
       isAgentPsdImageLayerSlot(layer) &&
       layer.id === defaultSourceImageLayerId &&
@@ -923,6 +918,9 @@ function createInitialState(
       imageAssignments[layer.id] = sourceImageUrl;
       imagePlacements[layer.id] = getDefaultAgentPsdImagePlacement();
     }
+    if (isAgentPsdLayerSuperLocked(layer)) {
+      continue;
+    }
     if (isAgentPsdTextLayerSlot(layer) && layer.defaultText) {
       textAssignments[layer.id] = layer.defaultText;
     }
@@ -1732,6 +1730,13 @@ export function AgentPsdTemplateEditorDialog({
     startClientY: number;
     startOffset: AgentPsdLayerPositionOffset;
   } | null>(null);
+  const imagePlacementDragStateRef = useRef<{
+    layerId: string;
+    pointerId: number;
+    startClientX: number;
+    startClientY: number;
+    startPlacement: AgentPsdImagePlacement;
+  } | null>(null);
   const textDragStateRef = useRef<{
     layerId: string;
     pointerId: number;
@@ -1938,9 +1943,7 @@ export function AgentPsdTemplateEditorDialog({
     () =>
       selectedTemplateLayers.filter(
         (layer): layer is AgentPsdTemplateImageLayerSlot =>
-          layer.isEditable &&
+          layer.isEditable && isAgentPsdImageLayerSlot(layer)
-          !isAgentPsdLayerSuperLocked(layer) &&
-          isAgentPsdImageLayerSlot(layer)
       ),
     [selectedTemplateLayers]
   );
@@ -2035,11 +2038,11 @@ export function AgentPsdTemplateEditorDialog({
   );
   const orderedEditableImageLayers = useMemo(
     () =>
-      orderedEditableLayers.filter(
+      orderedPreviewLayers.filter(
         (layer): layer is AgentPsdTemplateImageLayerSlot =>
-          isAgentPsdImageLayerSlot(layer)
+          layer.isEditable && isAgentPsdImageLayerSlot(layer)
       ),
-    [orderedEditableLayers]
+    [orderedPreviewLayers]
   );
   const orderedEditableTextLayers = useMemo(
     () =>
@@ -2190,17 +2193,24 @@ export function AgentPsdTemplateEditorDialog({
     const layer =
       selectedTemplateLayers.find((entry) => entry.id === selectedLayerId) ||
       null;
-    return layer && !isAgentPsdLayerSuperLocked(layer) ? layer : null;
+    return layer;
   }, [selectedLayerId, selectedTemplateLayers]);
+  const isSelectedLayerSuperLocked = Boolean(
+    selectedLayer && isAgentPsdLayerSuperLocked(selectedLayer)
+  );
   const isSelectedLayerHidden = Boolean(
     selectedLayer && hiddenLayerIdSet.has(selectedLayer.id)
   );
   const selectedImageLayer =
-    selectedLayer && isAgentPsdImageLayerSlot(selectedLayer)
+    selectedLayer &&
+    selectedLayer.isEditable &&
+    isAgentPsdImageLayerSlot(selectedLayer)
       ? selectedLayer
       : null;
   const selectedTextLayer =
-    selectedLayer && isAgentPsdTextLayerSlot(selectedLayer)
+    selectedLayer &&
+    !isSelectedLayerSuperLocked &&
+    isAgentPsdTextLayerSlot(selectedLayer)
       ? selectedLayer
       : null;
   const selectedImageAssignmentUrl = selectedImageLayer
@@ -2252,8 +2262,9 @@ export function AgentPsdTemplateEditorDialog({
       current.filter((currentLayerId) => currentLayerId !== normalizedLayerId)
     );
   }
-  const selectedLayerPositionPanel = selectedLayer ? (
+  const selectedLayerPositionPanel =
-    <div className="space-y-4 rounded-2xl border border-white/10 bg-white/[0.03] p-5 shadow-inner">
+    selectedLayer && !isSelectedLayerSuperLocked ? (
+      <div className="space-y-4 rounded-2xl border border-white/10 bg-white/[0.03] p-5 shadow-inner">
       <div className="flex items-start justify-between gap-4">
         <div>
           <div className="font-semibold text-sm text-white">图层层级</div>
@@ -2477,7 +2488,7 @@ export function AgentPsdTemplateEditorDialog({
                   槽位内图片位置
                 </div>
                 <div className="mt-1.5 text-white/50 text-xs">
-                  图层整体拖动已经改到中间预览区；这里保留槽位内图片的细调。
+                  目标图层保持固定；拖动预览中的替换图可在蒙版内微调位置。
                 </div>
               </div>
               <ImageIcon className="h-5 w-5 shrink-0 text-orange-300" />
@@ -3445,6 +3456,72 @@ export function AgentPsdTemplateEditorDialog({
     window.addEventListener("pointercancel", handlePointerUp);
   }
 
+  function handleAssignedImagePlacementDragStart(
+    layer: AgentPsdTemplateImageLayerSlot,
+    event: ReactPointerEvent<HTMLElement>
+  ) {
+    const assignmentUrl = String(
+      effectiveImageAssignments[layer.id] || ""
+    ).trim();
+    if (!assignmentUrl) {
+      return;
+    }
+
+    event.preventDefault();
+    event.stopPropagation();
+    setSelectedLayerId(layer.id);
+
+    imagePlacementDragStateRef.current = {
+      layerId: layer.id,
+      pointerId: event.pointerId,
+      startClientX: event.clientX,
+      startClientY: event.clientY,
+      startPlacement: normalizeAgentPsdImagePlacement(
+        effectiveImagePlacements[layer.id]
+      ),
+    };
+
+    const nextTarget = event.currentTarget;
+    try {
+      nextTarget.setPointerCapture?.(event.pointerId);
+    } catch (error) {
+      console.warn(
+        "[AgentPsdTemplateEditorDialog] setPointerCapture failed:",
+        error
+      );
+    }
+
+    const handlePointerMove = (moveEvent: PointerEvent) => {
+      const dragState = imagePlacementDragStateRef.current;
+      if (!dragState || dragState.layerId !== layer.id) {
+        return;
+      }
+
+      updateImagePlacement(layer.id, () => ({
+        ...dragState.startPlacement,
+        offsetX:
+          dragState.startPlacement.offsetX +
+          (moveEvent.clientX - dragState.startClientX) / stageScale,
+        offsetY:
+          dragState.startPlacement.offsetY +
+          (moveEvent.clientY - dragState.startClientY) / stageScale,
+      }));
+    };
+
+    const handlePointerUp = (upEvent: PointerEvent) => {
+      if (imagePlacementDragStateRef.current?.pointerId === upEvent.pointerId) {
+        imagePlacementDragStateRef.current = null;
+      }
+      window.removeEventListener("pointermove", handlePointerMove);
+      window.removeEventListener("pointerup", handlePointerUp);
+      window.removeEventListener("pointercancel", handlePointerUp);
+    };
+
+    window.addEventListener("pointermove", handlePointerMove);
+    window.addEventListener("pointerup", handlePointerUp);
+    window.addEventListener("pointercancel", handlePointerUp);
+  }
+
   function handleTextDragStart(
     layer: AgentPsdTemplateTextLayerSlot,
     event: ReactPointerEvent<HTMLDivElement>
@@ -4140,6 +4217,11 @@ export function AgentPsdTemplateEditorDialog({
                             if (isAgentPsdImageLayerSlot(layer)) {
                               const assignedUrl =
                                 effectiveImageAssignments[layer.id];
+                              const hasAssignedImage = Boolean(
+                                String(assignedUrl || "").trim()
+                              );
+                              const canDragAssignedImage =
+                                isLayerSuperLocked && hasAssignedImage;
                               const layerImageUrl =
                                 assignedUrl ||
                                 getPsdLayerPreviewSourceUrl(layer);
@@ -4156,39 +4238,51 @@ export function AgentPsdTemplateEditorDialog({
                               return (
                                 <div
                                   className={`absolute overflow-hidden ${
-                                    isLayerSuperLocked
+                                    isLayerSuperLocked && !hasAssignedImage
                                       ? "pointer-events-none"
                                       : "pointer-events-auto"
                                   }`}
                                   key={layer.id}
-                                  onClick={
+                                  onClick={(event) => {
-                                    isLayerSuperLocked
+                                    event.stopPropagation();
-                                      ? undefined
+                                    setSelectedLayerId(layer.id);
-                                      : (event) => {
+                                  }}
-                                          event.stopPropagation();
+                                  onPointerDown={(event) => {
-                                          setSelectedLayerId(layer.id);
+                                    if (canDragAssignedImage) {
-                                        }
+                                      handleAssignedImagePlacementDragStart(
-                                  }
+                                        layer,
-                                  onPointerDown={(event) =>
+                                        event
-                                    isLayerSuperLocked
+                                      );
-                                      ? undefined
+                                      return;
-                                      : handleLayerDragStart(layer, event)
+                                    }
-                                  }
+                                    if (!isLayerSuperLocked) {
+                                      handleLayerDragStart(layer, event);
+                                    }
+                                  }}
                                   style={{
                                     ...assignedImageContainerStyle,
                                     zIndex: baseZIndex,
-                                    cursor:
+                                    cursor: canDragAssignedImage
-                                      isLayerSuperLocked
+                                      ? imagePlacementDragStateRef.current
+                                          ?.layerId === layer.id
+                                        ? "grabbing"
+                                        : "grab"
+                                      : isLayerSuperLocked
                                         ? "default"
                                         : layerDragStateRef.current?.layerId ===
                                             layer.id
                                           ? "grabbing"
                                           : "grab",
-                                    touchAction: isLayerSuperLocked
+                                    touchAction:
-                                      ? "auto"
+                                      isLayerSuperLocked && !hasAssignedImage
-                                      : "none",
+                                        ? "auto"
+                                        : "none",
                                   }}
-                                  title={`${getLayerLabel(layer)}：${layer.layerName}`}
+                                  title={
+                                    canDragAssignedImage
+                                      ? `${getLayerLabel(layer)}：${layer.layerName}（目标已锁定，可拖动替换图）`
+                                      : `${getLayerLabel(layer)}：${layer.layerName}`
+                                  }
                                 >
                                   <img
                                     alt={layer.layerName}
@@ -4429,6 +4523,8 @@ export function AgentPsdTemplateEditorDialog({
                                 effectiveImageAssignments[layer.id] || ""
                               ).trim()
                             );
+                            const isLayerSuperLocked =
+                              isAgentPsdLayerSuperLocked(layer);
 
                             return isSelected && hasAssignedImage ? (
                               <div
@@ -4456,9 +4552,18 @@ export function AgentPsdTemplateEditorDialog({
                                 className="absolute overflow-hidden rounded-lg transition-all"
                                 key={layer.id}
                                 onClick={() => setSelectedLayerId(layer.id)}
-                                onPointerDown={(event) =>
+                                onPointerDown={(event) => {
-                                  handleLayerDragStart(layer, event)
+                                  if (isLayerSuperLocked && hasAssignedImage) {
-                                }
+                                    handleAssignedImagePlacementDragStart(
+                                      layer,
+                                      event
+                                    );
+                                    return;
+                                  }
+                                  if (!isLayerSuperLocked) {
+                                    handleLayerDragStart(layer, event);
+                                  }
+                                }}
                                 style={{
                                   ...frameStyle,
                                   zIndex:
@@ -4470,10 +4575,15 @@ export function AgentPsdTemplateEditorDialog({
                                     ? "rgba(249,115,22,0.08)"
                                     : "transparent",
                                   cursor:
-                                    layerDragStateRef.current?.layerId ===
+                                    isLayerSuperLocked && hasAssignedImage
-                                    layer.id
+                                      ? imagePlacementDragStateRef.current
-                                      ? "grabbing"
+                                          ?.layerId === layer.id
-                                      : "grab",
+                                        ? "grabbing"
+                                        : "grab"
+                                      : layerDragStateRef.current?.layerId ===
+                                          layer.id
+                                        ? "grabbing"
+                                        : "grab",
                                   touchAction: "none",
                                 }}
                                 title={`${getLayerLabel(layer)}：${layer.layerName}`}

lib/agents/psd-template-renderer.ts

@@ -576,13 +576,13 @@ export async function renderAgentPsdTemplate(params: {
     for (const layer of orderedTemplateLayers) {
       if (hiddenLayerIdSet.has(layer.id)) {
         continue;
-	      }
+      }
 
-	      const storedLayerSourceUrl = getStoredLayerSourceUrl(layer);
+      const storedLayerSourceUrl = getStoredLayerSourceUrl(layer);
-	      if (shouldRenderAsStaticLayer(layer)) {
+      if (shouldRenderAsStaticLayer(layer)) {
-	        if (shouldUseRenderBaseFallback || shouldUseRenderSegments) {
+        if (shouldUseRenderBaseFallback || shouldUseRenderSegments) {
-	          continue;
+          continue;
-	        }
+        }
         pushAsset(
           storedLayerSourceUrl,
           "PSD 图层素材",
@@ -913,7 +913,10 @@ export async function renderAgentPsdTemplate(params: {
   }
 
   for (const layer of [...orderedTemplateLayers].reverse()) {
-    if (shouldUseRenderSegments && isAgentPsdTemplateLayerUserEditable(layer)) {
+    if (
+      shouldUseRenderSegments &&
+      (isAgentPsdTemplateLayerUserEditable(layer) || hasImageAssignment(layer))
+    ) {
       await appendRenderSegmentBeforeLayer(layer.id);
     }
 
@@ -921,7 +924,7 @@ export async function renderAgentPsdTemplate(params: {
       continue;
     }
 
-    if (!isAgentPsdTemplateLayerUserEditable(layer)) {
+    if (shouldRenderAsStaticLayer(layer)) {
       if (shouldUseRenderBaseFallback || shouldUseRenderSegments) {
         continue;
       }