DNF90 服务端与启动器完整源码（含 GM 工具功能增强）

服务端（Go）：
- GM 塞背包/带属性装备发放：在线角色推送 op14 增量物品行，背包实时刷新，无需回角色选择界面
- GM 改金币/改等级：去掉在线拒绝，落库后推送 op14 钱包/op37 等级状态，在线实时刷新
- 等级端点统一切换到新版 GMSetCharacterLevel（自带在线刷新）
- 无限/锁死疲劳模式 + 燃烧疲劳：每房间消耗 2 点、打怪与通关经验双倍
- 燃烧疲劳开关时给所有在线角色推送系统提示（op12 mode 0）
- 深渊史诗掉率：GM 全局倍率 + 城镇增益药剂窗口倍率，真实接入掉落结算

启动器（Python/JS）：
- 标题栏自绘、窗口 1204x717、禁止拖拽改大小、仅最小化/关闭
- GM 工具：疲劳与燃烧、深渊史诗掉率、拍卖行上架（单一定价对齐）
- 拍卖行上架前端对齐服务端单一价格语义，修复 400 报错

server/internal/services/dnfbridge/npc_shop_projection.go

@@ -0,0 +1,677 @@
+package dnfbridge
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"math"
+	"strconv"
+	"strings"
+
+	dnfcarrygold "longheng.io/server/internal/modules/dnf/carrygold"
+	dnfnpcshop "longheng.io/server/internal/modules/dnf/npcshop"
+	"longheng.io/server/internal/modules/dnf/purchaselimit"
+	dnfrepo "longheng.io/server/internal/modules/dnf/repository"
+	dnfrevivecoin "longheng.io/server/internal/modules/dnf/revivecoin"
+	"longheng.io/server/internal/modules/dnf/wedding"
+)
+
+var (
+	errCurrentNPCShopOwnerUnavailable     = errors.New("dnf current NPC shop owner is unavailable")
+	errCurrentNPCShopGoldInsufficient     = errors.New("dnf current NPC shop gold is insufficient")
+	errCurrentNPCShopMaterialInsufficient = errors.New("dnf current NPC shop material is insufficient")
+	errCurrentNPCShopItemLocked           = errors.New("dnf current NPC shop item is equipment locked")
+	errCurrentNPCShopGoldOverflow         = errors.New("dnf current NPC shop gold exceeds the current client wallet")
+	errCurrentNPCShopGoldCarryCap         = errors.New("dnf current NPC shop payout exceeds the gold carry cap")
+	// errCurrentNPCShopPurchaseLimitReached：PVF `[purchase limit]` 上限已满。
+	errCurrentNPCShopPurchaseLimitReached = errors.New("dnf current NPC shop purchase limit reached")
+)
+
+func (s *Service) commitCurrentNPCShopBuy(ctx context.Context, session *gameSession, shop *currentNPCShopCatalog, items *pvfDungeonDropCatalog, request currentNPCShopBuyRequest) (currentNPCShopBuyResult, error) {
+	if s == nil || session == nil || session.selectedCharacterID == 0 || shop == nil || items == nil {
+		return currentNPCShopBuyResult{}, errCurrentNPCShopOwnerUnavailable
+	}
+	pricing, err := resolveCurrentNPCShopPricingForContext(shop, items, request.ItemID, request.ShopContext, request.ActorContext)
+	if err != nil {
+		return currentNPCShopBuyResult{}, err
+	}
+	if !pricing.Buyable {
+		return currentNPCShopBuyResult{}, fmt.Errorf("%w: item=%d listed=%t buy_gold=%d material_exchange=%t", errCurrentNPCShopProductUnavailable, request.ItemID, currentNPCShopContainsItem(shop, request.ItemID), pricing.BuyGold, pricing.MaterialExchange)
+	}
+	count, err := normalizeCurrentNPCShopBuyCount(pricing.Definition, request.Count)
+	if err != nil {
+		return currentNPCShopBuyResult{}, err
+	}
+	request.Count = count
+	// 婚房装饰（PVF stackable 类型 `[couple room item]`）不是普通背包商品：它要落进
+	// 19 号婚房容器，并伴随装饰加成重算。必须在下面的 stack limit 检查之前分流，
+	// 否则会被当成普通堆叠商品按背包上限拒掉。
+	if normalizeDungeonDropStackableType(pricing.Definition.StackableType) == "[couple room item]" {
+		return s.commitWeddingDecorationBuy(ctx, session, pricing, request)
+	}
+	if pricing.Definition.Kind == dungeonDropItemStackable && pricing.Definition.StackLimit > 0 && int64(request.Count) > pricing.Definition.StackLimit {
+		return currentNPCShopBuyResult{}, fmt.Errorf("%w: item=%d count=%d stack_limit=%d", errCurrentNPCShopProductUnavailable, request.ItemID, request.Count, pricing.Definition.StackLimit)
+	}
+	if pricing.MaterialExchange {
+		// 心意点（LovePointMaterial）是 PVF 商店的"夫妻货币"，不是可堆叠实体道具。
+		// 它必须走婚姻事务（买卖双方一起校验、金币与心意点同事务扣减），
+		// 不能落到通用材料交换路径。
+		if pricing.NeedMaterialItem == wedding.LovePointMaterial {
+			return s.commitWeddingRingBuy(ctx, session, pricing, request)
+		}
+		return s.commitCurrentNPCShopMaterialExchange(ctx, session, pricing, request)
+	}
+	if pricing.BuyGold > math.MaxInt64/int64(request.Count) {
+		return currentNPCShopBuyResult{}, errCurrentNPCShopGoldOverflow
+	}
+	totalCost := pricing.BuyGold * int64(request.Count)
+	accountID, characterID, repositories, owner, err := s.currentNPCShopMutationOwner(session)
+	if err != nil {
+		return currentNPCShopBuyResult{}, err
+	}
+	// 未解锁的背包扩展行不是合法落点，见 currentNPCShopPlacementMainSlotCount。
+	placementMainSlotCount := s.currentInventoryPlacementMainSlotCount(ctx, nil, characterID)
+	var result currentNPCShopBuyResult
+	err = owner.Mutate(ctx, dnfnpcshop.Command{
+		AccountID:   accountID,
+		CharacterID: characterID,
+		Project: func(assets *dnfnpcshop.Assets) (dnfnpcshop.Changes, error) {
+			character := assets.Character
+			inventory := assets.Inventory
+			if character.Stats == nil {
+				return dnfnpcshop.Changes{}, errCurrentNPCShopOwnerUnavailable
+			}
+			gold := character.Stats["gold"]
+			if gold < 0 || gold > math.MaxInt32 {
+				return dnfnpcshop.Changes{}, errCurrentNPCShopGoldOverflow
+			}
+			if gold < totalCost {
+				return dnfnpcshop.Changes{}, fmt.Errorf("%w: need=%d have=%d", errCurrentNPCShopGoldInsufficient, totalCost, gold)
+			}
+			// PVF 限购：超限即整笔回滚（同事务里金币、道具、计数一起失败）。
+			limitPolicy, limitState, limitErr := consumeCurrentPurchaseLimit(assets.Character, assets.Account, pricing.Definition, request.Count, s.currentPurchaseLimitTime())
+			if limitErr != nil {
+				return dnfnpcshop.Changes{}, fmt.Errorf("%w: item=%d scope=%s period=%s used=%d requested=%d limit=%d: %w",
+					errCurrentPurchaseLimitReached, request.ItemID, limitPolicy.Scope, limitPolicy.Period,
+					limitState.Used, request.Count, limitPolicy.Limit, limitErr)
+			}
+			// 无色小晶块 / 灵魂 这 12 个道具在自己账号里只有一个固定格
+			// （晶体仓库 354..359 + 灵魂仓库 360..365，权威表见
+			// repository/account_shared_materials.go）。**任何获取途径都必须落进
+			// 那个格子**，金币购买这条路过去漏了这一步：1111 买的 20 个无色留在
+			// 角色背包 0:154，而账号槽 0:358 另有 43890 个，同一条 list-0 报文里
+			// 出现两行同 itemID，客户端把背包那一行显示成了仓库的数量（现场
+			// 2026-09-21）。
+			//
+			// 落点判定不再在这里手写，改调统一入口 grantCurrentAccountSharedFirst
+			// （account_shared_grant.go）—— 同一个函数材料兑换、分解、礼盒等路径
+			// 也在用，新增功能照抄一行即可。装不下的余量仍然交给 NPC 商店自己的
+			// 角色侧发放（含 list 38 勋章/守护宝石与复活币钱包两条特例）。
+			account := assets.AccountInventory
+			if account == nil {
+				return dnfnpcshop.Changes{}, errCurrentNPCShopOwnerUnavailable
+			}
+			shared := grantCurrentAccountSharedFirst(account, pricing.Definition, request.Count, "npc_shop")
+			accountDirty := shared.Changed
+			grantSlots := make([]int16, 0, 2)
+			itemListType := dnfrepo.MainInventoryListType
+			if shared.Changed {
+				grantSlots = append(grantSlots, shared.Slot)
+			}
+			// 两种情形才走角色侧：该道具没有固定格（Remainder == 整笔），
+			// 或固定格装不下（堆叠上限已满 / 该格被别的道具占着的历史脏数据）。
+			characterCount := shared.Remainder
+			if !shared.Changed {
+				characterCount = request.Count
+			}
+			if characterCount > 0 {
+				listType, slots, grantErr := grantCurrentNPCShopProduct(inventory, pricing.Definition, characterCount, placementMainSlotCount)
+				if grantErr != nil {
+					return dnfnpcshop.Changes{}, grantErr
+				}
+				if !shared.Changed && len(slots) != 1 {
+					// 没有固定格时保持旧的"恰好一个槽"严格性，行为逐字不变。
+					return dnfnpcshop.Changes{}, fmt.Errorf("%w: item=%d changed_slots=%d", errCurrentNPCShopProductUnavailable, request.ItemID, len(slots))
+				}
+				itemListType = listType
+				grantSlots = append(grantSlots, slots...)
+			}
+			if len(grantSlots) == 0 {
+				return dnfnpcshop.Changes{}, fmt.Errorf("%w: item=%d changed_slots=0", errCurrentNPCShopProductUnavailable, request.ItemID)
+			}
+			goldAfter := gold - totalCost
+			character.Stats["gold"] = goldAfter
+			updates := []currentItemListEntry{currentGoldWalletItemListEntry(goldAfter)}
+			var itemUpdates []currentItemListEntry
+			var itemEntry currentItemListEntry
+			// A revive coin lands in the fixed slot-1 wallet as item 1, so the
+			// row that came back legitimately carries a different item id than
+			// the product bought (item 42, cash/coin_general.stk).
+			revivedCoinProduct := dnfrevivecoin.IsReward(int64(request.ItemID))
+			for index, slot := range grantSlots {
+				key := currentCeraShopInventorySlotKey(itemListType, slot)
+				// 账号共享槽（0:354..365）由账号记录持有，角色背包格由角色记录持有；
+				// 同一个 list-0 线地址，落库归属不同 —— 先查账号再查角色。
+				stack, found := account.Slots[key]
+				if !found {
+					stack, found = inventory.Slots[key]
+				}
+				if !found || stack.Count <= 0 ||
+					(!revivedCoinProduct && stack.ItemID != int64(request.ItemID)) ||
+					(revivedCoinProduct && stack.ItemID != dnfrevivecoin.WalletItemID) {
+					return dnfnpcshop.Changes{}, errCurrentNPCShopProductUnavailable
+				}
+				if stack.Extra == nil {
+					stack.Extra = make(map[string]string, 6)
+				}
+				stack.Extra["last_grant_source"] = "npc_shop"
+				stack.Extra["last_npc_shop_context"] = strconv.FormatUint(uint64(request.ShopContext), 10)
+				stack.Extra["last_npc_shop_actor_context"] = strconv.FormatUint(uint64(request.ActorContext), 10)
+				entry := currentItemListEntryFromStack(itemListType, slot, stack)
+				stack.RawEntry = append([]byte(nil), entry.data[:]...)
+				if _, accountOwned := account.Slots[key]; accountOwned {
+					account.Slots[key] = stack
+					accountDirty = true
+				} else {
+					inventory.Slots[key] = stack
+				}
+				if index == 0 {
+					itemEntry = entry
+				}
+				if itemListType == dnfrepo.MainInventoryListType {
+					updates = append(updates, entry)
+				} else {
+					itemUpdates = append(itemUpdates, entry)
+				}
+			}
+			sortCurrentItemListEntries(updates)
+			result = currentNPCShopBuyResult{
+				GoldAfter:    goldAfter,
+				SPAfter:      character.Stats["sp"],
+				Item:         itemEntry,
+				Updates:      updates,
+				ItemListType: itemListType,
+				ItemUpdates:  itemUpdates,
+				Slot:         grantSlots[0],
+				ItemID:       request.ItemID,
+				Count:        request.Count,
+			}
+			changes := dnfnpcshop.Changes{Character: true, Inventory: true, AccountInventory: accountDirty}
+			if limitPolicy.Scope == purchaselimit.ScopeAccount {
+				changes.Account = true
+			}
+			return changes, nil
+		},
+	})
+	if err != nil {
+		return currentNPCShopBuyResult{}, currentNPCShopMutationError(err)
+	}
+	// Cera is the account-shared pool; the NPC shop ACK only displays it and
+	// never debits, so a read-only post-commit load is sufficient.
+	result.CoinAfter = s.loadCurrentAccountCera(ctx, repositories, session)
+	return result, nil
+}
+
+// commitCurrentNPCShopMaterialExchange buys a [need material] shop item: it
+// consumes the material cost (account cube-fragment cell for cube fragments,
+// first matching character stack otherwise) and grants the purchase in the
+// same account+inventory transaction. Cube-fragment purchases land on their
+// fixed account warehouse slots.
+//
+// 2026-10-08: when the same PVF block ALSO carries an explicit [price], the gold
+// half is charged in this very transaction (currentNPCShopPricing.RequiresGold).
+// Every [need material] item used to be treated as material-only, so mixed goods
+// like 3042 ([price] 2000 + [need material] 3037 x100) cost no gold at all: seven
+// consecutive buys left gold_after unchanged at 49355535.
+func (s *Service) commitCurrentNPCShopMaterialExchange(ctx context.Context, session *gameSession, pricing currentNPCShopPricing, request currentNPCShopBuyRequest) (currentNPCShopBuyResult, error) {
+	if s == nil || session == nil || session.selectedCharacterID == 0 {
+		return currentNPCShopBuyResult{}, errCurrentNPCShopOwnerUnavailable
+	}
+	switch pricing.Definition.Kind {
+	case dungeonDropItemEquipment:
+		if request.Count != 1 {
+			return currentNPCShopBuyResult{}, fmt.Errorf("%w: exchange equipment=%d count=%d", errCurrentNPCShopProductUnavailable, request.ItemID, request.Count)
+		}
+	case dungeonDropItemStackable:
+		if request.Count == 0 {
+			return currentNPCShopBuyResult{}, fmt.Errorf("%w: exchange stackable=%d count=0", errCurrentNPCShopProductUnavailable, request.ItemID)
+		}
+	default:
+		return currentNPCShopBuyResult{}, fmt.Errorf("%w: exchange item=%d kind=%s", errCurrentNPCShopProductUnavailable, request.ItemID, pricing.Definition.Kind)
+	}
+	if pricing.NeedMaterialItem == 0 || pricing.NeedMaterialCount <= 0 || pricing.NeedMaterialCount > math.MaxInt64/int64(request.Count) {
+		return currentNPCShopBuyResult{}, fmt.Errorf("%w: exchange item=%d cost=%d x%d", errCurrentNPCShopProductUnavailable, request.ItemID, pricing.NeedMaterialItem, pricing.NeedMaterialCount)
+	}
+	totalMaterial := pricing.NeedMaterialCount * int64(request.Count)
+	// 显式标了 [price] 的商品：金币与材料必须在同一个事务里一起扣，否则就是"只收材料"。
+	goldCost := int64(0)
+	if pricing.RequiresGold {
+		if pricing.BuyGold <= 0 {
+			return currentNPCShopBuyResult{}, fmt.Errorf("%w: exchange item=%d requires_gold with price=%d", errCurrentNPCShopProductUnavailable, request.ItemID, pricing.BuyGold)
+		}
+		if pricing.BuyGold > math.MaxInt64/int64(request.Count) {
+			return currentNPCShopBuyResult{}, errCurrentNPCShopGoldOverflow
+		}
+		goldCost = pricing.BuyGold * int64(request.Count)
+	}
+	accountID, characterID, repositories, owner, err := s.currentNPCShopMutationOwner(session)
+	if err != nil {
+		return currentNPCShopBuyResult{}, err
+	}
+	// 未解锁的背包扩展行不是合法落点，见 currentNPCShopPlacementMainSlotCount。
+	placementMainSlotCount := s.currentInventoryPlacementMainSlotCount(ctx, nil, characterID)
+	var result currentNPCShopBuyResult
+	err = owner.Mutate(ctx, dnfnpcshop.Command{
+		AccountID:   accountID,
+		CharacterID: characterID,
+		Project: func(assets *dnfnpcshop.Assets) (dnfnpcshop.Changes, error) {
+			character := assets.Character
+			inventory := assets.Inventory
+			account := assets.AccountInventory
+			if character.Stats == nil {
+				return dnfnpcshop.Changes{}, errCurrentNPCShopOwnerUnavailable
+			}
+			gold := character.Stats["gold"]
+			if gold < 0 || gold > math.MaxInt32 {
+				return dnfnpcshop.Changes{}, errCurrentNPCShopGoldOverflow
+			}
+			if gold < goldCost {
+				return dnfnpcshop.Changes{}, fmt.Errorf("%w: need=%d have=%d", errCurrentNPCShopGoldInsufficient, goldCost, gold)
+			}
+			goldAfter := gold - goldCost
+			if goldCost > 0 {
+				character.Stats["gold"] = goldAfter
+			}
+			updates := make([]currentItemListEntry, 0, 4)
+
+			// Consume the material cost.
+			accountDirty := false
+			if materialSlot, warehouseMaterial := currentDisjointWarehouseFixedSlots[pricing.NeedMaterialItem]; warehouseMaterial {
+				key := dnfrepo.AccountSharedInventorySlotKey(materialSlot)
+				stack, exists := account.Slots[key]
+				if !exists || stack.ItemID != int64(pricing.NeedMaterialItem) || stack.Count < totalMaterial {
+					return dnfnpcshop.Changes{}, fmt.Errorf("%w: item=%d need=%d have=%d", errCurrentNPCShopMaterialInsufficient, pricing.NeedMaterialItem, totalMaterial, stack.Count)
+				}
+				stack.Count -= totalMaterial
+				entry := currentItemListEntryFromStack(dnfrepo.MainInventoryListType, materialSlot, stack)
+				stack.RawEntry = append([]byte(nil), entry.data[:]...)
+				account.Slots[key] = stack
+				accountDirty = true
+				result.CostItemID = pricing.NeedMaterialItem
+				result.CostItemNewCount = stack.Count
+				updates = append(updates, entry)
+			} else {
+				type materialCandidate struct {
+					slot  int16
+					key   string
+					stack dnfrepo.ItemStack
+				}
+				candidates := make([]materialCandidate, 0, 2)
+				available := int64(0)
+				for slot := int16(0); slot <= dnfrepo.SoulWarehouseLastSlot; slot++ {
+					if dnfrepo.IsAccountSharedInventorySlot(dnfrepo.MainInventoryListType, slot) {
+						continue
+					}
+					key := currentCeraShopInventorySlotKey(dnfrepo.MainInventoryListType, slot)
+					stack, exists := inventory.Slots[key]
+					if exists && stack.ItemID == int64(pricing.NeedMaterialItem) && stack.Count > 0 {
+						if available > math.MaxInt64-stack.Count {
+							return dnfnpcshop.Changes{}, errCurrentNPCShopGoldOverflow
+						}
+						available += stack.Count
+						candidates = append(candidates, materialCandidate{slot: slot, key: key, stack: stack})
+					}
+				}
+				if available < totalMaterial {
+					return dnfnpcshop.Changes{}, fmt.Errorf("%w: item=%d need=%d have=%d", errCurrentNPCShopMaterialInsufficient, pricing.NeedMaterialItem, totalMaterial, available)
+				}
+				remainingCost := totalMaterial
+				for _, candidate := range candidates {
+					if remainingCost == 0 {
+						break
+					}
+					take := candidate.stack.Count
+					if take > remainingCost {
+						take = remainingCost
+					}
+					candidate.stack.Count -= take
+					remainingCost -= take
+					if candidate.stack.Count == 0 {
+						delete(inventory.Slots, candidate.key)
+						var removed currentItemListEntry
+						removed.patchCore(candidate.slot, math.MaxUint32, 0)
+						updates = append(updates, removed)
+						continue
+					}
+					entry := currentItemListEntryFromStack(dnfrepo.MainInventoryListType, candidate.slot, candidate.stack)
+					candidate.stack.RawEntry = append([]byte(nil), entry.data[:]...)
+					inventory.Slots[candidate.key] = candidate.stack
+					updates = append(updates, entry)
+				}
+				result.CostItemID = pricing.NeedMaterialItem
+				result.CostItemNewCount = available - totalMaterial
+			}
+
+			// Grant the purchase.
+			// PVF 限购：材料兑换与金币购买共用同一套计数。角色维度落在
+			// 角色 Stats、账号维度落在账号记录 Metadata，分别需要各自的保存
+			// 标志（AccountInventory 是账号仓库记录，与账号记录不是同一条）。
+			limitPolicy, limitState, limitErr := consumeCurrentPurchaseLimit(assets.Character, assets.Account, pricing.Definition, request.Count, s.currentPurchaseLimitTime())
+			if limitErr != nil {
+				return dnfnpcshop.Changes{}, fmt.Errorf("%w: item=%d scope=%s period=%s used=%d requested=%d limit=%d: %w",
+					errCurrentPurchaseLimitReached, request.ItemID, limitPolicy.Scope, limitPolicy.Period,
+					limitState.Used, request.Count, limitPolicy.Limit, limitErr)
+			}
+			accountRecordDirty := limitPolicy.Scope == purchaselimit.ScopeAccount
+			characterStatsDirty := limitPolicy.Scope == purchaselimit.ScopeCharacter
+			// 与金币购买分支共用同一个落点入口（grantCurrentAccountSharedFirst）。
+			// 这两条分支过去各写一遍落点判定 —— 正是那次分家让金币购买漏掉了固定槽，
+			// 20 个无色落进背包（2026-09-21）。现在它们只可能一起对或一起错。
+			shared := grantCurrentAccountSharedFirst(account, pricing.Definition, request.Count, "npc_shop_material_exchange")
+			accountDirty = accountDirty || shared.Changed
+			grantSlots := make([]int16, 0, 2)
+			itemListType := dnfrepo.MainInventoryListType
+			if shared.Changed {
+				grantSlots = append(grantSlots, shared.Slot)
+			}
+			characterCount := shared.Remainder
+			if !shared.Changed {
+				characterCount = request.Count
+			}
+			if characterCount > 0 {
+				listType, slots, grantErr := grantCurrentNPCShopProduct(inventory, pricing.Definition, characterCount, placementMainSlotCount)
+				if grantErr != nil {
+					return dnfnpcshop.Changes{}, grantErr
+				}
+				if !shared.Changed && len(slots) != 1 {
+					return dnfnpcshop.Changes{}, fmt.Errorf("%w: item=%d changed_slots=%d", errCurrentNPCShopProductUnavailable, request.ItemID, len(slots))
+				}
+				itemListType = listType
+				grantSlots = append(grantSlots, slots...)
+			}
+			if len(grantSlots) == 0 {
+				return dnfnpcshop.Changes{}, fmt.Errorf("%w: item=%d changed_slots=0", errCurrentNPCShopProductUnavailable, request.ItemID)
+			}
+			var itemEntry currentItemListEntry
+			var itemUpdates []currentItemListEntry
+			for index, slot := range grantSlots {
+				key := currentCeraShopInventorySlotKey(itemListType, slot)
+				stack, found := account.Slots[key]
+				if !found {
+					stack, found = inventory.Slots[key]
+				}
+				if !found || stack.ItemID != int64(request.ItemID) || stack.Count <= 0 {
+					return dnfnpcshop.Changes{}, errCurrentNPCShopProductUnavailable
+				}
+				if stack.Extra == nil {
+					stack.Extra = make(map[string]string, 4)
+				}
+				stack.Extra["last_grant_source"] = "npc_shop"
+				stack.Extra["last_npc_shop_context"] = strconv.FormatUint(uint64(request.ShopContext), 10)
+				stack.Extra["last_npc_shop_actor_context"] = strconv.FormatUint(uint64(request.ActorContext), 10)
+				entry := currentItemListEntryFromStack(itemListType, slot, stack)
+				stack.RawEntry = append([]byte(nil), entry.data[:]...)
+				if _, isAccount := account.Slots[key]; isAccount {
+					account.Slots[key] = stack
+					accountDirty = true
+				} else {
+					inventory.Slots[key] = stack
+				}
+				if index == 0 {
+					itemEntry = entry
+				}
+				if itemListType == dnfrepo.MainInventoryListType {
+					updates = append(updates, entry)
+				} else {
+					itemUpdates = append(itemUpdates, entry)
+				}
+			}
+			updates = append(updates, currentGoldWalletItemListEntry(goldAfter))
+			sortCurrentItemListEntries(updates)
+			result.GoldAfter = goldAfter
+			result.SPAfter = character.Stats["sp"]
+			result.Item = itemEntry
+			result.Updates = updates
+			result.ItemListType = itemListType
+			result.ItemUpdates = itemUpdates
+			result.Slot = grantSlots[0]
+			result.ItemID = request.ItemID
+			result.Count = request.Count
+			return dnfnpcshop.Changes{
+				Account:          accountRecordDirty,
+				AccountInventory: accountDirty,
+				// 金币在角色 Stats 里：扣了就必须把角色记录一起落库。
+				Character: characterStatsDirty || goldCost > 0,
+				Inventory: true,
+			}, nil
+		},
+	})
+	if err != nil {
+		return currentNPCShopBuyResult{}, currentNPCShopMutationError(err)
+	}
+	result.CoinAfter = s.loadCurrentAccountCera(ctx, repositories, session)
+	return result, nil
+}
+
+func (s *Service) commitCurrentNPCShopSell(ctx context.Context, session *gameSession, shop *currentNPCShopCatalog, items *pvfDungeonDropCatalog, request currentNPCShopSellRequest) (currentNPCShopSellResult, error) {
+	if s == nil || session == nil || session.selectedCharacterID == 0 || shop == nil || items == nil {
+		return currentNPCShopSellResult{}, errCurrentNPCShopOwnerUnavailable
+	}
+	accountID, characterID, _, owner, err := s.currentNPCShopMutationOwner(session)
+	if err != nil {
+		return currentNPCShopSellResult{}, err
+	}
+	var result currentNPCShopSellResult
+	err = owner.Mutate(ctx, dnfnpcshop.Command{
+		AccountID:   accountID,
+		CharacterID: characterID,
+		Project: func(assets *dnfnpcshop.Assets) (dnfnpcshop.Changes, error) {
+			character := assets.Character
+			inventory := assets.Inventory
+			if character.Stats == nil {
+				return dnfnpcshop.Changes{}, errCurrentNPCShopOwnerUnavailable
+			}
+			// 晶体/灵魂仓库（list 0, 354..365）是**账号**所有：同一个 list-0 线地址
+			// 由账号记录持有，客户端照旧按普通 list-0 格子寻址。卖这一格就是扣账号记录
+			// 里的那一行，扣完把账号记录写回去（Changes.AccountInventory）。
+			accountOwned := dnfrepo.IsAccountSharedInventorySlot(request.ListType, request.Slot)
+			itemSlots := inventory.Slots
+			if accountOwned {
+				if assets.AccountInventory == nil {
+					return dnfnpcshop.Changes{}, errCurrentNPCShopOwnerUnavailable
+				}
+				itemSlots = assets.AccountInventory.Slots
+			}
+			key := currentCeraShopInventorySlotKey(request.ListType, request.Slot)
+			stack, found := itemSlots[key]
+			if !found || stack.ItemID <= 0 || stack.ItemID > math.MaxUint32 || stack.Count <= 0 {
+				return dnfnpcshop.Changes{}, fmt.Errorf("%w: list=%d slot=%d", errCurrentNPCShopProductUnavailable, request.ListType, request.Slot)
+			}
+			if currentNPCShopItemLocked(stack) {
+				return dnfnpcshop.Changes{}, fmt.Errorf("%w: list=%d slot=%d", errCurrentNPCShopItemLocked, request.ListType, request.Slot)
+			}
+			pricing, priceErr := resolveCurrentNPCShopPricingForContext(shop, items, uint32(stack.ItemID), 0, request.ActorContext)
+			if priceErr != nil {
+				return dnfnpcshop.Changes{}, priceErr
+			}
+			// Zero-value goods are sellable. No item-dictionary field forbids NPC
+			// sales (scanned 306066 stackable/equipment scripts, 1465 distinct keys:
+			// "sell"/"sale" only match the event-only [sale limit]/[sale npc index],
+			// and [npc gift disallowance] governs NPC gifts), so an item without
+			// [price]/[value] simply pays nothing and is consumed - which is exactly
+			// what the client already shows and lets the player confirm.
+			//
+			// Trading-system goods stay fail-closed: their price lives in the
+			// matching NPC row (time stones carry no PVF price at all), so a zero
+			// price there means the wrong NPC was used, not worthless goods.
+			if pricing.SellGold < 0 ||
+				pricing.SellGold == 0 && !pricing.ZeroGoldDisposal && currentNPCShopItemTradingListed(shop, uint32(stack.ItemID)) {
+				return dnfnpcshop.Changes{}, fmt.Errorf("%w: item=%d sell_gold=%d", errCurrentNPCShopProductUnavailable, stack.ItemID, pricing.SellGold)
+			}
+			applied := int64(request.Count)
+			if applied > stack.Count {
+				applied = stack.Count
+			}
+			if pricing.Definition.Kind == dungeonDropItemEquipment {
+				applied = 1
+			}
+			if applied <= 0 || applied > math.MaxUint32 || pricing.SellGold > 0 && applied > math.MaxInt64/pricing.SellGold {
+				return dnfnpcshop.Changes{}, errCurrentNPCShopGoldOverflow
+			}
+			gold := character.Stats["gold"]
+			if gold < 0 || gold > math.MaxInt32 {
+				return dnfnpcshop.Changes{}, errCurrentNPCShopGoldOverflow
+			}
+			goldDelta := pricing.SellGold * applied
+			if goldDelta > math.MaxInt32-gold {
+				return dnfnpcshop.Changes{}, errCurrentNPCShopGoldOverflow
+			}
+			// Selling is the one gold faucet the player can retry, so the carry
+			// cap refuses the sale instead of discarding the payout: the item
+			// stays in the bag rather than being turned into nothing.
+			if room := dnfcarrygold.Room(*character); goldDelta > room {
+				return dnfnpcshop.Changes{}, fmt.Errorf(
+					"%w: payout=%d room=%d limit=%d",
+					errCurrentNPCShopGoldCarryCap,
+					goldDelta,
+					room,
+					dnfcarrygold.LimitForCharacter(*character),
+				)
+			}
+			remaining := stack.Count - applied
+			var itemUpdate currentItemListEntry
+			if remaining <= 0 {
+				delete(itemSlots, key)
+				if accountOwned {
+					// 账号共享晶体/灵魂槽清空写 (itemID=0, count=0)，与拍卖行上架、摆摊售出
+					// 同一写法；0xFFFFFFFF 只适用于角色背包格（GM 工具那条路径实测）。
+					itemUpdate.patchCore(request.Slot, 0, 0)
+				} else {
+					itemUpdate.patchCore(request.Slot, math.MaxUint32, 0)
+				}
+			} else {
+				stack.Count = remaining
+				itemUpdate = currentItemListEntryFromStack(request.ListType, request.Slot, stack)
+				stack.RawEntry = append([]byte(nil), itemUpdate.data[:]...)
+				itemSlots[key] = stack
+			}
+			goldAfter := gold + goldDelta
+			character.Stats["gold"] = goldAfter
+			updates := []currentItemListEntry{currentGoldWalletItemListEntry(goldAfter), itemUpdate}
+			sortCurrentItemListEntries(updates)
+			result = currentNPCShopSellResult{
+				GoldAfter: goldAfter,
+				ListType:  request.ListType,
+				Slot:      request.Slot,
+				Applied:   uint32(applied),
+				ItemID:    uint32(stack.ItemID),
+				Updates:   updates,
+			}
+			return dnfnpcshop.Changes{
+				Character:        true,
+				Inventory:        !accountOwned,
+				AccountInventory: accountOwned,
+			}, nil
+		},
+	})
+	if err != nil {
+		return currentNPCShopSellResult{}, currentNPCShopMutationError(err)
+	}
+	return result, nil
+}
+
+func currentNPCShopItemLocked(stack dnfrepo.ItemStack) bool {
+	if stack.Extra == nil {
+		return false
+	}
+	switch strings.ToLower(strings.TrimSpace(stack.Extra["equipment_lock_state"])) {
+	case "1", "2", "active", "locked", "unlocking", "pending_unlock":
+		return true
+	default:
+		return false
+	}
+}
+
+// currentInventoryPlacementMainSlotCountFor 是自由函数形式，供没有 Service 接收者
+// 的发放路径使用（例如 commitCurrentCompoundRecipe）。
+// 读不到容器状态时返回 0 —— 对应"默认 4 行"，宁可对已扩展角色少放宽几行，也绝
+// 不让物品落进未解锁行。这里用只读的 LoadCharacterContainerState，不在事务外产生
+// 任何写入。
+func currentInventoryPlacementMainSlotCountFor(
+	ctx context.Context,
+	repository dnfrepo.SettingsRepository,
+	characterID string,
+) uint16 {
+	characterID = strings.TrimSpace(characterID)
+	if characterID == "" || repository == nil {
+		return 0
+	}
+	state, found, err := dnfrepo.LoadCharacterContainerState(ctx, repository, characterID)
+	if err != nil || !found {
+		return 0
+	}
+	return state.MainSlotCount
+}
+
+// currentInventoryPlacementMainSlotCount 取该角色当前已购买的背包扩展行数
+// （CharacterContainerState.MainSlotCount，取值 0/8/16/24）。
+//
+// 它必须一路透传到 grantCurrentCeraShopProduct，否则
+// limitCurrentMainInventoryDefinitionSlots 不会被调用，新物品的落点会越过已解锁
+// 范围落进未解锁的扩展行——那些格子客户端不渲染，物品看起来就"消失"了。
+// 赛丽亚商店是在事务内从 assets.Settings 取再透传的；其余模块的 Assets 都没有
+// Settings 字段，所以这里在 bridge 侧用容器状态统一取。
+//
+// characterID 为空时退回 inventory.CharacterID（Load 会填充它）。
+func (s *Service) currentInventoryPlacementMainSlotCount(
+	ctx context.Context,
+	inventory *dnfrepo.InventoryRecord,
+	characterID string,
+) uint16 {
+	characterID = strings.TrimSpace(characterID)
+	if characterID == "" && inventory != nil {
+		characterID = strings.TrimSpace(inventory.CharacterID)
+	}
+	if characterID == "" {
+		return 0
+	}
+	repositories, ok := s.repositoryGroup()
+	if !ok {
+		return 0
+	}
+	return currentInventoryPlacementMainSlotCountFor(ctx, repositories.Settings, characterID)
+}
+
+func (s *Service) currentNPCShopMutationOwner(session *gameSession) (string, string, dnfrepo.Group, *dnfnpcshop.Owner, error) {
+	if s == nil || session == nil || session.selectedCharacterID == 0 {
+		return "", "", dnfrepo.Group{}, nil, errCurrentNPCShopOwnerUnavailable
+	}
+	repositories, ok := s.repositoryGroup()
+	if !ok || repositories.AccountAssets == nil {
+		return "", "", dnfrepo.Group{}, nil, errCurrentNPCShopOwnerUnavailable
+	}
+	accountID := strings.TrimSpace(s.accountIDForSession(session))
+	if accountID == "" {
+		return "", "", dnfrepo.Group{}, nil, errCurrentNPCShopOwnerUnavailable
+	}
+	owner, err := dnfnpcshop.NewOwner(repositories)
+	if err != nil {
+		return "", "", dnfrepo.Group{}, nil, errCurrentNPCShopOwnerUnavailable
+	}
+	characterID := strconv.FormatUint(uint64(session.selectedCharacterID), 10)
+	return accountID, characterID, repositories, owner, nil
+}
+
+func currentNPCShopMutationError(err error) error {
+	switch {
+	case errors.Is(err, dnfnpcshop.ErrOwnerUnavailable),
+		errors.Is(err, dnfnpcshop.ErrAccountRequired),
+		errors.Is(err, dnfnpcshop.ErrCharacterRequired),
+		errors.Is(err, dnfnpcshop.ErrCharacterNotFound),
+		errors.Is(err, dnfnpcshop.ErrAccountMismatch),
+		errors.Is(err, dnfnpcshop.ErrInventoryNotFound):
+		return errors.Join(errCurrentNPCShopOwnerUnavailable, err)
+	default:
+		return err
+	}
+}