From 9bf2837505b7384ac18f1ae23de256729f561dfc Mon Sep 17 00:00:00 2001
From: Nat Goodspeed <nat@lindenlab.com>
Date: Thu, 29 Feb 2024 14:01:02 -0500
Subject: Add indra/newview/scripts/lua directory, copied into viewer image.

---
 indra/newview/scripts/lua/testmod.lua | 2 ++
 1 file changed, 2 insertions(+)
 create mode 100644 indra/newview/scripts/lua/testmod.lua

(limited to 'indra/newview/scripts')

diff --git a/indra/newview/scripts/lua/testmod.lua b/indra/newview/scripts/lua/testmod.lua
new file mode 100644
index 0000000000..22626e4038
--- /dev/null
+++ b/indra/newview/scripts/lua/testmod.lua
@@ -0,0 +1,2 @@
+print('scripts/lua/testmod.lua')
+return function () return 'hello from scripts/lua/testmod.lua' end
-- 
cgit v1.2.3


From ba1f0060b42390bd4f63de7fe32b0d0e9360f633 Mon Sep 17 00:00:00 2001
From: Nat Goodspeed <nat@lindenlab.com>
Date: Thu, 29 Feb 2024 15:08:20 -0500
Subject: Clarify that the print output from testmod.lua is load-time.

---
 indra/newview/scripts/lua/testmod.lua | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'indra/newview/scripts')

diff --git a/indra/newview/scripts/lua/testmod.lua b/indra/newview/scripts/lua/testmod.lua
index 22626e4038..60f7f80db1 100644
--- a/indra/newview/scripts/lua/testmod.lua
+++ b/indra/newview/scripts/lua/testmod.lua
@@ -1,2 +1,2 @@
-print('scripts/lua/testmod.lua')
+print('loaded scripts/lua/testmod.lua')
 return function () return 'hello from scripts/lua/testmod.lua' end
-- 
cgit v1.2.3


From d50d7c50651d5bcaf6f35349e2461351cf91224f Mon Sep 17 00:00:00 2001
From: Nat Goodspeed <nat@lindenlab.com>
Date: Thu, 29 Feb 2024 15:09:49 -0500
Subject: Add Queue.lua from roblox.com documentation.

---
 indra/newview/scripts/lua/Queue.lua | 40 +++++++++++++++++++++++++++++++++++++
 1 file changed, 40 insertions(+)
 create mode 100644 indra/newview/scripts/lua/Queue.lua

(limited to 'indra/newview/scripts')

diff --git a/indra/newview/scripts/lua/Queue.lua b/indra/newview/scripts/lua/Queue.lua
new file mode 100644
index 0000000000..fa8737334c
--- /dev/null
+++ b/indra/newview/scripts/lua/Queue.lua
@@ -0,0 +1,40 @@
+-- from https://create.roblox.com/docs/luau/queues#implementing-queues
+
+local Queue = {}
+Queue.__index = Queue
+​
+function Queue.new()
+	local self = setmetatable({}, Queue)
+​
+	self._first = 0
+	self._last = -1
+	self._queue = {}
+​
+	return self
+end
+​
+-- Check if the queue is empty
+function Queue:IsEmpty()
+	return self._first > self._last
+end
+​
+-- Add a value to the queue
+function Queue:Enqueue(value)
+	local last = self._last + 1
+	self._last = last
+	self._queue[last] = value
+end
+​
+-- Remove a value from the queue
+function Queue:Dequeue()
+	local first = self._first
+	if self:IsEmpty() then
+		return nil
+	end
+	local value = self._queue[first]
+	self._queue[first] = nil
+	self._first = first + 1
+	return value
+end
+​
+return Queue
-- 
cgit v1.2.3


From 6aee62f2bbdd06cf34c4042317cb52ec3c09570c Mon Sep 17 00:00:00 2001
From: Nat Goodspeed <nat@lindenlab.com>
Date: Thu, 29 Feb 2024 16:47:42 -0500
Subject: Fix wonky Unicode chars from web paste

---
 indra/newview/scripts/lua/Queue.lua | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

(limited to 'indra/newview/scripts')

diff --git a/indra/newview/scripts/lua/Queue.lua b/indra/newview/scripts/lua/Queue.lua
index fa8737334c..e178ad9969 100644
--- a/indra/newview/scripts/lua/Queue.lua
+++ b/indra/newview/scripts/lua/Queue.lua
@@ -2,29 +2,29 @@
 
 local Queue = {}
 Queue.__index = Queue
-​
+
 function Queue.new()
 	local self = setmetatable({}, Queue)
-​
+
 	self._first = 0
 	self._last = -1
 	self._queue = {}
-​
+
 	return self
 end
-​
+
 -- Check if the queue is empty
 function Queue:IsEmpty()
 	return self._first > self._last
 end
-​
+
 -- Add a value to the queue
 function Queue:Enqueue(value)
 	local last = self._last + 1
 	self._last = last
 	self._queue[last] = value
 end
-​
+
 -- Remove a value from the queue
 function Queue:Dequeue()
 	local first = self._first
@@ -36,5 +36,5 @@ function Queue:Dequeue()
 	self._first = first + 1
 	return value
 end
-​
+
 return Queue
-- 
cgit v1.2.3


From c621fc39fc4ac25482fbc1090b8067c4187de176 Mon Sep 17 00:00:00 2001
From: Nat Goodspeed <nat@lindenlab.com>
Date: Wed, 6 Mar 2024 09:56:45 -0500
Subject: WIP: Unfinished Queue.lua, WaitQueue.lua, ErrorQueue.lua, leap.lua.

Also qtest.lua to exercise the queue classes and inspect.lua (from
https://github.com/kikito/inspect.lua) for debugging.
---
 indra/newview/scripts/lua/ErrorQueue.lua |  32 +++
 indra/newview/scripts/lua/Queue.lua      |  41 ++--
 indra/newview/scripts/lua/WaitQueue.lua  |  68 ++++++
 indra/newview/scripts/lua/inspect.lua    | 371 +++++++++++++++++++++++++++++++
 indra/newview/scripts/lua/leap.lua       | 284 +++++++++++++++++++++++
 indra/newview/scripts/lua/qtest.lua      |  47 ++++
 6 files changed, 823 insertions(+), 20 deletions(-)
 create mode 100644 indra/newview/scripts/lua/ErrorQueue.lua
 create mode 100644 indra/newview/scripts/lua/WaitQueue.lua
 create mode 100644 indra/newview/scripts/lua/inspect.lua
 create mode 100644 indra/newview/scripts/lua/leap.lua
 create mode 100644 indra/newview/scripts/lua/qtest.lua

(limited to 'indra/newview/scripts')

diff --git a/indra/newview/scripts/lua/ErrorQueue.lua b/indra/newview/scripts/lua/ErrorQueue.lua
new file mode 100644
index 0000000000..e6279f8411
--- /dev/null
+++ b/indra/newview/scripts/lua/ErrorQueue.lua
@@ -0,0 +1,32 @@
+-- ErrorQueue isa WaitQueue with the added feature that a producer can push an
+-- error through the queue. When that error is dequeued, the consumer will
+-- throw that error.
+
+local WaitQueue = require('WaitQueue')
+
+ErrorQueue = WaitQueue:new()
+
+function ErrorQueue:Enqueue(value)
+    -- normal value, not error
+    WaitQueue:Enqueue({ false, value })
+end
+
+function ErrorQueue:Error(message)
+    -- flag this entry as an error message
+    WaitQueue:Enqueue({ true, message })
+end
+
+function ErrorQueue:Dequeue()
+    local errflag, value = table.unpack(WaitQueue:Dequeue())
+    if errflag == nil then
+        -- queue has been closed, tell caller
+        return nil
+    end
+    if errflag then
+        -- 'value' is a message pushed by Error()
+        error(value)
+    end
+    return value
+end
+
+return ErrorQueue
diff --git a/indra/newview/scripts/lua/Queue.lua b/indra/newview/scripts/lua/Queue.lua
index e178ad9969..b0a5a87f87 100644
--- a/indra/newview/scripts/lua/Queue.lua
+++ b/indra/newview/scripts/lua/Queue.lua
@@ -1,40 +1,41 @@
--- from https://create.roblox.com/docs/luau/queues#implementing-queues
+-- from https://create.roblox.com/docs/luau/queues#implementing-queues,
+-- amended per https://www.lua.org/pil/16.1.html
 
 local Queue = {}
-Queue.__index = Queue
 
-function Queue.new()
-	local self = setmetatable({}, Queue)
+function Queue:new()
+    local obj = setmetatable({}, self)
+    self.__index = self
 
-	self._first = 0
-	self._last = -1
-	self._queue = {}
+    obj._first = 0
+    obj._last = -1
+    obj._queue = {}
 
-	return self
+    return obj
 end
 
 -- Check if the queue is empty
 function Queue:IsEmpty()
-	return self._first > self._last
+    return self._first > self._last
 end
 
 -- Add a value to the queue
 function Queue:Enqueue(value)
-	local last = self._last + 1
-	self._last = last
-	self._queue[last] = value
+    local last = self._last + 1
+    self._last = last
+    self._queue[last] = value
 end
 
 -- Remove a value from the queue
 function Queue:Dequeue()
-	local first = self._first
-	if self:IsEmpty() then
-		return nil
-	end
-	local value = self._queue[first]
-	self._queue[first] = nil
-	self._first = first + 1
-	return value
+    if self:IsEmpty() then
+        return nil
+    end
+    local first = self._first
+    local value = self._queue[first]
+    self._queue[first] = nil
+    self._first = first + 1
+    return value
 end
 
 return Queue
diff --git a/indra/newview/scripts/lua/WaitQueue.lua b/indra/newview/scripts/lua/WaitQueue.lua
new file mode 100644
index 0000000000..05d2056085
--- /dev/null
+++ b/indra/newview/scripts/lua/WaitQueue.lua
@@ -0,0 +1,68 @@
+-- WaitQueue isa Queue with the added feature that when the queue is empty,
+-- the Dequeue() operation blocks the calling coroutine until some other
+-- coroutine Enqueue()s a new value.
+
+local Queue = require('Queue')
+
+WaitQueue = Queue:new()
+
+function WaitQueue:new()
+    local obj = setmetatable(Queue:new(), self)
+    self.__index = self
+    obj._waiters = {}
+    obj._closed = false
+    return obj
+end
+
+function WaitQueue:Enqueue(value)
+    if self._closed then
+        error("can't Enqueue() on closed Queue")
+    end
+    Queue:Enqueue(value)
+    -- WaitQueue is designed to support multi-producer, multi-consumer use
+    -- cases. With multiple consumers, if more than one is trying to
+    -- Dequeue() from an empty WaitQueue, we'll have multiple waiters.
+    -- Unlike OS threads, with cooperative concurrency it doesn't make sense
+    -- to "notify all": we need resume only one of the waiting Dequeue()
+    -- callers. But since resuming that caller might entail either Enqueue()
+    -- or Dequeue() calls, recheck every time around to see if we must resume
+    -- another waiting coroutine.
+    while not self:IsEmpty() and #self._waiters do
+        -- pop the oldest waiting coroutine instead of the most recent, for
+        -- more-or-less round robin fairness
+        local waiter = table.remove(self._waiters, 1)
+        -- don't pass the head item: let the resumed coroutine retrieve it
+        local ok, message = coroutine.resume(waiter)
+        -- if resuming that waiter encountered an error, don't swallow it
+        if not ok then
+            error(message)
+        end
+    end
+end
+
+function WaitQueue:Dequeue()
+    while self:IsEmpty() do
+        -- Don't check for closed until the queue is empty: producer can close
+        -- the queue while there are still items left, and we want the
+        -- consumer(s) to retrieve those last few items.
+        if self._closed then
+            return nil
+        end
+        local coro = coroutine.running()
+        if coro == nil then
+            error("WaitQueue:Dequeue() trying to suspend main coroutine")
+        end
+        -- add the running coroutine to the list of waiters
+        table.insert(self._waiters, coro)
+        -- then let somebody else run
+        coroutine.yield()
+    end
+    -- here we're sure this queue isn't empty
+    return Queue:Dequeue()
+end
+
+function WaitQueue:close()
+    self._closed = true
+end
+
+return WaitQueue
diff --git a/indra/newview/scripts/lua/inspect.lua b/indra/newview/scripts/lua/inspect.lua
new file mode 100644
index 0000000000..9900a0b81b
--- /dev/null
+++ b/indra/newview/scripts/lua/inspect.lua
@@ -0,0 +1,371 @@
+local _tl_compat; if (tonumber((_VERSION or ''):match('[%d.]*$')) or 0) < 5.3 then local p, m = pcall(require, 'compat53.module'); if p then _tl_compat = m end end; local math = _tl_compat and _tl_compat.math or math; local string = _tl_compat and _tl_compat.string or string; local table = _tl_compat and _tl_compat.table or table
+local inspect = {Options = {}, }
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+inspect._VERSION = 'inspect.lua 3.1.0'
+inspect._URL = 'http://github.com/kikito/inspect.lua'
+inspect._DESCRIPTION = 'human-readable representations of tables'
+inspect._LICENSE = [[
+  MIT LICENSE
+
+  Copyright (c) 2022 Enrique García Cota
+
+  Permission is hereby granted, free of charge, to any person obtaining a
+  copy of this software and associated documentation files (the
+  "Software"), to deal in the Software without restriction, including
+  without limitation the rights to use, copy, modify, merge, publish,
+  distribute, sublicense, and/or sell copies of the Software, and to
+  permit persons to whom the Software is furnished to do so, subject to
+  the following conditions:
+
+  The above copyright notice and this permission notice shall be included
+  in all copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+  OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+  CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+  TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+  SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+]]
+inspect.KEY = setmetatable({}, { __tostring = function() return 'inspect.KEY' end })
+inspect.METATABLE = setmetatable({}, { __tostring = function() return 'inspect.METATABLE' end })
+
+local tostring = tostring
+local rep = string.rep
+local match = string.match
+local char = string.char
+local gsub = string.gsub
+local fmt = string.format
+
+local _rawget
+if rawget then
+   _rawget = rawget
+else
+   _rawget = function(t, k) return t[k] end
+end
+
+local function rawpairs(t)
+   return next, t, nil
+end
+
+
+
+local function smartQuote(str)
+   if match(str, '"') and not match(str, "'") then
+      return "'" .. str .. "'"
+   end
+   return '"' .. gsub(str, '"', '\\"') .. '"'
+end
+
+
+local shortControlCharEscapes = {
+   ["\a"] = "\\a", ["\b"] = "\\b", ["\f"] = "\\f", ["\n"] = "\\n",
+   ["\r"] = "\\r", ["\t"] = "\\t", ["\v"] = "\\v", ["\127"] = "\\127",
+}
+local longControlCharEscapes = { ["\127"] = "\127" }
+for i = 0, 31 do
+   local ch = char(i)
+   if not shortControlCharEscapes[ch] then
+      shortControlCharEscapes[ch] = "\\" .. i
+      longControlCharEscapes[ch] = fmt("\\%03d", i)
+   end
+end
+
+local function escape(str)
+   return (gsub(gsub(gsub(str, "\\", "\\\\"),
+   "(%c)%f[0-9]", longControlCharEscapes),
+   "%c", shortControlCharEscapes))
+end
+
+local luaKeywords = {
+   ['and'] = true,
+   ['break'] = true,
+   ['do'] = true,
+   ['else'] = true,
+   ['elseif'] = true,
+   ['end'] = true,
+   ['false'] = true,
+   ['for'] = true,
+   ['function'] = true,
+   ['goto'] = true,
+   ['if'] = true,
+   ['in'] = true,
+   ['local'] = true,
+   ['nil'] = true,
+   ['not'] = true,
+   ['or'] = true,
+   ['repeat'] = true,
+   ['return'] = true,
+   ['then'] = true,
+   ['true'] = true,
+   ['until'] = true,
+   ['while'] = true,
+}
+
+local function isIdentifier(str)
+   return type(str) == "string" and
+   not not str:match("^[_%a][_%a%d]*$") and
+   not luaKeywords[str]
+end
+
+local flr = math.floor
+local function isSequenceKey(k, sequenceLength)
+   return type(k) == "number" and
+   flr(k) == k and
+   1 <= (k) and
+   k <= sequenceLength
+end
+
+local defaultTypeOrders = {
+   ['number'] = 1, ['boolean'] = 2, ['string'] = 3, ['table'] = 4,
+   ['function'] = 5, ['userdata'] = 6, ['thread'] = 7,
+}
+
+local function sortKeys(a, b)
+   local ta, tb = type(a), type(b)
+
+
+   if ta == tb and (ta == 'string' or ta == 'number') then
+      return (a) < (b)
+   end
+
+   local dta = defaultTypeOrders[ta] or 100
+   local dtb = defaultTypeOrders[tb] or 100
+
+
+   return dta == dtb and ta < tb or dta < dtb
+end
+
+local function getKeys(t)
+
+   local seqLen = 1
+   while _rawget(t, seqLen) ~= nil do
+      seqLen = seqLen + 1
+   end
+   seqLen = seqLen - 1
+
+   local keys, keysLen = {}, 0
+   for k in rawpairs(t) do
+      if not isSequenceKey(k, seqLen) then
+         keysLen = keysLen + 1
+         keys[keysLen] = k
+      end
+   end
+   table.sort(keys, sortKeys)
+   return keys, keysLen, seqLen
+end
+
+local function countCycles(x, cycles)
+   if type(x) == "table" then
+      if cycles[x] then
+         cycles[x] = cycles[x] + 1
+      else
+         cycles[x] = 1
+         for k, v in rawpairs(x) do
+            countCycles(k, cycles)
+            countCycles(v, cycles)
+         end
+         countCycles(getmetatable(x), cycles)
+      end
+   end
+end
+
+local function makePath(path, a, b)
+   local newPath = {}
+   local len = #path
+   for i = 1, len do newPath[i] = path[i] end
+
+   newPath[len + 1] = a
+   newPath[len + 2] = b
+
+   return newPath
+end
+
+
+local function processRecursive(process,
+   item,
+   path,
+   visited)
+   if item == nil then return nil end
+   if visited[item] then return visited[item] end
+
+   local processed = process(item, path)
+   if type(processed) == "table" then
+      local processedCopy = {}
+      visited[item] = processedCopy
+      local processedKey
+
+      for k, v in rawpairs(processed) do
+         processedKey = processRecursive(process, k, makePath(path, k, inspect.KEY), visited)
+         if processedKey ~= nil then
+            processedCopy[processedKey] = processRecursive(process, v, makePath(path, processedKey), visited)
+         end
+      end
+
+      local mt = processRecursive(process, getmetatable(processed), makePath(path, inspect.METATABLE), visited)
+      if type(mt) ~= 'table' then mt = nil end
+      setmetatable(processedCopy, mt)
+      processed = processedCopy
+   end
+   return processed
+end
+
+local function puts(buf, str)
+   buf.n = buf.n + 1
+   buf[buf.n] = str
+end
+
+
+
+local Inspector = {}
+
+
+
+
+
+
+
+
+
+
+local Inspector_mt = { __index = Inspector }
+
+local function tabify(inspector)
+   puts(inspector.buf, inspector.newline .. rep(inspector.indent, inspector.level))
+end
+
+function Inspector:getId(v)
+   local id = self.ids[v]
+   local ids = self.ids
+   if not id then
+      local tv = type(v)
+      id = (ids[tv] or 0) + 1
+      ids[v], ids[tv] = id, id
+   end
+   return tostring(id)
+end
+
+function Inspector:putValue(v)
+   local buf = self.buf
+   local tv = type(v)
+   if tv == 'string' then
+      puts(buf, smartQuote(escape(v)))
+   elseif tv == 'number' or tv == 'boolean' or tv == 'nil' or
+      tv == 'cdata' or tv == 'ctype' then
+      puts(buf, tostring(v))
+   elseif tv == 'table' and not self.ids[v] then
+      local t = v
+
+      if t == inspect.KEY or t == inspect.METATABLE then
+         puts(buf, tostring(t))
+      elseif self.level >= self.depth then
+         puts(buf, '{...}')
+      else
+         if self.cycles[t] > 1 then puts(buf, fmt('<%d>', self:getId(t))) end
+
+         local keys, keysLen, seqLen = getKeys(t)
+
+         puts(buf, '{')
+         self.level = self.level + 1
+
+         for i = 1, seqLen + keysLen do
+            if i > 1 then puts(buf, ',') end
+            if i <= seqLen then
+               puts(buf, ' ')
+               self:putValue(t[i])
+            else
+               local k = keys[i - seqLen]
+               tabify(self)
+               if isIdentifier(k) then
+                  puts(buf, k)
+               else
+                  puts(buf, "[")
+                  self:putValue(k)
+                  puts(buf, "]")
+               end
+               puts(buf, ' = ')
+               self:putValue(t[k])
+            end
+         end
+
+         local mt = getmetatable(t)
+         if type(mt) == 'table' then
+            if seqLen + keysLen > 0 then puts(buf, ',') end
+            tabify(self)
+            puts(buf, '<metatable> = ')
+            self:putValue(mt)
+         end
+
+         self.level = self.level - 1
+
+         if keysLen > 0 or type(mt) == 'table' then
+            tabify(self)
+         elseif seqLen > 0 then
+            puts(buf, ' ')
+         end
+
+         puts(buf, '}')
+      end
+
+   else
+      puts(buf, fmt('<%s %d>', tv, self:getId(v)))
+   end
+end
+
+
+
+
+function inspect.inspect(root, options)
+   options = options or {}
+
+   local depth = options.depth or (math.huge)
+   local newline = options.newline or '\n'
+   local indent = options.indent or '  '
+   local process = options.process
+
+   if process then
+      root = processRecursive(process, root, {}, {})
+   end
+
+   local cycles = {}
+   countCycles(root, cycles)
+
+   local inspector = setmetatable({
+      buf = { n = 0 },
+      ids = {},
+      cycles = cycles,
+      depth = depth,
+      level = 0,
+      newline = newline,
+      indent = indent,
+   }, Inspector_mt)
+
+   inspector:putValue(root)
+
+   return table.concat(inspector.buf)
+end
+
+setmetatable(inspect, {
+   __call = function(_, root, options)
+      return inspect.inspect(root, options)
+   end,
+})
+
+return inspect
diff --git a/indra/newview/scripts/lua/leap.lua b/indra/newview/scripts/lua/leap.lua
new file mode 100644
index 0000000000..351e1bf007
--- /dev/null
+++ b/indra/newview/scripts/lua/leap.lua
@@ -0,0 +1,284 @@
+-- Lua implementation of LEAP (LLSD Event API Plugin) protocol
+--
+-- This module supports Lua scripts run by the Second Life viewer.
+--
+-- LEAP protocol passes LLSD objects, converted to/from Lua tables, in both
+-- directions. A typical LLSD object is a map containing keys 'pump' and
+-- 'data'.
+--
+-- The viewer's Lua post_to(pump, data) function posts 'data' to the
+-- LLEventPump 'pump'. This is typically used to engage an LLEventAPI method.
+--
+-- Similarly, the viewer gives each Lua script its own LLEventPump with a
+-- unique name. That name is returned by get_event_pumps(). Every event
+-- received on that LLEventPump is queued for retrieval by get_event_next(),
+-- which returns (pump, data): the name of the LLEventPump on which the event
+-- was received and the received event data. When the queue is empty,
+-- get_event_next() blocks the calling Lua script until the next event is
+-- received.
+
+local leap = {}
+
+-- _reply: string name of reply LLEventPump. Any events the viewer posts to
+-- this pump will be queued for get_event_next(). We usually specify it as the
+-- reply pump for requests to internal viewer services.
+-- _command: string name of command LLEventPump. post_to(_command, ...)
+-- engages LLLeapListener operations such as listening on a specified other
+-- LLEventPump, etc.
+leap._reply, leap._command = get_event_pumps()
+-- Dict of features added to the LEAP protocol since baseline implementation.
+-- Before engaging a new feature that might break an older viewer, we can
+-- check for the presence of that feature key. This table is solely about the
+-- LEAP protocol itself, the way we communicate with the viewer. To discover
+-- whether a given listener exists, or supports a particular operation, use
+-- _command's "getAPI" operation.
+-- For Lua, _command's "getFeatures" operation suffices?
+-- leap._features = {}
+
+-- Each outstanding request() or generate() call has a corresponding
+-- WaitForReqid object (later in this module) to handle the
+-- response(s). If an incoming event contains an echoed ["reqid"] key,
+-- we can look up the appropriate WaitForReqid object more efficiently
+-- in a dict than by tossing such objects into the usual waitfors list.
+-- Note: the ["reqid"] must be unique, otherwise we could end up
+-- replacing an earlier WaitForReqid object in self.pending with a
+-- later one. That means that no incoming event will ever be given to
+-- the old WaitForReqid object. Any coroutine waiting on the discarded
+-- WaitForReqid object would therefore wait forever.
+leap._pending = {}
+-- Our consumer will instantiate some number of WaitFor subclass objects.
+-- As these are traversed in descending priority order, we must keep
+-- them in a list.
+leap._waitfors = {}
+-- It has been suggested that we should use UUIDs as ["reqid"] values,
+-- since UUIDs are guaranteed unique. However, as the "namespace" for
+-- ["reqid"] values is our very own _reply pump, we can get away with
+-- an integer.
+leap._reqid = 0
+
+-- get the name of the reply pump
+function leap.replypump()
+    return leap._reply
+end
+
+-- get the name of the command pump
+function leap.cmdpump()
+    return leap._command
+end
+
+-- Fire and forget. Send the specified request LLSD, expecting no reply.
+-- In fact, should the request produce an eventual reply, it will be
+-- treated as an unsolicited event.
+-- 
+-- See also request(), generate().
+function leap.send(pump, data, reqid)
+    local data = data
+    if type(data) == 'table' then
+        data = table.clone(data)
+        data['reply'] = leap._reply
+        if reqid ~= nil then
+            data['reqid'] = reqid
+        end
+    end
+    post_to(pump, data)
+end
+
+-- Send the specified request LLSD, expecting exactly one reply. Block
+-- the calling coroutine until we receive that reply.
+-- 
+-- Every request() (or generate()) LLSD block we send will get stamped
+-- with a distinct ["reqid"] value. The requested event API must echo the
+-- same ["reqid"] field in each reply associated with that request. This way
+-- we can correctly dispatch interleaved replies from different requests.
+-- 
+-- If the desired event API doesn't support the ["reqid"] echo convention,
+-- you should use send() instead -- since request() or generate() would
+-- wait forever for a reply stamped with that ["reqid"] -- and intercept
+-- any replies using WaitFor.
+-- 
+-- Unless the request data already contains a ["reply"] key, we insert
+-- reply=self.replypump to try to ensure that the expected reply will be
+-- returned over the socket.
+function leap.request(pump, data)
+    local reqid = leap._requestSetup(pump, data)
+    local ok, response = pcall(leap._pending[reqid].wait)
+    -- kill off temporary WaitForReqid object, even if error
+    leap._pending[reqid] = nil
+    if ok then
+        return response
+    else
+        error(response)
+    end
+end
+
+-- common setup code shared by request() and generate()
+function leap._requestSetup(pump, data)
+    -- invent a new, unique reqid
+    local reqid = leap._reqid
+    leap._reqid += 1
+    -- Instantiate a new WaitForReqid object. The priority is irrelevant
+    -- because, unlike the WaitFor base class, WaitForReqid does not
+    -- self-register on our leap._waitfors list. Instead, capture the new
+    -- WaitForReqid object in leap._pending so _dispatch() can find it.
+    leap._pending[reqid] = WaitForReqid.new(reqid)
+    -- Pass reqid to send() to stamp it into (a copy of) the request data.
+    leap.send(pump, data, reqid)
+    return reqid
+end
+
+-- Send the specified request LLSD, expecting an arbitrary number of replies.
+-- Each one is yielded on receipt. If you omit checklast, this is an infinite
+-- generator; it's up to the caller to recognize when the last reply has been
+-- received, and stop resuming for more.
+-- 
+-- If you pass checklast=<callable accepting(event)>, each response event is
+-- passed to that callable (after the yield). When the callable returns
+-- True, the generator terminates in the usual way.
+-- 
+-- See request() remarks about ["reqid"].
+function leap.generate(pump, data, checklast)
+    -- Invent a new, unique reqid. Arrange to handle incoming events
+    -- bearing that reqid. Stamp the outbound request with that reqid, and
+    -- send it.
+    local reqid = leap._requestSetup(pump, data)
+    local ok, response
+    repeat
+        ok, response = pcall(leap._pending[reqid].wait)
+        if not ok then
+            break
+        end
+        coroutine.yield(response)
+    until checklast and checklast(response)
+    -- If we break the above loop, whether or not due to error, clean up.
+    leap._pending[reqid] = nil
+    if not ok then
+        error(response)
+    end
+end
+
+-- Kick off response processing. The calling script must create and resume one
+-- or more coroutines to perform viewer requests using send(), request() or
+-- generate() before calling this function to handle responses.
+--
+-- While waiting for responses from the viewer, the C++ coroutine running the
+-- calling Lua script is blocked: no other Lua coroutine is running.
+function leap.process()
+    local ok, pump, data
+    while true do
+        ok, pump, data = pcall(get_event_next)
+        if not ok then
+            break
+        end
+        leap._dispatch(pump, data)
+    end
+    -- we're done: clean up all pending coroutines
+    for i, waitfor in pairs(leap._pending) do
+        waitfor._exception(pump)
+    end
+    for i, waitfor in pairs(leap._waitfors) do
+        waitfor._exception(pump)
+    end
+end
+
+-- Route incoming (pump, data) event to the appropriate waiting coroutine.
+function leap._dispatch(pump, data)
+    local reqid = data['reqid']
+    -- if the response has no 'reqid', it's not from request() or generate()
+    if reqid == nil then
+        return leap._unsolicited(pump, data)
+    end
+    -- have reqid; do we have a WaitForReqid?
+    local waitfor = leap._pending[reqid]
+    if waitfor == nil then
+        return leap._unsolicited(pump, data)
+    end
+    -- found the right WaitForReqid object, let it handle the event
+    data['reqid'] = nil
+    waitfor._handle(pump, data)
+end
+
+-- Handle an incoming (pump, data) event with no recognizable ['reqid']
+function leap._unsolicited(pump, data)
+    -- we maintain waitfors in descending priority order, so the first waitfor
+    -- to claim this event is the one with the highest priority
+    for i, waitfor in pairs(leap._waitfors) do
+        if waitfor._handle(pump, data) then
+            return
+        end
+    end
+    print_debug('_unsolicited(', pump, ', ', data, ') discarding unclaimed event')
+end
+
+-- called by WaitFor.enable()
+function leap._registerWaitFor(waitfor)
+    table.insert(leap._waitfors, waitfor)
+    -- keep waitfors sorted in descending order of specified priority
+    table.sort(leap._waitfors,
+               function (lhs, rhs) return lhs.priority > rhs.priority end)
+end
+
+-- called by WaitFor.disable()
+function leap._unregisterWaitFor(waitfor)
+    for i, w in pairs(leap._waitfors) do
+        if w == waitfor then
+            leap._waitfors[i] = nil
+            break
+        end
+    end
+end
+
+-- ******************************************************************************
+-- WaitFor and friends
+-- ******************************************************************************
+
+-- An unsolicited event is handled by the highest-priority WaitFor subclass
+-- object willing to accept it. If no such object is found, the unsolicited
+-- event is discarded.
+-- 
+-- - First, instantiate a WaitFor subclass object to register its interest in
+--   some incoming event(s). WaitFor instances are self-registering; merely
+--   instantiating the object suffices.
+-- - Any coroutine may call a given WaitFor object's wait() method. This blocks
+--   the calling coroutine until a suitable event arrives.
+-- - WaitFor's constructor accepts a float priority. Every incoming event
+--   (other than those claimed by request() or generate()) is passed to each
+--   extant WaitFor.filter() method in descending priority order. The first
+--   such filter() to return nontrivial data claims that event.
+-- - At that point, the blocked wait() call on that WaitFor object returns the
+--   item returned by filter().
+-- - WaitFor contains a queue. Multiple arriving events claimed by that WaitFor
+--   object's filter() method are added to the queue. Naturally, until the
+--   queue is empty, calling wait() immediately returns the front entry.
+-- 
+-- It's reasonable to instantiate a WaitFor subclass whose filter() method
+-- unconditionally returns the incoming event, and whose priority places it
+-- last in the list. This object will enqueue every unsolicited event left
+-- unclaimed by other WaitFor subclass objects.
+-- 
+-- It's not strictly necessary to associate a WaitFor object with exactly one
+-- coroutine. You might have multiple "worker" coroutines drawing from the same
+-- WaitFor object, useful if the work being done per event might itself involve
+-- "blocking" operations. Or a given coroutine might sample a number of WaitFor
+-- objects in round-robin fashion... etc. etc. Nonetheless, it's
+-- straightforward to designate one coroutine for each WaitFor object.
+leap.WaitFor = {}
+
+function leap.WaitFor:new()
+    obj = setmetatable({}, self)
+    self.__index = self
+
+    
+
+    self._first = 0
+    self._last = -1
+    self._queue = {}
+
+    return obj
+end
+
+-- Check if the queue is empty
+function Queue:IsEmpty()
+    return self._first > self._last
+end
+
+return leap
diff --git a/indra/newview/scripts/lua/qtest.lua b/indra/newview/scripts/lua/qtest.lua
new file mode 100644
index 0000000000..16a54be0d1
--- /dev/null
+++ b/indra/newview/scripts/lua/qtest.lua
@@ -0,0 +1,47 @@
+-- Exercise the Queue, WaitQueue, ErrorQueue family
+
+Queue = require('Queue')
+WaitQueue = require('WaitQueue')
+ErrorQueue = require('ErrorQueue')
+
+q1 = Queue:new()
+q2 = Queue:new()
+
+q1:Enqueue(17)
+
+assert(not q1:IsEmpty())
+assert(q2:IsEmpty())
+assert(q1:Dequeue() == 17)
+assert(q1:Dequeue() == nil)
+assert(q2:Dequeue() == nil)
+
+q1 = WaitQueue:new()
+
+inspect = require('inspect')
+print(inspect(q1))
+
+q2 = WaitQueue:new()
+result = {}
+
+values = { 1, 1, 2, 3, 5, 8, 13, 21 }
+for i, value in pairs(values) do
+    q1:Enqueue(value)
+end
+
+function consumer(desc, q)
+    print('consumer(', desc, ') start')
+    local value = q:Dequeue()
+    while value ~= nil do
+        table.insert(result, value)
+        value = q:Dequeue()
+    end
+    print('consumer(', desc, ') done')
+end
+
+coa = coroutine.create(consumer)
+cob = coroutine.create(consumer)
+coroutine.resume(coa, 'a', q1)
+coroutine.resume(cob, 'b', q1)
+
+assert(result == values)
+
-- 
cgit v1.2.3


From 63dcb3802c8139ff3b87b614cb275236cecea858 Mon Sep 17 00:00:00 2001
From: Nat Goodspeed <nat@lindenlab.com>
Date: Thu, 7 Mar 2024 13:46:24 -0500
Subject: Finish WaitQueue, ErrorQueue; add util.count(), join(); extend qtest.

For WaitQueue, nail down the mechanism for declaring a subclass and for
calling a base-class method from a subclass override. Break out new
_wake_waiters() method from Enqueue(): we need to do the same from close(), in
case there are waiting consumers. Also, in Lua, 0 is not false.

Instead of bundling a normal/error flag with every queued value, make
ErrorQueue overload its _closed attribute. Once you call ErrorQueue:Error(),
every subsequent Dequeue() call by any consumer will re-raise the same error.

util.count() literally counts entries in a table, since #t is documented to be
unreliable. (If you create a list with 5 entries and delete the middle one, #t
might return 2 or it might return 5, but it won't return 4.)

util.join() fixes a curious omission from Luau's string library: like Python's
str.join(), it concatenates all the strings from a list with an optional
separator. We assume that incrementally building a list of strings and then
doing a single allocation for the desired result string is cheaper than
reallocating each of a sequence of partial concatenated results.

Add qtest test that posts individual items to a WaitQueue, waking waiting
consumers to retrieve the next available result. Add test proving that calling
ErrorQueue:Error() propagates the error to all consumers.
---
 indra/newview/scripts/lua/ErrorQueue.lua |  32 +++++-----
 indra/newview/scripts/lua/WaitQueue.lua  |  20 +++++--
 indra/newview/scripts/lua/qtest.lua      | 100 ++++++++++++++++++++++++++++---
 indra/newview/scripts/lua/util.lua       |  72 ++++++++++++++++++++++
 4 files changed, 195 insertions(+), 29 deletions(-)
 create mode 100644 indra/newview/scripts/lua/util.lua

(limited to 'indra/newview/scripts')

diff --git a/indra/newview/scripts/lua/ErrorQueue.lua b/indra/newview/scripts/lua/ErrorQueue.lua
index e6279f8411..db7022661e 100644
--- a/indra/newview/scripts/lua/ErrorQueue.lua
+++ b/indra/newview/scripts/lua/ErrorQueue.lua
@@ -1,32 +1,30 @@
 -- ErrorQueue isa WaitQueue with the added feature that a producer can push an
--- error through the queue. When that error is dequeued, the consumer will
--- throw that error.
+-- error through the queue. Once that error is dequeued, every consumer will
+-- raise that error.
 
 local WaitQueue = require('WaitQueue')
 
 ErrorQueue = WaitQueue:new()
 
-function ErrorQueue:Enqueue(value)
-    -- normal value, not error
-    WaitQueue:Enqueue({ false, value })
-end
-
 function ErrorQueue:Error(message)
-    -- flag this entry as an error message
-    WaitQueue:Enqueue({ true, message })
+    -- Setting Error() is a marker, like closing the queue. Once we reach the
+    -- error, every subsequent Dequeue() call will raise the same error.
+    self._closed = message
+    self:_wake_waiters()
 end
 
 function ErrorQueue:Dequeue()
-    local errflag, value = table.unpack(WaitQueue:Dequeue())
-    if errflag == nil then
-        -- queue has been closed, tell caller
-        return nil
+    local value = WaitQueue.Dequeue(self)
+    if value ~= nil then
+        -- queue not yet closed, show caller
+        return value
     end
-    if errflag then
-        -- 'value' is a message pushed by Error()
-        error(value)
+    if self._closed == true then
+        -- WaitQueue:close() sets true: queue has only been closed, tell caller
+        return nil
     end
-    return value
+    -- self._closed is a message set by Error()
+    error(self._closed)
 end
 
 return ErrorQueue
diff --git a/indra/newview/scripts/lua/WaitQueue.lua b/indra/newview/scripts/lua/WaitQueue.lua
index 05d2056085..6a64c3dd67 100644
--- a/indra/newview/scripts/lua/WaitQueue.lua
+++ b/indra/newview/scripts/lua/WaitQueue.lua
@@ -7,8 +7,10 @@ local Queue = require('Queue')
 WaitQueue = Queue:new()
 
 function WaitQueue:new()
-    local obj = setmetatable(Queue:new(), self)
+    local obj = Queue:new()
+    setmetatable(obj, self)
     self.__index = self
+
     obj._waiters = {}
     obj._closed = false
     return obj
@@ -18,7 +20,14 @@ function WaitQueue:Enqueue(value)
     if self._closed then
         error("can't Enqueue() on closed Queue")
     end
-    Queue:Enqueue(value)
+    -- can't simply call Queue:Enqueue(value)! That calls the method on the
+    -- Queue class definition, instead of calling Queue:Enqueue() on self.
+    -- Hand-expand the Queue:Enqueue() syntactic sugar.
+    Queue.Enqueue(self, value)
+    self:_wake_waiters()
+end
+
+function WaitQueue:_wake_waiters()
     -- WaitQueue is designed to support multi-producer, multi-consumer use
     -- cases. With multiple consumers, if more than one is trying to
     -- Dequeue() from an empty WaitQueue, we'll have multiple waiters.
@@ -27,7 +36,7 @@ function WaitQueue:Enqueue(value)
     -- callers. But since resuming that caller might entail either Enqueue()
     -- or Dequeue() calls, recheck every time around to see if we must resume
     -- another waiting coroutine.
-    while not self:IsEmpty() and #self._waiters do
+    while not self:IsEmpty() and #self._waiters > 0 do
         -- pop the oldest waiting coroutine instead of the most recent, for
         -- more-or-less round robin fairness
         local waiter = table.remove(self._waiters, 1)
@@ -58,11 +67,14 @@ function WaitQueue:Dequeue()
         coroutine.yield()
     end
     -- here we're sure this queue isn't empty
-    return Queue:Dequeue()
+    return Queue.Dequeue(self)
 end
 
 function WaitQueue:close()
     self._closed = true
+    -- close() is like Enqueueing an end marker. If there are waiting
+    -- consumers, give them a chance to see we're closed.
+    self:_wake_waiters()
 end
 
 return WaitQueue
diff --git a/indra/newview/scripts/lua/qtest.lua b/indra/newview/scripts/lua/qtest.lua
index 16a54be0d1..12e425b7b2 100644
--- a/indra/newview/scripts/lua/qtest.lua
+++ b/indra/newview/scripts/lua/qtest.lua
@@ -3,7 +3,11 @@
 Queue = require('Queue')
 WaitQueue = require('WaitQueue')
 ErrorQueue = require('ErrorQueue')
+util = require('util')
 
+inspect = require('inspect')
+
+-- ------------------ Queue variables are instance-specific ------------------
 q1 = Queue:new()
 q2 = Queue:new()
 
@@ -15,33 +19,113 @@ assert(q1:Dequeue() == 17)
 assert(q1:Dequeue() == nil)
 assert(q2:Dequeue() == nil)
 
+-- ----------------------------- test WaitQueue ------------------------------
 q1 = WaitQueue:new()
-
-inspect = require('inspect')
-print(inspect(q1))
-
 q2 = WaitQueue:new()
 result = {}
-
 values = { 1, 1, 2, 3, 5, 8, 13, 21 }
+
 for i, value in pairs(values) do
     q1:Enqueue(value)
 end
+-- close() while not empty tests that queue drains before reporting done
+q1:close()
 
+-- ensure that WaitQueue instance variables are in fact independent
+assert(q2:IsEmpty())
+
+-- consumer() coroutine to pull from the passed q until closed
 function consumer(desc, q)
-    print('consumer(', desc, ') start')
+    print(string.format('consumer(%s) start', desc))
     local value = q:Dequeue()
     while value ~= nil do
+        print(string.format('consumer(%s) got %q', desc, value))
         table.insert(result, value)
         value = q:Dequeue()
     end
-    print('consumer(', desc, ') done')
+    print(string.format('consumer(%s) done', desc))
 end
 
+-- run two consumers
 coa = coroutine.create(consumer)
 cob = coroutine.create(consumer)
+-- Since consumer() doesn't yield while it can still retrieve values,
+-- consumer(a) will dequeue all values from q1 and return when done.
 coroutine.resume(coa, 'a', q1)
+-- consumer(b) will wake up to find the queue empty and closed.
 coroutine.resume(cob, 'b', q1)
+coroutine.close(coa)
+coroutine.close(cob)
+
+print('values:', inspect(values))
+print('result:', inspect(result))
+
+assert(util.equal(values, result))
+
+-- try incrementally enqueueing values
+q3 = WaitQueue:new()
+result = {}
+values = { 'This', 'is', 'a', 'test', 'script' }
+
+coros = {}
+for _, name in {'a', 'b'} do
+    local coro = coroutine.create(consumer)
+    table.insert(coros, coro)
+    -- Resuming both coroutines should leave them both waiting for a queue item.
+    coroutine.resume(coro, name, q3)
+end
+
+for _, s in pairs(values) do
+    print(string.format('Enqueue(%q)', s))
+    q3:Enqueue(s)
+end
+q3:close()
+
+function joinall(coros)
+    local running
+    local errors = 0
+    repeat
+        running = false
+        for i, coro in pairs(coros) do
+            if coroutine.status(coro) == 'suspended' then
+                running = true
+                local ok, message = coroutine.resume(coro)
+                if not ok then
+                    print('*** ' .. message)
+                    errors += 1
+                end
+                if coroutine.status(coro) == 'dead' then
+                    coros[i] = nil
+                end
+            end
+        end
+    until not running
+    return errors
+end
+
+joinall(coros)
+
+print(string.format('%q', util.join(result, ' ')))
+assert(util.equal(values, result))
+
+-- ----------------------------- test ErrorQueue -----------------------------
+q4 = ErrorQueue:new()
+result = {}
+values = { 'This', 'is', 'a', 'test', 'script' }
+
+coros = {}
+for _, name in {'a', 'b'} do
+    local coro = coroutine.create(consumer)
+    table.insert(coros, coro)
+    -- Resuming both coroutines should leave them both waiting for a queue item.
+    coroutine.resume(coro, name, q4)
+end
+
+for i = 1, 4 do
+    print(string.format('Enqueue(%q)', values[i]))
+    q4:Enqueue(values[i])
+end
+q4:Error('something went wrong')
 
-assert(result == values)
+assert(joinall(coros) == 2)
 
diff --git a/indra/newview/scripts/lua/util.lua b/indra/newview/scripts/lua/util.lua
new file mode 100644
index 0000000000..bb8d492d12
--- /dev/null
+++ b/indra/newview/scripts/lua/util.lua
@@ -0,0 +1,72 @@
+-- utility functions, in alpha order
+
+local util = {}
+
+-- cheap test whether table t is empty
+function util.empty(t)
+    for _ in pairs(t) do
+        return false
+    end
+    return true
+end
+
+-- reliable count of the number of entries in table t
+-- (since #t is unreliable)
+function util.count(t)
+    local count = 0
+    for _ in pairs(t) do
+        count += 1
+    end
+    return count
+end
+
+-- recursive table equality
+function util.equal(t1, t2)
+    if not (type(t1) == 'table' and type(t2) == 'table') then
+        return t1 == t2
+    end
+    -- both t1 and t2 are tables: get modifiable copy of t2
+    local temp = table.clone(t2)
+    for k, v in pairs(t1) do
+        -- if any key in t1 doesn't have same value in t2, not equal
+        if not util.equal(v, temp[k]) then
+            return false
+        end
+        -- temp[k] == t1[k], delete temp[k]
+        temp[k] = nil
+    end
+    -- All keys in t1 have equal values in t2; t2 == t1 if there are no extra keys in t2
+    return util.empty(temp)
+end
+
+-- Concatentate the strings in the passed list, return the composite string.
+-- For iterative string building, the theory is that building a list with
+-- table.insert() and then using join() to allocate the full-size result
+-- string once should be more efficient than reallocating an intermediate
+-- string for every partial concatenation.
+function util.join(list, sep)
+    -- This succinct implementation assumes that string.format() precomputes
+    -- the required size of its output buffer before populating it. We don't
+    -- know that. Moreover, this implementation predates our sep argument.
+--  return string.format(string.rep('%s', #list), table.unpack(list))
+
+    -- this implementation makes it explicit
+    local sep = sep or ''
+    local size = if util.empty(list) then 0 else -#sep
+    for _, s in pairs(list) do
+        size += #sep + #s
+    end
+    local result = buffer.create(size)
+    size = 0
+    for i, s in pairs(list) do
+        if i > 1 then
+            buffer.writestring(result, size, sep)
+            size += #sep
+        end
+        buffer.writestring(result, size, s)
+        size += #s
+    end
+    return buffer.tostring(result)
+end
+
+return util
-- 
cgit v1.2.3


From 7f46c285263acd65587884a6704f07fb7f391e92 Mon Sep 17 00:00:00 2001
From: Nat Goodspeed <nat@lindenlab.com>
Date: Thu, 7 Mar 2024 16:41:39 -0500
Subject: Finish adding leap.WaitFor and WaitForReqid. Untested.

---
 indra/newview/scripts/lua/ErrorQueue.lua |   2 +-
 indra/newview/scripts/lua/WaitQueue.lua  |   2 +-
 indra/newview/scripts/lua/leap.lua       | 141 +++++++++++++++++++++++++++----
 3 files changed, 127 insertions(+), 18 deletions(-)

(limited to 'indra/newview/scripts')

diff --git a/indra/newview/scripts/lua/ErrorQueue.lua b/indra/newview/scripts/lua/ErrorQueue.lua
index db7022661e..a6d4470044 100644
--- a/indra/newview/scripts/lua/ErrorQueue.lua
+++ b/indra/newview/scripts/lua/ErrorQueue.lua
@@ -4,7 +4,7 @@
 
 local WaitQueue = require('WaitQueue')
 
-ErrorQueue = WaitQueue:new()
+local ErrorQueue = WaitQueue:new()
 
 function ErrorQueue:Error(message)
     -- Setting Error() is a marker, like closing the queue. Once we reach the
diff --git a/indra/newview/scripts/lua/WaitQueue.lua b/indra/newview/scripts/lua/WaitQueue.lua
index 6a64c3dd67..e6adde0573 100644
--- a/indra/newview/scripts/lua/WaitQueue.lua
+++ b/indra/newview/scripts/lua/WaitQueue.lua
@@ -4,7 +4,7 @@
 
 local Queue = require('Queue')
 
-WaitQueue = Queue:new()
+local WaitQueue = Queue:new()
 
 function WaitQueue:new()
     local obj = Queue:new()
diff --git a/indra/newview/scripts/lua/leap.lua b/indra/newview/scripts/lua/leap.lua
index 351e1bf007..708df821e8 100644
--- a/indra/newview/scripts/lua/leap.lua
+++ b/indra/newview/scripts/lua/leap.lua
@@ -17,6 +17,8 @@
 -- get_event_next() blocks the calling Lua script until the next event is
 -- received.
 
+local ErrorQueue = require('ErrorQueue')
+
 local leap = {}
 
 -- _reply: string name of reply LLEventPump. Any events the viewer posts to
@@ -120,7 +122,7 @@ function leap._requestSetup(pump, data)
     -- because, unlike the WaitFor base class, WaitForReqid does not
     -- self-register on our leap._waitfors list. Instead, capture the new
     -- WaitForReqid object in leap._pending so _dispatch() can find it.
-    leap._pending[reqid] = WaitForReqid.new(reqid)
+    leap._pending[reqid] = leap.WaitForReqid:new(reqid)
     -- Pass reqid to send() to stamp it into (a copy of) the request data.
     leap.send(pump, data, reqid)
     return reqid
@@ -178,6 +180,10 @@ function leap.process()
     for i, waitfor in pairs(leap._waitfors) do
         waitfor._exception(pump)
     end
+    -- now that we're done with cleanup, propagate the error we caught above
+    if not ok then
+        error(pump)
+    end
 end
 
 -- Route incoming (pump, data) event to the appropriate waiting coroutine.
@@ -235,18 +241,18 @@ end
 -- object willing to accept it. If no such object is found, the unsolicited
 -- event is discarded.
 -- 
--- - First, instantiate a WaitFor subclass object to register its interest in
+-- * First, instantiate a WaitFor subclass object to register its interest in
 --   some incoming event(s). WaitFor instances are self-registering; merely
 --   instantiating the object suffices.
--- - Any coroutine may call a given WaitFor object's wait() method. This blocks
+-- * Any coroutine may call a given WaitFor object's wait() method. This blocks
 --   the calling coroutine until a suitable event arrives.
--- - WaitFor's constructor accepts a float priority. Every incoming event
+-- * WaitFor's constructor accepts a float priority. Every incoming event
 --   (other than those claimed by request() or generate()) is passed to each
 --   extant WaitFor.filter() method in descending priority order. The first
 --   such filter() to return nontrivial data claims that event.
--- - At that point, the blocked wait() call on that WaitFor object returns the
+-- * At that point, the blocked wait() call on that WaitFor object returns the
 --   item returned by filter().
--- - WaitFor contains a queue. Multiple arriving events claimed by that WaitFor
+-- * WaitFor contains a queue. Multiple arriving events claimed by that WaitFor
 --   object's filter() method are added to the queue. Naturally, until the
 --   queue is empty, calling wait() immediately returns the front entry.
 -- 
@@ -261,24 +267,127 @@ end
 -- "blocking" operations. Or a given coroutine might sample a number of WaitFor
 -- objects in round-robin fashion... etc. etc. Nonetheless, it's
 -- straightforward to designate one coroutine for each WaitFor object.
-leap.WaitFor = {}
 
-function leap.WaitFor:new()
-    obj = setmetatable({}, self)
+-- --------------------------------- WaitFor ---------------------------------
+leap.WaitFor = { _id=0 }
+
+function leap.WaitFor:new(priority, name)
+    local obj = setmetatable({}, self)
     self.__index = self
 
-    
+    obj.priority = priority
+    if name then
+        obj.name = name
+    else
+        self._id += 1
+        obj.name = 'WaitFor' .. self._id
+    end
+    obj._queue = ErrorQueue:new()
+    obj._registered = false
+    obj:enable()
+
+    return obj
+end
+
+function leap.WaitFor.tostring(self)
+    -- Lua (sub)classes have no name; can't prefix with that
+    return self.name
+end
+
+-- Re-enable a disable()d WaitFor object. New WaitFor objects are
+-- enable()d by default.
+function leap.WaitFor:enable()
+    if not self._registered then
+        leap._registerWaitFor(self)
+        self._registered = true
+    end
+end
+
+-- Disable an enable()d WaitFor object.
+function leap.WaitFor:disable()
+    if self._registered then
+        leap._unregisterWaitFor(self)
+        self._registered = false
+    end
+end
+
+-- Block the calling coroutine until a suitable unsolicited event (one
+-- for which filter() returns the event) arrives.
+function leap.WaitFor:wait()
+    return self._queue:Dequeue()
+end
+
+-- Loop over wait() calls.
+function leap.WaitFor:iterate()
+    -- on each iteration, call self.wait(self)
+    return self.wait, self, nil
+end
+
+-- Override filter() to examine the incoming event in whatever way
+-- makes sense.
+-- 
+-- Return nil to ignore this event.
+-- 
+-- To claim the event, return the item you want placed in the queue.
+-- Typically you'd write:
+-- return data
+-- or perhaps
+-- return {pump=pump, data=data}
+-- or some variation.
+function leap.WaitFor:filter(pump, data)
+    error('You must subclass WaitFor and override its filter() method')
+end
+
+-- called by leap._unsolicited() for each WaitFor in leap._waitfors
+function leap.WaitFor:_handle(pump, data)
+    item = self:filter(pump, data)
+    -- if this item doesn't pass the filter, we're not interested
+    if not item then
+        return false
+    end
+    -- okay, filter() claims this event
+    self:process(item)
+    return true
+end
 
-    self._first = 0
-    self._last = -1
-    self._queue = {}
+-- called by WaitFor:_handle() for an accepted event
+function leap.WaitFor:process(item)
+    self._queue:Enqueue(item)
+end
+
+-- called by leap.process() when get_event_next() raises an error
+function leap.WaitFor:_exception(message)
+    self._queue:Error(message)
+end
+
+-- ------------------------------ WaitForReqid -------------------------------
+leap.WaitForReqid = leap.WaitFor:new()
+
+function leap.WaitForReqid:new(reqid)
+    -- priority is meaningless, since this object won't be added to the
+    -- priority-sorted ViewerClient.waitfors list. Use the reqid as the
+    -- debugging name string.
+    local obj = leap.WaitFor:new(0, 'WaitForReqid(' .. reqid .. ')')
+    setmetatable(obj, self)
+    self.__index = self
 
     return obj
 end
 
--- Check if the queue is empty
-function Queue:IsEmpty()
-    return self._first > self._last
+function leap.WaitForReqid:enable()
+    -- Do NOT self-register in the normal way. request() and generate()
+    -- have an entirely different registry that points directly to the
+    -- WaitForReqid object of interest.
+end
+
+function leap.WaitForReqid:disable()
+end
+
+function leap.WaitForReqid:filter(pump, data)
+    -- Because we expect to directly look up the WaitForReqid object of
+    -- interest based on the incoming ["reqid"] value, it's not necessary
+    -- to test the event again. Accept every such event.
+    return data
 end
 
 return leap
-- 
cgit v1.2.3


From a249bfa18e492a4317d739f7b9d839b796f005ba Mon Sep 17 00:00:00 2001
From: Nat Goodspeed <nat@lindenlab.com>
Date: Mon, 11 Mar 2024 12:49:10 -0400
Subject: Make WaitQueue:_wait_waiters() skip dead coroutines.

That is, skip coroutines that have gone dead since they decided to wait on
Dequeue().
---
 indra/newview/scripts/lua/WaitQueue.lua | 21 ++++++++++++++-------
 1 file changed, 14 insertions(+), 7 deletions(-)

(limited to 'indra/newview/scripts')

diff --git a/indra/newview/scripts/lua/WaitQueue.lua b/indra/newview/scripts/lua/WaitQueue.lua
index e6adde0573..00766ccae7 100644
--- a/indra/newview/scripts/lua/WaitQueue.lua
+++ b/indra/newview/scripts/lua/WaitQueue.lua
@@ -37,14 +37,21 @@ function WaitQueue:_wake_waiters()
     -- or Dequeue() calls, recheck every time around to see if we must resume
     -- another waiting coroutine.
     while not self:IsEmpty() and #self._waiters > 0 do
-        -- pop the oldest waiting coroutine instead of the most recent, for
-        -- more-or-less round robin fairness
+        -- Pop the oldest waiting coroutine instead of the most recent, for
+        -- more-or-less round robin fairness. But skip any coroutines that
+        -- have gone dead in the meantime.
         local waiter = table.remove(self._waiters, 1)
-        -- don't pass the head item: let the resumed coroutine retrieve it
-        local ok, message = coroutine.resume(waiter)
-        -- if resuming that waiter encountered an error, don't swallow it
-        if not ok then
-            error(message)
+        while waiter and coroutine.status(waiter) ~= "suspended" do
+            waiter = table.remove(self._waiters, 1)
+        end
+        -- do we still have at least one waiting coroutine?
+        if waiter then
+            -- don't pass the head item: let the resumed coroutine retrieve it
+            local ok, message = coroutine.resume(waiter)
+            -- if resuming that waiter encountered an error, don't swallow it
+            if not ok then
+                error(message)
+            end
         end
     end
 end
-- 
cgit v1.2.3


From 4a8ea879fa62c0131985f625e940c5bc0b3fec46 Mon Sep 17 00:00:00 2001
From: Nat Goodspeed <nat@lindenlab.com>
Date: Mon, 11 Mar 2024 12:55:23 -0400
Subject: Polish up leap.lua to make it pass tests.

Add usage comments at the top.

Add leap.done() function.

Make leap.process() honor leap.done(), also recognize an incoming nil from the
viewer to mean it's all done.

Support leap.WaitFor with nil priority to mean "don't self-enable." This
obviates leap.WaitForReqid:enable() and disable() overrides that do nothing.

Add diagnostic logging.
---
 indra/newview/scripts/lua/leap.lua | 73 ++++++++++++++++++++++++++++----------
 1 file changed, 54 insertions(+), 19 deletions(-)

(limited to 'indra/newview/scripts')

diff --git a/indra/newview/scripts/lua/leap.lua b/indra/newview/scripts/lua/leap.lua
index 708df821e8..6477d1b9fd 100644
--- a/indra/newview/scripts/lua/leap.lua
+++ b/indra/newview/scripts/lua/leap.lua
@@ -16,6 +16,27 @@
 -- was received and the received event data. When the queue is empty,
 -- get_event_next() blocks the calling Lua script until the next event is
 -- received.
+--
+-- Usage:
+-- 1. Launch some number of Lua coroutines. The code in each coroutine may
+--    call leap.send(), leap.request() or leap.generate(). leap.send() returns
+--    immediately ("fire and forget"). leap.request() blocks the calling
+--    coroutine until it receives and returns the viewer's response to its
+--    request. leap.generate() expects an arbitrary number of responses to the
+--    original request.
+-- 2. To handle events from the viewer other than direct responses to
+--    requests, instantiate a leap.WaitFor object with a filter(pump, data)
+--    override method that returns non-nil for desired events. A coroutine may
+--    call wait() on any such WaitFor.
+-- 3. Once the coroutines have been launched, call leap.process() on the main
+--    coroutine. process() retrieves incoming events from the viewer and
+--    dispatches them to waiting request() or generate() calls, or to
+--    appropriate WaitFor instances. process() returns when either
+--    get_event_next() raises an error or the viewer posts nil to the script's
+--    reply pump to indicate it's done.
+-- 4. Alternatively, a running coroutine may call leap.done() to break out of
+--    leap.process(). process() won't notice until the next event from the
+--    viewer, though.
 
 local ErrorQueue = require('ErrorQueue')
 
@@ -57,6 +78,8 @@ leap._waitfors = {}
 -- ["reqid"] values is our very own _reply pump, we can get away with
 -- an integer.
 leap._reqid = 0
+-- break leap.process() loop
+leap._done = false
 
 -- get the name of the reply pump
 function leap.replypump()
@@ -101,6 +124,8 @@ end
 -- Unless the request data already contains a ["reply"] key, we insert
 -- reply=self.replypump to try to ensure that the expected reply will be
 -- returned over the socket.
+--
+-- See also send(), generate().
 function leap.request(pump, data)
     local reqid = leap._requestSetup(pump, data)
     local ok, response = pcall(leap._pending[reqid].wait)
@@ -165,20 +190,28 @@ end
 -- While waiting for responses from the viewer, the C++ coroutine running the
 -- calling Lua script is blocked: no other Lua coroutine is running.
 function leap.process()
+    leap._done = false
     local ok, pump, data
-    while true do
+    while not leap._done do
         ok, pump, data = pcall(get_event_next)
-        if not ok then
+        print_debug('leap.process() got', ok, pump, data)
+        -- ok false means get_event_next() raised a Lua error
+        -- data nil means get_event_next() returned (pump, LLSD()) to indicate done
+        if not (ok and data) then
+            print_debug('leap.process() done')
             break
         end
         leap._dispatch(pump, data)
     end
     -- we're done: clean up all pending coroutines
+    -- if ok, then we're just done.
+    -- if not ok, then 'pump' is actually the error message.
+    message = if ok then 'done' else pump
     for i, waitfor in pairs(leap._pending) do
-        waitfor._exception(pump)
+        waitfor:_exception(message)
     end
     for i, waitfor in pairs(leap._waitfors) do
-        waitfor._exception(pump)
+        waitfor:_exception(message)
     end
     -- now that we're done with cleanup, propagate the error we caught above
     if not ok then
@@ -186,6 +219,10 @@ function leap.process()
     end
 end
 
+function leap.done()
+    leap._done = true
+end
+
 -- Route incoming (pump, data) event to the appropriate waiting coroutine.
 function leap._dispatch(pump, data)
     local reqid = data['reqid']
@@ -200,7 +237,7 @@ function leap._dispatch(pump, data)
     end
     -- found the right WaitForReqid object, let it handle the event
     data['reqid'] = nil
-    waitfor._handle(pump, data)
+    waitfor:_handle(pump, data)
 end
 
 -- Handle an incoming (pump, data) event with no recognizable ['reqid']
@@ -208,7 +245,7 @@ function leap._unsolicited(pump, data)
     -- we maintain waitfors in descending priority order, so the first waitfor
     -- to claim this event is the one with the highest priority
     for i, waitfor in pairs(leap._waitfors) do
-        if waitfor._handle(pump, data) then
+        if waitfor:_handle(pump, data) then
             return
         end
     end
@@ -284,7 +321,10 @@ function leap.WaitFor:new(priority, name)
     end
     obj._queue = ErrorQueue:new()
     obj._registered = false
-    obj:enable()
+    -- if no priority, then don't enable() - remember 0 is truthy
+    if priority then
+        obj:enable()
+    end
 
     return obj
 end
@@ -314,7 +354,10 @@ end
 -- Block the calling coroutine until a suitable unsolicited event (one
 -- for which filter() returns the event) arrives.
 function leap.WaitFor:wait()
-    return self._queue:Dequeue()
+    print_debug(self.name .. ' about to wait')
+    item = self._queue:Dequeue()
+    print_debug(self.name .. ' got ', item)
+    return item
 end
 
 -- Loop over wait() calls.
@@ -335,7 +378,7 @@ end
 -- return {pump=pump, data=data}
 -- or some variation.
 function leap.WaitFor:filter(pump, data)
-    error('You must subclass WaitFor and override its filter() method')
+    error('You must override the WaitFor.filter() method')
 end
 
 -- called by leap._unsolicited() for each WaitFor in leap._waitfors
@@ -357,6 +400,7 @@ end
 
 -- called by leap.process() when get_event_next() raises an error
 function leap.WaitFor:_exception(message)
+    print_warning(self.name .. ' error: ' .. message)
     self._queue:Error(message)
 end
 
@@ -367,22 +411,13 @@ function leap.WaitForReqid:new(reqid)
     -- priority is meaningless, since this object won't be added to the
     -- priority-sorted ViewerClient.waitfors list. Use the reqid as the
     -- debugging name string.
-    local obj = leap.WaitFor:new(0, 'WaitForReqid(' .. reqid .. ')')
+    local obj = leap.WaitFor:new(nil, 'WaitForReqid(' .. reqid .. ')')
     setmetatable(obj, self)
     self.__index = self
 
     return obj
 end
 
-function leap.WaitForReqid:enable()
-    -- Do NOT self-register in the normal way. request() and generate()
-    -- have an entirely different registry that points directly to the
-    -- WaitForReqid object of interest.
-end
-
-function leap.WaitForReqid:disable()
-end
-
 function leap.WaitForReqid:filter(pump, data)
     -- Because we expect to directly look up the WaitForReqid object of
     -- interest based on the incoming ["reqid"] value, it's not necessary
-- 
cgit v1.2.3


From 42de5594cd4ebde605e6f93a48a7e7c9ab60ace4 Mon Sep 17 00:00:00 2001
From: Nat Goodspeed <nat@lindenlab.com>
Date: Mon, 11 Mar 2024 16:12:07 -0400
Subject: Lua already has a conventional cheap test for empty table.

---
 indra/newview/scripts/lua/util.lua | 5 +----
 1 file changed, 1 insertion(+), 4 deletions(-)

(limited to 'indra/newview/scripts')

diff --git a/indra/newview/scripts/lua/util.lua b/indra/newview/scripts/lua/util.lua
index bb8d492d12..898ddc58e3 100644
--- a/indra/newview/scripts/lua/util.lua
+++ b/indra/newview/scripts/lua/util.lua
@@ -4,10 +4,7 @@ local util = {}
 
 -- cheap test whether table t is empty
 function util.empty(t)
-    for _ in pairs(t) do
-        return false
-    end
-    return true
+    return not next(t)
 end
 
 -- reliable count of the number of entries in table t
-- 
cgit v1.2.3


From c371096fc3320f580fd271dad09c852f2e3d5f78 Mon Sep 17 00:00:00 2001
From: Nat Goodspeed <nat@lindenlab.com>
Date: Mon, 11 Mar 2024 16:49:03 -0400
Subject: Add coro.lua to aggregate created coroutines.

---
 indra/newview/scripts/lua/coro.lua | 57 ++++++++++++++++++++++++++++++++++++++
 1 file changed, 57 insertions(+)
 create mode 100644 indra/newview/scripts/lua/coro.lua

(limited to 'indra/newview/scripts')

diff --git a/indra/newview/scripts/lua/coro.lua b/indra/newview/scripts/lua/coro.lua
new file mode 100644
index 0000000000..8f868f5a48
--- /dev/null
+++ b/indra/newview/scripts/lua/coro.lua
@@ -0,0 +1,57 @@
+-- Manage Lua coroutines
+
+local coro = {}
+
+coro._coros = {}
+
+-- Launch a Lua coroutine: create and resume.
+-- Returns:
+-- new coroutine
+-- bool ok
+-- if not ok: error message
+-- if ok:     values yielded or returned
+function coro.launch(func, ...)
+    local co = coroutine.create(func)
+    table.insert(coro._coros, co)
+    return co, coroutine.resume(co, ...)
+end
+
+-- yield to other coroutines even if you don't know whether you're in a
+-- created coroutine or the main coroutine
+function coro.yield(...)
+    if coroutine.running() then
+        -- this is a real coroutine, yield normally
+        return coroutine.yield(...)
+    else
+        -- This is the main coroutine: coroutine.yield() doesn't work.
+        -- But we can take a spin through previously-launched coroutines.
+        -- Walk a copy of coro._coros in case any of these coroutines launches
+        -- another: next() forbids creating new entries during traversal.
+        for co in coro._live_coros_iter, table.clone(coro._coros) do
+            co.resume()
+        end
+    end
+end
+
+-- Walk coro._coros table, returning running or suspended coroutines.
+-- Once a coroutine becomes dead, remove it from _coros and don't return it.
+function coro._live_coros()
+    return coro._live_coros_iter, coro._coros
+end
+
+-- iterator function for _live_coros()
+function coro._live_coros_iter(t, idx)
+    local k, co = next(t, idx)
+    while k and coroutine.status(co) == 'dead' do
+--      t[k] = nil
+        -- See coro.yield(): sometimes we traverse a copy of _coros, but if we
+        -- discover a dead coroutine in that copy, delete it from _coros
+        -- anyway. Deleting it from a temporary copy does nothing.
+        coro._coros[k] = nil
+        coroutine.close(co)
+        k, co = next(t, k)
+    end
+    return co
+end
+
+return coro
-- 
cgit v1.2.3


From 587d65dc127fd72cd72aed5f02dbfd3bf277a9ef Mon Sep 17 00:00:00 2001
From: Nat Goodspeed <nat@lindenlab.com>
Date: Wed, 13 Mar 2024 14:31:05 -0400
Subject: Make a coro.resume() wrapper and use in coro.launch(), coro.yield().

coro.resume() checks the ok boolean returned by coroutine.resume() and, if not
ok, propagates the error. This avoids coroutine errors getting swallowed.
---
 indra/newview/scripts/lua/coro.lua | 24 +++++++++++++++++-------
 1 file changed, 17 insertions(+), 7 deletions(-)

(limited to 'indra/newview/scripts')

diff --git a/indra/newview/scripts/lua/coro.lua b/indra/newview/scripts/lua/coro.lua
index 8f868f5a48..616a797e95 100644
--- a/indra/newview/scripts/lua/coro.lua
+++ b/indra/newview/scripts/lua/coro.lua
@@ -5,15 +5,25 @@ local coro = {}
 coro._coros = {}
 
 -- Launch a Lua coroutine: create and resume.
--- Returns:
--- new coroutine
--- bool ok
--- if not ok: error message
--- if ok:     values yielded or returned
+-- Returns: new coroutine, values yielded or returned from initial resume()
+-- If initial resume() encountered an error, propagates the error.
 function coro.launch(func, ...)
     local co = coroutine.create(func)
     table.insert(coro._coros, co)
-    return co, coroutine.resume(co, ...)
+    return co, coro.resume(co, ...)
+end
+
+-- resume() wrapper to propagate errors
+function coro.resume(co, ...)
+    -- if there's an idiom other than table.pack() to assign an arbitrary
+    -- number of return values, I don't yet know it
+    local ok_result = table.pack(coroutine.resume(co, ...))
+    if not ok_result[1] then
+        -- if [1] is false, then [2] is the error message
+        error(ok_result[2])
+    end
+    -- ok is true, whew, just return the rest of the values
+    return table.unpack(ok_result, 2)
 end
 
 -- yield to other coroutines even if you don't know whether you're in a
@@ -28,7 +38,7 @@ function coro.yield(...)
         -- Walk a copy of coro._coros in case any of these coroutines launches
         -- another: next() forbids creating new entries during traversal.
         for co in coro._live_coros_iter, table.clone(coro._coros) do
-            co.resume()
+            coro.resume(co)
         end
     end
 end
-- 
cgit v1.2.3


From 354d7b55c0a267b542dc51e3985f7d3739ffcdfd Mon Sep 17 00:00:00 2001
From: Nat Goodspeed <nat@lindenlab.com>
Date: Wed, 13 Mar 2024 14:37:48 -0400
Subject: Introduce a resume() wrapper to surface coroutine errors.

---
 indra/newview/scripts/lua/qtest.lua | 25 ++++++++++++++++++++-----
 1 file changed, 20 insertions(+), 5 deletions(-)

(limited to 'indra/newview/scripts')

diff --git a/indra/newview/scripts/lua/qtest.lua b/indra/newview/scripts/lua/qtest.lua
index 12e425b7b2..009446d0c3 100644
--- a/indra/newview/scripts/lua/qtest.lua
+++ b/indra/newview/scripts/lua/qtest.lua
@@ -7,6 +7,19 @@ util = require('util')
 
 inspect = require('inspect')
 
+-- resume() wrapper to propagate errors
+function resume(co, ...)
+    -- if there's an idiom other than table.pack() to assign an arbitrary
+    -- number of return values, I don't yet know it
+    local ok_result = table.pack(coroutine.resume(co, ...))
+    if not ok_result[1] then
+        -- if [1] is false, then [2] is the error message
+        error(ok_result[2])
+    end
+    -- ok is true, whew, just return the rest of the values
+    return table.unpack(ok_result, 2)
+end
+
 -- ------------------ Queue variables are instance-specific ------------------
 q1 = Queue:new()
 q2 = Queue:new()
@@ -51,9 +64,9 @@ coa = coroutine.create(consumer)
 cob = coroutine.create(consumer)
 -- Since consumer() doesn't yield while it can still retrieve values,
 -- consumer(a) will dequeue all values from q1 and return when done.
-coroutine.resume(coa, 'a', q1)
+resume(coa, 'a', q1)
 -- consumer(b) will wake up to find the queue empty and closed.
-coroutine.resume(cob, 'b', q1)
+resume(cob, 'b', q1)
 coroutine.close(coa)
 coroutine.close(cob)
 
@@ -72,7 +85,7 @@ for _, name in {'a', 'b'} do
     local coro = coroutine.create(consumer)
     table.insert(coros, coro)
     -- Resuming both coroutines should leave them both waiting for a queue item.
-    coroutine.resume(coro, name, q3)
+    resume(coro, name, q3)
 end
 
 for _, s in pairs(values) do
@@ -89,6 +102,8 @@ function joinall(coros)
         for i, coro in pairs(coros) do
             if coroutine.status(coro) == 'suspended' then
                 running = true
+                -- directly call coroutine.resume() instead of our resume()
+                -- wrapper because we explicitly check for errors here
                 local ok, message = coroutine.resume(coro)
                 if not ok then
                     print('*** ' .. message)
@@ -105,7 +120,7 @@ end
 
 joinall(coros)
 
-print(string.format('%q', util.join(result, ' ')))
+print(string.format('%q', table.concat(result, ' ')))
 assert(util.equal(values, result))
 
 -- ----------------------------- test ErrorQueue -----------------------------
@@ -118,7 +133,7 @@ for _, name in {'a', 'b'} do
     local coro = coroutine.create(consumer)
     table.insert(coros, coro)
     -- Resuming both coroutines should leave them both waiting for a queue item.
-    coroutine.resume(coro, name, q4)
+    resume(coro, name, q4)
 end
 
 for i = 1, 4 do
-- 
cgit v1.2.3


From dfd47762afc757777dcdde3960a08951c45fb1ed Mon Sep 17 00:00:00 2001
From: Nat Goodspeed <nat@lindenlab.com>
Date: Wed, 13 Mar 2024 14:38:25 -0400
Subject: Fix minor bugs. Sprinkle in commented-out diagnostic output.

---
 indra/newview/scripts/lua/leap.lua | 27 +++++++++++++++++++--------
 1 file changed, 19 insertions(+), 8 deletions(-)

(limited to 'indra/newview/scripts')

diff --git a/indra/newview/scripts/lua/leap.lua b/indra/newview/scripts/lua/leap.lua
index 6477d1b9fd..2dd0d7b8ec 100644
--- a/indra/newview/scripts/lua/leap.lua
+++ b/indra/newview/scripts/lua/leap.lua
@@ -91,12 +91,15 @@ function leap.cmdpump()
     return leap._command
 end
 
+-- local inspect = require('inspect')
+
 -- Fire and forget. Send the specified request LLSD, expecting no reply.
 -- In fact, should the request produce an eventual reply, it will be
 -- treated as an unsolicited event.
 -- 
 -- See also request(), generate().
 function leap.send(pump, data, reqid)
+--  print_debug('leap.send('..pump..', '..inspect(data)..', '..reqid..') entry')
     local data = data
     if type(data) == 'table' then
         data = table.clone(data)
@@ -105,7 +108,8 @@ function leap.send(pump, data, reqid)
             data['reqid'] = reqid
         end
     end
-    post_to(pump, data)
+--  print_debug('leap.send('..pump..', '..inspect(data)..') calling post_on()')
+    post_on(pump, data)
 end
 
 -- Send the specified request LLSD, expecting exactly one reply. Block
@@ -128,7 +132,12 @@ end
 -- See also send(), generate().
 function leap.request(pump, data)
     local reqid = leap._requestSetup(pump, data)
-    local ok, response = pcall(leap._pending[reqid].wait)
+    waitfor = leap._pending[reqid]
+--  print_debug('leap.request('..tostring(pump)..', '..inspect(data)..') about to wait on '..
+--              tostring(waitfor))
+    local ok, response = pcall(waitfor.wait, waitfor)
+--  print_debug('leap.request('..tostring(pump)..', '..inspect(data)..') got '..
+--              tostring(ok)..': '..inspect(response))
     -- kill off temporary WaitForReqid object, even if error
     leap._pending[reqid] = nil
     if ok then
@@ -141,14 +150,15 @@ end
 -- common setup code shared by request() and generate()
 function leap._requestSetup(pump, data)
     -- invent a new, unique reqid
-    local reqid = leap._reqid
     leap._reqid += 1
+    local reqid = leap._reqid
     -- Instantiate a new WaitForReqid object. The priority is irrelevant
     -- because, unlike the WaitFor base class, WaitForReqid does not
     -- self-register on our leap._waitfors list. Instead, capture the new
     -- WaitForReqid object in leap._pending so _dispatch() can find it.
     leap._pending[reqid] = leap.WaitForReqid:new(reqid)
     -- Pass reqid to send() to stamp it into (a copy of) the request data.
+--  print_debug('leap._requestSetup('..tostring(pump)..', '..inspect(data)..')')
     leap.send(pump, data, reqid)
     return reqid
 end
@@ -193,16 +203,17 @@ function leap.process()
     leap._done = false
     local ok, pump, data
     while not leap._done do
+--      print_debug('leap.process() calling get_event_next()')
         ok, pump, data = pcall(get_event_next)
-        print_debug('leap.process() got', ok, pump, data)
+--      print_debug('leap.process() got '..tostring(ok)..': '..pump..', '..inspect(data))
         -- ok false means get_event_next() raised a Lua error
         -- data nil means get_event_next() returned (pump, LLSD()) to indicate done
         if not (ok and data) then
-            print_debug('leap.process() done')
             break
         end
         leap._dispatch(pump, data)
     end
+--  print_debug('leap.process() done')
     -- we're done: clean up all pending coroutines
     -- if ok, then we're just done.
     -- if not ok, then 'pump' is actually the error message.
@@ -249,7 +260,7 @@ function leap._unsolicited(pump, data)
             return
         end
     end
-    print_debug('_unsolicited(', pump, ', ', data, ') discarding unclaimed event')
+--  print_debug('_unsolicited(', pump, ', ', data, ') discarding unclaimed event')
 end
 
 -- called by WaitFor.enable()
@@ -354,9 +365,9 @@ end
 -- Block the calling coroutine until a suitable unsolicited event (one
 -- for which filter() returns the event) arrives.
 function leap.WaitFor:wait()
-    print_debug(self.name .. ' about to wait')
+--  print_debug(self.name .. ' about to wait')
     item = self._queue:Dequeue()
-    print_debug(self.name .. ' got ', item)
+--  print_debug(self.name .. ' got ', item)
     return item
 end
 
-- 
cgit v1.2.3


From a5f11a5f9eb0af70e580d15ed87c01530b13d98d Mon Sep 17 00:00:00 2001
From: Nat Goodspeed <nat@lindenlab.com>
Date: Wed, 13 Mar 2024 14:39:43 -0400
Subject: util.join() is unnecessary: luau provides table.concat().

---
 indra/newview/scripts/lua/util.lua | 30 ------------------------------
 1 file changed, 30 deletions(-)

(limited to 'indra/newview/scripts')

diff --git a/indra/newview/scripts/lua/util.lua b/indra/newview/scripts/lua/util.lua
index 898ddc58e3..e3af633ea7 100644
--- a/indra/newview/scripts/lua/util.lua
+++ b/indra/newview/scripts/lua/util.lua
@@ -36,34 +36,4 @@ function util.equal(t1, t2)
     return util.empty(temp)
 end
 
--- Concatentate the strings in the passed list, return the composite string.
--- For iterative string building, the theory is that building a list with
--- table.insert() and then using join() to allocate the full-size result
--- string once should be more efficient than reallocating an intermediate
--- string for every partial concatenation.
-function util.join(list, sep)
-    -- This succinct implementation assumes that string.format() precomputes
-    -- the required size of its output buffer before populating it. We don't
-    -- know that. Moreover, this implementation predates our sep argument.
---  return string.format(string.rep('%s', #list), table.unpack(list))
-
-    -- this implementation makes it explicit
-    local sep = sep or ''
-    local size = if util.empty(list) then 0 else -#sep
-    for _, s in pairs(list) do
-        size += #sep + #s
-    end
-    local result = buffer.create(size)
-    size = 0
-    for i, s in pairs(list) do
-        if i > 1 then
-            buffer.writestring(result, size, sep)
-            size += #sep
-        end
-        buffer.writestring(result, size, s)
-        size += #s
-    end
-    return buffer.tostring(result)
-end
-
 return util
-- 
cgit v1.2.3


From e9231a987d64d2ad7e19dee30645409cab0b48e5 Mon Sep 17 00:00:00 2001
From: Nat Goodspeed <nat@lindenlab.com>
Date: Thu, 14 Mar 2024 11:22:52 -0400
Subject: Fix a bug in leap.generate().

We weren't passing the WaitForReqid instance to WaitForReqid:wait().

Also remove 'reqid' from responses returned by leap.request() and generate().
---
 indra/newview/scripts/lua/leap.lua | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

(limited to 'indra/newview/scripts')

diff --git a/indra/newview/scripts/lua/leap.lua b/indra/newview/scripts/lua/leap.lua
index 2dd0d7b8ec..81728e7230 100644
--- a/indra/newview/scripts/lua/leap.lua
+++ b/indra/newview/scripts/lua/leap.lua
@@ -132,7 +132,7 @@ end
 -- See also send(), generate().
 function leap.request(pump, data)
     local reqid = leap._requestSetup(pump, data)
-    waitfor = leap._pending[reqid]
+    local waitfor = leap._pending[reqid]
 --  print_debug('leap.request('..tostring(pump)..', '..inspect(data)..') about to wait on '..
 --              tostring(waitfor))
     local ok, response = pcall(waitfor.wait, waitfor)
@@ -141,6 +141,7 @@ function leap.request(pump, data)
     -- kill off temporary WaitForReqid object, even if error
     leap._pending[reqid] = nil
     if ok then
+        response.reqid = nil
         return response
     else
         error(response)
@@ -178,12 +179,14 @@ function leap.generate(pump, data, checklast)
     -- bearing that reqid. Stamp the outbound request with that reqid, and
     -- send it.
     local reqid = leap._requestSetup(pump, data)
+    local waitfor = leap._pending[reqid]
     local ok, response
     repeat
-        ok, response = pcall(leap._pending[reqid].wait)
+        ok, response = pcall(waitfor.wait, waitfor)
         if not ok then
             break
         end
+        response.reqid = nil
         coroutine.yield(response)
     until checklast and checklast(response)
     -- If we break the above loop, whether or not due to error, clean up.
-- 
cgit v1.2.3


From bac113e30d987d7884c58490e6ea39a1bbd87d05 Mon Sep 17 00:00:00 2001
From: Nat Goodspeed <nat@lindenlab.com>
Date: Thu, 14 Mar 2024 11:24:51 -0400
Subject: Add preliminary Lua viewer API modules, with test scripts.

---
 indra/newview/scripts/lua/LLFloaterAbout.lua      | 11 ++++++++
 indra/newview/scripts/lua/LLGesture.lua           | 23 ++++++++++++++++
 indra/newview/scripts/lua/UI.lua                  | 16 ++++++++++++
 indra/newview/scripts/lua/test_LLFloaterAbout.lua | 14 ++++++++++
 indra/newview/scripts/lua/test_LLGesture.lua      | 32 +++++++++++++++++++++++
 5 files changed, 96 insertions(+)
 create mode 100644 indra/newview/scripts/lua/LLFloaterAbout.lua
 create mode 100644 indra/newview/scripts/lua/LLGesture.lua
 create mode 100644 indra/newview/scripts/lua/UI.lua
 create mode 100644 indra/newview/scripts/lua/test_LLFloaterAbout.lua
 create mode 100644 indra/newview/scripts/lua/test_LLGesture.lua

(limited to 'indra/newview/scripts')

diff --git a/indra/newview/scripts/lua/LLFloaterAbout.lua b/indra/newview/scripts/lua/LLFloaterAbout.lua
new file mode 100644
index 0000000000..44afee2e5c
--- /dev/null
+++ b/indra/newview/scripts/lua/LLFloaterAbout.lua
@@ -0,0 +1,11 @@
+-- Engage the LLFloaterAbout LLEventAPI
+
+leap = require 'leap'
+
+local LLFloaterAbout = {}
+
+function LLFloaterAbout.getInfo()
+    return leap.request('LLFloaterAbout', {op='getInfo'})
+end
+
+return LLFloaterAbout
diff --git a/indra/newview/scripts/lua/LLGesture.lua b/indra/newview/scripts/lua/LLGesture.lua
new file mode 100644
index 0000000000..cb410446d7
--- /dev/null
+++ b/indra/newview/scripts/lua/LLGesture.lua
@@ -0,0 +1,23 @@
+-- Engage the LLGesture LLEventAPI
+
+leap = require 'leap'
+
+local LLGesture = {}
+
+function LLGesture.getActiveGestures()
+    return leap.request('LLGesture', {op='getActiveGestures'})['gestures']
+end
+
+function LLGesture.isGesturePlaying(id)
+    return leap.request('LLGesture', {op='isGesturePlaying', id=id})['playing']
+end
+
+function LLGesture.startGesture(id)
+    leap.send('LLGesture', {op='startGesture', id=id})
+end
+
+function LLGesture.stopGesture(id)
+    leap.send('LLGesture', {op='stopGesture', id=id})
+end
+
+return LLGesture
diff --git a/indra/newview/scripts/lua/UI.lua b/indra/newview/scripts/lua/UI.lua
new file mode 100644
index 0000000000..f851632bad
--- /dev/null
+++ b/indra/newview/scripts/lua/UI.lua
@@ -0,0 +1,16 @@
+-- Engage the UI LLEventAPI
+
+leap = require 'leap'
+
+local UI = {}
+
+function UI.call(func, parameter)
+    -- 'call' is fire-and-forget
+    leap.send('UI', {op='call', ['function']=func, parameter=parameter})
+end
+
+function UI.getValue(path)
+    return leap.request('UI', {op='getValue', path=path})['value']
+end
+
+return UI
diff --git a/indra/newview/scripts/lua/test_LLFloaterAbout.lua b/indra/newview/scripts/lua/test_LLFloaterAbout.lua
new file mode 100644
index 0000000000..7abc437b79
--- /dev/null
+++ b/indra/newview/scripts/lua/test_LLFloaterAbout.lua
@@ -0,0 +1,14 @@
+-- test LLFloaterAbout
+
+LLFloaterAbout = require('LLFloaterAbout')
+leap = require('leap')
+coro = require('coro')
+inspect = require('inspect')
+
+coro.launch(function ()
+    print(inspect(LLFloaterAbout.getInfo()))
+    leap.done()
+end)
+
+leap.process()
+
diff --git a/indra/newview/scripts/lua/test_LLGesture.lua b/indra/newview/scripts/lua/test_LLGesture.lua
new file mode 100644
index 0000000000..5c0db6c063
--- /dev/null
+++ b/indra/newview/scripts/lua/test_LLGesture.lua
@@ -0,0 +1,32 @@
+-- exercise LLGesture API
+
+LLGesture = require 'LLGesture'
+inspect = require 'inspect'
+coro = require 'coro'
+leap = require 'leap'
+
+coro.launch(function()
+        -- getActiveGestures() returns {<UUID>: {name, playing, trigger}}
+        gestures_uuid = LLGesture.getActiveGestures()
+        -- convert to {<name>: <uuid>}
+        gestures = {}
+        for uuid, info in pairs(gestures_uuid) do
+            gestures[info.name] = uuid
+        end
+        -- now run through the list
+        for name, uuid in pairs(gestures) do
+            if name == 'afk' then
+                -- afk has a long timeout, and isn't interesting to look at
+                continue
+            end
+            print(name)
+            LLGesture.startGesture(uuid)
+            repeat
+                sleep(1)
+            until not LLGesture.isGesturePlaying(uuid)
+        end
+        print('Done.')
+        leap.done()
+end)
+
+leap.process()
-- 
cgit v1.2.3


From ad1f5ac8906316f8e90355a4ebdbf33400758080 Mon Sep 17 00:00:00 2001
From: Mnikolenko Productengine <mnikolenko@productengine.com>
Date: Tue, 19 Mar 2024 15:32:47 +0200
Subject: search xml file in the lib, if path is not full; add test lua floater
 scripts

---
 indra/newview/scripts/lua/luafloater_demo.xml      | 82 ++++++++++++++++++++++
 .../scripts/lua/luafloater_gesture_list.xml        | 21 ++++++
 indra/newview/scripts/lua/test_luafloater_demo.lua | 69 ++++++++++++++++++
 .../scripts/lua/test_luafloater_gesture_list.lua   | 62 ++++++++++++++++
 4 files changed, 234 insertions(+)
 create mode 100644 indra/newview/scripts/lua/luafloater_demo.xml
 create mode 100644 indra/newview/scripts/lua/luafloater_gesture_list.xml
 create mode 100644 indra/newview/scripts/lua/test_luafloater_demo.lua
 create mode 100644 indra/newview/scripts/lua/test_luafloater_gesture_list.lua

(limited to 'indra/newview/scripts')

diff --git a/indra/newview/scripts/lua/luafloater_demo.xml b/indra/newview/scripts/lua/luafloater_demo.xml
new file mode 100644
index 0000000000..069f229128
--- /dev/null
+++ b/indra/newview/scripts/lua/luafloater_demo.xml
@@ -0,0 +1,82 @@
+<?xml version="1.0" encoding="utf-8" standalone="yes" ?>
+<floater
+ legacy_header_height="18"
+ height="150"
+ layout="topleft"
+ name="lua_demo"
+ title="LUA"
+ width="320">
+    <check_box
+     height="16"
+     label="Disable button"
+     layout="topleft"
+     top_pad="35"
+     left="5"
+     name="disable_ctrl"
+     width="146" />
+    <line_editor
+     border_style="line"
+     border_thickness="1"
+     follows="left|bottom"
+     font="SansSerif"
+     height="20"
+     layout="topleft"
+     max_length_bytes="50"
+     name="openfloater_cmd"
+     top_delta="25"
+     width="100" />
+    <button
+     follows="left|bottom"
+     height="23"
+     label="Open floater"
+     layout="topleft"
+     name="open_btn"
+     top_delta="25"
+     width="100" >
+    </button>
+    <text
+     type="string"
+     follows="left|top"
+     height="10"
+     layout="topleft"
+     top="30"
+     left_delta="170"
+     name="title_lbl">
+      Select title
+    </text> 
+    <combo_box
+     follows="top|left"
+     height="23"
+     name="title_cmb"
+     top_pad="5"
+     width="100">
+        <combo_box.item
+         label="LUA"
+         value="LUA" />
+        <combo_box.item
+         label="LUA floater"
+         value="LUA floater" />
+        <combo_box.item
+         label="LUA-U title"
+         value="LUA-U title" />
+    </combo_box>
+    <text
+     type="string"
+     follows="left|bottom"
+     height="10"
+     layout="topleft"
+     top_delta="50"
+     name="show_time_lbl">
+       Double click me
+    </text>
+    <text
+     type="string"
+     follows="left|top"
+     height="10"
+     layout="topleft"
+     top_pad="15"
+     font="SansSerif"
+     text_color="white"
+     left_delta="15"
+     name="time_lbl"/>
+</floater>
diff --git a/indra/newview/scripts/lua/luafloater_gesture_list.xml b/indra/newview/scripts/lua/luafloater_gesture_list.xml
new file mode 100644
index 0000000000..a38a04eed0
--- /dev/null
+++ b/indra/newview/scripts/lua/luafloater_gesture_list.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="utf-8" standalone="yes" ?>
+<floater
+ legacy_header_height="18"
+ height="150"
+ layout="topleft"
+ name="lua_gestures"
+ title="Gestures"
+ width="320">
+    <scroll_list
+     draw_heading="false"
+     left="5"
+     width="310"
+     height="115"
+     top_pad ="25"
+     follows="all"
+     name="gesture_list">
+        <scroll_list.columns
+          name="gesture_name"
+          label="Name"/>
+    </scroll_list>
+</floater>
diff --git a/indra/newview/scripts/lua/test_luafloater_demo.lua b/indra/newview/scripts/lua/test_luafloater_demo.lua
new file mode 100644
index 0000000000..a7bbdccb30
--- /dev/null
+++ b/indra/newview/scripts/lua/test_luafloater_demo.lua
@@ -0,0 +1,69 @@
+XML_FILE_PATH = "luafloater_demo.xml"
+
+leap = require 'leap'
+coro = require 'coro'
+
+--event pump for sending actions to the floater
+COMMAND_PUMP_NAME = ""
+--table of floater UI events
+e={}
+coro.launch(function ()
+  e = leap.request("LLFloaterReg", {op="getFloaterEvents"})["events"]
+  leap.done()
+end)
+leap.process()
+
+function post(action)
+  leap.send(COMMAND_PUMP_NAME, action)
+end
+
+function getCurrentTime()
+    local currentTime = os.date("*t")
+    return string.format("%02d:%02d:%02d", currentTime.hour, currentTime.min, currentTime.sec)
+end
+
+function handleEvents(event_data)
+  if event_data.event == e.COMMIT_EVENT then
+    if event_data.ctrl_name == "disable_ctrl" then
+      post({action="set_enabled", ctrl_name="open_btn", value = (1 - event_data.value)})
+    elseif event_data.ctrl_name == "title_cmb" then
+      post({action="set_title", value= event_data.value})
+    elseif event_data.ctrl_name == "open_btn" then
+      floater_name = leap.request(COMMAND_PUMP_NAME, {action="get_value", ctrl_name='openfloater_cmd'})['value']
+      leap.send("LLFloaterReg", {name = floater_name, op = "showInstance"})
+    end
+  elseif event_data.event == e.DOUBLE_CLICK_EVENT then
+    if event_data.ctrl_name == "show_time_lbl" then
+      post({action="set_value", ctrl_name="time_lbl", value= getCurrentTime()})
+    end
+  elseif event_data.event == e.CLOSE_EVENT then
+    print_warning("Floater was closed")
+    leap.done()
+  --script received event pump name, after floater was built
+  elseif event_data.event == e.POST_BUILD_EVENT then
+    COMMAND_PUMP_NAME = event_data.command_name
+  end
+end
+
+catch_events = leap.WaitFor:new(-1, "all_events")
+function catch_events:filter(pump, data)
+  return data
+end
+
+function process_events(waitfor)
+  event_data = waitfor:wait()
+  while event_data do
+    handleEvents(event_data)
+    event_data = waitfor:wait()
+  end
+end
+
+local key = {xml_path = XML_FILE_PATH, op = "showLuaFloater"}
+
+--sign for additional events for defined control {<control_name>= {action1, action2, ...}}
+key.extra_events={show_time_lbl = {e.RIGHT_MOUSE_DOWN_EVENT, e.DOUBLE_CLICK_EVENT}}
+leap.send("LLFloaterReg", key)
+
+coro.launch(process_events, catch_events)
+leap.process()
+print_warning("End of the script")
diff --git a/indra/newview/scripts/lua/test_luafloater_gesture_list.lua b/indra/newview/scripts/lua/test_luafloater_gesture_list.lua
new file mode 100644
index 0000000000..070ff8415a
--- /dev/null
+++ b/indra/newview/scripts/lua/test_luafloater_gesture_list.lua
@@ -0,0 +1,62 @@
+XML_FILE_PATH = "luafloater_gesture_list.xml"
+
+leap = require 'leap'
+coro = require 'coro'
+LLGesture = require 'LLGesture'
+
+--event pump for sending actions to the floater
+COMMAND_PUMP_NAME = ""
+--table of floater UI events
+e={}
+coro.launch(function ()
+  e = leap.request("LLFloaterReg", {op="getFloaterEvents"})["events"]
+  leap.done()
+end)
+leap.process()
+
+function post(action)
+  leap.send(COMMAND_PUMP_NAME, action)
+end
+
+function handleEvents(event_data)
+  if event_data.event == e.CLOSE_EVENT then
+    leap.done()
+  elseif event_data.event == e.POST_BUILD_EVENT then
+    COMMAND_PUMP_NAME = event_data.command_name
+    gestures_uuid = LLGesture.getActiveGestures()
+    local action_data = {}
+    action_data.action = "add_list_element"
+    action_data.ctrl_name = "gesture_list"
+    gestures = {}
+    for uuid, info in pairs(gestures_uuid) do
+      element={value = uuid, columns ={column = "gesture_name", value = info.name}}
+      action_data.value = element
+      post(action_data)
+    end
+  elseif event_data.event == e.DOUBLE_CLICK_EVENT then
+    if event_data.ctrl_name == "gesture_list" then
+      LLGesture.startGesture(event_data.value)
+    end
+  end
+end
+
+catch_events = leap.WaitFor:new(-1, "all_events")
+function catch_events:filter(pump, data)
+  return data
+end
+
+function process_events(waitfor)
+  event_data = waitfor:wait()
+  while event_data do
+    handleEvents(event_data)
+    event_data = waitfor:wait()
+  end
+end
+
+local key = {xml_path = XML_FILE_PATH, op = "showLuaFloater"}
+--receive additional events for defined control {<control_name>= {action1, action2, ...}}
+key.extra_events={gesture_list = {e.DOUBLE_CLICK_EVENT}}
+leap.send("LLFloaterReg", key)
+
+coro.launch(process_events, catch_events)
+leap.process()
-- 
cgit v1.2.3


From ba6784647b53919c09ef339fd99af152aa0f8458 Mon Sep 17 00:00:00 2001
From: Mnikolenko Productengine <mnikolenko@productengine.com>
Date: Wed, 20 Mar 2024 23:21:48 +0200
Subject: LLLuaFloater code clean up

---
 indra/newview/scripts/lua/test_luafloater_demo.lua         | 2 +-
 indra/newview/scripts/lua/test_luafloater_gesture_list.lua | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

(limited to 'indra/newview/scripts')

diff --git a/indra/newview/scripts/lua/test_luafloater_demo.lua b/indra/newview/scripts/lua/test_luafloater_demo.lua
index a7bbdccb30..2cbafcec14 100644
--- a/indra/newview/scripts/lua/test_luafloater_demo.lua
+++ b/indra/newview/scripts/lua/test_luafloater_demo.lua
@@ -62,7 +62,7 @@ local key = {xml_path = XML_FILE_PATH, op = "showLuaFloater"}
 
 --sign for additional events for defined control {<control_name>= {action1, action2, ...}}
 key.extra_events={show_time_lbl = {e.RIGHT_MOUSE_DOWN_EVENT, e.DOUBLE_CLICK_EVENT}}
-leap.send("LLFloaterReg", key)
+leap.send("LLFloaterReg", key, "floater1")
 
 coro.launch(process_events, catch_events)
 leap.process()
diff --git a/indra/newview/scripts/lua/test_luafloater_gesture_list.lua b/indra/newview/scripts/lua/test_luafloater_gesture_list.lua
index 070ff8415a..5ea2b1e30d 100644
--- a/indra/newview/scripts/lua/test_luafloater_gesture_list.lua
+++ b/indra/newview/scripts/lua/test_luafloater_gesture_list.lua
@@ -56,7 +56,7 @@ end
 local key = {xml_path = XML_FILE_PATH, op = "showLuaFloater"}
 --receive additional events for defined control {<control_name>= {action1, action2, ...}}
 key.extra_events={gesture_list = {e.DOUBLE_CLICK_EVENT}}
-leap.send("LLFloaterReg", key)
+leap.send("LLFloaterReg", key, "floater1")
 
 coro.launch(process_events, catch_events)
 leap.process()
-- 
cgit v1.2.3


From 0566af988790e95414ed18cd82206710094d8fae Mon Sep 17 00:00:00 2001
From: Nat Goodspeed <nat@lindenlab.com>
Date: Thu, 21 Mar 2024 23:56:46 +0900
Subject: WIP: Add fiber.lua module and use in leap.lua and WaitQueue.lua.

fiber.lua goes beyond coro.lua in that it distinguishes ready suspended
coroutines from waiting suspended coroutines, and presents a rudimentary
scheduler in fiber.yield(). yield() can determine that when all coroutines are
waiting, it's time to retrieve the next incoming event from the viewer.
Moreover, it can detect when all coroutines have completed and exit without
being explicitly told.

fiber.launch() associates a name with each fiber for debugging purposes.
fiber.get_name() retrieves the name of the specified fiber, or the running fiber.
fiber.status() is like coroutine.status(), but can return 'ready' or 'waiting'
instead of 'suspended'.
fiber.yield() leaves the calling fiber ready, but lets other ready fibers run.
fiber.wait() suspends the calling fiber and lets other ready fibers run.
fiber.wake(), called from some other coroutine, returns the passed fiber to
ready status for a future call to fiber.yield().
fiber.run() drives the scheduler to run all fibers to completion.

If, on completion of the subject Lua script, LuaState::expr() detects that the
script loaded fiber.lua, it calls fiber.run() to finish running any dangling
fibers. This lets a script make calls to fiber.launch() and then just fall off
the end, leaving the implicit fiber.run() call to run them all.

fiber.lua is designed to allow the main thread, as well as explicitly launched
coroutines, to make leap.request() calls. This part still needs debugging.

The leap.lua module now configures a fiber.set_idle() function that honors
leap.done(), but calls get_event_next() and dispatches the next incoming event.

leap.request() and generate() now leave the reqid stamp in the response. This
lets a caller handle subsequent events with the same reqid, e.g. for
LLLuaFloater.

Remove leap.process(): it has been superseded by fiber.run().

Remove leap.WaitFor:iterate(): unfortunately that would run afoul of the Luau
bug that prevents suspending the calling coroutine within a generic 'for'
iterator function.

Make leap.lua use weak tables to track WaitFor objects.

Make WaitQueue:Dequeue() call fiber.wait() to suspend its caller when the queue
is empty, and Enqueue() call fiber.wake() to set it ready again when a new
item is pushed.

Make llluamanager_test.cpp's leap test script use the fiber module to launch
coroutines, instead of the coro module. Fix a bug in which its drain()
function was inadvertently setting and testing the global 'item' variable
instead of one local to the function. Since some other modules had the same
bug, it was getting confused.

Also add printf.lua, providing a printf() function. printf() is short for
print(string.format()), but it can also print tables: anything not a number or
string is formatted using the inspect() function.

Clean up some LL_DEBUGS() output left over from debugging lua_tollsd().
---
 indra/newview/scripts/lua/WaitQueue.lua |  29 ++-
 indra/newview/scripts/lua/fiber.lua     | 301 ++++++++++++++++++++++++++++++++
 indra/newview/scripts/lua/leap.lua      | 195 ++++++++++-----------
 indra/newview/scripts/lua/printf.lua    |  19 ++
 4 files changed, 428 insertions(+), 116 deletions(-)
 create mode 100644 indra/newview/scripts/lua/fiber.lua
 create mode 100644 indra/newview/scripts/lua/printf.lua

(limited to 'indra/newview/scripts')

diff --git a/indra/newview/scripts/lua/WaitQueue.lua b/indra/newview/scripts/lua/WaitQueue.lua
index 00766ccae7..b15e9c443b 100644
--- a/indra/newview/scripts/lua/WaitQueue.lua
+++ b/indra/newview/scripts/lua/WaitQueue.lua
@@ -2,8 +2,12 @@
 -- the Dequeue() operation blocks the calling coroutine until some other
 -- coroutine Enqueue()s a new value.
 
+local fiber = require('fiber')
 local Queue = require('Queue')
 
+-- local debug = print_debug
+local function debug(...) end
+
 local WaitQueue = Queue:new()
 
 function WaitQueue:new()
@@ -32,11 +36,9 @@ function WaitQueue:_wake_waiters()
     -- cases. With multiple consumers, if more than one is trying to
     -- Dequeue() from an empty WaitQueue, we'll have multiple waiters.
     -- Unlike OS threads, with cooperative concurrency it doesn't make sense
-    -- to "notify all": we need resume only one of the waiting Dequeue()
-    -- callers. But since resuming that caller might entail either Enqueue()
-    -- or Dequeue() calls, recheck every time around to see if we must resume
-    -- another waiting coroutine.
-    while not self:IsEmpty() and #self._waiters > 0 do
+    -- to "notify all": we need wake only one of the waiting Dequeue()
+    -- callers.
+    if not self:IsEmpty() and next(self._waiters) then
         -- Pop the oldest waiting coroutine instead of the most recent, for
         -- more-or-less round robin fairness. But skip any coroutines that
         -- have gone dead in the meantime.
@@ -47,11 +49,7 @@ function WaitQueue:_wake_waiters()
         -- do we still have at least one waiting coroutine?
         if waiter then
             -- don't pass the head item: let the resumed coroutine retrieve it
-            local ok, message = coroutine.resume(waiter)
-            -- if resuming that waiter encountered an error, don't swallow it
-            if not ok then
-                error(message)
-            end
+            fiber.wake(waiter)
         end
     end
 end
@@ -62,18 +60,17 @@ function WaitQueue:Dequeue()
         -- the queue while there are still items left, and we want the
         -- consumer(s) to retrieve those last few items.
         if self._closed then
+            debug('WaitQueue:Dequeue(): closed')
             return nil
         end
-        local coro = coroutine.running()
-        if coro == nil then
-            error("WaitQueue:Dequeue() trying to suspend main coroutine")
-        end
+        debug('WaitQueue:Dequeue(): waiting')
         -- add the running coroutine to the list of waiters
-        table.insert(self._waiters, coro)
+        table.insert(self._waiters, fiber.running())
         -- then let somebody else run
-        coroutine.yield()
+        fiber.wait()
     end
     -- here we're sure this queue isn't empty
+    debug('WaitQueue:Dequeue() calling Queue.Dequeue()')
     return Queue.Dequeue(self)
 end
 
diff --git a/indra/newview/scripts/lua/fiber.lua b/indra/newview/scripts/lua/fiber.lua
new file mode 100644
index 0000000000..f18d133cc8
--- /dev/null
+++ b/indra/newview/scripts/lua/fiber.lua
@@ -0,0 +1,301 @@
+-- Organize Lua coroutines into fibers.
+
+-- In this usage, the difference between coroutines and fibers is that fibers
+-- have a scheduler. Yielding a fiber means allowing other fibers, plural, to
+-- run: it's more than just returning control to the specific Lua thread that
+-- resumed the running coroutine.
+
+-- fiber.launch() creates a new fiber ready to run.
+-- fiber.status() reports (augmented) status of the passed fiber: instead of
+-- 'suspended', it returns either 'ready' or 'waiting'
+-- fiber.yield() allows other fibers to run, but leaves the calling fiber
+-- ready to run.
+-- fiber.wait() marks the running fiber not ready, and resumes other fibers.
+-- fiber.wake() marks the designated suspended fiber ready to run, but does
+-- not yet resume it.
+-- fiber.run() runs all current fibers until all have terminated (successfully
+-- or with an error).
+
+local printf = require 'printf'
+-- local debug = printf
+local function debug(...) end
+local coro = require 'coro'
+
+local fiber = {}
+
+-- The tables in which we track fibers must have weak keys so dead fibers
+-- can be garbage-collected.
+local weak_values = {__mode='v'}
+local weak_keys   = {__mode='k'}
+
+-- Track each current fiber as being either ready to run or not ready
+-- (waiting). wait() moves the running fiber from ready to waiting; wake()
+-- moves the designated fiber from waiting back to ready.
+-- The ready table is used as a list so yield() can go round robin.
+local ready   = setmetatable({'main'}, weak_keys)
+-- The waiting table is used as a set because order doesn't matter.
+local waiting = setmetatable({}, weak_keys)
+
+-- Every fiber has a name, for diagnostic purposes. Names must be unique.
+-- A colliding name will be suffixed with an integer.
+-- Predefine 'main' with our marker so nobody else claims that name.
+local names  = setmetatable({main='main'}, weak_keys)
+local byname = setmetatable({main='main'}, weak_values)
+-- each colliding name has its own distinct suffix counter
+local suffix = {}
+
+-- Specify a nullary idle() callback to be called whenever there are no ready
+-- fibers but there are waiting fibers. The idle() callback is responsible for
+-- changing zero or more waiting fibers to ready fibers by calling
+-- fiber.wake(), although a given call may leave them all still waiting.
+-- When there are no ready fibers, it's a good idea for the idle() function to
+-- return control to a higher-level execution agent. Simply returning without
+-- changing any fiber's status will spin the CPU.
+-- The idle() callback can return non-nil to exit fiber.run() with that value.
+function fiber._idle()
+    error('fiber.yield(): you must first call set_idle(nullary idle() function)')
+end
+
+function fiber.set_idle(func)
+    fiber._idle = func
+end
+
+-- Launch a new Lua fiber, ready to run.
+function fiber.launch(name, func, ...)
+    local args = table.pack(...)
+    local co = coroutine.create(function() func(table.unpack(args)) end)
+    -- a new fiber is ready to run
+    table.insert(ready, co)
+    local namekey = name
+    while byname[namekey] do
+        if not suffix[name] then
+            suffix[name] = 1
+        end
+        suffix[name] += 1
+        namekey = name .. tostring(suffix[name])
+    end
+    -- found a namekey not yet in byname: set it
+    byname[namekey] = co
+    -- and remember it as this fiber's name
+    names[co] = namekey
+--  debug('launch(%s)', namekey)
+--  debug('byname[%s] = %s', namekey, tostring(byname[namekey]))
+--  debug('names[%s] = %s', tostring(co), names[co])
+--  debug('ready[-1] = %s', tostring(ready[#ready]))
+end
+
+-- for debugging
+function fiber.print_all()
+    print('Ready fibers:' .. if next(ready) then '' else ' none')
+    for _, co in pairs(ready) do
+        printf('  %s: %s', fiber.get_name(co), fiber.status(co))
+    end
+    print('Waiting fibers:' .. if next(waiting) then '' else ' none')
+    for co in pairs(waiting) do
+        printf('  %s: %s', fiber.get_name(co), fiber.status(co))
+    end
+end
+
+-- return either the running coroutine or, if called from the main thread,
+-- 'main'
+function fiber.running()
+    return coroutine.running() or 'main'
+end
+
+-- Query a fiber's name (nil for the running fiber)
+function fiber.get_name(co)
+    if not co then
+        co = fiber.running()
+    end
+    if not names[co] then
+        return 'unknown'
+    end
+    return names[co]
+end
+
+-- Query status of the passed fiber
+function fiber.status(co)
+    local running = coroutine.running()
+    if (not co) or co == running then
+        -- silly to ask the status of the running fiber: it's 'running'
+        return 'running'
+    end
+    if co ~= 'main' then
+        -- for any coroutine but main, consult coroutine.status()
+        local status = coroutine.status(co)
+        if status ~= 'suspended' then
+            return status
+        end
+        -- here co is suspended, answer needs further refinement
+    else
+        -- co == 'main'
+        if not running then
+            -- asking about 'main' from the main fiber
+            return 'running'
+        end
+        -- asking about 'main' from some other fiber, so presumably main is suspended
+    end
+    -- here we know co is suspended -- but is it ready to run?
+    if waiting[co] then
+        return 'waiting'
+    end
+    -- not waiting should imply ready: sanity check
+    for _, maybe in pairs(ready) do
+        if maybe == co then
+            return 'ready'
+        end
+    end
+    -- Calls within yield() between popping the next ready fiber and
+    -- re-appending it to the list are in this state. Once we're done
+    -- debugging yield(), we could reinstate either of the below.
+--  error(string.format('fiber.status(%s) is stumped', fiber.get_name(co)))
+--  print(string.format('*** fiber.status(%s) is stumped', fiber.get_name(co)))
+    return '(unknown)'
+end
+
+-- change the running fiber's status to waiting
+local function set_waiting()
+    -- if called from the main fiber, inject a 'main' marker into the list
+    co = fiber.running()
+    -- delete from ready list
+    for i, maybe in pairs(ready) do
+        if maybe == co then
+            table.remove(ready, i)
+            break
+        end
+    end
+    -- add to waiting list
+    waiting[co] = true
+end
+
+-- Suspend the current fiber until some other fiber calls fiber.wake() on it
+function fiber.wait()
+    set_waiting()
+    -- now yield to other fibers
+    fiber.yield()
+end
+
+-- Mark a suspended fiber as being ready to run
+function fiber.wake(co)
+    if not waiting[co] then
+        error(string.format('fiber.wake(%s) but status=%s, ready=%s, waiting=%s',
+                            names[co], fiber.status(co), ready[co], waiting[co]))
+    end
+    -- delete from waiting list
+    waiting[co] = nil
+    -- add to end of ready list
+    table.insert(ready, co)
+    -- but don't yet resume it: that happens next time we reach yield()
+end
+
+-- Run fibers until all but main have terminated: return nil.
+-- Or until configured idle() callback returns x ~= nil: return x.
+function fiber.run()
+    -- A fiber calling run() is not also doing other useful work. Tell yield()
+    -- that we're waiting. Otherwise it would keep seeing that our caller is
+    -- ready and return to us, instead of realizing that all coroutines are
+    -- waiting and call idle().
+    set_waiting()
+    local others, idle_done
+    repeat
+        debug('%s calling fiber.run() calling yield()', fiber.get_name())
+        others, idle_done = fiber.yield()
+        debug("%s fiber.run()'s yield() returned %s, %s", fiber.get_name(),
+              tostring(others), tostring(idle_done))
+    until (not others)
+    debug('%s fiber.run() done', fiber.get_name())
+    fiber.wake(fiber.running())
+    -- Once there are no more waiting fibers, and the only ready fiber is
+    -- main, return to main. All previously-launched fibers are done. Possibly
+    -- the chunk is done, or the chunk may decide to launch a new batch of
+    -- fibers.
+    return idle_done
+end
+
+-- pop and return the next not-dead fiber in the ready list, or nil if none remain
+local function live_ready_iter()
+    -- don't write
+    -- for co in table.remove, ready, 1
+    -- because it would keep passing a new second parameter!
+    for co in function() return table.remove(ready, 1) end do
+        debug('%s live_ready_iter() sees %s, status %s',
+              fiber.get_name(), fiber.get_name(co), fiber.status(co))
+        -- keep removing the head entry until we find one that's not dead,
+        -- discarding any dead coroutines along the way
+        if co == 'main' or coroutine.status(co) ~= 'dead' then
+            debug('%s live_ready_iter() returning %s',
+                  fiber.get_name(), fiber.get_name(co))
+            return co
+        end
+    end
+    debug('%s live_ready_iter() returning nil', fiber.get_name())
+    return nil
+end
+
+-- prune the set of waiting fibers
+local function prune_waiting()
+    for waiter in pairs(waiting) do
+        if waiter ~= 'main' and coroutine.status(waiter) == 'dead' then
+            waiting[waiter] = nil
+        end
+    end
+end
+
+-- Give other ready fibers a chance to run, leaving this one ready, returning
+-- after a cycle. Returns:
+-- * true,  nil if there remain other live fibers, whether ready or waiting
+-- * false, nil if this is the only remaining fiber
+-- * nil,   x   if configured idle() callback returned non-nil x
+function fiber.yield()
+    if coroutine.running() then
+        -- seize the opportunity to make sure the viewer isn't shutting down
+--      check_stop()
+        -- this is a real coroutine, yield normally to main or whoever
+        coroutine.yield()
+        -- main certainly still exists
+        return true
+    end
+
+    -- This is the main fiber: coroutine.yield() doesn't work.
+    -- Instead, resume each of the ready fibers.
+    -- Prune the set of waiting fibers after every time fiber business logic
+    -- runs (i.e. other fibers might have terminated or hit error), such as
+    -- here on entry.
+    prune_waiting()
+    local others, idle_stop
+    repeat
+        for co in live_ready_iter do
+            -- seize the opportunity to make sure the viewer isn't shutting down
+--          check_stop()
+            -- before we re-append co, is it the only remaining entry?
+            others = next(ready)
+            -- co is live, re-append it to the ready list
+            table.insert(ready, co)
+            if co == 'main' then
+                -- Since we know the caller is the main fiber, it's our turn.
+                -- Tell caller if there are other ready or waiting fibers.
+                return others or next(waiting)
+            end
+            -- not main, but some other ready coroutine:
+            -- use coro.resume() so we'll propagate any error encountered
+            coro.resume(co)
+            prune_waiting()
+        end
+        -- Here there are no ready fibers. Are there any waiting fibers?
+        if not next(waiting) then
+            return false
+        end
+        -- there are waiting fibers: call consumer's configured idle() function
+        idle_stop = fiber._idle()
+        if idle_stop ~= nil then
+            return nil, idle_stop
+        end
+        prune_waiting()
+        -- loop "forever", that is, until:
+        -- * main is ready, or
+        -- * there are neither ready fibers nor waiting fibers, or
+        -- * fiber._idle() returned non-nil
+    until false
+end
+
+return fiber
diff --git a/indra/newview/scripts/lua/leap.lua b/indra/newview/scripts/lua/leap.lua
index 81728e7230..60e8266a76 100644
--- a/indra/newview/scripts/lua/leap.lua
+++ b/indra/newview/scripts/lua/leap.lua
@@ -38,7 +38,10 @@
 --    leap.process(). process() won't notice until the next event from the
 --    viewer, though.
 
+local fiber = require('fiber')
 local ErrorQueue = require('ErrorQueue')
+-- local debug = require('printf')
+local function debug(...) end 
 
 local leap = {}
 
@@ -68,11 +71,13 @@ leap._reply, leap._command = get_event_pumps()
 -- later one. That means that no incoming event will ever be given to
 -- the old WaitForReqid object. Any coroutine waiting on the discarded
 -- WaitForReqid object would therefore wait forever.
-leap._pending = {}
+-- these are weak values tables
+local weak_values = {__mode='v'}
+leap._pending = setmetatable({}, weak_values)
 -- Our consumer will instantiate some number of WaitFor subclass objects.
 -- As these are traversed in descending priority order, we must keep
 -- them in a list.
-leap._waitfors = {}
+leap._waitfors = setmetatable({}, weak_values)
 -- It has been suggested that we should use UUIDs as ["reqid"] values,
 -- since UUIDs are guaranteed unique. However, as the "namespace" for
 -- ["reqid"] values is our very own _reply pump, we can get away with
@@ -91,15 +96,13 @@ function leap.cmdpump()
     return leap._command
 end
 
--- local inspect = require('inspect')
-
 -- Fire and forget. Send the specified request LLSD, expecting no reply.
 -- In fact, should the request produce an eventual reply, it will be
 -- treated as an unsolicited event.
 -- 
 -- See also request(), generate().
 function leap.send(pump, data, reqid)
---  print_debug('leap.send('..pump..', '..inspect(data)..', '..reqid..') entry')
+    debug('leap.send(%s, %s, %s) entry', pump, data, reqid)
     local data = data
     if type(data) == 'table' then
         data = table.clone(data)
@@ -108,10 +111,26 @@ function leap.send(pump, data, reqid)
             data['reqid'] = reqid
         end
     end
---  print_debug('leap.send('..pump..', '..inspect(data)..') calling post_on()')
+    debug('leap.send(%s, %s) calling post_on()', pump, data)
     post_on(pump, data)
 end
 
+-- common setup code shared by request() and generate()
+local function requestSetup(pump, data)
+    -- invent a new, unique reqid
+    leap._reqid += 1
+    local reqid = leap._reqid
+    -- Instantiate a new WaitForReqid object. The priority is irrelevant
+    -- because, unlike the WaitFor base class, WaitForReqid does not
+    -- self-register on our leap._waitfors list. Instead, capture the new
+    -- WaitForReqid object in leap._pending so dispatch() can find it.
+    leap._pending[reqid] = leap.WaitForReqid:new(reqid)
+    -- Pass reqid to send() to stamp it into (a copy of) the request data.
+    debug('requestSetup(%s, %s)', pump, data)
+    leap.send(pump, data, reqid)
+    return reqid
+end
+
 -- Send the specified request LLSD, expecting exactly one reply. Block
 -- the calling coroutine until we receive that reply.
 -- 
@@ -131,39 +150,20 @@ end
 --
 -- See also send(), generate().
 function leap.request(pump, data)
-    local reqid = leap._requestSetup(pump, data)
+    local reqid = requestSetup(pump, data)
     local waitfor = leap._pending[reqid]
---  print_debug('leap.request('..tostring(pump)..', '..inspect(data)..') about to wait on '..
---              tostring(waitfor))
+    debug('leap.request(%s, %s) about to wait on %s', pump, data, tostring(waitfor))
     local ok, response = pcall(waitfor.wait, waitfor)
---  print_debug('leap.request('..tostring(pump)..', '..inspect(data)..') got '..
---              tostring(ok)..': '..inspect(response))
+    debug('leap.request(%s, %s) got %s: %s', pump, data, ok, response)
     -- kill off temporary WaitForReqid object, even if error
     leap._pending[reqid] = nil
     if ok then
-        response.reqid = nil
         return response
     else
         error(response)
     end
 end
 
--- common setup code shared by request() and generate()
-function leap._requestSetup(pump, data)
-    -- invent a new, unique reqid
-    leap._reqid += 1
-    local reqid = leap._reqid
-    -- Instantiate a new WaitForReqid object. The priority is irrelevant
-    -- because, unlike the WaitFor base class, WaitForReqid does not
-    -- self-register on our leap._waitfors list. Instead, capture the new
-    -- WaitForReqid object in leap._pending so _dispatch() can find it.
-    leap._pending[reqid] = leap.WaitForReqid:new(reqid)
-    -- Pass reqid to send() to stamp it into (a copy of) the request data.
---  print_debug('leap._requestSetup('..tostring(pump)..', '..inspect(data)..')')
-    leap.send(pump, data, reqid)
-    return reqid
-end
-
 -- Send the specified request LLSD, expecting an arbitrary number of replies.
 -- Each one is yielded on receipt. If you omit checklast, this is an infinite
 -- generator; it's up to the caller to recognize when the last reply has been
@@ -178,7 +178,7 @@ function leap.generate(pump, data, checklast)
     -- Invent a new, unique reqid. Arrange to handle incoming events
     -- bearing that reqid. Stamp the outbound request with that reqid, and
     -- send it.
-    local reqid = leap._requestSetup(pump, data)
+    local reqid = requestSetup(pump, data)
     local waitfor = leap._pending[reqid]
     local ok, response
     repeat
@@ -186,7 +186,6 @@ function leap.generate(pump, data, checklast)
         if not ok then
             break
         end
-        response.reqid = nil
         coroutine.yield(response)
     until checklast and checklast(response)
     -- If we break the above loop, whether or not due to error, clean up.
@@ -196,78 +195,79 @@ function leap.generate(pump, data, checklast)
     end
 end
 
--- Kick off response processing. The calling script must create and resume one
--- or more coroutines to perform viewer requests using send(), request() or
--- generate() before calling this function to handle responses.
---
--- While waiting for responses from the viewer, the C++ coroutine running the
--- calling Lua script is blocked: no other Lua coroutine is running.
-function leap.process()
-    leap._done = false
-    local ok, pump, data
-    while not leap._done do
---      print_debug('leap.process() calling get_event_next()')
-        ok, pump, data = pcall(get_event_next)
---      print_debug('leap.process() got '..tostring(ok)..': '..pump..', '..inspect(data))
-        -- ok false means get_event_next() raised a Lua error
-        -- data nil means get_event_next() returned (pump, LLSD()) to indicate done
-        if not (ok and data) then
-            break
-        end
-        leap._dispatch(pump, data)
-    end
---  print_debug('leap.process() done')
+local function cleanup(message)
     -- we're done: clean up all pending coroutines
-    -- if ok, then we're just done.
-    -- if not ok, then 'pump' is actually the error message.
-    message = if ok then 'done' else pump
     for i, waitfor in pairs(leap._pending) do
-        waitfor:_exception(message)
+        waitfor:exception(message)
     end
     for i, waitfor in pairs(leap._waitfors) do
-        waitfor:_exception(message)
-    end
-    -- now that we're done with cleanup, propagate the error we caught above
-    if not ok then
-        error(pump)
+        waitfor:exception(message)
     end
 end
 
-function leap.done()
-    leap._done = true
+-- Handle an incoming (pump, data) event with no recognizable ['reqid']
+local function unsolicited(pump, data)
+    -- we maintain waitfors in descending priority order, so the first waitfor
+    -- to claim this event is the one with the highest priority
+    for i, waitfor in pairs(leap._waitfors) do
+        debug('unsolicited() checking %s', waitfor.name)
+        if waitfor:handle(pump, data) then
+            return
+        end
+    end
+    print_debug(string.format('unsolicited(%s, %s) discarding unclaimed event', pump, data))
 end
 
 -- Route incoming (pump, data) event to the appropriate waiting coroutine.
-function leap._dispatch(pump, data)
+local function dispatch(pump, data)
     local reqid = data['reqid']
     -- if the response has no 'reqid', it's not from request() or generate()
     if reqid == nil then
-        return leap._unsolicited(pump, data)
+        return unsolicited(pump, data)
     end
     -- have reqid; do we have a WaitForReqid?
     local waitfor = leap._pending[reqid]
     if waitfor == nil then
-        return leap._unsolicited(pump, data)
+        return unsolicited(pump, data)
     end
     -- found the right WaitForReqid object, let it handle the event
-    data['reqid'] = nil
-    waitfor:_handle(pump, data)
+    waitfor:handle(pump, data)
 end
 
--- Handle an incoming (pump, data) event with no recognizable ['reqid']
-function leap._unsolicited(pump, data)
-    -- we maintain waitfors in descending priority order, so the first waitfor
-    -- to claim this event is the one with the highest priority
-    for i, waitfor in pairs(leap._waitfors) do
-        if waitfor:_handle(pump, data) then
-            return
-        end
+-- We configure fiber.set_idle() function. fiber.yield() calls the configured
+-- idle callback whenever there are waiting fibers but no ready fibers. In
+-- our case, that means it's time to fetch another incoming viewer event.
+fiber.set_idle(function ()
+    -- If someone has called leap.done(), then tell fiber.yield() to break loop.
+    if leap._done then
+        cleanup('done')
+        return 'done'
+    end
+    debug('leap.idle() calling get_event_next()')
+    local ok, pump, data = pcall(get_event_next)
+    debug('leap.idle() got %s: %s, %s', ok, pump, data)
+    -- ok false means get_event_next() raised a Lua error, pump is message
+    if not ok then
+        cleanup(pump)
+        error(pump)
+    end
+    -- data nil means get_event_next() returned (pump, LLSD()) to indicate done
+    if not data then
+        cleanup('end')
+        return 'end'
     end
---  print_debug('_unsolicited(', pump, ', ', data, ') discarding unclaimed event')
+    -- got a real pump, data pair 
+    dispatch(pump, data)
+    -- return to fiber.yield(): any incoming message might result in one or
+    -- more fibers becoming ready
+end)
+
+function leap.done()
+    leap._done = true
 end
 
 -- called by WaitFor.enable()
-function leap._registerWaitFor(waitfor)
+local function registerWaitFor(waitfor)
     table.insert(leap._waitfors, waitfor)
     -- keep waitfors sorted in descending order of specified priority
     table.sort(leap._waitfors,
@@ -275,7 +275,7 @@ function leap._registerWaitFor(waitfor)
 end
 
 -- called by WaitFor.disable()
-function leap._unregisterWaitFor(waitfor)
+local function unregisterWaitFor(waitfor)
     for i, w in pairs(leap._waitfors) do
         if w == waitfor then
             leap._waitfors[i] = nil
@@ -322,8 +322,13 @@ end
 -- --------------------------------- WaitFor ---------------------------------
 leap.WaitFor = { _id=0 }
 
+function leap.WaitFor.tostring(self)
+    -- Lua (sub)classes have no name; can't prefix with that
+    return self.name
+end
+
 function leap.WaitFor:new(priority, name)
-    local obj = setmetatable({}, self)
+    local obj = setmetatable({__tostring=leap.WaitFor.tostring}, self)
     self.__index = self
 
     obj.priority = priority
@@ -343,16 +348,11 @@ function leap.WaitFor:new(priority, name)
     return obj
 end
 
-function leap.WaitFor.tostring(self)
-    -- Lua (sub)classes have no name; can't prefix with that
-    return self.name
-end
-
 -- Re-enable a disable()d WaitFor object. New WaitFor objects are
 -- enable()d by default.
 function leap.WaitFor:enable()
     if not self._registered then
-        leap._registerWaitFor(self)
+        registerWaitFor(self)
         self._registered = true
     end
 end
@@ -360,7 +360,7 @@ end
 -- Disable an enable()d WaitFor object.
 function leap.WaitFor:disable()
     if self._registered then
-        leap._unregisterWaitFor(self)
+        unregisterWaitFor(self)
         self._registered = false
     end
 end
@@ -368,18 +368,12 @@ end
 -- Block the calling coroutine until a suitable unsolicited event (one
 -- for which filter() returns the event) arrives.
 function leap.WaitFor:wait()
---  print_debug(self.name .. ' about to wait')
-    item = self._queue:Dequeue()
---  print_debug(self.name .. ' got ', item)
+    debug('%s about to wait', self.name)
+    local item = self._queue:Dequeue()
+    debug('%s got %s', self.name, item)
     return item
 end
 
--- Loop over wait() calls.
-function leap.WaitFor:iterate()
-    -- on each iteration, call self.wait(self)
-    return self.wait, self, nil
-end
-
 -- Override filter() to examine the incoming event in whatever way
 -- makes sense.
 -- 
@@ -395,9 +389,10 @@ function leap.WaitFor:filter(pump, data)
     error('You must override the WaitFor.filter() method')
 end
 
--- called by leap._unsolicited() for each WaitFor in leap._waitfors
-function leap.WaitFor:_handle(pump, data)
-    item = self:filter(pump, data)
+-- called by unsolicited() for each WaitFor in leap._waitfors
+function leap.WaitFor:handle(pump, data)
+    local item = self:filter(pump, data)
+    debug('%s.filter() returned %s', self.name, item)
     -- if this item doesn't pass the filter, we're not interested
     if not item then
         return false
@@ -407,13 +402,13 @@ function leap.WaitFor:_handle(pump, data)
     return true
 end
 
--- called by WaitFor:_handle() for an accepted event
+-- called by WaitFor:handle() for an accepted event
 function leap.WaitFor:process(item)
     self._queue:Enqueue(item)
 end
 
 -- called by leap.process() when get_event_next() raises an error
-function leap.WaitFor:_exception(message)
+function leap.WaitFor:exception(message)
     print_warning(self.name .. ' error: ' .. message)
     self._queue:Error(message)
 end
diff --git a/indra/newview/scripts/lua/printf.lua b/indra/newview/scripts/lua/printf.lua
new file mode 100644
index 0000000000..584cd4f391
--- /dev/null
+++ b/indra/newview/scripts/lua/printf.lua
@@ -0,0 +1,19 @@
+-- printf(...) is short for print(string.format(...))
+
+local inspect = require 'inspect'
+
+local function printf(...)
+    -- string.format() only handles numbers and strings.
+    -- Convert anything else to string using the inspect module.
+    local args = {}
+    for _, arg in pairs(table.pack(...)) do
+        if type(arg) == 'number' or type(arg) == 'string' then
+            table.insert(args, arg)
+        else
+            table.insert(args, inspect(arg))
+        end
+    end
+    print(string.format(table.unpack(args)))
+end
+
+return printf
-- 
cgit v1.2.3


From 76752d6fc00a2789d96480da2a1e862ffecc812a Mon Sep 17 00:00:00 2001
From: Mnikolenko Productengine <mnikolenko@productengine.com>
Date: Thu, 21 Mar 2024 18:26:48 +0200
Subject: Switch to LLDispatchListener

---
 indra/newview/scripts/lua/test_luafloater_demo.lua    | 19 ++++++++++---------
 .../scripts/lua/test_luafloater_gesture_list.lua      | 14 +++++++++-----
 2 files changed, 19 insertions(+), 14 deletions(-)

(limited to 'indra/newview/scripts')

diff --git a/indra/newview/scripts/lua/test_luafloater_demo.lua b/indra/newview/scripts/lua/test_luafloater_demo.lua
index 2cbafcec14..308cebcb88 100644
--- a/indra/newview/scripts/lua/test_luafloater_demo.lua
+++ b/indra/newview/scripts/lua/test_luafloater_demo.lua
@@ -39,12 +39,19 @@ function handleEvents(event_data)
   elseif event_data.event == e.CLOSE_EVENT then
     print_warning("Floater was closed")
     leap.done()
-  --script received event pump name, after floater was built
-  elseif event_data.event == e.POST_BUILD_EVENT then
-    COMMAND_PUMP_NAME = event_data.command_name
   end
 end
 
+local key = {xml_path = XML_FILE_PATH, op = "showLuaFloater"}
+--sign for additional events for defined control {<control_name>= {action1, action2, ...}}
+key.extra_events={show_time_lbl = {e.RIGHT_MOUSE_DOWN_EVENT, e.DOUBLE_CLICK_EVENT}}
+coro.launch(function ()
+  --script received event pump name, after floater was built
+  COMMAND_PUMP_NAME = leap.request("LLFloaterReg", key)["command_name"]
+  leap.done()
+end)
+leap.process()
+
 catch_events = leap.WaitFor:new(-1, "all_events")
 function catch_events:filter(pump, data)
   return data
@@ -58,12 +65,6 @@ function process_events(waitfor)
   end
 end
 
-local key = {xml_path = XML_FILE_PATH, op = "showLuaFloater"}
-
---sign for additional events for defined control {<control_name>= {action1, action2, ...}}
-key.extra_events={show_time_lbl = {e.RIGHT_MOUSE_DOWN_EVENT, e.DOUBLE_CLICK_EVENT}}
-leap.send("LLFloaterReg", key, "floater1")
-
 coro.launch(process_events, catch_events)
 leap.process()
 print_warning("End of the script")
diff --git a/indra/newview/scripts/lua/test_luafloater_gesture_list.lua b/indra/newview/scripts/lua/test_luafloater_gesture_list.lua
index 5ea2b1e30d..57f737ce9b 100644
--- a/indra/newview/scripts/lua/test_luafloater_gesture_list.lua
+++ b/indra/newview/scripts/lua/test_luafloater_gesture_list.lua
@@ -40,6 +40,15 @@ function handleEvents(event_data)
   end
 end
 
+local key = {xml_path = XML_FILE_PATH, op = "showLuaFloater"}
+--receive additional events for defined control {<control_name>= {action1, action2, ...}}
+key.extra_events={gesture_list = {e.DOUBLE_CLICK_EVENT}}
+coro.launch(function ()
+  handleEvents(leap.request("LLFloaterReg", key))
+  leap.done()
+end)
+leap.process()
+
 catch_events = leap.WaitFor:new(-1, "all_events")
 function catch_events:filter(pump, data)
   return data
@@ -53,10 +62,5 @@ function process_events(waitfor)
   end
 end
 
-local key = {xml_path = XML_FILE_PATH, op = "showLuaFloater"}
---receive additional events for defined control {<control_name>= {action1, action2, ...}}
-key.extra_events={gesture_list = {e.DOUBLE_CLICK_EVENT}}
-leap.send("LLFloaterReg", key, "floater1")
-
 coro.launch(process_events, catch_events)
 leap.process()
-- 
cgit v1.2.3


From 4ffdae72392ba2f081edf8d740b688b95ac4fc65 Mon Sep 17 00:00:00 2001
From: Mnikolenko Productengine <mnikolenko@productengine.com>
Date: Thu, 21 Mar 2024 20:24:24 +0200
Subject: Accept an array for "add_list_item" and change EVENT_LIST type

---
 indra/newview/scripts/lua/test_luafloater_demo.lua | 20 ++++++++++++-----
 .../scripts/lua/test_luafloater_gesture_list.lua   | 26 ++++++++++++++--------
 indra/newview/scripts/lua/util.lua                 | 10 +++++++++
 3 files changed, 41 insertions(+), 15 deletions(-)

(limited to 'indra/newview/scripts')

diff --git a/indra/newview/scripts/lua/test_luafloater_demo.lua b/indra/newview/scripts/lua/test_luafloater_demo.lua
index 308cebcb88..b81259c060 100644
--- a/indra/newview/scripts/lua/test_luafloater_demo.lua
+++ b/indra/newview/scripts/lua/test_luafloater_demo.lua
@@ -2,17 +2,25 @@ XML_FILE_PATH = "luafloater_demo.xml"
 
 leap = require 'leap'
 coro = require 'coro'
+util = require 'util'
 
 --event pump for sending actions to the floater
 COMMAND_PUMP_NAME = ""
 --table of floater UI events
-e={}
+event_list={}
 coro.launch(function ()
-  e = leap.request("LLFloaterReg", {op="getFloaterEvents"})["events"]
+  event_list = leap.request("LLFloaterReg", {op="getFloaterEvents"})["events"]
   leap.done()
 end)
 leap.process()
 
+local function _event(event_name)
+  if not util.contains(event_list, event_name) then
+    print_warning("Incorrect event name: " .. event_name)
+  end
+  return event_name
+end
+
 function post(action)
   leap.send(COMMAND_PUMP_NAME, action)
 end
@@ -23,7 +31,7 @@ function getCurrentTime()
 end
 
 function handleEvents(event_data)
-  if event_data.event == e.COMMIT_EVENT then
+  if event_data.event == _event("commit") then
     if event_data.ctrl_name == "disable_ctrl" then
       post({action="set_enabled", ctrl_name="open_btn", value = (1 - event_data.value)})
     elseif event_data.ctrl_name == "title_cmb" then
@@ -32,11 +40,11 @@ function handleEvents(event_data)
       floater_name = leap.request(COMMAND_PUMP_NAME, {action="get_value", ctrl_name='openfloater_cmd'})['value']
       leap.send("LLFloaterReg", {name = floater_name, op = "showInstance"})
     end
-  elseif event_data.event == e.DOUBLE_CLICK_EVENT then
+  elseif event_data.event == _event("double_click") then
     if event_data.ctrl_name == "show_time_lbl" then
       post({action="set_value", ctrl_name="time_lbl", value= getCurrentTime()})
     end
-  elseif event_data.event == e.CLOSE_EVENT then
+  elseif event_data.event == _event("floater_close") then
     print_warning("Floater was closed")
     leap.done()
   end
@@ -44,7 +52,7 @@ end
 
 local key = {xml_path = XML_FILE_PATH, op = "showLuaFloater"}
 --sign for additional events for defined control {<control_name>= {action1, action2, ...}}
-key.extra_events={show_time_lbl = {e.RIGHT_MOUSE_DOWN_EVENT, e.DOUBLE_CLICK_EVENT}}
+key.extra_events={show_time_lbl = {_event("right_mouse_down"), _event("double_click")}}
 coro.launch(function ()
   --script received event pump name, after floater was built
   COMMAND_PUMP_NAME = leap.request("LLFloaterReg", key)["command_name"]
diff --git a/indra/newview/scripts/lua/test_luafloater_gesture_list.lua b/indra/newview/scripts/lua/test_luafloater_gesture_list.lua
index 57f737ce9b..b46e36b4d9 100644
--- a/indra/newview/scripts/lua/test_luafloater_gesture_list.lua
+++ b/indra/newview/scripts/lua/test_luafloater_gesture_list.lua
@@ -2,26 +2,34 @@ XML_FILE_PATH = "luafloater_gesture_list.xml"
 
 leap = require 'leap'
 coro = require 'coro'
+util = require 'util'
 LLGesture = require 'LLGesture'
 
 --event pump for sending actions to the floater
 COMMAND_PUMP_NAME = ""
 --table of floater UI events
-e={}
+event_list={}
 coro.launch(function ()
-  e = leap.request("LLFloaterReg", {op="getFloaterEvents"})["events"]
+  event_list = leap.request("LLFloaterReg", {op="getFloaterEvents"})["events"]
   leap.done()
 end)
 leap.process()
 
+local function _event(event_name)
+  if not util.contains(event_list, event_name) then
+    print_warning("Incorrect event name: " .. event_name)
+  end
+  return event_name
+end
+
 function post(action)
   leap.send(COMMAND_PUMP_NAME, action)
 end
 
 function handleEvents(event_data)
-  if event_data.event == e.CLOSE_EVENT then
+  if event_data.event == _event("floater_close") then
     leap.done()
-  elseif event_data.event == e.POST_BUILD_EVENT then
+  elseif event_data.event == _event("post_build") then
     COMMAND_PUMP_NAME = event_data.command_name
     gestures_uuid = LLGesture.getActiveGestures()
     local action_data = {}
@@ -29,11 +37,11 @@ function handleEvents(event_data)
     action_data.ctrl_name = "gesture_list"
     gestures = {}
     for uuid, info in pairs(gestures_uuid) do
-      element={value = uuid, columns ={column = "gesture_name", value = info.name}}
-      action_data.value = element
-      post(action_data)
+      table.insert(gestures, {value = uuid, columns ={column = "gesture_name", value = info.name}})
     end
-  elseif event_data.event == e.DOUBLE_CLICK_EVENT then
+    action_data.value = gestures
+    post(action_data)
+  elseif event_data.event == _event("double_click") then
     if event_data.ctrl_name == "gesture_list" then
       LLGesture.startGesture(event_data.value)
     end
@@ -42,7 +50,7 @@ end
 
 local key = {xml_path = XML_FILE_PATH, op = "showLuaFloater"}
 --receive additional events for defined control {<control_name>= {action1, action2, ...}}
-key.extra_events={gesture_list = {e.DOUBLE_CLICK_EVENT}}
+key.extra_events={gesture_list = {_event("double_click")}}
 coro.launch(function ()
   handleEvents(leap.request("LLFloaterReg", key))
   leap.done()
diff --git a/indra/newview/scripts/lua/util.lua b/indra/newview/scripts/lua/util.lua
index e3af633ea7..5d6042dfe5 100644
--- a/indra/newview/scripts/lua/util.lua
+++ b/indra/newview/scripts/lua/util.lua
@@ -36,4 +36,14 @@ function util.equal(t1, t2)
     return util.empty(temp)
 end
 
+-- check if array-like table contains certain value
+function util.contains(t, v)
+    for _, value in ipairs(t) do
+        if value == v then
+            return true
+        end
+    end
+    return false
+end
+
 return util
-- 
cgit v1.2.3


From bb39a8b223f78205a10ffcb61e3b3bfe05b3fd1a Mon Sep 17 00:00:00 2001
From: Nat Goodspeed <nat@lindenlab.com>
Date: Fri, 22 Mar 2024 21:04:48 +0900
Subject: Fix a couple bugs in fiber.lua machinery.

This fixes a hang if the Lua script explicitly calls fiber.run() before
LuaState::expr()'s implicit fiber.run() call.

Make fiber.run() remove the calling fiber from the ready list to avoid an
infinite loop when all other fibers have terminated: "You're ready!" "Okay,
yield()." "You're ready again!" ... But don't claim it's waiting, either,
because then when all other fibers have terminated, we'd call idle() in the
vain hope that something would make that one last fiber ready.

WaitQueue:_wake_waiters() needs to wake waiting fibers if the queue's not
empty OR it's been closed.

Introduce leap.WaitFor:close() to close the queue gracefully so that a looping
waiter can terminate, instead of using WaitFor:exception(), which stops the
whole script once it propagates. Make leap's cleanup() function call close().

Streamline fiber.get_name() by using 'or' instead of if ... then.

Streamline fiber.status() and fiber.set_waiting() by using table.find()
instead of a loop.
---
 indra/newview/scripts/lua/ErrorQueue.lua |  4 +++
 indra/newview/scripts/lua/WaitQueue.lua  |  2 +-
 indra/newview/scripts/lua/fiber.lua      | 42 +++++++++++++++-----------------
 indra/newview/scripts/lua/leap.lua       |  9 +++++--
 4 files changed, 31 insertions(+), 26 deletions(-)

(limited to 'indra/newview/scripts')

diff --git a/indra/newview/scripts/lua/ErrorQueue.lua b/indra/newview/scripts/lua/ErrorQueue.lua
index a6d4470044..076742815a 100644
--- a/indra/newview/scripts/lua/ErrorQueue.lua
+++ b/indra/newview/scripts/lua/ErrorQueue.lua
@@ -3,18 +3,22 @@
 -- raise that error.
 
 local WaitQueue = require('WaitQueue')
+-- local debug = require('printf')
+local function debug(...) end
 
 local ErrorQueue = WaitQueue:new()
 
 function ErrorQueue:Error(message)
     -- Setting Error() is a marker, like closing the queue. Once we reach the
     -- error, every subsequent Dequeue() call will raise the same error.
+    debug('Setting self._closed to %q', message)
     self._closed = message
     self:_wake_waiters()
 end
 
 function ErrorQueue:Dequeue()
     local value = WaitQueue.Dequeue(self)
+    debug('ErrorQueue:Dequeue: base Dequeue() got %s', value)
     if value ~= nil then
         -- queue not yet closed, show caller
         return value
diff --git a/indra/newview/scripts/lua/WaitQueue.lua b/indra/newview/scripts/lua/WaitQueue.lua
index b15e9c443b..f69baff09b 100644
--- a/indra/newview/scripts/lua/WaitQueue.lua
+++ b/indra/newview/scripts/lua/WaitQueue.lua
@@ -38,7 +38,7 @@ function WaitQueue:_wake_waiters()
     -- Unlike OS threads, with cooperative concurrency it doesn't make sense
     -- to "notify all": we need wake only one of the waiting Dequeue()
     -- callers.
-    if not self:IsEmpty() and next(self._waiters) then
+    if ((not self:IsEmpty()) or self._closed) and next(self._waiters) then
         -- Pop the oldest waiting coroutine instead of the most recent, for
         -- more-or-less round robin fairness. But skip any coroutines that
         -- have gone dead in the meantime.
diff --git a/indra/newview/scripts/lua/fiber.lua b/indra/newview/scripts/lua/fiber.lua
index f18d133cc8..8ed99f12b7 100644
--- a/indra/newview/scripts/lua/fiber.lua
+++ b/indra/newview/scripts/lua/fiber.lua
@@ -104,13 +104,7 @@ end
 
 -- Query a fiber's name (nil for the running fiber)
 function fiber.get_name(co)
-    if not co then
-        co = fiber.running()
-    end
-    if not names[co] then
-        return 'unknown'
-    end
-    return names[co]
+    return names[co or fiber.running()] or 'unknown'
 end
 
 -- Query status of the passed fiber
@@ -140,10 +134,8 @@ function fiber.status(co)
         return 'waiting'
     end
     -- not waiting should imply ready: sanity check
-    for _, maybe in pairs(ready) do
-        if maybe == co then
-            return 'ready'
-        end
+    if table.find(ready, co) then
+        return 'ready'
     end
     -- Calls within yield() between popping the next ready fiber and
     -- re-appending it to the list are in this state. Once we're done
@@ -158,11 +150,9 @@ local function set_waiting()
     -- if called from the main fiber, inject a 'main' marker into the list
     co = fiber.running()
     -- delete from ready list
-    for i, maybe in pairs(ready) do
-        if maybe == co then
-            table.remove(ready, i)
-            break
-        end
+    local i = table.find(ready, co)
+    if i then
+        table.remove(ready, i)
     end
     -- add to waiting list
     waiting[co] = true
@@ -191,11 +181,16 @@ end
 -- Run fibers until all but main have terminated: return nil.
 -- Or until configured idle() callback returns x ~= nil: return x.
 function fiber.run()
-    -- A fiber calling run() is not also doing other useful work. Tell yield()
-    -- that we're waiting. Otherwise it would keep seeing that our caller is
-    -- ready and return to us, instead of realizing that all coroutines are
-    -- waiting and call idle().
-    set_waiting()
+    -- A fiber calling run() is not also doing other useful work. Remove the
+    -- calling fiber from the ready list. Otherwise yield() would keep seeing
+    -- that our caller is ready and return to us, instead of realizing that
+    -- all coroutines are waiting and call idle(). But don't say we're
+    -- waiting, either, because then when all other fibers have terminated
+    -- we'd call idle() forever waiting for something to make us ready again.
+    local i = table.find(ready, fiber.running())
+    if i then
+        table.remove(ready, i)
+    end
     local others, idle_done
     repeat
         debug('%s calling fiber.run() calling yield()', fiber.get_name())
@@ -204,9 +199,10 @@ function fiber.run()
               tostring(others), tostring(idle_done))
     until (not others)
     debug('%s fiber.run() done', fiber.get_name())
-    fiber.wake(fiber.running())
+    -- For whatever it's worth, put our own fiber back in the ready list.
+    table.insert(ready, fiber.running())
     -- Once there are no more waiting fibers, and the only ready fiber is
-    -- main, return to main. All previously-launched fibers are done. Possibly
+    -- us, return to caller. All previously-launched fibers are done. Possibly
     -- the chunk is done, or the chunk may decide to launch a new batch of
     -- fibers.
     return idle_done
diff --git a/indra/newview/scripts/lua/leap.lua b/indra/newview/scripts/lua/leap.lua
index 60e8266a76..77f3a3e116 100644
--- a/indra/newview/scripts/lua/leap.lua
+++ b/indra/newview/scripts/lua/leap.lua
@@ -198,10 +198,10 @@ end
 local function cleanup(message)
     -- we're done: clean up all pending coroutines
     for i, waitfor in pairs(leap._pending) do
-        waitfor:exception(message)
+        waitfor:close()
     end
     for i, waitfor in pairs(leap._waitfors) do
-        waitfor:exception(message)
+        waitfor:close()
     end
 end
 
@@ -407,6 +407,11 @@ function leap.WaitFor:process(item)
     self._queue:Enqueue(item)
 end
 
+-- called by cleanup() at end
+function leap.WaitFor:close()
+    self._queue:close()
+end
+
 -- called by leap.process() when get_event_next() raises an error
 function leap.WaitFor:exception(message)
     print_warning(self.name .. ' error: ' .. message)
-- 
cgit v1.2.3


From 2dc003779443db99f46b3db6d17a1954f7b141dd Mon Sep 17 00:00:00 2001
From: Nat Goodspeed <nat@lindenlab.com>
Date: Sat, 23 Mar 2024 17:43:07 +0900
Subject: Make leap.request() work even from Lua's main thread.

Recast fiber.yield() as internal function scheduler().
Move fiber.run() after it so it can call scheduler() as a local function.

Add new fiber.yield() that also calls scheduler(); the added value of this new
fiber.yield() over plain scheduler() is that if scheduler() returns before the
caller is ready (because the configured set_idle() function returned non-nil),
it produces an explicit error rather than returning to its caller. So the
caller can assume that when fiber.yield() returns normally, the calling fiber
is ready.

This allows any fiber, including the main thread, to call fiber.yield() or
fiber.wait(). This supports using leap.request(), which posts a request and
then waits on a WaitForReqid, which calls ErrorQueue:Dequeue(), which calls
fiber.wait().

WaitQueue:_wake_waiters() must call fiber.status() instead of
coroutine.status() so it understands the special token 'main'.

Add a new llluamanager_test.cpp test to exercise calling leap.request() from
Lua's main thread.
---
 indra/newview/scripts/lua/WaitQueue.lua |   2 +-
 indra/newview/scripts/lua/fiber.lua     | 106 +++++++++++++++++++++-----------
 2 files changed, 71 insertions(+), 37 deletions(-)

(limited to 'indra/newview/scripts')

diff --git a/indra/newview/scripts/lua/WaitQueue.lua b/indra/newview/scripts/lua/WaitQueue.lua
index f69baff09b..a34dbef4d7 100644
--- a/indra/newview/scripts/lua/WaitQueue.lua
+++ b/indra/newview/scripts/lua/WaitQueue.lua
@@ -43,7 +43,7 @@ function WaitQueue:_wake_waiters()
         -- more-or-less round robin fairness. But skip any coroutines that
         -- have gone dead in the meantime.
         local waiter = table.remove(self._waiters, 1)
-        while waiter and coroutine.status(waiter) ~= "suspended" do
+        while waiter and fiber.status(waiter) == "dead" do
             waiter = table.remove(self._waiters, 1)
         end
         -- do we still have at least one waiting coroutine?
diff --git a/indra/newview/scripts/lua/fiber.lua b/indra/newview/scripts/lua/fiber.lua
index 8ed99f12b7..7dc67f510c 100644
--- a/indra/newview/scripts/lua/fiber.lua
+++ b/indra/newview/scripts/lua/fiber.lua
@@ -178,36 +178,6 @@ function fiber.wake(co)
     -- but don't yet resume it: that happens next time we reach yield()
 end
 
--- Run fibers until all but main have terminated: return nil.
--- Or until configured idle() callback returns x ~= nil: return x.
-function fiber.run()
-    -- A fiber calling run() is not also doing other useful work. Remove the
-    -- calling fiber from the ready list. Otherwise yield() would keep seeing
-    -- that our caller is ready and return to us, instead of realizing that
-    -- all coroutines are waiting and call idle(). But don't say we're
-    -- waiting, either, because then when all other fibers have terminated
-    -- we'd call idle() forever waiting for something to make us ready again.
-    local i = table.find(ready, fiber.running())
-    if i then
-        table.remove(ready, i)
-    end
-    local others, idle_done
-    repeat
-        debug('%s calling fiber.run() calling yield()', fiber.get_name())
-        others, idle_done = fiber.yield()
-        debug("%s fiber.run()'s yield() returned %s, %s", fiber.get_name(),
-              tostring(others), tostring(idle_done))
-    until (not others)
-    debug('%s fiber.run() done', fiber.get_name())
-    -- For whatever it's worth, put our own fiber back in the ready list.
-    table.insert(ready, fiber.running())
-    -- Once there are no more waiting fibers, and the only ready fiber is
-    -- us, return to caller. All previously-launched fibers are done. Possibly
-    -- the chunk is done, or the chunk may decide to launch a new batch of
-    -- fibers.
-    return idle_done
-end
-
 -- pop and return the next not-dead fiber in the ready list, or nil if none remain
 local function live_ready_iter()
     -- don't write
@@ -237,16 +207,24 @@ local function prune_waiting()
     end
 end
 
--- Give other ready fibers a chance to run, leaving this one ready, returning
--- after a cycle. Returns:
--- * true,  nil if there remain other live fibers, whether ready or waiting
+-- Run other ready fibers, leaving this one ready, returning after a cycle.
+-- Returns:
+-- * true, nil if there remain other live fibers, whether ready or waiting,
+--   but it's our turn to run
 -- * false, nil if this is the only remaining fiber
--- * nil,   x   if configured idle() callback returned non-nil x
-function fiber.yield()
+-- * nil,   x   if configured idle() callback returns non-nil x
+local function scheduler()
+    -- scheduler() is asymmetric because Lua distinguishes the main thread
+    -- from other coroutines. The main thread can't yield; it can only resume
+    -- other coroutines. So although an arbitrary coroutine could resume still
+    -- other arbitrary coroutines, it could NOT resume the main thread because
+    -- the main thread can't yield. Therefore, scheduler() delegates its real
+    -- processing to the main thread. If called from a coroutine, pass control
+    -- back to the main thread.
     if coroutine.running() then
         -- seize the opportunity to make sure the viewer isn't shutting down
 --      check_stop()
-        -- this is a real coroutine, yield normally to main or whoever
+        -- this is a real coroutine, yield normally to main thread
         coroutine.yield()
         -- main certainly still exists
         return true
@@ -294,4 +272,60 @@ function fiber.yield()
     until false
 end
 
+-- Let other fibers run. This is useful in either of two cases:
+-- * fiber.wait() calls this to run other fibers while this one is waiting.
+--   fiber.yield() (and therefore fiber.wait()) works from the main thread as
+--   well as from explicitly-launched fibers, without the caller having to
+--   care.
+-- * A long-running fiber that doesn't often call fiber.wait() should sprinkle
+--   in fiber.yield() calls to interleave processing on other fibers.
+function fiber.yield()
+    -- The difference between this and fiber.run() is that fiber.yield()
+    -- assumes its caller has work to do. yield() returns to its caller as
+    -- soon as scheduler() pops this fiber from the ready list. fiber.run()
+    -- continues looping until all other fibers have terminated, or the
+    -- set_idle() callback tells it to stop.
+    local others, idle_done = scheduler()
+    -- scheduler() returns either if we're ready, or if idle_done ~= nil.
+    if idle_done ~= nil then
+        -- Returning normally from yield() means the caller can carry on with
+        -- its pending work. But in this case scheduler() returned because the
+        -- configured set_idle() function interrupted it -- not because we're
+        -- actually ready. Don't return normally.
+        error('fiber.set_idle() interrupted yield() with: ' .. tostring(idle_done))
+    end
+    -- We're ready! Just return to caller. In this situation we don't care
+    -- whether there are other ready fibers.
+end
+
+-- Run fibers until all but main have terminated: return nil.
+-- Or until configured idle() callback returns x ~= nil: return x.
+function fiber.run()
+    -- A fiber calling run() is not also doing other useful work. Remove the
+    -- calling fiber from the ready list. Otherwise yield() would keep seeing
+    -- that our caller is ready and return to us, instead of realizing that
+    -- all coroutines are waiting and call idle(). But don't say we're
+    -- waiting, either, because then when all other fibers have terminated
+    -- we'd call idle() forever waiting for something to make us ready again.
+    local i = table.find(ready, fiber.running())
+    if i then
+        table.remove(ready, i)
+    end
+    local others, idle_done
+    repeat
+        debug('%s calling fiber.run() calling scheduler()', fiber.get_name())
+        others, idle_done = scheduler()
+        debug("%s fiber.run()'s scheduler() returned %s, %s", fiber.get_name(),
+              tostring(others), tostring(idle_done))
+    until (not others)
+    debug('%s fiber.run() done', fiber.get_name())
+    -- For whatever it's worth, put our own fiber back in the ready list.
+    table.insert(ready, fiber.running())
+    -- Once there are no more waiting fibers, and the only ready fiber is
+    -- us, return to caller. All previously-launched fibers are done. Possibly
+    -- the chunk is done, or the chunk may decide to launch a new batch of
+    -- fibers.
+    return idle_done
+end
+
 return fiber
-- 
cgit v1.2.3


From 41e14d35ae2dfa644716cb195545d59c468538c5 Mon Sep 17 00:00:00 2001
From: Mnikolenko Productengine <mnikolenko@productengine.com>
Date: Mon, 25 Mar 2024 15:06:11 +0200
Subject: Add keystroke event support and allow adding text lines to the line
 editor

---
 indra/newview/scripts/lua/luafloater_demo.xml              | 13 ++++++++++++-
 indra/newview/scripts/lua/test_luafloater_demo.lua         |  4 ++--
 indra/newview/scripts/lua/test_luafloater_gesture_list.lua |  3 +--
 indra/newview/scripts/lua/util.lua                         | 10 ----------
 4 files changed, 15 insertions(+), 15 deletions(-)

(limited to 'indra/newview/scripts')

diff --git a/indra/newview/scripts/lua/luafloater_demo.xml b/indra/newview/scripts/lua/luafloater_demo.xml
index 069f229128..b2273d7718 100644
--- a/indra/newview/scripts/lua/luafloater_demo.xml
+++ b/indra/newview/scripts/lua/luafloater_demo.xml
@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="utf-8" standalone="yes" ?>
 <floater
  legacy_header_height="18"
- height="150"
+ height="300"
  layout="topleft"
  name="lua_demo"
  title="LUA"
@@ -79,4 +79,15 @@
      text_color="white"
      left_delta="15"
      name="time_lbl"/>
+    <text_editor
+     follows="top|left"
+     font="SansSerif"
+     height="140"
+     left="5"
+     enabled="false"
+     name="events_editor"
+     top_pad="15"
+     word_wrap="true"
+     max_length="65536"
+     width="310"/>
 </floater>
diff --git a/indra/newview/scripts/lua/test_luafloater_demo.lua b/indra/newview/scripts/lua/test_luafloater_demo.lua
index b81259c060..22ed7d7b3a 100644
--- a/indra/newview/scripts/lua/test_luafloater_demo.lua
+++ b/indra/newview/scripts/lua/test_luafloater_demo.lua
@@ -2,7 +2,6 @@ XML_FILE_PATH = "luafloater_demo.xml"
 
 leap = require 'leap'
 coro = require 'coro'
-util = require 'util'
 
 --event pump for sending actions to the floater
 COMMAND_PUMP_NAME = ""
@@ -15,7 +14,7 @@ end)
 leap.process()
 
 local function _event(event_name)
-  if not util.contains(event_list, event_name) then
+  if not table.find(event_list, event_name) then
     print_warning("Incorrect event name: " .. event_name)
   end
   return event_name
@@ -31,6 +30,7 @@ function getCurrentTime()
 end
 
 function handleEvents(event_data)
+  post({action="add_text", ctrl_name="events_editor", value = event_data})
   if event_data.event == _event("commit") then
     if event_data.ctrl_name == "disable_ctrl" then
       post({action="set_enabled", ctrl_name="open_btn", value = (1 - event_data.value)})
diff --git a/indra/newview/scripts/lua/test_luafloater_gesture_list.lua b/indra/newview/scripts/lua/test_luafloater_gesture_list.lua
index b46e36b4d9..b1ff129d85 100644
--- a/indra/newview/scripts/lua/test_luafloater_gesture_list.lua
+++ b/indra/newview/scripts/lua/test_luafloater_gesture_list.lua
@@ -2,7 +2,6 @@ XML_FILE_PATH = "luafloater_gesture_list.xml"
 
 leap = require 'leap'
 coro = require 'coro'
-util = require 'util'
 LLGesture = require 'LLGesture'
 
 --event pump for sending actions to the floater
@@ -16,7 +15,7 @@ end)
 leap.process()
 
 local function _event(event_name)
-  if not util.contains(event_list, event_name) then
+  if not table.find(event_list, event_name) then
     print_warning("Incorrect event name: " .. event_name)
   end
   return event_name
diff --git a/indra/newview/scripts/lua/util.lua b/indra/newview/scripts/lua/util.lua
index 5d6042dfe5..e3af633ea7 100644
--- a/indra/newview/scripts/lua/util.lua
+++ b/indra/newview/scripts/lua/util.lua
@@ -36,14 +36,4 @@ function util.equal(t1, t2)
     return util.empty(temp)
 end
 
--- check if array-like table contains certain value
-function util.contains(t, v)
-    for _, value in ipairs(t) do
-        if value == v then
-            return true
-        end
-    end
-    return false
-end
-
 return util
-- 
cgit v1.2.3


From 6cedaecad9c4830aa29068b90611b8b9da301ac9 Mon Sep 17 00:00:00 2001
From: Mnikolenko Productengine <mnikolenko@productengine.com>
Date: Mon, 25 Mar 2024 20:41:33 +0200
Subject: Update test scripts to call leap.request() from main thread

---
 indra/newview/scripts/lua/test_luafloater_demo.lua       | 16 ++--------------
 .../newview/scripts/lua/test_luafloater_gesture_list.lua | 14 ++------------
 2 files changed, 4 insertions(+), 26 deletions(-)

(limited to 'indra/newview/scripts')

diff --git a/indra/newview/scripts/lua/test_luafloater_demo.lua b/indra/newview/scripts/lua/test_luafloater_demo.lua
index 22ed7d7b3a..f2cf34206e 100644
--- a/indra/newview/scripts/lua/test_luafloater_demo.lua
+++ b/indra/newview/scripts/lua/test_luafloater_demo.lua
@@ -6,12 +6,7 @@ coro = require 'coro'
 --event pump for sending actions to the floater
 COMMAND_PUMP_NAME = ""
 --table of floater UI events
-event_list={}
-coro.launch(function ()
-  event_list = leap.request("LLFloaterReg", {op="getFloaterEvents"})["events"]
-  leap.done()
-end)
-leap.process()
+event_list=leap.request("LLFloaterReg", {op="getFloaterEvents"}).events
 
 local function _event(event_name)
   if not table.find(event_list, event_name) then
@@ -53,12 +48,7 @@ end
 local key = {xml_path = XML_FILE_PATH, op = "showLuaFloater"}
 --sign for additional events for defined control {<control_name>= {action1, action2, ...}}
 key.extra_events={show_time_lbl = {_event("right_mouse_down"), _event("double_click")}}
-coro.launch(function ()
-  --script received event pump name, after floater was built
-  COMMAND_PUMP_NAME = leap.request("LLFloaterReg", key)["command_name"]
-  leap.done()
-end)
-leap.process()
+COMMAND_PUMP_NAME = leap.request("LLFloaterReg", key).command_name
 
 catch_events = leap.WaitFor:new(-1, "all_events")
 function catch_events:filter(pump, data)
@@ -74,5 +64,3 @@ function process_events(waitfor)
 end
 
 coro.launch(process_events, catch_events)
-leap.process()
-print_warning("End of the script")
diff --git a/indra/newview/scripts/lua/test_luafloater_gesture_list.lua b/indra/newview/scripts/lua/test_luafloater_gesture_list.lua
index b1ff129d85..049ba757d3 100644
--- a/indra/newview/scripts/lua/test_luafloater_gesture_list.lua
+++ b/indra/newview/scripts/lua/test_luafloater_gesture_list.lua
@@ -7,12 +7,7 @@ LLGesture = require 'LLGesture'
 --event pump for sending actions to the floater
 COMMAND_PUMP_NAME = ""
 --table of floater UI events
-event_list={}
-coro.launch(function ()
-  event_list = leap.request("LLFloaterReg", {op="getFloaterEvents"})["events"]
-  leap.done()
-end)
-leap.process()
+event_list=leap.request("LLFloaterReg", {op="getFloaterEvents"}).events
 
 local function _event(event_name)
   if not table.find(event_list, event_name) then
@@ -50,11 +45,7 @@ end
 local key = {xml_path = XML_FILE_PATH, op = "showLuaFloater"}
 --receive additional events for defined control {<control_name>= {action1, action2, ...}}
 key.extra_events={gesture_list = {_event("double_click")}}
-coro.launch(function ()
-  handleEvents(leap.request("LLFloaterReg", key))
-  leap.done()
-end)
-leap.process()
+handleEvents(leap.request("LLFloaterReg", key))
 
 catch_events = leap.WaitFor:new(-1, "all_events")
 function catch_events:filter(pump, data)
@@ -70,4 +61,3 @@ function process_events(waitfor)
 end
 
 coro.launch(process_events, catch_events)
-leap.process()
-- 
cgit v1.2.3


From ac4fa418e3a7402f9d9122c726d2fbfc4b8767b2 Mon Sep 17 00:00:00 2001
From: Nat Goodspeed <nat@lindenlab.com>
Date: Mon, 25 Mar 2024 16:29:17 -0400
Subject: Add LL. prefix to viewer entry points, fix existing references.

---
 indra/newview/scripts/lua/WaitQueue.lua                    |  2 +-
 indra/newview/scripts/lua/leap.lua                         | 10 +++++-----
 indra/newview/scripts/lua/test_LLGesture.lua               |  2 +-
 indra/newview/scripts/lua/test_luafloater_demo.lua         |  6 +++---
 indra/newview/scripts/lua/test_luafloater_gesture_list.lua |  2 +-
 5 files changed, 11 insertions(+), 11 deletions(-)

(limited to 'indra/newview/scripts')

diff --git a/indra/newview/scripts/lua/WaitQueue.lua b/indra/newview/scripts/lua/WaitQueue.lua
index a34dbef4d7..1fbcc50847 100644
--- a/indra/newview/scripts/lua/WaitQueue.lua
+++ b/indra/newview/scripts/lua/WaitQueue.lua
@@ -5,7 +5,7 @@
 local fiber = require('fiber')
 local Queue = require('Queue')
 
--- local debug = print_debug
+-- local debug = LL.print_debug
 local function debug(...) end
 
 local WaitQueue = Queue:new()
diff --git a/indra/newview/scripts/lua/leap.lua b/indra/newview/scripts/lua/leap.lua
index 77f3a3e116..a60819d493 100644
--- a/indra/newview/scripts/lua/leap.lua
+++ b/indra/newview/scripts/lua/leap.lua
@@ -51,7 +51,7 @@ local leap = {}
 -- _command: string name of command LLEventPump. post_to(_command, ...)
 -- engages LLLeapListener operations such as listening on a specified other
 -- LLEventPump, etc.
-leap._reply, leap._command = get_event_pumps()
+leap._reply, leap._command = LL.get_event_pumps()
 -- Dict of features added to the LEAP protocol since baseline implementation.
 -- Before engaging a new feature that might break an older viewer, we can
 -- check for the presence of that feature key. This table is solely about the
@@ -112,7 +112,7 @@ function leap.send(pump, data, reqid)
         end
     end
     debug('leap.send(%s, %s) calling post_on()', pump, data)
-    post_on(pump, data)
+    LL.post_on(pump, data)
 end
 
 -- common setup code shared by request() and generate()
@@ -215,7 +215,7 @@ local function unsolicited(pump, data)
             return
         end
     end
-    print_debug(string.format('unsolicited(%s, %s) discarding unclaimed event', pump, data))
+    LL.print_debug(string.format('unsolicited(%s, %s) discarding unclaimed event', pump, data))
 end
 
 -- Route incoming (pump, data) event to the appropriate waiting coroutine.
@@ -244,7 +244,7 @@ fiber.set_idle(function ()
         return 'done'
     end
     debug('leap.idle() calling get_event_next()')
-    local ok, pump, data = pcall(get_event_next)
+    local ok, pump, data = pcall(LL.get_event_next)
     debug('leap.idle() got %s: %s, %s', ok, pump, data)
     -- ok false means get_event_next() raised a Lua error, pump is message
     if not ok then
@@ -414,7 +414,7 @@ end
 
 -- called by leap.process() when get_event_next() raises an error
 function leap.WaitFor:exception(message)
-    print_warning(self.name .. ' error: ' .. message)
+    LL.print_warning(self.name .. ' error: ' .. message)
     self._queue:Error(message)
 end
 
diff --git a/indra/newview/scripts/lua/test_LLGesture.lua b/indra/newview/scripts/lua/test_LLGesture.lua
index 5c0db6c063..5897a0e3cb 100644
--- a/indra/newview/scripts/lua/test_LLGesture.lua
+++ b/indra/newview/scripts/lua/test_LLGesture.lua
@@ -22,7 +22,7 @@ coro.launch(function()
             print(name)
             LLGesture.startGesture(uuid)
             repeat
-                sleep(1)
+                LL.sleep(1)
             until not LLGesture.isGesturePlaying(uuid)
         end
         print('Done.')
diff --git a/indra/newview/scripts/lua/test_luafloater_demo.lua b/indra/newview/scripts/lua/test_luafloater_demo.lua
index b81259c060..4e071e4abe 100644
--- a/indra/newview/scripts/lua/test_luafloater_demo.lua
+++ b/indra/newview/scripts/lua/test_luafloater_demo.lua
@@ -16,7 +16,7 @@ leap.process()
 
 local function _event(event_name)
   if not util.contains(event_list, event_name) then
-    print_warning("Incorrect event name: " .. event_name)
+    LL.print_warning("Incorrect event name: " .. event_name)
   end
   return event_name
 end
@@ -45,7 +45,7 @@ function handleEvents(event_data)
       post({action="set_value", ctrl_name="time_lbl", value= getCurrentTime()})
     end
   elseif event_data.event == _event("floater_close") then
-    print_warning("Floater was closed")
+    LL.print_warning("Floater was closed")
     leap.done()
   end
 end
@@ -75,4 +75,4 @@ end
 
 coro.launch(process_events, catch_events)
 leap.process()
-print_warning("End of the script")
+LL.print_warning("End of the script")
diff --git a/indra/newview/scripts/lua/test_luafloater_gesture_list.lua b/indra/newview/scripts/lua/test_luafloater_gesture_list.lua
index b46e36b4d9..9c718c353b 100644
--- a/indra/newview/scripts/lua/test_luafloater_gesture_list.lua
+++ b/indra/newview/scripts/lua/test_luafloater_gesture_list.lua
@@ -17,7 +17,7 @@ leap.process()
 
 local function _event(event_name)
   if not util.contains(event_list, event_name) then
-    print_warning("Incorrect event name: " .. event_name)
+    LL.print_warning("Incorrect event name: " .. event_name)
   end
   return event_name
 end
-- 
cgit v1.2.3


From 98e6356aed0c757f16267cc2ae921f9c90a249fe Mon Sep 17 00:00:00 2001
From: Nat Goodspeed <nat@lindenlab.com>
Date: Mon, 25 Mar 2024 16:57:28 -0400
Subject: Add LL.check_stop() entry point and call it in fiber scheduler().

fiber.lua's scheduler() is greedy, in the sense that it wants to run every
ready Lua fiber before retrieving the next incoming event from the viewer (and
possibly blocking for some real time before it becomes available). But check
for viewer shutdown before resuming any suspended-but-ready Lua fiber.
---
 indra/newview/scripts/lua/fiber.lua | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

(limited to 'indra/newview/scripts')

diff --git a/indra/newview/scripts/lua/fiber.lua b/indra/newview/scripts/lua/fiber.lua
index 7dc67f510c..aebf27357f 100644
--- a/indra/newview/scripts/lua/fiber.lua
+++ b/indra/newview/scripts/lua/fiber.lua
@@ -222,8 +222,6 @@ local function scheduler()
     -- processing to the main thread. If called from a coroutine, pass control
     -- back to the main thread.
     if coroutine.running() then
-        -- seize the opportunity to make sure the viewer isn't shutting down
---      check_stop()
         -- this is a real coroutine, yield normally to main thread
         coroutine.yield()
         -- main certainly still exists
@@ -240,7 +238,7 @@ local function scheduler()
     repeat
         for co in live_ready_iter do
             -- seize the opportunity to make sure the viewer isn't shutting down
---          check_stop()
+            LL.check_stop()
             -- before we re-append co, is it the only remaining entry?
             others = next(ready)
             -- co is live, re-append it to the ready list
-- 
cgit v1.2.3


From 5b04ae7812e6cb0d0c9895aec6db6a206d4e09e8 Mon Sep 17 00:00:00 2001
From: Nat Goodspeed <nat@lindenlab.com>
Date: Mon, 25 Mar 2024 17:35:28 -0400
Subject: util.lua claims functions are in alpha order - make it so.

Also streamline util.contains(), given table.find().
---
 indra/newview/scripts/lua/util.lua | 21 ++++++++-------------
 1 file changed, 8 insertions(+), 13 deletions(-)

(limited to 'indra/newview/scripts')

diff --git a/indra/newview/scripts/lua/util.lua b/indra/newview/scripts/lua/util.lua
index 5d6042dfe5..a2191288f6 100644
--- a/indra/newview/scripts/lua/util.lua
+++ b/indra/newview/scripts/lua/util.lua
@@ -2,9 +2,9 @@
 
 local util = {}
 
--- cheap test whether table t is empty
-function util.empty(t)
-    return not next(t)
+-- check if array-like table contains certain value
+function util.contains(t, v)
+    return table.find(t, v) ~= nil
 end
 
 -- reliable count of the number of entries in table t
@@ -17,6 +17,11 @@ function util.count(t)
     return count
 end
 
+-- cheap test whether table t is empty
+function util.empty(t)
+    return not next(t)
+end
+
 -- recursive table equality
 function util.equal(t1, t2)
     if not (type(t1) == 'table' and type(t2) == 'table') then
@@ -36,14 +41,4 @@ function util.equal(t1, t2)
     return util.empty(temp)
 end
 
--- check if array-like table contains certain value
-function util.contains(t, v)
-    for _, value in ipairs(t) do
-        if value == v then
-            return true
-        end
-    end
-    return false
-end
-
 return util
-- 
cgit v1.2.3


From 24a7842b9b08dc5cfb89fe36e5ebcd9c2598fa44 Mon Sep 17 00:00:00 2001
From: Mnikolenko Productengine <mnikolenko@productengine.com>
Date: Tue, 26 Mar 2024 19:12:13 +0200
Subject: update scripts to use fiber.launch()

---
 indra/newview/scripts/lua/test_luafloater_demo.lua         | 3 ++-
 indra/newview/scripts/lua/test_luafloater_gesture_list.lua | 3 ++-
 2 files changed, 4 insertions(+), 2 deletions(-)

(limited to 'indra/newview/scripts')

diff --git a/indra/newview/scripts/lua/test_luafloater_demo.lua b/indra/newview/scripts/lua/test_luafloater_demo.lua
index f2cf34206e..be189bc146 100644
--- a/indra/newview/scripts/lua/test_luafloater_demo.lua
+++ b/indra/newview/scripts/lua/test_luafloater_demo.lua
@@ -2,6 +2,7 @@ XML_FILE_PATH = "luafloater_demo.xml"
 
 leap = require 'leap'
 coro = require 'coro'
+fiber = require 'fiber'
 
 --event pump for sending actions to the floater
 COMMAND_PUMP_NAME = ""
@@ -63,4 +64,4 @@ function process_events(waitfor)
   end
 end
 
-coro.launch(process_events, catch_events)
+fiber.launch("catch_events", process_events, catch_events)
diff --git a/indra/newview/scripts/lua/test_luafloater_gesture_list.lua b/indra/newview/scripts/lua/test_luafloater_gesture_list.lua
index 049ba757d3..7e2139468f 100644
--- a/indra/newview/scripts/lua/test_luafloater_gesture_list.lua
+++ b/indra/newview/scripts/lua/test_luafloater_gesture_list.lua
@@ -2,6 +2,7 @@ XML_FILE_PATH = "luafloater_gesture_list.xml"
 
 leap = require 'leap'
 coro = require 'coro'
+fiber = require 'fiber'
 LLGesture = require 'LLGesture'
 
 --event pump for sending actions to the floater
@@ -60,4 +61,4 @@ function process_events(waitfor)
   end
 end
 
-coro.launch(process_events, catch_events)
+fiber.launch("catch_events", process_events, catch_events)
-- 
cgit v1.2.3


From 58d5e288e0bfaa9819b68b376767a8a39a97fef8 Mon Sep 17 00:00:00 2001
From: Nat Goodspeed <nat@lindenlab.com>
Date: Wed, 27 Mar 2024 16:20:36 -0400
Subject: poetry

---
 indra/newview/scripts/lua/Queue.lua | 6 ++++++
 1 file changed, 6 insertions(+)

(limited to 'indra/newview/scripts')

diff --git a/indra/newview/scripts/lua/Queue.lua b/indra/newview/scripts/lua/Queue.lua
index b0a5a87f87..5ab2a8a72c 100644
--- a/indra/newview/scripts/lua/Queue.lua
+++ b/indra/newview/scripts/lua/Queue.lua
@@ -1,6 +1,12 @@
 -- from https://create.roblox.com/docs/luau/queues#implementing-queues,
 -- amended per https://www.lua.org/pil/16.1.html
 
+-- While coding some scripting in Lua
+-- I found that I needed a queua
+-- I thought of linked list
+-- But had to resist
+-- For fear it might be too obscua. 
+
 local Queue = {}
 
 function Queue:new()
-- 
cgit v1.2.3


From af38e606865c2ed49a13bd6bd91d9604997798c8 Mon Sep 17 00:00:00 2001
From: Nat Goodspeed <nat@lindenlab.com>
Date: Wed, 27 Mar 2024 16:38:45 -0400
Subject: Enhance Lua debugging output.

Don't use "debug" as the name of a function to conditionally write debug
messages: "debug" is a Luau built-in library, and assigning that name locally
would shadow the builtin. Use "dbg" instead.

Recast fiber.print_all() as fiber.format_all() that returns a string; then
print_all() is simply print(format_all()). This refactoring allows us to use
dbg(format_all()) as well.

Add a couple new dbg() messages at fiber state changes.
---
 indra/newview/scripts/lua/ErrorQueue.lua |  8 +++---
 indra/newview/scripts/lua/WaitQueue.lua  | 11 ++++----
 indra/newview/scripts/lua/fiber.lua      | 45 +++++++++++++++++++-------------
 indra/newview/scripts/lua/leap.lua       | 26 +++++++++---------
 4 files changed, 50 insertions(+), 40 deletions(-)

(limited to 'indra/newview/scripts')

diff --git a/indra/newview/scripts/lua/ErrorQueue.lua b/indra/newview/scripts/lua/ErrorQueue.lua
index 076742815a..6ed1c10d5c 100644
--- a/indra/newview/scripts/lua/ErrorQueue.lua
+++ b/indra/newview/scripts/lua/ErrorQueue.lua
@@ -3,22 +3,22 @@
 -- raise that error.
 
 local WaitQueue = require('WaitQueue')
--- local debug = require('printf')
-local function debug(...) end
+-- local dbg = require('printf')
+local function dbg(...) end
 
 local ErrorQueue = WaitQueue:new()
 
 function ErrorQueue:Error(message)
     -- Setting Error() is a marker, like closing the queue. Once we reach the
     -- error, every subsequent Dequeue() call will raise the same error.
-    debug('Setting self._closed to %q', message)
+    dbg('Setting self._closed to %q', message)
     self._closed = message
     self:_wake_waiters()
 end
 
 function ErrorQueue:Dequeue()
     local value = WaitQueue.Dequeue(self)
-    debug('ErrorQueue:Dequeue: base Dequeue() got %s', value)
+    dbg('ErrorQueue:Dequeue: base Dequeue() got %s', value)
     if value ~= nil then
         -- queue not yet closed, show caller
         return value
diff --git a/indra/newview/scripts/lua/WaitQueue.lua b/indra/newview/scripts/lua/WaitQueue.lua
index 1fbcc50847..ad4fdecf43 100644
--- a/indra/newview/scripts/lua/WaitQueue.lua
+++ b/indra/newview/scripts/lua/WaitQueue.lua
@@ -5,8 +5,8 @@
 local fiber = require('fiber')
 local Queue = require('Queue')
 
--- local debug = LL.print_debug
-local function debug(...) end
+-- local dbg = require('printf')
+local function dbg(...) end
 
 local WaitQueue = Queue:new()
 
@@ -60,17 +60,18 @@ function WaitQueue:Dequeue()
         -- the queue while there are still items left, and we want the
         -- consumer(s) to retrieve those last few items.
         if self._closed then
-            debug('WaitQueue:Dequeue(): closed')
+            dbg('WaitQueue:Dequeue(): closed')
             return nil
         end
-        debug('WaitQueue:Dequeue(): waiting')
+        dbg('WaitQueue:Dequeue(): waiting')
         -- add the running coroutine to the list of waiters
+        dbg('WaitQueue:Dequeue() running %s', tostring(coroutine.running() or 'main'))
         table.insert(self._waiters, fiber.running())
         -- then let somebody else run
         fiber.wait()
     end
     -- here we're sure this queue isn't empty
-    debug('WaitQueue:Dequeue() calling Queue.Dequeue()')
+    dbg('WaitQueue:Dequeue() calling Queue.Dequeue()')
     return Queue.Dequeue(self)
 end
 
diff --git a/indra/newview/scripts/lua/fiber.lua b/indra/newview/scripts/lua/fiber.lua
index aebf27357f..9057e6c890 100644
--- a/indra/newview/scripts/lua/fiber.lua
+++ b/indra/newview/scripts/lua/fiber.lua
@@ -17,8 +17,8 @@
 -- or with an error).
 
 local printf = require 'printf'
--- local debug = printf
-local function debug(...) end
+-- local dbg = printf
+local function dbg(...) end
 local coro = require 'coro'
 
 local fiber = {}
@@ -78,22 +78,28 @@ function fiber.launch(name, func, ...)
     byname[namekey] = co
     -- and remember it as this fiber's name
     names[co] = namekey
---  debug('launch(%s)', namekey)
---  debug('byname[%s] = %s', namekey, tostring(byname[namekey]))
---  debug('names[%s] = %s', tostring(co), names[co])
---  debug('ready[-1] = %s', tostring(ready[#ready]))
+--  dbg('launch(%s)', namekey)
+--  dbg('byname[%s] = %s', namekey, tostring(byname[namekey]))
+--  dbg('names[%s] = %s', tostring(co), names[co])
+--  dbg('ready[-1] = %s', tostring(ready[#ready]))
 end
 
 -- for debugging
-function fiber.print_all()
-    print('Ready fibers:' .. if next(ready) then '' else ' none')
+function format_all()
+    output = {}
+    table.insert(output, 'Ready fibers:' .. if next(ready) then '' else ' none')
     for _, co in pairs(ready) do
-        printf('  %s: %s', fiber.get_name(co), fiber.status(co))
+        table.insert(output, string.format('  %s: %s', fiber.get_name(co), fiber.status(co)))
     end
-    print('Waiting fibers:' .. if next(waiting) then '' else ' none')
+    table.insert(output, 'Waiting fibers:' .. if next(waiting) then '' else ' none')
     for co in pairs(waiting) do
-        printf('  %s: %s', fiber.get_name(co), fiber.status(co))
+        table.insert(output, string.format('  %s: %s', fiber.get_name(co), fiber.status(co)))
     end
+    return table.concat(output, '\n')
+end
+
+function fiber.print_all()
+    print(format_all())
 end
 
 -- return either the running coroutine or, if called from the main thread,
@@ -160,6 +166,7 @@ end
 
 -- Suspend the current fiber until some other fiber calls fiber.wake() on it
 function fiber.wait()
+    dbg('Fiber %q waiting', fiber.get_name())
     set_waiting()
     -- now yield to other fibers
     fiber.yield()
@@ -175,26 +182,27 @@ function fiber.wake(co)
     waiting[co] = nil
     -- add to end of ready list
     table.insert(ready, co)
+    dbg('Fiber %q ready', fiber.get_name(co))
     -- but don't yet resume it: that happens next time we reach yield()
 end
 
 -- pop and return the next not-dead fiber in the ready list, or nil if none remain
 local function live_ready_iter()
-    -- don't write
+    -- don't write:
     -- for co in table.remove, ready, 1
     -- because it would keep passing a new second parameter!
     for co in function() return table.remove(ready, 1) end do
-        debug('%s live_ready_iter() sees %s, status %s',
+        dbg('%s live_ready_iter() sees %s, status %s',
               fiber.get_name(), fiber.get_name(co), fiber.status(co))
         -- keep removing the head entry until we find one that's not dead,
         -- discarding any dead coroutines along the way
         if co == 'main' or coroutine.status(co) ~= 'dead' then
-            debug('%s live_ready_iter() returning %s',
+            dbg('%s live_ready_iter() returning %s',
                   fiber.get_name(), fiber.get_name(co))
             return co
         end
     end
-    debug('%s live_ready_iter() returning nil', fiber.get_name())
+    dbg('%s live_ready_iter() returning nil', fiber.get_name())
     return nil
 end
 
@@ -214,6 +222,7 @@ end
 -- * false, nil if this is the only remaining fiber
 -- * nil,   x   if configured idle() callback returns non-nil x
 local function scheduler()
+    dbg('scheduler():\n%s', format_all())
     -- scheduler() is asymmetric because Lua distinguishes the main thread
     -- from other coroutines. The main thread can't yield; it can only resume
     -- other coroutines. So although an arbitrary coroutine could resume still
@@ -311,12 +320,12 @@ function fiber.run()
     end
     local others, idle_done
     repeat
-        debug('%s calling fiber.run() calling scheduler()', fiber.get_name())
+        dbg('%s calling fiber.run() calling scheduler()', fiber.get_name())
         others, idle_done = scheduler()
-        debug("%s fiber.run()'s scheduler() returned %s, %s", fiber.get_name(),
+        dbg("%s fiber.run()'s scheduler() returned %s, %s", fiber.get_name(),
               tostring(others), tostring(idle_done))
     until (not others)
-    debug('%s fiber.run() done', fiber.get_name())
+    dbg('%s fiber.run() done', fiber.get_name())
     -- For whatever it's worth, put our own fiber back in the ready list.
     table.insert(ready, fiber.running())
     -- Once there are no more waiting fibers, and the only ready fiber is
diff --git a/indra/newview/scripts/lua/leap.lua b/indra/newview/scripts/lua/leap.lua
index a60819d493..9da1839c68 100644
--- a/indra/newview/scripts/lua/leap.lua
+++ b/indra/newview/scripts/lua/leap.lua
@@ -40,8 +40,8 @@
 
 local fiber = require('fiber')
 local ErrorQueue = require('ErrorQueue')
--- local debug = require('printf')
-local function debug(...) end 
+-- local dbg = require('printf')
+local function dbg(...) end 
 
 local leap = {}
 
@@ -102,7 +102,7 @@ end
 -- 
 -- See also request(), generate().
 function leap.send(pump, data, reqid)
-    debug('leap.send(%s, %s, %s) entry', pump, data, reqid)
+    dbg('leap.send(%s, %s, %s) entry', pump, data, reqid)
     local data = data
     if type(data) == 'table' then
         data = table.clone(data)
@@ -111,7 +111,7 @@ function leap.send(pump, data, reqid)
             data['reqid'] = reqid
         end
     end
-    debug('leap.send(%s, %s) calling post_on()', pump, data)
+    dbg('leap.send(%s, %s) calling post_on()', pump, data)
     LL.post_on(pump, data)
 end
 
@@ -126,7 +126,7 @@ local function requestSetup(pump, data)
     -- WaitForReqid object in leap._pending so dispatch() can find it.
     leap._pending[reqid] = leap.WaitForReqid:new(reqid)
     -- Pass reqid to send() to stamp it into (a copy of) the request data.
-    debug('requestSetup(%s, %s)', pump, data)
+    dbg('requestSetup(%s, %s)', pump, data)
     leap.send(pump, data, reqid)
     return reqid
 end
@@ -152,9 +152,9 @@ end
 function leap.request(pump, data)
     local reqid = requestSetup(pump, data)
     local waitfor = leap._pending[reqid]
-    debug('leap.request(%s, %s) about to wait on %s', pump, data, tostring(waitfor))
+    dbg('leap.request(%s, %s) about to wait on %s', pump, data, tostring(waitfor))
     local ok, response = pcall(waitfor.wait, waitfor)
-    debug('leap.request(%s, %s) got %s: %s', pump, data, ok, response)
+    dbg('leap.request(%s, %s) got %s: %s', pump, data, ok, response)
     -- kill off temporary WaitForReqid object, even if error
     leap._pending[reqid] = nil
     if ok then
@@ -210,7 +210,7 @@ local function unsolicited(pump, data)
     -- we maintain waitfors in descending priority order, so the first waitfor
     -- to claim this event is the one with the highest priority
     for i, waitfor in pairs(leap._waitfors) do
-        debug('unsolicited() checking %s', waitfor.name)
+        dbg('unsolicited() checking %s', waitfor.name)
         if waitfor:handle(pump, data) then
             return
         end
@@ -243,9 +243,9 @@ fiber.set_idle(function ()
         cleanup('done')
         return 'done'
     end
-    debug('leap.idle() calling get_event_next()')
+    dbg('leap.idle() calling get_event_next()')
     local ok, pump, data = pcall(LL.get_event_next)
-    debug('leap.idle() got %s: %s, %s', ok, pump, data)
+    dbg('leap.idle() got %s: %s, %s', ok, pump, data)
     -- ok false means get_event_next() raised a Lua error, pump is message
     if not ok then
         cleanup(pump)
@@ -368,9 +368,9 @@ end
 -- Block the calling coroutine until a suitable unsolicited event (one
 -- for which filter() returns the event) arrives.
 function leap.WaitFor:wait()
-    debug('%s about to wait', self.name)
+    dbg('%s about to wait', self.name)
     local item = self._queue:Dequeue()
-    debug('%s got %s', self.name, item)
+    dbg('%s got %s', self.name, item)
     return item
 end
 
@@ -392,7 +392,7 @@ end
 -- called by unsolicited() for each WaitFor in leap._waitfors
 function leap.WaitFor:handle(pump, data)
     local item = self:filter(pump, data)
-    debug('%s.filter() returned %s', self.name, item)
+    dbg('%s.filter() returned %s', self.name, item)
     -- if this item doesn't pass the filter, we're not interested
     if not item then
         return false
-- 
cgit v1.2.3


From bfeedacf5a32fb77bd505c43126f3b5dc4394296 Mon Sep 17 00:00:00 2001
From: Mnikolenko Productengine <mnikolenko@productengine.com>
Date: Wed, 27 Mar 2024 23:11:24 +0200
Subject: Run each script file with new LuaState

---
 indra/newview/scripts/lua/test_LLFloaterAbout.lua | 10 +----
 indra/newview/scripts/lua/test_LLGesture.lua      | 46 ++++++++++-------------
 2 files changed, 21 insertions(+), 35 deletions(-)

(limited to 'indra/newview/scripts')

diff --git a/indra/newview/scripts/lua/test_LLFloaterAbout.lua b/indra/newview/scripts/lua/test_LLFloaterAbout.lua
index 7abc437b79..6bbf61982d 100644
--- a/indra/newview/scripts/lua/test_LLFloaterAbout.lua
+++ b/indra/newview/scripts/lua/test_LLFloaterAbout.lua
@@ -1,14 +1,6 @@
 -- test LLFloaterAbout
 
 LLFloaterAbout = require('LLFloaterAbout')
-leap = require('leap')
-coro = require('coro')
 inspect = require('inspect')
 
-coro.launch(function ()
-    print(inspect(LLFloaterAbout.getInfo()))
-    leap.done()
-end)
-
-leap.process()
-
+print(inspect(LLFloaterAbout.getInfo()))
diff --git a/indra/newview/scripts/lua/test_LLGesture.lua b/indra/newview/scripts/lua/test_LLGesture.lua
index 5897a0e3cb..1cce674565 100644
--- a/indra/newview/scripts/lua/test_LLGesture.lua
+++ b/indra/newview/scripts/lua/test_LLGesture.lua
@@ -2,31 +2,25 @@
 
 LLGesture = require 'LLGesture'
 inspect = require 'inspect'
-coro = require 'coro'
-leap = require 'leap'
 
-coro.launch(function()
-        -- getActiveGestures() returns {<UUID>: {name, playing, trigger}}
-        gestures_uuid = LLGesture.getActiveGestures()
-        -- convert to {<name>: <uuid>}
-        gestures = {}
-        for uuid, info in pairs(gestures_uuid) do
-            gestures[info.name] = uuid
-        end
-        -- now run through the list
-        for name, uuid in pairs(gestures) do
-            if name == 'afk' then
-                -- afk has a long timeout, and isn't interesting to look at
-                continue
-            end
-            print(name)
-            LLGesture.startGesture(uuid)
-            repeat
-                LL.sleep(1)
-            until not LLGesture.isGesturePlaying(uuid)
-        end
-        print('Done.')
-        leap.done()
-end)
 
-leap.process()
+-- getActiveGestures() returns {<UUID>: {name, playing, trigger}}
+gestures_uuid = LLGesture.getActiveGestures()
+-- convert to {<name>: <uuid>}
+gestures = {}
+for uuid, info in pairs(gestures_uuid) do
+    gestures[info.name] = uuid
+end
+-- now run through the list
+for name, uuid in pairs(gestures) do
+    if name == 'afk' then
+    -- afk has a long timeout, and isn't interesting to look at
+        continue
+    end
+    print(name)
+    LLGesture.startGesture(uuid)
+    repeat
+        LL.sleep(1)
+    until not LLGesture.isGesturePlaying(uuid)
+end
+print('Done.')
-- 
cgit v1.2.3


From f45ae0def221b4e1911e83f2da528174cf1d8a0d Mon Sep 17 00:00:00 2001
From: Nat Goodspeed <nat@lindenlab.com>
Date: Tue, 2 Apr 2024 11:09:03 -0400
Subject: Defend leap.request(), generate() from garbage collection.

Earlier we had blithely designated the 'pending' list (which stores
WaitForReqid objects for pending request() and generate() calls) as a weak
table. But the caller of request() or generate() does not hold a reference to
the WaitForReqid object. Make pending hold "strong" references.

Private collections (pending, waitfors) and private scalars that are never
reassigned (reply, command) need not be entries in the leap table.
---
 indra/newview/scripts/lua/leap.lua | 77 ++++++++++++++++++++------------------
 1 file changed, 40 insertions(+), 37 deletions(-)

(limited to 'indra/newview/scripts')

diff --git a/indra/newview/scripts/lua/leap.lua b/indra/newview/scripts/lua/leap.lua
index 9da1839c68..d19273e8bc 100644
--- a/indra/newview/scripts/lua/leap.lua
+++ b/indra/newview/scripts/lua/leap.lua
@@ -40,25 +40,25 @@
 
 local fiber = require('fiber')
 local ErrorQueue = require('ErrorQueue')
--- local dbg = require('printf')
 local function dbg(...) end 
+-- local dbg = require('printf')
 
 local leap = {}
 
--- _reply: string name of reply LLEventPump. Any events the viewer posts to
+-- reply: string name of reply LLEventPump. Any events the viewer posts to
 -- this pump will be queued for get_event_next(). We usually specify it as the
 -- reply pump for requests to internal viewer services.
--- _command: string name of command LLEventPump. post_to(_command, ...)
+-- command: string name of command LLEventPump. post_to(command, ...)
 -- engages LLLeapListener operations such as listening on a specified other
 -- LLEventPump, etc.
-leap._reply, leap._command = LL.get_event_pumps()
+local reply, command = LL.get_event_pumps()
 -- Dict of features added to the LEAP protocol since baseline implementation.
 -- Before engaging a new feature that might break an older viewer, we can
 -- check for the presence of that feature key. This table is solely about the
 -- LEAP protocol itself, the way we communicate with the viewer. To discover
 -- whether a given listener exists, or supports a particular operation, use
--- _command's "getAPI" operation.
--- For Lua, _command's "getFeatures" operation suffices?
+-- command's "getAPI" operation.
+-- For Lua, command's "getFeatures" operation suffices?
 -- leap._features = {}
 
 -- Each outstanding request() or generate() call has a corresponding
@@ -67,20 +67,25 @@ leap._reply, leap._command = LL.get_event_pumps()
 -- we can look up the appropriate WaitForReqid object more efficiently
 -- in a dict than by tossing such objects into the usual waitfors list.
 -- Note: the ["reqid"] must be unique, otherwise we could end up
--- replacing an earlier WaitForReqid object in self.pending with a
+-- replacing an earlier WaitForReqid object in pending with a
 -- later one. That means that no incoming event will ever be given to
 -- the old WaitForReqid object. Any coroutine waiting on the discarded
 -- WaitForReqid object would therefore wait forever.
--- these are weak values tables
-local weak_values = {__mode='v'}
-leap._pending = setmetatable({}, weak_values)
+-- pending is NOT a weak table because the caller of request() or generate()
+-- never sees the WaitForReqid object. pending holds the only reference, so
+-- it should NOT be garbage-collected.
+pending = {}
 -- Our consumer will instantiate some number of WaitFor subclass objects.
 -- As these are traversed in descending priority order, we must keep
 -- them in a list.
-leap._waitfors = setmetatable({}, weak_values)
+-- Anyone who instantiates a WaitFor subclass object should retain a reference
+-- to it. Once the consuming script drops the reference, allow Lua to
+-- garbage-collect the WaitFor despite its entry in waitfors.
+local weak_values = {__mode='v'}
+waitfors = setmetatable({}, weak_values)
 -- It has been suggested that we should use UUIDs as ["reqid"] values,
 -- since UUIDs are guaranteed unique. However, as the "namespace" for
--- ["reqid"] values is our very own _reply pump, we can get away with
+-- ["reqid"] values is our very own reply pump, we can get away with
 -- an integer.
 leap._reqid = 0
 -- break leap.process() loop
@@ -88,12 +93,12 @@ leap._done = false
 
 -- get the name of the reply pump
 function leap.replypump()
-    return leap._reply
+    return reply
 end
 
 -- get the name of the command pump
 function leap.cmdpump()
-    return leap._command
+    return command
 end
 
 -- Fire and forget. Send the specified request LLSD, expecting no reply.
@@ -102,11 +107,10 @@ end
 -- 
 -- See also request(), generate().
 function leap.send(pump, data, reqid)
-    dbg('leap.send(%s, %s, %s) entry', pump, data, reqid)
     local data = data
     if type(data) == 'table' then
         data = table.clone(data)
-        data['reply'] = leap._reply
+        data['reply'] = reply
         if reqid ~= nil then
             data['reqid'] = reqid
         end
@@ -122,13 +126,14 @@ local function requestSetup(pump, data)
     local reqid = leap._reqid
     -- Instantiate a new WaitForReqid object. The priority is irrelevant
     -- because, unlike the WaitFor base class, WaitForReqid does not
-    -- self-register on our leap._waitfors list. Instead, capture the new
-    -- WaitForReqid object in leap._pending so dispatch() can find it.
-    leap._pending[reqid] = leap.WaitForReqid:new(reqid)
+    -- self-register on our waitfors list. Instead, capture the new
+    -- WaitForReqid object in pending so dispatch() can find it.
+    local waitfor = leap.WaitForReqid:new(reqid)
+    pending[reqid] = waitfor
     -- Pass reqid to send() to stamp it into (a copy of) the request data.
     dbg('requestSetup(%s, %s)', pump, data)
     leap.send(pump, data, reqid)
-    return reqid
+    return reqid, waitfor
 end
 
 -- Send the specified request LLSD, expecting exactly one reply. Block
@@ -150,13 +155,12 @@ end
 --
 -- See also send(), generate().
 function leap.request(pump, data)
-    local reqid = requestSetup(pump, data)
-    local waitfor = leap._pending[reqid]
+    local reqid, waitfor = requestSetup(pump, data)
     dbg('leap.request(%s, %s) about to wait on %s', pump, data, tostring(waitfor))
     local ok, response = pcall(waitfor.wait, waitfor)
     dbg('leap.request(%s, %s) got %s: %s', pump, data, ok, response)
     -- kill off temporary WaitForReqid object, even if error
-    leap._pending[reqid] = nil
+    pending[reqid] = nil
     if ok then
         return response
     else
@@ -178,8 +182,7 @@ function leap.generate(pump, data, checklast)
     -- Invent a new, unique reqid. Arrange to handle incoming events
     -- bearing that reqid. Stamp the outbound request with that reqid, and
     -- send it.
-    local reqid = requestSetup(pump, data)
-    local waitfor = leap._pending[reqid]
+    local reqid, waitfor = requestSetup(pump, data)
     local ok, response
     repeat
         ok, response = pcall(waitfor.wait, waitfor)
@@ -189,7 +192,7 @@ function leap.generate(pump, data, checklast)
         coroutine.yield(response)
     until checklast and checklast(response)
     -- If we break the above loop, whether or not due to error, clean up.
-    leap._pending[reqid] = nil
+    pending[reqid] = nil
     if not ok then
         error(response)
     end
@@ -197,10 +200,10 @@ end
 
 local function cleanup(message)
     -- we're done: clean up all pending coroutines
-    for i, waitfor in pairs(leap._pending) do
+    for i, waitfor in pairs(pending) do
         waitfor:close()
     end
-    for i, waitfor in pairs(leap._waitfors) do
+    for i, waitfor in pairs(waitfors) do
         waitfor:close()
     end
 end
@@ -209,7 +212,7 @@ end
 local function unsolicited(pump, data)
     -- we maintain waitfors in descending priority order, so the first waitfor
     -- to claim this event is the one with the highest priority
-    for i, waitfor in pairs(leap._waitfors) do
+    for i, waitfor in pairs(waitfors) do
         dbg('unsolicited() checking %s', waitfor.name)
         if waitfor:handle(pump, data) then
             return
@@ -226,7 +229,7 @@ local function dispatch(pump, data)
         return unsolicited(pump, data)
     end
     -- have reqid; do we have a WaitForReqid?
-    local waitfor = leap._pending[reqid]
+    local waitfor = pending[reqid]
     if waitfor == nil then
         return unsolicited(pump, data)
     end
@@ -268,17 +271,17 @@ end
 
 -- called by WaitFor.enable()
 local function registerWaitFor(waitfor)
-    table.insert(leap._waitfors, waitfor)
+    table.insert(waitfors, waitfor)
     -- keep waitfors sorted in descending order of specified priority
-    table.sort(leap._waitfors,
+    table.sort(waitfors,
                function (lhs, rhs) return lhs.priority > rhs.priority end)
 end
 
 -- called by WaitFor.disable()
 local function unregisterWaitFor(waitfor)
-    for i, w in pairs(leap._waitfors) do
+    for i, w in pairs(waitfors) do
         if w == waitfor then
-            leap._waitfors[i] = nil
+            waitfors[i] = nil
             break
         end
     end
@@ -389,7 +392,7 @@ function leap.WaitFor:filter(pump, data)
     error('You must override the WaitFor.filter() method')
 end
 
--- called by unsolicited() for each WaitFor in leap._waitfors
+-- called by unsolicited() for each WaitFor in waitfors
 function leap.WaitFor:handle(pump, data)
     local item = self:filter(pump, data)
     dbg('%s.filter() returned %s', self.name, item)
@@ -423,8 +426,8 @@ leap.WaitForReqid = leap.WaitFor:new()
 
 function leap.WaitForReqid:new(reqid)
     -- priority is meaningless, since this object won't be added to the
-    -- priority-sorted ViewerClient.waitfors list. Use the reqid as the
-    -- debugging name string.
+    -- priority-sorted waitfors list. Use the reqid as the debugging name
+    -- string.
     local obj = leap.WaitFor:new(nil, 'WaitForReqid(' .. reqid .. ')')
     setmetatable(obj, self)
     self.__index = self
-- 
cgit v1.2.3


From 1866d1a450b7857da82ceafbd2c6581d87b7f334 Mon Sep 17 00:00:00 2001
From: Nat Goodspeed <nat@lindenlab.com>
Date: Tue, 2 Apr 2024 11:29:29 -0400
Subject: Add startup.lua module with startup.ensure(), wait() functions.

This lets a calling script verify that it's running at the right point in the
viewer's life cycle. A script that wants to interact with the SL agent
wouldn't work if run from the viewer's command line -- unless it calls
startup.wait("STATE_STARTED"), which pauses until login is complete.

Modify test_luafloater_demo.lua and test_luafloater_gesture_list.lua to find
their respective floater XUI files in the same directory as themselves.
Make them both capture the reqid returned by the "showLuaFloater" operation,
and filter for events bearing the same reqid. This paves the way for a given
script to display more than one floater concurrently.

Make test_luafloater_demo.lua (which does not require in-world resources) wait
until 'STATE_LOGIN_WAIT', the point at which the viewer has presented the
login screen.

Make test_luafloater_gesture_list.lua (which interacts with the agent) wait
until 'STATE_STARTED', the point at which the viewer is fully in world.

Either or both can now be launched from the viewer's command line.
---
 indra/newview/scripts/lua/startup.lua              | 101 +++++++++++++++++++++
 indra/newview/scripts/lua/test_luafloater_demo.lua |  25 +++--
 .../scripts/lua/test_luafloater_gesture_list.lua   |  26 ++++--
 3 files changed, 138 insertions(+), 14 deletions(-)
 create mode 100644 indra/newview/scripts/lua/startup.lua

(limited to 'indra/newview/scripts')

diff --git a/indra/newview/scripts/lua/startup.lua b/indra/newview/scripts/lua/startup.lua
new file mode 100644
index 0000000000..4311bb9a60
--- /dev/null
+++ b/indra/newview/scripts/lua/startup.lua
@@ -0,0 +1,101 @@
+-- query, wait for or mandate a particular viewer startup state
+
+-- During startup, the viewer steps through a sequence of numbered (and named)
+-- states. This can be used to detect when, for instance, the login screen is
+-- displayed, or when the viewer has finished logging in and is fully
+-- in-world.
+
+local fiber = require 'fiber'
+local leap = require 'leap'
+local inspect = require 'inspect'
+local function dbg(...) end
+-- local dbg = require 'printf'
+
+-- ---------------------------------------------------------------------------
+-- Get the list of startup states from the viewer.
+local bynum = leap.request('LLStartUp', {op='getStateTable'})['table']
+
+local byname = setmetatable(
+    {},
+    -- set metatable to throw an error if you look up invalid state name
+    {__index=function(t, k)
+         local v = t[k]
+         if v then
+             return v
+         end
+         error(string.format('startup module passed invalid state %q', k), 2)
+    end})
+
+-- derive byname as a lookup table to find the 0-based index for a given name
+for i, name in pairs(bynum) do
+    -- the viewer's states are 0-based, not 1-based like Lua indexes
+    byname[name] = i - 1
+end
+-- dbg('startup states: %s', inspect(byname))
+
+-- specialize a WaitFor to track the viewer's startup state
+local startup_pump = 'StartupState'
+local waitfor = leap.WaitFor:new(0, startup_pump)
+function waitfor:filter(pump, data)
+    if pump == self.name then
+        return data
+    end
+end
+
+function waitfor:process(data)
+    -- keep updating startup._state for interested parties
+    startup._state = data.str
+    dbg('startup updating state to %q', data.str)
+    -- now pass data along to base-class method to queue
+    leap.WaitFor.process(self, data)
+end
+
+-- listen for StartupState events
+leap.request(leap.cmdpump(),
+             {op='listen', source=startup_pump, listener='startup.lua', tweak=true})
+-- poke LLStartUp to make sure we get an event
+leap.send('LLStartUp', {op='postStartupState'})
+
+-- ---------------------------------------------------------------------------
+startup = {}
+
+-- wait for response from postStartupState
+while not startup._state do
+    dbg('startup.state() waiting for first StartupState event')
+    waitfor:wait()
+end
+
+-- return a list of all known startup states
+function startup.list()
+    return bynum
+end
+
+-- report whether state with string name 'left' is before string name 'right'
+function startup.before(left, right)
+    return byname[left] < byname[right]
+end
+
+-- report the viewer's current startup state
+function startup.state()
+    return startup._state
+end
+
+-- error if script is called before specified state string name
+function startup.ensure(state)
+    if startup.before(startup.state(), state) then
+        -- tell error() to pretend this error was thrown by our caller
+        error('must not be called before startup state ' .. state, 2)
+    end
+end
+
+-- block calling fiber until viewer has reached state with specified string name
+function startup.wait(state)
+    dbg('startup.wait(%q)', state)
+    while startup.before(startup.state(), state) do
+        local item = waitfor:wait()
+        dbg('startup.wait(%q) sees %s', state, item)
+    end
+end
+
+return startup
+
diff --git a/indra/newview/scripts/lua/test_luafloater_demo.lua b/indra/newview/scripts/lua/test_luafloater_demo.lua
index c375a2abc7..c2d16d4f88 100644
--- a/indra/newview/scripts/lua/test_luafloater_demo.lua
+++ b/indra/newview/scripts/lua/test_luafloater_demo.lua
@@ -1,10 +1,16 @@
-XML_FILE_PATH = "luafloater_demo.xml"
+XML_FILE_PATH = LL.source_dir() .. "/luafloater_demo.xml"
+
+scriptparts = string.split(LL.source_path(), '/')
+scriptname = scriptparts[#scriptparts]
+print('Running ' .. scriptname)
 
 leap = require 'leap'
 fiber = require 'fiber'
+startup = require 'startup'
 
 --event pump for sending actions to the floater
-COMMAND_PUMP_NAME = ""
+local COMMAND_PUMP_NAME = ""
+local reqid
 --table of floater UI events
 event_list=leap.request("LLFloaterReg", {op="getFloaterEvents"}).events
 
@@ -41,24 +47,29 @@ function handleEvents(event_data)
     end
   elseif event_data.event == _event("floater_close") then
     LL.print_warning("Floater was closed")
-    leap.done()
+    return false
   end
+  return true
 end
 
+startup.wait('STATE_LOGIN_WAIT')
 local key = {xml_path = XML_FILE_PATH, op = "showLuaFloater"}
 --sign for additional events for defined control {<control_name>= {action1, action2, ...}}
 key.extra_events={show_time_lbl = {_event("right_mouse_down"), _event("double_click")}}
-COMMAND_PUMP_NAME = leap.request("LLFloaterReg", key).command_name
+local resp = leap.request("LLFloaterReg", key)
+COMMAND_PUMP_NAME = resp.command_name
+reqid = resp.reqid
 
 catch_events = leap.WaitFor:new(-1, "all_events")
 function catch_events:filter(pump, data)
-  return data
+  if data.reqid == reqid then
+    return data
+  end
 end
 
 function process_events(waitfor)
   event_data = waitfor:wait()
-  while event_data do
-    handleEvents(event_data)
+  while event_data and handleEvents(event_data) do
     event_data = waitfor:wait()
   end
 end
diff --git a/indra/newview/scripts/lua/test_luafloater_gesture_list.lua b/indra/newview/scripts/lua/test_luafloater_gesture_list.lua
index 6d4a8e0cad..a907eb2e90 100644
--- a/indra/newview/scripts/lua/test_luafloater_gesture_list.lua
+++ b/indra/newview/scripts/lua/test_luafloater_gesture_list.lua
@@ -1,11 +1,17 @@
-XML_FILE_PATH = "luafloater_gesture_list.xml"
+XML_FILE_PATH = LL.source_dir() .. "/luafloater_gesture_list.xml"
+
+scriptparts = string.split(LL.source_path(), '/')
+scriptname = scriptparts[#scriptparts]
+print('Running ' .. scriptname)
 
 leap = require 'leap'
 fiber = require 'fiber'
 LLGesture = require 'LLGesture'
+startup = require 'startup'
 
 --event pump for sending actions to the floater
-COMMAND_PUMP_NAME = ""
+local COMMAND_PUMP_NAME = ""
+local reqid
 --table of floater UI events
 event_list=leap.request("LLFloaterReg", {op="getFloaterEvents"}).events
 
@@ -22,9 +28,12 @@ end
 
 function handleEvents(event_data)
   if event_data.event == _event("floater_close") then
-    leap.done()
-  elseif event_data.event == _event("post_build") then
+    return false
+  end
+
+  if event_data.event == _event("post_build") then
     COMMAND_PUMP_NAME = event_data.command_name
+    reqid = event_data.reqid
     gestures_uuid = LLGesture.getActiveGestures()
     local action_data = {}
     action_data.action = "add_list_element"
@@ -40,8 +49,10 @@ function handleEvents(event_data)
       LLGesture.startGesture(event_data.value)
     end
   end
+  return true
 end
 
+startup.wait('STATE_STARTED')
 local key = {xml_path = XML_FILE_PATH, op = "showLuaFloater"}
 --receive additional events for defined control {<control_name>= {action1, action2, ...}}
 key.extra_events={gesture_list = {_event("double_click")}}
@@ -49,13 +60,14 @@ handleEvents(leap.request("LLFloaterReg", key))
 
 catch_events = leap.WaitFor:new(-1, "all_events")
 function catch_events:filter(pump, data)
-  return data
+  if data.reqid == reqid then
+    return data
+  end
 end
 
 function process_events(waitfor)
   event_data = waitfor:wait()
-  while event_data do
-    handleEvents(event_data)
+  while event_data and handleEvents(event_data) do
     event_data = waitfor:wait()
   end
 end
-- 
cgit v1.2.3


From 7049485ebd0b997a097c12e094425d58db56e043 Mon Sep 17 00:00:00 2001
From: Nat Goodspeed <nat@lindenlab.com>
Date: Tue, 2 Apr 2024 13:25:08 -0400
Subject: Fix std::filesystem::path - to - std::string conversions on Windows.

On Windows, std::filesystem::path::value_type is wchar_t, not char -- so
path::string_type is std::wstring, not std::string. So while Posix path
instances implicitly convert to string, Windows path instances do not. Add
explicit u8string() calls.

Also add LL.abspath() Lua entry point to further facilitate finding a resource
file relative to the calling Lua script. Use abspath() for both
test_luafloater_demo.lua and test_luafloater_gesture_list.lua.
---
 indra/newview/scripts/lua/test_luafloater_demo.lua         | 2 +-
 indra/newview/scripts/lua/test_luafloater_gesture_list.lua | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

(limited to 'indra/newview/scripts')

diff --git a/indra/newview/scripts/lua/test_luafloater_demo.lua b/indra/newview/scripts/lua/test_luafloater_demo.lua
index c2d16d4f88..ab638dcdd1 100644
--- a/indra/newview/scripts/lua/test_luafloater_demo.lua
+++ b/indra/newview/scripts/lua/test_luafloater_demo.lua
@@ -1,4 +1,4 @@
-XML_FILE_PATH = LL.source_dir() .. "/luafloater_demo.xml"
+XML_FILE_PATH = LL.abspath("luafloater_demo.xml")
 
 scriptparts = string.split(LL.source_path(), '/')
 scriptname = scriptparts[#scriptparts]
diff --git a/indra/newview/scripts/lua/test_luafloater_gesture_list.lua b/indra/newview/scripts/lua/test_luafloater_gesture_list.lua
index a907eb2e90..3d9a9b0ad4 100644
--- a/indra/newview/scripts/lua/test_luafloater_gesture_list.lua
+++ b/indra/newview/scripts/lua/test_luafloater_gesture_list.lua
@@ -1,4 +1,4 @@
-XML_FILE_PATH = LL.source_dir() .. "/luafloater_gesture_list.xml"
+XML_FILE_PATH = LL.abspath("luafloater_gesture_list.xml")
 
 scriptparts = string.split(LL.source_path(), '/')
 scriptname = scriptparts[#scriptparts]
-- 
cgit v1.2.3


From 26ce33d8ead68c2dbcc37b2b1e040c072866fe5b Mon Sep 17 00:00:00 2001
From: Nat Goodspeed <nat@lindenlab.com>
Date: Tue, 9 Apr 2024 15:21:05 -0400
Subject: Add Lua Floater class to simplify Lua script showing floaters.

Add test_luafloater_demo2.lua and test_luafloater_gesture_list2.lua examples.
---
 indra/newview/scripts/lua/Floater.lua              | 151 +++++++++++++++++++++
 indra/newview/scripts/lua/leap.lua                 |   7 +-
 .../newview/scripts/lua/test_luafloater_demo2.lua  |  39 ++++++
 .../scripts/lua/test_luafloater_gesture_list2.lua  |  27 ++++
 4 files changed, 221 insertions(+), 3 deletions(-)
 create mode 100644 indra/newview/scripts/lua/Floater.lua
 create mode 100644 indra/newview/scripts/lua/test_luafloater_demo2.lua
 create mode 100644 indra/newview/scripts/lua/test_luafloater_gesture_list2.lua

(limited to 'indra/newview/scripts')

diff --git a/indra/newview/scripts/lua/Floater.lua b/indra/newview/scripts/lua/Floater.lua
new file mode 100644
index 0000000000..76efd47c43
--- /dev/null
+++ b/indra/newview/scripts/lua/Floater.lua
@@ -0,0 +1,151 @@
+-- Floater base class
+
+local leap = require 'leap'
+local fiber = require 'fiber'
+
+-- list of all the events that a LLLuaFloater might send
+local event_list = leap.request("LLFloaterReg", {op="getFloaterEvents"}).events
+local event_set = {}
+for _, event in pairs(event_list) do
+    event_set[event] = true
+end
+
+local function _event(event_name)
+    if not event_set[event_name] then
+        error("Incorrect event name: " .. event_name, 3)
+    end
+    return event_name
+end
+
+-- ---------------------------------------------------------------------------
+local Floater = {}
+
+-- Pass:
+-- relative file path to floater's XUI definition file
+-- optional: sign up for additional events for defined control
+-- {<control_name>={action1, action2, ...}}
+function Floater:new(path, extra)
+    local obj = setmetatable({}, self)
+    self.__index = self
+
+    local path_parts = string.split(path, '/')
+    obj.name = 'Floater ' .. path_parts[#path_parts]
+
+    obj._command = {op="showLuaFloater", xml_path=LL.abspath(path)}
+    if extra then
+        -- validate each of the actions for each specified control
+        for control, actions in pairs(extra) do
+            for _, action in pairs(actions) do
+                _event(action)
+            end
+        end
+        obj._command.extra_events = extra
+    end
+
+    return obj
+end
+
+function Floater:show()
+    local event = leap.request('LLFloaterReg', self._command)
+    self._pump = event.command_name
+    -- we use the returned reqid to claim subsequent unsolicited events
+    local reqid = event.reqid
+
+    -- The response to 'showLuaFloater' *is* the 'post_build' event. Check if
+    -- subclass has a post_build() method. Honor the convention that if
+    -- handleEvents() returns false, we're done.
+    if not self:handleEvents(event) then
+        return
+    end
+
+    local waitfor = leap.WaitFor:new(-1, self.name)
+    function waitfor:filter(pump, data)
+        if data.reqid == reqid then
+            return data
+        end
+    end
+
+    fiber.launch(
+        self.name,
+        function ()
+            event = waitfor:wait()
+            while event and self:handleEvents(event) do
+                event = waitfor:wait()
+            end
+        end)
+end
+
+function Floater:post(action)
+    leap.send(self._pump, action)
+end
+
+function Floater:request(action)
+    return leap.request(self._pump, action)
+end
+
+-- local inspect = require 'inspect'
+
+function Floater:handleEvents(event_data)
+    local event = event_data.event
+    if event_set[event] == nil then
+        LL.print_warning(string.format('%s received unknown event %q', self.name, event))
+    end
+
+    -- Before checking for a general (e.g.) commit() method, first look for
+    -- commit_ctrl_name(): in other words, concatenate the event name with the
+    -- ctrl_name, with an underscore between. If there exists such a specific
+    -- method, call that.
+    local handler, ret
+    if event_data.ctrl_name then
+        local specific = event .. '_' .. event_data.ctrl_name
+        handler = self[specific]
+        if handler then
+            ret = handler(self, event_data)
+            -- Avoid 'return ret or true' because we explicitly want to allow
+            -- the handler to return false.
+            if ret ~= nil then
+                return ret
+            else
+                return true
+            end
+        end
+    end
+
+    -- No specific "event_on_ctrl()" method found; try just "event()"
+    handler = self[event]
+    if handler then
+        ret = handler(self, event_data)
+        if ret ~= nil then
+            return ret
+        end
+--  else
+--      print(string.format('%s ignoring event %s', self.name, inspect(event_data)))
+    end
+
+    -- We check for event() method before recognizing floater_close in case
+    -- the consumer needs to react specially to closing the floater. Now that
+    -- we've checked, recognize it ourselves. Returning false terminates the
+    -- anonymous fiber function launched by show().
+    if event == _event('floater_close') then
+        LL.print_warning(self.name .. ' closed')
+        return false
+    end
+    return true
+end
+
+-- onCtrl() permits a different dispatch style in which the general event()
+-- method explicitly calls (e.g.)
+-- self:onCtrl(event_data, {
+--     ctrl_name=function()
+--         self:post(...)
+--     end,
+--     ...
+-- })
+function Floater:onCtrl(event_data, ctrl_map)
+    local handler = ctrl_map[event_data.ctrl_name]
+    if handler then
+        handler()
+    end
+end
+
+return Floater
diff --git a/indra/newview/scripts/lua/leap.lua b/indra/newview/scripts/lua/leap.lua
index d19273e8bc..ade91789f0 100644
--- a/indra/newview/scripts/lua/leap.lua
+++ b/indra/newview/scripts/lua/leap.lua
@@ -183,14 +183,15 @@ function leap.generate(pump, data, checklast)
     -- bearing that reqid. Stamp the outbound request with that reqid, and
     -- send it.
     local reqid, waitfor = requestSetup(pump, data)
-    local ok, response
+    local ok, response, resumed_with
     repeat
         ok, response = pcall(waitfor.wait, waitfor)
         if not ok then
             break
         end
-        coroutine.yield(response)
-    until checklast and checklast(response)
+        -- can resume(false) to terminate generate() and clean up
+        resumed_with = coroutine.yield(response)
+    until (checklast and checklast(response)) or (resumed_with == false)
     -- If we break the above loop, whether or not due to error, clean up.
     pending[reqid] = nil
     if not ok then
diff --git a/indra/newview/scripts/lua/test_luafloater_demo2.lua b/indra/newview/scripts/lua/test_luafloater_demo2.lua
new file mode 100644
index 0000000000..9e24237d28
--- /dev/null
+++ b/indra/newview/scripts/lua/test_luafloater_demo2.lua
@@ -0,0 +1,39 @@
+local Floater = require 'Floater'
+local leap = require 'leap'
+local startup = require 'startup'
+
+local flt = Floater:new(
+    'luafloater_demo.xml',
+    {show_time_lbl = {"right_mouse_down", "double_click"}})
+
+-- override base-class handleEvents() to report the event data in the floater's display field
+function flt:handleEvents(event_data)
+    self:post({action="add_text", ctrl_name="events_editor", value = event_data})
+    -- forward the call to base-class handleEvents()
+    return Floater.handleEvents(self, event_data)
+end
+
+function flt:commit_disable_ctrl(event_data)
+    self:post({action="set_enabled", ctrl_name="open_btn", value = (1 - event_data.value)})
+end
+
+function flt:commit_title_cmb(event_data)
+    self:post({action="set_title", value=event_data.value})
+end
+
+function flt:commit_open_btn(event_data)
+    floater_name = self:request({action="get_value", ctrl_name='openfloater_cmd'}).value
+    leap.send("LLFloaterReg", {name = floater_name, op = "showInstance"})
+end
+
+local function getCurrentTime()
+    local currentTime = os.date("*t")
+    return string.format("%02d:%02d:%02d", currentTime.hour, currentTime.min, currentTime.sec)
+end
+
+function flt:double_click_show_time_lbl(event_data)
+    self:post({action="set_value", ctrl_name="time_lbl", value=getCurrentTime()})
+end
+
+startup.wait('STATE_LOGIN_WAIT')
+flt:show()
diff --git a/indra/newview/scripts/lua/test_luafloater_gesture_list2.lua b/indra/newview/scripts/lua/test_luafloater_gesture_list2.lua
new file mode 100644
index 0000000000..d702d09c51
--- /dev/null
+++ b/indra/newview/scripts/lua/test_luafloater_gesture_list2.lua
@@ -0,0 +1,27 @@
+local Floater = require 'Floater'
+local LLGesture = require 'LLGesture'
+local startup = require 'startup'
+
+local flt = Floater:new(
+    "luafloater_gesture_list.xml",
+    {gesture_list = {"double_click"}})
+
+function flt:post_build(event_data)
+    local gestures_uuid = LLGesture.getActiveGestures()
+    local action_data = {}
+    action_data.action = "add_list_element"
+    action_data.ctrl_name = "gesture_list"
+    local gestures = {}
+    for uuid, info in pairs(gestures_uuid) do
+      table.insert(gestures, {value = uuid, columns={column = "gesture_name", value = info.name}})
+    end
+    action_data.value = gestures
+    self:post(action_data)
+end
+
+function flt:double_click_gesture_list(event_data)
+    LLGesture.startGesture(event_data.value)
+end
+
+startup.wait('STATE_STARTED')
+flt:show()
-- 
cgit v1.2.3


From bb1f3f08cf93facbf926e57384674441be7e2884 Mon Sep 17 00:00:00 2001
From: Mnikolenko Productengine <mnikolenko@productengine.com>
Date: Mon, 22 Apr 2024 14:56:52 +0300
Subject: Add demo script with idle and notification interactions

---
 indra/newview/scripts/lua/LLNotification.lua       | 15 ++++++++++
 .../newview/scripts/lua/luafloater_speedometer.xml | 35 ++++++++++++++++++++++
 .../scripts/lua/test_luafloater_speedometer.lua    | 26 ++++++++++++++++
 3 files changed, 76 insertions(+)
 create mode 100644 indra/newview/scripts/lua/LLNotification.lua
 create mode 100644 indra/newview/scripts/lua/luafloater_speedometer.xml
 create mode 100644 indra/newview/scripts/lua/test_luafloater_speedometer.lua

(limited to 'indra/newview/scripts')

diff --git a/indra/newview/scripts/lua/LLNotification.lua b/indra/newview/scripts/lua/LLNotification.lua
new file mode 100644
index 0000000000..f47730d1cc
--- /dev/null
+++ b/indra/newview/scripts/lua/LLNotification.lua
@@ -0,0 +1,15 @@
+-- Engage the LLNotificationsListener LLEventAPI
+
+leap = require 'leap'
+
+local LLNotification = {}
+
+function LLNotification.add(name, substitutions)
+    leap.send('LLNotifications', {op='requestAdd', name=name, substitutions=substitutions})
+end
+
+function LLNotification.requestAdd(name, substitutions)
+    return leap.request('LLNotifications', {op='requestAdd', name=name, substitutions=substitutions})['response']
+end
+
+return LLNotification
diff --git a/indra/newview/scripts/lua/luafloater_speedometer.xml b/indra/newview/scripts/lua/luafloater_speedometer.xml
new file mode 100644
index 0000000000..54b99c7d48
--- /dev/null
+++ b/indra/newview/scripts/lua/luafloater_speedometer.xml
@@ -0,0 +1,35 @@
+<?xml version="1.0" encoding="utf-8" standalone="yes" ?>
+<floater
+ legacy_header_height="18"
+ height="60"
+ layout="topleft"
+ name="lua_speedometer"
+ title="Speedometer"
+ can_minimize="false"
+ width="170">
+    <text
+     type="string"
+     follows="left|top"     
+     font="SansSerifBold"
+     font.size="Huge"
+     text_color="White"
+     layout="topleft"
+     top="25"
+     left_delta="30"
+     width="70"
+     height="30"
+     name="speed_lbl"/>
+    <text
+     type="string"
+     follows="left|top"
+     width="55"
+     height="30"
+     font="SansSerifBold"
+     font.size="Huge"
+     text_color="White"
+     layout="topleft"
+     left_pad="2"
+     name="mps_lbl">
+      m/s
+    </text> 
+</floater>
diff --git a/indra/newview/scripts/lua/test_luafloater_speedometer.lua b/indra/newview/scripts/lua/test_luafloater_speedometer.lua
new file mode 100644
index 0000000000..610401ae44
--- /dev/null
+++ b/indra/newview/scripts/lua/test_luafloater_speedometer.lua
@@ -0,0 +1,26 @@
+local Floater = require 'Floater'
+local startup = require 'startup'
+inspect = require 'inspect'
+leap = require 'leap'
+LLNotification = require 'LLNotification'
+local max_speed = 0
+local flt = Floater:new("luafloater_speedometer.xml")
+startup.wait('STATE_STARTED')
+
+function flt:floater_close(event_data)
+    msg = "Registered max speed: " .. string.format("%.2f", max_speed) .. " m/s";
+    LLNotification.add('SystemMessageTip', {MESSAGE = msg})
+end
+
+function flt:idle(event_data)
+    local speed = leap.request('LLVOAvatar', {op='getSpeed'})['value']
+    flt:post({action="set_value", ctrl_name="speed_lbl", value = string.format("%.2f", speed)})
+    max_speed=math.max(max_speed, speed)
+end
+
+msg = 'Are you sure you want to run this "speedometer" script?'
+response = LLNotification.requestAdd('GenericAlertYesCancel', {MESSAGE = msg})
+
+if response.OK_okcancelbuttons then
+  flt:show()
+end
-- 
cgit v1.2.3


From 76d36fe7210443b4564d2646a2fe5aa6d7c490fc Mon Sep 17 00:00:00 2001
From: Mnikolenko Productengine <mnikolenko@productengine.com>
Date: Mon, 29 Apr 2024 19:56:41 +0300
Subject: Allow getting the value of debug settings via Lua script

---
 indra/newview/scripts/lua/LLDebugSettings.lua | 13 +++++++++++++
 1 file changed, 13 insertions(+)
 create mode 100644 indra/newview/scripts/lua/LLDebugSettings.lua

(limited to 'indra/newview/scripts')

diff --git a/indra/newview/scripts/lua/LLDebugSettings.lua b/indra/newview/scripts/lua/LLDebugSettings.lua
new file mode 100644
index 0000000000..71a12a2ca2
--- /dev/null
+++ b/indra/newview/scripts/lua/LLDebugSettings.lua
@@ -0,0 +1,13 @@
+leap = require 'leap'
+
+local LLDebugSettings = {}
+
+function LLDebugSettings.set(name, value)
+    leap.send('LLAppViewer', {op='setDebugSetting', setting=name, value=value})
+end
+
+function LLDebugSettings.get(name)
+    return leap.request('LLAppViewer', {op='getDebugSetting', setting=name})['value']
+end
+
+return LLDebugSettings
-- 
cgit v1.2.3


From 79dca07d790a47db192099bcb85e740676a643ee Mon Sep 17 00:00:00 2001
From: Mnikolenko Productengine <mnikolenko@productengine.com>
Date: Wed, 1 May 2024 19:58:47 +0300
Subject: Use LLViewerControlListener to access debug settings

---
 indra/newview/scripts/lua/LLDebugSettings.lua | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

(limited to 'indra/newview/scripts')

diff --git a/indra/newview/scripts/lua/LLDebugSettings.lua b/indra/newview/scripts/lua/LLDebugSettings.lua
index 71a12a2ca2..80ae7e87bb 100644
--- a/indra/newview/scripts/lua/LLDebugSettings.lua
+++ b/indra/newview/scripts/lua/LLDebugSettings.lua
@@ -3,11 +3,15 @@ leap = require 'leap'
 local LLDebugSettings = {}
 
 function LLDebugSettings.set(name, value)
-    leap.send('LLAppViewer', {op='setDebugSetting', setting=name, value=value})
+    return leap.request('LLViewerControl', {op='set', group='Global', key=name, value=value})
+end
+
+function LLDebugSettings.toggle(name)
+    return leap.request('LLViewerControl', {op='toggle', group='Global', key=name})
 end
 
 function LLDebugSettings.get(name)
-    return leap.request('LLAppViewer', {op='getDebugSetting', setting=name})['value']
+    return leap.request('LLViewerControl', {op='get', group='Global', key=name})['value']
 end
 
 return LLDebugSettings
-- 
cgit v1.2.3


From f9a2748b542d05d153fa591a8c452162d9402828 Mon Sep 17 00:00:00 2001
From: Mnikolenko Productengine <mnikolenko@productengine.com>
Date: Thu, 2 May 2024 14:03:34 +0300
Subject: Raise Lua error if LLViewerControlListener response contains one

---
 indra/newview/scripts/lua/LLDebugSettings.lua | 13 ++++++++++---
 1 file changed, 10 insertions(+), 3 deletions(-)

(limited to 'indra/newview/scripts')

diff --git a/indra/newview/scripts/lua/LLDebugSettings.lua b/indra/newview/scripts/lua/LLDebugSettings.lua
index 80ae7e87bb..c809dfff91 100644
--- a/indra/newview/scripts/lua/LLDebugSettings.lua
+++ b/indra/newview/scripts/lua/LLDebugSettings.lua
@@ -1,17 +1,24 @@
 leap = require 'leap'
 
+function check_response(res)
+  if res.error then
+    error(res.error)
+  end
+  return res
+end
+
 local LLDebugSettings = {}
 
 function LLDebugSettings.set(name, value)
-    return leap.request('LLViewerControl', {op='set', group='Global', key=name, value=value})
+    check_response(leap.request('LLViewerControl', {op='set', group='Global', key=name, value=value}))
 end
 
 function LLDebugSettings.toggle(name)
-    return leap.request('LLViewerControl', {op='toggle', group='Global', key=name})
+    check_response(leap.request('LLViewerControl', {op='toggle', group='Global', key=name}))
 end
 
 function LLDebugSettings.get(name)
-    return leap.request('LLViewerControl', {op='get', group='Global', key=name})['value']
+    return check_response(leap.request('LLViewerControl', {op='get', group='Global', key=name}))['value']
 end
 
 return LLDebugSettings
-- 
cgit v1.2.3


From cec3b8d870085925cd0c9fb900b7d5e4629bcbfd Mon Sep 17 00:00:00 2001
From: Mnikolenko Productengine <mnikolenko@productengine.com>
Date: Tue, 7 May 2024 13:10:00 +0300
Subject: Copy xml files to scripts/lua; make Lua debug floater resizable

---
 indra/newview/scripts/lua/LLDebugSettings.lua | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'indra/newview/scripts')

diff --git a/indra/newview/scripts/lua/LLDebugSettings.lua b/indra/newview/scripts/lua/LLDebugSettings.lua
index c809dfff91..c1d74fe00a 100644
--- a/indra/newview/scripts/lua/LLDebugSettings.lua
+++ b/indra/newview/scripts/lua/LLDebugSettings.lua
@@ -1,6 +1,6 @@
 leap = require 'leap'
 
-function check_response(res)
+local function check_response(res)
   if res.error then
     error(res.error)
   end
-- 
cgit v1.2.3


From bd8e1dd8d2340636521200d15a045321ea07b986 Mon Sep 17 00:00:00 2001
From: Nat Goodspeed <nat@lindenlab.com>
Date: Wed, 8 May 2024 16:58:34 -0400
Subject: Tweak a couple things

---
 indra/newview/scripts/lua/LLDebugSettings.lua | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'indra/newview/scripts')

diff --git a/indra/newview/scripts/lua/LLDebugSettings.lua b/indra/newview/scripts/lua/LLDebugSettings.lua
index c809dfff91..c1d74fe00a 100644
--- a/indra/newview/scripts/lua/LLDebugSettings.lua
+++ b/indra/newview/scripts/lua/LLDebugSettings.lua
@@ -1,6 +1,6 @@
 leap = require 'leap'
 
-function check_response(res)
+local function check_response(res)
   if res.error then
     error(res.error)
   end
-- 
cgit v1.2.3


From 1abf5f18d6afc7ae9e1b1562b92e5c1ce33b722f Mon Sep 17 00:00:00 2001
From: Nat Goodspeed <nat@lindenlab.com>
Date: Wed, 15 May 2024 09:03:02 -0400
Subject: Make leap.lua honor an "error" key in viewer response.

---
 indra/newview/scripts/lua/leap.lua | 12 ++++++++----
 1 file changed, 8 insertions(+), 4 deletions(-)

(limited to 'indra/newview/scripts')

diff --git a/indra/newview/scripts/lua/leap.lua b/indra/newview/scripts/lua/leap.lua
index ade91789f0..cfb7377523 100644
--- a/indra/newview/scripts/lua/leap.lua
+++ b/indra/newview/scripts/lua/leap.lua
@@ -161,10 +161,12 @@ function leap.request(pump, data)
     dbg('leap.request(%s, %s) got %s: %s', pump, data, ok, response)
     -- kill off temporary WaitForReqid object, even if error
     pending[reqid] = nil
-    if ok then
-        return response
-    else
+    if not ok then
         error(response)
+    elseif response.error then
+        error(response.error)
+    else
+        return response
     end
 end
 
@@ -186,7 +188,7 @@ function leap.generate(pump, data, checklast)
     local ok, response, resumed_with
     repeat
         ok, response = pcall(waitfor.wait, waitfor)
-        if not ok then
+        if (not ok) or response.error then
             break
         end
         -- can resume(false) to terminate generate() and clean up
@@ -196,6 +198,8 @@ function leap.generate(pump, data, checklast)
     pending[reqid] = nil
     if not ok then
         error(response)
+    elseif response.error then
+        error(response.error)
     end
 end
 
-- 
cgit v1.2.3


From 9f540f10e687bb3889de191afbae3b52cc21f415 Mon Sep 17 00:00:00 2001
From: Mnikolenko Productengine <mnikolenko@productengine.com>
Date: Wed, 15 May 2024 18:50:51 +0300
Subject: Add trusted flag to UI callbacks, so not everything is accessible
 from the script

---
 indra/newview/scripts/lua/LLDebugSettings.lua | 14 ++++----------
 indra/newview/scripts/lua/UI.lua              |  5 +++--
 indra/newview/scripts/lua/util.lua            |  7 +++++++
 3 files changed, 14 insertions(+), 12 deletions(-)

(limited to 'indra/newview/scripts')

diff --git a/indra/newview/scripts/lua/LLDebugSettings.lua b/indra/newview/scripts/lua/LLDebugSettings.lua
index c1d74fe00a..06a8a63727 100644
--- a/indra/newview/scripts/lua/LLDebugSettings.lua
+++ b/indra/newview/scripts/lua/LLDebugSettings.lua
@@ -1,24 +1,18 @@
 leap = require 'leap'
-
-local function check_response(res)
-  if res.error then
-    error(res.error)
-  end
-  return res
-end
+util = require 'util'
 
 local LLDebugSettings = {}
 
 function LLDebugSettings.set(name, value)
-    check_response(leap.request('LLViewerControl', {op='set', group='Global', key=name, value=value}))
+    util.check_response(leap.request('LLViewerControl', {op='set', group='Global', key=name, value=value}))
 end
 
 function LLDebugSettings.toggle(name)
-    check_response(leap.request('LLViewerControl', {op='toggle', group='Global', key=name}))
+    util.check_response(leap.request('LLViewerControl', {op='toggle', group='Global', key=name}))
 end
 
 function LLDebugSettings.get(name)
-    return check_response(leap.request('LLViewerControl', {op='get', group='Global', key=name}))['value']
+    return util.check_response(leap.request('LLViewerControl', {op='get', group='Global', key=name}))['value']
 end
 
 return LLDebugSettings
diff --git a/indra/newview/scripts/lua/UI.lua b/indra/newview/scripts/lua/UI.lua
index f851632bad..6101c7a312 100644
--- a/indra/newview/scripts/lua/UI.lua
+++ b/indra/newview/scripts/lua/UI.lua
@@ -1,16 +1,17 @@
 -- Engage the UI LLEventAPI
 
 leap = require 'leap'
+util = require 'util'
 
 local UI = {}
 
 function UI.call(func, parameter)
     -- 'call' is fire-and-forget
-    leap.send('UI', {op='call', ['function']=func, parameter=parameter})
+    util.check_response(leap.request('UI', {op='call', ['function']=func, parameter=parameter}))
 end
 
 function UI.getValue(path)
-    return leap.request('UI', {op='getValue', path=path})['value']
+    return util.check_response(leap.request('UI', {op='getValue', path=path}))['value']
 end
 
 return UI
diff --git a/indra/newview/scripts/lua/util.lua b/indra/newview/scripts/lua/util.lua
index a2191288f6..404efdf09e 100644
--- a/indra/newview/scripts/lua/util.lua
+++ b/indra/newview/scripts/lua/util.lua
@@ -41,4 +41,11 @@ function util.equal(t1, t2)
     return util.empty(temp)
 end
 
+function util.check_response(res)
+  if res.error then
+    error(res.error)
+  end
+  return res
+end
+
 return util
-- 
cgit v1.2.3


From 0f00dc2f658869cc73a18b03b024a6cc88964e0b Mon Sep 17 00:00:00 2001
From: Mnikolenko Productengine <mnikolenko@productengine.com>
Date: Wed, 22 May 2024 20:29:55 +0300
Subject: Add support for sending messages to Nearby chat from Lua script

---
 indra/newview/scripts/lua/LLChat.lua | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)
 create mode 100644 indra/newview/scripts/lua/LLChat.lua

(limited to 'indra/newview/scripts')

diff --git a/indra/newview/scripts/lua/LLChat.lua b/indra/newview/scripts/lua/LLChat.lua
new file mode 100644
index 0000000000..7db538e837
--- /dev/null
+++ b/indra/newview/scripts/lua/LLChat.lua
@@ -0,0 +1,17 @@
+leap = require 'leap'
+
+local LLChat = {}
+
+function LLChat.sendNearby(msg)
+    leap.send('LLChatBar', {op='sendChat', message=msg})
+end
+
+function LLChat.sendWhisper(msg)
+    leap.send('LLChatBar', {op='sendChat', type='whisper', message=msg})
+end
+
+function LLChat.sendShout(msg)
+    leap.send('LLChatBar', {op='sendChat', type='shout', message=msg})
+end
+
+return LLChat
-- 
cgit v1.2.3


From 85664b011e37c6c9926924f6fb72ceeb10d07833 Mon Sep 17 00:00:00 2001
From: Mnikolenko Productengine <mnikolenko@productengine.com>
Date: Wed, 22 May 2024 21:03:45 +0300
Subject: add throttle for sending messages; add simple demo script

---
 indra/newview/scripts/lua/test_LLChat.lua | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)
 create mode 100644 indra/newview/scripts/lua/test_LLChat.lua

(limited to 'indra/newview/scripts')

diff --git a/indra/newview/scripts/lua/test_LLChat.lua b/indra/newview/scripts/lua/test_LLChat.lua
new file mode 100644
index 0000000000..95bd218baa
--- /dev/null
+++ b/indra/newview/scripts/lua/test_LLChat.lua
@@ -0,0 +1,18 @@
+LLChat = require 'LLChat'
+
+function generateRandomWord(length)
+    local alphabet = "abcdefghijklmnopqrstuvwxyz"
+    local word = ""
+    for i = 1, length do
+        local randomIndex = math.random(1, #alphabet)
+        word = word .. alphabet:sub(randomIndex, randomIndex)
+    end
+    return word
+end
+
+local msg = ""
+math.randomseed(os.time())
+for i = 1, math.random(1, 10) do
+    msg = msg .. " ".. generateRandomWord(math.random(1, 8))
+end
+LLChat.sendNearby(msg)
-- 
cgit v1.2.3


From e4b7d2f463d19cab28985414365fd8415e3dc700 Mon Sep 17 00:00:00 2001
From: Mnikolenko Productengine <mnikolenko@productengine.com>
Date: Fri, 24 May 2024 15:24:50 +0300
Subject: Mark script messages in compact mode too; code clean up

---
 indra/newview/scripts/lua/test_LLChat.lua | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

(limited to 'indra/newview/scripts')

diff --git a/indra/newview/scripts/lua/test_LLChat.lua b/indra/newview/scripts/lua/test_LLChat.lua
index 95bd218baa..883b82fafb 100644
--- a/indra/newview/scripts/lua/test_LLChat.lua
+++ b/indra/newview/scripts/lua/test_LLChat.lua
@@ -2,15 +2,15 @@ LLChat = require 'LLChat'
 
 function generateRandomWord(length)
     local alphabet = "abcdefghijklmnopqrstuvwxyz"
-    local word = ""
+    local wordTable = {}
     for i = 1, length do
         local randomIndex = math.random(1, #alphabet)
-        word = word .. alphabet:sub(randomIndex, randomIndex)
+        table.insert(wordTable, alphabet:sub(randomIndex, randomIndex))
     end
-    return word
+    return table.concat(wordTable)
 end
 
-local msg = ""
+local msg = "AI says:"
 math.randomseed(os.time())
 for i = 1, math.random(1, 10) do
     msg = msg .. " ".. generateRandomWord(math.random(1, 8))
-- 
cgit v1.2.3


From b0ef843fe0702482e843379b4975b2dda4d58935 Mon Sep 17 00:00:00 2001
From: Nat Goodspeed <nat@lindenlab.com>
Date: Fri, 24 May 2024 09:22:40 -0400
Subject: Nat's ideas from PR #1547

---
 indra/newview/scripts/lua/test_LLChat.lua | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

(limited to 'indra/newview/scripts')

diff --git a/indra/newview/scripts/lua/test_LLChat.lua b/indra/newview/scripts/lua/test_LLChat.lua
index 95bd218baa..3c5cbeeeb2 100644
--- a/indra/newview/scripts/lua/test_LLChat.lua
+++ b/indra/newview/scripts/lua/test_LLChat.lua
@@ -2,17 +2,17 @@ LLChat = require 'LLChat'
 
 function generateRandomWord(length)
     local alphabet = "abcdefghijklmnopqrstuvwxyz"
-    local word = ""
+    local word = {}
     for i = 1, length do
         local randomIndex = math.random(1, #alphabet)
-        word = word .. alphabet:sub(randomIndex, randomIndex)
+        table.insert(word, alphabet:sub(randomIndex, randomIndex))
     end
-    return word
+    return table.concat(word)
 end
 
-local msg = ""
+local msg = {'AI says:'}
 math.randomseed(os.time())
 for i = 1, math.random(1, 10) do
-    msg = msg .. " ".. generateRandomWord(math.random(1, 8))
+    table.insert(msg, generateRandomWord(math.random(1, 8)))
 end
-LLChat.sendNearby(msg)
+LLChat.sendNearby(table.concat(msg, ' '))
-- 
cgit v1.2.3


From d61831cabb8c63677e3684c8ba12b24b66923aa9 Mon Sep 17 00:00:00 2001
From: Nat Goodspeed <nat@lindenlab.com>
Date: Fri, 31 May 2024 11:17:48 -0400
Subject: Don't check if printf(format) arg is a string.

---
 indra/newview/scripts/lua/printf.lua | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'indra/newview/scripts')

diff --git a/indra/newview/scripts/lua/printf.lua b/indra/newview/scripts/lua/printf.lua
index 584cd4f391..e84b2024df 100644
--- a/indra/newview/scripts/lua/printf.lua
+++ b/indra/newview/scripts/lua/printf.lua
@@ -2,7 +2,7 @@
 
 local inspect = require 'inspect'
 
-local function printf(...)
+local function printf(format, ...)
     -- string.format() only handles numbers and strings.
     -- Convert anything else to string using the inspect module.
     local args = {}
@@ -13,7 +13,7 @@ local function printf(...)
             table.insert(args, inspect(arg))
         end
     end
-    print(string.format(table.unpack(args)))
+    print(string.format(format, table.unpack(args)))
 end
 
 return printf
-- 
cgit v1.2.3


From e352192045cfe23a681dcaba71d94311f42e230f Mon Sep 17 00:00:00 2001
From: Nat Goodspeed <nat@lindenlab.com>
Date: Fri, 31 May 2024 11:19:58 -0400
Subject: Add a bit more dbg() conditional diagnostic output.

---
 indra/newview/scripts/lua/fiber.lua | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

(limited to 'indra/newview/scripts')

diff --git a/indra/newview/scripts/lua/fiber.lua b/indra/newview/scripts/lua/fiber.lua
index 9057e6c890..cae27b936b 100644
--- a/indra/newview/scripts/lua/fiber.lua
+++ b/indra/newview/scripts/lua/fiber.lua
@@ -17,8 +17,8 @@
 -- or with an error).
 
 local printf = require 'printf'
--- local dbg = printf
 local function dbg(...) end
+-- local dbg = printf
 local coro = require 'coro'
 
 local fiber = {}
@@ -303,6 +303,8 @@ function fiber.yield()
     end
     -- We're ready! Just return to caller. In this situation we don't care
     -- whether there are other ready fibers.
+    dbg('fiber.yield() returning to %s (%sothers are ready)',
+        fiber.get_name(), ((not others) and "no " or ""))
 end
 
 -- Run fibers until all but main have terminated: return nil.
-- 
cgit v1.2.3


From c59f8bc59ad958d169a7626739b2b81439180537 Mon Sep 17 00:00:00 2001
From: Nat Goodspeed <nat@lindenlab.com>
Date: Fri, 31 May 2024 11:35:30 -0400
Subject: Add leap.eventstream() and cancelreq() functions.

leap.eventstream() is used when we expect the viewer's LLEventAPI to send an
immediate first response with the reqid from the request, followed by some
number of subsequent responses bearing the same reqid. The difference between
eventstream() and generate() is that generate() expects the caller to request
each such response, whereas eventstream calls the caller's callback with each
response.

cancelreq() is for canceling the background fiber launched by eventstream()
before the callback tells it to quit.

Make WaitFor:close() remove the object from the waitfors list; similarly, make
WaitForReqid:close() remove the object from the pending list. For this reason,
cleanup() must iterate over a copy of each of the pending and waitfors lists.

Instead of unregisterWaitFor() manually searching the waitfors list, use
table.find().
---
 indra/newview/scripts/lua/leap.lua | 106 ++++++++++++++++++++++++++++++++-----
 1 file changed, 93 insertions(+), 13 deletions(-)

(limited to 'indra/newview/scripts')

diff --git a/indra/newview/scripts/lua/leap.lua b/indra/newview/scripts/lua/leap.lua
index cfb7377523..69cedb4c9e 100644
--- a/indra/newview/scripts/lua/leap.lua
+++ b/indra/newview/scripts/lua/leap.lua
@@ -40,6 +40,7 @@
 
 local fiber = require('fiber')
 local ErrorQueue = require('ErrorQueue')
+local inspect = require('inspect')
 local function dbg(...) end 
 -- local dbg = require('printf')
 
@@ -74,7 +75,7 @@ local reply, command = LL.get_event_pumps()
 -- pending is NOT a weak table because the caller of request() or generate()
 -- never sees the WaitForReqid object. pending holds the only reference, so
 -- it should NOT be garbage-collected.
-pending = {}
+local pending = {}
 -- Our consumer will instantiate some number of WaitFor subclass objects.
 -- As these are traversed in descending priority order, we must keep
 -- them in a list.
@@ -82,7 +83,7 @@ pending = {}
 -- to it. Once the consuming script drops the reference, allow Lua to
 -- garbage-collect the WaitFor despite its entry in waitfors.
 local weak_values = {__mode='v'}
-waitfors = setmetatable({}, weak_values)
+local waitfors = setmetatable({}, weak_values)
 -- It has been suggested that we should use UUIDs as ["reqid"] values,
 -- since UUIDs are guaranteed unique. However, as the "namespace" for
 -- ["reqid"] values is our very own reply pump, we can get away with
@@ -131,7 +132,7 @@ local function requestSetup(pump, data)
     local waitfor = leap.WaitForReqid:new(reqid)
     pending[reqid] = waitfor
     -- Pass reqid to send() to stamp it into (a copy of) the request data.
-    dbg('requestSetup(%s, %s)', pump, data)
+    dbg('requestSetup(%s, %s) storing %s', pump, data, waitfor.name)
     leap.send(pump, data, reqid)
     return reqid, waitfor
 end
@@ -177,7 +178,7 @@ end
 -- 
 -- If you pass checklast=<callable accepting(event)>, each response event is
 -- passed to that callable (after the yield). When the callable returns
--- True, the generator terminates in the usual way.
+-- true, the generator terminates in the usual way.
 -- 
 -- See request() remarks about ["reqid"].
 function leap.generate(pump, data, checklast)
@@ -203,12 +204,80 @@ function leap.generate(pump, data, checklast)
     end
 end
 
+-- Send the specified request LLSD, expecting an immediate reply followed by
+-- an arbitrary number of subsequent replies with the same reqid. Block the
+-- calling coroutine until the first (immediate) reply, but launch a separate
+-- fiber on which to call the passed callback with later replies.
+--
+-- Once the callback returns true, the background fiber terminates.
+function leap.eventstream(pump, data, callback)
+    local reqid, waitfor = requestSetup(pump, data)
+    local response = waitfor:wait()
+    if response.error then
+        -- clean up our WaitForReqid
+        waitfor:close()
+        error(response.error)
+    end
+    -- No error, so far so good:
+    -- call the callback with the first response just in case
+    local ok, done = pcall(callback, response)
+    if not ok then
+        -- clean up our WaitForReqid
+        waitfor:close()
+        error(done)
+    end
+    if done then
+        return response
+    end
+    -- callback didn't throw an error, and didn't say stop,
+    -- so set up to handle subsequent events
+    -- TODO: distinguish "daemon" fibers that can be terminated even if waiting
+    fiber.launch(
+        pump,
+        function ()
+            local ok, done
+            repeat
+                event = waitfor:wait()
+                if not event then
+                    -- wait() returns nil once the queue is closed (e.g. cancelreq())
+                    ok, done = true, true
+                else
+                    ok, done = pcall(callback, event)
+                end
+                -- not ok means callback threw an error (caught as 'done')
+                -- done means callback succeeded but wants to stop
+            until (not ok) or done
+            -- once we break this loop, clean up our WaitForReqid
+            waitfor:close()
+            if not ok then
+                -- can't reflect the error back to our caller
+                LL.print_warning(fiber.get_name() .. ': ' .. done)
+            end
+        end)
+    return response
+end
+
+-- we might want to clean up after leap.eventstream() even if the callback has
+-- not yet returned true
+function leap.cancelreq(reqid)
+    dbg('cancelreq(%s)', reqid)
+    local waitfor = pending[reqid]
+    if waitfor ~= nil then
+        -- close() removes the pending entry and also closes the queue,
+        -- breaking the background fiber's wait loop.
+        dbg('cancelreq(%s) canceling %s', reqid, waitfor.name)
+        waitfor:close()
+    end
+end
+
 local function cleanup(message)
-    -- we're done: clean up all pending coroutines
-    for i, waitfor in pairs(pending) do
+    -- We're done: clean up all pending coroutines.
+    -- Iterate over copies of the pending and waitfors tables, since the
+    -- close() operation modifies the real tables.
+    for i, waitfor in pairs(table.clone(pending)) do
         waitfor:close()
     end
-    for i, waitfor in pairs(waitfors) do
+    for i, waitfor in pairs(table.clone(waitfors)) do
         waitfor:close()
     end
 end
@@ -223,7 +292,8 @@ local function unsolicited(pump, data)
             return
         end
     end
-    LL.print_debug(string.format('unsolicited(%s, %s) discarding unclaimed event', pump, data))
+    LL.print_debug(string.format('unsolicited(%s, %s) discarding unclaimed event',
+                                 pump, inspect(data)))
 end
 
 -- Route incoming (pump, data) event to the appropriate waiting coroutine.
@@ -231,14 +301,17 @@ local function dispatch(pump, data)
     local reqid = data['reqid']
     -- if the response has no 'reqid', it's not from request() or generate()
     if reqid == nil then
+--      dbg('dispatch() found no reqid; calling unsolicited(%s, %s)', pump, data)
         return unsolicited(pump, data)
     end
     -- have reqid; do we have a WaitForReqid?
     local waitfor = pending[reqid]
     if waitfor == nil then
+--      dbg('dispatch() found no WaitForReqid(%s); calling unsolicited(%s, %s)', reqid, pump, data)
         return unsolicited(pump, data)
     end
     -- found the right WaitForReqid object, let it handle the event
+--  dbg('dispatch() calling %s.handle(%s, %s)', waitfor.name, pump, data)
     waitfor:handle(pump, data)
 end
 
@@ -284,11 +357,9 @@ end
 
 -- called by WaitFor.disable()
 local function unregisterWaitFor(waitfor)
-    for i, w in pairs(waitfors) do
-        if w == waitfor then
-            waitfors[i] = nil
-            break
-        end
+    local i = table.find(waitfors, waitfor)
+    if i ~= nil then
+        waitfors[i] = nil
     end
 end
 
@@ -417,6 +488,7 @@ end
 
 -- called by cleanup() at end
 function leap.WaitFor:close()
+    self:disable()
     self._queue:close()
 end
 
@@ -437,6 +509,8 @@ function leap.WaitForReqid:new(reqid)
     setmetatable(obj, self)
     self.__index = self
 
+    obj.reqid = reqid
+
     return obj
 end
 
@@ -447,4 +521,10 @@ function leap.WaitForReqid:filter(pump, data)
     return data
 end
 
+function leap.WaitForReqid:close()
+    -- remove this entry from pending table
+    pending[self.reqid] = nil
+    self._queue:close()
+end
+
 return leap
-- 
cgit v1.2.3


From f08a3c80d61795bb1fc0e576948bca3362ef8e6c Mon Sep 17 00:00:00 2001
From: Mnikolenko Productengine <mnikolenko@productengine.com>
Date: Fri, 31 May 2024 20:03:13 +0300
Subject: Cherry-pick leap.lua changes; other clean up

---
 indra/newview/scripts/lua/LLDebugSettings.lua |  7 +++----
 indra/newview/scripts/lua/UI.lua              |  5 ++---
 indra/newview/scripts/lua/leap.lua            | 12 ++++++++----
 indra/newview/scripts/lua/util.lua            |  7 -------
 4 files changed, 13 insertions(+), 18 deletions(-)

(limited to 'indra/newview/scripts')

diff --git a/indra/newview/scripts/lua/LLDebugSettings.lua b/indra/newview/scripts/lua/LLDebugSettings.lua
index 06a8a63727..c250019a00 100644
--- a/indra/newview/scripts/lua/LLDebugSettings.lua
+++ b/indra/newview/scripts/lua/LLDebugSettings.lua
@@ -1,18 +1,17 @@
 leap = require 'leap'
-util = require 'util'
 
 local LLDebugSettings = {}
 
 function LLDebugSettings.set(name, value)
-    util.check_response(leap.request('LLViewerControl', {op='set', group='Global', key=name, value=value}))
+    leap.request('LLViewerControl', {op='set', group='Global', key=name, value=value})
 end
 
 function LLDebugSettings.toggle(name)
-    util.check_response(leap.request('LLViewerControl', {op='toggle', group='Global', key=name}))
+    leap.request('LLViewerControl', {op='toggle', group='Global', key=name})
 end
 
 function LLDebugSettings.get(name)
-    return util.check_response(leap.request('LLViewerControl', {op='get', group='Global', key=name}))['value']
+    return leap.request('LLViewerControl', {op='get', group='Global', key=name})['value']
 end
 
 return LLDebugSettings
diff --git a/indra/newview/scripts/lua/UI.lua b/indra/newview/scripts/lua/UI.lua
index 6101c7a312..24f822bbd9 100644
--- a/indra/newview/scripts/lua/UI.lua
+++ b/indra/newview/scripts/lua/UI.lua
@@ -1,17 +1,16 @@
 -- Engage the UI LLEventAPI
 
 leap = require 'leap'
-util = require 'util'
 
 local UI = {}
 
 function UI.call(func, parameter)
     -- 'call' is fire-and-forget
-    util.check_response(leap.request('UI', {op='call', ['function']=func, parameter=parameter}))
+    leap.request('UI', {op='call', ['function']=func, parameter=parameter})
 end
 
 function UI.getValue(path)
-    return util.check_response(leap.request('UI', {op='getValue', path=path}))['value']
+    return leap.request('UI', {op='getValue', path=path})['value']
 end
 
 return UI
diff --git a/indra/newview/scripts/lua/leap.lua b/indra/newview/scripts/lua/leap.lua
index ade91789f0..cfb7377523 100644
--- a/indra/newview/scripts/lua/leap.lua
+++ b/indra/newview/scripts/lua/leap.lua
@@ -161,10 +161,12 @@ function leap.request(pump, data)
     dbg('leap.request(%s, %s) got %s: %s', pump, data, ok, response)
     -- kill off temporary WaitForReqid object, even if error
     pending[reqid] = nil
-    if ok then
-        return response
-    else
+    if not ok then
         error(response)
+    elseif response.error then
+        error(response.error)
+    else
+        return response
     end
 end
 
@@ -186,7 +188,7 @@ function leap.generate(pump, data, checklast)
     local ok, response, resumed_with
     repeat
         ok, response = pcall(waitfor.wait, waitfor)
-        if not ok then
+        if (not ok) or response.error then
             break
         end
         -- can resume(false) to terminate generate() and clean up
@@ -196,6 +198,8 @@ function leap.generate(pump, data, checklast)
     pending[reqid] = nil
     if not ok then
         error(response)
+    elseif response.error then
+        error(response.error)
     end
 end
 
diff --git a/indra/newview/scripts/lua/util.lua b/indra/newview/scripts/lua/util.lua
index 404efdf09e..a2191288f6 100644
--- a/indra/newview/scripts/lua/util.lua
+++ b/indra/newview/scripts/lua/util.lua
@@ -41,11 +41,4 @@ function util.equal(t1, t2)
     return util.empty(temp)
 end
 
-function util.check_response(res)
-  if res.error then
-    error(res.error)
-  end
-  return res
-end
-
 return util
-- 
cgit v1.2.3


From 894dd1937511df08fa57c5e586d40a7778473dae Mon Sep 17 00:00:00 2001
From: Nat Goodspeed <nat@lindenlab.com>
Date: Fri, 31 May 2024 17:02:25 -0400
Subject: Tweak for current Lua dbg() convention.

---
 indra/newview/scripts/lua/ErrorQueue.lua | 2 +-
 indra/newview/scripts/lua/WaitQueue.lua  | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

(limited to 'indra/newview/scripts')

diff --git a/indra/newview/scripts/lua/ErrorQueue.lua b/indra/newview/scripts/lua/ErrorQueue.lua
index 6ed1c10d5c..13e4e92941 100644
--- a/indra/newview/scripts/lua/ErrorQueue.lua
+++ b/indra/newview/scripts/lua/ErrorQueue.lua
@@ -3,8 +3,8 @@
 -- raise that error.
 
 local WaitQueue = require('WaitQueue')
--- local dbg = require('printf')
 local function dbg(...) end
+-- local dbg = require('printf')
 
 local ErrorQueue = WaitQueue:new()
 
diff --git a/indra/newview/scripts/lua/WaitQueue.lua b/indra/newview/scripts/lua/WaitQueue.lua
index ad4fdecf43..6bcb9d62c2 100644
--- a/indra/newview/scripts/lua/WaitQueue.lua
+++ b/indra/newview/scripts/lua/WaitQueue.lua
@@ -5,8 +5,8 @@
 local fiber = require('fiber')
 local Queue = require('Queue')
 
--- local dbg = require('printf')
 local function dbg(...) end
+-- local dbg = require('printf')
 
 local WaitQueue = Queue:new()
 
-- 
cgit v1.2.3


From de719553fddc381e274d8bff218ab4e3f6691945 Mon Sep 17 00:00:00 2001
From: Nat Goodspeed <nat@lindenlab.com>
Date: Fri, 31 May 2024 17:15:06 -0400
Subject: Add timers.lua API module and test_timers.lua test program.

Since timers presents a timers.Timer Lua class supporting queries and
cancellation, make TimersListener::scheduleAfter() and scheduleEvery() respond
immediately so the newly constructed Timer object has the reqid necessary to
perform those subsequent operations.

This requires that Lua invocations of these operations avoid calling the
caller's callback with that initial response.

Reinvent leap.generate() to return a Lua object supporting next() and done()
methods. A plain Lua coroutine that (indirectly) calls fiber.wait() confuses
the fiber scheduler, so avoid implementing generate() as a Lua coroutine.

Add a bit more leap.lua diagnostic output.
---
 indra/newview/scripts/lua/leap.lua        |  59 ++++++++++-------
 indra/newview/scripts/lua/test_timers.lua |  39 ++++++++++++
 indra/newview/scripts/lua/timers.lua      | 101 ++++++++++++++++++++++++++++++
 3 files changed, 177 insertions(+), 22 deletions(-)
 create mode 100644 indra/newview/scripts/lua/test_timers.lua
 create mode 100644 indra/newview/scripts/lua/timers.lua

(limited to 'indra/newview/scripts')

diff --git a/indra/newview/scripts/lua/leap.lua b/indra/newview/scripts/lua/leap.lua
index 69cedb4c9e..8caae24e94 100644
--- a/indra/newview/scripts/lua/leap.lua
+++ b/indra/newview/scripts/lua/leap.lua
@@ -172,36 +172,45 @@ function leap.request(pump, data)
 end
 
 -- Send the specified request LLSD, expecting an arbitrary number of replies.
--- Each one is yielded on receipt. If you omit checklast, this is an infinite
--- generator; it's up to the caller to recognize when the last reply has been
--- received, and stop resuming for more.
--- 
--- If you pass checklast=<callable accepting(event)>, each response event is
--- passed to that callable (after the yield). When the callable returns
--- true, the generator terminates in the usual way.
+-- Each one is returned on request.
+--
+-- Usage:
+-- sequence = leap.generate(pump, data)
+-- repeat
+--     response = sequence.next()
+-- until last(response)
+-- (last() means whatever test the caller wants to perform on response)
+-- sequence.done()
 -- 
 -- See request() remarks about ["reqid"].
+--
+-- Note: this seems like a prime use case for Lua coroutines. But in a script
+-- using fibers.lua, a "wild" coroutine confuses the fiber scheduler. If
+-- generate() were itself a coroutine, it would call WaitForReqid:wait(),
+-- which would yield -- thereby resuming generate() WITHOUT waiting.
 function leap.generate(pump, data, checklast)
     -- Invent a new, unique reqid. Arrange to handle incoming events
     -- bearing that reqid. Stamp the outbound request with that reqid, and
     -- send it.
     local reqid, waitfor = requestSetup(pump, data)
-    local ok, response, resumed_with
-    repeat
-        ok, response = pcall(waitfor.wait, waitfor)
-        if (not ok) or response.error then
-            break
+    return {
+        next = function()
+            dbg('leap.generate(%s).next() about to wait on %s', reqid, tostring(waitfor))
+            local ok, response = pcall(waitfor.wait, waitfor)
+            dbg('leap.generate(%s).next() got %s: %s', reqid, ok, response)
+            if not ok then
+                error(response)
+            elseif response.error then
+                error(response.error)
+            else
+                return response
+            end
+        end,
+        done = function()
+            -- cleanup consists of removing our WaitForReqid from pending
+            pending[reqid] = nil
         end
-        -- can resume(false) to terminate generate() and clean up
-        resumed_with = coroutine.yield(response)
-    until (checklast and checklast(response)) or (resumed_with == false)
-    -- If we break the above loop, whether or not due to error, clean up.
-    pending[reqid] = nil
-    if not ok then
-        error(response)
-    elseif response.error then
-        error(response.error)
-    end
+    }
 end
 
 -- Send the specified request LLSD, expecting an immediate reply followed by
@@ -220,7 +229,9 @@ function leap.eventstream(pump, data, callback)
     end
     -- No error, so far so good:
     -- call the callback with the first response just in case
+    dbg('leap.eventstream(%s): first callback', reqid)
     local ok, done = pcall(callback, response)
+    dbg('leap.eventstream(%s) got %s, %s', reqid, ok, done)
     if not ok then
         -- clean up our WaitForReqid
         waitfor:close()
@@ -236,13 +247,17 @@ function leap.eventstream(pump, data, callback)
         pump,
         function ()
             local ok, done
+            local nth = 1
             repeat
                 event = waitfor:wait()
                 if not event then
                     -- wait() returns nil once the queue is closed (e.g. cancelreq())
                     ok, done = true, true
                 else
+                    nth += 1
+                    dbg('leap.eventstream(%s): callback %d', reqid, nth)
                     ok, done = pcall(callback, event)
+                    dbg('leap.eventstream(%s) got %s, %s', reqid, ok, done)
                 end
                 -- not ok means callback threw an error (caught as 'done')
                 -- done means callback succeeded but wants to stop
diff --git a/indra/newview/scripts/lua/test_timers.lua b/indra/newview/scripts/lua/test_timers.lua
new file mode 100644
index 0000000000..53a2dc83f2
--- /dev/null
+++ b/indra/newview/scripts/lua/test_timers.lua
@@ -0,0 +1,39 @@
+local timers = require 'timers'
+
+print('t0:new(10)')
+start = os.clock()
+t0 = timers.Timer:new(10, function() print('t0 fired at', os.clock() - start) end)
+print('t0:isRunning(): ', t0:isRunning())
+print('t0:timeUntilCall(): ', t0:timeUntilCall())
+print('t0:cancel(): ', t0:cancel())
+print('t0:isRunning(): ', t0:isRunning())
+print('t0:timeUntilCall(): ', t0:timeUntilCall())
+print('t0:cancel(): ', t0:cancel())
+
+print('t1:new(5)')
+start = os.clock()
+t1 = timers.Timer:new(5, function() print('t1 fired at', os.clock() - start) end)
+
+print('t2:new(2)')
+start = os.clock()
+t2 = timers.Timer:new(2)
+function t2:tick()
+    print('t2 fired at', os.clock() - start)
+end
+
+start = os.clock()
+timers.Timer:new(5, 'wait')
+print(string.format('Timer(5) waited %f seconds', os.clock() - start))
+
+start = os.clock()
+timers.Timer:new(
+    2,
+    coroutine.wrap(function()
+            for i = 1,5 do
+                print('repeat(2) timer fired at ', os.clock() - start)
+                coroutine.yield(nil) -- keep running
+            end
+            print('repeat(2) timer fired last at ', os.clock() - start)
+            return true -- stop
+    end),
+    true) -- iterate
diff --git a/indra/newview/scripts/lua/timers.lua b/indra/newview/scripts/lua/timers.lua
new file mode 100644
index 0000000000..e0d27a680d
--- /dev/null
+++ b/indra/newview/scripts/lua/timers.lua
@@ -0,0 +1,101 @@
+-- Access to the viewer's time-delay facilities
+
+local leap = require 'leap'
+
+local timers = {}
+
+local function dbg(...) end
+-- local dbg = require 'printf'
+
+timers.Timer = {}
+
+-- delay:    time in seconds until callback
+-- callback: 'wait', or function to call when timer fires (self:tick if nil)
+-- iterate:  if non-nil, call callback repeatedly until it returns non-nil
+--           (ignored if 'wait')
+function timers.Timer:new(delay, callback, iterate)
+    local obj = setmetatable({}, self)
+    self.__index = self
+
+    if callback == 'wait' then
+        dbg('scheduleAfter(%d):', delay)
+        sequence = leap.generate('Timers', {op='scheduleAfter', after=delay})
+        -- ignore the immediate return
+        dbg('scheduleAfter(%d) -> %s', delay,
+        sequence.next())
+        -- this call is where we wait for real
+        dbg('next():')
+        dbg('next() -> %s',
+        sequence.next())
+        sequence.done()
+        return
+    end
+
+    callback = callback or function() obj:tick() end
+
+    local first = true
+    if iterate then
+        obj.id = leap.eventstream(
+            'Timers',
+            {op='scheduleEvery', every=delay},
+            function (event)
+                local reqid = event.reqid
+                if first then
+                    first = false
+                    dbg('timer(%s) first callback', reqid)
+                    -- discard the first (immediate) response: don't call callback
+                    return nil
+                else
+                    dbg('timer(%s) nth callback', reqid)
+                    return callback(event)
+                end
+            end
+        ).reqid
+    else
+        obj.id = leap.eventstream(
+            'Timers',
+            {op='scheduleAfter', after=delay},
+            function (event)
+                -- Arrange to return nil the first time, true the second. This
+                -- callback is called immediately with the response to
+                -- 'scheduleAfter', and if we immediately returned true, we'd
+                -- be done, and the subsequent timer event would be discarded.
+                if first then
+                    first = false
+                    -- Caller doesn't expect an immediate callback.
+                    return nil
+                else
+                    callback(event)
+                    -- Since caller doesn't want to iterate, the value
+                    -- returned by the callback is irrelevant: just stop after
+                    -- this one and only call.
+                    return true
+                end
+            end
+        ).reqid
+    end
+
+    return obj
+end
+
+function timers.Timer:tick()
+    error('Pass a callback to Timer:new(), or override Timer:tick()')
+end
+
+function timers.Timer:cancel()
+    local ok = leap.request('Timers', {op='cancel', id=self.id}).ok
+    leap.cancelreq(self.id)
+    return ok
+end
+
+function timers.Timer:isRunning()
+    return leap.request('Timers', {op='isRunning', id=self.id}).running
+end
+
+-- returns (true, seconds left) for a live timer, else (false, 0)
+function timers.Timer:timeUntilCall()
+    local result = leap.request('Timers', {op='timeUntilCall', id=self.id})
+    return result.ok, result.remaining
+end
+
+return timers
-- 
cgit v1.2.3


From 47821cf53f89acec4ed6d465e14d7793d2420b41 Mon Sep 17 00:00:00 2001
From: Nat Goodspeed <nat@lindenlab.com>
Date: Mon, 3 Jun 2024 11:48:11 -0400
Subject: Leverage new leap.eventstream() function in Floater.lua.

---
 indra/newview/scripts/lua/Floater.lua | 32 ++++++++++++--------------------
 1 file changed, 12 insertions(+), 20 deletions(-)

(limited to 'indra/newview/scripts')

diff --git a/indra/newview/scripts/lua/Floater.lua b/indra/newview/scripts/lua/Floater.lua
index 76efd47c43..75696533e4 100644
--- a/indra/newview/scripts/lua/Floater.lua
+++ b/indra/newview/scripts/lua/Floater.lua
@@ -46,10 +46,18 @@ function Floater:new(path, extra)
 end
 
 function Floater:show()
-    local event = leap.request('LLFloaterReg', self._command)
+    -- leap.eventstream() returns the first response, and launches a
+    -- background fiber to call the passed callback with all subsequent
+    -- responses.
+    local event = leap.eventstream(
+        'LLFloaterReg',
+        self._command,
+        -- handleEvents() returns false when done.
+        -- eventstream() expects a true return when done.
+        function(event) return not self:handleEvents(event) end)
     self._pump = event.command_name
-    -- we use the returned reqid to claim subsequent unsolicited events
-    local reqid = event.reqid
+    -- we might need the returned reqid to cancel the eventstream() fiber
+    self.reqid = event.reqid
 
     -- The response to 'showLuaFloater' *is* the 'post_build' event. Check if
     -- subclass has a post_build() method. Honor the convention that if
@@ -57,22 +65,6 @@ function Floater:show()
     if not self:handleEvents(event) then
         return
     end
-
-    local waitfor = leap.WaitFor:new(-1, self.name)
-    function waitfor:filter(pump, data)
-        if data.reqid == reqid then
-            return data
-        end
-    end
-
-    fiber.launch(
-        self.name,
-        function ()
-            event = waitfor:wait()
-            while event and self:handleEvents(event) do
-                event = waitfor:wait()
-            end
-        end)
 end
 
 function Floater:post(action)
@@ -125,7 +117,7 @@ function Floater:handleEvents(event_data)
     -- We check for event() method before recognizing floater_close in case
     -- the consumer needs to react specially to closing the floater. Now that
     -- we've checked, recognize it ourselves. Returning false terminates the
-    -- anonymous fiber function launched by show().
+    -- anonymous fiber function launched by leap.eventstream().
     if event == _event('floater_close') then
         LL.print_warning(self.name .. ' closed')
         return false
-- 
cgit v1.2.3


From 9e6cf32add0a857b4e28c638bd378a8d3f70fcdb Mon Sep 17 00:00:00 2001
From: Nat Goodspeed <nat@lindenlab.com>
Date: Tue, 4 Jun 2024 09:52:55 -0400
Subject: Comment the intent of test_timers.lua

so the user need not reverse-engineer the code to figure out the output.
---
 indra/newview/scripts/lua/test_timers.lua | 24 ++++++++++++++++++++++++
 1 file changed, 24 insertions(+)

(limited to 'indra/newview/scripts')

diff --git a/indra/newview/scripts/lua/test_timers.lua b/indra/newview/scripts/lua/test_timers.lua
index 53a2dc83f2..ed0de070f7 100644
--- a/indra/newview/scripts/lua/test_timers.lua
+++ b/indra/newview/scripts/lua/test_timers.lua
@@ -1,5 +1,11 @@
 local timers = require 'timers'
 
+-- This t0 is constructed for 10 seconds, but its purpose is to exercise the
+-- query and cancel methods. It would print "t0 fired at..." if it fired, but
+-- it doesn't, so you don't see that message. Instead you see that isRunning()
+-- is true, that timeUntilCall() is (true, close to 10), that cancel() returns
+-- true. After that, isRunning() is false, timeUntilCall() returns (false, 0),
+-- and a second cancel() returns false.
 print('t0:new(10)')
 start = os.clock()
 t0 = timers.Timer:new(10, function() print('t0 fired at', os.clock() - start) end)
@@ -10,10 +16,15 @@ print('t0:isRunning(): ', t0:isRunning())
 print('t0:timeUntilCall(): ', t0:timeUntilCall())
 print('t0:cancel(): ', t0:cancel())
 
+-- t1 is supposed to fire after 5 seconds, but it doesn't wait, so you see the
+-- t2 messages immediately after.
 print('t1:new(5)')
 start = os.clock()
 t1 = timers.Timer:new(5, function() print('t1 fired at', os.clock() - start) end)
 
+-- t2 illustrates that instead of passing a callback to new(), you can
+-- override the timer instance's tick() method. But t2 doesn't wait either, so
+-- you see the Timer(5) message immediately.
 print('t2:new(2)')
 start = os.clock()
 t2 = timers.Timer:new(2)
@@ -21,10 +32,23 @@ function t2:tick()
     print('t2 fired at', os.clock() - start)
 end
 
+-- This anonymous timer blocks the calling fiber for 5 seconds. Other fibers
+-- are free to run during that time, so you see the t2 callback message and
+-- then the t1 callback message before the Timer(5) completion message.
+print('Timer(5) waiting')
 start = os.clock()
 timers.Timer:new(5, 'wait')
 print(string.format('Timer(5) waited %f seconds', os.clock() - start))
 
+-- This test demonstrates a repeating timer. It also shows that you can (but
+-- need not) use a coroutine as the timer's callback function: unlike Python,
+-- Lua doesn't disinguish between yield() and return. A coroutine wrapped with
+-- coroutine.wrap() looks to Lua just like any other function that you can
+-- call repeatedly and get a result each time. We use that to count the
+-- callback calls and stop after a certain number. Of course that could also
+-- be arranged in a plain function by incrementing a script-scope counter, but
+-- it's worth knowing that a coroutine timer callback can be used to manage
+-- more complex control flows.
 start = os.clock()
 timers.Timer:new(
     2,
-- 
cgit v1.2.3


From 486a6b189a3ea3fb2700718a64f574c3240fae7d Mon Sep 17 00:00:00 2001
From: Nat Goodspeed <nat@lindenlab.com>
Date: Fri, 7 Jun 2024 21:43:41 -0400
Subject: Introduce mapargs.lua, which defines the mapargs() function.

There are two conventions for Lua function calls. You can call a function with
positional arguments as usual:

f(1, 2, 3)

Lua makes it easy to handle omitted positional arguments: their values are nil.
But as in C++, positional arguments get harder to read when there are many, or
when you want to omit arguments other than the last ones.

Alternatively, using Lua syntactic sugar, you can pass a single argument which
is a table containing the desired function arguments. For this you can use
table constructor syntax to effect keyword arguments:

f{a=1, b=2, c=3}

A call passing keyword arguments is more readable because you explicitly
associate the parameter name with each argument value. Moreover, it gracefully
handles the case of multiple optional arguments. The reader need not be
concerned about parameters *not* being passed.

Now you're coding a Lua module with a number of functions. Some have numerous
or complicated arguments; some do not. For simplicity, you code the simple
functions to accept positional arguments, the more complicated functions to
accept the single-table argument style.

But how the bleep is a consumer of your module supposed to remember which
calling style to use for a given function?

mapargs() blurs the distinction, accepting either style. Coding a function
like this (where '...' is literal code, not documentation ellipsis):

function f(...)
    local args = mapargs({'a', 'b', 'c'}, ...)
    -- now use args.a, args.b, args.c
end

supports calls like:

f(1, 2, 3)
f{1, 2, 3}
f{c=3, a=1, b=2}
f{1, 2, c=3}
f{c=3, 1, 2}  -- unlike Python!

In every call above, args.a == 1, args.b == 2, args.c == 3.

Moreover, omitting arguments (or explicitly passing nil, positionally or by
keyword) works correctly.

test_mapargs.lua exercises these cases.
---
 indra/newview/scripts/lua/mapargs.lua      | 67 +++++++++++++++++++++++++++++
 indra/newview/scripts/lua/test_mapargs.lua | 68 ++++++++++++++++++++++++++++++
 2 files changed, 135 insertions(+)
 create mode 100644 indra/newview/scripts/lua/mapargs.lua
 create mode 100644 indra/newview/scripts/lua/test_mapargs.lua

(limited to 'indra/newview/scripts')

diff --git a/indra/newview/scripts/lua/mapargs.lua b/indra/newview/scripts/lua/mapargs.lua
new file mode 100644
index 0000000000..78e691d8bc
--- /dev/null
+++ b/indra/newview/scripts/lua/mapargs.lua
@@ -0,0 +1,67 @@
+-- Allow a calling function to be passed a mix of positional arguments with
+-- keyword arguments. Reference them as fields of a table.
+-- Don't use this for a function that can accept a single table argument.
+-- mapargs() assumes that a single table argument means its caller was called
+-- with f{table constructor} syntax, and maps that table to the specified names.
+-- Usage:
+-- function f(...)
+--     local a = mapargs({'a1', 'a2', 'a3'}, ...)
+--     ... a.a1 ... etc.
+-- end
+-- f(10, 20, 30)     -- a.a1 == 10,  a.a2 == 20,  a.a3 == 30
+-- f{10, 20, 30}     -- a.a1 == 10,  a.a2 == 20,  a.a3 == 30
+-- f{a3=300, a1=100} -- a.a1 == 100, a.a2 == nil, a.a3 == 300
+-- f{1, a3=3}        -- a.a1 == 1,   a.a2 == nil, a.a3 == 3
+-- f{a3=3, 1}        -- a.a1 == 1,   a.a2 == nil, a.a3 == 3
+local function mapargs(names, ...)
+    local args = table.pack(...)
+    local posargs = {}
+    local keyargs = {}
+    -- For a mixed table, no Lua operation will reliably tell you how many
+    -- array items it contains, if there are any holes. Track that by hand.
+    -- We must be able to handle f(1, nil, 3) calls.
+    local maxpos = 0
+    if not (args.n == 1 and type(args[1]) == 'table') then
+        -- If caller passes more than one argument, or if the first argument
+        -- is not a table, then it's classic positional function-call syntax:
+        -- f(first, second, etc.). In that case we need not bother teasing
+        -- apart positional from keyword arguments.
+        posargs = args
+        maxpos = args.n
+    else
+        -- Single table argument implies f{mixed} syntax.
+        -- Tease apart positional arguments from keyword arguments.
+        for k, v in pairs(args[1]) do
+            if type(k) == 'number' then
+                posargs[k] = v
+                maxpos = math.max(maxpos, k)
+            else
+                if table.find(names, k) == nil then
+                    error('unknown keyword argument ' .. tostring(k))
+                end
+                keyargs[k] = v
+            end
+        end
+    end
+
+    -- keyargs already has keyword arguments in place, just fill in positionals
+    args = keyargs
+    -- Don't exceed the number of parameter names. Loop explicitly over every
+    -- index value instead of using ipairs() so we can support holes (nils) in
+    -- posargs.
+    for i = 1, math.min(#names, maxpos) do
+        if posargs[i] ~= nil then
+            -- As in Python, make it illegal to pass an argument both positionally
+            -- and by keyword. This implementation permits func(17, first=nil), a
+            -- corner case about which I don't particularly care.
+            if args[names[i]] ~= nil then
+                error(string.format('parameter %s passed both positionally and by keyword',
+                                    tostring(names[i])))
+            end
+            args[names[i]] = posargs[i]
+        end
+    end
+    return args
+end
+
+return mapargs
diff --git a/indra/newview/scripts/lua/test_mapargs.lua b/indra/newview/scripts/lua/test_mapargs.lua
new file mode 100644
index 0000000000..999a57acb4
--- /dev/null
+++ b/indra/newview/scripts/lua/test_mapargs.lua
@@ -0,0 +1,68 @@
+local mapargs = require 'mapargs'
+local inspect = require 'inspect'
+
+function tabfunc(...)
+    local a = mapargs({'a1', 'a2', 'a3'}, ...)
+    print(inspect(a))
+end
+
+print('----------')
+print('f(10, 20, 30)')
+tabfunc(10, 20, 30)
+print('f(10, nil, 30)')
+tabfunc(10, nil, 30)
+print('f{10, 20, 30}')
+tabfunc{10, 20, 30}
+print('f{10, nil, 30}')
+tabfunc{10, nil, 30}
+print('f{a3=300, a1=100}')
+tabfunc{a3=300, a1=100}
+print('f{1, a3=3}')
+tabfunc{1, a3=3}
+print('f{a3=3, 1}')
+tabfunc{a3=3, 1}
+print('----------')
+
+if false then
+    -- the code below was used to explore ideas that became mapargs()
+    mixed = { '[1]', nil, '[3]', abc='[abc]', '[3]', def='[def]' }
+    local function showtable(desc, t)
+        print(string.format('%s (len %s)\n%s', desc, #t, inspect(t)))
+    end
+    showtable('mixed', mixed)
+
+    print('ipairs(mixed)')
+    for k, v in ipairs(mixed) do
+        print(string.format('[%s] = %s', k, tostring(v)))
+    end
+
+    print('table.pack(mixed)')
+    print(inspect(table.pack(mixed)))
+
+    local function nilarg(desc, a, b, c)
+        print(desc)
+        print('a = ' .. tostring(a))
+        print('b = ' .. tostring(b))
+        print('c = ' .. tostring(c))
+    end
+
+    nilarg('nilarg(1)', 1)
+    nilarg('nilarg(1, nil, 3)', 1, nil, 3)
+
+    local function nilargs(desc, ...)
+        args = table.pack(...)
+        showtable(desc, args)
+    end
+
+    nilargs('nilargs{a=1, b=2, c=3}', {a=1, b=2, c=3})
+    nilargs('nilargs(1, 2, 3)', 1, 2, 3)
+    nilargs('nilargs(1, nil, 3)', 1, nil, 3)
+    nilargs('nilargs{1, 2, 3}', {1, 2, 3})
+    nilargs('nilargs{1, nil, 3}', {1, nil, 3})
+
+    print('table.unpack({1, nil, 3})')
+    a, b, c = table.unpack({1, nil, 3})
+    print('a = ' .. tostring(a))
+    print('b = ' .. tostring(b))
+    print('c = ' .. tostring(c))
+end
-- 
cgit v1.2.3


From eae45eefb55410782559b4ace5350b2a99f63234 Mon Sep 17 00:00:00 2001
From: Nat Goodspeed <nat@lindenlab.com>
Date: Tue, 11 Jun 2024 13:39:13 -0400
Subject: mapargs() now accepts 'name1,name2,...' as argument names

in addition to a list {'name1', 'name2', ...}.
---
 indra/newview/scripts/lua/mapargs.lua | 6 ++++++
 1 file changed, 6 insertions(+)

(limited to 'indra/newview/scripts')

diff --git a/indra/newview/scripts/lua/mapargs.lua b/indra/newview/scripts/lua/mapargs.lua
index 78e691d8bc..45f5a9c556 100644
--- a/indra/newview/scripts/lua/mapargs.lua
+++ b/indra/newview/scripts/lua/mapargs.lua
@@ -21,6 +21,12 @@ local function mapargs(names, ...)
     -- array items it contains, if there are any holes. Track that by hand.
     -- We must be able to handle f(1, nil, 3) calls.
     local maxpos = 0
+
+    -- For convenience, allow passing 'names' as a string 'n0,n1,...'
+    if type(names) == 'string' then
+        names = string.split(names, ',')
+    end
+
     if not (args.n == 1 and type(args[1]) == 'table') then
         -- If caller passes more than one argument, or if the first argument
         -- is not a table, then it's classic positional function-call syntax:
-- 
cgit v1.2.3


From 18c4dcc5998e061fe3ab54607665c775dd18c826 Mon Sep 17 00:00:00 2001
From: Nat Goodspeed <nat@lindenlab.com>
Date: Tue, 11 Jun 2024 21:42:10 -0400
Subject: Allow Python-like 'object = ClassName(ctor args)' constructor calls.

The discussions we've read about Lua classes conventionally use
ClassName:new() as the constructor, and so far we've followed that convention.

But setting metaclass(ClassName).__call = ClassName.new permits Lua to respond
to calls of the form ClassName(ctor args) by implicitly calling
ClassName:new(ctor args).

Introduce util.classctor(). Calling util.classctor(ClassName) sets ClassName's
metaclass's __call to ClassName's constructor method. If the constructor method
is named something other than new(), pass ClassName.method as the second arg.

Use util.classctor() on each of our classes that defines a new() method.

Replace ClassName:new(args) calls with ClassName(args) calls throughout.
---
 indra/newview/scripts/lua/ErrorQueue.lua           |  5 ++++-
 indra/newview/scripts/lua/Floater.lua              |  3 +++
 indra/newview/scripts/lua/Queue.lua                |  4 ++++
 indra/newview/scripts/lua/WaitQueue.lua            |  7 ++++--
 indra/newview/scripts/lua/leap.lua                 | 13 +++++++----
 indra/newview/scripts/lua/qtest.lua                | 12 +++++------
 indra/newview/scripts/lua/test_luafloater_demo.lua |  2 +-
 .../newview/scripts/lua/test_luafloater_demo2.lua  |  2 +-
 .../scripts/lua/test_luafloater_gesture_list.lua   |  2 +-
 .../scripts/lua/test_luafloater_gesture_list2.lua  |  2 +-
 indra/newview/scripts/lua/test_timers.lua          | 16 +++++++-------
 indra/newview/scripts/lua/timers.lua               |  3 +++
 indra/newview/scripts/lua/util.lua                 | 25 ++++++++++++++++++++++
 13 files changed, 71 insertions(+), 25 deletions(-)

(limited to 'indra/newview/scripts')

diff --git a/indra/newview/scripts/lua/ErrorQueue.lua b/indra/newview/scripts/lua/ErrorQueue.lua
index 13e4e92941..e6e9a5ef48 100644
--- a/indra/newview/scripts/lua/ErrorQueue.lua
+++ b/indra/newview/scripts/lua/ErrorQueue.lua
@@ -5,8 +5,11 @@
 local WaitQueue = require('WaitQueue')
 local function dbg(...) end
 -- local dbg = require('printf')
+local util = require('util')
 
-local ErrorQueue = WaitQueue:new()
+local ErrorQueue = WaitQueue()
+
+util.classctor(ErrorQueue)
 
 function ErrorQueue:Error(message)
     -- Setting Error() is a marker, like closing the queue. Once we reach the
diff --git a/indra/newview/scripts/lua/Floater.lua b/indra/newview/scripts/lua/Floater.lua
index 75696533e4..d057a74386 100644
--- a/indra/newview/scripts/lua/Floater.lua
+++ b/indra/newview/scripts/lua/Floater.lua
@@ -2,6 +2,7 @@
 
 local leap = require 'leap'
 local fiber = require 'fiber'
+local util = require 'util'
 
 -- list of all the events that a LLLuaFloater might send
 local event_list = leap.request("LLFloaterReg", {op="getFloaterEvents"}).events
@@ -45,6 +46,8 @@ function Floater:new(path, extra)
     return obj
 end
 
+util.classctor(Floater)
+
 function Floater:show()
     -- leap.eventstream() returns the first response, and launches a
     -- background fiber to call the passed callback with all subsequent
diff --git a/indra/newview/scripts/lua/Queue.lua b/indra/newview/scripts/lua/Queue.lua
index 5ab2a8a72c..5bc72e4057 100644
--- a/indra/newview/scripts/lua/Queue.lua
+++ b/indra/newview/scripts/lua/Queue.lua
@@ -7,6 +7,8 @@
 -- But had to resist
 -- For fear it might be too obscua. 
 
+local util = require 'util'
+
 local Queue = {}
 
 function Queue:new()
@@ -20,6 +22,8 @@ function Queue:new()
     return obj
 end
 
+util.classctor(Queue)
+
 -- Check if the queue is empty
 function Queue:IsEmpty()
     return self._first > self._last
diff --git a/indra/newview/scripts/lua/WaitQueue.lua b/indra/newview/scripts/lua/WaitQueue.lua
index 6bcb9d62c2..7e10d03295 100644
--- a/indra/newview/scripts/lua/WaitQueue.lua
+++ b/indra/newview/scripts/lua/WaitQueue.lua
@@ -4,14 +4,15 @@
 
 local fiber = require('fiber')
 local Queue = require('Queue')
+local util  = require('util')
 
 local function dbg(...) end
 -- local dbg = require('printf')
 
-local WaitQueue = Queue:new()
+local WaitQueue = Queue()
 
 function WaitQueue:new()
-    local obj = Queue:new()
+    local obj = Queue()
     setmetatable(obj, self)
     self.__index = self
 
@@ -20,6 +21,8 @@ function WaitQueue:new()
     return obj
 end
 
+util.classctor(WaitQueue)
+
 function WaitQueue:Enqueue(value)
     if self._closed then
         error("can't Enqueue() on closed Queue")
diff --git a/indra/newview/scripts/lua/leap.lua b/indra/newview/scripts/lua/leap.lua
index 8caae24e94..82f91ce9e9 100644
--- a/indra/newview/scripts/lua/leap.lua
+++ b/indra/newview/scripts/lua/leap.lua
@@ -43,6 +43,7 @@ local ErrorQueue = require('ErrorQueue')
 local inspect = require('inspect')
 local function dbg(...) end 
 -- local dbg = require('printf')
+local util = require('util')
 
 local leap = {}
 
@@ -129,7 +130,7 @@ local function requestSetup(pump, data)
     -- because, unlike the WaitFor base class, WaitForReqid does not
     -- self-register on our waitfors list. Instead, capture the new
     -- WaitForReqid object in pending so dispatch() can find it.
-    local waitfor = leap.WaitForReqid:new(reqid)
+    local waitfor = leap.WaitForReqid(reqid)
     pending[reqid] = waitfor
     -- Pass reqid to send() to stamp it into (a copy of) the request data.
     dbg('requestSetup(%s, %s) storing %s', pump, data, waitfor.name)
@@ -432,7 +433,7 @@ function leap.WaitFor:new(priority, name)
         self._id += 1
         obj.name = 'WaitFor' .. self._id
     end
-    obj._queue = ErrorQueue:new()
+    obj._queue = ErrorQueue()
     obj._registered = false
     -- if no priority, then don't enable() - remember 0 is truthy
     if priority then
@@ -442,6 +443,8 @@ function leap.WaitFor:new(priority, name)
     return obj
 end
 
+util.classctor(leap.WaitFor)
+
 -- Re-enable a disable()d WaitFor object. New WaitFor objects are
 -- enable()d by default.
 function leap.WaitFor:enable()
@@ -514,13 +517,13 @@ function leap.WaitFor:exception(message)
 end
 
 -- ------------------------------ WaitForReqid -------------------------------
-leap.WaitForReqid = leap.WaitFor:new()
+leap.WaitForReqid = leap.WaitFor()
 
 function leap.WaitForReqid:new(reqid)
     -- priority is meaningless, since this object won't be added to the
     -- priority-sorted waitfors list. Use the reqid as the debugging name
     -- string.
-    local obj = leap.WaitFor:new(nil, 'WaitForReqid(' .. reqid .. ')')
+    local obj = leap.WaitFor(nil, 'WaitForReqid(' .. reqid .. ')')
     setmetatable(obj, self)
     self.__index = self
 
@@ -529,6 +532,8 @@ function leap.WaitForReqid:new(reqid)
     return obj
 end
 
+util.classctor(leap.WaitForReqid)
+
 function leap.WaitForReqid:filter(pump, data)
     -- Because we expect to directly look up the WaitForReqid object of
     -- interest based on the incoming ["reqid"] value, it's not necessary
diff --git a/indra/newview/scripts/lua/qtest.lua b/indra/newview/scripts/lua/qtest.lua
index 009446d0c3..9526f58b04 100644
--- a/indra/newview/scripts/lua/qtest.lua
+++ b/indra/newview/scripts/lua/qtest.lua
@@ -21,8 +21,8 @@ function resume(co, ...)
 end
 
 -- ------------------ Queue variables are instance-specific ------------------
-q1 = Queue:new()
-q2 = Queue:new()
+q1 = Queue()
+q2 = Queue()
 
 q1:Enqueue(17)
 
@@ -33,8 +33,8 @@ assert(q1:Dequeue() == nil)
 assert(q2:Dequeue() == nil)
 
 -- ----------------------------- test WaitQueue ------------------------------
-q1 = WaitQueue:new()
-q2 = WaitQueue:new()
+q1 = WaitQueue()
+q2 = WaitQueue()
 result = {}
 values = { 1, 1, 2, 3, 5, 8, 13, 21 }
 
@@ -76,7 +76,7 @@ print('result:', inspect(result))
 assert(util.equal(values, result))
 
 -- try incrementally enqueueing values
-q3 = WaitQueue:new()
+q3 = WaitQueue()
 result = {}
 values = { 'This', 'is', 'a', 'test', 'script' }
 
@@ -124,7 +124,7 @@ print(string.format('%q', table.concat(result, ' ')))
 assert(util.equal(values, result))
 
 -- ----------------------------- test ErrorQueue -----------------------------
-q4 = ErrorQueue:new()
+q4 = ErrorQueue()
 result = {}
 values = { 'This', 'is', 'a', 'test', 'script' }
 
diff --git a/indra/newview/scripts/lua/test_luafloater_demo.lua b/indra/newview/scripts/lua/test_luafloater_demo.lua
index ab638dcdd1..65a31670c8 100644
--- a/indra/newview/scripts/lua/test_luafloater_demo.lua
+++ b/indra/newview/scripts/lua/test_luafloater_demo.lua
@@ -60,7 +60,7 @@ local resp = leap.request("LLFloaterReg", key)
 COMMAND_PUMP_NAME = resp.command_name
 reqid = resp.reqid
 
-catch_events = leap.WaitFor:new(-1, "all_events")
+catch_events = leap.WaitFor(-1, "all_events")
 function catch_events:filter(pump, data)
   if data.reqid == reqid then
     return data
diff --git a/indra/newview/scripts/lua/test_luafloater_demo2.lua b/indra/newview/scripts/lua/test_luafloater_demo2.lua
index 9e24237d28..3903d01e65 100644
--- a/indra/newview/scripts/lua/test_luafloater_demo2.lua
+++ b/indra/newview/scripts/lua/test_luafloater_demo2.lua
@@ -2,7 +2,7 @@ local Floater = require 'Floater'
 local leap = require 'leap'
 local startup = require 'startup'
 
-local flt = Floater:new(
+local flt = Floater(
     'luafloater_demo.xml',
     {show_time_lbl = {"right_mouse_down", "double_click"}})
 
diff --git a/indra/newview/scripts/lua/test_luafloater_gesture_list.lua b/indra/newview/scripts/lua/test_luafloater_gesture_list.lua
index 3d9a9b0ad4..a5fd325430 100644
--- a/indra/newview/scripts/lua/test_luafloater_gesture_list.lua
+++ b/indra/newview/scripts/lua/test_luafloater_gesture_list.lua
@@ -58,7 +58,7 @@ local key = {xml_path = XML_FILE_PATH, op = "showLuaFloater"}
 key.extra_events={gesture_list = {_event("double_click")}}
 handleEvents(leap.request("LLFloaterReg", key))
 
-catch_events = leap.WaitFor:new(-1, "all_events")
+catch_events = leap.WaitFor(-1, "all_events")
 function catch_events:filter(pump, data)
   if data.reqid == reqid then
     return data
diff --git a/indra/newview/scripts/lua/test_luafloater_gesture_list2.lua b/indra/newview/scripts/lua/test_luafloater_gesture_list2.lua
index d702d09c51..bd397ef2a6 100644
--- a/indra/newview/scripts/lua/test_luafloater_gesture_list2.lua
+++ b/indra/newview/scripts/lua/test_luafloater_gesture_list2.lua
@@ -2,7 +2,7 @@ local Floater = require 'Floater'
 local LLGesture = require 'LLGesture'
 local startup = require 'startup'
 
-local flt = Floater:new(
+local flt = Floater(
     "luafloater_gesture_list.xml",
     {gesture_list = {"double_click"}})
 
diff --git a/indra/newview/scripts/lua/test_timers.lua b/indra/newview/scripts/lua/test_timers.lua
index ed0de070f7..be5001aa16 100644
--- a/indra/newview/scripts/lua/test_timers.lua
+++ b/indra/newview/scripts/lua/test_timers.lua
@@ -6,9 +6,9 @@ local timers = require 'timers'
 -- is true, that timeUntilCall() is (true, close to 10), that cancel() returns
 -- true. After that, isRunning() is false, timeUntilCall() returns (false, 0),
 -- and a second cancel() returns false.
-print('t0:new(10)')
+print('t0(10)')
 start = os.clock()
-t0 = timers.Timer:new(10, function() print('t0 fired at', os.clock() - start) end)
+t0 = timers.Timer(10, function() print('t0 fired at', os.clock() - start) end)
 print('t0:isRunning(): ', t0:isRunning())
 print('t0:timeUntilCall(): ', t0:timeUntilCall())
 print('t0:cancel(): ', t0:cancel())
@@ -18,16 +18,16 @@ print('t0:cancel(): ', t0:cancel())
 
 -- t1 is supposed to fire after 5 seconds, but it doesn't wait, so you see the
 -- t2 messages immediately after.
-print('t1:new(5)')
+print('t1(5)')
 start = os.clock()
-t1 = timers.Timer:new(5, function() print('t1 fired at', os.clock() - start) end)
+t1 = timers.Timer(5, function() print('t1 fired at', os.clock() - start) end)
 
 -- t2 illustrates that instead of passing a callback to new(), you can
 -- override the timer instance's tick() method. But t2 doesn't wait either, so
 -- you see the Timer(5) message immediately.
-print('t2:new(2)')
+print('t2(2)')
 start = os.clock()
-t2 = timers.Timer:new(2)
+t2 = timers.Timer(2)
 function t2:tick()
     print('t2 fired at', os.clock() - start)
 end
@@ -37,7 +37,7 @@ end
 -- then the t1 callback message before the Timer(5) completion message.
 print('Timer(5) waiting')
 start = os.clock()
-timers.Timer:new(5, 'wait')
+timers.Timer(5, 'wait')
 print(string.format('Timer(5) waited %f seconds', os.clock() - start))
 
 -- This test demonstrates a repeating timer. It also shows that you can (but
@@ -50,7 +50,7 @@ print(string.format('Timer(5) waited %f seconds', os.clock() - start))
 -- it's worth knowing that a coroutine timer callback can be used to manage
 -- more complex control flows.
 start = os.clock()
-timers.Timer:new(
+timers.Timer(
     2,
     coroutine.wrap(function()
             for i = 1,5 do
diff --git a/indra/newview/scripts/lua/timers.lua b/indra/newview/scripts/lua/timers.lua
index e0d27a680d..e4938078dc 100644
--- a/indra/newview/scripts/lua/timers.lua
+++ b/indra/newview/scripts/lua/timers.lua
@@ -1,6 +1,7 @@
 -- Access to the viewer's time-delay facilities
 
 local leap = require 'leap'
+local util = require 'util'
 
 local timers = {}
 
@@ -78,6 +79,8 @@ function timers.Timer:new(delay, callback, iterate)
     return obj
 end
 
+util.classctor(timers.Timer)
+
 function timers.Timer:tick()
     error('Pass a callback to Timer:new(), or override Timer:tick()')
 end
diff --git a/indra/newview/scripts/lua/util.lua b/indra/newview/scripts/lua/util.lua
index a2191288f6..bfbfc8637c 100644
--- a/indra/newview/scripts/lua/util.lua
+++ b/indra/newview/scripts/lua/util.lua
@@ -2,6 +2,31 @@
 
 local util = {}
 
+-- Allow MyClass(ctor args...) equivalent to MyClass:new(ctor args...)
+-- Usage:
+-- local MyClass = {}
+-- function MyClass:new(...)
+--     ...
+-- end
+-- ...
+-- util.classctor(MyClass)
+-- or if your constructor is named something other than MyClass:new(), e.g.
+-- MyClass:construct():
+-- util.classctor(MyClass, MyClass.construct)
+-- return MyClass
+function util.classctor(class, ctor)
+    -- get the metatable for the passed class
+    local mt = getmetatable(class)
+    if mt == nil then
+        -- if it doesn't already have a metatable, then create one
+        mt = {}
+        setmetatable(class, mt)
+    end
+    -- now that class has a metatable, set its __call method to the specified
+    -- constructor method (class.new if not specified)
+    mt.__call = ctor or class.new
+end
+
 -- check if array-like table contains certain value
 function util.contains(t, v)
     return table.find(t, v) ~= nil
-- 
cgit v1.2.3


From f2020bff30808d28aec06cce5fed61717fcde7fc Mon Sep 17 00:00:00 2001
From: Nat Goodspeed <nat@lindenlab.com>
Date: Tue, 11 Jun 2024 21:50:35 -0400
Subject: Fix a couple bugs in startup.lua.

The 'startup' table, the module's namespace, must be defined near the top
because its local waitfor:process() override references startup.

The byname table's metatable's __index() function wants to raise an error if
you try to access an undefined entry, but it referenced t[k] to check that,
producing infinite recursion. Use rawget(t, k) instead.

Also use new leap.WaitFor(args) syntax instead of leap.WaitFor:new(args).
---
 indra/newview/scripts/lua/startup.lua | 9 ++++-----
 1 file changed, 4 insertions(+), 5 deletions(-)

(limited to 'indra/newview/scripts')

diff --git a/indra/newview/scripts/lua/startup.lua b/indra/newview/scripts/lua/startup.lua
index 4311bb9a60..c3040f94b8 100644
--- a/indra/newview/scripts/lua/startup.lua
+++ b/indra/newview/scripts/lua/startup.lua
@@ -12,6 +12,8 @@ local function dbg(...) end
 -- local dbg = require 'printf'
 
 -- ---------------------------------------------------------------------------
+local startup = {}
+
 -- Get the list of startup states from the viewer.
 local bynum = leap.request('LLStartUp', {op='getStateTable'})['table']
 
@@ -19,7 +21,7 @@ local byname = setmetatable(
     {},
     -- set metatable to throw an error if you look up invalid state name
     {__index=function(t, k)
-         local v = t[k]
+         local v = rawget(t, k)
          if v then
              return v
          end
@@ -35,7 +37,7 @@ end
 
 -- specialize a WaitFor to track the viewer's startup state
 local startup_pump = 'StartupState'
-local waitfor = leap.WaitFor:new(0, startup_pump)
+local waitfor = leap.WaitFor(0, startup_pump)
 function waitfor:filter(pump, data)
     if pump == self.name then
         return data
@@ -57,8 +59,6 @@ leap.request(leap.cmdpump(),
 leap.send('LLStartUp', {op='postStartupState'})
 
 -- ---------------------------------------------------------------------------
-startup = {}
-
 -- wait for response from postStartupState
 while not startup._state do
     dbg('startup.state() waiting for first StartupState event')
@@ -98,4 +98,3 @@ function startup.wait(state)
 end
 
 return startup
-
-- 
cgit v1.2.3


From 44182d0719c209aabe0d80aea291a9e3e45b1e59 Mon Sep 17 00:00:00 2001
From: Nat Goodspeed <nat@lindenlab.com>
Date: Tue, 11 Jun 2024 21:59:31 -0400
Subject: Add to UI.lua a set of 'LLWindow' listener operations.

Add listviews(), viewinfo(), click(), doubleclick(), drag(), keypress() and
type().

WIP: These are ported from Python LEAP equivalents, but the Lua implementation
has only been partially tested.
---
 indra/newview/scripts/lua/UI.lua | 113 ++++++++++++++++++++++++++++++++++++++-
 1 file changed, 111 insertions(+), 2 deletions(-)

(limited to 'indra/newview/scripts')

diff --git a/indra/newview/scripts/lua/UI.lua b/indra/newview/scripts/lua/UI.lua
index 24f822bbd9..eb1a4017c7 100644
--- a/indra/newview/scripts/lua/UI.lua
+++ b/indra/newview/scripts/lua/UI.lua
@@ -1,9 +1,14 @@
--- Engage the UI LLEventAPI
+-- Engage the viewer's UI
 
-leap = require 'leap'
+local leap = require 'leap'
+local Timer = (require 'timers').Timer
+local mapargs = require 'mapargs'
 
 local UI = {}
 
+-- ***************************************************************************
+--  registered menu actions
+-- ***************************************************************************
 function UI.call(func, parameter)
     -- 'call' is fire-and-forget
     leap.request('UI', {op='call', ['function']=func, parameter=parameter})
@@ -13,4 +18,108 @@ function UI.getValue(path)
     return leap.request('UI', {op='getValue', path=path})['value']
 end
 
+-- ***************************************************************************
+--  UI views
+-- ***************************************************************************
+-- Either:
+-- wreq{op='Something', a=1, b=2, ...}
+-- or:
+-- (args should be local, as this wreq() call modifies it)
+-- local args = {a=1, b=2, ...}
+-- wreq('Something', args)
+local function wreq(op_or_data, data_if_op)
+    if data_if_op ~= nil then
+        -- this is the wreq(op, data) form
+        data_if_op.op = op_or_data
+        op_or_data = data_if_op
+    end
+    return leap.request('LLWindow', op_or_data)
+end
+
+-- omit 'parent' to list all view paths
+function UI.listviews(parent)
+    return wreq{op='getPaths', under=parent}
+end
+
+function UI.viewinfo(path)
+    return wreq{op='getInfo', path=path}
+end
+
+-- ***************************************************************************
+--  mouse actions
+-- ***************************************************************************
+-- pass a table:
+-- UI.click{path=path
+--          [, button='LEFT' | 'CENTER' | 'RIGHT']
+--          [, x=x, y=y]
+--          [, hold=duration]}
+function UI.click(...)
+    local args = mapargs('path,button,x,y,hold', ...)
+    args.button = args.button or 'LEFT'
+    local hold = args.hold or 1.0
+    wreq('mouseMove', args)
+    wreq('mouseDown', args)
+    Timer(hold, 'wait')
+    wreq('mouseUp', args)
+end
+
+-- pass a table as for UI.click()
+function UI.doubleclick(...)
+    local args = mapargs('path,button,x,y', ...)
+    args.button = args.button or 'LEFT'
+    wreq('mouseDown', args)
+    wreq('mouseUp',   args)
+    wreq('mouseDown', args)
+    wreq('mouseUp',   args)
+end
+
+-- UI.drag{path=, xoff=, yoff=}
+function UI.drag(...)
+    local args = mapargs('path,xoff,yoff', ...)
+    -- query the specified path
+    local rect = UI.viewinfo(args.path).rect
+    local centerx = math.floor(rect.left   + (rect.right - rect.left)/2)
+    local centery = math.floor(rect.bottom + (rect.top   - rect.bottom)/2)
+    wreq{op='mouseMove', path=args.path, x=centerx, y=centery}
+    wreq{op='mouseDown', path=args.path, button='LEFT'}
+    wreq{op='mouseMove', path=args.path, x=centerx + args.xoff, y=centery + args.yoff}
+    wreq{op='mouseUp',   path=args.path, button='LEFT'}
+end
+
+-- ***************************************************************************
+--  keyboard actions
+-- ***************************************************************************
+-- pass a table:
+-- UI.keypress{
+--     [path=path]                      -- if omitted, default input field
+--     [, char='x']                     -- requires one of char, keycode, keysym
+--     [, keycode=120]
+--     keysym per https://github.com/secondlife/viewer/blob/main/indra/llwindow/llkeyboard.cpp#L68-L124
+--     [, keysym='Enter']
+--     [, mask={'SHIFT', 'CTL', 'ALT', 'MAC_CONTROL'}]  -- some subset of these
+--     }
+function UI.keypress(...)
+    local args = mapargs('path,char,keycode,keysym,mask', ...)
+    if args.char == '\n' then
+        args.char = nil
+        args.keysym = 'Enter'
+    end
+    return wreq('keyDown', args)
+end
+
+-- UI.type{text=, path=}
+function UI.type(...)
+    local args = mapargs('text,path', ...)
+    if #args.text > 0 then
+        -- The caller's path may be specified in a way that requires recursively
+        -- searching parts of the LLView tree. No point in doing that more than
+        -- once. Capture the actual path found by that first call and use that for
+        -- subsequent calls.
+        local path = UI.keypress{path=args.path, char=string.sub(args.text, 1, 1)}.path
+        for i = 2, #args.text do
+            UI.keypress{path=path, char=string.sub(args.text, i, i)}
+        end
+    end
+end
+
 return UI
-- 
cgit v1.2.3


From beb28c4351f3ef622c45f3603df0ba9c5e162793 Mon Sep 17 00:00:00 2001
From: Nat Goodspeed <nat@lindenlab.com>
Date: Tue, 11 Jun 2024 22:01:40 -0400
Subject: Add login.lua module with login() function.

The nullary login() call (login with saved credentials) has been tested, but
the binary login(username, password) call is known not to work yet.
---
 indra/newview/scripts/lua/login.lua      | 19 +++++++++++++++++++
 indra/newview/scripts/lua/test_login.lua |  7 +++++++
 2 files changed, 26 insertions(+)
 create mode 100644 indra/newview/scripts/lua/login.lua
 create mode 100644 indra/newview/scripts/lua/test_login.lua

(limited to 'indra/newview/scripts')

diff --git a/indra/newview/scripts/lua/login.lua b/indra/newview/scripts/lua/login.lua
new file mode 100644
index 0000000000..0d8591cace
--- /dev/null
+++ b/indra/newview/scripts/lua/login.lua
@@ -0,0 +1,19 @@
+local UI = require 'UI'
+local leap = require 'leap'
+
+local function login(username, password)
+    if username and password then
+        local userpath = '//username_combo/Combo Text Entry'
+        local passpath = '//password_edit'
+        -- first clear anything presently in those text fields
+        for _, path in pairs({userpath, passpath}) do
+            UI.click(path)
+            UI.keypress{keysym='Backsp', path=path}
+        end
+        UI.type{path=userpath, text=username}
+        UI.type{path=passpath, text=password}
+    end
+    leap.send('LLPanelLogin', {op='onClickConnect'})
+end
+
+return login
diff --git a/indra/newview/scripts/lua/test_login.lua b/indra/newview/scripts/lua/test_login.lua
new file mode 100644
index 0000000000..6df52b08c2
--- /dev/null
+++ b/indra/newview/scripts/lua/test_login.lua
@@ -0,0 +1,7 @@
+startup = require 'startup'
+login = require 'login'
+
+startup.wait('STATE_LOGIN_WAIT')
+login()
+-- WIP: not working as of 2024-06-11
+-- login('My Username', 'password')
-- 
cgit v1.2.3


From f95dc89d5e7481f4e02953617ce7a13feb87d27a Mon Sep 17 00:00:00 2001
From: Nat Goodspeed <nat@lindenlab.com>
Date: Tue, 11 Jun 2024 22:05:00 -0400
Subject: Add popup.lua, a preliminary API for viewer notifications.

WIP: This is known not to work yet.
---
 indra/newview/scripts/lua/popup.lua | 32 ++++++++++++++++++++++++++++++++
 1 file changed, 32 insertions(+)
 create mode 100644 indra/newview/scripts/lua/popup.lua

(limited to 'indra/newview/scripts')

diff --git a/indra/newview/scripts/lua/popup.lua b/indra/newview/scripts/lua/popup.lua
new file mode 100644
index 0000000000..65b04b513e
--- /dev/null
+++ b/indra/newview/scripts/lua/popup.lua
@@ -0,0 +1,32 @@
+leap = require 'leap'
+
+-- notification is any name defined in notifications.xml as
+-- <notification name=>
+-- vars is a table providing values for [VAR] substitution keys in the
+-- notification body.
+local popup_meta = {
+    -- setting this function as getmetatable(popup).__call() means this gets
+    -- called when a consumer calls popup(notification, vars, payload)
+    __call = function(self, notification, vars, payload)
+        return leap.request('LLNotifications',
+                            {op='requestAdd', name=notification,
+                             substitutions=vars,
+                             payload=payload or {}})
+    end
+}
+
+local popup = setmetatable({}, popup_meta)
+
+function popup:alert(message)
+    return self('GenericAlert', {MESSAGE=message})
+end
+
+function popup:alertOK(message)
+    return self('GenericAlertOK', {MESSAGE=message})
+end
+
+function popup:alertYesCancel(message)
+    return self('GenericAlertYesCancel', {MESSAGE=message})
+end
+
+return popup
-- 
cgit v1.2.3


From 241156cf9831e30a3bbb529478e73aaf233a759b Mon Sep 17 00:00:00 2001
From: Nat Goodspeed <nat@lindenlab.com>
Date: Wed, 12 Jun 2024 16:45:35 -0400
Subject: Make popup() directly pass payload.

The expression (payload or {}) is unnecessary, since that value will be
converted to LLSD -- and both Lua nil and empty table convert to
LLSD::isUndefined().
---
 indra/newview/scripts/lua/popup.lua | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'indra/newview/scripts')

diff --git a/indra/newview/scripts/lua/popup.lua b/indra/newview/scripts/lua/popup.lua
index 65b04b513e..9eecc46753 100644
--- a/indra/newview/scripts/lua/popup.lua
+++ b/indra/newview/scripts/lua/popup.lua
@@ -11,7 +11,7 @@ local popup_meta = {
         return leap.request('LLNotifications',
                             {op='requestAdd', name=notification,
                              substitutions=vars,
-                             payload=payload or {}})
+                             payload=payload})
     end
 }
 
-- 
cgit v1.2.3


From 7603ba216f35b44327c7fe9ed0a77d69356e0395 Mon Sep 17 00:00:00 2001
From: Nat Goodspeed <nat@lindenlab.com>
Date: Wed, 12 Jun 2024 17:32:51 -0400
Subject: Avoid messing up Lua's global namespace in 'require' modules.

---
 indra/newview/scripts/lua/LLChat.lua          | 2 +-
 indra/newview/scripts/lua/LLDebugSettings.lua | 2 +-
 indra/newview/scripts/lua/LLFloaterAbout.lua  | 2 +-
 indra/newview/scripts/lua/LLGesture.lua       | 2 +-
 indra/newview/scripts/lua/popup.lua           | 2 +-
 5 files changed, 5 insertions(+), 5 deletions(-)

(limited to 'indra/newview/scripts')

diff --git a/indra/newview/scripts/lua/LLChat.lua b/indra/newview/scripts/lua/LLChat.lua
index 7db538e837..78dca765e8 100644
--- a/indra/newview/scripts/lua/LLChat.lua
+++ b/indra/newview/scripts/lua/LLChat.lua
@@ -1,4 +1,4 @@
-leap = require 'leap'
+local leap = require 'leap'
 
 local LLChat = {}
 
diff --git a/indra/newview/scripts/lua/LLDebugSettings.lua b/indra/newview/scripts/lua/LLDebugSettings.lua
index c250019a00..cff1a63c21 100644
--- a/indra/newview/scripts/lua/LLDebugSettings.lua
+++ b/indra/newview/scripts/lua/LLDebugSettings.lua
@@ -1,4 +1,4 @@
-leap = require 'leap'
+local leap = require 'leap'
 
 local LLDebugSettings = {}
 
diff --git a/indra/newview/scripts/lua/LLFloaterAbout.lua b/indra/newview/scripts/lua/LLFloaterAbout.lua
index 44afee2e5c..a6e42d364f 100644
--- a/indra/newview/scripts/lua/LLFloaterAbout.lua
+++ b/indra/newview/scripts/lua/LLFloaterAbout.lua
@@ -1,6 +1,6 @@
 -- Engage the LLFloaterAbout LLEventAPI
 
-leap = require 'leap'
+local leap = require 'leap'
 
 local LLFloaterAbout = {}
 
diff --git a/indra/newview/scripts/lua/LLGesture.lua b/indra/newview/scripts/lua/LLGesture.lua
index cb410446d7..343b611e2c 100644
--- a/indra/newview/scripts/lua/LLGesture.lua
+++ b/indra/newview/scripts/lua/LLGesture.lua
@@ -1,6 +1,6 @@
 -- Engage the LLGesture LLEventAPI
 
-leap = require 'leap'
+local leap = require 'leap'
 
 local LLGesture = {}
 
diff --git a/indra/newview/scripts/lua/popup.lua b/indra/newview/scripts/lua/popup.lua
index 9eecc46753..8a01ab7836 100644
--- a/indra/newview/scripts/lua/popup.lua
+++ b/indra/newview/scripts/lua/popup.lua
@@ -1,4 +1,4 @@
-leap = require 'leap'
+local leap = require 'leap'
 
 -- notification is any name defined in notifications.xml as
 -- <notification name=>
-- 
cgit v1.2.3


From 81a153da87f56e4db0a38ebb94a9c72471e0b002 Mon Sep 17 00:00:00 2001
From: Mnikolenko Productengine <mnikolenko@productengine.com>
Date: Fri, 14 Jun 2024 15:39:35 +0300
Subject: Add nearby chat listener

---
 indra/newview/scripts/lua/LLChatListener.lua      | 41 +++++++++++++++++++++++
 indra/newview/scripts/lua/test_LLChatListener.lua | 27 +++++++++++++++
 2 files changed, 68 insertions(+)
 create mode 100644 indra/newview/scripts/lua/LLChatListener.lua
 create mode 100644 indra/newview/scripts/lua/test_LLChatListener.lua

(limited to 'indra/newview/scripts')

diff --git a/indra/newview/scripts/lua/LLChatListener.lua b/indra/newview/scripts/lua/LLChatListener.lua
new file mode 100644
index 0000000000..d615ae5dbc
--- /dev/null
+++ b/indra/newview/scripts/lua/LLChatListener.lua
@@ -0,0 +1,41 @@
+local fiber = require 'fiber'
+local inspect = require 'inspect'
+
+local LLChatListener = {}
+local waitfor = {}
+
+function LLChatListener:new()
+    local obj = setmetatable({}, self)
+    self.__index = self
+    obj.name = 'Chat_listener'
+
+    return obj
+end
+
+function LLChatListener:handleMessages(event_data)
+    --print(inspect(event_data))
+    return true
+end
+
+function LLChatListener:start()
+    waitfor = leap.WaitFor:new(-1, self.name)
+    function waitfor:filter(pump, data)
+        return data
+    end
+
+    fiber.launch(self.name, function()
+        event = waitfor:wait()
+        while event and self:handleMessages(event) do
+          event = waitfor:wait()
+        end
+    end)
+
+    leap.send('LLChatBar', {op='listen'})
+end
+
+function LLChatListener:stop()
+    leap.send('LLChatBar', {op='stopListening'})
+    waitfor:close()
+end
+
+return LLChatListener
diff --git a/indra/newview/scripts/lua/test_LLChatListener.lua b/indra/newview/scripts/lua/test_LLChatListener.lua
new file mode 100644
index 0000000000..2c7b1dc3e5
--- /dev/null
+++ b/indra/newview/scripts/lua/test_LLChatListener.lua
@@ -0,0 +1,27 @@
+local LLChatListener = require 'LLChatListener'
+local LLChat = require 'LLChat'
+
+function openOrEcho(message)
+    local floater_name = string.match(message, "^open%s+(%w+)")
+    if floater_name then
+      leap.send("LLFloaterReg", {name = floater_name, op = "showInstance"})
+    else
+      LLChat.sendNearby('Echo: ' .. message)
+    end
+end
+
+local listener = LLChatListener:new()
+
+function listener:handleMessages(event_data)
+    if string.find(event_data.message, '[LUA]') then
+      return true
+    elseif event_data.message == 'stop' then
+      LLChat.sendNearby('Closing echo script.')
+      return false
+    else
+      openOrEcho(event_data.message)
+    end
+    return LLChatListener.handleMessages(self, event_data)
+end
+
+listener:start()
-- 
cgit v1.2.3


From f7137765438f149cbae6f3b18da45dce75a25336 Mon Sep 17 00:00:00 2001
From: Nat Goodspeed <nat@lindenlab.com>
Date: Fri, 14 Jun 2024 12:16:12 -0400
Subject: Move Lua modules for 'require' to indra/newview/scripts/lua/require.

Make viewer_manifest.py copy them into the viewer install image.

Make the require() function look for them there.
---
 indra/newview/scripts/lua/ErrorQueue.lua           |  37 --
 indra/newview/scripts/lua/Floater.lua              | 146 ------
 indra/newview/scripts/lua/LLChat.lua               |  17 -
 indra/newview/scripts/lua/LLDebugSettings.lua      |  17 -
 indra/newview/scripts/lua/LLFloaterAbout.lua       |  11 -
 indra/newview/scripts/lua/LLGesture.lua            |  23 -
 indra/newview/scripts/lua/Queue.lua                |  51 --
 indra/newview/scripts/lua/UI.lua                   | 125 -----
 indra/newview/scripts/lua/WaitQueue.lua            |  88 ----
 indra/newview/scripts/lua/coro.lua                 |  67 ---
 indra/newview/scripts/lua/fiber.lua                | 340 -------------
 indra/newview/scripts/lua/inspect.lua              | 371 --------------
 indra/newview/scripts/lua/leap.lua                 | 550 ---------------------
 indra/newview/scripts/lua/printf.lua               |  19 -
 indra/newview/scripts/lua/require/ErrorQueue.lua   |  37 ++
 indra/newview/scripts/lua/require/Floater.lua      | 146 ++++++
 indra/newview/scripts/lua/require/LLChat.lua       |  17 +
 .../scripts/lua/require/LLDebugSettings.lua        |  17 +
 .../newview/scripts/lua/require/LLFloaterAbout.lua |  11 +
 indra/newview/scripts/lua/require/LLGesture.lua    |  23 +
 indra/newview/scripts/lua/require/Queue.lua        |  51 ++
 indra/newview/scripts/lua/require/UI.lua           | 125 +++++
 indra/newview/scripts/lua/require/WaitQueue.lua    |  88 ++++
 indra/newview/scripts/lua/require/coro.lua         |  67 +++
 indra/newview/scripts/lua/require/fiber.lua        | 340 +++++++++++++
 indra/newview/scripts/lua/require/inspect.lua      | 371 ++++++++++++++
 indra/newview/scripts/lua/require/leap.lua         | 550 +++++++++++++++++++++
 indra/newview/scripts/lua/require/printf.lua       |  19 +
 indra/newview/scripts/lua/require/startup.lua      | 100 ++++
 indra/newview/scripts/lua/require/timers.lua       | 104 ++++
 indra/newview/scripts/lua/require/util.lua         |  69 +++
 indra/newview/scripts/lua/startup.lua              | 100 ----
 indra/newview/scripts/lua/timers.lua               | 104 ----
 indra/newview/scripts/lua/util.lua                 |  69 ---
 34 files changed, 2135 insertions(+), 2135 deletions(-)
 delete mode 100644 indra/newview/scripts/lua/ErrorQueue.lua
 delete mode 100644 indra/newview/scripts/lua/Floater.lua
 delete mode 100644 indra/newview/scripts/lua/LLChat.lua
 delete mode 100644 indra/newview/scripts/lua/LLDebugSettings.lua
 delete mode 100644 indra/newview/scripts/lua/LLFloaterAbout.lua
 delete mode 100644 indra/newview/scripts/lua/LLGesture.lua
 delete mode 100644 indra/newview/scripts/lua/Queue.lua
 delete mode 100644 indra/newview/scripts/lua/UI.lua
 delete mode 100644 indra/newview/scripts/lua/WaitQueue.lua
 delete mode 100644 indra/newview/scripts/lua/coro.lua
 delete mode 100644 indra/newview/scripts/lua/fiber.lua
 delete mode 100644 indra/newview/scripts/lua/inspect.lua
 delete mode 100644 indra/newview/scripts/lua/leap.lua
 delete mode 100644 indra/newview/scripts/lua/printf.lua
 create mode 100644 indra/newview/scripts/lua/require/ErrorQueue.lua
 create mode 100644 indra/newview/scripts/lua/require/Floater.lua
 create mode 100644 indra/newview/scripts/lua/require/LLChat.lua
 create mode 100644 indra/newview/scripts/lua/require/LLDebugSettings.lua
 create mode 100644 indra/newview/scripts/lua/require/LLFloaterAbout.lua
 create mode 100644 indra/newview/scripts/lua/require/LLGesture.lua
 create mode 100644 indra/newview/scripts/lua/require/Queue.lua
 create mode 100644 indra/newview/scripts/lua/require/UI.lua
 create mode 100644 indra/newview/scripts/lua/require/WaitQueue.lua
 create mode 100644 indra/newview/scripts/lua/require/coro.lua
 create mode 100644 indra/newview/scripts/lua/require/fiber.lua
 create mode 100644 indra/newview/scripts/lua/require/inspect.lua
 create mode 100644 indra/newview/scripts/lua/require/leap.lua
 create mode 100644 indra/newview/scripts/lua/require/printf.lua
 create mode 100644 indra/newview/scripts/lua/require/startup.lua
 create mode 100644 indra/newview/scripts/lua/require/timers.lua
 create mode 100644 indra/newview/scripts/lua/require/util.lua
 delete mode 100644 indra/newview/scripts/lua/startup.lua
 delete mode 100644 indra/newview/scripts/lua/timers.lua
 delete mode 100644 indra/newview/scripts/lua/util.lua

(limited to 'indra/newview/scripts')

diff --git a/indra/newview/scripts/lua/ErrorQueue.lua b/indra/newview/scripts/lua/ErrorQueue.lua
deleted file mode 100644
index e6e9a5ef48..0000000000
--- a/indra/newview/scripts/lua/ErrorQueue.lua
+++ /dev/null
@@ -1,37 +0,0 @@
--- ErrorQueue isa WaitQueue with the added feature that a producer can push an
--- error through the queue. Once that error is dequeued, every consumer will
--- raise that error.
-
-local WaitQueue = require('WaitQueue')
-local function dbg(...) end
--- local dbg = require('printf')
-local util = require('util')
-
-local ErrorQueue = WaitQueue()
-
-util.classctor(ErrorQueue)
-
-function ErrorQueue:Error(message)
-    -- Setting Error() is a marker, like closing the queue. Once we reach the
-    -- error, every subsequent Dequeue() call will raise the same error.
-    dbg('Setting self._closed to %q', message)
-    self._closed = message
-    self:_wake_waiters()
-end
-
-function ErrorQueue:Dequeue()
-    local value = WaitQueue.Dequeue(self)
-    dbg('ErrorQueue:Dequeue: base Dequeue() got %s', value)
-    if value ~= nil then
-        -- queue not yet closed, show caller
-        return value
-    end
-    if self._closed == true then
-        -- WaitQueue:close() sets true: queue has only been closed, tell caller
-        return nil
-    end
-    -- self._closed is a message set by Error()
-    error(self._closed)
-end
-
-return ErrorQueue
diff --git a/indra/newview/scripts/lua/Floater.lua b/indra/newview/scripts/lua/Floater.lua
deleted file mode 100644
index d057a74386..0000000000
--- a/indra/newview/scripts/lua/Floater.lua
+++ /dev/null
@@ -1,146 +0,0 @@
--- Floater base class
-
-local leap = require 'leap'
-local fiber = require 'fiber'
-local util = require 'util'
-
--- list of all the events that a LLLuaFloater might send
-local event_list = leap.request("LLFloaterReg", {op="getFloaterEvents"}).events
-local event_set = {}
-for _, event in pairs(event_list) do
-    event_set[event] = true
-end
-
-local function _event(event_name)
-    if not event_set[event_name] then
-        error("Incorrect event name: " .. event_name, 3)
-    end
-    return event_name
-end
-
--- ---------------------------------------------------------------------------
-local Floater = {}
-
--- Pass:
--- relative file path to floater's XUI definition file
--- optional: sign up for additional events for defined control
--- {<control_name>={action1, action2, ...}}
-function Floater:new(path, extra)
-    local obj = setmetatable({}, self)
-    self.__index = self
-
-    local path_parts = string.split(path, '/')
-    obj.name = 'Floater ' .. path_parts[#path_parts]
-
-    obj._command = {op="showLuaFloater", xml_path=LL.abspath(path)}
-    if extra then
-        -- validate each of the actions for each specified control
-        for control, actions in pairs(extra) do
-            for _, action in pairs(actions) do
-                _event(action)
-            end
-        end
-        obj._command.extra_events = extra
-    end
-
-    return obj
-end
-
-util.classctor(Floater)
-
-function Floater:show()
-    -- leap.eventstream() returns the first response, and launches a
-    -- background fiber to call the passed callback with all subsequent
-    -- responses.
-    local event = leap.eventstream(
-        'LLFloaterReg',
-        self._command,
-        -- handleEvents() returns false when done.
-        -- eventstream() expects a true return when done.
-        function(event) return not self:handleEvents(event) end)
-    self._pump = event.command_name
-    -- we might need the returned reqid to cancel the eventstream() fiber
-    self.reqid = event.reqid
-
-    -- The response to 'showLuaFloater' *is* the 'post_build' event. Check if
-    -- subclass has a post_build() method. Honor the convention that if
-    -- handleEvents() returns false, we're done.
-    if not self:handleEvents(event) then
-        return
-    end
-end
-
-function Floater:post(action)
-    leap.send(self._pump, action)
-end
-
-function Floater:request(action)
-    return leap.request(self._pump, action)
-end
-
--- local inspect = require 'inspect'
-
-function Floater:handleEvents(event_data)
-    local event = event_data.event
-    if event_set[event] == nil then
-        LL.print_warning(string.format('%s received unknown event %q', self.name, event))
-    end
-
-    -- Before checking for a general (e.g.) commit() method, first look for
-    -- commit_ctrl_name(): in other words, concatenate the event name with the
-    -- ctrl_name, with an underscore between. If there exists such a specific
-    -- method, call that.
-    local handler, ret
-    if event_data.ctrl_name then
-        local specific = event .. '_' .. event_data.ctrl_name
-        handler = self[specific]
-        if handler then
-            ret = handler(self, event_data)
-            -- Avoid 'return ret or true' because we explicitly want to allow
-            -- the handler to return false.
-            if ret ~= nil then
-                return ret
-            else
-                return true
-            end
-        end
-    end
-
-    -- No specific "event_on_ctrl()" method found; try just "event()"
-    handler = self[event]
-    if handler then
-        ret = handler(self, event_data)
-        if ret ~= nil then
-            return ret
-        end
---  else
---      print(string.format('%s ignoring event %s', self.name, inspect(event_data)))
-    end
-
-    -- We check for event() method before recognizing floater_close in case
-    -- the consumer needs to react specially to closing the floater. Now that
-    -- we've checked, recognize it ourselves. Returning false terminates the
-    -- anonymous fiber function launched by leap.eventstream().
-    if event == _event('floater_close') then
-        LL.print_warning(self.name .. ' closed')
-        return false
-    end
-    return true
-end
-
--- onCtrl() permits a different dispatch style in which the general event()
--- method explicitly calls (e.g.)
--- self:onCtrl(event_data, {
---     ctrl_name=function()
---         self:post(...)
---     end,
---     ...
--- })
-function Floater:onCtrl(event_data, ctrl_map)
-    local handler = ctrl_map[event_data.ctrl_name]
-    if handler then
-        handler()
-    end
-end
-
-return Floater
diff --git a/indra/newview/scripts/lua/LLChat.lua b/indra/newview/scripts/lua/LLChat.lua
deleted file mode 100644
index 78dca765e8..0000000000
--- a/indra/newview/scripts/lua/LLChat.lua
+++ /dev/null
@@ -1,17 +0,0 @@
-local leap = require 'leap'
-
-local LLChat = {}
-
-function LLChat.sendNearby(msg)
-    leap.send('LLChatBar', {op='sendChat', message=msg})
-end
-
-function LLChat.sendWhisper(msg)
-    leap.send('LLChatBar', {op='sendChat', type='whisper', message=msg})
-end
-
-function LLChat.sendShout(msg)
-    leap.send('LLChatBar', {op='sendChat', type='shout', message=msg})
-end
-
-return LLChat
diff --git a/indra/newview/scripts/lua/LLDebugSettings.lua b/indra/newview/scripts/lua/LLDebugSettings.lua
deleted file mode 100644
index cff1a63c21..0000000000
--- a/indra/newview/scripts/lua/LLDebugSettings.lua
+++ /dev/null
@@ -1,17 +0,0 @@
-local leap = require 'leap'
-
-local LLDebugSettings = {}
-
-function LLDebugSettings.set(name, value)
-    leap.request('LLViewerControl', {op='set', group='Global', key=name, value=value})
-end
-
-function LLDebugSettings.toggle(name)
-    leap.request('LLViewerControl', {op='toggle', group='Global', key=name})
-end
-
-function LLDebugSettings.get(name)
-    return leap.request('LLViewerControl', {op='get', group='Global', key=name})['value']
-end
-
-return LLDebugSettings
diff --git a/indra/newview/scripts/lua/LLFloaterAbout.lua b/indra/newview/scripts/lua/LLFloaterAbout.lua
deleted file mode 100644
index a6e42d364f..0000000000
--- a/indra/newview/scripts/lua/LLFloaterAbout.lua
+++ /dev/null
@@ -1,11 +0,0 @@
--- Engage the LLFloaterAbout LLEventAPI
-
-local leap = require 'leap'
-
-local LLFloaterAbout = {}
-
-function LLFloaterAbout.getInfo()
-    return leap.request('LLFloaterAbout', {op='getInfo'})
-end
-
-return LLFloaterAbout
diff --git a/indra/newview/scripts/lua/LLGesture.lua b/indra/newview/scripts/lua/LLGesture.lua
deleted file mode 100644
index 343b611e2c..0000000000
--- a/indra/newview/scripts/lua/LLGesture.lua
+++ /dev/null
@@ -1,23 +0,0 @@
--- Engage the LLGesture LLEventAPI
-
-local leap = require 'leap'
-
-local LLGesture = {}
-
-function LLGesture.getActiveGestures()
-    return leap.request('LLGesture', {op='getActiveGestures'})['gestures']
-end
-
-function LLGesture.isGesturePlaying(id)
-    return leap.request('LLGesture', {op='isGesturePlaying', id=id})['playing']
-end
-
-function LLGesture.startGesture(id)
-    leap.send('LLGesture', {op='startGesture', id=id})
-end
-
-function LLGesture.stopGesture(id)
-    leap.send('LLGesture', {op='stopGesture', id=id})
-end
-
-return LLGesture
diff --git a/indra/newview/scripts/lua/Queue.lua b/indra/newview/scripts/lua/Queue.lua
deleted file mode 100644
index 5bc72e4057..0000000000
--- a/indra/newview/scripts/lua/Queue.lua
+++ /dev/null
@@ -1,51 +0,0 @@
--- from https://create.roblox.com/docs/luau/queues#implementing-queues,
--- amended per https://www.lua.org/pil/16.1.html
-
--- While coding some scripting in Lua
--- I found that I needed a queua
--- I thought of linked list
--- But had to resist
--- For fear it might be too obscua. 
-
-local util = require 'util'
-
-local Queue = {}
-
-function Queue:new()
-    local obj = setmetatable({}, self)
-    self.__index = self
-
-    obj._first = 0
-    obj._last = -1
-    obj._queue = {}
-
-    return obj
-end
-
-util.classctor(Queue)
-
--- Check if the queue is empty
-function Queue:IsEmpty()
-    return self._first > self._last
-end
-
--- Add a value to the queue
-function Queue:Enqueue(value)
-    local last = self._last + 1
-    self._last = last
-    self._queue[last] = value
-end
-
--- Remove a value from the queue
-function Queue:Dequeue()
-    if self:IsEmpty() then
-        return nil
-    end
-    local first = self._first
-    local value = self._queue[first]
-    self._queue[first] = nil
-    self._first = first + 1
-    return value
-end
-
-return Queue
diff --git a/indra/newview/scripts/lua/UI.lua b/indra/newview/scripts/lua/UI.lua
deleted file mode 100644
index eb1a4017c7..0000000000
--- a/indra/newview/scripts/lua/UI.lua
+++ /dev/null
@@ -1,125 +0,0 @@
--- Engage the viewer's UI
-
-local leap = require 'leap'
-local Timer = (require 'timers').Timer
-local mapargs = require 'mapargs'
-
-local UI = {}
-
--- ***************************************************************************
---  registered menu actions
--- ***************************************************************************
-function UI.call(func, parameter)
-    -- 'call' is fire-and-forget
-    leap.request('UI', {op='call', ['function']=func, parameter=parameter})
-end
-
-function UI.getValue(path)
-    return leap.request('UI', {op='getValue', path=path})['value']
-end
-
--- ***************************************************************************
---  UI views
--- ***************************************************************************
--- Either:
--- wreq{op='Something', a=1, b=2, ...}
--- or:
--- (args should be local, as this wreq() call modifies it)
--- local args = {a=1, b=2, ...}
--- wreq('Something', args)
-local function wreq(op_or_data, data_if_op)
-    if data_if_op ~= nil then
-        -- this is the wreq(op, data) form
-        data_if_op.op = op_or_data
-        op_or_data = data_if_op
-    end
-    return leap.request('LLWindow', op_or_data)
-end
-
--- omit 'parent' to list all view paths
-function UI.listviews(parent)
-    return wreq{op='getPaths', under=parent}
-end
-
-function UI.viewinfo(path)
-    return wreq{op='getInfo', path=path}
-end
-
--- ***************************************************************************
---  mouse actions
--- ***************************************************************************
--- pass a table:
--- UI.click{path=path
---          [, button='LEFT' | 'CENTER' | 'RIGHT']
---          [, x=x, y=y]
---          [, hold=duration]}
-function UI.click(...)
-    local args = mapargs('path,button,x,y,hold', ...)
-    args.button = args.button or 'LEFT'
-    local hold = args.hold or 1.0
-    wreq('mouseMove', args)
-    wreq('mouseDown', args)
-    Timer(hold, 'wait')
-    wreq('mouseUp', args)
-end
-
--- pass a table as for UI.click()
-function UI.doubleclick(...)
-    local args = mapargs('path,button,x,y', ...)
-    args.button = args.button or 'LEFT'
-    wreq('mouseDown', args)
-    wreq('mouseUp',   args)
-    wreq('mouseDown', args)
-    wreq('mouseUp',   args)
-end
-
--- UI.drag{path=, xoff=, yoff=}
-function UI.drag(...)
-    local args = mapargs('path,xoff,yoff', ...)
-    -- query the specified path
-    local rect = UI.viewinfo(args.path).rect
-    local centerx = math.floor(rect.left   + (rect.right - rect.left)/2)
-    local centery = math.floor(rect.bottom + (rect.top   - rect.bottom)/2)
-    wreq{op='mouseMove', path=args.path, x=centerx, y=centery}
-    wreq{op='mouseDown', path=args.path, button='LEFT'}
-    wreq{op='mouseMove', path=args.path, x=centerx + args.xoff, y=centery + args.yoff}
-    wreq{op='mouseUp',   path=args.path, button='LEFT'}
-end
-
--- ***************************************************************************
---  keyboard actions
--- ***************************************************************************
--- pass a table:
--- UI.keypress{
---     [path=path]                      -- if omitted, default input field
---     [, char='x']                     -- requires one of char, keycode, keysym
---     [, keycode=120]
---     keysym per https://github.com/secondlife/viewer/blob/main/indra/llwindow/llkeyboard.cpp#L68-L124
---     [, keysym='Enter']
---     [, mask={'SHIFT', 'CTL', 'ALT', 'MAC_CONTROL'}]  -- some subset of these
---     }
-function UI.keypress(...)
-    local args = mapargs('path,char,keycode,keysym,mask', ...)
-    if args.char == '\n' then
-        args.char = nil
-        args.keysym = 'Enter'
-    end
-    return wreq('keyDown', args)
-end
-
--- UI.type{text=, path=}
-function UI.type(...)
-    local args = mapargs('text,path', ...)
-    if #args.text > 0 then
-        -- The caller's path may be specified in a way that requires recursively
-        -- searching parts of the LLView tree. No point in doing that more than
-        -- once. Capture the actual path found by that first call and use that for
-        -- subsequent calls.
-        local path = UI.keypress{path=args.path, char=string.sub(args.text, 1, 1)}.path
-        for i = 2, #args.text do
-            UI.keypress{path=path, char=string.sub(args.text, i, i)}
-        end
-    end
-end
-
-return UI
diff --git a/indra/newview/scripts/lua/WaitQueue.lua b/indra/newview/scripts/lua/WaitQueue.lua
deleted file mode 100644
index 7e10d03295..0000000000
--- a/indra/newview/scripts/lua/WaitQueue.lua
+++ /dev/null
@@ -1,88 +0,0 @@
--- WaitQueue isa Queue with the added feature that when the queue is empty,
--- the Dequeue() operation blocks the calling coroutine until some other
--- coroutine Enqueue()s a new value.
-
-local fiber = require('fiber')
-local Queue = require('Queue')
-local util  = require('util')
-
-local function dbg(...) end
--- local dbg = require('printf')
-
-local WaitQueue = Queue()
-
-function WaitQueue:new()
-    local obj = Queue()
-    setmetatable(obj, self)
-    self.__index = self
-
-    obj._waiters = {}
-    obj._closed = false
-    return obj
-end
-
-util.classctor(WaitQueue)
-
-function WaitQueue:Enqueue(value)
-    if self._closed then
-        error("can't Enqueue() on closed Queue")
-    end
-    -- can't simply call Queue:Enqueue(value)! That calls the method on the
-    -- Queue class definition, instead of calling Queue:Enqueue() on self.
-    -- Hand-expand the Queue:Enqueue() syntactic sugar.
-    Queue.Enqueue(self, value)
-    self:_wake_waiters()
-end
-
-function WaitQueue:_wake_waiters()
-    -- WaitQueue is designed to support multi-producer, multi-consumer use
-    -- cases. With multiple consumers, if more than one is trying to
-    -- Dequeue() from an empty WaitQueue, we'll have multiple waiters.
-    -- Unlike OS threads, with cooperative concurrency it doesn't make sense
-    -- to "notify all": we need wake only one of the waiting Dequeue()
-    -- callers.
-    if ((not self:IsEmpty()) or self._closed) and next(self._waiters) then
-        -- Pop the oldest waiting coroutine instead of the most recent, for
-        -- more-or-less round robin fairness. But skip any coroutines that
-        -- have gone dead in the meantime.
-        local waiter = table.remove(self._waiters, 1)
-        while waiter and fiber.status(waiter) == "dead" do
-            waiter = table.remove(self._waiters, 1)
-        end
-        -- do we still have at least one waiting coroutine?
-        if waiter then
-            -- don't pass the head item: let the resumed coroutine retrieve it
-            fiber.wake(waiter)
-        end
-    end
-end
-
-function WaitQueue:Dequeue()
-    while self:IsEmpty() do
-        -- Don't check for closed until the queue is empty: producer can close
-        -- the queue while there are still items left, and we want the
-        -- consumer(s) to retrieve those last few items.
-        if self._closed then
-            dbg('WaitQueue:Dequeue(): closed')
-            return nil
-        end
-        dbg('WaitQueue:Dequeue(): waiting')
-        -- add the running coroutine to the list of waiters
-        dbg('WaitQueue:Dequeue() running %s', tostring(coroutine.running() or 'main'))
-        table.insert(self._waiters, fiber.running())
-        -- then let somebody else run
-        fiber.wait()
-    end
-    -- here we're sure this queue isn't empty
-    dbg('WaitQueue:Dequeue() calling Queue.Dequeue()')
-    return Queue.Dequeue(self)
-end
-
-function WaitQueue:close()
-    self._closed = true
-    -- close() is like Enqueueing an end marker. If there are waiting
-    -- consumers, give them a chance to see we're closed.
-    self:_wake_waiters()
-end
-
-return WaitQueue
diff --git a/indra/newview/scripts/lua/coro.lua b/indra/newview/scripts/lua/coro.lua
deleted file mode 100644
index 616a797e95..0000000000
--- a/indra/newview/scripts/lua/coro.lua
+++ /dev/null
@@ -1,67 +0,0 @@
--- Manage Lua coroutines
-
-local coro = {}
-
-coro._coros = {}
-
--- Launch a Lua coroutine: create and resume.
--- Returns: new coroutine, values yielded or returned from initial resume()
--- If initial resume() encountered an error, propagates the error.
-function coro.launch(func, ...)
-    local co = coroutine.create(func)
-    table.insert(coro._coros, co)
-    return co, coro.resume(co, ...)
-end
-
--- resume() wrapper to propagate errors
-function coro.resume(co, ...)
-    -- if there's an idiom other than table.pack() to assign an arbitrary
-    -- number of return values, I don't yet know it
-    local ok_result = table.pack(coroutine.resume(co, ...))
-    if not ok_result[1] then
-        -- if [1] is false, then [2] is the error message
-        error(ok_result[2])
-    end
-    -- ok is true, whew, just return the rest of the values
-    return table.unpack(ok_result, 2)
-end
-
--- yield to other coroutines even if you don't know whether you're in a
--- created coroutine or the main coroutine
-function coro.yield(...)
-    if coroutine.running() then
-        -- this is a real coroutine, yield normally
-        return coroutine.yield(...)
-    else
-        -- This is the main coroutine: coroutine.yield() doesn't work.
-        -- But we can take a spin through previously-launched coroutines.
-        -- Walk a copy of coro._coros in case any of these coroutines launches
-        -- another: next() forbids creating new entries during traversal.
-        for co in coro._live_coros_iter, table.clone(coro._coros) do
-            coro.resume(co)
-        end
-    end
-end
-
--- Walk coro._coros table, returning running or suspended coroutines.
--- Once a coroutine becomes dead, remove it from _coros and don't return it.
-function coro._live_coros()
-    return coro._live_coros_iter, coro._coros
-end
-
--- iterator function for _live_coros()
-function coro._live_coros_iter(t, idx)
-    local k, co = next(t, idx)
-    while k and coroutine.status(co) == 'dead' do
---      t[k] = nil
-        -- See coro.yield(): sometimes we traverse a copy of _coros, but if we
-        -- discover a dead coroutine in that copy, delete it from _coros
-        -- anyway. Deleting it from a temporary copy does nothing.
-        coro._coros[k] = nil
-        coroutine.close(co)
-        k, co = next(t, k)
-    end
-    return co
-end
-
-return coro
diff --git a/indra/newview/scripts/lua/fiber.lua b/indra/newview/scripts/lua/fiber.lua
deleted file mode 100644
index cae27b936b..0000000000
--- a/indra/newview/scripts/lua/fiber.lua
+++ /dev/null
@@ -1,340 +0,0 @@
--- Organize Lua coroutines into fibers.
-
--- In this usage, the difference between coroutines and fibers is that fibers
--- have a scheduler. Yielding a fiber means allowing other fibers, plural, to
--- run: it's more than just returning control to the specific Lua thread that
--- resumed the running coroutine.
-
--- fiber.launch() creates a new fiber ready to run.
--- fiber.status() reports (augmented) status of the passed fiber: instead of
--- 'suspended', it returns either 'ready' or 'waiting'
--- fiber.yield() allows other fibers to run, but leaves the calling fiber
--- ready to run.
--- fiber.wait() marks the running fiber not ready, and resumes other fibers.
--- fiber.wake() marks the designated suspended fiber ready to run, but does
--- not yet resume it.
--- fiber.run() runs all current fibers until all have terminated (successfully
--- or with an error).
-
-local printf = require 'printf'
-local function dbg(...) end
--- local dbg = printf
-local coro = require 'coro'
-
-local fiber = {}
-
--- The tables in which we track fibers must have weak keys so dead fibers
--- can be garbage-collected.
-local weak_values = {__mode='v'}
-local weak_keys   = {__mode='k'}
-
--- Track each current fiber as being either ready to run or not ready
--- (waiting). wait() moves the running fiber from ready to waiting; wake()
--- moves the designated fiber from waiting back to ready.
--- The ready table is used as a list so yield() can go round robin.
-local ready   = setmetatable({'main'}, weak_keys)
--- The waiting table is used as a set because order doesn't matter.
-local waiting = setmetatable({}, weak_keys)
-
--- Every fiber has a name, for diagnostic purposes. Names must be unique.
--- A colliding name will be suffixed with an integer.
--- Predefine 'main' with our marker so nobody else claims that name.
-local names  = setmetatable({main='main'}, weak_keys)
-local byname = setmetatable({main='main'}, weak_values)
--- each colliding name has its own distinct suffix counter
-local suffix = {}
-
--- Specify a nullary idle() callback to be called whenever there are no ready
--- fibers but there are waiting fibers. The idle() callback is responsible for
--- changing zero or more waiting fibers to ready fibers by calling
--- fiber.wake(), although a given call may leave them all still waiting.
--- When there are no ready fibers, it's a good idea for the idle() function to
--- return control to a higher-level execution agent. Simply returning without
--- changing any fiber's status will spin the CPU.
--- The idle() callback can return non-nil to exit fiber.run() with that value.
-function fiber._idle()
-    error('fiber.yield(): you must first call set_idle(nullary idle() function)')
-end
-
-function fiber.set_idle(func)
-    fiber._idle = func
-end
-
--- Launch a new Lua fiber, ready to run.
-function fiber.launch(name, func, ...)
-    local args = table.pack(...)
-    local co = coroutine.create(function() func(table.unpack(args)) end)
-    -- a new fiber is ready to run
-    table.insert(ready, co)
-    local namekey = name
-    while byname[namekey] do
-        if not suffix[name] then
-            suffix[name] = 1
-        end
-        suffix[name] += 1
-        namekey = name .. tostring(suffix[name])
-    end
-    -- found a namekey not yet in byname: set it
-    byname[namekey] = co
-    -- and remember it as this fiber's name
-    names[co] = namekey
---  dbg('launch(%s)', namekey)
---  dbg('byname[%s] = %s', namekey, tostring(byname[namekey]))
---  dbg('names[%s] = %s', tostring(co), names[co])
---  dbg('ready[-1] = %s', tostring(ready[#ready]))
-end
-
--- for debugging
-function format_all()
-    output = {}
-    table.insert(output, 'Ready fibers:' .. if next(ready) then '' else ' none')
-    for _, co in pairs(ready) do
-        table.insert(output, string.format('  %s: %s', fiber.get_name(co), fiber.status(co)))
-    end
-    table.insert(output, 'Waiting fibers:' .. if next(waiting) then '' else ' none')
-    for co in pairs(waiting) do
-        table.insert(output, string.format('  %s: %s', fiber.get_name(co), fiber.status(co)))
-    end
-    return table.concat(output, '\n')
-end
-
-function fiber.print_all()
-    print(format_all())
-end
-
--- return either the running coroutine or, if called from the main thread,
--- 'main'
-function fiber.running()
-    return coroutine.running() or 'main'
-end
-
--- Query a fiber's name (nil for the running fiber)
-function fiber.get_name(co)
-    return names[co or fiber.running()] or 'unknown'
-end
-
--- Query status of the passed fiber
-function fiber.status(co)
-    local running = coroutine.running()
-    if (not co) or co == running then
-        -- silly to ask the status of the running fiber: it's 'running'
-        return 'running'
-    end
-    if co ~= 'main' then
-        -- for any coroutine but main, consult coroutine.status()
-        local status = coroutine.status(co)
-        if status ~= 'suspended' then
-            return status
-        end
-        -- here co is suspended, answer needs further refinement
-    else
-        -- co == 'main'
-        if not running then
-            -- asking about 'main' from the main fiber
-            return 'running'
-        end
-        -- asking about 'main' from some other fiber, so presumably main is suspended
-    end
-    -- here we know co is suspended -- but is it ready to run?
-    if waiting[co] then
-        return 'waiting'
-    end
-    -- not waiting should imply ready: sanity check
-    if table.find(ready, co) then
-        return 'ready'
-    end
-    -- Calls within yield() between popping the next ready fiber and
-    -- re-appending it to the list are in this state. Once we're done
-    -- debugging yield(), we could reinstate either of the below.
---  error(string.format('fiber.status(%s) is stumped', fiber.get_name(co)))
---  print(string.format('*** fiber.status(%s) is stumped', fiber.get_name(co)))
-    return '(unknown)'
-end
-
--- change the running fiber's status to waiting
-local function set_waiting()
-    -- if called from the main fiber, inject a 'main' marker into the list
-    co = fiber.running()
-    -- delete from ready list
-    local i = table.find(ready, co)
-    if i then
-        table.remove(ready, i)
-    end
-    -- add to waiting list
-    waiting[co] = true
-end
-
--- Suspend the current fiber until some other fiber calls fiber.wake() on it
-function fiber.wait()
-    dbg('Fiber %q waiting', fiber.get_name())
-    set_waiting()
-    -- now yield to other fibers
-    fiber.yield()
-end
-
--- Mark a suspended fiber as being ready to run
-function fiber.wake(co)
-    if not waiting[co] then
-        error(string.format('fiber.wake(%s) but status=%s, ready=%s, waiting=%s',
-                            names[co], fiber.status(co), ready[co], waiting[co]))
-    end
-    -- delete from waiting list
-    waiting[co] = nil
-    -- add to end of ready list
-    table.insert(ready, co)
-    dbg('Fiber %q ready', fiber.get_name(co))
-    -- but don't yet resume it: that happens next time we reach yield()
-end
-
--- pop and return the next not-dead fiber in the ready list, or nil if none remain
-local function live_ready_iter()
-    -- don't write:
-    -- for co in table.remove, ready, 1
-    -- because it would keep passing a new second parameter!
-    for co in function() return table.remove(ready, 1) end do
-        dbg('%s live_ready_iter() sees %s, status %s',
-              fiber.get_name(), fiber.get_name(co), fiber.status(co))
-        -- keep removing the head entry until we find one that's not dead,
-        -- discarding any dead coroutines along the way
-        if co == 'main' or coroutine.status(co) ~= 'dead' then
-            dbg('%s live_ready_iter() returning %s',
-                  fiber.get_name(), fiber.get_name(co))
-            return co
-        end
-    end
-    dbg('%s live_ready_iter() returning nil', fiber.get_name())
-    return nil
-end
-
--- prune the set of waiting fibers
-local function prune_waiting()
-    for waiter in pairs(waiting) do
-        if waiter ~= 'main' and coroutine.status(waiter) == 'dead' then
-            waiting[waiter] = nil
-        end
-    end
-end
-
--- Run other ready fibers, leaving this one ready, returning after a cycle.
--- Returns:
--- * true, nil if there remain other live fibers, whether ready or waiting,
---   but it's our turn to run
--- * false, nil if this is the only remaining fiber
--- * nil,   x   if configured idle() callback returns non-nil x
-local function scheduler()
-    dbg('scheduler():\n%s', format_all())
-    -- scheduler() is asymmetric because Lua distinguishes the main thread
-    -- from other coroutines. The main thread can't yield; it can only resume
-    -- other coroutines. So although an arbitrary coroutine could resume still
-    -- other arbitrary coroutines, it could NOT resume the main thread because
-    -- the main thread can't yield. Therefore, scheduler() delegates its real
-    -- processing to the main thread. If called from a coroutine, pass control
-    -- back to the main thread.
-    if coroutine.running() then
-        -- this is a real coroutine, yield normally to main thread
-        coroutine.yield()
-        -- main certainly still exists
-        return true
-    end
-
-    -- This is the main fiber: coroutine.yield() doesn't work.
-    -- Instead, resume each of the ready fibers.
-    -- Prune the set of waiting fibers after every time fiber business logic
-    -- runs (i.e. other fibers might have terminated or hit error), such as
-    -- here on entry.
-    prune_waiting()
-    local others, idle_stop
-    repeat
-        for co in live_ready_iter do
-            -- seize the opportunity to make sure the viewer isn't shutting down
-            LL.check_stop()
-            -- before we re-append co, is it the only remaining entry?
-            others = next(ready)
-            -- co is live, re-append it to the ready list
-            table.insert(ready, co)
-            if co == 'main' then
-                -- Since we know the caller is the main fiber, it's our turn.
-                -- Tell caller if there are other ready or waiting fibers.
-                return others or next(waiting)
-            end
-            -- not main, but some other ready coroutine:
-            -- use coro.resume() so we'll propagate any error encountered
-            coro.resume(co)
-            prune_waiting()
-        end
-        -- Here there are no ready fibers. Are there any waiting fibers?
-        if not next(waiting) then
-            return false
-        end
-        -- there are waiting fibers: call consumer's configured idle() function
-        idle_stop = fiber._idle()
-        if idle_stop ~= nil then
-            return nil, idle_stop
-        end
-        prune_waiting()
-        -- loop "forever", that is, until:
-        -- * main is ready, or
-        -- * there are neither ready fibers nor waiting fibers, or
-        -- * fiber._idle() returned non-nil
-    until false
-end
-
--- Let other fibers run. This is useful in either of two cases:
--- * fiber.wait() calls this to run other fibers while this one is waiting.
---   fiber.yield() (and therefore fiber.wait()) works from the main thread as
---   well as from explicitly-launched fibers, without the caller having to
---   care.
--- * A long-running fiber that doesn't often call fiber.wait() should sprinkle
---   in fiber.yield() calls to interleave processing on other fibers.
-function fiber.yield()
-    -- The difference between this and fiber.run() is that fiber.yield()
-    -- assumes its caller has work to do. yield() returns to its caller as
-    -- soon as scheduler() pops this fiber from the ready list. fiber.run()
-    -- continues looping until all other fibers have terminated, or the
-    -- set_idle() callback tells it to stop.
-    local others, idle_done = scheduler()
-    -- scheduler() returns either if we're ready, or if idle_done ~= nil.
-    if idle_done ~= nil then
-        -- Returning normally from yield() means the caller can carry on with
-        -- its pending work. But in this case scheduler() returned because the
-        -- configured set_idle() function interrupted it -- not because we're
-        -- actually ready. Don't return normally.
-        error('fiber.set_idle() interrupted yield() with: ' .. tostring(idle_done))
-    end
-    -- We're ready! Just return to caller. In this situation we don't care
-    -- whether there are other ready fibers.
-    dbg('fiber.yield() returning to %s (%sothers are ready)',
-        fiber.get_name(), ((not others) and "no " or ""))
-end
-
--- Run fibers until all but main have terminated: return nil.
--- Or until configured idle() callback returns x ~= nil: return x.
-function fiber.run()
-    -- A fiber calling run() is not also doing other useful work. Remove the
-    -- calling fiber from the ready list. Otherwise yield() would keep seeing
-    -- that our caller is ready and return to us, instead of realizing that
-    -- all coroutines are waiting and call idle(). But don't say we're
-    -- waiting, either, because then when all other fibers have terminated
-    -- we'd call idle() forever waiting for something to make us ready again.
-    local i = table.find(ready, fiber.running())
-    if i then
-        table.remove(ready, i)
-    end
-    local others, idle_done
-    repeat
-        dbg('%s calling fiber.run() calling scheduler()', fiber.get_name())
-        others, idle_done = scheduler()
-        dbg("%s fiber.run()'s scheduler() returned %s, %s", fiber.get_name(),
-              tostring(others), tostring(idle_done))
-    until (not others)
-    dbg('%s fiber.run() done', fiber.get_name())
-    -- For whatever it's worth, put our own fiber back in the ready list.
-    table.insert(ready, fiber.running())
-    -- Once there are no more waiting fibers, and the only ready fiber is
-    -- us, return to caller. All previously-launched fibers are done. Possibly
-    -- the chunk is done, or the chunk may decide to launch a new batch of
-    -- fibers.
-    return idle_done
-end
-
-return fiber
diff --git a/indra/newview/scripts/lua/inspect.lua b/indra/newview/scripts/lua/inspect.lua
deleted file mode 100644
index 9900a0b81b..0000000000
--- a/indra/newview/scripts/lua/inspect.lua
+++ /dev/null
@@ -1,371 +0,0 @@
-local _tl_compat; if (tonumber((_VERSION or ''):match('[%d.]*$')) or 0) < 5.3 then local p, m = pcall(require, 'compat53.module'); if p then _tl_compat = m end end; local math = _tl_compat and _tl_compat.math or math; local string = _tl_compat and _tl_compat.string or string; local table = _tl_compat and _tl_compat.table or table
-local inspect = {Options = {}, }
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-inspect._VERSION = 'inspect.lua 3.1.0'
-inspect._URL = 'http://github.com/kikito/inspect.lua'
-inspect._DESCRIPTION = 'human-readable representations of tables'
-inspect._LICENSE = [[
-  MIT LICENSE
-
-  Copyright (c) 2022 Enrique García Cota
-
-  Permission is hereby granted, free of charge, to any person obtaining a
-  copy of this software and associated documentation files (the
-  "Software"), to deal in the Software without restriction, including
-  without limitation the rights to use, copy, modify, merge, publish,
-  distribute, sublicense, and/or sell copies of the Software, and to
-  permit persons to whom the Software is furnished to do so, subject to
-  the following conditions:
-
-  The above copyright notice and this permission notice shall be included
-  in all copies or substantial portions of the Software.
-
-  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-  OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
-  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
-  CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
-  TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
-  SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-]]
-inspect.KEY = setmetatable({}, { __tostring = function() return 'inspect.KEY' end })
-inspect.METATABLE = setmetatable({}, { __tostring = function() return 'inspect.METATABLE' end })
-
-local tostring = tostring
-local rep = string.rep
-local match = string.match
-local char = string.char
-local gsub = string.gsub
-local fmt = string.format
-
-local _rawget
-if rawget then
-   _rawget = rawget
-else
-   _rawget = function(t, k) return t[k] end
-end
-
-local function rawpairs(t)
-   return next, t, nil
-end
-
-
-
-local function smartQuote(str)
-   if match(str, '"') and not match(str, "'") then
-      return "'" .. str .. "'"
-   end
-   return '"' .. gsub(str, '"', '\\"') .. '"'
-end
-
-
-local shortControlCharEscapes = {
-   ["\a"] = "\\a", ["\b"] = "\\b", ["\f"] = "\\f", ["\n"] = "\\n",
-   ["\r"] = "\\r", ["\t"] = "\\t", ["\v"] = "\\v", ["\127"] = "\\127",
-}
-local longControlCharEscapes = { ["\127"] = "\127" }
-for i = 0, 31 do
-   local ch = char(i)
-   if not shortControlCharEscapes[ch] then
-      shortControlCharEscapes[ch] = "\\" .. i
-      longControlCharEscapes[ch] = fmt("\\%03d", i)
-   end
-end
-
-local function escape(str)
-   return (gsub(gsub(gsub(str, "\\", "\\\\"),
-   "(%c)%f[0-9]", longControlCharEscapes),
-   "%c", shortControlCharEscapes))
-end
-
-local luaKeywords = {
-   ['and'] = true,
-   ['break'] = true,
-   ['do'] = true,
-   ['else'] = true,
-   ['elseif'] = true,
-   ['end'] = true,
-   ['false'] = true,
-   ['for'] = true,
-   ['function'] = true,
-   ['goto'] = true,
-   ['if'] = true,
-   ['in'] = true,
-   ['local'] = true,
-   ['nil'] = true,
-   ['not'] = true,
-   ['or'] = true,
-   ['repeat'] = true,
-   ['return'] = true,
-   ['then'] = true,
-   ['true'] = true,
-   ['until'] = true,
-   ['while'] = true,
-}
-
-local function isIdentifier(str)
-   return type(str) == "string" and
-   not not str:match("^[_%a][_%a%d]*$") and
-   not luaKeywords[str]
-end
-
-local flr = math.floor
-local function isSequenceKey(k, sequenceLength)
-   return type(k) == "number" and
-   flr(k) == k and
-   1 <= (k) and
-   k <= sequenceLength
-end
-
-local defaultTypeOrders = {
-   ['number'] = 1, ['boolean'] = 2, ['string'] = 3, ['table'] = 4,
-   ['function'] = 5, ['userdata'] = 6, ['thread'] = 7,
-}
-
-local function sortKeys(a, b)
-   local ta, tb = type(a), type(b)
-
-
-   if ta == tb and (ta == 'string' or ta == 'number') then
-      return (a) < (b)
-   end
-
-   local dta = defaultTypeOrders[ta] or 100
-   local dtb = defaultTypeOrders[tb] or 100
-
-
-   return dta == dtb and ta < tb or dta < dtb
-end
-
-local function getKeys(t)
-
-   local seqLen = 1
-   while _rawget(t, seqLen) ~= nil do
-      seqLen = seqLen + 1
-   end
-   seqLen = seqLen - 1
-
-   local keys, keysLen = {}, 0
-   for k in rawpairs(t) do
-      if not isSequenceKey(k, seqLen) then
-         keysLen = keysLen + 1
-         keys[keysLen] = k
-      end
-   end
-   table.sort(keys, sortKeys)
-   return keys, keysLen, seqLen
-end
-
-local function countCycles(x, cycles)
-   if type(x) == "table" then
-      if cycles[x] then
-         cycles[x] = cycles[x] + 1
-      else
-         cycles[x] = 1
-         for k, v in rawpairs(x) do
-            countCycles(k, cycles)
-            countCycles(v, cycles)
-         end
-         countCycles(getmetatable(x), cycles)
-      end
-   end
-end
-
-local function makePath(path, a, b)
-   local newPath = {}
-   local len = #path
-   for i = 1, len do newPath[i] = path[i] end
-
-   newPath[len + 1] = a
-   newPath[len + 2] = b
-
-   return newPath
-end
-
-
-local function processRecursive(process,
-   item,
-   path,
-   visited)
-   if item == nil then return nil end
-   if visited[item] then return visited[item] end
-
-   local processed = process(item, path)
-   if type(processed) == "table" then
-      local processedCopy = {}
-      visited[item] = processedCopy
-      local processedKey
-
-      for k, v in rawpairs(processed) do
-         processedKey = processRecursive(process, k, makePath(path, k, inspect.KEY), visited)
-         if processedKey ~= nil then
-            processedCopy[processedKey] = processRecursive(process, v, makePath(path, processedKey), visited)
-         end
-      end
-
-      local mt = processRecursive(process, getmetatable(processed), makePath(path, inspect.METATABLE), visited)
-      if type(mt) ~= 'table' then mt = nil end
-      setmetatable(processedCopy, mt)
-      processed = processedCopy
-   end
-   return processed
-end
-
-local function puts(buf, str)
-   buf.n = buf.n + 1
-   buf[buf.n] = str
-end
-
-
-
-local Inspector = {}
-
-
-
-
-
-
-
-
-
-
-local Inspector_mt = { __index = Inspector }
-
-local function tabify(inspector)
-   puts(inspector.buf, inspector.newline .. rep(inspector.indent, inspector.level))
-end
-
-function Inspector:getId(v)
-   local id = self.ids[v]
-   local ids = self.ids
-   if not id then
-      local tv = type(v)
-      id = (ids[tv] or 0) + 1
-      ids[v], ids[tv] = id, id
-   end
-   return tostring(id)
-end
-
-function Inspector:putValue(v)
-   local buf = self.buf
-   local tv = type(v)
-   if tv == 'string' then
-      puts(buf, smartQuote(escape(v)))
-   elseif tv == 'number' or tv == 'boolean' or tv == 'nil' or
-      tv == 'cdata' or tv == 'ctype' then
-      puts(buf, tostring(v))
-   elseif tv == 'table' and not self.ids[v] then
-      local t = v
-
-      if t == inspect.KEY or t == inspect.METATABLE then
-         puts(buf, tostring(t))
-      elseif self.level >= self.depth then
-         puts(buf, '{...}')
-      else
-         if self.cycles[t] > 1 then puts(buf, fmt('<%d>', self:getId(t))) end
-
-         local keys, keysLen, seqLen = getKeys(t)
-
-         puts(buf, '{')
-         self.level = self.level + 1
-
-         for i = 1, seqLen + keysLen do
-            if i > 1 then puts(buf, ',') end
-            if i <= seqLen then
-               puts(buf, ' ')
-               self:putValue(t[i])
-            else
-               local k = keys[i - seqLen]
-               tabify(self)
-               if isIdentifier(k) then
-                  puts(buf, k)
-               else
-                  puts(buf, "[")
-                  self:putValue(k)
-                  puts(buf, "]")
-               end
-               puts(buf, ' = ')
-               self:putValue(t[k])
-            end
-         end
-
-         local mt = getmetatable(t)
-         if type(mt) == 'table' then
-            if seqLen + keysLen > 0 then puts(buf, ',') end
-            tabify(self)
-            puts(buf, '<metatable> = ')
-            self:putValue(mt)
-         end
-
-         self.level = self.level - 1
-
-         if keysLen > 0 or type(mt) == 'table' then
-            tabify(self)
-         elseif seqLen > 0 then
-            puts(buf, ' ')
-         end
-
-         puts(buf, '}')
-      end
-
-   else
-      puts(buf, fmt('<%s %d>', tv, self:getId(v)))
-   end
-end
-
-
-
-
-function inspect.inspect(root, options)
-   options = options or {}
-
-   local depth = options.depth or (math.huge)
-   local newline = options.newline or '\n'
-   local indent = options.indent or '  '
-   local process = options.process
-
-   if process then
-      root = processRecursive(process, root, {}, {})
-   end
-
-   local cycles = {}
-   countCycles(root, cycles)
-
-   local inspector = setmetatable({
-      buf = { n = 0 },
-      ids = {},
-      cycles = cycles,
-      depth = depth,
-      level = 0,
-      newline = newline,
-      indent = indent,
-   }, Inspector_mt)
-
-   inspector:putValue(root)
-
-   return table.concat(inspector.buf)
-end
-
-setmetatable(inspect, {
-   __call = function(_, root, options)
-      return inspect.inspect(root, options)
-   end,
-})
-
-return inspect
diff --git a/indra/newview/scripts/lua/leap.lua b/indra/newview/scripts/lua/leap.lua
deleted file mode 100644
index 82f91ce9e9..0000000000
--- a/indra/newview/scripts/lua/leap.lua
+++ /dev/null
@@ -1,550 +0,0 @@
--- Lua implementation of LEAP (LLSD Event API Plugin) protocol
---
--- This module supports Lua scripts run by the Second Life viewer.
---
--- LEAP protocol passes LLSD objects, converted to/from Lua tables, in both
--- directions. A typical LLSD object is a map containing keys 'pump' and
--- 'data'.
---
--- The viewer's Lua post_to(pump, data) function posts 'data' to the
--- LLEventPump 'pump'. This is typically used to engage an LLEventAPI method.
---
--- Similarly, the viewer gives each Lua script its own LLEventPump with a
--- unique name. That name is returned by get_event_pumps(). Every event
--- received on that LLEventPump is queued for retrieval by get_event_next(),
--- which returns (pump, data): the name of the LLEventPump on which the event
--- was received and the received event data. When the queue is empty,
--- get_event_next() blocks the calling Lua script until the next event is
--- received.
---
--- Usage:
--- 1. Launch some number of Lua coroutines. The code in each coroutine may
---    call leap.send(), leap.request() or leap.generate(). leap.send() returns
---    immediately ("fire and forget"). leap.request() blocks the calling
---    coroutine until it receives and returns the viewer's response to its
---    request. leap.generate() expects an arbitrary number of responses to the
---    original request.
--- 2. To handle events from the viewer other than direct responses to
---    requests, instantiate a leap.WaitFor object with a filter(pump, data)
---    override method that returns non-nil for desired events. A coroutine may
---    call wait() on any such WaitFor.
--- 3. Once the coroutines have been launched, call leap.process() on the main
---    coroutine. process() retrieves incoming events from the viewer and
---    dispatches them to waiting request() or generate() calls, or to
---    appropriate WaitFor instances. process() returns when either
---    get_event_next() raises an error or the viewer posts nil to the script's
---    reply pump to indicate it's done.
--- 4. Alternatively, a running coroutine may call leap.done() to break out of
---    leap.process(). process() won't notice until the next event from the
---    viewer, though.
-
-local fiber = require('fiber')
-local ErrorQueue = require('ErrorQueue')
-local inspect = require('inspect')
-local function dbg(...) end 
--- local dbg = require('printf')
-local util = require('util')
-
-local leap = {}
-
--- reply: string name of reply LLEventPump. Any events the viewer posts to
--- this pump will be queued for get_event_next(). We usually specify it as the
--- reply pump for requests to internal viewer services.
--- command: string name of command LLEventPump. post_to(command, ...)
--- engages LLLeapListener operations such as listening on a specified other
--- LLEventPump, etc.
-local reply, command = LL.get_event_pumps()
--- Dict of features added to the LEAP protocol since baseline implementation.
--- Before engaging a new feature that might break an older viewer, we can
--- check for the presence of that feature key. This table is solely about the
--- LEAP protocol itself, the way we communicate with the viewer. To discover
--- whether a given listener exists, or supports a particular operation, use
--- command's "getAPI" operation.
--- For Lua, command's "getFeatures" operation suffices?
--- leap._features = {}
-
--- Each outstanding request() or generate() call has a corresponding
--- WaitForReqid object (later in this module) to handle the
--- response(s). If an incoming event contains an echoed ["reqid"] key,
--- we can look up the appropriate WaitForReqid object more efficiently
--- in a dict than by tossing such objects into the usual waitfors list.
--- Note: the ["reqid"] must be unique, otherwise we could end up
--- replacing an earlier WaitForReqid object in pending with a
--- later one. That means that no incoming event will ever be given to
--- the old WaitForReqid object. Any coroutine waiting on the discarded
--- WaitForReqid object would therefore wait forever.
--- pending is NOT a weak table because the caller of request() or generate()
--- never sees the WaitForReqid object. pending holds the only reference, so
--- it should NOT be garbage-collected.
-local pending = {}
--- Our consumer will instantiate some number of WaitFor subclass objects.
--- As these are traversed in descending priority order, we must keep
--- them in a list.
--- Anyone who instantiates a WaitFor subclass object should retain a reference
--- to it. Once the consuming script drops the reference, allow Lua to
--- garbage-collect the WaitFor despite its entry in waitfors.
-local weak_values = {__mode='v'}
-local waitfors = setmetatable({}, weak_values)
--- It has been suggested that we should use UUIDs as ["reqid"] values,
--- since UUIDs are guaranteed unique. However, as the "namespace" for
--- ["reqid"] values is our very own reply pump, we can get away with
--- an integer.
-leap._reqid = 0
--- break leap.process() loop
-leap._done = false
-
--- get the name of the reply pump
-function leap.replypump()
-    return reply
-end
-
--- get the name of the command pump
-function leap.cmdpump()
-    return command
-end
-
--- Fire and forget. Send the specified request LLSD, expecting no reply.
--- In fact, should the request produce an eventual reply, it will be
--- treated as an unsolicited event.
--- 
--- See also request(), generate().
-function leap.send(pump, data, reqid)
-    local data = data
-    if type(data) == 'table' then
-        data = table.clone(data)
-        data['reply'] = reply
-        if reqid ~= nil then
-            data['reqid'] = reqid
-        end
-    end
-    dbg('leap.send(%s, %s) calling post_on()', pump, data)
-    LL.post_on(pump, data)
-end
-
--- common setup code shared by request() and generate()
-local function requestSetup(pump, data)
-    -- invent a new, unique reqid
-    leap._reqid += 1
-    local reqid = leap._reqid
-    -- Instantiate a new WaitForReqid object. The priority is irrelevant
-    -- because, unlike the WaitFor base class, WaitForReqid does not
-    -- self-register on our waitfors list. Instead, capture the new
-    -- WaitForReqid object in pending so dispatch() can find it.
-    local waitfor = leap.WaitForReqid(reqid)
-    pending[reqid] = waitfor
-    -- Pass reqid to send() to stamp it into (a copy of) the request data.
-    dbg('requestSetup(%s, %s) storing %s', pump, data, waitfor.name)
-    leap.send(pump, data, reqid)
-    return reqid, waitfor
-end
-
--- Send the specified request LLSD, expecting exactly one reply. Block
--- the calling coroutine until we receive that reply.
--- 
--- Every request() (or generate()) LLSD block we send will get stamped
--- with a distinct ["reqid"] value. The requested event API must echo the
--- same ["reqid"] field in each reply associated with that request. This way
--- we can correctly dispatch interleaved replies from different requests.
--- 
--- If the desired event API doesn't support the ["reqid"] echo convention,
--- you should use send() instead -- since request() or generate() would
--- wait forever for a reply stamped with that ["reqid"] -- and intercept
--- any replies using WaitFor.
--- 
--- Unless the request data already contains a ["reply"] key, we insert
--- reply=self.replypump to try to ensure that the expected reply will be
--- returned over the socket.
---
--- See also send(), generate().
-function leap.request(pump, data)
-    local reqid, waitfor = requestSetup(pump, data)
-    dbg('leap.request(%s, %s) about to wait on %s', pump, data, tostring(waitfor))
-    local ok, response = pcall(waitfor.wait, waitfor)
-    dbg('leap.request(%s, %s) got %s: %s', pump, data, ok, response)
-    -- kill off temporary WaitForReqid object, even if error
-    pending[reqid] = nil
-    if not ok then
-        error(response)
-    elseif response.error then
-        error(response.error)
-    else
-        return response
-    end
-end
-
--- Send the specified request LLSD, expecting an arbitrary number of replies.
--- Each one is returned on request.
---
--- Usage:
--- sequence = leap.generate(pump, data)
--- repeat
---     response = sequence.next()
--- until last(response)
--- (last() means whatever test the caller wants to perform on response)
--- sequence.done()
--- 
--- See request() remarks about ["reqid"].
---
--- Note: this seems like a prime use case for Lua coroutines. But in a script
--- using fibers.lua, a "wild" coroutine confuses the fiber scheduler. If
--- generate() were itself a coroutine, it would call WaitForReqid:wait(),
--- which would yield -- thereby resuming generate() WITHOUT waiting.
-function leap.generate(pump, data, checklast)
-    -- Invent a new, unique reqid. Arrange to handle incoming events
-    -- bearing that reqid. Stamp the outbound request with that reqid, and
-    -- send it.
-    local reqid, waitfor = requestSetup(pump, data)
-    return {
-        next = function()
-            dbg('leap.generate(%s).next() about to wait on %s', reqid, tostring(waitfor))
-            local ok, response = pcall(waitfor.wait, waitfor)
-            dbg('leap.generate(%s).next() got %s: %s', reqid, ok, response)
-            if not ok then
-                error(response)
-            elseif response.error then
-                error(response.error)
-            else
-                return response
-            end
-        end,
-        done = function()
-            -- cleanup consists of removing our WaitForReqid from pending
-            pending[reqid] = nil
-        end
-    }
-end
-
--- Send the specified request LLSD, expecting an immediate reply followed by
--- an arbitrary number of subsequent replies with the same reqid. Block the
--- calling coroutine until the first (immediate) reply, but launch a separate
--- fiber on which to call the passed callback with later replies.
---
--- Once the callback returns true, the background fiber terminates.
-function leap.eventstream(pump, data, callback)
-    local reqid, waitfor = requestSetup(pump, data)
-    local response = waitfor:wait()
-    if response.error then
-        -- clean up our WaitForReqid
-        waitfor:close()
-        error(response.error)
-    end
-    -- No error, so far so good:
-    -- call the callback with the first response just in case
-    dbg('leap.eventstream(%s): first callback', reqid)
-    local ok, done = pcall(callback, response)
-    dbg('leap.eventstream(%s) got %s, %s', reqid, ok, done)
-    if not ok then
-        -- clean up our WaitForReqid
-        waitfor:close()
-        error(done)
-    end
-    if done then
-        return response
-    end
-    -- callback didn't throw an error, and didn't say stop,
-    -- so set up to handle subsequent events
-    -- TODO: distinguish "daemon" fibers that can be terminated even if waiting
-    fiber.launch(
-        pump,
-        function ()
-            local ok, done
-            local nth = 1
-            repeat
-                event = waitfor:wait()
-                if not event then
-                    -- wait() returns nil once the queue is closed (e.g. cancelreq())
-                    ok, done = true, true
-                else
-                    nth += 1
-                    dbg('leap.eventstream(%s): callback %d', reqid, nth)
-                    ok, done = pcall(callback, event)
-                    dbg('leap.eventstream(%s) got %s, %s', reqid, ok, done)
-                end
-                -- not ok means callback threw an error (caught as 'done')
-                -- done means callback succeeded but wants to stop
-            until (not ok) or done
-            -- once we break this loop, clean up our WaitForReqid
-            waitfor:close()
-            if not ok then
-                -- can't reflect the error back to our caller
-                LL.print_warning(fiber.get_name() .. ': ' .. done)
-            end
-        end)
-    return response
-end
-
--- we might want to clean up after leap.eventstream() even if the callback has
--- not yet returned true
-function leap.cancelreq(reqid)
-    dbg('cancelreq(%s)', reqid)
-    local waitfor = pending[reqid]
-    if waitfor ~= nil then
-        -- close() removes the pending entry and also closes the queue,
-        -- breaking the background fiber's wait loop.
-        dbg('cancelreq(%s) canceling %s', reqid, waitfor.name)
-        waitfor:close()
-    end
-end
-
-local function cleanup(message)
-    -- We're done: clean up all pending coroutines.
-    -- Iterate over copies of the pending and waitfors tables, since the
-    -- close() operation modifies the real tables.
-    for i, waitfor in pairs(table.clone(pending)) do
-        waitfor:close()
-    end
-    for i, waitfor in pairs(table.clone(waitfors)) do
-        waitfor:close()
-    end
-end
-
--- Handle an incoming (pump, data) event with no recognizable ['reqid']
-local function unsolicited(pump, data)
-    -- we maintain waitfors in descending priority order, so the first waitfor
-    -- to claim this event is the one with the highest priority
-    for i, waitfor in pairs(waitfors) do
-        dbg('unsolicited() checking %s', waitfor.name)
-        if waitfor:handle(pump, data) then
-            return
-        end
-    end
-    LL.print_debug(string.format('unsolicited(%s, %s) discarding unclaimed event',
-                                 pump, inspect(data)))
-end
-
--- Route incoming (pump, data) event to the appropriate waiting coroutine.
-local function dispatch(pump, data)
-    local reqid = data['reqid']
-    -- if the response has no 'reqid', it's not from request() or generate()
-    if reqid == nil then
---      dbg('dispatch() found no reqid; calling unsolicited(%s, %s)', pump, data)
-        return unsolicited(pump, data)
-    end
-    -- have reqid; do we have a WaitForReqid?
-    local waitfor = pending[reqid]
-    if waitfor == nil then
---      dbg('dispatch() found no WaitForReqid(%s); calling unsolicited(%s, %s)', reqid, pump, data)
-        return unsolicited(pump, data)
-    end
-    -- found the right WaitForReqid object, let it handle the event
---  dbg('dispatch() calling %s.handle(%s, %s)', waitfor.name, pump, data)
-    waitfor:handle(pump, data)
-end
-
--- We configure fiber.set_idle() function. fiber.yield() calls the configured
--- idle callback whenever there are waiting fibers but no ready fibers. In
--- our case, that means it's time to fetch another incoming viewer event.
-fiber.set_idle(function ()
-    -- If someone has called leap.done(), then tell fiber.yield() to break loop.
-    if leap._done then
-        cleanup('done')
-        return 'done'
-    end
-    dbg('leap.idle() calling get_event_next()')
-    local ok, pump, data = pcall(LL.get_event_next)
-    dbg('leap.idle() got %s: %s, %s', ok, pump, data)
-    -- ok false means get_event_next() raised a Lua error, pump is message
-    if not ok then
-        cleanup(pump)
-        error(pump)
-    end
-    -- data nil means get_event_next() returned (pump, LLSD()) to indicate done
-    if not data then
-        cleanup('end')
-        return 'end'
-    end
-    -- got a real pump, data pair 
-    dispatch(pump, data)
-    -- return to fiber.yield(): any incoming message might result in one or
-    -- more fibers becoming ready
-end)
-
-function leap.done()
-    leap._done = true
-end
-
--- called by WaitFor.enable()
-local function registerWaitFor(waitfor)
-    table.insert(waitfors, waitfor)
-    -- keep waitfors sorted in descending order of specified priority
-    table.sort(waitfors,
-               function (lhs, rhs) return lhs.priority > rhs.priority end)
-end
-
--- called by WaitFor.disable()
-local function unregisterWaitFor(waitfor)
-    local i = table.find(waitfors, waitfor)
-    if i ~= nil then
-        waitfors[i] = nil
-    end
-end
-
--- ******************************************************************************
--- WaitFor and friends
--- ******************************************************************************
-
--- An unsolicited event is handled by the highest-priority WaitFor subclass
--- object willing to accept it. If no such object is found, the unsolicited
--- event is discarded.
--- 
--- * First, instantiate a WaitFor subclass object to register its interest in
---   some incoming event(s). WaitFor instances are self-registering; merely
---   instantiating the object suffices.
--- * Any coroutine may call a given WaitFor object's wait() method. This blocks
---   the calling coroutine until a suitable event arrives.
--- * WaitFor's constructor accepts a float priority. Every incoming event
---   (other than those claimed by request() or generate()) is passed to each
---   extant WaitFor.filter() method in descending priority order. The first
---   such filter() to return nontrivial data claims that event.
--- * At that point, the blocked wait() call on that WaitFor object returns the
---   item returned by filter().
--- * WaitFor contains a queue. Multiple arriving events claimed by that WaitFor
---   object's filter() method are added to the queue. Naturally, until the
---   queue is empty, calling wait() immediately returns the front entry.
--- 
--- It's reasonable to instantiate a WaitFor subclass whose filter() method
--- unconditionally returns the incoming event, and whose priority places it
--- last in the list. This object will enqueue every unsolicited event left
--- unclaimed by other WaitFor subclass objects.
--- 
--- It's not strictly necessary to associate a WaitFor object with exactly one
--- coroutine. You might have multiple "worker" coroutines drawing from the same
--- WaitFor object, useful if the work being done per event might itself involve
--- "blocking" operations. Or a given coroutine might sample a number of WaitFor
--- objects in round-robin fashion... etc. etc. Nonetheless, it's
--- straightforward to designate one coroutine for each WaitFor object.
-
--- --------------------------------- WaitFor ---------------------------------
-leap.WaitFor = { _id=0 }
-
-function leap.WaitFor.tostring(self)
-    -- Lua (sub)classes have no name; can't prefix with that
-    return self.name
-end
-
-function leap.WaitFor:new(priority, name)
-    local obj = setmetatable({__tostring=leap.WaitFor.tostring}, self)
-    self.__index = self
-
-    obj.priority = priority
-    if name then
-        obj.name = name
-    else
-        self._id += 1
-        obj.name = 'WaitFor' .. self._id
-    end
-    obj._queue = ErrorQueue()
-    obj._registered = false
-    -- if no priority, then don't enable() - remember 0 is truthy
-    if priority then
-        obj:enable()
-    end
-
-    return obj
-end
-
-util.classctor(leap.WaitFor)
-
--- Re-enable a disable()d WaitFor object. New WaitFor objects are
--- enable()d by default.
-function leap.WaitFor:enable()
-    if not self._registered then
-        registerWaitFor(self)
-        self._registered = true
-    end
-end
-
--- Disable an enable()d WaitFor object.
-function leap.WaitFor:disable()
-    if self._registered then
-        unregisterWaitFor(self)
-        self._registered = false
-    end
-end
-
--- Block the calling coroutine until a suitable unsolicited event (one
--- for which filter() returns the event) arrives.
-function leap.WaitFor:wait()
-    dbg('%s about to wait', self.name)
-    local item = self._queue:Dequeue()
-    dbg('%s got %s', self.name, item)
-    return item
-end
-
--- Override filter() to examine the incoming event in whatever way
--- makes sense.
--- 
--- Return nil to ignore this event.
--- 
--- To claim the event, return the item you want placed in the queue.
--- Typically you'd write:
--- return data
--- or perhaps
--- return {pump=pump, data=data}
--- or some variation.
-function leap.WaitFor:filter(pump, data)
-    error('You must override the WaitFor.filter() method')
-end
-
--- called by unsolicited() for each WaitFor in waitfors
-function leap.WaitFor:handle(pump, data)
-    local item = self:filter(pump, data)
-    dbg('%s.filter() returned %s', self.name, item)
-    -- if this item doesn't pass the filter, we're not interested
-    if not item then
-        return false
-    end
-    -- okay, filter() claims this event
-    self:process(item)
-    return true
-end
-
--- called by WaitFor:handle() for an accepted event
-function leap.WaitFor:process(item)
-    self._queue:Enqueue(item)
-end
-
--- called by cleanup() at end
-function leap.WaitFor:close()
-    self:disable()
-    self._queue:close()
-end
-
--- called by leap.process() when get_event_next() raises an error
-function leap.WaitFor:exception(message)
-    LL.print_warning(self.name .. ' error: ' .. message)
-    self._queue:Error(message)
-end
-
--- ------------------------------ WaitForReqid -------------------------------
-leap.WaitForReqid = leap.WaitFor()
-
-function leap.WaitForReqid:new(reqid)
-    -- priority is meaningless, since this object won't be added to the
-    -- priority-sorted waitfors list. Use the reqid as the debugging name
-    -- string.
-    local obj = leap.WaitFor(nil, 'WaitForReqid(' .. reqid .. ')')
-    setmetatable(obj, self)
-    self.__index = self
-
-    obj.reqid = reqid
-
-    return obj
-end
-
-util.classctor(leap.WaitForReqid)
-
-function leap.WaitForReqid:filter(pump, data)
-    -- Because we expect to directly look up the WaitForReqid object of
-    -- interest based on the incoming ["reqid"] value, it's not necessary
-    -- to test the event again. Accept every such event.
-    return data
-end
-
-function leap.WaitForReqid:close()
-    -- remove this entry from pending table
-    pending[self.reqid] = nil
-    self._queue:close()
-end
-
-return leap
diff --git a/indra/newview/scripts/lua/printf.lua b/indra/newview/scripts/lua/printf.lua
deleted file mode 100644
index e84b2024df..0000000000
--- a/indra/newview/scripts/lua/printf.lua
+++ /dev/null
@@ -1,19 +0,0 @@
--- printf(...) is short for print(string.format(...))
-
-local inspect = require 'inspect'
-
-local function printf(format, ...)
-    -- string.format() only handles numbers and strings.
-    -- Convert anything else to string using the inspect module.
-    local args = {}
-    for _, arg in pairs(table.pack(...)) do
-        if type(arg) == 'number' or type(arg) == 'string' then
-            table.insert(args, arg)
-        else
-            table.insert(args, inspect(arg))
-        end
-    end
-    print(string.format(format, table.unpack(args)))
-end
-
-return printf
diff --git a/indra/newview/scripts/lua/require/ErrorQueue.lua b/indra/newview/scripts/lua/require/ErrorQueue.lua
new file mode 100644
index 0000000000..e6e9a5ef48
--- /dev/null
+++ b/indra/newview/scripts/lua/require/ErrorQueue.lua
@@ -0,0 +1,37 @@
+-- ErrorQueue isa WaitQueue with the added feature that a producer can push an
+-- error through the queue. Once that error is dequeued, every consumer will
+-- raise that error.
+
+local WaitQueue = require('WaitQueue')
+local function dbg(...) end
+-- local dbg = require('printf')
+local util = require('util')
+
+local ErrorQueue = WaitQueue()
+
+util.classctor(ErrorQueue)
+
+function ErrorQueue:Error(message)
+    -- Setting Error() is a marker, like closing the queue. Once we reach the
+    -- error, every subsequent Dequeue() call will raise the same error.
+    dbg('Setting self._closed to %q', message)
+    self._closed = message
+    self:_wake_waiters()
+end
+
+function ErrorQueue:Dequeue()
+    local value = WaitQueue.Dequeue(self)
+    dbg('ErrorQueue:Dequeue: base Dequeue() got %s', value)
+    if value ~= nil then
+        -- queue not yet closed, show caller
+        return value
+    end
+    if self._closed == true then
+        -- WaitQueue:close() sets true: queue has only been closed, tell caller
+        return nil
+    end
+    -- self._closed is a message set by Error()
+    error(self._closed)
+end
+
+return ErrorQueue
diff --git a/indra/newview/scripts/lua/require/Floater.lua b/indra/newview/scripts/lua/require/Floater.lua
new file mode 100644
index 0000000000..d057a74386
--- /dev/null
+++ b/indra/newview/scripts/lua/require/Floater.lua
@@ -0,0 +1,146 @@
+-- Floater base class
+
+local leap = require 'leap'
+local fiber = require 'fiber'
+local util = require 'util'
+
+-- list of all the events that a LLLuaFloater might send
+local event_list = leap.request("LLFloaterReg", {op="getFloaterEvents"}).events
+local event_set = {}
+for _, event in pairs(event_list) do
+    event_set[event] = true
+end
+
+local function _event(event_name)
+    if not event_set[event_name] then
+        error("Incorrect event name: " .. event_name, 3)
+    end
+    return event_name
+end
+
+-- ---------------------------------------------------------------------------
+local Floater = {}
+
+-- Pass:
+-- relative file path to floater's XUI definition file
+-- optional: sign up for additional events for defined control
+-- {<control_name>={action1, action2, ...}}
+function Floater:new(path, extra)
+    local obj = setmetatable({}, self)
+    self.__index = self
+
+    local path_parts = string.split(path, '/')
+    obj.name = 'Floater ' .. path_parts[#path_parts]
+
+    obj._command = {op="showLuaFloater", xml_path=LL.abspath(path)}
+    if extra then
+        -- validate each of the actions for each specified control
+        for control, actions in pairs(extra) do
+            for _, action in pairs(actions) do
+                _event(action)
+            end
+        end
+        obj._command.extra_events = extra
+    end
+
+    return obj
+end
+
+util.classctor(Floater)
+
+function Floater:show()
+    -- leap.eventstream() returns the first response, and launches a
+    -- background fiber to call the passed callback with all subsequent
+    -- responses.
+    local event = leap.eventstream(
+        'LLFloaterReg',
+        self._command,
+        -- handleEvents() returns false when done.
+        -- eventstream() expects a true return when done.
+        function(event) return not self:handleEvents(event) end)
+    self._pump = event.command_name
+    -- we might need the returned reqid to cancel the eventstream() fiber
+    self.reqid = event.reqid
+
+    -- The response to 'showLuaFloater' *is* the 'post_build' event. Check if
+    -- subclass has a post_build() method. Honor the convention that if
+    -- handleEvents() returns false, we're done.
+    if not self:handleEvents(event) then
+        return
+    end
+end
+
+function Floater:post(action)
+    leap.send(self._pump, action)
+end
+
+function Floater:request(action)
+    return leap.request(self._pump, action)
+end
+
+-- local inspect = require 'inspect'
+
+function Floater:handleEvents(event_data)
+    local event = event_data.event
+    if event_set[event] == nil then
+        LL.print_warning(string.format('%s received unknown event %q', self.name, event))
+    end
+
+    -- Before checking for a general (e.g.) commit() method, first look for
+    -- commit_ctrl_name(): in other words, concatenate the event name with the
+    -- ctrl_name, with an underscore between. If there exists such a specific
+    -- method, call that.
+    local handler, ret
+    if event_data.ctrl_name then
+        local specific = event .. '_' .. event_data.ctrl_name
+        handler = self[specific]
+        if handler then
+            ret = handler(self, event_data)
+            -- Avoid 'return ret or true' because we explicitly want to allow
+            -- the handler to return false.
+            if ret ~= nil then
+                return ret
+            else
+                return true
+            end
+        end
+    end
+
+    -- No specific "event_on_ctrl()" method found; try just "event()"
+    handler = self[event]
+    if handler then
+        ret = handler(self, event_data)
+        if ret ~= nil then
+            return ret
+        end
+--  else
+--      print(string.format('%s ignoring event %s', self.name, inspect(event_data)))
+    end
+
+    -- We check for event() method before recognizing floater_close in case
+    -- the consumer needs to react specially to closing the floater. Now that
+    -- we've checked, recognize it ourselves. Returning false terminates the
+    -- anonymous fiber function launched by leap.eventstream().
+    if event == _event('floater_close') then
+        LL.print_warning(self.name .. ' closed')
+        return false
+    end
+    return true
+end
+
+-- onCtrl() permits a different dispatch style in which the general event()
+-- method explicitly calls (e.g.)
+-- self:onCtrl(event_data, {
+--     ctrl_name=function()
+--         self:post(...)
+--     end,
+--     ...
+-- })
+function Floater:onCtrl(event_data, ctrl_map)
+    local handler = ctrl_map[event_data.ctrl_name]
+    if handler then
+        handler()
+    end
+end
+
+return Floater
diff --git a/indra/newview/scripts/lua/require/LLChat.lua b/indra/newview/scripts/lua/require/LLChat.lua
new file mode 100644
index 0000000000..78dca765e8
--- /dev/null
+++ b/indra/newview/scripts/lua/require/LLChat.lua
@@ -0,0 +1,17 @@
+local leap = require 'leap'
+
+local LLChat = {}
+
+function LLChat.sendNearby(msg)
+    leap.send('LLChatBar', {op='sendChat', message=msg})
+end
+
+function LLChat.sendWhisper(msg)
+    leap.send('LLChatBar', {op='sendChat', type='whisper', message=msg})
+end
+
+function LLChat.sendShout(msg)
+    leap.send('LLChatBar', {op='sendChat', type='shout', message=msg})
+end
+
+return LLChat
diff --git a/indra/newview/scripts/lua/require/LLDebugSettings.lua b/indra/newview/scripts/lua/require/LLDebugSettings.lua
new file mode 100644
index 0000000000..cff1a63c21
--- /dev/null
+++ b/indra/newview/scripts/lua/require/LLDebugSettings.lua
@@ -0,0 +1,17 @@
+local leap = require 'leap'
+
+local LLDebugSettings = {}
+
+function LLDebugSettings.set(name, value)
+    leap.request('LLViewerControl', {op='set', group='Global', key=name, value=value})
+end
+
+function LLDebugSettings.toggle(name)
+    leap.request('LLViewerControl', {op='toggle', group='Global', key=name})
+end
+
+function LLDebugSettings.get(name)
+    return leap.request('LLViewerControl', {op='get', group='Global', key=name})['value']
+end
+
+return LLDebugSettings
diff --git a/indra/newview/scripts/lua/require/LLFloaterAbout.lua b/indra/newview/scripts/lua/require/LLFloaterAbout.lua
new file mode 100644
index 0000000000..a6e42d364f
--- /dev/null
+++ b/indra/newview/scripts/lua/require/LLFloaterAbout.lua
@@ -0,0 +1,11 @@
+-- Engage the LLFloaterAbout LLEventAPI
+
+local leap = require 'leap'
+
+local LLFloaterAbout = {}
+
+function LLFloaterAbout.getInfo()
+    return leap.request('LLFloaterAbout', {op='getInfo'})
+end
+
+return LLFloaterAbout
diff --git a/indra/newview/scripts/lua/require/LLGesture.lua b/indra/newview/scripts/lua/require/LLGesture.lua
new file mode 100644
index 0000000000..343b611e2c
--- /dev/null
+++ b/indra/newview/scripts/lua/require/LLGesture.lua
@@ -0,0 +1,23 @@
+-- Engage the LLGesture LLEventAPI
+
+local leap = require 'leap'
+
+local LLGesture = {}
+
+function LLGesture.getActiveGestures()
+    return leap.request('LLGesture', {op='getActiveGestures'})['gestures']
+end
+
+function LLGesture.isGesturePlaying(id)
+    return leap.request('LLGesture', {op='isGesturePlaying', id=id})['playing']
+end
+
+function LLGesture.startGesture(id)
+    leap.send('LLGesture', {op='startGesture', id=id})
+end
+
+function LLGesture.stopGesture(id)
+    leap.send('LLGesture', {op='stopGesture', id=id})
+end
+
+return LLGesture
diff --git a/indra/newview/scripts/lua/require/Queue.lua b/indra/newview/scripts/lua/require/Queue.lua
new file mode 100644
index 0000000000..5bc72e4057
--- /dev/null
+++ b/indra/newview/scripts/lua/require/Queue.lua
@@ -0,0 +1,51 @@
+-- from https://create.roblox.com/docs/luau/queues#implementing-queues,
+-- amended per https://www.lua.org/pil/16.1.html
+
+-- While coding some scripting in Lua
+-- I found that I needed a queua
+-- I thought of linked list
+-- But had to resist
+-- For fear it might be too obscua. 
+
+local util = require 'util'
+
+local Queue = {}
+
+function Queue:new()
+    local obj = setmetatable({}, self)
+    self.__index = self
+
+    obj._first = 0
+    obj._last = -1
+    obj._queue = {}
+
+    return obj
+end
+
+util.classctor(Queue)
+
+-- Check if the queue is empty
+function Queue:IsEmpty()
+    return self._first > self._last
+end
+
+-- Add a value to the queue
+function Queue:Enqueue(value)
+    local last = self._last + 1
+    self._last = last
+    self._queue[last] = value
+end
+
+-- Remove a value from the queue
+function Queue:Dequeue()
+    if self:IsEmpty() then
+        return nil
+    end
+    local first = self._first
+    local value = self._queue[first]
+    self._queue[first] = nil
+    self._first = first + 1
+    return value
+end
+
+return Queue
diff --git a/indra/newview/scripts/lua/require/UI.lua b/indra/newview/scripts/lua/require/UI.lua
new file mode 100644
index 0000000000..eb1a4017c7
--- /dev/null
+++ b/indra/newview/scripts/lua/require/UI.lua
@@ -0,0 +1,125 @@
+-- Engage the viewer's UI
+
+local leap = require 'leap'
+local Timer = (require 'timers').Timer
+local mapargs = require 'mapargs'
+
+local UI = {}
+
+-- ***************************************************************************
+--  registered menu actions
+-- ***************************************************************************
+function UI.call(func, parameter)
+    -- 'call' is fire-and-forget
+    leap.request('UI', {op='call', ['function']=func, parameter=parameter})
+end
+
+function UI.getValue(path)
+    return leap.request('UI', {op='getValue', path=path})['value']
+end
+
+-- ***************************************************************************
+--  UI views
+-- ***************************************************************************
+-- Either:
+-- wreq{op='Something', a=1, b=2, ...}
+-- or:
+-- (args should be local, as this wreq() call modifies it)
+-- local args = {a=1, b=2, ...}
+-- wreq('Something', args)
+local function wreq(op_or_data, data_if_op)
+    if data_if_op ~= nil then
+        -- this is the wreq(op, data) form
+        data_if_op.op = op_or_data
+        op_or_data = data_if_op
+    end
+    return leap.request('LLWindow', op_or_data)
+end
+
+-- omit 'parent' to list all view paths
+function UI.listviews(parent)
+    return wreq{op='getPaths', under=parent}
+end
+
+function UI.viewinfo(path)
+    return wreq{op='getInfo', path=path}
+end
+
+-- ***************************************************************************
+--  mouse actions
+-- ***************************************************************************
+-- pass a table:
+-- UI.click{path=path
+--          [, button='LEFT' | 'CENTER' | 'RIGHT']
+--          [, x=x, y=y]
+--          [, hold=duration]}
+function UI.click(...)
+    local args = mapargs('path,button,x,y,hold', ...)
+    args.button = args.button or 'LEFT'
+    local hold = args.hold or 1.0
+    wreq('mouseMove', args)
+    wreq('mouseDown', args)
+    Timer(hold, 'wait')
+    wreq('mouseUp', args)
+end
+
+-- pass a table as for UI.click()
+function UI.doubleclick(...)
+    local args = mapargs('path,button,x,y', ...)
+    args.button = args.button or 'LEFT'
+    wreq('mouseDown', args)
+    wreq('mouseUp',   args)
+    wreq('mouseDown', args)
+    wreq('mouseUp',   args)
+end
+
+-- UI.drag{path=, xoff=, yoff=}
+function UI.drag(...)
+    local args = mapargs('path,xoff,yoff', ...)
+    -- query the specified path
+    local rect = UI.viewinfo(args.path).rect
+    local centerx = math.floor(rect.left   + (rect.right - rect.left)/2)
+    local centery = math.floor(rect.bottom + (rect.top   - rect.bottom)/2)
+    wreq{op='mouseMove', path=args.path, x=centerx, y=centery}
+    wreq{op='mouseDown', path=args.path, button='LEFT'}
+    wreq{op='mouseMove', path=args.path, x=centerx + args.xoff, y=centery + args.yoff}
+    wreq{op='mouseUp',   path=args.path, button='LEFT'}
+end
+
+-- ***************************************************************************
+--  keyboard actions
+-- ***************************************************************************
+-- pass a table:
+-- UI.keypress{
+--     [path=path]                      -- if omitted, default input field
+--     [, char='x']                     -- requires one of char, keycode, keysym
+--     [, keycode=120]
+--     keysym per https://github.com/secondlife/viewer/blob/main/indra/llwindow/llkeyboard.cpp#L68-L124
+--     [, keysym='Enter']
+--     [, mask={'SHIFT', 'CTL', 'ALT', 'MAC_CONTROL'}]  -- some subset of these
+--     }
+function UI.keypress(...)
+    local args = mapargs('path,char,keycode,keysym,mask', ...)
+    if args.char == '\n' then
+        args.char = nil
+        args.keysym = 'Enter'
+    end
+    return wreq('keyDown', args)
+end
+
+-- UI.type{text=, path=}
+function UI.type(...)
+    local args = mapargs('text,path', ...)
+    if #args.text > 0 then
+        -- The caller's path may be specified in a way that requires recursively
+        -- searching parts of the LLView tree. No point in doing that more than
+        -- once. Capture the actual path found by that first call and use that for
+        -- subsequent calls.
+        local path = UI.keypress{path=args.path, char=string.sub(args.text, 1, 1)}.path
+        for i = 2, #args.text do
+            UI.keypress{path=path, char=string.sub(args.text, i, i)}
+        end
+    end
+end
+
+return UI
diff --git a/indra/newview/scripts/lua/require/WaitQueue.lua b/indra/newview/scripts/lua/require/WaitQueue.lua
new file mode 100644
index 0000000000..7e10d03295
--- /dev/null
+++ b/indra/newview/scripts/lua/require/WaitQueue.lua
@@ -0,0 +1,88 @@
+-- WaitQueue isa Queue with the added feature that when the queue is empty,
+-- the Dequeue() operation blocks the calling coroutine until some other
+-- coroutine Enqueue()s a new value.
+
+local fiber = require('fiber')
+local Queue = require('Queue')
+local util  = require('util')
+
+local function dbg(...) end
+-- local dbg = require('printf')
+
+local WaitQueue = Queue()
+
+function WaitQueue:new()
+    local obj = Queue()
+    setmetatable(obj, self)
+    self.__index = self
+
+    obj._waiters = {}
+    obj._closed = false
+    return obj
+end
+
+util.classctor(WaitQueue)
+
+function WaitQueue:Enqueue(value)
+    if self._closed then
+        error("can't Enqueue() on closed Queue")
+    end
+    -- can't simply call Queue:Enqueue(value)! That calls the method on the
+    -- Queue class definition, instead of calling Queue:Enqueue() on self.
+    -- Hand-expand the Queue:Enqueue() syntactic sugar.
+    Queue.Enqueue(self, value)
+    self:_wake_waiters()
+end
+
+function WaitQueue:_wake_waiters()
+    -- WaitQueue is designed to support multi-producer, multi-consumer use
+    -- cases. With multiple consumers, if more than one is trying to
+    -- Dequeue() from an empty WaitQueue, we'll have multiple waiters.
+    -- Unlike OS threads, with cooperative concurrency it doesn't make sense
+    -- to "notify all": we need wake only one of the waiting Dequeue()
+    -- callers.
+    if ((not self:IsEmpty()) or self._closed) and next(self._waiters) then
+        -- Pop the oldest waiting coroutine instead of the most recent, for
+        -- more-or-less round robin fairness. But skip any coroutines that
+        -- have gone dead in the meantime.
+        local waiter = table.remove(self._waiters, 1)
+        while waiter and fiber.status(waiter) == "dead" do
+            waiter = table.remove(self._waiters, 1)
+        end
+        -- do we still have at least one waiting coroutine?
+        if waiter then
+            -- don't pass the head item: let the resumed coroutine retrieve it
+            fiber.wake(waiter)
+        end
+    end
+end
+
+function WaitQueue:Dequeue()
+    while self:IsEmpty() do
+        -- Don't check for closed until the queue is empty: producer can close
+        -- the queue while there are still items left, and we want the
+        -- consumer(s) to retrieve those last few items.
+        if self._closed then
+            dbg('WaitQueue:Dequeue(): closed')
+            return nil
+        end
+        dbg('WaitQueue:Dequeue(): waiting')
+        -- add the running coroutine to the list of waiters
+        dbg('WaitQueue:Dequeue() running %s', tostring(coroutine.running() or 'main'))
+        table.insert(self._waiters, fiber.running())
+        -- then let somebody else run
+        fiber.wait()
+    end
+    -- here we're sure this queue isn't empty
+    dbg('WaitQueue:Dequeue() calling Queue.Dequeue()')
+    return Queue.Dequeue(self)
+end
+
+function WaitQueue:close()
+    self._closed = true
+    -- close() is like Enqueueing an end marker. If there are waiting
+    -- consumers, give them a chance to see we're closed.
+    self:_wake_waiters()
+end
+
+return WaitQueue
diff --git a/indra/newview/scripts/lua/require/coro.lua b/indra/newview/scripts/lua/require/coro.lua
new file mode 100644
index 0000000000..616a797e95
--- /dev/null
+++ b/indra/newview/scripts/lua/require/coro.lua
@@ -0,0 +1,67 @@
+-- Manage Lua coroutines
+
+local coro = {}
+
+coro._coros = {}
+
+-- Launch a Lua coroutine: create and resume.
+-- Returns: new coroutine, values yielded or returned from initial resume()
+-- If initial resume() encountered an error, propagates the error.
+function coro.launch(func, ...)
+    local co = coroutine.create(func)
+    table.insert(coro._coros, co)
+    return co, coro.resume(co, ...)
+end
+
+-- resume() wrapper to propagate errors
+function coro.resume(co, ...)
+    -- if there's an idiom other than table.pack() to assign an arbitrary
+    -- number of return values, I don't yet know it
+    local ok_result = table.pack(coroutine.resume(co, ...))
+    if not ok_result[1] then
+        -- if [1] is false, then [2] is the error message
+        error(ok_result[2])
+    end
+    -- ok is true, whew, just return the rest of the values
+    return table.unpack(ok_result, 2)
+end
+
+-- yield to other coroutines even if you don't know whether you're in a
+-- created coroutine or the main coroutine
+function coro.yield(...)
+    if coroutine.running() then
+        -- this is a real coroutine, yield normally
+        return coroutine.yield(...)
+    else
+        -- This is the main coroutine: coroutine.yield() doesn't work.
+        -- But we can take a spin through previously-launched coroutines.
+        -- Walk a copy of coro._coros in case any of these coroutines launches
+        -- another: next() forbids creating new entries during traversal.
+        for co in coro._live_coros_iter, table.clone(coro._coros) do
+            coro.resume(co)
+        end
+    end
+end
+
+-- Walk coro._coros table, returning running or suspended coroutines.
+-- Once a coroutine becomes dead, remove it from _coros and don't return it.
+function coro._live_coros()
+    return coro._live_coros_iter, coro._coros
+end
+
+-- iterator function for _live_coros()
+function coro._live_coros_iter(t, idx)
+    local k, co = next(t, idx)
+    while k and coroutine.status(co) == 'dead' do
+--      t[k] = nil
+        -- See coro.yield(): sometimes we traverse a copy of _coros, but if we
+        -- discover a dead coroutine in that copy, delete it from _coros
+        -- anyway. Deleting it from a temporary copy does nothing.
+        coro._coros[k] = nil
+        coroutine.close(co)
+        k, co = next(t, k)
+    end
+    return co
+end
+
+return coro
diff --git a/indra/newview/scripts/lua/require/fiber.lua b/indra/newview/scripts/lua/require/fiber.lua
new file mode 100644
index 0000000000..cae27b936b
--- /dev/null
+++ b/indra/newview/scripts/lua/require/fiber.lua
@@ -0,0 +1,340 @@
+-- Organize Lua coroutines into fibers.
+
+-- In this usage, the difference between coroutines and fibers is that fibers
+-- have a scheduler. Yielding a fiber means allowing other fibers, plural, to
+-- run: it's more than just returning control to the specific Lua thread that
+-- resumed the running coroutine.
+
+-- fiber.launch() creates a new fiber ready to run.
+-- fiber.status() reports (augmented) status of the passed fiber: instead of
+-- 'suspended', it returns either 'ready' or 'waiting'
+-- fiber.yield() allows other fibers to run, but leaves the calling fiber
+-- ready to run.
+-- fiber.wait() marks the running fiber not ready, and resumes other fibers.
+-- fiber.wake() marks the designated suspended fiber ready to run, but does
+-- not yet resume it.
+-- fiber.run() runs all current fibers until all have terminated (successfully
+-- or with an error).
+
+local printf = require 'printf'
+local function dbg(...) end
+-- local dbg = printf
+local coro = require 'coro'
+
+local fiber = {}
+
+-- The tables in which we track fibers must have weak keys so dead fibers
+-- can be garbage-collected.
+local weak_values = {__mode='v'}
+local weak_keys   = {__mode='k'}
+
+-- Track each current fiber as being either ready to run or not ready
+-- (waiting). wait() moves the running fiber from ready to waiting; wake()
+-- moves the designated fiber from waiting back to ready.
+-- The ready table is used as a list so yield() can go round robin.
+local ready   = setmetatable({'main'}, weak_keys)
+-- The waiting table is used as a set because order doesn't matter.
+local waiting = setmetatable({}, weak_keys)
+
+-- Every fiber has a name, for diagnostic purposes. Names must be unique.
+-- A colliding name will be suffixed with an integer.
+-- Predefine 'main' with our marker so nobody else claims that name.
+local names  = setmetatable({main='main'}, weak_keys)
+local byname = setmetatable({main='main'}, weak_values)
+-- each colliding name has its own distinct suffix counter
+local suffix = {}
+
+-- Specify a nullary idle() callback to be called whenever there are no ready
+-- fibers but there are waiting fibers. The idle() callback is responsible for
+-- changing zero or more waiting fibers to ready fibers by calling
+-- fiber.wake(), although a given call may leave them all still waiting.
+-- When there are no ready fibers, it's a good idea for the idle() function to
+-- return control to a higher-level execution agent. Simply returning without
+-- changing any fiber's status will spin the CPU.
+-- The idle() callback can return non-nil to exit fiber.run() with that value.
+function fiber._idle()
+    error('fiber.yield(): you must first call set_idle(nullary idle() function)')
+end
+
+function fiber.set_idle(func)
+    fiber._idle = func
+end
+
+-- Launch a new Lua fiber, ready to run.
+function fiber.launch(name, func, ...)
+    local args = table.pack(...)
+    local co = coroutine.create(function() func(table.unpack(args)) end)
+    -- a new fiber is ready to run
+    table.insert(ready, co)
+    local namekey = name
+    while byname[namekey] do
+        if not suffix[name] then
+            suffix[name] = 1
+        end
+        suffix[name] += 1
+        namekey = name .. tostring(suffix[name])
+    end
+    -- found a namekey not yet in byname: set it
+    byname[namekey] = co
+    -- and remember it as this fiber's name
+    names[co] = namekey
+--  dbg('launch(%s)', namekey)
+--  dbg('byname[%s] = %s', namekey, tostring(byname[namekey]))
+--  dbg('names[%s] = %s', tostring(co), names[co])
+--  dbg('ready[-1] = %s', tostring(ready[#ready]))
+end
+
+-- for debugging
+function format_all()
+    output = {}
+    table.insert(output, 'Ready fibers:' .. if next(ready) then '' else ' none')
+    for _, co in pairs(ready) do
+        table.insert(output, string.format('  %s: %s', fiber.get_name(co), fiber.status(co)))
+    end
+    table.insert(output, 'Waiting fibers:' .. if next(waiting) then '' else ' none')
+    for co in pairs(waiting) do
+        table.insert(output, string.format('  %s: %s', fiber.get_name(co), fiber.status(co)))
+    end
+    return table.concat(output, '\n')
+end
+
+function fiber.print_all()
+    print(format_all())
+end
+
+-- return either the running coroutine or, if called from the main thread,
+-- 'main'
+function fiber.running()
+    return coroutine.running() or 'main'
+end
+
+-- Query a fiber's name (nil for the running fiber)
+function fiber.get_name(co)
+    return names[co or fiber.running()] or 'unknown'
+end
+
+-- Query status of the passed fiber
+function fiber.status(co)
+    local running = coroutine.running()
+    if (not co) or co == running then
+        -- silly to ask the status of the running fiber: it's 'running'
+        return 'running'
+    end
+    if co ~= 'main' then
+        -- for any coroutine but main, consult coroutine.status()
+        local status = coroutine.status(co)
+        if status ~= 'suspended' then
+            return status
+        end
+        -- here co is suspended, answer needs further refinement
+    else
+        -- co == 'main'
+        if not running then
+            -- asking about 'main' from the main fiber
+            return 'running'
+        end
+        -- asking about 'main' from some other fiber, so presumably main is suspended
+    end
+    -- here we know co is suspended -- but is it ready to run?
+    if waiting[co] then
+        return 'waiting'
+    end
+    -- not waiting should imply ready: sanity check
+    if table.find(ready, co) then
+        return 'ready'
+    end
+    -- Calls within yield() between popping the next ready fiber and
+    -- re-appending it to the list are in this state. Once we're done
+    -- debugging yield(), we could reinstate either of the below.
+--  error(string.format('fiber.status(%s) is stumped', fiber.get_name(co)))
+--  print(string.format('*** fiber.status(%s) is stumped', fiber.get_name(co)))
+    return '(unknown)'
+end
+
+-- change the running fiber's status to waiting
+local function set_waiting()
+    -- if called from the main fiber, inject a 'main' marker into the list
+    co = fiber.running()
+    -- delete from ready list
+    local i = table.find(ready, co)
+    if i then
+        table.remove(ready, i)
+    end
+    -- add to waiting list
+    waiting[co] = true
+end
+
+-- Suspend the current fiber until some other fiber calls fiber.wake() on it
+function fiber.wait()
+    dbg('Fiber %q waiting', fiber.get_name())
+    set_waiting()
+    -- now yield to other fibers
+    fiber.yield()
+end
+
+-- Mark a suspended fiber as being ready to run
+function fiber.wake(co)
+    if not waiting[co] then
+        error(string.format('fiber.wake(%s) but status=%s, ready=%s, waiting=%s',
+                            names[co], fiber.status(co), ready[co], waiting[co]))
+    end
+    -- delete from waiting list
+    waiting[co] = nil
+    -- add to end of ready list
+    table.insert(ready, co)
+    dbg('Fiber %q ready', fiber.get_name(co))
+    -- but don't yet resume it: that happens next time we reach yield()
+end
+
+-- pop and return the next not-dead fiber in the ready list, or nil if none remain
+local function live_ready_iter()
+    -- don't write:
+    -- for co in table.remove, ready, 1
+    -- because it would keep passing a new second parameter!
+    for co in function() return table.remove(ready, 1) end do
+        dbg('%s live_ready_iter() sees %s, status %s',
+              fiber.get_name(), fiber.get_name(co), fiber.status(co))
+        -- keep removing the head entry until we find one that's not dead,
+        -- discarding any dead coroutines along the way
+        if co == 'main' or coroutine.status(co) ~= 'dead' then
+            dbg('%s live_ready_iter() returning %s',
+                  fiber.get_name(), fiber.get_name(co))
+            return co
+        end
+    end
+    dbg('%s live_ready_iter() returning nil', fiber.get_name())
+    return nil
+end
+
+-- prune the set of waiting fibers
+local function prune_waiting()
+    for waiter in pairs(waiting) do
+        if waiter ~= 'main' and coroutine.status(waiter) == 'dead' then
+            waiting[waiter] = nil
+        end
+    end
+end
+
+-- Run other ready fibers, leaving this one ready, returning after a cycle.
+-- Returns:
+-- * true, nil if there remain other live fibers, whether ready or waiting,
+--   but it's our turn to run
+-- * false, nil if this is the only remaining fiber
+-- * nil,   x   if configured idle() callback returns non-nil x
+local function scheduler()
+    dbg('scheduler():\n%s', format_all())
+    -- scheduler() is asymmetric because Lua distinguishes the main thread
+    -- from other coroutines. The main thread can't yield; it can only resume
+    -- other coroutines. So although an arbitrary coroutine could resume still
+    -- other arbitrary coroutines, it could NOT resume the main thread because
+    -- the main thread can't yield. Therefore, scheduler() delegates its real
+    -- processing to the main thread. If called from a coroutine, pass control
+    -- back to the main thread.
+    if coroutine.running() then
+        -- this is a real coroutine, yield normally to main thread
+        coroutine.yield()
+        -- main certainly still exists
+        return true
+    end
+
+    -- This is the main fiber: coroutine.yield() doesn't work.
+    -- Instead, resume each of the ready fibers.
+    -- Prune the set of waiting fibers after every time fiber business logic
+    -- runs (i.e. other fibers might have terminated or hit error), such as
+    -- here on entry.
+    prune_waiting()
+    local others, idle_stop
+    repeat
+        for co in live_ready_iter do
+            -- seize the opportunity to make sure the viewer isn't shutting down
+            LL.check_stop()
+            -- before we re-append co, is it the only remaining entry?
+            others = next(ready)
+            -- co is live, re-append it to the ready list
+            table.insert(ready, co)
+            if co == 'main' then
+                -- Since we know the caller is the main fiber, it's our turn.
+                -- Tell caller if there are other ready or waiting fibers.
+                return others or next(waiting)
+            end
+            -- not main, but some other ready coroutine:
+            -- use coro.resume() so we'll propagate any error encountered
+            coro.resume(co)
+            prune_waiting()
+        end
+        -- Here there are no ready fibers. Are there any waiting fibers?
+        if not next(waiting) then
+            return false
+        end
+        -- there are waiting fibers: call consumer's configured idle() function
+        idle_stop = fiber._idle()
+        if idle_stop ~= nil then
+            return nil, idle_stop
+        end
+        prune_waiting()
+        -- loop "forever", that is, until:
+        -- * main is ready, or
+        -- * there are neither ready fibers nor waiting fibers, or
+        -- * fiber._idle() returned non-nil
+    until false
+end
+
+-- Let other fibers run. This is useful in either of two cases:
+-- * fiber.wait() calls this to run other fibers while this one is waiting.
+--   fiber.yield() (and therefore fiber.wait()) works from the main thread as
+--   well as from explicitly-launched fibers, without the caller having to
+--   care.
+-- * A long-running fiber that doesn't often call fiber.wait() should sprinkle
+--   in fiber.yield() calls to interleave processing on other fibers.
+function fiber.yield()
+    -- The difference between this and fiber.run() is that fiber.yield()
+    -- assumes its caller has work to do. yield() returns to its caller as
+    -- soon as scheduler() pops this fiber from the ready list. fiber.run()
+    -- continues looping until all other fibers have terminated, or the
+    -- set_idle() callback tells it to stop.
+    local others, idle_done = scheduler()
+    -- scheduler() returns either if we're ready, or if idle_done ~= nil.
+    if idle_done ~= nil then
+        -- Returning normally from yield() means the caller can carry on with
+        -- its pending work. But in this case scheduler() returned because the
+        -- configured set_idle() function interrupted it -- not because we're
+        -- actually ready. Don't return normally.
+        error('fiber.set_idle() interrupted yield() with: ' .. tostring(idle_done))
+    end
+    -- We're ready! Just return to caller. In this situation we don't care
+    -- whether there are other ready fibers.
+    dbg('fiber.yield() returning to %s (%sothers are ready)',
+        fiber.get_name(), ((not others) and "no " or ""))
+end
+
+-- Run fibers until all but main have terminated: return nil.
+-- Or until configured idle() callback returns x ~= nil: return x.
+function fiber.run()
+    -- A fiber calling run() is not also doing other useful work. Remove the
+    -- calling fiber from the ready list. Otherwise yield() would keep seeing
+    -- that our caller is ready and return to us, instead of realizing that
+    -- all coroutines are waiting and call idle(). But don't say we're
+    -- waiting, either, because then when all other fibers have terminated
+    -- we'd call idle() forever waiting for something to make us ready again.
+    local i = table.find(ready, fiber.running())
+    if i then
+        table.remove(ready, i)
+    end
+    local others, idle_done
+    repeat
+        dbg('%s calling fiber.run() calling scheduler()', fiber.get_name())
+        others, idle_done = scheduler()
+        dbg("%s fiber.run()'s scheduler() returned %s, %s", fiber.get_name(),
+              tostring(others), tostring(idle_done))
+    until (not others)
+    dbg('%s fiber.run() done', fiber.get_name())
+    -- For whatever it's worth, put our own fiber back in the ready list.
+    table.insert(ready, fiber.running())
+    -- Once there are no more waiting fibers, and the only ready fiber is
+    -- us, return to caller. All previously-launched fibers are done. Possibly
+    -- the chunk is done, or the chunk may decide to launch a new batch of
+    -- fibers.
+    return idle_done
+end
+
+return fiber
diff --git a/indra/newview/scripts/lua/require/inspect.lua b/indra/newview/scripts/lua/require/inspect.lua
new file mode 100644
index 0000000000..9900a0b81b
--- /dev/null
+++ b/indra/newview/scripts/lua/require/inspect.lua
@@ -0,0 +1,371 @@
+local _tl_compat; if (tonumber((_VERSION or ''):match('[%d.]*$')) or 0) < 5.3 then local p, m = pcall(require, 'compat53.module'); if p then _tl_compat = m end end; local math = _tl_compat and _tl_compat.math or math; local string = _tl_compat and _tl_compat.string or string; local table = _tl_compat and _tl_compat.table or table
+local inspect = {Options = {}, }
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+inspect._VERSION = 'inspect.lua 3.1.0'
+inspect._URL = 'http://github.com/kikito/inspect.lua'
+inspect._DESCRIPTION = 'human-readable representations of tables'
+inspect._LICENSE = [[
+  MIT LICENSE
+
+  Copyright (c) 2022 Enrique García Cota
+
+  Permission is hereby granted, free of charge, to any person obtaining a
+  copy of this software and associated documentation files (the
+  "Software"), to deal in the Software without restriction, including
+  without limitation the rights to use, copy, modify, merge, publish,
+  distribute, sublicense, and/or sell copies of the Software, and to
+  permit persons to whom the Software is furnished to do so, subject to
+  the following conditions:
+
+  The above copyright notice and this permission notice shall be included
+  in all copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+  OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+  CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+  TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+  SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+]]
+inspect.KEY = setmetatable({}, { __tostring = function() return 'inspect.KEY' end })
+inspect.METATABLE = setmetatable({}, { __tostring = function() return 'inspect.METATABLE' end })
+
+local tostring = tostring
+local rep = string.rep
+local match = string.match
+local char = string.char
+local gsub = string.gsub
+local fmt = string.format
+
+local _rawget
+if rawget then
+   _rawget = rawget
+else
+   _rawget = function(t, k) return t[k] end
+end
+
+local function rawpairs(t)
+   return next, t, nil
+end
+
+
+
+local function smartQuote(str)
+   if match(str, '"') and not match(str, "'") then
+      return "'" .. str .. "'"
+   end
+   return '"' .. gsub(str, '"', '\\"') .. '"'
+end
+
+
+local shortControlCharEscapes = {
+   ["\a"] = "\\a", ["\b"] = "\\b", ["\f"] = "\\f", ["\n"] = "\\n",
+   ["\r"] = "\\r", ["\t"] = "\\t", ["\v"] = "\\v", ["\127"] = "\\127",
+}
+local longControlCharEscapes = { ["\127"] = "\127" }
+for i = 0, 31 do
+   local ch = char(i)
+   if not shortControlCharEscapes[ch] then
+      shortControlCharEscapes[ch] = "\\" .. i
+      longControlCharEscapes[ch] = fmt("\\%03d", i)
+   end
+end
+
+local function escape(str)
+   return (gsub(gsub(gsub(str, "\\", "\\\\"),
+   "(%c)%f[0-9]", longControlCharEscapes),
+   "%c", shortControlCharEscapes))
+end
+
+local luaKeywords = {
+   ['and'] = true,
+   ['break'] = true,
+   ['do'] = true,
+   ['else'] = true,
+   ['elseif'] = true,
+   ['end'] = true,
+   ['false'] = true,
+   ['for'] = true,
+   ['function'] = true,
+   ['goto'] = true,
+   ['if'] = true,
+   ['in'] = true,
+   ['local'] = true,
+   ['nil'] = true,
+   ['not'] = true,
+   ['or'] = true,
+   ['repeat'] = true,
+   ['return'] = true,
+   ['then'] = true,
+   ['true'] = true,
+   ['until'] = true,
+   ['while'] = true,
+}
+
+local function isIdentifier(str)
+   return type(str) == "string" and
+   not not str:match("^[_%a][_%a%d]*$") and
+   not luaKeywords[str]
+end
+
+local flr = math.floor
+local function isSequenceKey(k, sequenceLength)
+   return type(k) == "number" and
+   flr(k) == k and
+   1 <= (k) and
+   k <= sequenceLength
+end
+
+local defaultTypeOrders = {
+   ['number'] = 1, ['boolean'] = 2, ['string'] = 3, ['table'] = 4,
+   ['function'] = 5, ['userdata'] = 6, ['thread'] = 7,
+}
+
+local function sortKeys(a, b)
+   local ta, tb = type(a), type(b)
+
+
+   if ta == tb and (ta == 'string' or ta == 'number') then
+      return (a) < (b)
+   end
+
+   local dta = defaultTypeOrders[ta] or 100
+   local dtb = defaultTypeOrders[tb] or 100
+
+
+   return dta == dtb and ta < tb or dta < dtb
+end
+
+local function getKeys(t)
+
+   local seqLen = 1
+   while _rawget(t, seqLen) ~= nil do
+      seqLen = seqLen + 1
+   end
+   seqLen = seqLen - 1
+
+   local keys, keysLen = {}, 0
+   for k in rawpairs(t) do
+      if not isSequenceKey(k, seqLen) then
+         keysLen = keysLen + 1
+         keys[keysLen] = k
+      end
+   end
+   table.sort(keys, sortKeys)
+   return keys, keysLen, seqLen
+end
+
+local function countCycles(x, cycles)
+   if type(x) == "table" then
+      if cycles[x] then
+         cycles[x] = cycles[x] + 1
+      else
+         cycles[x] = 1
+         for k, v in rawpairs(x) do
+            countCycles(k, cycles)
+            countCycles(v, cycles)
+         end
+         countCycles(getmetatable(x), cycles)
+      end
+   end
+end
+
+local function makePath(path, a, b)
+   local newPath = {}
+   local len = #path
+   for i = 1, len do newPath[i] = path[i] end
+
+   newPath[len + 1] = a
+   newPath[len + 2] = b
+
+   return newPath
+end
+
+
+local function processRecursive(process,
+   item,
+   path,
+   visited)
+   if item == nil then return nil end
+   if visited[item] then return visited[item] end
+
+   local processed = process(item, path)
+   if type(processed) == "table" then
+      local processedCopy = {}
+      visited[item] = processedCopy
+      local processedKey
+
+      for k, v in rawpairs(processed) do
+         processedKey = processRecursive(process, k, makePath(path, k, inspect.KEY), visited)
+         if processedKey ~= nil then
+            processedCopy[processedKey] = processRecursive(process, v, makePath(path, processedKey), visited)
+         end
+      end
+
+      local mt = processRecursive(process, getmetatable(processed), makePath(path, inspect.METATABLE), visited)
+      if type(mt) ~= 'table' then mt = nil end
+      setmetatable(processedCopy, mt)
+      processed = processedCopy
+   end
+   return processed
+end
+
+local function puts(buf, str)
+   buf.n = buf.n + 1
+   buf[buf.n] = str
+end
+
+
+
+local Inspector = {}
+
+
+
+
+
+
+
+
+
+
+local Inspector_mt = { __index = Inspector }
+
+local function tabify(inspector)
+   puts(inspector.buf, inspector.newline .. rep(inspector.indent, inspector.level))
+end
+
+function Inspector:getId(v)
+   local id = self.ids[v]
+   local ids = self.ids
+   if not id then
+      local tv = type(v)
+      id = (ids[tv] or 0) + 1
+      ids[v], ids[tv] = id, id
+   end
+   return tostring(id)
+end
+
+function Inspector:putValue(v)
+   local buf = self.buf
+   local tv = type(v)
+   if tv == 'string' then
+      puts(buf, smartQuote(escape(v)))
+   elseif tv == 'number' or tv == 'boolean' or tv == 'nil' or
+      tv == 'cdata' or tv == 'ctype' then
+      puts(buf, tostring(v))
+   elseif tv == 'table' and not self.ids[v] then
+      local t = v
+
+      if t == inspect.KEY or t == inspect.METATABLE then
+         puts(buf, tostring(t))
+      elseif self.level >= self.depth then
+         puts(buf, '{...}')
+      else
+         if self.cycles[t] > 1 then puts(buf, fmt('<%d>', self:getId(t))) end
+
+         local keys, keysLen, seqLen = getKeys(t)
+
+         puts(buf, '{')
+         self.level = self.level + 1
+
+         for i = 1, seqLen + keysLen do
+            if i > 1 then puts(buf, ',') end
+            if i <= seqLen then
+               puts(buf, ' ')
+               self:putValue(t[i])
+            else
+               local k = keys[i - seqLen]
+               tabify(self)
+               if isIdentifier(k) then
+                  puts(buf, k)
+               else
+                  puts(buf, "[")
+                  self:putValue(k)
+                  puts(buf, "]")
+               end
+               puts(buf, ' = ')
+               self:putValue(t[k])
+            end
+         end
+
+         local mt = getmetatable(t)
+         if type(mt) == 'table' then
+            if seqLen + keysLen > 0 then puts(buf, ',') end
+            tabify(self)
+            puts(buf, '<metatable> = ')
+            self:putValue(mt)
+         end
+
+         self.level = self.level - 1
+
+         if keysLen > 0 or type(mt) == 'table' then
+            tabify(self)
+         elseif seqLen > 0 then
+            puts(buf, ' ')
+         end
+
+         puts(buf, '}')
+      end
+
+   else
+      puts(buf, fmt('<%s %d>', tv, self:getId(v)))
+   end
+end
+
+
+
+
+function inspect.inspect(root, options)
+   options = options or {}
+
+   local depth = options.depth or (math.huge)
+   local newline = options.newline or '\n'
+   local indent = options.indent or '  '
+   local process = options.process
+
+   if process then
+      root = processRecursive(process, root, {}, {})
+   end
+
+   local cycles = {}
+   countCycles(root, cycles)
+
+   local inspector = setmetatable({
+      buf = { n = 0 },
+      ids = {},
+      cycles = cycles,
+      depth = depth,
+      level = 0,
+      newline = newline,
+      indent = indent,
+   }, Inspector_mt)
+
+   inspector:putValue(root)
+
+   return table.concat(inspector.buf)
+end
+
+setmetatable(inspect, {
+   __call = function(_, root, options)
+      return inspect.inspect(root, options)
+   end,
+})
+
+return inspect
diff --git a/indra/newview/scripts/lua/require/leap.lua b/indra/newview/scripts/lua/require/leap.lua
new file mode 100644
index 0000000000..82f91ce9e9
--- /dev/null
+++ b/indra/newview/scripts/lua/require/leap.lua
@@ -0,0 +1,550 @@
+-- Lua implementation of LEAP (LLSD Event API Plugin) protocol
+--
+-- This module supports Lua scripts run by the Second Life viewer.
+--
+-- LEAP protocol passes LLSD objects, converted to/from Lua tables, in both
+-- directions. A typical LLSD object is a map containing keys 'pump' and
+-- 'data'.
+--
+-- The viewer's Lua post_to(pump, data) function posts 'data' to the
+-- LLEventPump 'pump'. This is typically used to engage an LLEventAPI method.
+--
+-- Similarly, the viewer gives each Lua script its own LLEventPump with a
+-- unique name. That name is returned by get_event_pumps(). Every event
+-- received on that LLEventPump is queued for retrieval by get_event_next(),
+-- which returns (pump, data): the name of the LLEventPump on which the event
+-- was received and the received event data. When the queue is empty,
+-- get_event_next() blocks the calling Lua script until the next event is
+-- received.
+--
+-- Usage:
+-- 1. Launch some number of Lua coroutines. The code in each coroutine may
+--    call leap.send(), leap.request() or leap.generate(). leap.send() returns
+--    immediately ("fire and forget"). leap.request() blocks the calling
+--    coroutine until it receives and returns the viewer's response to its
+--    request. leap.generate() expects an arbitrary number of responses to the
+--    original request.
+-- 2. To handle events from the viewer other than direct responses to
+--    requests, instantiate a leap.WaitFor object with a filter(pump, data)
+--    override method that returns non-nil for desired events. A coroutine may
+--    call wait() on any such WaitFor.
+-- 3. Once the coroutines have been launched, call leap.process() on the main
+--    coroutine. process() retrieves incoming events from the viewer and
+--    dispatches them to waiting request() or generate() calls, or to
+--    appropriate WaitFor instances. process() returns when either
+--    get_event_next() raises an error or the viewer posts nil to the script's
+--    reply pump to indicate it's done.
+-- 4. Alternatively, a running coroutine may call leap.done() to break out of
+--    leap.process(). process() won't notice until the next event from the
+--    viewer, though.
+
+local fiber = require('fiber')
+local ErrorQueue = require('ErrorQueue')
+local inspect = require('inspect')
+local function dbg(...) end 
+-- local dbg = require('printf')
+local util = require('util')
+
+local leap = {}
+
+-- reply: string name of reply LLEventPump. Any events the viewer posts to
+-- this pump will be queued for get_event_next(). We usually specify it as the
+-- reply pump for requests to internal viewer services.
+-- command: string name of command LLEventPump. post_to(command, ...)
+-- engages LLLeapListener operations such as listening on a specified other
+-- LLEventPump, etc.
+local reply, command = LL.get_event_pumps()
+-- Dict of features added to the LEAP protocol since baseline implementation.
+-- Before engaging a new feature that might break an older viewer, we can
+-- check for the presence of that feature key. This table is solely about the
+-- LEAP protocol itself, the way we communicate with the viewer. To discover
+-- whether a given listener exists, or supports a particular operation, use
+-- command's "getAPI" operation.
+-- For Lua, command's "getFeatures" operation suffices?
+-- leap._features = {}
+
+-- Each outstanding request() or generate() call has a corresponding
+-- WaitForReqid object (later in this module) to handle the
+-- response(s). If an incoming event contains an echoed ["reqid"] key,
+-- we can look up the appropriate WaitForReqid object more efficiently
+-- in a dict than by tossing such objects into the usual waitfors list.
+-- Note: the ["reqid"] must be unique, otherwise we could end up
+-- replacing an earlier WaitForReqid object in pending with a
+-- later one. That means that no incoming event will ever be given to
+-- the old WaitForReqid object. Any coroutine waiting on the discarded
+-- WaitForReqid object would therefore wait forever.
+-- pending is NOT a weak table because the caller of request() or generate()
+-- never sees the WaitForReqid object. pending holds the only reference, so
+-- it should NOT be garbage-collected.
+local pending = {}
+-- Our consumer will instantiate some number of WaitFor subclass objects.
+-- As these are traversed in descending priority order, we must keep
+-- them in a list.
+-- Anyone who instantiates a WaitFor subclass object should retain a reference
+-- to it. Once the consuming script drops the reference, allow Lua to
+-- garbage-collect the WaitFor despite its entry in waitfors.
+local weak_values = {__mode='v'}
+local waitfors = setmetatable({}, weak_values)
+-- It has been suggested that we should use UUIDs as ["reqid"] values,
+-- since UUIDs are guaranteed unique. However, as the "namespace" for
+-- ["reqid"] values is our very own reply pump, we can get away with
+-- an integer.
+leap._reqid = 0
+-- break leap.process() loop
+leap._done = false
+
+-- get the name of the reply pump
+function leap.replypump()
+    return reply
+end
+
+-- get the name of the command pump
+function leap.cmdpump()
+    return command
+end
+
+-- Fire and forget. Send the specified request LLSD, expecting no reply.
+-- In fact, should the request produce an eventual reply, it will be
+-- treated as an unsolicited event.
+-- 
+-- See also request(), generate().
+function leap.send(pump, data, reqid)
+    local data = data
+    if type(data) == 'table' then
+        data = table.clone(data)
+        data['reply'] = reply
+        if reqid ~= nil then
+            data['reqid'] = reqid
+        end
+    end
+    dbg('leap.send(%s, %s) calling post_on()', pump, data)
+    LL.post_on(pump, data)
+end
+
+-- common setup code shared by request() and generate()
+local function requestSetup(pump, data)
+    -- invent a new, unique reqid
+    leap._reqid += 1
+    local reqid = leap._reqid
+    -- Instantiate a new WaitForReqid object. The priority is irrelevant
+    -- because, unlike the WaitFor base class, WaitForReqid does not
+    -- self-register on our waitfors list. Instead, capture the new
+    -- WaitForReqid object in pending so dispatch() can find it.
+    local waitfor = leap.WaitForReqid(reqid)
+    pending[reqid] = waitfor
+    -- Pass reqid to send() to stamp it into (a copy of) the request data.
+    dbg('requestSetup(%s, %s) storing %s', pump, data, waitfor.name)
+    leap.send(pump, data, reqid)
+    return reqid, waitfor
+end
+
+-- Send the specified request LLSD, expecting exactly one reply. Block
+-- the calling coroutine until we receive that reply.
+-- 
+-- Every request() (or generate()) LLSD block we send will get stamped
+-- with a distinct ["reqid"] value. The requested event API must echo the
+-- same ["reqid"] field in each reply associated with that request. This way
+-- we can correctly dispatch interleaved replies from different requests.
+-- 
+-- If the desired event API doesn't support the ["reqid"] echo convention,
+-- you should use send() instead -- since request() or generate() would
+-- wait forever for a reply stamped with that ["reqid"] -- and intercept
+-- any replies using WaitFor.
+-- 
+-- Unless the request data already contains a ["reply"] key, we insert
+-- reply=self.replypump to try to ensure that the expected reply will be
+-- returned over the socket.
+--
+-- See also send(), generate().
+function leap.request(pump, data)
+    local reqid, waitfor = requestSetup(pump, data)
+    dbg('leap.request(%s, %s) about to wait on %s', pump, data, tostring(waitfor))
+    local ok, response = pcall(waitfor.wait, waitfor)
+    dbg('leap.request(%s, %s) got %s: %s', pump, data, ok, response)
+    -- kill off temporary WaitForReqid object, even if error
+    pending[reqid] = nil
+    if not ok then
+        error(response)
+    elseif response.error then
+        error(response.error)
+    else
+        return response
+    end
+end
+
+-- Send the specified request LLSD, expecting an arbitrary number of replies.
+-- Each one is returned on request.
+--
+-- Usage:
+-- sequence = leap.generate(pump, data)
+-- repeat
+--     response = sequence.next()
+-- until last(response)
+-- (last() means whatever test the caller wants to perform on response)
+-- sequence.done()
+-- 
+-- See request() remarks about ["reqid"].
+--
+-- Note: this seems like a prime use case for Lua coroutines. But in a script
+-- using fibers.lua, a "wild" coroutine confuses the fiber scheduler. If
+-- generate() were itself a coroutine, it would call WaitForReqid:wait(),
+-- which would yield -- thereby resuming generate() WITHOUT waiting.
+function leap.generate(pump, data, checklast)
+    -- Invent a new, unique reqid. Arrange to handle incoming events
+    -- bearing that reqid. Stamp the outbound request with that reqid, and
+    -- send it.
+    local reqid, waitfor = requestSetup(pump, data)
+    return {
+        next = function()
+            dbg('leap.generate(%s).next() about to wait on %s', reqid, tostring(waitfor))
+            local ok, response = pcall(waitfor.wait, waitfor)
+            dbg('leap.generate(%s).next() got %s: %s', reqid, ok, response)
+            if not ok then
+                error(response)
+            elseif response.error then
+                error(response.error)
+            else
+                return response
+            end
+        end,
+        done = function()
+            -- cleanup consists of removing our WaitForReqid from pending
+            pending[reqid] = nil
+        end
+    }
+end
+
+-- Send the specified request LLSD, expecting an immediate reply followed by
+-- an arbitrary number of subsequent replies with the same reqid. Block the
+-- calling coroutine until the first (immediate) reply, but launch a separate
+-- fiber on which to call the passed callback with later replies.
+--
+-- Once the callback returns true, the background fiber terminates.
+function leap.eventstream(pump, data, callback)
+    local reqid, waitfor = requestSetup(pump, data)
+    local response = waitfor:wait()
+    if response.error then
+        -- clean up our WaitForReqid
+        waitfor:close()
+        error(response.error)
+    end
+    -- No error, so far so good:
+    -- call the callback with the first response just in case
+    dbg('leap.eventstream(%s): first callback', reqid)
+    local ok, done = pcall(callback, response)
+    dbg('leap.eventstream(%s) got %s, %s', reqid, ok, done)
+    if not ok then
+        -- clean up our WaitForReqid
+        waitfor:close()
+        error(done)
+    end
+    if done then
+        return response
+    end
+    -- callback didn't throw an error, and didn't say stop,
+    -- so set up to handle subsequent events
+    -- TODO: distinguish "daemon" fibers that can be terminated even if waiting
+    fiber.launch(
+        pump,
+        function ()
+            local ok, done
+            local nth = 1
+            repeat
+                event = waitfor:wait()
+                if not event then
+                    -- wait() returns nil once the queue is closed (e.g. cancelreq())
+                    ok, done = true, true
+                else
+                    nth += 1
+                    dbg('leap.eventstream(%s): callback %d', reqid, nth)
+                    ok, done = pcall(callback, event)
+                    dbg('leap.eventstream(%s) got %s, %s', reqid, ok, done)
+                end
+                -- not ok means callback threw an error (caught as 'done')
+                -- done means callback succeeded but wants to stop
+            until (not ok) or done
+            -- once we break this loop, clean up our WaitForReqid
+            waitfor:close()
+            if not ok then
+                -- can't reflect the error back to our caller
+                LL.print_warning(fiber.get_name() .. ': ' .. done)
+            end
+        end)
+    return response
+end
+
+-- we might want to clean up after leap.eventstream() even if the callback has
+-- not yet returned true
+function leap.cancelreq(reqid)
+    dbg('cancelreq(%s)', reqid)
+    local waitfor = pending[reqid]
+    if waitfor ~= nil then
+        -- close() removes the pending entry and also closes the queue,
+        -- breaking the background fiber's wait loop.
+        dbg('cancelreq(%s) canceling %s', reqid, waitfor.name)
+        waitfor:close()
+    end
+end
+
+local function cleanup(message)
+    -- We're done: clean up all pending coroutines.
+    -- Iterate over copies of the pending and waitfors tables, since the
+    -- close() operation modifies the real tables.
+    for i, waitfor in pairs(table.clone(pending)) do
+        waitfor:close()
+    end
+    for i, waitfor in pairs(table.clone(waitfors)) do
+        waitfor:close()
+    end
+end
+
+-- Handle an incoming (pump, data) event with no recognizable ['reqid']
+local function unsolicited(pump, data)
+    -- we maintain waitfors in descending priority order, so the first waitfor
+    -- to claim this event is the one with the highest priority
+    for i, waitfor in pairs(waitfors) do
+        dbg('unsolicited() checking %s', waitfor.name)
+        if waitfor:handle(pump, data) then
+            return
+        end
+    end
+    LL.print_debug(string.format('unsolicited(%s, %s) discarding unclaimed event',
+                                 pump, inspect(data)))
+end
+
+-- Route incoming (pump, data) event to the appropriate waiting coroutine.
+local function dispatch(pump, data)
+    local reqid = data['reqid']
+    -- if the response has no 'reqid', it's not from request() or generate()
+    if reqid == nil then
+--      dbg('dispatch() found no reqid; calling unsolicited(%s, %s)', pump, data)
+        return unsolicited(pump, data)
+    end
+    -- have reqid; do we have a WaitForReqid?
+    local waitfor = pending[reqid]
+    if waitfor == nil then
+--      dbg('dispatch() found no WaitForReqid(%s); calling unsolicited(%s, %s)', reqid, pump, data)
+        return unsolicited(pump, data)
+    end
+    -- found the right WaitForReqid object, let it handle the event
+--  dbg('dispatch() calling %s.handle(%s, %s)', waitfor.name, pump, data)
+    waitfor:handle(pump, data)
+end
+
+-- We configure fiber.set_idle() function. fiber.yield() calls the configured
+-- idle callback whenever there are waiting fibers but no ready fibers. In
+-- our case, that means it's time to fetch another incoming viewer event.
+fiber.set_idle(function ()
+    -- If someone has called leap.done(), then tell fiber.yield() to break loop.
+    if leap._done then
+        cleanup('done')
+        return 'done'
+    end
+    dbg('leap.idle() calling get_event_next()')
+    local ok, pump, data = pcall(LL.get_event_next)
+    dbg('leap.idle() got %s: %s, %s', ok, pump, data)
+    -- ok false means get_event_next() raised a Lua error, pump is message
+    if not ok then
+        cleanup(pump)
+        error(pump)
+    end
+    -- data nil means get_event_next() returned (pump, LLSD()) to indicate done
+    if not data then
+        cleanup('end')
+        return 'end'
+    end
+    -- got a real pump, data pair 
+    dispatch(pump, data)
+    -- return to fiber.yield(): any incoming message might result in one or
+    -- more fibers becoming ready
+end)
+
+function leap.done()
+    leap._done = true
+end
+
+-- called by WaitFor.enable()
+local function registerWaitFor(waitfor)
+    table.insert(waitfors, waitfor)
+    -- keep waitfors sorted in descending order of specified priority
+    table.sort(waitfors,
+               function (lhs, rhs) return lhs.priority > rhs.priority end)
+end
+
+-- called by WaitFor.disable()
+local function unregisterWaitFor(waitfor)
+    local i = table.find(waitfors, waitfor)
+    if i ~= nil then
+        waitfors[i] = nil
+    end
+end
+
+-- ******************************************************************************
+-- WaitFor and friends
+-- ******************************************************************************
+
+-- An unsolicited event is handled by the highest-priority WaitFor subclass
+-- object willing to accept it. If no such object is found, the unsolicited
+-- event is discarded.
+-- 
+-- * First, instantiate a WaitFor subclass object to register its interest in
+--   some incoming event(s). WaitFor instances are self-registering; merely
+--   instantiating the object suffices.
+-- * Any coroutine may call a given WaitFor object's wait() method. This blocks
+--   the calling coroutine until a suitable event arrives.
+-- * WaitFor's constructor accepts a float priority. Every incoming event
+--   (other than those claimed by request() or generate()) is passed to each
+--   extant WaitFor.filter() method in descending priority order. The first
+--   such filter() to return nontrivial data claims that event.
+-- * At that point, the blocked wait() call on that WaitFor object returns the
+--   item returned by filter().
+-- * WaitFor contains a queue. Multiple arriving events claimed by that WaitFor
+--   object's filter() method are added to the queue. Naturally, until the
+--   queue is empty, calling wait() immediately returns the front entry.
+-- 
+-- It's reasonable to instantiate a WaitFor subclass whose filter() method
+-- unconditionally returns the incoming event, and whose priority places it
+-- last in the list. This object will enqueue every unsolicited event left
+-- unclaimed by other WaitFor subclass objects.
+-- 
+-- It's not strictly necessary to associate a WaitFor object with exactly one
+-- coroutine. You might have multiple "worker" coroutines drawing from the same
+-- WaitFor object, useful if the work being done per event might itself involve
+-- "blocking" operations. Or a given coroutine might sample a number of WaitFor
+-- objects in round-robin fashion... etc. etc. Nonetheless, it's
+-- straightforward to designate one coroutine for each WaitFor object.
+
+-- --------------------------------- WaitFor ---------------------------------
+leap.WaitFor = { _id=0 }
+
+function leap.WaitFor.tostring(self)
+    -- Lua (sub)classes have no name; can't prefix with that
+    return self.name
+end
+
+function leap.WaitFor:new(priority, name)
+    local obj = setmetatable({__tostring=leap.WaitFor.tostring}, self)
+    self.__index = self
+
+    obj.priority = priority
+    if name then
+        obj.name = name
+    else
+        self._id += 1
+        obj.name = 'WaitFor' .. self._id
+    end
+    obj._queue = ErrorQueue()
+    obj._registered = false
+    -- if no priority, then don't enable() - remember 0 is truthy
+    if priority then
+        obj:enable()
+    end
+
+    return obj
+end
+
+util.classctor(leap.WaitFor)
+
+-- Re-enable a disable()d WaitFor object. New WaitFor objects are
+-- enable()d by default.
+function leap.WaitFor:enable()
+    if not self._registered then
+        registerWaitFor(self)
+        self._registered = true
+    end
+end
+
+-- Disable an enable()d WaitFor object.
+function leap.WaitFor:disable()
+    if self._registered then
+        unregisterWaitFor(self)
+        self._registered = false
+    end
+end
+
+-- Block the calling coroutine until a suitable unsolicited event (one
+-- for which filter() returns the event) arrives.
+function leap.WaitFor:wait()
+    dbg('%s about to wait', self.name)
+    local item = self._queue:Dequeue()
+    dbg('%s got %s', self.name, item)
+    return item
+end
+
+-- Override filter() to examine the incoming event in whatever way
+-- makes sense.
+-- 
+-- Return nil to ignore this event.
+-- 
+-- To claim the event, return the item you want placed in the queue.
+-- Typically you'd write:
+-- return data
+-- or perhaps
+-- return {pump=pump, data=data}
+-- or some variation.
+function leap.WaitFor:filter(pump, data)
+    error('You must override the WaitFor.filter() method')
+end
+
+-- called by unsolicited() for each WaitFor in waitfors
+function leap.WaitFor:handle(pump, data)
+    local item = self:filter(pump, data)
+    dbg('%s.filter() returned %s', self.name, item)
+    -- if this item doesn't pass the filter, we're not interested
+    if not item then
+        return false
+    end
+    -- okay, filter() claims this event
+    self:process(item)
+    return true
+end
+
+-- called by WaitFor:handle() for an accepted event
+function leap.WaitFor:process(item)
+    self._queue:Enqueue(item)
+end
+
+-- called by cleanup() at end
+function leap.WaitFor:close()
+    self:disable()
+    self._queue:close()
+end
+
+-- called by leap.process() when get_event_next() raises an error
+function leap.WaitFor:exception(message)
+    LL.print_warning(self.name .. ' error: ' .. message)
+    self._queue:Error(message)
+end
+
+-- ------------------------------ WaitForReqid -------------------------------
+leap.WaitForReqid = leap.WaitFor()
+
+function leap.WaitForReqid:new(reqid)
+    -- priority is meaningless, since this object won't be added to the
+    -- priority-sorted waitfors list. Use the reqid as the debugging name
+    -- string.
+    local obj = leap.WaitFor(nil, 'WaitForReqid(' .. reqid .. ')')
+    setmetatable(obj, self)
+    self.__index = self
+
+    obj.reqid = reqid
+
+    return obj
+end
+
+util.classctor(leap.WaitForReqid)
+
+function leap.WaitForReqid:filter(pump, data)
+    -- Because we expect to directly look up the WaitForReqid object of
+    -- interest based on the incoming ["reqid"] value, it's not necessary
+    -- to test the event again. Accept every such event.
+    return data
+end
+
+function leap.WaitForReqid:close()
+    -- remove this entry from pending table
+    pending[self.reqid] = nil
+    self._queue:close()
+end
+
+return leap
diff --git a/indra/newview/scripts/lua/require/printf.lua b/indra/newview/scripts/lua/require/printf.lua
new file mode 100644
index 0000000000..e84b2024df
--- /dev/null
+++ b/indra/newview/scripts/lua/require/printf.lua
@@ -0,0 +1,19 @@
+-- printf(...) is short for print(string.format(...))
+
+local inspect = require 'inspect'
+
+local function printf(format, ...)
+    -- string.format() only handles numbers and strings.
+    -- Convert anything else to string using the inspect module.
+    local args = {}
+    for _, arg in pairs(table.pack(...)) do
+        if type(arg) == 'number' or type(arg) == 'string' then
+            table.insert(args, arg)
+        else
+            table.insert(args, inspect(arg))
+        end
+    end
+    print(string.format(format, table.unpack(args)))
+end
+
+return printf
diff --git a/indra/newview/scripts/lua/require/startup.lua b/indra/newview/scripts/lua/require/startup.lua
new file mode 100644
index 0000000000..c3040f94b8
--- /dev/null
+++ b/indra/newview/scripts/lua/require/startup.lua
@@ -0,0 +1,100 @@
+-- query, wait for or mandate a particular viewer startup state
+
+-- During startup, the viewer steps through a sequence of numbered (and named)
+-- states. This can be used to detect when, for instance, the login screen is
+-- displayed, or when the viewer has finished logging in and is fully
+-- in-world.
+
+local fiber = require 'fiber'
+local leap = require 'leap'
+local inspect = require 'inspect'
+local function dbg(...) end
+-- local dbg = require 'printf'
+
+-- ---------------------------------------------------------------------------
+local startup = {}
+
+-- Get the list of startup states from the viewer.
+local bynum = leap.request('LLStartUp', {op='getStateTable'})['table']
+
+local byname = setmetatable(
+    {},
+    -- set metatable to throw an error if you look up invalid state name
+    {__index=function(t, k)
+         local v = rawget(t, k)
+         if v then
+             return v
+         end
+         error(string.format('startup module passed invalid state %q', k), 2)
+    end})
+
+-- derive byname as a lookup table to find the 0-based index for a given name
+for i, name in pairs(bynum) do
+    -- the viewer's states are 0-based, not 1-based like Lua indexes
+    byname[name] = i - 1
+end
+-- dbg('startup states: %s', inspect(byname))
+
+-- specialize a WaitFor to track the viewer's startup state
+local startup_pump = 'StartupState'
+local waitfor = leap.WaitFor(0, startup_pump)
+function waitfor:filter(pump, data)
+    if pump == self.name then
+        return data
+    end
+end
+
+function waitfor:process(data)
+    -- keep updating startup._state for interested parties
+    startup._state = data.str
+    dbg('startup updating state to %q', data.str)
+    -- now pass data along to base-class method to queue
+    leap.WaitFor.process(self, data)
+end
+
+-- listen for StartupState events
+leap.request(leap.cmdpump(),
+             {op='listen', source=startup_pump, listener='startup.lua', tweak=true})
+-- poke LLStartUp to make sure we get an event
+leap.send('LLStartUp', {op='postStartupState'})
+
+-- ---------------------------------------------------------------------------
+-- wait for response from postStartupState
+while not startup._state do
+    dbg('startup.state() waiting for first StartupState event')
+    waitfor:wait()
+end
+
+-- return a list of all known startup states
+function startup.list()
+    return bynum
+end
+
+-- report whether state with string name 'left' is before string name 'right'
+function startup.before(left, right)
+    return byname[left] < byname[right]
+end
+
+-- report the viewer's current startup state
+function startup.state()
+    return startup._state
+end
+
+-- error if script is called before specified state string name
+function startup.ensure(state)
+    if startup.before(startup.state(), state) then
+        -- tell error() to pretend this error was thrown by our caller
+        error('must not be called before startup state ' .. state, 2)
+    end
+end
+
+-- block calling fiber until viewer has reached state with specified string name
+function startup.wait(state)
+    dbg('startup.wait(%q)', state)
+    while startup.before(startup.state(), state) do
+        local item = waitfor:wait()
+        dbg('startup.wait(%q) sees %s', state, item)
+    end
+end
+
+return startup
diff --git a/indra/newview/scripts/lua/require/timers.lua b/indra/newview/scripts/lua/require/timers.lua
new file mode 100644
index 0000000000..e4938078dc
--- /dev/null
+++ b/indra/newview/scripts/lua/require/timers.lua
@@ -0,0 +1,104 @@
+-- Access to the viewer's time-delay facilities
+
+local leap = require 'leap'
+local util = require 'util'
+
+local timers = {}
+
+local function dbg(...) end
+-- local dbg = require 'printf'
+
+timers.Timer = {}
+
+-- delay:    time in seconds until callback
+-- callback: 'wait', or function to call when timer fires (self:tick if nil)
+-- iterate:  if non-nil, call callback repeatedly until it returns non-nil
+--           (ignored if 'wait')
+function timers.Timer:new(delay, callback, iterate)
+    local obj = setmetatable({}, self)
+    self.__index = self
+
+    if callback == 'wait' then
+        dbg('scheduleAfter(%d):', delay)
+        sequence = leap.generate('Timers', {op='scheduleAfter', after=delay})
+        -- ignore the immediate return
+        dbg('scheduleAfter(%d) -> %s', delay,
+        sequence.next())
+        -- this call is where we wait for real
+        dbg('next():')
+        dbg('next() -> %s',
+        sequence.next())
+        sequence.done()
+        return
+    end
+
+    callback = callback or function() obj:tick() end
+
+    local first = true
+    if iterate then
+        obj.id = leap.eventstream(
+            'Timers',
+            {op='scheduleEvery', every=delay},
+            function (event)
+                local reqid = event.reqid
+                if first then
+                    first = false
+                    dbg('timer(%s) first callback', reqid)
+                    -- discard the first (immediate) response: don't call callback
+                    return nil
+                else
+                    dbg('timer(%s) nth callback', reqid)
+                    return callback(event)
+                end
+            end
+        ).reqid
+    else
+        obj.id = leap.eventstream(
+            'Timers',
+            {op='scheduleAfter', after=delay},
+            function (event)
+                -- Arrange to return nil the first time, true the second. This
+                -- callback is called immediately with the response to
+                -- 'scheduleAfter', and if we immediately returned true, we'd
+                -- be done, and the subsequent timer event would be discarded.
+                if first then
+                    first = false
+                    -- Caller doesn't expect an immediate callback.
+                    return nil
+                else
+                    callback(event)
+                    -- Since caller doesn't want to iterate, the value
+                    -- returned by the callback is irrelevant: just stop after
+                    -- this one and only call.
+                    return true
+                end
+            end
+        ).reqid
+    end
+
+    return obj
+end
+
+util.classctor(timers.Timer)
+
+function timers.Timer:tick()
+    error('Pass a callback to Timer:new(), or override Timer:tick()')
+end
+
+function timers.Timer:cancel()
+    local ok = leap.request('Timers', {op='cancel', id=self.id}).ok
+    leap.cancelreq(self.id)
+    return ok
+end
+
+function timers.Timer:isRunning()
+    return leap.request('Timers', {op='isRunning', id=self.id}).running
+end
+
+-- returns (true, seconds left) for a live timer, else (false, 0)
+function timers.Timer:timeUntilCall()
+    local result = leap.request('Timers', {op='timeUntilCall', id=self.id})
+    return result.ok, result.remaining
+end
+
+return timers
diff --git a/indra/newview/scripts/lua/require/util.lua b/indra/newview/scripts/lua/require/util.lua
new file mode 100644
index 0000000000..bfbfc8637c
--- /dev/null
+++ b/indra/newview/scripts/lua/require/util.lua
@@ -0,0 +1,69 @@
+-- utility functions, in alpha order
+
+local util = {}
+
+-- Allow MyClass(ctor args...) equivalent to MyClass:new(ctor args...)
+-- Usage:
+-- local MyClass = {}
+-- function MyClass:new(...)
+--     ...
+-- end
+-- ...
+-- util.classctor(MyClass)
+-- or if your constructor is named something other than MyClass:new(), e.g.
+-- MyClass:construct():
+-- util.classctor(MyClass, MyClass.construct)
+-- return MyClass
+function util.classctor(class, ctor)
+    -- get the metatable for the passed class
+    local mt = getmetatable(class)
+    if mt == nil then
+        -- if it doesn't already have a metatable, then create one
+        mt = {}
+        setmetatable(class, mt)
+    end
+    -- now that class has a metatable, set its __call method to the specified
+    -- constructor method (class.new if not specified)
+    mt.__call = ctor or class.new
+end
+
+-- check if array-like table contains certain value
+function util.contains(t, v)
+    return table.find(t, v) ~= nil
+end
+
+-- reliable count of the number of entries in table t
+-- (since #t is unreliable)
+function util.count(t)
+    local count = 0
+    for _ in pairs(t) do
+        count += 1
+    end
+    return count
+end
+
+-- cheap test whether table t is empty
+function util.empty(t)
+    return not next(t)
+end
+
+-- recursive table equality
+function util.equal(t1, t2)
+    if not (type(t1) == 'table' and type(t2) == 'table') then
+        return t1 == t2
+    end
+    -- both t1 and t2 are tables: get modifiable copy of t2
+    local temp = table.clone(t2)
+    for k, v in pairs(t1) do
+        -- if any key in t1 doesn't have same value in t2, not equal
+        if not util.equal(v, temp[k]) then
+            return false
+        end
+        -- temp[k] == t1[k], delete temp[k]
+        temp[k] = nil
+    end
+    -- All keys in t1 have equal values in t2; t2 == t1 if there are no extra keys in t2
+    return util.empty(temp)
+end
+
+return util
diff --git a/indra/newview/scripts/lua/startup.lua b/indra/newview/scripts/lua/startup.lua
deleted file mode 100644
index c3040f94b8..0000000000
--- a/indra/newview/scripts/lua/startup.lua
+++ /dev/null
@@ -1,100 +0,0 @@
--- query, wait for or mandate a particular viewer startup state
-
--- During startup, the viewer steps through a sequence of numbered (and named)
--- states. This can be used to detect when, for instance, the login screen is
--- displayed, or when the viewer has finished logging in and is fully
--- in-world.
-
-local fiber = require 'fiber'
-local leap = require 'leap'
-local inspect = require 'inspect'
-local function dbg(...) end
--- local dbg = require 'printf'
-
--- ---------------------------------------------------------------------------
-local startup = {}
-
--- Get the list of startup states from the viewer.
-local bynum = leap.request('LLStartUp', {op='getStateTable'})['table']
-
-local byname = setmetatable(
-    {},
-    -- set metatable to throw an error if you look up invalid state name
-    {__index=function(t, k)
-         local v = rawget(t, k)
-         if v then
-             return v
-         end
-         error(string.format('startup module passed invalid state %q', k), 2)
-    end})
-
--- derive byname as a lookup table to find the 0-based index for a given name
-for i, name in pairs(bynum) do
-    -- the viewer's states are 0-based, not 1-based like Lua indexes
-    byname[name] = i - 1
-end
--- dbg('startup states: %s', inspect(byname))
-
--- specialize a WaitFor to track the viewer's startup state
-local startup_pump = 'StartupState'
-local waitfor = leap.WaitFor(0, startup_pump)
-function waitfor:filter(pump, data)
-    if pump == self.name then
-        return data
-    end
-end
-
-function waitfor:process(data)
-    -- keep updating startup._state for interested parties
-    startup._state = data.str
-    dbg('startup updating state to %q', data.str)
-    -- now pass data along to base-class method to queue
-    leap.WaitFor.process(self, data)
-end
-
--- listen for StartupState events
-leap.request(leap.cmdpump(),
-             {op='listen', source=startup_pump, listener='startup.lua', tweak=true})
--- poke LLStartUp to make sure we get an event
-leap.send('LLStartUp', {op='postStartupState'})
-
--- ---------------------------------------------------------------------------
--- wait for response from postStartupState
-while not startup._state do
-    dbg('startup.state() waiting for first StartupState event')
-    waitfor:wait()
-end
-
--- return a list of all known startup states
-function startup.list()
-    return bynum
-end
-
--- report whether state with string name 'left' is before string name 'right'
-function startup.before(left, right)
-    return byname[left] < byname[right]
-end
-
--- report the viewer's current startup state
-function startup.state()
-    return startup._state
-end
-
--- error if script is called before specified state string name
-function startup.ensure(state)
-    if startup.before(startup.state(), state) then
-        -- tell error() to pretend this error was thrown by our caller
-        error('must not be called before startup state ' .. state, 2)
-    end
-end
-
--- block calling fiber until viewer has reached state with specified string name
-function startup.wait(state)
-    dbg('startup.wait(%q)', state)
-    while startup.before(startup.state(), state) do
-        local item = waitfor:wait()
-        dbg('startup.wait(%q) sees %s', state, item)
-    end
-end
-
-return startup
diff --git a/indra/newview/scripts/lua/timers.lua b/indra/newview/scripts/lua/timers.lua
deleted file mode 100644
index e4938078dc..0000000000
--- a/indra/newview/scripts/lua/timers.lua
+++ /dev/null
@@ -1,104 +0,0 @@
--- Access to the viewer's time-delay facilities
-
-local leap = require 'leap'
-local util = require 'util'
-
-local timers = {}
-
-local function dbg(...) end
--- local dbg = require 'printf'
-
-timers.Timer = {}
-
--- delay:    time in seconds until callback
--- callback: 'wait', or function to call when timer fires (self:tick if nil)
--- iterate:  if non-nil, call callback repeatedly until it returns non-nil
---           (ignored if 'wait')
-function timers.Timer:new(delay, callback, iterate)
-    local obj = setmetatable({}, self)
-    self.__index = self
-
-    if callback == 'wait' then
-        dbg('scheduleAfter(%d):', delay)
-        sequence = leap.generate('Timers', {op='scheduleAfter', after=delay})
-        -- ignore the immediate return
-        dbg('scheduleAfter(%d) -> %s', delay,
-        sequence.next())
-        -- this call is where we wait for real
-        dbg('next():')
-        dbg('next() -> %s',
-        sequence.next())
-        sequence.done()
-        return
-    end
-
-    callback = callback or function() obj:tick() end
-
-    local first = true
-    if iterate then
-        obj.id = leap.eventstream(
-            'Timers',
-            {op='scheduleEvery', every=delay},
-            function (event)
-                local reqid = event.reqid
-                if first then
-                    first = false
-                    dbg('timer(%s) first callback', reqid)
-                    -- discard the first (immediate) response: don't call callback
-                    return nil
-                else
-                    dbg('timer(%s) nth callback', reqid)
-                    return callback(event)
-                end
-            end
-        ).reqid
-    else
-        obj.id = leap.eventstream(
-            'Timers',
-            {op='scheduleAfter', after=delay},
-            function (event)
-                -- Arrange to return nil the first time, true the second. This
-                -- callback is called immediately with the response to
-                -- 'scheduleAfter', and if we immediately returned true, we'd
-                -- be done, and the subsequent timer event would be discarded.
-                if first then
-                    first = false
-                    -- Caller doesn't expect an immediate callback.
-                    return nil
-                else
-                    callback(event)
-                    -- Since caller doesn't want to iterate, the value
-                    -- returned by the callback is irrelevant: just stop after
-                    -- this one and only call.
-                    return true
-                end
-            end
-        ).reqid
-    end
-
-    return obj
-end
-
-util.classctor(timers.Timer)
-
-function timers.Timer:tick()
-    error('Pass a callback to Timer:new(), or override Timer:tick()')
-end
-
-function timers.Timer:cancel()
-    local ok = leap.request('Timers', {op='cancel', id=self.id}).ok
-    leap.cancelreq(self.id)
-    return ok
-end
-
-function timers.Timer:isRunning()
-    return leap.request('Timers', {op='isRunning', id=self.id}).running
-end
-
--- returns (true, seconds left) for a live timer, else (false, 0)
-function timers.Timer:timeUntilCall()
-    local result = leap.request('Timers', {op='timeUntilCall', id=self.id})
-    return result.ok, result.remaining
-end
-
-return timers
diff --git a/indra/newview/scripts/lua/util.lua b/indra/newview/scripts/lua/util.lua
deleted file mode 100644
index bfbfc8637c..0000000000
--- a/indra/newview/scripts/lua/util.lua
+++ /dev/null
@@ -1,69 +0,0 @@
--- utility functions, in alpha order
-
-local util = {}
-
--- Allow MyClass(ctor args...) equivalent to MyClass:new(ctor args...)
--- Usage:
--- local MyClass = {}
--- function MyClass:new(...)
---     ...
--- end
--- ...
--- util.classctor(MyClass)
--- or if your constructor is named something other than MyClass:new(), e.g.
--- MyClass:construct():
--- util.classctor(MyClass, MyClass.construct)
--- return MyClass
-function util.classctor(class, ctor)
-    -- get the metatable for the passed class
-    local mt = getmetatable(class)
-    if mt == nil then
-        -- if it doesn't already have a metatable, then create one
-        mt = {}
-        setmetatable(class, mt)
-    end
-    -- now that class has a metatable, set its __call method to the specified
-    -- constructor method (class.new if not specified)
-    mt.__call = ctor or class.new
-end
-
--- check if array-like table contains certain value
-function util.contains(t, v)
-    return table.find(t, v) ~= nil
-end
-
--- reliable count of the number of entries in table t
--- (since #t is unreliable)
-function util.count(t)
-    local count = 0
-    for _ in pairs(t) do
-        count += 1
-    end
-    return count
-end
-
--- cheap test whether table t is empty
-function util.empty(t)
-    return not next(t)
-end
-
--- recursive table equality
-function util.equal(t1, t2)
-    if not (type(t1) == 'table' and type(t2) == 'table') then
-        return t1 == t2
-    end
-    -- both t1 and t2 are tables: get modifiable copy of t2
-    local temp = table.clone(t2)
-    for k, v in pairs(t1) do
-        -- if any key in t1 doesn't have same value in t2, not equal
-        if not util.equal(v, temp[k]) then
-            return false
-        end
-        -- temp[k] == t1[k], delete temp[k]
-        temp[k] = nil
-    end
-    -- All keys in t1 have equal values in t2; t2 == t1 if there are no extra keys in t2
-    return util.empty(temp)
-end
-
-return util
-- 
cgit v1.2.3


From e26727e03bb02d26b3f0d83f748dbd8eb88e4940 Mon Sep 17 00:00:00 2001
From: Nat Goodspeed <nat@lindenlab.com>
Date: Tue, 18 Jun 2024 13:13:39 -0400
Subject: Remove special-case ~LuaState() code to call fiber.run().

Instead, make fiber.lua call LL.atexit(fiber.run) to schedule that final run()
call at ~LuaState() time using the generic mechanism.

Append an explicit fiber.run() call to a specific test in llluamanager_test.cpp
because the test code wants to interact with multiple Lua fibers *before* we
destroy the LuaState.
---
 indra/newview/scripts/lua/require/fiber.lua | 6 ++++++
 1 file changed, 6 insertions(+)

(limited to 'indra/newview/scripts')

diff --git a/indra/newview/scripts/lua/require/fiber.lua b/indra/newview/scripts/lua/require/fiber.lua
index cae27b936b..b3c684dd67 100644
--- a/indra/newview/scripts/lua/require/fiber.lua
+++ b/indra/newview/scripts/lua/require/fiber.lua
@@ -337,4 +337,10 @@ function fiber.run()
     return idle_done
 end
 
+-- Make sure we finish up with a call to run(). That allows a consuming script
+-- to kick off some number of fibers, do some work on the main thread and then
+-- fall off the end of the script without explicitly calling fiber.run().
+-- run() ensures the rest of the fibers run to completion (or error).
+LL.atexit(fiber.run)
+
 return fiber
-- 
cgit v1.2.3


From 165b3cb04266f96f7fc48f542f915b93a4795aaf Mon Sep 17 00:00:00 2001
From: Nat Goodspeed <nat@lindenlab.com>
Date: Wed, 19 Jun 2024 10:10:53 -0400
Subject: Move popup.lua to require subdir with the rest of the modules.

---
 indra/newview/scripts/lua/popup.lua         | 32 -----------------------------
 indra/newview/scripts/lua/require/popup.lua | 32 +++++++++++++++++++++++++++++
 2 files changed, 32 insertions(+), 32 deletions(-)
 delete mode 100644 indra/newview/scripts/lua/popup.lua
 create mode 100644 indra/newview/scripts/lua/require/popup.lua

(limited to 'indra/newview/scripts')

diff --git a/indra/newview/scripts/lua/popup.lua b/indra/newview/scripts/lua/popup.lua
deleted file mode 100644
index 8a01ab7836..0000000000
--- a/indra/newview/scripts/lua/popup.lua
+++ /dev/null
@@ -1,32 +0,0 @@
-local leap = require 'leap'
-
--- notification is any name defined in notifications.xml as
--- <notification name=>
--- vars is a table providing values for [VAR] substitution keys in the
--- notification body.
-local popup_meta = {
-    -- setting this function as getmetatable(popup).__call() means this gets
-    -- called when a consumer calls popup(notification, vars, payload)
-    __call = function(self, notification, vars, payload)
-        return leap.request('LLNotifications',
-                            {op='requestAdd', name=notification,
-                             substitutions=vars,
-                             payload=payload})
-    end
-}
-
-local popup = setmetatable({}, popup_meta)
-
-function popup:alert(message)
-    return self('GenericAlert', {MESSAGE=message})
-end
-
-function popup:alertOK(message)
-    return self('GenericAlertOK', {MESSAGE=message})
-end
-
-function popup:alertYesCancel(message)
-    return self('GenericAlertYesCancel', {MESSAGE=message})
-end
-
-return popup
diff --git a/indra/newview/scripts/lua/require/popup.lua b/indra/newview/scripts/lua/require/popup.lua
new file mode 100644
index 0000000000..8a01ab7836
--- /dev/null
+++ b/indra/newview/scripts/lua/require/popup.lua
@@ -0,0 +1,32 @@
+local leap = require 'leap'
+
+-- notification is any name defined in notifications.xml as
+-- <notification name=>
+-- vars is a table providing values for [VAR] substitution keys in the
+-- notification body.
+local popup_meta = {
+    -- setting this function as getmetatable(popup).__call() means this gets
+    -- called when a consumer calls popup(notification, vars, payload)
+    __call = function(self, notification, vars, payload)
+        return leap.request('LLNotifications',
+                            {op='requestAdd', name=notification,
+                             substitutions=vars,
+                             payload=payload})
+    end
+}
+
+local popup = setmetatable({}, popup_meta)
+
+function popup:alert(message)
+    return self('GenericAlert', {MESSAGE=message})
+end
+
+function popup:alertOK(message)
+    return self('GenericAlertOK', {MESSAGE=message})
+end
+
+function popup:alertYesCancel(message)
+    return self('GenericAlertYesCancel', {MESSAGE=message})
+end
+
+return popup
-- 
cgit v1.2.3


From 09b814a2dc6d3a647d75bcf0a310eba2678a0228 Mon Sep 17 00:00:00 2001
From: Mnikolenko Productengine <mnikolenko@productengine.com>
Date: Thu, 20 Jun 2024 00:42:25 +0300
Subject: Use LLLeapListener to listen to LLNearbyChat pump

---
 indra/newview/scripts/lua/LLChatListener.lua      | 12 ++++++++----
 indra/newview/scripts/lua/test_LLChatListener.lua |  3 ++-
 2 files changed, 10 insertions(+), 5 deletions(-)

(limited to 'indra/newview/scripts')

diff --git a/indra/newview/scripts/lua/LLChatListener.lua b/indra/newview/scripts/lua/LLChatListener.lua
index d615ae5dbc..b4e90d272c 100644
--- a/indra/newview/scripts/lua/LLChatListener.lua
+++ b/indra/newview/scripts/lua/LLChatListener.lua
@@ -1,8 +1,10 @@
 local fiber = require 'fiber'
 local inspect = require 'inspect'
+local leap = require 'leap'
 
 local LLChatListener = {}
 local waitfor = {}
+local listener_name = {}
 
 function LLChatListener:new()
     local obj = setmetatable({}, self)
@@ -13,14 +15,16 @@ function LLChatListener:new()
 end
 
 function LLChatListener:handleMessages(event_data)
-    --print(inspect(event_data))
+    print(inspect(event_data))
     return true
 end
 
 function LLChatListener:start()
     waitfor = leap.WaitFor:new(-1, self.name)
     function waitfor:filter(pump, data)
-        return data
+        if pump == "LLNearbyChat" then
+          return data
+        end
     end
 
     fiber.launch(self.name, function()
@@ -30,11 +34,11 @@ function LLChatListener:start()
         end
     end)
 
-    leap.send('LLChatBar', {op='listen'})
+    listener_name = leap.request(leap.cmdpump(), {op='listen', source='LLNearbyChat', listener="ChatListener", tweak=true}).listener
 end
 
 function LLChatListener:stop()
-    leap.send('LLChatBar', {op='stopListening'})
+    leap.send(leap.cmdpump(), {op='stoplistening', source='LLNearbyChat', listener=listener_name})
     waitfor:close()
 end
 
diff --git a/indra/newview/scripts/lua/test_LLChatListener.lua b/indra/newview/scripts/lua/test_LLChatListener.lua
index 2c7b1dc3e5..b9696e7cfc 100644
--- a/indra/newview/scripts/lua/test_LLChatListener.lua
+++ b/indra/newview/scripts/lua/test_LLChatListener.lua
@@ -1,5 +1,6 @@
 local LLChatListener = require 'LLChatListener'
 local LLChat = require 'LLChat'
+local leap = require 'leap'
 
 function openOrEcho(message)
     local floater_name = string.match(message, "^open%s+(%w+)")
@@ -21,7 +22,7 @@ function listener:handleMessages(event_data)
     else
       openOrEcho(event_data.message)
     end
-    return LLChatListener.handleMessages(self, event_data)
+    return true
 end
 
 listener:start()
-- 
cgit v1.2.3


From 350225e54ba02a7523e17106936a4ce44af91e55 Mon Sep 17 00:00:00 2001
From: Nat Goodspeed <nat@lindenlab.com>
Date: Thu, 20 Jun 2024 10:55:19 -0400
Subject: Give popup() the ability to not wait; add popup:tip(message).

popup:tip() engages 'SystemMessageTip'.
---
 indra/newview/scripts/lua/require/popup.lua | 33 +++++++++++++++++++++++------
 1 file changed, 27 insertions(+), 6 deletions(-)

(limited to 'indra/newview/scripts')

diff --git a/indra/newview/scripts/lua/require/popup.lua b/indra/newview/scripts/lua/require/popup.lua
index 8a01ab7836..3aaadf85ba 100644
--- a/indra/newview/scripts/lua/require/popup.lua
+++ b/indra/newview/scripts/lua/require/popup.lua
@@ -1,17 +1,34 @@
 local leap = require 'leap'
+local mapargs = require 'mapargs'
 
 -- notification is any name defined in notifications.xml as
 -- <notification name=>
 -- vars is a table providing values for [VAR] substitution keys in the
--- notification body.
+-- notification body
+-- payload prepopulates the response table
+-- wait=false means fire and forget, otherwise wait for user response
 local popup_meta = {
     -- setting this function as getmetatable(popup).__call() means this gets
     -- called when a consumer calls popup(notification, vars, payload)
-    __call = function(self, notification, vars, payload)
-        return leap.request('LLNotifications',
-                            {op='requestAdd', name=notification,
-                             substitutions=vars,
-                             payload=payload})
+    __call = function(self, ...)
+        local args = mapargs('notification,vars,payload,wait', ...)
+        -- we use convenience argument names different from 'LLNotifications'
+        -- listener
+        args.name = args.notification
+        args.notification = nil
+        args.substitutions = args.vars
+        args.vars = nil
+        local wait = args.wait
+        args.wait = nil
+        args.op = 'requestAdd'
+        -- Specifically test (wait == false), NOT (not wait), because we treat
+        -- nil (omitted, default true) differently than false (explicitly
+        -- DON'T wait).
+        if wait == false then
+            leap.send('LLNotifications', args)
+        else
+            return leap.request('LLNotifications', args).response
+        end
     end
 }
 
@@ -29,4 +46,8 @@ function popup:alertYesCancel(message)
     return self('GenericAlertYesCancel', {MESSAGE=message})
 end
 
+function popup:tip(message)
+    self{'SystemMessageTip', {MESSAGE=message}, wait=false}
+end
+
 return popup
-- 
cgit v1.2.3


From 3a2018ddda6feb1aaa023106f95de6d8e0a0b507 Mon Sep 17 00:00:00 2001
From: nat-goodspeed <nat@lindenlab.com>
Date: Thu, 20 Jun 2024 12:56:35 -0400
Subject: Revert LLLuaFloater "idle" events in favor of Lua timers.Timer().

---
 .../newview/scripts/lua/test_luafloater_speedometer.lua  | 16 +++++++++++-----
 1 file changed, 11 insertions(+), 5 deletions(-)

(limited to 'indra/newview/scripts')

diff --git a/indra/newview/scripts/lua/test_luafloater_speedometer.lua b/indra/newview/scripts/lua/test_luafloater_speedometer.lua
index 610401ae44..a9d3a70330 100644
--- a/indra/newview/scripts/lua/test_luafloater_speedometer.lua
+++ b/indra/newview/scripts/lua/test_luafloater_speedometer.lua
@@ -1,18 +1,23 @@
 local Floater = require 'Floater'
+local leap = require 'leap'
+local LLNotification = require 'LLNotification'
 local startup = require 'startup'
-inspect = require 'inspect'
-leap = require 'leap'
-LLNotification = require 'LLNotification'
+local Timer = (require 'timers').Timer
 local max_speed = 0
 local flt = Floater:new("luafloater_speedometer.xml")
 startup.wait('STATE_STARTED')
 
+local timer
+
 function flt:floater_close(event_data)
+    if timer then
+        timer:cancel()
+    end
     msg = "Registered max speed: " .. string.format("%.2f", max_speed) .. " m/s";
     LLNotification.add('SystemMessageTip', {MESSAGE = msg})
 end
 
-function flt:idle(event_data)
+local function idle(event_data)
     local speed = leap.request('LLVOAvatar', {op='getSpeed'})['value']
     flt:post({action="set_value", ctrl_name="speed_lbl", value = string.format("%.2f", speed)})
     max_speed=math.max(max_speed, speed)
@@ -22,5 +27,6 @@ msg = 'Are you sure you want to run this "speedometer" script?'
 response = LLNotification.requestAdd('GenericAlertYesCancel', {MESSAGE = msg})
 
 if response.OK_okcancelbuttons then
-  flt:show()
+    flt:show()
+    timer = Timer:new(1, idle, true) -- iterate
 end
-- 
cgit v1.2.3


From 6d29c1fcf80441cc4619e672ca07469cc3efe100 Mon Sep 17 00:00:00 2001
From: Nat Goodspeed <nat@lindenlab.com>
Date: Thu, 20 Jun 2024 16:21:17 -0400
Subject: Use new popup.lua, which supersedes LLNotification.lua.

Use ClassName(ctor args) for classes using util.classctor().
---
 indra/newview/scripts/lua/LLNotification.lua              | 15 ---------------
 indra/newview/scripts/lua/test_luafloater_speedometer.lua | 11 +++++------
 2 files changed, 5 insertions(+), 21 deletions(-)
 delete mode 100644 indra/newview/scripts/lua/LLNotification.lua

(limited to 'indra/newview/scripts')

diff --git a/indra/newview/scripts/lua/LLNotification.lua b/indra/newview/scripts/lua/LLNotification.lua
deleted file mode 100644
index f47730d1cc..0000000000
--- a/indra/newview/scripts/lua/LLNotification.lua
+++ /dev/null
@@ -1,15 +0,0 @@
--- Engage the LLNotificationsListener LLEventAPI
-
-leap = require 'leap'
-
-local LLNotification = {}
-
-function LLNotification.add(name, substitutions)
-    leap.send('LLNotifications', {op='requestAdd', name=name, substitutions=substitutions})
-end
-
-function LLNotification.requestAdd(name, substitutions)
-    return leap.request('LLNotifications', {op='requestAdd', name=name, substitutions=substitutions})['response']
-end
-
-return LLNotification
diff --git a/indra/newview/scripts/lua/test_luafloater_speedometer.lua b/indra/newview/scripts/lua/test_luafloater_speedometer.lua
index a9d3a70330..af7189a2cb 100644
--- a/indra/newview/scripts/lua/test_luafloater_speedometer.lua
+++ b/indra/newview/scripts/lua/test_luafloater_speedometer.lua
@@ -1,10 +1,10 @@
 local Floater = require 'Floater'
 local leap = require 'leap'
-local LLNotification = require 'LLNotification'
+local popup = require 'popup'
 local startup = require 'startup'
 local Timer = (require 'timers').Timer
 local max_speed = 0
-local flt = Floater:new("luafloater_speedometer.xml")
+local flt = Floater("luafloater_speedometer.xml")
 startup.wait('STATE_STARTED')
 
 local timer
@@ -13,8 +13,7 @@ function flt:floater_close(event_data)
     if timer then
         timer:cancel()
     end
-    msg = "Registered max speed: " .. string.format("%.2f", max_speed) .. " m/s";
-    LLNotification.add('SystemMessageTip', {MESSAGE = msg})
+    popup:tip(string.format("Registered max speed: %.2f m/s", max_speed))
 end
 
 local function idle(event_data)
@@ -24,9 +23,9 @@ local function idle(event_data)
 end
 
 msg = 'Are you sure you want to run this "speedometer" script?'
-response = LLNotification.requestAdd('GenericAlertYesCancel', {MESSAGE = msg})
+response = popup:alertYesCancel(msg)
 
 if response.OK_okcancelbuttons then
     flt:show()
-    timer = Timer:new(1, idle, true) -- iterate
+    timer = Timer(1, idle, true) -- iterate
 end
-- 
cgit v1.2.3


From 5dbca6bb3ed33cb8f19ea3871ce7ef9f07957088 Mon Sep 17 00:00:00 2001
From: Nat Goodspeed <nat@lindenlab.com>
Date: Fri, 21 Jun 2024 10:06:55 -0400
Subject: Move newer Lua modules to scripts/lua/require subdirectory.

---
 indra/newview/scripts/lua/LLChatListener.lua       | 45 -------------
 indra/newview/scripts/lua/login.lua                | 19 ------
 indra/newview/scripts/lua/mapargs.lua              | 73 ----------------------
 .../newview/scripts/lua/require/LLChatListener.lua | 45 +++++++++++++
 indra/newview/scripts/lua/require/login.lua        | 19 ++++++
 indra/newview/scripts/lua/require/mapargs.lua      | 73 ++++++++++++++++++++++
 6 files changed, 137 insertions(+), 137 deletions(-)
 delete mode 100644 indra/newview/scripts/lua/LLChatListener.lua
 delete mode 100644 indra/newview/scripts/lua/login.lua
 delete mode 100644 indra/newview/scripts/lua/mapargs.lua
 create mode 100644 indra/newview/scripts/lua/require/LLChatListener.lua
 create mode 100644 indra/newview/scripts/lua/require/login.lua
 create mode 100644 indra/newview/scripts/lua/require/mapargs.lua

(limited to 'indra/newview/scripts')

diff --git a/indra/newview/scripts/lua/LLChatListener.lua b/indra/newview/scripts/lua/LLChatListener.lua
deleted file mode 100644
index b4e90d272c..0000000000
--- a/indra/newview/scripts/lua/LLChatListener.lua
+++ /dev/null
@@ -1,45 +0,0 @@
-local fiber = require 'fiber'
-local inspect = require 'inspect'
-local leap = require 'leap'
-
-local LLChatListener = {}
-local waitfor = {}
-local listener_name = {}
-
-function LLChatListener:new()
-    local obj = setmetatable({}, self)
-    self.__index = self
-    obj.name = 'Chat_listener'
-
-    return obj
-end
-
-function LLChatListener:handleMessages(event_data)
-    print(inspect(event_data))
-    return true
-end
-
-function LLChatListener:start()
-    waitfor = leap.WaitFor:new(-1, self.name)
-    function waitfor:filter(pump, data)
-        if pump == "LLNearbyChat" then
-          return data
-        end
-    end
-
-    fiber.launch(self.name, function()
-        event = waitfor:wait()
-        while event and self:handleMessages(event) do
-          event = waitfor:wait()
-        end
-    end)
-
-    listener_name = leap.request(leap.cmdpump(), {op='listen', source='LLNearbyChat', listener="ChatListener", tweak=true}).listener
-end
-
-function LLChatListener:stop()
-    leap.send(leap.cmdpump(), {op='stoplistening', source='LLNearbyChat', listener=listener_name})
-    waitfor:close()
-end
-
-return LLChatListener
diff --git a/indra/newview/scripts/lua/login.lua b/indra/newview/scripts/lua/login.lua
deleted file mode 100644
index 0d8591cace..0000000000
--- a/indra/newview/scripts/lua/login.lua
+++ /dev/null
@@ -1,19 +0,0 @@
-local UI = require 'UI'
-local leap = require 'leap'
-
-local function login(username, password)
-    if username and password then
-        local userpath = '//username_combo/Combo Text Entry'
-        local passpath = '//password_edit'
-        -- first clear anything presently in those text fields
-        for _, path in pairs({userpath, passpath}) do
-            UI.click(path)
-            UI.keypress{keysym='Backsp', path=path}
-        end
-        UI.type{path=userpath, text=username}
-        UI.type{path=passpath, text=password}
-    end
-    leap.send('LLPanelLogin', {op='onClickConnect'})
-end
-
-return login
diff --git a/indra/newview/scripts/lua/mapargs.lua b/indra/newview/scripts/lua/mapargs.lua
deleted file mode 100644
index 45f5a9c556..0000000000
--- a/indra/newview/scripts/lua/mapargs.lua
+++ /dev/null
@@ -1,73 +0,0 @@
--- Allow a calling function to be passed a mix of positional arguments with
--- keyword arguments. Reference them as fields of a table.
--- Don't use this for a function that can accept a single table argument.
--- mapargs() assumes that a single table argument means its caller was called
--- with f{table constructor} syntax, and maps that table to the specified names.
--- Usage:
--- function f(...)
---     local a = mapargs({'a1', 'a2', 'a3'}, ...)
---     ... a.a1 ... etc.
--- end
--- f(10, 20, 30)     -- a.a1 == 10,  a.a2 == 20,  a.a3 == 30
--- f{10, 20, 30}     -- a.a1 == 10,  a.a2 == 20,  a.a3 == 30
--- f{a3=300, a1=100} -- a.a1 == 100, a.a2 == nil, a.a3 == 300
--- f{1, a3=3}        -- a.a1 == 1,   a.a2 == nil, a.a3 == 3
--- f{a3=3, 1}        -- a.a1 == 1,   a.a2 == nil, a.a3 == 3
-local function mapargs(names, ...)
-    local args = table.pack(...)
-    local posargs = {}
-    local keyargs = {}
-    -- For a mixed table, no Lua operation will reliably tell you how many
-    -- array items it contains, if there are any holes. Track that by hand.
-    -- We must be able to handle f(1, nil, 3) calls.
-    local maxpos = 0
-
-    -- For convenience, allow passing 'names' as a string 'n0,n1,...'
-    if type(names) == 'string' then
-        names = string.split(names, ',')
-    end
-
-    if not (args.n == 1 and type(args[1]) == 'table') then
-        -- If caller passes more than one argument, or if the first argument
-        -- is not a table, then it's classic positional function-call syntax:
-        -- f(first, second, etc.). In that case we need not bother teasing
-        -- apart positional from keyword arguments.
-        posargs = args
-        maxpos = args.n
-    else
-        -- Single table argument implies f{mixed} syntax.
-        -- Tease apart positional arguments from keyword arguments.
-        for k, v in pairs(args[1]) do
-            if type(k) == 'number' then
-                posargs[k] = v
-                maxpos = math.max(maxpos, k)
-            else
-                if table.find(names, k) == nil then
-                    error('unknown keyword argument ' .. tostring(k))
-                end
-                keyargs[k] = v
-            end
-        end
-    end
-
-    -- keyargs already has keyword arguments in place, just fill in positionals
-    args = keyargs
-    -- Don't exceed the number of parameter names. Loop explicitly over every
-    -- index value instead of using ipairs() so we can support holes (nils) in
-    -- posargs.
-    for i = 1, math.min(#names, maxpos) do
-        if posargs[i] ~= nil then
-            -- As in Python, make it illegal to pass an argument both positionally
-            -- and by keyword. This implementation permits func(17, first=nil), a
-            -- corner case about which I don't particularly care.
-            if args[names[i]] ~= nil then
-                error(string.format('parameter %s passed both positionally and by keyword',
-                                    tostring(names[i])))
-            end
-            args[names[i]] = posargs[i]
-        end
-    end
-    return args
-end
-
-return mapargs
diff --git a/indra/newview/scripts/lua/require/LLChatListener.lua b/indra/newview/scripts/lua/require/LLChatListener.lua
new file mode 100644
index 0000000000..b4e90d272c
--- /dev/null
+++ b/indra/newview/scripts/lua/require/LLChatListener.lua
@@ -0,0 +1,45 @@
+local fiber = require 'fiber'
+local inspect = require 'inspect'
+local leap = require 'leap'
+
+local LLChatListener = {}
+local waitfor = {}
+local listener_name = {}
+
+function LLChatListener:new()
+    local obj = setmetatable({}, self)
+    self.__index = self
+    obj.name = 'Chat_listener'
+
+    return obj
+end
+
+function LLChatListener:handleMessages(event_data)
+    print(inspect(event_data))
+    return true
+end
+
+function LLChatListener:start()
+    waitfor = leap.WaitFor:new(-1, self.name)
+    function waitfor:filter(pump, data)
+        if pump == "LLNearbyChat" then
+          return data
+        end
+    end
+
+    fiber.launch(self.name, function()
+        event = waitfor:wait()
+        while event and self:handleMessages(event) do
+          event = waitfor:wait()
+        end
+    end)
+
+    listener_name = leap.request(leap.cmdpump(), {op='listen', source='LLNearbyChat', listener="ChatListener", tweak=true}).listener
+end
+
+function LLChatListener:stop()
+    leap.send(leap.cmdpump(), {op='stoplistening', source='LLNearbyChat', listener=listener_name})
+    waitfor:close()
+end
+
+return LLChatListener
diff --git a/indra/newview/scripts/lua/require/login.lua b/indra/newview/scripts/lua/require/login.lua
new file mode 100644
index 0000000000..0d8591cace
--- /dev/null
+++ b/indra/newview/scripts/lua/require/login.lua
@@ -0,0 +1,19 @@
+local UI = require 'UI'
+local leap = require 'leap'
+
+local function login(username, password)
+    if username and password then
+        local userpath = '//username_combo/Combo Text Entry'
+        local passpath = '//password_edit'
+        -- first clear anything presently in those text fields
+        for _, path in pairs({userpath, passpath}) do
+            UI.click(path)
+            UI.keypress{keysym='Backsp', path=path}
+        end
+        UI.type{path=userpath, text=username}
+        UI.type{path=passpath, text=password}
+    end
+    leap.send('LLPanelLogin', {op='onClickConnect'})
+end
+
+return login
diff --git a/indra/newview/scripts/lua/require/mapargs.lua b/indra/newview/scripts/lua/require/mapargs.lua
new file mode 100644
index 0000000000..45f5a9c556
--- /dev/null
+++ b/indra/newview/scripts/lua/require/mapargs.lua
@@ -0,0 +1,73 @@
+-- Allow a calling function to be passed a mix of positional arguments with
+-- keyword arguments. Reference them as fields of a table.
+-- Don't use this for a function that can accept a single table argument.
+-- mapargs() assumes that a single table argument means its caller was called
+-- with f{table constructor} syntax, and maps that table to the specified names.
+-- Usage:
+-- function f(...)
+--     local a = mapargs({'a1', 'a2', 'a3'}, ...)
+--     ... a.a1 ... etc.
+-- end
+-- f(10, 20, 30)     -- a.a1 == 10,  a.a2 == 20,  a.a3 == 30
+-- f{10, 20, 30}     -- a.a1 == 10,  a.a2 == 20,  a.a3 == 30
+-- f{a3=300, a1=100} -- a.a1 == 100, a.a2 == nil, a.a3 == 300
+-- f{1, a3=3}        -- a.a1 == 1,   a.a2 == nil, a.a3 == 3
+-- f{a3=3, 1}        -- a.a1 == 1,   a.a2 == nil, a.a3 == 3
+local function mapargs(names, ...)
+    local args = table.pack(...)
+    local posargs = {}
+    local keyargs = {}
+    -- For a mixed table, no Lua operation will reliably tell you how many
+    -- array items it contains, if there are any holes. Track that by hand.
+    -- We must be able to handle f(1, nil, 3) calls.
+    local maxpos = 0
+
+    -- For convenience, allow passing 'names' as a string 'n0,n1,...'
+    if type(names) == 'string' then
+        names = string.split(names, ',')
+    end
+
+    if not (args.n == 1 and type(args[1]) == 'table') then
+        -- If caller passes more than one argument, or if the first argument
+        -- is not a table, then it's classic positional function-call syntax:
+        -- f(first, second, etc.). In that case we need not bother teasing
+        -- apart positional from keyword arguments.
+        posargs = args
+        maxpos = args.n
+    else
+        -- Single table argument implies f{mixed} syntax.
+        -- Tease apart positional arguments from keyword arguments.
+        for k, v in pairs(args[1]) do
+            if type(k) == 'number' then
+                posargs[k] = v
+                maxpos = math.max(maxpos, k)
+            else
+                if table.find(names, k) == nil then
+                    error('unknown keyword argument ' .. tostring(k))
+                end
+                keyargs[k] = v
+            end
+        end
+    end
+
+    -- keyargs already has keyword arguments in place, just fill in positionals
+    args = keyargs
+    -- Don't exceed the number of parameter names. Loop explicitly over every
+    -- index value instead of using ipairs() so we can support holes (nils) in
+    -- posargs.
+    for i = 1, math.min(#names, maxpos) do
+        if posargs[i] ~= nil then
+            -- As in Python, make it illegal to pass an argument both positionally
+            -- and by keyword. This implementation permits func(17, first=nil), a
+            -- corner case about which I don't particularly care.
+            if args[names[i]] ~= nil then
+                error(string.format('parameter %s passed both positionally and by keyword',
+                                    tostring(names[i])))
+            end
+            args[names[i]] = posargs[i]
+        end
+    end
+    return args
+end
+
+return mapargs
-- 
cgit v1.2.3


From 63e7e0b35dff15a2e06b924945dbb09389723686 Mon Sep 17 00:00:00 2001
From: Nat Goodspeed <nat@lindenlab.com>
Date: Fri, 21 Jun 2024 10:10:35 -0400
Subject: Use util.classctor(LLChatListener).

---
 indra/newview/scripts/lua/require/LLChatListener.lua | 3 +++
 indra/newview/scripts/lua/test_LLChatListener.lua    | 2 +-
 2 files changed, 4 insertions(+), 1 deletion(-)

(limited to 'indra/newview/scripts')

diff --git a/indra/newview/scripts/lua/require/LLChatListener.lua b/indra/newview/scripts/lua/require/LLChatListener.lua
index b4e90d272c..428dca881e 100644
--- a/indra/newview/scripts/lua/require/LLChatListener.lua
+++ b/indra/newview/scripts/lua/require/LLChatListener.lua
@@ -1,6 +1,7 @@
 local fiber = require 'fiber'
 local inspect = require 'inspect'
 local leap = require 'leap'
+local util = require 'util'
 
 local LLChatListener = {}
 local waitfor = {}
@@ -14,6 +15,8 @@ function LLChatListener:new()
     return obj
 end
 
+util.classctor(LLChatListener)
+
 function LLChatListener:handleMessages(event_data)
     print(inspect(event_data))
     return true
diff --git a/indra/newview/scripts/lua/test_LLChatListener.lua b/indra/newview/scripts/lua/test_LLChatListener.lua
index b9696e7cfc..18363ed43b 100644
--- a/indra/newview/scripts/lua/test_LLChatListener.lua
+++ b/indra/newview/scripts/lua/test_LLChatListener.lua
@@ -11,7 +11,7 @@ function openOrEcho(message)
     end
 end
 
-local listener = LLChatListener:new()
+local listener = LLChatListener()
 
 function listener:handleMessages(event_data)
     if string.find(event_data.message, '[LUA]') then
-- 
cgit v1.2.3


From b8e0c16ab1eb3cdd1d11e869bd3fd6196de51d4b Mon Sep 17 00:00:00 2001
From: Mnikolenko Productengine <mnikolenko@productengine.com>
Date: Fri, 21 Jun 2024 17:42:45 +0300
Subject: Add Appearance listener

---
 indra/newview/scripts/lua/LLAppearance.lua         | 25 ++++++++++++++++++++
 .../scripts/lua/luafloater_outfits_list.xml        | 21 +++++++++++++++++
 indra/newview/scripts/lua/test_outfits_list.lua    | 27 ++++++++++++++++++++++
 3 files changed, 73 insertions(+)
 create mode 100644 indra/newview/scripts/lua/LLAppearance.lua
 create mode 100644 indra/newview/scripts/lua/luafloater_outfits_list.xml
 create mode 100644 indra/newview/scripts/lua/test_outfits_list.lua

(limited to 'indra/newview/scripts')

diff --git a/indra/newview/scripts/lua/LLAppearance.lua b/indra/newview/scripts/lua/LLAppearance.lua
new file mode 100644
index 0000000000..ec7a25197f
--- /dev/null
+++ b/indra/newview/scripts/lua/LLAppearance.lua
@@ -0,0 +1,25 @@
+leap = require 'leap'
+
+local LLAppearance = {}
+
+function LLAppearance.addOutfit(folder)
+    leap.request('LLAppearance', {op='wearOutfit', append = true, folder_id=folder})
+end
+
+function LLAppearance.replaceOutfit(folder)
+    leap.request('LLAppearance', {op='wearOutfit', append = false, folder_id=folder})
+end
+
+function LLAppearance.addOutfitByName(folder)
+    leap.request('LLAppearance', {op='wearOutfitByName', append = true, folder_name=folder})
+end
+
+function LLAppearance.replaceOutfitByName(folder)
+    leap.request('LLAppearance', {op='wearOutfitByName', append = false, folder_name=folder})
+end
+
+function LLAppearance.getOutfitsList()
+    return leap.request('LLAppearance', {op='getOutfitsList'})['outfits']
+end
+
+return LLAppearance
diff --git a/indra/newview/scripts/lua/luafloater_outfits_list.xml b/indra/newview/scripts/lua/luafloater_outfits_list.xml
new file mode 100644
index 0000000000..1f6505cb8d
--- /dev/null
+++ b/indra/newview/scripts/lua/luafloater_outfits_list.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="utf-8" standalone="yes" ?>
+<floater
+ legacy_header_height="18"
+ height="185"
+ layout="topleft"
+ name="lua_outfits"
+ title="Outfits"
+ width="320">
+    <scroll_list
+     draw_heading="false"
+     left="5"
+     width="310"
+     height="150"
+     top_pad ="25"
+     follows="all"
+     name="outfits_list">
+        <scroll_list.columns
+          name="outfit_name"
+          label="Name"/>
+    </scroll_list>
+</floater>
diff --git a/indra/newview/scripts/lua/test_outfits_list.lua b/indra/newview/scripts/lua/test_outfits_list.lua
new file mode 100644
index 0000000000..5875fd51da
--- /dev/null
+++ b/indra/newview/scripts/lua/test_outfits_list.lua
@@ -0,0 +1,27 @@
+local Floater = require 'Floater'
+local LLAppearance = require 'LLAppearance'
+local startup = require 'startup'
+
+local flt = Floater:new(
+    "luafloater_outfits_list.xml",
+    {outfits_list = {"double_click"}})
+
+function flt:post_build(event_data)
+    local outfits_map = LLAppearance.getOutfitsList()
+    local action_data = {}
+    action_data.action = "add_list_element"
+    action_data.ctrl_name = "outfits_list"
+    local outfits = {}
+    for uuid, name in pairs(outfits_map) do
+      table.insert(outfits, {value = uuid, columns={column = "outfit_name", value = name}})
+    end
+    action_data.value = outfits
+    self:post(action_data)
+end
+
+function flt:double_click_outfits_list(event_data)
+    LLAppearance.replaceOutfit(event_data.value)
+end
+
+startup.wait('STATE_STARTED')
+flt:show()
-- 
cgit v1.2.3


From e05155494cb3a4b24f9e89252e34953e68eb7107 Mon Sep 17 00:00:00 2001
From: Nat Goodspeed <nat@lindenlab.com>
Date: Fri, 21 Jun 2024 14:25:05 -0400
Subject: Multiple LL.atexit(function) calls run functions in reverse order.

---
 indra/newview/scripts/lua/test_atexit.lua | 3 +++
 1 file changed, 3 insertions(+)
 create mode 100644 indra/newview/scripts/lua/test_atexit.lua

(limited to 'indra/newview/scripts')

diff --git a/indra/newview/scripts/lua/test_atexit.lua b/indra/newview/scripts/lua/test_atexit.lua
new file mode 100644
index 0000000000..6fbc0f3eb1
--- /dev/null
+++ b/indra/newview/scripts/lua/test_atexit.lua
@@ -0,0 +1,3 @@
+LL.atexit(function() print('Third') end)
+LL.atexit(function() print('Second') end)
+LL.atexit(function() print('First') end)
-- 
cgit v1.2.3


From 1c19563a76dd227c80693701fdc2d52d65bbf4f4 Mon Sep 17 00:00:00 2001
From: Nat Goodspeed <nat@lindenlab.com>
Date: Fri, 21 Jun 2024 14:26:36 -0400
Subject: Introduce require/logout.lua and test_logout.lua.

Add "userQuit" operation to LLAppViewerListener to engage
LLAppViewer::userQuit(), which pops up "Are you sure?" prompt unless
suppressed.
---
 indra/newview/scripts/lua/require/logout.lua | 7 +++++++
 indra/newview/scripts/lua/test_logout.lua    | 3 +++
 2 files changed, 10 insertions(+)
 create mode 100644 indra/newview/scripts/lua/require/logout.lua
 create mode 100644 indra/newview/scripts/lua/test_logout.lua

(limited to 'indra/newview/scripts')

diff --git a/indra/newview/scripts/lua/require/logout.lua b/indra/newview/scripts/lua/require/logout.lua
new file mode 100644
index 0000000000..63dcd7f01f
--- /dev/null
+++ b/indra/newview/scripts/lua/require/logout.lua
@@ -0,0 +1,7 @@
+local leap = require 'leap'
+
+local function logout()
+    leap.send('LLAppViewer', {op='userQuit'});
+end
+
+return logout
diff --git a/indra/newview/scripts/lua/test_logout.lua b/indra/newview/scripts/lua/test_logout.lua
new file mode 100644
index 0000000000..b1ac59e38c
--- /dev/null
+++ b/indra/newview/scripts/lua/test_logout.lua
@@ -0,0 +1,3 @@
+logout = require 'logout'
+
+logout()
-- 
cgit v1.2.3


From a6d860f9f3bd7ce8ed5d42635a730c1ee9714aea Mon Sep 17 00:00:00 2001
From: Nat Goodspeed <nat@lindenlab.com>
Date: Fri, 21 Jun 2024 14:47:30 -0400
Subject: login.lua works now, update test_login.lua accordingly.

---
 indra/newview/scripts/lua/test_login.lua | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'indra/newview/scripts')

diff --git a/indra/newview/scripts/lua/test_login.lua b/indra/newview/scripts/lua/test_login.lua
index 6df52b08c2..a8c31807bc 100644
--- a/indra/newview/scripts/lua/test_login.lua
+++ b/indra/newview/scripts/lua/test_login.lua
@@ -3,5 +3,5 @@ login = require 'login'
 
 startup.wait('STATE_LOGIN_WAIT')
 login()
--- WIP: not working as of 2024-06-11
+-- Fill in valid credentials as they would be entered on the login screen
 -- login('My Username', 'password')
-- 
cgit v1.2.3


From 8fa98f095a89778cd3153f3ee88f5626fc5a0d02 Mon Sep 17 00:00:00 2001
From: Nat Goodspeed <nat@lindenlab.com>
Date: Fri, 21 Jun 2024 14:50:35 -0400
Subject: Remove pre-Floater.lua versions of the floater test scripts.

---
 indra/newview/scripts/lua/test_luafloater_demo.lua | 77 ----------------------
 .../scripts/lua/test_luafloater_gesture_list.lua   | 75 ---------------------
 2 files changed, 152 deletions(-)
 delete mode 100644 indra/newview/scripts/lua/test_luafloater_demo.lua
 delete mode 100644 indra/newview/scripts/lua/test_luafloater_gesture_list.lua

(limited to 'indra/newview/scripts')

diff --git a/indra/newview/scripts/lua/test_luafloater_demo.lua b/indra/newview/scripts/lua/test_luafloater_demo.lua
deleted file mode 100644
index 65a31670c8..0000000000
--- a/indra/newview/scripts/lua/test_luafloater_demo.lua
+++ /dev/null
@@ -1,77 +0,0 @@
-XML_FILE_PATH = LL.abspath("luafloater_demo.xml")
-
-scriptparts = string.split(LL.source_path(), '/')
-scriptname = scriptparts[#scriptparts]
-print('Running ' .. scriptname)
-
-leap = require 'leap'
-fiber = require 'fiber'
-startup = require 'startup'
-
---event pump for sending actions to the floater
-local COMMAND_PUMP_NAME = ""
-local reqid
---table of floater UI events
-event_list=leap.request("LLFloaterReg", {op="getFloaterEvents"}).events
-
-local function _event(event_name)
-  if not table.find(event_list, event_name) then
-    LL.print_warning("Incorrect event name: " .. event_name)
-  end
-  return event_name
-end
-
-function post(action)
-  leap.send(COMMAND_PUMP_NAME, action)
-end
-
-function getCurrentTime()
-    local currentTime = os.date("*t")
-    return string.format("%02d:%02d:%02d", currentTime.hour, currentTime.min, currentTime.sec)
-end
-
-function handleEvents(event_data)
-  post({action="add_text", ctrl_name="events_editor", value = event_data})
-  if event_data.event == _event("commit") then
-    if event_data.ctrl_name == "disable_ctrl" then
-      post({action="set_enabled", ctrl_name="open_btn", value = (1 - event_data.value)})
-    elseif event_data.ctrl_name == "title_cmb" then
-      post({action="set_title", value= event_data.value})
-    elseif event_data.ctrl_name == "open_btn" then
-      floater_name = leap.request(COMMAND_PUMP_NAME, {action="get_value", ctrl_name='openfloater_cmd'})['value']
-      leap.send("LLFloaterReg", {name = floater_name, op = "showInstance"})
-    end
-  elseif event_data.event == _event("double_click") then
-    if event_data.ctrl_name == "show_time_lbl" then
-      post({action="set_value", ctrl_name="time_lbl", value= getCurrentTime()})
-    end
-  elseif event_data.event == _event("floater_close") then
-    LL.print_warning("Floater was closed")
-    return false
-  end
-  return true
-end
-
-startup.wait('STATE_LOGIN_WAIT')
-local key = {xml_path = XML_FILE_PATH, op = "showLuaFloater"}
---sign for additional events for defined control {<control_name>= {action1, action2, ...}}
-key.extra_events={show_time_lbl = {_event("right_mouse_down"), _event("double_click")}}
-local resp = leap.request("LLFloaterReg", key)
-COMMAND_PUMP_NAME = resp.command_name
-reqid = resp.reqid
-
-catch_events = leap.WaitFor(-1, "all_events")
-function catch_events:filter(pump, data)
-  if data.reqid == reqid then
-    return data
-  end
-end
-
-function process_events(waitfor)
-  event_data = waitfor:wait()
-  while event_data and handleEvents(event_data) do
-    event_data = waitfor:wait()
-  end
-end
-
-fiber.launch("catch_events", process_events, catch_events)
diff --git a/indra/newview/scripts/lua/test_luafloater_gesture_list.lua b/indra/newview/scripts/lua/test_luafloater_gesture_list.lua
deleted file mode 100644
index a5fd325430..0000000000
--- a/indra/newview/scripts/lua/test_luafloater_gesture_list.lua
+++ /dev/null
@@ -1,75 +0,0 @@
-XML_FILE_PATH = LL.abspath("luafloater_gesture_list.xml")
-
-scriptparts = string.split(LL.source_path(), '/')
-scriptname = scriptparts[#scriptparts]
-print('Running ' .. scriptname)
-
-leap = require 'leap'
-fiber = require 'fiber'
-LLGesture = require 'LLGesture'
-startup = require 'startup'
-
---event pump for sending actions to the floater
-local COMMAND_PUMP_NAME = ""
-local reqid
---table of floater UI events
-event_list=leap.request("LLFloaterReg", {op="getFloaterEvents"}).events
-
-local function _event(event_name)
-  if not table.find(event_list, event_name) then
-    LL.print_warning("Incorrect event name: " .. event_name)
-  end
-  return event_name
-end
-
-function post(action)
-  leap.send(COMMAND_PUMP_NAME, action)
-end
-
-function handleEvents(event_data)
-  if event_data.event == _event("floater_close") then
-    return false
-  end
-
-  if event_data.event == _event("post_build") then
-    COMMAND_PUMP_NAME = event_data.command_name
-    reqid = event_data.reqid
-    gestures_uuid = LLGesture.getActiveGestures()
-    local action_data = {}
-    action_data.action = "add_list_element"
-    action_data.ctrl_name = "gesture_list"
-    gestures = {}
-    for uuid, info in pairs(gestures_uuid) do
-      table.insert(gestures, {value = uuid, columns ={column = "gesture_name", value = info.name}})
-    end
-    action_data.value = gestures
-    post(action_data)
-  elseif event_data.event == _event("double_click") then
-    if event_data.ctrl_name == "gesture_list" then
-      LLGesture.startGesture(event_data.value)
-    end
-  end
-  return true
-end
-
-startup.wait('STATE_STARTED')
-local key = {xml_path = XML_FILE_PATH, op = "showLuaFloater"}
---receive additional events for defined control {<control_name>= {action1, action2, ...}}
-key.extra_events={gesture_list = {_event("double_click")}}
-handleEvents(leap.request("LLFloaterReg", key))
-
-catch_events = leap.WaitFor(-1, "all_events")
-function catch_events:filter(pump, data)
-  if data.reqid == reqid then
-    return data
-  end
-end
-
-function process_events(waitfor)
-  event_data = waitfor:wait()
-  while event_data and handleEvents(event_data) do
-    event_data = waitfor:wait()
-  end
-end
-
-fiber.launch("catch_events", process_events, catch_events)
-- 
cgit v1.2.3


From 56e4b8c5f637343c8a1a181fd59324e033b4782d Mon Sep 17 00:00:00 2001
From: Nat Goodspeed <nat@lindenlab.com>
Date: Fri, 21 Jun 2024 15:11:57 -0400
Subject: Exercise the simple popup.lua APIs

---
 indra/newview/scripts/lua/test_popup.lua | 6 ++++++
 1 file changed, 6 insertions(+)
 create mode 100644 indra/newview/scripts/lua/test_popup.lua

(limited to 'indra/newview/scripts')

diff --git a/indra/newview/scripts/lua/test_popup.lua b/indra/newview/scripts/lua/test_popup.lua
new file mode 100644
index 0000000000..e48f89c3a7
--- /dev/null
+++ b/indra/newview/scripts/lua/test_popup.lua
@@ -0,0 +1,6 @@
+popup = require 'popup'
+
+response = popup:alert('This just has a Close button')
+response = popup:alertOK(string.format('You said "%s", is that OK?', next(response)))
+response = popup:alertYesCancel(string.format('You said "%s"', next(response)))
+popup:tip(string.format('You said "%s"', next(response)))
-- 
cgit v1.2.3


From eb6d24e531aa5faa251b7aaf8b13c62f06708696 Mon Sep 17 00:00:00 2001
From: Mnikolenko Productengine <mnikolenko@productengine.com>
Date: Tue, 25 Jun 2024 14:51:53 +0300
Subject: Add wear/detach actions to Appearance listener; update example script

---
 indra/newview/scripts/lua/LLAppearance.lua         | 25 ------
 .../scripts/lua/luafloater_outfits_list.xml        | 36 ++++++++-
 indra/newview/scripts/lua/require/LLAppearance.lua | 37 +++++++++
 indra/newview/scripts/lua/test_outfits_list.lua    | 93 ++++++++++++++++++++--
 4 files changed, 157 insertions(+), 34 deletions(-)
 delete mode 100644 indra/newview/scripts/lua/LLAppearance.lua
 create mode 100644 indra/newview/scripts/lua/require/LLAppearance.lua

(limited to 'indra/newview/scripts')

diff --git a/indra/newview/scripts/lua/LLAppearance.lua b/indra/newview/scripts/lua/LLAppearance.lua
deleted file mode 100644
index ec7a25197f..0000000000
--- a/indra/newview/scripts/lua/LLAppearance.lua
+++ /dev/null
@@ -1,25 +0,0 @@
-leap = require 'leap'
-
-local LLAppearance = {}
-
-function LLAppearance.addOutfit(folder)
-    leap.request('LLAppearance', {op='wearOutfit', append = true, folder_id=folder})
-end
-
-function LLAppearance.replaceOutfit(folder)
-    leap.request('LLAppearance', {op='wearOutfit', append = false, folder_id=folder})
-end
-
-function LLAppearance.addOutfitByName(folder)
-    leap.request('LLAppearance', {op='wearOutfitByName', append = true, folder_name=folder})
-end
-
-function LLAppearance.replaceOutfitByName(folder)
-    leap.request('LLAppearance', {op='wearOutfitByName', append = false, folder_name=folder})
-end
-
-function LLAppearance.getOutfitsList()
-    return leap.request('LLAppearance', {op='getOutfitsList'})['outfits']
-end
-
-return LLAppearance
diff --git a/indra/newview/scripts/lua/luafloater_outfits_list.xml b/indra/newview/scripts/lua/luafloater_outfits_list.xml
index 1f6505cb8d..8cab864308 100644
--- a/indra/newview/scripts/lua/luafloater_outfits_list.xml
+++ b/indra/newview/scripts/lua/luafloater_outfits_list.xml
@@ -1,15 +1,15 @@
 <?xml version="1.0" encoding="utf-8" standalone="yes" ?>
 <floater
  legacy_header_height="18"
- height="185"
+ height="205"
  layout="topleft"
  name="lua_outfits"
  title="Outfits"
- width="320">
+ width="325">
     <scroll_list
      draw_heading="false"
      left="5"
-     width="310"
+     width="315"
      height="150"
      top_pad ="25"
      follows="all"
@@ -18,4 +18,34 @@
           name="outfit_name"
           label="Name"/>
     </scroll_list>
+    <button
+     follows="left|bottom"
+     height="23"
+     label="Replace COF"
+     layout="topleft"
+     name="replace_btn"
+     enabled="false"
+     top_pad="5"
+     width="95" >
+    </button>
+    <button
+     follows="left|bottom"
+     height="23"
+     label="Add to COF"
+     left_pad="7"
+     layout="topleft"
+     name="add_btn"
+     enabled="false"
+     width="95" >
+    </button>
+    <button
+     follows="left|bottom"
+     height="23"
+     label="Show wearables"
+     left_pad="7"
+     layout="topleft"
+     name="select_btn"
+     enabled="false"
+     width="111" >
+    </button>
 </floater>
diff --git a/indra/newview/scripts/lua/require/LLAppearance.lua b/indra/newview/scripts/lua/require/LLAppearance.lua
new file mode 100644
index 0000000000..165bb6d06f
--- /dev/null
+++ b/indra/newview/scripts/lua/require/LLAppearance.lua
@@ -0,0 +1,37 @@
+leap = require 'leap'
+
+local LLAppearance = {}
+
+function LLAppearance.addOutfit(folder)
+    leap.request('LLAppearance', {op='wearOutfit', append = true, folder_id=folder})
+end
+
+function LLAppearance.replaceOutfit(folder)
+    leap.request('LLAppearance', {op='wearOutfit', append = false, folder_id=folder})
+end
+
+function LLAppearance.addOutfitByName(folder)
+    leap.request('LLAppearance', {op='wearOutfitByName', append = true, folder_name=folder})
+end
+
+function LLAppearance.replaceOutfitByName(folder)
+    leap.request('LLAppearance', {op='wearOutfitByName', append = false, folder_name=folder})
+end
+
+function LLAppearance.wearItem(item_id, replace)
+    leap.send('LLAppearance', {op='wearItem', replace = replace, item_id=item_id})
+end
+
+function LLAppearance.detachItem(item_id)
+    leap.send('LLAppearance', {op='detachItem', item_id=item_id})
+end
+
+function LLAppearance.getOutfitsList()
+    return leap.request('LLAppearance', {op='getOutfitsList'})['outfits']
+end
+
+function LLAppearance.getOutfitItems(id)
+    return leap.request('LLAppearance', {op='getOutfitItems', outfit_id = id})['items']
+end
+
+return LLAppearance
diff --git a/indra/newview/scripts/lua/test_outfits_list.lua b/indra/newview/scripts/lua/test_outfits_list.lua
index 5875fd51da..dd5f914402 100644
--- a/indra/newview/scripts/lua/test_outfits_list.lua
+++ b/indra/newview/scripts/lua/test_outfits_list.lua
@@ -1,26 +1,107 @@
 local Floater = require 'Floater'
 local LLAppearance = require 'LLAppearance'
 local startup = require 'startup'
+local inspect = require 'inspect'
+
+local SHOW_OUTFITS = true
+local SELECTED_OUTFIT_ID = {}
+local DATA_MAP = {}
+
+local wearables_lbl = 'Show wearables'
+local outfits_lbl = 'Show outfits'
+local replace_cof_lbl = 'Replace COF'
+local add_cof_lbl = 'Add to COF'
+local outfits_title = 'Outfits'
+local wear_lbl = 'Wear item'
+local detach_lbl = 'Detach item'
 
 local flt = Floater:new(
     "luafloater_outfits_list.xml",
     {outfits_list = {"double_click"}})
 
-function flt:post_build(event_data)
-    local outfits_map = LLAppearance.getOutfitsList()
+function get_selected_id()
+    return flt:request({action="get_selected_id", ctrl_name='outfits_list'}).value
+end
+
+function populate_list()
+    if SHOW_OUTFITS then
+      DATA_MAP = LLAppearance.getOutfitsList()
+    else
+      DATA_MAP = LLAppearance.getOutfitItems(SELECTED_OUTFIT_ID)
+    end
+
     local action_data = {}
     action_data.action = "add_list_element"
     action_data.ctrl_name = "outfits_list"
     local outfits = {}
-    for uuid, name in pairs(outfits_map) do
+    for uuid, name in pairs(DATA_MAP) do
       table.insert(outfits, {value = uuid, columns={column = "outfit_name", value = name}})
     end
     action_data.value = outfits
-    self:post(action_data)
+    flt:post(action_data)
+end
+
+function set_label(btn_name, value)
+    flt:post({action="set_label", ctrl_name=btn_name, value=value})
+end
+
+function set_enabled(btn_name, value)
+    flt:post({action="set_enabled", ctrl_name=btn_name, value=value})
+end
+
+function update_labels()
+    if SHOW_OUTFITS then
+      set_label('select_btn', wearables_lbl)
+      set_label('replace_btn', replace_cof_lbl)
+      set_label('add_btn', add_cof_lbl)
+
+      set_enabled('select_btn', false)
+      flt:post({action="set_title", value=outfits_title})
+    else
+      set_label('select_btn', outfits_lbl)
+      set_label('replace_btn', wear_lbl)
+      set_label('add_btn', detach_lbl)
+
+      set_enabled('select_btn', true)
+      flt:post({action="set_title", value=DATA_MAP[SELECTED_OUTFIT_ID]})
+    end
+
+    set_enabled('replace_btn', false)
+    set_enabled('add_btn', false)
+end
+
+function flt:post_build(event_data)
+    populate_list()
+end
+
+function flt:commit_replace_btn(event_data)
+    if SHOW_OUTFITS then
+      LLAppearance.replaceOutfit(get_selected_id())
+    else
+      LLAppearance.wearItem(get_selected_id(), false)
+    end
+end
+
+function flt:commit_add_btn(event_data)
+    if SHOW_OUTFITS then
+      LLAppearance.addOutfit(get_selected_id())
+    else
+      LLAppearance.detachItem(get_selected_id())
+    end
+end
+
+function flt:commit_select_btn(event_data)
+    SHOW_OUTFITS = not SHOW_OUTFITS
+    SELECTED_OUTFIT_ID = get_selected_id()
+    update_labels()
+    self:post({action="clear_list", ctrl_name='outfits_list'})
+    populate_list()
 end
 
-function flt:double_click_outfits_list(event_data)
-    LLAppearance.replaceOutfit(event_data.value)
+function flt:commit_outfits_list(event_data)
+      set_enabled('replace_btn', true)
+      set_enabled('add_btn', true)
+      set_enabled('select_btn', true)
 end
 
 startup.wait('STATE_STARTED')
-- 
cgit v1.2.3


From 07f0f12bcbe864177a145b074c2739eaf08f2c5c Mon Sep 17 00:00:00 2001
From: Mnikolenko Productengine <mnikolenko@productengine.com>
Date: Mon, 1 Jul 2024 13:02:49 +0300
Subject: Move error strings to strings.xml; pass wearable type and is_worn
 flag for outfit items

---
 indra/newview/scripts/lua/test_outfits_list.lua | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

(limited to 'indra/newview/scripts')

diff --git a/indra/newview/scripts/lua/test_outfits_list.lua b/indra/newview/scripts/lua/test_outfits_list.lua
index dd5f914402..1011029f34 100644
--- a/indra/newview/scripts/lua/test_outfits_list.lua
+++ b/indra/newview/scripts/lua/test_outfits_list.lua
@@ -34,7 +34,13 @@ function populate_list()
     action_data.action = "add_list_element"
     action_data.ctrl_name = "outfits_list"
     local outfits = {}
-    for uuid, name in pairs(DATA_MAP) do
+    for uuid, info in pairs(DATA_MAP) do
+      name = {}
+      if SHOW_OUTFITS then
+        name = info
+      else
+        name = info.name
+      end
       table.insert(outfits, {value = uuid, columns={column = "outfit_name", value = name}})
     end
     action_data.value = outfits
-- 
cgit v1.2.3


From ece0f4eb566af937d724f60f934beb6dfcb4d493 Mon Sep 17 00:00:00 2001
From: Mnikolenko Productengine <mnikolenko@productengine.com>
Date: Fri, 5 Jul 2024 16:03:51 +0300
Subject: clean up and rename demo script

---
 indra/newview/scripts/lua/require/LLAppearance.lua |  28 ++---
 indra/newview/scripts/lua/test_LLAppearance.lua    | 114 +++++++++++++++++++++
 indra/newview/scripts/lua/test_outfits_list.lua    | 114 ---------------------
 3 files changed, 125 insertions(+), 131 deletions(-)
 create mode 100644 indra/newview/scripts/lua/test_LLAppearance.lua
 delete mode 100644 indra/newview/scripts/lua/test_outfits_list.lua

(limited to 'indra/newview/scripts')

diff --git a/indra/newview/scripts/lua/require/LLAppearance.lua b/indra/newview/scripts/lua/require/LLAppearance.lua
index 165bb6d06f..f533d22daf 100644
--- a/indra/newview/scripts/lua/require/LLAppearance.lua
+++ b/indra/newview/scripts/lua/require/LLAppearance.lua
@@ -1,29 +1,23 @@
-leap = require 'leap'
+local leap = require 'leap'
 
 local LLAppearance = {}
 
-function LLAppearance.addOutfit(folder)
-    leap.request('LLAppearance', {op='wearOutfit', append = true, folder_id=folder})
+function LLAppearance.wearOutfit(folder, action)
+    action = action or 'add'
+    leap.request('LLAppearance', {op='wearOutfit', append = (action == 'add'), folder_id=folder})
 end
 
-function LLAppearance.replaceOutfit(folder)
-    leap.request('LLAppearance', {op='wearOutfit', append = false, folder_id=folder})
+function LLAppearance.wearOutfitByName(folder, action)
+    action = action or 'add'
+    leap.request('LLAppearance', {op='wearOutfit', append = (action == 'add'), folder_name=folder})
 end
 
-function LLAppearance.addOutfitByName(folder)
-    leap.request('LLAppearance', {op='wearOutfitByName', append = true, folder_name=folder})
+function LLAppearance.wearItems(items_id, replace)
+    leap.send('LLAppearance', {op='wearItems', replace = replace, items_id=items_id})
 end
 
-function LLAppearance.replaceOutfitByName(folder)
-    leap.request('LLAppearance', {op='wearOutfitByName', append = false, folder_name=folder})
-end
-
-function LLAppearance.wearItem(item_id, replace)
-    leap.send('LLAppearance', {op='wearItem', replace = replace, item_id=item_id})
-end
-
-function LLAppearance.detachItem(item_id)
-    leap.send('LLAppearance', {op='detachItem', item_id=item_id})
+function LLAppearance.detachItems(items_id)
+    leap.send('LLAppearance', {op='detachItems', items_id=items_id})
 end
 
 function LLAppearance.getOutfitsList()
diff --git a/indra/newview/scripts/lua/test_LLAppearance.lua b/indra/newview/scripts/lua/test_LLAppearance.lua
new file mode 100644
index 0000000000..5ddd9f15ff
--- /dev/null
+++ b/indra/newview/scripts/lua/test_LLAppearance.lua
@@ -0,0 +1,114 @@
+local Floater = require 'Floater'
+local LLAppearance = require 'LLAppearance'
+local startup = require 'startup'
+local inspect = require 'inspect'
+
+local SHOW_OUTFITS = true
+local SELECTED_OUTFIT_ID = {}
+local DATA_MAP = {}
+
+local wearables_lbl = 'Show wearables'
+local outfits_lbl = 'Show outfits'
+local replace_cof_lbl = 'Replace COF'
+local add_cof_lbl = 'Add to COF'
+local outfits_title = 'Outfits'
+local wear_lbl = 'Wear item'
+local detach_lbl = 'Detach item'
+
+local flt = Floater:new(
+    "luafloater_outfits_list.xml",
+    {outfits_list = {"double_click"}})
+
+function get_selected_id()
+    return flt:request({action="get_selected_id", ctrl_name='outfits_list'}).value
+end
+
+function populate_list()
+    if SHOW_OUTFITS then
+      DATA_MAP = LLAppearance.getOutfitsList()
+    else
+      DATA_MAP = LLAppearance.getOutfitItems(SELECTED_OUTFIT_ID)
+    end
+
+    local action_data = {}
+    action_data.action = "add_list_element"
+    action_data.ctrl_name = "outfits_list"
+    local outfits = {}
+    for uuid, info in pairs(DATA_MAP) do
+      name = {}
+      if SHOW_OUTFITS then
+        name = info
+      else
+        name = info.name
+      end
+      table.insert(outfits, {value = uuid, columns={column = "outfit_name", value = name}})
+    end
+    action_data.value = outfits
+    flt:post(action_data)
+end
+
+function set_label(btn_name, value)
+    flt:post({action="set_label", ctrl_name=btn_name, value=value})
+end
+
+function set_enabled(btn_name, value)
+    flt:post({action="set_enabled", ctrl_name=btn_name, value=value})
+end
+
+function update_labels()
+    if SHOW_OUTFITS then
+      set_label('select_btn', wearables_lbl)
+      set_label('replace_btn', replace_cof_lbl)
+      set_label('add_btn', add_cof_lbl)
+
+      set_enabled('select_btn', false)
+      flt:post({action="set_title", value=outfits_title})
+    else
+      set_label('select_btn', outfits_lbl)
+      set_label('replace_btn', wear_lbl)
+      set_label('add_btn', detach_lbl)
+
+      set_enabled('select_btn', true)
+      flt:post({action="set_title", value=DATA_MAP[SELECTED_OUTFIT_ID]})
+    end
+
+    set_enabled('replace_btn', false)
+    set_enabled('add_btn', false)
+end
+
+function flt:post_build(event_data)
+    populate_list()
+end
+
+function flt:commit_replace_btn(event_data)
+    if SHOW_OUTFITS then
+      LLAppearance.wearOutfit(get_selected_id(), 'replace')
+    else
+      LLAppearance.wearItems(get_selected_id(), false)
+    end
+end
+
+function flt:commit_add_btn(event_data)
+    if SHOW_OUTFITS then
+      LLAppearance.wearOutfit(get_selected_id(), 'add')
+    else
+      LLAppearance.detachItems(get_selected_id())
+    end
+end
+
+function flt:commit_select_btn(event_data)
+    SHOW_OUTFITS = not SHOW_OUTFITS
+    SELECTED_OUTFIT_ID = get_selected_id()
+    update_labels()
+    self:post({action="clear_list", ctrl_name='outfits_list'})
+    populate_list()
+end
+
+function flt:commit_outfits_list(event_data)
+      set_enabled('replace_btn', true)
+      set_enabled('add_btn', true)
+      set_enabled('select_btn', true)
+end
+
+startup.wait('STATE_STARTED')
+flt:show()
diff --git a/indra/newview/scripts/lua/test_outfits_list.lua b/indra/newview/scripts/lua/test_outfits_list.lua
deleted file mode 100644
index 1011029f34..0000000000
--- a/indra/newview/scripts/lua/test_outfits_list.lua
+++ /dev/null
@@ -1,114 +0,0 @@
-local Floater = require 'Floater'
-local LLAppearance = require 'LLAppearance'
-local startup = require 'startup'
-local inspect = require 'inspect'
-
-local SHOW_OUTFITS = true
-local SELECTED_OUTFIT_ID = {}
-local DATA_MAP = {}
-
-local wearables_lbl = 'Show wearables'
-local outfits_lbl = 'Show outfits'
-local replace_cof_lbl = 'Replace COF'
-local add_cof_lbl = 'Add to COF'
-local outfits_title = 'Outfits'
-local wear_lbl = 'Wear item'
-local detach_lbl = 'Detach item'
-
-local flt = Floater:new(
-    "luafloater_outfits_list.xml",
-    {outfits_list = {"double_click"}})
-
-function get_selected_id()
-    return flt:request({action="get_selected_id", ctrl_name='outfits_list'}).value
-end
-
-function populate_list()
-    if SHOW_OUTFITS then
-      DATA_MAP = LLAppearance.getOutfitsList()
-    else
-      DATA_MAP = LLAppearance.getOutfitItems(SELECTED_OUTFIT_ID)
-    end
-
-    local action_data = {}
-    action_data.action = "add_list_element"
-    action_data.ctrl_name = "outfits_list"
-    local outfits = {}
-    for uuid, info in pairs(DATA_MAP) do
-      name = {}
-      if SHOW_OUTFITS then
-        name = info
-      else
-        name = info.name
-      end
-      table.insert(outfits, {value = uuid, columns={column = "outfit_name", value = name}})
-    end
-    action_data.value = outfits
-    flt:post(action_data)
-end
-
-function set_label(btn_name, value)
-    flt:post({action="set_label", ctrl_name=btn_name, value=value})
-end
-
-function set_enabled(btn_name, value)
-    flt:post({action="set_enabled", ctrl_name=btn_name, value=value})
-end
-
-function update_labels()
-    if SHOW_OUTFITS then
-      set_label('select_btn', wearables_lbl)
-      set_label('replace_btn', replace_cof_lbl)
-      set_label('add_btn', add_cof_lbl)
-
-      set_enabled('select_btn', false)
-      flt:post({action="set_title", value=outfits_title})
-    else
-      set_label('select_btn', outfits_lbl)
-      set_label('replace_btn', wear_lbl)
-      set_label('add_btn', detach_lbl)
-
-      set_enabled('select_btn', true)
-      flt:post({action="set_title", value=DATA_MAP[SELECTED_OUTFIT_ID]})
-    end
-
-    set_enabled('replace_btn', false)
-    set_enabled('add_btn', false)
-end
-
-function flt:post_build(event_data)
-    populate_list()
-end
-
-function flt:commit_replace_btn(event_data)
-    if SHOW_OUTFITS then
-      LLAppearance.replaceOutfit(get_selected_id())
-    else
-      LLAppearance.wearItem(get_selected_id(), false)
-    end
-end
-
-function flt:commit_add_btn(event_data)
-    if SHOW_OUTFITS then
-      LLAppearance.addOutfit(get_selected_id())
-    else
-      LLAppearance.detachItem(get_selected_id())
-    end
-end
-
-function flt:commit_select_btn(event_data)
-    SHOW_OUTFITS = not SHOW_OUTFITS
-    SELECTED_OUTFIT_ID = get_selected_id()
-    update_labels()
-    self:post({action="clear_list", ctrl_name='outfits_list'})
-    populate_list()
-end
-
-function flt:commit_outfits_list(event_data)
-      set_enabled('replace_btn', true)
-      set_enabled('add_btn', true)
-      set_enabled('select_btn', true)
-end
-
-startup.wait('STATE_STARTED')
-flt:show()
-- 
cgit v1.2.3


From b27606feca00172cdfd7467ff3e216824f1c9518 Mon Sep 17 00:00:00 2001
From: Mnikolenko Productengine <mnikolenko@productengine.com>
Date: Mon, 8 Jul 2024 13:56:46 +0300
Subject: Lua api for Snapshot and demo script

---
 indra/newview/scripts/lua/require/UI.lua    | 15 +++++++++++++++
 indra/newview/scripts/lua/test_snapshot.lua | 15 +++++++++++++++
 2 files changed, 30 insertions(+)
 create mode 100644 indra/newview/scripts/lua/test_snapshot.lua

(limited to 'indra/newview/scripts')

diff --git a/indra/newview/scripts/lua/require/UI.lua b/indra/newview/scripts/lua/require/UI.lua
index eb1a4017c7..8fcc446e09 100644
--- a/indra/newview/scripts/lua/require/UI.lua
+++ b/indra/newview/scripts/lua/require/UI.lua
@@ -122,4 +122,19 @@ function UI.type(...)
     end
 end
 
+-- ***************************************************************************
+--  Snapshot
+-- ***************************************************************************
+-- UI.snapshot{filename=filename            -- extension may be specified: bmp, jpeg, png
+--          [, type='COLOR' | 'DEPTH']
+--          [, width=width][, height=height]  -- uses current window size if not specified
+--          [, showui=true][, showhud=true]
+--          [, rebuild=false]}
+function UI.snapshot(...)
+    local args = mapargs('filename,width,height,showui,showhud,rebuild,type', ...)
+    leap.request('LLViewerWindow', {op='saveSnapshot', filename = args.filename,
+                                    width=args.width, height=args.height,
+                                    showui=args.showui, showhud=args.showhud,
+                                    rebuild=args.rebuild, type=args.type})
+end
 return UI
diff --git a/indra/newview/scripts/lua/test_snapshot.lua b/indra/newview/scripts/lua/test_snapshot.lua
new file mode 100644
index 0000000000..d7c878833b
--- /dev/null
+++ b/indra/newview/scripts/lua/test_snapshot.lua
@@ -0,0 +1,15 @@
+local UI = require 'UI'
+
+PATH = 'E:\\'
+-- 'png', 'jpeg' or 'bmp'
+EXT = '.png'
+
+NAME_SIMPLE = 'Snapshot_simple' .. '_' .. os.date("%Y-%m-%d_%H-%M-%S")
+UI.snapshot(PATH .. NAME_SIMPLE .. EXT)
+
+NAME_ARGS = 'Snapshot_args' .. '_' .. os.date("%Y-%m-%d_%H-%M-%S")
+
+-- 'COLOR' or 'DEPTH'
+TYPE = 'COLOR'
+UI.snapshot{PATH .. NAME_ARGS .. EXT, width = 700, height = 400,
+            type = TYPE, showui = false, showhud = false}
-- 
cgit v1.2.3


From 98761798b9a118c46e5482b1f36fef1260c9c5f9 Mon Sep 17 00:00:00 2001
From: Mnikolenko Productengine <mnikolenko@productengine.com>
Date: Wed, 10 Jul 2024 12:03:49 +0300
Subject: Simplify passing keys to leap.request

---
 indra/newview/scripts/lua/require/UI.lua | 6 ++----
 1 file changed, 2 insertions(+), 4 deletions(-)

(limited to 'indra/newview/scripts')

diff --git a/indra/newview/scripts/lua/require/UI.lua b/indra/newview/scripts/lua/require/UI.lua
index 8fcc446e09..1eee4657f4 100644
--- a/indra/newview/scripts/lua/require/UI.lua
+++ b/indra/newview/scripts/lua/require/UI.lua
@@ -132,9 +132,7 @@ end
 --          [, rebuild=false]}
 function UI.snapshot(...)
     local args = mapargs('filename,width,height,showui,showhud,rebuild,type', ...)
-    leap.request('LLViewerWindow', {op='saveSnapshot', filename = args.filename,
-                                    width=args.width, height=args.height,
-                                    showui=args.showui, showhud=args.showhud,
-                                    rebuild=args.rebuild, type=args.type})
+    args.op = 'saveSnapshot'
+    return leap.request('LLViewerWindow', args).result
 end
 return UI
-- 
cgit v1.2.3


From 50d60c2518710e92cff05b806624b11ac714369f Mon Sep 17 00:00:00 2001
From: Maxim Nikolenko <maximnproductengine@lindenlab.com>
Date: Wed, 17 Jul 2024 16:46:00 +0300
Subject: Lua api for adding new menu items to the Top menu

---
 indra/newview/scripts/lua/require/UI.lua    | 28 ++++++++++++++++++++++++
 indra/newview/scripts/lua/test_top_menu.lua | 34 +++++++++++++++++++++++++++++
 2 files changed, 62 insertions(+)
 create mode 100644 indra/newview/scripts/lua/test_top_menu.lua

(limited to 'indra/newview/scripts')

diff --git a/indra/newview/scripts/lua/require/UI.lua b/indra/newview/scripts/lua/require/UI.lua
index 1eee4657f4..28488ff3e1 100644
--- a/indra/newview/scripts/lua/require/UI.lua
+++ b/indra/newview/scripts/lua/require/UI.lua
@@ -135,4 +135,32 @@ function UI.snapshot(...)
     args.op = 'saveSnapshot'
     return leap.request('LLViewerWindow', args).result
 end
+
+-- ***************************************************************************
+--  Top menu
+-- ***************************************************************************
+
+function UI.addMenu(...)
+    local args = mapargs('name,label', ...)
+    args.op = 'addMenu'
+    return leap.request('UI', args)
+end
+
+function UI.addMenuBranch(...)
+    local args = mapargs('name,label,parent_menu', ...)
+    args.op = 'addMenuBranch'
+    return leap.request('UI', args)
+end
+
+function UI.addMenuItem(...)
+    local args = mapargs('name,label,parent_menu,func,param', ...)
+    args.op = 'addMenuItem'
+    return leap.request('UI', args)
+end
+
+function UI.addMenuSeparator(...)
+    local args = mapargs('parent_menu', ...)
+    args.op = 'addMenuSeparator'
+    return leap.request('UI', args)
+end
 return UI
diff --git a/indra/newview/scripts/lua/test_top_menu.lua b/indra/newview/scripts/lua/test_top_menu.lua
new file mode 100644
index 0000000000..780a384c92
--- /dev/null
+++ b/indra/newview/scripts/lua/test_top_menu.lua
@@ -0,0 +1,34 @@
+UI = require 'UI'
+
+--Add new drop-down 'LUA Menu' to the Top menu.
+local MENU_NAME = "lua_menu"
+UI.addMenu{name=MENU_NAME,label="LUA Menu"}
+
+--Add two new menu items to the 'LUA Menu': 'Debug console' and 'Scripts'
+UI.addMenuItem{name="lua_debug",label="Debug console",
+                param="lua_debug",
+                func="Floater.ToggleOrBringToFront",
+                parent_menu=MENU_NAME}
+
+UI.addMenuItem{name="lua_scripts",label="Scripts",
+                param="lua_scripts",
+                func="Floater.ToggleOrBringToFront",
+                parent_menu=MENU_NAME}
+
+--Add menu separator to the 'LUA Menu' under added menu items
+UI.addMenuSeparator{parent_menu=MENU_NAME}
+
+--Add two new menu branch 'About...' to the 'LUA Menu'
+local BRANCH_NAME = "about_branch"
+UI.addMenuBranch{name="about_branch",label="About...",parent_menu=MENU_NAME}
+
+--Add two new menu items to the 'About...' branch
+UI.addMenuItem{name="lua_info",label="Lua...",
+                param="https://www.lua.org/about.html",
+                func="Advanced.ShowURL",
+                parent_menu=BRANCH_NAME}
+
+UI.addMenuItem{name="lua_info",label="Luau...",
+                param="https://luau-lang.org/",
+                func="Advanced.ShowURL",
+                parent_menu=BRANCH_NAME}
-- 
cgit v1.2.3


From decc2d3aa5ba8dc583dae5396a5ae8ca738412dd Mon Sep 17 00:00:00 2001
From: Mnikolenko Productengine <mnikolenko@productengine.com>
Date: Thu, 25 Jul 2024 18:15:24 +0300
Subject: Lua api for Follow Camera control

---
 .../scripts/lua/luafloater_camera_control.xml      | 244 +++++++++++++++++++++
 indra/newview/scripts/lua/require/LLAgent.lua      |  28 +++
 indra/newview/scripts/lua/test_camera_control.lua  |  52 +++++
 3 files changed, 324 insertions(+)
 create mode 100644 indra/newview/scripts/lua/luafloater_camera_control.xml
 create mode 100644 indra/newview/scripts/lua/require/LLAgent.lua
 create mode 100644 indra/newview/scripts/lua/test_camera_control.lua

(limited to 'indra/newview/scripts')

diff --git a/indra/newview/scripts/lua/luafloater_camera_control.xml b/indra/newview/scripts/lua/luafloater_camera_control.xml
new file mode 100644
index 0000000000..0601a363e5
--- /dev/null
+++ b/indra/newview/scripts/lua/luafloater_camera_control.xml
@@ -0,0 +1,244 @@
+<?xml version="1.0" encoding="utf-8" standalone="yes" ?>
+<floater
+ legacy_header_height="18"
+ height="350"
+ layout="topleft"
+ name="camera_demo"
+ title="Follow camera control"
+ width="360">
+    <text
+     type="string"
+     follows="left|top"
+     height="10"
+     width="100"
+     layout="topleft"
+     top="30"
+     left="10"
+     name="camera_lbl">
+    Camera position:
+    </text>
+    <text
+     type="string"
+     follows="left|top"
+     height="10"
+     width="10"
+     layout="topleft"
+     top_pad="12"
+     left="10"
+     value="X"
+     name="cam_x_lbl"/>
+    <line_editor
+     border_style="line"
+     border_thickness="1"
+     follows="left|bottom"
+     font="SansSerif"
+     height="20"
+     layout="topleft"
+     max_length_bytes="50"
+     name="cam_x"
+     top_delta="-2"
+     left_pad="5"
+     width="65" />
+    <button
+     follows="left|bottom"
+     height="20"
+     image_overlay="Icon_Copy"
+     image_selected="Toolbar_Middle_Selected"
+     image_unselected="Toolbar_Middle_Off"
+     layout="topleft"
+     tool_tip="Use Agent position"
+     name="agent_cam_btn"
+     left_pad="10"
+     width="20" >
+    </button>
+    <text
+     type="string"
+     follows="left|top"
+     height="10"
+     width="10"
+     layout="topleft"
+     top_pad="7"
+     left="10"
+     value="Y"
+     name="cam_y_lbl"/>
+    <line_editor
+     border_style="line"
+     border_thickness="1"
+     follows="left|bottom"
+     font="SansSerif"
+     height="20"
+     layout="topleft"
+     max_length_bytes="50"
+     name="cam_y"
+     top_delta="-2"
+     left_pad="5"
+     width="65" />
+    <text
+     type="string"
+     follows="left|top"
+     height="10"
+     width="10"
+     layout="topleft"
+     top_pad="7"
+     left="10"
+     value="Z"
+     name="cam_z_lbl"/>
+    <line_editor
+     border_style="line"
+     border_thickness="1"
+     follows="left|bottom"
+     font="SansSerif"
+     height="20"
+     layout="topleft"
+     max_length_bytes="50"
+     name="cam_z"
+     top_delta="-2"
+     left_pad="5"
+     width="65" />
+    <text
+     type="string"
+     follows="left|top"
+     height="10"
+     width="100"
+     layout="topleft"
+     top="30"
+     left="145"
+     name="focus_lbl">
+    Focus position:
+    </text>
+    <text
+     type="string"
+     follows="left|top"
+     height="10"
+     width="10"
+     layout="topleft"
+     top_pad="12"
+     left="145"
+     value="X"
+     name="cam_x_lbl"/>
+    <line_editor
+     border_style="line"
+     border_thickness="1"
+     follows="left|bottom"
+     font="SansSerif"
+     height="20"
+     layout="topleft"
+     max_length_bytes="50"
+     name="focus_x"
+     top_delta="-2"
+     left_pad="5"
+     width="60" />
+    <button
+     follows="left|bottom"
+     height="20"
+     image_overlay="Icon_Copy"
+     image_selected="Toolbar_Middle_Selected"
+     image_unselected="Toolbar_Middle_Off"
+     layout="topleft"
+     tool_tip="Use Agent position"
+     name="agent_focus_btn"
+     left_pad="10"
+     width="20" >
+    </button>
+    <text
+     type="string"
+     follows="left|top"
+     height="10"
+     width="10"
+     layout="topleft"
+     top_pad="7"
+     left="145"
+     value="Y"
+     name="cam_y_lbl"/>
+    <line_editor
+     border_style="line"
+     border_thickness="1"
+     follows="left|bottom"
+     font="SansSerif"
+     height="20"
+     layout="topleft"
+     max_length_bytes="50"
+     name="focus_y"
+     top_delta="-2"
+     left_pad="5"
+     width="60" />
+    <text
+     type="string"
+     follows="left|top"
+     height="10"
+     width="10"
+     layout="topleft"
+     top_pad="7"
+     left="145"
+     value="Z"
+     name="cam_z_lbl"/>
+    <line_editor
+     border_style="line"
+     border_thickness="1"
+     follows="left|bottom"
+     font="SansSerif"
+     height="20"
+     layout="topleft"
+     max_length_bytes="50"
+     name="focus_z"
+     top_delta="-2"
+     left_pad="5"
+     width="60" />
+    <text
+     type="string"
+     follows="left|top"
+     height="10"
+     width="100"
+     layout="topleft"
+     top="30"
+     left="270"
+     name="focus_lbl">
+    Lock:
+    </text>
+    <check_box
+     width="80"
+     height="21"
+     layout="topleft"
+     follows="top|left"
+     top_pad="12"
+     label="Camera"
+     name="lock_camera_ctrl"/>
+    <check_box
+     width="80"
+     height="21"
+     layout="topleft"
+     follows="top|left"
+     top_pad="2"
+     label="Focus"
+     name="lock_focus_ctrl"/>
+    <button
+     follows="left|bottom"
+     height="25"
+     label="Update params"
+     layout="topleft"
+     name="update_btn"
+     left="10"
+     top="140"
+     width="120" >
+    </button>
+    <button
+     follows="left|bottom"
+     height="25"
+     label="Reset"
+     layout="topleft"
+     name="reset_btn"
+     left_pad="15"
+     width="90" >
+    </button>
+    <text_editor
+     follows="top|left"
+     font="SansSerif"
+     height="160"
+     left="5"
+     enabled="false"
+     name="events_editor"
+     top_pad="15"
+     word_wrap="true"
+     max_length="65536"
+     width="350"/>
+</floater>
diff --git a/indra/newview/scripts/lua/require/LLAgent.lua b/indra/newview/scripts/lua/require/LLAgent.lua
new file mode 100644
index 0000000000..7c6a842555
--- /dev/null
+++ b/indra/newview/scripts/lua/require/LLAgent.lua
@@ -0,0 +1,28 @@
+local leap = require 'leap'
+local mapargs = require 'mapargs'
+
+local LLAgent = {}
+
+function LLAgent.getRegionPosition()
+    return leap.request('LLAgent', {op = 'getPosition'}).region
+end
+
+function LLAgent.getGlobalPosition()
+    return leap.request('LLAgent', {op = 'getPosition'}).global
+end
+
+function LLAgent.setCamera(...)
+    local args = mapargs('camera_pos,focus_pos,focus_offset,camera_locked,focus_locked', ...)
+    args.op = 'setCameraParams'
+    leap.send('LLAgent', args)
+end
+
+function LLAgent.setFollowCamActive(active)
+    leap.send('LLAgent', {op = 'setFollowCamActive', active = active})
+end
+
+function LLAgent.removeCamParams()
+    leap.send('LLAgent', {op = 'removeCameraParams'})
+end
+
+return LLAgent
diff --git a/indra/newview/scripts/lua/test_camera_control.lua b/indra/newview/scripts/lua/test_camera_control.lua
new file mode 100644
index 0000000000..db76201932
--- /dev/null
+++ b/indra/newview/scripts/lua/test_camera_control.lua
@@ -0,0 +1,52 @@
+local Floater = require 'Floater'
+local LLAgent = require 'LLAgent'
+local leap = require 'leap'
+local startup = require 'startup'
+local inspect = require 'inspect'
+
+local flt = Floater('luafloater_camera_control.xml')
+
+function getValue(ctrl_name)
+    return flt:request({action="get_value", ctrl_name=ctrl_name}).value
+end
+
+function setValue(ctrl_name, value)
+    flt:post({action="set_value", ctrl_name=ctrl_name, value=value})
+end
+
+function flt:commit_update_btn(event_data)
+    lock_focus = getValue('lock_focus_ctrl')
+    lock_camera = self:request({action="get_value", ctrl_name='lock_camera_ctrl'}).value
+
+    local camera_pos = {getValue('cam_x'),getValue('cam_y'),getValue('cam_z')}
+    local focus_pos = {getValue('focus_x'),getValue('focus_y'),getValue('focus_z')}
+
+
+    LLAgent.setCamera{camera_pos=camera_pos,focus_pos=focus_pos,
+                        focus_locked = lock_focus,camera_locked = lock_camera}
+
+    self:post({action="add_text", ctrl_name="events_editor",
+                value = {'Updating FollowCam params', 'camera_pos:', camera_pos, 'focus_pos:', focus_pos, 'lock_focus:', lock_focus, 'lock_camera:', lock_camera}})
+end
+
+function flt:commit_agent_cam_btn(event_data)
+    agent_pos = LLAgent.getRegionPosition()
+    setValue('cam_x', math.floor(agent_pos[1]))
+    setValue('cam_y', math.floor(agent_pos[2]))
+    setValue('cam_z', math.floor(agent_pos[3]))
+end
+
+function flt:commit_agent_focus_btn(event_data)
+    agent_pos = LLAgent.getRegionPosition()
+    setValue('focus_x', math.floor(agent_pos[1]))
+    setValue('focus_y', math.floor(agent_pos[2]))
+    setValue('focus_z', math.floor(agent_pos[3]))
+end
+
+function flt:commit_reset_btn(event_data)
+    LLAgent.removeCamParams()
+    LLAgent.setFollowCamActive(false)
+end
+
+startup.wait('STATE_LOGIN_WAIT')
+flt:show()
-- 
cgit v1.2.3


From 4edcebdb31b7d49faf94b60a66c9921e90e23899 Mon Sep 17 00:00:00 2001
From: Mnikolenko Productengine <mnikolenko@productengine.com>
Date: Thu, 25 Jul 2024 18:29:06 +0300
Subject: Script clean up

---
 indra/newview/scripts/lua/test_camera_control.lua | 17 +++++++----------
 1 file changed, 7 insertions(+), 10 deletions(-)

(limited to 'indra/newview/scripts')

diff --git a/indra/newview/scripts/lua/test_camera_control.lua b/indra/newview/scripts/lua/test_camera_control.lua
index db76201932..e7ad69b473 100644
--- a/indra/newview/scripts/lua/test_camera_control.lua
+++ b/indra/newview/scripts/lua/test_camera_control.lua
@@ -1,8 +1,6 @@
 local Floater = require 'Floater'
 local LLAgent = require 'LLAgent'
-local leap = require 'leap'
 local startup = require 'startup'
-local inspect = require 'inspect'
 
 local flt = Floater('luafloater_camera_control.xml')
 
@@ -16,17 +14,16 @@ end
 
 function flt:commit_update_btn(event_data)
     lock_focus = getValue('lock_focus_ctrl')
-    lock_camera = self:request({action="get_value", ctrl_name='lock_camera_ctrl'}).value
+    lock_camera = getValue('lock_camera_ctrl')
+    local camera_pos = {getValue('cam_x'), getValue('cam_y'), getValue('cam_z')}
+    local focus_pos = {getValue('focus_x'), getValue('focus_y'), getValue('focus_z')}
 
-    local camera_pos = {getValue('cam_x'),getValue('cam_y'),getValue('cam_z')}
-    local focus_pos = {getValue('focus_x'),getValue('focus_y'),getValue('focus_z')}
-
-
-    LLAgent.setCamera{camera_pos=camera_pos,focus_pos=focus_pos,
-                        focus_locked = lock_focus,camera_locked = lock_camera}
+    LLAgent.setCamera{camera_pos=camera_pos, focus_pos=focus_pos,
+                      focus_locked=lock_focus, camera_locked=lock_camera}
 
     self:post({action="add_text", ctrl_name="events_editor",
-                value = {'Updating FollowCam params', 'camera_pos:', camera_pos, 'focus_pos:', focus_pos, 'lock_focus:', lock_focus, 'lock_camera:', lock_camera}})
+                value = {'Updating FollowCam params', 'camera_pos:', camera_pos, 'focus_pos:', focus_pos,
+                          'lock_focus:', lock_focus, 'lock_camera:', lock_camera}})
 end
 
 function flt:commit_agent_cam_btn(event_data)
-- 
cgit v1.2.3


From 41ea8a61c247d915ebe53436e9cfc999a712b692 Mon Sep 17 00:00:00 2001
From: Mnikolenko Productengine <mnikolenko@productengine.com>
Date: Fri, 26 Jul 2024 15:55:17 +0300
Subject: Add api for more script camera params

---
 indra/newview/scripts/lua/require/LLAgent.lua | 19 ++++++++++++++++++-
 1 file changed, 18 insertions(+), 1 deletion(-)

(limited to 'indra/newview/scripts')

diff --git a/indra/newview/scripts/lua/require/LLAgent.lua b/indra/newview/scripts/lua/require/LLAgent.lua
index 7c6a842555..bc9a6b23a0 100644
--- a/indra/newview/scripts/lua/require/LLAgent.lua
+++ b/indra/newview/scripts/lua/require/LLAgent.lua
@@ -11,8 +11,25 @@ function LLAgent.getGlobalPosition()
     return leap.request('LLAgent', {op = 'getPosition'}).global
 end
 
+-- Use LL.leaphelp('LLAgent') and see 'setCameraParams' to get more info about params
+--                                          -- TYPE               -- DEFAULT      -- RANGE
+-- LLAgent.setCamera{ [, camera_pos]        -- vector3
+--                    [, focus_pos]         -- vector3
+--                    [, focus_offset]      -- vector3            -- {1,0,0}      -- {-10,-10,-10} to {10,10,10}
+--                    [, distance]          -- float (meters)     -- 3            -- 0.5 to 50
+--                    [, focus_threshold]   -- float (meters)     -- 1            -- 0 to 4
+--                    [, camera_threshold]  -- float (meters)     -- 1            -- 0 to 4
+--                    [, focus_lag]         -- float (seconds)    -- 0.1          -- 0 to 3
+--                    [, camera_lag]        -- float (seconds)    -- 0.1          -- 0 to 3
+--                    [, camera_pitch]      -- float (degrees)    -- 0            -- -45 to 80
+--                    [, behindness_angle]  -- float (degrees)    -- 10           -- 0 to 180
+--                    [, behindness_lag]    -- float (seconds)    -- 0            -- 0 to 3
+--                    [, camera_locked]     -- bool               -- false
+--                    [, focus_locked]}     -- bool               -- false
 function LLAgent.setCamera(...)
-    local args = mapargs('camera_pos,focus_pos,focus_offset,camera_locked,focus_locked', ...)
+    local args = mapargs('camera_pos,focus_pos,focus_offset,focus_lag,camera_lag,' ..
+                         'distance,focus_threshold,camera_threshold,camera_pitch,' ..
+                         'camera_locked,focus_locked,behindness_angle,behindness_lag', ...)
     args.op = 'setCameraParams'
     leap.send('LLAgent', args)
 end
-- 
cgit v1.2.3


From ffeb738afda99fca98a9c1ba7704d7f6144da70c Mon Sep 17 00:00:00 2001
From: nat-goodspeed <nat@lindenlab.com>
Date: Wed, 31 Jul 2024 06:30:19 -0400
Subject: Represent the many "LLAgent" "setCameraParams" args in an array.

This encapsulates the boilerplate associated with passing each distinct
parameter to its corresponding LLFollowCamMgr method.
---
 indra/newview/scripts/lua/test_camera_control.lua | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'indra/newview/scripts')

diff --git a/indra/newview/scripts/lua/test_camera_control.lua b/indra/newview/scripts/lua/test_camera_control.lua
index e7ad69b473..9b35cdf8cd 100644
--- a/indra/newview/scripts/lua/test_camera_control.lua
+++ b/indra/newview/scripts/lua/test_camera_control.lua
@@ -45,5 +45,5 @@ function flt:commit_reset_btn(event_data)
     LLAgent.setFollowCamActive(false)
 end
 
-startup.wait('STATE_LOGIN_WAIT')
+startup.wait('STATE_STARTED')
 flt:show()
-- 
cgit v1.2.3


From fdb7207aa0d1f25ed3e14fbc4e8615e8383e508c Mon Sep 17 00:00:00 2001
From: Nat Goodspeed <nat@lindenlab.com>
Date: Thu, 1 Aug 2024 16:52:44 -0400
Subject: Add UI.callables() and corresponding entry point.

---
 indra/newview/scripts/lua/require/UI.lua     | 6 ++++++
 indra/newview/scripts/lua/test_callables.lua | 6 ++++++
 2 files changed, 12 insertions(+)
 create mode 100644 indra/newview/scripts/lua/test_callables.lua

(limited to 'indra/newview/scripts')

diff --git a/indra/newview/scripts/lua/require/UI.lua b/indra/newview/scripts/lua/require/UI.lua
index 28488ff3e1..06b49c6269 100644
--- a/indra/newview/scripts/lua/require/UI.lua
+++ b/indra/newview/scripts/lua/require/UI.lua
@@ -14,6 +14,10 @@ function UI.call(func, parameter)
     leap.request('UI', {op='call', ['function']=func, parameter=parameter})
 end
 
+function UI.callables()
+    return leap.request('UI', {op='callables'}).callables
+end
+
 function UI.getValue(path)
     return leap.request('UI', {op='getValue', path=path})['value']
 end
@@ -152,6 +156,7 @@ function UI.addMenuBranch(...)
     return leap.request('UI', args)
 end
 
+-- see UI.callables() for valid values of 'func'
 function UI.addMenuItem(...)
     local args = mapargs('name,label,parent_menu,func,param', ...)
     args.op = 'addMenuItem'
@@ -163,4 +168,5 @@ function UI.addMenuSeparator(...)
     args.op = 'addMenuSeparator'
     return leap.request('UI', args)
 end
+
 return UI
diff --git a/indra/newview/scripts/lua/test_callables.lua b/indra/newview/scripts/lua/test_callables.lua
new file mode 100644
index 0000000000..1bee062db8
--- /dev/null
+++ b/indra/newview/scripts/lua/test_callables.lua
@@ -0,0 +1,6 @@
+startup=require 'startup'
+UI=require 'UI'
+startup.wait('STATE_LOGIN_WAIT')
+for _, cbl in pairs(UI.callables()) do
+    print(`{cbl.name} ({cbl.access})`)
+end
-- 
cgit v1.2.3


From 99307b619a5aa27bef3bb67027c4cb5e54f21ad4 Mon Sep 17 00:00:00 2001
From: Mnikolenko Productengine <mnikolenko@productengine.com>
Date: Fri, 2 Aug 2024 19:46:52 +0300
Subject: Lua api for adjusting toolbars

---
 indra/newview/scripts/lua/require/UI.lua | 30 ++++++++++++++++++++++++++++++
 1 file changed, 30 insertions(+)

(limited to 'indra/newview/scripts')

diff --git a/indra/newview/scripts/lua/require/UI.lua b/indra/newview/scripts/lua/require/UI.lua
index 06b49c6269..30b7189c3c 100644
--- a/indra/newview/scripts/lua/require/UI.lua
+++ b/indra/newview/scripts/lua/require/UI.lua
@@ -169,4 +169,34 @@ function UI.addMenuSeparator(...)
     return leap.request('UI', args)
 end
 
+-- ***************************************************************************
+--  Toolbar buttons
+-- ***************************************************************************
+-- Clears all buttons off the toolbars
+function UI.clearToolbars()
+    leap.send('UI', {op='clearToolbars'})
+end
+
+function UI.defaultToolbars()
+    leap.send('UI', {op='defaultToolbars'})
+end
+
+-- UI.addToolbarBtn{btn_name=btn_name
+--          [, toolbar= 3] -- 1 [TOOLBAR_LEFT], 2 [TOOLBAR_RIGHT], 3 [TOOLBAR_BOTTOM]
+--          [, rank=1]} -- position on the toolbar
+function UI.addToolbarBtn(...)
+    local args = mapargs('btn_name,toolbar,rank', ...)
+    args.op = 'addToolbarBtn'
+    return leap.request('UI', args)
+end
+
+-- Returns the rank(position) of the command in the original list
+function UI.removeToolbarBtn(btn_name)
+    return leap.request('UI', {op = 'removeToolbarBtn', btn_name=btn_name}).rank
+end
+
+function UI.getToolbarBtnNames()
+    return leap.request('UI', {op = 'getToolbarBtnNames'}).cmd_names
+end
+
 return UI
-- 
cgit v1.2.3


From a67a01240cbd58a1800290294be83e7b874fefb6 Mon Sep 17 00:00:00 2001
From: Mnikolenko Productengine <mnikolenko@productengine.com>
Date: Fri, 2 Aug 2024 20:19:53 +0300
Subject: Lua api for showing/hiding floater; rename demo scripts

---
 indra/newview/scripts/lua/require/UI.lua           | 23 +++++++++++++
 indra/newview/scripts/lua/test_luafloater_demo.lua | 39 ++++++++++++++++++++++
 .../newview/scripts/lua/test_luafloater_demo2.lua  | 39 ----------------------
 .../scripts/lua/test_luafloater_gesture_list.lua   | 27 +++++++++++++++
 .../scripts/lua/test_luafloater_gesture_list2.lua  | 27 ---------------
 5 files changed, 89 insertions(+), 66 deletions(-)
 create mode 100644 indra/newview/scripts/lua/test_luafloater_demo.lua
 delete mode 100644 indra/newview/scripts/lua/test_luafloater_demo2.lua
 create mode 100644 indra/newview/scripts/lua/test_luafloater_gesture_list.lua
 delete mode 100644 indra/newview/scripts/lua/test_luafloater_gesture_list2.lua

(limited to 'indra/newview/scripts')

diff --git a/indra/newview/scripts/lua/require/UI.lua b/indra/newview/scripts/lua/require/UI.lua
index 30b7189c3c..df77eb2b56 100644
--- a/indra/newview/scripts/lua/require/UI.lua
+++ b/indra/newview/scripts/lua/require/UI.lua
@@ -199,4 +199,27 @@ function UI.getToolbarBtnNames()
     return leap.request('UI', {op = 'getToolbarBtnNames'}).cmd_names
 end
 
+-- ***************************************************************************
+--  Floaters
+-- ***************************************************************************
+function UI.showFloater(floater_name)
+    leap.send("LLFloaterReg", {op = "showInstance", name = floater_name})
+end
+
+function UI.hideFloater(floater_name)
+    leap.send("LLFloaterReg", {op = "hideInstance", name = floater_name})
+end
+
+function UI.toggleFloater(floater_name)
+    leap.send("LLFloaterReg", {op = "toggleInstance", name = floater_name})
+end
+
+function UI.isFloaterVisible(floater_name)
+    return leap.request("LLFloaterReg", {op = "instanceVisible", name = floater_name}).visible
+end
+
+function UI.closeAllFloaters()
+    return leap.send("UI", {op = "closeAllFloaters"})
+end
+
 return UI
diff --git a/indra/newview/scripts/lua/test_luafloater_demo.lua b/indra/newview/scripts/lua/test_luafloater_demo.lua
new file mode 100644
index 0000000000..3903d01e65
--- /dev/null
+++ b/indra/newview/scripts/lua/test_luafloater_demo.lua
@@ -0,0 +1,39 @@
+local Floater = require 'Floater'
+local leap = require 'leap'
+local startup = require 'startup'
+
+local flt = Floater(
+    'luafloater_demo.xml',
+    {show_time_lbl = {"right_mouse_down", "double_click"}})
+
+-- override base-class handleEvents() to report the event data in the floater's display field
+function flt:handleEvents(event_data)
+    self:post({action="add_text", ctrl_name="events_editor", value = event_data})
+    -- forward the call to base-class handleEvents()
+    return Floater.handleEvents(self, event_data)
+end
+
+function flt:commit_disable_ctrl(event_data)
+    self:post({action="set_enabled", ctrl_name="open_btn", value = (1 - event_data.value)})
+end
+
+function flt:commit_title_cmb(event_data)
+    self:post({action="set_title", value=event_data.value})
+end
+
+function flt:commit_open_btn(event_data)
+    floater_name = self:request({action="get_value", ctrl_name='openfloater_cmd'}).value
+    leap.send("LLFloaterReg", {name = floater_name, op = "showInstance"})
+end
+
+local function getCurrentTime()
+    local currentTime = os.date("*t")
+    return string.format("%02d:%02d:%02d", currentTime.hour, currentTime.min, currentTime.sec)
+end
+
+function flt:double_click_show_time_lbl(event_data)
+    self:post({action="set_value", ctrl_name="time_lbl", value=getCurrentTime()})
+end
+
+startup.wait('STATE_LOGIN_WAIT')
+flt:show()
diff --git a/indra/newview/scripts/lua/test_luafloater_demo2.lua b/indra/newview/scripts/lua/test_luafloater_demo2.lua
deleted file mode 100644
index 3903d01e65..0000000000
--- a/indra/newview/scripts/lua/test_luafloater_demo2.lua
+++ /dev/null
@@ -1,39 +0,0 @@
-local Floater = require 'Floater'
-local leap = require 'leap'
-local startup = require 'startup'
-
-local flt = Floater(
-    'luafloater_demo.xml',
-    {show_time_lbl = {"right_mouse_down", "double_click"}})
-
--- override base-class handleEvents() to report the event data in the floater's display field
-function flt:handleEvents(event_data)
-    self:post({action="add_text", ctrl_name="events_editor", value = event_data})
-    -- forward the call to base-class handleEvents()
-    return Floater.handleEvents(self, event_data)
-end
-
-function flt:commit_disable_ctrl(event_data)
-    self:post({action="set_enabled", ctrl_name="open_btn", value = (1 - event_data.value)})
-end
-
-function flt:commit_title_cmb(event_data)
-    self:post({action="set_title", value=event_data.value})
-end
-
-function flt:commit_open_btn(event_data)
-    floater_name = self:request({action="get_value", ctrl_name='openfloater_cmd'}).value
-    leap.send("LLFloaterReg", {name = floater_name, op = "showInstance"})
-end
-
-local function getCurrentTime()
-    local currentTime = os.date("*t")
-    return string.format("%02d:%02d:%02d", currentTime.hour, currentTime.min, currentTime.sec)
-end
-
-function flt:double_click_show_time_lbl(event_data)
-    self:post({action="set_value", ctrl_name="time_lbl", value=getCurrentTime()})
-end
-
-startup.wait('STATE_LOGIN_WAIT')
-flt:show()
diff --git a/indra/newview/scripts/lua/test_luafloater_gesture_list.lua b/indra/newview/scripts/lua/test_luafloater_gesture_list.lua
new file mode 100644
index 0000000000..bd397ef2a6
--- /dev/null
+++ b/indra/newview/scripts/lua/test_luafloater_gesture_list.lua
@@ -0,0 +1,27 @@
+local Floater = require 'Floater'
+local LLGesture = require 'LLGesture'
+local startup = require 'startup'
+
+local flt = Floater(
+    "luafloater_gesture_list.xml",
+    {gesture_list = {"double_click"}})
+
+function flt:post_build(event_data)
+    local gestures_uuid = LLGesture.getActiveGestures()
+    local action_data = {}
+    action_data.action = "add_list_element"
+    action_data.ctrl_name = "gesture_list"
+    local gestures = {}
+    for uuid, info in pairs(gestures_uuid) do
+      table.insert(gestures, {value = uuid, columns={column = "gesture_name", value = info.name}})
+    end
+    action_data.value = gestures
+    self:post(action_data)
+end
+
+function flt:double_click_gesture_list(event_data)
+    LLGesture.startGesture(event_data.value)
+end
+
+startup.wait('STATE_STARTED')
+flt:show()
diff --git a/indra/newview/scripts/lua/test_luafloater_gesture_list2.lua b/indra/newview/scripts/lua/test_luafloater_gesture_list2.lua
deleted file mode 100644
index bd397ef2a6..0000000000
--- a/indra/newview/scripts/lua/test_luafloater_gesture_list2.lua
+++ /dev/null
@@ -1,27 +0,0 @@
-local Floater = require 'Floater'
-local LLGesture = require 'LLGesture'
-local startup = require 'startup'
-
-local flt = Floater(
-    "luafloater_gesture_list.xml",
-    {gesture_list = {"double_click"}})
-
-function flt:post_build(event_data)
-    local gestures_uuid = LLGesture.getActiveGestures()
-    local action_data = {}
-    action_data.action = "add_list_element"
-    action_data.ctrl_name = "gesture_list"
-    local gestures = {}
-    for uuid, info in pairs(gestures_uuid) do
-      table.insert(gestures, {value = uuid, columns={column = "gesture_name", value = info.name}})
-    end
-    action_data.value = gestures
-    self:post(action_data)
-end
-
-function flt:double_click_gesture_list(event_data)
-    LLGesture.startGesture(event_data.value)
-end
-
-startup.wait('STATE_STARTED')
-flt:show()
-- 
cgit v1.2.3


From af947de6928daa70098edb8346effb9dc8146f47 Mon Sep 17 00:00:00 2001
From: Nat Goodspeed <nat@lindenlab.com>
Date: Fri, 2 Aug 2024 19:24:07 -0400
Subject: Add 'LLPanelLogin' 'login', 'savedLogins' operations.

'login' accepts optional 'username', 'slurl', 'grid'.

'savedLogins' returns the list of saved usernames in both display form and
internal form.

Make LLPanelLogin::getUserName() accept (const LLPointer<LLCredential>&).
There's a whole separate discussion pending as to whether const LLPointer<T>
should provide access to non-const T methods.

Similarly, make LLCredential::getIdentifier() a const method. These two
changes enable read-only access to credentials.

Make LLPanelLogin methods capture and reuse LLGridManager::instance() as
appropriate.

Add require/login.lua and test_login.lua.
---
 indra/newview/scripts/lua/require/login.lua | 21 +++++++--------------
 indra/newview/scripts/lua/test_login.lua    | 10 +++++-----
 2 files changed, 12 insertions(+), 19 deletions(-)

(limited to 'indra/newview/scripts')

diff --git a/indra/newview/scripts/lua/require/login.lua b/indra/newview/scripts/lua/require/login.lua
index 0d8591cace..f4e65b1606 100644
--- a/indra/newview/scripts/lua/require/login.lua
+++ b/indra/newview/scripts/lua/require/login.lua
@@ -1,19 +1,12 @@
-local UI = require 'UI'
 local leap = require 'leap'
+local startup = require 'startup'
+local mapargs = require 'mapargs'
 
-local function login(username, password)
-    if username and password then
-        local userpath = '//username_combo/Combo Text Entry'
-        local passpath = '//password_edit'
-        -- first clear anything presently in those text fields
-        for _, path in pairs({userpath, passpath}) do
-            UI.click(path)
-            UI.keypress{keysym='Backsp', path=path}
-        end
-        UI.type{path=userpath, text=username}
-        UI.type{path=passpath, text=password}
-    end
-    leap.send('LLPanelLogin', {op='onClickConnect'})
+local function login(...)
+    startup.wait('STATE_LOGIN_WAIT')
+    local args = mapargs('username,grid,slurl', ...)
+    args.op = 'login'
+    return leap.request('LLPanelLogin', args)
 end
 
 return login
diff --git a/indra/newview/scripts/lua/test_login.lua b/indra/newview/scripts/lua/test_login.lua
index a8c31807bc..f263940f79 100644
--- a/indra/newview/scripts/lua/test_login.lua
+++ b/indra/newview/scripts/lua/test_login.lua
@@ -1,7 +1,7 @@
-startup = require 'startup'
+inspect = require 'inspect'
 login = require 'login'
 
-startup.wait('STATE_LOGIN_WAIT')
-login()
--- Fill in valid credentials as they would be entered on the login screen
--- login('My Username', 'password')
+print(inspect(login{
+    username='Nat Linden',
+--    grid='agni'
+    }))
-- 
cgit v1.2.3


From b12d135c38e327774c01594acfa96e37a9e67a64 Mon Sep 17 00:00:00 2001
From: Nat Goodspeed <nat@lindenlab.com>
Date: Mon, 5 Aug 2024 11:24:01 -0400
Subject: Fix a couple problems with "LLPanelLogin" listener (thanks Maxim!).

Convert plain grid (e.g. "agni") to domain form (e.g. "util.agni.lindenlab.com").

Fix a typo in `savedLogins()`: "login_list", not "login.list".

login.lua now returns a table with two functions: `login.login()` and
`login.savedLogins()`.

Defend Lua caller against trying to engage login features too late in startup
sequence: in addition to waiting for "STATE_LOGIN_WAIT", produce an error if
`startup.state()` is beyond that state. Since by then `LLPanelLogin` is
destroyed, `leap.request("LLPanelLogin", ...)` would get no response, causing
the calling Lua script to hang until viewer shutdown.
---
 indra/newview/scripts/lua/require/login.lua | 23 ++++++++++++++++++++++-
 indra/newview/scripts/lua/test_login.lua    |  9 ++++++---
 2 files changed, 28 insertions(+), 4 deletions(-)

(limited to 'indra/newview/scripts')

diff --git a/indra/newview/scripts/lua/require/login.lua b/indra/newview/scripts/lua/require/login.lua
index f4e65b1606..50fc9e3793 100644
--- a/indra/newview/scripts/lua/require/login.lua
+++ b/indra/newview/scripts/lua/require/login.lua
@@ -2,11 +2,32 @@ local leap = require 'leap'
 local startup = require 'startup'
 local mapargs = require 'mapargs'
 
-local function login(...)
+local login = {}
+
+local function ensure_login_state(op)
+    -- no point trying to login until the viewer is ready
     startup.wait('STATE_LOGIN_WAIT')
+    -- Once we've actually started login, LLPanelLogin is destroyed, and so is
+    -- its "LLPanelLogin" listener. At that point,
+    -- leap.request("LLPanelLogin", ...) will hang indefinitely because no one
+    -- is listening on that LLEventPump any more. Intercept that case and
+    -- produce a sensible error.
+    local state = startup.state()
+    if startup.before('STATE_LOGIN_WAIT', state) then
+        error(`Can't engage login operation {op} once we've reached state {state}`, 2)
+    end
+end
+
+function login.login(...)
+    ensure_login_state('login')
     local args = mapargs('username,grid,slurl', ...)
     args.op = 'login'
     return leap.request('LLPanelLogin', args)
 end
 
+function login.savedLogins(grid)
+    ensure_login_state('savedLogins')
+    return leap.request('LLPanelLogin', {op='savedLogins'})['logins']
+end
+
 return login
diff --git a/indra/newview/scripts/lua/test_login.lua b/indra/newview/scripts/lua/test_login.lua
index f263940f79..54d3635a41 100644
--- a/indra/newview/scripts/lua/test_login.lua
+++ b/indra/newview/scripts/lua/test_login.lua
@@ -1,7 +1,10 @@
 inspect = require 'inspect'
 login = require 'login'
 
-print(inspect(login{
-    username='Nat Linden',
---    grid='agni'
+local grid = 'agni'
+print(inspect(login.savedLogins(grid)))
+
+print(inspect(login.login{
+    username='Your Username',
+    grid=grid
     }))
-- 
cgit v1.2.3


From cf29b701b19644062a1428a64023c3cf9829e2de Mon Sep 17 00:00:00 2001
From: Mnikolenko Productengine <mnikolenko@productengine.com>
Date: Mon, 5 Aug 2024 20:37:03 +0300
Subject: Allow getting the list of floater names, hide top menu items; add
 demo script

---
 indra/newview/scripts/lua/require/UI.lua          |  8 +++++++
 indra/newview/scripts/lua/test_LLChatListener.lua | 19 ++++++++++++----
 indra/newview/scripts/lua/test_toolbars.lua       | 27 +++++++++++++++++++++++
 3 files changed, 50 insertions(+), 4 deletions(-)
 create mode 100644 indra/newview/scripts/lua/test_toolbars.lua

(limited to 'indra/newview/scripts')

diff --git a/indra/newview/scripts/lua/require/UI.lua b/indra/newview/scripts/lua/require/UI.lua
index df77eb2b56..df76b1501c 100644
--- a/indra/newview/scripts/lua/require/UI.lua
+++ b/indra/newview/scripts/lua/require/UI.lua
@@ -150,6 +150,10 @@ function UI.addMenu(...)
     return leap.request('UI', args)
 end
 
+function UI.setMenuVisible(name, visible)
+    return leap.request('UI', {op='setMenuVisible', name=name, visible=visible})
+end
+
 function UI.addMenuBranch(...)
     local args = mapargs('name,label,parent_menu', ...)
     args.op = 'addMenuBranch'
@@ -222,4 +226,8 @@ function UI.closeAllFloaters()
     return leap.send("UI", {op = "closeAllFloaters"})
 end
 
+function UI.getFloaterNames()
+    return leap.request("LLFloaterReg", {op = "getFloaterNames"}).floaters
+end
+
 return UI
diff --git a/indra/newview/scripts/lua/test_LLChatListener.lua b/indra/newview/scripts/lua/test_LLChatListener.lua
index 18363ed43b..4a4d40bee5 100644
--- a/indra/newview/scripts/lua/test_LLChatListener.lua
+++ b/indra/newview/scripts/lua/test_LLChatListener.lua
@@ -1,11 +1,22 @@
 local LLChatListener = require 'LLChatListener'
 local LLChat = require 'LLChat'
-local leap = require 'leap'
+local UI = require 'UI'
 
+-- Chat listener script allows to use the following commands in Nearby chat:
+-- open inventory   -- open defined floater by name
+-- close inventory  -- close defined floater by name
+-- closeall         -- close all floaters
+-- stop             -- close the script
+-- any other messages will be echoed.
 function openOrEcho(message)
-    local floater_name = string.match(message, "^open%s+(%w+)")
-    if floater_name then
-      leap.send("LLFloaterReg", {name = floater_name, op = "showInstance"})
+    local open_floater_name = string.match(message, "^open%s+(%w+)")
+    local close_floater_name = string.match(message, "^close%s+(%w+)")
+    if open_floater_name then
+      UI.showFloater(open_floater_name)
+    elseif close_floater_name then
+      UI.hideFloater(close_floater_name)
+    elseif message == 'closeall' then
+      UI.closeAllFloaters()
     else
       LLChat.sendNearby('Echo: ' .. message)
     end
diff --git a/indra/newview/scripts/lua/test_toolbars.lua b/indra/newview/scripts/lua/test_toolbars.lua
new file mode 100644
index 0000000000..70035db775
--- /dev/null
+++ b/indra/newview/scripts/lua/test_toolbars.lua
@@ -0,0 +1,27 @@
+popup = require 'popup'
+UI = require 'UI'
+
+local OK = 'OK_okcancelbuttons'
+local BUTTONS = UI.getToolbarBtnNames()
+
+-- Clear the toolbars and then add the toolbar buttons to the random toolbar
+response = popup:alertYesCancel('Toolbars will be randomly reshuffled. Proceed?')
+if next(response) == OK then
+    UI.clearToolbars()
+    math.randomseed(os.time())
+
+    -- add the buttons to the random toolbar
+    for i = 1, #BUTTONS do
+      UI.addToolbarBtn(BUTTONS[i], math.random(3))
+    end
+
+    -- remove some of the added buttons from the toolbars
+    for i = 1, #BUTTONS do
+      if math.random(100) < 30 then
+        UI.removeToolbarBtn(BUTTONS[i])
+      end
+    end
+    popup:tip('Toolbars were reshuffled')
+else
+    popup:tip('Canceled')
+end
-- 
cgit v1.2.3


From eb82c78b071d71a0fd2d7be1c573997e41bab51e Mon Sep 17 00:00:00 2001
From: Mnikolenko Productengine <mnikolenko@productengine.com>
Date: Tue, 6 Aug 2024 20:38:06 +0300
Subject: code clean up

---
 indra/newview/scripts/lua/require/UI.lua    | 8 ++++----
 indra/newview/scripts/lua/test_toolbars.lua | 5 +++--
 2 files changed, 7 insertions(+), 6 deletions(-)

(limited to 'indra/newview/scripts')

diff --git a/indra/newview/scripts/lua/require/UI.lua b/indra/newview/scripts/lua/require/UI.lua
index df76b1501c..9bc9a3685d 100644
--- a/indra/newview/scripts/lua/require/UI.lua
+++ b/indra/newview/scripts/lua/require/UI.lua
@@ -177,8 +177,8 @@ end
 --  Toolbar buttons
 -- ***************************************************************************
 -- Clears all buttons off the toolbars
-function UI.clearToolbars()
-    leap.send('UI', {op='clearToolbars'})
+function UI.clearAllToolbars()
+    leap.send('UI', {op='clearAllToolbars'})
 end
 
 function UI.defaultToolbars()
@@ -186,8 +186,8 @@ function UI.defaultToolbars()
 end
 
 -- UI.addToolbarBtn{btn_name=btn_name
---          [, toolbar= 3] -- 1 [TOOLBAR_LEFT], 2 [TOOLBAR_RIGHT], 3 [TOOLBAR_BOTTOM]
---          [, rank=1]} -- position on the toolbar
+--          [, toolbar= bottom] -- left, right, bottom -- default is bottom
+--          [, rank=1]} -- position on the toolbar, starts at 0 (0 - first position, 1 - second position etc.)
 function UI.addToolbarBtn(...)
     local args = mapargs('btn_name,toolbar,rank', ...)
     args.op = 'addToolbarBtn'
diff --git a/indra/newview/scripts/lua/test_toolbars.lua b/indra/newview/scripts/lua/test_toolbars.lua
index 70035db775..9a832c5644 100644
--- a/indra/newview/scripts/lua/test_toolbars.lua
+++ b/indra/newview/scripts/lua/test_toolbars.lua
@@ -3,16 +3,17 @@ UI = require 'UI'
 
 local OK = 'OK_okcancelbuttons'
 local BUTTONS = UI.getToolbarBtnNames()
+local TOOLBARS = {'left','right','bottom'}
 
 -- Clear the toolbars and then add the toolbar buttons to the random toolbar
 response = popup:alertYesCancel('Toolbars will be randomly reshuffled. Proceed?')
 if next(response) == OK then
-    UI.clearToolbars()
+    UI.clearAllToolbars()
     math.randomseed(os.time())
 
     -- add the buttons to the random toolbar
     for i = 1, #BUTTONS do
-      UI.addToolbarBtn(BUTTONS[i], math.random(3))
+      UI.addToolbarBtn(BUTTONS[i], TOOLBARS[math.random(3)])
     end
 
     -- remove some of the added buttons from the toolbars
-- 
cgit v1.2.3


From 5fde031b876e3b8ce794286e5796ffb8f0614cd3 Mon Sep 17 00:00:00 2001
From: Nat Goodspeed <nat@lindenlab.com>
Date: Wed, 7 Aug 2024 10:39:30 -0400
Subject: Rename 'UI' 'getParents' op to 'getTopMenus', add UI.lua function.

Also update the 'UI' help text to reflect its more general nature.

Mention 0-relative rank in the xxToolbarBtn operation help text.
---
 indra/newview/scripts/lua/require/UI.lua | 4 ++++
 1 file changed, 4 insertions(+)

(limited to 'indra/newview/scripts')

diff --git a/indra/newview/scripts/lua/require/UI.lua b/indra/newview/scripts/lua/require/UI.lua
index 9bc9a3685d..464e6547ea 100644
--- a/indra/newview/scripts/lua/require/UI.lua
+++ b/indra/newview/scripts/lua/require/UI.lua
@@ -144,6 +144,10 @@ end
 --  Top menu
 -- ***************************************************************************
 
+function UI.getTopMenus()
+    return leap.request('UI', {op='getTopMenus'}).menus
+end
+
 function UI.addMenu(...)
     local args = mapargs('name,label', ...)
     args.op = 'addMenu'
-- 
cgit v1.2.3


From 2df6ee631507bd3c9bff783d57b96d4546405a8a Mon Sep 17 00:00:00 2001
From: Nat Goodspeed <nat@lindenlab.com>
Date: Wed, 7 Aug 2024 12:51:47 -0400
Subject: Fix omission in login.savedLogins().

Also add Region.lua.
---
 indra/newview/scripts/lua/require/Region.lua | 17 +++++++++++++++++
 indra/newview/scripts/lua/require/login.lua  |  2 +-
 2 files changed, 18 insertions(+), 1 deletion(-)
 create mode 100644 indra/newview/scripts/lua/require/Region.lua

(limited to 'indra/newview/scripts')

diff --git a/indra/newview/scripts/lua/require/Region.lua b/indra/newview/scripts/lua/require/Region.lua
new file mode 100644
index 0000000000..e4eefece33
--- /dev/null
+++ b/indra/newview/scripts/lua/require/Region.lua
@@ -0,0 +1,17 @@
+LLFloaterAbout = require 'LLFloaterAbout'
+
+local Region = {}
+
+function Region.getInfo()
+    info = LLFloaterAbout.getInfo()
+    return {
+        HOSTNAME=info.HOSTNAME,
+        POSITION=info.POSITION,
+        POSITION_LOCAL=info.POSITION_LOCAL,
+        REGION=info.REGION,
+        SERVER_VERSION=info.SERVER_VERSION,
+        SLURL=info.SLURL,
+    }
+end
+
+return Region
diff --git a/indra/newview/scripts/lua/require/login.lua b/indra/newview/scripts/lua/require/login.lua
index 50fc9e3793..919434f3a5 100644
--- a/indra/newview/scripts/lua/require/login.lua
+++ b/indra/newview/scripts/lua/require/login.lua
@@ -27,7 +27,7 @@ end
 
 function login.savedLogins(grid)
     ensure_login_state('savedLogins')
-    return leap.request('LLPanelLogin', {op='savedLogins'})['logins']
+    return leap.request('LLPanelLogin', {op='savedLogins', grid=grid})['logins']
 end
 
 return login
-- 
cgit v1.2.3


From 3102dc0db472acac7c4007e7423e405a889d665a Mon Sep 17 00:00:00 2001
From: Nat Goodspeed <nat@lindenlab.com>
Date: Wed, 7 Aug 2024 16:12:23 -0400
Subject: Allow smaller minimum timer intervals.

Add test_flycam.lua to exercise the smaller intervals.
---
 indra/newview/scripts/lua/test_flycam.lua | 38 +++++++++++++++++++++++++++++++
 1 file changed, 38 insertions(+)
 create mode 100644 indra/newview/scripts/lua/test_flycam.lua

(limited to 'indra/newview/scripts')

diff --git a/indra/newview/scripts/lua/test_flycam.lua b/indra/newview/scripts/lua/test_flycam.lua
new file mode 100644
index 0000000000..4fb5608b33
--- /dev/null
+++ b/indra/newview/scripts/lua/test_flycam.lua
@@ -0,0 +1,38 @@
+-- Make camera fly around the subject avatar for a few seconds.
+
+local LLAgent = require 'LLAgent'
+local startup = require 'startup'
+local timers = require 'timers'
+
+local initial = LLAgent.getRegionPosition()
+local height = 2.0 -- meters
+local radius = 4.0 -- meters
+local speed = 1.0 -- meters/second along circle
+local start = os.clock()
+local stop  = os.clock() + 30 -- seconds
+
+local function cameraPos(t)
+    local radians = speed * t
+    return {
+        initial[1] + radius * math.cos(radians),
+        initial[2] + radius * math.sin(radians),
+        initial[3] + height
+    }
+end
+
+local function moveCamera()
+    if os.clock() < stop then
+        -- usual case
+        LLAgent.setCamera{ camera_pos=cameraPos(os.clock() - start), camera_locked=true }
+        return nil
+    else
+        -- last time
+        LLAgent.removeCamParams()
+        LLAgent.setFollowCamActive(false)
+        return true
+    end
+end
+
+startup.wait('STATE_STARTED')
+-- call moveCamera() repeatedly until it returns true
+local timer = timers.Timer(0.1, moveCamera, true)
-- 
cgit v1.2.3


From b4fe47a5c0abac02d161640e04a9a78afb1c5987 Mon Sep 17 00:00:00 2001
From: Nat Goodspeed <nat@lindenlab.com>
Date: Thu, 8 Aug 2024 09:07:56 -0400
Subject: Ensure that the flycam stays near moving avatar.

---
 indra/newview/scripts/lua/test_flycam.lua | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

(limited to 'indra/newview/scripts')

diff --git a/indra/newview/scripts/lua/test_flycam.lua b/indra/newview/scripts/lua/test_flycam.lua
index 4fb5608b33..05c3c37b93 100644
--- a/indra/newview/scripts/lua/test_flycam.lua
+++ b/indra/newview/scripts/lua/test_flycam.lua
@@ -4,7 +4,6 @@ local LLAgent = require 'LLAgent'
 local startup = require 'startup'
 local timers = require 'timers'
 
-local initial = LLAgent.getRegionPosition()
 local height = 2.0 -- meters
 local radius = 4.0 -- meters
 local speed = 1.0 -- meters/second along circle
@@ -12,11 +11,12 @@ local start = os.clock()
 local stop  = os.clock() + 30 -- seconds
 
 local function cameraPos(t)
+    local agent = LLAgent.getRegionPosition()
     local radians = speed * t
     return {
-        initial[1] + radius * math.cos(radians),
-        initial[2] + radius * math.sin(radians),
-        initial[3] + height
+        agent[1] + radius * math.cos(radians),
+        agent[2] + radius * math.sin(radians),
+        agent[3] + height
     }
 end
 
-- 
cgit v1.2.3


From 087cbe553e5bac6fe702200c33acc42baf4eef4f Mon Sep 17 00:00:00 2001
From: Mnikolenko Productengine <mnikolenko@productengine.com>
Date: Fri, 9 Aug 2024 15:00:04 +0300
Subject: Lua api for sending group messages

---
 indra/newview/scripts/lua/require/LLChat.lua | 25 +++++++++++++++++++++++++
 1 file changed, 25 insertions(+)

(limited to 'indra/newview/scripts')

diff --git a/indra/newview/scripts/lua/require/LLChat.lua b/indra/newview/scripts/lua/require/LLChat.lua
index 78dca765e8..ea6329d574 100644
--- a/indra/newview/scripts/lua/require/LLChat.lua
+++ b/indra/newview/scripts/lua/require/LLChat.lua
@@ -2,6 +2,10 @@ local leap = require 'leap'
 
 local LLChat = {}
 
+-- ***************************************************************************
+--  Nearby chat
+-- ***************************************************************************
+
 function LLChat.sendNearby(msg)
     leap.send('LLChatBar', {op='sendChat', message=msg})
 end
@@ -14,4 +18,25 @@ function LLChat.sendShout(msg)
     leap.send('LLChatBar', {op='sendChat', type='shout', message=msg})
 end
 
+-- 0 is public nearby channel, other channels are used to communicate with LSL scripts
+function LLChat.sendChannel(msg, channel)
+    leap.send('LLChatBar', {op='sendChat', channel=channel, message=msg})
+end
+
+-- ***************************************************************************
+--  Group chat
+-- ***************************************************************************
+
+function LLChat.startGroupChat(group_id)
+    return leap.request('GroupChat', {op='startGroupChat', group_id=group_id})
+end
+
+function LLChat.leaveGroupChat(group_id)
+    leap.send('GroupChat', {op='leaveGroupChat', group_id=group_id})
+end
+
+function LLChat.sendGroupIM(msg, group_id)
+    leap.send('GroupChat', {op='sendGroupIM', message=msg, group_id=group_id})
+end
+
 return LLChat
-- 
cgit v1.2.3


From 926a32aa0a9518fe7f19d0c63b30b12a66469f2d Mon Sep 17 00:00:00 2001
From: Mnikolenko Productengine <mnikolenko@productengine.com>
Date: Fri, 9 Aug 2024 18:24:25 +0300
Subject: add demo script for sending group chat messages

---
 indra/newview/scripts/lua/require/LLAgent.lua | 11 +++++++++++
 indra/newview/scripts/lua/test_group_chat.lua | 16 ++++++++++++++++
 2 files changed, 27 insertions(+)
 create mode 100644 indra/newview/scripts/lua/test_group_chat.lua

(limited to 'indra/newview/scripts')

diff --git a/indra/newview/scripts/lua/require/LLAgent.lua b/indra/newview/scripts/lua/require/LLAgent.lua
index bc9a6b23a0..5ee092f2f6 100644
--- a/indra/newview/scripts/lua/require/LLAgent.lua
+++ b/indra/newview/scripts/lua/require/LLAgent.lua
@@ -11,6 +11,17 @@ function LLAgent.getGlobalPosition()
     return leap.request('LLAgent', {op = 'getPosition'}).global
 end
 
+-- Return array information about the agent's groups
+-- id: group id\n"
+-- name: group name\n"
+-- insignia: group insignia texture id
+-- notices: bool indicating if this user accepts notices from this group
+-- display: bool indicating if this group is listed in the user's profile
+-- contrib: user's land contribution to this group
+function LLAgent.getGroups()
+    return leap.request('LLAgent', {op = 'getGroups'}).groups
+end
+
 -- Use LL.leaphelp('LLAgent') and see 'setCameraParams' to get more info about params
 --                                          -- TYPE               -- DEFAULT      -- RANGE
 -- LLAgent.setCamera{ [, camera_pos]        -- vector3
diff --git a/indra/newview/scripts/lua/test_group_chat.lua b/indra/newview/scripts/lua/test_group_chat.lua
new file mode 100644
index 0000000000..6299ba535f
--- /dev/null
+++ b/indra/newview/scripts/lua/test_group_chat.lua
@@ -0,0 +1,16 @@
+LLChat = require 'LLChat'
+inspect = require 'inspect'
+LLAgent = require 'LLAgent'
+popup = require 'popup'
+
+local OK = 'OK_okcancelbuttons'
+local GROUPS = LLAgent.getGroups()
+
+-- Choose one of the groups randomly and send group message
+math.randomseed(os.time())
+group_info = GROUPS[math.random(#GROUPS)]
+LLChat.startGroupChat(group_info.id)
+response = popup:alertYesCancel('Started group chat with ' .. group_info.name .. ' group. Send greetings?')
+if next(response) == OK then
+  LLChat.sendGroupIM('Greetings', group_info.id)
+end
-- 
cgit v1.2.3


From 9f2e322c7eea6830d372943d74f986d299cd314a Mon Sep 17 00:00:00 2001
From: Mnikolenko Productengine <mnikolenko@productengine.com>
Date: Tue, 13 Aug 2024 14:50:04 +0300
Subject: clean up and add comment

---
 indra/newview/scripts/lua/require/LLChat.lua  | 10 +++-------
 indra/newview/scripts/lua/test_group_chat.lua |  1 -
 2 files changed, 3 insertions(+), 8 deletions(-)

(limited to 'indra/newview/scripts')

diff --git a/indra/newview/scripts/lua/require/LLChat.lua b/indra/newview/scripts/lua/require/LLChat.lua
index ea6329d574..bc0fc86d22 100644
--- a/indra/newview/scripts/lua/require/LLChat.lua
+++ b/indra/newview/scripts/lua/require/LLChat.lua
@@ -6,8 +6,9 @@ local LLChat = {}
 --  Nearby chat
 -- ***************************************************************************
 
-function LLChat.sendNearby(msg)
-    leap.send('LLChatBar', {op='sendChat', message=msg})
+-- 0 is public nearby channel, other channels are used to communicate with LSL scripts
+function LLChat.sendNearby(msg, channel)
+    leap.send('LLChatBar', {op='sendChat', message=msg, channel=channel})
 end
 
 function LLChat.sendWhisper(msg)
@@ -18,11 +19,6 @@ function LLChat.sendShout(msg)
     leap.send('LLChatBar', {op='sendChat', type='shout', message=msg})
 end
 
--- 0 is public nearby channel, other channels are used to communicate with LSL scripts
-function LLChat.sendChannel(msg, channel)
-    leap.send('LLChatBar', {op='sendChat', channel=channel, message=msg})
-end
-
 -- ***************************************************************************
 --  Group chat
 -- ***************************************************************************
diff --git a/indra/newview/scripts/lua/test_group_chat.lua b/indra/newview/scripts/lua/test_group_chat.lua
index 6299ba535f..eaff07ed14 100644
--- a/indra/newview/scripts/lua/test_group_chat.lua
+++ b/indra/newview/scripts/lua/test_group_chat.lua
@@ -1,5 +1,4 @@
 LLChat = require 'LLChat'
-inspect = require 'inspect'
 LLAgent = require 'LLAgent'
 popup = require 'popup'
 
-- 
cgit v1.2.3


From ab0f7ff14cd80b89524ba95eb5a39e2d6df55b26 Mon Sep 17 00:00:00 2001
From: Mnikolenko Productengine <mnikolenko@productengine.com>
Date: Thu, 15 Aug 2024 23:29:54 +0300
Subject: First batch of Inventory api; raise interrupts limit

---
 indra/newview/scripts/lua/require/LLInventory.lua | 28 +++++++++++++++++++++++
 1 file changed, 28 insertions(+)
 create mode 100644 indra/newview/scripts/lua/require/LLInventory.lua

(limited to 'indra/newview/scripts')

diff --git a/indra/newview/scripts/lua/require/LLInventory.lua b/indra/newview/scripts/lua/require/LLInventory.lua
new file mode 100644
index 0000000000..880a2516f1
--- /dev/null
+++ b/indra/newview/scripts/lua/require/LLInventory.lua
@@ -0,0 +1,28 @@
+local leap = require 'leap'
+local mapargs = require 'mapargs'
+
+local LLInventory = {}
+
+-- Get the items/folders info by provided IDs,
+-- reply will contain "items" and "categories" tables accordingly
+function LLInventory.getItemsInfo(items_id)
+    return leap.request('LLInventory', {op = 'getItemsInfo', items_id=items_id})
+end
+
+-- Get the table of folder type names, which can be later used to get the ID of the basic folders
+function LLInventory.getFolderTypeNames()
+    return leap.request('LLInventory', {op = 'getFolderTypeNames'}).type_names
+end
+
+-- Get the UUID of the basic folder("Textures", "My outfits", "Sounds" etc.) by specified folder type name
+function LLInventory.getBasicFolderID(ft_name)
+    return leap.request('LLInventory', {op = 'getBasicFolderID', ft_name=ft_name}).id
+end
+
+-- Get the direct descendents of the 'folder_id' provided,
+-- reply will contain "items" and "categories" tables accordingly
+function LLInventory.getDirectDescendents(folder_id)
+    return leap.request('LLInventory', {op = 'getDirectDescendents', folder_id=folder_id})
+end
+
+return LLInventory
-- 
cgit v1.2.3


From 3cef79d979f2d21c29d17d123d6c166b9f7e7e0e Mon Sep 17 00:00:00 2001
From: Mnikolenko Productengine <mnikolenko@productengine.com>
Date: Tue, 20 Aug 2024 23:09:14 +0300
Subject: Add collectDescendentsIf api for Lua

---
 indra/newview/scripts/lua/require/LLInventory.lua | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)

(limited to 'indra/newview/scripts')

diff --git a/indra/newview/scripts/lua/require/LLInventory.lua b/indra/newview/scripts/lua/require/LLInventory.lua
index 880a2516f1..e6a347532b 100644
--- a/indra/newview/scripts/lua/require/LLInventory.lua
+++ b/indra/newview/scripts/lua/require/LLInventory.lua
@@ -19,10 +19,29 @@ function LLInventory.getBasicFolderID(ft_name)
     return leap.request('LLInventory', {op = 'getBasicFolderID', ft_name=ft_name}).id
 end
 
+-- Get the table of asset type names, which can be later used to get the specific items via LLInventory.collectDescendentsIf(...)
+function LLInventory.getAssetTypeNames()
+    return leap.request('LLInventory', {op = 'getAssetTypeNames'}).type_names
+end
+
 -- Get the direct descendents of the 'folder_id' provided,
 -- reply will contain "items" and "categories" tables accordingly
 function LLInventory.getDirectDescendents(folder_id)
     return leap.request('LLInventory', {op = 'getDirectDescendents', folder_id=folder_id})
 end
 
+-- Get the descendents of the 'folder_id' provided, which pass specified filters
+-- reply will contain "items" and "categories" tables accordingly
+-- LLInventory.collectDescendentsIf{ folder_id   -- parent folder ID
+-- [, name]              -- name (substring)
+-- [, desc]              -- description (substring)
+-- [, type]              -- asset type
+-- [, filter_links]}     -- EXCLUDE_LINKS - don't show links, ONLY_LINKS - only show links, INCLUDE_LINKS - show links too (default)
+function LLInventory.collectDescendentsIf(...)
+    local args = mapargs('folder_id,name,desc,type,filter_links', ...)
+    args.op = 'collectDescendentsIf'
+    return leap.request('LLInventory', args)
+end
+
+
 return LLInventory
-- 
cgit v1.2.3


From d37aa5c1823fcb202e87b1457842e49655c72b95 Mon Sep 17 00:00:00 2001
From: Nat Goodspeed <nat@lindenlab.com>
Date: Tue, 20 Aug 2024 21:22:46 -0400
Subject: Defend timers.Timer(iterate=True) against long callbacks.

Specifically, defend against a callback that runs so long it suspends at a
point after the next timer tick.
---
 indra/newview/scripts/lua/require/timers.lua | 34 +++++++++++++++++++++-------
 1 file changed, 26 insertions(+), 8 deletions(-)

(limited to 'indra/newview/scripts')

diff --git a/indra/newview/scripts/lua/require/timers.lua b/indra/newview/scripts/lua/require/timers.lua
index e4938078dc..ab1615ffbf 100644
--- a/indra/newview/scripts/lua/require/timers.lua
+++ b/indra/newview/scripts/lua/require/timers.lua
@@ -34,35 +34,53 @@ function timers.Timer:new(delay, callback, iterate)
 
     callback = callback or function() obj:tick() end
 
-    local first = true
+    local calls = 0
     if iterate then
+        -- With iterative timers, beware of running a timer callback which
+        -- performs async actions lasting longer than the timer interval. The
+        -- lengthy callback suspends, allowing leap to retrieve the next
+        -- event, which is a timer tick. leap calls a new instance of the
+        -- callback, even though the previous callback call is still
+        -- suspended... etc. 'in_callback' defends against that recursive
+        -- case. Rather than re-enter the suspended callback, drop the
+        -- too-soon timer event. (We could count the too-soon timer events and
+        -- iterate calling the callback, but it's a bathtub problem: the
+        -- callback could end up getting farther and farther behind.)
+        local in_callback = false
         obj.id = leap.eventstream(
             'Timers',
             {op='scheduleEvery', every=delay},
             function (event)
                 local reqid = event.reqid
-                if first then
-                    first = false
+                calls += 1
+                if calls == 1 then
                     dbg('timer(%s) first callback', reqid)
                     -- discard the first (immediate) response: don't call callback
                     return nil
                 else
-                    dbg('timer(%s) nth callback', reqid)
-                    return callback(event)
+                    if in_callback then
+                        dbg('dropping timer(%s) callback %d', reqid, calls)
+                    else
+                        dbg('timer(%s) callback %d', reqid, calls)
+                        in_callback = true
+                        local ret = callback(event)
+                        in_callback = false
+                        return ret
+                    end
                 end
             end
         ).reqid
-    else
+    else                        -- (not iterate)
         obj.id = leap.eventstream(
             'Timers',
             {op='scheduleAfter', after=delay},
             function (event)
+                calls += 1
                 -- Arrange to return nil the first time, true the second. This
                 -- callback is called immediately with the response to
                 -- 'scheduleAfter', and if we immediately returned true, we'd
                 -- be done, and the subsequent timer event would be discarded.
-                if first then
-                    first = false
+                if calls == 1 then
                     -- Caller doesn't expect an immediate callback.
                     return nil
                 else
-- 
cgit v1.2.3


From 86eec90d97c03ac0f6be8897041185c6b5601968 Mon Sep 17 00:00:00 2001
From: Mnikolenko Productengine <mnikolenko@productengine.com>
Date: Wed, 21 Aug 2024 20:43:38 +0300
Subject: Add item limit for collectDescendentsIf func; add demo script

---
 indra/newview/scripts/lua/require/LLInventory.lua |  3 ++-
 indra/newview/scripts/lua/test_LLInventory.lua    | 21 +++++++++++++++++++++
 2 files changed, 23 insertions(+), 1 deletion(-)
 create mode 100644 indra/newview/scripts/lua/test_LLInventory.lua

(limited to 'indra/newview/scripts')

diff --git a/indra/newview/scripts/lua/require/LLInventory.lua b/indra/newview/scripts/lua/require/LLInventory.lua
index e6a347532b..b3f817da94 100644
--- a/indra/newview/scripts/lua/require/LLInventory.lua
+++ b/indra/newview/scripts/lua/require/LLInventory.lua
@@ -36,9 +36,10 @@ end
 -- [, name]              -- name (substring)
 -- [, desc]              -- description (substring)
 -- [, type]              -- asset type
+-- [, item_limit]        -- item count limit in reply, maximum and default is 100
 -- [, filter_links]}     -- EXCLUDE_LINKS - don't show links, ONLY_LINKS - only show links, INCLUDE_LINKS - show links too (default)
 function LLInventory.collectDescendentsIf(...)
-    local args = mapargs('folder_id,name,desc,type,filter_links', ...)
+    local args = mapargs('folder_id,name,desc,type,filter_links,item_limit', ...)
     args.op = 'collectDescendentsIf'
     return leap.request('LLInventory', args)
 end
diff --git a/indra/newview/scripts/lua/test_LLInventory.lua b/indra/newview/scripts/lua/test_LLInventory.lua
new file mode 100644
index 0000000000..dc6eb243ad
--- /dev/null
+++ b/indra/newview/scripts/lua/test_LLInventory.lua
@@ -0,0 +1,21 @@
+inspect = require 'inspect'
+LLInventory = require 'LLInventory'
+
+-- Get 'My Landmarks' folder id (you can see all folder types via LLInventory.getFolderTypeNames())
+my_landmarks_id = LLInventory.getBasicFolderID('landmark')
+-- Get 3 landmarks from the 'My Landmarks' folder (you can see all folder types via LLInventory.getAssetTypeNames())
+landmarks = LLInventory.collectDescendentsIf{folder_id=my_landmarks_id, type="landmark", item_limit=3}
+print(inspect(landmarks))
+
+-- Get 'Calling Cards' folder id
+calling_cards_id = LLInventory.getBasicFolderID('callcard')
+-- Get all items located directly in 'Calling Cards' folder
+calling_cards = LLInventory.getDirectDescendents(calling_cards_id).items
+
+-- Print a random calling card name from 'Calling Cards' folder
+local card_names = {}
+for _, value in pairs(calling_cards) do
+    table.insert(card_names, value.name)
+end
+math.randomseed(os.time())
+print("Random calling card: " .. inspect(card_names[math.random(#card_names)]))
-- 
cgit v1.2.3


From a80b9487dc7c893f5e96f48f15140a5f82b99e30 Mon Sep 17 00:00:00 2001
From: Nat Goodspeed <nat@lindenlab.com>
Date: Fri, 23 Aug 2024 17:18:14 -0400
Subject: Allow UI to have lazily-loaded submodules.

Equip UI with an __index metamethod. When someone references an unknown
key/field in UI, require() that module and cache it for future reference.

Add util.setmetamethods() as a way to find or create a metatable on a
specified table containing specified metamethods.

Exercise the new functionality by referencing UI.popup in test_popup.lua.
---
 indra/newview/scripts/lua/require/UI.lua   | 22 ++++++++++++--
 indra/newview/scripts/lua/require/util.lua | 46 +++++++++++++++++++++++-------
 indra/newview/scripts/lua/test_popup.lua   |  3 +-
 3 files changed, 57 insertions(+), 14 deletions(-)

(limited to 'indra/newview/scripts')

diff --git a/indra/newview/scripts/lua/require/UI.lua b/indra/newview/scripts/lua/require/UI.lua
index 464e6547ea..969a2cbded 100644
--- a/indra/newview/scripts/lua/require/UI.lua
+++ b/indra/newview/scripts/lua/require/UI.lua
@@ -1,10 +1,26 @@
 -- Engage the viewer's UI
 
 local leap = require 'leap'
-local Timer = (require 'timers').Timer
 local mapargs = require 'mapargs'
-
-local UI = {}
+local Timer = (require 'timers').Timer
+local util = require 'util'
+
+-- Allow lazily accessing certain other modules on demand, e.g. a reference to
+-- UI.Floater lazily loads the Floater module. Use of UI's __index metamethod
+-- theoretically permits any other module you can require() to appear as a
+-- submodule of UI, but it doesn't make sense to support (e.g.) UI.Queue.
+local submods = { 'Floater', 'popup' }
+local UI = util.setmetamethods{
+    __index=function(t, key)
+        if not table.find(submods, key) then
+            error(`Invalid UI submodule {key}`, 2)
+        end
+        local mod = require(key)
+        -- cache the submodule
+        t[key] = mod
+        return mod
+    end
+}                               
 
 -- ***************************************************************************
 --  registered menu actions
diff --git a/indra/newview/scripts/lua/require/util.lua b/indra/newview/scripts/lua/require/util.lua
index bfbfc8637c..a000359226 100644
--- a/indra/newview/scripts/lua/require/util.lua
+++ b/indra/newview/scripts/lua/require/util.lua
@@ -15,16 +15,9 @@ local util = {}
 -- util.classctor(MyClass, MyClass.construct)
 -- return MyClass
 function util.classctor(class, ctor)
-    -- get the metatable for the passed class
-    local mt = getmetatable(class)
-    if mt == nil then
-        -- if it doesn't already have a metatable, then create one
-        mt = {}
-        setmetatable(class, mt)
-    end
-    -- now that class has a metatable, set its __call method to the specified
-    -- constructor method (class.new if not specified)
-    mt.__call = ctor or class.new
+    -- set class's __call metamethod to the specified constructor function
+    -- (class.new if not specified)
+    util.setmetamethods{class, __call=(ctor or class.new)}
 end
 
 -- check if array-like table contains certain value
@@ -66,4 +59,37 @@ function util.equal(t1, t2)
     return util.empty(temp)
 end
 
+-- Find or create the metatable for a specified table (a new empty table if
+-- omitted), and to that metatable assign the specified keys.
+-- Setting multiple keys at once is more efficient than a function to set only
+-- one at a time, e.g. setametamethod().
+-- t = util.setmetamethods{__index=readfunc, __len=lenfunc}
+-- returns a new table with specified metamethods __index, __len
+-- util.setmetamethods{t, __call=action}
+-- finds or creates the metatable for existing table t and sets __call
+-- util.setmetamethods{table=t, __call=action}
+-- same as util.setmetamethods{t, __call=action}
+function util.setmetamethods(specs)
+    -- first determine the target table
+    assert(not (specs.table and specs[1]),
+           "Pass setmetamethods table either as positional or table=, not both")
+    local t = specs.table or specs[1] or {}
+    -- remove both ways of specifying table, leaving only the metamethods
+    specs.table = nil
+    specs[1] = nil
+    local mt = getmetatable(t)
+    if not mt then
+        -- t doesn't already have a metatable: just set specs
+        setmetatable(t, specs)
+    else
+        -- t already has a metatable: copy specs into it
+        local key, value
+        for key, value in pairs(specs) do
+            mt[key] = value
+        end
+    end
+    -- having set or enriched t's metatable, return t
+    return t
+end
+
 return util
diff --git a/indra/newview/scripts/lua/test_popup.lua b/indra/newview/scripts/lua/test_popup.lua
index e48f89c3a7..156c09c78f 100644
--- a/indra/newview/scripts/lua/test_popup.lua
+++ b/indra/newview/scripts/lua/test_popup.lua
@@ -1,4 +1,5 @@
-popup = require 'popup'
+UI = require 'UI'
+popup = UI.popup
 
 response = popup:alert('This just has a Close button')
 response = popup:alertOK(string.format('You said "%s", is that OK?', next(response)))
-- 
cgit v1.2.3


From e4a710296943674573be800f5233b24214440929 Mon Sep 17 00:00:00 2001
From: Nat Goodspeed <nat@lindenlab.com>
Date: Fri, 23 Aug 2024 20:55:22 -0400
Subject: Look for lazy UI submodules in a require/UI subdirectory.

This way encourages "UI = require 'UI'; UI.Floater"
instead of just "Floater = require 'Floater'".
Moreover, now we don't need UI to maintain a list of allowed submodules;
that's effected by membership in the subdirectory.
---
 indra/newview/scripts/lua/require/Floater.lua    | 146 -----------------------
 indra/newview/scripts/lua/require/UI.lua         |  12 +-
 indra/newview/scripts/lua/require/UI/Floater.lua | 146 +++++++++++++++++++++++
 indra/newview/scripts/lua/require/UI/popup.lua   |  53 ++++++++
 indra/newview/scripts/lua/require/popup.lua      |  53 --------
 5 files changed, 202 insertions(+), 208 deletions(-)
 delete mode 100644 indra/newview/scripts/lua/require/Floater.lua
 create mode 100644 indra/newview/scripts/lua/require/UI/Floater.lua
 create mode 100644 indra/newview/scripts/lua/require/UI/popup.lua
 delete mode 100644 indra/newview/scripts/lua/require/popup.lua

(limited to 'indra/newview/scripts')

diff --git a/indra/newview/scripts/lua/require/Floater.lua b/indra/newview/scripts/lua/require/Floater.lua
deleted file mode 100644
index d057a74386..0000000000
--- a/indra/newview/scripts/lua/require/Floater.lua
+++ /dev/null
@@ -1,146 +0,0 @@
--- Floater base class
-
-local leap = require 'leap'
-local fiber = require 'fiber'
-local util = require 'util'
-
--- list of all the events that a LLLuaFloater might send
-local event_list = leap.request("LLFloaterReg", {op="getFloaterEvents"}).events
-local event_set = {}
-for _, event in pairs(event_list) do
-    event_set[event] = true
-end
-
-local function _event(event_name)
-    if not event_set[event_name] then
-        error("Incorrect event name: " .. event_name, 3)
-    end
-    return event_name
-end
-
--- ---------------------------------------------------------------------------
-local Floater = {}
-
--- Pass:
--- relative file path to floater's XUI definition file
--- optional: sign up for additional events for defined control
--- {<control_name>={action1, action2, ...}}
-function Floater:new(path, extra)
-    local obj = setmetatable({}, self)
-    self.__index = self
-
-    local path_parts = string.split(path, '/')
-    obj.name = 'Floater ' .. path_parts[#path_parts]
-
-    obj._command = {op="showLuaFloater", xml_path=LL.abspath(path)}
-    if extra then
-        -- validate each of the actions for each specified control
-        for control, actions in pairs(extra) do
-            for _, action in pairs(actions) do
-                _event(action)
-            end
-        end
-        obj._command.extra_events = extra
-    end
-
-    return obj
-end
-
-util.classctor(Floater)
-
-function Floater:show()
-    -- leap.eventstream() returns the first response, and launches a
-    -- background fiber to call the passed callback with all subsequent
-    -- responses.
-    local event = leap.eventstream(
-        'LLFloaterReg',
-        self._command,
-        -- handleEvents() returns false when done.
-        -- eventstream() expects a true return when done.
-        function(event) return not self:handleEvents(event) end)
-    self._pump = event.command_name
-    -- we might need the returned reqid to cancel the eventstream() fiber
-    self.reqid = event.reqid
-
-    -- The response to 'showLuaFloater' *is* the 'post_build' event. Check if
-    -- subclass has a post_build() method. Honor the convention that if
-    -- handleEvents() returns false, we're done.
-    if not self:handleEvents(event) then
-        return
-    end
-end
-
-function Floater:post(action)
-    leap.send(self._pump, action)
-end
-
-function Floater:request(action)
-    return leap.request(self._pump, action)
-end
-
--- local inspect = require 'inspect'
-
-function Floater:handleEvents(event_data)
-    local event = event_data.event
-    if event_set[event] == nil then
-        LL.print_warning(string.format('%s received unknown event %q', self.name, event))
-    end
-
-    -- Before checking for a general (e.g.) commit() method, first look for
-    -- commit_ctrl_name(): in other words, concatenate the event name with the
-    -- ctrl_name, with an underscore between. If there exists such a specific
-    -- method, call that.
-    local handler, ret
-    if event_data.ctrl_name then
-        local specific = event .. '_' .. event_data.ctrl_name
-        handler = self[specific]
-        if handler then
-            ret = handler(self, event_data)
-            -- Avoid 'return ret or true' because we explicitly want to allow
-            -- the handler to return false.
-            if ret ~= nil then
-                return ret
-            else
-                return true
-            end
-        end
-    end
-
-    -- No specific "event_on_ctrl()" method found; try just "event()"
-    handler = self[event]
-    if handler then
-        ret = handler(self, event_data)
-        if ret ~= nil then
-            return ret
-        end
---  else
---      print(string.format('%s ignoring event %s', self.name, inspect(event_data)))
-    end
-
-    -- We check for event() method before recognizing floater_close in case
-    -- the consumer needs to react specially to closing the floater. Now that
-    -- we've checked, recognize it ourselves. Returning false terminates the
-    -- anonymous fiber function launched by leap.eventstream().
-    if event == _event('floater_close') then
-        LL.print_warning(self.name .. ' closed')
-        return false
-    end
-    return true
-end
-
--- onCtrl() permits a different dispatch style in which the general event()
--- method explicitly calls (e.g.)
--- self:onCtrl(event_data, {
---     ctrl_name=function()
---         self:post(...)
---     end,
---     ...
--- })
-function Floater:onCtrl(event_data, ctrl_map)
-    local handler = ctrl_map[event_data.ctrl_name]
-    if handler then
-        handler()
-    end
-end
-
-return Floater
diff --git a/indra/newview/scripts/lua/require/UI.lua b/indra/newview/scripts/lua/require/UI.lua
index 969a2cbded..2df70fd453 100644
--- a/indra/newview/scripts/lua/require/UI.lua
+++ b/indra/newview/scripts/lua/require/UI.lua
@@ -5,17 +5,11 @@ local mapargs = require 'mapargs'
 local Timer = (require 'timers').Timer
 local util = require 'util'
 
--- Allow lazily accessing certain other modules on demand, e.g. a reference to
--- UI.Floater lazily loads the Floater module. Use of UI's __index metamethod
--- theoretically permits any other module you can require() to appear as a
--- submodule of UI, but it doesn't make sense to support (e.g.) UI.Queue.
-local submods = { 'Floater', 'popup' }
+-- Allow lazily accessing UI submodules on demand, e.g. a reference to
+-- UI.Floater lazily loads the UI/Floater module.
 local UI = util.setmetamethods{
     __index=function(t, key)
-        if not table.find(submods, key) then
-            error(`Invalid UI submodule {key}`, 2)
-        end
-        local mod = require(key)
+        local mod = require('UI/' .. key)
         -- cache the submodule
         t[key] = mod
         return mod
diff --git a/indra/newview/scripts/lua/require/UI/Floater.lua b/indra/newview/scripts/lua/require/UI/Floater.lua
new file mode 100644
index 0000000000..d057a74386
--- /dev/null
+++ b/indra/newview/scripts/lua/require/UI/Floater.lua
@@ -0,0 +1,146 @@
+-- Floater base class
+
+local leap = require 'leap'
+local fiber = require 'fiber'
+local util = require 'util'
+
+-- list of all the events that a LLLuaFloater might send
+local event_list = leap.request("LLFloaterReg", {op="getFloaterEvents"}).events
+local event_set = {}
+for _, event in pairs(event_list) do
+    event_set[event] = true
+end
+
+local function _event(event_name)
+    if not event_set[event_name] then
+        error("Incorrect event name: " .. event_name, 3)
+    end
+    return event_name
+end
+
+-- ---------------------------------------------------------------------------
+local Floater = {}
+
+-- Pass:
+-- relative file path to floater's XUI definition file
+-- optional: sign up for additional events for defined control
+-- {<control_name>={action1, action2, ...}}
+function Floater:new(path, extra)
+    local obj = setmetatable({}, self)
+    self.__index = self
+
+    local path_parts = string.split(path, '/')
+    obj.name = 'Floater ' .. path_parts[#path_parts]
+
+    obj._command = {op="showLuaFloater", xml_path=LL.abspath(path)}
+    if extra then
+        -- validate each of the actions for each specified control
+        for control, actions in pairs(extra) do
+            for _, action in pairs(actions) do
+                _event(action)
+            end
+        end
+        obj._command.extra_events = extra
+    end
+
+    return obj
+end
+
+util.classctor(Floater)
+
+function Floater:show()
+    -- leap.eventstream() returns the first response, and launches a
+    -- background fiber to call the passed callback with all subsequent
+    -- responses.
+    local event = leap.eventstream(
+        'LLFloaterReg',
+        self._command,
+        -- handleEvents() returns false when done.
+        -- eventstream() expects a true return when done.
+        function(event) return not self:handleEvents(event) end)
+    self._pump = event.command_name
+    -- we might need the returned reqid to cancel the eventstream() fiber
+    self.reqid = event.reqid
+
+    -- The response to 'showLuaFloater' *is* the 'post_build' event. Check if
+    -- subclass has a post_build() method. Honor the convention that if
+    -- handleEvents() returns false, we're done.
+    if not self:handleEvents(event) then
+        return
+    end
+end
+
+function Floater:post(action)
+    leap.send(self._pump, action)
+end
+
+function Floater:request(action)
+    return leap.request(self._pump, action)
+end
+
+-- local inspect = require 'inspect'
+
+function Floater:handleEvents(event_data)
+    local event = event_data.event
+    if event_set[event] == nil then
+        LL.print_warning(string.format('%s received unknown event %q', self.name, event))
+    end
+
+    -- Before checking for a general (e.g.) commit() method, first look for
+    -- commit_ctrl_name(): in other words, concatenate the event name with the
+    -- ctrl_name, with an underscore between. If there exists such a specific
+    -- method, call that.
+    local handler, ret
+    if event_data.ctrl_name then
+        local specific = event .. '_' .. event_data.ctrl_name
+        handler = self[specific]
+        if handler then
+            ret = handler(self, event_data)
+            -- Avoid 'return ret or true' because we explicitly want to allow
+            -- the handler to return false.
+            if ret ~= nil then
+                return ret
+            else
+                return true
+            end
+        end
+    end
+
+    -- No specific "event_on_ctrl()" method found; try just "event()"
+    handler = self[event]
+    if handler then
+        ret = handler(self, event_data)
+        if ret ~= nil then
+            return ret
+        end
+--  else
+--      print(string.format('%s ignoring event %s', self.name, inspect(event_data)))
+    end
+
+    -- We check for event() method before recognizing floater_close in case
+    -- the consumer needs to react specially to closing the floater. Now that
+    -- we've checked, recognize it ourselves. Returning false terminates the
+    -- anonymous fiber function launched by leap.eventstream().
+    if event == _event('floater_close') then
+        LL.print_warning(self.name .. ' closed')
+        return false
+    end
+    return true
+end
+
+-- onCtrl() permits a different dispatch style in which the general event()
+-- method explicitly calls (e.g.)
+-- self:onCtrl(event_data, {
+--     ctrl_name=function()
+--         self:post(...)
+--     end,
+--     ...
+-- })
+function Floater:onCtrl(event_data, ctrl_map)
+    local handler = ctrl_map[event_data.ctrl_name]
+    if handler then
+        handler()
+    end
+end
+
+return Floater
diff --git a/indra/newview/scripts/lua/require/UI/popup.lua b/indra/newview/scripts/lua/require/UI/popup.lua
new file mode 100644
index 0000000000..3aaadf85ba
--- /dev/null
+++ b/indra/newview/scripts/lua/require/UI/popup.lua
@@ -0,0 +1,53 @@
+local leap = require 'leap'
+local mapargs = require 'mapargs'
+
+-- notification is any name defined in notifications.xml as
+-- <notification name=>
+-- vars is a table providing values for [VAR] substitution keys in the
+-- notification body
+-- payload prepopulates the response table
+-- wait=false means fire and forget, otherwise wait for user response
+local popup_meta = {
+    -- setting this function as getmetatable(popup).__call() means this gets
+    -- called when a consumer calls popup(notification, vars, payload)
+    __call = function(self, ...)
+        local args = mapargs('notification,vars,payload,wait', ...)
+        -- we use convenience argument names different from 'LLNotifications'
+        -- listener
+        args.name = args.notification
+        args.notification = nil
+        args.substitutions = args.vars
+        args.vars = nil
+        local wait = args.wait
+        args.wait = nil
+        args.op = 'requestAdd'
+        -- Specifically test (wait == false), NOT (not wait), because we treat
+        -- nil (omitted, default true) differently than false (explicitly
+        -- DON'T wait).
+        if wait == false then
+            leap.send('LLNotifications', args)
+        else
+            return leap.request('LLNotifications', args).response
+        end
+    end
+}
+
+local popup = setmetatable({}, popup_meta)
+
+function popup:alert(message)
+    return self('GenericAlert', {MESSAGE=message})
+end
+
+function popup:alertOK(message)
+    return self('GenericAlertOK', {MESSAGE=message})
+end
+
+function popup:alertYesCancel(message)
+    return self('GenericAlertYesCancel', {MESSAGE=message})
+end
+
+function popup:tip(message)
+    self{'SystemMessageTip', {MESSAGE=message}, wait=false}
+end
+
+return popup
diff --git a/indra/newview/scripts/lua/require/popup.lua b/indra/newview/scripts/lua/require/popup.lua
deleted file mode 100644
index 3aaadf85ba..0000000000
--- a/indra/newview/scripts/lua/require/popup.lua
+++ /dev/null
@@ -1,53 +0,0 @@
-local leap = require 'leap'
-local mapargs = require 'mapargs'
-
--- notification is any name defined in notifications.xml as
--- <notification name=>
--- vars is a table providing values for [VAR] substitution keys in the
--- notification body
--- payload prepopulates the response table
--- wait=false means fire and forget, otherwise wait for user response
-local popup_meta = {
-    -- setting this function as getmetatable(popup).__call() means this gets
-    -- called when a consumer calls popup(notification, vars, payload)
-    __call = function(self, ...)
-        local args = mapargs('notification,vars,payload,wait', ...)
-        -- we use convenience argument names different from 'LLNotifications'
-        -- listener
-        args.name = args.notification
-        args.notification = nil
-        args.substitutions = args.vars
-        args.vars = nil
-        local wait = args.wait
-        args.wait = nil
-        args.op = 'requestAdd'
-        -- Specifically test (wait == false), NOT (not wait), because we treat
-        -- nil (omitted, default true) differently than false (explicitly
-        -- DON'T wait).
-        if wait == false then
-            leap.send('LLNotifications', args)
-        else
-            return leap.request('LLNotifications', args).response
-        end
-    end
-}
-
-local popup = setmetatable({}, popup_meta)
-
-function popup:alert(message)
-    return self('GenericAlert', {MESSAGE=message})
-end
-
-function popup:alertOK(message)
-    return self('GenericAlertOK', {MESSAGE=message})
-end
-
-function popup:alertYesCancel(message)
-    return self('GenericAlertYesCancel', {MESSAGE=message})
-end
-
-function popup:tip(message)
-    self{'SystemMessageTip', {MESSAGE=message}, wait=false}
-end
-
-return popup
-- 
cgit v1.2.3


From 2e815acb529159f5b6f0a4365a2eaf64d35330cc Mon Sep 17 00:00:00 2001
From: Nat Goodspeed <nat@lindenlab.com>
Date: Fri, 23 Aug 2024 21:28:03 -0400
Subject: Encapsulate the lazy submodule idiom as util.submoduledir().

---
 indra/newview/scripts/lua/require/UI.lua   |  9 +--------
 indra/newview/scripts/lua/require/util.lua | 19 +++++++++++++++++++
 2 files changed, 20 insertions(+), 8 deletions(-)

(limited to 'indra/newview/scripts')

diff --git a/indra/newview/scripts/lua/require/UI.lua b/indra/newview/scripts/lua/require/UI.lua
index 2df70fd453..bbcae3514a 100644
--- a/indra/newview/scripts/lua/require/UI.lua
+++ b/indra/newview/scripts/lua/require/UI.lua
@@ -7,14 +7,7 @@ local util = require 'util'
 
 -- Allow lazily accessing UI submodules on demand, e.g. a reference to
 -- UI.Floater lazily loads the UI/Floater module.
-local UI = util.setmetamethods{
-    __index=function(t, key)
-        local mod = require('UI/' .. key)
-        -- cache the submodule
-        t[key] = mod
-        return mod
-    end
-}                               
+local UI = util.submoduledir({}, 'UI')
 
 -- ***************************************************************************
 --  registered menu actions
diff --git a/indra/newview/scripts/lua/require/util.lua b/indra/newview/scripts/lua/require/util.lua
index a000359226..40737a159a 100644
--- a/indra/newview/scripts/lua/require/util.lua
+++ b/indra/newview/scripts/lua/require/util.lua
@@ -92,4 +92,23 @@ function util.setmetamethods(specs)
     return t
 end
 
+-- On the passed module (i.e. table), set an __index metamethod such that
+-- referencing module.submodule lazily requires(path/submodule).
+-- The loaded submodule is cached in the module table so it need not be passed
+-- to require() again.
+-- 'path', like any require() string, can be relative to LuaRequirePath.
+-- Returns the enriched module, permitting e.g.
+-- mymod = util.submoduledir({}, 'mymod')
+function util.submoduledir(module, path)
+    return util.setmetamethods{
+        module,
+        __index=function(t, key)
+            local mod = require(`{path}/{key}`)
+            -- cache the submodule
+            t[key] = mod
+            return mod
+        end
+    }
+end
+
 return util
-- 
cgit v1.2.3


From e6d8379744b08f9a52af6734ba1f0e1b50fb5906 Mon Sep 17 00:00:00 2001
From: Nat Goodspeed <nat@lindenlab.com>
Date: Fri, 23 Aug 2024 22:39:30 -0400
Subject: Massage results from UI.popup() for ease of use.

In particular, where the raw leap.request().response call would return
{OK_okcancelbuttons=true}, just return the string 'OK' or 'Cancel'.

Update existing consumer scripts.
---
 indra/newview/scripts/lua/require/UI/popup.lua     | 77 +++++++++++++++-------
 indra/newview/scripts/lua/test_group_chat.lua      |  7 +-
 .../scripts/lua/test_luafloater_speedometer.lua    |  5 +-
 indra/newview/scripts/lua/test_popup.lua           |  9 ++-
 indra/newview/scripts/lua/test_toolbars.lua        |  6 +-
 5 files changed, 67 insertions(+), 37 deletions(-)

(limited to 'indra/newview/scripts')

diff --git a/indra/newview/scripts/lua/require/UI/popup.lua b/indra/newview/scripts/lua/require/UI/popup.lua
index 3aaadf85ba..8ccf3b87f3 100644
--- a/indra/newview/scripts/lua/require/UI/popup.lua
+++ b/indra/newview/scripts/lua/require/UI/popup.lua
@@ -1,53 +1,82 @@
 local leap = require 'leap'
 local mapargs = require 'mapargs'
+local util = require 'util'
 
 -- notification is any name defined in notifications.xml as
 -- <notification name=>
 -- vars is a table providing values for [VAR] substitution keys in the
 -- notification body
 -- payload prepopulates the response table
--- wait=false means fire and forget, otherwise wait for user response
-local popup_meta = {
-    -- setting this function as getmetatable(popup).__call() means this gets
-    -- called when a consumer calls popup(notification, vars, payload)
+-- wait=false means fire and forget, returning nil
+-- wait=true waits for user response:
+-- * If the viewer returns a table containing exactly one key=true pair,
+--   popup() returns just that key. If the key is a string containing an
+--   underscore, e.g. 'OK_okcancelbuttons', it's truncated at the first
+--   underscore, e.g. 'OK'.
+-- * Otherwise the viewer's response is returned unchanged. To suppress the
+--   above transformations, pass a non-empty payload table; this will cause
+--   the viewer to return a table with at least two keys.
+local popup = util.setmetamethods{
+    -- this gets called when a consumer calls popup(notification, vars, payload)
     __call = function(self, ...)
         local args = mapargs('notification,vars,payload,wait', ...)
         -- we use convenience argument names different from 'LLNotifications'
         -- listener
-        args.name = args.notification
-        args.notification = nil
-        args.substitutions = args.vars
-        args.vars = nil
-        local wait = args.wait
-        args.wait = nil
-        args.op = 'requestAdd'
+        newargs = {op='requestAdd',
+                   name=args.notification,
+                   substitutions=args.vars,
+                   payload=args.payload}
         -- Specifically test (wait == false), NOT (not wait), because we treat
         -- nil (omitted, default true) differently than false (explicitly
         -- DON'T wait).
-        if wait == false then
-            leap.send('LLNotifications', args)
+        if args.wait == false then
+            leap.send('LLNotifications', newargs)
         else
-            return leap.request('LLNotifications', args).response
+            local response = leap.request('LLNotifications', newargs).response
+            -- response is typically a table. It might have multiple keys,
+            -- e.g. if caller passed non-empty payload. In that case, just
+            -- return the whole thing.
+            if type(response) ~= 'table' then
+                return response
+            end
+            -- get first key=value pair, if any
+            local key, value = next(response)
+            if (not key) or next(response, key) then
+                -- key == nil means response is empty
+                -- next(response, non-nil first key) ~= nil means at least two keys
+                return response
+            end
+            -- Here response is a table containing exactly one key. The
+            -- notifications system typically returns a table of the form
+            -- {OK_okcancelbuttons=true}, which is tricky to test for because it
+            -- varies with each set of buttons.
+            if value == true then
+                -- change {key=true} to plain key
+                response = key
+                if type(response) == 'string' then
+                    -- change 'OK_okcancelbuttons' to plain 'OK'
+                    response = string.split(response, '_')[1]
+                end
+            end
+            return response
         end
     end
 }
 
-local popup = setmetatable({}, popup_meta)
-
-function popup:alert(message)
-    return self('GenericAlert', {MESSAGE=message})
+function popup:alert(message, payload)
+    return self('GenericAlert', {MESSAGE=message, payload=payload})
 end
 
-function popup:alertOK(message)
-    return self('GenericAlertOK', {MESSAGE=message})
+function popup:alertOK(message, payload)
+    return self('GenericAlertOK', {MESSAGE=message, payload=payload})
 end
 
-function popup:alertYesCancel(message)
-    return self('GenericAlertYesCancel', {MESSAGE=message})
+function popup:alertYesCancel(message, payload)
+    return self('GenericAlertYesCancel', {MESSAGE=message, payload=payload})
 end
 
-function popup:tip(message)
-    self{'SystemMessageTip', {MESSAGE=message}, wait=false}
+function popup:tip(message, payload)
+    self{'SystemMessageTip', {MESSAGE=message, payload=payload}, wait=false}
 end
 
 return popup
diff --git a/indra/newview/scripts/lua/test_group_chat.lua b/indra/newview/scripts/lua/test_group_chat.lua
index eaff07ed14..373411c26c 100644
--- a/indra/newview/scripts/lua/test_group_chat.lua
+++ b/indra/newview/scripts/lua/test_group_chat.lua
@@ -1,15 +1,14 @@
 LLChat = require 'LLChat'
 LLAgent = require 'LLAgent'
-popup = require 'popup'
+UI = require 'UI'
 
-local OK = 'OK_okcancelbuttons'
 local GROUPS = LLAgent.getGroups()
 
 -- Choose one of the groups randomly and send group message
 math.randomseed(os.time())
 group_info = GROUPS[math.random(#GROUPS)]
 LLChat.startGroupChat(group_info.id)
-response = popup:alertYesCancel('Started group chat with ' .. group_info.name .. ' group. Send greetings?')
-if next(response) == OK then
+response = UI.popup:alertYesCancel('Started group chat with ' .. group_info.name .. ' group. Send greetings?')
+if response == 'OK' then
   LLChat.sendGroupIM('Greetings', group_info.id)
 end
diff --git a/indra/newview/scripts/lua/test_luafloater_speedometer.lua b/indra/newview/scripts/lua/test_luafloater_speedometer.lua
index af7189a2cb..8bc18ad286 100644
--- a/indra/newview/scripts/lua/test_luafloater_speedometer.lua
+++ b/indra/newview/scripts/lua/test_luafloater_speedometer.lua
@@ -1,8 +1,9 @@
 local Floater = require 'Floater'
 local leap = require 'leap'
-local popup = require 'popup'
 local startup = require 'startup'
 local Timer = (require 'timers').Timer
+local UI = require 'UI'
+local popup = UI.popup
 local max_speed = 0
 local flt = Floater("luafloater_speedometer.xml")
 startup.wait('STATE_STARTED')
@@ -25,7 +26,7 @@ end
 msg = 'Are you sure you want to run this "speedometer" script?'
 response = popup:alertYesCancel(msg)
 
-if response.OK_okcancelbuttons then
+if response == 'OK' then
     flt:show()
     timer = Timer(1, idle, true) -- iterate
 end
diff --git a/indra/newview/scripts/lua/test_popup.lua b/indra/newview/scripts/lua/test_popup.lua
index 156c09c78f..7a11895669 100644
--- a/indra/newview/scripts/lua/test_popup.lua
+++ b/indra/newview/scripts/lua/test_popup.lua
@@ -1,7 +1,10 @@
 UI = require 'UI'
 popup = UI.popup
+startup = require 'startup'
+
+startup.wait('STATE_STARTED')
 
 response = popup:alert('This just has a Close button')
-response = popup:alertOK(string.format('You said "%s", is that OK?', next(response)))
-response = popup:alertYesCancel(string.format('You said "%s"', next(response)))
-popup:tip(string.format('You said "%s"', next(response)))
+response = popup:alertOK(string.format('You said "%s", is that OK?', response))
+response = popup:alertYesCancel(string.format('You said "%s"', response))
+popup:tip(string.format('You said "%s"', response))
diff --git a/indra/newview/scripts/lua/test_toolbars.lua b/indra/newview/scripts/lua/test_toolbars.lua
index 9a832c5644..7683fca8a3 100644
--- a/indra/newview/scripts/lua/test_toolbars.lua
+++ b/indra/newview/scripts/lua/test_toolbars.lua
@@ -1,13 +1,11 @@
-popup = require 'popup'
 UI = require 'UI'
 
-local OK = 'OK_okcancelbuttons'
 local BUTTONS = UI.getToolbarBtnNames()
 local TOOLBARS = {'left','right','bottom'}
 
 -- Clear the toolbars and then add the toolbar buttons to the random toolbar
-response = popup:alertYesCancel('Toolbars will be randomly reshuffled. Proceed?')
-if next(response) == OK then
+response = UI.popup:alertYesCancel('Toolbars will be randomly reshuffled. Proceed?')
+if response == 'OK' then
     UI.clearAllToolbars()
     math.randomseed(os.time())
 
-- 
cgit v1.2.3


From 7b21acd39745d265548eeb62d687cde9febb1f7a Mon Sep 17 00:00:00 2001
From: Nat Goodspeed <nat@lindenlab.com>
Date: Sat, 24 Aug 2024 10:37:57 -0400
Subject: Update test scripts to reference UI.Floater, not standalone Floater.

---
 indra/newview/scripts/lua/require/LLChatListener.lua       | 2 +-
 indra/newview/scripts/lua/test_LLAppearance.lua            | 4 ++--
 indra/newview/scripts/lua/test_camera_control.lua          | 4 ++--
 indra/newview/scripts/lua/test_luafloater_demo.lua         | 6 +++---
 indra/newview/scripts/lua/test_luafloater_gesture_list.lua | 4 ++--
 indra/newview/scripts/lua/test_luafloater_speedometer.lua  | 3 +--
 6 files changed, 11 insertions(+), 12 deletions(-)

(limited to 'indra/newview/scripts')

diff --git a/indra/newview/scripts/lua/require/LLChatListener.lua b/indra/newview/scripts/lua/require/LLChatListener.lua
index 428dca881e..82b28966ce 100644
--- a/indra/newview/scripts/lua/require/LLChatListener.lua
+++ b/indra/newview/scripts/lua/require/LLChatListener.lua
@@ -23,7 +23,7 @@ function LLChatListener:handleMessages(event_data)
 end
 
 function LLChatListener:start()
-    waitfor = leap.WaitFor:new(-1, self.name)
+    waitfor = leap.WaitFor(-1, self.name)
     function waitfor:filter(pump, data)
         if pump == "LLNearbyChat" then
           return data
diff --git a/indra/newview/scripts/lua/test_LLAppearance.lua b/indra/newview/scripts/lua/test_LLAppearance.lua
index 5ddd9f15ff..a97ec4e0ca 100644
--- a/indra/newview/scripts/lua/test_LLAppearance.lua
+++ b/indra/newview/scripts/lua/test_LLAppearance.lua
@@ -1,7 +1,7 @@
-local Floater = require 'Floater'
 local LLAppearance = require 'LLAppearance'
 local startup = require 'startup'
 local inspect = require 'inspect'
+local UI = require 'UI'
 
 local SHOW_OUTFITS = true
 local SELECTED_OUTFIT_ID = {}
@@ -15,7 +15,7 @@ local outfits_title = 'Outfits'
 local wear_lbl = 'Wear item'
 local detach_lbl = 'Detach item'
 
-local flt = Floater:new(
+local flt = UI.Floater(
     "luafloater_outfits_list.xml",
     {outfits_list = {"double_click"}})
 
diff --git a/indra/newview/scripts/lua/test_camera_control.lua b/indra/newview/scripts/lua/test_camera_control.lua
index 9b35cdf8cd..7ac0986ee6 100644
--- a/indra/newview/scripts/lua/test_camera_control.lua
+++ b/indra/newview/scripts/lua/test_camera_control.lua
@@ -1,8 +1,8 @@
-local Floater = require 'Floater'
 local LLAgent = require 'LLAgent'
 local startup = require 'startup'
+local UI = require 'UI'
 
-local flt = Floater('luafloater_camera_control.xml')
+local flt = UI.Floater('luafloater_camera_control.xml')
 
 function getValue(ctrl_name)
     return flt:request({action="get_value", ctrl_name=ctrl_name}).value
diff --git a/indra/newview/scripts/lua/test_luafloater_demo.lua b/indra/newview/scripts/lua/test_luafloater_demo.lua
index 3903d01e65..2158134511 100644
--- a/indra/newview/scripts/lua/test_luafloater_demo.lua
+++ b/indra/newview/scripts/lua/test_luafloater_demo.lua
@@ -1,8 +1,8 @@
-local Floater = require 'Floater'
 local leap = require 'leap'
 local startup = require 'startup'
+local UI = require 'UI'
 
-local flt = Floater(
+local flt = UI.Floater(
     'luafloater_demo.xml',
     {show_time_lbl = {"right_mouse_down", "double_click"}})
 
@@ -10,7 +10,7 @@ local flt = Floater(
 function flt:handleEvents(event_data)
     self:post({action="add_text", ctrl_name="events_editor", value = event_data})
     -- forward the call to base-class handleEvents()
-    return Floater.handleEvents(self, event_data)
+    return UI.Floater.handleEvents(self, event_data)
 end
 
 function flt:commit_disable_ctrl(event_data)
diff --git a/indra/newview/scripts/lua/test_luafloater_gesture_list.lua b/indra/newview/scripts/lua/test_luafloater_gesture_list.lua
index bd397ef2a6..5f929c0d0c 100644
--- a/indra/newview/scripts/lua/test_luafloater_gesture_list.lua
+++ b/indra/newview/scripts/lua/test_luafloater_gesture_list.lua
@@ -1,8 +1,8 @@
-local Floater = require 'Floater'
 local LLGesture = require 'LLGesture'
 local startup = require 'startup'
+local UI = require 'UI'
 
-local flt = Floater(
+local flt = UI.Floater(
     "luafloater_gesture_list.xml",
     {gesture_list = {"double_click"}})
 
diff --git a/indra/newview/scripts/lua/test_luafloater_speedometer.lua b/indra/newview/scripts/lua/test_luafloater_speedometer.lua
index 8bc18ad286..2cdd41fd7e 100644
--- a/indra/newview/scripts/lua/test_luafloater_speedometer.lua
+++ b/indra/newview/scripts/lua/test_luafloater_speedometer.lua
@@ -1,11 +1,10 @@
-local Floater = require 'Floater'
 local leap = require 'leap'
 local startup = require 'startup'
 local Timer = (require 'timers').Timer
 local UI = require 'UI'
 local popup = UI.popup
 local max_speed = 0
-local flt = Floater("luafloater_speedometer.xml")
+local flt = UI.Floater("luafloater_speedometer.xml")
 startup.wait('STATE_STARTED')
 
 local timer
-- 
cgit v1.2.3


From 27ce2a23a286709c90579db31c2551e0c3f292e7 Mon Sep 17 00:00:00 2001
From: Mnikolenko Productengine <mnikolenko@productengine.com>
Date: Tue, 27 Aug 2024 16:27:34 +0300
Subject: code clean up

---
 indra/newview/scripts/lua/require/LLInventory.lua | 12 ++++++------
 indra/newview/scripts/lua/test_LLInventory.lua    |  2 +-
 2 files changed, 7 insertions(+), 7 deletions(-)

(limited to 'indra/newview/scripts')

diff --git a/indra/newview/scripts/lua/require/LLInventory.lua b/indra/newview/scripts/lua/require/LLInventory.lua
index b3f817da94..dd1b910250 100644
--- a/indra/newview/scripts/lua/require/LLInventory.lua
+++ b/indra/newview/scripts/lua/require/LLInventory.lua
@@ -5,13 +5,13 @@ local LLInventory = {}
 
 -- Get the items/folders info by provided IDs,
 -- reply will contain "items" and "categories" tables accordingly
-function LLInventory.getItemsInfo(items_id)
-    return leap.request('LLInventory', {op = 'getItemsInfo', items_id=items_id})
+function LLInventory.getItemsInfo(item_ids)
+    return leap.request('LLInventory', {op = 'getItemsInfo', item_ids=item_ids})
 end
 
 -- Get the table of folder type names, which can be later used to get the ID of the basic folders
 function LLInventory.getFolderTypeNames()
-    return leap.request('LLInventory', {op = 'getFolderTypeNames'}).type_names
+    return leap.request('LLInventory', {op = 'getFolderTypeNames'}).names
 end
 
 -- Get the UUID of the basic folder("Textures", "My outfits", "Sounds" etc.) by specified folder type name
@@ -21,7 +21,7 @@ end
 
 -- Get the table of asset type names, which can be later used to get the specific items via LLInventory.collectDescendentsIf(...)
 function LLInventory.getAssetTypeNames()
-    return leap.request('LLInventory', {op = 'getAssetTypeNames'}).type_names
+    return leap.request('LLInventory', {op = 'getAssetTypeNames'}).names
 end
 
 -- Get the direct descendents of the 'folder_id' provided,
@@ -36,10 +36,10 @@ end
 -- [, name]              -- name (substring)
 -- [, desc]              -- description (substring)
 -- [, type]              -- asset type
--- [, item_limit]        -- item count limit in reply, maximum and default is 100
+-- [, limit]             -- item count limit in reply, maximum and default is 100
 -- [, filter_links]}     -- EXCLUDE_LINKS - don't show links, ONLY_LINKS - only show links, INCLUDE_LINKS - show links too (default)
 function LLInventory.collectDescendentsIf(...)
-    local args = mapargs('folder_id,name,desc,type,filter_links,item_limit', ...)
+    local args = mapargs('folder_id,name,desc,type,filter_links,limit', ...)
     args.op = 'collectDescendentsIf'
     return leap.request('LLInventory', args)
 end
diff --git a/indra/newview/scripts/lua/test_LLInventory.lua b/indra/newview/scripts/lua/test_LLInventory.lua
index dc6eb243ad..107b0791d4 100644
--- a/indra/newview/scripts/lua/test_LLInventory.lua
+++ b/indra/newview/scripts/lua/test_LLInventory.lua
@@ -4,7 +4,7 @@ LLInventory = require 'LLInventory'
 -- Get 'My Landmarks' folder id (you can see all folder types via LLInventory.getFolderTypeNames())
 my_landmarks_id = LLInventory.getBasicFolderID('landmark')
 -- Get 3 landmarks from the 'My Landmarks' folder (you can see all folder types via LLInventory.getAssetTypeNames())
-landmarks = LLInventory.collectDescendentsIf{folder_id=my_landmarks_id, type="landmark", item_limit=3}
+landmarks = LLInventory.collectDescendentsIf{folder_id=my_landmarks_id, type="landmark", limit=3}
 print(inspect(landmarks))
 
 -- Get 'Calling Cards' folder id
-- 
cgit v1.2.3


From 14c8fc3768d978205bf17ffc1905c2772afbd434 Mon Sep 17 00:00:00 2001
From: Nat Goodspeed <nat@lindenlab.com>
Date: Wed, 28 Aug 2024 16:47:38 -0400
Subject: Add `LL.setdtor()` function to add a "destructor" to any Lua object.

`setdtor('description', object, function)` returns a proxy userdata object
referencing object and function. When the proxy is garbage-collected, or at
the end of the script, its destructor calls `function(object)`.

The original object may be retrieved as `proxy._target`, e.g. to pass it to
the `table` library. The proxy also has a metatable with metamethods
supporting arithmetic operations, string concatenation, length and table
indexing. For other operations, retrieve `proxy._target`. (But don't assign to
`proxy._target`. It will appear to work, in that subsequent references to
`proxy._target` will retrieve the replacement object -- however, the
destructor will still call `function(original object)`.)

Fix bugs in `lua_setfieldv()`, `lua_rawgetfield()` and `lua_rawsetfield()`.

Add C++ functions `lua_destroyuserdata()` to explicitly destroy a
`lua_emplace<T>()` userdata object, plus `lua_destroybounduserdata()`. The
latter can bind such a userdata object as an upvalue to pass to `LL.atexit()`.

Make `LL.help()` and `LL.leaphelp()` help text include the `LL.` prefix.
---
 indra/newview/scripts/lua/test_setdtor.lua | 62 ++++++++++++++++++++++++++++++
 1 file changed, 62 insertions(+)
 create mode 100644 indra/newview/scripts/lua/test_setdtor.lua

(limited to 'indra/newview/scripts')

diff --git a/indra/newview/scripts/lua/test_setdtor.lua b/indra/newview/scripts/lua/test_setdtor.lua
new file mode 100644
index 0000000000..743c5168d0
--- /dev/null
+++ b/indra/newview/scripts/lua/test_setdtor.lua
@@ -0,0 +1,62 @@
+inspect = require 'inspect'
+
+print('initial setdtor')
+bye = LL.setdtor('initial setdtor', 'Goodbye world!', print)
+
+print('arithmetic')
+n = LL.setdtor('arithmetic', 11, print)
+print("n =", n)
+print("n._target =", n._target)
+print("getmetatable(n) =", inspect(getmetatable(n)))
+print("-n =", -n)
+for i = 10, 12 do
+    -- Comparison metamethods are only called if both operands have the same
+    -- metamethod.
+    tempi = LL.setdtor('tempi', i, function(n) print('temp', i) end)
+    print(`n <  {i}`, n <  tempi)
+    print(`n <= {i}`, n <= tempi)
+    print(`n == {i}`, n == tempi)
+    print(`n ~= {i}`, n ~= tempi)
+    print(`n >= {i}`, n >= tempi)
+    print(`n >  {i}`, n >  tempi)
+end
+for i = 2, 3 do
+    print(`n + {i} =`, n + i)
+    print(`{i} + n =`, i + n)
+    print(`n - {i} =`, n - i)
+    print(`{i} - n =`, i - n)
+    print(`n * {i} =`, n * i)
+    print(`{i} * n =`, i * n)
+    print(`n / {i} =`, n / i)
+    print(`{i} / n =`, i / n)
+    print(`n % {i} =`, n % i)
+    print(`{i} % n =`, i % n)
+    print(`n ^ {i} =`, n ^ i)
+    print(`{i} ^ n =`, i ^ n)
+end
+
+print('string')
+s = LL.setdtor('string', 'hello', print)
+print('s =', s)
+print('#s =', #s)
+print('s .. " world" =', s .. " world")
+print('"world " .. s =', "world " .. s)
+
+print('table')
+t = LL.setdtor('table', {'[1]', '[2]', abc='.abc', def='.def'},
+               function(t) print(inspect(t)) end)
+print('t =', inspect(t))
+print('t._target =', inspect(t._target))
+print('#t =', #t)
+print('t[2] =', t[2])
+print('t.def =', t.def)
+t[1] = 'new [1]'
+print('t[1] =', t[1])
+
+print('function')
+f = LL.setdtor('function', function(a, b) return (a .. b) end, print)
+print('f =', f)
+print('f._target =', f._target)
+print('f("Hello", " world") =', f("Hello", " world"))
+
+print('cleanup')
-- 
cgit v1.2.3


From 364ea79ab3a4d48e0d10fbeabb9b8e88f226baac Mon Sep 17 00:00:00 2001
From: Nat Goodspeed <nat@lindenlab.com>
Date: Wed, 28 Aug 2024 19:34:05 -0400
Subject: Prevent erroneous assignment to LL.setdtor() proxy._target field.

Trim redundant output from test_setdtor.lua.
---
 indra/newview/scripts/lua/test_setdtor.lua | 28 ++++++++++++++--------------
 1 file changed, 14 insertions(+), 14 deletions(-)

(limited to 'indra/newview/scripts')

diff --git a/indra/newview/scripts/lua/test_setdtor.lua b/indra/newview/scripts/lua/test_setdtor.lua
index 743c5168d0..61ed86dcc8 100644
--- a/indra/newview/scripts/lua/test_setdtor.lua
+++ b/indra/newview/scripts/lua/test_setdtor.lua
@@ -7,6 +7,7 @@ print('arithmetic')
 n = LL.setdtor('arithmetic', 11, print)
 print("n =", n)
 print("n._target =", n._target)
+print(pcall(function() n._target = 12 end))
 print("getmetatable(n) =", inspect(getmetatable(n)))
 print("-n =", -n)
 for i = 10, 12 do
@@ -20,20 +21,19 @@ for i = 10, 12 do
     print(`n >= {i}`, n >= tempi)
     print(`n >  {i}`, n >  tempi)
 end
-for i = 2, 3 do
-    print(`n + {i} =`, n + i)
-    print(`{i} + n =`, i + n)
-    print(`n - {i} =`, n - i)
-    print(`{i} - n =`, i - n)
-    print(`n * {i} =`, n * i)
-    print(`{i} * n =`, i * n)
-    print(`n / {i} =`, n / i)
-    print(`{i} / n =`, i / n)
-    print(`n % {i} =`, n % i)
-    print(`{i} % n =`, i % n)
-    print(`n ^ {i} =`, n ^ i)
-    print(`{i} ^ n =`, i ^ n)
-end
+i = 2
+print(`n + {i} =`, n + i)
+print(`{i} + n =`, i + n)
+print(`n - {i} =`, n - i)
+print(`{i} - n =`, i - n)
+print(`n * {i} =`, n * i)
+print(`{i} * n =`, i * n)
+print(`n / {i} =`, n / i)
+print(`{i} / n =`, i / n)
+print(`n % {i} =`, n % i)
+print(`{i} % n =`, i % n)
+print(`n ^ {i} =`, n ^ i)
+print(`{i} ^ n =`, i ^ n)
 
 print('string')
 s = LL.setdtor('string', 'hello', print)
-- 
cgit v1.2.3


From 2d5cf36be6e0e367efec2bfa01378146269f33db Mon Sep 17 00:00:00 2001
From: Nat Goodspeed <nat@lindenlab.com>
Date: Thu, 29 Aug 2024 21:36:39 -0400
Subject: Support next(), pairs(), ipairs() for LL.setdtor() table proxies.

Replace the global next(), pairs() and ipairs() functions with a C++ function
that drills down through layers of setdtor() proxy objects and then forwards
the updated arguments to the original global function.

Add a Luau __iter() metamethod to setdtor() proxy objects that, like other
proxy metamethods, drills down to the underlying _target object. __iter()
recognizes the case of a _target table which itself has a __iter() metamethod.

Also add __idiv() metamethod to support integer division.

Add tests for proxy // division, next(proxy), next(proxy, key), pairs(proxy),
ipairs(proxy) and 'for k, v in proxy'. Also test the case where the table
wrapped in the proxy has an __iter() metamethod of its own.
---
 indra/newview/scripts/lua/test_setdtor.lua | 29 +++++++++++++++++++++++++++++
 1 file changed, 29 insertions(+)

(limited to 'indra/newview/scripts')

diff --git a/indra/newview/scripts/lua/test_setdtor.lua b/indra/newview/scripts/lua/test_setdtor.lua
index 61ed86dcc8..ec5cd47e93 100644
--- a/indra/newview/scripts/lua/test_setdtor.lua
+++ b/indra/newview/scripts/lua/test_setdtor.lua
@@ -30,6 +30,8 @@ print(`n * {i} =`, n * i)
 print(`{i} * n =`, i * n)
 print(`n / {i} =`, n / i)
 print(`{i} / n =`, i / n)
+print(`n // {i} =`, n // i)
+print(`{i} // n =`, i // n)
 print(`n % {i} =`, n % i)
 print(`{i} % n =`, i % n)
 print(`n ^ {i} =`, n ^ i)
@@ -48,10 +50,37 @@ t = LL.setdtor('table', {'[1]', '[2]', abc='.abc', def='.def'},
 print('t =', inspect(t))
 print('t._target =', inspect(t._target))
 print('#t =', #t)
+print('next(t) =', next(t))
+print('next(t, 1) =', next(t, 1))
 print('t[2] =', t[2])
 print('t.def =', t.def)
 t[1] = 'new [1]'
 print('t[1] =', t[1])
+print('for k, v in pairs(t) do')
+for k, v in pairs(t) do
+    print(`{k}: {v}`)
+end
+print('for k, v in ipairs(t) do')
+for k, v in ipairs(t) do
+    print(`{k}: {v}`)
+end
+print('for k, v in t do')
+for k, v in t do
+    print(`{k}: {v}`)
+end
+-- and now for something completely different
+setmetatable(
+    t._target,
+    {
+        __iter = function(arg)
+            return next, {'alternate', '__iter'}
+        end
+    }
+)
+print('for k, v in t with __iter() metamethod do')
+for k, v in t do
+    print(`{k}: {v}`)
+end
 
 print('function')
 f = LL.setdtor('function', function(a, b) return (a .. b) end, print)
-- 
cgit v1.2.3


From 6e47dc1af90c242c792c90e93d013355c9a43b97 Mon Sep 17 00:00:00 2001
From: Mnikolenko Productengine <mnikolenko@productengine.com>
Date: Fri, 30 Aug 2024 12:18:20 +0300
Subject: Add Lua api to start/stop playing animation

---
 indra/newview/scripts/lua/require/LLAgent.lua | 14 ++++++++++++++
 1 file changed, 14 insertions(+)

(limited to 'indra/newview/scripts')

diff --git a/indra/newview/scripts/lua/require/LLAgent.lua b/indra/newview/scripts/lua/require/LLAgent.lua
index 5ee092f2f6..56907f53cd 100644
--- a/indra/newview/scripts/lua/require/LLAgent.lua
+++ b/indra/newview/scripts/lua/require/LLAgent.lua
@@ -53,4 +53,18 @@ function LLAgent.removeCamParams()
     leap.send('LLAgent', {op = 'removeCameraParams'})
 end
 
+function LLAgent.playAnimation(...)
+    local args = mapargs('item_id,inworld', ...)
+    args.op = 'playAnimation'
+    return leap.request('LLAgent', args)
+end
+
+function LLAgent.stopAnimation(item_id)
+    return leap.request('LLAgent', {op = 'stopAnimation', item_id=item_id})
+end
+
+function LLAgent.getAnimationInfo(item_id)
+    return leap.request('LLAgent', {op = 'getAnimationInfo', item_id=item_id}).anim_info
+end
+
 return LLAgent
-- 
cgit v1.2.3


From 4312a2b7703f6ba35a1cdcd1edc48dddfe084270 Mon Sep 17 00:00:00 2001
From: Mnikolenko Productengine <mnikolenko@productengine.com>
Date: Fri, 30 Aug 2024 14:48:36 +0300
Subject: Add throttle for playing an animation; add demo script

---
 indra/newview/scripts/lua/require/LLAgent.lua |  4 ++++
 indra/newview/scripts/lua/test_animation.lua  | 28 +++++++++++++++++++++++++++
 2 files changed, 32 insertions(+)
 create mode 100644 indra/newview/scripts/lua/test_animation.lua

(limited to 'indra/newview/scripts')

diff --git a/indra/newview/scripts/lua/require/LLAgent.lua b/indra/newview/scripts/lua/require/LLAgent.lua
index 56907f53cd..07ef1e0b0b 100644
--- a/indra/newview/scripts/lua/require/LLAgent.lua
+++ b/indra/newview/scripts/lua/require/LLAgent.lua
@@ -53,6 +53,8 @@ function LLAgent.removeCamParams()
     leap.send('LLAgent', {op = 'removeCameraParams'})
 end
 
+-- Play specified animation by "item_id" locally
+-- if "inworld" is specified as true, animation will be played inworld instead
 function LLAgent.playAnimation(...)
     local args = mapargs('item_id,inworld', ...)
     args.op = 'playAnimation'
@@ -63,6 +65,8 @@ function LLAgent.stopAnimation(item_id)
     return leap.request('LLAgent', {op = 'stopAnimation', item_id=item_id})
 end
 
+-- Get animation info by "item_id"
+-- reply contains "duration", "is_loop", "num_joints", "asset_id", "priority"
 function LLAgent.getAnimationInfo(item_id)
     return leap.request('LLAgent', {op = 'getAnimationInfo', item_id=item_id}).anim_info
 end
diff --git a/indra/newview/scripts/lua/test_animation.lua b/indra/newview/scripts/lua/test_animation.lua
new file mode 100644
index 0000000000..c16fef4918
--- /dev/null
+++ b/indra/newview/scripts/lua/test_animation.lua
@@ -0,0 +1,28 @@
+LLInventory = require 'LLInventory'
+LLAgent = require 'LLAgent'
+
+-- Get 'Animations' folder id (you can see all folder types via LLInventory.getFolderTypeNames())
+animations_id = LLInventory.getBasicFolderID('animatn')
+-- Get animations from the 'Animation' folder (you can see all folder types via LLInventory.getAssetTypeNames())
+anims = LLInventory.collectDescendentsIf{folder_id=animations_id, type="animatn"}.items
+
+local anim_ids = {}
+for key in pairs(anims) do
+    table.insert(anim_ids, key)
+end
+
+-- Start playing a random animation
+math.randomseed(os.time())
+local random_id = anim_ids[math.random(#anim_ids)]
+local anim_info = LLAgent.getAnimationInfo(random_id)
+
+print("Starting animation locally: " .. anims[random_id].name)
+print("Loop: " .. anim_info.is_loop .. " Joints: " .. anim_info.num_joints .. " Duration " .. tonumber(string.format("%.2f", anim_info.duration)))
+LLAgent.playAnimation{item_id=random_id}
+
+-- Stop animation after 3 sec if it's looped or longer than 3 sec
+if anim_info.is_loop == 1 or anim_info.duration > 3 then
+    LL.sleep(3)
+    print("Stop animation.")
+    LLAgent.stopAnimation(random_id)
+end
-- 
cgit v1.2.3


From 23f0aafb74551a741de8c87d62d74e7c6cee8b01 Mon Sep 17 00:00:00 2001
From: Nat Goodspeed <nat@lindenlab.com>
Date: Sat, 31 Aug 2024 09:42:52 -0400
Subject: Give certain LLInventory queries an API based on result sets.

Introduce abstract base class InvResultSet, derived from LLIntTracker so each
instance has a unique int key. InvResultSet supports virtual getLength() and
getSlice() operations. getSlice() returns an LLSD array limited to
MAX_ITEM_LIMIT result set entries. It permits retrieving a "slice" of the
contained result set starting at an arbitrary index. A sequence of getSlice()
calls can eventually retrieve a whole result set.

InvResultSet has subclasses CatResultSet containing cat_array_t, and
ItemResultSet containing item_array_t. Each implements a virtual method that
produces an LLSD map from a single array item.

Make LLInventoryListener::getItemsInfo(), getDirectDescendants() and
collectDescendantsIf() instantiate heap CatResultSet and ItemResultSet objects
containing the resultant LLPointer arrays, and return their int keys for
categories and items.

Add LLInventoryListener::getSlice() and closeResult() methods that accept the
int keys of result sets. getSlice() returns the requested LLSD array to its
caller, while closeResult() is fire-and-forget.

Because bulk data transfer is now performed by getSlice() rather than by
collectDescendantsIf(), change the latter's "limit" default to unlimited.
Allow the C++ code to collect an arbitrary number of LLPointer array entries,
as long as getSlice() limits retrieval overhead.

Spell "descendants" correctly, unlike the "descendents" spelling embedded in
the rest of the viewer... sigh. Make the Lua module provide both spellings.

Make MAX_ITEM_LIMIT a U32 instead of F32.

In LLInventory.lua, store int result set keys from 'getItemsInfo',
'getDirectDescendants' and 'collectDescendantsIf' in a table with a close()
function. The close() function invokes 'closeResult' with the bound int keys.

Give that table an __index() metamethod that recognizes only 'categories' and
'items' keys: anything else returns nil. For either of the recognized keys,
call 'getSlice' with the corresponding result set key to retrieve (the initial
slice of) the actual result set. Cache that result. Lazy retrieval means that
if the caller only cares about categories, or only about items, the other
result set need never be retrieved at all.

This is a first step: like the previous code, it still retrieves only up to
the first 100 result set entries. But the C++ code now supports retrieval of
additional slices, so extending result set retrieval is mostly Lua work.

Finally, wrap the table-with-metamethod in an LL.setdtor() proxy whose
destructor calls its close() method to tell LLInventoryListener to destroy the
CatResultSet and ItemResultSet with the bound keys.
---
 indra/newview/scripts/lua/require/LLInventory.lua | 79 +++++++++++++++++++----
 1 file changed, 68 insertions(+), 11 deletions(-)

(limited to 'indra/newview/scripts')

diff --git a/indra/newview/scripts/lua/require/LLInventory.lua b/indra/newview/scripts/lua/require/LLInventory.lua
index dd1b910250..0ff6b9fb37 100644
--- a/indra/newview/scripts/lua/require/LLInventory.lua
+++ b/indra/newview/scripts/lua/require/LLInventory.lua
@@ -1,12 +1,66 @@
 local leap = require 'leap'
 local mapargs = require 'mapargs'
 
+local function result(keys)
+    return LL.setdtor(
+        'LLInventory result',
+        setmetatable(
+            -- the basic table wrapped by setmetatable just captures the int
+            -- result-set keys from 'keys', but with underscore prefixes
+            {
+                _categories=keys.categories,
+                _items=keys.items,
+                -- call result:close() to release result sets before garbage
+                -- collection or script completion
+                close = function(self)
+                    leap.send('LLInventory',
+                              {op='closeResult',
+                               result={self._categories, self._items}})
+                end
+            },
+            -- The caller of one of our methods that returns a result set
+            -- isn't necessarily interested in both categories and items, so
+            -- don't proactively populate both. Instead, when caller references
+            -- either 'categories' or 'items', the __index() metamethod
+            -- populates that field.
+            {
+                __index = function(t, key)
+                    -- we really don't care about references to any other field
+                    if not table.find({'categories', 'items'}, key) then
+                        return nil
+                    end
+                    -- We cleverly saved the int result set key in a field
+                    -- with the same name but an underscore prefix.
+                    local resultkey = t['_' .. key]
+                    -- TODO: This only ever fetches the FIRST slice. What we
+                    -- really want is to return a table with metamethods that
+                    -- manage indexed access and table iteration.
+                    -- Remember our C++ entry point uses 0-relative indexing.
+                    local slice = leap.request(
+                        'LLInventory',
+                        {op='getSlice', result=resultkey, index=0}).slice
+                    print(`getSlice({resultkey}, 0) => {slice} ({#slice} entries)`)
+                    -- cache this slice for future reference
+                    t[key] = slice
+                    return slice
+                end
+            }
+        ),
+        -- When the table-with-metatable above is destroyed, tell LLInventory
+        -- we're done with its result sets -- whether or not we ever fetched
+        -- either of them.
+        function(keys)
+            keys:close()
+        end
+    )
+end
+
 local LLInventory = {}
 
 -- Get the items/folders info by provided IDs,
 -- reply will contain "items" and "categories" tables accordingly
 function LLInventory.getItemsInfo(item_ids)
-    return leap.request('LLInventory', {op = 'getItemsInfo', item_ids=item_ids})
+    return result(leap.request('LLInventory', {op = 'getItemsInfo', item_ids=item_ids}))
 end
 
 -- Get the table of folder type names, which can be later used to get the ID of the basic folders
@@ -19,30 +73,33 @@ function LLInventory.getBasicFolderID(ft_name)
     return leap.request('LLInventory', {op = 'getBasicFolderID', ft_name=ft_name}).id
 end
 
--- Get the table of asset type names, which can be later used to get the specific items via LLInventory.collectDescendentsIf(...)
+-- Get the table of asset type names, which can be later used to get the specific items via LLInventory.collectDescendantsIf(...)
 function LLInventory.getAssetTypeNames()
     return leap.request('LLInventory', {op = 'getAssetTypeNames'}).names
 end
 
--- Get the direct descendents of the 'folder_id' provided,
+-- Get the direct descendants of the 'folder_id' provided,
 -- reply will contain "items" and "categories" tables accordingly
-function LLInventory.getDirectDescendents(folder_id)
-    return leap.request('LLInventory', {op = 'getDirectDescendents', folder_id=folder_id})
+function LLInventory.getDirectDescendants(folder_id)
+    return result(leap.request('LLInventory', {op = 'getDirectDescendants', folder_id=folder_id}))
 end
+-- backwards compatibility
+LLInventory.getDirectDescendents = LLInventory.getDirectDescendants
 
--- Get the descendents of the 'folder_id' provided, which pass specified filters
+-- Get the descendants of the 'folder_id' provided, which pass specified filters
 -- reply will contain "items" and "categories" tables accordingly
--- LLInventory.collectDescendentsIf{ folder_id   -- parent folder ID
+-- LLInventory.collectDescendantsIf{ folder_id   -- parent folder ID
 -- [, name]              -- name (substring)
 -- [, desc]              -- description (substring)
 -- [, type]              -- asset type
 -- [, limit]             -- item count limit in reply, maximum and default is 100
 -- [, filter_links]}     -- EXCLUDE_LINKS - don't show links, ONLY_LINKS - only show links, INCLUDE_LINKS - show links too (default)
-function LLInventory.collectDescendentsIf(...)
+function LLInventory.collectDescendantsIf(...)
     local args = mapargs('folder_id,name,desc,type,filter_links,limit', ...)
-    args.op = 'collectDescendentsIf'
-    return leap.request('LLInventory', args)
+    args.op = 'collectDescendantsIf'
+    return result(leap.request('LLInventory', args))
 end
-
+-- backwards compatibility
+LLInventory.collectDescendentsIf = LLInventory.collectDescendantsIf
 
 return LLInventory
-- 
cgit v1.2.3


From 1101ed699a0c3c23c0bb11267d390febfdc02409 Mon Sep 17 00:00:00 2001
From: Nat Goodspeed <nat@lindenlab.com>
Date: Mon, 2 Sep 2024 16:41:09 -0400
Subject: Introduce result_view.lua, and use it in LLInventory.lua.

result_view(key_length, fetch) returns a virtual view of a potentially-large
C++ result set. Given the result-set key, its total length and a function
fetch(key, start) => (slice, adjusted start), the read-only table returned by
result_view() manages indexed access and table iteration over the entire
result set, fetching a slice at a time as required.

Change LLInventory to use result_view() instead of only ever fetching the
first slice of a result set.

TODO: This depends on the viewer's "LLInventory" listener returning the total
result set length as well as the result set key. It does not yet return the
length.
---
 indra/newview/scripts/lua/require/LLInventory.lua | 38 +++++++-------
 indra/newview/scripts/lua/require/result_view.lua | 62 +++++++++++++++++++++++
 2 files changed, 82 insertions(+), 18 deletions(-)
 create mode 100644 indra/newview/scripts/lua/require/result_view.lua

(limited to 'indra/newview/scripts')

diff --git a/indra/newview/scripts/lua/require/LLInventory.lua b/indra/newview/scripts/lua/require/LLInventory.lua
index 0ff6b9fb37..ce501e75f3 100644
--- a/indra/newview/scripts/lua/require/LLInventory.lua
+++ b/indra/newview/scripts/lua/require/LLInventory.lua
@@ -1,12 +1,14 @@
 local leap = require 'leap'
 local mapargs = require 'mapargs'
+local result_view = require 'result_view'
 
 local function result(keys)
     return LL.setdtor(
         'LLInventory result',
         setmetatable(
             -- the basic table wrapped by setmetatable just captures the int
-            -- result-set keys from 'keys', but with underscore prefixes
+            -- result-set {key, length} pairs from 'keys', but with underscore
+            -- prefixes
             {
                 _categories=keys.categories,
                 _items=keys.items,
@@ -15,7 +17,7 @@ local function result(keys)
                 close = function(self)
                     leap.send('LLInventory',
                               {op='closeResult',
-                               result={self._categories, self._items}})
+                               result={self._categories[1], self._items[1]}})
                 end
             },
             -- The caller of one of our methods that returns a result set
@@ -24,25 +26,25 @@ local function result(keys)
             -- either 'categories' or 'items', the __index() metamethod
             -- populates that field.
             {
-                __index = function(t, key)
+                __index = function(t, field)
                     -- we really don't care about references to any other field
-                    if not table.find({'categories', 'items'}, key) then
+                    if not table.find({'categories', 'items'}, field) then
                         return nil
                     end
-                    -- We cleverly saved the int result set key in a field
-                    -- with the same name but an underscore prefix.
-                    local resultkey = t['_' .. key]
-                    -- TODO: This only ever fetches the FIRST slice. What we
-                    -- really want is to return a table with metamethods that
-                    -- manage indexed access and table iteration.
-                    -- Remember our C++ entry point uses 0-relative indexing.
-                    local slice = leap.request(
-                        'LLInventory',
-                        {op='getSlice', result=resultkey, index=0}).slice
-                    print(`getSlice({resultkey}, 0) => {slice} ({#slice} entries)`)
-                    -- cache this slice for future reference
-                    t[key] = slice
-                    return slice
+                    local view = result_view(
+                        -- We cleverly saved the result set {key, length} pair in
+                        -- a field with the same name but an underscore prefix.
+                        t['_' .. field],
+                        function(key, start)
+                            local fetched = leap.request(
+                                'LLInventory',
+                                {op='getSlice', result=key, index=start})
+                            return fetched.slice, fetched.start
+                        end
+                    )
+                    -- cache that view for future reference
+                    t[field] = view
+                    return view
                 end
             }
         ),
diff --git a/indra/newview/scripts/lua/require/result_view.lua b/indra/newview/scripts/lua/require/result_view.lua
new file mode 100644
index 0000000000..4a58636f2f
--- /dev/null
+++ b/indra/newview/scripts/lua/require/result_view.lua
@@ -0,0 +1,62 @@
+-- result_view(key_length, fetch) returns a table which stores only a slice
+-- of a result set plus some control values, yet presents read-only virtual
+-- access to the entire result set.
+-- key_length: {result set key, total result set length}
+-- fetch:      function(key, start) that returns (slice, adjusted start) 
+local function result_view(key_length, fetch)
+    return setmetatable(
+        {
+            key=key_length[1],
+            length=key_length[2],
+            -- C++ result sets use 0-based indexing, so internally we do too
+            start=0,
+            -- start with a dummy array with length 0
+            slice={}
+        },
+        {
+            __len = function(this)
+                return this.length
+            end,
+            __index = function(this, i)
+                -- right away, convert to 0-relative indexing
+                i -= 1
+                -- can we find this index within the current slice?
+                local reli = i - this.start
+                if 0 <= reli and reli < #this.slice then
+                    return this.slice[reli]
+                end
+                -- is this index outside the overall result set?
+                if not (0 <= i and i < this.length) then
+                    return nil
+                end
+                -- fetch a new slice starting at i, using provided fetch()
+                local start
+                this.slice, start = fetch(key, i)
+                -- It's possible that caller-provided fetch() function forgot
+                -- to return the adjusted start index of the new slice. In
+                -- Lua, 0 tests as true, so if fetch() returned (slice, 0),
+                -- we'll duly reset this.start to 0.
+                if start then
+                    this.start = start
+                end
+                -- hopefully this slice contains the desired i
+                return this.slice[i - this.start]
+            end,
+            -- We purposely avoid putting any array entries (int keys) into
+            -- our table so that access to any int key will always call our
+            -- __index() metamethod. Moreover, we want any table iteration to
+            -- call __index(table, i) however many times; we do NOT want it to
+            -- retrieve key, length, start, slice.
+            -- So turn 'for k, v in result' into 'for k, v in ipairs(result)'.
+            __iter = ipairs,
+            -- This result set provides read-only access.
+            -- We do not support pushing updates to individual items back to
+            -- C++; for the intended use cases, that makes no sense.
+            __newindex = function(this, i, value)
+                error("result_view is a read-only data structure", 2)
+            end
+        }
+    )
+end
+
+return result_view
-- 
cgit v1.2.3


From 6a4b9b1184c142ca1b317296fa12304bf231fc7d Mon Sep 17 00:00:00 2001
From: Nat Goodspeed <nat@lindenlab.com>
Date: Tue, 3 Sep 2024 12:34:21 -0400
Subject: Add test_result_view.lua; fix minor bugs in result_view.lua.

---
 indra/newview/scripts/lua/require/result_view.lua | 18 ++++----
 indra/newview/scripts/lua/test_result_view.lua    | 55 +++++++++++++++++++++++
 2 files changed, 65 insertions(+), 8 deletions(-)
 create mode 100644 indra/newview/scripts/lua/test_result_view.lua

(limited to 'indra/newview/scripts')

diff --git a/indra/newview/scripts/lua/require/result_view.lua b/indra/newview/scripts/lua/require/result_view.lua
index 4a58636f2f..d53d953c24 100644
--- a/indra/newview/scripts/lua/require/result_view.lua
+++ b/indra/newview/scripts/lua/require/result_view.lua
@@ -23,7 +23,8 @@ local function result_view(key_length, fetch)
                 -- can we find this index within the current slice?
                 local reli = i - this.start
                 if 0 <= reli and reli < #this.slice then
-                    return this.slice[reli]
+                    -- Lua 1-relative indexing
+                    return this.slice[reli + 1]
                 end
                 -- is this index outside the overall result set?
                 if not (0 <= i and i < this.length) then
@@ -31,16 +32,17 @@ local function result_view(key_length, fetch)
                 end
                 -- fetch a new slice starting at i, using provided fetch()
                 local start
-                this.slice, start = fetch(key, i)
+                this.slice, start = fetch(this.key, i)
                 -- It's possible that caller-provided fetch() function forgot
                 -- to return the adjusted start index of the new slice. In
                 -- Lua, 0 tests as true, so if fetch() returned (slice, 0),
-                -- we'll duly reset this.start to 0.
-                if start then
-                    this.start = start
-                end
-                -- hopefully this slice contains the desired i
-                return this.slice[i - this.start]
+                -- we'll duly reset this.start to 0. Otherwise, assume the
+                -- requested index was not adjusted: that the returned slice
+                -- really does start at i.
+                this.start = start or i
+                -- Hopefully this slice contains the desired i.
+                -- Back to 1-relative indexing.
+                return this.slice[i - this.start + 1]
             end,
             -- We purposely avoid putting any array entries (int keys) into
             -- our table so that access to any int key will always call our
diff --git a/indra/newview/scripts/lua/test_result_view.lua b/indra/newview/scripts/lua/test_result_view.lua
new file mode 100644
index 0000000000..304633a472
--- /dev/null
+++ b/indra/newview/scripts/lua/test_result_view.lua
@@ -0,0 +1,55 @@
+-- Verify the functionality of result_view.
+result_view = require 'result_view'
+
+print('alphabet')
+alphabet = "abcdefghijklmnopqrstuvwxyz"
+assert(#alphabet == 26)
+alphabits = string.split(alphabet, '')
+
+print('function slice()')
+function slice(t, index, count)
+    return table.move(t, index, index + count - 1, 1, {})
+end
+
+print('verify slice()')
+-- verify that slice() does what we expect
+assert(table.concat(slice(alphabits, 4, 3))  == "def")
+assert(table.concat(slice(alphabits, 14, 3)) == "nop")
+assert(table.concat(slice(alphabits, 25, 3)) == "yz")
+
+print('function fetch()')
+function fetch(key, index)
+    -- fetch function is defined to be 0-relative: fix for Lua data
+    -- constrain view of alphabits to slices of at most 3 elements
+    return slice(alphabits, index+1, 3), index
+end
+
+print('result_view()')
+-- for test purposes, key is irrelevant, so just 'key'
+view = result_view({'key', #alphabits}, fetch)
+
+print('function check_iter()')
+function check_iter(...)
+    result = {}
+    for k, v in ... do
+        table.insert(result, v)
+    end
+    assert(table.concat(result) == alphabet)
+end
+
+print('check_iter(pairs(view))')
+check_iter(pairs(view))
+print('check_iter(ipairs(view))')
+check_iter(ipairs(view))
+print('check_iter(view)')
+check_iter(view)
+
+print('raw index access')
+assert(view[5]  == 'e')
+assert(view[10] == 'j')
+assert(view[15] == 'o')
+assert(view[20] == 't')
+assert(view[25] == 'y')
+
+print('Success!')
+
-- 
cgit v1.2.3


From 2157fa4fa9acf4db6093b962569274105e4d1fb4 Mon Sep 17 00:00:00 2001
From: Nat Goodspeed <nat@lindenlab.com>
Date: Tue, 3 Sep 2024 12:52:34 -0400
Subject: result_view() now reuses same metatable instance for every table.

---
 indra/newview/scripts/lua/require/result_view.lua | 97 ++++++++++++-----------
 1 file changed, 51 insertions(+), 46 deletions(-)

(limited to 'indra/newview/scripts')

diff --git a/indra/newview/scripts/lua/require/result_view.lua b/indra/newview/scripts/lua/require/result_view.lua
index d53d953c24..c719681c66 100644
--- a/indra/newview/scripts/lua/require/result_view.lua
+++ b/indra/newview/scripts/lua/require/result_view.lua
@@ -1,3 +1,50 @@
+-- metatable for every result_view() table
+local mt = {
+    __len = function(this)
+        return this.length
+    end,
+    __index = function(this, i)
+        -- right away, convert to 0-relative indexing
+        i -= 1
+        -- can we find this index within the current slice?
+        local reli = i - this.start
+        if 0 <= reli and reli < #this.slice then
+            -- Lua 1-relative indexing
+            return this.slice[reli + 1]
+        end
+        -- is this index outside the overall result set?
+        if not (0 <= i and i < this.length) then
+            return nil
+        end
+        -- fetch a new slice starting at i, using provided fetch()
+        local start
+        this.slice, start = this.fetch(this.key, i)
+        -- It's possible that caller-provided fetch() function forgot
+        -- to return the adjusted start index of the new slice. In
+        -- Lua, 0 tests as true, so if fetch() returned (slice, 0),
+        -- we'll duly reset this.start to 0. Otherwise, assume the
+        -- requested index was not adjusted: that the returned slice
+        -- really does start at i.
+        this.start = start or i
+        -- Hopefully this slice contains the desired i.
+        -- Back to 1-relative indexing.
+        return this.slice[i - this.start + 1]
+    end,
+    -- We purposely avoid putting any array entries (int keys) into
+    -- our table so that access to any int key will always call our
+    -- __index() metamethod. Moreover, we want any table iteration to
+    -- call __index(table, i) however many times; we do NOT want it to
+    -- retrieve key, length, start, slice.
+    -- So turn 'for k, v in result' into 'for k, v in ipairs(result)'.
+    __iter = ipairs,
+    -- This result set provides read-only access.
+    -- We do not support pushing updates to individual items back to
+    -- C++; for the intended use cases, that makes no sense.
+    __newindex = function(this, i, value)
+        error("result_view is a read-only data structure", 2)
+    end
+}
+
 -- result_view(key_length, fetch) returns a table which stores only a slice
 -- of a result set plus some control values, yet presents read-only virtual
 -- access to the entire result set.
@@ -11,53 +58,11 @@ local function result_view(key_length, fetch)
             -- C++ result sets use 0-based indexing, so internally we do too
             start=0,
             -- start with a dummy array with length 0
-            slice={}
+            slice={},
+            fetch=fetch
         },
-        {
-            __len = function(this)
-                return this.length
-            end,
-            __index = function(this, i)
-                -- right away, convert to 0-relative indexing
-                i -= 1
-                -- can we find this index within the current slice?
-                local reli = i - this.start
-                if 0 <= reli and reli < #this.slice then
-                    -- Lua 1-relative indexing
-                    return this.slice[reli + 1]
-                end
-                -- is this index outside the overall result set?
-                if not (0 <= i and i < this.length) then
-                    return nil
-                end
-                -- fetch a new slice starting at i, using provided fetch()
-                local start
-                this.slice, start = fetch(this.key, i)
-                -- It's possible that caller-provided fetch() function forgot
-                -- to return the adjusted start index of the new slice. In
-                -- Lua, 0 tests as true, so if fetch() returned (slice, 0),
-                -- we'll duly reset this.start to 0. Otherwise, assume the
-                -- requested index was not adjusted: that the returned slice
-                -- really does start at i.
-                this.start = start or i
-                -- Hopefully this slice contains the desired i.
-                -- Back to 1-relative indexing.
-                return this.slice[i - this.start + 1]
-            end,
-            -- We purposely avoid putting any array entries (int keys) into
-            -- our table so that access to any int key will always call our
-            -- __index() metamethod. Moreover, we want any table iteration to
-            -- call __index(table, i) however many times; we do NOT want it to
-            -- retrieve key, length, start, slice.
-            -- So turn 'for k, v in result' into 'for k, v in ipairs(result)'.
-            __iter = ipairs,
-            -- This result set provides read-only access.
-            -- We do not support pushing updates to individual items back to
-            -- C++; for the intended use cases, that makes no sense.
-            __newindex = function(this, i, value)
-                error("result_view is a read-only data structure", 2)
-            end
-        }
+        -- use our special metatable
+        mt
     )
 end
 
-- 
cgit v1.2.3


From 93c21b503abdf4f9530064f8c3f1df7ea0dc244f Mon Sep 17 00:00:00 2001
From: Nat Goodspeed <nat@lindenlab.com>
Date: Tue, 3 Sep 2024 13:01:11 -0400
Subject: test_inv_resultset.lua exercises LLInventory's result-set
 functionality.

---
 indra/newview/scripts/lua/test_inv_resultset.lua | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)
 create mode 100644 indra/newview/scripts/lua/test_inv_resultset.lua

(limited to 'indra/newview/scripts')

diff --git a/indra/newview/scripts/lua/test_inv_resultset.lua b/indra/newview/scripts/lua/test_inv_resultset.lua
new file mode 100644
index 0000000000..c31cfe3c67
--- /dev/null
+++ b/indra/newview/scripts/lua/test_inv_resultset.lua
@@ -0,0 +1,18 @@
+local LLInventory = require 'LLInventory'
+local inspect = require 'inspect'
+
+print('basic folders:')
+print(inspect(LLInventory.getFolderTypeNames()))
+
+local folder = LLInventory.getBasicFolderID('my_otfts')
+print(`folder = {folder}`)
+local result = LLInventory.getDirectDescendants(folder)
+print(`type(result) = {type(result)}`)
+print(#result.categories, 'categories:')
+for i, cat in pairs(result.categories) do
+    print(`{i}: {cat.name}`)
+end
+print(#result.items, 'items')
+for i, item in pairs(result.items) do
+    print(`{i}: {item.name}`)
+end
-- 
cgit v1.2.3


From 83eace32cfccc672e7a5a2841bd7d844dce0ea3e Mon Sep 17 00:00:00 2001
From: Nat Goodspeed <nat@lindenlab.com>
Date: Tue, 3 Sep 2024 13:13:22 -0400
Subject: Iterate to print landmarks returned by LLInventory.

At this point, inspect(landmarks) just returns "<userdata 1>".
---
 indra/newview/scripts/lua/test_LLInventory.lua | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

(limited to 'indra/newview/scripts')

diff --git a/indra/newview/scripts/lua/test_LLInventory.lua b/indra/newview/scripts/lua/test_LLInventory.lua
index 107b0791d4..918ca56a2e 100644
--- a/indra/newview/scripts/lua/test_LLInventory.lua
+++ b/indra/newview/scripts/lua/test_LLInventory.lua
@@ -5,7 +5,9 @@ LLInventory = require 'LLInventory'
 my_landmarks_id = LLInventory.getBasicFolderID('landmark')
 -- Get 3 landmarks from the 'My Landmarks' folder (you can see all folder types via LLInventory.getAssetTypeNames())
 landmarks = LLInventory.collectDescendentsIf{folder_id=my_landmarks_id, type="landmark", limit=3}
-print(inspect(landmarks))
+for _, landmark in pairs(landmarks.items) do
+    print(landmark.name)
+end
 
 -- Get 'Calling Cards' folder id
 calling_cards_id = LLInventory.getBasicFolderID('callcard')
-- 
cgit v1.2.3


From f3896d37ca625a4f7060ee5139a8825c2f6e6a74 Mon Sep 17 00:00:00 2001
From: Nat Goodspeed <nat@lindenlab.com>
Date: Tue, 3 Sep 2024 20:39:14 -0400
Subject: Generalize Lua-side result-set machinery for other use cases.

Change `result_view()` from a simple function to a callable table so we can
add conventional/default functions to it: `result_view.fetch()` is a generic
`fetch()` function suitable for use with `result_view()`, and `result_view.close()`
is a variadic function that closes result sets for whichever keys are passed.

This arises from the fact that any `LL::ResultSet` subclass is accessed
generically through its base class, therefore we don't need distinct
"getSlice" and "closeResult" operations for different `LLEventAPI` listeners.
(It might make sense to relocate those operations to a new generic listener,
but for now "LLInventory" works.)

That lets `result_view()`'s caller omit the `fetch` parameter unless it
requires special behavior. Omitting it uses the generic `result_view.fetch()`
function.

Moreover, every view returned by `result_view()` now contains a close()
function that closes that view's result set.

The table returned by LLInventory.lua's `result()` function has a `close()`
method; that method can now call `result_view.close()` with the two keys of
interest. That table's `__index()` metamethod can now leverage `result_view()`'s
default `fetch` function.
---
 indra/newview/scripts/lua/require/LLInventory.lua | 22 ++----
 indra/newview/scripts/lua/require/result_view.lua | 83 +++++++++++++++--------
 2 files changed, 62 insertions(+), 43 deletions(-)

(limited to 'indra/newview/scripts')

diff --git a/indra/newview/scripts/lua/require/LLInventory.lua b/indra/newview/scripts/lua/require/LLInventory.lua
index ce501e75f3..9cf72a8678 100644
--- a/indra/newview/scripts/lua/require/LLInventory.lua
+++ b/indra/newview/scripts/lua/require/LLInventory.lua
@@ -15,9 +15,7 @@ local function result(keys)
                 -- call result:close() to release result sets before garbage
                 -- collection or script completion
                 close = function(self)
-                    leap.send('LLInventory',
-                              {op='closeResult',
-                               result={self._categories[1], self._items[1]}})
+                    result_view.close(self._categories[1], self._items[1])
                 end
             },
             -- The caller of one of our methods that returns a result set
@@ -31,17 +29,9 @@ local function result(keys)
                     if not table.find({'categories', 'items'}, field) then
                         return nil
                     end
-                    local view = result_view(
-                        -- We cleverly saved the result set {key, length} pair in
-                        -- a field with the same name but an underscore prefix.
-                        t['_' .. field],
-                        function(key, start)
-                            local fetched = leap.request(
-                                'LLInventory',
-                                {op='getSlice', result=key, index=start})
-                            return fetched.slice, fetched.start
-                        end
-                    )
+                    -- We cleverly saved the result set {key, length} pair in
+                    -- a field with the same name but an underscore prefix.
+                    local view = result_view(t['_' .. field])
                     -- cache that view for future reference
                     t[field] = view
                     return view
@@ -51,8 +41,8 @@ local function result(keys)
         -- When the table-with-metatable above is destroyed, tell LLInventory
         -- we're done with its result sets -- whether or not we ever fetched
         -- either of them.
-        function(keys)
-            keys:close()
+        function(res)
+            res:close()
         end
     )
 end
diff --git a/indra/newview/scripts/lua/require/result_view.lua b/indra/newview/scripts/lua/require/result_view.lua
index c719681c66..5301d7838c 100644
--- a/indra/newview/scripts/lua/require/result_view.lua
+++ b/indra/newview/scripts/lua/require/result_view.lua
@@ -1,34 +1,36 @@
+local leap = require 'leap'
+
 -- metatable for every result_view() table
 local mt = {
-    __len = function(this)
-        return this.length
+    __len = function(self)
+        return self.length
     end,
-    __index = function(this, i)
+    __index = function(self, i)
         -- right away, convert to 0-relative indexing
         i -= 1
         -- can we find this index within the current slice?
-        local reli = i - this.start
-        if 0 <= reli and reli < #this.slice then
+        local reli = i - self.start
+        if 0 <= reli and reli < #self.slice then
             -- Lua 1-relative indexing
-            return this.slice[reli + 1]
+            return self.slice[reli + 1]
         end
         -- is this index outside the overall result set?
-        if not (0 <= i and i < this.length) then
+        if not (0 <= i and i < self.length) then
             return nil
         end
         -- fetch a new slice starting at i, using provided fetch()
         local start
-        this.slice, start = this.fetch(this.key, i)
+        self.slice, start = self.fetch(self.key, i)
         -- It's possible that caller-provided fetch() function forgot
         -- to return the adjusted start index of the new slice. In
         -- Lua, 0 tests as true, so if fetch() returned (slice, 0),
-        -- we'll duly reset this.start to 0. Otherwise, assume the
+        -- we'll duly reset self.start to 0. Otherwise, assume the
         -- requested index was not adjusted: that the returned slice
         -- really does start at i.
-        this.start = start or i
+        self.start = start or i
         -- Hopefully this slice contains the desired i.
         -- Back to 1-relative indexing.
-        return this.slice[i - this.start + 1]
+        return self.slice[i - self.start + 1]
     end,
     -- We purposely avoid putting any array entries (int keys) into
     -- our table so that access to any int key will always call our
@@ -40,7 +42,7 @@ local mt = {
     -- This result set provides read-only access.
     -- We do not support pushing updates to individual items back to
     -- C++; for the intended use cases, that makes no sense.
-    __newindex = function(this, i, value)
+    __newindex = function(self, i, value)
         error("result_view is a read-only data structure", 2)
     end
 }
@@ -50,20 +52,47 @@ local mt = {
 -- access to the entire result set.
 -- key_length: {result set key, total result set length}
 -- fetch:      function(key, start) that returns (slice, adjusted start) 
-local function result_view(key_length, fetch)
-    return setmetatable(
-        {
-            key=key_length[1],
-            length=key_length[2],
-            -- C++ result sets use 0-based indexing, so internally we do too
-            start=0,
-            -- start with a dummy array with length 0
-            slice={},
-            fetch=fetch
-        },
-        -- use our special metatable
-        mt
-    )
-end
+local result_view = setmetatable(
+    {
+        -- generic fetch() function
+        fetch = function(key, start)
+            local fetched = leap.request(
+                'LLInventory',
+                {op='getSlice', result=key, index=start})
+            return fetched.slice, fetched.start
+        end,
+        -- generic close() function accepting variadic result-set keys
+        close = function(...)
+            local keys = table.pack(...)
+            -- table.pack() produces a table with an array entry for every
+            -- parameter, PLUS an 'n' key with the count. Unfortunately that
+            -- 'n' key bollixes our conversion to LLSD, which requires either
+            -- all int keys (for an array) or all string keys (for a map).
+            keys.n = nil
+            leap.send('LLInventory', {op='closeResult', result=keys})
+        end
+    },
+    {
+        -- result_view(key_length, fetch) calls this
+        __call = function(class, key_length, fetch)
+            return setmetatable(
+                {
+                    key=key_length[1],
+                    length=key_length[2],
+                    -- C++ result sets use 0-based indexing, so internally we do too
+                    start=0,
+                    -- start with a dummy array with length 0
+                    slice={},
+                    -- if caller didn't pass fetch() function, use generic
+                    fetch=fetch or class.fetch,
+                    -- returned view:close() will close result set with passed key
+                    close=function(self) class.close(key_length[1]) end
+                },
+                -- use our special metatable
+                mt
+            )
+        end
+    }
+)
 
 return result_view
-- 
cgit v1.2.3


From a8dd7135f0423384dbbb1e3b98514149c6a69e6b Mon Sep 17 00:00:00 2001
From: Nat Goodspeed <nat@lindenlab.com>
Date: Tue, 3 Sep 2024 20:50:18 -0400
Subject: Use Lua result-set logic for "LLFloaterReg"s "getFloaterNames" op.

This is the query that produced so many results that, before we lifted the
infinite-loop interrupt limit, inspect(result) hit the limit and terminated.
---
 indra/newview/scripts/lua/require/UI.lua | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

(limited to 'indra/newview/scripts')

diff --git a/indra/newview/scripts/lua/require/UI.lua b/indra/newview/scripts/lua/require/UI.lua
index bbcae3514a..aa64c0c7f9 100644
--- a/indra/newview/scripts/lua/require/UI.lua
+++ b/indra/newview/scripts/lua/require/UI.lua
@@ -2,6 +2,7 @@
 
 local leap = require 'leap'
 local mapargs = require 'mapargs'
+local result_view = require 'result_view'
 local Timer = (require 'timers').Timer
 local util = require 'util'
 
@@ -234,7 +235,12 @@ function UI.closeAllFloaters()
 end
 
 function UI.getFloaterNames()
-    return leap.request("LLFloaterReg", {op = "getFloaterNames"}).floaters
+    local key_length = leap.request("LLFloaterReg", {op = "getFloaterNames"}).floaters
+    local view = result_view(key_length)
+    return LL.setdtor(
+        'registered floater names',
+        view,
+        function(self) view:close() end)
 end
 
 return UI
-- 
cgit v1.2.3


From 35c3f0227c334e059abdc36c36cc942a517d92ec Mon Sep 17 00:00:00 2001
From: Nat Goodspeed <nat@lindenlab.com>
Date: Wed, 4 Sep 2024 07:43:48 -0400
Subject: Instead of traversing all calling cards, pick a selected few.

Make test_LLInventory.lua directly select from the calling_cards result set,
instead of first copying all names to a separate array.
---
 indra/newview/scripts/lua/test_LLInventory.lua | 11 ++++++-----
 1 file changed, 6 insertions(+), 5 deletions(-)

(limited to 'indra/newview/scripts')

diff --git a/indra/newview/scripts/lua/test_LLInventory.lua b/indra/newview/scripts/lua/test_LLInventory.lua
index 918ca56a2e..de57484bcd 100644
--- a/indra/newview/scripts/lua/test_LLInventory.lua
+++ b/indra/newview/scripts/lua/test_LLInventory.lua
@@ -15,9 +15,10 @@ calling_cards_id = LLInventory.getBasicFolderID('callcard')
 calling_cards = LLInventory.getDirectDescendents(calling_cards_id).items
 
 -- Print a random calling card name from 'Calling Cards' folder
-local card_names = {}
-for _, value in pairs(calling_cards) do
-    table.insert(card_names, value.name)
-end
+-- (because getDirectDescendents().items is a Lua result set, selecting
+-- a random entry only fetches one slice containing that entry)
 math.randomseed(os.time())
-print("Random calling card: " .. inspect(card_names[math.random(#card_names)]))
+for i = 1, 5 do
+    pick = math.random(#calling_cards)
+    print(`Random calling card (#{pick} of {#calling_cards}): {calling_cards[pick].name}`)
+end
-- 
cgit v1.2.3


From d67ad5da3b5a37f7b4cb78e686ae36f31c513153 Mon Sep 17 00:00:00 2001
From: Nat Goodspeed <nat@lindenlab.com>
Date: Wed, 4 Sep 2024 09:15:10 -0400
Subject: `result_view()`'s table's `close()` method need not be further
 wrapped.

`LL.setdtor(desc, table, func)` eventually calls `func(table)`. So the
`close()` method on the table returned by `result_view()` can be directly
passed to `setdtor()`, instead of wrapped in a new anonymous function whose
only job is to pass the table to it.

Moreover, there's no need for the table returned by LLInventory.lua's
`result()` function to lazily instantiate the `result_view()` for `categories`
or `items`: neither `result_view` will fetch a slice unless asked. Just return
`{categories=result_view(...), items=result_view(...), close=...}`. This
dramatically simplifies the `result()` function.

Since that table also defines a `close()` function, that too can be passed
directly to `setdtor()` without being wrapped in a new anonymous function.
---
 indra/newview/scripts/lua/require/LLInventory.lua | 52 +++++------------------
 indra/newview/scripts/lua/require/UI.lua          |  5 +--
 2 files changed, 12 insertions(+), 45 deletions(-)

(limited to 'indra/newview/scripts')

diff --git a/indra/newview/scripts/lua/require/LLInventory.lua b/indra/newview/scripts/lua/require/LLInventory.lua
index 9cf72a8678..2c80a8602b 100644
--- a/indra/newview/scripts/lua/require/LLInventory.lua
+++ b/indra/newview/scripts/lua/require/LLInventory.lua
@@ -3,48 +3,18 @@ local mapargs = require 'mapargs'
 local result_view = require 'result_view'
 
 local function result(keys)
-    return LL.setdtor(
-        'LLInventory result',
-        setmetatable(
-            -- the basic table wrapped by setmetatable just captures the int
-            -- result-set {key, length} pairs from 'keys', but with underscore
-            -- prefixes
-            {
-                _categories=keys.categories,
-                _items=keys.items,
-                -- call result:close() to release result sets before garbage
-                -- collection or script completion
-                close = function(self)
-                    result_view.close(self._categories[1], self._items[1])
-                end
-            },
-            -- The caller of one of our methods that returns a result set
-            -- isn't necessarily interested in both categories and items, so
-            -- don't proactively populate both. Instead, when caller references
-            -- either 'categories' or 'items', the __index() metamethod
-            -- populates that field.
-            {
-                __index = function(t, field)
-                    -- we really don't care about references to any other field
-                    if not table.find({'categories', 'items'}, field) then
-                        return nil
-                    end
-                    -- We cleverly saved the result set {key, length} pair in
-                    -- a field with the same name but an underscore prefix.
-                    local view = result_view(t['_' .. field])
-                    -- cache that view for future reference
-                    t[field] = view
-                    return view
-                end
-            }
-        ),
-        -- When the table-with-metatable above is destroyed, tell LLInventory
-        -- we're done with its result sets -- whether or not we ever fetched
-        -- either of them.
-        function(res)
-            res:close()
+    -- capture result_view() instances for both categories and items
+    local result_table = {
+        categories=result_view(keys.categories),
+        items=result_view(keys.items),
+        -- call result_table:close() to release result sets before garbage
+        -- collection or script completion
+        close = function(self)
+            result_view.close(keys.categories[1], keys.items[1])
         end
-    )
+    }
+    -- When the result_table is destroyed, close its result_views.
+    return LL.setdtor('LLInventory result', result_table, result_table.close)
 end
 
 local LLInventory = {}
diff --git a/indra/newview/scripts/lua/require/UI.lua b/indra/newview/scripts/lua/require/UI.lua
index aa64c0c7f9..73a76fa6b8 100644
--- a/indra/newview/scripts/lua/require/UI.lua
+++ b/indra/newview/scripts/lua/require/UI.lua
@@ -237,10 +237,7 @@ end
 function UI.getFloaterNames()
     local key_length = leap.request("LLFloaterReg", {op = "getFloaterNames"}).floaters
     local view = result_view(key_length)
-    return LL.setdtor(
-        'registered floater names',
-        view,
-        function(self) view:close() end)
+    return LL.setdtor('registered floater names', view, view.close)
 end
 
 return UI
-- 
cgit v1.2.3


From 8c68abb2f63d54aeb4614c63a109b838ed8d0656 Mon Sep 17 00:00:00 2001
From: Nat Goodspeed <nat@lindenlab.com>
Date: Fri, 6 Sep 2024 15:14:59 -0400
Subject: Remove Lua floaters from menu_viewer.xml; re-add if Lua enabled.

Add a menus.lua autorun script that waits until login, then adds the Lua
floaters back into the Develop->Consoles menu where they were originally.

Extend UI.addMenuItem() and addMenuSeparator() to support pos argument.
---
 indra/newview/scripts/lua/auto/menus.lua | 51 ++++++++++++++++++++++++++++++++
 indra/newview/scripts/lua/require/UI.lua |  4 +--
 2 files changed, 53 insertions(+), 2 deletions(-)
 create mode 100644 indra/newview/scripts/lua/auto/menus.lua

(limited to 'indra/newview/scripts')

diff --git a/indra/newview/scripts/lua/auto/menus.lua b/indra/newview/scripts/lua/auto/menus.lua
new file mode 100644
index 0000000000..b2f54d83df
--- /dev/null
+++ b/indra/newview/scripts/lua/auto/menus.lua
@@ -0,0 +1,51 @@
+-- Inject Lua-related menus into the top menu structure. Run this as a Lua
+-- script so that turning off the Lua feature also disables these menus.
+
+-- Under Develop -> Consoles, want to present the equivalent of:
+-- <menu_item_separator/>
+-- <menu_item_check
+--     label="LUA Debug Console"
+--     name="LUA Debug Console">
+--   <menu_item_check.on_check
+--       function="Floater.Visible"
+--       parameter="lua_debug" />
+--   <menu_item_check.on_click
+--       function="Floater.Toggle"
+--       parameter="lua_debug" />
+-- </menu_item_check>
+-- <menu_item_check
+--     label="LUA Scripts Info"
+--     name="LUA Scripts">
+--   <menu_item_check.on_check
+--       function="Floater.Visible"
+--       parameter="lua_scripts" />
+--   <menu_item_check.on_click
+--       function="Floater.Toggle"
+--       parameter="lua_scripts" />
+-- </menu_item_check>
+
+local startup = require 'startup'
+local UI = require 'UI'
+
+-- Don't mess with the viewer's menu structure until we've logged in.
+startup.wait('STATE_STARTED')
+
+-- Add LUA Debug Console to Develop->Consoles
+local pos = 9
+UI.addMenuSeparator{
+    parent_menu='Consoles', pos=pos,
+}
+pos += 1
+UI.addMenuItem{
+    parent_menu='Consoles', pos=pos,
+    name='lua_debug', label='LUA Debug Console',
+    func='Floater.ToggleOrBringToFront', param='lua_debug',
+}
+pos += 1
+
+-- Add LUA Scripts Info to Develop->Consoles
+UI.addMenuItem{
+    parent_menu='Consoles', pos=pos,
+    name='lua_scripts', label='LUA Scripts Info',
+    func='Floater.ToggleOrBringToFront', param='lua_scripts',
+}
diff --git a/indra/newview/scripts/lua/require/UI.lua b/indra/newview/scripts/lua/require/UI.lua
index 73a76fa6b8..cf2695917e 100644
--- a/indra/newview/scripts/lua/require/UI.lua
+++ b/indra/newview/scripts/lua/require/UI.lua
@@ -170,13 +170,13 @@ end
 
 -- see UI.callables() for valid values of 'func'
 function UI.addMenuItem(...)
-    local args = mapargs('name,label,parent_menu,func,param', ...)
+    local args = mapargs('name,label,parent_menu,func,param,pos', ...)
     args.op = 'addMenuItem'
     return leap.request('UI', args)
 end
 
 function UI.addMenuSeparator(...)
-    local args = mapargs('parent_menu', ...)
+    local args = mapargs('parent_menu,pos', ...)
     args.op = 'addMenuSeparator'
     return leap.request('UI', args)
 end
-- 
cgit v1.2.3


From 4ae12a08265998055627a0530f6e7ef8da5ca2ed Mon Sep 17 00:00:00 2001
From: Nat Goodspeed <nat@lindenlab.com>
Date: Thu, 12 Sep 2024 11:05:24 -0400
Subject: Add LLAgent.teleport() Lua function

that wraps existing "LLTeleportHandler" LEAP listener.
---
 indra/newview/scripts/lua/require/LLAgent.lua | 8 ++++++++
 1 file changed, 8 insertions(+)

(limited to 'indra/newview/scripts')

diff --git a/indra/newview/scripts/lua/require/LLAgent.lua b/indra/newview/scripts/lua/require/LLAgent.lua
index 07ef1e0b0b..9eebede59f 100644
--- a/indra/newview/scripts/lua/require/LLAgent.lua
+++ b/indra/newview/scripts/lua/require/LLAgent.lua
@@ -71,4 +71,12 @@ function LLAgent.getAnimationInfo(item_id)
     return leap.request('LLAgent', {op = 'getAnimationInfo', item_id=item_id}).anim_info
 end
 
+-- Teleport to specified "regionname" at specified region-relative "x", "y", "z".
+-- If "regionname" omitted, teleport to GLOBAL coordinates "x", "y", "z".
+function LLAgent.teleport(...)
+    local args = mapargs('regionname,x,y,z', ...)
+    args.op = 'teleport'
+    return leap.request('LLTeleportHandler', args)
+end
+
 return LLAgent
-- 
cgit v1.2.3


From a68bb4eb27573a9313169799a188dda3ae765666 Mon Sep 17 00:00:00 2001
From: Nat Goodspeed <nat@lindenlab.com>
Date: Thu, 12 Sep 2024 12:27:08 -0400
Subject: Support "LLTeleportHandler" "teleport" regionname="home".

---
 indra/newview/scripts/lua/require/LLAgent.lua | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

(limited to 'indra/newview/scripts')

diff --git a/indra/newview/scripts/lua/require/LLAgent.lua b/indra/newview/scripts/lua/require/LLAgent.lua
index 9eebede59f..5cee998fcd 100644
--- a/indra/newview/scripts/lua/require/LLAgent.lua
+++ b/indra/newview/scripts/lua/require/LLAgent.lua
@@ -72,11 +72,12 @@ function LLAgent.getAnimationInfo(item_id)
 end
 
 -- Teleport to specified "regionname" at specified region-relative "x", "y", "z".
+-- If "regionname" is "home", ignore "x", "y", "z" and teleport home.
 -- If "regionname" omitted, teleport to GLOBAL coordinates "x", "y", "z".
 function LLAgent.teleport(...)
     local args = mapargs('regionname,x,y,z', ...)
     args.op = 'teleport'
-    return leap.request('LLTeleportHandler', args)
+    return leap.request('LLTeleportHandler', args).message
 end
 
 return LLAgent
-- 
cgit v1.2.3


From 6c6a42fbbc231bad6a7921c37cdcb82d17dc225f Mon Sep 17 00:00:00 2001
From: Nat Goodspeed <nat@lindenlab.com>
Date: Thu, 12 Sep 2024 13:46:30 -0400
Subject: Let test_animation.lua cope with the case of 0 animations.

---
 indra/newview/scripts/lua/test_animation.lua | 28 ++++++++++++++++------------
 1 file changed, 16 insertions(+), 12 deletions(-)

(limited to 'indra/newview/scripts')

diff --git a/indra/newview/scripts/lua/test_animation.lua b/indra/newview/scripts/lua/test_animation.lua
index c16fef4918..37e7254a6c 100644
--- a/indra/newview/scripts/lua/test_animation.lua
+++ b/indra/newview/scripts/lua/test_animation.lua
@@ -11,18 +11,22 @@ for key in pairs(anims) do
     table.insert(anim_ids, key)
 end
 
--- Start playing a random animation
-math.randomseed(os.time())
-local random_id = anim_ids[math.random(#anim_ids)]
-local anim_info = LLAgent.getAnimationInfo(random_id)
+if #anim_ids == 0 then
+    print("No animations found")
+else
+    -- Start playing a random animation
+    math.randomseed(os.time())
+    local random_id = anim_ids[math.random(#anim_ids)]
+    local anim_info = LLAgent.getAnimationInfo(random_id)
 
-print("Starting animation locally: " .. anims[random_id].name)
-print("Loop: " .. anim_info.is_loop .. " Joints: " .. anim_info.num_joints .. " Duration " .. tonumber(string.format("%.2f", anim_info.duration)))
-LLAgent.playAnimation{item_id=random_id}
+    print("Starting animation locally: " .. anims[random_id].name)
+    print("Loop: " .. anim_info.is_loop .. " Joints: " .. anim_info.num_joints .. " Duration " .. tonumber(string.format("%.2f", anim_info.duration)))
+    LLAgent.playAnimation{item_id=random_id}
 
--- Stop animation after 3 sec if it's looped or longer than 3 sec
-if anim_info.is_loop == 1 or anim_info.duration > 3 then
-    LL.sleep(3)
-    print("Stop animation.")
-    LLAgent.stopAnimation(random_id)
+    -- Stop animation after 3 sec if it's looped or longer than 3 sec
+    if anim_info.is_loop == 1 or anim_info.duration > 3 then
+        LL.sleep(3)
+        print("Stop animation.")
+        LLAgent.stopAnimation(random_id)
+    end
 end
-- 
cgit v1.2.3


From 1b7fdac4689e29ec3f64c37f10b843a114d7805d Mon Sep 17 00:00:00 2001
From: Nat Goodspeed <nat@lindenlab.com>
Date: Thu, 12 Sep 2024 15:09:24 -0400
Subject: Add frame_profile.lua to TP to known spot and take frame profile.

frame_profile.lua teleports home when done.

Further add frame_profile bash script to run the specified viewer,
automatically log into said known spot, take frame profile and quit.
The frame_profile bash script runs frame_profile_quit.lua.
frame_profile_quit.lua is derived from frame_profile.lua, but different:
it doesn't teleport either way because it assumes autologin to the target
location, and because it logs out instead of returning home.
---
 indra/newview/scripts/lua/frame_profile.lua      | 24 +++++++++++++++++++++++
 indra/newview/scripts/lua/frame_profile_quit.lua | 25 ++++++++++++++++++++++++
 2 files changed, 49 insertions(+)
 create mode 100644 indra/newview/scripts/lua/frame_profile.lua
 create mode 100644 indra/newview/scripts/lua/frame_profile_quit.lua

(limited to 'indra/newview/scripts')

diff --git a/indra/newview/scripts/lua/frame_profile.lua b/indra/newview/scripts/lua/frame_profile.lua
new file mode 100644
index 0000000000..3c6353ff68
--- /dev/null
+++ b/indra/newview/scripts/lua/frame_profile.lua
@@ -0,0 +1,24 @@
+-- Trigger Develop -> Render Tests -> Frame Profile
+
+LLAgent = require 'LLAgent'
+startup = require 'startup'
+Timer = (require 'timers').Timer
+UI = require 'UI'
+
+startup.wait('STATE_STARTED')
+
+-- teleport to http://maps.secondlife.com/secondlife/Bug%20Island/220/224/27
+print(LLAgent.teleport{regionname='Bug Island', x=220, y=224, z=27})
+Timer(10, 'wait')
+LLAgent.setCamera{camera_pos={220, 224, 26}, camera_locked=true,
+                  focus_pos ={228, 232, 26}, focus_locked=true}
+Timer(1, 'wait')
+-- This freezes the viewer for perceptible realtime
+UI.popup:tip('starting Render Tests -> Frame Profile')
+UI.call("Advanced.ClickRenderProfile")
+Timer(1, 'wait')
+LLAgent.removeCamParams()
+LLAgent.setFollowCamActive(false)
+
+-- Home, James!
+print(LLAgent.teleport('home'))
diff --git a/indra/newview/scripts/lua/frame_profile_quit.lua b/indra/newview/scripts/lua/frame_profile_quit.lua
new file mode 100644
index 0000000000..e3177a3f67
--- /dev/null
+++ b/indra/newview/scripts/lua/frame_profile_quit.lua
@@ -0,0 +1,25 @@
+-- Trigger Develop -> Render Tests -> Frame Profile and quit
+
+LLAgent = require 'LLAgent'
+logout = require 'logout'
+startup = require 'startup'
+Timer = (require 'timers').Timer
+UI = require 'UI'
+
+startup.wait('STATE_STARTED')
+
+-- Assume we logged into http://maps.secondlife.com/secondlife/Bug%20Island/220/224/27
+-- (see frame_profile bash script)
+Timer(10, 'wait')
+LLAgent.setCamera{camera_pos={220, 224, 26}, camera_locked=true,
+                  focus_pos ={228, 232, 26}, focus_locked=true}
+Timer(1, 'wait')
+-- This freezes the viewer for perceptible realtime
+UI.popup:tip('starting Render Tests -> Frame Profile')
+UI.call("Advanced.ClickRenderProfile")
+Timer(1, 'wait')
+LLAgent.removeCamParams()
+LLAgent.setFollowCamActive(false)
+
+-- done
+logout()
-- 
cgit v1.2.3


From 328bdeb3cc26648060a3d7331ccdb80539953f33 Mon Sep 17 00:00:00 2001
From: Nat Goodspeed <nat@lindenlab.com>
Date: Fri, 13 Sep 2024 16:52:17 -0400
Subject: Remove autorun 'menus.lua' since menu_viewer.xml handles visibility

---
 indra/newview/scripts/lua/auto/menus.lua | 51 --------------------------------
 1 file changed, 51 deletions(-)
 delete mode 100644 indra/newview/scripts/lua/auto/menus.lua

(limited to 'indra/newview/scripts')

diff --git a/indra/newview/scripts/lua/auto/menus.lua b/indra/newview/scripts/lua/auto/menus.lua
deleted file mode 100644
index b2f54d83df..0000000000
--- a/indra/newview/scripts/lua/auto/menus.lua
+++ /dev/null
@@ -1,51 +0,0 @@
--- Inject Lua-related menus into the top menu structure. Run this as a Lua
--- script so that turning off the Lua feature also disables these menus.
-
--- Under Develop -> Consoles, want to present the equivalent of:
--- <menu_item_separator/>
--- <menu_item_check
---     label="LUA Debug Console"
---     name="LUA Debug Console">
---   <menu_item_check.on_check
---       function="Floater.Visible"
---       parameter="lua_debug" />
---   <menu_item_check.on_click
---       function="Floater.Toggle"
---       parameter="lua_debug" />
--- </menu_item_check>
--- <menu_item_check
---     label="LUA Scripts Info"
---     name="LUA Scripts">
---   <menu_item_check.on_check
---       function="Floater.Visible"
---       parameter="lua_scripts" />
---   <menu_item_check.on_click
---       function="Floater.Toggle"
---       parameter="lua_scripts" />
--- </menu_item_check>
-
-local startup = require 'startup'
-local UI = require 'UI'
-
--- Don't mess with the viewer's menu structure until we've logged in.
-startup.wait('STATE_STARTED')
-
--- Add LUA Debug Console to Develop->Consoles
-local pos = 9
-UI.addMenuSeparator{
-    parent_menu='Consoles', pos=pos,
-}
-pos += 1
-UI.addMenuItem{
-    parent_menu='Consoles', pos=pos,
-    name='lua_debug', label='LUA Debug Console',
-    func='Floater.ToggleOrBringToFront', param='lua_debug',
-}
-pos += 1
-
--- Add LUA Scripts Info to Develop->Consoles
-UI.addMenuItem{
-    parent_menu='Consoles', pos=pos,
-    name='lua_scripts', label='LUA Scripts Info',
-    func='Floater.ToggleOrBringToFront', param='lua_scripts',
-}
-- 
cgit v1.2.3


From 50513bab2d6b1823f983c145553b8a6af44c2f28 Mon Sep 17 00:00:00 2001
From: Nat Goodspeed <nat@lindenlab.com>
Date: Thu, 19 Sep 2024 15:00:37 -0400
Subject: Make login.lua enhance plain grid='agni' to required form.

---
 indra/newview/scripts/lua/require/login.lua | 11 ++++++++++-
 1 file changed, 10 insertions(+), 1 deletion(-)

(limited to 'indra/newview/scripts')

diff --git a/indra/newview/scripts/lua/require/login.lua b/indra/newview/scripts/lua/require/login.lua
index 919434f3a5..37c9093a21 100644
--- a/indra/newview/scripts/lua/require/login.lua
+++ b/indra/newview/scripts/lua/require/login.lua
@@ -18,16 +18,25 @@ local function ensure_login_state(op)
     end
 end
 
+local function fullgrid(grid)
+    if string.find(grid, '.', 1, true) then
+        return grid
+    else
+        return `util.{grid}.secondlife.com`
+    end
+end
+
 function login.login(...)
     ensure_login_state('login')
     local args = mapargs('username,grid,slurl', ...)
     args.op = 'login'
+    args.grid = fullgrid(args.grid)
     return leap.request('LLPanelLogin', args)
 end
 
 function login.savedLogins(grid)
     ensure_login_state('savedLogins')
-    return leap.request('LLPanelLogin', {op='savedLogins', grid=grid})['logins']
+    return leap.request('LLPanelLogin', {op='savedLogins', grid=fullgrid(grid)})['logins']
 end
 
 return login
-- 
cgit v1.2.3


From 8efba1db81fc1294114cea70de0df53f4d4ab9a4 Mon Sep 17 00:00:00 2001
From: Nat Goodspeed <nat@lindenlab.com>
Date: Mon, 23 Sep 2024 10:23:37 -0400
Subject: Use Lua command-line args to make frame_profile_quit.lua generic.

Now the location to which to teleport and the camera focus point can both be
specified by the caller, in this case the frame_profile bash script.
---
 indra/newview/scripts/lua/frame_profile_quit.lua | 17 +++++++++++++----
 1 file changed, 13 insertions(+), 4 deletions(-)

(limited to 'indra/newview/scripts')

diff --git a/indra/newview/scripts/lua/frame_profile_quit.lua b/indra/newview/scripts/lua/frame_profile_quit.lua
index e3177a3f67..ad136c86d2 100644
--- a/indra/newview/scripts/lua/frame_profile_quit.lua
+++ b/indra/newview/scripts/lua/frame_profile_quit.lua
@@ -1,5 +1,11 @@
 -- Trigger Develop -> Render Tests -> Frame Profile and quit
 
+assert(arg.n == 3, 'Usage: frame_profile_quit.lua x y z (for camera focus)')
+-- Try coercing string arguments to numbers, using Lua's implicit conversion.
+-- If the args passed as x, y, z won't convert nicely to numbers, better find
+-- out now.
+focus = {arg[1]+0, arg[2]+0, arg[3]+0}
+
 LLAgent = require 'LLAgent'
 logout = require 'logout'
 startup = require 'startup'
@@ -8,11 +14,14 @@ UI = require 'UI'
 
 startup.wait('STATE_STARTED')
 
--- Assume we logged into http://maps.secondlife.com/secondlife/Bug%20Island/220/224/27
--- (see frame_profile bash script)
+-- Figure out where we are
+camera = LLAgent.getRegionPosition()
+-- assume z is the agent's feet, add 2 meters
+camera[2] += 2
+
 Timer(10, 'wait')
-LLAgent.setCamera{camera_pos={220, 224, 26}, camera_locked=true,
-                  focus_pos ={228, 232, 26}, focus_locked=true}
+LLAgent.setCamera{camera_pos=camera, camera_locked=true,
+                  focus_pos=focus, focus_locked=true}
 Timer(1, 'wait')
 -- This freezes the viewer for perceptible realtime
 UI.popup:tip('starting Render Tests -> Frame Profile')
-- 
cgit v1.2.3


From b6cbad1cf6c6ae6293825da776ce2191175d4632 Mon Sep 17 00:00:00 2001
From: Mnikolenko Productengine <mnikolenko@productengine.com>
Date: Mon, 16 Sep 2024 20:29:53 +0300
Subject: Lua api for autopilot functions

---
 indra/newview/scripts/lua/require/LLAgent.lua | 49 +++++++++++++++++++++++++++
 1 file changed, 49 insertions(+)

(limited to 'indra/newview/scripts')

diff --git a/indra/newview/scripts/lua/require/LLAgent.lua b/indra/newview/scripts/lua/require/LLAgent.lua
index 5cee998fcd..7b12493acc 100644
--- a/indra/newview/scripts/lua/require/LLAgent.lua
+++ b/indra/newview/scripts/lua/require/LLAgent.lua
@@ -80,4 +80,53 @@ function LLAgent.teleport(...)
     return leap.request('LLTeleportHandler', args).message
 end
 
+function LLAgent.requestSit(...)
+    local args = mapargs('obj_uuid,position', ...)
+    args.op = 'requestSit'
+    return leap.request('LLAgent', args)
+end
+
+function LLAgent.requestStand()
+    leap.send('LLAgent', {op = 'requestStand'})
+end
+
+-- Start the autopilot to move to "target_global" location using specified parameters
+-- LLAgent.startAutoPilot{ target_global       array of target global {x, y, z} position
+--                      [, allow_flying]       allow flying during autopilot [default: true]
+--                      [, stop_distance]      target maximum distance from target [default: autopilot guess]
+--                      [, behavior_name]      name of the autopilot behavior [default: (script name)]
+--                      [, target_rotation]    array of [x, y, z, w] quaternion values [default: no target]
+--                      [, rotation_threshold] target maximum angle from target facing rotation [default: 0.03 radians]
+function LLAgent.startAutoPilot(...)
+    local args = mapargs('target_global,allow_flying,stop_distance,behavior_name,target_rotation,rotation_threshold', ...)
+    args.op = 'startAutoPilot'
+    leap.send('LLAgent', args)
+end
+
+-- Update target location for currently running autopilot
+function LLAgent.setAutoPilotTarget(target_global)
+    leap.send('LLAgent', {op = 'setAutoPilotTarget', target_global=target_global})
+end
+
+-- Start the autopilot to move to the specified target location
+-- either "leader_id" (uuid of target) or "avatar_name" (avatar full name) should be specified
+-- "allow_flying" [default: true], "stop_distance" [default: autopilot guess]
+function LLAgent.startFollowPilot(...)
+    local args = mapargs('leader_id,avatar_name,allow_flying,stop_distance', ...)
+    args.op = 'startFollowPilot'
+    return leap.request('LLAgent', args)
+end
+
+-- Stop the autopilot system: "user_cancel" indicates whether or not to act as though user canceled autopilot [default: false]
+function LLAgent.stopAutoPilot(...)
+    local args = mapargs('user_cancel', ...)
+    args.op = 'stopAutoPilot'
+    leap.send('LLAgent', args)
+end
+
+-- Get information about current state of the autopilot
+function LLAgent.getAutoPilot()
+    return leap.request('LLAgent', {op = 'getAutoPilot'})
+end
+
 return LLAgent
-- 
cgit v1.2.3


From ed7603bfe63ce5e8c1ff1101270e0406de01dc92 Mon Sep 17 00:00:00 2001
From: Mnikolenko Productengine <mnikolenko@productengine.com>
Date: Tue, 17 Sep 2024 12:37:17 +0300
Subject: Use event pump to get autopilot status, when it's terminated; add
 demo script

---
 indra/newview/scripts/lua/require/LLAgent.lua      | 13 +++++-
 indra/newview/scripts/lua/require/LLChat.lua       |  1 +
 .../newview/scripts/lua/require/LLChatListener.lua | 48 ---------------------
 indra/newview/scripts/lua/require/LLListener.lua   | 50 ++++++++++++++++++++++
 indra/newview/scripts/lua/test_LLChatListener.lua  |  6 +--
 indra/newview/scripts/lua/test_autopilot.lua       | 22 ++++++++++
 6 files changed, 88 insertions(+), 52 deletions(-)
 delete mode 100644 indra/newview/scripts/lua/require/LLChatListener.lua
 create mode 100644 indra/newview/scripts/lua/require/LLListener.lua
 create mode 100644 indra/newview/scripts/lua/test_autopilot.lua

(limited to 'indra/newview/scripts')

diff --git a/indra/newview/scripts/lua/require/LLAgent.lua b/indra/newview/scripts/lua/require/LLAgent.lua
index 7b12493acc..4a1132fe7e 100644
--- a/indra/newview/scripts/lua/require/LLAgent.lua
+++ b/indra/newview/scripts/lua/require/LLAgent.lua
@@ -80,6 +80,11 @@ function LLAgent.teleport(...)
     return leap.request('LLTeleportHandler', args).message
 end
 
+-- Call with no arguments to sit on the ground.
+-- Otherwise specify "obj_uuid" to sit on,
+-- or region "position" {x, y, z} where to find closest object to sit on.
+-- For example: LLAgent.requestSit{position=LLAgent.getRegionPosition()}
+-- Your avatar should be close enough to the object you want to sit on
 function LLAgent.requestSit(...)
     local args = mapargs('obj_uuid,position', ...)
     args.op = 'requestSit'
@@ -90,6 +95,11 @@ function LLAgent.requestStand()
     leap.send('LLAgent', {op = 'requestStand'})
 end
 
+-- ***************************************************************************
+--  Autopilot
+-- ***************************************************************************
+LLAgent.autoPilotPump = "LLAutopilot"
+
 -- Start the autopilot to move to "target_global" location using specified parameters
 -- LLAgent.startAutoPilot{ target_global       array of target global {x, y, z} position
 --                      [, allow_flying]       allow flying during autopilot [default: true]
@@ -97,6 +107,7 @@ end
 --                      [, behavior_name]      name of the autopilot behavior [default: (script name)]
 --                      [, target_rotation]    array of [x, y, z, w] quaternion values [default: no target]
 --                      [, rotation_threshold] target maximum angle from target facing rotation [default: 0.03 radians]
+-- an event with "success" flag is sent to "LLAutopilot" event pump, when auto pilot is terminated
 function LLAgent.startAutoPilot(...)
     local args = mapargs('target_global,allow_flying,stop_distance,behavior_name,target_rotation,rotation_threshold', ...)
     args.op = 'startAutoPilot'
@@ -109,7 +120,7 @@ function LLAgent.setAutoPilotTarget(target_global)
 end
 
 -- Start the autopilot to move to the specified target location
--- either "leader_id" (uuid of target) or "avatar_name" (avatar full name) should be specified
+-- either "leader_id" (uuid of target) or "avatar_name" (avatar full name: use just first name for 'Resident') should be specified
 -- "allow_flying" [default: true], "stop_distance" [default: autopilot guess]
 function LLAgent.startFollowPilot(...)
     local args = mapargs('leader_id,avatar_name,allow_flying,stop_distance', ...)
diff --git a/indra/newview/scripts/lua/require/LLChat.lua b/indra/newview/scripts/lua/require/LLChat.lua
index bc0fc86d22..3ac3bab746 100644
--- a/indra/newview/scripts/lua/require/LLChat.lua
+++ b/indra/newview/scripts/lua/require/LLChat.lua
@@ -5,6 +5,7 @@ local LLChat = {}
 -- ***************************************************************************
 --  Nearby chat
 -- ***************************************************************************
+LLChat.nearbyChatPump = "LLNearbyChat"
 
 -- 0 is public nearby channel, other channels are used to communicate with LSL scripts
 function LLChat.sendNearby(msg, channel)
diff --git a/indra/newview/scripts/lua/require/LLChatListener.lua b/indra/newview/scripts/lua/require/LLChatListener.lua
deleted file mode 100644
index 82b28966ce..0000000000
--- a/indra/newview/scripts/lua/require/LLChatListener.lua
+++ /dev/null
@@ -1,48 +0,0 @@
-local fiber = require 'fiber'
-local inspect = require 'inspect'
-local leap = require 'leap'
-local util = require 'util'
-
-local LLChatListener = {}
-local waitfor = {}
-local listener_name = {}
-
-function LLChatListener:new()
-    local obj = setmetatable({}, self)
-    self.__index = self
-    obj.name = 'Chat_listener'
-
-    return obj
-end
-
-util.classctor(LLChatListener)
-
-function LLChatListener:handleMessages(event_data)
-    print(inspect(event_data))
-    return true
-end
-
-function LLChatListener:start()
-    waitfor = leap.WaitFor(-1, self.name)
-    function waitfor:filter(pump, data)
-        if pump == "LLNearbyChat" then
-          return data
-        end
-    end
-
-    fiber.launch(self.name, function()
-        event = waitfor:wait()
-        while event and self:handleMessages(event) do
-          event = waitfor:wait()
-        end
-    end)
-
-    listener_name = leap.request(leap.cmdpump(), {op='listen', source='LLNearbyChat', listener="ChatListener", tweak=true}).listener
-end
-
-function LLChatListener:stop()
-    leap.send(leap.cmdpump(), {op='stoplistening', source='LLNearbyChat', listener=listener_name})
-    waitfor:close()
-end
-
-return LLChatListener
diff --git a/indra/newview/scripts/lua/require/LLListener.lua b/indra/newview/scripts/lua/require/LLListener.lua
new file mode 100644
index 0000000000..e3bfb6b358
--- /dev/null
+++ b/indra/newview/scripts/lua/require/LLListener.lua
@@ -0,0 +1,50 @@
+local fiber = require 'fiber'
+local inspect = require 'inspect'
+local leap = require 'leap'
+local util = require 'util'
+
+local LLListener = {}
+local waitfor = {}
+local listener_name = {}
+local pump = {}
+
+function LLListener:new()
+    local obj = setmetatable({}, self)
+    self.__index = self
+    obj.name = 'Listener'
+
+    return obj
+end
+
+util.classctor(LLListener)
+
+function LLListener:handleMessages(event_data)
+    print(inspect(event_data))
+    return true
+end
+
+function LLListener:start(pump_name)
+    pump = pump_name
+    waitfor = leap.WaitFor(-1, self.name)
+    function waitfor:filter(pump_, data)
+        if pump == pump_ then
+          return data
+        end
+    end
+
+    fiber.launch(self.name, function()
+        event = waitfor:wait()
+        while event and self:handleMessages(event) do
+          event = waitfor:wait()
+        end
+    end)
+
+    listener_name = leap.request(leap.cmdpump(), {op='listen', source=pump, listener="LLListener", tweak=true}).listener
+end
+
+function LLListener:stop()
+    leap.send(leap.cmdpump(), {op='stoplistening', source=pump, listener=listener_name})
+    waitfor:close()
+end
+
+return LLListener
diff --git a/indra/newview/scripts/lua/test_LLChatListener.lua b/indra/newview/scripts/lua/test_LLChatListener.lua
index 4a4d40bee5..1df2880f3d 100644
--- a/indra/newview/scripts/lua/test_LLChatListener.lua
+++ b/indra/newview/scripts/lua/test_LLChatListener.lua
@@ -1,4 +1,4 @@
-local LLChatListener = require 'LLChatListener'
+local LLListener = require 'LLListener'
 local LLChat = require 'LLChat'
 local UI = require 'UI'
 
@@ -22,7 +22,7 @@ function openOrEcho(message)
     end
 end
 
-local listener = LLChatListener()
+local listener = LLListener()
 
 function listener:handleMessages(event_data)
     if string.find(event_data.message, '[LUA]') then
@@ -36,4 +36,4 @@ function listener:handleMessages(event_data)
     return true
 end
 
-listener:start()
+listener:start(LLChat.nearbyChatPump)
diff --git a/indra/newview/scripts/lua/test_autopilot.lua b/indra/newview/scripts/lua/test_autopilot.lua
new file mode 100644
index 0000000000..0560477d38
--- /dev/null
+++ b/indra/newview/scripts/lua/test_autopilot.lua
@@ -0,0 +1,22 @@
+local LLAgent = require 'LLAgent'
+local LLListener = require 'LLListener'
+
+local pos = LLAgent.getGlobalPosition()
+pos[1]+=10 -- delta x
+pos[2]+=5  -- delta y
+LLAgent.requestStand()
+LLAgent.startAutoPilot{target_global=pos,allow_flying=false,stop_distance=1}
+
+local listener = LLListener()
+
+function listener:handleMessages(event_data)
+    if event_data.success then
+      print('Destination is reached')
+      LLAgent.requestSit()
+    else
+      print('Failed to reach destination')
+    end
+    return false
+end
+
+listener:start(LLAgent.autoPilotPump)
-- 
cgit v1.2.3


From 80066449b9cbee018dd1c874c02579b1cbd3d348 Mon Sep 17 00:00:00 2001
From: Mnikolenko Productengine <mnikolenko@productengine.com>
Date: Thu, 26 Sep 2024 17:20:47 +0300
Subject: update LLListener and related scripts

---
 indra/newview/scripts/lua/require/LLListener.lua  | 18 +++++++++---------
 indra/newview/scripts/lua/test_LLChatListener.lua |  4 ++--
 indra/newview/scripts/lua/test_autopilot.lua      |  4 ++--
 3 files changed, 13 insertions(+), 13 deletions(-)

(limited to 'indra/newview/scripts')

diff --git a/indra/newview/scripts/lua/require/LLListener.lua b/indra/newview/scripts/lua/require/LLListener.lua
index e3bfb6b358..b05f966097 100644
--- a/indra/newview/scripts/lua/require/LLListener.lua
+++ b/indra/newview/scripts/lua/require/LLListener.lua
@@ -6,12 +6,12 @@ local util = require 'util'
 local LLListener = {}
 local waitfor = {}
 local listener_name = {}
-local pump = {}
 
-function LLListener:new()
+function LLListener:new(pump_name)
     local obj = setmetatable({}, self)
     self.__index = self
-    obj.name = 'Listener'
+    obj.name = 'Listener:' .. pump_name
+    obj._pump = pump_name
 
     return obj
 end
@@ -23,11 +23,11 @@ function LLListener:handleMessages(event_data)
     return true
 end
 
-function LLListener:start(pump_name)
-    pump = pump_name
+function LLListener:start()
+    _pump = self._pump
     waitfor = leap.WaitFor(-1, self.name)
-    function waitfor:filter(pump_, data)
-        if pump == pump_ then
+    function waitfor:filter(pump, data)
+        if _pump == pump then
           return data
         end
     end
@@ -39,11 +39,11 @@ function LLListener:start(pump_name)
         end
     end)
 
-    listener_name = leap.request(leap.cmdpump(), {op='listen', source=pump, listener="LLListener", tweak=true}).listener
+    listener_name = leap.request(leap.cmdpump(), {op='listen', source=_pump, listener="LLListener", tweak=true}).listener
 end
 
 function LLListener:stop()
-    leap.send(leap.cmdpump(), {op='stoplistening', source=pump, listener=listener_name})
+    leap.send(leap.cmdpump(), {op='stoplistening', source=self._pump, listener=listener_name})
     waitfor:close()
 end
 
diff --git a/indra/newview/scripts/lua/test_LLChatListener.lua b/indra/newview/scripts/lua/test_LLChatListener.lua
index 1df2880f3d..0f269b54e6 100644
--- a/indra/newview/scripts/lua/test_LLChatListener.lua
+++ b/indra/newview/scripts/lua/test_LLChatListener.lua
@@ -22,7 +22,7 @@ function openOrEcho(message)
     end
 end
 
-local listener = LLListener()
+local listener = LLListener(LLChat.nearbyChatPump)
 
 function listener:handleMessages(event_data)
     if string.find(event_data.message, '[LUA]') then
@@ -36,4 +36,4 @@ function listener:handleMessages(event_data)
     return true
 end
 
-listener:start(LLChat.nearbyChatPump)
+listener:start()
diff --git a/indra/newview/scripts/lua/test_autopilot.lua b/indra/newview/scripts/lua/test_autopilot.lua
index 0560477d38..09c85c140a 100644
--- a/indra/newview/scripts/lua/test_autopilot.lua
+++ b/indra/newview/scripts/lua/test_autopilot.lua
@@ -7,7 +7,7 @@ pos[2]+=5  -- delta y
 LLAgent.requestStand()
 LLAgent.startAutoPilot{target_global=pos,allow_flying=false,stop_distance=1}
 
-local listener = LLListener()
+local listener = LLListener(LLAgent.autoPilotPump)
 
 function listener:handleMessages(event_data)
     if event_data.success then
@@ -19,4 +19,4 @@ function listener:handleMessages(event_data)
     return false
 end
 
-listener:start(LLAgent.autoPilotPump)
+listener:start()
-- 
cgit v1.2.3


From 00331d3dca86fd54e6f31aea3c0f5018672e1bcb Mon Sep 17 00:00:00 2001
From: Mnikolenko Productengine <mnikolenko@productengine.com>
Date: Fri, 27 Sep 2024 17:33:01 +0300
Subject: Add UI callback to invoke specified script via menu

---
 indra/newview/scripts/lua/test_top_menu.lua | 28 +++++++++++++++++++++++-----
 1 file changed, 23 insertions(+), 5 deletions(-)

(limited to 'indra/newview/scripts')

diff --git a/indra/newview/scripts/lua/test_top_menu.lua b/indra/newview/scripts/lua/test_top_menu.lua
index 780a384c92..f877cda5eb 100644
--- a/indra/newview/scripts/lua/test_top_menu.lua
+++ b/indra/newview/scripts/lua/test_top_menu.lua
@@ -18,17 +18,35 @@ UI.addMenuItem{name="lua_scripts",label="Scripts",
 --Add menu separator to the 'LUA Menu' under added menu items
 UI.addMenuSeparator{parent_menu=MENU_NAME}
 
---Add two new menu branch 'About...' to the 'LUA Menu'
-local BRANCH_NAME = "about_branch"
-UI.addMenuBranch{name="about_branch",label="About...",parent_menu=MENU_NAME}
+--Add 'Demo scripts...' branch to the 'LUA Menu'
+local DEMO_BRANCH = "demo_scripts"
+UI.addMenuBranch{name=DEMO_BRANCH,label="Demo scripts...",parent_menu=MENU_NAME}
+
+--Add menu items to the 'Demo scripts...' branch, which will invoke specified script on click
+UI.addMenuItem{name="speedometer",label="Speedometer",
+                param="test_luafloater_speedometer.lua",
+                func="Lua.RunScript",
+                parent_menu=DEMO_BRANCH}
+
+UI.addMenuItem{name="gesture_list",label="Gesture list",
+                param="test_luafloater_gesture_list.lua",
+                func="Lua.RunScript",
+                parent_menu=DEMO_BRANCH}
+
+--Add one more menu separator
+UI.addMenuSeparator{parent_menu=MENU_NAME}
+
+--Add 'About...' branch to the 'LUA Menu'
+local ABOUT_BRANCH = "about_branch"
+UI.addMenuBranch{name=ABOUT_BRANCH,label="About...",parent_menu=MENU_NAME}
 
 --Add two new menu items to the 'About...' branch
 UI.addMenuItem{name="lua_info",label="Lua...",
                 param="https://www.lua.org/about.html",
                 func="Advanced.ShowURL",
-                parent_menu=BRANCH_NAME}
+                parent_menu=ABOUT_BRANCH}
 
 UI.addMenuItem{name="lua_info",label="Luau...",
                 param="https://luau-lang.org/",
                 func="Advanced.ShowURL",
-                parent_menu=BRANCH_NAME}
+                parent_menu=ABOUT_BRANCH}
-- 
cgit v1.2.3