RAHHH

backend/lib/python3.12/site-packages/autobahn/wamp/__init__.py

@@ -0,0 +1,81 @@
+###############################################################################
+#
+# The MIT License (MIT)
+#
+# Copyright (c) typedef int GmbH
+#
+# 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.
+#
+###############################################################################
+
+from autobahn.wamp.types import \
+    ComponentConfig, \
+    SessionDetails, \
+    CloseDetails, \
+    RegisterOptions, \
+    CallOptions, \
+    CallDetails, \
+    CallResult, \
+    SubscribeOptions, \
+    PublishOptions, \
+    EventDetails
+
+from autobahn.wamp.exception import \
+    Error, \
+    SessionNotReady, \
+    SerializationError, \
+    ProtocolError, \
+    TransportLost, \
+    ApplicationError, \
+    InvalidUri
+
+from autobahn.wamp.interfaces import ISession
+
+from autobahn.wamp.uri import \
+    error, \
+    register, \
+    subscribe
+
+
+__all__ = (
+    'ComponentConfig',
+    'SessionDetails',
+    'CloseDetails',
+    'RegisterOptions',
+    'CallOptions',
+    'CallDetails',
+    'CallResult',
+    'SubscribeOptions',
+    'PublishOptions',
+    'EventDetails',
+
+    'Error',
+    'SessionNotReady',
+    'SerializationError',
+    'ProtocolError',
+    'TransportLost',
+    'ApplicationError',
+    'InvalidUri',
+
+    'ISession',
+
+    'error',
+    'register',
+    'subscribe',
+)

backend/lib/python3.12/site-packages/autobahn/wamp/auth.py

@@ -0,0 +1,694 @@
+###############################################################################
+#
+# The MIT License (MIT)
+#
+# Copyright (c) typedef int GmbH
+#
+# 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.
+#
+###############################################################################
+
+import os
+import base64
+import struct
+import time
+import binascii
+import hmac
+import hashlib
+import random
+from typing import Optional, Dict
+
+from autobahn.util import public
+from autobahn.util import xor as xor_array
+from autobahn.wamp.interfaces import IAuthenticator
+
+from cryptography.hazmat.primitives.kdf.pbkdf2 import PBKDF2HMAC
+from cryptography.hazmat.primitives import hashes
+from cryptography.hazmat.backends import default_backend
+
+# if we don't have argon2/passlib (see "authentication" extra) then
+# you don't get AuthScram and variants
+try:
+    from argon2.low_level import hash_secret
+    from argon2 import Type
+    from passlib.utils import saslprep
+    HAS_ARGON = True
+except ImportError:
+    HAS_ARGON = False
+
+
+__all__ = (
+    'AuthAnonymous',
+    'AuthScram',
+    'AuthCryptoSign',
+    'AuthWampCra',
+    'AuthTicket',
+    'create_authenticator',
+    'pbkdf2',
+    'generate_totp_secret',
+    'compute_totp',
+    'check_totp',
+    'qrcode_from_totp',
+    'derive_key',
+    'generate_wcs',
+    'compute_wcs',
+    'derive_scram_credential',
+)
+
+
+def create_authenticator(name, **kwargs):
+    """
+    Accepts various keys and values to configure an authenticator. The
+    valid keys depend on the kind of authenticator but all can
+    understand: `authextra`, `authid` and `authrole`
+
+    :return: an instance implementing IAuthenticator with the given
+        configuration.
+    """
+    try:
+        klass = {
+            AuthScram.name: AuthScram,
+            AuthCryptoSign.name: AuthCryptoSign,
+            AuthCryptoSignProxy.name: AuthCryptoSignProxy,
+            AuthWampCra.name: AuthWampCra,
+            AuthAnonymous.name: AuthAnonymous,
+            AuthAnonymousProxy.name: AuthAnonymousProxy,
+            AuthTicket.name: AuthTicket,
+        }[name]
+    except KeyError:
+        raise ValueError(
+            "Unknown authenticator '{}'".format(name)
+        )
+    # this may raise further ValueErrors if the kwargs are wrong
+    authenticator = klass(**kwargs)
+    return authenticator
+
+
+# experimental authentication API
+class AuthAnonymous(object):
+    name = 'anonymous'
+
+    def __init__(self, **kw):
+        self._args = kw
+
+    @property
+    def authextra(self):
+        return self._args.get('authextra', dict())
+
+    def on_challenge(self, session, challenge):
+        raise RuntimeError(
+            "on_challenge called on anonymous authentication"
+        )
+
+    def on_welcome(self, msg, authextra):
+        return None
+
+
+IAuthenticator.register(AuthAnonymous)
+
+
+class AuthAnonymousProxy(AuthAnonymous):
+    name = 'anonymous-proxy'
+
+
+IAuthenticator.register(AuthAnonymousProxy)
+
+
+class AuthTicket(object):
+    name = 'ticket'
+
+    def __init__(self, **kw):
+        self._args = kw
+        try:
+            self._ticket = self._args.pop('ticket')
+        except KeyError:
+            raise ValueError(
+                "ticket authentication requires 'ticket=' kwarg"
+            )
+
+    @property
+    def authextra(self):
+        return self._args.get('authextra', dict())
+
+    def on_challenge(self, session, challenge):
+        assert challenge.method == "ticket"
+        return self._ticket
+
+    def on_welcome(self, msg, authextra):
+        return None
+
+
+IAuthenticator.register(AuthTicket)
+
+
+class AuthCryptoSign(object):
+    name = 'cryptosign'
+
+    def __init__(self, **kw):
+        # should put in checkconfig or similar
+        for key in kw.keys():
+            if key not in ['authextra', 'authid', 'authrole', 'privkey']:
+                raise ValueError(
+                    "Unexpected key '{}' for {}".format(key, self.__class__.__name__)
+                )
+        for key in ['privkey']:
+            if key not in kw:
+                raise ValueError(
+                    "Must provide '{}' for cryptosign".format(key)
+                )
+
+        from autobahn.wamp.cryptosign import CryptosignKey
+        self._privkey = CryptosignKey.from_bytes(
+            binascii.a2b_hex(kw['privkey'])
+        )
+
+        if 'pubkey' in kw.get('authextra', dict()):
+            pubkey = kw['authextra']['pubkey']
+            if pubkey != self._privkey.public_key():
+                raise ValueError(
+                    "Public key doesn't correspond to private key"
+                )
+        else:
+            kw['authextra'] = kw.get('authextra', dict())
+            kw['authextra']['pubkey'] = self._privkey.public_key()
+
+        self._channel_binding = kw.get('authextra', dict()).get('channel_binding', None)
+        self._args = kw
+
+    @property
+    def authextra(self):
+        return self._args.get('authextra', dict())
+
+    def on_challenge(self, session, challenge):
+        channel_id = session._transport.transport_details.channel_id.get(self._channel_binding, None)
+        return self._privkey.sign_challenge(challenge,
+                                            channel_id=channel_id,
+                                            channel_id_type=self._channel_binding)
+
+    def on_welcome(self, msg, authextra):
+        return None
+
+
+IAuthenticator.register(AuthCryptoSign)
+
+
+class AuthCryptoSignProxy(AuthCryptoSign):
+    name = 'cryptosign-proxy'
+
+
+IAuthenticator.register(AuthCryptoSignProxy)
+
+
+def _hash_argon2id13_secret(password, salt, iterations, memory):
+    """
+    Internal helper. Returns the salted/hashed password using the
+    argon2id-13 algorithm. The return value is base64-encoded.
+    """
+    rawhash = hash_secret(
+        secret=password,
+        salt=base64.b64decode(salt),
+        time_cost=iterations,
+        memory_cost=memory,
+        parallelism=1,  # hard-coded by WAMP-SCRAM spec
+        hash_len=32,
+        type=Type.ID,
+        version=0x13,  # note this is decimal "19" which appears in places
+    )
+    # spits out stuff like:
+    # '$argon2i$v=19$m=512,t=2,p=2$5VtWOO3cGWYQHEMaYGbsfQ$AcmqasQgW/wI6wAHAMk4aQ'
+
+    _, tag, ver, options, salt_data, hash_data = rawhash.split(b'$')
+    return hash_data
+
+
+def _hash_pbkdf2_secret(password, salt, iterations):
+    """
+    Internal helper for SCRAM authentication
+    """
+    return pbkdf2(password, salt, iterations, keylen=32)
+
+
+class AuthScram(object):
+    """
+    Implements "wamp-scram" authentication for components.
+
+    NOTE: This is a prototype of a draft spec; see
+    https://github.com/wamp-proto/wamp-proto/issues/135
+    """
+    name = 'scram'
+
+    def __init__(self, **kw):
+        if not HAS_ARGON:
+            raise RuntimeError(
+                "Cannot support WAMP-SCRAM without argon2_cffi and "
+                "passlib libraries; install autobahn['scram']"
+            )
+        self._args = kw
+        self._client_nonce = None
+
+    @property
+    def authextra(self):
+        # is authextra() called exactly once per authentication?
+        if self._client_nonce is None:
+            self._client_nonce = base64.b64encode(os.urandom(16)).decode('ascii')
+        return {
+            "nonce": self._client_nonce,
+        }
+
+    def on_challenge(self, session, challenge):
+        assert challenge.method == "scram"
+        assert self._client_nonce is not None
+        required_args = ['nonce', 'kdf', 'salt', 'iterations']
+        optional_args = ['memory', 'channel_binding']
+        for k in required_args:
+            if k not in challenge.extra:
+                raise RuntimeError(
+                    "WAMP-SCRAM challenge option '{}' is "
+                    " required but not specified".format(k)
+                )
+        for k in challenge.extra:
+            if k not in optional_args + required_args:
+                raise RuntimeError(
+                    "WAMP-SCRAM challenge has unknown attribute '{}'".format(k)
+                )
+
+        channel_binding = challenge.extra.get('channel_binding', '')
+        server_nonce = challenge.extra['nonce']  # base64
+        salt = challenge.extra['salt']  # base64
+        iterations = int(challenge.extra['iterations'])
+        memory = int(challenge.extra.get('memory', -1))
+        password = self._args['password'].encode('utf8')  # supplied by user
+        authid = saslprep(self._args['authid'])
+        algorithm = challenge.extra['kdf']
+        client_nonce = self._client_nonce
+
+        self._auth_message = (
+            "{client_first_bare},{server_first},{client_final_no_proof}".format(
+                client_first_bare="n={},r={}".format(authid, client_nonce),
+                server_first="r={},s={},i={}".format(server_nonce, salt, iterations),
+                client_final_no_proof="c={},r={}".format(channel_binding, server_nonce),
+            )
+        ).encode('ascii')
+
+        if algorithm == 'argon2id-13':
+            if memory == -1:
+                raise ValueError(
+                    "WAMP-SCRAM 'argon2id-13' challenge requires 'memory' parameter"
+                )
+            self._salted_password = _hash_argon2id13_secret(password, salt, iterations, memory)
+        elif algorithm == 'pbkdf2':
+            self._salted_password = _hash_pbkdf2_secret(password, salt, iterations)
+        else:
+            raise RuntimeError(
+                "WAMP-SCRAM specified unknown KDF '{}'".format(algorithm)
+            )
+
+        client_key = hmac.new(self._salted_password, b"Client Key", hashlib.sha256).digest()
+        stored_key = hashlib.new('sha256', client_key).digest()
+
+        client_signature = hmac.new(stored_key, self._auth_message, hashlib.sha256).digest()
+        client_proof = xor_array(client_key, client_signature)
+
+        return base64.b64encode(client_proof)
+
+    def on_welcome(self, session, authextra):
+        """
+        When the server is satisfied, it sends a 'WELCOME' message.
+
+        This hook allows us an opportunity to deny the session right
+        before it gets set up -- we check the server-signature thus
+        authorizing the server and if it fails we drop the connection.
+        """
+        alleged_server_sig = base64.b64decode(authextra['scram_server_signature'])
+        server_key = hmac.new(self._salted_password, b"Server Key", hashlib.sha256).digest()
+        server_signature = hmac.new(server_key, self._auth_message, hashlib.sha256).digest()
+        if not hmac.compare_digest(server_signature, alleged_server_sig):
+            session.log.error("Verification of server SCRAM signature failed")
+            return "Verification of server SCRAM signature failed"
+        session.log.info(
+            "Verification of server SCRAM signature successful"
+        )
+        return None
+
+
+IAuthenticator.register(AuthScram)
+
+
+class AuthWampCra(object):
+    name = 'wampcra'
+
+    def __init__(self, **kw):
+        # should put in checkconfig or similar
+        for key in kw.keys():
+            if key not in ['authextra', 'authid', 'authrole', 'secret']:
+                raise ValueError(
+                    "Unexpected key '{}' for {}".format(key, self.__class__.__name__)
+                )
+        for key in ['secret', 'authid']:
+            if key not in kw:
+                raise ValueError(
+                    "Must provide '{}' for wampcra".format(key)
+                )
+
+        self._args = kw
+        self._secret = kw.pop('secret')
+        if not isinstance(self._secret, str):
+            self._secret = self._secret.decode('utf8')
+
+    @property
+    def authextra(self):
+        return self._args.get('authextra', dict())
+
+    def on_challenge(self, session, challenge):
+        key = self._secret.encode('utf8')
+        if 'salt' in challenge.extra:
+            key = derive_key(
+                key,
+                challenge.extra['salt'],
+                challenge.extra['iterations'],
+                challenge.extra['keylen']
+            )
+
+        signature = compute_wcs(
+            key,
+            challenge.extra['challenge'].encode('utf8')
+        )
+        return signature.decode('ascii')
+
+    def on_welcome(self, msg, authextra):
+        return None
+
+
+IAuthenticator.register(AuthWampCra)
+
+
+@public
+def generate_totp_secret(length=10):
+    """
+    Generates a new Base32 encoded, random secret.
+
+    .. seealso:: http://en.wikipedia.org/wiki/Base32
+
+    :param length: The length of the entropy used to generate the secret.
+    :type length: int
+
+    :returns: The generated secret in Base32 (letters ``A-Z`` and digits ``2-7``).
+       The length of the generated secret is ``length * 8 / 5`` octets.
+    :rtype: unicode
+    """
+    assert(type(length) == int)
+    return base64.b32encode(os.urandom(length)).decode('ascii')
+
+
+@public
+def compute_totp(secret, offset=0):
+    """
+    Computes the current TOTP code.
+
+    :param secret: Base32 encoded secret.
+    :type secret: unicode
+    :param offset: Time offset (in steps, use eg -1, 0, +1 for compliance with RFC6238)
+        for which to compute TOTP.
+    :type offset: int
+
+    :returns: TOTP for current time (+/- offset).
+    :rtype: unicode
+    """
+    assert(type(secret) == str)
+    assert(type(offset) == int)
+    try:
+        key = base64.b32decode(secret)
+    except TypeError:
+        raise Exception('invalid secret')
+    interval = offset + int(time.time()) // 30
+    msg = struct.pack('>Q', interval)
+    digest = hmac.new(key, msg, hashlib.sha1).digest()
+    o = 15 & (digest[19])
+    token = (struct.unpack('>I', digest[o:o + 4])[0] & 0x7fffffff) % 1000000
+    return '{0:06d}'.format(token)
+
+
+@public
+def check_totp(secret, ticket):
+    """
+    Check a TOTP value received from a principal trying to authenticate against
+    the expected value computed from the secret shared between the principal and
+    the authenticating entity.
+
+    The Internet can be slow, and clocks might not match exactly, so some
+    leniency is allowed. RFC6238 recommends looking an extra time step in either
+    direction, which essentially opens the window from 30 seconds to 90 seconds.
+
+    :param secret: The secret shared between the principal (eg a client) that
+        is authenticating, and the authenticating entity (eg a server).
+    :type secret: unicode
+    :param ticket: The TOTP value to be checked.
+    :type ticket: unicode
+
+    :returns: ``True`` if the TOTP value is correct, else ``False``.
+    :rtype: bool
+    """
+    for offset in [0, 1, -1]:
+        if ticket == compute_totp(secret, offset):
+            return True
+    return False
+
+
+@public
+def qrcode_from_totp(secret, label, issuer):
+    if type(secret) != str:
+        raise Exception('secret must be of type unicode, not {}'.format(type(secret)))
+
+    if type(label) != str:
+        raise Exception('label must be of type unicode, not {}'.format(type(label)))
+
+    try:
+        import qrcode
+        import qrcode.image.svg
+    except ImportError:
+        raise Exception('qrcode not installed')
+
+    return qrcode.make(
+        'otpauth://totp/{}?secret={}&issuer={}'.format(label, secret, issuer),
+        box_size=3,
+        image_factory=qrcode.image.svg.SvgImage).to_string()
+
+
+@public
+def pbkdf2(data, salt, iterations=1000, keylen=32, hashfunc=None):
+    """
+    Returns a binary digest for the PBKDF2 hash algorithm of ``data``
+    with the given ``salt``. It iterates ``iterations`` time and produces a
+    key of ``keylen`` bytes. By default SHA-256 is used as hash function,
+    a different hashlib ``hashfunc`` can be provided.
+
+    :param data: The data for which to compute the PBKDF2 derived key.
+    :type data: bytes
+    :param salt: The salt to use for deriving the key.
+    :type salt: bytes
+    :param iterations: The number of iterations to perform in PBKDF2.
+    :type iterations: int
+    :param keylen: The length of the cryptographic key to derive.
+    :type keylen: int
+    :param hashfunc: Name of the hash algorithm to use
+    :type hashfunc: str
+
+    :returns: The derived cryptographic key.
+    :rtype: bytes
+    """
+    if not (type(data) == bytes) or \
+       not (type(salt) == bytes) or \
+       not (type(iterations) == int) or \
+       not (type(keylen) == int):
+        raise ValueError("Invalid argument types")
+
+    # justification: WAMP-CRA uses SHA256 and users shouldn't have any
+    # other reason to call this particular pbkdf2 function (arguably,
+    # it should be private maybe?)
+    if hashfunc is None:
+        hashfunc = 'sha256'
+    if hashfunc is callable:
+        # used to take stuff from hashlib; translate?
+        raise ValueError(
+            "pbkdf2 now takes the name of a hash algorithm for 'hashfunc='"
+        )
+
+    backend = default_backend()
+
+    # https://cryptography.io/en/latest/hazmat/primitives/key-derivation-functions/#pbkdf2
+    kdf = PBKDF2HMAC(
+        algorithm=getattr(hashes, hashfunc.upper())(),
+        length=keylen,
+        salt=salt,
+        iterations=iterations,
+        backend=backend,
+    )
+    return kdf.derive(data)
+
+
+@public
+def derive_key(secret, salt, iterations=1000, keylen=32):
+    """
+    Computes a derived cryptographic key from a password according to PBKDF2.
+
+    .. seealso:: http://en.wikipedia.org/wiki/PBKDF2
+
+    :param secret: The secret.
+    :type secret: bytes or unicode
+    :param salt: The salt to be used.
+    :type salt: bytes or unicode
+    :param iterations: Number of iterations of derivation algorithm to run.
+    :type iterations: int
+    :param keylen: Length of the key to derive in bytes.
+    :type keylen: int
+
+    :return: The derived key in Base64 encoding.
+    :rtype: bytes
+    """
+    if not (type(secret) in [str, bytes]):
+        raise ValueError("'secret' must be bytes")
+    if not (type(salt) in [str, bytes]):
+        raise ValueError("'salt' must be bytes")
+    if not (type(iterations) == int):
+        raise ValueError("'iterations' must be an integer")
+    if not (type(keylen) == int):
+        raise ValueError("'keylen' must be an integer")
+    if type(secret) == str:
+        secret = secret.encode('utf8')
+    if type(salt) == str:
+        salt = salt.encode('utf8')
+    key = pbkdf2(secret, salt, iterations, keylen)
+    return binascii.b2a_base64(key).strip()
+
+
+WCS_SECRET_CHARSET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"
+"""
+The characters from which :func:`autobahn.wamp.auth.generate_wcs` generates secrets.
+"""
+
+
+@public
+def generate_wcs(length=14):
+    """
+    Generates a new random secret for use with WAMP-CRA.
+
+    The secret generated is a random character sequence drawn from
+
+    - upper and lower case latin letters
+    - digits
+    -
+
+    :param length: The length of the secret to generate.
+    :type length: int
+
+    :return: The generated secret. The length of the generated is ``length`` octets.
+    :rtype: bytes
+    """
+    assert(type(length) == int)
+    return "".join(random.choice(WCS_SECRET_CHARSET) for _ in range(length)).encode('ascii')
+
+
+@public
+def compute_wcs(key, challenge):
+    """
+    Compute an WAMP-CRA authentication signature from an authentication
+    challenge and a (derived) key.
+
+    :param key: The key derived (via PBKDF2) from the secret.
+    :type key: bytes
+    :param challenge: The authentication challenge to sign.
+    :type challenge: bytes
+
+    :return: The authentication signature.
+    :rtype: bytes
+    """
+    assert(type(key) in [str, bytes])
+    assert(type(challenge) in [str, bytes])
+    if type(key) == str:
+        key = key.encode('utf8')
+    if type(challenge) == str:
+        challenge = challenge.encode('utf8')
+    sig = hmac.new(key, challenge, hashlib.sha256).digest()
+    return binascii.b2a_base64(sig).strip()
+
+
+def derive_scram_credential(email: str, password: str, salt: Optional[bytes] = None) -> Dict:
+    """
+    Derive WAMP-SCRAM credentials from user email and password. The SCRAM parameters used
+    are the following (these are also contained in the returned credentials):
+
+    * kdf ``argon2id-13``
+    * time cost ``4096``
+    * memory cost ``512``
+    * parallelism ``1``
+
+    See `draft-irtf-cfrg-argon2 <https://datatracker.ietf.org/doc/draft-irtf-cfrg-argon2/>`__ and
+    `argon2-cffi <https://argon2-cffi.readthedocs.io/en/stable/>`__.
+
+    :param email: User email.
+    :param password: User password.
+    :param salt: Optional salt to use (must be 16 bytes long). If none is given, compute salt
+        from email as ``salt = SHA256(email)[:16]``.
+    :return: WAMP-SCRAM credentials. When serialized, the returned credentials can be copy-pasted
+        into the ``config.json`` node configuration for a Crossbar.io node.
+    """
+    assert HAS_ARGON, 'missing dependency argon2'
+    from argon2.low_level import hash_secret
+    from argon2.low_level import Type
+
+    # derive salt from email
+    if not salt:
+        m = hashlib.sha256()
+        m.update(email.encode('utf8'))
+        salt = m.digest()[:16]
+    assert len(salt) == 16
+
+    hash_data = hash_secret(
+        secret=password.encode('utf8'),
+        salt=salt,
+        time_cost=4096,
+        memory_cost=512,
+        parallelism=1,
+        hash_len=32,
+        type=Type.ID,
+        version=19,
+    )
+    _, tag, v, params, _, salted_password = hash_data.decode('ascii').split('$')
+    assert tag == 'argon2id'
+    assert v == 'v=19'  # argon's version 1.3 is represented as 0x13, which is 19 decimal...
+    params = {
+        k: v
+        for k, v in
+        [x.split('=') for x in params.split(',')]
+    }
+
+    salted_password = salted_password.encode('ascii')
+    client_key = hmac.new(salted_password, b"Client Key", hashlib.sha256).digest()
+    stored_key = hashlib.new('sha256', client_key).digest()
+    server_key = hmac.new(salted_password, b"Server Key", hashlib.sha256).digest()
+
+    credential = {
+        "kdf": "argon2id-13",
+        "memory": int(params['m']),
+        "iterations": int(params['t']),
+        "salt": binascii.b2a_hex(salt).decode('ascii'),
+        "stored-key": binascii.b2a_hex(stored_key).decode('ascii'),
+        "server-key": binascii.b2a_hex(server_key).decode('ascii'),
+    }
+    return credential

backend/lib/python3.12/site-packages/autobahn/wamp/component.py

@@ -0,0 +1,983 @@
+###############################################################################
+#
+# The MIT License (MIT)
+#
+# Copyright (c) typedef int GmbH
+#
+# 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.
+#
+###############################################################################
+
+
+import itertools
+import random
+from functools import partial
+
+import txaio
+
+from autobahn.util import ObservableMixin
+from autobahn.websocket.util import parse_url as parse_ws_url
+from autobahn.rawsocket.util import parse_url as parse_rs_url
+
+from autobahn.wamp.types import ComponentConfig, SubscribeOptions, RegisterOptions
+from autobahn.wamp.exception import SessionNotReady, ApplicationError
+from autobahn.wamp.auth import create_authenticator, IAuthenticator
+from autobahn.wamp.serializer import SERID_TO_SER
+
+
+__all__ = (
+    'Component'
+)
+
+
+def _validate_endpoint(endpoint, check_native_endpoint=None):
+    """
+    Check a WAMP connecting endpoint configuration.
+    """
+    if check_native_endpoint:
+        check_native_endpoint(endpoint)
+    elif not isinstance(endpoint, dict):
+        raise ValueError(
+            "'endpoint' must be a dict"
+        )
+
+    # note, we're falling through here -- check_native_endpoint can
+    # disallow or allow dict-based config as it likes, but if it
+    # *does* allow a dict through, we want to check "base options"
+    # here so that both Twisted and asyncio don't have to check these
+    # things as well.
+    if isinstance(endpoint, dict):
+        # XXX what about filling in anything missing from the URL? Or
+        # is that only for when *nothing* is provided for endpoint?
+        if 'type' not in endpoint:
+            # could maybe just make tcp the default?
+            raise ValueError("'type' required in endpoint configuration")
+        if endpoint['type'] not in ['tcp', 'unix']:
+            raise ValueError('invalid type "{}" in endpoint'.format(endpoint['type']))
+
+        for k in endpoint.keys():
+            if k not in ['type', 'host', 'port', 'path', 'tls', 'timeout', 'version']:
+                raise ValueError(
+                    "Invalid key '{}' in endpoint configuration".format(k)
+                )
+
+        if endpoint['type'] == 'tcp':
+            for k in ['host', 'port']:
+                if k not in endpoint:
+                    raise ValueError(
+                        "'{}' required in 'tcp' endpoint config".format(k)
+                    )
+            for k in ['path']:
+                if k in endpoint:
+                    raise ValueError(
+                        "'{}' not valid in 'tcp' endpoint config".format(k)
+                    )
+        elif endpoint['type'] == 'unix':
+            for k in ['path']:
+                if k not in endpoint:
+                    raise ValueError(
+                        "'{}' required for 'unix' endpoint config".format(k)
+                    )
+            for k in ['host', 'port', 'tls']:
+                if k in endpoint:
+                    raise ValueError(
+                        "'{}' not valid in 'unix' endpoint config".format(k)
+                    )
+        else:
+            assert False, 'should not arrive here'
+
+
+def _create_transport(index, transport, check_native_endpoint=None):
+    """
+    Internal helper to insert defaults and create _Transport instances.
+
+    :param transport: a (possibly valid) transport configuration
+    :type transport: dict
+
+    :returns: a _Transport instance
+
+    :raises: ValueError on invalid configuration
+    """
+    if type(transport) != dict:
+        raise ValueError('invalid type {} for transport configuration - must be a dict'.format(type(transport)))
+
+    valid_transport_keys = [
+        'type', 'url', 'endpoint', 'serializer', 'serializers', 'options',
+        'max_retries', 'max_retry_delay', 'initial_retry_delay',
+        'retry_delay_growth', 'retry_delay_jitter', 'proxy', 'headers'
+    ]
+    for k in transport.keys():
+        if k not in valid_transport_keys:
+            raise ValueError(
+                "'{}' is not a valid configuration item".format(k)
+            )
+
+    kind = 'websocket'
+    if 'type' in transport:
+        if transport['type'] not in ['websocket', 'rawsocket']:
+            raise ValueError('Invalid transport type {}'.format(transport['type']))
+        kind = transport['type']
+    else:
+        transport['type'] = 'websocket'
+
+    if 'proxy' in transport and kind != 'websocket':
+        raise ValueError(
+            "proxy= only supported for type=websocket transports"
+        )
+    proxy = transport.get("proxy", None)
+    if proxy is not None:
+        for k in proxy.keys():
+            if k not in ['host', 'port']:
+                raise ValueError(
+                    "Unknown key '{}' in proxy config".format(k)
+                )
+        for k in ['host', 'port']:
+            if k not in proxy:
+                raise ValueError(
+                    "Proxy config requires '{}'".formaT(k)
+                )
+
+    options = dict()
+    if 'options' in transport:
+        options = transport['options']
+        if not isinstance(options, dict):
+            raise ValueError(
+                'options must be a dict, not {}'.format(type(options))
+            )
+
+    headers = transport.get("headers")
+
+    if kind == 'websocket':
+        for key in ['url']:
+            if key not in transport:
+                raise ValueError("Transport requires '{}' key".format(key))
+        # endpoint not required; we will deduce from URL if it's not provided
+        # XXX not in the branch I rebased; can this go away? (is it redundant??)
+        if 'endpoint' not in transport:
+            is_secure, host, port, resource, path, params = parse_ws_url(transport['url'])
+            endpoint_config = {
+                'type': 'tcp',
+                'host': host,
+                'port': port,
+                'tls': is_secure,
+            }
+        else:
+            # note: we're avoiding mutating the incoming "configuration"
+            # dict, so this should avoid that too...
+            endpoint_config = transport['endpoint']
+            _validate_endpoint(endpoint_config, check_native_endpoint)
+
+        if 'serializer' in transport:
+            raise ValueError("'serializer' is only for rawsocket; use 'serializers'")
+        if 'serializers' in transport:
+            if not isinstance(transport['serializers'], (list, tuple)):
+                raise ValueError("'serializers' must be a list of strings")
+            if not all([
+                    isinstance(s, (str, str))
+                    for s in transport['serializers']]):
+                raise ValueError("'serializers' must be a list of strings")
+            valid_serializers = SERID_TO_SER.keys()
+            for serial in transport['serializers']:
+                if serial not in valid_serializers:
+                    raise ValueError(
+                        "Invalid serializer '{}' (expected one of: {})".format(
+                            serial,
+                            ', '.join([repr(s) for s in valid_serializers]),
+                        )
+                    )
+        serializer_config = transport.get('serializers', ['cbor', 'json'])
+
+    elif kind == 'rawsocket':
+        if 'endpoint' not in transport:
+            if transport['url'].startswith('rs'):
+                # # try to parse RawSocket URL ..
+                isSecure, host, port = parse_rs_url(transport['url'])
+            elif transport['url'].startswith('ws'):
+                # try to parse WebSocket URL ..
+                isSecure, host, port, resource, path, params = parse_ws_url(transport['url'])
+            else:
+                raise RuntimeError()
+            if host == 'unix':
+                # here, "port" is actually holding the path on the host, eg "/tmp/file.sock"
+                endpoint_config = {
+                    'type': 'unix',
+                    'path': port,
+                }
+            else:
+                endpoint_config = {
+                    'type': 'tcp',
+                    'host': host,
+                    'port': port,
+                }
+        else:
+            endpoint_config = transport['endpoint']
+        if 'serializers' in transport:
+            raise ValueError("'serializers' is only for websocket; use 'serializer'")
+        if headers is not None:
+            raise ValueError("'headers' not supported for rawsocket transport")
+        # always a list; len == 1 for rawsocket
+        if 'serializer' in transport:
+            if not isinstance(transport['serializer'], (str, str)):
+                raise ValueError("'serializer' must be a string")
+            serializer_config = [transport['serializer']]
+        else:
+            serializer_config = ['cbor']
+
+    else:
+        assert False, 'should not arrive here'
+
+    kw = {}
+    for key in ['max_retries', 'max_retry_delay', 'initial_retry_delay',
+                'retry_delay_growth', 'retry_delay_jitter']:
+        if key in transport:
+            kw[key] = transport[key]
+
+    return _Transport(
+        index,
+        kind=kind,
+        url=transport.get('url', None),
+        endpoint=endpoint_config,
+        serializers=serializer_config,
+        proxy=proxy,
+        options=options,
+        headers=headers,
+        **kw
+    )
+
+
+class _Transport(object):
+    """
+    Thin-wrapper for WAMP transports used by a Connection.
+    """
+
+    def __init__(self, idx, kind, url, endpoint, serializers,
+                 max_retries=-1,
+                 max_retry_delay=300,
+                 initial_retry_delay=1.5,
+                 retry_delay_growth=1.5,
+                 retry_delay_jitter=0.1,
+                 proxy=None,
+                 options=None,
+                 headers=None):
+        """
+        """
+        if options is None:
+            options = dict()
+        self.idx = idx
+
+        self.type = kind
+        self.url = url
+        self.endpoint = endpoint
+        self.options = options
+        self.headers = headers
+
+        self.serializers = serializers
+        if self.type == 'rawsocket' and len(serializers) != 1:
+            raise ValueError(
+                "'rawsocket' transport requires exactly one serializer"
+            )
+
+        self.max_retries = max_retries
+        self.max_retry_delay = max_retry_delay
+        self.initial_retry_delay = initial_retry_delay
+        self.retry_delay_growth = retry_delay_growth
+        self.retry_delay_jitter = retry_delay_jitter
+        self.proxy = proxy  # this is a dict of proxy config
+
+        # used via can_reconnect() and failed() to record this
+        # transport is never going to work
+        self._permanent_failure = False
+
+        self.reset()
+
+    def reset(self):
+        """
+        set connection failure rates and retry-delay to initial values
+        """
+        self.connect_attempts = 0
+        self.connect_sucesses = 0
+        self.connect_failures = 0
+        self.retry_delay = self.initial_retry_delay
+
+    def failed(self):
+        """
+        Mark this transport as failed, meaning we won't try to connect to
+        it any longer (that is: can_reconnect() will always return
+        False afer calling this).
+        """
+        self._permanent_failure = True
+
+    def can_reconnect(self):
+        if self._permanent_failure:
+            return False
+        if self.max_retries == -1:
+            return True
+        return self.connect_attempts < self.max_retries + 1
+
+    def next_delay(self):
+        if self.connect_attempts == 0:
+            # if we never tried before, try immediately
+            return 0
+        elif self.max_retries != -1 and self.connect_attempts >= self.max_retries + 1:
+            raise RuntimeError('max reconnects reached')
+        else:
+            self.retry_delay = self.retry_delay * self.retry_delay_growth
+            self.retry_delay = random.normalvariate(self.retry_delay, self.retry_delay * self.retry_delay_jitter)
+            if self.retry_delay > self.max_retry_delay:
+                self.retry_delay = self.max_retry_delay
+            return self.retry_delay
+
+    def describe_endpoint(self):
+        """
+        returns a human-readable description of the endpoint
+        """
+        if isinstance(self.endpoint, dict):
+            return self.endpoint['type']
+        return repr(self.endpoint)
+
+
+# this could probably implement twisted.application.service.IService
+# if we wanted; or via an adapter...which just adds a startService()
+# and stopService() [latter can be async]
+
+class Component(ObservableMixin):
+    """
+    A WAMP application component. A component holds configuration for
+    (and knows how to create) transports and sessions.
+    """
+
+    session_factory = None
+    """
+    The factory of the session we will instantiate.
+    """
+
+    def subscribe(self, topic, options=None, check_types=False):
+        """
+        A decorator as a shortcut for subscribing during on-join
+
+        For example::
+
+            @component.subscribe(
+                "some.topic",
+                options=SubscribeOptions(match='prefix'),
+            )
+            def topic(*args, **kw):
+                print("some.topic({}, {}): event received".format(args, kw))
+        """
+        assert options is None or isinstance(options, SubscribeOptions)
+
+        def decorator(fn):
+
+            def do_subscription(session, details):
+                return session.subscribe(fn, topic=topic, options=options, check_types=check_types)
+            self.on('join', do_subscription)
+            return fn
+        return decorator
+
+    def register(self, uri, options=None, check_types=False):
+        """
+        A decorator as a shortcut for registering during on-join
+
+        For example::
+
+            @component.register(
+                "com.example.add",
+                options=RegisterOptions(invoke='roundrobin'),
+            )
+            def add(*args, **kw):
+                print("add({}, {}): event received".format(args, kw))
+        """
+        assert options is None or isinstance(options, RegisterOptions)
+
+        def decorator(fn):
+
+            def do_registration(session, details):
+                return session.register(fn, procedure=uri, options=options, check_types=check_types)
+            self.on('join', do_registration)
+            return fn
+        return decorator
+
+    def __init__(self, main=None, transports=None, config=None, realm='realm1', extra=None,
+                 authentication=None, session_factory=None, is_fatal=None):
+        """
+        :param main: After a transport has been connected and a session
+            has been established and joined to a realm, this (async)
+            procedure will be run until it finishes -- which signals that
+            the component has run to completion. In this case, it usually
+            doesn't make sense to use the ``on_*`` kwargs. If you do not
+            pass a main() procedure, the session will not be closed
+            (unless you arrange for .leave() to be called).
+
+        :type main: callable taking two args ``reactor`` and ``ISession``
+
+        :param transports: Transport configurations for creating
+            transports. Each transport can be a WAMP URL, or a dict
+            containing the following configuration keys:
+
+                - ``type`` (optional): ``websocket`` (default) or ``rawsocket``
+                - ``url``: the router URL
+                - ``endpoint`` (optional, derived from URL if not provided):
+                    - ``type``: "tcp" or "unix"
+                    - ``host``, ``port``: only for TCP
+                    - ``path``: only for unix
+                    - ``timeout``: in seconds
+                    - ``tls``: ``True`` or (under Twisted) an
+                      ``twisted.internet.ssl.IOpenSSLClientComponentCreator``
+                      instance (such as returned from
+                      ``twisted.internet.ssl.optionsForClientTLS``) or
+                      ``CertificateOptions`` instance.
+                - ``max_retries``: Maximum number of reconnection attempts. Unlimited if set to -1.
+                - ``initial_retry_delay``: Initial delay for reconnection attempt in seconds (Default: 1.0s).
+                - ``max_retry_delay``: Maximum delay for reconnection attempts in seconds (Default: 60s).
+                - ``retry_delay_growth``: The growth factor applied to the retry delay between reconnection attempts (Default 1.5).
+                - ``retry_delay_jitter``: A 0-argument callable that introduces nose into the delay. (Default random.random)
+                - ``serializer`` (only for raw socket): Specify an accepted serializer (e.g. 'json', 'msgpack', 'cbor', 'ubjson', 'flatbuffers')
+                - ``serializers``: Specify list of accepted serializers
+                - ``options``: tbd
+                - ``proxy``: tbd
+
+        :type transports: None or str or list
+
+        :param realm: the realm to join
+        :type realm: str
+
+        :param authentication: configuration of authenticators
+        :type authentication: dict
+
+        :param session_factory: if None, ``ApplicationSession`` is
+            used, otherwise a callable taking a single ``config`` argument
+            that is used to create a new `ApplicationSession` instance.
+
+        :param is_fatal: a callable taking a single argument, an
+            ``Exception`` instance. The callable should return ``True`` if
+            this error is "fatal", meaning we should not try connecting to
+            the current transport again. The default behavior (on None) is
+            to always return ``False``
+        """
+        self.set_valid_events(
+            [
+                'start',        # fired by base class
+                'connect',      # fired by ApplicationSession
+                'join',         # fired by ApplicationSession
+                'ready',        # fired by ApplicationSession
+                'leave',        # fired by ApplicationSession
+                'disconnect',   # fired by ApplicationSession
+                'connectfailure',   # fired by base class
+            ]
+        )
+
+        if is_fatal is not None and not callable(is_fatal):
+            raise ValueError('"is_fatal" must be a callable or None')
+        self._is_fatal = is_fatal
+
+        if main is not None and not callable(main):
+            raise ValueError('"main" must be a callable if given')
+        self._entry = main
+
+        # use WAMP-over-WebSocket to localhost when no transport is specified at all
+        if transports is None:
+            transports = 'ws://127.0.0.1:8080/ws'
+
+        # allows to provide a URL instead of a list of transports
+        if isinstance(transports, (str, str)):
+            url = transports
+            # 'endpoint' will get filled in by parsing the 'url'
+            transport = {
+                'type': 'websocket',
+                'url': url,
+            }
+            transports = [transport]
+
+        # allows single transport instead of a list (convenience)
+        elif isinstance(transports, dict):
+            transports = [transports]
+
+        # XXX do we want to be able to provide an infinite iterable of
+        # transports here? e.g. a generator that makes new transport
+        # to try?
+
+        # now check and save list of transports
+        self._transports = []
+        for idx, transport in enumerate(transports):
+            # allows to provide a URL instead of transport dict
+            if type(transport) == str:
+                _transport = {
+                    'type': 'websocket',
+                    'url': transport,
+                }
+            else:
+                _transport = transport
+            self._transports.append(
+                _create_transport(idx, _transport, self._check_native_endpoint)
+            )
+
+        # XXX should have some checkconfig support
+        self._authentication = authentication or {}
+
+        if session_factory:
+            self.session_factory = session_factory
+        self._realm = realm
+        self._extra = extra
+
+        self._delay_f = None
+        self._done_f = None
+        self._session = None
+        self._stopping = False
+
+    def _can_reconnect(self):
+        # check if any of our transport has any reconnect attempt left
+        for transport in self._transports:
+            if transport.can_reconnect():
+                return True
+        return False
+
+    def _start(self, loop=None):
+        """
+        This starts the Component, which means it will start connecting
+        (and re-connecting) to its configured transports. A Component
+        runs until it is "done", which means one of:
+
+        - There was a "main" function defined, and it completed successfully;
+        - Something called ``.leave()`` on our session, and we left successfully;
+        - ``.stop()`` was called, and completed successfully;
+        - none of our transports were able to connect successfully (failure);
+
+        :returns: a Future/Deferred which will resolve (to ``None``) when we are
+            "done" or with an error if something went wrong.
+        """
+
+        # we can only be "start()ed" once before we stop .. but that
+        # doesn't have to be an error we can give back another future
+        # that fires when our "real" _done_f is completed.
+        if self._done_f is not None:
+            d = txaio.create_future()
+
+            def _cb(arg):
+                txaio.resolve(d, arg)
+
+            txaio.add_callbacks(self._done_f, _cb, _cb)
+            return d
+
+        # this future will be returned, and thus has the semantics
+        # specified in the docstring.
+        self._done_f = txaio.create_future()
+
+        def _reset(arg):
+            """
+            if the _done_f future is resolved (good or bad), we want to set it
+            to None in our class
+            """
+            self._done_f = None
+            return arg
+        txaio.add_callbacks(self._done_f, _reset, _reset)
+
+        # Create a generator of transports that .can_reconnect()
+        transport_gen = itertools.cycle(self._transports)
+
+        # this is a 1-element list so we can set it from closures in
+        # this function
+        transport_candidate = [0]
+
+        def error(fail):
+            self._delay_f = None
+            if self._stopping:
+                # might be better to add framework-specific checks in
+                # subclasses to see if this is CancelledError (for
+                # Twisted) and whatever asyncio does .. but tracking
+                # if we're in the shutdown path is fine too
+                txaio.resolve(self._done_f, None)
+            else:
+                self.log.info("Internal error {msg}", msg=txaio.failure_message(fail))
+                self.log.debug("{tb}", tb=txaio.failure_format_traceback(fail))
+                txaio.reject(self._done_f, fail)
+
+        def attempt_connect(_):
+            self._delay_f = None
+
+            def handle_connect_error(fail):
+                # FIXME - make txaio friendly
+                # Can connect_f ever be in a cancelled state?
+                # if txaio.using_asyncio and isinstance(fail.value, asyncio.CancelledError):
+                #     unrecoverable_error = True
+
+                self.log.debug('component failed: {error}', error=txaio.failure_message(fail))
+                self.log.debug('{tb}', tb=txaio.failure_format_traceback(fail))
+                # If this is a "fatal error" that will never work,
+                # we bail out now
+                if isinstance(fail.value, ApplicationError):
+                    self.log.error("{msg}", msg=fail.value.error_message())
+
+                elif isinstance(fail.value, OSError):
+                    # failed to connect entirely, like nobody
+                    # listening etc.
+                    self.log.info("Connection failed with OS error: {msg}", msg=txaio.failure_message(fail))
+
+                elif self._is_ssl_error(fail.value):
+                    # Quoting pyOpenSSL docs: "Whenever
+                    # [SSL.Error] is raised directly, it has a
+                    # list of error messages from the OpenSSL
+                    # error queue, where each item is a tuple
+                    # (lib, function, reason). Here lib, function
+                    # and reason are all strings, describing where
+                    # and what the problem is. See err(3) for more
+                    # information."
+                    # (and 'args' is a 1-tuple containing the above
+                    # 3-tuple...)
+                    ssl_lib, ssl_func, ssl_reason = fail.value.args[0][0]
+                    self.log.error("TLS failure: {reason}", reason=ssl_reason)
+                else:
+                    self.log.error(
+                        'Connection failed: {error}',
+                        error=txaio.failure_message(fail),
+                    )
+
+                if self._is_fatal is None:
+                    is_fatal = False
+                else:
+                    is_fatal = self._is_fatal(fail.value)
+                if is_fatal:
+                    self.log.info("Error was fatal; failing transport")
+                    transport_candidate[0].failed()
+
+                txaio.call_later(0, transport_check, None)
+                return
+
+            def notify_connect_error(fail):
+                chain_f = txaio.create_future()
+                # hmm, if connectfailure took a _Transport instead of
+                # (or in addition to?) self it could .failed() the
+                # transport and we could do away with the is_fatal
+                # listener?
+                handler_f = self.fire('connectfailure', self, fail.value)
+                txaio.add_callbacks(
+                    handler_f,
+                    lambda _: txaio.reject(chain_f, fail),
+                    lambda _: txaio.reject(chain_f, fail)
+                )
+                return chain_f
+
+            def connect_error(fail):
+                notify_f = notify_connect_error(fail)
+                txaio.add_callbacks(notify_f, None, handle_connect_error)
+
+            def session_done(x):
+                txaio.resolve(self._done_f, None)
+
+            connect_f = txaio.as_future(
+                self._connect_once,
+                loop, transport_candidate[0],
+            )
+            txaio.add_callbacks(connect_f, session_done, connect_error)
+
+        def transport_check(_):
+            self.log.debug('Entering re-connect loop')
+
+            if not self._can_reconnect():
+                err_msg = "Component failed: Exhausted all transport connect attempts"
+                self.log.info(err_msg)
+                try:
+                    raise RuntimeError(err_msg)
+                except RuntimeError as e:
+                    txaio.reject(self._done_f, e)
+                    return
+
+            while True:
+
+                transport = next(transport_gen)
+
+                if transport.can_reconnect():
+                    transport_candidate[0] = transport
+                    break
+
+            delay = transport.next_delay()
+            self.log.warn(
+                'trying transport {transport_idx} ("{transport_url}") using connect delay {transport_delay}',
+                transport_idx=transport.idx,
+                transport_url=transport.url,
+                transport_delay=delay,
+            )
+
+            self._delay_f = txaio.sleep(delay)
+            txaio.add_callbacks(self._delay_f, attempt_connect, error)
+
+        # issue our first event, then start reconnect loop
+        start_f = self.fire('start', loop, self)
+        txaio.add_callbacks(start_f, transport_check, error)
+        return self._done_f
+
+    def stop(self):
+        self._stopping = True
+        if self._session and self._session.is_attached():
+            return self._session.leave()
+        elif self._delay_f:
+            # This cancel request will actually call the "error" callback of
+            # the _delay_f future. Nothing to worry about.
+            return txaio.as_future(txaio.cancel, self._delay_f)
+        # if (for some reason -- should we log warning here to figure
+        # out if this can evern happen?) we've not fired _done_f, we
+        # do that now (causing our "main" to exit, and thus react() to
+        # quit)
+        if not txaio.is_called(self._done_f):
+            txaio.resolve(self._done_f, None)
+        return txaio.create_future_success(None)
+
+    def _connect_once(self, reactor, transport):
+
+        self.log.info(
+            'connecting once using transport type "{transport_type}" '
+            'over endpoint "{endpoint_desc}"',
+            transport_type=transport.type,
+            endpoint_desc=transport.describe_endpoint(),
+        )
+
+        done = txaio.create_future()
+
+        # factory for ISession objects
+        def create_session():
+            cfg = ComponentConfig(self._realm, self._extra)
+            try:
+                self._session = session = self.session_factory(cfg)
+                for auth_name, auth_config in self._authentication.items():
+                    if isinstance(auth_config, IAuthenticator):
+                        session.add_authenticator(auth_config)
+                    else:
+                        authenticator = create_authenticator(auth_name, **auth_config)
+                        session.add_authenticator(authenticator)
+
+            except Exception as e:
+                # couldn't instantiate session calls, which is fatal.
+                # let the reconnection logic deal with that
+                f = txaio.create_failure(e)
+                txaio.reject(done, f)
+                raise
+            else:
+                # hook up the listener to the parent so we can bubble
+                # up events happning on the session onto the
+                # connection. This lets you do component.on('join',
+                # cb) which will work just as if you called
+                # session.on('join', cb) for every session created.
+                session._parent = self
+
+                # listen on leave events; if we get errors
+                # (e.g. no_such_realm), an on_leave can happen without
+                # an on_join before
+                def on_leave(session, details):
+                    self.log.info(
+                        "session leaving '{details.reason}'",
+                        details=details,
+                    )
+                    if not txaio.is_called(done):
+                        if details.reason in ["wamp.close.normal", "wamp.close.goodbye_and_out"]:
+                            txaio.resolve(done, None)
+                        else:
+                            f = txaio.create_failure(
+                                ApplicationError(details.reason, details.message)
+                            )
+                            txaio.reject(done, f)
+                session.on('leave', on_leave)
+
+                # if we were given a "main" procedure, we run through
+                # it completely (i.e. until its Deferred fires) and
+                # then disconnect this session
+                def on_join(session, details):
+                    transport.reset()
+                    transport.connect_sucesses += 1
+                    self.log.debug("session on_join: {details}", details=details)
+                    d = txaio.as_future(self._entry, reactor, session)
+
+                    def main_success(_):
+                        self.log.debug("main_success")
+
+                        def leave():
+                            try:
+                                session.leave()
+                            except SessionNotReady:
+                                # someone may have already called
+                                # leave()
+                                pass
+                        txaio.call_later(0, leave)
+
+                    def main_error(err):
+                        self.log.debug("main_error: {err}", err=err)
+                        txaio.reject(done, err)
+                        session.disconnect()
+                    txaio.add_callbacks(d, main_success, main_error)
+                if self._entry is not None:
+                    session.on('join', on_join)
+
+                # listen on disconnect events. Note that in case we
+                # had a "main" procedure, we could have already
+                # resolve()'d our "done" future
+                def on_disconnect(session, was_clean):
+                    self.log.debug(
+                        "session on_disconnect: was_clean={was_clean}",
+                        was_clean=was_clean,
+                    )
+                    if not txaio.is_called(done):
+                        if not was_clean:
+                            self.log.warn(
+                                "Session disconnected uncleanly"
+                            )
+                        else:
+                            # eg the session has left the realm, and the transport was properly
+                            # shut down. successfully finish the connection
+                            txaio.resolve(done, None)
+                session.on('disconnect', on_disconnect)
+
+                # return the fresh session object
+                return session
+
+        transport.connect_attempts += 1
+
+        d = txaio.as_future(
+            self._connect_transport,
+            reactor, transport, create_session, done,
+        )
+
+        def on_error(err):
+            """
+            this may seem redundant after looking at _connect_transport, but
+            it will handle a case where something goes wrong in
+            _connect_transport itself -- as the only connect our
+            caller has is the 'done' future
+            """
+            transport.connect_failures += 1
+            # something bad has happened, and maybe didn't get caught
+            # upstream yet
+            if not txaio.is_called(done):
+                txaio.reject(done, err)
+        txaio.add_callbacks(d, None, on_error)
+
+        return done
+
+    def on_join(self, fn):
+        """
+        A decorator as a shortcut for listening for 'join' events.
+
+        For example::
+
+           @component.on_join
+           def joined(session, details):
+               print("Session {} joined: {}".format(session, details))
+        """
+        self.on('join', fn)
+
+    def on_leave(self, fn):
+        """
+        A decorator as a shortcut for listening for 'leave' events.
+        """
+        self.on('leave', fn)
+
+    def on_connect(self, fn):
+        """
+        A decorator as a shortcut for listening for 'connect' events.
+        """
+        self.on('connect', fn)
+
+    def on_disconnect(self, fn):
+        """
+        A decorator as a shortcut for listening for 'disconnect' events.
+        """
+        self.on('disconnect', fn)
+
+    def on_ready(self, fn):
+        """
+        A decorator as a shortcut for listening for 'ready' events.
+        """
+        self.on('ready', fn)
+
+    def on_connectfailure(self, fn):
+        """
+        A decorator as a shortcut for listening for 'connectfailure' events.
+        """
+        self.on('connectfailure', fn)
+
+
+def _run(reactor, components, done_callback=None):
+    """
+    Internal helper. Use "run" method from autobahn.twisted.wamp or
+    autobahn.asyncio.wamp
+
+    This is the generic parts of the run() method so that there's very
+    little code in the twisted/asyncio specific run() methods.
+
+    This is called by react() (or run_until_complete() so any errors
+    coming out of this should be handled properly. Logging will
+    already be started.
+    """
+    # let user pass a single component to run, too
+    # XXX probably want IComponent? only demand it, here and below?
+    if isinstance(components, Component):
+        components = [components]
+
+    if type(components) != list:
+        raise ValueError(
+            '"components" must be a list of Component objects - encountered'
+            ' {0}'.format(type(components))
+        )
+
+    for c in components:
+        if not isinstance(c, Component):
+            raise ValueError(
+                '"components" must be a list of Component objects - encountered'
+                'item of type {0}'.format(type(c))
+            )
+
+    # validation complete; proceed with startup
+    log = txaio.make_logger()
+
+    def component_success(comp, arg):
+        log.debug("Component '{c}' successfully completed: {arg}", c=comp, arg=arg)
+        return arg
+
+    def component_failure(comp, f):
+        log.error("Component '{c}' error: {msg}", c=comp, msg=txaio.failure_message(f))
+        log.debug("Component error: {tb}", tb=txaio.failure_format_traceback(f))
+        # double-check: is a component-failure still fatal to the
+        # startup process (because we passed consume_exception=False
+        # to gather() below?)
+        return None
+
+    def component_start(comp):
+        # the future from start() errbacks if we fail, or callbacks
+        # when the component is considered "done" (so maybe never)
+        d = txaio.as_future(comp.start, reactor)
+        txaio.add_callbacks(
+            d,
+            partial(component_success, comp),
+            partial(component_failure, comp),
+        )
+        return d
+
+    # note that these are started in parallel -- maybe we want to add
+    # a "connected" signal to components so we could start them in the
+    # order they're given to run() as "a" solution to dependencies.
+    dl = []
+    for comp in components:
+        d = component_start(comp)
+        dl.append(d)
+    done_d = txaio.gather(dl, consume_exceptions=False)
+
+    if done_callback:
+        def all_done(arg):
+            log.debug("All components ended; stopping reactor")
+            done_callback(reactor, arg)
+        txaio.add_callbacks(done_d, all_done, all_done)
+
+    return done_d

backend/lib/python3.12/site-packages/autobahn/wamp/cryptobox.py

@@ -0,0 +1,268 @@
+###############################################################################
+#
+# The MIT License (MIT)
+#
+# Copyright (c) typedef int GmbH
+#
+# 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.
+#
+###############################################################################
+
+
+from autobahn.util import public
+from autobahn.wamp.interfaces import IPayloadCodec
+from autobahn.wamp.types import EncodedPayload
+from autobahn.wamp.serializer import _dumps as _json_dumps
+from autobahn.wamp.serializer import _loads as _json_loads
+
+__all__ = [
+    'HAS_CRYPTOBOX',
+    'EncodedPayload'
+]
+
+try:
+    # try to import everything we need for WAMP-cryptobox
+    from nacl.encoding import Base64Encoder, RawEncoder, HexEncoder
+    from nacl.public import PrivateKey, PublicKey, Box
+    from nacl.utils import random
+    from pytrie import StringTrie
+except ImportError:
+    HAS_CRYPTOBOX = False
+else:
+    HAS_CRYPTOBOX = True
+    __all__.extend(['Key', 'KeyRing'])
+
+
+if HAS_CRYPTOBOX:
+
+    @public
+    class Key(object):
+        """
+        Holds originator and responder keys for an URI.
+
+        The originator is either a caller or a publisher. The responder is either a callee or subscriber.
+        """
+
+        def __init__(self, originator_priv=None, originator_pub=None, responder_priv=None, responder_pub=None):
+            # the originator private and public keys, as available
+            if originator_priv:
+                self.originator_priv = PrivateKey(originator_priv, encoder=Base64Encoder)
+            else:
+                self.originator_priv = None
+
+            if self.originator_priv:
+                self.originator_pub = self.originator_priv.public_key
+                assert(originator_pub is None or originator_pub == self.originator_pub)
+            else:
+                self.originator_pub = PublicKey(originator_pub, encoder=Base64Encoder)
+
+            # the responder private and public keys, as available
+            if responder_priv:
+                self.responder_priv = PrivateKey(responder_priv, encoder=Base64Encoder)
+            else:
+                self.responder_priv = None
+
+            if self.responder_priv:
+                self.responder_pub = self.responder_priv.public_key
+                assert(responder_pub is None or responder_pub == self.responder_pub)
+            else:
+                self.responder_pub = PublicKey(responder_pub, encoder=Base64Encoder)
+
+            # this crypto box is for originators (callers, publishers):
+            #
+            #  1. _encrypting_ WAMP messages outgoing from originators: CALL*, PUBLISH*
+            #  2. _decrypting_ WAMP messages incoming to originators: RESULT*, ERROR
+            #
+            if self.originator_priv and self.responder_pub:
+                self.originator_box = Box(self.originator_priv, self.responder_pub)
+            else:
+                self.originator_box = None
+
+            # this crypto box is for responders (callees, subscribers):
+            #
+            #  1. _decrypting_ WAMP messages incoming to responders: INVOCATION*, EVENT*
+            #  2. _encrypting_ WAMP messages outgoing from responders: YIELD*, ERROR
+            #
+            if self.responder_priv and self.originator_pub:
+                self.responder_box = Box(self.responder_priv, self.originator_pub)
+            else:
+                self.responder_box = None
+
+            if not (self.originator_box or self.responder_box):
+                raise Exception("insufficient keys provided for at least originator or responder role")
+
+    @public
+    class SymKey(object):
+        """
+        Holds a symmetric key for an URI.
+        """
+        def __init__(self, raw=None):
+            pass
+
+    @public
+    class KeyRing(object):
+        """
+        A keyring holds (cryptobox) public-private key pairs for use with WAMP-cryptobox payload
+        encryption. The keyring can be set on a WAMP session and then transparently will get used
+        for encrypting and decrypting WAMP message payloads.
+        """
+
+        @public
+        def __init__(self, default_key=None):
+            """
+
+            Create a new key ring to hold public and private keys mapped from an URI space.
+            """
+            assert(default_key is None or isinstance(default_key, Key) or type(default_key == str))
+            self._uri_to_key = StringTrie()
+            if type(default_key) == str:
+                default_key = Key(originator_priv=default_key, responder_priv=default_key)
+            self._default_key = default_key
+
+        @public
+        def generate_key(self):
+            """
+            Generate a new private key and return a pair with the base64 encodings
+            of (priv_key, pub_key).
+            """
+            key = PrivateKey.generate()
+            priv_key = key.encode(encoder=Base64Encoder)
+            pub_key = key.public_key.encode(encoder=Base64Encoder)
+            return priv_key.decode('ascii'), pub_key.decode('ascii')
+
+        @public
+        def generate_key_hex(self):
+            """
+            Generate a new private key and return a pair with the hex encodings
+            of (priv_key, pub_key).
+            """
+            key = PrivateKey.generate()
+            priv_key = key.encode(encoder=HexEncoder)
+            pub_key = key.public_key.encode(encoder=HexEncoder)
+            return priv_key.decode('ascii'), pub_key.decode('ascii')
+
+        @public
+        def set_key(self, uri, key):
+            """
+            Add a key set for a given URI.
+            """
+            assert(type(uri) == str)
+            assert(key is None or isinstance(key, Key) or type(key) == str)
+            if type(key) == str:
+                key = Key(originator_priv=key, responder_priv=key)
+            if uri == '':
+                self._default_key = key
+            else:
+                if key is None:
+                    if uri in self._uri_to_key:
+                        del self._uri_to_key[uri]
+                else:
+                    self._uri_to_key[uri] = key
+
+        @public
+        def rotate_key(self, uri):
+            assert(type(uri) == str)
+            if uri in self._uri_to_key:
+                self._uri_to_key[uri].rotate()
+            else:
+                self._uri_to_key[uri].rotate()
+
+        def _get_box(self, is_originating, uri, match_exact=False):
+            try:
+                if match_exact:
+                    key = self._uri_to_key[uri]
+                else:
+                    key = self._uri_to_key.longest_prefix_value(uri)
+            except KeyError:
+                if self._default_key:
+                    key = self._default_key
+                else:
+                    return None
+
+            if is_originating:
+                return key.originator_box
+            else:
+                return key.responder_box
+
+        @public
+        def encode(self, is_originating, uri, args=None, kwargs=None):
+            """
+            Encrypt the given WAMP URI, args and kwargs into an EncodedPayload instance, or None
+            if the URI should not be encrypted.
+            """
+            assert(type(is_originating) == bool)
+            assert(type(uri) == str)
+            assert(args is None or type(args) in (list, tuple))
+            assert(kwargs is None or type(kwargs) == dict)
+
+            box = self._get_box(is_originating, uri)
+
+            if not box:
+                # if we didn't find a crypto box, then return None, which
+                # signals that the payload travel unencrypted (normal)
+                return None
+
+            payload = {
+                'uri': uri,
+                'args': args,
+                'kwargs': kwargs
+            }
+            nonce = random(Box.NONCE_SIZE)
+            payload_ser = _json_dumps(payload).encode('utf8')
+
+            payload_encr = box.encrypt(payload_ser, nonce, encoder=RawEncoder)
+
+            # above returns an instance of http://pynacl.readthedocs.io/en/latest/utils/#nacl.utils.EncryptedMessage
+            # which is a bytes _subclass_! hence we apply bytes() to get at the underlying plain
+            # bytes "scalar", which is the concatenation of `payload_encr.nonce + payload_encr.ciphertext`
+            payload_bytes = bytes(payload_encr)
+            payload_key = None
+
+            return EncodedPayload(payload_bytes, 'cryptobox', 'json', enc_key=payload_key)
+
+        @public
+        def decode(self, is_originating, uri, encoded_payload):
+            """
+            Decrypt the given WAMP URI and EncodedPayload into a tuple ``(uri, args, kwargs)``.
+            """
+            assert(type(uri) == str)
+            assert(isinstance(encoded_payload, EncodedPayload))
+            assert(encoded_payload.enc_algo == 'cryptobox')
+
+            box = self._get_box(is_originating, uri)
+
+            if not box:
+                raise Exception("received encrypted payload, but can't find key!")
+
+            payload_ser = box.decrypt(encoded_payload.payload, encoder=RawEncoder)
+
+            if encoded_payload.enc_serializer != 'json':
+                raise Exception("received encrypted payload, but don't know how to process serializer '{}'".format(encoded_payload.enc_serializer))
+
+            payload = _json_loads(payload_ser.decode('utf8'))
+
+            uri = payload.get('uri', None)
+            args = payload.get('args', None)
+            kwargs = payload.get('kwargs', None)
+
+            return uri, args, kwargs
+
+    # A WAMP-cryptobox keyring can work as a codec for
+    # payload transparency
+    IPayloadCodec.register(KeyRing)

backend/lib/python3.12/site-packages/autobahn/wamp/exception.py

@@ -0,0 +1,326 @@
+###############################################################################
+#
+# The MIT License (MIT)
+#
+# Copyright (c) typedef int GmbH
+#
+# 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.
+#
+###############################################################################
+
+
+from autobahn.util import public
+from autobahn.wamp.uri import error
+
+__all__ = (
+    'Error',
+    'SessionNotReady',
+    'SerializationError',
+    'InvalidUriError',
+    'ProtocolError',
+    'TransportLost',
+    'ApplicationError',
+    'NotAuthorized',
+    'InvalidUri',
+    'InvalidPayload',
+    'TypeCheckError',
+)
+
+
+@public
+class Error(RuntimeError):
+    """
+    Base class for all exceptions related to WAMP.
+    """
+
+
+@public
+class SessionNotReady(Error):
+    """
+    The application tried to perform a WAMP interaction, but the
+    session is not yet fully established.
+    """
+
+
+@public
+class SerializationError(Error):
+    """
+    Exception raised when the WAMP serializer could not serialize the
+    application payload (``args`` or ``kwargs`` for ``CALL``, ``PUBLISH``, etc).
+    """
+
+
+@public
+class InvalidUriError(Error):
+    """
+    Exception raised when an invalid WAMP URI was used.
+    """
+
+
+@public
+class ProtocolError(Error):
+    """
+    Exception raised when WAMP protocol was violated. Protocol errors
+    are fatal and are handled by the WAMP implementation. They are
+    not supposed to be handled at the application level.
+    """
+
+
+@public
+class TransportLost(Error):
+    """
+    Exception raised when the transport underlying the WAMP session
+    was lost or is not connected.
+    """
+
+
+@public
+class ApplicationError(Error):
+    """
+    Base class for all exceptions that can/may be handled
+    at the application level.
+    """
+
+    INVALID_URI = "wamp.error.invalid_uri"
+    """
+    Peer provided an incorrect URI for a URI-based attribute of a WAMP message
+    such as a realm, topic or procedure.
+    """
+
+    INVALID_PAYLOAD = "wamp.error.invalid_payload"
+    """
+    The application payload could not be serialized.
+    """
+
+    PAYLOAD_SIZE_EXCEEDED = "wamp.error.payload_size_exceeded"
+    """
+    The application payload could not be transported becuase the serialized/framed payload
+    exceeds the transport limits.
+    """
+
+    NO_SUCH_PROCEDURE = "wamp.error.no_such_procedure"
+    """
+    A Dealer could not perform a call, since not procedure is currently registered
+    under the given URI.
+    """
+
+    PROCEDURE_ALREADY_EXISTS = "wamp.error.procedure_already_exists"
+    """
+    A procedure could not be registered, since a procedure with the given URI is
+    already registered.
+    """
+
+    PROCEDURE_EXISTS_INVOCATION_POLICY_CONFLICT = "wamp.error.procedure_exists_with_different_invocation_policy"
+    """
+    A procedure could not be registered, since a procedure with the given URI is
+    already registered, and the registration has a conflicting invocation policy.
+    """
+
+    NO_SUCH_REGISTRATION = "wamp.error.no_such_registration"
+    """
+    A Dealer could not perform a unregister, since the given registration is not active.
+    """
+
+    NO_SUCH_SUBSCRIPTION = "wamp.error.no_such_subscription"
+    """
+    A Broker could not perform a unsubscribe, since the given subscription is not active.
+    """
+
+    NO_SUCH_SESSION = "wamp.error.no_such_session"
+    """
+    A router could not perform an operation, since a session ID specified was non-existant.
+    """
+
+    INVALID_ARGUMENT = "wamp.error.invalid_argument"
+    """
+    A call failed, since the given argument types or values are not acceptable to the
+    called procedure - in which case the *Callee* may throw this error. Or a Router
+    performing *payload validation* checked the payload (``args`` / ``kwargs``) of a call,
+    call result, call error or publish, and the payload did not conform.
+    """
+
+    # FIXME: this currently isn't used neither in Autobahn nor Crossbar. Check!
+    SYSTEM_SHUTDOWN = "wamp.error.system_shutdown"
+    """
+    The *Peer* is shutting down completely - used as a ``GOODBYE`` (or ``ABORT``) reason.
+    """
+
+    # FIXME: this currently isn't used neither in Autobahn nor Crossbar. Check!
+    CLOSE_REALM = "wamp.error.close_realm"
+    """
+    The *Peer* want to leave the realm - used as a ``GOODBYE`` reason.
+    """
+
+    # FIXME: this currently isn't used neither in Autobahn nor Crossbar. Check!
+    GOODBYE_AND_OUT = "wamp.error.goodbye_and_out"
+    """
+    A *Peer* acknowledges ending of a session - used as a ``GOOBYE`` reply reason.
+    """
+
+    NOT_AUTHORIZED = "wamp.error.not_authorized"
+    """
+    A call, register, publish or subscribe failed, since the session is not authorized
+    to perform the operation.
+    """
+
+    AUTHORIZATION_FAILED = "wamp.error.authorization_failed"
+    """
+    A Dealer or Broker could not determine if the *Peer* is authorized to perform
+    a join, call, register, publish or subscribe, since the authorization operation
+    *itself* failed. E.g. a custom authorizer did run into an error.
+    """
+
+    AUTHENTICATION_FAILED = "wamp.error.authentication_failed"
+    """
+    Something failed with the authentication itself, that is, authentication could
+    not run to end.
+    """
+
+    NO_AUTH_METHOD = "wamp.error.no_auth_method"
+    """
+    No authentication method the peer offered is available or active.
+    """
+
+    NO_SUCH_REALM = "wamp.error.no_such_realm"
+    """
+    Peer wanted to join a non-existing realm (and the *Router* did not allow to auto-create
+    the realm).
+    """
+
+    NO_SUCH_ROLE = "wamp.error.no_such_role"
+    """
+    A *Peer* was to be authenticated under a Role that does not (or no longer) exists on the Router.
+    For example, the *Peer* was successfully authenticated, but the Role configured does not
+    exists - hence there is some misconfiguration in the Router.
+    """
+
+    NO_SUCH_PRINCIPAL = "wamp.error.no_such_principal"
+    """
+    A *Peer* was authenticated for an authid that does not or longer exists.
+    """
+
+    CANCELED = "wamp.error.canceled"
+    """
+    A Dealer or Callee canceled a call previously issued (WAMP AP).
+    """
+
+    TIMEOUT = "wamp.error.timeout"
+    """
+    A pending (in-flight) call was timed out.
+    """
+
+    # FIXME: this currently isn't used neither in Autobahn nor Crossbar. Check!
+    NO_ELIGIBLE_CALLEE = "wamp.error.no_eligible_callee"
+    """
+    A *Dealer* could not perform a call, since a procedure with the given URI is registered,
+    but *Callee Black- and Whitelisting* and/or *Caller Exclusion* lead to the
+    exclusion of (any) *Callee* providing the procedure (WAMP AP).
+    """
+
+    ENC_NO_PAYLOAD_CODEC = "wamp.error.no_payload_codec"
+    """
+    WAMP message in payload transparency mode received, but no codec set
+    or codec did not decode the payload.
+    """
+
+    ENC_TRUSTED_URI_MISMATCH = "wamp.error.encryption.trusted_uri_mismatch"
+    """
+    WAMP-cryptobox application payload end-to-end encryption error.
+    """
+
+    ENC_DECRYPT_ERROR = "wamp.error.encryption.decrypt_error"
+    """
+    WAMP-cryptobox application payload end-to-end encryption error.
+    """
+
+    TYPE_CHECK_ERROR = "wamp.error.type_check_error"
+    """
+    WAMP procedure called with wrong argument types or subscription published
+    with wrong argument types.
+    """
+
+    def __init__(self, error, *args, **kwargs):
+        """
+
+        :param error: The URI of the error that occurred, e.g. ``wamp.error.not_authorized``.
+        :type error: str
+        """
+        Exception.__init__(self, *args)
+        self.kwargs = kwargs
+        self.error = error
+        self.enc_algo = kwargs.pop('enc_algo', None)
+        self.callee = kwargs.pop('callee', None)
+        self.callee_authid = kwargs.pop('callee_authid', None)
+        self.callee_authrole = kwargs.pop('callee_authrole', None)
+        self.forward_for = kwargs.pop('forward_for', None)
+
+    @public
+    def error_message(self):
+        """
+        Get the error message of this exception.
+
+        :returns: The error message.
+        :rtype: str
+        """
+        return '{0}: {1}'.format(
+            self.error,
+            ' '.join([str(a) for a in self.args]),
+        )
+
+    def __unicode__(self):
+        if self.kwargs and 'traceback' in self.kwargs:
+            tb = ':\n' + self.kwargs.pop('traceback') + '\n'
+            self.kwargs['traceback'] = '...'
+        else:
+            tb = ''
+        return "ApplicationError(error=<{0}>, args={1}, kwargs={2}, enc_algo={3}, callee={4}, callee_authid={5}, callee_authrole={6}, forward_for={7}){8}".format(
+            self.error, list(self.args), self.kwargs, self.enc_algo, self.callee, self.callee_authid, self.callee_authrole, self.forward_for, tb)
+
+    def __str__(self):
+        return self.__unicode__()
+
+
+@error(ApplicationError.NOT_AUTHORIZED)
+class NotAuthorized(Exception):
+    """
+    Not authorized to perform the respective action.
+    """
+
+
+@error(ApplicationError.INVALID_URI)
+class InvalidUri(Exception):
+    """
+    The URI for a topic, procedure or error is not a valid WAMP URI.
+    """
+
+
+@error(ApplicationError.INVALID_PAYLOAD)
+class InvalidPayload(Exception):
+    """
+    The URI for a topic, procedure or error is not a valid WAMP URI.
+    """
+
+
+class TypeCheckError(ApplicationError):
+    """
+    The URI for a topic published with invalid argument types or a
+    procedure called with invalid arguments types.
+    """
+    def __init__(self, *args, **kwargs):
+        super().__init__(ApplicationError.TYPE_CHECK_ERROR, *args, **kwargs)

backend/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/Map.py

@@ -0,0 +1,52 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: wamp
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+class Map(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = Map()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsMap(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    # Map
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # Map
+    def Key(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # Map
+    def Value(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+def MapStart(builder): builder.StartObject(2)
+def Start(builder):
+    return MapStart(builder)
+def MapAddKey(builder, key): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(key), 0)
+def AddKey(builder, key):
+    return MapAddKey(builder, key)
+def MapAddValue(builder, value): builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(value), 0)
+def AddValue(builder, value):
+    return MapAddValue(builder, value)
+def MapEnd(builder): return builder.EndObject()
+def End(builder):
+    return MapEnd(builder)

backend/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/Void.py

@@ -0,0 +1,32 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: wamp
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+class Void(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = Void()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsVoid(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    # Void
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+def VoidStart(builder): builder.StartObject(0)
+def Start(builder):
+    return VoidStart(builder)
+def VoidEnd(builder): return builder.EndObject()
+def End(builder):
+    return VoidEnd(builder)

backend/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/proto/Abort.py

@@ -0,0 +1,62 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: proto
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+class Abort(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = Abort()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsAbort(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    # Abort
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # Abort
+    def Session(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
+        return 0
+
+    # Abort
+    def Reason(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # Abort
+    def Message(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+def AbortStart(builder): builder.StartObject(3)
+def Start(builder):
+    return AbortStart(builder)
+def AbortAddSession(builder, session): builder.PrependUint64Slot(0, session, 0)
+def AddSession(builder, session):
+    return AbortAddSession(builder, session)
+def AbortAddReason(builder, reason): builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(reason), 0)
+def AddReason(builder, reason):
+    return AbortAddReason(builder, reason)
+def AbortAddMessage(builder, message): builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(message), 0)
+def AddMessage(builder, message):
+    return AbortAddMessage(builder, message)
+def AbortEnd(builder): return builder.EndObject()
+def End(builder):
+    return AbortEnd(builder)

backend/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/proto/AnyMessage.py

@@ -0,0 +1,31 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: proto
+
+class AnyMessage(object):
+    NONE = 0
+    Hello = 1
+    Welcome = 2
+    Abort = 3
+    Challenge = 4
+    Authenticate = 5
+    Goodbye = 6
+    Error = 7
+    Publish = 8
+    Published = 9
+    Subscribe = 10
+    Subscribed = 11
+    Unsubscribe = 12
+    Unsubscribed = 13
+    Event = 14
+    EventReceived = 15
+    Call = 16
+    Cancel = 17
+    Result = 18
+    Register = 19
+    Registered = 20
+    Unregister = 21
+    Unregistered = 22
+    Invocation = 23
+    Interrupt = 24
+    Yield = 25

backend/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/proto/AuthCraChallenge.py

@@ -0,0 +1,72 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: proto
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+class AuthCraChallenge(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = AuthCraChallenge()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsAuthCraChallenge(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    # AuthCraChallenge
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # AuthCraChallenge
+    def Challenge(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # AuthCraChallenge
+    def Salt(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # AuthCraChallenge
+    def Iterations(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos)
+        return 1000
+
+    # AuthCraChallenge
+    def Keylen(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
+        return 32
+
+def AuthCraChallengeStart(builder): builder.StartObject(4)
+def Start(builder):
+    return AuthCraChallengeStart(builder)
+def AuthCraChallengeAddChallenge(builder, challenge): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(challenge), 0)
+def AddChallenge(builder, challenge):
+    return AuthCraChallengeAddChallenge(builder, challenge)
+def AuthCraChallengeAddSalt(builder, salt): builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(salt), 0)
+def AddSalt(builder, salt):
+    return AuthCraChallengeAddSalt(builder, salt)
+def AuthCraChallengeAddIterations(builder, iterations): builder.PrependUint32Slot(2, iterations, 1000)
+def AddIterations(builder, iterations):
+    return AuthCraChallengeAddIterations(builder, iterations)
+def AuthCraChallengeAddKeylen(builder, keylen): builder.PrependUint8Slot(3, keylen, 32)
+def AddKeylen(builder, keylen):
+    return AuthCraChallengeAddKeylen(builder, keylen)
+def AuthCraChallengeEnd(builder): return builder.EndObject()
+def End(builder):
+    return AuthCraChallengeEnd(builder)

backend/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/proto/AuthCraRequest.py

@@ -0,0 +1,32 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: proto
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+class AuthCraRequest(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = AuthCraRequest()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsAuthCraRequest(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    # AuthCraRequest
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+def AuthCraRequestStart(builder): builder.StartObject(0)
+def Start(builder):
+    return AuthCraRequestStart(builder)
+def AuthCraRequestEnd(builder): return builder.EndObject()
+def End(builder):
+    return AuthCraRequestEnd(builder)

backend/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/proto/AuthCraWelcome.py

@@ -0,0 +1,32 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: proto
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+class AuthCraWelcome(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = AuthCraWelcome()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsAuthCraWelcome(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    # AuthCraWelcome
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+def AuthCraWelcomeStart(builder): builder.StartObject(0)
+def Start(builder):
+    return AuthCraWelcomeStart(builder)
+def AuthCraWelcomeEnd(builder): return builder.EndObject()
+def End(builder):
+    return AuthCraWelcomeEnd(builder)

backend/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/proto/AuthCryptosignChallenge.py

@@ -0,0 +1,42 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: proto
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+class AuthCryptosignChallenge(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = AuthCryptosignChallenge()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsAuthCryptosignChallenge(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    # AuthCryptosignChallenge
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # AuthCryptosignChallenge
+    def ChannelBinding(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
+        return 0
+
+def AuthCryptosignChallengeStart(builder): builder.StartObject(1)
+def Start(builder):
+    return AuthCryptosignChallengeStart(builder)
+def AuthCryptosignChallengeAddChannelBinding(builder, channelBinding): builder.PrependUint8Slot(0, channelBinding, 0)
+def AddChannelBinding(builder, channelBinding):
+    return AuthCryptosignChallengeAddChannelBinding(builder, channelBinding)
+def AuthCryptosignChallengeEnd(builder): return builder.EndObject()
+def End(builder):
+    return AuthCryptosignChallengeEnd(builder)

backend/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/proto/AuthCryptosignRequest.py

@@ -0,0 +1,52 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: proto
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+class AuthCryptosignRequest(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = AuthCryptosignRequest()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsAuthCryptosignRequest(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    # AuthCryptosignRequest
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # AuthCryptosignRequest
+    def Pubkey(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # AuthCryptosignRequest
+    def ChannelBinding(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
+        return 0
+
+def AuthCryptosignRequestStart(builder): builder.StartObject(2)
+def Start(builder):
+    return AuthCryptosignRequestStart(builder)
+def AuthCryptosignRequestAddPubkey(builder, pubkey): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(pubkey), 0)
+def AddPubkey(builder, pubkey):
+    return AuthCryptosignRequestAddPubkey(builder, pubkey)
+def AuthCryptosignRequestAddChannelBinding(builder, channelBinding): builder.PrependUint8Slot(1, channelBinding, 0)
+def AddChannelBinding(builder, channelBinding):
+    return AuthCryptosignRequestAddChannelBinding(builder, channelBinding)
+def AuthCryptosignRequestEnd(builder): return builder.EndObject()
+def End(builder):
+    return AuthCryptosignRequestEnd(builder)

backend/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/proto/AuthCryptosignWelcome.py

@@ -0,0 +1,32 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: proto
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+class AuthCryptosignWelcome(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = AuthCryptosignWelcome()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsAuthCryptosignWelcome(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    # AuthCryptosignWelcome
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+def AuthCryptosignWelcomeStart(builder): builder.StartObject(0)
+def Start(builder):
+    return AuthCryptosignWelcomeStart(builder)
+def AuthCryptosignWelcomeEnd(builder): return builder.EndObject()
+def End(builder):
+    return AuthCryptosignWelcomeEnd(builder)

backend/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/proto/AuthFactor.py

@@ -0,0 +1,10 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: proto
+
+class AuthFactor(object):
+    NONE = 0
+    AuthTicketRequest = 1
+    AuthCraRequest = 2
+    AuthScramRequest = 3
+    AuthCryptosignRequest = 4

backend/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/proto/AuthMethod.py

@@ -0,0 +1,12 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: proto
+
+class AuthMethod(object):
+    ANONYMOUS = 0
+    COOKIE = 1
+    TLS = 2
+    TICKET = 3
+    CRA = 4
+    SCRAM = 5
+    CRYPTOSIGN = 6

backend/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/proto/AuthMode.py

@@ -0,0 +1,7 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: proto
+
+class AuthMode(object):
+    FIRST = 0
+    MULTIFACTOR = 1

backend/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/proto/AuthScramChallenge.py

@@ -0,0 +1,92 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: proto
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+class AuthScramChallenge(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = AuthScramChallenge()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsAuthScramChallenge(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    # AuthScramChallenge
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # AuthScramChallenge
+    def Nonce(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # AuthScramChallenge
+    def Salt(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # AuthScramChallenge
+    def Kdf(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
+        return 2
+
+    # AuthScramChallenge
+    def Iterations(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos)
+        return 0
+
+    # AuthScramChallenge
+    def Memory(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos)
+        return 0
+
+    # AuthScramChallenge
+    def ChannelBinding(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
+        return 0
+
+def AuthScramChallengeStart(builder): builder.StartObject(6)
+def Start(builder):
+    return AuthScramChallengeStart(builder)
+def AuthScramChallengeAddNonce(builder, nonce): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(nonce), 0)
+def AddNonce(builder, nonce):
+    return AuthScramChallengeAddNonce(builder, nonce)
+def AuthScramChallengeAddSalt(builder, salt): builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(salt), 0)
+def AddSalt(builder, salt):
+    return AuthScramChallengeAddSalt(builder, salt)
+def AuthScramChallengeAddKdf(builder, kdf): builder.PrependUint8Slot(2, kdf, 2)
+def AddKdf(builder, kdf):
+    return AuthScramChallengeAddKdf(builder, kdf)
+def AuthScramChallengeAddIterations(builder, iterations): builder.PrependUint32Slot(3, iterations, 0)
+def AddIterations(builder, iterations):
+    return AuthScramChallengeAddIterations(builder, iterations)
+def AuthScramChallengeAddMemory(builder, memory): builder.PrependUint32Slot(4, memory, 0)
+def AddMemory(builder, memory):
+    return AuthScramChallengeAddMemory(builder, memory)
+def AuthScramChallengeAddChannelBinding(builder, channelBinding): builder.PrependUint8Slot(5, channelBinding, 0)
+def AddChannelBinding(builder, channelBinding):
+    return AuthScramChallengeAddChannelBinding(builder, channelBinding)
+def AuthScramChallengeEnd(builder): return builder.EndObject()
+def End(builder):
+    return AuthScramChallengeEnd(builder)

backend/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/proto/AuthScramRequest.py

@@ -0,0 +1,52 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: proto
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+class AuthScramRequest(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = AuthScramRequest()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsAuthScramRequest(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    # AuthScramRequest
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # AuthScramRequest
+    def Nonce(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # AuthScramRequest
+    def ChannelBinding(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
+        return 0
+
+def AuthScramRequestStart(builder): builder.StartObject(2)
+def Start(builder):
+    return AuthScramRequestStart(builder)
+def AuthScramRequestAddNonce(builder, nonce): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(nonce), 0)
+def AddNonce(builder, nonce):
+    return AuthScramRequestAddNonce(builder, nonce)
+def AuthScramRequestAddChannelBinding(builder, channelBinding): builder.PrependUint8Slot(1, channelBinding, 0)
+def AddChannelBinding(builder, channelBinding):
+    return AuthScramRequestAddChannelBinding(builder, channelBinding)
+def AuthScramRequestEnd(builder): return builder.EndObject()
+def End(builder):
+    return AuthScramRequestEnd(builder)

backend/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/proto/AuthScramWelcome.py

@@ -0,0 +1,42 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: proto
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+class AuthScramWelcome(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = AuthScramWelcome()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsAuthScramWelcome(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    # AuthScramWelcome
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # AuthScramWelcome
+    def Verifier(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+def AuthScramWelcomeStart(builder): builder.StartObject(1)
+def Start(builder):
+    return AuthScramWelcomeStart(builder)
+def AuthScramWelcomeAddVerifier(builder, verifier): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(verifier), 0)
+def AddVerifier(builder, verifier):
+    return AuthScramWelcomeAddVerifier(builder, verifier)
+def AuthScramWelcomeEnd(builder): return builder.EndObject()
+def End(builder):
+    return AuthScramWelcomeEnd(builder)

backend/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/proto/AuthTicketChallenge.py

@@ -0,0 +1,32 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: proto
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+class AuthTicketChallenge(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = AuthTicketChallenge()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsAuthTicketChallenge(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    # AuthTicketChallenge
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+def AuthTicketChallengeStart(builder): builder.StartObject(0)
+def Start(builder):
+    return AuthTicketChallengeStart(builder)
+def AuthTicketChallengeEnd(builder): return builder.EndObject()
+def End(builder):
+    return AuthTicketChallengeEnd(builder)

backend/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/proto/AuthTicketRequest.py

@@ -0,0 +1,32 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: proto
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+class AuthTicketRequest(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = AuthTicketRequest()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsAuthTicketRequest(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    # AuthTicketRequest
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+def AuthTicketRequestStart(builder): builder.StartObject(0)
+def Start(builder):
+    return AuthTicketRequestStart(builder)
+def AuthTicketRequestEnd(builder): return builder.EndObject()
+def End(builder):
+    return AuthTicketRequestEnd(builder)

backend/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/proto/AuthTicketWelcome.py

@@ -0,0 +1,32 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: proto
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+class AuthTicketWelcome(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = AuthTicketWelcome()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsAuthTicketWelcome(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    # AuthTicketWelcome
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+def AuthTicketWelcomeStart(builder): builder.StartObject(0)
+def Start(builder):
+    return AuthTicketWelcomeStart(builder)
+def AuthTicketWelcomeEnd(builder): return builder.EndObject()
+def End(builder):
+    return AuthTicketWelcomeEnd(builder)

backend/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/proto/Authenticate.py

@@ -0,0 +1,66 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: proto
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+class Authenticate(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = Authenticate()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsAuthenticate(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    # Authenticate
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # Authenticate
+    def Session(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
+        return 0
+
+    # Authenticate
+    def Signature(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # Authenticate
+    def Extra(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            x = self._tab.Indirect(o + self._tab.Pos)
+            from wamp.Map import Map
+            obj = Map()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+def AuthenticateStart(builder): builder.StartObject(3)
+def Start(builder):
+    return AuthenticateStart(builder)
+def AuthenticateAddSession(builder, session): builder.PrependUint64Slot(0, session, 0)
+def AddSession(builder, session):
+    return AuthenticateAddSession(builder, session)
+def AuthenticateAddSignature(builder, signature): builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(signature), 0)
+def AddSignature(builder, signature):
+    return AuthenticateAddSignature(builder, signature)
+def AuthenticateAddExtra(builder, extra): builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(extra), 0)
+def AddExtra(builder, extra):
+    return AuthenticateAddExtra(builder, extra)
+def AuthenticateEnd(builder): return builder.EndObject()
+def End(builder):
+    return AuthenticateEnd(builder)

backend/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/proto/BrokerFeatures.py

@@ -0,0 +1,172 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: proto
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+class BrokerFeatures(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = BrokerFeatures()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsBrokerFeatures(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    # BrokerFeatures
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # BrokerFeatures
+    def PublisherIdentification(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+    # BrokerFeatures
+    def PublisherExclusion(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+    # BrokerFeatures
+    def SubscriberBlackwhiteListing(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+    # BrokerFeatures
+    def PatternBasedSubscription(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+    # BrokerFeatures
+    def PublicationTrustlevels(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+    # BrokerFeatures
+    def SubscriptionRevocation(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+    # BrokerFeatures
+    def SessionMetaApi(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+    # BrokerFeatures
+    def SubscriptionMetaApi(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+    # BrokerFeatures
+    def EventRetention(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(20))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+    # BrokerFeatures
+    def EventHistory(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+    # BrokerFeatures
+    def AcknowledgeEventReceived(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+    # BrokerFeatures
+    def AcknowledgeSubscriberReceived(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(26))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+    # BrokerFeatures
+    def PayloadTransparency(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(28))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+    # BrokerFeatures
+    def PayloadEncryptionCryptobox(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(30))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+def BrokerFeaturesStart(builder): builder.StartObject(14)
+def Start(builder):
+    return BrokerFeaturesStart(builder)
+def BrokerFeaturesAddPublisherIdentification(builder, publisherIdentification): builder.PrependBoolSlot(0, publisherIdentification, 0)
+def AddPublisherIdentification(builder, publisherIdentification):
+    return BrokerFeaturesAddPublisherIdentification(builder, publisherIdentification)
+def BrokerFeaturesAddPublisherExclusion(builder, publisherExclusion): builder.PrependBoolSlot(1, publisherExclusion, 0)
+def AddPublisherExclusion(builder, publisherExclusion):
+    return BrokerFeaturesAddPublisherExclusion(builder, publisherExclusion)
+def BrokerFeaturesAddSubscriberBlackwhiteListing(builder, subscriberBlackwhiteListing): builder.PrependBoolSlot(2, subscriberBlackwhiteListing, 0)
+def AddSubscriberBlackwhiteListing(builder, subscriberBlackwhiteListing):
+    return BrokerFeaturesAddSubscriberBlackwhiteListing(builder, subscriberBlackwhiteListing)
+def BrokerFeaturesAddPatternBasedSubscription(builder, patternBasedSubscription): builder.PrependBoolSlot(3, patternBasedSubscription, 0)
+def AddPatternBasedSubscription(builder, patternBasedSubscription):
+    return BrokerFeaturesAddPatternBasedSubscription(builder, patternBasedSubscription)
+def BrokerFeaturesAddPublicationTrustlevels(builder, publicationTrustlevels): builder.PrependBoolSlot(4, publicationTrustlevels, 0)
+def AddPublicationTrustlevels(builder, publicationTrustlevels):
+    return BrokerFeaturesAddPublicationTrustlevels(builder, publicationTrustlevels)
+def BrokerFeaturesAddSubscriptionRevocation(builder, subscriptionRevocation): builder.PrependBoolSlot(5, subscriptionRevocation, 0)
+def AddSubscriptionRevocation(builder, subscriptionRevocation):
+    return BrokerFeaturesAddSubscriptionRevocation(builder, subscriptionRevocation)
+def BrokerFeaturesAddSessionMetaApi(builder, sessionMetaApi): builder.PrependBoolSlot(6, sessionMetaApi, 0)
+def AddSessionMetaApi(builder, sessionMetaApi):
+    return BrokerFeaturesAddSessionMetaApi(builder, sessionMetaApi)
+def BrokerFeaturesAddSubscriptionMetaApi(builder, subscriptionMetaApi): builder.PrependBoolSlot(7, subscriptionMetaApi, 0)
+def AddSubscriptionMetaApi(builder, subscriptionMetaApi):
+    return BrokerFeaturesAddSubscriptionMetaApi(builder, subscriptionMetaApi)
+def BrokerFeaturesAddEventRetention(builder, eventRetention): builder.PrependBoolSlot(8, eventRetention, 0)
+def AddEventRetention(builder, eventRetention):
+    return BrokerFeaturesAddEventRetention(builder, eventRetention)
+def BrokerFeaturesAddEventHistory(builder, eventHistory): builder.PrependBoolSlot(9, eventHistory, 0)
+def AddEventHistory(builder, eventHistory):
+    return BrokerFeaturesAddEventHistory(builder, eventHistory)
+def BrokerFeaturesAddAcknowledgeEventReceived(builder, acknowledgeEventReceived): builder.PrependBoolSlot(10, acknowledgeEventReceived, 0)
+def AddAcknowledgeEventReceived(builder, acknowledgeEventReceived):
+    return BrokerFeaturesAddAcknowledgeEventReceived(builder, acknowledgeEventReceived)
+def BrokerFeaturesAddAcknowledgeSubscriberReceived(builder, acknowledgeSubscriberReceived): builder.PrependBoolSlot(11, acknowledgeSubscriberReceived, 0)
+def AddAcknowledgeSubscriberReceived(builder, acknowledgeSubscriberReceived):
+    return BrokerFeaturesAddAcknowledgeSubscriberReceived(builder, acknowledgeSubscriberReceived)
+def BrokerFeaturesAddPayloadTransparency(builder, payloadTransparency): builder.PrependBoolSlot(12, payloadTransparency, 0)
+def AddPayloadTransparency(builder, payloadTransparency):
+    return BrokerFeaturesAddPayloadTransparency(builder, payloadTransparency)
+def BrokerFeaturesAddPayloadEncryptionCryptobox(builder, payloadEncryptionCryptobox): builder.PrependBoolSlot(13, payloadEncryptionCryptobox, 0)
+def AddPayloadEncryptionCryptobox(builder, payloadEncryptionCryptobox):
+    return BrokerFeaturesAddPayloadEncryptionCryptobox(builder, payloadEncryptionCryptobox)
+def BrokerFeaturesEnd(builder): return builder.EndObject()
+def End(builder):
+    return BrokerFeaturesEnd(builder)

backend/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/proto/Call.py

@@ -0,0 +1,238 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: proto
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+class Call(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = Call()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsCall(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    # Call
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # Call
+    def Session(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
+        return 0
+
+    # Call
+    def Request(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
+        return 0
+
+    # Call
+    def Procedure(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # Call
+    def Payload(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        if o != 0:
+            a = self._tab.Vector(o)
+            return self._tab.Get(flatbuffers.number_types.Uint8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1))
+        return 0
+
+    # Call
+    def PayloadAsNumpy(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        if o != 0:
+            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o)
+        return 0
+
+    # Call
+    def PayloadLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # Call
+    def PayloadIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        return o == 0
+
+    # Call
+    def EncAlgo(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
+        return 0
+
+    # Call
+    def EncSerializer(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
+        return 0
+
+    # Call
+    def EncKey(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16))
+        if o != 0:
+            a = self._tab.Vector(o)
+            return self._tab.Get(flatbuffers.number_types.Uint8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1))
+        return 0
+
+    # Call
+    def EncKeyAsNumpy(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16))
+        if o != 0:
+            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o)
+        return 0
+
+    # Call
+    def EncKeyLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # Call
+    def EncKeyIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16))
+        return o == 0
+
+    # Call
+    def Timeout(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos)
+        return 0
+
+    # Call
+    def ReceiveProgress(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(20))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+    # Call
+    def TransactionHash(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # Call
+    def Caller(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
+        return 0
+
+    # Call
+    def CallerAuthid(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(26))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # Call
+    def CallerAuthrole(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(28))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # Call
+    def ForwardFor(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(30))
+        if o != 0:
+            x = self._tab.Vector(o)
+            x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 8
+            from wamp.proto.Principal import Principal
+            obj = Principal()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+    # Call
+    def ForwardForLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(30))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # Call
+    def ForwardForIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(30))
+        return o == 0
+
+def CallStart(builder): builder.StartObject(14)
+def Start(builder):
+    return CallStart(builder)
+def CallAddSession(builder, session): builder.PrependUint64Slot(0, session, 0)
+def AddSession(builder, session):
+    return CallAddSession(builder, session)
+def CallAddRequest(builder, request): builder.PrependUint64Slot(1, request, 0)
+def AddRequest(builder, request):
+    return CallAddRequest(builder, request)
+def CallAddProcedure(builder, procedure): builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(procedure), 0)
+def AddProcedure(builder, procedure):
+    return CallAddProcedure(builder, procedure)
+def CallAddPayload(builder, payload): builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(payload), 0)
+def AddPayload(builder, payload):
+    return CallAddPayload(builder, payload)
+def CallStartPayloadVector(builder, numElems): return builder.StartVector(1, numElems, 1)
+def StartPayloadVector(builder, numElems):
+    return CallStartPayloadVector(builder, numElems)
+def CallAddEncAlgo(builder, encAlgo): builder.PrependUint8Slot(4, encAlgo, 0)
+def AddEncAlgo(builder, encAlgo):
+    return CallAddEncAlgo(builder, encAlgo)
+def CallAddEncSerializer(builder, encSerializer): builder.PrependUint8Slot(5, encSerializer, 0)
+def AddEncSerializer(builder, encSerializer):
+    return CallAddEncSerializer(builder, encSerializer)
+def CallAddEncKey(builder, encKey): builder.PrependUOffsetTRelativeSlot(6, flatbuffers.number_types.UOffsetTFlags.py_type(encKey), 0)
+def AddEncKey(builder, encKey):
+    return CallAddEncKey(builder, encKey)
+def CallStartEncKeyVector(builder, numElems): return builder.StartVector(1, numElems, 1)
+def StartEncKeyVector(builder, numElems):
+    return CallStartEncKeyVector(builder, numElems)
+def CallAddTimeout(builder, timeout): builder.PrependUint32Slot(7, timeout, 0)
+def AddTimeout(builder, timeout):
+    return CallAddTimeout(builder, timeout)
+def CallAddReceiveProgress(builder, receiveProgress): builder.PrependBoolSlot(8, receiveProgress, 0)
+def AddReceiveProgress(builder, receiveProgress):
+    return CallAddReceiveProgress(builder, receiveProgress)
+def CallAddTransactionHash(builder, transactionHash): builder.PrependUOffsetTRelativeSlot(9, flatbuffers.number_types.UOffsetTFlags.py_type(transactionHash), 0)
+def AddTransactionHash(builder, transactionHash):
+    return CallAddTransactionHash(builder, transactionHash)
+def CallAddCaller(builder, caller): builder.PrependUint64Slot(10, caller, 0)
+def AddCaller(builder, caller):
+    return CallAddCaller(builder, caller)
+def CallAddCallerAuthid(builder, callerAuthid): builder.PrependUOffsetTRelativeSlot(11, flatbuffers.number_types.UOffsetTFlags.py_type(callerAuthid), 0)
+def AddCallerAuthid(builder, callerAuthid):
+    return CallAddCallerAuthid(builder, callerAuthid)
+def CallAddCallerAuthrole(builder, callerAuthrole): builder.PrependUOffsetTRelativeSlot(12, flatbuffers.number_types.UOffsetTFlags.py_type(callerAuthrole), 0)
+def AddCallerAuthrole(builder, callerAuthrole):
+    return CallAddCallerAuthrole(builder, callerAuthrole)
+def CallAddForwardFor(builder, forwardFor): builder.PrependUOffsetTRelativeSlot(13, flatbuffers.number_types.UOffsetTFlags.py_type(forwardFor), 0)
+def AddForwardFor(builder, forwardFor):
+    return CallAddForwardFor(builder, forwardFor)
+def CallStartForwardForVector(builder, numElems): return builder.StartVector(8, numElems, 8)
+def StartForwardForVector(builder, numElems):
+    return CallStartForwardForVector(builder, numElems)
+def CallEnd(builder): return builder.EndObject()
+def End(builder):
+    return CallEnd(builder)

backend/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/proto/CalleeFeatures.py

@@ -0,0 +1,132 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: proto
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+class CalleeFeatures(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = CalleeFeatures()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsCalleeFeatures(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    # CalleeFeatures
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # CalleeFeatures
+    def CallerIdentification(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+    # CalleeFeatures
+    def CallTrustlevels(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+    # CalleeFeatures
+    def CallTimeout(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+    # CalleeFeatures
+    def CallCanceling(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+    # CalleeFeatures
+    def ProgressiveCallResults(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+    # CalleeFeatures
+    def RegistrationRevocation(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+    # CalleeFeatures
+    def PatternBasedRegistration(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+    # CalleeFeatures
+    def SharedRegistration(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+    # CalleeFeatures
+    def PayloadTransparency(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(20))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+    # CalleeFeatures
+    def PayloadEncryptionCryptobox(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+def CalleeFeaturesStart(builder): builder.StartObject(10)
+def Start(builder):
+    return CalleeFeaturesStart(builder)
+def CalleeFeaturesAddCallerIdentification(builder, callerIdentification): builder.PrependBoolSlot(0, callerIdentification, 0)
+def AddCallerIdentification(builder, callerIdentification):
+    return CalleeFeaturesAddCallerIdentification(builder, callerIdentification)
+def CalleeFeaturesAddCallTrustlevels(builder, callTrustlevels): builder.PrependBoolSlot(1, callTrustlevels, 0)
+def AddCallTrustlevels(builder, callTrustlevels):
+    return CalleeFeaturesAddCallTrustlevels(builder, callTrustlevels)
+def CalleeFeaturesAddCallTimeout(builder, callTimeout): builder.PrependBoolSlot(2, callTimeout, 0)
+def AddCallTimeout(builder, callTimeout):
+    return CalleeFeaturesAddCallTimeout(builder, callTimeout)
+def CalleeFeaturesAddCallCanceling(builder, callCanceling): builder.PrependBoolSlot(3, callCanceling, 0)
+def AddCallCanceling(builder, callCanceling):
+    return CalleeFeaturesAddCallCanceling(builder, callCanceling)
+def CalleeFeaturesAddProgressiveCallResults(builder, progressiveCallResults): builder.PrependBoolSlot(4, progressiveCallResults, 0)
+def AddProgressiveCallResults(builder, progressiveCallResults):
+    return CalleeFeaturesAddProgressiveCallResults(builder, progressiveCallResults)
+def CalleeFeaturesAddRegistrationRevocation(builder, registrationRevocation): builder.PrependBoolSlot(5, registrationRevocation, 0)
+def AddRegistrationRevocation(builder, registrationRevocation):
+    return CalleeFeaturesAddRegistrationRevocation(builder, registrationRevocation)
+def CalleeFeaturesAddPatternBasedRegistration(builder, patternBasedRegistration): builder.PrependBoolSlot(6, patternBasedRegistration, 0)
+def AddPatternBasedRegistration(builder, patternBasedRegistration):
+    return CalleeFeaturesAddPatternBasedRegistration(builder, patternBasedRegistration)
+def CalleeFeaturesAddSharedRegistration(builder, sharedRegistration): builder.PrependBoolSlot(7, sharedRegistration, 0)
+def AddSharedRegistration(builder, sharedRegistration):
+    return CalleeFeaturesAddSharedRegistration(builder, sharedRegistration)
+def CalleeFeaturesAddPayloadTransparency(builder, payloadTransparency): builder.PrependBoolSlot(8, payloadTransparency, 0)
+def AddPayloadTransparency(builder, payloadTransparency):
+    return CalleeFeaturesAddPayloadTransparency(builder, payloadTransparency)
+def CalleeFeaturesAddPayloadEncryptionCryptobox(builder, payloadEncryptionCryptobox): builder.PrependBoolSlot(9, payloadEncryptionCryptobox, 0)
+def AddPayloadEncryptionCryptobox(builder, payloadEncryptionCryptobox):
+    return CalleeFeaturesAddPayloadEncryptionCryptobox(builder, payloadEncryptionCryptobox)
+def CalleeFeaturesEnd(builder): return builder.EndObject()
+def End(builder):
+    return CalleeFeaturesEnd(builder)

backend/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/proto/CallerFeatures.py

@@ -0,0 +1,92 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: proto
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+class CallerFeatures(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = CallerFeatures()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsCallerFeatures(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    # CallerFeatures
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # CallerFeatures
+    def CallerIdentification(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+    # CallerFeatures
+    def CallTimeout(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+    # CallerFeatures
+    def CallCanceling(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+    # CallerFeatures
+    def ProgressiveCallResults(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+    # CallerFeatures
+    def PayloadTransparency(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+    # CallerFeatures
+    def PayloadEncryptionCryptobox(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+def CallerFeaturesStart(builder): builder.StartObject(6)
+def Start(builder):
+    return CallerFeaturesStart(builder)
+def CallerFeaturesAddCallerIdentification(builder, callerIdentification): builder.PrependBoolSlot(0, callerIdentification, 0)
+def AddCallerIdentification(builder, callerIdentification):
+    return CallerFeaturesAddCallerIdentification(builder, callerIdentification)
+def CallerFeaturesAddCallTimeout(builder, callTimeout): builder.PrependBoolSlot(1, callTimeout, 0)
+def AddCallTimeout(builder, callTimeout):
+    return CallerFeaturesAddCallTimeout(builder, callTimeout)
+def CallerFeaturesAddCallCanceling(builder, callCanceling): builder.PrependBoolSlot(2, callCanceling, 0)
+def AddCallCanceling(builder, callCanceling):
+    return CallerFeaturesAddCallCanceling(builder, callCanceling)
+def CallerFeaturesAddProgressiveCallResults(builder, progressiveCallResults): builder.PrependBoolSlot(3, progressiveCallResults, 0)
+def AddProgressiveCallResults(builder, progressiveCallResults):
+    return CallerFeaturesAddProgressiveCallResults(builder, progressiveCallResults)
+def CallerFeaturesAddPayloadTransparency(builder, payloadTransparency): builder.PrependBoolSlot(4, payloadTransparency, 0)
+def AddPayloadTransparency(builder, payloadTransparency):
+    return CallerFeaturesAddPayloadTransparency(builder, payloadTransparency)
+def CallerFeaturesAddPayloadEncryptionCryptobox(builder, payloadEncryptionCryptobox): builder.PrependBoolSlot(5, payloadEncryptionCryptobox, 0)
+def AddPayloadEncryptionCryptobox(builder, payloadEncryptionCryptobox):
+    return CallerFeaturesAddPayloadEncryptionCryptobox(builder, payloadEncryptionCryptobox)
+def CallerFeaturesEnd(builder): return builder.EndObject()
+def End(builder):
+    return CallerFeaturesEnd(builder)

backend/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/proto/Cancel.py

@@ -0,0 +1,92 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: proto
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+class Cancel(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = Cancel()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsCancel(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    # Cancel
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # Cancel
+    def Session(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
+        return 0
+
+    # Cancel
+    def Request(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
+        return 0
+
+    # Cancel
+    def Mode(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
+        return 0
+
+    # Cancel
+    def ForwardFor(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        if o != 0:
+            x = self._tab.Vector(o)
+            x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 8
+            from wamp.proto.Principal import Principal
+            obj = Principal()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+    # Cancel
+    def ForwardForLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # Cancel
+    def ForwardForIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        return o == 0
+
+def CancelStart(builder): builder.StartObject(4)
+def Start(builder):
+    return CancelStart(builder)
+def CancelAddSession(builder, session): builder.PrependUint64Slot(0, session, 0)
+def AddSession(builder, session):
+    return CancelAddSession(builder, session)
+def CancelAddRequest(builder, request): builder.PrependUint64Slot(1, request, 0)
+def AddRequest(builder, request):
+    return CancelAddRequest(builder, request)
+def CancelAddMode(builder, mode): builder.PrependUint8Slot(2, mode, 0)
+def AddMode(builder, mode):
+    return CancelAddMode(builder, mode)
+def CancelAddForwardFor(builder, forwardFor): builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(forwardFor), 0)
+def AddForwardFor(builder, forwardFor):
+    return CancelAddForwardFor(builder, forwardFor)
+def CancelStartForwardForVector(builder, numElems): return builder.StartVector(8, numElems, 8)
+def StartForwardForVector(builder, numElems):
+    return CancelStartForwardForVector(builder, numElems)
+def CancelEnd(builder): return builder.EndObject()
+def End(builder):
+    return CancelEnd(builder)

backend/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/proto/CancelMode.py

@@ -0,0 +1,8 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: proto
+
+class CancelMode(object):
+    SKIP = 0
+    ABORT = 1
+    KILL = 2

backend/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/proto/Challenge.py

@@ -0,0 +1,66 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: proto
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+class Challenge(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = Challenge()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsChallenge(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    # Challenge
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # Challenge
+    def Session(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
+        return 0
+
+    # Challenge
+    def Method(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
+        return 0
+
+    # Challenge
+    def Extra(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            x = self._tab.Indirect(o + self._tab.Pos)
+            from wamp.Map import Map
+            obj = Map()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+def ChallengeStart(builder): builder.StartObject(3)
+def Start(builder):
+    return ChallengeStart(builder)
+def ChallengeAddSession(builder, session): builder.PrependUint64Slot(0, session, 0)
+def AddSession(builder, session):
+    return ChallengeAddSession(builder, session)
+def ChallengeAddMethod(builder, method): builder.PrependUint8Slot(1, method, 0)
+def AddMethod(builder, method):
+    return ChallengeAddMethod(builder, method)
+def ChallengeAddExtra(builder, extra): builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(extra), 0)
+def AddExtra(builder, extra):
+    return ChallengeAddExtra(builder, extra)
+def ChallengeEnd(builder): return builder.EndObject()
+def End(builder):
+    return ChallengeEnd(builder)

backend/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/proto/ChannelBinding.py

@@ -0,0 +1,7 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: proto
+
+class ChannelBinding(object):
+    NONE = 0
+    TLS_UNIQUE = 1

backend/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/proto/ClientRoles.py

@@ -0,0 +1,88 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: proto
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+class ClientRoles(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = ClientRoles()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsClientRoles(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    # ClientRoles
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # ClientRoles
+    def Publisher(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            x = self._tab.Indirect(o + self._tab.Pos)
+            from wamp.proto.PublisherFeatures import PublisherFeatures
+            obj = PublisherFeatures()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+    # ClientRoles
+    def Subscriber(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            x = self._tab.Indirect(o + self._tab.Pos)
+            from wamp.proto.SubscriberFeatures import SubscriberFeatures
+            obj = SubscriberFeatures()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+    # ClientRoles
+    def Caller(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            x = self._tab.Indirect(o + self._tab.Pos)
+            from wamp.proto.CallerFeatures import CallerFeatures
+            obj = CallerFeatures()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+    # ClientRoles
+    def Callee(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        if o != 0:
+            x = self._tab.Indirect(o + self._tab.Pos)
+            from wamp.proto.CalleeFeatures import CalleeFeatures
+            obj = CalleeFeatures()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+def ClientRolesStart(builder): builder.StartObject(4)
+def Start(builder):
+    return ClientRolesStart(builder)
+def ClientRolesAddPublisher(builder, publisher): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(publisher), 0)
+def AddPublisher(builder, publisher):
+    return ClientRolesAddPublisher(builder, publisher)
+def ClientRolesAddSubscriber(builder, subscriber): builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(subscriber), 0)
+def AddSubscriber(builder, subscriber):
+    return ClientRolesAddSubscriber(builder, subscriber)
+def ClientRolesAddCaller(builder, caller): builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(caller), 0)
+def AddCaller(builder, caller):
+    return ClientRolesAddCaller(builder, caller)
+def ClientRolesAddCallee(builder, callee): builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(callee), 0)
+def AddCallee(builder, callee):
+    return ClientRolesAddCallee(builder, callee)
+def ClientRolesEnd(builder): return builder.EndObject()
+def End(builder):
+    return ClientRolesEnd(builder)

backend/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/proto/DealerFeatures.py

@@ -0,0 +1,162 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: proto
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+class DealerFeatures(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = DealerFeatures()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsDealerFeatures(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    # DealerFeatures
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # DealerFeatures
+    def CallerIdentification(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+    # DealerFeatures
+    def CallTrustlevels(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+    # DealerFeatures
+    def CallTimeout(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+    # DealerFeatures
+    def CallCanceling(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+    # DealerFeatures
+    def ProgressiveCallResults(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+    # DealerFeatures
+    def RegistrationRevocation(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+    # DealerFeatures
+    def PatternBasedRegistration(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+    # DealerFeatures
+    def SharedRegistration(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+    # DealerFeatures
+    def SessionMetaApi(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(20))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+    # DealerFeatures
+    def RegistrationMetaApi(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+    # DealerFeatures
+    def TestamentMetaApi(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+    # DealerFeatures
+    def PayloadTransparency(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(26))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+    # DealerFeatures
+    def PayloadEncryptionCryptobox(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(28))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+def DealerFeaturesStart(builder): builder.StartObject(13)
+def Start(builder):
+    return DealerFeaturesStart(builder)
+def DealerFeaturesAddCallerIdentification(builder, callerIdentification): builder.PrependBoolSlot(0, callerIdentification, 0)
+def AddCallerIdentification(builder, callerIdentification):
+    return DealerFeaturesAddCallerIdentification(builder, callerIdentification)
+def DealerFeaturesAddCallTrustlevels(builder, callTrustlevels): builder.PrependBoolSlot(1, callTrustlevels, 0)
+def AddCallTrustlevels(builder, callTrustlevels):
+    return DealerFeaturesAddCallTrustlevels(builder, callTrustlevels)
+def DealerFeaturesAddCallTimeout(builder, callTimeout): builder.PrependBoolSlot(2, callTimeout, 0)
+def AddCallTimeout(builder, callTimeout):
+    return DealerFeaturesAddCallTimeout(builder, callTimeout)
+def DealerFeaturesAddCallCanceling(builder, callCanceling): builder.PrependBoolSlot(3, callCanceling, 0)
+def AddCallCanceling(builder, callCanceling):
+    return DealerFeaturesAddCallCanceling(builder, callCanceling)
+def DealerFeaturesAddProgressiveCallResults(builder, progressiveCallResults): builder.PrependBoolSlot(4, progressiveCallResults, 0)
+def AddProgressiveCallResults(builder, progressiveCallResults):
+    return DealerFeaturesAddProgressiveCallResults(builder, progressiveCallResults)
+def DealerFeaturesAddRegistrationRevocation(builder, registrationRevocation): builder.PrependBoolSlot(5, registrationRevocation, 0)
+def AddRegistrationRevocation(builder, registrationRevocation):
+    return DealerFeaturesAddRegistrationRevocation(builder, registrationRevocation)
+def DealerFeaturesAddPatternBasedRegistration(builder, patternBasedRegistration): builder.PrependBoolSlot(6, patternBasedRegistration, 0)
+def AddPatternBasedRegistration(builder, patternBasedRegistration):
+    return DealerFeaturesAddPatternBasedRegistration(builder, patternBasedRegistration)
+def DealerFeaturesAddSharedRegistration(builder, sharedRegistration): builder.PrependBoolSlot(7, sharedRegistration, 0)
+def AddSharedRegistration(builder, sharedRegistration):
+    return DealerFeaturesAddSharedRegistration(builder, sharedRegistration)
+def DealerFeaturesAddSessionMetaApi(builder, sessionMetaApi): builder.PrependBoolSlot(8, sessionMetaApi, 0)
+def AddSessionMetaApi(builder, sessionMetaApi):
+    return DealerFeaturesAddSessionMetaApi(builder, sessionMetaApi)
+def DealerFeaturesAddRegistrationMetaApi(builder, registrationMetaApi): builder.PrependBoolSlot(9, registrationMetaApi, 0)
+def AddRegistrationMetaApi(builder, registrationMetaApi):
+    return DealerFeaturesAddRegistrationMetaApi(builder, registrationMetaApi)
+def DealerFeaturesAddTestamentMetaApi(builder, testamentMetaApi): builder.PrependBoolSlot(10, testamentMetaApi, 0)
+def AddTestamentMetaApi(builder, testamentMetaApi):
+    return DealerFeaturesAddTestamentMetaApi(builder, testamentMetaApi)
+def DealerFeaturesAddPayloadTransparency(builder, payloadTransparency): builder.PrependBoolSlot(11, payloadTransparency, 0)
+def AddPayloadTransparency(builder, payloadTransparency):
+    return DealerFeaturesAddPayloadTransparency(builder, payloadTransparency)
+def DealerFeaturesAddPayloadEncryptionCryptobox(builder, payloadEncryptionCryptobox): builder.PrependBoolSlot(12, payloadEncryptionCryptobox, 0)
+def AddPayloadEncryptionCryptobox(builder, payloadEncryptionCryptobox):
+    return DealerFeaturesAddPayloadEncryptionCryptobox(builder, payloadEncryptionCryptobox)
+def DealerFeaturesEnd(builder): return builder.EndObject()
+def End(builder):
+    return DealerFeaturesEnd(builder)

backend/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/proto/Error.py

@@ -0,0 +1,158 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: proto
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+class Error(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = Error()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsError(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    # Error
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # Error
+    def Session(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
+        return 0
+
+    # Error
+    def RequestType(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint16Flags, o + self._tab.Pos)
+        return 0
+
+    # Error
+    def Request(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
+        return 0
+
+    # Error
+    def Error(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # Error
+    def Payload(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
+        if o != 0:
+            a = self._tab.Vector(o)
+            return self._tab.Get(flatbuffers.number_types.Uint8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1))
+        return 0
+
+    # Error
+    def PayloadAsNumpy(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
+        if o != 0:
+            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o)
+        return 0
+
+    # Error
+    def PayloadLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # Error
+    def PayloadIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
+        return o == 0
+
+    # Error
+    def EncAlgo(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
+        return 0
+
+    # Error
+    def EncSerializer(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
+        return 0
+
+    # Error
+    def EncKey(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18))
+        if o != 0:
+            a = self._tab.Vector(o)
+            return self._tab.Get(flatbuffers.number_types.Uint8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1))
+        return 0
+
+    # Error
+    def EncKeyAsNumpy(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18))
+        if o != 0:
+            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o)
+        return 0
+
+    # Error
+    def EncKeyLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # Error
+    def EncKeyIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18))
+        return o == 0
+
+def ErrorStart(builder): builder.StartObject(8)
+def Start(builder):
+    return ErrorStart(builder)
+def ErrorAddSession(builder, session): builder.PrependUint64Slot(0, session, 0)
+def AddSession(builder, session):
+    return ErrorAddSession(builder, session)
+def ErrorAddRequestType(builder, requestType): builder.PrependUint16Slot(1, requestType, 0)
+def AddRequestType(builder, requestType):
+    return ErrorAddRequestType(builder, requestType)
+def ErrorAddRequest(builder, request): builder.PrependUint64Slot(2, request, 0)
+def AddRequest(builder, request):
+    return ErrorAddRequest(builder, request)
+def ErrorAddError(builder, error): builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(error), 0)
+def AddError(builder, error):
+    return ErrorAddError(builder, error)
+def ErrorAddPayload(builder, payload): builder.PrependUOffsetTRelativeSlot(4, flatbuffers.number_types.UOffsetTFlags.py_type(payload), 0)
+def AddPayload(builder, payload):
+    return ErrorAddPayload(builder, payload)
+def ErrorStartPayloadVector(builder, numElems): return builder.StartVector(1, numElems, 1)
+def StartPayloadVector(builder, numElems):
+    return ErrorStartPayloadVector(builder, numElems)
+def ErrorAddEncAlgo(builder, encAlgo): builder.PrependUint8Slot(5, encAlgo, 0)
+def AddEncAlgo(builder, encAlgo):
+    return ErrorAddEncAlgo(builder, encAlgo)
+def ErrorAddEncSerializer(builder, encSerializer): builder.PrependUint8Slot(6, encSerializer, 0)
+def AddEncSerializer(builder, encSerializer):
+    return ErrorAddEncSerializer(builder, encSerializer)
+def ErrorAddEncKey(builder, encKey): builder.PrependUOffsetTRelativeSlot(7, flatbuffers.number_types.UOffsetTFlags.py_type(encKey), 0)
+def AddEncKey(builder, encKey):
+    return ErrorAddEncKey(builder, encKey)
+def ErrorStartEncKeyVector(builder, numElems): return builder.StartVector(1, numElems, 1)
+def StartEncKeyVector(builder, numElems):
+    return ErrorStartEncKeyVector(builder, numElems)
+def ErrorEnd(builder): return builder.EndObject()
+def End(builder):
+    return ErrorEnd(builder)

backend/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/proto/Event.py

@@ -0,0 +1,317 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: proto
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+class Event(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = Event()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsEvent(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    # Event
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # Event
+    def Session(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
+        return 0
+
+    # Event
+    def Subscription(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
+        return 0
+
+    # Event
+    def Publication(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
+        return 0
+
+    # Positional values for application-defined event payload.
+    # Event
+    def Args(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        if o != 0:
+            a = self._tab.Vector(o)
+            return self._tab.Get(flatbuffers.number_types.Uint8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1))
+        return 0
+
+    # Event
+    def ArgsAsNumpy(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        if o != 0:
+            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o)
+        return 0
+
+    # Event
+    def ArgsLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # Event
+    def ArgsIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        return o == 0
+
+    # Keyword values for application-defined event payload.
+    # Event
+    def Kwargs(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
+        if o != 0:
+            a = self._tab.Vector(o)
+            return self._tab.Get(flatbuffers.number_types.Uint8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1))
+        return 0
+
+    # Event
+    def KwargsAsNumpy(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
+        if o != 0:
+            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o)
+        return 0
+
+    # Event
+    def KwargsLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # Event
+    def KwargsIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
+        return o == 0
+
+    # Alternative, transparent payload. If given, ``args`` and ``kwargs`` must be left unset.
+    # Event
+    def Payload(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
+        if o != 0:
+            a = self._tab.Vector(o)
+            return self._tab.Get(flatbuffers.number_types.Uint8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1))
+        return 0
+
+    # Event
+    def PayloadAsNumpy(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
+        if o != 0:
+            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o)
+        return 0
+
+    # Event
+    def PayloadLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # Event
+    def PayloadIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
+        return o == 0
+
+    # Event
+    def EncAlgo(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
+        return 0
+
+    # Event
+    def EncSerializer(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
+        return 0
+
+    # Event
+    def EncKey(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(20))
+        if o != 0:
+            a = self._tab.Vector(o)
+            return self._tab.Get(flatbuffers.number_types.Uint8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1))
+        return 0
+
+    # Event
+    def EncKeyAsNumpy(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(20))
+        if o != 0:
+            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o)
+        return 0
+
+    # Event
+    def EncKeyLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(20))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # Event
+    def EncKeyIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(20))
+        return o == 0
+
+    # Event
+    def Publisher(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
+        return 0
+
+    # Event
+    def PublisherAuthid(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # Event
+    def PublisherAuthrole(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(26))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # Event
+    def Topic(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(28))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # Event
+    def Retained(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(30))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+    # Event
+    def TransactionHash(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(32))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # Event
+    def Acknowledge(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(34))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+    # Event
+    def ForwardFor(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(36))
+        if o != 0:
+            x = self._tab.Vector(o)
+            x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 8
+            from wamp.proto.Principal import Principal
+            obj = Principal()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+    # Event
+    def ForwardForLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(36))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # Event
+    def ForwardForIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(36))
+        return o == 0
+
+def EventStart(builder): builder.StartObject(17)
+def Start(builder):
+    return EventStart(builder)
+def EventAddSession(builder, session): builder.PrependUint64Slot(0, session, 0)
+def AddSession(builder, session):
+    return EventAddSession(builder, session)
+def EventAddSubscription(builder, subscription): builder.PrependUint64Slot(1, subscription, 0)
+def AddSubscription(builder, subscription):
+    return EventAddSubscription(builder, subscription)
+def EventAddPublication(builder, publication): builder.PrependUint64Slot(2, publication, 0)
+def AddPublication(builder, publication):
+    return EventAddPublication(builder, publication)
+def EventAddArgs(builder, args): builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(args), 0)
+def AddArgs(builder, args):
+    return EventAddArgs(builder, args)
+def EventStartArgsVector(builder, numElems): return builder.StartVector(1, numElems, 1)
+def StartArgsVector(builder, numElems):
+    return EventStartArgsVector(builder, numElems)
+def EventAddKwargs(builder, kwargs): builder.PrependUOffsetTRelativeSlot(4, flatbuffers.number_types.UOffsetTFlags.py_type(kwargs), 0)
+def AddKwargs(builder, kwargs):
+    return EventAddKwargs(builder, kwargs)
+def EventStartKwargsVector(builder, numElems): return builder.StartVector(1, numElems, 1)
+def StartKwargsVector(builder, numElems):
+    return EventStartKwargsVector(builder, numElems)
+def EventAddPayload(builder, payload): builder.PrependUOffsetTRelativeSlot(5, flatbuffers.number_types.UOffsetTFlags.py_type(payload), 0)
+def AddPayload(builder, payload):
+    return EventAddPayload(builder, payload)
+def EventStartPayloadVector(builder, numElems): return builder.StartVector(1, numElems, 1)
+def StartPayloadVector(builder, numElems):
+    return EventStartPayloadVector(builder, numElems)
+def EventAddEncAlgo(builder, encAlgo): builder.PrependUint8Slot(6, encAlgo, 0)
+def AddEncAlgo(builder, encAlgo):
+    return EventAddEncAlgo(builder, encAlgo)
+def EventAddEncSerializer(builder, encSerializer): builder.PrependUint8Slot(7, encSerializer, 0)
+def AddEncSerializer(builder, encSerializer):
+    return EventAddEncSerializer(builder, encSerializer)
+def EventAddEncKey(builder, encKey): builder.PrependUOffsetTRelativeSlot(8, flatbuffers.number_types.UOffsetTFlags.py_type(encKey), 0)
+def AddEncKey(builder, encKey):
+    return EventAddEncKey(builder, encKey)
+def EventStartEncKeyVector(builder, numElems): return builder.StartVector(1, numElems, 1)
+def StartEncKeyVector(builder, numElems):
+    return EventStartEncKeyVector(builder, numElems)
+def EventAddPublisher(builder, publisher): builder.PrependUint64Slot(9, publisher, 0)
+def AddPublisher(builder, publisher):
+    return EventAddPublisher(builder, publisher)
+def EventAddPublisherAuthid(builder, publisherAuthid): builder.PrependUOffsetTRelativeSlot(10, flatbuffers.number_types.UOffsetTFlags.py_type(publisherAuthid), 0)
+def AddPublisherAuthid(builder, publisherAuthid):
+    return EventAddPublisherAuthid(builder, publisherAuthid)
+def EventAddPublisherAuthrole(builder, publisherAuthrole): builder.PrependUOffsetTRelativeSlot(11, flatbuffers.number_types.UOffsetTFlags.py_type(publisherAuthrole), 0)
+def AddPublisherAuthrole(builder, publisherAuthrole):
+    return EventAddPublisherAuthrole(builder, publisherAuthrole)
+def EventAddTopic(builder, topic): builder.PrependUOffsetTRelativeSlot(12, flatbuffers.number_types.UOffsetTFlags.py_type(topic), 0)
+def AddTopic(builder, topic):
+    return EventAddTopic(builder, topic)
+def EventAddRetained(builder, retained): builder.PrependBoolSlot(13, retained, 0)
+def AddRetained(builder, retained):
+    return EventAddRetained(builder, retained)
+def EventAddTransactionHash(builder, transactionHash): builder.PrependUOffsetTRelativeSlot(14, flatbuffers.number_types.UOffsetTFlags.py_type(transactionHash), 0)
+def AddTransactionHash(builder, transactionHash):
+    return EventAddTransactionHash(builder, transactionHash)
+def EventAddAcknowledge(builder, acknowledge): builder.PrependBoolSlot(15, acknowledge, 0)
+def AddAcknowledge(builder, acknowledge):
+    return EventAddAcknowledge(builder, acknowledge)
+def EventAddForwardFor(builder, forwardFor): builder.PrependUOffsetTRelativeSlot(16, flatbuffers.number_types.UOffsetTFlags.py_type(forwardFor), 0)
+def AddForwardFor(builder, forwardFor):
+    return EventAddForwardFor(builder, forwardFor)
+def EventStartForwardForVector(builder, numElems): return builder.StartVector(8, numElems, 8)
+def StartForwardForVector(builder, numElems):
+    return EventStartForwardForVector(builder, numElems)
+def EventEnd(builder): return builder.EndObject()
+def End(builder):
+    return EventEnd(builder)

backend/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/proto/EventReceived.py

@@ -0,0 +1,138 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: proto
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+class EventReceived(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = EventReceived()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsEventReceived(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    # EventReceived
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # EventReceived
+    def Session(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
+        return 0
+
+    # EventReceived
+    def Publication(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
+        return 0
+
+    # EventReceived
+    def Payload(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            a = self._tab.Vector(o)
+            return self._tab.Get(flatbuffers.number_types.Uint8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1))
+        return 0
+
+    # EventReceived
+    def PayloadAsNumpy(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o)
+        return 0
+
+    # EventReceived
+    def PayloadLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # EventReceived
+    def PayloadIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        return o == 0
+
+    # EventReceived
+    def EncAlgo(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
+        return 0
+
+    # EventReceived
+    def EncSerializer(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
+        return 0
+
+    # EventReceived
+    def EncKey(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
+        if o != 0:
+            a = self._tab.Vector(o)
+            return self._tab.Get(flatbuffers.number_types.Uint8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1))
+        return 0
+
+    # EventReceived
+    def EncKeyAsNumpy(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
+        if o != 0:
+            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o)
+        return 0
+
+    # EventReceived
+    def EncKeyLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # EventReceived
+    def EncKeyIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
+        return o == 0
+
+def EventReceivedStart(builder): builder.StartObject(6)
+def Start(builder):
+    return EventReceivedStart(builder)
+def EventReceivedAddSession(builder, session): builder.PrependUint64Slot(0, session, 0)
+def AddSession(builder, session):
+    return EventReceivedAddSession(builder, session)
+def EventReceivedAddPublication(builder, publication): builder.PrependUint64Slot(1, publication, 0)
+def AddPublication(builder, publication):
+    return EventReceivedAddPublication(builder, publication)
+def EventReceivedAddPayload(builder, payload): builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(payload), 0)
+def AddPayload(builder, payload):
+    return EventReceivedAddPayload(builder, payload)
+def EventReceivedStartPayloadVector(builder, numElems): return builder.StartVector(1, numElems, 1)
+def StartPayloadVector(builder, numElems):
+    return EventReceivedStartPayloadVector(builder, numElems)
+def EventReceivedAddEncAlgo(builder, encAlgo): builder.PrependUint8Slot(3, encAlgo, 0)
+def AddEncAlgo(builder, encAlgo):
+    return EventReceivedAddEncAlgo(builder, encAlgo)
+def EventReceivedAddEncSerializer(builder, encSerializer): builder.PrependUint8Slot(4, encSerializer, 0)
+def AddEncSerializer(builder, encSerializer):
+    return EventReceivedAddEncSerializer(builder, encSerializer)
+def EventReceivedAddEncKey(builder, encKey): builder.PrependUOffsetTRelativeSlot(5, flatbuffers.number_types.UOffsetTFlags.py_type(encKey), 0)
+def AddEncKey(builder, encKey):
+    return EventReceivedAddEncKey(builder, encKey)
+def EventReceivedStartEncKeyVector(builder, numElems): return builder.StartVector(1, numElems, 1)
+def StartEncKeyVector(builder, numElems):
+    return EventReceivedStartEncKeyVector(builder, numElems)
+def EventReceivedEnd(builder): return builder.EndObject()
+def End(builder):
+    return EventReceivedEnd(builder)

backend/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/proto/Goodbye.py

@@ -0,0 +1,72 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: proto
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+class Goodbye(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = Goodbye()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsGoodbye(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    # Goodbye
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # Goodbye
+    def Session(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
+        return 0
+
+    # Goodbye
+    def Reason(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # Goodbye
+    def Message(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # Goodbye
+    def Resumable(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+def GoodbyeStart(builder): builder.StartObject(4)
+def Start(builder):
+    return GoodbyeStart(builder)
+def GoodbyeAddSession(builder, session): builder.PrependUint64Slot(0, session, 0)
+def AddSession(builder, session):
+    return GoodbyeAddSession(builder, session)
+def GoodbyeAddReason(builder, reason): builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(reason), 0)
+def AddReason(builder, reason):
+    return GoodbyeAddReason(builder, reason)
+def GoodbyeAddMessage(builder, message): builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(message), 0)
+def AddMessage(builder, message):
+    return GoodbyeAddMessage(builder, message)
+def GoodbyeAddResumable(builder, resumable): builder.PrependBoolSlot(3, resumable, 0)
+def AddResumable(builder, resumable):
+    return GoodbyeAddResumable(builder, resumable)
+def GoodbyeEnd(builder): return builder.EndObject()
+def End(builder):
+    return GoodbyeEnd(builder)

backend/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/proto/Hello.py

@@ -0,0 +1,163 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: proto
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+class Hello(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = Hello()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsHello(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    # Hello
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # Hello
+    def Session(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
+        return 0
+
+    # Hello
+    def Roles(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            x = self._tab.Indirect(o + self._tab.Pos)
+            from wamp.proto.ClientRoles import ClientRoles
+            obj = ClientRoles()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+    # Hello
+    def Realm(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # Hello
+    def Authmethods(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        if o != 0:
+            a = self._tab.Vector(o)
+            return self._tab.Get(flatbuffers.number_types.Uint8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1))
+        return 0
+
+    # Hello
+    def AuthmethodsAsNumpy(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        if o != 0:
+            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o)
+        return 0
+
+    # Hello
+    def AuthmethodsLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # Hello
+    def AuthmethodsIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        return o == 0
+
+    # Hello
+    def Authid(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # Hello
+    def Authrole(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # Hello
+    def Authextra(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16))
+        if o != 0:
+            x = self._tab.Indirect(o + self._tab.Pos)
+            from wamp.Map import Map
+            obj = Map()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+    # Hello
+    def Resumable(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+    # Hello
+    def ResumeSession(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(20))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
+        return 0
+
+    # Hello
+    def ResumeToken(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+def HelloStart(builder): builder.StartObject(10)
+def Start(builder):
+    return HelloStart(builder)
+def HelloAddSession(builder, session): builder.PrependUint64Slot(0, session, 0)
+def AddSession(builder, session):
+    return HelloAddSession(builder, session)
+def HelloAddRoles(builder, roles): builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(roles), 0)
+def AddRoles(builder, roles):
+    return HelloAddRoles(builder, roles)
+def HelloAddRealm(builder, realm): builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(realm), 0)
+def AddRealm(builder, realm):
+    return HelloAddRealm(builder, realm)
+def HelloAddAuthmethods(builder, authmethods): builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(authmethods), 0)
+def AddAuthmethods(builder, authmethods):
+    return HelloAddAuthmethods(builder, authmethods)
+def HelloStartAuthmethodsVector(builder, numElems): return builder.StartVector(1, numElems, 1)
+def StartAuthmethodsVector(builder, numElems):
+    return HelloStartAuthmethodsVector(builder, numElems)
+def HelloAddAuthid(builder, authid): builder.PrependUOffsetTRelativeSlot(4, flatbuffers.number_types.UOffsetTFlags.py_type(authid), 0)
+def AddAuthid(builder, authid):
+    return HelloAddAuthid(builder, authid)
+def HelloAddAuthrole(builder, authrole): builder.PrependUOffsetTRelativeSlot(5, flatbuffers.number_types.UOffsetTFlags.py_type(authrole), 0)
+def AddAuthrole(builder, authrole):
+    return HelloAddAuthrole(builder, authrole)
+def HelloAddAuthextra(builder, authextra): builder.PrependUOffsetTRelativeSlot(6, flatbuffers.number_types.UOffsetTFlags.py_type(authextra), 0)
+def AddAuthextra(builder, authextra):
+    return HelloAddAuthextra(builder, authextra)
+def HelloAddResumable(builder, resumable): builder.PrependBoolSlot(7, resumable, 0)
+def AddResumable(builder, resumable):
+    return HelloAddResumable(builder, resumable)
+def HelloAddResumeSession(builder, resumeSession): builder.PrependUint64Slot(8, resumeSession, 0)
+def AddResumeSession(builder, resumeSession):
+    return HelloAddResumeSession(builder, resumeSession)
+def HelloAddResumeToken(builder, resumeToken): builder.PrependUOffsetTRelativeSlot(9, flatbuffers.number_types.UOffsetTFlags.py_type(resumeToken), 0)
+def AddResumeToken(builder, resumeToken):
+    return HelloAddResumeToken(builder, resumeToken)
+def HelloEnd(builder): return builder.EndObject()
+def End(builder):
+    return HelloEnd(builder)

backend/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/proto/HelloNew.py

@@ -0,0 +1,185 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: proto
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+class HelloNew(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = HelloNew()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsHelloNew(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    # HelloNew
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # HelloNew
+    def Roles(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            x = self._tab.Indirect(o + self._tab.Pos)
+            from wamp.proto.ClientRoles import ClientRoles
+            obj = ClientRoles()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+    # HelloNew
+    def Realm(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # HelloNew
+    def Authid(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # HelloNew
+    def Authrole(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # HelloNew
+    def Authmode(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
+        return 0
+
+    # HelloNew
+    def Authfactor1Type(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
+        return 0
+
+    # HelloNew
+    def Authfactor1(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16))
+        if o != 0:
+            from flatbuffers.table import Table
+            obj = Table(bytearray(), 0)
+            self._tab.Union(obj, o)
+            return obj
+        return None
+
+    # HelloNew
+    def Authfactor2Type(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
+        return 0
+
+    # HelloNew
+    def Authfactor2(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(20))
+        if o != 0:
+            from flatbuffers.table import Table
+            obj = Table(bytearray(), 0)
+            self._tab.Union(obj, o)
+            return obj
+        return None
+
+    # HelloNew
+    def Authfactor3Type(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
+        return 0
+
+    # HelloNew
+    def Authfactor3(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24))
+        if o != 0:
+            from flatbuffers.table import Table
+            obj = Table(bytearray(), 0)
+            self._tab.Union(obj, o)
+            return obj
+        return None
+
+    # HelloNew
+    def Resumable(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(26))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+    # HelloNew
+    def ResumeSession(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(28))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
+        return 0
+
+    # HelloNew
+    def ResumeToken(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(30))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+def HelloNewStart(builder): builder.StartObject(14)
+def Start(builder):
+    return HelloNewStart(builder)
+def HelloNewAddRoles(builder, roles): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(roles), 0)
+def AddRoles(builder, roles):
+    return HelloNewAddRoles(builder, roles)
+def HelloNewAddRealm(builder, realm): builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(realm), 0)
+def AddRealm(builder, realm):
+    return HelloNewAddRealm(builder, realm)
+def HelloNewAddAuthid(builder, authid): builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(authid), 0)
+def AddAuthid(builder, authid):
+    return HelloNewAddAuthid(builder, authid)
+def HelloNewAddAuthrole(builder, authrole): builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(authrole), 0)
+def AddAuthrole(builder, authrole):
+    return HelloNewAddAuthrole(builder, authrole)
+def HelloNewAddAuthmode(builder, authmode): builder.PrependUint8Slot(4, authmode, 0)
+def AddAuthmode(builder, authmode):
+    return HelloNewAddAuthmode(builder, authmode)
+def HelloNewAddAuthfactor1Type(builder, authfactor1Type): builder.PrependUint8Slot(5, authfactor1Type, 0)
+def AddAuthfactor1Type(builder, authfactor1Type):
+    return HelloNewAddAuthfactor1Type(builder, authfactor1Type)
+def HelloNewAddAuthfactor1(builder, authfactor1): builder.PrependUOffsetTRelativeSlot(6, flatbuffers.number_types.UOffsetTFlags.py_type(authfactor1), 0)
+def AddAuthfactor1(builder, authfactor1):
+    return HelloNewAddAuthfactor1(builder, authfactor1)
+def HelloNewAddAuthfactor2Type(builder, authfactor2Type): builder.PrependUint8Slot(7, authfactor2Type, 0)
+def AddAuthfactor2Type(builder, authfactor2Type):
+    return HelloNewAddAuthfactor2Type(builder, authfactor2Type)
+def HelloNewAddAuthfactor2(builder, authfactor2): builder.PrependUOffsetTRelativeSlot(8, flatbuffers.number_types.UOffsetTFlags.py_type(authfactor2), 0)
+def AddAuthfactor2(builder, authfactor2):
+    return HelloNewAddAuthfactor2(builder, authfactor2)
+def HelloNewAddAuthfactor3Type(builder, authfactor3Type): builder.PrependUint8Slot(9, authfactor3Type, 0)
+def AddAuthfactor3Type(builder, authfactor3Type):
+    return HelloNewAddAuthfactor3Type(builder, authfactor3Type)
+def HelloNewAddAuthfactor3(builder, authfactor3): builder.PrependUOffsetTRelativeSlot(10, flatbuffers.number_types.UOffsetTFlags.py_type(authfactor3), 0)
+def AddAuthfactor3(builder, authfactor3):
+    return HelloNewAddAuthfactor3(builder, authfactor3)
+def HelloNewAddResumable(builder, resumable): builder.PrependBoolSlot(11, resumable, 0)
+def AddResumable(builder, resumable):
+    return HelloNewAddResumable(builder, resumable)
+def HelloNewAddResumeSession(builder, resumeSession): builder.PrependUint64Slot(12, resumeSession, 0)
+def AddResumeSession(builder, resumeSession):
+    return HelloNewAddResumeSession(builder, resumeSession)
+def HelloNewAddResumeToken(builder, resumeToken): builder.PrependUOffsetTRelativeSlot(13, flatbuffers.number_types.UOffsetTFlags.py_type(resumeToken), 0)
+def AddResumeToken(builder, resumeToken):
+    return HelloNewAddResumeToken(builder, resumeToken)
+def HelloNewEnd(builder): return builder.EndObject()
+def End(builder):
+    return HelloNewEnd(builder)

backend/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/proto/Interrupt.py

@@ -0,0 +1,102 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: proto
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+class Interrupt(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = Interrupt()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsInterrupt(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    # Interrupt
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # Interrupt
+    def Session(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
+        return 0
+
+    # Interrupt
+    def Request(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
+        return 0
+
+    # Interrupt
+    def Mode(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
+        return 1
+
+    # Interrupt
+    def Reason(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # Interrupt
+    def ForwardFor(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
+        if o != 0:
+            x = self._tab.Vector(o)
+            x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 8
+            from wamp.proto.Principal import Principal
+            obj = Principal()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+    # Interrupt
+    def ForwardForLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # Interrupt
+    def ForwardForIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
+        return o == 0
+
+def InterruptStart(builder): builder.StartObject(5)
+def Start(builder):
+    return InterruptStart(builder)
+def InterruptAddSession(builder, session): builder.PrependUint64Slot(0, session, 0)
+def AddSession(builder, session):
+    return InterruptAddSession(builder, session)
+def InterruptAddRequest(builder, request): builder.PrependUint64Slot(1, request, 0)
+def AddRequest(builder, request):
+    return InterruptAddRequest(builder, request)
+def InterruptAddMode(builder, mode): builder.PrependUint8Slot(2, mode, 1)
+def AddMode(builder, mode):
+    return InterruptAddMode(builder, mode)
+def InterruptAddReason(builder, reason): builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(reason), 0)
+def AddReason(builder, reason):
+    return InterruptAddReason(builder, reason)
+def InterruptAddForwardFor(builder, forwardFor): builder.PrependUOffsetTRelativeSlot(4, flatbuffers.number_types.UOffsetTFlags.py_type(forwardFor), 0)
+def AddForwardFor(builder, forwardFor):
+    return InterruptAddForwardFor(builder, forwardFor)
+def InterruptStartForwardForVector(builder, numElems): return builder.StartVector(8, numElems, 8)
+def StartForwardForVector(builder, numElems):
+    return InterruptStartForwardForVector(builder, numElems)
+def InterruptEnd(builder): return builder.EndObject()
+def End(builder):
+    return InterruptEnd(builder)

backend/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/proto/Invocation.py

@@ -0,0 +1,248 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: proto
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+class Invocation(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = Invocation()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsInvocation(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    # Invocation
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # Invocation
+    def Session(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
+        return 0
+
+    # Invocation
+    def Request(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
+        return 0
+
+    # Invocation
+    def Registration(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
+        return 0
+
+    # Invocation
+    def Payload(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        if o != 0:
+            a = self._tab.Vector(o)
+            return self._tab.Get(flatbuffers.number_types.Uint8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1))
+        return 0
+
+    # Invocation
+    def PayloadAsNumpy(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        if o != 0:
+            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o)
+        return 0
+
+    # Invocation
+    def PayloadLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # Invocation
+    def PayloadIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        return o == 0
+
+    # Invocation
+    def EncAlgo(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
+        return 0
+
+    # Invocation
+    def EncSerializer(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
+        return 0
+
+    # Invocation
+    def EncKey(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16))
+        if o != 0:
+            a = self._tab.Vector(o)
+            return self._tab.Get(flatbuffers.number_types.Uint8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1))
+        return 0
+
+    # Invocation
+    def EncKeyAsNumpy(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16))
+        if o != 0:
+            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o)
+        return 0
+
+    # Invocation
+    def EncKeyLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # Invocation
+    def EncKeyIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16))
+        return o == 0
+
+    # Invocation
+    def Procedure(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # Invocation
+    def Timeout(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(20))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos)
+        return 0
+
+    # Invocation
+    def ReceiveProgress(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+    # Invocation
+    def TransactionHash(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # Invocation
+    def Caller(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(26))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
+        return 0
+
+    # Invocation
+    def CallerAuthid(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(28))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # Invocation
+    def CallerAuthrole(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(30))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # Invocation
+    def ForwardFor(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(32))
+        if o != 0:
+            x = self._tab.Vector(o)
+            x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 8
+            from wamp.proto.Principal import Principal
+            obj = Principal()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+    # Invocation
+    def ForwardForLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(32))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # Invocation
+    def ForwardForIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(32))
+        return o == 0
+
+def InvocationStart(builder): builder.StartObject(15)
+def Start(builder):
+    return InvocationStart(builder)
+def InvocationAddSession(builder, session): builder.PrependUint64Slot(0, session, 0)
+def AddSession(builder, session):
+    return InvocationAddSession(builder, session)
+def InvocationAddRequest(builder, request): builder.PrependUint64Slot(1, request, 0)
+def AddRequest(builder, request):
+    return InvocationAddRequest(builder, request)
+def InvocationAddRegistration(builder, registration): builder.PrependUint64Slot(2, registration, 0)
+def AddRegistration(builder, registration):
+    return InvocationAddRegistration(builder, registration)
+def InvocationAddPayload(builder, payload): builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(payload), 0)
+def AddPayload(builder, payload):
+    return InvocationAddPayload(builder, payload)
+def InvocationStartPayloadVector(builder, numElems): return builder.StartVector(1, numElems, 1)
+def StartPayloadVector(builder, numElems):
+    return InvocationStartPayloadVector(builder, numElems)
+def InvocationAddEncAlgo(builder, encAlgo): builder.PrependUint8Slot(4, encAlgo, 0)
+def AddEncAlgo(builder, encAlgo):
+    return InvocationAddEncAlgo(builder, encAlgo)
+def InvocationAddEncSerializer(builder, encSerializer): builder.PrependUint8Slot(5, encSerializer, 0)
+def AddEncSerializer(builder, encSerializer):
+    return InvocationAddEncSerializer(builder, encSerializer)
+def InvocationAddEncKey(builder, encKey): builder.PrependUOffsetTRelativeSlot(6, flatbuffers.number_types.UOffsetTFlags.py_type(encKey), 0)
+def AddEncKey(builder, encKey):
+    return InvocationAddEncKey(builder, encKey)
+def InvocationStartEncKeyVector(builder, numElems): return builder.StartVector(1, numElems, 1)
+def StartEncKeyVector(builder, numElems):
+    return InvocationStartEncKeyVector(builder, numElems)
+def InvocationAddProcedure(builder, procedure): builder.PrependUOffsetTRelativeSlot(7, flatbuffers.number_types.UOffsetTFlags.py_type(procedure), 0)
+def AddProcedure(builder, procedure):
+    return InvocationAddProcedure(builder, procedure)
+def InvocationAddTimeout(builder, timeout): builder.PrependUint32Slot(8, timeout, 0)
+def AddTimeout(builder, timeout):
+    return InvocationAddTimeout(builder, timeout)
+def InvocationAddReceiveProgress(builder, receiveProgress): builder.PrependBoolSlot(9, receiveProgress, 0)
+def AddReceiveProgress(builder, receiveProgress):
+    return InvocationAddReceiveProgress(builder, receiveProgress)
+def InvocationAddTransactionHash(builder, transactionHash): builder.PrependUOffsetTRelativeSlot(10, flatbuffers.number_types.UOffsetTFlags.py_type(transactionHash), 0)
+def AddTransactionHash(builder, transactionHash):
+    return InvocationAddTransactionHash(builder, transactionHash)
+def InvocationAddCaller(builder, caller): builder.PrependUint64Slot(11, caller, 0)
+def AddCaller(builder, caller):
+    return InvocationAddCaller(builder, caller)
+def InvocationAddCallerAuthid(builder, callerAuthid): builder.PrependUOffsetTRelativeSlot(12, flatbuffers.number_types.UOffsetTFlags.py_type(callerAuthid), 0)
+def AddCallerAuthid(builder, callerAuthid):
+    return InvocationAddCallerAuthid(builder, callerAuthid)
+def InvocationAddCallerAuthrole(builder, callerAuthrole): builder.PrependUOffsetTRelativeSlot(13, flatbuffers.number_types.UOffsetTFlags.py_type(callerAuthrole), 0)
+def AddCallerAuthrole(builder, callerAuthrole):
+    return InvocationAddCallerAuthrole(builder, callerAuthrole)
+def InvocationAddForwardFor(builder, forwardFor): builder.PrependUOffsetTRelativeSlot(14, flatbuffers.number_types.UOffsetTFlags.py_type(forwardFor), 0)
+def AddForwardFor(builder, forwardFor):
+    return InvocationAddForwardFor(builder, forwardFor)
+def InvocationStartForwardForVector(builder, numElems): return builder.StartVector(8, numElems, 8)
+def StartForwardForVector(builder, numElems):
+    return InvocationStartForwardForVector(builder, numElems)
+def InvocationEnd(builder): return builder.EndObject()
+def End(builder):
+    return InvocationEnd(builder)

backend/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/proto/InvocationPolicy.py

@@ -0,0 +1,10 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: proto
+
+class InvocationPolicy(object):
+    SINGLE = 0
+    FIRST = 1
+    LAST = 2
+    ROUNDROBIN = 3
+    RANDOM = 4

backend/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/proto/Kdf.py

@@ -0,0 +1,8 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: proto
+
+class Kdf(object):
+    NONE = 0
+    PBKDF2 = 1
+    ARGON2 = 2

backend/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/proto/Match.py

@@ -0,0 +1,8 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: proto
+
+class Match(object):
+    EXACT = 0
+    PREFIX = 1
+    WILDCARD = 2

backend/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/proto/Message.py

@@ -0,0 +1,55 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: proto
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+class Message(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = Message()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsMessage(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    # Message
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # Message
+    def MsgType(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
+        return 0
+
+    # Message
+    def Msg(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            from flatbuffers.table import Table
+            obj = Table(bytearray(), 0)
+            self._tab.Union(obj, o)
+            return obj
+        return None
+
+def MessageStart(builder): builder.StartObject(2)
+def Start(builder):
+    return MessageStart(builder)
+def MessageAddMsgType(builder, msgType): builder.PrependUint8Slot(0, msgType, 0)
+def AddMsgType(builder, msgType):
+    return MessageAddMsgType(builder, msgType)
+def MessageAddMsg(builder, msg): builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(msg), 0)
+def AddMsg(builder, msg):
+    return MessageAddMsg(builder, msg)
+def MessageEnd(builder): return builder.EndObject()
+def End(builder):
+    return MessageEnd(builder)

backend/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/proto/MessageType.py

@@ -0,0 +1,31 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: proto
+
+class MessageType(object):
+    NULL = 0
+    HELLO = 1
+    WELCOME = 2
+    ABORT = 3
+    CHALLENGE = 4
+    AUTHENTICATE = 5
+    GOODBYE = 6
+    ERROR = 8
+    PUBLISH = 16
+    PUBLISHED = 17
+    SUBSCRIBE = 32
+    SUBSCRIBED = 33
+    UNSUBSCRIBE = 34
+    UNSUBSCRIBED = 35
+    EVENT = 36
+    EVENT_RECEIVED = 37
+    CALL = 48
+    CANCEL = 49
+    RESULT = 50
+    REGISTER = 64
+    REGISTERED = 65
+    UNREGISTER = 66
+    UNREGISTERED = 67
+    INVOCATION = 68
+    INTERRUPT = 69
+    YIELD = 70

backend/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/proto/Payload.py

@@ -0,0 +1,8 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: proto
+
+class Payload(object):
+    PLAIN = 0
+    CRYPTOBOX = 1
+    OPAQUE = 2

backend/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/proto/Principal.py

@@ -0,0 +1,26 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: proto
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+class Principal(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def SizeOf(cls):
+        return 8
+
+    # Principal
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # Principal
+    def Session(self): return self._tab.Get(flatbuffers.number_types.Uint64Flags, self._tab.Pos + flatbuffers.number_types.UOffsetTFlags.py_type(0))
+
+def CreatePrincipal(builder, session):
+    builder.Prep(8, 8)
+    builder.PrependUint64(session)
+    return builder.Offset()

backend/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/proto/Publish.py

@@ -0,0 +1,457 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: proto
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+class Publish(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = Publish()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsPublish(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    # Publish
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # Publish
+    def Session(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
+        return 0
+
+    # Publish
+    def Request(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
+        return 0
+
+    # Publish
+    def Topic(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # Positional values for application-defined event payload.
+    # Publish
+    def Args(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        if o != 0:
+            a = self._tab.Vector(o)
+            return self._tab.Get(flatbuffers.number_types.Uint8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1))
+        return 0
+
+    # Publish
+    def ArgsAsNumpy(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        if o != 0:
+            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o)
+        return 0
+
+    # Publish
+    def ArgsLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # Publish
+    def ArgsIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        return o == 0
+
+    # Keyword values for application-defined event payload.
+    # Publish
+    def Kwargs(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
+        if o != 0:
+            a = self._tab.Vector(o)
+            return self._tab.Get(flatbuffers.number_types.Uint8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1))
+        return 0
+
+    # Publish
+    def KwargsAsNumpy(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
+        if o != 0:
+            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o)
+        return 0
+
+    # Publish
+    def KwargsLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # Publish
+    def KwargsIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
+        return o == 0
+
+    # Alternative, transparent payload. If given, ``args`` and ``kwargs`` must be left unset.
+    # Publish
+    def Payload(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
+        if o != 0:
+            a = self._tab.Vector(o)
+            return self._tab.Get(flatbuffers.number_types.Uint8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1))
+        return 0
+
+    # Publish
+    def PayloadAsNumpy(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
+        if o != 0:
+            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o)
+        return 0
+
+    # Publish
+    def PayloadLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # Publish
+    def PayloadIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
+        return o == 0
+
+    # Publish
+    def EncAlgo(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
+        return 0
+
+    # Publish
+    def EncSerializer(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
+        return 0
+
+    # Publish
+    def EncKey(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(20))
+        if o != 0:
+            a = self._tab.Vector(o)
+            return self._tab.Get(flatbuffers.number_types.Uint8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1))
+        return 0
+
+    # Publish
+    def EncKeyAsNumpy(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(20))
+        if o != 0:
+            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o)
+        return 0
+
+    # Publish
+    def EncKeyLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(20))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # Publish
+    def EncKeyIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(20))
+        return o == 0
+
+    # Publish
+    def Acknowledge(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+    # Publish
+    def ExcludeMe(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return True
+
+    # Publish
+    def Exclude(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(26))
+        if o != 0:
+            a = self._tab.Vector(o)
+            return self._tab.Get(flatbuffers.number_types.Uint64Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 8))
+        return 0
+
+    # Publish
+    def ExcludeAsNumpy(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(26))
+        if o != 0:
+            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint64Flags, o)
+        return 0
+
+    # Publish
+    def ExcludeLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(26))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # Publish
+    def ExcludeIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(26))
+        return o == 0
+
+    # Publish
+    def ExcludeAuthid(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(28))
+        if o != 0:
+            a = self._tab.Vector(o)
+            return self._tab.String(a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4))
+        return ""
+
+    # Publish
+    def ExcludeAuthidLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(28))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # Publish
+    def ExcludeAuthidIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(28))
+        return o == 0
+
+    # Publish
+    def ExcludeAuthrole(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(30))
+        if o != 0:
+            a = self._tab.Vector(o)
+            return self._tab.String(a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4))
+        return ""
+
+    # Publish
+    def ExcludeAuthroleLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(30))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # Publish
+    def ExcludeAuthroleIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(30))
+        return o == 0
+
+    # Publish
+    def Eligible(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(32))
+        if o != 0:
+            a = self._tab.Vector(o)
+            return self._tab.Get(flatbuffers.number_types.Uint64Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 8))
+        return 0
+
+    # Publish
+    def EligibleAsNumpy(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(32))
+        if o != 0:
+            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint64Flags, o)
+        return 0
+
+    # Publish
+    def EligibleLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(32))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # Publish
+    def EligibleIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(32))
+        return o == 0
+
+    # Publish
+    def EligibleAuthid(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(34))
+        if o != 0:
+            a = self._tab.Vector(o)
+            return self._tab.String(a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4))
+        return ""
+
+    # Publish
+    def EligibleAuthidLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(34))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # Publish
+    def EligibleAuthidIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(34))
+        return o == 0
+
+    # Publish
+    def EligibleAuthrole(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(36))
+        if o != 0:
+            a = self._tab.Vector(o)
+            return self._tab.String(a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4))
+        return ""
+
+    # Publish
+    def EligibleAuthroleLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(36))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # Publish
+    def EligibleAuthroleIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(36))
+        return o == 0
+
+    # Publish
+    def Retain(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(38))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+    # Publish
+    def TransactionHash(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(40))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # Publish
+    def ForwardFor(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(42))
+        if o != 0:
+            x = self._tab.Vector(o)
+            x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 8
+            from wamp.proto.Principal import Principal
+            obj = Principal()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+    # Publish
+    def ForwardForLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(42))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # Publish
+    def ForwardForIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(42))
+        return o == 0
+
+def PublishStart(builder): builder.StartObject(20)
+def Start(builder):
+    return PublishStart(builder)
+def PublishAddSession(builder, session): builder.PrependUint64Slot(0, session, 0)
+def AddSession(builder, session):
+    return PublishAddSession(builder, session)
+def PublishAddRequest(builder, request): builder.PrependUint64Slot(1, request, 0)
+def AddRequest(builder, request):
+    return PublishAddRequest(builder, request)
+def PublishAddTopic(builder, topic): builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(topic), 0)
+def AddTopic(builder, topic):
+    return PublishAddTopic(builder, topic)
+def PublishAddArgs(builder, args): builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(args), 0)
+def AddArgs(builder, args):
+    return PublishAddArgs(builder, args)
+def PublishStartArgsVector(builder, numElems): return builder.StartVector(1, numElems, 1)
+def StartArgsVector(builder, numElems):
+    return PublishStartArgsVector(builder, numElems)
+def PublishAddKwargs(builder, kwargs): builder.PrependUOffsetTRelativeSlot(4, flatbuffers.number_types.UOffsetTFlags.py_type(kwargs), 0)
+def AddKwargs(builder, kwargs):
+    return PublishAddKwargs(builder, kwargs)
+def PublishStartKwargsVector(builder, numElems): return builder.StartVector(1, numElems, 1)
+def StartKwargsVector(builder, numElems):
+    return PublishStartKwargsVector(builder, numElems)
+def PublishAddPayload(builder, payload): builder.PrependUOffsetTRelativeSlot(5, flatbuffers.number_types.UOffsetTFlags.py_type(payload), 0)
+def AddPayload(builder, payload):
+    return PublishAddPayload(builder, payload)
+def PublishStartPayloadVector(builder, numElems): return builder.StartVector(1, numElems, 1)
+def StartPayloadVector(builder, numElems):
+    return PublishStartPayloadVector(builder, numElems)
+def PublishAddEncAlgo(builder, encAlgo): builder.PrependUint8Slot(6, encAlgo, 0)
+def AddEncAlgo(builder, encAlgo):
+    return PublishAddEncAlgo(builder, encAlgo)
+def PublishAddEncSerializer(builder, encSerializer): builder.PrependUint8Slot(7, encSerializer, 0)
+def AddEncSerializer(builder, encSerializer):
+    return PublishAddEncSerializer(builder, encSerializer)
+def PublishAddEncKey(builder, encKey): builder.PrependUOffsetTRelativeSlot(8, flatbuffers.number_types.UOffsetTFlags.py_type(encKey), 0)
+def AddEncKey(builder, encKey):
+    return PublishAddEncKey(builder, encKey)
+def PublishStartEncKeyVector(builder, numElems): return builder.StartVector(1, numElems, 1)
+def StartEncKeyVector(builder, numElems):
+    return PublishStartEncKeyVector(builder, numElems)
+def PublishAddAcknowledge(builder, acknowledge): builder.PrependBoolSlot(9, acknowledge, 0)
+def AddAcknowledge(builder, acknowledge):
+    return PublishAddAcknowledge(builder, acknowledge)
+def PublishAddExcludeMe(builder, excludeMe): builder.PrependBoolSlot(10, excludeMe, 1)
+def AddExcludeMe(builder, excludeMe):
+    return PublishAddExcludeMe(builder, excludeMe)
+def PublishAddExclude(builder, exclude): builder.PrependUOffsetTRelativeSlot(11, flatbuffers.number_types.UOffsetTFlags.py_type(exclude), 0)
+def AddExclude(builder, exclude):
+    return PublishAddExclude(builder, exclude)
+def PublishStartExcludeVector(builder, numElems): return builder.StartVector(8, numElems, 8)
+def StartExcludeVector(builder, numElems):
+    return PublishStartExcludeVector(builder, numElems)
+def PublishAddExcludeAuthid(builder, excludeAuthid): builder.PrependUOffsetTRelativeSlot(12, flatbuffers.number_types.UOffsetTFlags.py_type(excludeAuthid), 0)
+def AddExcludeAuthid(builder, excludeAuthid):
+    return PublishAddExcludeAuthid(builder, excludeAuthid)
+def PublishStartExcludeAuthidVector(builder, numElems): return builder.StartVector(4, numElems, 4)
+def StartExcludeAuthidVector(builder, numElems):
+    return PublishStartExcludeAuthidVector(builder, numElems)
+def PublishAddExcludeAuthrole(builder, excludeAuthrole): builder.PrependUOffsetTRelativeSlot(13, flatbuffers.number_types.UOffsetTFlags.py_type(excludeAuthrole), 0)
+def AddExcludeAuthrole(builder, excludeAuthrole):
+    return PublishAddExcludeAuthrole(builder, excludeAuthrole)
+def PublishStartExcludeAuthroleVector(builder, numElems): return builder.StartVector(4, numElems, 4)
+def StartExcludeAuthroleVector(builder, numElems):
+    return PublishStartExcludeAuthroleVector(builder, numElems)
+def PublishAddEligible(builder, eligible): builder.PrependUOffsetTRelativeSlot(14, flatbuffers.number_types.UOffsetTFlags.py_type(eligible), 0)
+def AddEligible(builder, eligible):
+    return PublishAddEligible(builder, eligible)
+def PublishStartEligibleVector(builder, numElems): return builder.StartVector(8, numElems, 8)
+def StartEligibleVector(builder, numElems):
+    return PublishStartEligibleVector(builder, numElems)
+def PublishAddEligibleAuthid(builder, eligibleAuthid): builder.PrependUOffsetTRelativeSlot(15, flatbuffers.number_types.UOffsetTFlags.py_type(eligibleAuthid), 0)
+def AddEligibleAuthid(builder, eligibleAuthid):
+    return PublishAddEligibleAuthid(builder, eligibleAuthid)
+def PublishStartEligibleAuthidVector(builder, numElems): return builder.StartVector(4, numElems, 4)
+def StartEligibleAuthidVector(builder, numElems):
+    return PublishStartEligibleAuthidVector(builder, numElems)
+def PublishAddEligibleAuthrole(builder, eligibleAuthrole): builder.PrependUOffsetTRelativeSlot(16, flatbuffers.number_types.UOffsetTFlags.py_type(eligibleAuthrole), 0)
+def AddEligibleAuthrole(builder, eligibleAuthrole):
+    return PublishAddEligibleAuthrole(builder, eligibleAuthrole)
+def PublishStartEligibleAuthroleVector(builder, numElems): return builder.StartVector(4, numElems, 4)
+def StartEligibleAuthroleVector(builder, numElems):
+    return PublishStartEligibleAuthroleVector(builder, numElems)
+def PublishAddRetain(builder, retain): builder.PrependBoolSlot(17, retain, 0)
+def AddRetain(builder, retain):
+    return PublishAddRetain(builder, retain)
+def PublishAddTransactionHash(builder, transactionHash): builder.PrependUOffsetTRelativeSlot(18, flatbuffers.number_types.UOffsetTFlags.py_type(transactionHash), 0)
+def AddTransactionHash(builder, transactionHash):
+    return PublishAddTransactionHash(builder, transactionHash)
+def PublishAddForwardFor(builder, forwardFor): builder.PrependUOffsetTRelativeSlot(19, flatbuffers.number_types.UOffsetTFlags.py_type(forwardFor), 0)
+def AddForwardFor(builder, forwardFor):
+    return PublishAddForwardFor(builder, forwardFor)
+def PublishStartForwardForVector(builder, numElems): return builder.StartVector(8, numElems, 8)
+def StartForwardForVector(builder, numElems):
+    return PublishStartForwardForVector(builder, numElems)
+def PublishEnd(builder): return builder.EndObject()
+def End(builder):
+    return PublishEnd(builder)

backend/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/proto/Published.py

@@ -0,0 +1,62 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: proto
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+class Published(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = Published()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsPublished(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    # Published
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # Published
+    def Session(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
+        return 0
+
+    # Published
+    def Request(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
+        return 0
+
+    # Published
+    def Publication(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
+        return 0
+
+def PublishedStart(builder): builder.StartObject(3)
+def Start(builder):
+    return PublishedStart(builder)
+def PublishedAddSession(builder, session): builder.PrependUint64Slot(0, session, 0)
+def AddSession(builder, session):
+    return PublishedAddSession(builder, session)
+def PublishedAddRequest(builder, request): builder.PrependUint64Slot(1, request, 0)
+def AddRequest(builder, request):
+    return PublishedAddRequest(builder, request)
+def PublishedAddPublication(builder, publication): builder.PrependUint64Slot(2, publication, 0)
+def AddPublication(builder, publication):
+    return PublishedAddPublication(builder, publication)
+def PublishedEnd(builder): return builder.EndObject()
+def End(builder):
+    return PublishedEnd(builder)

backend/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/proto/PublisherFeatures.py

@@ -0,0 +1,92 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: proto
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+class PublisherFeatures(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = PublisherFeatures()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsPublisherFeatures(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    # PublisherFeatures
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # PublisherFeatures
+    def PublisherIdentification(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+    # PublisherFeatures
+    def PublisherExclusion(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+    # PublisherFeatures
+    def SubscriberBlackwhiteListing(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+    # PublisherFeatures
+    def AcknowledgeEventReceived(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+    # PublisherFeatures
+    def PayloadTransparency(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+    # PublisherFeatures
+    def PayloadEncryptionCryptobox(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+def PublisherFeaturesStart(builder): builder.StartObject(6)
+def Start(builder):
+    return PublisherFeaturesStart(builder)
+def PublisherFeaturesAddPublisherIdentification(builder, publisherIdentification): builder.PrependBoolSlot(0, publisherIdentification, 0)
+def AddPublisherIdentification(builder, publisherIdentification):
+    return PublisherFeaturesAddPublisherIdentification(builder, publisherIdentification)
+def PublisherFeaturesAddPublisherExclusion(builder, publisherExclusion): builder.PrependBoolSlot(1, publisherExclusion, 0)
+def AddPublisherExclusion(builder, publisherExclusion):
+    return PublisherFeaturesAddPublisherExclusion(builder, publisherExclusion)
+def PublisherFeaturesAddSubscriberBlackwhiteListing(builder, subscriberBlackwhiteListing): builder.PrependBoolSlot(2, subscriberBlackwhiteListing, 0)
+def AddSubscriberBlackwhiteListing(builder, subscriberBlackwhiteListing):
+    return PublisherFeaturesAddSubscriberBlackwhiteListing(builder, subscriberBlackwhiteListing)
+def PublisherFeaturesAddAcknowledgeEventReceived(builder, acknowledgeEventReceived): builder.PrependBoolSlot(3, acknowledgeEventReceived, 0)
+def AddAcknowledgeEventReceived(builder, acknowledgeEventReceived):
+    return PublisherFeaturesAddAcknowledgeEventReceived(builder, acknowledgeEventReceived)
+def PublisherFeaturesAddPayloadTransparency(builder, payloadTransparency): builder.PrependBoolSlot(4, payloadTransparency, 0)
+def AddPayloadTransparency(builder, payloadTransparency):
+    return PublisherFeaturesAddPayloadTransparency(builder, payloadTransparency)
+def PublisherFeaturesAddPayloadEncryptionCryptobox(builder, payloadEncryptionCryptobox): builder.PrependBoolSlot(5, payloadEncryptionCryptobox, 0)
+def AddPayloadEncryptionCryptobox(builder, payloadEncryptionCryptobox):
+    return PublisherFeaturesAddPayloadEncryptionCryptobox(builder, payloadEncryptionCryptobox)
+def PublisherFeaturesEnd(builder): return builder.EndObject()
+def End(builder):
+    return PublisherFeaturesEnd(builder)

backend/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/proto/Register.py

@@ -0,0 +1,102 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: proto
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+class Register(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = Register()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsRegister(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    # Register
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # Register
+    def Session(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
+        return 0
+
+    # Register
+    def Request(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
+        return 0
+
+    # Register
+    def Procedure(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # Register
+    def Match(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
+        return 0
+
+    # Register
+    def Invoke(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
+        return 0
+
+    # Register
+    def Concurrency(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint16Flags, o + self._tab.Pos)
+        return 0
+
+    # Register
+    def ForceReregister(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+def RegisterStart(builder): builder.StartObject(7)
+def Start(builder):
+    return RegisterStart(builder)
+def RegisterAddSession(builder, session): builder.PrependUint64Slot(0, session, 0)
+def AddSession(builder, session):
+    return RegisterAddSession(builder, session)
+def RegisterAddRequest(builder, request): builder.PrependUint64Slot(1, request, 0)
+def AddRequest(builder, request):
+    return RegisterAddRequest(builder, request)
+def RegisterAddProcedure(builder, procedure): builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(procedure), 0)
+def AddProcedure(builder, procedure):
+    return RegisterAddProcedure(builder, procedure)
+def RegisterAddMatch(builder, match): builder.PrependUint8Slot(3, match, 0)
+def AddMatch(builder, match):
+    return RegisterAddMatch(builder, match)
+def RegisterAddInvoke(builder, invoke): builder.PrependUint8Slot(4, invoke, 0)
+def AddInvoke(builder, invoke):
+    return RegisterAddInvoke(builder, invoke)
+def RegisterAddConcurrency(builder, concurrency): builder.PrependUint16Slot(5, concurrency, 0)
+def AddConcurrency(builder, concurrency):
+    return RegisterAddConcurrency(builder, concurrency)
+def RegisterAddForceReregister(builder, forceReregister): builder.PrependBoolSlot(6, forceReregister, 0)
+def AddForceReregister(builder, forceReregister):
+    return RegisterAddForceReregister(builder, forceReregister)
+def RegisterEnd(builder): return builder.EndObject()
+def End(builder):
+    return RegisterEnd(builder)

backend/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/proto/Registered.py

@@ -0,0 +1,62 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: proto
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+class Registered(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = Registered()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsRegistered(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    # Registered
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # Registered
+    def Session(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
+        return 0
+
+    # Registered
+    def Request(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
+        return 0
+
+    # Registered
+    def Registration(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
+        return 0
+
+def RegisteredStart(builder): builder.StartObject(3)
+def Start(builder):
+    return RegisteredStart(builder)
+def RegisteredAddSession(builder, session): builder.PrependUint64Slot(0, session, 0)
+def AddSession(builder, session):
+    return RegisteredAddSession(builder, session)
+def RegisteredAddRequest(builder, request): builder.PrependUint64Slot(1, request, 0)
+def AddRequest(builder, request):
+    return RegisteredAddRequest(builder, request)
+def RegisteredAddRegistration(builder, registration): builder.PrependUint64Slot(2, registration, 0)
+def AddRegistration(builder, registration):
+    return RegisteredAddRegistration(builder, registration)
+def RegisteredEnd(builder): return builder.EndObject()
+def End(builder):
+    return RegisteredEnd(builder)

backend/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/proto/Result.py

@@ -0,0 +1,208 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: proto
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+class Result(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = Result()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsResult(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    # Result
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # Result
+    def Session(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
+        return 0
+
+    # Result
+    def Request(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
+        return 0
+
+    # Result
+    def Payload(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            a = self._tab.Vector(o)
+            return self._tab.Get(flatbuffers.number_types.Uint8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1))
+        return 0
+
+    # Result
+    def PayloadAsNumpy(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o)
+        return 0
+
+    # Result
+    def PayloadLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # Result
+    def PayloadIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        return o == 0
+
+    # Result
+    def EncAlgo(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
+        return 0
+
+    # Result
+    def EncSerializer(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
+        return 0
+
+    # Result
+    def EncKey(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
+        if o != 0:
+            a = self._tab.Vector(o)
+            return self._tab.Get(flatbuffers.number_types.Uint8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1))
+        return 0
+
+    # Result
+    def EncKeyAsNumpy(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
+        if o != 0:
+            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o)
+        return 0
+
+    # Result
+    def EncKeyLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # Result
+    def EncKeyIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
+        return o == 0
+
+    # Result
+    def Progress(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+    # Result
+    def Callee(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
+        return 0
+
+    # Result
+    def CalleeAuthid(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(20))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # Result
+    def CalleeAuthrole(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # Result
+    def ForwardFor(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24))
+        if o != 0:
+            x = self._tab.Vector(o)
+            x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 8
+            from wamp.proto.Principal import Principal
+            obj = Principal()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+    # Result
+    def ForwardForLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # Result
+    def ForwardForIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24))
+        return o == 0
+
+def ResultStart(builder): builder.StartObject(11)
+def Start(builder):
+    return ResultStart(builder)
+def ResultAddSession(builder, session): builder.PrependUint64Slot(0, session, 0)
+def AddSession(builder, session):
+    return ResultAddSession(builder, session)
+def ResultAddRequest(builder, request): builder.PrependUint64Slot(1, request, 0)
+def AddRequest(builder, request):
+    return ResultAddRequest(builder, request)
+def ResultAddPayload(builder, payload): builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(payload), 0)
+def AddPayload(builder, payload):
+    return ResultAddPayload(builder, payload)
+def ResultStartPayloadVector(builder, numElems): return builder.StartVector(1, numElems, 1)
+def StartPayloadVector(builder, numElems):
+    return ResultStartPayloadVector(builder, numElems)
+def ResultAddEncAlgo(builder, encAlgo): builder.PrependUint8Slot(3, encAlgo, 0)
+def AddEncAlgo(builder, encAlgo):
+    return ResultAddEncAlgo(builder, encAlgo)
+def ResultAddEncSerializer(builder, encSerializer): builder.PrependUint8Slot(4, encSerializer, 0)
+def AddEncSerializer(builder, encSerializer):
+    return ResultAddEncSerializer(builder, encSerializer)
+def ResultAddEncKey(builder, encKey): builder.PrependUOffsetTRelativeSlot(5, flatbuffers.number_types.UOffsetTFlags.py_type(encKey), 0)
+def AddEncKey(builder, encKey):
+    return ResultAddEncKey(builder, encKey)
+def ResultStartEncKeyVector(builder, numElems): return builder.StartVector(1, numElems, 1)
+def StartEncKeyVector(builder, numElems):
+    return ResultStartEncKeyVector(builder, numElems)
+def ResultAddProgress(builder, progress): builder.PrependBoolSlot(6, progress, 0)
+def AddProgress(builder, progress):
+    return ResultAddProgress(builder, progress)
+def ResultAddCallee(builder, callee): builder.PrependUint64Slot(7, callee, 0)
+def AddCallee(builder, callee):
+    return ResultAddCallee(builder, callee)
+def ResultAddCalleeAuthid(builder, calleeAuthid): builder.PrependUOffsetTRelativeSlot(8, flatbuffers.number_types.UOffsetTFlags.py_type(calleeAuthid), 0)
+def AddCalleeAuthid(builder, calleeAuthid):
+    return ResultAddCalleeAuthid(builder, calleeAuthid)
+def ResultAddCalleeAuthrole(builder, calleeAuthrole): builder.PrependUOffsetTRelativeSlot(9, flatbuffers.number_types.UOffsetTFlags.py_type(calleeAuthrole), 0)
+def AddCalleeAuthrole(builder, calleeAuthrole):
+    return ResultAddCalleeAuthrole(builder, calleeAuthrole)
+def ResultAddForwardFor(builder, forwardFor): builder.PrependUOffsetTRelativeSlot(10, flatbuffers.number_types.UOffsetTFlags.py_type(forwardFor), 0)
+def AddForwardFor(builder, forwardFor):
+    return ResultAddForwardFor(builder, forwardFor)
+def ResultStartForwardForVector(builder, numElems): return builder.StartVector(8, numElems, 8)
+def StartForwardForVector(builder, numElems):
+    return ResultStartForwardForVector(builder, numElems)
+def ResultEnd(builder): return builder.EndObject()
+def End(builder):
+    return ResultEnd(builder)

backend/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/proto/RouterRoles.py

@@ -0,0 +1,60 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: proto
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+class RouterRoles(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = RouterRoles()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsRouterRoles(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    # RouterRoles
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # RouterRoles
+    def Broker(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            x = self._tab.Indirect(o + self._tab.Pos)
+            from wamp.proto.BrokerFeatures import BrokerFeatures
+            obj = BrokerFeatures()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+    # RouterRoles
+    def Dealer(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            x = self._tab.Indirect(o + self._tab.Pos)
+            from wamp.proto.DealerFeatures import DealerFeatures
+            obj = DealerFeatures()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+def RouterRolesStart(builder): builder.StartObject(2)
+def Start(builder):
+    return RouterRolesStart(builder)
+def RouterRolesAddBroker(builder, broker): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(broker), 0)
+def AddBroker(builder, broker):
+    return RouterRolesAddBroker(builder, broker)
+def RouterRolesAddDealer(builder, dealer): builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(dealer), 0)
+def AddDealer(builder, dealer):
+    return RouterRolesAddDealer(builder, dealer)
+def RouterRolesEnd(builder): return builder.EndObject()
+def End(builder):
+    return RouterRolesEnd(builder)

backend/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/proto/Serializer.py

@@ -0,0 +1,13 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: proto
+
+class Serializer(object):
+    TRANSPORT = 0
+    JSON = 1
+    MSGPACK = 2
+    CBOR = 3
+    UBJSON = 4
+    OPAQUE = 5
+    FLATBUFFERS = 6
+    FLEXBUFFERS = 7

backend/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/proto/Subscribe.py

@@ -0,0 +1,82 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: proto
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+class Subscribe(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = Subscribe()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsSubscribe(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    # Subscribe
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # Subscribe
+    def Session(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
+        return 0
+
+    # Subscribe
+    def Request(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
+        return 0
+
+    # Subscribe
+    def Topic(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # Subscribe
+    def Match(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
+        return 0
+
+    # Subscribe
+    def GetRetained(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+def SubscribeStart(builder): builder.StartObject(5)
+def Start(builder):
+    return SubscribeStart(builder)
+def SubscribeAddSession(builder, session): builder.PrependUint64Slot(0, session, 0)
+def AddSession(builder, session):
+    return SubscribeAddSession(builder, session)
+def SubscribeAddRequest(builder, request): builder.PrependUint64Slot(1, request, 0)
+def AddRequest(builder, request):
+    return SubscribeAddRequest(builder, request)
+def SubscribeAddTopic(builder, topic): builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(topic), 0)
+def AddTopic(builder, topic):
+    return SubscribeAddTopic(builder, topic)
+def SubscribeAddMatch(builder, match): builder.PrependUint8Slot(3, match, 0)
+def AddMatch(builder, match):
+    return SubscribeAddMatch(builder, match)
+def SubscribeAddGetRetained(builder, getRetained): builder.PrependBoolSlot(4, getRetained, 0)
+def AddGetRetained(builder, getRetained):
+    return SubscribeAddGetRetained(builder, getRetained)
+def SubscribeEnd(builder): return builder.EndObject()
+def End(builder):
+    return SubscribeEnd(builder)

backend/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/proto/Subscribed.py

@@ -0,0 +1,62 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: proto
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+class Subscribed(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = Subscribed()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsSubscribed(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    # Subscribed
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # Subscribed
+    def Session(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
+        return 0
+
+    # Subscribed
+    def Request(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
+        return 0
+
+    # Subscribed
+    def Subscription(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
+        return 0
+
+def SubscribedStart(builder): builder.StartObject(3)
+def Start(builder):
+    return SubscribedStart(builder)
+def SubscribedAddSession(builder, session): builder.PrependUint64Slot(0, session, 0)
+def AddSession(builder, session):
+    return SubscribedAddSession(builder, session)
+def SubscribedAddRequest(builder, request): builder.PrependUint64Slot(1, request, 0)
+def AddRequest(builder, request):
+    return SubscribedAddRequest(builder, request)
+def SubscribedAddSubscription(builder, subscription): builder.PrependUint64Slot(2, subscription, 0)
+def AddSubscription(builder, subscription):
+    return SubscribedAddSubscription(builder, subscription)
+def SubscribedEnd(builder): return builder.EndObject()
+def End(builder):
+    return SubscribedEnd(builder)

backend/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/proto/SubscriberFeatures.py

@@ -0,0 +1,112 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: proto
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+class SubscriberFeatures(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = SubscriberFeatures()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsSubscriberFeatures(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    # SubscriberFeatures
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # SubscriberFeatures
+    def PublisherIdentification(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+    # SubscriberFeatures
+    def PatternBasedSubscription(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+    # SubscriberFeatures
+    def PublicationTrustlevels(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+    # SubscriberFeatures
+    def SubscriptionRevocation(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+    # SubscriberFeatures
+    def EventHistory(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+    # SubscriberFeatures
+    def AcknowledgeSubscriberReceived(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+    # SubscriberFeatures
+    def PayloadTransparency(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+    # SubscriberFeatures
+    def PayloadEncryptionCryptobox(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+def SubscriberFeaturesStart(builder): builder.StartObject(8)
+def Start(builder):
+    return SubscriberFeaturesStart(builder)
+def SubscriberFeaturesAddPublisherIdentification(builder, publisherIdentification): builder.PrependBoolSlot(0, publisherIdentification, 0)
+def AddPublisherIdentification(builder, publisherIdentification):
+    return SubscriberFeaturesAddPublisherIdentification(builder, publisherIdentification)
+def SubscriberFeaturesAddPatternBasedSubscription(builder, patternBasedSubscription): builder.PrependBoolSlot(1, patternBasedSubscription, 0)
+def AddPatternBasedSubscription(builder, patternBasedSubscription):
+    return SubscriberFeaturesAddPatternBasedSubscription(builder, patternBasedSubscription)
+def SubscriberFeaturesAddPublicationTrustlevels(builder, publicationTrustlevels): builder.PrependBoolSlot(2, publicationTrustlevels, 0)
+def AddPublicationTrustlevels(builder, publicationTrustlevels):
+    return SubscriberFeaturesAddPublicationTrustlevels(builder, publicationTrustlevels)
+def SubscriberFeaturesAddSubscriptionRevocation(builder, subscriptionRevocation): builder.PrependBoolSlot(3, subscriptionRevocation, 0)
+def AddSubscriptionRevocation(builder, subscriptionRevocation):
+    return SubscriberFeaturesAddSubscriptionRevocation(builder, subscriptionRevocation)
+def SubscriberFeaturesAddEventHistory(builder, eventHistory): builder.PrependBoolSlot(4, eventHistory, 0)
+def AddEventHistory(builder, eventHistory):
+    return SubscriberFeaturesAddEventHistory(builder, eventHistory)
+def SubscriberFeaturesAddAcknowledgeSubscriberReceived(builder, acknowledgeSubscriberReceived): builder.PrependBoolSlot(5, acknowledgeSubscriberReceived, 0)
+def AddAcknowledgeSubscriberReceived(builder, acknowledgeSubscriberReceived):
+    return SubscriberFeaturesAddAcknowledgeSubscriberReceived(builder, acknowledgeSubscriberReceived)
+def SubscriberFeaturesAddPayloadTransparency(builder, payloadTransparency): builder.PrependBoolSlot(6, payloadTransparency, 0)
+def AddPayloadTransparency(builder, payloadTransparency):
+    return SubscriberFeaturesAddPayloadTransparency(builder, payloadTransparency)
+def SubscriberFeaturesAddPayloadEncryptionCryptobox(builder, payloadEncryptionCryptobox): builder.PrependBoolSlot(7, payloadEncryptionCryptobox, 0)
+def AddPayloadEncryptionCryptobox(builder, payloadEncryptionCryptobox):
+    return SubscriberFeaturesAddPayloadEncryptionCryptobox(builder, payloadEncryptionCryptobox)
+def SubscriberFeaturesEnd(builder): return builder.EndObject()
+def End(builder):
+    return SubscriberFeaturesEnd(builder)

backend/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/proto/SubscriberReceived.py

@@ -0,0 +1,158 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: proto
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+class SubscriberReceived(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = SubscriberReceived()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsSubscriberReceived(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    # SubscriberReceived
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # SubscriberReceived
+    def Publication(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
+        return 0
+
+    # SubscriberReceived
+    def Subscriber(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
+        return 0
+
+    # SubscriberReceived
+    def SubscriberAuthid(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # SubscriberReceived
+    def SubscriberAuthrole(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # SubscriberReceived
+    def Payload(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
+        if o != 0:
+            a = self._tab.Vector(o)
+            return self._tab.Get(flatbuffers.number_types.Uint8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1))
+        return 0
+
+    # SubscriberReceived
+    def PayloadAsNumpy(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
+        if o != 0:
+            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o)
+        return 0
+
+    # SubscriberReceived
+    def PayloadLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # SubscriberReceived
+    def PayloadIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
+        return o == 0
+
+    # SubscriberReceived
+    def EncAlgo(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
+        return 0
+
+    # SubscriberReceived
+    def EncSerializer(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
+        return 0
+
+    # SubscriberReceived
+    def EncKey(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18))
+        if o != 0:
+            a = self._tab.Vector(o)
+            return self._tab.Get(flatbuffers.number_types.Uint8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1))
+        return 0
+
+    # SubscriberReceived
+    def EncKeyAsNumpy(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18))
+        if o != 0:
+            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o)
+        return 0
+
+    # SubscriberReceived
+    def EncKeyLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # SubscriberReceived
+    def EncKeyIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18))
+        return o == 0
+
+def SubscriberReceivedStart(builder): builder.StartObject(8)
+def Start(builder):
+    return SubscriberReceivedStart(builder)
+def SubscriberReceivedAddPublication(builder, publication): builder.PrependUint64Slot(0, publication, 0)
+def AddPublication(builder, publication):
+    return SubscriberReceivedAddPublication(builder, publication)
+def SubscriberReceivedAddSubscriber(builder, subscriber): builder.PrependUint64Slot(1, subscriber, 0)
+def AddSubscriber(builder, subscriber):
+    return SubscriberReceivedAddSubscriber(builder, subscriber)
+def SubscriberReceivedAddSubscriberAuthid(builder, subscriberAuthid): builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(subscriberAuthid), 0)
+def AddSubscriberAuthid(builder, subscriberAuthid):
+    return SubscriberReceivedAddSubscriberAuthid(builder, subscriberAuthid)
+def SubscriberReceivedAddSubscriberAuthrole(builder, subscriberAuthrole): builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(subscriberAuthrole), 0)
+def AddSubscriberAuthrole(builder, subscriberAuthrole):
+    return SubscriberReceivedAddSubscriberAuthrole(builder, subscriberAuthrole)
+def SubscriberReceivedAddPayload(builder, payload): builder.PrependUOffsetTRelativeSlot(4, flatbuffers.number_types.UOffsetTFlags.py_type(payload), 0)
+def AddPayload(builder, payload):
+    return SubscriberReceivedAddPayload(builder, payload)
+def SubscriberReceivedStartPayloadVector(builder, numElems): return builder.StartVector(1, numElems, 1)
+def StartPayloadVector(builder, numElems):
+    return SubscriberReceivedStartPayloadVector(builder, numElems)
+def SubscriberReceivedAddEncAlgo(builder, encAlgo): builder.PrependUint8Slot(5, encAlgo, 0)
+def AddEncAlgo(builder, encAlgo):
+    return SubscriberReceivedAddEncAlgo(builder, encAlgo)
+def SubscriberReceivedAddEncSerializer(builder, encSerializer): builder.PrependUint8Slot(6, encSerializer, 0)
+def AddEncSerializer(builder, encSerializer):
+    return SubscriberReceivedAddEncSerializer(builder, encSerializer)
+def SubscriberReceivedAddEncKey(builder, encKey): builder.PrependUOffsetTRelativeSlot(7, flatbuffers.number_types.UOffsetTFlags.py_type(encKey), 0)
+def AddEncKey(builder, encKey):
+    return SubscriberReceivedAddEncKey(builder, encKey)
+def SubscriberReceivedStartEncKeyVector(builder, numElems): return builder.StartVector(1, numElems, 1)
+def StartEncKeyVector(builder, numElems):
+    return SubscriberReceivedStartEncKeyVector(builder, numElems)
+def SubscriberReceivedEnd(builder): return builder.EndObject()
+def End(builder):
+    return SubscriberReceivedEnd(builder)

backend/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/proto/Unregister.py

@@ -0,0 +1,62 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: proto
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+class Unregister(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = Unregister()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsUnregister(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    # Unregister
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # Unregister
+    def Session(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
+        return 0
+
+    # Unregister
+    def Request(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
+        return 0
+
+    # Unregister
+    def Registration(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
+        return 0
+
+def UnregisterStart(builder): builder.StartObject(3)
+def Start(builder):
+    return UnregisterStart(builder)
+def UnregisterAddSession(builder, session): builder.PrependUint64Slot(0, session, 0)
+def AddSession(builder, session):
+    return UnregisterAddSession(builder, session)
+def UnregisterAddRequest(builder, request): builder.PrependUint64Slot(1, request, 0)
+def AddRequest(builder, request):
+    return UnregisterAddRequest(builder, request)
+def UnregisterAddRegistration(builder, registration): builder.PrependUint64Slot(2, registration, 0)
+def AddRegistration(builder, registration):
+    return UnregisterAddRegistration(builder, registration)
+def UnregisterEnd(builder): return builder.EndObject()
+def End(builder):
+    return UnregisterEnd(builder)

backend/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/proto/Unregistered.py

@@ -0,0 +1,72 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: proto
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+class Unregistered(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = Unregistered()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsUnregistered(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    # Unregistered
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # Unregistered
+    def Session(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
+        return 0
+
+    # Unregistered
+    def Request(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
+        return 0
+
+    # Unregistered
+    def Registration(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
+        return 0
+
+    # Unregistered
+    def Reason(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+def UnregisteredStart(builder): builder.StartObject(4)
+def Start(builder):
+    return UnregisteredStart(builder)
+def UnregisteredAddSession(builder, session): builder.PrependUint64Slot(0, session, 0)
+def AddSession(builder, session):
+    return UnregisteredAddSession(builder, session)
+def UnregisteredAddRequest(builder, request): builder.PrependUint64Slot(1, request, 0)
+def AddRequest(builder, request):
+    return UnregisteredAddRequest(builder, request)
+def UnregisteredAddRegistration(builder, registration): builder.PrependUint64Slot(2, registration, 0)
+def AddRegistration(builder, registration):
+    return UnregisteredAddRegistration(builder, registration)
+def UnregisteredAddReason(builder, reason): builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(reason), 0)
+def AddReason(builder, reason):
+    return UnregisteredAddReason(builder, reason)
+def UnregisteredEnd(builder): return builder.EndObject()
+def End(builder):
+    return UnregisteredEnd(builder)

backend/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/proto/Unsubscribe.py

@@ -0,0 +1,62 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: proto
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+class Unsubscribe(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = Unsubscribe()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsUnsubscribe(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    # Unsubscribe
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # Unsubscribe
+    def Session(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
+        return 0
+
+    # Unsubscribe
+    def Request(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
+        return 0
+
+    # Unsubscribe
+    def Subscription(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
+        return 0
+
+def UnsubscribeStart(builder): builder.StartObject(3)
+def Start(builder):
+    return UnsubscribeStart(builder)
+def UnsubscribeAddSession(builder, session): builder.PrependUint64Slot(0, session, 0)
+def AddSession(builder, session):
+    return UnsubscribeAddSession(builder, session)
+def UnsubscribeAddRequest(builder, request): builder.PrependUint64Slot(1, request, 0)
+def AddRequest(builder, request):
+    return UnsubscribeAddRequest(builder, request)
+def UnsubscribeAddSubscription(builder, subscription): builder.PrependUint64Slot(2, subscription, 0)
+def AddSubscription(builder, subscription):
+    return UnsubscribeAddSubscription(builder, subscription)
+def UnsubscribeEnd(builder): return builder.EndObject()
+def End(builder):
+    return UnsubscribeEnd(builder)

backend/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/proto/Unsubscribed.py

@@ -0,0 +1,72 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: proto
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+class Unsubscribed(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = Unsubscribed()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsUnsubscribed(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    # Unsubscribed
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # Unsubscribed
+    def Session(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
+        return 0
+
+    # Unsubscribed
+    def Request(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
+        return 0
+
+    # Unsubscribed
+    def Subscription(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
+        return 0
+
+    # Unsubscribed
+    def Reason(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+def UnsubscribedStart(builder): builder.StartObject(4)
+def Start(builder):
+    return UnsubscribedStart(builder)
+def UnsubscribedAddSession(builder, session): builder.PrependUint64Slot(0, session, 0)
+def AddSession(builder, session):
+    return UnsubscribedAddSession(builder, session)
+def UnsubscribedAddRequest(builder, request): builder.PrependUint64Slot(1, request, 0)
+def AddRequest(builder, request):
+    return UnsubscribedAddRequest(builder, request)
+def UnsubscribedAddSubscription(builder, subscription): builder.PrependUint64Slot(2, subscription, 0)
+def AddSubscription(builder, subscription):
+    return UnsubscribedAddSubscription(builder, subscription)
+def UnsubscribedAddReason(builder, reason): builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(reason), 0)
+def AddReason(builder, reason):
+    return UnsubscribedAddReason(builder, reason)
+def UnsubscribedEnd(builder): return builder.EndObject()
+def End(builder):
+    return UnsubscribedEnd(builder)

backend/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/proto/Welcome.py

@@ -0,0 +1,150 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: proto
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+class Welcome(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = Welcome()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsWelcome(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    # Welcome
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # Welcome
+    def Session(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
+        return 0
+
+    # Welcome
+    def Roles(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            x = self._tab.Indirect(o + self._tab.Pos)
+            from wamp.proto.RouterRoles import RouterRoles
+            obj = RouterRoles()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+    # Welcome
+    def Realm(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # Welcome
+    def Authid(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # Welcome
+    def Authrole(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # Welcome
+    def Authmethod(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
+        return 0
+
+    # Welcome
+    def Authprovider(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # Welcome
+    def Authextra(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18))
+        if o != 0:
+            x = self._tab.Indirect(o + self._tab.Pos)
+            from wamp.Map import Map
+            obj = Map()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+    # Welcome
+    def Resumed(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(20))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+    # Welcome
+    def Resumable(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+    # Welcome
+    def ResumeToken(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+def WelcomeStart(builder): builder.StartObject(11)
+def Start(builder):
+    return WelcomeStart(builder)
+def WelcomeAddSession(builder, session): builder.PrependUint64Slot(0, session, 0)
+def AddSession(builder, session):
+    return WelcomeAddSession(builder, session)
+def WelcomeAddRoles(builder, roles): builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(roles), 0)
+def AddRoles(builder, roles):
+    return WelcomeAddRoles(builder, roles)
+def WelcomeAddRealm(builder, realm): builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(realm), 0)
+def AddRealm(builder, realm):
+    return WelcomeAddRealm(builder, realm)
+def WelcomeAddAuthid(builder, authid): builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(authid), 0)
+def AddAuthid(builder, authid):
+    return WelcomeAddAuthid(builder, authid)
+def WelcomeAddAuthrole(builder, authrole): builder.PrependUOffsetTRelativeSlot(4, flatbuffers.number_types.UOffsetTFlags.py_type(authrole), 0)
+def AddAuthrole(builder, authrole):
+    return WelcomeAddAuthrole(builder, authrole)
+def WelcomeAddAuthmethod(builder, authmethod): builder.PrependUint8Slot(5, authmethod, 0)
+def AddAuthmethod(builder, authmethod):
+    return WelcomeAddAuthmethod(builder, authmethod)
+def WelcomeAddAuthprovider(builder, authprovider): builder.PrependUOffsetTRelativeSlot(6, flatbuffers.number_types.UOffsetTFlags.py_type(authprovider), 0)
+def AddAuthprovider(builder, authprovider):
+    return WelcomeAddAuthprovider(builder, authprovider)
+def WelcomeAddAuthextra(builder, authextra): builder.PrependUOffsetTRelativeSlot(7, flatbuffers.number_types.UOffsetTFlags.py_type(authextra), 0)
+def AddAuthextra(builder, authextra):
+    return WelcomeAddAuthextra(builder, authextra)
+def WelcomeAddResumed(builder, resumed): builder.PrependBoolSlot(8, resumed, 0)
+def AddResumed(builder, resumed):
+    return WelcomeAddResumed(builder, resumed)
+def WelcomeAddResumable(builder, resumable): builder.PrependBoolSlot(9, resumable, 0)
+def AddResumable(builder, resumable):
+    return WelcomeAddResumable(builder, resumable)
+def WelcomeAddResumeToken(builder, resumeToken): builder.PrependUOffsetTRelativeSlot(10, flatbuffers.number_types.UOffsetTFlags.py_type(resumeToken), 0)
+def AddResumeToken(builder, resumeToken):
+    return WelcomeAddResumeToken(builder, resumeToken)
+def WelcomeEnd(builder): return builder.EndObject()
+def End(builder):
+    return WelcomeEnd(builder)

backend/lib/python3.12/site-packages/autobahn/wamp/gen/wamp/proto/Yield.py

@@ -0,0 +1,208 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: proto
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+class Yield(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = Yield()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsYield(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    # Yield
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # Yield
+    def Session(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
+        return 0
+
+    # Yield
+    def Request(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
+        return 0
+
+    # Yield
+    def Payload(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            a = self._tab.Vector(o)
+            return self._tab.Get(flatbuffers.number_types.Uint8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1))
+        return 0
+
+    # Yield
+    def PayloadAsNumpy(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o)
+        return 0
+
+    # Yield
+    def PayloadLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # Yield
+    def PayloadIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        return o == 0
+
+    # Yield
+    def EncAlgo(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
+        return 0
+
+    # Yield
+    def EncSerializer(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
+        return 0
+
+    # Yield
+    def EncKey(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
+        if o != 0:
+            a = self._tab.Vector(o)
+            return self._tab.Get(flatbuffers.number_types.Uint8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1))
+        return 0
+
+    # Yield
+    def EncKeyAsNumpy(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
+        if o != 0:
+            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o)
+        return 0
+
+    # Yield
+    def EncKeyLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # Yield
+    def EncKeyIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
+        return o == 0
+
+    # Yield
+    def Progress(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+    # Yield
+    def Callee(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
+        return 0
+
+    # Yield
+    def CalleeAuthid(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(20))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # Yield
+    def CalleeAuthrole(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # Yield
+    def ForwardFor(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24))
+        if o != 0:
+            x = self._tab.Vector(o)
+            x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 8
+            from wamp.proto.Principal import Principal
+            obj = Principal()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+    # Yield
+    def ForwardForLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # Yield
+    def ForwardForIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24))
+        return o == 0
+
+def YieldStart(builder): builder.StartObject(11)
+def Start(builder):
+    return YieldStart(builder)
+def YieldAddSession(builder, session): builder.PrependUint64Slot(0, session, 0)
+def AddSession(builder, session):
+    return YieldAddSession(builder, session)
+def YieldAddRequest(builder, request): builder.PrependUint64Slot(1, request, 0)
+def AddRequest(builder, request):
+    return YieldAddRequest(builder, request)
+def YieldAddPayload(builder, payload): builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(payload), 0)
+def AddPayload(builder, payload):
+    return YieldAddPayload(builder, payload)
+def YieldStartPayloadVector(builder, numElems): return builder.StartVector(1, numElems, 1)
+def StartPayloadVector(builder, numElems):
+    return YieldStartPayloadVector(builder, numElems)
+def YieldAddEncAlgo(builder, encAlgo): builder.PrependUint8Slot(3, encAlgo, 0)
+def AddEncAlgo(builder, encAlgo):
+    return YieldAddEncAlgo(builder, encAlgo)
+def YieldAddEncSerializer(builder, encSerializer): builder.PrependUint8Slot(4, encSerializer, 0)
+def AddEncSerializer(builder, encSerializer):
+    return YieldAddEncSerializer(builder, encSerializer)
+def YieldAddEncKey(builder, encKey): builder.PrependUOffsetTRelativeSlot(5, flatbuffers.number_types.UOffsetTFlags.py_type(encKey), 0)
+def AddEncKey(builder, encKey):
+    return YieldAddEncKey(builder, encKey)
+def YieldStartEncKeyVector(builder, numElems): return builder.StartVector(1, numElems, 1)
+def StartEncKeyVector(builder, numElems):
+    return YieldStartEncKeyVector(builder, numElems)
+def YieldAddProgress(builder, progress): builder.PrependBoolSlot(6, progress, 0)
+def AddProgress(builder, progress):
+    return YieldAddProgress(builder, progress)
+def YieldAddCallee(builder, callee): builder.PrependUint64Slot(7, callee, 0)
+def AddCallee(builder, callee):
+    return YieldAddCallee(builder, callee)
+def YieldAddCalleeAuthid(builder, calleeAuthid): builder.PrependUOffsetTRelativeSlot(8, flatbuffers.number_types.UOffsetTFlags.py_type(calleeAuthid), 0)
+def AddCalleeAuthid(builder, calleeAuthid):
+    return YieldAddCalleeAuthid(builder, calleeAuthid)
+def YieldAddCalleeAuthrole(builder, calleeAuthrole): builder.PrependUOffsetTRelativeSlot(9, flatbuffers.number_types.UOffsetTFlags.py_type(calleeAuthrole), 0)
+def AddCalleeAuthrole(builder, calleeAuthrole):
+    return YieldAddCalleeAuthrole(builder, calleeAuthrole)
+def YieldAddForwardFor(builder, forwardFor): builder.PrependUOffsetTRelativeSlot(10, flatbuffers.number_types.UOffsetTFlags.py_type(forwardFor), 0)
+def AddForwardFor(builder, forwardFor):
+    return YieldAddForwardFor(builder, forwardFor)
+def YieldStartForwardForVector(builder, numElems): return builder.StartVector(8, numElems, 8)
+def StartForwardForVector(builder, numElems):
+    return YieldStartForwardForVector(builder, numElems)
+def YieldEnd(builder): return builder.EndObject()
+def End(builder):
+    return YieldEnd(builder)