Upload 7 files

app.py

@@ -67,13 +67,13 @@ from router_users_social import router as users_social_router
 # ==========================================
 # 其他业务模块
 # ==========================================
-from router_items import router as items_router       # 📦 内容管理(工具/Skill/应用/推荐)
-from router_comments import router as comments_router # 💬 评论系统
+from router_items import (router as items_router, start_resource_reads, stop_resource_reads, close_resource_reads)       # 📦 内容管理(工具/Skill/应用/推荐)
+from router_comments import (router as comments_router, start_comment_writes, stop_comment_writes, close_comment_writes) # 💬 评论系统
 from router_messages import (router as messages_router, start_message_io, stop_message_io, close_message_io) # ✉️ 私信系统
 from router_wallet import router as wallet_router     # 💰 钱包/提现
 from router_proxy import router as proxy_router       # 🔗 代理下载
-from router_posts import router as posts_router       # 💬 讨论区
-from router_prompts import router as prompts_router   # ✨ 提示词市场
+from router_posts import (router as posts_router, start_posts_io, stop_posts_io, close_posts_io)       # 💬 讨论区
+from router_prompts import (router as prompts_router, start_prompts_io, stop_prompts_io, close_prompts_io)   # ✨ 提示词市场
 from router_tasks import router as tasks_router       # 📝 任务榜
 from router_open_api import start_open_sql, stop_open_sql, close_open_sql
 from router_open_api import router as open_api_router  # 🌐 通用开放API（第三方插件）
@@ -295,7 +295,11 @@ async def on_startup():
             start_shared_work()
             start_open_sql()
             start_resource_work()
+            start_resource_reads()
+            start_comment_writes()
             start_message_io()
+            start_posts_io()
+            start_prompts_io()
             start_comment_reads()
             start_admin_scripts()
 
@@ -354,6 +358,8 @@ async def _shutdown_resources():
     failures.call('log_start', logger.info, "🛑 ComfyUI-Ranking API 正在关闭...")
     failures.call('stop_warmup', stop_startup_warmup, app.state)
     for stage, stop in (
+        ('stop_resource_reads', stop_resource_reads), ('stop_comment_writes', stop_comment_writes),
+        ('stop_posts', stop_posts_io), ('stop_prompts', stop_prompts_io),
         ('stop_messages', stop_message_io), ('stop_resources', stop_resource_work), ('stop_open_sql', stop_open_sql), ('stop_shared', stop_shared_work),
         ('stop_identity', stop_identity_io), ('stop_auth', stop_auth_io),
         ('stop_verification', stop_verification_io), ('stop_scripts', stop_admin_scripts),
@@ -368,6 +374,8 @@ async def _shutdown_resources():
         failures.call('stop_' + name, request_periodic_stop, app.state, (name,))
     for stage, close, args in (
         ('wait_warmup', wait_startup_warmup, (app.state,)),
+        ('close_resource_reads', close_resource_reads, ()), ('close_comment_writes', close_comment_writes, ()),
+        ('close_posts', close_posts_io, ()), ('close_prompts', close_prompts_io, ()),
         ('close_messages', close_message_io, ()), ('close_resources', close_resource_work, ()), ('close_open_sql', close_open_sql, ()), ('close_shared', close_shared_work, ()),
         ('close_identity', close_identity_io, ()), ('close_auth', close_auth_io, ()),
         ('close_verification', close_verification_io, ()), ('close_profile', close_profile_io, ()),

owned_thread.py

@@ -1,131 +1,144 @@
-"""等待所属同步工作真实终态；内部取消也不能遗留仍读写资源的线程。"""
-import asyncio
-import threading
-
-
-async def run_owned_thread(function, *args, **kwargs):
-    ownership = threading.Lock()
-    finished = threading.Event()
-    started = False
-    outcome = None
-
-    def abandon_unstarted(result):
-        nonlocal outcome
-        with ownership:
-            if not started and not finished.is_set():
-                outcome = result
-                finished.set()
-
-    def execute():
-        nonlocal started, outcome
-        with ownership:
-            if finished.is_set():
-                return
-            started = True
-        try:
-            result = (True, function(*args, **kwargs))
-        except BaseException as error:
-            # 同步异常作为数据交回；取消shield不暴露私有异常正文。
-            result = (False, error)
-        with ownership:
-            outcome = result
-            finished.set()
-
-    async def finish():
-        try:
-            await asyncio.to_thread(execute)
-        except asyncio.CancelledError:
-            raise
-        except BaseException as error:
-            abandon_unstarted((False, error))
-
-    coroutine = finish()
-    try:
-        task = asyncio.create_task(coroutine)
-    except BaseException:
-        coroutine.close()
-        raise
-
-    def consume(completed):
-        if completed.cancelled():
-            # 取消和线程启动竞争时，只有尚未开始的工作能被撤销。
-            abandon_unstarted((False, asyncio.CancelledError()))
-        else:
-            error = completed.exception()
-            if error is not None:
-                abandon_unstarted((False, error))
-    task.add_done_callback(consume)
-
-    cancelled = None
-    while not finished.is_set():
-        try:
-            if not task.done():
-                await asyncio.shield(task)
-            else:
-                # 内部task已取消但线程仍在运行，不占线程池等待其终态。
-                await asyncio.sleep(0.01)
-        except asyncio.CancelledError as error:
-            cancelled = error
-    with ownership:
-        succeeded, result = outcome
-    if cancelled is not None:
-        raise cancelled
-    if not succeeded:
-        raise result
-    return result
-
-
-class OwnedThreadGroup:
-    def __init__(self, capacity, unavailable):
-        if type(capacity) is not int or capacity < 1:
-            raise ValueError('invalid owned thread capacity')
-        self._capacity = threading.BoundedSemaphore(capacity)
-        self._unavailable = unavailable
-        self._gate = threading.Lock()
-        self._accepting = True
-        self._pending = 0
-        self._closers = 0
-        self._drained = threading.Event()
-        self._drained.set()
-
-    def start(self):
-        with self._gate:
-            if self._pending or self._closers:
-                raise RuntimeError('owned work is still pending')
-            self._accepting = True
-
-    def stop(self):
-        with self._gate:
-            self._accepting = False
-
-    async def close(self):
-        with self._gate:
-            self._accepting = False
-            self._closers += 1
-        try:
-            cancelled = False
-            while not self._drained.is_set():
-                try:
-                    await asyncio.sleep(.01)
-                except asyncio.CancelledError:
-                    cancelled = True
-            if cancelled:
-                raise asyncio.CancelledError
-        finally:
-            with self._gate:
-                self._closers -= 1
-
-    async def run(self, function, *args, **kwargs):
-        with self._gate:
-            if not self._accepting or not self._capacity.acquire(blocking=False):
-                raise self._unavailable()
-            self._pending += 1
-            self._drained.clear()
-        try:
-            return await run_owned_thread(function, *args, **kwargs)
-        finally:
-            with self._gate:
-                self._capacity.release()
-                self._pending -= 1
-                if not self._pending:
-                    self._drained.set()
+"""等待所属同步工作真实终态；内部取消也不能遗留仍读写资源的线程。"""
+import asyncio
+from functools import wraps
+from inspect import iscoroutinefunction, isasyncgenfunction, isgeneratorfunction
+import threading
+
+
+async def run_owned_thread(function, *args, **kwargs):
+    ownership = threading.Lock()
+    finished = threading.Event()
+    started = False
+    outcome = None
+
+    def abandon_unstarted(result):
+        nonlocal outcome
+        with ownership:
+            if not started and not finished.is_set():
+                outcome = result
+                finished.set()
+
+    def execute():
+        nonlocal started, outcome
+        with ownership:
+            if finished.is_set():
+                return
+            started = True
+        try:
+            result = (True, function(*args, **kwargs))
+        except BaseException as error:
+            # 同步异常作为数据交回；取消shield不暴露私有异常正文。
+            result = (False, error)
+        with ownership:
+            outcome = result
+            finished.set()
+
+    async def finish():
+        try:
+            await asyncio.to_thread(execute)
+        except asyncio.CancelledError:
+            raise
+        except BaseException as error:
+            abandon_unstarted((False, error))
+
+    coroutine = finish()
+    try:
+        task = asyncio.create_task(coroutine)
+    except BaseException:
+        coroutine.close()
+        raise
+
+    def consume(completed):
+        if completed.cancelled():
+            # 取消和线程启动竞争时，只有尚未开始的工作能被撤销。
+            abandon_unstarted((False, asyncio.CancelledError()))
+        else:
+            error = completed.exception()
+            if error is not None:
+                abandon_unstarted((False, error))
+    task.add_done_callback(consume)
+
+    cancelled = None
+    while not finished.is_set():
+        try:
+            if not task.done():
+                await asyncio.shield(task)
+            else:
+                # 内部task已取消但线程仍在运行，不占线程池等待其终态。
+                await asyncio.sleep(0.01)
+        except asyncio.CancelledError as error:
+            cancelled = error
+    with ownership:
+        succeeded, result = outcome
+    if cancelled is not None:
+        raise cancelled
+    if not succeeded:
+        raise result
+    return result
+
+
+class OwnedThreadGroup:
+    def __init__(self, capacity, unavailable):
+        if type(capacity) is not int or capacity < 1:
+            raise ValueError('invalid owned thread capacity')
+        self._capacity = threading.BoundedSemaphore(capacity)
+        self._unavailable = unavailable
+        self._gate = threading.Lock()
+        self._accepting = True
+        self._pending = 0
+        self._closers = 0
+        self._drained = threading.Event()
+        self._drained.set()
+
+    def start(self):
+        with self._gate:
+            if self._pending or self._closers:
+                raise RuntimeError('owned work is still pending')
+            self._accepting = True
+
+    def stop(self):
+        with self._gate:
+            self._accepting = False
+
+    async def close(self):
+        with self._gate:
+            self._accepting = False
+            self._closers += 1
+        try:
+            cancelled = False
+            while not self._drained.is_set():
+                try:
+                    await asyncio.sleep(.01)
+                except asyncio.CancelledError:
+                    cancelled = True
+            if cancelled:
+                raise asyncio.CancelledError
+        finally:
+            with self._gate:
+                self._closers -= 1
+
+    async def run(self, function, *args, **kwargs):
+        with self._gate:
+            if not self._accepting or not self._capacity.acquire(blocking=False):
+                raise self._unavailable()
+            self._pending += 1
+            self._drained.clear()
+        try:
+            return await run_owned_thread(function, *args, **kwargs)
+        finally:
+            with self._gate:
+                self._capacity.release()
+                self._pending -= 1
+                if not self._pending:
+                    self._drained.set()
+
+
+def owned_sync_endpoint(group):
+    def decorate(endpoint):
+        if iscoroutinefunction(endpoint) or isasyncgenfunction(endpoint) or isgeneratorfunction(endpoint):
+            raise TypeError('owned endpoint must be a synchronous function')
+        @wraps(endpoint)
+        async def invoke(*args, **kwargs):
+            return await group.run(endpoint, *args, **kwargs)
+        return invoke
+    return decorate

resource_work.py

@@ -3,7 +3,7 @@ import asyncio
 import logging
 
 from fastapi import HTTPException
-from owned_thread import OwnedThreadGroup
+from owned_thread import OwnedThreadGroup, owned_sync_endpoint
 
 MAX_RESOURCE_WRITES = 8
 MAX_RESOURCE_BACKGROUND = 2
@@ -82,6 +82,7 @@ class ResourceWork:
 
 _resource_work = ResourceWork()
 run_resource_write = _resource_work.run
+resource_write_endpoint = owned_sync_endpoint(_resource_work)
 start_resource_background = _resource_work.background
 start_resource_work = _resource_work.start
 stop_resource_work = _resource_work.stop

router_comments.py

@@ -1,126 +1,138 @@
-# router_comments.py
-from fastapi import APIRouter, HTTPException, Depends, Request
-import time
-import uuid
-from html import escape
-import 数据库连接 as db
-from comment_store import COMMENT_MAX_LENGTH, append_comment, delete_comment
-from notifications import add_notification
-from models import InteractionToggle, CommentCreate
-from 安全认证 import require_auth, is_admin
-
-# 🔒 频次限制（与 router_users_auth.py / router_wallet.py / router_prompts.py 同一写法）
-from rate_limit import shared_limit
-from db_utils import sort_cache
-
-router = APIRouter()
-
-@router.post("/api/interactions/toggle")
-@shared_limit(30)
-async def toggle_interaction(request: Request, interaction: InteractionToggle, current_user: str = Depends(require_auth)):
-    interaction.user_id = current_user  # 强制使用当前用户身份，防止伪造
-    
-    list_key = f"{interaction.action_type}d_by" 
-    count_key = "likes" if interaction.action_type == "like" else "favorites"
-    
-    # 使用闭包容器传递原子操作结果
-    result_container = {}
-    
-    def updater(items_db):
-        target_item = next((item for item in items_db if item["id"] == interaction.item_id), None)
-        if not target_item:
-            result_container["error"] = "目标存在问题"
-            return
-        
-        if list_key not in target_item:
-            target_item[list_key] = []
-        
-        user_list = target_item[list_key]
-        if interaction.is_active:
-            # 双重检查：防止并发重复添加
-            if interaction.user_id not in user_list:
-                user_list.append(interaction.user_id)
-        else:
-            if interaction.user_id in user_list:
-                user_list.remove(interaction.user_id)
-        
-        # 基于实际列表长度计算 count，即使并发重复也不会导致数量错误
-        target_item[count_key] = len(target_item[list_key])
-        result_container["count"] = target_item[count_key]
-        result_container["author"] = target_item.get("author", "")
-        result_container["item_id"] = target_item["id"]
-        result_container["title"] = target_item.get("title", "")
-    
-    db.atomic_update("items.json", updater, default_data=[])
-    
-    if result_container.get("error"):
-        raise HTTPException(status_code=404, detail=result_container["error"])
-
-    # 统一互动接口也会改变资源排序，成功提交后失效派生排序缓存。
-    sort_cache.invalidate("items:")
-    
-    # 通知在原子操作外发送（通知失败不影响主流程）
-    if interaction.is_active:
-        add_notification(result_container.get("author", ""), {"type": interaction.action_type, "from_user": interaction.user_id, "target_item_id": result_container["item_id"], "target_item_title": result_container["title"]})
-    
-    return {"status": "success", "new_count": result_container["count"]}
-
-@router.post("/api/comments")
-@shared_limit(10)  # 🔒 安全限流：防止刷评论洗版（正常用户不会一分钟发 10 条以上）
-async def post_comment(request: Request, comment: CommentCreate, current_user: str = Depends(require_auth)):
-    comment.author = current_user  # 强制使用认证用户身份，防止伪造
-    # 评论内容长度校验
-    if not comment.content or len(comment.content) > COMMENT_MAX_LENGTH:
-        raise HTTPException(status_code=400, detail="评论长度必须在1-5000字符之间")
-    # HTML 转义，防止 XSS
-    comment.content = escape(comment.content)
-    users_db = db.load_data("users.json", default_data={})
-    author_info = users_db.get(comment.author, {})
-    reply_name = users_db.get(comment.reply_to_user, {}).get("name", comment.reply_to_user) if comment.reply_to_user else None
-
-    new_comment = {
-        "id": f"c_{int(time.time())}_{uuid.uuid4().hex[:6]}", "author": comment.author, 
-        "authorName": author_info.get("name", comment.author), "avatar": author_info.get("avatarDataUrl", ""),
-        "content": comment.content, "replyToUser": comment.reply_to_user, "replyToUserName": reply_name,
-        "isDeleted": False, "replies": [], "created_at": int(time.time())
-    }
-    
-    notification = None
-    if comment.parent_id:
-        if comment.reply_to_user:
-            notification = (comment.reply_to_user, {"type": "reply", "from_user": comment.author, "target_item_id": comment.item_id, "target_item_title": "收到新的回复", "content": comment.content})
-    else: 
-        items_db = db.load_data("items.json", default_data=[])
-        posts_db = db.load_data("posts.json", default_data=[])
-        target_item = next((item for item in items_db if item["id"] == comment.item_id), None)
-        target_post = next((post for post in posts_db if post["id"] == comment.item_id), None)
-        if target_item:
-            notification = (target_item.get("author", ""), {"type": "comment", "from_user": comment.author, "target_item_id": comment.item_id, "target_item_title": target_item["title"], "content": comment.content})
-        elif target_post:
-            notification = (target_post.get("author", ""), {"type": "comment", "from_user": comment.author, "target_item_id": comment.item_id, "target_item_title": target_post.get("title", "") or "", "content": comment.content})
-        elif comment.item_id in users_db:
-            notification = (comment.item_id, {"type": "comment", "from_user": comment.author, "target_item_id": comment.item_id, "target_item_title": "您的个人留言板", "content": comment.content})
-
-    append_comment(comment.item_id, new_comment, parent_id=comment.parent_id)
-    if notification:
-        add_notification(*notification)
-    return {"status": "success", "data": new_comment}
-
-@router.delete("/api/comments/{item_id}/{comment_id}")
-@shared_limit(10)
-async def soft_delete_comment(request: Request, item_id: str, comment_id: str, account: str = Depends(require_auth)):
-    """
-    软删除评论
-    权限规则：评论作者可删除自己的评论，帖子/内容作者可删除其帖子下的评论，管理员可删除任何评论
-    """
-    items_db = db.load_data("items.json", default_data=[])
-    posts_db = db.load_data("posts.json", default_data=[])
-    users_db = db.load_data("users.json", default_data={})
-    tasks_db = db.load_data("tasks.json", default_data=[])
-    is_content_author = any(entry.get("id") == item_id and entry.get("author") == account
-                            for entry in posts_db + items_db)
-    is_content_author = is_content_author or any(entry.get("id") == item_id and entry.get("publisher") == account
-                                               for entry in tasks_db)
-    is_content_author = is_content_author or (item_id == account and item_id in users_db)
-    delete_comment(item_id, comment_id, account, can_moderate=is_content_author or is_admin(account))
-    return {"status": "success"}
+# router_comments.py
+from fastapi import APIRouter, HTTPException, Depends, Request
+import time
+import uuid
+from html import escape
+import 数据库连接 as db
+from comment_store import COMMENT_MAX_LENGTH, append_comment, delete_comment
+from notifications import add_notification
+from models import InteractionToggle, CommentCreate
+from 安全认证 import require_auth, is_admin
+
+# 🔒 频次限制（与 router_users_auth.py / router_wallet.py / router_prompts.py 同一写法）
+from rate_limit import shared_limit
+from db_utils import sort_cache
+from owned_thread import OwnedThreadGroup, owned_sync_endpoint
+
+MAX_COMMENT_WRITES = 8
+_comment_writes = OwnedThreadGroup(MAX_COMMENT_WRITES,
+    lambda: HTTPException(status_code=503, detail="评论数据暂不可用"))
+start_comment_writes = _comment_writes.start
+stop_comment_writes = _comment_writes.stop
+close_comment_writes = _comment_writes.close
+_comment_endpoint = owned_sync_endpoint(_comment_writes)
+
+router = APIRouter()
+
+@router.post("/api/interactions/toggle")
+@shared_limit(30)
+@_comment_endpoint
+def toggle_interaction(request: Request, interaction: InteractionToggle, current_user: str = Depends(require_auth)):
+    interaction.user_id = current_user  # 强制使用当前用户身份，防止伪造
+    
+    list_key = f"{interaction.action_type}d_by" 
+    count_key = "likes" if interaction.action_type == "like" else "favorites"
+    
+    # 使用闭包容器传递原子操作结果
+    result_container = {}
+    
+    def updater(items_db):
+        target_item = next((item for item in items_db if item["id"] == interaction.item_id), None)
+        if not target_item:
+            result_container["error"] = "目标存在问题"
+            return
+        
+        if list_key not in target_item:
+            target_item[list_key] = []
+        
+        user_list = target_item[list_key]
+        if interaction.is_active:
+            # 双重检查：防止并发重复添加
+            if interaction.user_id not in user_list:
+                user_list.append(interaction.user_id)
+        else:
+            if interaction.user_id in user_list:
+                user_list.remove(interaction.user_id)
+        
+        # 基于实际列表长度计算 count，即使并发重复也不会导致数量错误
+        target_item[count_key] = len(target_item[list_key])
+        result_container["count"] = target_item[count_key]
+        result_container["author"] = target_item.get("author", "")
+        result_container["item_id"] = target_item["id"]
+        result_container["title"] = target_item.get("title", "")
+    
+    db.atomic_update("items.json", updater, default_data=[])
+    
+    if result_container.get("error"):
+        raise HTTPException(status_code=404, detail=result_container["error"])
+
+    # 统一互动接口也会改变资源排序，成功提交后失效派生排序缓存。
+    sort_cache.invalidate("items:")
+    
+    # 通知在原子操作外发送（通知失败不影响主流程）
+    if interaction.is_active:
+        add_notification(result_container.get("author", ""), {"type": interaction.action_type, "from_user": interaction.user_id, "target_item_id": result_container["item_id"], "target_item_title": result_container["title"]})
+    
+    return {"status": "success", "new_count": result_container["count"]}
+
+@router.post("/api/comments")
+@shared_limit(10)  # 🔒 安全限流：防止刷评论洗版（正常用户不会一分钟发 10 条以上）
+@_comment_endpoint
+def post_comment(request: Request, comment: CommentCreate, current_user: str = Depends(require_auth)):
+    comment.author = current_user  # 强制使用认证用户身份，防止伪造
+    # 评论内容长度校验
+    if not comment.content or len(comment.content) > COMMENT_MAX_LENGTH:
+        raise HTTPException(status_code=400, detail="评论长度必须在1-5000字符之间")
+    # HTML 转义，防止 XSS
+    comment.content = escape(comment.content)
+    users_db = db.load_data("users.json", default_data={})
+    author_info = users_db.get(comment.author, {})
+    reply_name = users_db.get(comment.reply_to_user, {}).get("name", comment.reply_to_user) if comment.reply_to_user else None
+
+    new_comment = {
+        "id": f"c_{int(time.time())}_{uuid.uuid4().hex[:6]}", "author": comment.author, 
+        "authorName": author_info.get("name", comment.author), "avatar": author_info.get("avatarDataUrl", ""),
+        "content": comment.content, "replyToUser": comment.reply_to_user, "replyToUserName": reply_name,
+        "isDeleted": False, "replies": [], "created_at": int(time.time())
+    }
+    
+    notification = None
+    if comment.parent_id:
+        if comment.reply_to_user:
+            notification = (comment.reply_to_user, {"type": "reply", "from_user": comment.author, "target_item_id": comment.item_id, "target_item_title": "收到新的回复", "content": comment.content})
+    else: 
+        items_db = db.load_data("items.json", default_data=[])
+        posts_db = db.load_data("posts.json", default_data=[])
+        target_item = next((item for item in items_db if item["id"] == comment.item_id), None)
+        target_post = next((post for post in posts_db if post["id"] == comment.item_id), None)
+        if target_item:
+            notification = (target_item.get("author", ""), {"type": "comment", "from_user": comment.author, "target_item_id": comment.item_id, "target_item_title": target_item["title"], "content": comment.content})
+        elif target_post:
+            notification = (target_post.get("author", ""), {"type": "comment", "from_user": comment.author, "target_item_id": comment.item_id, "target_item_title": target_post.get("title", "") or "", "content": comment.content})
+        elif comment.item_id in users_db:
+            notification = (comment.item_id, {"type": "comment", "from_user": comment.author, "target_item_id": comment.item_id, "target_item_title": "您的个人留言板", "content": comment.content})
+
+    append_comment(comment.item_id, new_comment, parent_id=comment.parent_id)
+    if notification:
+        add_notification(*notification)
+    return {"status": "success", "data": new_comment}
+
+@router.delete("/api/comments/{item_id}/{comment_id}")
+@shared_limit(10)
+@_comment_endpoint
+def soft_delete_comment(request: Request, item_id: str, comment_id: str, account: str = Depends(require_auth)):
+    """
+    软删除评论
+    权限规则：评论作者可删除自己的评论，帖子/内容作者可删除其帖子下的评论，管理员可删除任何评论
+    """
+    items_db = db.load_data("items.json", default_data=[])
+    posts_db = db.load_data("posts.json", default_data=[])
+    users_db = db.load_data("users.json", default_data={})
+    tasks_db = db.load_data("tasks.json", default_data=[])
+    is_content_author = any(entry.get("id") == item_id and entry.get("author") == account
+                            for entry in posts_db + items_db)
+    is_content_author = is_content_author or any(entry.get("id") == item_id and entry.get("publisher") == account
+                                               for entry in tasks_db)
+    is_content_author = is_content_author or (item_id == account and item_id in users_db)
+    delete_comment(item_id, comment_id, account, can_moderate=is_content_author or is_admin(account))
+    return {"status": "success"}

router_items.py

@@ -1,4 +1,5 @@
-from resource_work import run_resource_write, start_resource_background
+from resource_work import run_resource_write, start_resource_background, resource_write_endpoint
+from owned_thread import OwnedThreadGroup, owned_sync_endpoint
 # router_items.py
 from fastapi import APIRouter, HTTPException, Depends, Request
 from rate_limit import shared_limit
@@ -22,6 +23,14 @@ from resource_store import publish_resource, published_response, edit_resource,
 from purchase_transaction import effective_resource_price
 from resource_deletion import delete_resource
 
+MAX_RESOURCE_READS = 16
+_resource_reads = OwnedThreadGroup(MAX_RESOURCE_READS,
+    lambda: HTTPException(status_code=503, detail="ranking_data_unavailable"))
+start_resource_reads = _resource_reads.start
+stop_resource_reads = _resource_reads.stop
+close_resource_reads = _resource_reads.close
+_resource_read_endpoint = owned_sync_endpoint(_resource_reads)
+
 router = APIRouter()
 
 def safe_str(val):
@@ -84,7 +93,8 @@ def get_last_6_months():
 data_file = "items.json"
 
 @router.get("/api/items")
-async def get_items(type: str = "tool", sort: str = "time", limit: int = 50): # 优化：默认限制调大至 50，提升前端列表体验
+@_resource_read_endpoint
+def get_items(type: str = "tool", sort: str = "time", limit: int = 50): # 优化：默认限制调大至 50，提升前端列表体验
     read_epoch = sort_cache.capture_read_epoch()
     items_db = read_public_source(db, "items.json", default_data=[])
     comments_db = read_public_source(db, "comments.json", default_data={})
@@ -177,7 +187,8 @@ def _build_creator_trend_data(account: str, u_items: list, months: list) -> dict
 
 
 @router.get("/api/creators/search")
-async def search_creators(keyword: str, sort: str = "downloads", limit: int = 50):
+@_resource_read_endpoint
+def search_creators(keyword: str, sort: str = "downloads", limit: int = 50):
     """
     搜索创作者
     根据关键词搜索创作者（name、account、shortDesc 不区分大小写子串匹配）
@@ -249,7 +260,8 @@ async def search_creators(keyword: str, sort: str = "downloads", limit: int = 50
 
 
 @router.get("/api/creators")
-async def get_creators(sort: str = "downloads", limit: int = 100):
+@_resource_read_endpoint
+def get_creators(sort: str = "downloads", limit: int = 100):
     """
     获取创作者列表
     🚀 P1性能优化：预构建 author->items 索引，避免 N+1 查询
@@ -311,7 +323,8 @@ async def get_creators(sort: str = "downloads", limit: int = 100):
 
 
 @router.get("/api/creators/{account}/details")
-async def get_creator_details(account: str):
+@_resource_read_endpoint
+def get_creator_details(account: str):
     """
     获取单个创作者的详细数据
     供前端展开卡片时按需加载
@@ -508,7 +521,8 @@ async def check_github_updates(request: Request, current_user: str = Depends(req
     }
 
 @router.get("/api/items/{item_id}")
-async def get_item_by_id(item_id: str):
+@_resource_read_endpoint
+def get_item_by_id(item_id: str):
     """根据ID获取单个资源的详细信息"""
     items_db = read_public_source(db, "items.json", default_data=[])
     comments_db = read_public_source(db, "comments.json", default_data={})
@@ -534,7 +548,8 @@ async def get_item_by_id(item_id: str):
     raise HTTPException(status_code=404, detail="资源不存在")
 
 @router.get("/api/item/{item_id}/version")
-async def get_item_version(item_id: str):
+@_resource_read_endpoint
+def get_item_version(item_id: str):
     """获取单个资源的最新版本号"""
     versions_db = read_public_source(db, "versions.json", default_data={})
     return {"status": "success", "version": _get_version_str(versions_db, item_id)}
@@ -555,7 +570,8 @@ async def delete_item(request: Request, item_id: str, current_user: str = Depend
 
 @router.post("/api/items/{item_id}/view")
 @shared_limit(60)
-async def record_item_view(request: Request, item_id: str, current_user: str = Depends(require_auth)):
+@resource_write_endpoint
+def record_item_view(request: Request, item_id: str, current_user: str = Depends(require_auth)):
     """
     记录资源访问量
     👁️ 需要用户认证，每个用户只计算一次总访问量，日访问量每次调用都增加
@@ -573,7 +589,8 @@ async def record_item_view(request: Request, item_id: str, current_user: str = D
 
 @router.post("/api/items/{item_id}/use")
 @shared_limit(30)
-async def record_item_use(request: Request, item_id: str, current_user: str = Depends(require_auth)):
+@resource_write_endpoint
+def record_item_use(request: Request, item_id: str, current_user: str = Depends(require_auth)):
     """
     记录资源使用量/下载量（原子操作，并发安全）
     📥 每个用户对同一资源只计一次，防止重复计数
@@ -618,7 +635,8 @@ async def record_item_use(request: Request, item_id: str, current_user: str = De
 
 @router.post("/api/items/{item_id}/rating")
 @shared_limit(20)
-async def rate_item(request: Request, item_id: str, payload: RatingRequest, current_user: str = Depends(require_auth)):
+@resource_write_endpoint
+def rate_item(request: Request, item_id: str, payload: RatingRequest, current_user: str = Depends(require_auth)):
     """
     为资源评分（原子操作，并发安全）
     ⭐ score: 1-5
@@ -693,7 +711,8 @@ async def rate_item(request: Request, item_id: str, payload: RatingRequest, curr
 
 @router.post("/api/items/{item_id}/like")
 @shared_limit(30)
-async def toggle_item_like(request: Request, item_id: str, current_user: str = Depends(require_auth)):
+@resource_write_endpoint
+def toggle_item_like(request: Request, item_id: str, current_user: str = Depends(require_auth)):
     """
     点赞/取消点赞（原子操作，并发安全）
     """
@@ -729,7 +748,8 @@ async def toggle_item_like(request: Request, item_id: str, current_user: str = D
 
 @router.post("/api/items/{item_id}/favorite")
 @shared_limit(30)
-async def toggle_item_favorite(request: Request, item_id: str, current_user: str = Depends(require_auth)):
+@resource_write_endpoint
+def toggle_item_favorite(request: Request, item_id: str, current_user: str = Depends(require_auth)):
     """
     收藏/取消收藏（原子操作，并发安全）
     """

router_posts.py

@@ -1,629 +1,648 @@
-from publication_identity import publication_identity
-# 云端Space代码/router_posts.py
-# ==========================================
-# 💬 讨论区API路由（小红书风格图文社区）
-# ==========================================
-# 功能：帖子发布、列表、详情、互动（点赞/收藏/评论/打赏）
-# ==========================================
-
-from fastapi import APIRouter, HTTPException, Depends, Request
-from sqlalchemy.orm import Session
-from models import PostCreate, PostUpdate, RatingRequest
-import 数据库连接 as db
-from comment_store import COMMENT_MAX_LENGTH, append_comment, increment_comment_count, attach_comment_counts, read_comment_view
-from 安全认证 import require_auth
-from db_utils import read_public_source, record_view, sort_cache
-from database_sql import get_db
-from models_sql import Wallet, Transaction
-from notifications import add_notification
-from tip_transaction import lock_tip_wallets
-from tip_store import run_tip_effect
-import time
-import asyncio
-from post_store import publish_post, edit_post, delete_post as remove_post, PostStoreError
-import uuid
-import hashlib
-import datetime
-import logging
-
-# 🔒 频次限制（与 router_users_auth.py / router_wallet.py / router_prompts.py 同一写法）
-from rate_limit import shared_limit
-
-router = APIRouter()
-
-
-async def _post_mutation(operation, *args):
-    try:
-        return await asyncio.to_thread(operation, *args)
-    except PostStoreError as error:
-        raise HTTPException(status_code=error.status_code, detail=error.message) from None
-
-
-def _invalidate_posts():
-    try:
-        sort_cache.invalidate("posts:")
-    except Exception as error:
-        logging.getLogger(__name__).warning("帖子排序缓存失效失败: error_type=%s", type(error).__name__)
-
-# ==========================================
-# 📝 帖子CRUD接口
-# ==========================================
-
-@router.get("/api/posts")
-async def get_posts(page: int = 1, limit: int = 20, sort: str = "latest"):
-    """
-    获取帖子列表（分页，支持多种排序方式）
-    - sort=latest: 按创建时间降序（默认）
-    - sort=likes: 按点赞数降序
-    - sort=favorites: 按收藏数降序
-    - sort=views: 按总访问量降序
-    - sort=daily_views: 按日访问量降序
-    - sort=tips: 按打赏总额降序
-    """
-    read_epoch = sort_cache.capture_read_epoch()
-    posts_db = read_public_source(db, "posts.json", default_data=[])
-    users_db = read_public_source(db, "users.json", default_data={})
-    
-    # users_db 已经是 {account: user_info} 格式，直接使用
-    user_map = users_db
-    
-    # 🗂️ 使用排序缓存优化排序性能
-    cache_sort = sort if sort in ("latest", "likes", "favorites", "views", "daily_views", "tips", "rating") else "latest"
-    cache_key = f"posts:{cache_sort}"
-    
-    def order_key(item):
-        if sort == "likes":
-            return item.get("likes", 0)
-        elif sort == "favorites":
-            return item.get("favorites", 0)
-        elif sort == "views":
-            return item.get("views", 0)
-        elif sort == "daily_views":
-            return item.get("daily_views", 0)
-        elif sort == "tips":
-            return sum(t.get("amount", 0) for t in item.get("tip_board", []))
-        elif sort == "rating":  # ⭐ 按评分排序
-            return (item.get("rating_avg", 0), item.get("rating_count", 0))
-        else:  # latest 或其他默认
-            return item.get("created_at", 0)
-
-    def sort_fn(data):
-        data.sort(key=order_key, reverse=True)
-    
-    sorted_posts = sort_cache.get_sorted(cache_key, posts_db, sort_fn, read_epoch=read_epoch, fresh=True)
-    
-    # 分页
-    start = (page - 1) * limit
-    end = start + limit
-    paged_posts = sorted_posts[start:end]
-    
-    # 附加作者信息，并过滤敏感字段
-    result = []
-    for post in paged_posts:
-        author_info = user_map.get(post.get("author"), {})
-        post_data = {
-            **post,
-            "author_name": author_info.get("name", post.get("author")),
-            "author_avatar": author_info.get("avatarDataUrl", "")
-        }
-        # 过滤敏感字段（列表接口仅过滤 viewed_by，保留 liked_by 和 favorited_by）
-        post_data.pop("viewed_by", None)
-        result.append(post_data)
-
-    attach_comment_counts(result)
-    return {
-        "status": "success",
-        "data": result,
-        "total": len(posts_db),
-        "page": page,
-        "limit": limit
-    }
-
-@router.get("/api/my-posts")
-async def get_my_posts(current_user: str = Depends(require_auth)):
-    """
-    获取我的帖子列表
-    """
-    posts_db = db.load_data("posts.json", default_data=[])
-    
-    # 筛选当前用户的帖子
-    my_posts = [p for p in posts_db if p.get("author") == current_user]
-    
-    # 按创建时间倒序
-    my_posts = sorted(my_posts, key=lambda x: x.get("created_at", 0), reverse=True)
-    
-    # 过滤敏感字段（列表接口仅过滤 viewed_by，保留 liked_by 和 favorited_by）
-    result = []
-    for post in my_posts:
-        post_data = dict(post)
-        post_data.pop("viewed_by", None)
-        result.append(post_data)
-
-    attach_comment_counts(result)
-    return {
-        "status": "success",
-        "data": result
-    }
-
-@router.get("/api/posts/{post_id}")
-async def get_post_detail(post_id: str):
-    """
-    获取帖子详情
-    """
-    posts_db = db.load_data("posts.json", default_data=[])
-    users_db = db.load_data("users.json", default_data={})
-    
-    # users_db 已经是 {account: user_info} 格式，直接使用
-    user_map = users_db
-    
-    for post in posts_db:
-        if post["id"] == post_id:
-            author_info = user_map.get(post.get("author"), {})
-            post_data = {
-                **post,
-                "author_name": author_info.get("name", post.get("author")),
-                "author_avatar": author_info.get("avatarDataUrl", "")
-            }
-            # 过滤敏感字段
-            post_data.pop("viewed_by", None)
-            attach_comment_counts([post_data])
-            return {
-                "status": "success",
-                "data": post_data
-            }
-    
-    raise HTTPException(status_code=404, detail="帖子不存在")
-
-@router.post("/api/posts")
-@shared_limit(5)  # 🔒 安全限流：防止刷帖洗版（一次发布含多图上传，但建帖只调一次）
-async def create_post(request: Request, post: PostCreate, current_user: str = Depends(require_auth)):
-    """
-    发布帖子
-    """
-    try:
-        stable_id = publication_identity('post', current_user, getattr(request, 'headers', {}).get('Idempotency-Key'))
-    except ValueError:
-        raise HTTPException(status_code=400, detail='发布请求身份无效') from None
-
-    # 限制图片数量
-    images = (post.images or [])[:9]
-    post_type = post.post_type if hasattr(post, "post_type") else "image"
-    video_url = post.video_url if hasattr(post, "video_url") else None
-    
-    # 视频帖：images 置为空列表
-    if post_type == "video":
-        images = []
-    
-    new_post = {
-        "id": stable_id or f"post_{int(time.time())}_{uuid.uuid4().hex}",
-        "title": post.title,
-        "content": post.content,
-        "cover_image": post.cover_image,
-        "images": images,
-        "author": current_user,
-        "created_at": int(time.time()),
-        "is_original": post.is_original if post.is_original is not None else False,  # 🎨 原创作品标记
-        "post_type": post_type,
-        "video_url": video_url,
-        # 互动数据
-        "likes": 0,
-        "favorites": 0,
-        "comments": 0,
-        "liked_by": [],
-        "favorited_by": [],
-        "tip_board": [],  # 打赏榜单
-        "views": 0,
-        "daily_views": 0,
-        "viewed_by": [],
-        "daily_views_date": "",
-        "rating_avg": 0.0,
-        "rating_count": 0,
-        "rating_dist": {"1": 0, "2": 0, "3": 0, "4": 0, "5": 0},
-        "rated_by": {}
-    }
-    
-    new_post = await _post_mutation(publish_post, db, new_post, stable_id is not None)
-    _invalidate_posts()
-    
-    return {"status": "success", "data": new_post}
-
-@router.put("/api/posts/{post_id}")
-@shared_limit(10)
-async def update_post(request: Request, post_id: str, update_data: PostUpdate, current_user: str = Depends(require_auth)):
-    """
-    更新帖子（仅作者可操作，原子操作，并发安全）
-    """
-    changes = {key: getattr(update_data, key) for key in (
-        "title", "content", "cover_image", "images", "is_original", "post_type", "video_url")}
-    await _post_mutation(edit_post, db, post_id, current_user, changes)
-    _invalidate_posts()
-    return {"status": "success"}
-
-@router.delete("/api/posts/{post_id}")
-@shared_limit(10)
-async def delete_post(request: Request, post_id: str, current_user: str = Depends(require_auth)):
-    """删除帖子；锁内确认最新作者，只删除目标主记录。"""
-    await _post_mutation(remove_post, db, post_id, current_user)
-    _invalidate_posts()
-    return {"status": "success"}
-
-# ==========================================
-# ❤️ 互动接口（点赞/收藏）
-# ==========================================
-
-@router.post("/api/posts/{post_id}/rating")
-@shared_limit(20)
-async def rate_post(request: Request, post_id: str, payload: RatingRequest, current_user: str = Depends(require_auth)):
-    """
-    为帖子评分（原子操作，并发安全）
-    ⭐ score: 1-5
-    """
-    score = payload.score
-    if score < 1 or score > 5:
-        raise HTTPException(status_code=400, detail="评分必须在1-5之间")
-    
-    result_container = [None]
-    
-    def updater(data):
-        for post in data:
-            if post["id"] == post_id:
-                # 禁止自评
-                if post.get("author") == current_user:
-                    result_container[0] = {"error": "self_rating"}
-                    return
-                # 初始化评分字段
-                if "rating_avg" not in post:
-                    post["rating_avg"] = 0.0
-                if "rating_count" not in post:
-                    post["rating_count"] = 0
-                if "rating_dist" not in post:
-                    post["rating_dist"] = {"1": 0, "2": 0, "3": 0, "4": 0, "5": 0}
-                if "rated_by" not in post:
-                    post["rated_by"] = {}
-                
-                rated_by = post["rated_by"]
-                rating_dist = post["rating_dist"]
-                old_score = None
-                if current_user in rated_by:
-                    old_score = rated_by[current_user]["score"]
-                
-                if old_score is not None:
-                    # 已评分，先减去旧分数分布
-                    rating_dist[str(old_score)] = max(0, rating_dist.get(str(old_score), 0) - 1)
-                    rating_dist[str(score)] = rating_dist.get(str(score), 0) + 1
-                else:
-                    # 未评分，增加计数
-                    post["rating_count"] = post.get("rating_count", 0) + 1
-                    rating_dist[str(score)] = rating_dist.get(str(score), 0) + 1
-                
-                rated_by[current_user] = {"score": score, "time": int(time.time())}
-                
-                # 重新计算平均分
-                total = sum(int(k) * v for k, v in rating_dist.items())
-                count = post["rating_count"]
-                post["rating_avg"] = round(total / count, 2) if count > 0 else 0.0
-                
-                result_container[0] = {
-                    "status": "success",
-                    "rating_avg": post["rating_avg"],
-                    "rating_count": post["rating_count"],
-                    "rating_dist": post["rating_dist"],
-                    "user_score": score
-                }
-                return
-        result_container[0] = None  # 未找到帖子
-    
-    db.atomic_update("posts.json", updater, default_data=[])
-    
-    if result_container[0] is None:
-        raise HTTPException(status_code=404, detail="帖子不存在")
-    if result_container[0].get("error") == "self_rating":
-        raise HTTPException(status_code=400, detail="不能给自己发布的帖子评分")
-    
-    # 🗂️ 清除排序缓存（评分变化可能影响排序）
-    sort_cache.invalidate("posts:")
-    
-    return result_container[0]
-
-
-@router.post("/api/posts/{post_id}/like")
-@shared_limit(30)
-async def toggle_like(request: Request, post_id: str, current_user: str = Depends(require_auth)):
-    """
-    点赞/取消点赞（原子操作，并发安全）
-    """
-    result_container = [None]
-    
-    def updater(data):
-        for post in data:
-            if post["id"] == post_id:
-                liked_by = post.get("liked_by", [])
-                if current_user in liked_by:
-                    liked_by.remove(current_user)
-                    post["likes"] = max(0, post.get("likes", 0) - 1)
-                    action = "unliked"
-                else:
-                    liked_by.append(current_user)
-                    post["likes"] = post.get("likes", 0) + 1
-                    action = "liked"
-                post["liked_by"] = liked_by
-                result_container[0] = {"status": "success", "action": action, "likes": post["likes"]}
-                return
-        result_container[0] = None  # 未找到帖子
-    
-    db.atomic_update("posts.json", updater, default_data=[])
-    
-    if result_container[0] is None:
-        raise HTTPException(status_code=404, detail="帖子不存在")
-    
-    # 🗂️ 清除排序缓存（点赞数变化可能影响排序）
-    sort_cache.invalidate("posts:")
-    
-    return result_container[0]
-
-@router.post("/api/posts/{post_id}/favorite")
-@shared_limit(30)
-async def toggle_favorite(request: Request, post_id: str, current_user: str = Depends(require_auth)):
-    """
-    收藏/取消收藏（原子操作，并发安全）
-    """
-    result_container = [None]
-    
-    def updater(data):
-        for post in data:
-            if post["id"] == post_id:
-                favorited_by = post.get("favorited_by", [])
-                if current_user in favorited_by:
-                    favorited_by.remove(current_user)
-                    post["favorites"] = max(0, post.get("favorites", 0) - 1)
-                    action = "unfavorited"
-                else:
-                    favorited_by.append(current_user)
-                    post["favorites"] = post.get("favorites", 0) + 1
-                    action = "favorited"
-                post["favorited_by"] = favorited_by
-                result_container[0] = {"status": "success", "action": action, "favorites": post["favorites"]}
-                return
-        result_container[0] = None  # 未找到帖子
-    
-    db.atomic_update("posts.json", updater, default_data=[])
-    
-    if result_container[0] is None:
-        raise HTTPException(status_code=404, detail="帖子不存在")
-    
-    # 🗂️ 清除排序缓存（收藏数变化可能影响排序）
-    sort_cache.invalidate("posts:")
-    
-    return result_container[0]
-
-# ==========================================
-# 🎁 打赏接口
-# ==========================================
-
-# 📝 审计日志
-logger = logging.getLogger("ComfyUI-Ranking.Posts")
-
-def calculate_tx_hash(tx_id, account, tx_type, amount, prev_hash):
-    data = f"{tx_id}{account}{tx_type}{amount}{prev_hash}"
-    return hashlib.sha256(data.encode()).hexdigest()
-
-@router.post("/api/posts/{post_id}/tip")
-@shared_limit(10)
-async def tip_post(request: Request, post_id: str, amount: int, is_anon: bool = False, current_user: str = Depends(require_auth), db_session: Session = Depends(get_db)):
-    """
-    打赏帖子（原子操作，并发安全）- 使用 SQL Wallet 系统
-    """
-    if amount <= 0:
-        raise HTTPException(status_code=400, detail="打赏金额必须大于0")
-    MAX_TIP_AMOUNT = 100000
-    if amount > MAX_TIP_AMOUNT:
-        raise HTTPException(status_code=400, detail=f"打赏金额必须在1-{MAX_TIP_AMOUNT}之间")
-    
-    # 🔒 P0数据修复（时序）：先只读校验 → SQL转账扣款 → 提交成功后再写打赏榜
-    # 避免余额不足/重复请求时榜单已被更新的数据不一致
-    posts_db_ro = db.load_data("posts.json", default_data=[])
-    target_post = next((p for p in posts_db_ro if p["id"] == post_id), None)
-    if not target_post:
-        raise HTTPException(status_code=404, detail="帖子不存在")
-    if target_post.get("author") == current_user:
-        raise HTTPException(status_code=400, detail="不能打赏自己的帖子")
-    author = target_post.get("author")
-    if not author:
-        raise HTTPException(status_code=404, detail="作者账户不存在")
-    post_title = target_post.get("title")
-    
-    # 💳 使用 SQL Wallet 系统处理余额转账（先扣款）
-    try:
-        
-        # 🔒 并发安全：使用悲观锁获取双方钱包
-        tipper_wallet, author_wallet = lock_tip_wallets(db_session, current_user, author)
-        # 🔒 P1幂等性防护：检查最近5秒内是否存在相同交易
-        recent_cutoff = datetime.datetime.utcnow() - datetime.timedelta(seconds=5)
-        duplicate_tx = db_session.query(Transaction).filter(
-            Transaction.account == current_user,
-            Transaction.tx_type == "TIP_OUT",
-            Transaction.amount == -amount,
-            Transaction.related_account == author,
-            Transaction.item_id == post_id,
-            Transaction.item_type == "post",
-            Transaction.created_at >= recent_cutoff
-        ).with_for_update().first()
-        if duplicate_tx:
-            db_session.rollback()  # 重复请求释放锁，不执行任何后续操作
-            return {"status": "success", "message": "打赏已处理（重复请求）"}
-        
-        if not tipper_wallet or tipper_wallet.balance < amount:
-            raise HTTPException(status_code=400, detail="余额不足")
-
-        
-        # 执行转账
-        tipper_wallet.balance -= amount
-        author_wallet.balance += amount         # 实际收入进统一余额
-        author_wallet.tip_balance += amount     # 累计打赏收益统计（只增不减）
-        
-        # 创建交易记录
-        tx_id_tipper = f"TIP_OUT_{int(time.time())}_{uuid.uuid4().hex[:6]}"
-        tx_id_author = f"TIP_IN_{int(time.time())}_{uuid.uuid4().hex[:6]}"
-        
-        # 获取最后交易记录的哈希
-        last_tx_tipper = db_session.query(Transaction).filter(Transaction.account == current_user).order_by(Transaction.created_at.desc()).first()
-        last_tx_author = db_session.query(Transaction).filter(Transaction.account == author).order_by(Transaction.created_at.desc()).first()
-        prev_hash_tipper = last_tx_tipper.tx_hash if last_tx_tipper else "GENESIS_HASH"
-        prev_hash_author = last_tx_author.tx_hash if last_tx_author else "GENESIS_HASH"
-        
-        # 获取用户信息（post_title 已在预校验阶段取得）
-        users_db = db.load_data("users.json", default_data={})
-        author_info = users_db.get(author, {})
-        tipper_info = users_db.get(current_user, {})
-        author_name = author_info.get("name", author)
-        tipper_name = tipper_info.get("name", current_user)
-        
-        # 打赏方交易记录 (TIP_OUT)
-        tx_tipper = Transaction(
-            tx_id=tx_id_tipper,
-            account=current_user,
-            tx_type="TIP_OUT",
-            amount=-amount,
-            related_account=author,
-            item_id=post_id,
-            prev_hash=prev_hash_tipper,
-            tx_hash=calculate_tx_hash(tx_id_tipper, current_user, "TIP_OUT", -amount, prev_hash_tipper),
-            description=f"打赏给 {author_name}" + (f" 的帖子《{post_title}》" if post_title else ""),
-            item_title=post_title,
-            item_type="post",
-            related_user_name=author_name
-        )
-        
-        # 接收方交易记录 (TIP_IN)
-        tx_author = Transaction(
-            tx_id=tx_id_author,
-            account=author,
-            tx_type="TIP_IN",
-            amount=amount,
-            related_account=current_user,
-            item_id=post_id,
-            prev_hash=prev_hash_author,
-            tx_hash=calculate_tx_hash(tx_id_author, author, "TIP_IN", amount, prev_hash_author),
-            description=f"收到 {tipper_name} 的帖子打赏" + (f" ({post_title})" if post_title else ""),
-            item_title=post_title,
-            item_type="post",
-            related_user_name=tipper_name if not is_anon else "匿名用户"
-        )
-        
-        db_session.add(tx_tipper)
-        db_session.add(tx_author)
-        db_session.commit()
-        
-        # 📝 审计日志
-        logger.info("POST_TIP")
-        
-    except HTTPException:
-        db_session.rollback()
-        raise
-    except Exception as e:
-        db_session.rollback()
-        logger.error("POST_TIP_ERROR | error_type=%s", type(e).__name__)
-        raise HTTPException(status_code=500, detail="打赏处理失败，请稍后重试")
-    
-    def notify_tip():
-        # 🔔 打赏通知（考虑匿名）
-        if not is_anon:
-            add_notification(author, {
-                "type": "tip",
-                "from_user": current_user,
-                "target_item_id": post_id,
-                "target_item_title": post_title or "",
-                "content": f"您收到来自 {tipper_name} 的 {amount} 积分帖子打赏"
-            })
-        else:
-            add_notification(author, {
-                "type": "tip",
-                "from_user": "anonymous",
-                "target_item_id": post_id,
-                "target_item_title": "",
-                "content": f"您收到了一份 {amount} 积分的匿名帖子打赏"
-            })
-    
-    run_tip_effect(notify_tip)
-    run_tip_effect(lambda: sort_cache.invalidate("posts:"))
-
-    # 🏆 扣款成功后再写打赏榜（写榜失败仅记录日志，不影响资金安全）
-    def board_updater(data):
-        for post in data:
-            if post["id"] == post_id:
-                tip_board = post.get("tip_board", [])
-                existing = next((t for t in tip_board if t["account"] == current_user), None)
-                if existing:
-                    existing["amount"] += amount
-                else:
-                    tip_board.append({"account": current_user, "amount": amount, "is_anon": is_anon})
-                tip_board.sort(key=lambda x: x["amount"], reverse=True)
-                post["tip_board"] = tip_board
-                break
-    
-    try:
-        db.atomic_update("posts.json", board_updater, default_data=[])
-    except Exception as e:
-        logger.error("POST_TIP_BOARD_ERROR | error_type=%s", type(e).__name__)
-    
-    return {"status": "success", "message": f"成功打赏 {amount} 积分"}
-
-# ==========================================
-# 💬 评论接口（复用通用评论系统）
-# ==========================================
-
-@router.get("/api/posts/{post_id}/comments")
-async def get_post_comments(post_id: str):
-    """获取评论；有界后台读取并保留原作者附加字段。"""
-    return {"status": "success", "data": await read_comment_view(post_id)}
-
-@router.post("/api/posts/{post_id}/comments")
-@shared_limit(10)
-async def add_post_comment(request: Request, post_id: str, content: str, current_user: str = Depends(require_auth)):
-    """
-    添加帖子评论
-    """
-    if not content or not content.strip():
-        raise HTTPException(status_code=400, detail="评论内容不能为空")
-    if len(content) > COMMENT_MAX_LENGTH:
-        raise HTTPException(status_code=400, detail="评论长度必须在1-5000字符之间")
-    
-    posts_db = db.load_data("posts.json", default_data=[])
-    
-    # 检查帖子是否存在
-    post_exists = any(p["id"] == post_id for p in posts_db)
-    if not post_exists:
-        raise HTTPException(status_code=404, detail="帖子不存在")
-    
-    new_comment = {
-        "id": f"comment_{int(time.time())}_{uuid.uuid4().hex[:6]}",
-        "author": current_user,
-        "content": content.strip(),
-        "created_at": int(time.time())
-    }
-    
-    append_comment(post_id, new_comment, prepend=True)
-    increment_comment_count("posts.json", post_id)
-
-    # 🗂️ 清除排序缓存（评论数变化可能影响排序）
-    sort_cache.invalidate("posts:")
-    
-    return {"status": "success", "data": new_comment}
-
-
-@router.post("/api/posts/{post_id}/view")
-@shared_limit(60)
-async def record_post_view(request: Request, post_id: str, current_user: str = Depends(require_auth)):
-    """
-    记录帖子访问量
-    👁️ 需要用户认证，每个用户只计算一次总访问量，日访问量每次调用都增加
-    """
-    result = record_view("posts.json", post_id, current_user)
-    
-    if result is None:
-        raise HTTPException(status_code=404, detail="帖子不存在")
-    
-    # 🗂️ 清除排序缓存（浏览量变化可能影响排序）
-    sort_cache.invalidate("posts:")
-    
-    return {"status": "success", "views": result["views"], "daily_views": result["daily_views"]}
+from publication_identity import publication_identity
+# 云端Space代码/router_posts.py
+# ==========================================
+# 💬 讨论区API路由（小红书风格图文社区）
+# ==========================================
+# 功能：帖子发布、列表、详情、互动（点赞/收藏/评论/打赏）
+# ==========================================
+
+from fastapi import APIRouter, HTTPException, Depends, Request
+from sqlalchemy.orm import Session
+from models import PostCreate, PostUpdate, RatingRequest
+import 数据库连接 as db
+from comment_store import COMMENT_MAX_LENGTH, append_comment, increment_comment_count, attach_comment_counts, read_comment_view
+from 安全认证 import require_auth
+from db_utils import read_public_source, record_view, sort_cache
+from database_sql import get_db
+from models_sql import Wallet, Transaction
+from notifications import add_notification
+from tip_transaction import lock_tip_wallets
+from tip_store import run_tip_effect
+import time
+from owned_thread import OwnedThreadGroup, owned_sync_endpoint
+from post_store import publish_post, edit_post, delete_post as remove_post, PostStoreError
+import uuid
+import hashlib
+import datetime
+import logging
+
+# 🔒 频次限制（与 router_users_auth.py / router_wallet.py / router_prompts.py 同一写法）
+from rate_limit import shared_limit
+
+MAX_POSTS_IO = 16
+_posts_io = OwnedThreadGroup(MAX_POSTS_IO,
+    lambda: HTTPException(status_code=503, detail="帖子数据暂不可用"))
+start_posts_io = _posts_io.start
+stop_posts_io = _posts_io.stop
+close_posts_io = _posts_io.close
+_posts_endpoint = owned_sync_endpoint(_posts_io)
+
+router = APIRouter()
+
+
+def _post_mutation(operation, *args):
+    try:
+        return operation(*args)
+    except PostStoreError as error:
+        raise HTTPException(status_code=error.status_code, detail=error.message) from None
+
+
+def _invalidate_posts():
+    try:
+        sort_cache.invalidate("posts:")
+    except Exception as error:
+        logging.getLogger(__name__).warning("帖子排序缓存失效失败: error_type=%s", type(error).__name__)
+
+# ==========================================
+# 📝 帖子CRUD接口
+# ==========================================
+
+@router.get("/api/posts")
+@_posts_endpoint
+def get_posts(page: int = 1, limit: int = 20, sort: str = "latest"):
+    """
+    获取帖子列表（分页，支持多种排序方式）
+    - sort=latest: 按创建时间降序（默认）
+    - sort=likes: 按点赞数降序
+    - sort=favorites: 按收藏数降序
+    - sort=views: 按总访问量降序
+    - sort=daily_views: 按日访问量降序
+    - sort=tips: 按打赏总额降序
+    """
+    read_epoch = sort_cache.capture_read_epoch()
+    posts_db = read_public_source(db, "posts.json", default_data=[])
+    users_db = read_public_source(db, "users.json", default_data={})
+    
+    # users_db 已经是 {account: user_info} 格式，直接使用
+    user_map = users_db
+    
+    # 🗂️ 使用排序缓存优化排序性能
+    cache_sort = sort if sort in ("latest", "likes", "favorites", "views", "daily_views", "tips", "rating") else "latest"
+    cache_key = f"posts:{cache_sort}"
+    
+    def order_key(item):
+        if sort == "likes":
+            return item.get("likes", 0)
+        elif sort == "favorites":
+            return item.get("favorites", 0)
+        elif sort == "views":
+            return item.get("views", 0)
+        elif sort == "daily_views":
+            return item.get("daily_views", 0)
+        elif sort == "tips":
+            return sum(t.get("amount", 0) for t in item.get("tip_board", []))
+        elif sort == "rating":  # ⭐ 按评分排序
+            return (item.get("rating_avg", 0), item.get("rating_count", 0))
+        else:  # latest 或其他默认
+            return item.get("created_at", 0)
+
+    def sort_fn(data):
+        data.sort(key=order_key, reverse=True)
+    
+    sorted_posts = sort_cache.get_sorted(cache_key, posts_db, sort_fn, read_epoch=read_epoch, fresh=True)
+    
+    # 分页
+    start = (page - 1) * limit
+    end = start + limit
+    paged_posts = sorted_posts[start:end]
+    
+    # 附加作者信息，并过滤敏感字段
+    result = []
+    for post in paged_posts:
+        author_info = user_map.get(post.get("author"), {})
+        post_data = {
+            **post,
+            "author_name": author_info.get("name", post.get("author")),
+            "author_avatar": author_info.get("avatarDataUrl", "")
+        }
+        # 过滤敏感字段（列表接口仅过滤 viewed_by，保留 liked_by 和 favorited_by）
+        post_data.pop("viewed_by", None)
+        result.append(post_data)
+
+    attach_comment_counts(result)
+    return {
+        "status": "success",
+        "data": result,
+        "total": len(posts_db),
+        "page": page,
+        "limit": limit
+    }
+
+@router.get("/api/my-posts")
+@_posts_endpoint
+def get_my_posts(current_user: str = Depends(require_auth)):
+    """
+    获取我的帖子列表
+    """
+    posts_db = db.load_data("posts.json", default_data=[])
+    
+    # 筛选当前用户的帖子
+    my_posts = [p for p in posts_db if p.get("author") == current_user]
+    
+    # 按创建时间倒序
+    my_posts = sorted(my_posts, key=lambda x: x.get("created_at", 0), reverse=True)
+    
+    # 过滤敏感字段（列表接口仅过滤 viewed_by，保留 liked_by 和 favorited_by）
+    result = []
+    for post in my_posts:
+        post_data = dict(post)
+        post_data.pop("viewed_by", None)
+        result.append(post_data)
+
+    attach_comment_counts(result)
+    return {
+        "status": "success",
+        "data": result
+    }
+
+@router.get("/api/posts/{post_id}")
+@_posts_endpoint
+def get_post_detail(post_id: str):
+    """
+    获取帖子详情
+    """
+    posts_db = db.load_data("posts.json", default_data=[])
+    users_db = db.load_data("users.json", default_data={})
+    
+    # users_db 已经是 {account: user_info} 格式，直接使用
+    user_map = users_db
+    
+    for post in posts_db:
+        if post["id"] == post_id:
+            author_info = user_map.get(post.get("author"), {})
+            post_data = {
+                **post,
+                "author_name": author_info.get("name", post.get("author")),
+                "author_avatar": author_info.get("avatarDataUrl", "")
+            }
+            # 过滤敏感字段
+            post_data.pop("viewed_by", None)
+            attach_comment_counts([post_data])
+            return {
+                "status": "success",
+                "data": post_data
+            }
+    
+    raise HTTPException(status_code=404, detail="帖子不存在")
+
+@router.post("/api/posts")
+@shared_limit(5)  # 🔒 安全限流：防止刷帖洗版（一次发布含多图上传，但建帖只调一次）
+@_posts_endpoint
+def create_post(request: Request, post: PostCreate, current_user: str = Depends(require_auth)):
+    """
+    发布帖子
+    """
+    try:
+        stable_id = publication_identity('post', current_user, getattr(request, 'headers', {}).get('Idempotency-Key'))
+    except ValueError:
+        raise HTTPException(status_code=400, detail='发布请求身份无效') from None
+
+    # 限制图片数量
+    images = (post.images or [])[:9]
+    post_type = post.post_type if hasattr(post, "post_type") else "image"
+    video_url = post.video_url if hasattr(post, "video_url") else None
+    
+    # 视频帖：images 置为空列表
+    if post_type == "video":
+        images = []
+    
+    new_post = {
+        "id": stable_id or f"post_{int(time.time())}_{uuid.uuid4().hex}",
+        "title": post.title,
+        "content": post.content,
+        "cover_image": post.cover_image,
+        "images": images,
+        "author": current_user,
+        "created_at": int(time.time()),
+        "is_original": post.is_original if post.is_original is not None else False,  # 🎨 原创作品标记
+        "post_type": post_type,
+        "video_url": video_url,
+        # 互动数据
+        "likes": 0,
+        "favorites": 0,
+        "comments": 0,
+        "liked_by": [],
+        "favorited_by": [],
+        "tip_board": [],  # 打赏榜单
+        "views": 0,
+        "daily_views": 0,
+        "viewed_by": [],
+        "daily_views_date": "",
+        "rating_avg": 0.0,
+        "rating_count": 0,
+        "rating_dist": {"1": 0, "2": 0, "3": 0, "4": 0, "5": 0},
+        "rated_by": {}
+    }
+    
+    new_post = _post_mutation(publish_post, db, new_post, stable_id is not None)
+    _invalidate_posts()
+    
+    return {"status": "success", "data": new_post}
+
+@router.put("/api/posts/{post_id}")
+@shared_limit(10)
+@_posts_endpoint
+def update_post(request: Request, post_id: str, update_data: PostUpdate, current_user: str = Depends(require_auth)):
+    """
+    更新帖子（仅作者可操作，原子操作，并发安全）
+    """
+    changes = {key: getattr(update_data, key) for key in (
+        "title", "content", "cover_image", "images", "is_original", "post_type", "video_url")}
+    _post_mutation(edit_post, db, post_id, current_user, changes)
+    _invalidate_posts()
+    return {"status": "success"}
+
+@router.delete("/api/posts/{post_id}")
+@shared_limit(10)
+@_posts_endpoint
+def delete_post(request: Request, post_id: str, current_user: str = Depends(require_auth)):
+    """删除帖子；锁内确认最新作者，只删除目标主记录。"""
+    _post_mutation(remove_post, db, post_id, current_user)
+    _invalidate_posts()
+    return {"status": "success"}
+
+# ==========================================
+# ❤️ 互动接口（点赞/收藏）
+# ==========================================
+
+@router.post("/api/posts/{post_id}/rating")
+@shared_limit(20)
+@_posts_endpoint
+def rate_post(request: Request, post_id: str, payload: RatingRequest, current_user: str = Depends(require_auth)):
+    """
+    为帖子评分（原子操作，并发安全）
+    ⭐ score: 1-5
+    """
+    score = payload.score
+    if score < 1 or score > 5:
+        raise HTTPException(status_code=400, detail="评分必须在1-5之间")
+    
+    result_container = [None]
+    
+    def updater(data):
+        for post in data:
+            if post["id"] == post_id:
+                # 禁止自评
+                if post.get("author") == current_user:
+                    result_container[0] = {"error": "self_rating"}
+                    return
+                # 初始化评分字段
+                if "rating_avg" not in post:
+                    post["rating_avg"] = 0.0
+                if "rating_count" not in post:
+                    post["rating_count"] = 0
+                if "rating_dist" not in post:
+                    post["rating_dist"] = {"1": 0, "2": 0, "3": 0, "4": 0, "5": 0}
+                if "rated_by" not in post:
+                    post["rated_by"] = {}
+                
+                rated_by = post["rated_by"]
+                rating_dist = post["rating_dist"]
+                old_score = None
+                if current_user in rated_by:
+                    old_score = rated_by[current_user]["score"]
+                
+                if old_score is not None:
+                    # 已评分，先减去旧分数分布
+                    rating_dist[str(old_score)] = max(0, rating_dist.get(str(old_score), 0) - 1)
+                    rating_dist[str(score)] = rating_dist.get(str(score), 0) + 1
+                else:
+                    # 未评分，增加计数
+                    post["rating_count"] = post.get("rating_count", 0) + 1
+                    rating_dist[str(score)] = rating_dist.get(str(score), 0) + 1
+                
+                rated_by[current_user] = {"score": score, "time": int(time.time())}
+                
+                # 重新计算平均分
+                total = sum(int(k) * v for k, v in rating_dist.items())
+                count = post["rating_count"]
+                post["rating_avg"] = round(total / count, 2) if count > 0 else 0.0
+                
+                result_container[0] = {
+                    "status": "success",
+                    "rating_avg": post["rating_avg"],
+                    "rating_count": post["rating_count"],
+                    "rating_dist": post["rating_dist"],
+                    "user_score": score
+                }
+                return
+        result_container[0] = None  # 未找到帖子
+    
+    db.atomic_update("posts.json", updater, default_data=[])
+    
+    if result_container[0] is None:
+        raise HTTPException(status_code=404, detail="帖子不存在")
+    if result_container[0].get("error") == "self_rating":
+        raise HTTPException(status_code=400, detail="不能给自己发布的帖子评分")
+    
+    # 🗂️ 清除排序缓存（评分变化可能影响排序）
+    sort_cache.invalidate("posts:")
+    
+    return result_container[0]
+
+
+@router.post("/api/posts/{post_id}/like")
+@shared_limit(30)
+@_posts_endpoint
+def toggle_like(request: Request, post_id: str, current_user: str = Depends(require_auth)):
+    """
+    点赞/取消点赞（原子操作，并发安全）
+    """
+    result_container = [None]
+    
+    def updater(data):
+        for post in data:
+            if post["id"] == post_id:
+                liked_by = post.get("liked_by", [])
+                if current_user in liked_by:
+                    liked_by.remove(current_user)
+                    post["likes"] = max(0, post.get("likes", 0) - 1)
+                    action = "unliked"
+                else:
+                    liked_by.append(current_user)
+                    post["likes"] = post.get("likes", 0) + 1
+                    action = "liked"
+                post["liked_by"] = liked_by
+                result_container[0] = {"status": "success", "action": action, "likes": post["likes"]}
+                return
+        result_container[0] = None  # 未找到帖子
+    
+    db.atomic_update("posts.json", updater, default_data=[])
+    
+    if result_container[0] is None:
+        raise HTTPException(status_code=404, detail="帖子不存在")
+    
+    # 🗂️ 清除排序缓存（点赞数变化可能影响排序）
+    sort_cache.invalidate("posts:")
+    
+    return result_container[0]
+
+@router.post("/api/posts/{post_id}/favorite")
+@shared_limit(30)
+@_posts_endpoint
+def toggle_favorite(request: Request, post_id: str, current_user: str = Depends(require_auth)):
+    """
+    收藏/取消收藏（原子操作，并发安全）
+    """
+    result_container = [None]
+    
+    def updater(data):
+        for post in data:
+            if post["id"] == post_id:
+                favorited_by = post.get("favorited_by", [])
+                if current_user in favorited_by:
+                    favorited_by.remove(current_user)
+                    post["favorites"] = max(0, post.get("favorites", 0) - 1)
+                    action = "unfavorited"
+                else:
+                    favorited_by.append(current_user)
+                    post["favorites"] = post.get("favorites", 0) + 1
+                    action = "favorited"
+                post["favorited_by"] = favorited_by
+                result_container[0] = {"status": "success", "action": action, "favorites": post["favorites"]}
+                return
+        result_container[0] = None  # 未找到帖子
+    
+    db.atomic_update("posts.json", updater, default_data=[])
+    
+    if result_container[0] is None:
+        raise HTTPException(status_code=404, detail="帖子不存在")
+    
+    # 🗂️ 清除排序缓存（收藏数变化可能影响排序）
+    sort_cache.invalidate("posts:")
+    
+    return result_container[0]
+
+# ==========================================
+# 🎁 打赏接口
+# ==========================================
+
+# 📝 审计日志
+logger = logging.getLogger("ComfyUI-Ranking.Posts")
+
+def calculate_tx_hash(tx_id, account, tx_type, amount, prev_hash):
+    data = f"{tx_id}{account}{tx_type}{amount}{prev_hash}"
+    return hashlib.sha256(data.encode()).hexdigest()
+
+@router.post("/api/posts/{post_id}/tip")
+@shared_limit(10)
+async def tip_post(request: Request, post_id: str, amount: int, is_anon: bool = False, current_user: str = Depends(require_auth), db_session: Session = Depends(get_db)):
+    """
+    打赏帖子（原子操作，并发安全）- 使用 SQL Wallet 系统
+    """
+    if amount <= 0:
+        raise HTTPException(status_code=400, detail="打赏金额必须大于0")
+    MAX_TIP_AMOUNT = 100000
+    if amount > MAX_TIP_AMOUNT:
+        raise HTTPException(status_code=400, detail=f"打赏金额必须在1-{MAX_TIP_AMOUNT}之间")
+    
+    # 🔒 P0数据修复（时序）：先只读校验 → SQL转账扣款 → 提交成功后再写打赏榜
+    # 避免余额不足/重复请求时榜单已被更新的数据不一致
+    posts_db_ro = db.load_data("posts.json", default_data=[])
+    target_post = next((p for p in posts_db_ro if p["id"] == post_id), None)
+    if not target_post:
+        raise HTTPException(status_code=404, detail="帖子不存在")
+    if target_post.get("author") == current_user:
+        raise HTTPException(status_code=400, detail="不能打赏自己的帖子")
+    author = target_post.get("author")
+    if not author:
+        raise HTTPException(status_code=404, detail="作者账户不存在")
+    post_title = target_post.get("title")
+    
+    # 💳 使用 SQL Wallet 系统处理余额转账（先扣款）
+    try:
+        
+        # 🔒 并发安全：使用悲观锁获取双方钱包
+        tipper_wallet, author_wallet = lock_tip_wallets(db_session, current_user, author)
+        # 🔒 P1幂等性防护：检查最近5秒内是否存在相同交易
+        recent_cutoff = datetime.datetime.utcnow() - datetime.timedelta(seconds=5)
+        duplicate_tx = db_session.query(Transaction).filter(
+            Transaction.account == current_user,
+            Transaction.tx_type == "TIP_OUT",
+            Transaction.amount == -amount,
+            Transaction.related_account == author,
+            Transaction.item_id == post_id,
+            Transaction.item_type == "post",
+            Transaction.created_at >= recent_cutoff
+        ).with_for_update().first()
+        if duplicate_tx:
+            db_session.rollback()  # 重复请求释放锁，不执行任何后续操作
+            return {"status": "success", "message": "打赏已处理（重复请求）"}
+        
+        if not tipper_wallet or tipper_wallet.balance < amount:
+            raise HTTPException(status_code=400, detail="余额不足")
+
+        
+        # 执行转账
+        tipper_wallet.balance -= amount
+        author_wallet.balance += amount         # 实际收入进统一余额
+        author_wallet.tip_balance += amount     # 累计打赏收益统计（只增不减）
+        
+        # 创建交易记录
+        tx_id_tipper = f"TIP_OUT_{int(time.time())}_{uuid.uuid4().hex[:6]}"
+        tx_id_author = f"TIP_IN_{int(time.time())}_{uuid.uuid4().hex[:6]}"
+        
+        # 获取最后交易记录的哈希
+        last_tx_tipper = db_session.query(Transaction).filter(Transaction.account == current_user).order_by(Transaction.created_at.desc()).first()
+        last_tx_author = db_session.query(Transaction).filter(Transaction.account == author).order_by(Transaction.created_at.desc()).first()
+        prev_hash_tipper = last_tx_tipper.tx_hash if last_tx_tipper else "GENESIS_HASH"
+        prev_hash_author = last_tx_author.tx_hash if last_tx_author else "GENESIS_HASH"
+        
+        # 获取用户信息（post_title 已在预校验阶段取得）
+        users_db = db.load_data("users.json", default_data={})
+        author_info = users_db.get(author, {})
+        tipper_info = users_db.get(current_user, {})
+        author_name = author_info.get("name", author)
+        tipper_name = tipper_info.get("name", current_user)
+        
+        # 打赏方交易记录 (TIP_OUT)
+        tx_tipper = Transaction(
+            tx_id=tx_id_tipper,
+            account=current_user,
+            tx_type="TIP_OUT",
+            amount=-amount,
+            related_account=author,
+            item_id=post_id,
+            prev_hash=prev_hash_tipper,
+            tx_hash=calculate_tx_hash(tx_id_tipper, current_user, "TIP_OUT", -amount, prev_hash_tipper),
+            description=f"打赏给 {author_name}" + (f" 的帖子《{post_title}》" if post_title else ""),
+            item_title=post_title,
+            item_type="post",
+            related_user_name=author_name
+        )
+        
+        # 接收方交易记录 (TIP_IN)
+        tx_author = Transaction(
+            tx_id=tx_id_author,
+            account=author,
+            tx_type="TIP_IN",
+            amount=amount,
+            related_account=current_user,
+            item_id=post_id,
+            prev_hash=prev_hash_author,
+            tx_hash=calculate_tx_hash(tx_id_author, author, "TIP_IN", amount, prev_hash_author),
+            description=f"收到 {tipper_name} 的帖子打赏" + (f" ({post_title})" if post_title else ""),
+            item_title=post_title,
+            item_type="post",
+            related_user_name=tipper_name if not is_anon else "匿名用户"
+        )
+        
+        db_session.add(tx_tipper)
+        db_session.add(tx_author)
+        db_session.commit()
+        
+        # 📝 审计日志
+        logger.info("POST_TIP")
+        
+    except HTTPException:
+        db_session.rollback()
+        raise
+    except Exception as e:
+        db_session.rollback()
+        logger.error("POST_TIP_ERROR | error_type=%s", type(e).__name__)
+        raise HTTPException(status_code=500, detail="打赏处理失败，请稍后重试")
+    
+    def notify_tip():
+        # 🔔 打赏通知（考虑匿名）
+        if not is_anon:
+            add_notification(author, {
+                "type": "tip",
+                "from_user": current_user,
+                "target_item_id": post_id,
+                "target_item_title": post_title or "",
+                "content": f"您收到来自 {tipper_name} 的 {amount} 积分帖子打赏"
+            })
+        else:
+            add_notification(author, {
+                "type": "tip",
+                "from_user": "anonymous",
+                "target_item_id": post_id,
+                "target_item_title": "",
+                "content": f"您收到了一份 {amount} 积分的匿名帖子打赏"
+            })
+    
+    run_tip_effect(notify_tip)
+    run_tip_effect(lambda: sort_cache.invalidate("posts:"))
+
+    # 🏆 扣款成功后再写打赏榜（写榜失败仅记录日志，不影响资金安全）
+    def board_updater(data):
+        for post in data:
+            if post["id"] == post_id:
+                tip_board = post.get("tip_board", [])
+                existing = next((t for t in tip_board if t["account"] == current_user), None)
+                if existing:
+                    existing["amount"] += amount
+                else:
+                    tip_board.append({"account": current_user, "amount": amount, "is_anon": is_anon})
+                tip_board.sort(key=lambda x: x["amount"], reverse=True)
+                post["tip_board"] = tip_board
+                break
+    
+    try:
+        db.atomic_update("posts.json", board_updater, default_data=[])
+    except Exception as e:
+        logger.error("POST_TIP_BOARD_ERROR | error_type=%s", type(e).__name__)
+    
+    return {"status": "success", "message": f"成功打赏 {amount} 积分"}
+
+# ==========================================
+# 💬 评论接口（复用通用评论系统）
+# ==========================================
+
+@router.get("/api/posts/{post_id}/comments")
+async def get_post_comments(post_id: str):
+    """获取评论；有界后台读取并保留原作者附加字段。"""
+    return {"status": "success", "data": await read_comment_view(post_id)}
+
+@router.post("/api/posts/{post_id}/comments")
+@shared_limit(10)
+@_posts_endpoint
+def add_post_comment(request: Request, post_id: str, content: str, current_user: str = Depends(require_auth)):
+    """
+    添加帖子评论
+    """
+    if not content or not content.strip():
+        raise HTTPException(status_code=400, detail="评论内容不能为空")
+    if len(content) > COMMENT_MAX_LENGTH:
+        raise HTTPException(status_code=400, detail="评论长度必须在1-5000字符之间")
+    
+    posts_db = db.load_data("posts.json", default_data=[])
+    
+    # 检查帖子是否存在
+    post_exists = any(p["id"] == post_id for p in posts_db)
+    if not post_exists:
+        raise HTTPException(status_code=404, detail="帖子不存在")
+    
+    new_comment = {
+        "id": f"comment_{int(time.time())}_{uuid.uuid4().hex[:6]}",
+        "author": current_user,
+        "content": content.strip(),
+        "created_at": int(time.time())
+    }
+    
+    append_comment(post_id, new_comment, prepend=True)
+    increment_comment_count("posts.json", post_id)
+
+    # 🗂️ 清除排序缓存（评论数变化可能影响排序）
+    sort_cache.invalidate("posts:")
+    
+    return {"status": "success", "data": new_comment}
+
+
+@router.post("/api/posts/{post_id}/view")
+@shared_limit(60)
+@_posts_endpoint
+def record_post_view(request: Request, post_id: str, current_user: str = Depends(require_auth)):
+    """
+    记录帖子访问量
+    👁️ 需要用户认证，每个用户只计算一次总访问量，日访问量每次调用都增加
+    """
+    result = record_view("posts.json", post_id, current_user)
+    
+    if result is None:
+        raise HTTPException(status_code=404, detail="帖子不存在")
+    
+    # 🗂️ 清除排序缓存（浏览量变化可能影响排序）
+    sort_cache.invalidate("posts:")
+    
+    return {"status": "success", "views": result["views"], "daily_views": result["daily_views"]}

router_prompts.py

@@ -1,967 +1,988 @@
-from publication_identity import publication_identity
-# 云端Space代码/router_prompts.py
-# ==========================================
-# ✨ 提示词市场API路由（图像/视频提示词）
-# ==========================================
-# 功能：提示词发布、列表（分类筛选）、详情（付费内容脱敏）、
-#       互动（点赞/收藏/评论/打赏）、购买解锁、分类管理
-# 数据持久化：prompts.json / prompt_categories.json
-#   与 posts.json 相同，经 数据库连接.py 自动同步至 HF Dataset
-# 关联文件：
-#   - router_posts.py (实现模式参照)
-#   - router_wallet.py (钱包/交易逻辑参照)
-#   - models_sql.py (Wallet/Transaction/Ownership)
-# ==========================================
-
-from fastapi import APIRouter, HTTPException, Depends, Request
-from sqlalchemy.orm import Session
-from models import PromptCreate, PromptUpdate, PromptCategoryAdd, PromptPurchaseRequest
-from typing import Optional
-import 数据库连接 as db
-from comment_store import COMMENT_MAX_LENGTH, append_comment, increment_comment_count, attach_comment_counts, read_comment_view
-from 安全认证 import require_auth, optional_auth, is_admin
-from db_utils import read_public_source, record_view, sort_cache
-from database_sql import get_db
-from models_sql import Wallet, Transaction, Ownership
-from notifications import add_notification
-from tip_transaction import lock_tip_wallets
-from purchase_transaction import effective_resource_price, lock_resource_purchase_wallets
-from tip_store import run_tip_effect
-import time
-import asyncio
-from prompt_store import (PromptStoreError, publish_prompt, edit_prompt,
-    delete_prompt as remove_prompt, project_price, load_categories, modify_category, read_prompts)
-import uuid
-import hashlib
-import datetime
-import logging
-
-# 🔒 P0安全优化：API限流（与 router_wallet.py 保持一致）
-from rate_limit import shared_limit
-
-router = APIRouter()
-
-# 📝 审计日志
-logger = logging.getLogger("ComfyUI-Ranking.Prompts")
-
-# 内置默认分类（首次读取 prompt_categories.json 不存在时自动初始化）
-DEFAULT_CATEGORIES = {
-    "image": ["人物", "动物", "植物", "道具", "建筑"],
-    "video": ["动作", "表情变化", "天气变化", "光效变化", "运镜", "视觉风格"],
-    "music": ["中国风", "流行", "说唱", "摇滚", "电音", "纯音乐"]
-}
-
-VALID_PROMPT_TYPES = ("image", "video", "music")
-
-# 内容长度上限
-MAX_TITLE_LEN = 50
-MAX_CONTENT_LEN = 2000
-MAX_PROMPT_TEXT_LEN = 20000
-MAX_PRICE = 10000
-MAX_CATEGORY_LEN = 8
-MAX_CATEGORY_PER_TYPE = 30
-MAX_TAGS = 10          # 单个提示词最多标签数
-MAX_TAG_LEN = 12       # 单个标签最大字数
-MAX_IMAGES = 9         # 图像提示词最多图片数（与讨论区一致）
-
-
-def _sanitize_images(images) -> list:
-    """清洗图片列表：过滤非法元素，最多 MAX_IMAGES 张"""
-    if not isinstance(images, list):
-        return []
-    cleaned = []
-    for url in images:
-        if not isinstance(url, str):
-            continue
-        u = url.strip()
-        if u:
-            cleaned.append(u)
-        if len(cleaned) >= MAX_IMAGES:
-            break
-    return cleaned
-
-
-def calculate_tx_hash(tx_id, account, tx_type, amount, prev_hash):
-    data = f"{tx_id}{account}{tx_type}{amount}{prev_hash}"
-    return hashlib.sha256(data.encode()).hexdigest()
-
-
-def _sanitize_tags(tags) -> list:
-    """清洗标签：去空白/去重/截断，最多 MAX_TAGS 个，每个≤ MAX_TAG_LEN 字"""
-    if not isinstance(tags, list):
-        return []
-    cleaned = []
-    for tag in tags:
-        if not isinstance(tag, str):
-            continue
-        name = tag.strip()[:MAX_TAG_LEN]
-        if name and name not in cleaned:
-            cleaned.append(name)
-        if len(cleaned) >= MAX_TAGS:
-            break
-    return cleaned
-
-
-async def _prompt_operation(operation, *args, **kwargs):
-    try:
-        return await asyncio.to_thread(operation, *args, **kwargs)
-    except PromptStoreError as error:
-        raise HTTPException(status_code=error.status_code, detail=error.message) from None
-
-
-def _invalidate_prompts():
-    try:
-        sort_cache.invalidate("prompts:")
-    except Exception as error:
-        logger.warning("提示词排序缓存失效失败: error_type=%s", type(error).__name__)
-
-
-def _user_owns_prompt(db_session: Session, account: str, prompt_id: str) -> bool:
-    """检查用户是否已购买（未退款）该提示词"""
-    if not account:
-        return False
-    ownership = db_session.query(Ownership).filter(
-        Ownership.account == account,
-        Ownership.item_id == prompt_id,
-        Ownership.is_refunded == False
-    ).first()
-    return ownership is not None
-
-
-def _mask_prompt_text(prompt_data: dict, can_view: bool) -> dict:
-    """
-    🔒 内容脱敏核心逻辑：
-    ���授权用户一律不下发 prompt_text（服务端脱敏，不依赖前端隐藏）
-    """
-    if can_view:
-        prompt_data["locked"] = False
-    else:
-        prompt_data["prompt_text"] = None
-        prompt_data["locked"] = True
-    return prompt_data
-
-
-# ==========================================
-# 📂 分类管理接口
-# ==========================================
-
-@router.get("/api/prompt-categories")
-async def get_prompt_categories(prompt_type: str = None):
-    """
-    获取提示词分类列表
-    - prompt_type: image / video / music，不传则返回全部
-    """
-    categories = await _prompt_operation(load_categories, db, DEFAULT_CATEGORIES)
-    if prompt_type in VALID_PROMPT_TYPES:
-        return {"status": "success", "data": categories.get(prompt_type, [])}
-    return {"status": "success", "data": categories}
-
-
-@router.post("/api/prompt-categories")
-@shared_limit(5)  # 🔒 限流：防止分类刷屏
-async def add_prompt_category(request: Request, body: PromptCategoryAdd, current_user: str = Depends(require_auth)):
-    """
-    添加提示词分类（仅管理员，入口在云端管理界面，重名去重）
-    """
-    if not is_admin(current_user):
-        raise HTTPException(status_code=403, detail="需要管理员权限")
-    if body.prompt_type not in VALID_PROMPT_TYPES:
-        raise HTTPException(status_code=400, detail="分类所属类型必须是 image、video 或 music")
-
-    name = (body.name or "").strip()
-    if not name:
-        raise HTTPException(status_code=400, detail="分类名称不能为空")
-    if len(name) > MAX_CATEGORY_LEN:
-        raise HTTPException(status_code=400, detail=f"分类名称不能超过{MAX_CATEGORY_LEN}个字")
-
-    values = await _prompt_operation(modify_category, db, DEFAULT_CATEGORIES, body.prompt_type, name, maximum=MAX_CATEGORY_PER_TYPE)
-    logger.info("PROMPT_CATEGORY_ADD | type=%s", body.prompt_type)
-    return {"status": "success", "data": values}
-
-
-@router.delete("/api/prompt-categories")
-@shared_limit(5)  # 🔒 限流：与添加分类一致
-async def delete_prompt_category(request: Request, prompt_type: str = None, name: str = None,
-                                current_user: str = Depends(require_auth)):
-    """
-    删除提示词分类（仅管理员）
-    - prompt_type: image / video / music
-    - name: 分类名称
-    ⚠️ 已使用该分类的提示词不受影响（分类字段保留原文本，仅从可选列表移除）
-    """
-    if not is_admin(current_user):
-        raise HTTPException(status_code=403, detail="需要管理员权限")
-    if prompt_type not in VALID_PROMPT_TYPES:
-        raise HTTPException(status_code=400, detail="分类所属类型必须是 image、video 或 music")
-
-    name = (name or "").strip()
-    if not name:
-        raise HTTPException(status_code=400, detail="分类名称不能为空")
-
-    values = await _prompt_operation(modify_category, db, DEFAULT_CATEGORIES, prompt_type, name, delete=True)
-    logger.info("PROMPT_CATEGORY_DELETE | type=%s", prompt_type)
-    return {"status": "success", "data": values}
-
-
-# ==========================================
-# 📝 提示词CRUD接口
-# ==========================================
-
-@router.get("/api/prompt-tags")
-async def get_prompt_tags():
-    """
-    🏷️ 聚合全站标签（发布表单推荐用，按使用次数降序，最多返回100个）
-    """
-    prompts_db = db.load_data("prompts.json", default_data=[])
-    counter = {}
-    for prompt in prompts_db:
-        for tag in (prompt.get("tags") or []):
-            if isinstance(tag, str) and tag.strip():
-                counter[tag] = counter.get(tag, 0) + 1
-    ranked = sorted(counter.items(), key=lambda kv: (-kv[1], kv[0]))[:100]
-    return {"status": "success", "data": [{"name": n, "count": c} for n, c in ranked]}
-
-
-@router.get("/api/prompts")
-async def get_prompts(prompt_type: str = None, category: str = None,
-                      page: int = 1, limit: int = 20, sort: str = "latest"):
-    """
-    获取提示词列表（分页，支持类型/分类筛选与多种排序）
-    - prompt_type: image / video / music（子界面筛选）
-    - category: 分类筛选
-    - sort: latest / likes / favorites / views / daily_views / tips
-    ⚠️ 列表接口永不下发 prompt_text（付费内容脱敏）
-    """
-    read_epoch = sort_cache.capture_read_epoch()
-    prompts_db = await _prompt_operation(read_prompts, db)
-    users_db = read_public_source(db, "users.json", default_data={})
-    user_map = users_db
-
-    # 🗂️ 使用排序缓存优化排序性能
-    cache_sort = sort if sort in ("latest", "likes", "favorites", "views", "daily_views", "tips") else "latest"
-    cache_key = f"prompts:{cache_sort}"
-
-    def order_key(item):
-        if sort == "likes":
-            return item.get("likes", 0)
-        elif sort == "favorites":
-            return item.get("favorites", 0)
-        elif sort == "views":
-            return item.get("views", 0)
-        elif sort == "daily_views":
-            return item.get("daily_views", 0)
-        elif sort == "tips":
-            return sum(t.get("amount", 0) for t in item.get("tip_board", []))
-        else:  # latest 或其他默认
-            return item.get("created_at", 0)
-
-    def sort_fn(data):
-        data.sort(key=order_key, reverse=True)
-
-    sorted_prompts = sort_cache.get_sorted(cache_key, prompts_db, sort_fn, read_epoch=read_epoch, fresh=True)
-
-    # 类型与分类过滤
-    if prompt_type in VALID_PROMPT_TYPES:
-        sorted_prompts = [p for p in sorted_prompts if p.get("prompt_type") == prompt_type]
-    if category:
-        sorted_prompts = [p for p in sorted_prompts if p.get("category") == category]
-
-    # 分页
-    total = len(sorted_prompts)
-    start = (page - 1) * limit
-    end = start + limit
-    paged_prompts = sorted_prompts[start:end]
-
-    # 附加作者信息，并过滤敏感字段
-    result = []
-    for prompt in paged_prompts:
-        try:
-            prompt = project_price(prompt)
-        except Exception:
-            raise HTTPException(status_code=503, detail="提示词暂时不可读取") from None
-        author_info = user_map.get(prompt.get("author"), {})
-        prompt_data = {
-            **prompt,
-            "author_name": author_info.get("name", prompt.get("author")),
-            "author_avatar": author_info.get("avatarDataUrl", "")
-        }
-        # 🔒 脱敏：列表永不下发提示词正文与浏览记录
-        prompt_data.pop("prompt_text", None)
-        prompt_data.pop("viewed_by", None)
-        result.append(prompt_data)
-
-    attach_comment_counts(result)
-    return {
-        "status": "success",
-        "data": result,
-        "total": total,
-        "page": page,
-        "limit": limit
-    }
-
-
-@router.get("/api/my-prompts")
-async def get_my_prompts(current_user: str = Depends(require_auth)):
-    """
-    获取我发布的提示词（个人中心用）
-    作者本人可见自己的 prompt_text
-    """
-    prompts_db = await _prompt_operation(read_prompts, db)
-
-    my_prompts = [p for p in prompts_db if p.get("author") == current_user]
-    my_prompts = sorted(my_prompts, key=lambda x: x.get("created_at", 0), reverse=True)
-
-    result = []
-    for prompt in my_prompts:
-        try:
-            prompt = project_price(prompt)
-        except Exception:
-            raise HTTPException(status_code=503, detail="提示词暂时不可读取") from None
-        prompt_data = dict(prompt)
-        prompt_data.pop("viewed_by", None)
-        result.append(prompt_data)
-
-    attach_comment_counts(result)
-    return {"status": "success", "data": result}
-
-
-@router.get("/api/prompts/{prompt_id}")
-async def get_prompt_detail(prompt_id: str, current_user: str = Depends(optional_auth),
-                            db_session: Session = Depends(get_db)):
-    """
-    获取提示词详情
-    🔒 仅当 ①免费 ②作者本人 ③已购买 时下发 prompt_text
-    """
-    try:
-        prompts_db = db.load_data("prompts.json", default_data=[], strict=True, skip_cache=True)
-        if not isinstance(prompts_db, list):
-            raise ValueError("invalid prompt collection")
-    except Exception:
-        raise HTTPException(status_code=503, detail="提示词暂时不可读取")
-    users_db = db.load_data("users.json", default_data={})
-    user_map = users_db
-
-    for prompt in prompts_db:
-        if isinstance(prompt, dict) and prompt.get("id") == prompt_id:
-            try:
-                price = effective_resource_price(prompt)
-            except Exception:
-                raise HTTPException(status_code=503, detail="提示词暂时不可读取")
-
-            author_info = user_map.get(prompt.get("author"), {})
-            prompt_data = {
-                **prompt,
-                "price": price,
-                "author_name": author_info.get("name", prompt.get("author")),
-                "author_avatar": author_info.get("avatarDataUrl", "")
-            }
-            prompt_data.pop("viewed_by", None)
-
-            is_author = current_user and current_user == prompt.get("author")
-            can_view = price <= 0 or is_author or _user_owns_prompt(db_session, current_user, prompt_id)
-            prompt_data["owned"] = bool(can_view)
-            prompt_data["price_confirmation_supported"] = True
-            _mask_prompt_text(prompt_data, can_view)
-
-            attach_comment_counts([prompt_data])
-            return {"status": "success", "data": prompt_data}
-
-    raise HTTPException(status_code=404, detail="提示词不存在")
-
-
-@router.post("/api/prompts")
-@shared_limit(5)
-async def create_prompt(request: Request, prompt: PromptCreate, current_user: str = Depends(require_auth)):
-    """
-    发布提示词
-    """
-    try:
-        stable_id = publication_identity('prompt', current_user, getattr(request, 'headers', {}).get('Idempotency-Key'))
-    except ValueError:
-        raise HTTPException(status_code=400, detail='发布请求身份无效') from None
-
-    # 参数校验
-    if prompt.prompt_type not in VALID_PROMPT_TYPES:
-        raise HTTPException(status_code=400, detail="提示词类型必须是 image、video 或 music")
-    title = (prompt.title or "").strip()
-    content = (prompt.content or "").strip()
-    prompt_text = (prompt.prompt_text or "").strip()
-    category = (prompt.category or "").strip()
-    if not title or not content or not prompt_text:
-        raise HTTPException(status_code=400, detail="标题、介绍文案与提示词正文均不能为空")
-    if len(title) > MAX_TITLE_LEN:
-        raise HTTPException(status_code=400, detail=f"标题不能超过{MAX_TITLE_LEN}个字")
-    if len(content) > MAX_CONTENT_LEN:
-        raise HTTPException(status_code=400, detail=f"介绍文案不能超过{MAX_CONTENT_LEN}个字")
-    if len(prompt_text) > MAX_PROMPT_TEXT_LEN:
-        raise HTTPException(status_code=400, detail=f"提示词正文不能超过{MAX_PROMPT_TEXT_LEN}个字")
-    if not category:
-        raise HTTPException(status_code=400, detail="请选择分类")
-
-    # 分类必须存在于分类库
-    categories = await _prompt_operation(load_categories, db, DEFAULT_CATEGORIES)
-    if category not in categories.get(prompt.prompt_type, []):
-        raise HTTPException(status_code=400, detail="所选分类不存在")
-
-    price = prompt.price
-    if type(price) is not int or not 0 <= price <= MAX_PRICE:
-        raise HTTPException(status_code=400, detail=f"定价必须在0-{MAX_PRICE}之间")
-
-    media_type = prompt.media_type if prompt.media_type in ("image", "video") else "image"
-    video_url = prompt.video_url if media_type == "video" else None
-    if media_type == "video" and not video_url:
-        # 未上传示例视频时降级为图片展示
-        media_type = "image"
-
-    # 图像提示词的图片列表（首张即封面）；视频提示词不保留图片列表
-    images = _sanitize_images(prompt.images) if media_type == "image" else []
-
-    # 🎵 音乐提示词支持音频示例（图片+音频方案，视频可选）；非音乐类型不保留
-    audio_url = (prompt.audio_url or "").strip() or None
-    if prompt.prompt_type != "music":
-        audio_url = None
-
-    new_prompt = {
-        "id": stable_id or f"prompt_{int(time.time())}_{uuid.uuid4().hex}",
-        "prompt_type": prompt.prompt_type,
-        "category": category,
-        "title": title,
-        "content": content,
-        "prompt_text": prompt_text,
-        "cover_image": prompt.cover_image,
-        "media_type": media_type,
-        "video_url": video_url,
-        "audio_url": audio_url,
-        "images": images,
-        "is_original": bool(prompt.is_original),
-        "price": price,
-        "author": current_user,
-        "created_at": int(time.time()),
-        # 互动数据
-        "likes": 0,
-        "favorites": 0,
-        "comments": 0,
-        "liked_by": [],
-        "favorited_by": [],
-        "tip_board": [],  # 打赏榜单
-        "views": 0,
-        "daily_views": 0,
-        "viewed_by": [],
-        "daily_views_date": "",
-        "tags": _sanitize_tags(prompt.tags)
-    }
-
-    new_prompt = await _prompt_operation(publish_prompt, db, new_prompt, stable_id is not None)
-    _invalidate_prompts()
-
-    return {"status": "success", "data": new_prompt}
-
-
-@router.put("/api/prompts/{prompt_id}")
-@shared_limit(10)
-async def update_prompt(request: Request, prompt_id: str, update_data: PromptUpdate, current_user: str = Depends(require_auth)):
-    """
-    更新提示词（仅作者可操作，原子操作，并发安全）
-    """
-    error_map = {
-        "forbidden": (403, "无权修改他人提示词"),
-        "not_found": (404, "提示词不存在"),
-        "invalid_title": (400, f"标题不能为空且不能超过{MAX_TITLE_LEN}个字"),
-        "invalid_content": (400, f"介绍文案不能超过{MAX_CONTENT_LEN}个字"),
-        "invalid_prompt_text": (400, "提示词正文不能为空且长度超限"),
-        "invalid_category": (400, "所选分类不存在"),
-        "invalid_price": (400, f"定价必须在0-{MAX_PRICE}之间"),
-        "invalid_media_type": (400, "媒体类型必须是 image 或 video")
-    }
-    categories = await _prompt_operation(load_categories, db, DEFAULT_CATEGORIES) if update_data.category is not None else None
-
-    def apply(prompt):
-        # 更新字段
-        if update_data.title is not None:
-            title = update_data.title.strip()
-            if not title or len(title) > MAX_TITLE_LEN:
-                raise PromptStoreError(*error_map["invalid_title"])
-            prompt["title"] = title
-        if update_data.content is not None:
-            content = update_data.content.strip()
-            if len(content) > MAX_CONTENT_LEN:
-                raise PromptStoreError(*error_map["invalid_content"])
-            prompt["content"] = content
-        if update_data.prompt_text is not None:
-            prompt_text = update_data.prompt_text.strip()
-            if not prompt_text or len(prompt_text) > MAX_PROMPT_TEXT_LEN:
-                raise PromptStoreError(*error_map["invalid_prompt_text"])
-            prompt["prompt_text"] = prompt_text
-        if update_data.category is not None:
-            category = update_data.category.strip()
-            if category not in categories.get(prompt.get("prompt_type"), []):
-                raise PromptStoreError(*error_map["invalid_category"])
-            prompt["category"] = category
-        if update_data.cover_image is not None:
-            prompt["cover_image"] = update_data.cover_image
-        if update_data.price is not None:
-            price = update_data.price
-            if type(price) is not int or not 0 <= price <= MAX_PRICE:
-                raise PromptStoreError(*error_map["invalid_price"])
-            current_price = effective_resource_price(prompt)
-            if current_price != price:
-                # 设置待生效价格，24小时后生效（与资源改价机制同构；提示词不支持退款，无需禁购配套）
-                effective_time = datetime.datetime.now() + datetime.timedelta(hours=24)
-                prompt["pending_price"] = price
-                prompt["pending_price_effective_at"] = effective_time.isoformat()
-                # 不立即修改 price，等待24小时后生效
-            else:
-                # 价格未变，清除待生效价格
-                prompt["pending_price"] = None
-                prompt["pending_price_effective_at"] = None
-        if update_data.media_type is not None:
-            if update_data.media_type not in ("image", "video"):
-                raise PromptStoreError(*error_map["invalid_media_type"])
-            prompt["media_type"] = update_data.media_type
-            if update_data.media_type == "image":
-                # 图像类型不保留视频（与 create 逻辑一致）
-                prompt["video_url"] = None
-        if update_data.video_url is not None:
-            prompt["video_url"] = update_data.video_url
-            if update_data.video_url:
-                prompt["media_type"] = "video"
-        if update_data.audio_url is not None or "audio_url" in getattr(update_data, "model_fields_set", set()):
-            # 🎵 音频仅音乐提示词保留；显式空字符串/null 清除，未传保持
-            audio_url = (update_data.audio_url or "").strip() or None
-            prompt["audio_url"] = audio_url if prompt.get("prompt_type") == "music" else None
-        if update_data.images is not None:
-            prompt["images"] = _sanitize_images(update_data.images)
-        if update_data.is_original is not None:
-            prompt["is_original"] = bool(update_data.is_original)
-        if update_data.tags is not None:
-            prompt["tags"] = _sanitize_tags(update_data.tags)
-        if prompt.get("media_type") == "image":
-            prompt["video_url"] = None
-        else:
-            prompt["images"] = []
-
-    await _prompt_operation(edit_prompt, db, prompt_id, current_user, apply)
-    _invalidate_prompts()
-    return {"status": "success"}
-
-
-@router.delete("/api/prompts/{prompt_id}")
-@shared_limit(10)
-async def delete_prompt(request: Request, prompt_id: str, current_user: str = Depends(require_auth)):
-    """
-    删除提示词（仅作者可操作）
-    """
-    await _prompt_operation(remove_prompt, db, prompt_id, current_user)
-    _invalidate_prompts()
-    return {"status": "success"}
-
-
-# ==========================================
-# ❤️ 互动接口（点赞/收藏）
-# ==========================================
-
-@router.post("/api/prompts/{prompt_id}/like")
-@shared_limit(30)
-async def toggle_like(request: Request, prompt_id: str, current_user: str = Depends(require_auth)):
-    """
-    点赞/取消点赞（原子操作，并发安全）
-    """
-    result_container = [None]
-
-    def updater(data):
-        for prompt in data:
-            if prompt["id"] == prompt_id:
-                liked_by = prompt.get("liked_by", [])
-                if current_user in liked_by:
-                    liked_by.remove(current_user)
-                    prompt["likes"] = max(0, prompt.get("likes", 0) - 1)
-                    action = "unliked"
-                else:
-                    liked_by.append(current_user)
-                    prompt["likes"] = prompt.get("likes", 0) + 1
-                    action = "liked"
-                prompt["liked_by"] = liked_by
-                result_container[0] = {"status": "success", "action": action, "likes": prompt["likes"]}
-                return
-        result_container[0] = None  # 未找到提示词
-
-    db.atomic_update("prompts.json", updater, default_data=[])
-
-    if result_container[0] is None:
-        raise HTTPException(status_code=404, detail="提示词不存在")
-
-    # 🗂️ 清除排序缓存（点赞数变化可能影响排序）
-    sort_cache.invalidate("prompts:")
-
-    return result_container[0]
-
-
-@router.post("/api/prompts/{prompt_id}/favorite")
-@shared_limit(30)
-async def toggle_favorite(request: Request, prompt_id: str, current_user: str = Depends(require_auth)):
-    """
-    收藏/取消收藏（原子操作，并发安全）
-    """
-    result_container = [None]
-
-    def updater(data):
-        for prompt in data:
-            if prompt["id"] == prompt_id:
-                favorited_by = prompt.get("favorited_by", [])
-                if current_user in favorited_by:
-                    favorited_by.remove(current_user)
-                    prompt["favorites"] = max(0, prompt.get("favorites", 0) - 1)
-                    action = "unfavorited"
-                else:
-                    favorited_by.append(current_user)
-                    prompt["favorites"] = prompt.get("favorites", 0) + 1
-                    action = "favorited"
-                prompt["favorited_by"] = favorited_by
-                result_container[0] = {"status": "success", "action": action, "favorites": prompt["favorites"]}
-                return
-        result_container[0] = None  # 未找到提示词
-
-    db.atomic_update("prompts.json", updater, default_data=[])
-
-    if result_container[0] is None:
-        raise HTTPException(status_code=404, detail="提示词不存在")
-
-    # 🗂️ 清除排序缓存（收藏数变化可能影响排序）
-    sort_cache.invalidate("prompts:")
-
-    return result_container[0]
-
-
-# ==========================================
-# 🎁 打赏接口
-# ==========================================
-
-@router.post("/api/prompts/{prompt_id}/tip")
-@shared_limit(10)
-async def tip_prompt(request: Request, prompt_id: str, amount: int, is_anon: bool = False,
-                     current_user: str = Depends(require_auth), db_session: Session = Depends(get_db)):
-    """
-    打赏提示词（原子操作，并发安全）- 使用 SQL Wallet 系统
-    """
-    if amount <= 0:
-        raise HTTPException(status_code=400, detail="打赏金额必须大于0")
-    MAX_TIP_AMOUNT = 100000
-    if amount > MAX_TIP_AMOUNT:
-        raise HTTPException(status_code=400, detail=f"打赏金额必须在1-{MAX_TIP_AMOUNT}之间")
-
-    # 🔒 P0数据修复（时序）：先只读校验 → SQL转账扣款 → 提交成功后再写打赏榜
-    # 避免余额不足/重复请求时榜单已被更新的数据不一致
-    prompts_db_ro = db.load_data("prompts.json", default_data=[])
-    target_prompt = next((p for p in prompts_db_ro if p["id"] == prompt_id), None)
-    if not target_prompt:
-        raise HTTPException(status_code=404, detail="提示词不存在")
-    if target_prompt.get("author") == current_user:
-        raise HTTPException(status_code=400, detail="不能打赏自己的提示词")
-    author = target_prompt.get("author")
-    if not author:
-        raise HTTPException(status_code=404, detail="作者账户不存在")
-    prompt_title = target_prompt.get("title")
-
-    # 💳 使用 SQL Wallet 系统处理余额转账（先扣款）
-    try:
-
-        # 🔒 并发安全：使用悲观锁获取双方钱包
-        tipper_wallet, author_wallet = lock_tip_wallets(db_session, current_user, author)
-        # 🔒 P1幂等性防护：检查最近5秒内是否存在相同交易
-        recent_cutoff = datetime.datetime.utcnow() - datetime.timedelta(seconds=5)
-        duplicate_tx = db_session.query(Transaction).filter(
-            Transaction.account == current_user,
-            Transaction.tx_type == "TIP_OUT",
-            Transaction.amount == -amount,
-            Transaction.related_account == author,
-            Transaction.item_id == prompt_id,
-            Transaction.item_type == "prompt",
-            Transaction.created_at >= recent_cutoff
-        ).with_for_update().first()
-        if duplicate_tx:
-            db_session.rollback()  # 重复请求释放锁，不执行任何后续操作
-            return {"status": "success", "message": "打赏已处理（重复请求）"}
-
-        if not tipper_wallet or tipper_wallet.balance < amount:
-            raise HTTPException(status_code=400, detail="余额不足")
-
-        # 执行转账
-        tipper_wallet.balance -= amount
-        author_wallet.balance += amount         # 实际收入进统一余额
-        author_wallet.tip_balance += amount     # 累计打赏收益统计（只增不减）
-
-        # 创建交易记录
-        tx_id_tipper = f"TIP_OUT_{int(time.time())}_{uuid.uuid4().hex[:6]}"
-        tx_id_author = f"TIP_IN_{int(time.time())}_{uuid.uuid4().hex[:6]}"
-
-        # 获取最后交易记录的哈希
-        last_tx_tipper = db_session.query(Transaction).filter(Transaction.account == current_user).order_by(Transaction.created_at.desc()).first()
-        last_tx_author = db_session.query(Transaction).filter(Transaction.account == author).order_by(Transaction.created_at.desc()).first()
-        prev_hash_tipper = last_tx_tipper.tx_hash if last_tx_tipper else "GENESIS_HASH"
-        prev_hash_author = last_tx_author.tx_hash if last_tx_author else "GENESIS_HASH"
-
-        # 获取用户信息（prompt_title 已在预校验阶段取得）
-        users_db = db.load_data("users.json", default_data={})
-        author_info = users_db.get(author, {})
-        tipper_info = users_db.get(current_user, {})
-        author_name = author_info.get("name", author)
-        tipper_name = tipper_info.get("name", current_user)
-
-        # 打赏方交易记录 (TIP_OUT)
-        tx_tipper = Transaction(
-            tx_id=tx_id_tipper,
-            account=current_user,
-            tx_type="TIP_OUT",
-            amount=-amount,
-            related_account=author,
-            item_id=prompt_id,
-            prev_hash=prev_hash_tipper,
-            tx_hash=calculate_tx_hash(tx_id_tipper, current_user, "TIP_OUT", -amount, prev_hash_tipper),
-            description=f"打赏给 {author_name}" + (f" 的提示词《{prompt_title}》" if prompt_title else ""),
-            item_title=prompt_title,
-            item_type="prompt",
-            related_user_name=author_name
-        )
-
-        # 接收方交易记录 (TIP_IN)
-        tx_author = Transaction(
-            tx_id=tx_id_author,
-            account=author,
-            tx_type="TIP_IN",
-            amount=amount,
-            related_account=current_user,
-            item_id=prompt_id,
-            prev_hash=prev_hash_author,
-            tx_hash=calculate_tx_hash(tx_id_author, author, "TIP_IN", amount, prev_hash_author),
-            description=f"收到 {tipper_name} 的提示词打赏" + (f" ({prompt_title})" if prompt_title else ""),
-            item_title=prompt_title,
-            item_type="prompt",
-            related_user_name=tipper_name if not is_anon else "匿名用户"
-        )
-
-        db_session.add(tx_tipper)
-        db_session.add(tx_author)
-        db_session.commit()
-
-        # 📝 审计日志
-        logger.info("PROMPT_TIP")
-
-    except HTTPException:
-        db_session.rollback()
-        raise
-    except Exception as e:
-        db_session.rollback()
-        logger.error("PROMPT_TIP_ERROR | error_type=%s", type(e).__name__)
-        raise HTTPException(status_code=500, detail="打赏处理失败，请稍后重试")
-
-    def notify_tip():
-        # 🔔 打赏通知（考虑匿名）
-        if not is_anon:
-            add_notification(author, {
-                "type": "tip",
-                "from_user": current_user,
-                "target_item_id": prompt_id,
-                "target_item_title": prompt_title or "",
-                "content": f"您收到来自 {tipper_name} 的 {amount} 积分提示词打赏"
-            })
-        else:
-            add_notification(author, {
-                "type": "tip",
-                "from_user": "anonymous",
-                "target_item_id": prompt_id,
-                "target_item_title": "",
-                "content": f"您收到了一份 {amount} 积分的匿名提示词打赏"
-            })
-
-    run_tip_effect(notify_tip)
-    run_tip_effect(lambda: sort_cache.invalidate("prompts:"))
-
-    # 🏆 扣款成功后再写打赏榜（写榜失败仅记录日志，不影响资金安全）
-    def board_updater(data):
-        for prompt in data:
-            if prompt["id"] == prompt_id:
-                tip_board = prompt.get("tip_board", [])
-                existing = next((t for t in tip_board if t["account"] == current_user), None)
-                if existing:
-                    existing["amount"] += amount
-                else:
-                    tip_board.append({"account": current_user, "amount": amount, "is_anon": is_anon})
-                tip_board.sort(key=lambda x: x["amount"], reverse=True)
-                prompt["tip_board"] = tip_board
-                break
-
-    try:
-        db.atomic_update("prompts.json", board_updater, default_data=[])
-    except Exception as e:
-        logger.error("PROMPT_TIP_BOARD_ERROR | error_type=%s", type(e).__name__)
-
-    return {"status": "success", "message": f"成功打赏 {amount} 积分"}
-
-
-# ==========================================
-# 🛒 购买解锁接口
-# ==========================================
-
-@router.post("/api/prompts/{prompt_id}/purchase")
-@shared_limit(10)  # 🔒 P0安全优化：购买每分钟最多10次
-async def purchase_prompt(request: Request, prompt_id: str,
-                          purchase: Optional[PromptPurchaseRequest] = None,
-                          current_user: str = Depends(require_auth), db_session: Session = Depends(get_db)):
-    """资金与所有权原子提交；通知失败不改变已提交的购买结果。"""
-    try:
-        prompts_db = db.load_data("prompts.json", default_data=[], strict=True, skip_cache=True)
-        if not isinstance(prompts_db, list):
-            raise ValueError("invalid prompt collection")
-        prompt = next((p for p in prompts_db if isinstance(p, dict) and p.get("id") == prompt_id), None)
-        if prompt is None:
-            raise HTTPException(status_code=404, detail="提示词不存在")
-        price = effective_resource_price(prompt)
-        seller_account = prompt.get("author")
-        prompt_text = prompt.get("prompt_text")
-        if not isinstance(seller_account, str) or not seller_account.strip() or not isinstance(prompt_text, str):
-            raise ValueError("invalid prompt delivery")
-        response = {"status": "success", "already_owned": True, "prompt_text": prompt_text}
-    except HTTPException:
-        raise
-    except Exception as error:
-        logger.error("PROMPT_PURCHASE_SOURCE_ERROR | error_type=%s", type(error).__name__)
-        raise HTTPException(status_code=503, detail="提示词暂时不可购买")
-
-    # 非资金展示资料在写锁外读取；失败不影响正文交付或交易。
-    try:
-        users_db = db.load_data("users.json", default_data={})
-        seller_info = users_db.get(seller_account, {})
-        buyer_info = users_db.get(current_user, {})
-        seller_user_name = seller_info.get("name", seller_account)
-        buyer_user_name = buyer_info.get("name", current_user)
-    except Exception:
-        seller_user_name, buyer_user_name = seller_account, current_user
-
-    free = price == 0 or current_user == seller_account
-    try:
-        # 必须是本次事务的第一项 SQL；SQLite 使用 BEGIN IMMEDIATE。
-        buyer_wallet, seller_wallet = lock_resource_purchase_wallets(
-            db_session, current_user, seller_account, free)
-        owned = db_session.query(Ownership).filter(
-            Ownership.account == current_user,
-            Ownership.item_id == prompt_id,
-            Ownership.is_refunded == False
-        ).first()
-        if owned:
-            db_session.rollback()
-            return response
-        if free:
-            db_session.add(Ownership(account=current_user, item_id=prompt_id, price_paid=0))
-            db_session.commit()
-            return response
-        expected_price = getattr(purchase, "expected_price", None)
-        if expected_price is None:
-            raise HTTPException(status_code=428, detail="purchase_price_confirmation_required")
-        if isinstance(expected_price, bool) or not isinstance(expected_price, int) or expected_price < 0:
-            raise HTTPException(status_code=422, detail="purchase_price_invalid")
-        if expected_price != price:
-            raise HTTPException(status_code=409, detail="purchase_price_changed")
-        if buyer_wallet is None or buyer_wallet.balance < price:
-            raise HTTPException(status_code=402, detail="余额不足，请先充值")
-        for amount in (buyer_wallet.balance, seller_wallet.balance, seller_wallet.earn_balance):
-            if isinstance(amount, bool) or not isinstance(amount, int):
-                raise ValueError("invalid wallet amount")
-        buyer_wallet.balance -= price
-        seller_wallet.balance += price
-        seller_wallet.earn_balance += price
-        db_session.add(Ownership(account=current_user, item_id=prompt_id, price_paid=price))
-
-        for account, other, tx_type, amount, user_name, description in (
-            (current_user, seller_account, "PURCHASE", -price, seller_user_name,
-             f"购买提示词 {prompt.get('title', '未知提示词')}"),
-            (seller_account, current_user, "SALE", price, buyer_user_name,
-             f"销售收入: {prompt.get('title', prompt_id)}")
-        ):
-            last_tx = db_session.query(Transaction).filter(Transaction.account == account).order_by(
-                Transaction.created_at.desc(), Transaction.tx_id.desc()).with_for_update().first()
-            prev_hash = last_tx.tx_hash if last_tx else "GENESIS_HASH"
-            tx_id = f"{tx_type}_{uuid.uuid4().hex}"
-            db_session.add(Transaction(
-                tx_id=tx_id, account=account, tx_type=tx_type, amount=amount,
-                related_account=other, item_id=prompt_id, prev_hash=prev_hash,
-                tx_hash=calculate_tx_hash(tx_id, account, tx_type, amount, prev_hash),
-                description=description, item_title=prompt.get("title", ""),
-                item_type="prompt", related_user_name=user_name))
-        response["already_owned"] = False
-        db_session.commit()
-    except HTTPException:
-        db_session.rollback()
-        raise
-    except Exception as error:
-        db_session.rollback()
-        logger.error("PROMPT_PURCHASE_ERROR | error_type=%s", type(error).__name__)
-        raise HTTPException(status_code=500, detail="购买处理失败，请稍后重试")
-
-    run_tip_effect(lambda: logger.info("PROMPT_PURCHASE_COMPLETED"))
-    run_tip_effect(lambda: add_notification(seller_account, {
-        "type": "purchase", "from_user": current_user,
-        "target_item_id": prompt_id, "target_item_title": prompt.get("title", ""),
-        "content": f"您的提示词《{prompt.get('title', '')}》已被购买"
-    }))
-    return response
-
-
-# ==========================================
-# 💬 评论接口（复用通用评论存储 comments.json）
-# ==========================================
-
-@router.get("/api/prompts/{prompt_id}/comments")
-async def get_prompt_comments(prompt_id: str):
-    """获取评论；有界后台读取并保留原作者附加字段。"""
-    return {"status": "success", "data": await read_comment_view(prompt_id)}
-
-@router.post("/api/prompts/{prompt_id}/comments")
-@shared_limit(10)
-async def add_prompt_comment(request: Request, prompt_id: str, content: str, current_user: str = Depends(require_auth)):
-    """
-    添加提示词评论
-    """
-    if not content or not content.strip():
-        raise HTTPException(status_code=400, detail="评论内容不能为空")
-    if len(content) > COMMENT_MAX_LENGTH:
-        raise HTTPException(status_code=400, detail="评论长度必须在1-5000字符之间")
-
-    prompts_db = db.load_data("prompts.json", default_data=[])
-
-    # 检查提示词是否存在
-    prompt_exists = any(p["id"] == prompt_id for p in prompts_db)
-    if not prompt_exists:
-        raise HTTPException(status_code=404, detail="提示词不存在")
-
-    new_comment = {
-        "id": f"comment_{int(time.time())}_{uuid.uuid4().hex[:6]}",
-        "author": current_user,
-        "content": content.strip(),
-        "created_at": int(time.time())
-    }
-
-    append_comment(prompt_id, new_comment, prepend=True)
-    increment_comment_count("prompts.json", prompt_id)
-
-    # 🗂️ 清除排序缓存（评论数变化可能影响排序）
-    sort_cache.invalidate("prompts:")
-
-    return {"status": "success", "data": new_comment}
-
-
-@router.post("/api/prompts/{prompt_id}/view")
-@shared_limit(60)
-async def record_prompt_view(request: Request, prompt_id: str, current_user: str = Depends(require_auth)):
-    """
-    记录提示词访问量
-    👁️ 需要用户认证，每个用户只计算一次总访问量，日访问量每次调用都增加
-    """
-    result = record_view("prompts.json", prompt_id, current_user)
-
-    if result is None:
-        raise HTTPException(status_code=404, detail="提示词不存在")
-
-    # 🗂️ 清除排序缓存（浏览量变化可能影响排序）
-    sort_cache.invalidate("prompts:")
-
-    return {"status": "success", "views": result["views"], "daily_views": result["daily_views"]}
+from publication_identity import publication_identity
+# 云端Space代码/router_prompts.py
+# ==========================================
+# ✨ 提示词市场API路由（图像/视频提示词）
+# ==========================================
+# 功能：提示词发布、列表（分类筛选）、详情（付费内容脱敏）、
+#       互动（点赞/收藏/评论/打赏）、购买解锁、分类管理
+# 数据持久化：prompts.json / prompt_categories.json
+#   与 posts.json 相同，经 数据库连接.py 自动同步至 HF Dataset
+# 关联文件：
+#   - router_posts.py (实现模式参照)
+#   - router_wallet.py (钱包/交易逻辑参照)
+#   - models_sql.py (Wallet/Transaction/Ownership)
+# ==========================================
+
+from fastapi import APIRouter, HTTPException, Depends, Request
+from sqlalchemy.orm import Session
+from models import PromptCreate, PromptUpdate, PromptCategoryAdd, PromptPurchaseRequest
+from typing import Optional
+import 数据库连接 as db
+from comment_store import COMMENT_MAX_LENGTH, append_comment, increment_comment_count, attach_comment_counts, read_comment_view
+from 安全认证 import require_auth, optional_auth, is_admin
+from db_utils import read_public_source, record_view, sort_cache
+from database_sql import get_db
+from models_sql import Wallet, Transaction, Ownership
+from notifications import add_notification
+from tip_transaction import lock_tip_wallets
+from purchase_transaction import effective_resource_price, lock_resource_purchase_wallets
+from tip_store import run_tip_effect
+import time
+from owned_thread import OwnedThreadGroup, owned_sync_endpoint
+from prompt_store import (PromptStoreError, publish_prompt, edit_prompt,
+    delete_prompt as remove_prompt, project_price, load_categories, modify_category, read_prompts)
+import uuid
+import hashlib
+import datetime
+import logging
+
+# 🔒 P0安全优化：API限流（与 router_wallet.py 保持一致）
+from rate_limit import shared_limit
+
+MAX_PROMPTS_IO = 16
+_prompts_io = OwnedThreadGroup(MAX_PROMPTS_IO,
+    lambda: HTTPException(status_code=503, detail="提示词数据暂不可用"))
+start_prompts_io = _prompts_io.start
+stop_prompts_io = _prompts_io.stop
+close_prompts_io = _prompts_io.close
+_prompts_endpoint = owned_sync_endpoint(_prompts_io)
+
+router = APIRouter()
+
+# 📝 审计日志
+logger = logging.getLogger("ComfyUI-Ranking.Prompts")
+
+# 内置默认分类（首次读取 prompt_categories.json 不存在时自动初始化）
+DEFAULT_CATEGORIES = {
+    "image": ["人物", "动物", "植物", "道具", "建筑"],
+    "video": ["动作", "表情变化", "天气变化", "光效变化", "运镜", "视觉风格"],
+    "music": ["中国风", "流行", "说唱", "摇滚", "电音", "纯音乐"]
+}
+
+VALID_PROMPT_TYPES = ("image", "video", "music")
+
+# 内容长度上限
+MAX_TITLE_LEN = 50
+MAX_CONTENT_LEN = 2000
+MAX_PROMPT_TEXT_LEN = 20000
+MAX_PRICE = 10000
+MAX_CATEGORY_LEN = 8
+MAX_CATEGORY_PER_TYPE = 30
+MAX_TAGS = 10          # 单个提示词最多标签数
+MAX_TAG_LEN = 12       # 单个标签最大字数
+MAX_IMAGES = 9         # 图像提示词最多图片数（与讨论区一致）
+
+
+def _sanitize_images(images) -> list:
+    """清洗图片列表：过滤非法元素，最多 MAX_IMAGES 张"""
+    if not isinstance(images, list):
+        return []
+    cleaned = []
+    for url in images:
+        if not isinstance(url, str):
+            continue
+        u = url.strip()
+        if u:
+            cleaned.append(u)
+        if len(cleaned) >= MAX_IMAGES:
+            break
+    return cleaned
+
+
+def calculate_tx_hash(tx_id, account, tx_type, amount, prev_hash):
+    data = f"{tx_id}{account}{tx_type}{amount}{prev_hash}"
+    return hashlib.sha256(data.encode()).hexdigest()
+
+
+def _sanitize_tags(tags) -> list:
+    """清洗标签：去空白/去重/截断，最多 MAX_TAGS 个，每个≤ MAX_TAG_LEN 字"""
+    if not isinstance(tags, list):
+        return []
+    cleaned = []
+    for tag in tags:
+        if not isinstance(tag, str):
+            continue
+        name = tag.strip()[:MAX_TAG_LEN]
+        if name and name not in cleaned:
+            cleaned.append(name)
+        if len(cleaned) >= MAX_TAGS:
+            break
+    return cleaned
+
+
+def _prompt_operation(operation, *args, **kwargs):
+    try:
+        return operation(*args, **kwargs)
+    except PromptStoreError as error:
+        raise HTTPException(status_code=error.status_code, detail=error.message) from None
+
+
+def _invalidate_prompts():
+    try:
+        sort_cache.invalidate("prompts:")
+    except Exception as error:
+        logger.warning("提示词排序缓存失效失败: error_type=%s", type(error).__name__)
+
+
+def _user_owns_prompt(db_session: Session, account: str, prompt_id: str) -> bool:
+    """检查用户是否已购买（未退款）该提示词"""
+    if not account:
+        return False
+    ownership = db_session.query(Ownership).filter(
+        Ownership.account == account,
+        Ownership.item_id == prompt_id,
+        Ownership.is_refunded == False
+    ).first()
+    return ownership is not None
+
+
+def _mask_prompt_text(prompt_data: dict, can_view: bool) -> dict:
+    """
+    🔒 内容脱敏核心逻辑：
+    未授权用户一律不下发 prompt_text（服务端脱敏，不依赖前端隐藏）
+    """
+    if can_view:
+        prompt_data["locked"] = False
+    else:
+        prompt_data["prompt_text"] = None
+        prompt_data["locked"] = True
+    return prompt_data
+
+
+# ==========================================
+# 📂 分类管理接口
+# ==========================================
+
+@router.get("/api/prompt-categories")
+@_prompts_endpoint
+def get_prompt_categories(prompt_type: str = None):
+    """
+    获取提示词分类列表
+    - prompt_type: image / video / music，不传则返回全部
+    """
+    categories = _prompt_operation(load_categories, db, DEFAULT_CATEGORIES)
+    if prompt_type in VALID_PROMPT_TYPES:
+        return {"status": "success", "data": categories.get(prompt_type, [])}
+    return {"status": "success", "data": categories}
+
+
+@router.post("/api/prompt-categories")
+@shared_limit(5)  # 🔒 限流：防止分类刷屏
+@_prompts_endpoint
+def add_prompt_category(request: Request, body: PromptCategoryAdd, current_user: str = Depends(require_auth)):
+    """
+    添加提示词分类（仅管理员，入口在云端管理界面，重名去重）
+    """
+    if not is_admin(current_user):
+        raise HTTPException(status_code=403, detail="需要管理员权限")
+    if body.prompt_type not in VALID_PROMPT_TYPES:
+        raise HTTPException(status_code=400, detail="分类所属类型必须是 image、video 或 music")
+
+    name = (body.name or "").strip()
+    if not name:
+        raise HTTPException(status_code=400, detail="分类名称不能为空")
+    if len(name) > MAX_CATEGORY_LEN:
+        raise HTTPException(status_code=400, detail=f"分类名称不能超过{MAX_CATEGORY_LEN}个字")
+
+    values = _prompt_operation(modify_category, db, DEFAULT_CATEGORIES, body.prompt_type, name, maximum=MAX_CATEGORY_PER_TYPE)
+    logger.info("PROMPT_CATEGORY_ADD | type=%s", body.prompt_type)
+    return {"status": "success", "data": values}
+
+
+@router.delete("/api/prompt-categories")
+@shared_limit(5)  # 🔒 限流：与添加分类一致
+@_prompts_endpoint
+def delete_prompt_category(request: Request, prompt_type: str = None, name: str = None,
+                                current_user: str = Depends(require_auth)):
+    """
+    删除提示词分类（仅管理员）
+    - prompt_type: image / video / music
+    - name: 分类名称
+    ⚠️ 已使用该分类的提示词不受影响（分类字段保留原文本，仅从可选列表移除）
+    """
+    if not is_admin(current_user):
+        raise HTTPException(status_code=403, detail="需要管理员权限")
+    if prompt_type not in VALID_PROMPT_TYPES:
+        raise HTTPException(status_code=400, detail="分类所属类型必须是 image、video 或 music")
+
+    name = (name or "").strip()
+    if not name:
+        raise HTTPException(status_code=400, detail="分类名称不能为空")
+
+    values = _prompt_operation(modify_category, db, DEFAULT_CATEGORIES, prompt_type, name, delete=True)
+    logger.info("PROMPT_CATEGORY_DELETE | type=%s", prompt_type)
+    return {"status": "success", "data": values}
+
+
+# ==========================================
+# 📝 提示词CRUD接口
+# ==========================================
+
+@router.get("/api/prompt-tags")
+@_prompts_endpoint
+def get_prompt_tags():
+    """
+    🏷️ 聚合全站标签（发布表单推荐用，按使用次数降序，最多返回100个）
+    """
+    prompts_db = db.load_data("prompts.json", default_data=[])
+    counter = {}
+    for prompt in prompts_db:
+        for tag in (prompt.get("tags") or []):
+            if isinstance(tag, str) and tag.strip():
+                counter[tag] = counter.get(tag, 0) + 1
+    ranked = sorted(counter.items(), key=lambda kv: (-kv[1], kv[0]))[:100]
+    return {"status": "success", "data": [{"name": n, "count": c} for n, c in ranked]}
+
+
+@router.get("/api/prompts")
+@_prompts_endpoint
+def get_prompts(prompt_type: str = None, category: str = None,
+                      page: int = 1, limit: int = 20, sort: str = "latest"):
+    """
+    获取提示词列表（分页，支持类型/分类筛选与多种排序）
+    - prompt_type: image / video / music（子界面筛选）
+    - category: 分类筛选
+    - sort: latest / likes / favorites / views / daily_views / tips
+    ⚠️ 列表接口永不下发 prompt_text（付费内容脱敏）
+    """
+    read_epoch = sort_cache.capture_read_epoch()
+    prompts_db = _prompt_operation(read_prompts, db)
+    users_db = read_public_source(db, "users.json", default_data={})
+    user_map = users_db
+
+    # 🗂️ 使用排序缓存优化排序性能
+    cache_sort = sort if sort in ("latest", "likes", "favorites", "views", "daily_views", "tips") else "latest"
+    cache_key = f"prompts:{cache_sort}"
+
+    def order_key(item):
+        if sort == "likes":
+            return item.get("likes", 0)
+        elif sort == "favorites":
+            return item.get("favorites", 0)
+        elif sort == "views":
+            return item.get("views", 0)
+        elif sort == "daily_views":
+            return item.get("daily_views", 0)
+        elif sort == "tips":
+            return sum(t.get("amount", 0) for t in item.get("tip_board", []))
+        else:  # latest 或其他默认
+            return item.get("created_at", 0)
+
+    def sort_fn(data):
+        data.sort(key=order_key, reverse=True)
+
+    sorted_prompts = sort_cache.get_sorted(cache_key, prompts_db, sort_fn, read_epoch=read_epoch, fresh=True)
+
+    # 类型与分类过滤
+    if prompt_type in VALID_PROMPT_TYPES:
+        sorted_prompts = [p for p in sorted_prompts if p.get("prompt_type") == prompt_type]
+    if category:
+        sorted_prompts = [p for p in sorted_prompts if p.get("category") == category]
+
+    # 分页
+    total = len(sorted_prompts)
+    start = (page - 1) * limit
+    end = start + limit
+    paged_prompts = sorted_prompts[start:end]
+
+    # 附加作者信息，并过滤敏感字段
+    result = []
+    for prompt in paged_prompts:
+        try:
+            prompt = project_price(prompt)
+        except Exception:
+            raise HTTPException(status_code=503, detail="提示词暂时不可读取") from None
+        author_info = user_map.get(prompt.get("author"), {})
+        prompt_data = {
+            **prompt,
+            "author_name": author_info.get("name", prompt.get("author")),
+            "author_avatar": author_info.get("avatarDataUrl", "")
+        }
+        # 🔒 脱敏：列表永不下发提示词正文与浏览记录
+        prompt_data.pop("prompt_text", None)
+        prompt_data.pop("viewed_by", None)
+        result.append(prompt_data)
+
+    attach_comment_counts(result)
+    return {
+        "status": "success",
+        "data": result,
+        "total": total,
+        "page": page,
+        "limit": limit
+    }
+
+
+@router.get("/api/my-prompts")
+@_prompts_endpoint
+def get_my_prompts(current_user: str = Depends(require_auth)):
+    """
+    获取我发布的提示词（个人中心用）
+    作者本人可见自己的 prompt_text
+    """
+    prompts_db = _prompt_operation(read_prompts, db)
+
+    my_prompts = [p for p in prompts_db if p.get("author") == current_user]
+    my_prompts = sorted(my_prompts, key=lambda x: x.get("created_at", 0), reverse=True)
+
+    result = []
+    for prompt in my_prompts:
+        try:
+            prompt = project_price(prompt)
+        except Exception:
+            raise HTTPException(status_code=503, detail="提示词暂时不可读取") from None
+        prompt_data = dict(prompt)
+        prompt_data.pop("viewed_by", None)
+        result.append(prompt_data)
+
+    attach_comment_counts(result)
+    return {"status": "success", "data": result}
+
+
+@router.get("/api/prompts/{prompt_id}")
+async def get_prompt_detail(prompt_id: str, current_user: str = Depends(optional_auth),
+                            db_session: Session = Depends(get_db)):
+    """
+    获取提示词详情
+    🔒 仅当 ①免费 ②作者本人 ③已购买 时下发 prompt_text
+    """
+    try:
+        prompts_db = db.load_data("prompts.json", default_data=[], strict=True, skip_cache=True)
+        if not isinstance(prompts_db, list):
+            raise ValueError("invalid prompt collection")
+    except Exception:
+        raise HTTPException(status_code=503, detail="提示词暂时不可读取")
+    users_db = db.load_data("users.json", default_data={})
+    user_map = users_db
+
+    for prompt in prompts_db:
+        if isinstance(prompt, dict) and prompt.get("id") == prompt_id:
+            try:
+                price = effective_resource_price(prompt)
+            except Exception:
+                raise HTTPException(status_code=503, detail="提示词暂时不可读取")
+
+            author_info = user_map.get(prompt.get("author"), {})
+            prompt_data = {
+                **prompt,
+                "price": price,
+                "author_name": author_info.get("name", prompt.get("author")),
+                "author_avatar": author_info.get("avatarDataUrl", "")
+            }
+            prompt_data.pop("viewed_by", None)
+
+            is_author = current_user and current_user == prompt.get("author")
+            can_view = price <= 0 or is_author or _user_owns_prompt(db_session, current_user, prompt_id)
+            prompt_data["owned"] = bool(can_view)
+            prompt_data["price_confirmation_supported"] = True
+            _mask_prompt_text(prompt_data, can_view)
+
+            attach_comment_counts([prompt_data])
+            return {"status": "success", "data": prompt_data}
+
+    raise HTTPException(status_code=404, detail="提示词不存在")
+
+
+@router.post("/api/prompts")
+@shared_limit(5)
+@_prompts_endpoint
+def create_prompt(request: Request, prompt: PromptCreate, current_user: str = Depends(require_auth)):
+    """
+    发布提示词
+    """
+    try:
+        stable_id = publication_identity('prompt', current_user, getattr(request, 'headers', {}).get('Idempotency-Key'))
+    except ValueError:
+        raise HTTPException(status_code=400, detail='发布请求身份无效') from None
+
+    # 参数校验
+    if prompt.prompt_type not in VALID_PROMPT_TYPES:
+        raise HTTPException(status_code=400, detail="提示词类型必须是 image、video 或 music")
+    title = (prompt.title or "").strip()
+    content = (prompt.content or "").strip()
+    prompt_text = (prompt.prompt_text or "").strip()
+    category = (prompt.category or "").strip()
+    if not title or not content or not prompt_text:
+        raise HTTPException(status_code=400, detail="标题、介绍文案与提示词正文均不能为空")
+    if len(title) > MAX_TITLE_LEN:
+        raise HTTPException(status_code=400, detail=f"标题不能超过{MAX_TITLE_LEN}个字")
+    if len(content) > MAX_CONTENT_LEN:
+        raise HTTPException(status_code=400, detail=f"介绍文案不能超过{MAX_CONTENT_LEN}个字")
+    if len(prompt_text) > MAX_PROMPT_TEXT_LEN:
+        raise HTTPException(status_code=400, detail=f"提示词正文不能超过{MAX_PROMPT_TEXT_LEN}个字")
+    if not category:
+        raise HTTPException(status_code=400, detail="请选择分类")
+
+    # 分类必须存在于分类库
+    categories = _prompt_operation(load_categories, db, DEFAULT_CATEGORIES)
+    if category not in categories.get(prompt.prompt_type, []):
+        raise HTTPException(status_code=400, detail="所选分类不存在")
+
+    price = prompt.price
+    if type(price) is not int or not 0 <= price <= MAX_PRICE:
+        raise HTTPException(status_code=400, detail=f"定价必须在0-{MAX_PRICE}之间")
+
+    media_type = prompt.media_type if prompt.media_type in ("image", "video") else "image"
+    video_url = prompt.video_url if media_type == "video" else None
+    if media_type == "video" and not video_url:
+        # 未上传示例视频时降级为图片展示
+        media_type = "image"
+
+    # 图像提示词的图片列表（首张即封面）；视频提示词不保留图片列表
+    images = _sanitize_images(prompt.images) if media_type == "image" else []
+
+    # 🎵 音乐提示词支持音频示例（图片+音频方案，视频可选）；非音乐类型不保留
+    audio_url = (prompt.audio_url or "").strip() or None
+    if prompt.prompt_type != "music":
+        audio_url = None
+
+    new_prompt = {
+        "id": stable_id or f"prompt_{int(time.time())}_{uuid.uuid4().hex}",
+        "prompt_type": prompt.prompt_type,
+        "category": category,
+        "title": title,
+        "content": content,
+        "prompt_text": prompt_text,
+        "cover_image": prompt.cover_image,
+        "media_type": media_type,
+        "video_url": video_url,
+        "audio_url": audio_url,
+        "images": images,
+        "is_original": bool(prompt.is_original),
+        "price": price,
+        "author": current_user,
+        "created_at": int(time.time()),
+        # 互动数据
+        "likes": 0,
+        "favorites": 0,
+        "comments": 0,
+        "liked_by": [],
+        "favorited_by": [],
+        "tip_board": [],  # 打赏榜单
+        "views": 0,
+        "daily_views": 0,
+        "viewed_by": [],
+        "daily_views_date": "",
+        "tags": _sanitize_tags(prompt.tags)
+    }
+
+    new_prompt = _prompt_operation(publish_prompt, db, new_prompt, stable_id is not None)
+    _invalidate_prompts()
+
+    return {"status": "success", "data": new_prompt}
+
+
+@router.put("/api/prompts/{prompt_id}")
+@shared_limit(10)
+@_prompts_endpoint
+def update_prompt(request: Request, prompt_id: str, update_data: PromptUpdate, current_user: str = Depends(require_auth)):
+    """
+    更新提示词（仅作者可操作，原子操作，并发安全）
+    """
+    error_map = {
+        "forbidden": (403, "无权修改他人提示词"),
+        "not_found": (404, "提示词不存在"),
+        "invalid_title": (400, f"标题不能为空且不能超过{MAX_TITLE_LEN}个字"),
+        "invalid_content": (400, f"介绍文案不能超过{MAX_CONTENT_LEN}个字"),
+        "invalid_prompt_text": (400, "提示词正文不能为空且长度超限"),
+        "invalid_category": (400, "所选分类不存在"),
+        "invalid_price": (400, f"定价必须在0-{MAX_PRICE}之间"),
+        "invalid_media_type": (400, "媒体类型必须是 image 或 video")
+    }
+    categories = _prompt_operation(load_categories, db, DEFAULT_CATEGORIES) if update_data.category is not None else None
+
+    def apply(prompt):
+        # 更新字段
+        if update_data.title is not None:
+            title = update_data.title.strip()
+            if not title or len(title) > MAX_TITLE_LEN:
+                raise PromptStoreError(*error_map["invalid_title"])
+            prompt["title"] = title
+        if update_data.content is not None:
+            content = update_data.content.strip()
+            if len(content) > MAX_CONTENT_LEN:
+                raise PromptStoreError(*error_map["invalid_content"])
+            prompt["content"] = content
+        if update_data.prompt_text is not None:
+            prompt_text = update_data.prompt_text.strip()
+            if not prompt_text or len(prompt_text) > MAX_PROMPT_TEXT_LEN:
+                raise PromptStoreError(*error_map["invalid_prompt_text"])
+            prompt["prompt_text"] = prompt_text
+        if update_data.category is not None:
+            category = update_data.category.strip()
+            if category not in categories.get(prompt.get("prompt_type"), []):
+                raise PromptStoreError(*error_map["invalid_category"])
+            prompt["category"] = category
+        if update_data.cover_image is not None:
+            prompt["cover_image"] = update_data.cover_image
+        if update_data.price is not None:
+            price = update_data.price
+            if type(price) is not int or not 0 <= price <= MAX_PRICE:
+                raise PromptStoreError(*error_map["invalid_price"])
+            current_price = effective_resource_price(prompt)
+            if current_price != price:
+                # 设置待生效价格，24小时后生效（与资源改价机制同构；提示词不支持退款，无需禁购配套）
+                effective_time = datetime.datetime.now() + datetime.timedelta(hours=24)
+                prompt["pending_price"] = price
+                prompt["pending_price_effective_at"] = effective_time.isoformat()
+                # 不立即修改 price，等待24小时后生效
+            else:
+                # 价格未变，清除待生效价格
+                prompt["pending_price"] = None
+                prompt["pending_price_effective_at"] = None
+        if update_data.media_type is not None:
+            if update_data.media_type not in ("image", "video"):
+                raise PromptStoreError(*error_map["invalid_media_type"])
+            prompt["media_type"] = update_data.media_type
+            if update_data.media_type == "image":
+                # 图像类型不保留视频（与 create 逻辑一致）
+                prompt["video_url"] = None
+        if update_data.video_url is not None:
+            prompt["video_url"] = update_data.video_url
+            if update_data.video_url:
+                prompt["media_type"] = "video"
+        if update_data.audio_url is not None or "audio_url" in getattr(update_data, "model_fields_set", set()):
+            # 🎵 音频仅音乐提示词保留；显式空字符串/null 清除，未传保持
+            audio_url = (update_data.audio_url or "").strip() or None
+            prompt["audio_url"] = audio_url if prompt.get("prompt_type") == "music" else None
+        if update_data.images is not None:
+            prompt["images"] = _sanitize_images(update_data.images)
+        if update_data.is_original is not None:
+            prompt["is_original"] = bool(update_data.is_original)
+        if update_data.tags is not None:
+            prompt["tags"] = _sanitize_tags(update_data.tags)
+        if prompt.get("media_type") == "image":
+            prompt["video_url"] = None
+        else:
+            prompt["images"] = []
+
+    _prompt_operation(edit_prompt, db, prompt_id, current_user, apply)
+    _invalidate_prompts()
+    return {"status": "success"}
+
+
+@router.delete("/api/prompts/{prompt_id}")
+@shared_limit(10)
+@_prompts_endpoint
+def delete_prompt(request: Request, prompt_id: str, current_user: str = Depends(require_auth)):
+    """
+    删除提示词（仅作者可操作）
+    """
+    _prompt_operation(remove_prompt, db, prompt_id, current_user)
+    _invalidate_prompts()
+    return {"status": "success"}
+
+
+# ==========================================
+# ❤️ 互动接口（点赞/收藏）
+# ==========================================
+
+@router.post("/api/prompts/{prompt_id}/like")
+@shared_limit(30)
+@_prompts_endpoint
+def toggle_like(request: Request, prompt_id: str, current_user: str = Depends(require_auth)):
+    """
+    点赞/取消点赞（原子操作，并发安全）
+    """
+    result_container = [None]
+
+    def updater(data):
+        for prompt in data:
+            if prompt["id"] == prompt_id:
+                liked_by = prompt.get("liked_by", [])
+                if current_user in liked_by:
+                    liked_by.remove(current_user)
+                    prompt["likes"] = max(0, prompt.get("likes", 0) - 1)
+                    action = "unliked"
+                else:
+                    liked_by.append(current_user)
+                    prompt["likes"] = prompt.get("likes", 0) + 1
+                    action = "liked"
+                prompt["liked_by"] = liked_by
+                result_container[0] = {"status": "success", "action": action, "likes": prompt["likes"]}
+                return
+        result_container[0] = None  # 未找到提示词
+
+    db.atomic_update("prompts.json", updater, default_data=[])
+
+    if result_container[0] is None:
+        raise HTTPException(status_code=404, detail="提示词不存在")
+
+    # 🗂️ 清除排序缓存（点赞数变化可能影响排序）
+    sort_cache.invalidate("prompts:")
+
+    return result_container[0]
+
+
+@router.post("/api/prompts/{prompt_id}/favorite")
+@shared_limit(30)
+@_prompts_endpoint
+def toggle_favorite(request: Request, prompt_id: str, current_user: str = Depends(require_auth)):
+    """
+    收藏/取消收藏（原子操作，并发安全）
+    """
+    result_container = [None]
+
+    def updater(data):
+        for prompt in data:
+            if prompt["id"] == prompt_id:
+                favorited_by = prompt.get("favorited_by", [])
+                if current_user in favorited_by:
+                    favorited_by.remove(current_user)
+                    prompt["favorites"] = max(0, prompt.get("favorites", 0) - 1)
+                    action = "unfavorited"
+                else:
+                    favorited_by.append(current_user)
+                    prompt["favorites"] = prompt.get("favorites", 0) + 1
+                    action = "favorited"
+                prompt["favorited_by"] = favorited_by
+                result_container[0] = {"status": "success", "action": action, "favorites": prompt["favorites"]}
+                return
+        result_container[0] = None  # 未找到提示词
+
+    db.atomic_update("prompts.json", updater, default_data=[])
+
+    if result_container[0] is None:
+        raise HTTPException(status_code=404, detail="提示词不存在")
+
+    # 🗂️ 清除排序缓存（收藏数变化可能影响排序）
+    sort_cache.invalidate("prompts:")
+
+    return result_container[0]
+
+
+# ==========================================
+# 🎁 打赏接口
+# ==========================================
+
+@router.post("/api/prompts/{prompt_id}/tip")
+@shared_limit(10)
+async def tip_prompt(request: Request, prompt_id: str, amount: int, is_anon: bool = False,
+                     current_user: str = Depends(require_auth), db_session: Session = Depends(get_db)):
+    """
+    打赏提示词（原子操作，并发安全）- 使用 SQL Wallet 系统
+    """
+    if amount <= 0:
+        raise HTTPException(status_code=400, detail="打赏金额必须大于0")
+    MAX_TIP_AMOUNT = 100000
+    if amount > MAX_TIP_AMOUNT:
+        raise HTTPException(status_code=400, detail=f"打赏金额必须在1-{MAX_TIP_AMOUNT}之间")
+
+    # 🔒 P0数据修复（时序）：先只读校验 → SQL转账扣款 → 提交成功后再写打赏榜
+    # 避���余额不足/重复请求时榜单已被更新的数据不一致
+    prompts_db_ro = db.load_data("prompts.json", default_data=[])
+    target_prompt = next((p for p in prompts_db_ro if p["id"] == prompt_id), None)
+    if not target_prompt:
+        raise HTTPException(status_code=404, detail="提示词不存在")
+    if target_prompt.get("author") == current_user:
+        raise HTTPException(status_code=400, detail="不能打赏自己的提示词")
+    author = target_prompt.get("author")
+    if not author:
+        raise HTTPException(status_code=404, detail="作者账户不存在")
+    prompt_title = target_prompt.get("title")
+
+    # 💳 使用 SQL Wallet 系统处理余额转账（先扣款）
+    try:
+
+        # 🔒 并发安全：使用悲观锁获取双方钱包
+        tipper_wallet, author_wallet = lock_tip_wallets(db_session, current_user, author)
+        # 🔒 P1幂等性防护：检查最近5秒内是否存在相同交易
+        recent_cutoff = datetime.datetime.utcnow() - datetime.timedelta(seconds=5)
+        duplicate_tx = db_session.query(Transaction).filter(
+            Transaction.account == current_user,
+            Transaction.tx_type == "TIP_OUT",
+            Transaction.amount == -amount,
+            Transaction.related_account == author,
+            Transaction.item_id == prompt_id,
+            Transaction.item_type == "prompt",
+            Transaction.created_at >= recent_cutoff
+        ).with_for_update().first()
+        if duplicate_tx:
+            db_session.rollback()  # 重复请求释放锁，不执行任何后续操作
+            return {"status": "success", "message": "打赏已处理（重复请求）"}
+
+        if not tipper_wallet or tipper_wallet.balance < amount:
+            raise HTTPException(status_code=400, detail="余额不足")
+
+        # 执行转账
+        tipper_wallet.balance -= amount
+        author_wallet.balance += amount         # 实际收入进统一余额
+        author_wallet.tip_balance += amount     # 累计打赏收益统计（只增不减）
+
+        # 创建交易记录
+        tx_id_tipper = f"TIP_OUT_{int(time.time())}_{uuid.uuid4().hex[:6]}"
+        tx_id_author = f"TIP_IN_{int(time.time())}_{uuid.uuid4().hex[:6]}"
+
+        # 获取最后交易记录的哈希
+        last_tx_tipper = db_session.query(Transaction).filter(Transaction.account == current_user).order_by(Transaction.created_at.desc()).first()
+        last_tx_author = db_session.query(Transaction).filter(Transaction.account == author).order_by(Transaction.created_at.desc()).first()
+        prev_hash_tipper = last_tx_tipper.tx_hash if last_tx_tipper else "GENESIS_HASH"
+        prev_hash_author = last_tx_author.tx_hash if last_tx_author else "GENESIS_HASH"
+
+        # 获取用户信息（prompt_title 已在预校验阶段取得）
+        users_db = db.load_data("users.json", default_data={})
+        author_info = users_db.get(author, {})
+        tipper_info = users_db.get(current_user, {})
+        author_name = author_info.get("name", author)
+        tipper_name = tipper_info.get("name", current_user)
+
+        # 打赏方交易记录 (TIP_OUT)
+        tx_tipper = Transaction(
+            tx_id=tx_id_tipper,
+            account=current_user,
+            tx_type="TIP_OUT",
+            amount=-amount,
+            related_account=author,
+            item_id=prompt_id,
+            prev_hash=prev_hash_tipper,
+            tx_hash=calculate_tx_hash(tx_id_tipper, current_user, "TIP_OUT", -amount, prev_hash_tipper),
+            description=f"打赏给 {author_name}" + (f" 的提示词《{prompt_title}》" if prompt_title else ""),
+            item_title=prompt_title,
+            item_type="prompt",
+            related_user_name=author_name
+        )
+
+        # 接收方交易记录 (TIP_IN)
+        tx_author = Transaction(
+            tx_id=tx_id_author,
+            account=author,
+            tx_type="TIP_IN",
+            amount=amount,
+            related_account=current_user,
+            item_id=prompt_id,
+            prev_hash=prev_hash_author,
+            tx_hash=calculate_tx_hash(tx_id_author, author, "TIP_IN", amount, prev_hash_author),
+            description=f"收到 {tipper_name} 的提示词打赏" + (f" ({prompt_title})" if prompt_title else ""),
+            item_title=prompt_title,
+            item_type="prompt",
+            related_user_name=tipper_name if not is_anon else "匿名用户"
+        )
+
+        db_session.add(tx_tipper)
+        db_session.add(tx_author)
+        db_session.commit()
+
+        # 📝 审计日志
+        logger.info("PROMPT_TIP")
+
+    except HTTPException:
+        db_session.rollback()
+        raise
+    except Exception as e:
+        db_session.rollback()
+        logger.error("PROMPT_TIP_ERROR | error_type=%s", type(e).__name__)
+        raise HTTPException(status_code=500, detail="打赏处理失败，请稍后重试")
+
+    def notify_tip():
+        # 🔔 打赏通知（考虑匿名）
+        if not is_anon:
+            add_notification(author, {
+                "type": "tip",
+                "from_user": current_user,
+                "target_item_id": prompt_id,
+                "target_item_title": prompt_title or "",
+                "content": f"您收到来自 {tipper_name} 的 {amount} 积分提示词打赏"
+            })
+        else:
+            add_notification(author, {
+                "type": "tip",
+                "from_user": "anonymous",
+                "target_item_id": prompt_id,
+                "target_item_title": "",
+                "content": f"您收到了一份 {amount} 积分的匿名提示词打赏"
+            })
+
+    run_tip_effect(notify_tip)
+    run_tip_effect(lambda: sort_cache.invalidate("prompts:"))
+
+    # 🏆 扣款成功后再写打赏榜（写榜失败仅记录日志，不影响资金安全）
+    def board_updater(data):
+        for prompt in data:
+            if prompt["id"] == prompt_id:
+                tip_board = prompt.get("tip_board", [])
+                existing = next((t for t in tip_board if t["account"] == current_user), None)
+                if existing:
+                    existing["amount"] += amount
+                else:
+                    tip_board.append({"account": current_user, "amount": amount, "is_anon": is_anon})
+                tip_board.sort(key=lambda x: x["amount"], reverse=True)
+                prompt["tip_board"] = tip_board
+                break
+
+    try:
+        db.atomic_update("prompts.json", board_updater, default_data=[])
+    except Exception as e:
+        logger.error("PROMPT_TIP_BOARD_ERROR | error_type=%s", type(e).__name__)
+
+    return {"status": "success", "message": f"成功打赏 {amount} 积分"}
+
+
+# ==========================================
+# 🛒 购买解锁接口
+# ==========================================
+
+@router.post("/api/prompts/{prompt_id}/purchase")
+@shared_limit(10)  # 🔒 P0安全优化：购买每分钟最多10次
+async def purchase_prompt(request: Request, prompt_id: str,
+                          purchase: Optional[PromptPurchaseRequest] = None,
+                          current_user: str = Depends(require_auth), db_session: Session = Depends(get_db)):
+    """资金与所有权原子提交；通知失败不改变已提交的购买结果。"""
+    try:
+        prompts_db = db.load_data("prompts.json", default_data=[], strict=True, skip_cache=True)
+        if not isinstance(prompts_db, list):
+            raise ValueError("invalid prompt collection")
+        prompt = next((p for p in prompts_db if isinstance(p, dict) and p.get("id") == prompt_id), None)
+        if prompt is None:
+            raise HTTPException(status_code=404, detail="提示词不存在")
+        price = effective_resource_price(prompt)
+        seller_account = prompt.get("author")
+        prompt_text = prompt.get("prompt_text")
+        if not isinstance(seller_account, str) or not seller_account.strip() or not isinstance(prompt_text, str):
+            raise ValueError("invalid prompt delivery")
+        response = {"status": "success", "already_owned": True, "prompt_text": prompt_text}
+    except HTTPException:
+        raise
+    except Exception as error:
+        logger.error("PROMPT_PURCHASE_SOURCE_ERROR | error_type=%s", type(error).__name__)
+        raise HTTPException(status_code=503, detail="提示词暂时不可购买")
+
+    # 非资金展示资料在写锁外读取；失败不影响正文交付或交易。
+    try:
+        users_db = db.load_data("users.json", default_data={})
+        seller_info = users_db.get(seller_account, {})
+        buyer_info = users_db.get(current_user, {})
+        seller_user_name = seller_info.get("name", seller_account)
+        buyer_user_name = buyer_info.get("name", current_user)
+    except Exception:
+        seller_user_name, buyer_user_name = seller_account, current_user
+
+    free = price == 0 or current_user == seller_account
+    try:
+        # 必须是本次事务的第一项 SQL；SQLite 使用 BEGIN IMMEDIATE。
+        buyer_wallet, seller_wallet = lock_resource_purchase_wallets(
+            db_session, current_user, seller_account, free)
+        owned = db_session.query(Ownership).filter(
+            Ownership.account == current_user,
+            Ownership.item_id == prompt_id,
+            Ownership.is_refunded == False
+        ).first()
+        if owned:
+            db_session.rollback()
+            return response
+        if free:
+            db_session.add(Ownership(account=current_user, item_id=prompt_id, price_paid=0))
+            db_session.commit()
+            return response
+        expected_price = getattr(purchase, "expected_price", None)
+        if expected_price is None:
+            raise HTTPException(status_code=428, detail="purchase_price_confirmation_required")
+        if isinstance(expected_price, bool) or not isinstance(expected_price, int) or expected_price < 0:
+            raise HTTPException(status_code=422, detail="purchase_price_invalid")
+        if expected_price != price:
+            raise HTTPException(status_code=409, detail="purchase_price_changed")
+        if buyer_wallet is None or buyer_wallet.balance < price:
+            raise HTTPException(status_code=402, detail="余额不足，请先充值")
+        for amount in (buyer_wallet.balance, seller_wallet.balance, seller_wallet.earn_balance):
+            if isinstance(amount, bool) or not isinstance(amount, int):
+                raise ValueError("invalid wallet amount")
+        buyer_wallet.balance -= price
+        seller_wallet.balance += price
+        seller_wallet.earn_balance += price
+        db_session.add(Ownership(account=current_user, item_id=prompt_id, price_paid=price))
+
+        for account, other, tx_type, amount, user_name, description in (
+            (current_user, seller_account, "PURCHASE", -price, seller_user_name,
+             f"购买提示词 {prompt.get('title', '未知提示词')}"),
+            (seller_account, current_user, "SALE", price, buyer_user_name,
+             f"销售收入: {prompt.get('title', prompt_id)}")
+        ):
+            last_tx = db_session.query(Transaction).filter(Transaction.account == account).order_by(
+                Transaction.created_at.desc(), Transaction.tx_id.desc()).with_for_update().first()
+            prev_hash = last_tx.tx_hash if last_tx else "GENESIS_HASH"
+            tx_id = f"{tx_type}_{uuid.uuid4().hex}"
+            db_session.add(Transaction(
+                tx_id=tx_id, account=account, tx_type=tx_type, amount=amount,
+                related_account=other, item_id=prompt_id, prev_hash=prev_hash,
+                tx_hash=calculate_tx_hash(tx_id, account, tx_type, amount, prev_hash),
+                description=description, item_title=prompt.get("title", ""),
+                item_type="prompt", related_user_name=user_name))
+        response["already_owned"] = False
+        db_session.commit()
+    except HTTPException:
+        db_session.rollback()
+        raise
+    except Exception as error:
+        db_session.rollback()
+        logger.error("PROMPT_PURCHASE_ERROR | error_type=%s", type(error).__name__)
+        raise HTTPException(status_code=500, detail="购买处理失败，请稍后重试")
+
+    run_tip_effect(lambda: logger.info("PROMPT_PURCHASE_COMPLETED"))
+    run_tip_effect(lambda: add_notification(seller_account, {
+        "type": "purchase", "from_user": current_user,
+        "target_item_id": prompt_id, "target_item_title": prompt.get("title", ""),
+        "content": f"您的提示词《{prompt.get('title', '')}》已被购买"
+    }))
+    return response
+
+
+# ==========================================
+# 💬 评论接口（复用通用评论存储 comments.json）
+# ==========================================
+
+@router.get("/api/prompts/{prompt_id}/comments")
+async def get_prompt_comments(prompt_id: str):
+    """获取评论；有界后台读取并保留原作者附加字段。"""
+    return {"status": "success", "data": await read_comment_view(prompt_id)}
+
+@router.post("/api/prompts/{prompt_id}/comments")
+@shared_limit(10)
+@_prompts_endpoint
+def add_prompt_comment(request: Request, prompt_id: str, content: str, current_user: str = Depends(require_auth)):
+    """
+    添加提示词评论
+    """
+    if not content or not content.strip():
+        raise HTTPException(status_code=400, detail="评论内容不能为空")
+    if len(content) > COMMENT_MAX_LENGTH:
+        raise HTTPException(status_code=400, detail="评论长度必须在1-5000字符之间")
+
+    prompts_db = db.load_data("prompts.json", default_data=[])
+
+    # 检查提示词是否存在
+    prompt_exists = any(p["id"] == prompt_id for p in prompts_db)
+    if not prompt_exists:
+        raise HTTPException(status_code=404, detail="提示词不存在")
+
+    new_comment = {
+        "id": f"comment_{int(time.time())}_{uuid.uuid4().hex[:6]}",
+        "author": current_user,
+        "content": content.strip(),
+        "created_at": int(time.time())
+    }
+
+    append_comment(prompt_id, new_comment, prepend=True)
+    increment_comment_count("prompts.json", prompt_id)
+
+    # 🗂️ 清除排序缓存（评论数变化可能影响排序）
+    sort_cache.invalidate("prompts:")
+
+    return {"status": "success", "data": new_comment}
+
+
+@router.post("/api/prompts/{prompt_id}/view")
+@shared_limit(60)
+@_prompts_endpoint
+def record_prompt_view(request: Request, prompt_id: str, current_user: str = Depends(require_auth)):
+    """
+    记录提示词访问量
+    👁️ 需要用户认证，每个用户只计算一次总访问量，日访问量每次调用都增加
+    """
+    result = record_view("prompts.json", prompt_id, current_user)
+
+    if result is None:
+        raise HTTPException(status_code=404, detail="提示词不存在")
+
+    # 🗂️ 清除排序缓存（浏览量变化可能影响排序）
+    sort_cache.invalidate("prompts:")
+
+    return {"status": "success", "views": result["views"], "daily_views": result["daily_views"]}