@soundworks/core 5.4.0 → 5.4.3-alpha.0

package/CHANGELOG.md

@@ -1,3 +1,21 @@
+## v5.4.2 - 2026-02-10
+
+- Chore: upgrade API documentation system
+
+## v5.4.1 - 2025-11-18
+
+- Fix: do to not send abort message to requester when acknowledge is false
+
+## v5.4.0 - 2025-11-07
+
+- Feat: expose `BaseStateManager.validateClassDescription` method
+- Feat: implement acknowledge modifier for shared state parameters
+
+## v5.3.0 - 2025-08-14
+
+- Fix: add try / catch block around detach and delete callbacks
+- Fix: throw if calling `SharedState#onDelete` on attached instance
+
 ## v5.2.1 - 2025-08-11
 
 - Fix: Use CancelablePromise to cancel pending promise rather than reject when a state is deleted

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@soundworks/core",
-  "version": "5.4.0",
+  "version": "5.4.3-alpha.0",
   "description": "Open-source creative coding framework for distributed applications based on Web technologies",
   "collaborators": [
     "Benjamin Matuszewski",
@@ -54,32 +54,32 @@
     "postversion": "node ./misc/scripts/check-changelog.js && git commit -am \"$npm_new_version\" --allow-empty"
   },
   "dependencies": {
-    "@ircam/sc-utils": "^1.8.0",
+    "@ircam/sc-utils": "^1.13.0",
     "cancelable-promise": "^4.3.1",
-    "chalk": "^5.3.0",
+    "chalk": "^5.6.2",
     "fast-deep-equal": "^3.1.3",
     "isomorphic-ws": "^5.0.0",
-    "keyv": "^4.5.4",
-    "keyv-file": "^0.3.1",
-    "lodash": "^4.17.21",
+    "keyv": "^5.6.0",
+    "keyv-file": "^5.3.3",
+    "lodash": "^4.17.23",
     "pem": "^1.14.8",
-    "uuid": "^9.0.1",
-    "ws": "^8.17.0"
+    "uuid": "^13.0.0",
+    "ws": "^8.19.0"
   },
   "devDependencies": {
     "@ircam/eslint-config": "^2.0.1",
-    "chai": "^5.1.1",
-    "docdash": "^2.0.2",
-    "dotenv": "^16.4.5",
-    "eslint": "^9.18.0",
-    "jsdoc": "^4.0.3",
-    "mocha": "^10.4.0",
-    "puppeteer": "^22.9.0",
+    "@ircam/jsdoc-template": "^1.1.0",
+    "chai": "^6.2.2",
+    "dotenv": "^17.3.1",
+    "eslint": "^10.0.3",
+    "jsdoc": "^4.0.5",
+    "mocha": "^11.7.5",
+    "puppeteer": "^24.39.0",
     "tcp-ping": "^0.1.1",
-    "typescript": "^5.4.5"
+    "typescript": "^5.9.3"
   },
   "optionalDependencies": {
-    "bufferutil": "^4.0.5",
-    "utf-8-validate": "^5.0.7"
+    "bufferutil": "^4.1.0",
+    "utf-8-validate": "^6.0.6"
   }
 }

package/src/client/ClientPlugin.js

@@ -33,7 +33,7 @@ export const kClientPluginName = Symbol.for('soundworks:client-plugin-name');
  * @extends BasePlugin
  * @inheritdoc
  */
-export default class ClientPlugin extends BasePlugin {
+class ClientPlugin extends BasePlugin {
   // Note: we need this workaround in plugin tests, because the test app and
   // the tested plugin will import different versions of ServerPlugin
   static [kClientPluginName] = 'ClientPlugin';
@@ -73,3 +73,5 @@ export default class ClientPlugin extends BasePlugin {
   //  */
   // async deactivate() {}
 }
+
+export default ClientPlugin;

package/src/common/ParameterBag.js

@@ -160,9 +160,18 @@ class ParameterBag {
             throw new TypeError(`Invalid ParameterDescription for param ${name}: 'default' property is set and not null while the parameter definition is declared as 'event' or 'required'`);
           }
         } else if (!Object.prototype.hasOwnProperty.call(def, key)) {
-          throw new TypeError(`Invalid ParameterDescription for param "${name}"; property '${key}' key is required`);
+          throw new TypeError(`Invalid ParameterDescription for param "${name}": property '${key}' key is required`);
         }
       });
+
+      // check given default value if any
+      if ('default' in def && def.default !== null) {
+        try {
+          types[def.type].coerceFunction(name, def, def.default);
+        } catch (err) {
+          throw new TypeError(`Invalid ParameterDescription for param "${name}": ${err.message}`);
+        }
+      }
     }
   }
 
@@ -430,6 +439,19 @@ class ParameterBag {
 
     return defaults;
   }
+
+  // @todo - should cache result
+  getParamListByDescriptor(descriptorName, descriptorValue) {
+    const result = [];
+
+    for (let [name, def] of Object.entries(this.#description)) {
+      if (def[descriptorName] === descriptorValue) {
+        result.push(name);
+      }
+    }
+
+    return result;
+  }
 }
 
 export default ParameterBag;

package/src/common/version.js

@@ -1,2 +1,2 @@
 // [WARNING] This file is generated, do not edit
-export default '5.4.0';
+export default '5.4.3-alpha.0';

package/src/server/Server.js

@@ -13,7 +13,7 @@ import {
 import chalk from 'chalk';
 import Keyv from 'keyv';
 import { KeyvFile } from 'keyv-file';
-import merge from 'lodash/merge.js';
+import _ from 'lodash';
 
 import auditClassDescription from './audit-state-class-description.js';
 import {
@@ -159,7 +159,7 @@ class Server {
       throw new TypeError(`Cannot construct 'Server': Parameter 1 must be an object`);
     }
 
-    config = merge({}, DEFAULT_CONFIG, config);
+    config = _.merge({}, DEFAULT_CONFIG, config);
 
     // ---------------------------------------------------------------------
     // Deprecation checks for config

package/src/server/ServerPlugin.js

@@ -20,7 +20,7 @@ export const kServerPluginName = Symbol.for('soundworks:server-plugin-name');
  * @extends {BasePlugin}
  * @inheritdoc
  */
-export default class ServerPlugin extends BasePlugin {
+class ServerPlugin extends BasePlugin {
   // Note: we need this workaround in plugin tests, because the test app and
   // the tested plugin will import different versions of ServerPlugin
   static [kServerPluginName] = 'ServerPlugin';
@@ -77,3 +77,5 @@ export default class ServerPlugin extends BasePlugin {
     this.#clients.delete(client);
   }
 }
+
+export default ServerPlugin;

package/src/server/SharedStatePrivate.js

@@ -127,6 +127,9 @@ class SharedStatePrivate {
       // apply registered hooks
       const hooks = this.#manager[kServerStateManagerGetUpdateHooks](this.className);
       const values = this.#parameters.getValues();
+      // make sur we don't propagate back to requester param that are marked as `acknowledge=false`
+      const acknowledgeFilter = this.#parameters.getParamListByDescriptor('acknowledge', false);
+
       let hookAborted = false;
 
       // cf. https://github.com/collective-soundworks/soundworks/issues/45
@@ -145,13 +148,12 @@ class SharedStatePrivate {
 
       if (hookAborted === false) {
         let acknowledgedUpdates = {};
-        let acknowledgeFilter = [];
 
         for (let name in updates) {
           const [newValue, changed] = this.#parameters.set(name, updates[name]);
           // if `filterChange` is set to `false` we don't check if the value
           // has been changed or not, it is always propagated to client states
-          const { event, filterChange, acknowledge } = this.#parameters.getDescription(name);
+          const { event, filterChange } = this.#parameters.getDescription(name);
 
           // if event type reset internal value to null
           if (event) {
@@ -160,10 +162,6 @@ class SharedStatePrivate {
 
           if ((filterChange && changed) || !filterChange) {
             acknowledgedUpdates[name] = newValue;
-
-            if (acknowledge === false) {
-              acknowledgeFilter.push(name);
-            }
           }
         }
 
@@ -247,18 +245,27 @@ class SharedStatePrivate {
             }
           }
         } else {
-          // propagate back to the requester that the update has been aborted, ignore all peers
-          client.transport.emit(`${UPDATE_ABORT}-${this.id}-${instanceId}`, reqId, updates);
+          // @note - abort messages are only sent back to requester
+          const requesterFilteredUpdates = blackListFilterUpdates(updates, acknowledgeFilter);
+
+          if (Object.keys(requesterFilteredUpdates).length > 0) {
+            // propagate back to the requester that the update has been aborted, ignore all peers
+            client.transport.emit(`${UPDATE_ABORT}-${this.id}-${instanceId}`, reqId, requesterFilteredUpdates);
+          }
         }
       } else {
-        // retrieve values from inner state (also handle immediate appropriately)
-        const oldValues = {};
+        // @note - abort messages are only sent back to requester
+        // explicitly aborted by hook (return `null`), send back current values to requester
+        const currentValues = {};
 
         for (let name in updates) {
-          oldValues[name] = this.#parameters.get(name);
+          currentValues[name] = this.#parameters.get(name);
+        }
+
+        const requesterFilteredUpdates = blackListFilterUpdates(currentValues, acknowledgeFilter);
+        if (Object.keys(requesterFilteredUpdates).length > 0) {
+          client.transport.emit(`${UPDATE_ABORT}-${this.id}-${instanceId}`, reqId, requesterFilteredUpdates);
         }
-        // aborted by hook (updates have been overridden to {})
-        client.transport.emit(`${UPDATE_ABORT}-${this.id}-${instanceId}`, reqId, oldValues);
       }
     });
 

package/types/client/Client.d.ts

@@ -217,3 +217,4 @@ import ClientSocket from './ClientSocket.js';
 import ClientContextManager from './ClientContextManager.js';
 import ClientPluginManager from './ClientPluginManager.js';
 import ClientStateManager from './ClientStateManager.js';
+//# sourceMappingURL=Client.d.ts.map

package/types/client/Client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Client.d.ts","sourceRoot":"","sources":["../../src/client/Client.js"],"names":[],"mappings":"AA6BA,+CAA2E;AAC3E,2DAAqG;;AAErG;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH;IAeE;;;OAGG;IACH,oBAHW,YAAY,EA+DtB;IAED;;;;OAIG;IACH,eAFU,MAAM,CAIf;IAED;;;;OAIG;IACH,YAFU,MAAM,CAIf;IAED;;;;OAIG;IACH,cAFU,YAAY,CAIrB;IAED;;;;;;;OAOG;IACH,UAFU,MAAM,CAIf;IAED;;;;;OAKG;IACH,YAFU,MAAM,CAIf;IAED;;;;;;;OAOG;IACH,aAFU,MAAM,CAIf;IAED;;;;OAIG;IACH,eAFU,MAAM,GAAC,SAAS,CAIzB;IAED;;OAEG;IACH,iCAGC;IAED;;;;;OAKG;IACH,cAFU,YAAY,CAIrB;IAED;;;;;;;OAOG;IACH,sBAFU,oBAAoB,CAI7B;IAED;;;;;;;OAOG;IACH,8CAEC;IAED;;;;;;;OAOG;IACH,oBAFU,kBAAkB,CAI3B;IAED;;;;OAIG;IACH,cAFU,MAAM,GAAC,QAAQ,GAAC,SAAS,GAAC,SAAS,CAI5C;IAqBD;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACH,sBA0DC;IAED;;;;;;;;;;;;;;;OAeG;IACH,uBAgBC;IAED;;;;;;;;;;;;;;;OAeG;IACH,sBAcC;IAED;;;;;;;;;;;;;;;;OAgBG;IACH,iBAPa,OAAO,CAAC,WAAW,CAAC,CAiBhC;IAED;;;;;OAKG;IACH,6CAGC;IA3VC,2CAAgD;;CA4VnD;yBAndM,mBAAmB;iCARnB,2BAA2B;gCACF,0BAA0B;+BAQ3B,yBAAyB"}

package/types/client/ClientContext.d.ts

@@ -162,3 +162,4 @@ declare class ClientContext {
     #private;
 }
 import Client from './Client.js';
+//# sourceMappingURL=ClientContext.d.ts.map

package/types/client/ClientContext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ClientContext.d.ts","sourceRoot":"","sources":["../../src/client/ClientContext.js"],"names":[],"mappings":"AAcA,iDAA+E;;AAK/E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH;IAGE;;;OAGG;IACH,oBAHW,MAAM,EA4ChB;IAED;;;OAGG;IACH,cAFU,MAAM,CAIf;IAED;;;OAGG;IACH,cAFU,MAAM,GAAC,QAAQ,GAAC,SAAS,GAAC,SAAS,CAI5C;IAED;;;;;;;;;;;;;;;;OAgBG;IACH,qBATU,MAAM,CAWf;IAED;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH,uBAAgB;IAEhB;;;;;;OAMG;IACH,sBAAe;IAEf;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACH,SAda,OAAO,CAAC,IAAI,CAAC,CA6BzB;IAED;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,QAda,OAAO,CAAC,IAAI,CAAC,CAwBzB;IAvLC,+BAAmC;;CAwLtC;mBAlQkB,aAAa"}

package/types/client/ClientContextManager.d.ts

@@ -40,3 +40,4 @@ declare class ClientContextManager {
     private [kClientContextManagerStop];
     #private;
 }
+//# sourceMappingURL=ClientContextManager.d.ts.map

package/types/client/ClientContextManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ClientContextManager.d.ts","sourceRoot":"","sources":["../../src/client/ClientContextManager.js"],"names":[],"mappings":"AAIA,uDAA4F;AAC5F,sDAA0F;AAC1F,0DAAkG;;AA2BlG;;;;;;;;GAQG;AACH;IAoCE;;;;;;;OAOG;IACH,iBAHW,MAAM,GACJ,OAAO,CAAC,aAAa,CAAC,CA2BlC;IAjED;;;;;OAKG;IACH,wCAMC;IAED;;;OAGG;IACH,qCAGC;IAED;;;OAGG;IACH,oCAGC;;CAoCF"}

package/types/client/ClientPlugin.d.ts

@@ -1,4 +1,9 @@
 export const kClientPluginName: unique symbol;
+export default ClientPlugin;
+/**
+ * ~onStateChangeCallback
+ */
+export type ClientPlugin = (#state: ClientPlugin) => any;
 /**
  * Callback executed when the plugin state is updated.
  *
@@ -28,7 +33,7 @@ export const kClientPluginName: unique symbol;
  * @extends BasePlugin
  * @inheritdoc
  */
-export default class ClientPlugin extends BasePlugin {
+declare class ClientPlugin extends BasePlugin {
     static [kClientPluginName]: string;
     /**
      * @param {Client} client - A soundworks client instance.
@@ -44,8 +49,5 @@ export default class ClientPlugin extends BasePlugin {
     get client(): Client;
     #private;
 }
-/**
- * ~onStateChangeCallback
- */
-export type ClientPlugin = (#state: ClientPlugin) => any;
 import BasePlugin from '../common/BasePlugin.js';
+//# sourceMappingURL=ClientPlugin.d.ts.map

package/types/client/ClientPlugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ClientPlugin.d.ts","sourceRoot":"","sources":["../../src/client/ClientPlugin.js"],"names":[],"mappings":"AAEA,8CAA6E;;;;;oCAMlE,YAAY;AAJvB;;;;;GAKG;AAEH;;;;GAIG;AAEH;;;;;;;;;;;;;;;;;GAiBG;AACH;IAGE,mCAA4C;IAI5C;;;OAGG;IACH,oBAHW,MAAM,MACN,MAAM,EAMhB;IAED;;;;;OAKG;IACH,cAHU,MAAM,CAKf;;CAcF;uBA1EsB,yBAAyB"}

package/types/client/ClientPluginManager.d.ts

@@ -109,3 +109,4 @@ declare class ClientPluginManager<T> extends BasePluginManager {
 }
 import BasePluginManager from '../common/BasePluginManager.js';
 import Client from './Client.js';
+//# sourceMappingURL=ClientPluginManager.d.ts.map

package/types/client/ClientPluginManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ClientPluginManager.d.ts","sourceRoot":"","sources":["../../src/client/ClientPluginManager.js"],"names":[],"mappings":";AAIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyDG;AACH,kCAFa,CAAC;IAGZ;;;OAGG;IACH,oBAHW,MAAM,EAShB;IAED;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,aAfW,MAAM,QAEN,CAAC,CAAC,YAAY,CAAC,YACf,MAAM,sBAmBhB;IAED;;;;;;;;;;;;;;;;;OAiBG;IACH,QAHW,MAAM,GACJ,OAAO,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC,CAQpC;CACF;8BAnI6B,gCAAgC;mBAD3C,aAAa"}

package/types/client/ClientSocket.d.ts

@@ -74,3 +74,4 @@ declare class ClientSocket {
     private [kSocketTerminate];
     #private;
 }
+//# sourceMappingURL=ClientSocket.d.ts.map

package/types/client/ClientSocket.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ClientSocket.d.ts","sourceRoot":"","sources":["../../src/client/ClientSocket.js"],"names":[],"mappings":"AAaA,6CAAsE;;AAEtE;;;;;;;;;;;;;;;;;;;GAmBG;AACH;IAOE,wDAIC;IAED;;;;;;;OAOG;IACH,aA4HC;IAoCD;;;;;;OAMG;IACH,cAJW,MAAM,WACH,GAAC,EAAA,QAQd;IAED;;;;;;;OAOG;IACH,qBALW,MAAM,4BAYhB;IAED;;;;;OAKG;IACH,wBAHW,MAAM,4BAYhB;IAED;;;;OAIG;IACH,6BAFW,MAAM,QAQhB;IA7FD;;;;;;;;;OASG;IACH,2BAWC;;CAyEF"}

package/types/client/ClientStateManager.d.ts

@@ -67,3 +67,4 @@ export type ClientStateManager = () => any;
 declare class ClientStateManager extends BaseStateManager {
 }
 import BaseStateManager from '../common/BaseStateManager.js';
+//# sourceMappingURL=ClientStateManager.d.ts.map

package/types/client/ClientStateManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ClientStateManager.d.ts","sourceRoot":"","sources":["../../src/client/ClientStateManager.js"],"names":[],"mappings":";;;;;AAEA;;;;;;GAMG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqDG;AACH;CAAoD;6BAhEvB,+BAA+B"}

package/types/client/index.d.ts

@@ -54,3 +54,4 @@ export type ClientConfig = {
      */
     env: ClientEnvConfig;
 };
+//# sourceMappingURL=index.d.ts.map

package/types/client/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/client/index.js"],"names":[],"mappings":";;;;;;;;;;;WAac,MAAM;;;;aACN,MAAM;;;;;;;;;UAON,MAAM;;;;;mBACN,MAAM;;;;cAEN,OAAO;;;;cACP,MAAM;;;;;;;;;UAON,MAAM;;;;SACN,eAAe;;;;SACf,eAAe"}

package/types/common/BasePlugin.d.ts

@@ -154,3 +154,4 @@ declare class BasePlugin {
     private [kBasePluginStatus];
     #private;
 }
+//# sourceMappingURL=BasePlugin.d.ts.map

package/types/common/BasePlugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BasePlugin.d.ts","sourceRoot":"","sources":["../../src/common/BasePlugin.js"],"names":[],"mappings":"AAGA,8CAA6E;;;;;mDAMlE,UAAU;;;;;AAJrB;;;;;GAKG;AAEH;;;;GAIG;AAEH,eAAe;AACf;IAIE,qBAkBC;IAbC;;;;;;;;;;;OAWG;IACH,iBAPU,MAAM,CAOD;IAGjB;;;;;;;OAOG;IACH,mBALU,MAAM,CAOf;IAED;;;;;;;;;OASG;IACH,qBAHU,MAAM,CAKf;IAED;;;;OAIG;IACH,cAFU,MAAM,GAAC,QAAQ,GAAC,SAAS,GAAC,SAAS,CAI5C;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA+BG;IACH,uBAAgB;IAEhB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA+BG;IACH,sBAAe;IAEf;;;;;;;;;;OAUG;IACH,wBARW,2BAA2B,GACzB,iCAAiC,CAU7C;IAED;;;;;;;;;OASG;IACH,8BALW,MAAM,QAQhB;IAtJC,eAAe;IACf,4BAAgC;;CAsJnC"}

package/types/common/BasePluginManager.d.ts

@@ -131,3 +131,4 @@ declare class BasePluginManager {
     private [kPluginManagerInstances];
     #private;
 }
+//# sourceMappingURL=BasePluginManager.d.ts.map

package/types/common/BasePluginManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BasePluginManager.d.ts","sourceRoot":"","sources":["../../src/common/BasePluginManager.js"],"names":[],"mappings":"AAQA,gDAA6E;AAC7E,+CAA2E;AAC3E,oDAAqF;;;;;oDAM1E,MAAM,aACN,YAAY,GAAC,YAAY,GAAC,IAAI;;;;;AALzC;;;;;;;;GAQG;AAEH;;;;GAIG;AAEH,eAAe;AACf;IAQE,uBAIC;IA8DD;;;;OAIG;IACH,cAFU,MAAM,GAAC,QAAQ,GAAC,SAAS,GAAC,SAAS,CAI5C;IAED;;;;OAIG;IACH,kBAEC;IAED;;;;;;;;;OASG;IACH,iCAqDC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA8BG;IACH,aAfW,MAAM,4BAGN,MAAM,sBA6ChB;IAED;;;;OAIG;IACH,sDAGC;IAED;;;OAGG;IACH,wBAFa,MAAM,EAAE,CAIpB;IAED;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,wBAhBW,kCAAkC,GAChC,wCAAwC,CAkBpD;IA9OD;;;;;;OAMG;IACH,8BAyBC;IAED,eAAe;IACf,6BAQC;IA9DC,eAAe;IACf,kCAAyC;;CAiQ5C"}

package/types/common/BaseStateManager.d.ts

@@ -254,3 +254,4 @@ declare class BaseStateManager {
 }
 import SharedState from './SharedState.js';
 import SharedStateCollection from './SharedStateCollection.js';
+//# sourceMappingURL=BaseStateManager.d.ts.map

package/types/common/BaseStateManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BaseStateManager.d.ts","sourceRoot":"","sources":["../../src/common/BaseStateManager.js"],"names":[],"mappings":"AA2BA,8CAAyE;AACzE,qDAAwF;AAExF,gDAA6E;;;;;;;;;;;AAE7E;;;;;;;;GAQG;AACH;;;;;GAKG;AAEH,eAAe;AACf;IAuLE;;;;;;OAMG;IACH,2CAHW,GAAC,QAKX;IAED;;;;;;;;OAQG;IACH,+BANW,oBAAoB,GAEnB,2BAA2B,CAatC;IAED;;OAEG;IACH,wCAGC;IAED;;;;;;;;OAQG;IACH,kBANW,oBAAoB;;QAElB,OAAO,CAAC,WAAW,CAAC,CAahC;;;;;;;;;;;IAKE,kBACQ,oBAAoB,GAClB,OAAO,CAAC,WAAW,CAAC,CAE9B;;;;;;;;;;;;IAMA,kBACQ,oBAAoB,WACpB,MAAM,GACJ,OAAO,CAAC,WAAW,CAAC,CAE9B;;;;;;;;;;;;IAMA,kBACQ,oBAAoB,UACpB,MAAM,EAAE,GACN,OAAO,CAAC,WAAW,CAAC,CAE9B;;;;;;;;;;;;;IAMA,kBACQ,oBAAoB,WACpB,MAAM,UACN,MAAM,EAAE,GACN,OAAO,CAAC,WAAW,CAAC,CAE9B;;;;;;;;;;;;;;IAsEA,kBACQ,2BAA2B,OAEnC;;;;;;;;;;;;;;;IAWA,mBACQ,oBAAoB,YAEpB,2BAA2B,OAEnC;;;;;;;;;;;;;;;;;;IASA,kBACQ,2BAA2B,WAGnC;QAAyB,YAAY,EAA7B,OAAO;KAEf,OAAA;;;;;;;;;;;;;;;;;;IAWA,mBACQ,oBAAoB,YAEpB,2BAA2B,WAGnC;QAAyB,YAAY,EAA7B,OAAO;KAEf,OAAA;;;;;;;;;;;IAwJA,yBACQ,oBAAoB,GAClB,OAAO,CAAC,qBAAqB,CAAC,CAExC;;;;;;;;;;;;;IAMA,yBACQ,oBAAoB,UACpB,wBAAwB,EAAE,GAExB,OAAO,CAAC,qBAAqB,CAAC,CAExC;;;;;;;;;;;;;;IAMA,yBACQ,oBAAoB,WAE5B;QAAyB,YAAY,EAA7B,OAAO;KAEf,GAAU,OAAO,CAAC,qBAAqB,CAAC,CAExC;;;;;;;;;;;;;;;;IAMA,yBACQ,oBAAoB,UACpB,wBAAwB,EAAE,WAGlC;QAAyB,YAAY,EAA7B,OAAO;KAEf,GAAU,OAAO,CAAC,qBAAqB,CAAC,CAExC;IA7jBH,eAAe;IACf,mCAEC;IAED;;;;;;;OAOG;IACH,4BA2IC;IA5KC,eAAe;IACf,8BAAgC;;CAupBnC;wBAjtBuB,kBAAkB;kCAGnC,4BAA4B"}

package/types/common/BatchedTransport.d.ts

@@ -11,3 +11,4 @@ declare class BatchedTransport {
     removeAllListeners(channel?: any): void;
     #private;
 }
+//# sourceMappingURL=BatchedTransport.d.ts.map

package/types/common/BatchedTransport.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BatchedTransport.d.ts","sourceRoot":"","sources":["../../src/common/BatchedTransport.js"],"names":[],"mappings":";AAEA;;;GAGG;AACH;IAME,4BAeC;IAED,+CAOC;IAED,kDAWC;IAED,kDAKC;IAED,wCAOC;;CACF"}

package/types/common/ParameterBag.d.ts

@@ -138,5 +138,7 @@ declare class ParameterBag {
     getDescription(name?: any): object;
     getInitValues(): {};
     getDefaults(): {};
+    getParamListByDescriptor(descriptorName: any, descriptorValue: any): string[];
     #private;
 }
+//# sourceMappingURL=ParameterBag.d.ts.map

package/types/common/ParameterBag.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ParameterBag.d.ts","sourceRoot":"","sources":["../../src/common/ParameterBag.js"],"names":[],"mappings":";;;;;;;;;;;;;;QAuBoB,yEAMf;;;;;;;QAOe,0EAMf;;;;;;;;QAUoB,mDAgBpB;QACe,0EAMf;;;;;;;;QAUoB,qDAgBpB;;QACe,0EAMf;;;;;;;;QAOe,uEAOf;;;;;;;;;QAOe,uEAGf;;;;;AAKL,eAAe;AACf;IACE,mDAoCC;IAED,iDAyBC;IAKD,+CAyCC;IAED;;;;;OAKG;IACH,UAHW,MAAM,WAKhB;IAED;;;;;OAKG;IACH,aAFY,MAAM,CAUjB;IAED;;;;;;;;OAQG;IACH,mBAFY,MAAM,CAUjB;IAED;;;;;;OAMG;IACH,UAHW,MAAM,GACL,KAAK,CAchB;IAED;;;;;;;;;OASG;IACH,gBAHW,MAAM,GACL,KAAK,CAQhB;IAED;;;;;OAKG;IACH,iCAFW,KAAK,SAmBf;IAED;;;;;;;;OAQG;IACH,UAJW,MAAM,SACN,KAAK,SAqBf;IAED;;;;;;OAMG;IAWH;;OAEG;IACH,4BAFY,MAAM,CAYjB;IAGD,oBAQC;IAGD,kBAQC;IAGD,8EAUC;;CACF"}

package/types/common/PromiseStore.d.ts

@@ -13,3 +13,4 @@ export default class PromiseStore {
     reject(id: any, msg: any): void;
     flush(): void;
 }
+//# sourceMappingURL=PromiseStore.d.ts.map

package/types/common/PromiseStore.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PromiseStore.d.ts","sourceRoot":"","sources":["../../src/common/PromiseStore.js"],"names":[],"mappings":"AAKA,eAAe;AACf;IACE,uBAIC;IAHC,UAAgB;IAChB,qBAAsB;IACtB,gBAA2B;IAG7B;;;MAYC;IAID,yDAGC;IAED,kCAcC;IAED,gCASC;IAGD,cAMC;CACF"}

package/types/common/SharedState.d.ts

@@ -289,3 +289,4 @@ declare class SharedState {
     private [kSharedStatePromiseStore];
     #private;
 }
+//# sourceMappingURL=SharedState.d.ts.map

package/types/common/SharedState.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SharedState.d.ts","sourceRoot":"","sources":["../../src/common/SharedState.js"],"names":[],"mappings":"AA0BA,qDAAwF;;;;;;;;;;AAExF;;;;;;;;GAQG;AAEH;;;;GAIG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuDG;AACH;IAeE;;;;;;;;;OA4JC;IAED;;;OAGG;IACH,iBAEC;IAED;;;OAGG;IACH,wBAEC;IAED;;OAEG;IACH,yBAGC;IAED;;;OAGG;IACH,uBAEC;IAwED;;;;;;;;;;;OAWG;IACH,2BARW,MAAM,GAEL,2BAA2B,GAAC,+BAA+B,CAYtE;IAED;;OAEG;IACH,gCAGC;;;;;;;;;;;IAQE,aACQ,MAAM,GACJ,OAAO,KAAQ,CAC3B;;;;;;;;;;;;IAOE,UACQ,wBAAwB,SACxB,GAAC,GACC,OAAO,KAAQ,CAC3B;IAyKD;;;;;;;;;;;;;;OAcG;IACH,UANW,wBAAwB,GACvB,GAAG,CAiBd;IAED;;;;;;;;;;;;;;OAcG;IACH,gBANW,wBAAwB,GACvB,GAAG,CAiBd;IAED;;;;;;;;OAQG;IACH,aAJY,MAAM,CAgBjB;IAED;;;;;;;;;;;;OAYG;IACH,mBAJY,MAAM,CAgBjB;IAED;;;;;;;OAOG;IACH,iBAJY,MAAM,CAMjB;IAED;;;;;;OAMG;IACH,eAJY,MAAM,CAMjB;IAED;;;;;;;;OAQG;IACH,uBAiBC;IAED;;;;;;;;;;;;;;OAcG;IACH,uBAUC;IAED;;;;;;;;;;;;;;;;;;;OAmBG;IACH,oDAba,iCAAiC,CAkC7C;IAED;;;;;;;OAOG;IACH,4CAGC;IAED;;;;;;OAMG;IACH,4CAOC;IArsBC,eAAe;IACf,mCAAwE;;CAqsB3E"}

package/types/common/SharedStateCollection.d.ts

@@ -325,3 +325,4 @@ declare class SharedStateCollection {
     };
     #private;
 }
+//# sourceMappingURL=SharedStateCollection.d.ts.map

package/types/common/SharedStateCollection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SharedStateCollection.d.ts","sourceRoot":"","sources":["../../src/common/SharedStateCollection.js"],"names":[],"mappings":"AAEA;;;;;;;;;;GAUG;AAEH;;;;GAIG;AAEH;;;;;GAKG;AAEH;;;;GAIG;AAEH;;;;;;GAMG;AAEH;;;;GAIG;AAEH;;;;GAIG;AAEH;;;;GAIG;AAEH,uDAA4F;;;;;;4DApDjF,WAAW;;;;;;;;4DAiBX,WAAW;;;;;;;;;4DAcX,WAAW;;;;;;;;;;;;;AAuBtB;;;;;;;;;;;;;;;;;GAiBG;AACH;IAaE,2EAKC;IAuCD;;;;OAIG;IACH,uBAHU,MAAM,CAKf;IAED;;;OAGG;IACH,YAFU,MAAM,CAIf;IAED;;;OAGG;IACH,wBAEC;IAED;;OAEG;IACH,yBAGC;IAED;;OAEG;IACH,gCAGC;IAED;;;;;;;;;;;OAWG;IACH,2BARW,MAAM,GAEL,2BAA2B,GAAC,+BAA+B,CAgBtE;IAED;;;;;;OAMG;IACH,eAJY,MAAM,CAUjB;IAED;;;OAGG;IACH,aAFY,KAAQ,CAInB;IAED;;;;;;;;;;OAUG;IACH,mBAFY,KAAQ,CAInB;IAED;;;;;OAKG;IACH,mBAFY,GAAG,EAAE,CAMhB;IAED;;;;;;;;;OASG;IACH,yBAFY,GAAG,EAAE,CAMhB;;;;;;;;;;;IAQE,aACQ,MAAM,GACJ,OAAO,CAAC,KAAK,KAAQ,CAAC,CAClC;;;;;;;;;;;;IAOE,UACQ,wBAAwB,SACxB,GAAC,GACC,OAAO,CAAC,KAAK,KAAQ,CAAC,CAClC;IAwBD;;;;;;;;;OASG;IACH,mBAPW,qCAAqC,8BAInC,2CAA2C,CAyBvD;IAED;;;;;;;;;;OAUG;IACH,mBAPW,qCAAqC,oBAErC,OAAO,GAEL,2CAA2C,CAWvD;IAED;;;;;;;;OAQG;IACH,mBALW,qCAAqC,GAEnC,2CAA2C,CAOvD;IAED;;;;;;;;;;;OAWG;IACH,mBARW,qCAAqC,8BAEnC,2CAA2C,CAcvD;IAED;;;OAGG;IACH,wBAUC;IAED;;;;;OAKG;IACH,8BAEC;IAED;;;;;;OAMG;IACH,2BAEC;IAED;;;;;;;OAOG;IACH,8BAEC;IAED;;;;OAIG;IACH,2BAEC;IAED;;;;;;;OAOG;IACH,0BAEC;IAED;;;;;;;;;;;;;;OAcG;IACH,OAVa,CAAC,gCAKH,CAAC,mBAGA,CAAC,CASZ;IA5YD,eAAe;IACf,qCAkCC;IA2WD;;OAEG;IACH;;;;;MAYC;;CACF"}

package/types/common/constants.d.ts

@@ -40,3 +40,4 @@ export const CLIENT_HANDSHAKE_RESPONSE: "cl:h:res";
 export const CLIENT_HANDSHAKE_ERROR: "cl:h:err";
 export const AUDIT_STATE_NAME: "p:s:audit";
 export const PRIVATE_STATES: string[];
+//# sourceMappingURL=constants.d.ts.map

package/types/common/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../src/common/constants.js"],"names":[],"mappings":"AACA,wBAAyB,CAAC,CAAC,CAAC;AAE5B,mCAAuC;AACvC,2BAA4B,QAAQ,CAAC;AACrC,2BAA4B,QAAQ,CAAC;AAGrC,wCAAyC,KAAK,CAAC;AAG/C,6BAA8B,SAAS,CAAC;AACxC,8BAA+B,SAAS,CAAC;AACzC,2BAA4B,SAAS,CAAC;AAEtC,6BAA8B,UAAU,CAAC;AACzC,8BAA+B,UAAU,CAAC;AAC1C,2BAA4B,UAAU,CAAC;AACvC,kCAAmC,UAAU,CAAC;AAE9C,6BAA8B,SAAS,CAAC;AACxC,8BAA+B,SAAS,CAAC;AACzC,2BAA4B,SAAS,CAAC;AAEtC,6BAA8B,UAAU,CAAC;AACzC,8BAA+B,UAAU,CAAC;AAC1C,2BAA4B,UAAU,CAAC;AAEvC,8BAA+B,SAAS,CAAC;AACzC,+BAAgC,SAAS,CAAC;AAC1C,4BAA6B,SAAS,CAAC;AACvC,mCAAoC,SAAS,CAAC;AAE9C,qCAAsC,UAAU,CAAC;AAEjD,6BAA8B,SAAS,CAAC;AACxC,8BAA+B,SAAS,CAAC;AACzC,2BAA4B,QAAQ,CAAC;AACrC,kCAAmC,SAAS,CAAC;AAE7C,wCAAyC,OAAO,CAAC;AAEjD,4CAA6C,SAAS,CAAC;AACvD,6CAA8C,SAAS,CAAC;AACxD,0CAA2C,SAAS,CAAC;AAGrD,oCAAqC,UAAU,CAAC;AAChD,qCAAsC,UAAU,CAAC;AACjD,kCAAmC,UAAU,CAAC;AAE9C,mCAAoC,UAAU,CAAC;AAC/C,oCAAqC,UAAU,CAAC;AAChD,iCAAkC,UAAU,CAAC;AAG7C,uCAAwC,UAAU,CAAC;AACnD,wCAAyC,UAAU,CAAC;AACpD,qCAAsC,UAAU,CAAC;AAGjD,+BAAgC,WAAW,CAAC;AAC5C,sCAAiD"}

package/types/common/logger.d.ts

@@ -16,3 +16,4 @@ declare namespace logger {
     function removed(oldAPI: any, hint: any, lastSupportedVersion: any): never;
     function httpsCertsInfos(httpsCertsInfos: any): void;
 }
+//# sourceMappingURL=logger.d.ts.map

package/types/common/logger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../../src/common/logger.js"],"names":[],"mappings":";;;IAQE,uCAEC;IAED,+BAMC;IAED,6BAMC;IAED,8BAMC;IAED,+BAMC;IAED,0DAMC;IAED,sCAMC;IAED,wCAMC;IAED,sCAMC;IAED,wCAMC;IAED,iGAaC;IAED,+EAOC;IAED,2EAOC;IAED,qDA6BC"}

package/types/common/shared-state-types.d.ts

@@ -104,3 +104,4 @@ type SharedStateParameterDescription = {
      */
     metas?: object;
 };
+//# sourceMappingURL=shared-state-types.d.ts.map

package/types/common/shared-state-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shared-state-types.d.ts","sourceRoot":"","sources":["../../src/common/shared-state-types.js"],"names":[],"mappings":";;;4BAGa,MAAM;;;;;;;;;;;;;;;;gCAoCN,MAAM;;;;;;;;UAOL,SAAS,GAAC,QAAQ,GAAC,SAAS,GAAC,OAAO,GAAC,MAAM,GAAC,KAAK;;;;;aACjD,GAAG;;;;;eAEH,OAAO;;;;;;YAEP,OAAO;;;;;eAGP,OAAO;;;;;;;;;mBAEP,OAAO;;;;;;;;;;;gBAMP,OAAO;;;;;;;;;YAQP,OAAO;;;;;;;;kBAMP,OAAO;;;;;UAKP,MAAM;;;;;UAEN,MAAM;;;;;WAEN,KAAK,CAAC,GAAG,CAAC;;;;YAEV,MAAM"}

package/types/common/sockets-utils.d.ts

@@ -2,3 +2,4 @@
 export function packStringMessage(channel: any, ...args: any[]): string;
 /** @private */
 export function unpackStringMessage(data: any): any;
+//# sourceMappingURL=sockets-utils.d.ts.map

package/types/common/sockets-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sockets-utils.d.ts","sourceRoot":"","sources":["../../src/common/sockets-utils.js"],"names":[],"mappings":"AAAA,eAAe;AACf,wEAEC;AAED,eAAe;AACf,oDAEC"}

package/types/common/version.d.ts

@@ -1,2 +1,3 @@
-declare const _default: "5.4.0";
+declare const _default: "5.4.3-alpha.0";
 export default _default;
+//# sourceMappingURL=version.d.ts.map

package/types/common/version.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"version.d.ts","sourceRoot":"","sources":["../../src/common/version.js"],"names":[],"mappings":"wBACe,eAAe"}

package/types/server/Server.d.ts

@@ -300,3 +300,4 @@ import ServerPluginManager from './ServerPluginManager.js';
 import ServerStateManager from './ServerStateManager.js';
 import ServerContextManager from './ServerContextManager.js';
 import ServerClient from './ServerClient.js';
+//# sourceMappingURL=Server.d.ts.map

package/types/server/Server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Server.d.ts","sourceRoot":"","sources":["../../src/server/Server.js"],"names":[],"mappings":"AA2FA,sDAA0F;AAC1F,0DAAmG;AAEnG,2DAAqG;;AAErG;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH;IAuBE;;;;;;;;OAQG;IACH,oBARW,YAAY,EA+FtB;IAED;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,cAFU,YAAY,CAIrB;IAED;;;;OAIG;IACH,eAFU,MAAM,CAIf;IAED;;;;OAIG;IACH,mBAHU,MAAM,CAKf;IAED;;;;OAIG;IACH,cAFU,MAAM,GAAC,QAAQ,GAAC,SAAS,GAAC,SAAS,CAI5C;IAwBD,wBAaC;IAnCD;;;;;;;;;;;;;;;;;OAiBG;IACH,kBAEC;IAiBD;;;;;OAKG;IACH,sBAEC;IAED;;;;OAIG;IACH,cAEC;IAED;;;;OAIG;IACH,eAFU,aAAa,CAItB;IAED;;;;OAIG;IACH,8CAEC;IAED;;;;OAIG;IACH,oBAFU,kBAAkB,CAI3B;IAED;;;;OAIG;IACH,gDAEC;IAqBD;;;;;;;;;;;OAWG;IACH,kDAGC;IAED;;;;;;;;;;;;;;;OAeG;IACH,iBAPa,OAAO,CAAC,WAAW,CAAC,CAahC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAiCG;IACH,sBA2CC;IAED;;;;;;;;;;;;;;;;;;OAkBG;IACH,sBA4CC;IAED;;;;;;;;;;;;;;;;OAgBG;IACH,sBAqBC;IAED,8CAGC;IAED,iDAGC;IAiHD,eAAe;IACf,8BAMC;IAED;;;;;;OAMG;IACH,oCAcC;IAqBD;;;;;;OAMG;IACH,wBAHW,YAAY,GACV,OAAO,CAQnB;IAED;;;;;;;;OAQG;IAEH,yBANW,MAAM,YACN,MAAM,SACN,MAAM,GACJ,OAAO,CAqBnB;IAED;;;;;;;OAOG;IACH,2BAmBC;IAED;;OAEG;IACH,sCAGC;IAlPD;;;OAGG;IACH,oCAwGC;IAmCD,eAAe;IACf,wCAgBC;IAvjBC,eAAe;IACf,yCAAgD;;CAyoBnD;0BA5zBM,oBAAoB;gCApBpB,0BAA0B;+BAS1B,yBAAyB;iCAdzB,2BAA2B;yBAN3B,mBAAmB"}

package/types/server/ServerClient.d.ts

@@ -43,3 +43,4 @@ declare class ServerClient {
     private [kServerClientToken];
     #private;
 }
+//# sourceMappingURL=ServerClient.d.ts.map

package/types/server/ServerClient.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ServerClient.d.ts","sourceRoot":"","sources":["../../src/server/ServerClient.js"],"names":[],"mappings":"AAKA,+CAA2E;;AAE3E;;;;;GAKG;AACH;IAME;;;OAGG;IACH,kCAFW,YAAY,EAatB;IAED;;;;OAIG;IACH,mBAEC;IAED;;;;OAIG;IACH,iBAEC;IAED;;;;OAIG;IACH,mBAEC;IAED;;;;OAIG;IACH,cAFU,YAAY,CAIrB;IAzCC;;;OAGG;IACH,6BAA+B;;CAsClC"}

package/types/server/ServerContext.d.ts

@@ -207,3 +207,4 @@ declare class ServerContext {
 }
 import Server from './Server.js';
 import ServerClient from './ServerClient.js';
+//# sourceMappingURL=ServerContext.d.ts.map

package/types/server/ServerContext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ServerContext.d.ts","sourceRoot":"","sources":["../../src/server/ServerContext.js"],"names":[],"mappings":"AAOA,iDAA+E;;AAE/E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+DG;AACH;IAKE;;;;;;;;OAQG;IACH,oBARW,MAAM,UACN,MAAM,GAAC,MAAM,EAAE,EAqBzB;IAED;;;;OAIG;IACH,cAFU,MAAM,CAIf;IAED;;;;OAIG;IACH,eAFU,GAAG,CAAC,YAAY,CAAC,CAI1B;IAED;;;;OAIG;IACH,aAFU,GAAG,CAAC,MAAM,CAAC,CAIpB;IAED;;;;OAIG;IACH,cAFU,MAAM,CAIf;IAED;;;;;;;;;;;;;;;;OAgBG;IACH,YAVU,MAAM,CAYf;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;OA0BG;IACH,uBAAgB;IAEhB;;;;;;OAMG;IACH,sBAAe;IAEf;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACH,cAhBW,YAAY,gBAsBtB;IAED;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,aAhBW,YAAY,gBAsBtB;IAjKC,eAAe;IACf,+BAAmC;;CAiKtC;mBAlQkB,aAAa;yBADP,mBAAmB"}

package/types/server/ServerContextManager.d.ts

@@ -73,3 +73,4 @@ declare class ServerContextManager<T> {
 }
 import ServerContext from './ServerContext.js';
 import Server from './Server.js';
+//# sourceMappingURL=ServerContextManager.d.ts.map

package/types/server/ServerContextManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ServerContextManager.d.ts","sourceRoot":"","sources":["../../src/server/ServerContextManager.js"],"names":[],"mappings":"AAaA,uDAA4F;AAC5F,sDAA0F;AAC1F,2DAAqG;AACrG,8DAA2G;AAC3G,0DAAkG;AAElG,0DAAkG;;AA8ClG;;;;;;;;GAQG;AACH,mCAFa,CAAC;IAOZ;;;OAGG;IACH,oBAHW,MAAM,EAWhB;IA6JD;;;;;;;OAOG;IACH,iBAHW,MAAM,GACL,OAAO,CAAC,CAAC,CAAC,aAAa,CAAC,CAAC,CA2BpC;IA5LD;;;;;;;OAOG;IACH,wCAOC;IAED;;;;;OAKG;IACH,qCAGC;IAED;;;;OAIG;IACH,oCAGC;IAED;;;;;;OAMG;IACH,yCAyFC;IAED;;;;;;OAMG;IACH,4CAUC;IA7JC,eAAe;IACf,wCAA6D;;CAgMhE;0BAvRM,oBAAoB;mBAHR,aAAa"}

package/types/server/ServerPlugin.d.ts

@@ -1,4 +1,5 @@
 export const kServerPluginName: unique symbol;
+export default ServerPlugin;
 /**
  * Base class to extend in order to create the server-side counterpart of a
  * `soundworks` plugin.
@@ -17,7 +18,7 @@ export const kServerPluginName: unique symbol;
  * @extends {BasePlugin}
  * @inheritdoc
  */
-export default class ServerPlugin extends BasePlugin {
+declare class ServerPlugin extends BasePlugin {
     static [kServerPluginName]: string;
     /**
      * @param {Server} server - The soundworks server instance.
@@ -55,3 +56,4 @@ export default class ServerPlugin extends BasePlugin {
     #private;
 }
 import BasePlugin from '../common/BasePlugin.js';
+//# sourceMappingURL=ServerPlugin.d.ts.map

package/types/server/ServerPlugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ServerPlugin.d.ts","sourceRoot":"","sources":["../../src/server/ServerPlugin.js"],"names":[],"mappings":"AAEA,8CAA6E;;AAE7E;;;;;;;;;;;;;;;;;GAiBG;AACH;IAGE,mCAA4C;IAK5C;;;OAGG;IACH,oBAHW,MAAM,MACN,MAAM,EAKhB;IAED;;;;OAIG;IACH,cAHU,MAAM,CAKf;IAED;;;;OAIG;IACH,eAHU,GAAG,CAAC,YAAY,CAAC,CAK1B;IAED;;;;;;OAMG;IACH,kBAFW,YAAY,iBAItB;IAED;;;;;;OAMG;IACH,qBAFW,YAAY,iBAItB;;CACF;uBA9EsB,yBAAyB"}

package/types/server/ServerPluginManager.d.ts

@@ -112,3 +112,4 @@ declare class ServerPluginManager<T> extends BasePluginManager {
     private [kServerPluginManagerRemoveClient];
 }
 import BasePluginManager from '../common/BasePluginManager.js';
+//# sourceMappingURL=ServerPluginManager.d.ts.map

package/types/server/ServerPluginManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ServerPluginManager.d.ts","sourceRoot":"","sources":["../../src/server/ServerPluginManager.js"],"names":[],"mappings":"AAMA,uEAA8H;AAC9H,0DAAmG;AACnG,6DAAyG;;AAEzG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuDG;AACH,kCAFa,CAAC;IAGZ,uBAAuB;IACvB,yBAMC;IA2CD;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,aAfW,MAAM,QAEN,CAAC,CAAC,YAAY,CAAC,YACf,MAAM,sBAmBhB;IAED;;;;;;;;;;;;;;;;;OAiBG;IACH,cAFa,OAAO,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC,CAQpC;IAjGD,eAAe;IACf,qDAYC;IAED,eAAe;IACf,wCAUC;IAED,eAAe;IACf,2CAUC;CA2DF;8BA3KM,gCAAgC"}

package/types/server/ServerSocket.d.ts

@@ -67,3 +67,4 @@ declare class ServerSocket {
     private [kSocketTerminate];
     #private;
 }
+//# sourceMappingURL=ServerSocket.d.ts.map

package/types/server/ServerSocket.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ServerSocket.d.ts","sourceRoot":"","sources":["../../src/server/ServerSocket.js"],"names":[],"mappings":"AAgBA,4CAAqE;AACrE,6CAAsE;;AAEtE;;;;;;;;;;;GAWG;AACH;IAME,mCAmFC;IA8CD;;OAEG;IACH,mBAEC;IAED;;;;;OAKG;IACH,kBAFU,MAAM,CAIf;IAED;;;;;;OAMG;IACH,cAJW,MAAM,WACH,GAAC,EAAA,QAkBd;IAED;;;;;;;OAOG;IACH,qBALW,MAAM,4BAYhB;IAED;;;;;OAKG;IACH,wBAHW,MAAM,4BAYhB;IAED;;;;OAIG;IACH,6BAFW,MAAM,QAQhB;IAtHD;;;;;;;OAOG;IACH,2BAsBC;;CAyFF"}

package/types/server/ServerSockets.d.ts

@@ -40,3 +40,4 @@ declare class ServerSockets {
     [kSocketsDebugPreventHeartBeat]: boolean;
     #private;
 }
+//# sourceMappingURL=ServerSockets.d.ts.map

package/types/server/ServerSockets.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ServerSockets.d.ts","sourceRoot":"","sources":["../../src/server/ServerSockets.js"],"names":[],"mappings":"AAoBA,0CAAgE;AAChE,yCAA8D;AAE9D,iDAA+E;AAC/E,uDAA4F;AAC5F,0DAAkG;;AAElG;;;;;GAKG;AACH;IAME,sCAMC;IAoFD,eAAe;IACf,gBAEC;IAED,eAAe;IACf,aAEC;IAED,eAAe;IACf,eAEC;IAED,yBAEC;IAnGD;;;;;OAKG;IACH,wBAuDC;IAED;;;OAGG;IACH,uBAKC;IAED;;;OAGG;IACH,+BAEC;IApFC,kCAAuC;IACvC,yCAA2C;;CAuG9C"}

package/types/server/ServerStateManager.d.ts

@@ -289,3 +289,4 @@ declare class ServerStateManager extends BaseStateManager {
 }
 import BaseStateManager from '../common/BaseStateManager.js';
 import { kStateManagerInit } from '../common/BaseStateManager.js';
+//# sourceMappingURL=ServerStateManager.d.ts.map

package/types/server/ServerStateManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ServerStateManager.d.ts","sourceRoot":"","sources":["../../src/server/ServerStateManager.js"],"names":[],"mappings":"AAwCA,yDAAiG;AACjG,4DAAuG;AACvG,yDAAiG;AACjG,kEAAoH;AACpH,8DAA4G;AAE5G,yDAAiG;;;;;AAGjG;;;;;;GAMG;AAEH;;;;;;;;GAQG;AAEH;;;;;;GAMG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwDG;AACH;IA0TE;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,uBApBW,oBAAoB,oBACpB,2BAA2B,QA2CrC;IAED;;OAEG;IACH,4DAGC;IAED;;;;;;;OAOG;IACH,uBAFW,oBAAoB,QA8B9B;IAED;;OAEG;IACH,mCAGC;IAED;;;;;OAKG;IACH,0BAHW,oBAAoB,GAClB,OAAO,CAInB;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAsCG;IACH,8BAzBW,MAAM,cACN,4BAA4B,YAqCtC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAgCG;IACH,8BAnBW,MAAM,6BAgChB;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAuCG;IACH,8BAxBW,MAAM,cACN,4BAA4B,YAoCtC;IAxjBD,eAAe;IACf,4BAIC;IAED,eAAe;IACf,gDAiBC;IAED,eAAe;IACf,4CAEC;IAED,eAAe;IACf,uCAEC;IAED;;;;;;;;;;OAUG;IACH,uCAqMC;IAED;;;;;;;;;OASG;IACH,0CAoCC;IAzSC,eAAe;IACf,uCAA8C;;CA4jBjD;6BAtsBM,+BAA+B;kCAA/B,+BAA+B"}

package/types/server/SharedStatePrivate.d.ts

@@ -21,3 +21,4 @@ declare class SharedStatePrivate {
     [kSharedStatePrivateDetachClient](instanceId: any, client: any): void;
     #private;
 }
+//# sourceMappingURL=SharedStatePrivate.d.ts.map

package/types/server/SharedStatePrivate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SharedStatePrivate.d.ts","sourceRoot":"","sources":["../../src/server/SharedStatePrivate.js"],"names":[],"mappings":"AA4DA,4DAAuG;AACvG,4DAAuG;AACvG,yDAAiG;;AAEjG;;;;;GAKG;AACH;IASE,0FAMC;IAED,cAEC;IAED,qBAEC;IAED,qBAEC;IAED,6BAEC;IAED,qCAEC;IAED,sBAEC;IAED,sCAEC;IAED,iGAyLC;IAED,sEAMC;;CACF"}

package/types/server/audit-network-latency.worker.d.ts

@@ -1,2 +1,3 @@
 declare const _default: "\nconst { parentPort } = require('node:worker_threads');\nconst { hrtime } =  require('node:process');\n\nlet stack = [];\nlet averageLatencyWindow = 5;\nlet averageLatencyPeriod = 2;\n\nlet intervalId = null;\nlet meanLatency = 0;\n\n// workaround that sc-utils is pure ecmascript module\n// 2024/09/06 - Just copy getTime implementation so that we don't even need the node_modules\nconst start = hrtime.bigint();\n\nfunction getTime() {\n  const now = hrtime.bigint();\n  const delta = now - start;\n  return Number(delta) * 1e-9;\n}\n\nparentPort.on('message', async msg => {\n  switch (msg.type) {\n    case 'config': {\n      averageLatencyWindow = msg.value.averageLatencyWindow;\n      averageLatencyPeriod = msg.value.averageLatencyPeriod;\n\n      // launch compute in its own loop so that the number of computation is\n      // decoupled from the number of connected clients\n      clearInterval(intervalId);\n      intervalId = setInterval(computeAverageLatency, averageLatencyPeriod * 1000);\n      break;\n    }\n    case 'add-measurement': {\n      // compute latency considering ping and pong time are equal\n      const entry = msg.value;\n      entry.latency = (entry.pong - entry.ping) / 2;\n      // add new measure to the stack\n      stack.push(entry);\n    }\n  }\n});\n\nfunction computeAverageLatency() {\n  const now = getTime();\n  // remove old measurements from stack\n  stack = stack.filter(entry => entry.pong >= now - averageLatencyWindow);\n\n  // prevent dividing by zero, just return last computed value\n  if (stack.length === 0) {\n    parentPort.postMessage({\n      type: 'computed-average-latency',\n      value: meanLatency,\n    });\n  } else {\n    // compute mean\n    let sum = 0;\n    stack.forEach(entry => sum += entry.latency);\n\n    meanLatency = sum / stack.length;\n    // send result to main thread\n    parentPort.postMessage({\n      type: 'computed-average-latency',\n      value: meanLatency,\n    });\n  }\n}\n";
 export default _default;
+//# sourceMappingURL=audit-network-latency.worker.d.ts.map

package/types/server/audit-network-latency.worker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"audit-network-latency.worker.d.ts","sourceRoot":"","sources":["../../src/server/audit-network-latency.worker.js"],"names":[],"mappings":""}

package/types/server/audit-state-class-description.d.ts

@@ -24,3 +24,4 @@ declare namespace _default {
     }
 }
 export default _default;
+//# sourceMappingURL=audit-state-class-description.d.ts.map

package/types/server/audit-state-class-description.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"audit-state-class-description.d.ts","sourceRoot":"","sources":["../../src/server/audit-state-class-description.js"],"names":[],"mappings":""}

package/types/server/create-http-server.d.ts

@@ -3,3 +3,4 @@
  * @return {HttpServer|HttpsServer}
  */
 export function createHttpServer(server: any): HttpServer | HttpsServer;
+//# sourceMappingURL=create-http-server.d.ts.map

package/types/server/create-http-server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-http-server.d.ts","sourceRoot":"","sources":["../../src/server/create-http-server.js"],"names":[],"mappings":"AAaA;;;GAGG;AACH,+CAFY,UAAU,GAAC,WAAW,CA+GjC"}

package/types/server/crypto.d.ts

@@ -2,3 +2,4 @@
 export function encryptData(obj: any): string;
 /** @private */
 export function decryptData(encryptedData: any): any;
+//# sourceMappingURL=crypto.d.ts.map

package/types/server/crypto.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"crypto.d.ts","sourceRoot":"","sources":["../../src/server/crypto.js"],"names":[],"mappings":"AAuBA,eAAe;AACf,8CAKC;AAED,eAAe;AACf,qDAMC"}

package/types/server/index.d.ts

@@ -53,3 +53,4 @@ export type ServerConfig = {
      */
     env: ServerEnvConfig;
 };
+//# sourceMappingURL=index.d.ts.map

package/types/server/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/server/index.js"],"names":[],"mappings":";;;;;;;;;yBAcU,MAAM;;;;;aAKF,SAAS,GAAC,MAAM;;;;;cAChB,OAAO;;;;;;;;;QAQP,MAAM;;;;WACN,MAAM;;;;aACN,MAAM;;;;;8BAMV,MAAM;;;;;;;;SAwBF,SAAS;;;;SACT,eAAe"}