From ebf9cd31d789c0556d741987e95a961edd2955d0 Mon Sep 17 00:00:00 2001
From: Rider Linden <rider@lindenlab.com>
Date: Wed, 5 Aug 2026 17:15:43 -0700
Subject: Move object publishing tracking to its own manager in the viewer.

---
 indra/newview/llpublishedobjectmgr.cpp | 838 +++++++++++++++++++++++++++++++++
 1 file changed, 838 insertions(+)
 create mode 100644 indra/newview/llpublishedobjectmgr.cpp

(limited to 'indra/newview/llpublishedobjectmgr.cpp')

diff --git a/indra/newview/llpublishedobjectmgr.cpp b/indra/newview/llpublishedobjectmgr.cpp
new file mode 100644
index 0000000000..2c2eff58a5
--- /dev/null
+++ b/indra/newview/llpublishedobjectmgr.cpp
@@ -0,0 +1,838 @@
+/**
+ * @file llpublishedobjectmgr.cpp
+ * @brief Published object state/logic manager extracted from llscripteditorws
+ *
+ * $LicenseInfo:firstyear=2026&license=viewerlgpl$
+ * Second Life Viewer Source Code
+ * Copyright (C) 2026, Linden Research, Inc.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation;
+ * version 2.1 of the License only.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
+ * $/LicenseInfo$
+ */
+
+#include "llviewerprecompiledheaders.h"
+#include "llpublishedobjectmgr.h"
+
+#include "llscripteditorws.h"
+
+#include "llinventorydefines.h"
+#include "llselectmgr.h"
+#include "llviewerinventory.h"
+#include "llviewerobject.h"
+#include "llviewerobjectlist.h"
+#include "llviewerregion.h"
+#include "llvoinventorylistener.h"
+
+namespace
+{
+    std::string nv_string(LLViewerObject* obj, const char* key)
+    {
+        if (!obj)
+        {
+            return std::string();
+        }
+        LLNameValue* nv = obj->getNVPair(key);
+        if (!nv)
+        {
+            return std::string();
+        }
+        const char* s = nv->getString();
+        if (!s || s[0] == '\0')
+        {
+            return std::string();
+        }
+        return std::string(s);
+    }
+
+    std::string get_prim_name(LLViewerObject* obj)
+    {
+        std::string name = nv_string(obj, "Name");
+        if (!name.empty())
+        {
+            return name;
+        }
+
+        if (!obj)
+        {
+            return std::string();
+        }
+
+        LLSelectNode* node = LLSelectMgr::instance().getSelection()->findNode(obj);
+        return (node && !node->mName.empty()) ? node->mName : std::string();
+    }
+}
+
+class LLPublishedPrimListener : public LLVOInventoryListener
+{
+public:
+    LLPublishedPrimListener(LLScriptEditorWSServer* server, const LLUUID& object_id, const LLUUID& prim_id,
+                            LLViewerObject* object)
+        : mServer(server)
+        , mObjectID(object_id)
+        , mPrimID(prim_id)
+    {
+        registerVOInventoryListener(object, nullptr);
+    }
+
+    ~LLPublishedPrimListener() override = default;
+
+    void inventoryChanged(LLViewerObject* object,
+                         LLInventoryObject::object_list_t* inventory,
+                         S32 serial_num, void* user_data) override
+    {
+        if (mServer)
+        {
+            if (mServer->isObjectPublished(mObjectID))
+            {
+                mServer->onPrimInventoryChanged(mObjectID, mPrimID);
+            }
+            else
+            {
+                mServer->onPrimInventoryReady(mObjectID, mPrimID);
+            }
+        }
+    }
+
+    const LLUUID& getObjectID() const { return mObjectID; }
+    const LLUUID& getPrimID() const { return mPrimID; }
+
+private:
+    LLScriptEditorWSServer* mServer;
+    LLUUID                  mObjectID;
+    LLUUID                  mPrimID;
+};
+
+LLPublishedObjectMgr::LLPublishedObjectMgr(LLScriptEditorWSServer* server)
+    : mServer(server)
+{
+}
+
+LLPublishedObjectMgr::~LLPublishedObjectMgr() = default;
+
+LLPublishedObjectMgr::PublishedObjectInfo::PublishedObjectInfo() = default;
+LLPublishedObjectMgr::PublishedObjectInfo::~PublishedObjectInfo() = default;
+LLPublishedObjectMgr::PublishedObjectInfo::PublishedObjectInfo(PublishedObjectInfo&&) noexcept = default;
+LLPublishedObjectMgr::PublishedObjectInfo& LLPublishedObjectMgr::PublishedObjectInfo::operator=(PublishedObjectInfo&&) noexcept = default;
+
+LLPublishedObjectMgr::PendingPublish::PendingPublish() = default;
+LLPublishedObjectMgr::PendingPublish::~PendingPublish() = default;
+LLPublishedObjectMgr::PendingPublish::PendingPublish(PendingPublish&&) noexcept = default;
+LLPublishedObjectMgr::PendingPublish& LLPublishedObjectMgr::PendingPublish::operator=(PendingPublish&&) noexcept = default;
+
+void LLPublishedObjectMgr::beginPendingPublish(const LLUUID& object_id, const std::vector<LLViewerObject*>& prims)
+{
+    PendingPublish pending;
+    pending.mObjectID = object_id;
+    for (LLViewerObject* prim : prims)
+    {
+        pending.mPendingPrims.insert(prim->getID());
+        auto listener = std::make_unique<LLPublishedPrimListener>(
+            mServer, object_id, prim->getID(), prim);
+        pending.mListeners.push_back(std::move(listener));
+    }
+    mPendingPublishes[object_id] = std::move(pending);
+}
+
+bool LLPublishedObjectMgr::hasPendingPublish(const LLUUID& object_id) const
+{
+    return mPendingPublishes.find(object_id) != mPendingPublishes.end();
+}
+
+bool LLPublishedObjectMgr::markPendingPublishPrimReady(const LLUUID& object_id, const LLUUID& prim_id)
+{
+    auto it = mPendingPublishes.find(object_id);
+    if (it == mPendingPublishes.end())
+    {
+        return false;
+    }
+
+    it->second.mPendingPrims.erase(prim_id);
+    return it->second.mPendingPrims.empty();
+}
+
+std::vector<std::unique_ptr<LLPublishedPrimListener>> LLPublishedObjectMgr::takePendingPublishListeners(const LLUUID& object_id)
+{
+    auto it = mPendingPublishes.find(object_id);
+    if (it == mPendingPublishes.end())
+    {
+        return {};
+    }
+
+    auto listeners = std::move(it->second.mListeners);
+    mPendingPublishes.erase(it);
+    return listeners;
+}
+
+void LLPublishedObjectMgr::cancelPendingPublish(const LLUUID& object_id)
+{
+    mPendingPublishes.erase(object_id);
+}
+
+void LLPublishedObjectMgr::cancelPendingPublishWithCleanup(const LLUUID& object_id)
+{
+    auto it = mPendingPublishes.find(object_id);
+    if (it == mPendingPublishes.end())
+    {
+        return;
+    }
+
+    it->second.mListeners.clear();
+    mPendingPublishes.erase(it);
+}
+
+LLPublishedObjectMgr::PublishedObjectInfo* LLPublishedObjectMgr::getPublished(const LLUUID& object_id)
+{
+    auto it = mPublishedObjects.find(object_id);
+    if (it == mPublishedObjects.end())
+    {
+        return nullptr;
+    }
+
+    return &it->second;
+}
+
+const LLPublishedObjectMgr::PublishedObjectInfo* LLPublishedObjectMgr::getPublished(const LLUUID& object_id) const
+{
+    auto it = mPublishedObjects.find(object_id);
+    if (it == mPublishedObjects.end())
+    {
+        return nullptr;
+    }
+
+    return &it->second;
+}
+
+bool LLPublishedObjectMgr::reservePendingItemCreate(const LLUUID& prim_id, std::string&& pump_name)
+{
+    auto it = mPendingItemCreates.find(prim_id);
+    if (it != mPendingItemCreates.end())
+    {
+        return false;
+    }
+
+    mPendingItemCreates[prim_id] = std::move(pump_name);
+    return true;
+}
+
+bool LLPublishedObjectMgr::consumePendingItemCreate(const LLUUID& prim_id, std::string& pump_name)
+{
+    auto it = mPendingItemCreates.find(prim_id);
+    if (it == mPendingItemCreates.end())
+    {
+        return false;
+    }
+
+    pump_name = it->second;
+    mPendingItemCreates.erase(it);
+    return true;
+}
+
+void LLPublishedObjectMgr::clearPendingItemCreate(const LLUUID& prim_id)
+{
+    mPendingItemCreates.erase(prim_id);
+}
+
+LLSD LLPublishedObjectMgr::buildPrimInventoryLLSD(LLViewerObject* object) const
+{
+    LL_PROFILE_ZONE_SCOPED_CATEGORY_SCRIPTDEV;
+    LLSD items = LLSD::emptyArray();
+    if (!object)
+    {
+        return items;
+    }
+
+    LLInventoryObject::object_list_t contents;
+    object->getInventoryContents(contents);
+
+    for (const auto& obj : contents)
+    {
+        LLInventoryItem* item = dynamic_cast<LLInventoryItem*>(obj.get());
+        if (!item)
+        {
+            continue;
+        }
+
+        LLAssetType::EType type = item->getType();
+        if (type != LLAssetType::AT_LSL_TEXT && type != LLAssetType::AT_NOTECARD)
+        {
+            continue;
+        }
+
+        LLSD entry;
+        entry["item_id"]     = item->getUUID();
+        entry["name"]        = item->getName();
+        entry["description"] = item->getDescription();
+        entry["type"]        = (type == LLAssetType::AT_LSL_TEXT) ? "script" : "notecard";
+
+        if (type == LLAssetType::AT_LSL_TEXT)
+        {
+            U8 subtype = item->getInventorySubType();
+            entry["subtype"] = static_cast<S32>(subtype);
+
+            const std::string& runtime = item->getRuntime();
+            if (!runtime.empty())
+            {
+                entry["vm"] = runtime;
+            }
+
+            LLViewerInventoryItem* viewer_item = dynamic_cast<LLViewerInventoryItem*>(item);
+            if (viewer_item)
+            {
+                entry["running"] = viewer_item->getIsRunning();
+                entry["faulted"] = viewer_item->getIsFaulted();
+            }
+        }
+
+        const LLPermissions& perms = item->getPermissions();
+        LLSD perm_entry;
+        perm_entry["owner"]      = static_cast<S32>(perms.getMaskOwner());
+        perm_entry["next_owner"] = static_cast<S32>(perms.getMaskNextOwner());
+        entry["permissions"]     = perm_entry;
+
+        entry["creator_id"] = perms.getCreator();
+
+        items.append(entry);
+    }
+
+    return items;
+}
+
+LLSD LLPublishedObjectMgr::buildPublishedObjectLLSD(LLViewerObject* root) const
+{
+    LL_PROFILE_ZONE_SCOPED_CATEGORY_SCRIPTDEV;
+    LLSD pub;
+    pub["object_id"]          = root->getID();
+    pub["object_name"]        = get_prim_name(root);
+    pub["object_description"] = nv_string(root, "Desc");
+    pub["owner_id"]           = root->mOwnerID;
+    if (root->getRegion())
+    {
+        pub["region"] = root->getRegion()->getName();
+    }
+    pub["inventory"] = buildPrimInventoryLLSD(root);
+
+    LLSD linked_objects = LLSD::emptyArray();
+    S32 link_number = 2;
+    for (LLViewerObject* child : root->getChildren())
+    {
+        LLSD link;
+        link["link_id"]          = child->getID();
+        link["link_number"]      = link_number++;
+        link["link_name"]        = get_prim_name(child);
+        link["link_description"] = nv_string(child, "Desc");
+        link["inventory"]        = buildPrimInventoryLLSD(child);
+        linked_objects.append(link);
+    }
+    if (linked_objects.size() > 0)
+    {
+        pub["linked_objects"] = linked_objects;
+    }
+
+    return pub;
+}
+
+LLSD LLPublishedObjectMgr::buildObjectListLLSD() const
+{
+    LLSD objects = LLSD::emptyArray();
+    for (const auto& [object_id, info] : mPublishedObjects)
+    {
+        LLViewerObject* root = gObjectList.findObject(object_id);
+        if (!root)
+        {
+            LL_DEBUGS("ScriptEditorWS") << "object.list: skipping " << object_id
+                << " (no longer in scene)" << LL_ENDL;
+            continue;
+        }
+
+        LLSD pub;
+        pub["object_id"]          = info.mObjectID;
+        pub["object_name"]        = info.mObjectName;
+        pub["object_description"] = info.mObjectDescription;
+        pub["owner_id"]           = info.mOwnerID;
+        if (!info.mRegionName.empty())
+        {
+            pub["region"] = info.mRegionName;
+        }
+        pub["inventory"] = buildPrimInventoryLLSD(root);
+
+        LLSD linked_objects = LLSD::emptyArray();
+        for (const auto& prim_info : info.mPrims)
+        {
+            if (prim_info.mLinkNumber == 1)
+            {
+                continue;
+            }
+
+            LLViewerObject* child = gObjectList.findObject(prim_info.mPrimID);
+            if (!child)
+            {
+                continue;
+            }
+
+            LLSD link;
+            link["link_id"]     = prim_info.mPrimID;
+            link["link_number"] = prim_info.mLinkNumber;
+            link["link_name"]   = prim_info.mPrimName;
+            link["inventory"]   = buildPrimInventoryLLSD(child);
+            linked_objects.append(link);
+        }
+        if (linked_objects.size() > 0)
+        {
+            pub["linked_objects"] = linked_objects;
+        }
+
+        objects.append(pub);
+    }
+
+    return objects;
+}
+
+bool LLPublishedObjectMgr::buildLinksetUpdateLLSD(
+    const LLUUID& root_id, LLSD& update) const
+{
+    const PublishedObjectInfo* info = getPublished(root_id);
+    if (!info)
+    {
+        return false;
+    }
+
+    LLSD linked_objects = LLSD::emptyArray();
+    for (const PublishedPrimInfo& prim_info : info->mPrims)
+    {
+        if (prim_info.mPrimID == root_id)
+        {
+            continue;
+        }
+
+        LLSD entry;
+        entry["link_id"]     = prim_info.mPrimID;
+        entry["link_number"] = prim_info.mLinkNumber;
+
+        LLViewerObject* prim = gObjectList.findObject(prim_info.mPrimID);
+        std::string link_name = prim ? get_prim_name(prim) : std::string();
+        if (link_name.empty())
+        {
+            link_name = prim_info.mPrimName;
+        }
+        entry["link_name"] = link_name;
+        entry["inventory"] = prim ? buildPrimInventoryLLSD(prim) : LLSD::emptyArray();
+
+        linked_objects.append(entry);
+    }
+
+    update = LLSD();
+    update["object_id"]      = root_id;
+    update["linked_objects"] = linked_objects;
+    return true;
+}
+
+bool LLPublishedObjectMgr::reconcileLinksetChildAdded(
+    const LLUUID& root_id,
+    LLViewerObject* child,
+    F64 request_start_sec)
+{
+    PublishedObjectInfo* info = getPublished(root_id);
+    if (!info || !child)
+    {
+        return false;
+    }
+
+    const LLUUID child_id = child->getID();
+
+    info->mPrims.erase(
+        std::remove_if(
+            info->mPrims.begin(),
+            info->mPrims.end(),
+            [&](const PublishedPrimInfo& p) { return p.mPrimID == child_id; }),
+        info->mPrims.end());
+
+    PublishedPrimInfo prim_info;
+    prim_info.mPrimID          = child_id;
+    prim_info.mPrimName        = get_prim_name(child);
+    prim_info.mLinkNumber      = static_cast<S32>(info->mPrims.size()) + 1;
+    prim_info.mInventorySerial = -1;
+    info->mPrims.push_back(prim_info);
+
+    auto listener = std::make_unique<LLPublishedPrimListener>(
+        mServer, root_id, child_id, child);
+    info->mListeners.push_back(std::move(listener));
+
+    mInventoryRequestStartSec[child_id] = request_start_sec;
+    mNewChildPrims[root_id].insert(child_id);
+    return true;
+}
+
+bool LLPublishedObjectMgr::reconcileLinksetChildRemoved(
+    const LLUUID& root_id, const LLUUID& child_id)
+{
+    PublishedObjectInfo* info = getPublished(root_id);
+    if (!info)
+    {
+        return false;
+    }
+
+    info->mPrims.erase(
+        std::remove_if(
+            info->mPrims.begin(),
+            info->mPrims.end(),
+            [&](const PublishedPrimInfo& p) { return p.mPrimID == child_id; }),
+        info->mPrims.end());
+
+    info->mListeners.erase(
+        std::remove_if(
+            info->mListeners.begin(),
+            info->mListeners.end(),
+            [&](const std::unique_ptr<LLPublishedPrimListener>& l)
+            {
+                return l->getPrimID() == child_id;
+            }),
+        info->mListeners.end());
+
+    bool root_empty_after_remove = false;
+    consumePendingNewChild(root_id, child_id, root_empty_after_remove);
+
+    mInventoryRequestStartSec.erase(child_id);
+
+    S32 link_num = 2;
+    for (auto& p : info->mPrims)
+    {
+        if (p.mPrimID != root_id)
+        {
+            p.mLinkNumber = link_num++;
+        }
+    }
+
+    return true;
+}
+
+bool LLPublishedObjectMgr::handlePrimInventoryReadyEvent(
+    const LLUUID& object_id, const LLUUID& prim_id)
+{
+    return markPendingPublishPrimReady(object_id, prim_id);
+}
+
+LLPublishedObjectMgr::PrimInventoryEventResult
+LLPublishedObjectMgr::handlePrimInventoryChangedEvent(
+    const LLUUID& object_id,
+    const LLUUID& prim_id,
+    LLViewerObject* prim,
+    F64 now_sec)
+{
+    PrimInventoryEventResult result;
+    if (!hasPublished(object_id) || !prim)
+    {
+        return result;
+    }
+
+    F64 request_start_sec = 0.0;
+    if (consumeInventoryRequestStart(prim_id, request_start_sec))
+    {
+        result.mTimingConsumed = true;
+        result.mTimingElapsedSec = llmax(0.0, now_sec - request_start_sec);
+    }
+
+    InventoryChangeResult inv_result = reconcileInventoryChanged(object_id, prim_id, prim);
+    result.mKind = inv_result.mKind;
+    result.mUpdate = inv_result.mUpdate;
+
+    if (result.mKind == InventoryChangeKind::ROOT_INVENTORY_UPDATE ||
+        result.mKind == InventoryChangeKind::CHILD_INVENTORY_UPDATE)
+    {
+        std::string pending_item_create_pump;
+        if (consumePendingItemCreate(prim_id, pending_item_create_pump))
+        {
+            result.mHasPendingItemCreate = true;
+            result.mPendingItemCreatePump = pending_item_create_pump;
+        }
+    }
+
+    return result;
+}
+
+LLPublishedObjectMgr::InventoryChangeResult
+LLPublishedObjectMgr::reconcileInventoryChanged(
+    const LLUUID& object_id,
+    const LLUUID& prim_id,
+    LLViewerObject* prim)
+{
+    InventoryChangeResult result;
+    PublishedObjectInfo* pub_info = getPublished(object_id);
+    if (!pub_info || !prim)
+    {
+        return result;
+    }
+
+    bool root_empty_after_remove = false;
+    if (consumePendingNewChild(object_id, prim_id, root_empty_after_remove))
+    {
+        for (auto& p : pub_info->mPrims)
+        {
+            if (p.mPrimID == prim_id)
+            {
+                p.mPrimName        = get_prim_name(prim);
+                p.mInventorySerial = 0;
+                break;
+            }
+        }
+        result.mKind = root_empty_after_remove
+            ? InventoryChangeKind::CHILD_READY_FLUSH_NOW
+            : InventoryChangeKind::CHILD_READY_WAIT;
+        return result;
+    }
+
+    result.mUpdate = LLSD();
+    result.mUpdate["object_id"] = object_id;
+    LLSD inv = buildPrimInventoryLLSD(prim);
+    if (prim_id == object_id)
+    {
+        result.mUpdate["inventory"] = inv;
+        result.mKind = InventoryChangeKind::ROOT_INVENTORY_UPDATE;
+    }
+    else
+    {
+        LLSD modified_entry;
+        modified_entry["link_id"]   = prim_id;
+        modified_entry["inventory"] = inv;
+        LLSD modified_arr = LLSD::emptyArray();
+        modified_arr.append(modified_entry);
+        result.mUpdate["changes"]["linked_objects"]["modified"] = modified_arr;
+        result.mKind = InventoryChangeKind::CHILD_INVENTORY_UPDATE;
+    }
+    return result;
+}
+
+bool LLPublishedObjectMgr::applyPropertyChange(
+    const LLUUID& root_id,
+    const LLUUID& prim_id,
+    const std::string& name,
+    const std::string& desc,
+    LLSD& update)
+{
+    PublishedObjectInfo* pub_info = getPublished(root_id);
+    if (!pub_info)
+    {
+        return false;
+    }
+
+    update = LLSD();
+    update["object_id"] = root_id;
+
+    if (prim_id == root_id)
+    {
+        bool name_changed = (pub_info->mObjectName != name);
+        bool desc_changed = (pub_info->mObjectDescription != desc);
+        if (!name_changed && !desc_changed)
+        {
+            return false;
+        }
+
+        if (name_changed)
+        {
+            pub_info->mObjectName = name;
+            update["object_name"] = name;
+        }
+        if (desc_changed)
+        {
+            pub_info->mObjectDescription = desc;
+            update["object_description"] = desc;
+        }
+        return true;
+    }
+
+    auto prim_it = std::find_if(pub_info->mPrims.begin(), pub_info->mPrims.end(),
+        [&](const PublishedPrimInfo& p) { return p.mPrimID == prim_id; });
+    if (prim_it == pub_info->mPrims.end())
+    {
+        return false;
+    }
+    if (prim_it->mPrimName == name)
+    {
+        return false;
+    }
+
+    prim_it->mPrimName = name;
+    LLSD modified_entry;
+    modified_entry["link_id"]   = prim_id;
+    modified_entry["link_name"] = name;
+    LLSD modified_arr = LLSD::emptyArray();
+    modified_arr.append(modified_entry);
+    update["changes"]["linked_objects"]["modified"] = modified_arr;
+    return true;
+}
+
+bool LLPublishedObjectMgr::hasActiveLinksetFlushTimer(const LLUUID& root_id) const
+{
+    auto it = mLinksetFlushTimers.find(root_id);
+    if (it == mLinksetFlushTimers.end())
+    {
+        return false;
+    }
+
+    return !it->second.expired();
+}
+
+void LLPublishedObjectMgr::setLinksetFlushTimer(
+    const LLUUID& root_id, const std::weak_ptr<LLEventTimer>& timer)
+{
+    mLinksetFlushTimers[root_id] = timer;
+}
+
+bool LLPublishedObjectMgr::cancelLinksetFlushTimer(const LLUUID& root_id)
+{
+    auto it = mLinksetFlushTimers.find(root_id);
+    if (it == mLinksetFlushTimers.end())
+    {
+        return false;
+    }
+
+    if (auto locked = it->second.lock())
+    {
+        delete locked.get();
+    }
+
+    mLinksetFlushTimers.erase(it);
+    return true;
+}
+
+void LLPublishedObjectMgr::clearLinksetFlushTimer(const LLUUID& root_id)
+{
+    mLinksetFlushTimers.erase(root_id);
+}
+
+bool LLPublishedObjectMgr::consumeInventoryRequestStart(
+    const LLUUID& prim_id, F64& start_sec)
+{
+    auto it = mInventoryRequestStartSec.find(prim_id);
+    if (it == mInventoryRequestStartSec.end())
+    {
+        return false;
+    }
+
+    start_sec = it->second;
+    mInventoryRequestStartSec.erase(it);
+    return true;
+}
+
+bool LLPublishedObjectMgr::markPrimInventorySerialAndDetectChange(
+    const LLUUID& root_id, const LLUUID& prim_id, S16 inventory_serial)
+{
+    if (inventory_serial < 0)
+    {
+        return false;
+    }
+
+    PublishedObjectInfo* info = getPublished(root_id);
+    if (!info)
+    {
+        return false;
+    }
+
+    auto it = std::find_if(
+        info->mPrims.begin(),
+        info->mPrims.end(),
+        [&](const PublishedPrimInfo& p)
+        {
+            return p.mPrimID == prim_id;
+        });
+    if (it == info->mPrims.end())
+    {
+        return false;
+    }
+
+    if (it->mInventorySerial == inventory_serial)
+    {
+        return false;
+    }
+
+    it->mInventorySerial = inventory_serial;
+    return true;
+}
+
+bool LLPublishedObjectMgr::consumePendingNewChild(
+    const LLUUID& root_id, const LLUUID& child_id, bool& root_empty_after_remove)
+{
+    root_empty_after_remove = false;
+    auto root_it = mNewChildPrims.find(root_id);
+    if (root_it == mNewChildPrims.end())
+    {
+        return false;
+    }
+
+    auto child_it = root_it->second.find(child_id);
+    if (child_it == root_it->second.end())
+    {
+        return false;
+    }
+
+    root_it->second.erase(child_it);
+    if (root_it->second.empty())
+    {
+        root_empty_after_remove = true;
+        mNewChildPrims.erase(root_it);
+    }
+
+    return true;
+}
+
+LLPublishedObjectMgr::PublishedObjectInfo& LLPublishedObjectMgr::finalizePendingPublish(
+    const LLUUID& object_id, PublishedObjectInfo&& info)
+{
+    PublishedObjectInfo& published_info = mPublishedObjects[object_id];
+    published_info = std::move(info);
+    published_info.mListeners = takePendingPublishListeners(object_id);
+    return published_info;
+}
+
+bool LLPublishedObjectMgr::cleanupObjectStateForUnpublish(const LLUUID& object_id)
+{
+    const bool was_published = hasPublished(object_id);
+
+    cancelPendingPublishWithCleanup(object_id);
+    clearPublishedListeners(object_id);
+    erasePublished(object_id);
+
+    cancelLinksetFlushTimer(object_id);
+    clearPendingNewChildren(object_id);
+
+    return was_published;
+}
+
+void LLPublishedObjectMgr::clearPublishedListeners(const LLUUID& object_id)
+{
+    auto pub_info = getPublished(object_id);
+    if (!pub_info)
+    {
+        return;
+    }
+
+    pub_info->mListeners.clear();
+}
+
+void LLPublishedObjectMgr::clearAllStateWithListenerCleanup()
+{
+    for (auto& [id, pending] : mPendingPublishes)
+    {
+        pending.mListeners.clear();
+    }
+    mPendingPublishes.clear();
+
+    for (auto& [id, info] : mPublishedObjects)
+    {
+        info.mListeners.clear();
+    }
+    mPublishedObjects.clear();
+}
-- 
cgit v1.3


From 5e2d671895b292726f923db5f8e7375097b6e159 Mon Sep 17 00:00:00 2001
From: Rider Linden <rider@lindenlab.com>
Date: Mon, 10 Aug 2026 15:45:03 -0700
Subject: Refresh the object's data when it is published. (link children seem
 to be an issue still)

---
 indra/newview/llpublishedobjectmgr.cpp | 107 ++++++++++++++++++++++++++++++---
 indra/newview/llpublishedobjectmgr.h   |  11 ++++
 indra/newview/llscripteditorws.cpp     |  49 ++++++++++++++-
 3 files changed, 159 insertions(+), 8 deletions(-)

(limited to 'indra/newview/llpublishedobjectmgr.cpp')

diff --git a/indra/newview/llpublishedobjectmgr.cpp b/indra/newview/llpublishedobjectmgr.cpp
index 2c2eff58a5..6f78ba82d9 100644
--- a/indra/newview/llpublishedobjectmgr.cpp
+++ b/indra/newview/llpublishedobjectmgr.cpp
@@ -72,7 +72,13 @@ namespace
         }
 
         LLSelectNode* node = LLSelectMgr::instance().getSelection()->findNode(obj);
-        return (node && !node->mName.empty()) ? node->mName : std::string();
+        if (node && !node->mName.empty())
+        {
+            return node->mName;
+        }
+
+        // Never emit an empty prim/object name to downstream tooling.
+        return obj->getID().asString();
     }
 }
 
@@ -164,6 +170,37 @@ bool LLPublishedObjectMgr::markPendingPublishPrimReady(const LLUUID& object_id,
     return it->second.mPendingPrims.empty();
 }
 
+void LLPublishedObjectMgr::recordPendingPropertyChange(
+    const LLUUID& root_id,
+    const LLUUID& prim_id,
+    const std::string& name,
+    const std::string& desc)
+{
+    auto it = mPendingPublishes.find(root_id);
+    if (it == mPendingPublishes.end())
+    {
+        return;
+    }
+
+    PendingPublish& pending = it->second;
+    if (prim_id == root_id)
+    {
+        pending.mHasRootProperties = true;
+        pending.mObjectDescription = desc;
+        if (!name.empty())
+        {
+            pending.mObjectName = name;
+        }
+        return;
+    }
+
+    if (!name.empty())
+    {
+        pending.mPrimNames[prim_id] = name;
+    }
+    pending.mPrimDescriptions[prim_id] = desc;
+}
+
 std::vector<std::unique_ptr<LLPublishedPrimListener>> LLPublishedObjectMgr::takePendingPublishListeners(const LLUUID& object_id)
 {
     auto it = mPendingPublishes.find(object_id);
@@ -387,6 +424,7 @@ LLSD LLPublishedObjectMgr::buildObjectListLLSD() const
             link["link_id"]     = prim_info.mPrimID;
             link["link_number"] = prim_info.mLinkNumber;
             link["link_name"]   = prim_info.mPrimName;
+            link["link_description"] = prim_info.mPrimDescription;
             link["inventory"]   = buildPrimInventoryLLSD(child);
             linked_objects.append(link);
         }
@@ -428,7 +466,13 @@ bool LLPublishedObjectMgr::buildLinksetUpdateLLSD(
         {
             link_name = prim_info.mPrimName;
         }
+        std::string link_desc = prim ? nv_string(prim, "Desc") : std::string();
+        if (link_desc.empty())
+        {
+            link_desc = prim_info.mPrimDescription;
+        }
         entry["link_name"] = link_name;
+        entry["link_description"] = link_desc;
         entry["inventory"] = prim ? buildPrimInventoryLLSD(prim) : LLSD::emptyArray();
 
         linked_objects.append(entry);
@@ -463,6 +507,7 @@ bool LLPublishedObjectMgr::reconcileLinksetChildAdded(
     PublishedPrimInfo prim_info;
     prim_info.mPrimID          = child_id;
     prim_info.mPrimName        = get_prim_name(child);
+    prim_info.mPrimDescription = nv_string(child, "Desc");
     prim_info.mLinkNumber      = static_cast<S32>(info->mPrims.size()) + 1;
     prim_info.mInventorySerial = -1;
     info->mPrims.push_back(prim_info);
@@ -584,6 +629,7 @@ LLPublishedObjectMgr::reconcileInventoryChanged(
             if (p.mPrimID == prim_id)
             {
                 p.mPrimName        = get_prim_name(prim);
+                p.mPrimDescription = nv_string(prim, "Desc");
                 p.mInventorySerial = 0;
                 break;
             }
@@ -633,7 +679,8 @@ bool LLPublishedObjectMgr::applyPropertyChange(
 
     if (prim_id == root_id)
     {
-        bool name_changed = (pub_info->mObjectName != name);
+        bool has_name = !name.empty();
+        bool name_changed = has_name && (pub_info->mObjectName != name);
         bool desc_changed = (pub_info->mObjectDescription != desc);
         if (!name_changed && !desc_changed)
         {
@@ -659,15 +706,25 @@ bool LLPublishedObjectMgr::applyPropertyChange(
     {
         return false;
     }
-    if (prim_it->mPrimName == name)
+    const bool name_changed = !name.empty() && prim_it->mPrimName != name;
+    const bool desc_changed = prim_it->mPrimDescription != desc;
+    if (!name_changed && !desc_changed)
     {
         return false;
     }
 
-    prim_it->mPrimName = name;
     LLSD modified_entry;
-    modified_entry["link_id"]   = prim_id;
-    modified_entry["link_name"] = name;
+    modified_entry["link_id"] = prim_id;
+    if (name_changed)
+    {
+        prim_it->mPrimName = name;
+        modified_entry["link_name"] = name;
+    }
+    if (desc_changed)
+    {
+        prim_it->mPrimDescription = desc;
+        modified_entry["link_description"] = desc;
+    }
     LLSD modified_arr = LLSD::emptyArray();
     modified_arr.append(modified_entry);
     update["changes"]["linked_objects"]["modified"] = modified_arr;
@@ -792,8 +849,44 @@ LLPublishedObjectMgr::PublishedObjectInfo& LLPublishedObjectMgr::finalizePending
     const LLUUID& object_id, PublishedObjectInfo&& info)
 {
     PublishedObjectInfo& published_info = mPublishedObjects[object_id];
+    auto pending_it = mPendingPublishes.find(object_id);
     published_info = std::move(info);
-    published_info.mListeners = takePendingPublishListeners(object_id);
+
+    if (pending_it != mPendingPublishes.end())
+    {
+        PendingPublish& pending = pending_it->second;
+        if (pending.mHasRootProperties)
+        {
+            if (!pending.mObjectName.empty())
+            {
+                published_info.mObjectName = pending.mObjectName;
+            }
+            published_info.mObjectDescription = pending.mObjectDescription;
+        }
+
+        for (PublishedPrimInfo& prim_info : published_info.mPrims)
+        {
+            auto name_it = pending.mPrimNames.find(prim_info.mPrimID);
+            if (name_it != pending.mPrimNames.end() && !name_it->second.empty())
+            {
+                prim_info.mPrimName = name_it->second;
+            }
+
+            auto desc_it = pending.mPrimDescriptions.find(prim_info.mPrimID);
+            if (desc_it != pending.mPrimDescriptions.end())
+            {
+                prim_info.mPrimDescription = desc_it->second;
+            }
+        }
+
+        published_info.mListeners = std::move(pending.mListeners);
+        mPendingPublishes.erase(pending_it);
+    }
+    else
+    {
+        published_info.mListeners = takePendingPublishListeners(object_id);
+    }
+
     return published_info;
 }
 
diff --git a/indra/newview/llpublishedobjectmgr.h b/indra/newview/llpublishedobjectmgr.h
index 4d4bd55aff..d7eca09d80 100644
--- a/indra/newview/llpublishedobjectmgr.h
+++ b/indra/newview/llpublishedobjectmgr.h
@@ -49,6 +49,7 @@ public:
         LLUUID      mPrimID;
         std::string mPrimName;
         S32         mLinkNumber;
+        std::string mPrimDescription;
         S16         mInventorySerial;
     };
 
@@ -82,6 +83,11 @@ public:
         LLUUID      mObjectID;
         std::set<LLUUID> mPendingPrims;
         std::vector<std::unique_ptr<LLPublishedPrimListener>> mListeners;
+        bool        mHasRootProperties{ false };
+        std::string mObjectName;
+        std::string mObjectDescription;
+        std::map<LLUUID, std::string> mPrimNames;
+        std::map<LLUUID, std::string> mPrimDescriptions;
     };
 
     enum class InventoryChangeKind
@@ -153,6 +159,11 @@ public:
     bool hasPendingPublish(const LLUUID& object_id) const;
     bool markPendingPublishPrimReady(const LLUUID& object_id, const LLUUID& prim_id);
     std::vector<std::unique_ptr<LLPublishedPrimListener>> takePendingPublishListeners(const LLUUID& object_id);
+    void recordPendingPropertyChange(
+        const LLUUID& root_id,
+        const LLUUID& prim_id,
+        const std::string& name,
+        const std::string& desc);
     void cancelPendingPublish(const LLUUID& object_id);
     PublishedObjectInfo& finalizePendingPublish(const LLUUID& object_id, PublishedObjectInfo&& info);
     bool cleanupObjectStateForUnpublish(const LLUUID& object_id);
diff --git a/indra/newview/llscripteditorws.cpp b/indra/newview/llscripteditorws.cpp
index 3fbcd5c384..95e06583d3 100644
--- a/indra/newview/llscripteditorws.cpp
+++ b/indra/newview/llscripteditorws.cpp
@@ -2086,7 +2086,13 @@ std::string LLScriptEditorWSServer::getPrimName(LLViewerObject* obj)
     }
 
     LLSelectNode* node = LLSelectMgr::instance().getSelection()->findNode(obj);
-    return (node && !node->mName.empty()) ? node->mName : std::string();
+    if (node && !node->mName.empty())
+    {
+        return node->mName;
+    }
+
+    // Never emit an empty prim/object name to downstream tooling.
+    return obj->getID().asString();
 }
 
 bool LLScriptEditorWSServer::publishObject(const LLUUID& object_id)
@@ -2114,6 +2120,13 @@ bool LLScriptEditorWSServer::publishObject(const LLUUID& object_id)
     // Collect root + all children
     std::vector<LLViewerObject*> prims = collect_linkset(root);
 
+    // Request object properties for each prim in the linkset (root + children),
+    // matching the hover path so name/description metadata is refreshed.
+    for (LLViewerObject* prim : prims)
+    {
+        LLSelectMgr::instance().requestObjectPropertiesFamily(prim);
+    }
+
     // Set up a PendingPublish to coordinate inventory loading across all prims.
     // We register a listener and call requestInventory() on every prim.
     // If inventory is already loaded, requestInventory() fires the callback
@@ -2196,6 +2209,31 @@ void LLScriptEditorWSServer::buildAndSendPublish(const LLUUID& object_id)
 
     LLPublishedObjectMgr::PublishedObjectInfo& published_info = mPublishedObjectManager.finalizePendingPublish(object_id, std::move(info));
 
+    // Align outgoing publish payload with any property responses that arrived
+    // while inventory-gated publish was still pending.
+    pub["object_name"] = published_info.mObjectName;
+    pub["object_description"] = published_info.mObjectDescription;
+    if (pub.has("linked_objects"))
+    {
+        LLSD& linked_objects = pub["linked_objects"];
+        for (S32 i = 0; i < linked_objects.size(); ++i)
+        {
+            const LLUUID link_id = linked_objects[i]["link_id"].asUUID();
+            auto prim_it = std::find_if(
+                published_info.mPrims.begin(),
+                published_info.mPrims.end(),
+                [&](const LLPublishedObjectMgr::PublishedPrimInfo& p)
+                {
+                    return p.mPrimID == link_id;
+                });
+            if (prim_it != published_info.mPrims.end())
+            {
+                linked_objects[i]["link_name"] = prim_it->mPrimName;
+                linked_objects[i]["link_description"] = prim_it->mPrimDescription;
+            }
+        }
+    }
+
     // Send notification
     LLSD message;
     message["object"] = pub;
@@ -2204,6 +2242,13 @@ void LLScriptEditorWSServer::buildAndSendPublish(const LLUUID& object_id)
     LL_INFOS("ScriptEditorWS") << "Published object " << object_id
         << " (" << pub["object_name"].asString() << ") with "
         << (prims.size() - 1) << " linked prim(s)" << LL_ENDL;
+
+    // Re-request object properties now that the object is published so
+    // onObjectPropertyChanged can emit object.update for root and linked prims.
+    for (LLViewerObject* prim : prims)
+    {
+        LLSelectMgr::instance().requestObjectPropertiesFamily(prim);
+    }
 }
 
 void LLScriptEditorWSServer::onLinksetChildAdded(const LLUUID& root_id, LLViewerObject* child)
@@ -2344,6 +2389,8 @@ void LLScriptEditorWSServer::onObjectPropertyChanged(
 
     LLUUID root_id = prim->getRootEdit()->getID();
 
+    mPublishedObjectManager.recordPendingPropertyChange(root_id, prim_id, name, desc);
+
     bool should_refresh_inventory = mPublishedObjectManager.markPrimInventorySerialAndDetectChange(
         root_id,
         prim_id,
-- 
cgit v1.3


From 32a8200a788b286073a11c81255aac471aa37b67 Mon Sep 17 00:00:00 2001
From: Rider Linden <rider@lindenlab.com>
Date: Wed, 12 Aug 2026 15:25:20 -0700
Subject: Issue https://github.com/secondlife/sl-vscode-plugin/issues/99: Allow
 rezzed objects to be saved back to their rezzer's inventory.

---
 indra/newview/llpublishedobjectmgr.cpp |  1 +
 indra/newview/llpublishedobjectmgr.h   |  2 +
 indra/newview/llscripteditorws.cpp     | 80 ++++++++++++++++++++++++++++++++++
 indra/newview/llscripteditorws.h       |  1 +
 indra/newview/llviewermenu.cpp         | 34 +++++++++++++--
 indra/newview/llviewermenu.h           |  2 +
 6 files changed, 117 insertions(+), 3 deletions(-)

(limited to 'indra/newview/llpublishedobjectmgr.cpp')

diff --git a/indra/newview/llpublishedobjectmgr.cpp b/indra/newview/llpublishedobjectmgr.cpp
index 6f78ba82d9..e9d13c1213 100644
--- a/indra/newview/llpublishedobjectmgr.cpp
+++ b/indra/newview/llpublishedobjectmgr.cpp
@@ -404,6 +404,7 @@ LLSD LLPublishedObjectMgr::buildObjectListLLSD() const
         {
             pub["region"] = info.mRegionName;
         }
+        pub["can_save_back"] = info.mCanSaveBackToContents;
         pub["inventory"] = buildPrimInventoryLLSD(root);
 
         LLSD linked_objects = LLSD::emptyArray();
diff --git a/indra/newview/llpublishedobjectmgr.h b/indra/newview/llpublishedobjectmgr.h
index d7eca09d80..99ffa34b39 100644
--- a/indra/newview/llpublishedobjectmgr.h
+++ b/indra/newview/llpublishedobjectmgr.h
@@ -67,6 +67,8 @@ public:
         std::string mObjectName;
         std::string mObjectDescription;
         std::string mRegionName;
+        bool        mCanSaveBackToContents{ false };
+        LLUUID      mSourceTaskID;
         std::vector<PublishedPrimInfo> mPrims;
         std::vector<std::unique_ptr<LLPublishedPrimListener>> mListeners;
     };
diff --git a/indra/newview/llscripteditorws.cpp b/indra/newview/llscripteditorws.cpp
index d9a4e4b064..2b77ff1481 100644
--- a/indra/newview/llscripteditorws.cpp
+++ b/indra/newview/llscripteditorws.cpp
@@ -208,6 +208,12 @@ LLScriptEditorWSServer::LLScriptEditorWSServer(const std::string& name, U16 port
             response["success"] = true;
             return response;
         });
+
+    registerCommand({ "viewer.object.save_back_to_contents", "Save an in-world object back to source object contents" },
+        [this](U32 connection_id, const LLSD& p) -> LLSD
+        {
+            return this->handleSaveBackToObjectContents(connection_id, p);
+        });
 }
 
 LLScriptEditorWSServer::ptr_t LLScriptEditorWSServer::getServer()
@@ -918,6 +924,65 @@ bool LLScriptEditorWSConnection::hasFeature(const std::string& feature) const
     return mFeatures.count(feature) > 0;
 }
 
+LLSD LLScriptEditorWSServer::handleSaveBackToObjectContents(U32 connection_id, const LLSD& params)
+{
+    LLUUID object_id = params["object_id"].asUUID();
+    if (object_id.isNull())
+    {
+        throw LLJSONRPCConnection::InvalidParams("object_id is required");
+    }
+
+    const LLPublishedObjectMgr::PublishedObjectInfo* published_info =
+        mPublishedObjectManager.getPublished(object_id);
+    if (!published_info)
+    {
+        LLSD response;
+        response["success"] = false;
+        response["error_code"] = WSCommandError::InvalidParams;
+        response["message"] = "Object is not published";
+        return response;
+    }
+
+    if (!published_info->mCanSaveBackToContents || published_info->mSourceTaskID.isNull())
+    {
+        LLSD response;
+        response["success"] = false;
+        response["error_code"] = WSCommandError::NotPermitted;
+        response["message"] = "Save back is not available for this object";
+        return response;
+    }
+
+    LLViewerObject* root = gObjectList.findObject(object_id);
+    if (!root)
+    {
+        LLSD response;
+        response["success"] = false;
+        response["error_code"] = WSCommandError::InvalidParams;
+        response["message"] = "object_id not found";
+        return response;
+    }
+
+    if (!save_object_back_to_contents(root, published_info->mSourceTaskID))
+    {
+        LLSD response;
+        response["success"] = false;
+        response["error_code"] = WSCommandError::ExecutionError;
+        response["message"] = "Failed to save object back to contents";
+        return response;
+    }
+
+    LL_DEBUGS("ScriptEditorWS") << "Save-back requested via command for object "
+                                << object_id << " on connection " << connection_id << LL_ENDL;
+
+    LLSD response;
+    response["success"] = true;
+
+    LLSD result;
+    result["object_id"] = object_id;
+    response["result"] = result;
+    return response;
+}
+
 LLSD LLScriptEditorWSServer::handleCommandExecute(U32 connection_id, const LLSD& params)
 {
     const std::string command = params["command"].asString();
@@ -2228,6 +2293,20 @@ void LLScriptEditorWSServer::buildAndSendPublish(const LLUUID& object_id)
     {
         info.mRegionName = root->getRegion()->getName();
     }
+    LLSelectNode* root_select_node = LLSelectMgr::instance().getSelection()->findNode(root);
+    if (root_select_node
+        && root_select_node->mValid
+        && !root_select_node->mFromTaskID.isNull()
+        && !root->isAttachment())
+    {
+        info.mCanSaveBackToContents = true;
+        info.mSourceTaskID = root_select_node->mFromTaskID;
+    }
+    else
+    {
+        info.mCanSaveBackToContents = false;
+        info.mSourceTaskID.setNull();
+    }
 
     S32 link_num = 1;
     std::vector<LLViewerObject*> prims = collect_linkset(root);
@@ -2246,6 +2325,7 @@ void LLScriptEditorWSServer::buildAndSendPublish(const LLUUID& object_id)
     // Align outgoing publish payload with any property responses that arrived
     // while inventory-gated publish was still pending.
     pub["object_name"] = published_info.mObjectName;
+    pub["can_save_back"] = published_info.mCanSaveBackToContents;
     pub["object_description"] = published_info.mObjectDescription;
     if (pub.has("linked_objects"))
     {
diff --git a/indra/newview/llscripteditorws.h b/indra/newview/llscripteditorws.h
index 63b60335ff..ded83e6369 100644
--- a/indra/newview/llscripteditorws.h
+++ b/indra/newview/llscripteditorws.h
@@ -247,6 +247,7 @@ protected:
     LLSD handleObjectModify(U32 connection_id, const LLSD& params);
     LLSD handleObjectItemModify(U32 connection_id, const LLSD& params);
     LLSD handleCommandExecute(U32 connection_id, const LLSD& params);
+    LLSD handleSaveBackToObjectContents(U32 connection_id, const LLSD& params);
     LLSD handleCommandList();
     void sendCommandExecute(U32 connection_id, const std::string& command, const LLSD& params);
 
diff --git a/indra/newview/llviewermenu.cpp b/indra/newview/llviewermenu.cpp
index dc509479c4..eaaa923b59 100644
--- a/indra/newview/llviewermenu.cpp
+++ b/indra/newview/llviewermenu.cpp
@@ -5136,6 +5136,31 @@ static void derez_objects(EDeRezDestination dest, const LLUUID& dest_id)
     derez_objects(dest, dest_id, first_region, error, NULL);
 }
 
+bool save_object_back_to_contents(LLViewerObject* object, const LLUUID& source_task_id)
+{
+    if (!object || source_task_id.isNull())
+    {
+        return false;
+    }
+
+    LLViewerRegion* first_region = object->getRegion();
+    if (!first_region)
+    {
+        return false;
+    }
+
+    std::vector<LLViewerObjectPtr> objects;
+    objects.push_back(object);
+
+    std::string error;
+    derez_objects(DRD_SAVE_INTO_TASK_INVENTORY, source_task_id, first_region, error, &objects);
+    if (!error.empty())
+    {
+        return false;
+    }
+    return true;
+}
+
 static void derez_objects_separate(EDeRezDestination dest, const LLUUID &dest_id)
 {
     std::vector<LLViewerObjectPtr> derez_object_list;
@@ -5710,10 +5735,13 @@ class LLToolsSaveToObjectInventory : public view_listener_t
     bool handleEvent(const LLSD& userdata)
     {
         LLSelectNode* node = LLSelectMgr::getInstance()->getSelection()->getFirstRootNode();
-        if(node && (node->mValid) && (!node->mFromTaskID.isNull()))
+        if (node && node->mValid && !node->mFromTaskID.isNull())
         {
-            // *TODO: check to see if the fromtaskid object exists.
-            derez_objects(DRD_SAVE_INTO_TASK_INVENTORY, node->mFromTaskID);
+            LLViewerObject* object = node->getObject();
+            if (object)
+            {
+                save_object_back_to_contents(object, node->mFromTaskID);
+            }
         }
         return true;
     }
diff --git a/indra/newview/llviewermenu.h b/indra/newview/llviewermenu.h
index 522c7e8109..6699780a76 100644
--- a/indra/newview/llviewermenu.h
+++ b/indra/newview/llviewermenu.h
@@ -37,6 +37,7 @@ class LLView;
 class LLParcelSelection;
 class LLObjectSelection;
 class LLSelectNode;
+class LLViewerObject;
 
 void initialize_edit_menu();
 void initialize_spellcheck_menu();
@@ -74,6 +75,7 @@ void handle_take(bool take_separate = false);
 void handle_take_copy();
 void handle_look_at_selection(const LLSD& param);
 bool handle_zoom_to_object(const LLUUID& object_id);
+bool save_object_back_to_contents(LLViewerObject* object, const LLUUID& source_task_id);
 void handle_object_return();
 void handle_object_delete();
 void handle_object_edit();
-- 
cgit v1.3


From 7af436c43d8bb7027c146e9a57bb19c3c89c5d3e Mon Sep 17 00:00:00 2001
From: Rider Linden <rider@lindenlab.com>
Date: Mon, 17 Aug 2026 17:24:06 -0700
Subject: Issue https://github.com/secondlife/sl-vscode-plugin/issues/98:
 Refactor message passing into unified format.

---
 doc/external-editor-json-rpc.md                |  38 ++-
 indra/llcorehttp/CMakeLists.txt                |   1 +
 indra/llcorehttp/lljsonrpcws.cpp               |  18 ++
 indra/llcorehttp/lljsonrpcws.h                 |   5 +
 indra/llcorehttp/tests/llcorehttp_test.cpp     |   1 +
 indra/llcorehttp/tests/test_jsonrpcws.hpp      | 146 ++++++++++
 indra/newview/llfloaterimnearbychathandler.cpp |  36 ++-
 indra/newview/llpreviewscript.cpp              |  10 +-
 indra/newview/llpublishedobjectmgr.cpp         | 381 ++++++++++++++++++++++++-
 indra/newview/llpublishedobjectmgr.h           | 127 ++++++++-
 indra/newview/llscripteditorws.cpp             | 376 +++++++++++-------------
 indra/newview/llscripteditorws.h               |  41 +--
 12 files changed, 904 insertions(+), 276 deletions(-)
 create mode 100644 indra/llcorehttp/tests/test_jsonrpcws.hpp

(limited to 'indra/newview/llpublishedobjectmgr.cpp')

diff --git a/doc/external-editor-json-rpc.md b/doc/external-editor-json-rpc.md
index 6c041cf70b..5c7d70185e 100644
--- a/doc/external-editor-json-rpc.md
+++ b/doc/external-editor-json-rpc.md
@@ -25,7 +25,7 @@ This document describes all the message interfaces defined for WebSocket communi
   - [ScriptUnsubscribe](#scriptunsubscribe)
   - [ScriptList](#scriptlist)
 - [Compilation Interfaces](#compilation-interfaces)
-  - [CompilationError](#compilationerror)
+  - [Diagnostic](#diagnostic)
   - [CompilationResult](#compilationresult)
 - [Runtime Event Interfaces](#runtime-event-interfaces)
   - [RuntimeDebug](#runtimedebug)
@@ -601,12 +601,12 @@ interface ScriptList {
 
 ## Compilation Interfaces
 
-### CompilationError
+### Diagnostic
 
 Individual compilation error record.
 
 ```typescript
-interface CompilationError {
+interface Diagnostic {
   row: number;
   column: number;
   level: string;
@@ -631,10 +631,11 @@ Result of a compilation operation in the viewer.
 
 ```typescript
 interface CompilationResult {
+  /** Deprecated: retained during migration to item-based routing. */
   script_id: string;
   success: boolean;
   running: boolean;
-  errors?: CompilationError[];
+  diagnostics?: Diagnostic[];
 }
 ```
 
@@ -643,7 +644,7 @@ interface CompilationResult {
 - `script_id`: Unique identifier for the script that was compiled
 - `success`: Whether the compilation was successful
 - `running`: Whether the compiled script is currently running
-- `errors` (optional): Array of compilation errors if any occurred
+- `diagnostics` (optional): Array of `Diagnostic` records if any occurred
 
 ## Runtime Event Interfaces
 
@@ -655,10 +656,15 @@ Debug message notification sent by the viewer during script execution.
 
 ```typescript
 interface RuntimeDebug {
+  /** Deprecated: use item.item_id when available. */
   script_id: string;
   object_id: string;
+  prim_id?: string;
+  item_id?: string;
   object_name: string;
   message: string;
+  channel?: "debug" | "owner_say";
+  item?: ItemRef;
 }
 ```
 
@@ -677,13 +683,27 @@ Runtime error notification sent by the viewer when a script encounters an error
 
 ```typescript
 interface RuntimeError {
+  /** Deprecated: use item.item_id when available. */
   script_id: string;
   object_id: string;
+  prim_id?: string;
+  item_id?: string;
   object_name: string;
   message: string;
   error: string;
   line: number;
+  column?: number;
   stack?: string[];
+  channel?: "debug" | "owner_say";
+  item?: ItemRef;
+}
+
+interface ItemRef {
+  root_id: string;
+  prim_id?: string;
+  item_id?: string;
+  name?: string;
+  language?: "lsl" | "luau";
 }
 ```
 
@@ -693,8 +713,8 @@ interface RuntimeError {
 - `object_id`: Unique identifier for the object containing the script
 - `object_name`: Human-readable name of the object
 - `message`: The full raw chat text of the runtime error message as received from the simulator
-- `error`: Extracted error description. Currently always an empty string - runtime error extraction from the simulator's multi-message format is not yet fully implemented.
-- `line`: Line number where the error occurred. Currently always `0` for the same reason.
+- `error`: Extracted runtime error description. This remains a top-level compatibility field while the protocol stays on version `1.0`.
+- `line`: Line number where the error occurred when the runtime format can be parsed; otherwise `0`.
 - `stack` (optional): Stack trace lines if they could be extracted from the error message
 
 ## Handler and Configuration Interfaces
@@ -973,7 +993,7 @@ interface ObjectContentSaveResponse {
   prim_id?: string;
   item_id?: string;
   compiled?: boolean;
-  errors?: string[];
+  diagnostics?: Diagnostic[];
   message?: string;
 }
 ```
@@ -986,7 +1006,7 @@ interface ObjectContentSaveResponse {
 - `vm` (optional): Scripts only compile target. Accepted values are `"mono"`, `"lsl2"`, `"luau"`. When `"luau"` is specified for an LSL script (as opposed to a native Luau script), the viewer automatically selects the correct LSL-on-Luau compile path. If omitted, inferred from item metadata or content analysis.
 - `success`: Whether the upload/save operation succeeded.
 - `compiled` (optional): Scripts only. `true` when compilation succeeded, `false` when source saved but compile failed.
-- `errors` (optional): Scripts only. Compiler diagnostics when `compiled` is `false`.
+- `diagnostics` (optional): Scripts only. Array of `Diagnostic` records when `compiled` is `false`.
 - `message` (optional): Error description on failure.
 
 ---
diff --git a/indra/llcorehttp/CMakeLists.txt b/indra/llcorehttp/CMakeLists.txt
index fbc25a7cd5..c2c4078ff0 100644
--- a/indra/llcorehttp/CMakeLists.txt
+++ b/indra/llcorehttp/CMakeLists.txt
@@ -119,6 +119,7 @@ if (LL_TESTS AND LLCOREHTTP_TESTS)
       tests/test_httpheaders.hpp
       tests/test_bufferarray.hpp
       tests/test_bufferstream.hpp
+      tests/test_jsonrpcws.hpp
       )
 
   list(APPEND llcorehttp_TEST_SOURCE_FILES ${llcorehttp_TEST_HEADER_FILES})
diff --git a/indra/llcorehttp/lljsonrpcws.cpp b/indra/llcorehttp/lljsonrpcws.cpp
index 3a0d3d1f26..d6c5b0eb97 100644
--- a/indra/llcorehttp/lljsonrpcws.cpp
+++ b/indra/llcorehttp/lljsonrpcws.cpp
@@ -457,6 +457,24 @@ void LLJSONRPCConnection::sweepTimeouts()
     }
 }
 
+void LLJSONRPCConnection::testInjectPendingRequest(const std::string& id, F64 deadline, ResponseCallback callback)
+{
+    LLMutexLock lock(&mMutex);
+    mPendingRequests[id] = std::move(callback);
+    mPendingDeadlines.push({ deadline, id });
+}
+
+void LLJSONRPCConnection::testSweepTimeouts()
+{
+    sweepTimeouts();
+}
+
+size_t LLJSONRPCConnection::testPendingRequestCount() const
+{
+    LLMutexLock lock(&mMutex);
+    return mPendingRequests.size();
+}
+
 LLSD LLJSONRPCConnection::generateId()
 {
     // Server-wide atomic counter for efficient unique ID generation.
diff --git a/indra/llcorehttp/lljsonrpcws.h b/indra/llcorehttp/lljsonrpcws.h
index cd71473a47..7cb26b1fb2 100644
--- a/indra/llcorehttp/lljsonrpcws.h
+++ b/indra/llcorehttp/lljsonrpcws.h
@@ -401,6 +401,11 @@ private:
     /// Invoked by the sweep timer; fires the timeout callback for any
     /// request whose deadline has passed. Safe to call from the main thread.
     void sweepTimeouts();
+
+public:
+    void testInjectPendingRequest(const std::string& id, F64 deadline, ResponseCallback callback);
+    void testSweepTimeouts();
+    size_t testPendingRequestCount() const;
 };
 
 /**
diff --git a/indra/llcorehttp/tests/llcorehttp_test.cpp b/indra/llcorehttp/tests/llcorehttp_test.cpp
index c7c50e6166..65d7fe93a9 100644
--- a/indra/llcorehttp/tests/llcorehttp_test.cpp
+++ b/indra/llcorehttp/tests/llcorehttp_test.cpp
@@ -44,6 +44,7 @@
 #include "test_httprequest.hpp"
 #include "test_httpheaders.hpp"
 #include "test_httprequestqueue.hpp"
+#include "test_jsonrpcws.hpp"
 #include "_httpservice.h"
 
 #include "llproxy.h"
diff --git a/indra/llcorehttp/tests/test_jsonrpcws.hpp b/indra/llcorehttp/tests/test_jsonrpcws.hpp
new file mode 100644
index 0000000000..6cf7932aa0
--- /dev/null
+++ b/indra/llcorehttp/tests/test_jsonrpcws.hpp
@@ -0,0 +1,146 @@
+/**
+ * @file test_jsonrpcws.hpp
+ * @brief unit tests for LLJSONRPCConnection helpers and dispatch behavior
+ */
+
+#ifndef TEST_LLCORE_JSONRPCWS_H_
+#define TEST_LLCORE_JSONRPCWS_H_
+
+#include "lljsonrpcws.h"
+#include "lltimer.h"
+
+namespace
+{
+class TestJSONRPCConnection : public LLJSONRPCConnection
+{
+public:
+    TestJSONRPCConnection()
+        : LLJSONRPCConnection(LLWebsocketMgr::WSServer::ptr_t(), LLWebsocketMgr::connection_h())
+    {
+    }
+
+    using LLJSONRPCConnection::processMessage;
+    using LLJSONRPCConnection::validateMessage;
+    using LLJSONRPCConnection::testInjectPendingRequest;
+    using LLJSONRPCConnection::testPendingRequestCount;
+    using LLJSONRPCConnection::testSweepTimeouts;
+};
+}
+
+namespace tut
+{
+    struct JSONRPCWSTestData
+    {
+    };
+
+    typedef test_group<JSONRPCWSTestData> JSONRPCWSTestGroupType;
+    typedef JSONRPCWSTestGroupType::object JSONRPCWSTestObjectType;
+    JSONRPCWSTestGroupType JSONRPCWSTestGroup("LLJSONRPCConnection Tests");
+
+    template<> template<>
+    void JSONRPCWSTestObjectType::test<1>()
+    {
+        set_test_name("makeEnvelope notification omits id");
+
+        LLSD params;
+        params["value"] = 42;
+        LLSD env = LLJSONRPCConnection::makeEnvelope(LLSD(), "runtime.debug", params, LLSD(), LLSD());
+
+        ensure("jsonrpc field should exist", env.has("jsonrpc"));
+        ensure_equals("jsonrpc version", env["jsonrpc"].asString(), "2.0");
+        ensure("notification should omit id", !env.has("id"));
+        ensure_equals("method", env["method"].asString(), "runtime.debug");
+        ensure_equals("param round trip", env["params"]["value"].asInteger(), 42);
+    }
+
+    template<> template<>
+    void JSONRPCWSTestObjectType::test<2>()
+    {
+        set_test_name("makeEnvelope response keeps id slot");
+
+        LLSD env = LLJSONRPCConnection::makeEnvelope(LLSD(), std::string(), LLSD(), LLSD("ok"), LLSD());
+
+        ensure("response should include id", env.has("id"));
+        ensure("response should not include method", !env.has("method"));
+        ensure_equals("result", env["result"].asString(), "ok");
+    }
+
+    template<> template<>
+    void JSONRPCWSTestObjectType::test<3>()
+    {
+        set_test_name("validateMessage accepts valid request and rejects invalid params");
+
+        TestJSONRPCConnection conn;
+
+        LLSD valid;
+        valid["jsonrpc"] = "2.0";
+        valid["method"] = "session.ping";
+        LLSD params = LLSD::emptyMap();
+        params["timestamp"] = 123;
+        valid["params"] = params;
+        ensure("valid request should pass", conn.validateMessage(valid, true));
+
+        LLSD invalid = valid;
+        invalid["params"] = "not-an-array-or-object";
+        ensure("invalid params type should fail", !conn.validateMessage(invalid, true));
+    }
+
+    template<> template<>
+    void JSONRPCWSTestObjectType::test<4>()
+    {
+        set_test_name("processMessage dispatches notification handler");
+
+        TestJSONRPCConnection conn;
+
+        bool called = false;
+        LLSD seen_id;
+        LLSD seen_params;
+        conn.registerMethod("runtime.debug",
+            [&](const std::string& method, const LLSD& id, const LLSD& params) -> LLSD
+            {
+                called = true;
+                ensure_equals("method propagated", method, "runtime.debug");
+                seen_id = id;
+                seen_params = params;
+                return LLSD();
+            });
+
+        LLSD params;
+        params["message"] = "hello";
+        LLSD notification = LLJSONRPCConnection::makeEnvelope(LLSD(), "runtime.debug", params, LLSD(), LLSD());
+        conn.processMessage(notification);
+
+        ensure("handler should be called", called);
+        ensure("notification id should be undefined", seen_id.isUndefined());
+        ensure_equals("payload should be forwarded", seen_params["message"].asString(), "hello");
+    }
+
+    template<> template<>
+    void JSONRPCWSTestObjectType::test<5>()
+    {
+        set_test_name("sweepTimeouts expires overdue callbacks");
+
+        TestJSONRPCConnection conn;
+
+        bool callback_called = false;
+        conn.testInjectPendingRequest(
+            "req_1",
+            LLTimer::getTotalSeconds() - 1.0,
+            [&](const LLSD& result, const LLSD& error)
+            {
+                callback_called = true;
+                ensure("timed out result should be undefined", result.isUndefined());
+                ensure_equals(
+                    "timeout code",
+                    error["code"].asInteger(),
+                    LLJSONRPCConnection::RPCError::REQUEST_TIMEOUT);
+            });
+
+        ensure_equals("pending request should be tracked", conn.testPendingRequestCount(), (size_t)1);
+        conn.testSweepTimeouts();
+        ensure("timeout callback should be called", callback_called);
+        ensure_equals("pending request should be removed", conn.testPendingRequestCount(), (size_t)0);
+    }
+}
+
+#endif
\ No newline at end of file
diff --git a/indra/newview/llfloaterimnearbychathandler.cpp b/indra/newview/llfloaterimnearbychathandler.cpp
index e92672f684..34570725ce 100644
--- a/indra/newview/llfloaterimnearbychathandler.cpp
+++ b/indra/newview/llfloaterimnearbychathandler.cpp
@@ -564,6 +564,23 @@ void LLFloaterIMNearbyChatHandler::processChat(const LLChat& chat_msg,
         return;
     }
 
+    if (LLScriptEditorWSServer::isEnabled() &&
+        gSavedSettings.getBOOL("ExternalWebsocketForwardDebug") &&
+        (chat_msg.mChatType == CHAT_TYPE_DEBUG_MSG ||
+         chat_msg.mChatType == CHAT_TYPE_OWNER))
+    {
+        LLScriptEditorWSServer::ptr_t server =
+            LLScriptEditorWSServer::getServer();
+        if (server)
+        {
+            const auto channel =
+                chat_msg.mChatType == CHAT_TYPE_OWNER
+                    ? LLPublishedObjectMgr::RuntimeEventAggregator::Channel::OWNER_SAY
+                    : LLPublishedObjectMgr::RuntimeEventAggregator::Channel::DEBUG;
+            server->forwardChatToIDE(chat_msg, channel);
+        }
+    }
+
     // don't show toast and add message to chat history on receive debug message
     // with disabled setting showing script errors or enabled setting to show script
     // errors in separate window.
@@ -575,15 +592,6 @@ void LLFloaterIMNearbyChatHandler::processChat(const LLChat& chat_msg,
         if (!gSavedSettings.getBOOL("ShowScriptErrors"))
             return;
 
-        if (LLScriptEditorWSServer::isEnabled() && gSavedSettings.getBOOL("ExternalWebsocketForwardDebug"))
-        {
-            LLScriptEditorWSServer::ptr_t server = LLScriptEditorWSServer::getServer();
-            if (server)
-            {
-                server->forwardChatToIDE(chat_msg);
-            }
-        }
-
         // don't process debug messages from not owned objects, see EXT-7762
         if (gAgentID != chat_msg.mOwnerID)
         {
@@ -603,16 +611,6 @@ void LLFloaterIMNearbyChatHandler::processChat(const LLChat& chat_msg,
             return;
         }
     }
-    else if ((chat_msg.mChatType == CHAT_TYPE_OWNER) && LLScriptEditorWSServer::isEnabled() &&
-        gSavedSettings.getBOOL("ExternalWebsocketForwardDebug"))
-    {
-        LLScriptEditorWSServer::ptr_t server = LLScriptEditorWSServer::getServer();
-        if (server)
-        {
-            server->forwardChatToIDE(chat_msg);
-        }
-    }
-
     nearby_chat->addMessage(chat_msg, true, args);
 
     if (chat_msg.mSourceType == CHAT_SOURCE_AGENT
diff --git a/indra/newview/llpreviewscript.cpp b/indra/newview/llpreviewscript.cpp
index 10bacf53b7..354147336a 100644
--- a/indra/newview/llpreviewscript.cpp
+++ b/indra/newview/llpreviewscript.cpp
@@ -40,7 +40,6 @@
 #include "llinventorymodel.h"
 #include "llkeyboard.h"
 #include "lllineeditor.h"
-#include "llmd5.h"
 #include "llhelp.h"
 #include "llnotificationsutil.h"
 #include "llresmgr.h"
@@ -1613,14 +1612,7 @@ std::string LLScriptEdContainer::getUniqueHash() const
     // Take script inventory item id (within the object inventory)
     // to consideration so that it's possible to edit multiple scripts
     // in the same object inventory simultaneously (STORM-781).
-    std::string script_id = mObjectUUID.asString() + "_" + mItemUUID.asString();
-
-    // Use MD5 sum to make the file name shorter and not exceed maximum path length.
-    char  script_id_hash_str[33]; /* Flawfinder: ignore */
-    LLMD5 script_id_hash((const U8*)script_id.c_str());
-    script_id_hash.hex_digest(script_id_hash_str);
-
-    return std::string(script_id_hash_str);
+    return LLScriptEditorWSServer::buildScriptSubscriptionId(mObjectUUID, mItemUUID);
 }
 
 std::string LLScriptEdContainer::getErrorLogFileName(const std::string& script_path)
diff --git a/indra/newview/llpublishedobjectmgr.cpp b/indra/newview/llpublishedobjectmgr.cpp
index e9d13c1213..d92bb382de 100644
--- a/indra/newview/llpublishedobjectmgr.cpp
+++ b/indra/newview/llpublishedobjectmgr.cpp
@@ -29,7 +29,9 @@
 
 #include "llscripteditorws.h"
 
+#include "llchat.h"
 #include "llinventorydefines.h"
+#include "llregex.h"
 #include "llselectmgr.h"
 #include "llviewerinventory.h"
 #include "llviewerobject.h"
@@ -39,6 +41,12 @@
 
 namespace
 {
+    static const boost::regex LUAU_LOCATION_PATTERN(
+        R"(^([^:]*):([0-9]+):\s*(.*)$)");
+
+    static const boost::regex LSL_LOCATION_PATTERN(
+        R"(\((\d+), (\d+)\) : ([^:]+) : (.+))");
+
     std::string nv_string(LLViewerObject* obj, const char* key)
     {
         if (!obj)
@@ -122,13 +130,382 @@ private:
     LLUUID                  mPrimID;
 };
 
-LLPublishedObjectMgr::LLPublishedObjectMgr(LLScriptEditorWSServer* server)
-    : mServer(server)
+LLPublishedObjectMgr::LLPublishedObjectMgr(
+    LLScriptEditorWSServer* server,
+    RuntimeEventCallback runtime_event_callback):
+    mServer(server),
+    mRuntimeEventCallback(std::move(runtime_event_callback)),
+      mRuntimeEventAggregator(std::make_unique<RuntimeEventAggregator>(
+          [this](const RuntimeEventAggregator::RuntimeEvent& runtime_event)
+          {
+              std::optional<RuntimeChatEvent> event =
+                  buildRuntimeChatEvent(runtime_event);
+              if (event && mRuntimeEventCallback)
+              {
+                  mRuntimeEventCallback(*event);
+              }
+          })),
+      mRuntimeFlushTimer(
+          std::unique_ptr<LLEventTimer>(
+              LLEventTimer::run_every(
+                  RUNTIME_FLUSH_INTERVAL,
+                  [this]()
+                  {
+                      flushExpiredRuntimeFragments();
+                  })))
 {
 }
 
 LLPublishedObjectMgr::~LLPublishedObjectMgr() = default;
 
+void LLPublishedObjectMgr::ingestRuntimeChat(
+    const LLChat& chat_msg,
+    RuntimeEventAggregator::Channel channel)
+{
+    static const boost::regex runtime_error_header(
+        R"(^(.+?)\s+\[script:([^\]]+)\]\s+Script run-time error)");
+
+    std::vector<std::string> lines =
+        LLStringUtil::getTokens(chat_msg.mText, "\n");
+    boost::smatch match;
+    bool is_error_header =
+        !lines.empty() &&
+        boost::regex_match(lines.front(), match, runtime_error_header);
+
+    if (!is_error_header && !mRuntimeEventAggregator->hasPending())
+    {
+        RuntimeEventAggregator::RuntimeEvent runtime_event;
+        runtime_event.mVM = RuntimeEventAggregator::VM::LSL2;
+        runtime_event.mChannel = channel;
+
+        RuntimeEventAggregator::Fragment fragment;
+        fragment.mFromID = chat_msg.mFromID;
+        fragment.mFromName = chat_msg.mFromName;
+        fragment.mText = chat_msg.mText;
+        runtime_event.mFragments.push_back(std::move(fragment));
+
+        std::optional<RuntimeChatEvent> event =
+            buildRuntimeChatEvent(runtime_event);
+        if (event && mRuntimeEventCallback)
+        {
+            mRuntimeEventCallback(*event);
+        }
+        return;
+    }
+
+    RuntimeEventAggregator::VM vm = RuntimeEventAggregator::VM::LSL2;
+    LLViewerObject* prim = gObjectList.findObject(chat_msg.mFromID);
+    if (prim)
+    {
+        std::vector<std::string> lines =
+            LLStringUtil::getTokens(chat_msg.mText, "\n");
+        static const boost::regex runtime_error_header(
+            R"(^(.+?)\s+\[script:([^\]]+)\]\s+Script run-time error)");
+        boost::smatch match;
+
+        if (!lines.empty() &&
+            boost::regex_match(lines.front(), match, runtime_error_header))
+        {
+            const std::string script_name = match[2].str();
+            LLInventoryObject::object_list_t inventory;
+            prim->getInventoryContents(inventory);
+            for (const auto& inventory_object : inventory)
+            {
+                LLInventoryItem* item =
+                    dynamic_cast<LLInventoryItem*>(inventory_object.get());
+                if (item && item->getName() == script_name &&
+                    item->getRuntime() == "luau")
+                {
+                    vm = RuntimeEventAggregator::VM::LUAU;
+                    break;
+                }
+            }
+        }
+    }
+
+    mRuntimeEventAggregator->ingest(
+        chat_msg.mFromID,
+        chat_msg.mFromName,
+        chat_msg.mText,
+        vm,
+        channel);
+}
+
+void LLPublishedObjectMgr::flushExpiredRuntimeFragments()
+{
+    mRuntimeEventAggregator->flushExpired();
+}
+
+std::optional<LLPublishedObjectMgr::RuntimeChatEvent>
+LLPublishedObjectMgr::buildRuntimeChatEvent(
+    const RuntimeEventAggregator::RuntimeEvent& runtime_event) const
+{
+    if (runtime_event.mFragments.empty())
+    {
+        return std::nullopt;
+    }
+
+    const RuntimeEventAggregator::Fragment& source =
+        runtime_event.mFragments.front();
+    LLViewerObject* prim = gObjectList.findObject(source.mFromID);
+    if (!prim)
+    {
+        return std::nullopt;
+    }
+
+    LLViewerObject* root = prim->getRootEdit();
+    if (!root)
+    {
+        return std::nullopt;
+    }
+
+    RuntimeChatEvent event;
+    event.mChannel = runtime_event.mChannel;
+    event.mVM = runtime_event.mVM;
+    event.mRootID = root->getID();
+    event.mPrimID = prim->getID();
+    event.mObjectName = source.mFromName;
+    for (const auto& fragment : runtime_event.mFragments)
+    {
+        if (!event.mMessage.empty())
+        {
+            event.mMessage += "\n";
+        }
+        event.mMessage += fragment.mText;
+    }
+
+    std::vector<std::string> lines =
+        LLStringUtil::getTokens(event.mMessage, "\n");
+    static const std::string runtime_error_marker = "Script run-time error";
+    static const boost::regex runtime_error_header(
+        R"(^(.+?)\s+\[script:([^\]]+)\]\s+Script run-time error)");
+
+    auto ends_with = [](const std::string& value, const std::string& suffix)
+    {
+        return value.size() >= suffix.size() &&
+               std::equal(suffix.rbegin(), suffix.rend(), value.rbegin());
+    };
+
+    if (!lines.empty() && ends_with(lines.front(), runtime_error_marker))
+    {
+        event.mIsError = true;
+        boost::smatch match;
+        if (boost::regex_match(lines.front(), match, runtime_error_header))
+        {
+            event.mObjectName = match[1].str();
+            event.mScriptName = match[2].str();
+            lines.erase(lines.begin());
+        }
+        else
+        {
+            lines.clear();
+        }
+    }
+
+    LLInventoryObject::object_list_t inventory;
+    prim->getInventoryContents(inventory);
+    for (const auto& inventory_object : inventory)
+    {
+        LLInventoryItem* item =
+            dynamic_cast<LLInventoryItem*>(inventory_object.get());
+        if (item && !event.mScriptName.empty() &&
+            item->getName() == event.mScriptName)
+        {
+            event.mItemID = item->getUUID();
+            break;
+        }
+    }
+
+    if (event.mIsError && !lines.empty())
+    {
+        RuntimeEventAggregator::VM vm = runtime_event.mVM;
+        if (event.mItemID.notNull())
+        {
+            LLInventoryItem* item =
+                dynamic_cast<LLInventoryItem*>(prim->getInventoryObject(event.mItemID));
+            if (item && item->getRuntime() == "luau")
+            {
+                vm = RuntimeEventAggregator::VM::LUAU;
+            }
+        }
+
+        RuntimeEventAggregator::ParsedError parsed =
+            mRuntimeEventAggregator->parseError(vm, runtime_event.mFragments);
+        event.mError = parsed.mError;
+        event.mLine = parsed.mLine;
+        event.mColumn = parsed.mColumn;
+        event.mStack = lines;
+    }
+
+    return event;
+}
+
+LLPublishedObjectMgr::RuntimeEventAggregator::RuntimeEventAggregator(
+    FlushCallback flush_callback):
+    mFlushCallback(std::move(flush_callback))
+{
+}
+
+void LLPublishedObjectMgr::RuntimeEventAggregator::ingest(
+    const LLUUID& from_id,
+    const std::string& from_name,
+    const std::string& text,
+    VM vm,
+    Channel channel)
+{
+    if (mPending &&
+        isNewBurst(from_id, from_name, vm, channel))
+    {
+        flushPending();
+    }
+
+    if (!mPending)
+    {
+        mPending = std::make_unique<PendingBurst>();
+        mPending->mFromID = from_id;
+        mPending->mFromName = from_name;
+        mPending->mVM = vm;
+        mPending->mChannel = channel;
+    }
+
+    Fragment fragment;
+    fragment.mFromID = from_id;
+    fragment.mFromName = from_name;
+    fragment.mText = text;
+    mPending->mFragments.push_back(std::move(fragment));
+    mPending->mTimer.setTimerExpirySec(FRAGMENT_TIMEOUT);
+}
+
+void LLPublishedObjectMgr::RuntimeEventAggregator::flushExpired()
+{
+    if (mPending && mPending->mTimer.hasExpired())
+    {
+        flushPending();
+    }
+}
+
+void LLPublishedObjectMgr::RuntimeEventAggregator::flush()
+{
+    flushPending();
+}
+
+bool LLPublishedObjectMgr::RuntimeEventAggregator::hasPending() const
+{
+    return mPending != nullptr;
+}
+
+LLPublishedObjectMgr::RuntimeEventAggregator::ParsedError
+LLPublishedObjectMgr::RuntimeEventAggregator::parseError(
+    VM vm,
+    const fragments_t& fragments) const
+{
+    ParsedError parsed;
+    const boost::regex* location_pattern = nullptr;
+    bool lsl_coordinates = false;
+
+    switch (vm)
+    {
+    case VM::LUAU:
+        location_pattern = &LUAU_LOCATION_PATTERN;
+        break;
+    case VM::LSL2:
+        location_pattern = &LSL_LOCATION_PATTERN;
+        lsl_coordinates = true;
+        break;
+    }
+
+    for (const auto& fragment : fragments)
+    {
+        std::vector<std::string> lines =
+            LLStringUtil::getTokens(fragment.mText, "\n");
+        for (const auto& line : lines)
+        {
+            boost::smatch match;
+            if (!boost::regex_match(line, match, *location_pattern))
+            {
+                continue;
+            }
+
+            if (lsl_coordinates)
+            {
+                parsed.mLine = static_cast<S32>(
+                    std::strtol(match[1].str().c_str(), nullptr, 10)) + 1;
+                parsed.mColumn = static_cast<S32>(
+                    std::strtol(match[2].str().c_str(), nullptr, 10)) + 1;
+                parsed.mError = match[4].str();
+            }
+            else
+            {
+                parsed.mSource = match[1].str();
+                parsed.mLine = static_cast<S32>(
+                    std::strtol(match[2].str().c_str(), nullptr, 10));
+                parsed.mColumn = 0;
+                parsed.mError = match[3].str();
+            }
+            return parsed;
+        }
+    }
+
+    // LSL runtime errors commonly arrive as plain text without source
+    // location metadata, for example: "Math Error".
+    if (vm == VM::LSL2)
+    {
+        for (const auto& fragment : fragments)
+        {
+            const std::vector<std::string> lines =
+                LLStringUtil::getTokens(fragment.mText, "\n");
+            for (const auto& line : lines)
+            {
+                if (line.empty() ||
+                    line.find("Script run-time error") != std::string::npos)
+                {
+                    continue;
+                }
+
+                parsed.mError = line;
+                return parsed;
+            }
+        }
+    }
+
+    return parsed;
+}
+
+void LLPublishedObjectMgr::RuntimeEventAggregator::flushPending()
+{
+    if (!mPending)
+    {
+        return;
+    }
+
+    if (!mFlushCallback)
+    {
+        mPending.reset();
+        return;
+    }
+
+    RuntimeEvent event;
+    event.mVM = mPending->mVM;
+    event.mChannel = mPending->mChannel;
+    event.mFragments = mPending->mFragments;
+    event.mError = parseError(mPending->mVM, mPending->mFragments);
+    mFlushCallback(event);
+
+    mPending.reset();
+}
+
+bool LLPublishedObjectMgr::RuntimeEventAggregator::isNewBurst(
+    const LLUUID& from_id,
+    const std::string& from_name,
+    VM vm,
+    Channel channel) const
+{
+    return mPending->mFromID != from_id ||
+           mPending->mFromName != from_name ||
+           mPending->mVM != vm ||
+           mPending->mChannel != channel;
+}
+
 LLPublishedObjectMgr::PublishedObjectInfo::PublishedObjectInfo() = default;
 LLPublishedObjectMgr::PublishedObjectInfo::~PublishedObjectInfo() = default;
 LLPublishedObjectMgr::PublishedObjectInfo::PublishedObjectInfo(PublishedObjectInfo&&) noexcept = default;
diff --git a/indra/newview/llpublishedobjectmgr.h b/indra/newview/llpublishedobjectmgr.h
index 99ffa34b39..51af129dcb 100644
--- a/indra/newview/llpublishedobjectmgr.h
+++ b/indra/newview/llpublishedobjectmgr.h
@@ -27,17 +27,21 @@
 #pragma once
 
 #include "llsd.h"
+#include "lltimer.h"
 #include "lluuid.h"
 #include "lleventtimer.h"
 #include "stdtypes.h"
 
 #include <map>
+#include <functional>
 #include <memory>
+#include <optional>
 #include <set>
 #include <string>
 #include <vector>
 
 class LLScriptEditorWSServer;
+class LLChat;
 class LLPublishedPrimListener;
 class LLViewerObject;
 
@@ -117,9 +121,124 @@ public:
         std::string mPendingItemCreatePump;
     };
 
-    explicit LLPublishedObjectMgr(LLScriptEditorWSServer* server = nullptr);
+    class RuntimeEventAggregator
+    {
+    public:
+        enum class Channel
+        {
+            DEBUG,
+            OWNER_SAY
+        };
+
+        enum class VM
+        {
+            LSL2,
+            LUAU
+        };
+
+        struct StackFrame
+        {
+            S32         mLine{ 0 };
+            std::string mFunction;
+            std::string mSource;
+        };
+
+        struct ParsedError
+        {
+            std::string             mSource;
+            std::string             mError;
+            S32                     mLine{ 0 };
+            S32                     mColumn{ 0 };
+            std::vector<StackFrame> mStack;
+        };
+
+        struct Fragment
+        {
+            LLUUID      mFromID;
+            std::string mFromName;
+            std::string mText;
+        };
+
+        using fragments_t = std::vector<Fragment>;
+
+        struct RuntimeEvent
+        {
+            VM          mVM;
+            Channel     mChannel;
+            fragments_t mFragments;
+            ParsedError mError;
+        };
+
+        using FlushCallback = std::function<void(const RuntimeEvent&)>;
+
+        explicit RuntimeEventAggregator(FlushCallback flush_callback);
+
+        void ingest(const LLUUID& from_id,
+                    const std::string& from_name,
+                    const std::string& text,
+                    VM vm,
+                    Channel channel);
+        void flushExpired();
+        void flush();
+        ParsedError parseError(VM vm,
+                               const fragments_t& fragments) const;
+        bool hasPending() const;
+
+    private:
+        struct PendingBurst
+        {
+            LLUUID      mFromID;
+            std::string mFromName;
+            VM          mVM{ VM::LSL2 };
+            Channel     mChannel{ Channel::DEBUG };
+            fragments_t mFragments;
+            LLTimer     mTimer;
+        };
+
+        static constexpr F32 FRAGMENT_TIMEOUT = 1.0f;
+
+        void flushPending();
+        bool isNewBurst(const LLUUID& from_id,
+                const std::string& from_name,
+                VM vm,
+                Channel channel) const;
+
+        FlushCallback mFlushCallback;
+        std::unique_ptr<PendingBurst> mPending;
+    };
+
+    struct RuntimeChatEvent
+    {
+        RuntimeEventAggregator::Channel mChannel;
+        RuntimeEventAggregator::VM      mVM;
+        LLUUID                          mRootID;
+        LLUUID                          mPrimID;
+        LLUUID                          mItemID;
+        std::string                     mObjectName;
+        std::string                     mScriptName;
+        std::string                     mMessage;
+        std::string                     mError;
+        S32                             mLine{ 0 };
+        S32                             mColumn{ 0 };
+        std::vector<std::string>        mStack;
+        bool                            mIsError{ false };
+    };
+
+    using RuntimeEventCallback =
+        std::function<void(const RuntimeChatEvent&)>;
+
+    explicit LLPublishedObjectMgr(
+        LLScriptEditorWSServer* server = nullptr,
+        RuntimeEventCallback runtime_event_callback = {});
     ~LLPublishedObjectMgr();
 
+    void flushExpiredRuntimeFragments();
+    void ingestRuntimeChat(
+        const LLChat& chat_msg,
+        RuntimeEventAggregator::Channel channel);
+    std::optional<RuntimeChatEvent> buildRuntimeChatEvent(
+        const RuntimeEventAggregator::RuntimeEvent& event) const;
+
     bool hasPublished(const LLUUID& object_id) const { return mPublishedObjects.find(object_id) != mPublishedObjects.end(); }
     void erasePublished(const LLUUID& object_id) { mPublishedObjects.erase(object_id); }
     PublishedObjectInfo* getPublished(const LLUUID& object_id);
@@ -190,6 +309,12 @@ public:
 
 private:
     LLScriptEditorWSServer* mServer{ nullptr };
+    std::unique_ptr<RuntimeEventAggregator> mRuntimeEventAggregator;
+    RuntimeEventCallback mRuntimeEventCallback;
+    std::unique_ptr<LLEventTimer> mRuntimeFlushTimer;
+
+    static constexpr F32 RUNTIME_FLUSH_INTERVAL = 0.25f;
+
     void cancelPendingPublishWithCleanup(const LLUUID& object_id);
     void clearPublishedListeners(const LLUUID& object_id);
 
diff --git a/indra/newview/llscripteditorws.cpp b/indra/newview/llscripteditorws.cpp
index 0487ebd06d..e33e18bcd4 100644
--- a/indra/newview/llscripteditorws.cpp
+++ b/indra/newview/llscripteditorws.cpp
@@ -50,6 +50,7 @@
 #include "llpreviewscript.h"
 #include "llprocess.h"
 #include "llregex.h"
+#include "llmd5.h"
 #include "llsdjson.h"
 #include "llselectmgr.h"
 #include "lltrans.h"
@@ -68,6 +69,8 @@
 #include "llvoinventorylistener.h"
 #include "roles_constants.h"
 
+#include <array>
+
 namespace
 {
     // Per-operation timeouts (seconds) for coroutine-based async RPC handlers.
@@ -80,6 +83,12 @@ namespace
     constexpr F32 LINKSET_ADD_FLUSH_DELAY    = 5.0f;
     constexpr F32 LINKSET_REMOVE_FLUSH_DELAY = 0.2f;
 
+    static const boost::regex LUAU_LOCATION_PATTERN(
+        R"(^([^:]*):([0-9]+):\s*(.*)$)");
+
+    static const boost::regex LSL_LOCATION_PATTERN(
+        R"(\((\d+), (\d+)\) : ([^:]+) : (.+))");
+
     // Creates a uniquely-named LLEventMailDrop under "<prefix>.<uuid>", passes
     // its name to kickoff (which arranges for one post to that pump), then
     // suspends the current coroutine up to 	imeout seconds for the result.
@@ -165,7 +174,12 @@ namespace
 //========================================================================
 LLScriptEditorWSServer::LLScriptEditorWSServer(const std::string& name, U16 port, bool local_only):
     LLJSONRPCServer(name, port, local_only),
-    mPublishedObjectManager(this)
+    mPublishedObjectManager(
+        this,
+        [this](const LLPublishedObjectMgr::RuntimeChatEvent& event)
+        {
+            sendRuntimeEvent(event);
+        })
 {
     LL_INFOS("ScriptEditorWS") << "Created JSON-RPC script editor server: " << name
                                << " on port " << port << LL_ENDL;
@@ -198,11 +212,8 @@ LLScriptEditorWSServer::LLScriptEditorWSServer(const std::string& name, U16 port
 
             if (!handle_zoom_to_object(object_id))
             {
-                LLSD response;
-                response["success"]    = false;
-                response["error_code"] = WSCommandError::ExecutionError;
-                response["message"]    = "Object not found or not reachable";
-                return response;
+                throw LLJSONRPCConnection::InternalError(
+                    "Object not found or not reachable");
             }
 
             LLSD response;
@@ -279,6 +290,18 @@ LLScriptEditorWSServer::ptr_t LLScriptEditorWSServer::ensureServerRunning()
     return server;
 }
 
+std::string LLScriptEditorWSServer::buildScriptSubscriptionId(const LLUUID& object_id,
+                                                              const LLUUID& item_id)
+{
+    std::string script_id = object_id.asString() + "_" + item_id.asString();
+
+    std::array<char, MD5HEX_STR_SIZE> script_id_hash_str = {};
+    LLMD5 script_id_hash((const U8*)script_id.c_str());
+    script_id_hash.hex_digest(script_id_hash_str.data());
+
+    return std::string(script_id_hash_str.data());
+}
+
 std::string LLScriptEditorWSServer::buildVSCodeURI(const LLUUID& object_id,
                                                     const LLUUID& script_id)
 {
@@ -431,8 +454,12 @@ bool LLScriptEditorWSServer::subscribeScriptEditor(const LLUUID& object_id, cons
     if (it == mSubscriptions.end())
     {
         // New subscription
-        mSubscriptions.emplace(script_id,
-            EditorSubscription(object_id, item_id, script_name, editor_handle));
+            ItemRef item_ref;
+            item_ref.mPrimID = object_id;
+            item_ref.mItemID = item_id;
+            item_ref.mScriptName = script_name;
+            mSubscriptions.emplace(script_id,
+                EditorSubscription(item_ref, editor_handle));
     }
     else
     {
@@ -451,8 +478,6 @@ void LLScriptEditorWSServer::unsubscribeEditor(const std::string &script_id)
         auto connection = it->second.mConnection.lock();
         mSubscriptions.erase(it);
 
-        // Maintain per-connection count; erase entry when it hits zero.
-        bool last_for_connection = false;
         if (connection_id != 0)
         {
             auto cit = mConnectionSubscriptionCounts.find(connection_id);
@@ -461,21 +486,8 @@ void LLScriptEditorWSServer::unsubscribeEditor(const std::string &script_id)
                 if (--cit->second <= 0)
                 {
                     mConnectionSubscriptionCounts.erase(cit);
-                    last_for_connection = true;
                 }
             }
-            else
-            {
-                // No counter entry means no other subs referenced this connection.
-                last_for_connection = true;
-            }
-        }
-
-        if (connection && last_for_connection)
-        { // We have removed the last subscription, close the connection
-            LL_DEBUGS("ScriptEditorWS") << "Closing connection ID " << connection_id <<
-                " as last subscription was removed" << LL_ENDL;
-            connection->sendDisconnect(LLScriptEditorWSConnection::DisconnectReason::EDITOR_CLOSED, "Editor closed");
         }
 
     }
@@ -597,7 +609,7 @@ void LLScriptEditorWSServer::setupConnectionMethods(LLJSONRPCConnection::ptr_t c
                 return s.handleSyntaxCacheFileRequest(params);
             }));
 
-        script_connection->registerMethod("script.subscribe",
+        script_connection->registerAsyncMethod("script.subscribe",
             bindHandler([connection_id](LLScriptEditorWSServer& s, auto&, auto&, const LLSD& params)
             {
                 return s.handleScriptSubscribe(connection_id, params);
@@ -609,7 +621,7 @@ void LLScriptEditorWSServer::setupConnectionMethods(LLJSONRPCConnection::ptr_t c
                 return s.handleFileWatcherFileListRequest();
             }));
 
-        script_connection->registerMethod("object.unpublish",
+        script_connection->registerAsyncMethod("object.unpublish",
             bindHandler([connection_id](LLScriptEditorWSServer& s, auto&, auto&, const LLSD& params)
             {
                 return s.handleObjectUnpublish(connection_id, params);
@@ -946,39 +958,27 @@ LLSD LLScriptEditorWSServer::handleSaveBackToObjectContents(U32 connection_id, c
         mPublishedObjectManager.getPublished(object_id);
     if (!published_info)
     {
-        LLSD response;
-        response["success"] = false;
-        response["error_code"] = WSCommandError::InvalidParams;
-        response["message"] = "Object is not published";
-        return response;
+        throw LLJSONRPCConnection::InvalidParams(
+            "Object is not published");
     }
 
     if (!published_info->mCanSaveBackToContents || published_info->mSourceTaskID.isNull())
     {
-        LLSD response;
-        response["success"] = false;
-        response["error_code"] = WSCommandError::NotPermitted;
-        response["message"] = "Save back is not available for this object";
-        return response;
+        throw LLJSONRPCConnection::ForbiddenError(
+            "Save back is not available for this object");
     }
 
     LLViewerObject* root = gObjectList.findObject(object_id);
     if (!root)
     {
-        LLSD response;
-        response["success"] = false;
-        response["error_code"] = WSCommandError::InvalidParams;
-        response["message"] = "object_id not found";
-        return response;
+        throw LLJSONRPCConnection::InvalidParams(
+            "object_id not found");
     }
 
     if (!save_object_back_to_contents(root, published_info->mSourceTaskID))
     {
-        LLSD response;
-        response["success"] = false;
-        response["error_code"] = WSCommandError::ExecutionError;
-        response["message"] = "Failed to save object back to contents";
-        return response;
+        throw LLJSONRPCConnection::InternalError(
+            "Failed to save object back to contents");
     }
 
     LL_DEBUGS("ScriptEditorWS") << "Save-back requested via command for object "
@@ -1004,11 +1004,8 @@ LLSD LLScriptEditorWSServer::handleCommandExecute(U32 connection_id, const LLSD&
     auto it = mCommandRegistry.find(command);
     if (it == mCommandRegistry.end())
     {
-        LLSD response;
-        response["success"]    = false;
-        response["error_code"] = WSCommandError::UnknownCommand;
-        response["message"]    = "Unknown command: " + command;
-        return response;
+        throw LLJSONRPCConnection::InvalidParams(
+            "Unknown command: " + command);
     }
 
     return it->second.second(connection_id, params["params"]);
@@ -1088,27 +1085,32 @@ LLSD LLScriptEditorWSServer::handleSyntaxRequest(const LLSD& params) const
 
     if (category.empty())
     {
-        response["error"] = "No syntax category specified";
-        response["success"] = false;
-        return response;
+        throw LLJSONRPCConnection::InvalidParams(
+            "No syntax category specified");
     }
 
     response["id"] = mLastSyntaxId;
     if (category == "defs.lua")
     {
         response["defs"] = LLSyntaxDefCache::instance().getLuaKeywords();
-        response["success"] = response["defs"].isDefined();
     }
     else if (category == "defs.lsl")
     {
         response["defs"] = LLSyntaxDefCache::instance().getLSLKeywords();
-        response["success"] = response["defs"].isDefined();
     }
     else
     {
-        response["error"] = "Unknown syntax category requested";
-        response["success"] = false;
+        throw LLJSONRPCConnection::InvalidParams(
+            "Unknown syntax category requested");
+    }
+
+    if (!response["defs"].isDefined())
+    {
+        throw LLJSONRPCConnection::InternalError(
+            "Syntax definitions are unavailable");
     }
+
+    response["success"] = true;
     return response;
 }
 
@@ -1136,28 +1138,25 @@ LLSD LLScriptEditorWSServer::handleSyntaxCacheFileRequest(const LLSD& params) co
 
     if (filename.empty())
     {
-        response["error"] = "No filename specified";
-        response["success"] = false;
-        return response;
+        throw LLJSONRPCConnection::InvalidParams(
+            "No filename specified");
     }
     if (!cache.hasCacheFile(filename))
     {
-        response["error"] = "Requested syntax cache file not found";
-        response["success"] = false;
-        return response;
+        throw LLJSONRPCConnection::InvalidParams(
+            "Requested syntax cache file not found");
     }
-    bool success = false;
     if (as_json)
     {
         LLSD file_content   = cache.loadCacheFileAsLLSD(filename);
         if (file_content.isDefined())
         {
             response["content"] = file_content;
-            success = true;
         }
         else
         {
-            response["error"] = "Failed to load and format syntax cache file.";
+            throw LLJSONRPCConnection::InternalError(
+                "Failed to load and format syntax cache file.");
         }
     }
     else
@@ -1166,14 +1165,14 @@ LLSD LLScriptEditorWSServer::handleSyntaxCacheFileRequest(const LLSD& params) co
         if (!content.empty())
         {
             response["content"] = content;
-            success = true;
         }
         else
         {
-            response["error"] = "Failed to load syntax cache file";
+            throw LLJSONRPCConnection::InternalError(
+                "Failed to load syntax cache file");
         }
     }
-    response["success"] = success;
+    response["success"] = true;
     return response;
 }
 
@@ -1217,10 +1216,22 @@ LLSD LLScriptEditorWSServer::handleScriptSubscribe(U32 connection_id, const LLSD
         auto it = mSubscriptions.find(script_id);
         if (it != mSubscriptions.end())
         {
-            LLViewerObject* object  = gObjectList.findObject((*it).second.mObjectID);
-            response["object_id"] = (*it).second.mObjectID;
+            LLUUID prim_id = (*it).second.mItemRef.mPrimID;
+            LLUUID root_id = prim_id;
+            LLViewerObject* object = gObjectList.findObject(prim_id);
+            if (object)
+            {
+                LLViewerObject* root = object->getRootEdit();
+                if (root)
+                {
+                    root_id = root->getID();
+                }
+            }
+
+            response["object_id"] = prim_id;
+            response["root_id"] = root_id;
             //response["object_name"] = object ? object->getName() : "Unknown";
-            response["item_id"] = (*it).second.mItemID;
+            response["item_id"] = (*it).second.mItemRef.mItemID;
         }
     }
 
@@ -1265,32 +1276,31 @@ LLSD LLScriptEditorWSServer::handleObjectRequest(U32 connection_id, const LLSD&
 
     if (object_id.isNull())
     {
-        response["success"] = false;
-        response["message"] = "No object_id specified";
-        return response;
+        throw LLJSONRPCConnection::InvalidParams(
+            "No object_id specified");
     }
 
     LLViewerObject* object = gObjectList.findObject(object_id);
     if (!object)
     {
-        response["success"] = false;
-        response["message"] = "Object not found";
-        return response;
+        throw LLJSONRPCConnection::InvalidParams(
+            "Object not found");
     }
 
     if (!object->permModify())
     {
-        response["success"] = false;
-        response["message"] = "Permission denied";
-        return response;
+        throw LLJSONRPCConnection::ForbiddenError(
+            "Permission denied");
     }
 
     bool accepted = publishObject(object_id);
-    response["success"] = accepted;
     if (!accepted)
     {
-        response["message"] = "Failed to initiate publish";
+        throw LLJSONRPCConnection::InternalError(
+            "Failed to initiate publish");
     }
+
+    response["success"] = true;
     return response;
 }
 
@@ -1531,7 +1541,16 @@ LLSD LLScriptEditorWSServer::saveScript(LLViewerObject* prim, LLInventoryItem* i
     response["compiled"] = cb_result["compiled"];
     if (!cb_result["compiled"].asBoolean() && cb_result.has("errors"))
     {
-        response["errors"] = cb_result["errors"];
+        response["diagnostics"] = LLSD::emptyArray();
+        for (const auto& error : llsd::inArray(cb_result["errors"]))
+        {
+            LLSD diagnostic;
+            diagnostic["row"] = 0;
+            diagnostic["column"] = 0;
+            diagnostic["level"] = "ERROR";
+            diagnostic["message"] = error.asString();
+            response["diagnostics"].append(diagnostic);
+        }
     }
 
     // If the script is open in the viewer's editor, update it
@@ -1934,12 +1953,10 @@ void LLScriptEditorWSServer::sendCompileResults(const std::string &script_id, co
     params["running"]  = results["is_running"].asBoolean();
     if (results.has("errors"))
     {
-        params["errors"] = LLSD::emptyArray();
+        params["diagnostics"] = LLSD::emptyArray();
 
         if (is_lua)
         {   // lua errors: ":line: message", line is 1-based
-            const static boost::regex lua_err_regex(R"(^[^:]*:(\d+): (.+)$)");
-
             for (const auto& err : llsd::inArray(results["errors"]))
             {
                 boost::smatch match;
@@ -1948,10 +1965,10 @@ void LLScriptEditorWSServer::sendCompileResults(const std::string &script_id, co
                 err_entry["column"] = 0; // TODO: Lua compiler does not provide column info
                 err_entry["level"]  = "ERROR";
 
-                if (boost::regex_match(err.asString(), match, lua_err_regex))
+                if (boost::regex_match(err.asString(), match, LUAU_LOCATION_PATTERN))
                 {
-                    S32 line_number = std::stoi(match[1].str());
-                    std::string message = match[2].str();
+                    S32 line_number = std::stoi(match[2].str());
+                    std::string message = match[3].str();
 
                     err_entry["row"] = line_number;
                     err_entry["message"] = message;
@@ -1961,19 +1978,17 @@ void LLScriptEditorWSServer::sendCompileResults(const std::string &script_id, co
                     err_entry["row"] = 0;
                     err_entry["message"] = err.asString();
                 }
-                params["errors"].append(err_entry);
+                params["diagnostics"].append(err_entry);
             }
         }
         else
         {   // lsl errors: "(line, column) : SEVERITY : message", line and column are 0-based
-            static const boost::regex lsl_err_regex(R"(\((\d+), (\d+)\) : ([^:]+) : (.+))");
-
             for (const auto& err : llsd::inArray(results["errors"]))
             {
                 boost::smatch match;
                 LLSD err_entry;
 
-                if (boost::regex_match(err.asString(), match, lsl_err_regex))
+                if (boost::regex_match(err.asString(), match, LSL_LOCATION_PATTERN))
                 {
                     S32         line_number = std::stoi(match[1].str());
                     S32         col_number = std::stoi(match[2].str());
@@ -1994,7 +2009,7 @@ void LLScriptEditorWSServer::sendCompileResults(const std::string &script_id, co
                     err_entry["message"] = err.asString();
                     err_entry["format"]  = "lsl";
                 }
-                params["errors"].append(err_entry);
+                params["diagnostics"].append(err_entry);
             }
         }
     }
@@ -2002,138 +2017,73 @@ void LLScriptEditorWSServer::sendCompileResults(const std::string &script_id, co
     notifyScript(script_id, "script.compiled", params);
 }
 
-void LLScriptEditorWSServer::forwardChatToIDE(const LLChat& chat_msg) const
+void LLScriptEditorWSServer::forwardChatToIDE(
+    const LLChat& chat_msg,
+    LLPublishedObjectMgr::RuntimeEventAggregator::Channel channel) const
 {
     LL_PROFILE_ZONE_SCOPED_CATEGORY_SCRIPTDEV;
 
-    LLUUID object_id = chat_msg.mFromID;
-    bool tracking = false;
-    bool publish    = false;
+    mPublishedObjectManager.ingestRuntimeChat(chat_msg, channel);
+}
 
-    LLUUID publish_id = object_id;
-    LLViewerObject* objectp = gObjectList.findObject(object_id);
-    if (objectp)
-    {
-        LLViewerObject* root = objectp->getRootEdit();
-        if (root)
-        {
-            publish_id = root->getID();
-        }
-    }
+void LLScriptEditorWSServer::sendRuntimeEvent(
+    const LLPublishedObjectMgr::RuntimeChatEvent& event) const
+{
 
-    const EditorSubscription* subinfo = nullptr;
-    std::string               script_id;
-    // have we either published or subscribed to this object?
-    if (isObjectPublished(publish_id))
+    std::string script_id;
+    if (event.mItemID.notNull())
     {
-        tracking = true;
-        publish  = true;
-    }
-    else
-    {
-        // If the object is not published, we may still be tracking it if it is a script we are subscribed to
-        auto it = std::find_if(mSubscriptions.begin(), mSubscriptions.end(),
-                               [&object_id](const auto& pair) { return (pair.second.mObjectID == object_id); });
-        if (it != mSubscriptions.end())
-        {
-            tracking = true;
-            subinfo = &it->second;
-            script_id = it->first;
-        }
+        script_id = buildScriptSubscriptionId(event.mPrimID, event.mItemID);
     }
 
-    if (!tracking)
-    {   // Not a script we are tracking
-        return;
-    }
-
-    bool is_error = false;
-    std::string error_message;
-    std::string object_name = chat_msg.mFromName;
-    std::string script_name;
-    S32         line_number = 0;
-    // We have at least one script from this object, we will forward the message to the IDE
-    // but first we need to see if it is a runtime error
-    std::vector<std::string> lines = LLStringUtil::getTokens(chat_msg.mText, "\n");
-    // If this is a runtime error, the first line will look like: "<Object Name> [script:<Script Name>] Script run-time error"
-    static const std::string runtime_error_marker = "Script run-time error";
-    auto ends_with = [](const std::string& s, const std::string& suffix)
-    {
-        return s.size() >= suffix.size() &&
-               std::equal(suffix.rbegin(), suffix.rend(), s.rbegin());
-    };
-
-    if (!lines.empty() && ends_with(lines.front(), runtime_error_marker))
+    if (!isObjectPublished(event.mRootID) &&
+        (script_id.empty() || mSubscriptions.find(script_id) == mSubscriptions.end()))
     {
-        is_error = true;
-        std::string first_line = lines.front();
-
-        // Extract the object and script name from the first line
-        static const boost::regex RUNTIME_ERR_REGEX_FLEX(R"(^(.+?)\s+\[script:([^\]]+)\]\s+Script run-time error)");
-        boost::smatch m;
-
-        S32 remove_count = 0;
-        if (boost::regex_match(first_line, m, RUNTIME_ERR_REGEX_FLEX))
-        {
-            object_name = m[1].str();
-            script_name = m[2].str();
-            remove_count++;
-        }
-
-        // TODO: Build an actual error message to forward to the external editor.
-        // The complete error message arrives as two or three separate chat
-        // messages from the server (2 for LSL / non-owner Lua, 3 for owner Lua):
-        //   Message 1: <Object Name> [script:<Script Name>] Script run-time error
-        //   Message 2: <runtime error>
-        //   Message 3: <script>:<line>: <actual error message>\n<call stack>
-        // These need to be composited into a single error message for the IDE.
-        if (lines.size() > remove_count)
-        {   // The rest of the lines may contain a stack trace
-            lines.erase(lines.begin(), lines.begin() + remove_count);
-        }
-        else
-        {
-            lines.clear();
-        }
-
-        if (subinfo)
-        {
-            // We should also check that the script name matches one of our subscriptions
-            if (!script_name.empty() && (subinfo->mScriptName != script_name))
-            { // right object, wrong script
-                auto sit =
-                    std::find_if(mSubscriptions.begin(), mSubscriptions.end(), [&chat_msg, &script_name](const auto& pair)
-                                 { return (pair.second.mScriptName == script_name) && (pair.second.mObjectID == chat_msg.mFromID); });
-                if (sit != mSubscriptions.end())
-                { // We have a better match
-                    subinfo = &sit->second;
-                    script_id = sit->first;
-                }
-            }
-        }
+        return;
     }
 
     LLSD message;
     message["script_id"] = script_id;
-    message["object_id"] = object_id;
-    message["object_name"] = object_name;
-    message["message"]     = chat_msg.mText;
+    message["object_id"] = event.mRootID;
+    message["prim_id"] = event.mPrimID;
+    message["item_id"] = event.mItemID;
+    message["object_name"] = event.mObjectName;
+    message["message"] = event.mMessage;
+
+    LLSD item;
+    item["root_id"] = event.mRootID;
+    item["prim_id"] = event.mPrimID;
+    item["item_id"] = event.mItemID;
+    item["name"] = event.mScriptName;
+    item["language"] =
+        event.mVM == LLPublishedObjectMgr::RuntimeEventAggregator::VM::LUAU
+            ? "luau"
+            : "lsl";
+    message["item"] = item;
+
+    switch (event.mChannel)
+    {
+    case LLPublishedObjectMgr::RuntimeEventAggregator::Channel::DEBUG:
+        message["channel"] = "debug";
+        break;
+    case LLPublishedObjectMgr::RuntimeEventAggregator::Channel::OWNER_SAY:
+        message["channel"] = "owner_say";
+        break;
+    }
 
-    if (is_error)
+    if (event.mIsError)
     {
-        message["error"] = error_message;
-        message["line"] = line_number;
-        if (!lines.empty())
+        message["error"] = event.mError;
+        message["line"] = event.mLine;
+        message["column"] = event.mColumn;
+        message["stack"] = LLSD::emptyArray();
+        for (const auto& line : event.mStack)
         {
-            message["stack"] = LLSD::emptyArray();
-            for (const auto& line : lines)
-            {
-                message["stack"].append(line);
-            }
+            message["stack"].append(line);
         }
     }
 
-    notifyAll(is_error ? "runtime.error" : "runtime.debug", message);
+    notifyAll(event.mIsError ? "runtime.error" : "runtime.debug", message);
 }
 
 void LLScriptEditorWSServer::notifyConnection(U32 connection_id, const std::string& method, const LLSD& params) const
@@ -2171,15 +2121,6 @@ void LLScriptEditorWSServer::notifyAll(const std::string& method, const LLSD& pa
 }
 
 
-// static
-LLSD LLScriptEditorWSServer::errorResponse(const std::string& message)
-{
-    LLSD response;
-    response["success"] = false;
-    response["message"] = message;
-    return response;
-}
-
 // static
 std::string LLScriptEditorWSServer::getPrimName(LLViewerObject* obj)
 {
@@ -2599,6 +2540,7 @@ void LLScriptEditorWSConnection::onOpen()
     features["compilation"]      = true;
     features["syntax_cache"]     = true;
     features["commands"]         = true;
+    features["unified_diagnostics"] = true;
     handshake["features"]        = features;
 
     wptr_t that = weak_from_this();
diff --git a/indra/newview/llscripteditorws.h b/indra/newview/llscripteditorws.h
index ded83e6369..1dc218853b 100644
--- a/indra/newview/llscripteditorws.h
+++ b/indra/newview/llscripteditorws.h
@@ -36,6 +36,7 @@
 
 #include <memory>
 #include <string>
+#include <vector>
 #include <map>
 #include <set>
 #include <atomic>
@@ -157,6 +158,14 @@ private:
 class LLScriptEditorWSServer : public LLJSONRPCServer
 {
 public:
+    struct ItemRef
+    {
+        LLUUID      mRootID;
+        LLUUID      mPrimID;
+        LLUUID      mItemID;
+        std::string mScriptName;
+    };
+
     static constexpr U32 ALL_CONNECTIONS = 0xFFFFFFFF;
     enum class SubscriptionError
     {
@@ -179,6 +188,8 @@ public:
 
     static LLScriptEditorWSServer::ptr_t getServer();
     static LLScriptEditorWSServer::ptr_t ensureServerRunning();
+    static std::string                   buildScriptSubscriptionId(const LLUUID& object_id,
+                                                                   const LLUUID& item_id);
     static std::string                   buildVSCodeURI(const LLUUID& object_id = LLUUID::null,
                                                         const LLUUID& script_id = LLUUID::null);
     static bool                          launchVSCode(const LLUUID& object_id = LLUUID::null,
@@ -199,7 +210,9 @@ public:
 
     LLHandle<LLPanel> findEditorForScript(const std::string& script_id) const;
 
-    void forwardChatToIDE(const LLChat& chat_msg) const;
+    void forwardChatToIDE(
+        const LLChat& chat_msg,
+        LLPublishedObjectMgr::RuntimeEventAggregator::Channel channel) const;
 
     std::set<std::string> getActiveScripts() const;
 
@@ -268,7 +281,6 @@ protected:
     void scheduleLinksetFlush(const LLUUID& root_id, F32 delay);
     void cancelLinksetFlushTimer(const LLUUID& root_id);
     void flushLinksetUpdate(const LLUUID& root_id);
-    static LLSD errorResponse(const std::string& message);
 
     /// Wraps `fn` in a MethodHandler with a weak-ptr guard on this server,
     /// so the handler safely no-ops after server shutdown. `fn` is called
@@ -291,18 +303,18 @@ protected:
     }
 
 private:
+    void sendRuntimeEvent(
+        const LLPublishedObjectMgr::RuntimeChatEvent& event) const;
+
     struct EditorSubscription
     {
-        EditorSubscription(const LLUUID &object_id, const LLUUID &item_id, std::string_view script_name, LLHandle<LLPanel> editor_handle):
-            mObjectID(object_id),
-            mItemID(item_id),
-            mScriptName(script_name),
+        EditorSubscription(const ItemRef& item_ref, LLHandle<LLPanel> editor_handle):
+            mItemRef(item_ref),
             mEditorHandle(editor_handle)
-        {}
+        {
+        }
         U32 mConnectionID{ 0 };
-        LLUUID mObjectID;
-        LLUUID mItemID;
-        std::string mScriptName;
+        ItemRef mItemRef;
         LLScriptEditorWSConnection::wptr_t mConnection;
         LLHandle<LLPanel> mEditorHandle;
     };
@@ -312,10 +324,6 @@ private:
     void                unsubscribeConnection(U32 connection_id);
 
     subscriptions_t mSubscriptions;
-    // Per-connection subscription count. Invariant: for c != 0,
-    // mConnectionSubscriptionCounts[c] == count of entries in mSubscriptions
-    // whose mConnectionID == c. Maintained transactionally at every site that
-    // mutates SubscriptionInfo::mConnectionID.
     std::unordered_map<U32, S32> mConnectionSubscriptionCounts;
     std::map<U32, LLScriptEditorWSConnection::wptr_t> mActiveConnections;
 
@@ -341,9 +349,4 @@ private:
     boost::signals2::connection mLanguageChangeSignal;
     LLUUID mLastSyntaxId;
 
-
-    LLTimer mCleanupTimer;
-    static constexpr F32 CLEANUP_INTERVAL = 60.0f; // seconds
-    static constexpr F32 CONNECTION_TIMEOUT = 300.0f; // 5 minutes
-
 };
-- 
cgit v1.3


From 9aa7feee4eae4fbc34d7e777c94be2e024f6c053 Mon Sep 17 00:00:00 2001
From: Rider Linden <rider@lindenlab.com>
Date: Wed, 26 Aug 2026 09:52:39 -0700
Subject: Issue #6192: object.publish was not sending can_save_back.

---
 indra/newview/llpublishedobjectmgr.cpp | 5 +++++
 1 file changed, 5 insertions(+)

(limited to 'indra/newview/llpublishedobjectmgr.cpp')

diff --git a/indra/newview/llpublishedobjectmgr.cpp b/indra/newview/llpublishedobjectmgr.cpp
index d92bb382de..1eb000d98f 100644
--- a/indra/newview/llpublishedobjectmgr.cpp
+++ b/indra/newview/llpublishedobjectmgr.cpp
@@ -737,6 +737,11 @@ LLSD LLPublishedObjectMgr::buildPublishedObjectLLSD(LLViewerObject* root) const
     {
         pub["region"] = root->getRegion()->getName();
     }
+    const PublishedObjectInfo* published_info = getPublished(root->getID());
+    if (published_info)
+    {
+        pub["can_save_back"] = published_info->mCanSaveBackToContents;
+    }
     pub["inventory"] = buildPrimInventoryLLSD(root);
 
     LLSD linked_objects = LLSD::emptyArray();
-- 
cgit v1.3


From af70716e4e7dc43434c1859fa6d96e7dea5ffb9b Mon Sep 17 00:00:00 2001
From: Rider Linden <rider@lindenlab.com>
Date: Wed, 26 Aug 2026 10:38:17 -0700
Subject: Issue #6182: Include object permissions for both root object and
 linked prims.

---
 doc/external-editor-json-rpc.md        |  3 ++-
 indra/newview/llpublishedobjectmgr.cpp | 20 ++++++++++++++++++++
 2 files changed, 22 insertions(+), 1 deletion(-)

(limited to 'indra/newview/llpublishedobjectmgr.cpp')

diff --git a/doc/external-editor-json-rpc.md b/doc/external-editor-json-rpc.md
index 3744bfd5e9..74ee34f528 100644
--- a/doc/external-editor-json-rpc.md
+++ b/doc/external-editor-json-rpc.md
@@ -958,6 +958,7 @@ interface LinkedObject {
   link_number: number;      // Link number (root=1, children≥2)
   link_name: string;
   link_description?: string;
+  permissions?: ObjectPermissions;   // Actual permissions for this linked prim
   inventory: ObjectInventoryItem[];
 }
 
@@ -973,7 +974,7 @@ interface PublishedObject {
   object_description?: string;
   region?: string;
   owner_id?: string;
-  permissions?: ObjectPermissions;
+  permissions?: ObjectPermissions;   // Actual permissions for this root prim
   can_save_back?: boolean;      // Whether Save Back to Contents is currently available for this object
   inventory: ObjectInventoryItem[];      // Root prim's scripts and notecards
   linked_objects?: LinkedObject[];       // Child prims
diff --git a/indra/newview/llpublishedobjectmgr.cpp b/indra/newview/llpublishedobjectmgr.cpp
index 1eb000d98f..5c9c080b5d 100644
--- a/indra/newview/llpublishedobjectmgr.cpp
+++ b/indra/newview/llpublishedobjectmgr.cpp
@@ -729,6 +729,11 @@ LLSD LLPublishedObjectMgr::buildPublishedObjectLLSD(LLViewerObject* root) const
 {
     LL_PROFILE_ZONE_SCOPED_CATEGORY_SCRIPTDEV;
     LLSD pub;
+    const LLPermissions& root_perms = root->getPermissions();
+    LLSD root_perm_entry;
+    root_perm_entry["owner"]      = static_cast<S32>(root_perms.getMaskOwner());
+    root_perm_entry["next_owner"] = static_cast<S32>(root_perms.getMaskNextOwner());
+    pub["permissions"]            = root_perm_entry;
     pub["object_id"]          = root->getID();
     pub["object_name"]        = get_prim_name(root);
     pub["object_description"] = nv_string(root, "Desc");
@@ -753,6 +758,11 @@ LLSD LLPublishedObjectMgr::buildPublishedObjectLLSD(LLViewerObject* root) const
         link["link_number"]      = link_number++;
         link["link_name"]        = get_prim_name(child);
         link["link_description"] = nv_string(child, "Desc");
+        const LLPermissions& child_perms = child->getPermissions();
+        LLSD child_perm_entry;
+        child_perm_entry["owner"]      = static_cast<S32>(child_perms.getMaskOwner());
+        child_perm_entry["next_owner"] = static_cast<S32>(child_perms.getMaskNextOwner());
+        link["permissions"]            = child_perm_entry;
         link["inventory"]        = buildPrimInventoryLLSD(child);
         linked_objects.append(link);
     }
@@ -778,6 +788,11 @@ LLSD LLPublishedObjectMgr::buildObjectListLLSD() const
         }
 
         LLSD pub;
+        const LLPermissions& root_perms = root->getPermissions();
+        LLSD root_perm_entry;
+        root_perm_entry["owner"]      = static_cast<S32>(root_perms.getMaskOwner());
+        root_perm_entry["next_owner"] = static_cast<S32>(root_perms.getMaskNextOwner());
+        pub["permissions"]            = root_perm_entry;
         pub["object_id"]          = info.mObjectID;
         pub["object_name"]        = info.mObjectName;
         pub["object_description"] = info.mObjectDescription;
@@ -808,6 +823,11 @@ LLSD LLPublishedObjectMgr::buildObjectListLLSD() const
             link["link_number"] = prim_info.mLinkNumber;
             link["link_name"]   = prim_info.mPrimName;
             link["link_description"] = prim_info.mPrimDescription;
+            const LLPermissions& child_perms = child->getPermissions();
+            LLSD child_perm_entry;
+            child_perm_entry["owner"]      = static_cast<S32>(child_perms.getMaskOwner());
+            child_perm_entry["next_owner"] = static_cast<S32>(child_perms.getMaskNextOwner());
+            link["permissions"]            = child_perm_entry;
             link["inventory"]   = buildPrimInventoryLLSD(child);
             linked_objects.append(link);
         }
-- 
cgit v1.3


From 71548bcc9ccbc0f94d9f1f47b710ff7a351a05d3 Mon Sep 17 00:00:00 2001
From: Rider Linden <rider@lindenlab.com>
Date: Wed, 26 Aug 2026 12:18:27 -0700
Subject: Cleanup from second set of fixes.

---
 indra/newview/llpublishedobjectmgr.cpp | 41 +++++++++++++++++-----------------
 1 file changed, 21 insertions(+), 20 deletions(-)

(limited to 'indra/newview/llpublishedobjectmgr.cpp')

diff --git a/indra/newview/llpublishedobjectmgr.cpp b/indra/newview/llpublishedobjectmgr.cpp
index 5c9c080b5d..c11a45a3b1 100644
--- a/indra/newview/llpublishedobjectmgr.cpp
+++ b/indra/newview/llpublishedobjectmgr.cpp
@@ -88,6 +88,23 @@ namespace
         // Never emit an empty prim/object name to downstream tooling.
         return obj->getID().asString();
     }
+
+    void add_object_permissions(LLSD& object_data, LLViewerObject* object)
+    {
+        LLPermissions* permissions =
+            LLSelectMgr::getInstance()->findObjectPermissions(object);
+        if (!permissions)
+        {
+            return;
+        }
+
+        LLSD permission_entry;
+        permission_entry["owner"] =
+            static_cast<S32>(permissions->getMaskOwner());
+        permission_entry["next_owner"] =
+            static_cast<S32>(permissions->getMaskNextOwner());
+        object_data["permissions"] = permission_entry;
+    }
 }
 
 class LLPublishedPrimListener : public LLVOInventoryListener
@@ -729,11 +746,7 @@ LLSD LLPublishedObjectMgr::buildPublishedObjectLLSD(LLViewerObject* root) const
 {
     LL_PROFILE_ZONE_SCOPED_CATEGORY_SCRIPTDEV;
     LLSD pub;
-    const LLPermissions& root_perms = root->getPermissions();
-    LLSD root_perm_entry;
-    root_perm_entry["owner"]      = static_cast<S32>(root_perms.getMaskOwner());
-    root_perm_entry["next_owner"] = static_cast<S32>(root_perms.getMaskNextOwner());
-    pub["permissions"]            = root_perm_entry;
+    add_object_permissions(pub, root);
     pub["object_id"]          = root->getID();
     pub["object_name"]        = get_prim_name(root);
     pub["object_description"] = nv_string(root, "Desc");
@@ -758,11 +771,7 @@ LLSD LLPublishedObjectMgr::buildPublishedObjectLLSD(LLViewerObject* root) const
         link["link_number"]      = link_number++;
         link["link_name"]        = get_prim_name(child);
         link["link_description"] = nv_string(child, "Desc");
-        const LLPermissions& child_perms = child->getPermissions();
-        LLSD child_perm_entry;
-        child_perm_entry["owner"]      = static_cast<S32>(child_perms.getMaskOwner());
-        child_perm_entry["next_owner"] = static_cast<S32>(child_perms.getMaskNextOwner());
-        link["permissions"]            = child_perm_entry;
+        add_object_permissions(link, child);
         link["inventory"]        = buildPrimInventoryLLSD(child);
         linked_objects.append(link);
     }
@@ -788,11 +797,7 @@ LLSD LLPublishedObjectMgr::buildObjectListLLSD() const
         }
 
         LLSD pub;
-        const LLPermissions& root_perms = root->getPermissions();
-        LLSD root_perm_entry;
-        root_perm_entry["owner"]      = static_cast<S32>(root_perms.getMaskOwner());
-        root_perm_entry["next_owner"] = static_cast<S32>(root_perms.getMaskNextOwner());
-        pub["permissions"]            = root_perm_entry;
+    add_object_permissions(pub, root);
         pub["object_id"]          = info.mObjectID;
         pub["object_name"]        = info.mObjectName;
         pub["object_description"] = info.mObjectDescription;
@@ -823,11 +828,7 @@ LLSD LLPublishedObjectMgr::buildObjectListLLSD() const
             link["link_number"] = prim_info.mLinkNumber;
             link["link_name"]   = prim_info.mPrimName;
             link["link_description"] = prim_info.mPrimDescription;
-            const LLPermissions& child_perms = child->getPermissions();
-            LLSD child_perm_entry;
-            child_perm_entry["owner"]      = static_cast<S32>(child_perms.getMaskOwner());
-            child_perm_entry["next_owner"] = static_cast<S32>(child_perms.getMaskNextOwner());
-            link["permissions"]            = child_perm_entry;
+            add_object_permissions(link, child);
             link["inventory"]   = buildPrimInventoryLLSD(child);
             linked_objects.append(link);
         }
-- 
cgit v1.3


From 0d4540a5cfa6a0027cb2a635958da1a0b45cea50 Mon Sep 17 00:00:00 2001
From: Rider Linden <rider@lindenlab.com>
Date: Thu, 27 Aug 2026 14:11:20 -0700
Subject: Apply suggestions from code review

Co-authored-by: Copilot Autofix powered by AI <175728472+Copilot@users.noreply.github.com>
---
 indra/newview/llpublishedobjectmgr.cpp | 2 +-
 indra/newview/llscripteditorws.cpp     | 3 +--
 2 files changed, 2 insertions(+), 3 deletions(-)

(limited to 'indra/newview/llpublishedobjectmgr.cpp')

diff --git a/indra/newview/llpublishedobjectmgr.cpp b/indra/newview/llpublishedobjectmgr.cpp
index c11a45a3b1..85a9542dce 100644
--- a/indra/newview/llpublishedobjectmgr.cpp
+++ b/indra/newview/llpublishedobjectmgr.cpp
@@ -797,7 +797,7 @@ LLSD LLPublishedObjectMgr::buildObjectListLLSD() const
         }
 
         LLSD pub;
-    add_object_permissions(pub, root);
+        add_object_permissions(pub, root);
         pub["object_id"]          = info.mObjectID;
         pub["object_name"]        = info.mObjectName;
         pub["object_description"] = info.mObjectDescription;
diff --git a/indra/newview/llscripteditorws.cpp b/indra/newview/llscripteditorws.cpp
index 41efa7e016..6563a5418e 100644
--- a/indra/newview/llscripteditorws.cpp
+++ b/indra/newview/llscripteditorws.cpp
@@ -970,10 +970,9 @@ LLSD LLScriptEditorWSServer::handleObjectScriptRecompileAll(
 
     queue->setTitle(LLTrans::getString("CompileQueueTitle"));
 
-    LLSD response;
     response["success"] = true;
     response["object_id"] = root->getID();
-    response["target"] = target;
+    response["target"] = (target == "auto-luau") ? "luau" : target;
     response["queued"] = true;
     return response;
 }
-- 
cgit v1.3


From d186daa361567fe499b80efe8481e192ffe8199b Mon Sep 17 00:00:00 2001
From: Rider Linden <rider@lindenlab.com>
Date: Wed, 23 Sep 2026 11:51:39 -0700
Subject: Issue #6205: There was an issue with permissions not being sent in
 the update message.

---
 doc/external-editor-json-rpc.md        |  18 +++-
 indra/newview/llpublishedobjectmgr.cpp | 166 +++++++++++++++++++++++++++------
 indra/newview/llpublishedobjectmgr.h   |  15 +++
 indra/newview/llscripteditorws.cpp     |  62 ++++++------
 indra/newview/llscripteditorws.h       |   3 +-
 indra/newview/llselectmgr.cpp          |   2 +
 6 files changed, 206 insertions(+), 60 deletions(-)

(limited to 'indra/newview/llpublishedobjectmgr.cpp')

diff --git a/doc/external-editor-json-rpc.md b/doc/external-editor-json-rpc.md
index 0c32c043fe..b62e002a33 100644
--- a/doc/external-editor-json-rpc.md
+++ b/doc/external-editor-json-rpc.md
@@ -1084,7 +1084,7 @@ interface LinkedObject {
 
 interface ObjectPermissions {
   owner: number;
-  next_owner: number;
+  next_owner?: number;   // Absent until the viewer receives ObjectProperties for the prim
 }
 
 /** Root of a linkset, as published to the extension */
@@ -1235,19 +1235,30 @@ Sent when an explored object's inventory, properties, or linkset membership chan
 | ------- | ------- |
 | Root prim inventory changed | `object_id`, `inventory` (complete replacement array) |
 | Child prim inventory changed | `object_id`, `changes.linked_objects.modified[]` with `link_id` and `inventory` (complete replacement array for that child) |
-| Root prim name/description changed | `object_id`, `object_name` and/or `object_description` |
-| Child prim name/description changed | `object_id`, `changes.linked_objects.modified[]` with `link_id` and `link_name` and/or `link_description` |
+| Root prim properties changed | `object_id`, plus any changed subset of `object_name`, `object_description`, `owner_id`, `permissions`, `can_save_back` |
+| Child prim properties changed | `object_id`, `changes.linked_objects.modified[]` with `link_id` plus any changed subset of `link_name`, `link_description`, `permissions` |
 | Linkset membership changed | `object_id`, `linked_objects` (complete replacement array covering every child prim) |
 
 `inventory` and `linked_objects` are always complete replacements of the prior state, never
 increments. Linkset membership changes are coalesced behind a short flush delay, so several
 rapid link or unlink operations may arrive as a single update.
 
+**Deferred permission fields.** `object.publish` is gated on inventory loading, which can finish
+before the `ObjectProperties` reply arrives. Until it does the viewer derives `permissions.owner`
+from the object's update flags, which describe the current agent's rights, and omits `next_owner`.
+`owner_id` may be absent or the null UUID, and `can_save_back` may be `false` because it depends on
+selection state. Once properties arrive the viewer sends an `object.update` carrying the full
+`owner`/`next_owner` block and the real `owner_id`, so clients must merge these fields on update
+rather than assuming the publish payload is final.
+
 ```typescript
 interface ObjectUpdateMessage {
   object_id: string;
   object_name?: string;
   object_description?: string;
+  owner_id?: string;
+  permissions?: ObjectPermissions;
+  can_save_back?: boolean;
   // Full replacement
   inventory?: ObjectInventoryItem[];
   linked_objects?: LinkedObject[];
@@ -1264,6 +1275,7 @@ interface LinkedObjectChanges {
     link_id: string;
     link_name?: string;
     link_description?: string;
+    permissions?: ObjectPermissions;
     inventory?: ObjectInventoryItem[];   // Complete replacement array, not a delta
   }[];
 }
diff --git a/indra/newview/llpublishedobjectmgr.cpp b/indra/newview/llpublishedobjectmgr.cpp
index 85a9542dce..5cbb7ca76d 100644
--- a/indra/newview/llpublishedobjectmgr.cpp
+++ b/indra/newview/llpublishedobjectmgr.cpp
@@ -32,6 +32,7 @@
 #include "llchat.h"
 #include "llinventorydefines.h"
 #include "llregex.h"
+#include "llsdutil.h"
 #include "llselectmgr.h"
 #include "llviewerinventory.h"
 #include "llviewerobject.h"
@@ -66,7 +67,7 @@ namespace
         return std::string(s);
     }
 
-    std::string get_prim_name(LLViewerObject* obj)
+    std::string get_prim_name(LLViewerObject* obj, S32 link_number = 1)
     {
         std::string name = nv_string(obj, "Name");
         if (!name.empty())
@@ -85,25 +86,17 @@ namespace
             return node->mName;
         }
 
-        // Never emit an empty prim/object name to downstream tooling.
-        return obj->getID().asString();
+        // Real prim names need a full ObjectProperties reply, which requires selection.
+        return (link_number > 1) ? llformat("Link #%d", link_number) : std::string("Object");
     }
 
     void add_object_permissions(LLSD& object_data, LLViewerObject* object)
     {
-        LLPermissions* permissions =
-            LLSelectMgr::getInstance()->findObjectPermissions(object);
-        if (!permissions)
+        LLSD permissions = LLPublishedObjectMgr::getObjectPermissionsLLSD(object);
+        if (permissions.isDefined())
         {
-            return;
+            object_data["permissions"] = permissions;
         }
-
-        LLSD permission_entry;
-        permission_entry["owner"] =
-            static_cast<S32>(permissions->getMaskOwner());
-        permission_entry["next_owner"] =
-            static_cast<S32>(permissions->getMaskNextOwner());
-        object_data["permissions"] = permission_entry;
     }
 }
 
@@ -742,6 +735,59 @@ LLSD LLPublishedObjectMgr::buildPrimInventoryLLSD(LLViewerObject* object) const
     return items;
 }
 
+LLSD LLPublishedObjectMgr::makePermissionsLLSD(U32 owner_mask, U32 next_owner_mask)
+{
+    LLSD permissions;
+    permissions["owner"]      = static_cast<S32>(owner_mask);
+    permissions["next_owner"] = static_cast<S32>(next_owner_mask);
+    return permissions;
+}
+
+LLSD LLPublishedObjectMgr::getObjectPermissionsLLSD(LLViewerObject* object)
+{
+    if (!object)
+    {
+        return LLSD();
+    }
+
+    LLPermissions* permissions =
+        LLSelectMgr::getInstance()->findObjectPermissions(object);
+    if (permissions)
+    {
+        return makePermissionsLLSD(permissions->getMaskOwner(), permissions->getMaskNextOwner());
+    }
+
+    // Unselected prims carry no LLPermissions, but object flags still hold this agent's rights.
+    // next_owner is unavailable from flags and is omitted until ObjectProperties arrives.
+    U32 owner_mask = 0;
+    if (object->permModify())   { owner_mask |= PERM_MODIFY; }
+    if (object->permCopy())     { owner_mask |= PERM_COPY; }
+    if (object->permTransfer()) { owner_mask |= PERM_TRANSFER; }
+    if (object->permMove())     { owner_mask |= PERM_MOVE; }
+
+    LLSD permission_entry;
+    permission_entry["owner"] = static_cast<S32>(owner_mask);
+    return permission_entry;
+}
+
+bool LLPublishedObjectMgr::computeCanSaveBack(LLViewerObject* root, LLUUID& source_task_id)
+{
+    source_task_id.setNull();
+    if (!root || root->isAttachment())
+    {
+        return false;
+    }
+
+    LLSelectNode* node = LLSelectMgr::instance().getSelection()->findNode(root);
+    if (!node || !node->mValid || node->mFromTaskID.isNull())
+    {
+        return false;
+    }
+
+    source_task_id = node->mFromTaskID;
+    return true;
+}
+
 LLSD LLPublishedObjectMgr::buildPublishedObjectLLSD(LLViewerObject* root) const
 {
     LL_PROFILE_ZONE_SCOPED_CATEGORY_SCRIPTDEV;
@@ -768,12 +814,13 @@ LLSD LLPublishedObjectMgr::buildPublishedObjectLLSD(LLViewerObject* root) const
     {
         LLSD link;
         link["link_id"]          = child->getID();
-        link["link_number"]      = link_number++;
-        link["link_name"]        = get_prim_name(child);
+        link["link_number"]      = link_number;
+        link["link_name"]        = get_prim_name(child, link_number);
         link["link_description"] = nv_string(child, "Desc");
         add_object_permissions(link, child);
         link["inventory"]        = buildPrimInventoryLLSD(child);
         linked_objects.append(link);
+        ++link_number;
     }
     if (linked_objects.size() > 0)
     {
@@ -1083,25 +1130,37 @@ bool LLPublishedObjectMgr::applyPropertyChange(
 
     if (prim_id == root_id)
     {
-        bool has_name = !name.empty();
-        bool name_changed = has_name && (pub_info->mObjectName != name);
-        bool desc_changed = (pub_info->mObjectDescription != desc);
-        if (!name_changed && !desc_changed)
-        {
-            return false;
-        }
+        bool changed = false;
 
-        if (name_changed)
+        if (!name.empty() && pub_info->mObjectName != name)
         {
             pub_info->mObjectName = name;
             update["object_name"] = name;
+            changed = true;
         }
-        if (desc_changed)
+        if (pub_info->mObjectDescription != desc)
         {
             pub_info->mObjectDescription = desc;
             update["object_description"] = desc;
+            changed = true;
         }
-        return true;
+
+        // Properties arrive after publish, so this field is backfilled here.
+        LLViewerObject* root = gObjectList.findObject(root_id);
+        if (root)
+        {
+            LLUUID source_task_id;
+            const bool can_save_back = computeCanSaveBack(root, source_task_id);
+            if (can_save_back != pub_info->mCanSaveBackToContents)
+            {
+                pub_info->mCanSaveBackToContents = can_save_back;
+                pub_info->mSourceTaskID = source_task_id;
+                update["can_save_back"] = can_save_back;
+                changed = true;
+            }
+        }
+
+        return changed;
     }
 
     auto prim_it = std::find_if(pub_info->mPrims.begin(), pub_info->mPrims.end(),
@@ -1135,6 +1194,61 @@ bool LLPublishedObjectMgr::applyPropertyChange(
     return true;
 }
 
+bool LLPublishedObjectMgr::applyPermissionsChange(
+    const LLUUID& root_id,
+    const LLUUID& prim_id,
+    const LLUUID& owner_id,
+    U32 owner_mask,
+    U32 next_owner_mask,
+    LLSD& update)
+{
+    PublishedObjectInfo* pub_info = getPublished(root_id);
+    if (!pub_info)
+    {
+        return false;
+    }
+
+    const LLSD permissions = makePermissionsLLSD(owner_mask, next_owner_mask);
+
+    update = LLSD();
+    update["object_id"] = root_id;
+
+    if (prim_id == root_id)
+    {
+        bool changed = false;
+        if (!llsd_equals(permissions, pub_info->mPermissions))
+        {
+            pub_info->mPermissions = permissions;
+            update["permissions"] = permissions;
+            changed = true;
+        }
+        if (owner_id.notNull() && pub_info->mOwnerID != owner_id)
+        {
+            pub_info->mOwnerID = owner_id;
+            update["owner_id"] = owner_id;
+            changed = true;
+        }
+        return changed;
+    }
+
+    auto prim_it = std::find_if(pub_info->mPrims.begin(), pub_info->mPrims.end(),
+        [&](const PublishedPrimInfo& p) { return p.mPrimID == prim_id; });
+    if (prim_it == pub_info->mPrims.end() || llsd_equals(permissions, prim_it->mPermissions))
+    {
+        return false;
+    }
+
+    prim_it->mPermissions = permissions;
+
+    LLSD modified_entry;
+    modified_entry["link_id"]     = prim_id;
+    modified_entry["permissions"] = permissions;
+    LLSD modified_arr = LLSD::emptyArray();
+    modified_arr.append(modified_entry);
+    update["changes"]["linked_objects"]["modified"] = modified_arr;
+    return true;
+}
+
 bool LLPublishedObjectMgr::hasActiveLinksetFlushTimer(const LLUUID& root_id) const
 {
     auto it = mLinksetFlushTimers.find(root_id);
diff --git a/indra/newview/llpublishedobjectmgr.h b/indra/newview/llpublishedobjectmgr.h
index 51af129dcb..8a6c8b705c 100644
--- a/indra/newview/llpublishedobjectmgr.h
+++ b/indra/newview/llpublishedobjectmgr.h
@@ -55,6 +55,7 @@ public:
         S32         mLinkNumber;
         std::string mPrimDescription;
         S16         mInventorySerial;
+        LLSD        mPermissions;
     };
 
     struct PublishedObjectInfo
@@ -73,6 +74,7 @@ public:
         std::string mRegionName;
         bool        mCanSaveBackToContents{ false };
         LLUUID      mSourceTaskID;
+        LLSD        mPermissions;
         std::vector<PublishedPrimInfo> mPrims;
         std::vector<std::unique_ptr<LLPublishedPrimListener>> mListeners;
     };
@@ -256,6 +258,12 @@ public:
     LLSD buildPrimInventoryLLSD(LLViewerObject* object) const;
     LLSD buildPublishedObjectLLSD(LLViewerObject* root) const;
     LLSD buildObjectListLLSD() const;
+
+    // Both depend on a valid LLSelectNode, so they yield nothing until ObjectProperties arrives.
+    static LLSD getObjectPermissionsLLSD(LLViewerObject* object);
+    static bool computeCanSaveBack(LLViewerObject* root, LLUUID& source_task_id);
+    static LLSD makePermissionsLLSD(U32 owner_mask, U32 next_owner_mask);
+
     bool buildLinksetUpdateLLSD(const LLUUID& root_id, LLSD& update) const;
     bool reconcileLinksetChildAdded(const LLUUID& root_id, LLViewerObject* child, F64 request_start_sec);
     bool reconcileLinksetChildRemoved(const LLUUID& root_id, const LLUUID& child_id);
@@ -275,6 +283,13 @@ public:
         const std::string& name,
         const std::string& desc,
         LLSD& update);
+    bool applyPermissionsChange(
+        const LLUUID& root_id,
+        const LLUUID& prim_id,
+        const LLUUID& owner_id,
+        U32 owner_mask,
+        U32 next_owner_mask,
+        LLSD& update);
 
     void beginPendingPublish(const LLUUID& object_id, const std::vector<LLViewerObject*>& prims);
     bool hasPendingPublish(const LLUUID& object_id) const;
diff --git a/indra/newview/llscripteditorws.cpp b/indra/newview/llscripteditorws.cpp
index 017d9a5540..8413547935 100644
--- a/indra/newview/llscripteditorws.cpp
+++ b/indra/newview/llscripteditorws.cpp
@@ -2395,7 +2395,7 @@ void LLScriptEditorWSServer::notifyAll(const std::string& method, const LLSD& pa
 
 
 // static
-std::string LLScriptEditorWSServer::getPrimName(LLViewerObject* obj)
+std::string LLScriptEditorWSServer::getPrimName(LLViewerObject* obj, S32 link_number)
 {
     std::string name = nv_string(obj, "Name");
     if (!name.empty())
@@ -2414,8 +2414,8 @@ std::string LLScriptEditorWSServer::getPrimName(LLViewerObject* obj)
         return node->mName;
     }
 
-    // Never emit an empty prim/object name to downstream tooling.
-    return obj->getID().asString();
+    // Real prim names need a full ObjectProperties reply, which requires selection.
+    return (link_number > 1) ? llformat("Link #%d", link_number) : std::string("Object");
 }
 
 bool LLScriptEditorWSServer::publishObject(const LLUUID& object_id)
@@ -2443,12 +2443,8 @@ bool LLScriptEditorWSServer::publishObject(const LLUUID& object_id)
     // Collect root + all children
     std::vector<LLViewerObject*> prims = collect_linkset(root);
 
-    // Request object properties for each prim in the linkset (root + children),
-    // matching the hover path so name/description metadata is refreshed.
-    for (LLViewerObject* prim : prims)
-    {
-        LLSelectMgr::instance().requestObjectPropertiesFamily(prim);
-    }
+    // The sim coalesces properties-family requests to the root, so one request covers the linkset.
+    LLSelectMgr::instance().requestObjectPropertiesFamily(root);
 
     // Set up a PendingPublish to coordinate inventory loading across all prims.
     // We register a listener and call requestInventory() on every prim.
@@ -2513,24 +2509,14 @@ void LLScriptEditorWSServer::buildAndSendPublish(const LLUUID& object_id)
     info.mOwnerID           = root->mOwnerID;
     info.mObjectName        = pub["object_name"].asString();
     info.mObjectDescription = pub["object_description"].asString();
+    info.mPermissions       = LLPublishedObjectMgr::getObjectPermissionsLLSD(root);
     if (root->getRegion())
     {
         info.mRegionName = root->getRegion()->getName();
     }
-    LLSelectNode* root_select_node = LLSelectMgr::instance().getSelection()->findNode(root);
-    if (root_select_node
-        && root_select_node->mValid
-        && !root_select_node->mFromTaskID.isNull()
-        && !root->isAttachment())
-    {
-        info.mCanSaveBackToContents = true;
-        info.mSourceTaskID = root_select_node->mFromTaskID;
-    }
-    else
-    {
-        info.mCanSaveBackToContents = false;
-        info.mSourceTaskID.setNull();
-    }
+    LLUUID source_task_id;
+    info.mCanSaveBackToContents = LLPublishedObjectMgr::computeCanSaveBack(root, source_task_id);
+    info.mSourceTaskID          = source_task_id;
 
     S32 link_num = 1;
     std::vector<LLViewerObject*> prims = collect_linkset(root);
@@ -2538,9 +2524,10 @@ void LLScriptEditorWSServer::buildAndSendPublish(const LLUUID& object_id)
     {
         LLPublishedObjectMgr::PublishedPrimInfo prim_info;
         prim_info.mPrimID          = prim->getID();
-        prim_info.mPrimName        = getPrimName(prim);  // Use helper with selection fallback
         prim_info.mLinkNumber      = link_num++;
+        prim_info.mPrimName        = getPrimName(prim, prim_info.mLinkNumber);
         prim_info.mInventorySerial = static_cast<S16>(prim->getInventorySerial());
+        prim_info.mPermissions     = LLPublishedObjectMgr::getObjectPermissionsLLSD(prim);
         info.mPrims.push_back(prim_info);
     }
 
@@ -2581,12 +2568,9 @@ void LLScriptEditorWSServer::buildAndSendPublish(const LLUUID& object_id)
         << " (" << pub["object_name"].asString() << ") with "
         << (prims.size() - 1) << " linked prim(s)" << LL_ENDL;
 
-    // Re-request object properties now that the object is published so
-    // onObjectPropertyChanged can emit object.update for root and linked prims.
-    for (LLViewerObject* prim : prims)
-    {
-        LLSelectMgr::instance().requestObjectPropertiesFamily(prim);
-    }
+    // Re-request now that the object is published so onObjectPropertyChanged can emit
+    // object.update. The sim answers per linkset, so only the root needs asking.
+    LLSelectMgr::instance().requestObjectPropertiesFamily(root);
 }
 
 void LLScriptEditorWSServer::onLinksetChildAdded(const LLUUID& root_id, LLViewerObject* child)
@@ -2748,6 +2732,24 @@ void LLScriptEditorWSServer::onObjectPropertyChanged(
     }
 }
 
+void LLScriptEditorWSServer::onObjectPermissionsReceived(
+    const LLUUID& prim_id, const LLUUID& owner_id, U32 owner_mask, U32 next_owner_mask)
+{
+    LL_PROFILE_ZONE_SCOPED_CATEGORY_SCRIPTDEV;
+    LLViewerObject* prim = gObjectList.findObject(prim_id);
+    if (!prim)
+    {
+        return;
+    }
+
+    LLSD update;
+    if (mPublishedObjectManager.applyPermissionsChange(
+            prim->getRootEdit()->getID(), prim_id, owner_id, owner_mask, next_owner_mask, update))
+    {
+        notifyAll("object.update", update);
+    }
+}
+
 void LLScriptEditorWSServer::unpublishObject(const LLUUID& object_id, const std::string& reason)
 {
     LL_PROFILE_ZONE_SCOPED_CATEGORY_SCRIPTDEV;
diff --git a/indra/newview/llscripteditorws.h b/indra/newview/llscripteditorws.h
index 6eb8385210..f85c3e6475 100644
--- a/indra/newview/llscripteditorws.h
+++ b/indra/newview/llscripteditorws.h
@@ -225,6 +225,7 @@ public:
     void onPrimInventoryReady(const LLUUID& object_id, const LLUUID& prim_id);
     void onPrimInventoryChanged(const LLUUID& object_id, const LLUUID& prim_id);
     void onObjectPropertyChanged(const LLUUID& prim_id, const std::string& name, const std::string& desc, S16 inventory_serial = -1);
+    void onObjectPermissionsReceived(const LLUUID& prim_id, const LLUUID& owner_id, U32 owner_mask, U32 next_owner_mask);
     void onLinksetChildAdded(const LLUUID& root_id, LLViewerObject* child);
     void onLinksetChildRemoved(const LLUUID& root_id, const LLUUID& child_id);
 
@@ -280,7 +281,7 @@ protected:
     ValidatedItem validatePublishedItem(const LLSD& params, U32 permMask) const;
 
     // --- Object Content Publishing (helpers) ---
-    static std::string getPrimName(LLViewerObject* obj);
+    static std::string getPrimName(LLViewerObject* obj, S32 link_number = 1);
     void notifyConnection(U32 connection_id, const std::string& method, const LLSD& params) const;
     void notifyAll(const std::string& method, const LLSD& params) const;
     void buildAndSendPublish(const LLUUID& object_id);
diff --git a/indra/newview/llselectmgr.cpp b/indra/newview/llselectmgr.cpp
index 432678b132..f9108fcc64 100644
--- a/indra/newview/llselectmgr.cpp
+++ b/indra/newview/llselectmgr.cpp
@@ -6115,6 +6115,7 @@ void LLSelectMgr::processObjectProperties(LLMessageSystem* msg, void** user_data
         if (ws_server)
         {
             ws_server->onObjectPropertyChanged(id, name, desc, inv_serial);
+            ws_server->onObjectPermissionsReceived(id, owner_id, owner_mask, next_owner_mask);
         }
     }
 
@@ -6215,6 +6216,7 @@ void LLSelectMgr::processObjectPropertiesFamily(LLMessageSystem* msg, void** use
     if (auto ws_server = LLScriptEditorWSServer::getServer())
     {
         ws_server->onObjectPropertyChanged(id, name, desc);
+        ws_server->onObjectPermissionsReceived(id, owner_id, owner_mask, next_owner_mask);
     }
 }
 
-- 
cgit v1.3