iobroker.javascript 9.2.2 → 9.2.4

package/build/lib/sandbox.js

@@ -33,6 +33,8 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.isExactId = isExactId;
+exports.removeFromDispatchIndex = removeFromDispatchIndex;
 exports.sandBox = sandBox;
 const jsonataMod = __importStar(require("jsonata"));
 const adapter_core_1 = require("@iobroker/adapter-core");
@@ -43,6 +45,61 @@ const eventObjMod = __importStar(require("./eventObj"));
 const patternCompareFunctions_1 = require("./patternCompareFunctions");
 const SCRIPT_CODE_MARKER = 'script.js.';
 const pattern2RegEx = adapter_core_1.commonTools.pattern2RegEx;
+// Pre-compiled RegExp constants for formatTimeDiff – avoids recompiling on every call
+const FTD_TEST_D = /(?<!\\)[DTД]/;
+const FTD_REPL_DD = /(?<!\\)(?:DD|TT|ДД)/g;
+const FTD_REPL_D = /(?<!\\)[DTД]/g;
+const FTD_TEST_H = /(?<!\\)[hSч]/;
+const FTD_REPL_HH = /(?<!\\)(?:hh|SS|чч)/g;
+const FTD_REPL_H = /(?<!\\)[hSч]/g;
+const FTD_TEST_M = /(?<!\\)[mм]/;
+const FTD_REPL_MM = /(?<!\\)(?:mm|мм)/g;
+const FTD_REPL_M = /(?<!\\)[mм]/g;
+const FTD_TEST_S = /(?<!\\)[sс]/;
+const FTD_REPL_SS = /(?<!\\)(?:ss|сс)/g;
+const FTD_REPL_S = /(?<!\\)[sс]/g;
+const FTD_UNESCAPE = [
+    [/\\([DTД])/g, '$1'],
+    [/\\([hSч])/g, '$1'],
+    [/\\([mм])/g, '$1'],
+    [/\\([sс])/g, '$1'],
+];
+/** Maximum number of cached selector RegExps before FIFO eviction kicks in */
+const _SELECTOR_REGEXP_CACHE_MAX = 1000;
+/** Cache for selector-string → RegExp to avoid recompiling identical patterns (FIFO-bounded) */
+const _selectorRegExpCache = new Map();
+/** Monotonically increasing handler-ID counter – avoids Date.now()+random collisions */
+let _handlerIdCounter = 1;
+/** Returns true when patId is a plain exact state-ID (no wildcards, no RegExp notation). */
+function isExactId(patId) {
+    return (!!patId && typeof patId === 'string' && !patId.includes('*') && !patId.includes('?') && !patId.startsWith('/'));
+}
+/**
+ * Removes a subscription from the O(1) dispatch index (subscriptionsMap / subscriptionsWildcard).
+ * Must use the same exact-id classification as the subscribe side (isExactId),
+ * otherwise entries leak in the structure that was not searched.
+ */
+function removeFromDispatchIndex(ctx, sub) {
+    const patId = sub.pattern?.id;
+    if (isExactId(patId)) {
+        const bucket = ctx.subscriptionsMap.get(patId);
+        if (bucket) {
+            const pos = bucket.indexOf(sub);
+            if (pos !== -1) {
+                bucket.splice(pos, 1);
+            }
+            if (bucket.length === 0) {
+                ctx.subscriptionsMap.delete(patId);
+            }
+        }
+    }
+    else {
+        const wPos = ctx.subscriptionsWildcard.indexOf(sub);
+        if (wPos !== -1) {
+            ctx.subscriptionsWildcard.splice(wPos, 1);
+        }
+    }
+}
 function sandBox(script, name, verbose, debug, context) {
     const consts = constsMod;
     const words = wordsMod;
@@ -90,7 +147,8 @@ function sandBox(script, name, verbose, debug, context) {
                     });
                 }
                 else {
-                    adapter.getForeignStates(pattern, (_err, _states) => _states && Object.keys(_states).forEach(id => (states[id] = _states[id])));
+                    // IO-3: Object.assign instead of Object.keys().forEach() – no temporary keys array
+                    adapter.getForeignStates(pattern, (_err, _states) => _states && Object.assign(states, _states));
                 }
             }
             else {
@@ -210,14 +268,24 @@ function sandBox(script, name, verbose, debug, context) {
      * @param str The selector string to transform into a regular expression
      */
     function selectorStringToRegExp(str) {
+        const cached = _selectorRegExpCache.get(str);
+        if (cached) {
+            return cached;
+        }
         const startsWithWildcard = str[0] === '*';
         const endsWithWildcard = str[str.length - 1] === '*';
-        // Sanitize the selector, so it is safe to use in a RegEx
-        // Taken from https://stackoverflow.com/a/3561711/10179833 but modified
-        // since * has a special meaning in our selector and should not be escaped
         // eslint-disable-next-line no-useless-escape
-        str = str.replace(/[-\/\\^$+?.()|[\]{}]/g, '\\$&').replace(/\*/g, '.*');
-        return new RegExp((startsWithWildcard ? '' : '^') + str + (endsWithWildcard ? '' : '$'));
+        const escaped = str.replace(/[-\/\\^$+?.()|[\]{}]/g, '\\$&').replace(/\*/g, '.*');
+        const re = new RegExp((startsWithWildcard ? '' : '^') + escaped + (endsWithWildcard ? '' : '$'));
+        // FIFO eviction: drop the oldest entry once the cache exceeds its limit
+        if (_selectorRegExpCache.size >= _SELECTOR_REGEXP_CACHE_MAX) {
+            const oldestKey = _selectorRegExpCache.keys().next().value;
+            if (oldestKey !== undefined) {
+                _selectorRegExpCache.delete(oldestKey);
+            }
+        }
+        _selectorRegExpCache.set(str, re);
+        return re;
     }
     /**
      * Adds a regular expression for selectors targeting the state ID
@@ -482,9 +550,21 @@ function sandBox(script, name, verbose, debug, context) {
                     if (!adapter.config.subscribe && context.interimStateValues[id]) {
                         // if the state is changed, we will compare it with interimStateValues
                         const oldState = context.interimStateValues[id];
-                        const attrs = Object.keys(stateAsObject).filter(attr => attr !== 'ts' && stateAsObject[attr] !== undefined);
-                        if (!attrs.every(attr => stateAsObject[attr] ===
-                            oldState[attr])) {
+                        // IO-1: for…in instead of Object.keys().filter().every() – no temporary array per call
+                        let stateHasChanged = false;
+                        for (const attr in stateAsObject) {
+                            if (attr === 'ts') {
+                                continue;
+                            }
+                            if (stateAsObject[attr] === undefined) {
+                                continue;
+                            }
+                            if (stateAsObject[attr] !== oldState[attr]) {
+                                stateHasChanged = true;
+                                break;
+                            }
+                        }
+                        if (stateHasChanged) {
                             // state is changed for sure, and we will call setForeignState
                             // and store new state to interimStateValues
                             context.interimStateValues[id] = stateAsObject;
@@ -728,17 +808,17 @@ function sandBox(script, name, verbose, debug, context) {
                 if (!context.channels || !context.devices) {
                     context.channels = {};
                     context.devices = {};
-                    for (const _id in objects) {
-                        if (Object.prototype.hasOwnProperty.call(objects, _id) && objects[_id].type === 'state') {
+                    for (const _id of Object.keys(objects)) {
+                        if (objects[_id].type === 'state') {
                             const parts = _id.split('.');
                             parts.pop();
                             const chn = parts.join('.');
                             parts.pop();
                             const dev = parts.join('.');
-                            context.devices[dev] = context.devices[dev] || [];
-                            context.devices[dev].push(_id);
-                            context.channels[chn] = context.channels[chn] || [];
-                            context.channels[chn].push(_id);
+                            context.devices[dev] = context.devices[dev] || new Set();
+                            context.devices[dev].add(_id);
+                            context.channels[chn] = context.channels[chn] || new Set();
+                            context.channels[chn].add(_id);
                         }
                     }
                 }
@@ -746,8 +826,8 @@ function sandBox(script, name, verbose, debug, context) {
             if (name === 'schedule') {
                 if (!context.schedules) {
                     context.schedules = [];
-                    for (const _id in objects) {
-                        if (Object.prototype.hasOwnProperty.call(objects, _id) && objects[_id].type === 'schedule') {
+                    for (const _id of Object.keys(objects)) {
+                        if (objects[_id].type === 'schedule') {
                             context.schedules.push(_id);
                         }
                     }
@@ -851,7 +931,7 @@ function sandBox(script, name, verbose, debug, context) {
                 }
                 // retrieve the state ID collection for all remaining channels
                 res = res
-                    .map(id => channels[id])
+                    .map(id => [...(channels[id] || [])])
                     // and flatten the array to get only the state IDs
                     .reduce((acc, next) => acc.concat(next), []);
                 // now filter out those that don't match every ID selector for the state ID
@@ -884,7 +964,7 @@ function sandBox(script, name, verbose, debug, context) {
                 }
                 // retrieve the state ID collection for all remaining devices
                 res = res
-                    .map(id => devices[id])
+                    .map(id => [...(devices[id] || [])])
                     // and flatten the array to get only the state IDs
                     .reduce((acc, next) => acc.concat(next), []);
                 // now filter out those that don't match every ID selector for the state ID
@@ -921,12 +1001,8 @@ function sandBox(script, name, verbose, debug, context) {
                     res = res.filter(id => applyEnumSelectors(id));
                 }
             }
-            const resUnique = [];
-            for (let i = 0; i < res.length; i++) {
-                if (!resUnique.includes(res[i])) {
-                    resUnique.push(res[i]);
-                }
-            }
+            // IO-2: O(1) deduplication via Set instead of O(n²) resUnique.includes()
+            const resUnique = [...new Set(res)];
             for (let i = 0; i < resUnique.length; i++) {
                 result[i] = resUnique[i];
             }
@@ -1078,7 +1154,7 @@ function sandBox(script, name, verbose, debug, context) {
                 sandbox.log(`Invalid callback for onLog`, 'warn');
                 return 0;
             }
-            const handler = { id: Date.now() + Math.floor(Math.random() * 10000), cb: callback, sandbox, severity };
+            const handler = { id: _handlerIdCounter++, cb: callback, sandbox, severity };
             context.logSubscriptions[sandbox.scriptName] = context.logSubscriptions[sandbox.scriptName] || [];
             context.logSubscriptions[sandbox.scriptName].push(handler);
             context.updateLogSubscriptions();
@@ -1355,8 +1431,8 @@ function sandBox(script, name, verbose, debug, context) {
             if (oPattern?.id && Array.isArray(oPattern.id)) {
                 const result = [];
                 for (let t = 0; t < oPattern.id.length; t++) {
-                    const pa = JSON.parse(JSON.stringify(oPattern));
-                    pa.id = oPattern.id[t];
+                    // IO-4: Spread instead of JSON.parse(JSON.stringify()) – no deep clone needed (only primitive fields)
+                    const pa = { ...oPattern, id: oPattern.id[t] };
                     result.push(sandbox.subscribe(pa, callbackOrChangeTypeOrId, value));
                 }
                 return result;
@@ -1431,10 +1507,11 @@ function sandBox(script, name, verbose, debug, context) {
                 const _adapter = `system.adapter.${a}`;
                 if (objects[_adapter] && objects[_adapter].common && objects[_adapter].common.subscribable) {
                     const alive = `system.adapter.${a}.alive`;
-                    context.adapterSubs[alive] = context.adapterSubs[alive] || [];
-                    const subExists = context.adapterSubs[alive].filter(sub => sub === oPattern.id).length > 0;
+                    context.adapterSubs[alive] = context.adapterSubs[alive] || new Set();
+                    // Set.has() is O(1) and automatically prevents duplicates
+                    const subExists = context.adapterSubs[alive].has(oPattern.id);
                     if (!subExists) {
-                        context.adapterSubs[alive].push(oPattern.id);
+                        context.adapterSubs[alive].add(oPattern.id);
                         adapter.sendTo(a, 'subscribe', oPattern.id);
                     }
                 }
@@ -1445,6 +1522,16 @@ function sandBox(script, name, verbose, debug, context) {
             subscribePattern(script, oPattern.id);
             subs.patternCompareFunctions = getPatternCompareFunctions(oPattern);
             context.subscriptions.push(subs);
+            // O(1) dispatch index: exact string IDs go into the map, everything else into the wildcard array
+            if (isExactId(oPattern.id)) {
+                if (!context.subscriptionsMap.has(oPattern.id)) {
+                    context.subscriptionsMap.set(oPattern.id, []);
+                }
+                context.subscriptionsMap.get(oPattern.id).push(subs);
+            }
+            else {
+                context.subscriptionsWildcard.push(subs);
+            }
             if (oPattern.enumName || oPattern.enumId) {
                 context.isEnums = true;
             }
@@ -1452,13 +1539,13 @@ function sandBox(script, name, verbose, debug, context) {
         },
         getSubscriptions: function () {
             const result = {};
-            for (let s = 0; s < context.subscriptions.length; s++) {
-                result[context.subscriptions[s].pattern.id] =
-                    result[context.subscriptions[s].pattern.id] || [];
-                result[context.subscriptions[s].pattern.id].push({
-                    name: context.subscriptions[s].name,
-                    pattern: context.subscriptions[s].pattern,
-                });
+            // Iterate over the O(1) dispatch index instead of the flat array
+            for (const [id, bucket] of context.subscriptionsMap) {
+                result[id] = bucket.map(s => ({ name: s.name, pattern: s.pattern }));
+            }
+            for (const s of context.subscriptionsWildcard) {
+                const key = s.pattern.id;
+                (result[key] ??= []).push({ name: s.name, pattern: s.pattern });
             }
             if (sandbox.verbose) {
                 sandbox.log(`getSubscriptions() => ${JSON.stringify(result)}`, 'info');
@@ -1491,8 +1578,8 @@ function sandBox(script, name, verbose, debug, context) {
             if (objects[_adapter]?.common?.subscribable) {
                 const a = `${parts[0]}.${parts[1]}`;
                 const alive = `system.adapter.${a}.alive`;
-                context.adapterSubs[alive] = context.adapterSubs[alive] || [];
-                context.adapterSubs[alive].push(id);
+                context.adapterSubs[alive] = context.adapterSubs[alive] || new Set();
+                context.adapterSubs[alive].add(id);
                 if (sandbox.verbose) {
                     sandbox.log(`adapterSubscribe: ${a} - ${id}`, 'info');
                 }
@@ -1517,8 +1604,11 @@ function sandBox(script, name, verbose, debug, context) {
             if ((0, tools_1.isObject)(idOrObject)) {
                 for (let i = context.subscriptions.length - 1; i >= 0; i--) {
                     if (context.subscriptions[i] === idOrObject) {
-                        unsubscribePattern(script, context.subscriptions[i].pattern.id);
+                        const sub = context.subscriptions[i];
+                        unsubscribePattern(script, sub.pattern.id);
                         context.subscriptions.splice(i, 1);
+                        // Remove from O(1) dispatch structures
+                        removeFromDispatchIndex(context, sub);
                         sandbox.__engine.__subscriptions--;
                         return true;
                     }
@@ -1529,8 +1619,11 @@ function sandBox(script, name, verbose, debug, context) {
             for (let i = context.subscriptions.length - 1; i >= 0; i--) {
                 if (context.subscriptions[i].name === name && context.subscriptions[i].pattern.id === idOrObject) {
                     deleted++;
-                    unsubscribePattern(script, context.subscriptions[i].pattern.id);
+                    const sub = context.subscriptions[i];
+                    unsubscribePattern(script, sub.pattern.id);
                     context.subscriptions.splice(i, 1);
+                    // Remove from O(1) dispatch structures
+                    removeFromDispatchIndex(context, sub);
                     sandbox.__engine.__subscriptions--;
                 }
             }
@@ -1542,7 +1635,7 @@ function sandBox(script, name, verbose, debug, context) {
             return sandbox.subscribe(pattern, callbackOrChangeTypeOrId, value);
         },
         onEnumMembers: function (enumId, callback) {
-            if (enums.includes(enumId)) {
+            if (enums.has(enumId)) {
                 const subscriptions = {};
                 const init = () => {
                     const obj = objects[enumId];
@@ -1557,7 +1650,8 @@ function sandBox(script, name, verbose, debug, context) {
                     }
                     // Subscribe to all members of enum
                     for (const objId of members) {
-                        if (!Object.keys(subscriptions).includes(objId)) {
+                        // IO-6: `in` operator instead of Object.keys().includes() – O(1) instead of O(n)
+                        if (!(objId in subscriptions)) {
                             if (objects?.[objId]?.type === 'state') {
                                 // Just subscribe to states
                                 subscriptions[objId] = sandbox.subscribe(objId, callback); // TODO: more features
@@ -2059,11 +2153,13 @@ function sandBox(script, name, verbose, debug, context) {
             const schedules = context.scheduler?.getList() || [];
             if (allScripts) {
                 Object.keys(context.scripts).forEach(name => context.scripts[name].schedules &&
-                    context.scripts[name].schedules.forEach(s => schedules.push(JSON.parse(JSON.stringify(s._ioBroker)))));
+                    // IO-8: Spread instead of JSON.parse(JSON.stringify()) – _ioBroker has only primitive fields
+                    context.scripts[name].schedules.forEach(s => schedules.push({ ...s._ioBroker })));
             }
             else {
                 script.schedules &&
-                    script.schedules.forEach(s => schedules.push(JSON.parse(JSON.stringify(s._ioBroker))));
+                    // IO-8: Spread instead of JSON.parse(JSON.stringify())
+                    script.schedules.forEach(s => schedules.push({ ...s._ioBroker }));
             }
             return schedules;
         },
@@ -2100,10 +2196,22 @@ function sandBox(script, name, verbose, debug, context) {
                 if (timers[id]) {
                     sandbox.verbose &&
                         sandbox.log(`setStateDelayed: clear ${timers[id].length} running timers`, 'info');
+                    // collect affected scriptNames before deleting
+                    const affectedScripts = new Set(timers[id].map(e => e.scriptName));
                     for (let i = 0; i < timers[id].length; i++) {
                         clearTimeout(timers[id][i].t);
                     }
                     delete timers[id];
+                    // update timersByScript reverse-index for all affected scripts
+                    for (const scriptName of affectedScripts) {
+                        const scriptSet = context.timersByScript.get(scriptName);
+                        if (scriptSet) {
+                            scriptSet.delete(id);
+                            if (!scriptSet.size) {
+                                context.timersByScript.delete(scriptName);
+                            }
+                        }
+                    }
                 }
                 else {
                     if (sandbox.verbose) {
@@ -2130,18 +2238,36 @@ function sandBox(script, name, verbose, debug, context) {
                 if (timers[_id]) {
                     // optimisation
                     if (timers[_id].length === 1) {
+                        const scriptName = timers[_id][0].scriptName;
                         delete timers[_id];
+                        // update timersByScript reverse-index
+                        const scriptSet = context.timersByScript.get(scriptName);
+                        if (scriptSet) {
+                            scriptSet.delete(_id);
+                            if (!scriptSet.size) {
+                                context.timersByScript.delete(scriptName);
+                            }
+                        }
                     }
                     else {
                         for (let t = 0; t < timers[_id].length; t++) {
                             if (timers[_id][t].id === _timerId) {
+                                const scriptName = timers[_id][t].scriptName;
                                 timers[_id].splice(t, 1);
+                                if (!timers[_id].length) {
+                                    delete timers[_id];
+                                    // update timersByScript reverse-index
+                                    const scriptSet = context.timersByScript.get(scriptName);
+                                    if (scriptSet) {
+                                        scriptSet.delete(_id);
+                                        if (!scriptSet.size) {
+                                            context.timersByScript.delete(scriptName);
+                                        }
+                                    }
+                                }
                                 break;
                             }
                         }
-                        if (!timers[_id].length) {
-                            delete timers[_id];
-                        }
                     }
                 }
             }, delay, context.timerId, id, state, isAck);
@@ -2161,6 +2287,11 @@ function sandBox(script, name, verbose, debug, context) {
                     : isAck,
                 scriptName: name,
             });
+            // Keep reverse-index in sync for O(1) cleanup in stopScript
+            if (!context.timersByScript.has(name)) {
+                context.timersByScript.set(name, new Set());
+            }
+            context.timersByScript.get(name).add(id);
             return context.timerId;
         },
         clearStateDelayed: function (id, timerId) {
@@ -2172,14 +2303,18 @@ function sandBox(script, name, verbose, debug, context) {
                 sandbox.log(`clearStateDelayed(id=${id}, timerId=${timerId})`, 'info');
             }
             if (timers[id]) {
+                // collect scriptNames of entries that will be removed
+                const removedScripts = new Set();
                 for (let i = timers[id].length - 1; i >= 0; i--) {
                     if (timerId === undefined || timers[id][i].id === timerId) {
+                        const clearedTimerId = timers[id][i].id;
+                        removedScripts.add(timers[id][i].scriptName);
                         clearTimeout(timers[id][i].t);
                         if (timerId !== undefined) {
                             timers[id].splice(i, 1);
                         }
                         if (sandbox.verbose) {
-                            sandbox.log(`clearStateDelayed: clear timer ${timers[id][i].id}`, 'info');
+                            sandbox.log(`clearStateDelayed: clear timer ${clearedTimerId}`, 'info');
                         }
                     }
                 }
@@ -2191,6 +2326,25 @@ function sandBox(script, name, verbose, debug, context) {
                         delete timers[id];
                     }
                 }
+                // IO-7: keep the timersByScript reverse-index in sync. For every script whose
+                // timer(s) we just removed, drop `id` from its set – unless that script still has
+                // another timer for this state (other scripts' timers may keep timers[id] alive).
+                if (removedScripts.size) {
+                    const remaining = timers[id]; // undefined if the whole entry was deleted
+                    for (const scriptName of removedScripts) {
+                        const stateIds = context.timersByScript.get(scriptName);
+                        if (!stateIds) {
+                            continue;
+                        }
+                        if (remaining?.some(e => e.scriptName === scriptName)) {
+                            continue;
+                        }
+                        stateIds.delete(id);
+                        if (!stateIds.size) {
+                            context.timersByScript.delete(scriptName);
+                        }
+                    }
+                }
                 return true;
             }
             return false;
@@ -2388,7 +2542,7 @@ function sandBox(script, name, verbose, debug, context) {
                     }
                     let result;
                     try {
-                        result = JSON.parse(JSON.stringify(objects[id]));
+                        result = objects[id] ? structuredClone(objects[id]) : undefined;
                     }
                     catch (err) {
                         void adapter.setState(`scriptProblem.${name.substring(SCRIPT_CODE_MARKER.length)}`, {
@@ -2413,9 +2567,9 @@ function sandBox(script, name, verbose, debug, context) {
                 }
                 if (enumName) {
                     const e = eventObj.getObjectEnumsSync(context, id);
-                    const obj = JSON.parse(JSON.stringify(objects[id]));
-                    obj.enumIds = JSON.parse(JSON.stringify(e.enumIds));
-                    obj.enumNames = JSON.parse(JSON.stringify(e.enumNames));
+                    const obj = structuredClone(objects[id]);
+                    obj.enumIds = structuredClone(e.enumIds);
+                    obj.enumNames = structuredClone(e.enumNames);
                     if (typeof enumName === 'string') {
                         const r = new RegExp(`^enum\\.${enumName}\\.`);
                         for (let i = obj.enumIds.length - 1; i >= 0; i--) {
@@ -2431,7 +2585,7 @@ function sandBox(script, name, verbose, debug, context) {
                 }
                 let result;
                 try {
-                    result = JSON.parse(JSON.stringify(objects[id]));
+                    result = structuredClone(objects[id]);
                 }
                 catch (err) {
                     void adapter.setState(`scriptProblem.${name.substring(SCRIPT_CODE_MARKER.length)}`, {
@@ -2489,11 +2643,11 @@ function sandBox(script, name, verbose, debug, context) {
         getEnums: function (enumName) {
             const result = [];
             const r = enumName ? new RegExp(`^enum\\.${enumName}\\.`) : false;
-            for (let i = 0; i < enums.length; i++) {
-                if (!r || r.test(enums[i])) {
-                    const common = objects[enums[i]].common || {};
+            for (const enumId of enums) {
+                if (!r || r.test(enumId)) {
+                    const common = objects[enumId].common || {};
                     result.push({
-                        id: enums[i],
+                        id: enumId,
                         members: common.members || [],
                         name: common.name || '',
                     });
@@ -2502,7 +2656,7 @@ function sandBox(script, name, verbose, debug, context) {
             if (sandbox.verbose) {
                 sandbox.log(`getEnums(enumName=${enumName}) => ${JSON.stringify(result)}`, 'info');
             }
-            return JSON.parse(JSON.stringify(result));
+            return structuredClone(result);
         },
         createAlias: function (name, alias, forceCreation, common, native, callback) {
             if (typeof native === 'function') {
@@ -3154,19 +3308,39 @@ function sandBox(script, name, verbose, debug, context) {
                 adapter.sendTo(_adapter, cmd, msg, cbFunc, options);
             }
             else {
-                // Send it to all instances
-                context.adapter.getObjectView('system', 'instance', { startkey: `system.adapter.${_adapter}.`, endkey: `system.adapter.${_adapter}.\u9999` }, options, (err, res) => {
-                    if (err || !res) {
-                        sandbox.log(`sendTo failed: ${err?.message}`, 'error');
-                        return;
-                    }
-                    const instances = res.rows.map(item => item.id.substring('system.adapter.'.length));
-                    instances.forEach(instance => {
+                // IO-9: Cache sendTo broadcast instance list – avoid repeated getObjectView DB calls
+                const cached = context.sendToInstanceCache.get(_adapter);
+                if (cached) {
+                    cached.forEach(instance => {
                         sandbox.verbose &&
-                            sandbox.log(`sendTo(instance=${instance}, cmd=${cmd}, msg=${JSON.stringify(msg)}, hasCallback=${typeof callback === 'function'})`, 'info');
+                            sandbox.log(`sendTo(instance=${instance}, cmd=${cmd}, msg=${JSON.stringify(msg)}, hasCallback=${typeof callback === 'function'}) [cached]`, 'info');
                         adapter.sendTo(instance, cmd, msg, cbFunc, options);
                     });
-                });
+                }
+                else {
+                    // Send it to all instances
+                    context.adapter.getObjectView('system', 'instance', { startkey: `system.adapter.${_adapter}.`, endkey: `system.adapter.${_adapter}.\u9999` }, options, (err, res) => {
+                        if (err || !res) {
+                            sandbox.log(`sendTo failed: ${err?.message}`, 'error');
+                            return;
+                        }
+                        const instances = res.rows.map(item => item.id.substring('system.adapter.'.length));
+                        // Store in cache for subsequent calls (invalidated on system.adapter.* object change).
+                        // LRU eviction: keep the map bounded to avoid unbounded memory growth.
+                        if (context.sendToInstanceCache.size >= 200) {
+                            const firstKey = context.sendToInstanceCache.keys().next().value;
+                            if (firstKey !== undefined) {
+                                context.sendToInstanceCache.delete(firstKey);
+                            }
+                        }
+                        context.sendToInstanceCache.set(_adapter, instances);
+                        instances.forEach(instance => {
+                            sandbox.verbose &&
+                                sandbox.log(`sendTo(instance=${instance}, cmd=${cmd}, msg=${JSON.stringify(msg)}, hasCallback=${typeof callback === 'function'})`, 'info');
+                            adapter.sendTo(instance, cmd, msg, cbFunc, options);
+                        });
+                    });
+                }
             }
         },
         sendto: function (_adapter, cmd, msg, callback) {
@@ -3230,7 +3404,8 @@ function sandBox(script, name, verbose, debug, context) {
                         errorInCallback(err);
                     }
                 }, ms);
-                script.intervals.push(int);
+                // IO-10: Set.add() – O(1) instead of Array.push()
+                script.intervals.add(int);
                 if (sandbox.verbose) {
                     sandbox.log(`setInterval(ms=${ms})`, 'info');
                 }
@@ -3240,13 +3415,13 @@ function sandBox(script, name, verbose, debug, context) {
             return null;
         },
         clearInterval: function (id) {
-            const pos = script.intervals.indexOf(id);
-            if (pos !== -1) {
+            // IO-10: Set.has/delete – O(1) instead of Array.indexOf+splice O(n)
+            if (script.intervals.has(id)) {
                 if (sandbox.verbose) {
                     sandbox.log('clearInterval() => cleared', 'info');
                 }
                 clearInterval(id);
-                script.intervals.splice(pos, 1);
+                script.intervals.delete(id);
             }
             else {
                 if (sandbox.verbose) {
@@ -3257,11 +3432,8 @@ function sandBox(script, name, verbose, debug, context) {
         setTimeout: function (callback, ms, ...args) {
             if (typeof callback === 'function') {
                 const to = setTimeout(() => {
-                    // Remove timeout from the list
-                    const pos = script.timeouts.indexOf(to);
-                    if (pos !== -1) {
-                        script.timeouts.splice(pos, 1);
-                    }
+                    // IO-10: Set.delete – O(1) instead of Array.indexOf+splice O(n)
+                    script.timeouts.delete(to);
                     try {
                         callback.call(sandbox, ...args);
                     }
@@ -3272,20 +3444,21 @@ function sandBox(script, name, verbose, debug, context) {
                 if (sandbox.verbose) {
                     sandbox.log(`setTimeout(ms=${ms})`, 'info');
                 }
-                script.timeouts.push(to);
+                // IO-10: Set.add – O(1) instead of Array.push
+                script.timeouts.add(to);
                 return to;
             }
             sandbox.log(`Invalid callback for setTimeout! - ${typeof callback}`, 'error');
             return null;
         },
         clearTimeout: function (id) {
-            const pos = script.timeouts.indexOf(id);
-            if (pos !== -1) {
+            // IO-10: Set.has/delete – O(1) instead of Array.indexOf+splice O(n)
+            if (script.timeouts.has(id)) {
                 if (sandbox.verbose) {
                     sandbox.log('clearTimeout() => cleared', 'info');
                 }
                 clearTimeout(id);
-                script.timeouts.splice(pos, 1);
+                script.timeouts.delete(id);
             }
             else {
                 if (sandbox.verbose) {
@@ -3632,50 +3805,45 @@ function sandBox(script, name, verbose, debug, context) {
             const day = 24 * hour;
             const neg = diff < 0;
             diff = Math.abs(diff);
-            if (/(?<!\\)(D|T|Д)/.test(text)) {
+            if (FTD_TEST_D.test(text)) {
                 const days = Math.floor(diff / day);
-                text = text
-                    .replace(/(?<!\\)(DD|TT|ДД)/g, days.toString().padStart(2, '0'))
-                    .replace(/(?<!\\)(D|T|Д)/g, days.toString());
+                text = text.replace(FTD_REPL_DD, days.toString().padStart(2, '0')).replace(FTD_REPL_D, days.toString());
                 if (sandbox.verbose) {
                     sandbox.log(`formatTimeDiff(format=${format}, text=${text}, days=${days})`, 'debug');
                 }
                 diff -= days * day;
             }
-            if (/(?<!\\)(h|S|ч)/.test(text)) {
+            if (FTD_TEST_H.test(text)) {
                 const hours = Math.floor(diff / hour);
                 text = text
-                    .replace(/(?<!\\)(hh|SS|чч)/g, hours.toString().padStart(2, '0'))
-                    .replace(/(?<!\\)(h|S|ч)/g, hours.toString());
+                    .replace(FTD_REPL_HH, hours.toString().padStart(2, '0'))
+                    .replace(FTD_REPL_H, hours.toString());
                 if (sandbox.verbose) {
                     sandbox.log(`formatTimeDiff(format=${format}, text=${text}, hours=${hours})`, 'debug');
                 }
                 diff -= hours * hour;
             }
-            if (/(?<!\\)(m|м)/.test(text)) {
+            if (FTD_TEST_M.test(text)) {
                 const minutes = Math.floor(diff / minute);
                 text = text
-                    .replace(/(?<!\\)(mm|мм)/g, minutes.toString().padStart(2, '0'))
-                    .replace(/(?<!\\)(m|м)/g, minutes.toString());
+                    .replace(FTD_REPL_MM, minutes.toString().padStart(2, '0'))
+                    .replace(FTD_REPL_M, minutes.toString());
                 if (sandbox.verbose) {
                     sandbox.log(`formatTimeDiff(format=${format}, text=${text}, minutes=${minutes})`, 'debug');
                 }
                 diff -= minutes * minute;
             }
-            if (/(?<!\\)(s|с)/.test(text)) {
+            if (FTD_TEST_S.test(text)) {
                 const seconds = Math.floor(diff / second);
                 text = text
-                    .replace(/(?<!\\)(ss|сс)/g, seconds.toString().padStart(2, '0'))
-                    .replace(/(?<!\\)(s|с)/g, seconds.toString());
+                    .replace(FTD_REPL_SS, seconds.toString().padStart(2, '0'))
+                    .replace(FTD_REPL_S, seconds.toString());
                 sandbox.verbose &&
                     sandbox.log(`formatTimeDiff(format=${format}, text=${text}, seconds=${seconds})`, 'debug');
-                // diff -= seconds * second; // no milliseconds
             }
-            text = text
-                .replace(/\\(D|T|Д)/g, '$1')
-                .replace(/\\(h|S|ч)/g, '$1')
-                .replace(/\\(m|м)/g, '$1')
-                .replace(/\\(s|с)/g, '$1');
+            for (const [pattern, replacement] of FTD_UNESCAPE) {
+                text = text.replace(pattern, replacement);
+            }
             if (sandbox.verbose) {
                 sandbox.log(`formatTimeDiff(format=${format}, text=${text})`, 'debug');
             }
@@ -4299,7 +4467,7 @@ function sandBox(script, name, verbose, debug, context) {
             context.messageBusHandlers[sandbox.scriptName] = context.messageBusHandlers[sandbox.scriptName] || {};
             context.messageBusHandlers[sandbox.scriptName][messageName] =
                 context.messageBusHandlers[sandbox.scriptName][messageName] || [];
-            const handler = { id: Date.now() + Math.floor(Math.random() * 10000), cb: callback, sandbox };
+            const handler = { id: _handlerIdCounter++, cb: callback, sandbox };
             context.messageBusHandlers[sandbox.scriptName][messageName].push(handler);
             sandbox.__engine.__subscriptionsMessage += 1;
             if (sandbox.__engine.__subscriptionsMessage %
@@ -4314,23 +4482,18 @@ function sandBox(script, name, verbose, debug, context) {
             let found = false;
             if (ctx) {
                 if (typeof idOrName === 'number') {
-                    for (const messageName in ctx) {
-                        if (Object.prototype.hasOwnProperty.call(ctx, messageName)) {
-                            for (let i = 0; i < ctx[messageName].length; i++) {
-                                if (ctx[messageName][i].id === idOrName) {
-                                    ctx[messageName].splice(i, 1);
-                                    if (!ctx[messageName].length) {
-                                        delete ctx[messageName];
-                                        sandbox.__engine.__subscriptionsMessage--;
-                                    }
-                                    found = true;
-                                    break;
+                    outer: for (const messageName of Object.keys(ctx)) {
+                        for (let i = 0; i < ctx[messageName].length; i++) {
+                            if (ctx[messageName][i].id === idOrName) {
+                                ctx[messageName].splice(i, 1);
+                                if (!ctx[messageName].length) {
+                                    delete ctx[messageName];
+                                    sandbox.__engine.__subscriptionsMessage--;
                                 }
+                                found = true;
+                                break outer;
                             }
                         }
-                        if (found) {
-                            break;
-                        }
                     }
                 }
                 else if (idOrName && ctx[idOrName]) {
@@ -4401,6 +4564,11 @@ function sandBox(script, name, verbose, debug, context) {
             }
             adapter.subscribeForeignObjects(pattern);
             context.subscriptionsObject.push(subs);
+            // Keep O(1) dispatch map in sync
+            if (!context.subscriptionsObjectMap.has(pattern)) {
+                context.subscriptionsObjectMap.set(pattern, []);
+            }
+            context.subscriptionsObjectMap.get(pattern).push(subs);
             return subs;
         },
         unsubscribeObject: function (subObject) {
@@ -4418,6 +4586,17 @@ function sandBox(script, name, verbose, debug, context) {
                 if (context.subscriptionsObject[i] === subObject) {
                     adapter.unsubscribeForeignObjects(subObject.pattern);
                     context.subscriptionsObject.splice(i, 1);
+                    // Keep O(1) dispatch map in sync
+                    const mapSubs = context.subscriptionsObjectMap.get(subObject.pattern);
+                    if (mapSubs) {
+                        const pos = mapSubs.indexOf(subObject);
+                        if (pos !== -1) {
+                            mapSubs.splice(pos, 1);
+                        }
+                        if (!mapSubs.length) {
+                            context.subscriptionsObjectMap.delete(subObject.pattern);
+                        }
+                    }
                     sandbox.__engine.__subscriptionsObject--;
                     return true;
                 }
@@ -4428,6 +4607,17 @@ function sandBox(script, name, verbose, debug, context) {
                     context.subscriptionsObject[i].pattern === subObject.pattern) {
                     deleted++;
                     adapter.unsubscribeForeignObjects(subObject.pattern);
+                    // Keep O(1) dispatch map in sync
+                    const mapSubsP = context.subscriptionsObjectMap.get(subObject.pattern);
+                    if (mapSubsP) {
+                        const pos = mapSubsP.indexOf(context.subscriptionsObject[i]);
+                        if (pos !== -1) {
+                            mapSubsP.splice(pos, 1);
+                        }
+                        if (!mapSubsP.length) {
+                            context.subscriptionsObjectMap.delete(subObject.pattern);
+                        }
+                    }
                     context.subscriptionsObject.splice(i, 1);
                     sandbox.__engine.__subscriptionsObject--;
                 }
@@ -4552,11 +4742,33 @@ function sandBox(script, name, verbose, debug, context) {
                 if (sandbox.verbose) {
                     sandbox.log(`extendObject(id=${id}, obj=${JSON.stringify(obj)})`, 'info');
                 }
+                let objClone;
+                try {
+                    objClone = structuredClone(obj);
+                }
+                catch (err) {
+                    // e.g. DataCloneError when the object contains functions
+                    void adapter.setState(`scriptProblem.${name.substring(SCRIPT_CODE_MARKER.length)}`, {
+                        val: true,
+                        ack: true,
+                        c: 'extendObject',
+                    });
+                    sandbox.log(`Object "${id}" can't be copied: ${JSON.stringify(err)}`, 'error');
+                    if (typeof callback === 'function') {
+                        try {
+                            callback.call(sandbox, new Error(`Object "${id}" can't be copied`));
+                        }
+                        catch (err) {
+                            errorInCallback(err);
+                        }
+                    }
+                    return;
+                }
                 if (callback) {
-                    adapter.extendForeignObject(id, JSON.parse(JSON.stringify(obj)), callback);
+                    adapter.extendForeignObject(id, objClone, callback);
                 }
                 else {
-                    void adapter.extendForeignObject(id, JSON.parse(JSON.stringify(obj)));
+                    void adapter.extendForeignObject(id, objClone);
                 }
             }
         };
@@ -4612,6 +4824,11 @@ function sandBox(script, name, verbose, debug, context) {
             writable: false,
         });
     }
+    // Shallow-freeze the console object exposed to scripts to prevent its methods from being overwritten
+    // Note: __engine must NOT be frozen because its counter properties are mutated at runtime
+    if (sandbox.console && typeof sandbox.console === 'object') {
+        Object.freeze(sandbox.console);
+    }
     return sandbox;
 }
 //# sourceMappingURL=sandbox.js.map