@ntcore-ts/client 1.0.0-beta.2

package/dist/index.esm.js

@@ -0,0 +1,4845 @@
+import { Logger } from 'tslog';
+import { z } from 'zod';
+import { decodeMulti, encode } from '@msgpack/msgpack';
+import WebSocket from 'isomorphic-ws';
+import * as protobufNs from 'protobufjs';
+import 'protobufjs/ext/descriptor/index.js';
+import descriptorJson from 'protobufjs/google/protobuf/descriptor.json' assert { type: 'json' };
+
+/**
+ * Log levels available for configuration.
+ * These map to tslog's log levels:
+ * - TRACE = 1 (tslog's trace)
+ * - DEBUG = 2 (tslog's debug)
+ * - INFO = 3 (tslog's info)
+ * - WARN = 4 (tslog's warn)
+ * - ERROR = 5 (tslog's error)
+ * - FATAL = 6 (tslog's fatal)
+ * - SILENT = 99 (disable all logging, not a tslog level)
+ */
+var LogLevel;
+(function (LogLevel) {
+    /** Very detailed debugging information (maps to tslog's trace level 1) */
+    LogLevel[LogLevel["TRACE"] = 1] = "TRACE";
+    /** Detailed debugging information (maps to tslog's debug level 2) */
+    LogLevel[LogLevel["DEBUG"] = 2] = "DEBUG";
+    /** General informational messages (maps to tslog's info level 3) */
+    LogLevel[LogLevel["INFO"] = 3] = "INFO";
+    /** Warning messages (maps to tslog's warn level 4) */
+    LogLevel[LogLevel["WARN"] = 4] = "WARN";
+    /** Error messages (maps to tslog's error level 5) */
+    LogLevel[LogLevel["ERROR"] = 5] = "ERROR";
+    /** Fatal error messages (maps to tslog's fatal level 6) */
+    LogLevel[LogLevel["FATAL"] = 6] = "FATAL";
+    /** Disable all logging (uses 99, not a tslog level) */
+    LogLevel[LogLevel["SILENT"] = 99] = "SILENT";
+})(LogLevel || (LogLevel = {}));
+/**
+ * Map of module names to their logger instances.
+ */
+const moduleLoggers = new Map();
+/**
+ * Creates a base logger with the specified min level.
+ * @param minLevel - The minimum log level to display.
+ * @returns A base logger instance.
+ */
+function createBaseLogger(minLevel) {
+    return new Logger({
+        minLevel,
+        type: 'pretty',
+        // v5: hideLogPositionForProduction → stack.capture; prettyLogTemplate → pretty.template
+        stack: { capture: 'off' },
+        pretty: {
+            template: '{{yyyy}}.{{mm}}.{{dd}} {{hh}}:{{MM}}:{{ss}}:{{ms}}\t[{{logLevelName}}]\t{{name}}\t',
+        },
+    });
+}
+// Use a mutable variable so we can recreate the base logger when settings change
+let baseLogger = createBaseLogger(LogLevel.INFO);
+/**
+ * Gets or creates a logger instance for a specific module.
+ * @param module - The module name.
+ * @returns A logger instance configured for the module.
+ */
+function getLogger(module = 'default') {
+    let logger = moduleLoggers.get(module);
+    if (!logger) {
+        logger = baseLogger.getSubLogger({
+            name: module.toUpperCase(),
+        });
+        moduleLoggers.set(module, logger);
+    }
+    return logger;
+}
+/**
+ * Sets the log level for all loggers.
+ * @param level - The log level to set.
+ */
+function setLogLevel(level) {
+    // LogLevel enum values already match tslog's numeric levels (except SILENT)
+    const numericLevel = level === LogLevel.SILENT ? 99 : level;
+    // Recreate base logger with new level
+    baseLogger = createBaseLogger(numericLevel);
+    // Recreate all module loggers to inherit new settings
+    moduleLoggers.forEach((_logger, module) => {
+        const newLogger = baseLogger.getSubLogger({
+            name: module.toUpperCase(),
+        });
+        moduleLoggers.set(module, newLogger);
+    });
+}
+/**
+ * Sets the log level for a specific module.
+ * @param module - The module name.
+ * @param level - The log level to set.
+ */
+function setModuleLogLevel(module, level) {
+    // LogLevel enum values already match tslog's numeric levels (except SILENT)
+    const numericLevel = level === LogLevel.SILENT ? 99 : level;
+    // Create a new sub-logger with the specific level
+    const newLogger = baseLogger.getSubLogger({
+        name: module.toUpperCase(),
+        minLevel: numericLevel,
+    });
+    moduleLoggers.set(module, newLogger);
+}
+/**
+ * Gets the current log level for a specific module.
+ * @param module - The module name.
+ * @returns The current log level.
+ */
+function getModuleLogLevel(module = 'default') {
+    const logger = getLogger(module);
+    const minLevel = logger.settings.minLevel;
+    // Map tslog's numeric levels to our LogLevel enum
+    // tslog: 0=silly, 1=trace, 2=debug, 3=info, 4=warn, 5=error, 6=fatal
+    // Our enum: TRACE=1, DEBUG=2, INFO=3, WARN=4, ERROR=5, FATAL=6, SILENT=99
+    if (minLevel >= 99)
+        return LogLevel.SILENT;
+    if (minLevel >= 6)
+        return LogLevel.FATAL;
+    if (minLevel >= 5)
+        return LogLevel.ERROR;
+    if (minLevel >= 4)
+        return LogLevel.WARN;
+    if (minLevel >= 3)
+        return LogLevel.INFO;
+    if (minLevel >= 2)
+        return LogLevel.DEBUG;
+    if (minLevel >= 1)
+        return LogLevel.TRACE;
+    // minLevel 0 is tslog's "silly" level, map to TRACE
+    return LogLevel.TRACE;
+}
+/**
+ * Creates a proxy logger that always returns the current logger instance from the map.
+ * This ensures exported loggers update when setLogLevel() or setModuleLogLevel() is called.
+ * @param module - The module name.
+ * @returns A logger instance.
+ */
+function createLoggerProxy(module) {
+    return new Proxy({}, {
+        get(_target, prop) {
+            const logger = getLogger(module);
+            const value = logger[prop];
+            // Bind methods to the actual logger instance to preserve 'this' context
+            if (typeof value === 'function') {
+                return value.bind(logger);
+            }
+            return value;
+        },
+    });
+}
+// Export convenience loggers for each module
+// These proxies ensure they always reference the current logger instance
+const socketLogger = createLoggerProxy('socket');
+const messengerLogger = createLoggerProxy('messenger');
+const pubsubLogger = createLoggerProxy('pubsub');
+const defaultLogger = createLoggerProxy('default');
+
+class NetworkTablesBaseTopic {
+    isRegular() {
+        return this.type === 'regular';
+    }
+    isPrefix() {
+        return this.type === 'prefix';
+    }
+    /**
+     * Gets the ID of the topic.
+     * @returns The ID of the topic.
+     */
+    get id() {
+        return this._id;
+    }
+    /**
+     * Gets the name of the topic.
+     * @returns The name of the topic.
+     */
+    get name() {
+        return this._name;
+    }
+    /**
+     * Gets the server time of the last value change.
+     * @returns The server time of the last value change.
+     */
+    get lastChangedTime() {
+        return this._lastChangedTime;
+    }
+    /**
+     * Whether the topic has been announced.
+     * @returns Whether the topic has been announced.
+     */
+    get announced() {
+        return this._announceParams != null;
+    }
+    /**
+     * Gets the subscribers to the topic.
+     * @returns The subscribers to the topic.
+     */
+    get subscribers() {
+        return this._subscribers;
+    }
+    /**
+     * Creates a new topic. This should only be done after the
+     * base NTCore client has been initialized.
+     * @param client - The client that owns the topic.
+     * @param name - The name of the topic.
+     */
+    constructor(client, name) {
+        this.client = client;
+        this._name = name;
+        this._announceParams = null;
+        this._subscribers = new Map();
+    }
+    // ------------- //
+    // ANNOUNCEMENTS //
+    // ------------- //
+    /**
+     * Marks the topic as announced. This should only be called by the PubSubClient.
+     * @param params - The parameters of the announcement.
+     */
+    announce(params) {
+        pubsubLogger.debug('Topic announced in base topic', { topicName: this.name, topicId: params.id });
+        this._announceParams = params;
+        this._id = params.id;
+    }
+    /** Marks the topic as unannounced. This should only be called by the PubSubClient. */
+    unannounce() {
+        pubsubLogger.debug('Topic unannounced in base topic', { topicName: this.name, topicId: this._id });
+        this._announceParams = null;
+        this._id = undefined;
+    }
+    /**
+     * Removes a subscriber
+     * @param subuid - The UID of the subscriber.
+     * @param removeCallback - Whether to remove the callback. Leave this as true unless you know what you're doing.
+     */
+    unsubscribe(subuid, removeCallback = true) {
+        pubsubLogger.debug('Unsubscribed from topic', {
+            topicName: this.name,
+            subuid,
+            removeCallback,
+            remainingSubscribers: this.subscribers.size - (this.subscribers.has(subuid) ? 1 : 0),
+        });
+        this.client.messenger.unsubscribe(subuid);
+        if (removeCallback)
+            this.subscribers.delete(subuid);
+    }
+    /**
+     * Removes all local subscribers.
+     */
+    unsubscribeAll() {
+        const subscriberCount = this.subscribers.size;
+        pubsubLogger.debug('Unsubscribing all', { topicName: this.name, subscriberCount });
+        this.subscribers.forEach((_, subuid) => this.unsubscribe(subuid));
+    }
+    /**
+     * Strips client-only subscribe options (e.g. `immediateNotify`) before sending to the NT server.
+     * @param options - The subscriber options, possibly including client-only fields.
+     * @returns Protocol subscribe options.
+     */
+    toProtocolSubscribeOptions(options = {}) {
+        const rest = { ...options };
+        delete rest.immediateNotify;
+        return rest;
+    }
+    // ---------- //
+    // PUBLISHING //
+    // ---------- //
+    /**
+     * Sets the properties of the topic.
+     * @param properties - Topic properties to update (e.g. `{ persistent: true, retained: true }`).
+     * @returns The server's response.
+     */
+    async setProperties(properties = {}) {
+        const setPropertiesParams = {
+            name: this.name,
+            update: properties,
+        };
+        // Send the set properties request
+        return await this.client.messenger.setProperties(setPropertiesParams);
+    }
+}
+
+class NetworkTablesPrefixTopic extends NetworkTablesBaseTopic {
+    /**
+     * Creates a new topic. This should only be done after the
+     * base NTCore client has been initialized.
+     * @param client - The client that owns the topic.
+     * @param name - The name of the topic.
+     */
+    constructor(client, name) {
+        super(client, name);
+        this.type = 'prefix';
+        this._lastSubtopicValues = new Map();
+        const existingTopic = this.client.getPrefixTopicFromName(name);
+        if (existingTopic) {
+            pubsubLogger.debug('Existing prefix topic reused', { prefix: name });
+            return existingTopic;
+        }
+        pubsubLogger.debug('Prefix topic created', { prefix: name });
+        this.client.registerTopic(this);
+    }
+    /** */
+    /* SUBSCRIBING */
+    /** */
+    /**
+     * Creates a new subscriber.
+     * @param callback - The callback to call when the topic value changes.
+     * @param options - The options for the subscriber. `immediateNotify` is client-side only
+     *   and replays cached matching subtopic values (not sent to the NT server).
+     * @returns The UID of the subscriber.
+     */
+    subscribe(callback, options = {}) {
+        const subuid = this.subscribeWithId(callback, options, undefined, true);
+        if (options.immediateNotify) {
+            this._lastSubtopicValues.forEach(({ params, value }) => {
+                if (params.name === this.name)
+                    return;
+                try {
+                    callback(value, params);
+                }
+                catch (error) {
+                    pubsubLogger.warn('Prefix immediateNotify callback threw', {
+                        prefix: this.name,
+                        subtopicName: params.name,
+                        error,
+                    });
+                }
+            });
+        }
+        return subuid;
+    }
+    /**
+     * Creates a new subscriber, optionally reusing a subscription UID.
+     * @internal Used by resubscribeAll. Does not honor `immediateNotify`.
+     * @param callback - The callback to call when the topic value changes.
+     * @param options - The options for the subscriber.
+     * @param id - The UID of the subscriber.
+     * @param save - Whether to save the subscriber.
+     * @returns The UID of the subscriber.
+     */
+    subscribeWithId(callback, options = {}, id, save = true) {
+        const subuid = id || this.client.messenger.getNextSubUID();
+        const serverOptions = this.toProtocolSubscribeOptions(options);
+        const subscribeParams = {
+            topics: [this.name],
+            subuid,
+            options: {
+                ...serverOptions,
+                prefix: true,
+            },
+        };
+        this.client.messenger.subscribe(subscribeParams);
+        if (save)
+            this.subscribers.set(subuid, { callback, options: serverOptions });
+        pubsubLogger.debug('Subscriber added to prefix topic', {
+            prefix: this.name,
+            subuid,
+            options: serverOptions,
+            totalSubscribers: this.subscribers.size,
+        });
+        return subuid;
+    }
+    resubscribeAll(client) {
+        const subscriberCount = this.subscribers.size;
+        pubsubLogger.debug('Resubscribe all prefix topic', { prefix: this.name, subscriberCount });
+        this.client = client;
+        this.subscribers.forEach((info, subuid) => {
+            this.subscribeWithId(info.callback, info.options, subuid, false);
+        });
+    }
+    /**
+     * Updates the value of a subtopic. Notifies all subscribers of the change.
+     * @param params - The params of the subtopic
+     * @param value - The value of the subtopic
+     * @param serverTime - The time the value was updated
+     */
+    updateValue(params, value, serverTime) {
+        pubsubLogger.debug('Value update applied to prefix topic', {
+            prefix: this.name,
+            subtopicName: params.name,
+            subtopicId: params.id,
+            serverTime,
+        });
+        if (value == null) {
+            this._lastSubtopicValues.delete(params.name);
+        }
+        else {
+            this._lastSubtopicValues.set(params.name, { params, value });
+        }
+        this._lastChangedTime = serverTime;
+        this.notifySubscribers(params, value);
+    }
+    notifySubscribers(params, value) {
+        const subscriberCount = this.subscribers.size;
+        pubsubLogger.debug('Subscribers notified for prefix topic', {
+            prefix: this.name,
+            subtopicName: params.name,
+            count: subscriberCount,
+        });
+        this.subscribers.forEach((info, subuid) => {
+            pubsubLogger.trace('Callback invoked for prefix topic', {
+                prefix: this.name,
+                subuid,
+                subtopicName: params.name,
+                value,
+                params,
+            });
+            try {
+                info.callback(value, params);
+            }
+            catch (error) {
+                pubsubLogger.warn('Prefix subscriber callback threw', {
+                    prefix: this.name,
+                    subuid,
+                    subtopicName: params.name,
+                    error,
+                });
+            }
+        });
+    }
+}
+
+class NetworkTablesTopic extends NetworkTablesBaseTopic {
+    /**
+     * Gets the type info for the topic.
+     * @returns The type info for the topic.
+     */
+    get typeInfo() {
+        return this._typeInfo;
+    }
+    /**
+     * Gets whether the client is the publisher of the topic.
+     * @returns Whether the client is the publisher of the topic.
+     */
+    get publisher() {
+        return this._publisher;
+    }
+    /**
+     * Gets the UID of the publisher.
+     * @returns The UID of the publisher, or undefined if the client is not the publisher.
+     */
+    get pubuid() {
+        return this._pubuid;
+    }
+    /**
+     * Creates a new topic. This should only be done after the
+     * base NTCore client has been initialized.
+     * @param client - The client that owns the topic.
+     * @param name - The name of the topic.
+     * @param typeInfo - The type info for the topic.
+     * @param defaultValue - The default value for the topic.
+     */
+    constructor(client, name, typeInfo, defaultValue) {
+        super(client, name);
+        this.type = 'regular';
+        this._typeInfo = typeInfo;
+        this._wireValue = (defaultValue ?? null);
+        this._publisher = false;
+        const existingTopic = this.client.getTopicFromName(name);
+        if (existingTopic) {
+            if (existingTopic.typeInfo[0] === typeInfo[0] && existingTopic.typeInfo[1] === typeInfo[1]) {
+                pubsubLogger.debug('Existing topic reused', { topicName: name, type: typeInfo[1] });
+                // Valid cast: we verified typeInfo matches; map stores base topic type.
+                return existingTopic;
+            }
+            else {
+                pubsubLogger.debug('Type mismatch detected', {
+                    topicName: name,
+                    existingType: existingTopic.typeInfo[1],
+                    requestedType: typeInfo[1],
+                });
+                throw new Error(`Topic ${name} already exists, but with a different type.`);
+            }
+        }
+        pubsubLogger.debug('Topic created', { topicName: name, type: typeInfo[1] });
+        this.client.registerTopic(this);
+    }
+    /**
+     * Sets the value of the topic.
+     * The client must be the publisher of the topic to set the value.
+     * @param value - The value to set.
+     */
+    setValue(value) {
+        if (!this.publisher) {
+            pubsubLogger.debug('Publisher check failed before setValue', { topicName: this.name });
+            throw new Error('Cannot set value on topic without being the publisher');
+        }
+        const oldValue = this.getValue();
+        pubsubLogger.debug('Value set', { topicName: this.name, oldValue, newValue: value, type: this._typeInfo[1] });
+        this.setWireValue(value);
+        this.afterSetWireValue();
+    }
+    /** Internal: set wire-format value and notify subscribers. Subclasses may call this when encoding decoded values. */
+    setWireValue(value) {
+        this._wireValue = value;
+        this.notifySubscribers();
+    }
+    /** Called after setWireValue from subclasses that encode before setting. Runs prefix notify and updateServer. */
+    afterSetWireValue() {
+        if (this._wireValue == null)
+            return;
+        // Notify prefix subscribers (e.g. "all topics" table) so locally published values appear there.
+        this.client.notifyPrefixTopicsForLocalUpdate(this.getAnnounceParamsForNotify(), (this.getValue() ?? this._wireValue));
+        // If we're disconnected, just keep our local retained value.
+        // We will always resend the latest retained value after reconnect.
+        if (!this.client.messenger.socket.isConnected()) {
+            pubsubLogger.debug('Skipped server update (awaiting reconnect)', { topicName: this.name });
+            return;
+        }
+        this.client.updateServer(this, this._wireValue);
+    }
+    /** Params for prefix notify; use real announce params when we have them, else minimal fallback. */
+    getAnnounceParamsForNotify() {
+        return this._announceParams ?? { name: this.name, id: -1, type: this._typeInfo[1], properties: {} };
+    }
+    /**
+     * Resends the latest retained value after reconnect.
+     *
+     * This is intended to be called after reconnect, once publish frames have been re-sent.
+     * This ensures that if the server/robot restarted, it receives the current state.
+     */
+    resendLatestValue() {
+        if (!this._publisher ||
+            this._pubuid == null ||
+            !this.client.messenger.socket.isConnected() ||
+            this._wireValue == null) {
+            return;
+        }
+        pubsubLogger.debug('Resending latest retained value after reconnect', {
+            topicName: this.name,
+            pubuid: this._pubuid,
+        });
+        this.client.updateServer(this, this._wireValue);
+    }
+    /**
+     * Gets the value of the topic.
+     * @returns The value of the topic.
+     */
+    getValue() {
+        return this._wireValue;
+    }
+    /**
+     * Updates the value of the topic.
+     * This should only be called by the PubSubClient.
+     * @param value - The value to update (wire format).
+     * @param lastChangedTime - The server time of the last value change.
+     */
+    updateValue(value, lastChangedTime) {
+        const oldValue = this._wireValue;
+        pubsubLogger.debug('Value updated', {
+            topicName: this.name,
+            oldValue,
+            newValue: value,
+            lastChangedTime,
+            type: this._typeInfo[1],
+        });
+        this.setWireValue(value);
+        this._lastChangedTime = lastChangedTime;
+    }
+    /** */
+    /* ANNOUNCEMENTS */
+    /** */
+    /**
+     * Marks the topic as announced. This should only be called by the PubSubClient.
+     * @param params - The parameters of the announcement.
+     */
+    announce(params) {
+        super.announce(params);
+        const wasPublisher = this._publisher;
+        if (params.pubuid === this._pubuid) {
+            this._publisher = true;
+            pubsubLogger.debug('Publisher status updated', {
+                topicName: this.name,
+                pubuid: this._pubuid,
+                wasPublisher,
+                isPublisher: true,
+            });
+        }
+        pubsubLogger.debug('Topic announced', { topicName: this.name, topicId: params.id, pubuid: params.pubuid });
+    }
+    /** */
+    /* SUBSCRIBING */
+    /** */
+    /**
+     * Creates a new subscriber.
+     * @param callback - The callback to call when the topic value changes.
+     * @param options - The options for the subscriber. `immediateNotify` is client-side only and is
+     *   not sent to the NT server. `id` and `save` are not part of this public signature.
+     * @returns The UID of the subscriber.
+     */
+    subscribe(callback, options = {}) {
+        const subuid = this.subscribeWithId(callback, options, undefined, true);
+        if (options.immediateNotify) {
+            const params = this._announceParams ??
+                {
+                    name: this.name,
+                    id: -1,
+                    type: this._typeInfo[1],
+                    properties: this._publishProperties ?? {},
+                    ...(this._pubuid != null ? { pubuid: this._pubuid } : {}),
+                };
+            callback(this.getValue(), params);
+        }
+        return subuid;
+    }
+    /**
+     * Creates a new subscriber, optionally reusing a subscription UID.
+     * @internal Used by resubscribeAll. Does not honor `immediateNotify`.
+     * @param callback - The callback to call when the topic value changes.
+     * @param options - The options for the subscriber.
+     * @param id - The UID of the subscriber. You must verify that the ID is not already in use.
+     * @param save - Whether to save the subscriber.
+     * @returns The UID of the subscriber.
+     */
+    subscribeWithId(callback, options = {}, id, save = true) {
+        const subuid = id || this.client.messenger.getNextSubUID();
+        const serverOptions = this.toProtocolSubscribeOptions(options);
+        const subscribeParams = {
+            topics: [this.name],
+            subuid,
+            options: serverOptions,
+        };
+        this.client.messenger.subscribe(subscribeParams);
+        if (save)
+            this.subscribers.set(subuid, { callback, options: serverOptions });
+        pubsubLogger.debug('Subscriber added', {
+            topicName: this.name,
+            subuid,
+            options: serverOptions,
+            totalSubscribers: this.subscribers.size,
+        });
+        return subuid;
+    }
+    resubscribeAll(client) {
+        const subscriberCount = this.subscribers.size;
+        pubsubLogger.debug('Resubscribe all', { topicName: this.name, subscriberCount });
+        this.client = client;
+        this.subscribers.forEach((info, subuid) => {
+            this.subscribeWithId(info.callback, info.options, subuid, false);
+        });
+    }
+    /**
+     * Notifies all subscribers of the current value.
+     * Protected so derived classes (e.g. NetworkTablesProtobufTopic) can override
+     * and pass decoded/transformed values to callbacks.
+     */
+    notifySubscribers() {
+        const subscriberCount = this.subscribers.size;
+        pubsubLogger.debug('Subscribers notified', { topicName: this.name, count: subscriberCount });
+        // If the topic has not been announced yet, synthesize params so callbacks always
+        // receive a well-formed object (rather than `null`).
+        const params = this._announceParams ??
+            {
+                name: this.name,
+                id: -1,
+                type: this._typeInfo[1],
+                properties: this._publishProperties ?? {},
+                ...(this._pubuid != null ? { pubuid: this._pubuid } : {}),
+            };
+        this.subscribers.forEach((info, subuid) => {
+            pubsubLogger.trace('Callback invoked', {
+                topicName: this.name,
+                subuid,
+                value: this.getValue(),
+                params,
+            });
+            info.callback(this.getValue(), params);
+        });
+    }
+    /** */
+    /* PUBLISHING */
+    /** */
+    /**
+     * Publishes the topic.
+     * @param properties - The properties to publish the topic with.
+     * @param id - The UID of the publisher. You must verify that the ID is not already in use.
+     * @returns A promise that resolves when the topic is published.
+     */
+    async publish(properties = {}, id) {
+        // Use unified in-flight protection from PubSubClient
+        // Key format: "publish:" prefix to avoid conflicts with schema registrations
+        const operationKey = `publish:${this.name}`;
+        return this.client.getOrCreateInFlightOperation(operationKey, async () => {
+            // Check if already publisher inside the in-flight operation to prevent race conditions
+            if (this.publisher) {
+                pubsubLogger.debug('Publish skipped', { topicName: this.name, reason: 'already publisher' });
+                return;
+            }
+            this._pubuid = id ?? this.client.messenger.getNextPubUID();
+            this._publishProperties = properties;
+            pubsubLogger.debug('Topic published', { topicName: this.name, pubuid: this._pubuid, properties });
+            const publishParams = {
+                type: this.typeInfo[1],
+                name: this.name,
+                pubuid: this._pubuid,
+                properties,
+            };
+            return await this.client.messenger.publish(publishParams);
+        });
+    }
+    /**
+     * Unpublishes the topic.
+     */
+    unpublish() {
+        if (this._pubuid == null) {
+            pubsubLogger.debug('Publisher check failed before unpublish', {
+                topicName: this.name,
+                publisher: this.publisher,
+                pubuid: this._pubuid,
+            });
+            throw new Error('Cannot unpublish topic without being the publisher');
+        }
+        pubsubLogger.debug('Topic unpublished', { topicName: this.name, pubuid: this._pubuid });
+        this.client.messenger.unpublish(this._pubuid);
+        this._publisher = false;
+        this._pubuid = undefined;
+    }
+    /**
+     * Republishes the topic.
+     * @param client - The client to republish with.
+     * @returns A promise that resolves when the topic is republished.
+     */
+    async republish(client) {
+        this.client = client;
+        if (!this.publisher || this._pubuid == null) {
+            throw new Error('Cannot republish topic without being the publisher');
+        }
+        pubsubLogger.debug('Topic republished', { topicName: this.name, pubuid: this._pubuid });
+        this._publisher = false;
+        return await this.publish(this._publishProperties, this._pubuid);
+    }
+}
+
+/**
+ * Primitive type names and their byte sizes (WPILib struct schema).
+ */
+const PRIMITIVE_SIZES = {
+    bool: 1,
+    char: 1,
+    int8: 1,
+    uint8: 1,
+    int16: 2,
+    uint16: 2,
+    int32: 4,
+    uint32: 4,
+    int64: 8,
+    uint64: 8,
+    float: 4,
+    float32: 4,
+    double: 8,
+    float64: 8,
+};
+/**
+ * Returns the size in bytes of a primitive type.
+ */
+function getPrimitiveSize(primitive) {
+    const size = PRIMITIVE_SIZES[primitive];
+    if (size === undefined) {
+        throw new Error(`Unknown primitive type: ${primitive}`);
+    }
+    return size;
+}
+/**
+ * Returns whether the given string is a known primitive type name.
+ */
+function isPrimitiveType(typeName) {
+    return typeName in PRIMITIVE_SIZES;
+}
+
+/**
+ * Unpacks a little-endian binary buffer into a plain object using the struct descriptor.
+ * @throws Error if buffer is too small for the descriptor size.
+ */
+function unpack(buffer, descriptor) {
+    if (buffer.length < descriptor.size) {
+        throw new Error(`Struct unpack: buffer too small (${buffer.length} bytes, need ${descriptor.size} for ${descriptor.typeName})`);
+    }
+    const view = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+    const out = {};
+    for (const field of descriptor.fields) {
+        out[field.name] = unpackField(view, field);
+    }
+    return out;
+}
+/**
+ * Packs a plain object into a little-endian Uint8Array using the struct descriptor.
+ * @throws Error if value is missing required fields or has invalid types.
+ */
+function pack(value, descriptor) {
+    const buffer = new Uint8Array(descriptor.size);
+    const view = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+    for (const field of descriptor.fields) {
+        const v = value[field.name];
+        if (v === undefined) {
+            throw new Error(`Struct pack: missing required field "${field.name}" for ${descriptor.typeName}`);
+        }
+        packField(view, field, v);
+    }
+    return buffer;
+}
+function unpackField(view, field) {
+    const offset = field.offset;
+    if (field.nestedDescriptor) {
+        if (field.arraySize === 1) {
+            return unpack(new Uint8Array(view.buffer, view.byteOffset + offset, field.size), field.nestedDescriptor);
+        }
+        const arr = [];
+        const elemSize = field.nestedDescriptor.size;
+        for (let i = 0; i < field.arraySize; i++) {
+            arr.push(unpack(new Uint8Array(view.buffer, view.byteOffset + offset + i * elemSize, elemSize), field.nestedDescriptor));
+        }
+        return arr;
+    }
+    const prim = field.primitive;
+    if (!prim)
+        throw new Error(`Struct field "${field.name}" has neither nestedDescriptor nor primitive`);
+    if (field.arraySize > 1) {
+        const elemSize = getPrimitiveSize(prim);
+        const arr = [];
+        for (let i = 0; i < field.arraySize; i++) {
+            arr.push(readPrimitive(view, offset + i * elemSize, prim));
+        }
+        return arr;
+    }
+    if (field.bitWidth > 0 && field.bitWidth < field.size * 8) {
+        const bitfieldValue = readBitfield(view, offset, field.size, field.bitWidth, field.bitShift);
+        return prim === 'bool' ? bitfieldValue !== 0 : bitfieldValue;
+    }
+    return readPrimitive(view, offset, prim);
+}
+function packField(view, field, value) {
+    const offset = field.offset;
+    if (field.nestedDescriptor) {
+        if (field.arraySize === 1) {
+            const buf = pack(value, field.nestedDescriptor);
+            new Uint8Array(view.buffer, view.byteOffset + offset, field.size).set(buf);
+            return;
+        }
+        const arr = value;
+        if (!Array.isArray(arr) || arr.length !== field.arraySize) {
+            throw new Error(`Struct pack: field "${field.name}" expects array of size ${field.arraySize}`);
+        }
+        const elemSize = field.nestedDescriptor.size;
+        for (let i = 0; i < field.arraySize; i++) {
+            const slice = new Uint8Array(view.buffer, view.byteOffset + offset + i * elemSize, elemSize);
+            slice.set(pack(arr[i], field.nestedDescriptor));
+        }
+        return;
+    }
+    const prim = field.primitive;
+    if (!prim)
+        throw new Error(`Struct field "${field.name}" has neither nestedDescriptor nor primitive`);
+    if (field.arraySize > 1) {
+        const arr = value;
+        if (!Array.isArray(arr) || arr.length !== field.arraySize) {
+            throw new Error(`Struct pack: field "${field.name}" expects array of size ${field.arraySize}`);
+        }
+        const elemSize = getPrimitiveSize(prim);
+        for (let i = 0; i < field.arraySize; i++) {
+            writePrimitive(view, offset + i * elemSize, prim, arr[i]);
+        }
+        return;
+    }
+    if (field.bitWidth > 0 && field.bitWidth < field.size * 8) {
+        writeBitfield(view, offset, field.size, field.bitWidth, field.bitShift, value);
+        return;
+    }
+    writePrimitive(view, offset, prim, value);
+}
+function readPrimitive(view, offset, prim) {
+    switch (prim) {
+        case 'bool':
+            return view.getUint8(offset) !== 0;
+        case 'char':
+            return view.getInt8(offset);
+        case 'int8':
+            return view.getInt8(offset);
+        case 'uint8':
+            return view.getUint8(offset);
+        case 'int16':
+            return view.getInt16(offset, true);
+        case 'uint16':
+            return view.getUint16(offset, true);
+        case 'int32':
+            return view.getInt32(offset, true);
+        case 'uint32':
+            return view.getUint32(offset, true);
+        case 'int64':
+            // Converted to Number (loses precision beyond ±2^53). BigInt is avoided because it
+            // can't mix with Number in arithmetic and breaks JSON.stringify / Zod / React state.
+            // No built-in WPILib struct types use int64; revisit if full precision is needed.
+            return Number(view.getBigInt64(offset, true));
+        case 'uint64':
+            return Number(view.getBigUint64(offset, true));
+        case 'float':
+        case 'float32':
+            return view.getFloat32(offset, true);
+        case 'double':
+        case 'float64':
+            return view.getFloat64(offset, true);
+        default:
+            throw new Error(`Unknown primitive: ${prim}`);
+    }
+}
+function writePrimitive(view, offset, prim, value) {
+    switch (prim) {
+        case 'bool':
+            view.setUint8(offset, value ? 1 : 0);
+            break;
+        case 'char':
+        case 'int8':
+            view.setInt8(offset, value);
+            break;
+        case 'uint8':
+            view.setUint8(offset, value);
+            break;
+        case 'int16':
+            view.setInt16(offset, value, true);
+            break;
+        case 'uint16':
+            view.setUint16(offset, value, true);
+            break;
+        case 'int32':
+            view.setInt32(offset, value, true);
+            break;
+        case 'uint32':
+            view.setUint32(offset, value, true);
+            break;
+        case 'int64': {
+            const v = typeof value === 'bigint'
+                ? value
+                : typeof value === 'number' && Number.isSafeInteger(value)
+                    ? BigInt(value)
+                    : (() => {
+                        throw new Error(`Struct pack int64: value ${String(value)} is not a safe integer. ` +
+                            `Pass a BigInt for values outside ±2^53.`);
+                    })();
+            view.setBigInt64(offset, v, true);
+            break;
+        }
+        case 'uint64': {
+            const v = typeof value === 'bigint'
+                ? value
+                : typeof value === 'number' && Number.isSafeInteger(value)
+                    ? BigInt(value)
+                    : (() => {
+                        throw new Error(`Struct pack uint64: value ${String(value)} is not a safe integer. ` +
+                            `Pass a BigInt for values outside ±2^53.`);
+                    })();
+            view.setBigUint64(offset, v, true);
+            break;
+        }
+        case 'float':
+        case 'float32':
+            view.setFloat32(offset, value, true);
+            break;
+        case 'double':
+        case 'float64':
+            view.setFloat64(offset, value, true);
+            break;
+        default:
+            throw new Error(`Unknown primitive: ${prim}`);
+    }
+}
+function readStorageUnit(view, offset, byteSize) {
+    switch (byteSize) {
+        case 1:
+            return view.getUint8(offset);
+        case 2:
+            return view.getUint16(offset, true);
+        case 4:
+            return view.getUint32(offset, true);
+        default:
+            return Number(view.getBigUint64(offset, true));
+    }
+}
+function writeStorageUnit(view, offset, byteSize, value) {
+    switch (byteSize) {
+        case 1:
+            view.setUint8(offset, value);
+            break;
+        case 2:
+            view.setUint16(offset, value, true);
+            break;
+        case 4:
+            view.setUint32(offset, value, true);
+            break;
+        default:
+            view.setBigUint64(offset, BigInt(value), true);
+    }
+}
+const MAX_BITFIELD_WIDTH = 31;
+/**
+ * Reads a bitfield value from a storage unit. Mirrors WPILib's unsigned read path:
+ * `(rawVal >>> bitShift) & bitMask`. Signed sign-extension is not implemented since
+ * WPILib only allows unsigned/bool bitfields in practice.
+ * JS bitwise ops are 32-bit; bitfields wider than 31 bits or 8-byte storage are unsupported.
+ *
+ * @see DynamicStruct.java — getFieldImpl()
+ */
+function readBitfield(view, offset, byteSize, bitWidth, bitShift) {
+    if (byteSize === 8 || bitWidth > MAX_BITFIELD_WIDTH) {
+        throw new Error(`Struct codec: bitfield read unsupported for byteSize=${byteSize} bitWidth=${bitWidth} (max ${MAX_BITFIELD_WIDTH} bits)`);
+    }
+    const raw = readStorageUnit(view, offset, byteSize);
+    // Use unsigned mask so bitWidth=31 works: (1 << 31) would overflow to negative in JS.
+    const mask = (0xffffffff >>> (32 - bitWidth)) >>> 0;
+    return (raw >>> bitShift) & mask;
+}
+/**
+ * Writes a bitfield value into a storage unit via read-modify-write. Clears the target
+ * bits with `~(mask << shift)`, then sets with `(value & mask) << shift`.
+ * JS bitwise ops are 32-bit; bitfields wider than 31 bits or 8-byte storage are unsupported.
+ *
+ * @see DynamicStruct.java — setFieldImpl()
+ */
+function writeBitfield(view, offset, byteSize, bitWidth, bitShift, value) {
+    if (byteSize === 8 || bitWidth > MAX_BITFIELD_WIDTH) {
+        throw new Error(`Struct codec: bitfield write unsupported for byteSize=${byteSize} bitWidth=${bitWidth} (max ${MAX_BITFIELD_WIDTH} bits)`);
+    }
+    // Use unsigned mask so bitWidth=31 works: (1 << 31) would overflow to negative in JS.
+    const mask = (0xffffffff >>> (32 - bitWidth)) >>> 0;
+    const v = (value & mask) >>> 0;
+    const raw = readStorageUnit(view, offset, byteSize);
+    const updated = ((raw & ~(mask << bitShift)) | (v << bitShift)) >>> 0;
+    writeStorageUnit(view, offset, byteSize, updated);
+}
+
+/** Single punctuation or keyword token. */
+const PUNCT = /^[[\]{}:;,=]/;
+/** Identifier: letter or _ then alphanumeric or _. */
+const IDENT = /^[a-zA-Z_][a-zA-Z0-9_]*/;
+/** Integer: optional minus then digits. */
+const INT = /^-?\d+/;
+/** Whitespace. */
+const WS = /^[\s\r\n\t]+/;
+class Lexer {
+    constructor(input) {
+        this.pos = 0;
+        this.input = input;
+    }
+    eof() {
+        this.skipWhitespace();
+        return this.pos >= this.input.length;
+    }
+    skipWhitespace() {
+        while (this.pos < this.input.length) {
+            const m = this.input.slice(this.pos).match(WS);
+            if (m) {
+                this.pos += m[0].length;
+            }
+            else {
+                break;
+            }
+        }
+    }
+    /** Returns next token as string, or null if eof. */
+    next() {
+        this.skipWhitespace();
+        if (this.pos >= this.input.length)
+            return null;
+        const rest = this.input.slice(this.pos);
+        const p = rest.match(PUNCT);
+        if (p) {
+            this.pos += p[0].length;
+            return p[0];
+        }
+        const i = rest.match(INT);
+        if (i) {
+            this.pos += i[0].length;
+            return i[0];
+        }
+        const id = rest.match(IDENT);
+        if (id) {
+            this.pos += id[0].length;
+            return id[0];
+        }
+        throw new Error(`Struct schema lexer: unexpected character at position ${this.pos}`);
+    }
+    /** Peek next token without consuming. */
+    peek() {
+        const saved = this.pos;
+        const t = this.next();
+        this.pos = saved;
+        return t;
+    }
+}
+/**
+ * Parses a WPILib struct schema string into a list of field declarations.
+ * @param schema - Schema string (e.g. "double x;double y" or "Translation2d translation;Rotation2d rotation").
+ * @returns Array of parsed fields.
+ * @throws Error on malformed schema.
+ */
+function parseSchema(schema) {
+    const lex = new Lexer(schema);
+    const fields = [];
+    while (!lex.eof()) {
+        let enumValues;
+        const first = lex.next();
+        if (!first)
+            break;
+        if (first === 'enum') {
+            const open = lex.next();
+            if (open !== '{')
+                throw new Error('Struct schema: expected "{" after enum');
+            enumValues = parseEnumEntries(lex);
+            const close = lex.next();
+            if (close !== '}')
+                throw new Error('Struct schema: expected "}" after enum entries');
+        }
+        else if (first === '{') {
+            enumValues = parseEnumEntries(lex);
+            const close = lex.next();
+            if (close !== '}')
+                throw new Error('Struct schema: expected "}" after enum entries');
+        }
+        const typeName = first === 'enum' || first === '{' ? lex.next() : first;
+        if (!typeName || PUNCT.test(typeName) || INT.test(typeName)) {
+            throw new Error('Struct schema: expected type after declaration start');
+        }
+        const name = lex.next();
+        if (!name || PUNCT.test(name) || INT.test(name)) {
+            throw new Error('Struct schema: expected identifier after type');
+        }
+        let arraySize = 1;
+        let bitWidth = 0;
+        const afterName = lex.peek();
+        if (afterName === '[') {
+            lex.next();
+            const sizeTok = lex.next();
+            if (!sizeTok || !INT.test(sizeTok))
+                throw new Error('Struct schema: expected integer in array size');
+            const n = parseInt(sizeTok, 10);
+            if (n <= 0)
+                throw new Error('Struct schema: array size must be positive');
+            arraySize = n;
+            const close = lex.next();
+            if (close !== ']')
+                throw new Error('Struct schema: expected "]" after array size');
+        }
+        else if (afterName === ':') {
+            lex.next();
+            const widthTok = lex.next();
+            if (!widthTok || !INT.test(widthTok))
+                throw new Error('Struct schema: expected integer in bitfield width');
+            bitWidth = parseInt(widthTok, 10);
+            if (bitWidth <= 0)
+                throw new Error('Struct schema: bitfield width must be positive');
+        }
+        fields.push({ typeName, name, arraySize, bitWidth, enumValues });
+        while (lex.peek() === ';') {
+            lex.next();
+        }
+    }
+    return fields;
+}
+function parseEnumEntries(lex) {
+    const enumValues = {};
+    for (;;) {
+        if (lex.peek() === '}')
+            break;
+        const id = lex.next();
+        if (!id)
+            break;
+        if (PUNCT.test(id) || INT.test(id))
+            throw new Error('Struct schema: expected identifier in enum entry');
+        const eq = lex.next();
+        if (eq !== '=')
+            throw new Error('Struct schema: expected "=" in enum entry');
+        const num = lex.next();
+        if (!num || !INT.test(num))
+            throw new Error('Struct schema: expected integer in enum value');
+        enumValues[id] = parseInt(num, 10);
+        const next = lex.peek();
+        if (next === ',') {
+            lex.next();
+        }
+        else if (next === '}') {
+            break;
+        }
+        else if (next !== null) {
+            throw new Error(`Struct schema: unexpected token "${next}" in enum`);
+        }
+    }
+    return enumValues;
+}
+/**
+ * Builds a StructDescriptor from parsed fields and a resolver for nested struct sizes.
+ *
+ * Implements the WPILib `StructDescriptor.calculateOffsets()` algorithm for bitfield
+ * coalescing. Fields are densely packed with no alignment padding. Consecutive bitfields
+ * of the same underlying type share a single storage unit (e.g. two `uint8:4` fields
+ * occupy 1 byte, not 2). When the type changes or bits overflow the storage unit, a new
+ * unit starts.
+ *
+ * @see https://github.com/wpilibsuite/allwpilib — StructDescriptor.java, calculateOffsets()
+ */
+function buildStructDescriptor(typeName, parsedFields, getNestedDescriptor) {
+    function resolveElemSize(f) {
+        if (isPrimitiveType(f.typeName)) {
+            const elemSize = getPrimitiveSize(f.typeName);
+            if (f.bitWidth > 0 && f.bitWidth > elemSize * 8) {
+                throw new Error(`Struct schema: bitfield width ${f.bitWidth} exceeds type ${f.typeName} size (${elemSize} bytes)`);
+            }
+            return { elemSize, nested: null };
+        }
+        if (f.typeName === typeName) {
+            throw new Error(`Struct schema: circular struct reference "${f.typeName}" in "${typeName}"`);
+        }
+        const nested = getNestedDescriptor(f.typeName);
+        if (!nested) {
+            throw new Error(`Struct schema: unknown or circular struct type "${f.typeName}" in "${typeName}"`);
+        }
+        return { elemSize: nested.size, nested };
+    }
+    const fields = [];
+    // Mirrors WPILib's calculateOffsets state: byte offset, bit position within the
+    // current bitfield storage unit, and the byte-size of that storage unit (0 = none active).
+    let offset = 0;
+    let shift = 0;
+    let prevBitfieldSize = 0;
+    for (const f of parsedFields) {
+        const { elemSize, nested } = resolveElemSize(f);
+        const isBitfield = f.bitWidth > 0 && f.bitWidth < elemSize * 8;
+        if (!isBitfield) {
+            // Non-bitfield: close any active bitfield storage unit, then lay out normally.
+            shift = 0;
+            offset += prevBitfieldSize;
+            prevBitfieldSize = 0;
+            if (nested) {
+                fields.push({
+                    name: f.name,
+                    offset,
+                    size: elemSize,
+                    arraySize: f.arraySize,
+                    bitWidth: 0,
+                    bitShift: 0,
+                    nestedDescriptor: nested,
+                });
+            }
+            else {
+                fields.push({
+                    name: f.name,
+                    offset,
+                    size: elemSize,
+                    arraySize: f.arraySize,
+                    bitWidth: 0,
+                    bitShift: 0,
+                    enumValues: f.enumValues,
+                    primitive: f.typeName,
+                });
+            }
+            offset += elemSize * f.arraySize;
+        }
+        else {
+            // Bitfield coalescing: consecutive bitfields of the same underlying type pack into
+            // a shared storage unit at increasing bitShift offsets (LSB-first). Three cases:
+            const bitWidth = f.bitWidth;
+            const isBool = f.typeName === 'bool';
+            if (isBool && prevBitfieldSize !== 0 && shift + 1 <= prevBitfieldSize * 8) ;
+            else if (elemSize !== prevBitfieldSize || shift + bitWidth > elemSize * 8) {
+                // Case 2: Type changed or bits won't fit — start a new storage unit.
+                shift = 0;
+                offset += prevBitfieldSize;
+            }
+            // Case 3 (implicit): Same type, fits — continues packing into current unit.
+            prevBitfieldSize =
+                isBool && prevBitfieldSize !== 0 && shift + 1 <= prevBitfieldSize * 8 ? prevBitfieldSize : elemSize;
+            fields.push({
+                name: f.name,
+                offset,
+                size: prevBitfieldSize,
+                arraySize: 1,
+                bitWidth,
+                bitShift: shift,
+                enumValues: f.enumValues,
+                primitive: f.typeName,
+            });
+            shift += bitWidth;
+        }
+    }
+    // Account for any trailing bitfield storage unit.
+    const totalSize = offset + prevBitfieldSize;
+    return { typeName, size: totalSize, fields };
+}
+
+const SCHEMAS = {
+    Translation2d: 'double x;double y',
+    Rotation2d: 'double value',
+    Pose2d: 'Translation2d translation;Rotation2d rotation',
+    Transform2d: 'Translation2d translation;Rotation2d rotation',
+    Twist2d: 'double dx;double dy;double dtheta',
+    Translation3d: 'double x;double y;double z',
+    Quaternion: 'double w;double x;double y;double z',
+    Rotation3d: 'Quaternion q',
+    Pose3d: 'Translation3d translation;Rotation3d rotation',
+    Transform3d: 'Translation3d translation;Rotation3d rotation',
+    Twist3d: 'double dx;double dy;double dz;double rx;double ry;double rz',
+};
+const SCHEMA_STRINGS = SCHEMAS;
+const builtInDescriptors = new Map();
+function getBuiltIn(name) {
+    return builtInDescriptors.get(name) ?? null;
+}
+function initBuiltIns() {
+    const order = [
+        'Translation2d',
+        'Rotation2d',
+        'Translation3d',
+        'Quaternion',
+        'Pose2d',
+        'Transform2d',
+        'Twist2d',
+        'Rotation3d',
+        'Pose3d',
+        'Transform3d',
+        'Twist3d',
+    ];
+    for (const typeName of order) {
+        if (builtInDescriptors.has(typeName))
+            continue;
+        const schema = SCHEMA_STRINGS[typeName];
+        if (!schema)
+            continue;
+        const fields = parseSchema(schema);
+        const descriptor = buildStructDescriptor(typeName, fields, getBuiltIn);
+        builtInDescriptors.set(typeName, descriptor);
+    }
+}
+function getBuiltInDescriptor(typeName) {
+    if (builtInDescriptors.size === 0)
+        initBuiltIns();
+    const cached = builtInDescriptors.get(typeName);
+    if (cached)
+        return cached;
+    const schema = SCHEMA_STRINGS[typeName];
+    if (!schema)
+        return null;
+    const fields = parseSchema(schema);
+    const descriptor = buildStructDescriptor(typeName, fields, getBuiltIn);
+    builtInDescriptors.set(typeName, descriptor);
+    return descriptor;
+}
+/** All built-in struct type names (WPILib geometry). */
+const BUILT_IN_STRUCT_TYPE_NAMES = Object.keys(SCHEMAS);
+/** Returns the schema string for a built-in type, or undefined. */
+function getBuiltInSchemaString(typeName) {
+    return SCHEMA_STRINGS[typeName];
+}
+
+function structTypeInfo(typeName, isArray) {
+    return [5, isArray ? `struct:${typeName}[]` : `struct:${typeName}`];
+}
+class NetworkTablesStructTopic extends NetworkTablesTopic {
+    constructor(client, name, options) {
+        const typeName = options?.typeName ?? '';
+        const isArray = typeName.endsWith('[]');
+        const baseTypeName = isArray ? typeName.slice(0, -2) : typeName;
+        super(client, name, structTypeInfo(baseTypeName || 'Unknown', isArray), undefined);
+        this.decodedValue = null;
+        this._descriptor = null;
+        /** When schema option build fails (e.g. nested not yet available), store and retry in ensureDescriptor. */
+        this._pendingSchema = null;
+        this._typeName = baseTypeName || typeName;
+        this._isArray = isArray;
+        this._validator = options?.validator;
+        if (options?.defaultValue !== undefined) {
+            this.decodedValue = options.defaultValue;
+        }
+        if (options?.schema) {
+            try {
+                const fields = parseSchema(options.schema);
+                const getNested = (n) => client.structSchemaManager.fetchDescriptor(n);
+                this._descriptor = buildStructDescriptor(this._typeName, fields, getNested);
+            }
+            catch (err) {
+                pubsubLogger.debug('Deferred struct descriptor build from schema option', { topicName: name, error: err });
+                this._pendingSchema = options.schema;
+            }
+        }
+        if (!this._descriptor && this._typeName) {
+            this._descriptor = getBuiltInDescriptor(this._typeName) ?? null;
+        }
+    }
+    /**
+     * Applies options to this topic. Used when returning a cached topic from getStructTopic.
+     * A later `validator` replaces any previous validator because the topic is a singleton.
+     * @param options - The options to apply.
+     */
+    applyOptions(options) {
+        if (!options)
+            return;
+        if (options.schema !== undefined) {
+            const schema = options.schema;
+            this._pendingSchema = schema || null;
+            if (schema) {
+                try {
+                    const fields = parseSchema(schema);
+                    const getNested = (n) => this.client.structSchemaManager.fetchDescriptor(n);
+                    this._descriptor = buildStructDescriptor(this._typeName, fields, getNested);
+                    this._pendingSchema = null;
+                }
+                catch (err) {
+                    pubsubLogger.debug('Deferred struct descriptor build from schema option (applyOptions)', {
+                        topicName: this.name,
+                        error: err,
+                    });
+                    this._descriptor = null;
+                }
+            }
+            else {
+                this._descriptor = null;
+            }
+        }
+        if (!this._descriptor && this._typeName) {
+            this._descriptor = getBuiltInDescriptor(this._typeName) ?? null;
+        }
+        if (options.validator !== undefined)
+            this._validator = options.validator;
+        if (options.defaultValue !== undefined && this.decodedValue == null)
+            this.decodedValue = options.defaultValue;
+    }
+    ensureDescriptor() {
+        if (this._descriptor)
+            return this._descriptor;
+        const schemaToTry = this._pendingSchema;
+        if (schemaToTry) {
+            try {
+                const fields = parseSchema(schemaToTry);
+                const getNested = (n) => this.client.structSchemaManager.fetchDescriptor(n);
+                this._descriptor = buildStructDescriptor(this._typeName, fields, getNested);
+                this._pendingSchema = null;
+                return this._descriptor;
+            }
+            catch (err) {
+                pubsubLogger.debug('Retry struct descriptor from pending schema failed', {
+                    topicName: this.name,
+                    error: err,
+                });
+            }
+        }
+        const d = this.client.structSchemaManager.fetchDescriptor(this._typeName);
+        if (d) {
+            this._descriptor = d;
+            return d;
+        }
+        throw new Error(`Struct descriptor not found for type "${this._typeName}"`);
+    }
+    maybeValidate(value) {
+        return (this._validator ? this._validator.parse(value) : value);
+    }
+    getValue() {
+        return this.decodedValue;
+    }
+    setValue(value) {
+        if (!this.publisher) {
+            pubsubLogger.debug('Publisher check failed before setValue', { topicName: this.name });
+            throw new Error('Cannot set value on topic without being the publisher');
+        }
+        const validated = this.maybeValidate(value);
+        const encoded = this.encodeValue(validated);
+        this.decodedValue = validated;
+        this.setWireValue(encoded);
+        this.afterSetWireValue();
+    }
+    decodeValue(value) {
+        try {
+            const desc = this.ensureDescriptor();
+            if (this._isArray) {
+                const elemSize = desc.size;
+                if (value.length % elemSize !== 0)
+                    return null;
+                const n = value.length / elemSize;
+                const arr = [];
+                for (let i = 0; i < n; i++) {
+                    arr.push(unpack(new Uint8Array(value.buffer, value.byteOffset + i * elemSize, elemSize), desc));
+                }
+                return this.maybeValidate(arr);
+            }
+            const out = unpack(value, desc);
+            return this.maybeValidate(out);
+        }
+        catch (err) {
+            pubsubLogger.debug('Failed to decode struct value', { topicName: this.name, error: err });
+            return null;
+        }
+    }
+    encodeValue(value) {
+        const desc = this.ensureDescriptor();
+        if (this._isArray) {
+            if (!Array.isArray(value)) {
+                throw new Error(`Expected an array for array struct topic ${this.name}, got ${typeof value}${value === null ? ' (null)' : value === undefined ? ' (undefined)' : ''}`);
+            }
+            const arr = value;
+            const elemSize = desc.size;
+            const buf = new Uint8Array(arr.length * elemSize);
+            for (let i = 0; i < arr.length; i++) {
+                buf.set(pack(arr[i], desc), i * elemSize);
+            }
+            return buf;
+        }
+        return pack(value, desc);
+    }
+    updateValue(value, lastChangedTime) {
+        this.decodedValue = this.decodeValue(value);
+        super.updateValue(value, lastChangedTime);
+    }
+    announce(params) {
+        super.announce(params);
+        const typeString = params.type;
+        if (!this.name.startsWith('/.schema/') && typeString.startsWith('struct:')) {
+            const suffix = typeString.slice(7);
+            this._isArray = suffix.endsWith('[]');
+            this._typeName = this._isArray ? suffix.slice(0, -2) : suffix;
+            this._descriptor = this.client.structSchemaManager.fetchDescriptor(this._typeName) ?? this._descriptor;
+        }
+    }
+    async publish(properties = {}, id) {
+        const operationKey = `publish:${this.name}`;
+        return this.client.getOrCreateInFlightOperation(operationKey, async () => {
+            if (this.publisher) {
+                pubsubLogger.debug('Publish skipped', { topicName: this.name, reason: 'already publisher' });
+                return;
+            }
+            const desc = this.ensureDescriptor();
+            await this.client.structSchemaManager.addSchema(desc);
+            const typeString = this._isArray ? `struct:${this._typeName}[]` : `struct:${this._typeName}`;
+            const pubuid = id ?? this.client.messenger.getNextPubUID();
+            this._pubuid = pubuid;
+            this._publishProperties = properties;
+            pubsubLogger.debug('Topic published', { topicName: this.name, pubuid, properties, type: typeString });
+            const publishParams = { type: typeString, name: this.name, pubuid, properties };
+            return await this.client.messenger.publish(publishParams);
+        });
+    }
+}
+
+/** Schema for an integer. */
+const finiteNumSchema = z.number();
+const integerSchema = finiteNumSchema.int();
+/** Schema for type numbers in the NT protocol. */
+const typeNumSchema = z.union([
+    z.literal(0),
+    z.literal(1),
+    z.literal(2),
+    z.literal(3),
+    z.literal(4),
+    z.literal(5),
+    z.literal(16),
+    z.literal(17),
+    z.literal(18),
+    z.literal(19),
+    z.literal(20),
+]);
+/** Schema for type strings in the NT protocol (JSON text frames always use strings per NT 4.1 spec). */
+const typeStringSchema = z.union([
+    z.literal('boolean'),
+    z.literal('double'),
+    z.literal('int'),
+    z.literal('float'),
+    z.literal('string'),
+    z.literal('json'),
+    z.literal('raw'),
+    z.literal('rpc'),
+    z.literal('msgpack'),
+    z.literal('structschema'),
+    z.literal('protobuf'),
+    z.literal('boolean[]'),
+    z.literal('double[]'),
+    z.literal('int[]'),
+    z.literal('float[]'),
+    z.literal('string[]'),
+    z.string().startsWith('proto:'),
+    z.string().startsWith('struct:'),
+    z.string().startsWith('photonstruct:'),
+]);
+/** Schema for topic properties in the NT protocol. */
+const topicPropertiesSchema = z
+    .object({
+    persistent: z.boolean(),
+    retained: z.boolean(),
+    cached: z.boolean(),
+})
+    .partial();
+/** Schema for a topic in the NT protocol. */
+const topicSchema = z.object({
+    name: z.string(),
+    id: integerSchema,
+    type: typeStringSchema,
+    properties: topicPropertiesSchema,
+});
+/** Schema for subscription options in the NT protocol. */
+const subscriptionOptionsSchema = z
+    .object({
+    periodic: finiteNumSchema.nonnegative(),
+    all: z.boolean(),
+    topicsonly: z.boolean(),
+    prefix: z.boolean(),
+})
+    .partial();
+/** Schema for the publish message in the NT protocol. */
+const publishMessageParamsSchema = z.object({
+    name: z.string(),
+    pubuid: integerSchema,
+    type: typeStringSchema,
+    properties: topicPropertiesSchema,
+});
+/** Schema for the unpublish message params in the NT protocol. */
+const unpublishMessageParamsSchema = z.object({
+    pubuid: integerSchema,
+});
+/** Schema for the set properties message params in the NT protocol. */
+const setPropertiesMessageParamsSchema = z.object({
+    name: z.string(),
+    update: topicPropertiesSchema,
+});
+/** Schema for the subscribe message params in the NT protocol. */
+const subscribeMessageParamsSchema = z.object({
+    topics: z.array(z.string()),
+    subuid: integerSchema,
+    options: subscriptionOptionsSchema,
+});
+/** Schema for the unsubscribe message params in the NT protocol. */
+const unsubscribeMessageParamsSchema = z.object({
+    subuid: integerSchema,
+});
+/** Schema for the announce message params in the NT protocol. */
+const announceMessageParamsSchema = topicSchema.extend({
+    pubuid: integerSchema.optional(),
+});
+/** Schema for the unannounce message params in the NT protocol. */
+const unannounceMessageParamsSchema = z.object({
+    name: z.string(),
+    id: integerSchema,
+});
+/** Schema for the properties message params in the NT protocol. */
+const propertiesMessageParamsSchema = z.object({
+    name: z.string(),
+    ack: z.boolean().optional(),
+    update: topicPropertiesSchema,
+});
+/** Schema for a publish message in the NT protocol. */
+const publishMessageSchema = z.object({
+    method: z.literal('publish'),
+    params: publishMessageParamsSchema,
+});
+/** Schema for an unpublish message in the NT protocol. */
+const unpublishMessageSchema = z.object({
+    method: z.literal('unpublish'),
+    params: unpublishMessageParamsSchema,
+});
+/** Schema for a setproperties message in the NT protocol. */
+const setPropertiesMessageSchema = z.object({
+    method: z.literal('setproperties'),
+    params: setPropertiesMessageParamsSchema,
+});
+/** Schema for a subscribe message in the NT protocol. */
+const subscribeMessageSchema = z.object({
+    method: z.literal('subscribe'),
+    params: subscribeMessageParamsSchema,
+});
+/** Schema for an unsubscribe message in the NT protocol. */
+const unsubscribeMessageSchema = z.object({
+    method: z.literal('unsubscribe'),
+    params: unsubscribeMessageParamsSchema,
+});
+/** Schema for an announce message in the NT protocol. */
+const announceMessageSchema = z.object({
+    method: z.literal('announce'),
+    params: announceMessageParamsSchema,
+});
+/** Schema for an unannounce message in the NT protocol. */
+const unannounceMessageSchema = z.object({
+    method: z.literal('unannounce'),
+    params: unannounceMessageParamsSchema,
+});
+/** Schema for a properties message in the NT protocol. */
+const propertiesMessageSchema = z.object({
+    method: z.literal('properties'),
+    params: propertiesMessageParamsSchema,
+});
+/** Schema for a text frame message in the NT protocol. */
+const messageSchema = z.array(z.discriminatedUnion('method', [
+    publishMessageSchema,
+    unpublishMessageSchema,
+    setPropertiesMessageSchema,
+    subscribeMessageSchema,
+    unsubscribeMessageSchema,
+    announceMessageSchema,
+    unannounceMessageSchema,
+    propertiesMessageSchema,
+]));
+/** Schema for a value in the msgpack format. */
+const msgPackValueSchema = z.union([
+    z.boolean(),
+    integerSchema,
+    finiteNumSchema,
+    z.string(),
+    z.custom((v) => v instanceof Uint8Array || (typeof Buffer !== 'undefined' && Buffer.isBuffer(v))),
+    z.array(z.boolean()),
+    z.array(z.string()),
+    z.array(integerSchema),
+    z.array(finiteNumSchema),
+]);
+/** Schema for a binary message in the msgpack format. */
+const msgPackSchema = z.tuple([
+    z.union([integerSchema.nonnegative(), z.literal(-1)]),
+    integerSchema.nonnegative(),
+    typeNumSchema,
+    msgPackValueSchema,
+]);
+
+class NetworkTablesTypeInfos {
+    /**
+     * Validates and parses a value based on the expected NetworkTables type information.
+     * @param expectedTypeInfo - The expected type information from `NetworkTablesTypeInfo`.
+     * @param value - The value to validate and parse.
+     * @returns The parsed value, matching the expected type.
+     * @throws Will throw an error if the value does not match the expected type or if parsing fails.
+     */
+    static validateData(expectedTypeInfo, value) {
+        switch (expectedTypeInfo) {
+            // 0
+            case NetworkTablesTypeInfos.kBoolean:
+                return z.boolean().parse(value);
+            // 1
+            case NetworkTablesTypeInfos.kDouble:
+                return finiteNumSchema.parse(value);
+            // 2
+            case NetworkTablesTypeInfos.kInteger:
+                return integerSchema.parse(value);
+            // 3
+            case NetworkTablesTypeInfos.kFloat:
+                return finiteNumSchema.parse(value);
+            // 4
+            case NetworkTablesTypeInfos.kString:
+                return z.string().parse(value);
+            case NetworkTablesTypeInfos.kJson: {
+                const parsedString = z.string().parse(value);
+                const parsedJson = JSON.parse(parsedString);
+                if (typeof parsedJson === 'object' && parsedJson !== null) {
+                    return parsedString;
+                }
+                else {
+                    throw new Error(`Bad JSON value: ${value}`);
+                }
+            }
+            // 5
+            case NetworkTablesTypeInfos.kUint8Array:
+                if (value instanceof Uint8Array) {
+                    return value;
+                }
+                else {
+                    throw new Error(`Invalid Uint8Array value: ${value}`);
+                }
+            case NetworkTablesTypeInfos.kRPC:
+                if (value instanceof Uint8Array) {
+                    return value;
+                }
+                else {
+                    throw new Error(`Invalid RPC value: ${value}`);
+                }
+            case NetworkTablesTypeInfos.kMsgpack:
+                if (value instanceof Uint8Array) {
+                    return value;
+                }
+                else {
+                    throw new Error(`Invalid Msgpack value: ${value}`);
+                }
+            case NetworkTablesTypeInfos.kProtobuf:
+                if (value instanceof Uint8Array) {
+                    return value;
+                }
+                else {
+                    throw new Error(`Invalid Protobuf value: ${value}`);
+                }
+            case NetworkTablesTypeInfos.kStructSchema:
+                if (value instanceof Uint8Array) {
+                    return value;
+                }
+                else {
+                    throw new Error(`Invalid struct schema value: ${value}`);
+                }
+            // 16
+            case NetworkTablesTypeInfos.kBooleanArray:
+                return z.array(z.boolean()).parse(value);
+            // 17
+            case NetworkTablesTypeInfos.kDoubleArray:
+                return z.array(finiteNumSchema).parse(value);
+            // 18
+            case NetworkTablesTypeInfos.kIntegerArray:
+                return z.array(integerSchema).parse(value);
+            // 19
+            case NetworkTablesTypeInfos.kFloatArray:
+                return z.array(finiteNumSchema).parse(value);
+            // 20
+            case NetworkTablesTypeInfos.kStringArray:
+                return z.array(z.string()).parse(value);
+            default: {
+                // Type num 5: struct topics store full type in typeInfo (e.g. struct:Pose2d) for topic
+                // reuse/type identity, so we see struct: here. Protobuf topics use kProtobuf [5, 'protobuf']
+                // only; proto:MessageName is used in announce/decoding, not as topic typeInfo.
+                const typeString = expectedTypeInfo[1];
+                if (typeString.startsWith('struct:')) {
+                    if (value instanceof Uint8Array)
+                        return value;
+                    throw new Error(`Invalid struct value: expected Uint8Array`);
+                }
+                throw new Error(`Invalid type info: ${expectedTypeInfo}`);
+            }
+        }
+    }
+}
+NetworkTablesTypeInfos.kBoolean = [0, 'boolean'];
+NetworkTablesTypeInfos.kDouble = [1, 'double'];
+NetworkTablesTypeInfos.kInteger = [2, 'int'];
+NetworkTablesTypeInfos.kFloat = [3, 'float'];
+NetworkTablesTypeInfos.kString = [4, 'string'];
+NetworkTablesTypeInfos.kJson = [4, 'json'];
+NetworkTablesTypeInfos.kUint8Array = [5, 'raw'];
+NetworkTablesTypeInfos.kRPC = [5, 'rpc'];
+NetworkTablesTypeInfos.kMsgpack = [5, 'msgpack'];
+NetworkTablesTypeInfos.kProtobuf = [5, 'protobuf'];
+/** Type info for struct schema topics (/.schema/struct:TypeName). Wire type 5 (raw bytes), type string 'structschema'. */
+NetworkTablesTypeInfos.kStructSchema = [5, 'structschema'];
+NetworkTablesTypeInfos.kBooleanArray = [16, 'boolean[]'];
+NetworkTablesTypeInfos.kDoubleArray = [17, 'double[]'];
+NetworkTablesTypeInfos.kIntegerArray = [18, 'int[]'];
+NetworkTablesTypeInfos.kFloatArray = [19, 'float[]'];
+NetworkTablesTypeInfos.kStringArray = [20, 'string[]'];
+
+class NetworkTablesProtobufTopic extends NetworkTablesTopic {
+    /**
+     * Creates a new topic. This should only be done after the
+     * base NTCore client has been initialized.
+     * @param client - The client that owns the topic.
+     * @param name - The name of the topic.
+     * @param options - The options for the topic.
+     * @param options.defaultValue
+     * @param options.validator
+     * @param options.protoFilePath - Node.js only. Use protoSource or messageType in the browser.
+     * @param options.protoSource - In-memory .proto text. Safe in the browser.
+     * @param options.messageType - Prebuilt protobufjs Type. Safe in the browser.
+     */
+    constructor(client, name, options) {
+        // Note: We can't encode the default value here because we don't have the message type yet.
+        // The default value will be encoded when setValue is called or when the schema is available.
+        super(client, name, NetworkTablesTypeInfos.kProtobuf, undefined);
+        // Protobuf support
+        this.decodedValue = null;
+        this._protobufMessageType = null;
+        this._schemaRegistered = false;
+        /** Stored error when constructor's fire-and-forget loadProtoSchema fails; re-thrown by ensureMessageType. */
+        this._schemaLoadError = null;
+        this._validator = options?.validator;
+        this._protoFilePath = options?.protoFilePath;
+        this._protoSource = options?.protoSource;
+        this._providedMessageType = options?.messageType;
+        // Store the default value to encode later when we have the schema
+        if (options?.defaultValue !== undefined) {
+            this.decodedValue = options.defaultValue;
+        }
+        if (options?.messageType) {
+            this.applyMessageType(options.messageType);
+        }
+        else if (options?.protoSource) {
+            try {
+                const { messageName, root } = this.client.protobufSchemaManager.parseSource(options.protoSource);
+                this._protobufMessageName = messageName;
+                this._messageTypeString = `proto:${messageName}`;
+                this._protobufMessageType = root.lookupType(messageName);
+            }
+            catch (error) {
+                this._schemaLoadError =
+                    error instanceof Error ? error : new Error(`Failed to parse proto source: ${String(error)}`);
+                console.error(`Failed to parse proto source for ${name}:`, error);
+            }
+            this.loadProtoSource(options.protoSource).catch((error) => {
+                if (this._protobufMessageType != null) {
+                    console.error(`Failed to register proto source for ${name}:`, error);
+                    return;
+                }
+                this._schemaLoadError =
+                    error instanceof Error ? error : new Error(`Failed to parse proto source: ${String(error)}`);
+                console.error(`Failed to parse proto source for ${name}:`, error);
+            });
+        }
+        else if (options?.protoFilePath) {
+            this.loadProtoSchema(options.protoFilePath).catch((error) => {
+                this._schemaLoadError =
+                    error instanceof Error ? error : new Error(`Failed to load proto schema: ${String(error)}`);
+                console.error(`Failed to load proto schema from ${options.protoFilePath}:`, error);
+            });
+        }
+    }
+    /**
+     * Applies options to an existing protobuf topic.
+     * Used when returning a cached topic from getProtobufTopic so the returned
+     * instance has the requested validator, protoFilePath, and defaultValue.
+     * A later `validator` replaces any previous validator because the topic is a singleton.
+     * @param options - The options to apply.
+     */
+    applyOptions(options) {
+        if (options?.validator !== undefined) {
+            this._validator = options.validator;
+        }
+        if (options?.messageType !== undefined) {
+            this.assertMessageTypeUnchanged(this.normalizeMessageName(options.messageType.fullName));
+            this._providedMessageType = options.messageType;
+            this._schemaLoadError = null;
+            this.applyMessageType(options.messageType);
+            if (!this._publisher)
+                this._schemaRegistered = false;
+        }
+        else if (options?.protoSource !== undefined) {
+            let parsed;
+            try {
+                parsed = this.client.protobufSchemaManager.parseSource(options.protoSource);
+            }
+            catch (error) {
+                if (this._protobufMessageType == null) {
+                    this._schemaLoadError =
+                        error instanceof Error ? error : new Error(`Failed to parse proto source: ${String(error)}`);
+                }
+                console.error(`Failed to parse proto source for ${this.name}:`, error);
+                return;
+            }
+            this.assertMessageTypeUnchanged(parsed.messageName);
+            this._protoSource = options.protoSource;
+            this._schemaLoadError = null;
+            this._protobufMessageName = parsed.messageName;
+            this._messageTypeString = `proto:${parsed.messageName}`;
+            this._protobufMessageType = parsed.root.lookupType(parsed.messageName);
+            if (!this._publisher)
+                this._schemaRegistered = false;
+        }
+        else if (options?.protoFilePath !== undefined) {
+            if (!this._publisher)
+                this._schemaRegistered = false;
+            this.loadProtoSchema(options.protoFilePath)
+                .then(() => {
+                this._protoFilePath = options.protoFilePath;
+                this._schemaLoadError = null;
+            })
+                .catch((error) => {
+                if (this._protobufMessageType == null) {
+                    this._schemaLoadError =
+                        error instanceof Error ? error : new Error(`Failed to load proto schema: ${String(error)}`);
+                }
+                console.error(`Failed to load proto schema from ${options.protoFilePath}:`, error);
+            });
+        }
+        if (options?.defaultValue !== undefined && this.decodedValue == null) {
+            this.decodedValue = options.defaultValue;
+        }
+    }
+    normalizeMessageName(name) {
+        return name.startsWith('.') ? name.slice(1) : name;
+    }
+    assertMessageTypeUnchanged(messageName) {
+        if (this._protobufMessageName && this._protobufMessageName !== messageName) {
+            throw new Error(`Cannot change protobuf message type on published topic "${this.name}" from "${this._protobufMessageName}" to "${messageName}".`);
+        }
+    }
+    /**
+     * Gets the value of the topic.
+     * @returns The value of the topic.
+     */
+    getValue() {
+        return this.decodedValue;
+    }
+    setValue(value) {
+        const validatedValue = this._validator ? this._validator.parse(value) : value;
+        // Encode first so schema load errors (e.g. bad protoFilePath) are thrown before publisher check
+        const encoded = this.encodeValue(validatedValue);
+        if (!this.publisher) {
+            pubsubLogger.debug('Publisher check failed before setValue', { topicName: this.name });
+            throw new Error('Cannot set value on topic without being the publisher');
+        }
+        this.decodedValue = validatedValue;
+        this.setWireValue(encoded);
+        this.afterSetWireValue();
+    }
+    /**
+     * Ensures the protobuf message type is available, fetching it if necessary.
+     * @returns The protobuf message type.
+     * @throws {Error} If schema loading failed in the constructor (protoFilePath), re-throws that error.
+     * @throws {Error} If the protobuf message type cannot be found in the schema cache.
+     */
+    ensureMessageType() {
+        if (this._schemaLoadError) {
+            throw this._schemaLoadError;
+        }
+        if (!this._protobufMessageType) {
+            // Try to fetch schema if not already fetched
+            if (this._protobufMessageName) {
+                this.fetchProtobufSchema(this._protobufMessageName);
+            }
+            if (!this._protobufMessageType) {
+                throw new Error('Protobuf message type not found');
+            }
+        }
+        return this._protobufMessageType;
+    }
+    /**
+     * Decodes a protobuf-encoded value to a typed object.
+     * @param value - The protobuf-encoded Uint8Array value.
+     * @returns The decoded protobuf object.
+     * @throws {Error} If the protobuf message type is not found in the schema cache.
+     *                  This can occur if decoding is attempted before the schema has been
+     *                  fetched from NetworkTables (e.g., value update arrives before
+     *                  announcement is processed or schema topic is received).
+     */
+    decodeValue(value) {
+        const messageType = this.ensureMessageType();
+        const decoded = messageType.decode(value);
+        const obj = messageType.toObject(decoded, { defaults: true });
+        // If a validator is provided, validate the decoded object
+        if (this._validator) {
+            return this._validator.parse(obj);
+        }
+        return obj;
+    }
+    /**
+     * Encodes a typed object to a protobuf-encoded Uint8Array.
+     * @param value - The typed object to encode.
+     * @returns The protobuf-encoded Uint8Array.
+     * @throws {Error} If the protobuf message type is not found in the schema cache.
+     *                  This can occur if encoding is attempted before the schema has been
+     *                  loaded (e.g., setValue called before protoFilePath schema is loaded
+     *                  or before the topic announcement provides the message type).
+     */
+    encodeValue(value) {
+        const messageType = this.ensureMessageType();
+        return messageType.encode(value).finish();
+    }
+    /**
+     * Updates the value of the topic.
+     * This should only be called by the PubSubClient.
+     * @param value - The value to update.
+     * @param lastChangedTime - The server time of the last value change.
+     */
+    updateValue(value, lastChangedTime) {
+        this.decodedValue = this.decodeValue(value);
+        super.updateValue(value, lastChangedTime);
+    }
+    // ------------- //
+    // ANNOUNCEMENTS //
+    // ------------- //
+    /**
+     * Marks the topic as announced. This should only be called by the PubSubClient.
+     * @param params - The parameters of the announcement.
+     */
+    announce(params) {
+        super.announce(params);
+        const typeString = params.type;
+        // Check if this is a protobuf topic
+        // Skip schema topics (they contain FileDescriptorProto and shouldn't be decoded)
+        if (!this.name.startsWith('/.schema/')) {
+            // Extract message name from type string
+            let messageName;
+            if (typeString.startsWith('proto:')) {
+                // Type is like "proto:frc.Pose2d" - extract "frc.Pose2d"
+                messageName = typeString.substring(6); // Remove "proto:" prefix
+            }
+            else if (typeString === 'protobuf') {
+                // Type is just "protobuf" - try to infer from topic name
+                // This is a fallback; ideally the type should be "proto:MessageName"
+                messageName = this.name.split('/').pop(); // Use last segment of topic name
+            }
+            if (messageName) {
+                this._protobufMessageName = messageName;
+                // Fetch schema asynchronously
+                this.fetchProtobufSchema(messageName);
+            }
+        }
+    }
+    /**
+     * Fetches the protobuf schema for this topic.
+     * @param messageName - The protobuf message name.
+     */
+    fetchProtobufSchema(messageName) {
+        const messageType = this.client.protobufSchemaManager.fetchMessageType(messageName);
+        if (messageType) {
+            this._protobufMessageType = messageType;
+        }
+    }
+    /**
+     * Loads a proto schema from a file path (Node.js only).
+     * @param protoFilePath - Path to the .proto file.
+     */
+    async loadProtoSchema(protoFilePath) {
+        try {
+            const { messageName, root } = await this.client.protobufSchemaManager.registerSchema(protoFilePath);
+            this.assertMessageTypeUnchanged(messageName);
+            this._protobufMessageName = messageName;
+            this._messageTypeString = `proto:${messageName}`;
+            const messageType = root.lookupType(messageName);
+            if (messageType) {
+                this._protobufMessageType = messageType;
+            }
+        }
+        catch (error) {
+            throw new Error('Failed to load proto schema', { cause: error });
+        }
+    }
+    /**
+     * Loads a proto schema from an in-memory source string.
+     * @param protoSource - Contents of a .proto file.
+     */
+    async loadProtoSource(protoSource) {
+        try {
+            const { messageName, root } = this.client.protobufSchemaManager.parseSource(protoSource);
+            this._protobufMessageName = messageName;
+            this._messageTypeString = `proto:${messageName}`;
+            this._protobufMessageType = root.lookupType(messageName);
+            await this.client.protobufSchemaManager.registerSchemaFromSource(protoSource);
+        }
+        catch (error) {
+            throw new Error('Failed to parse proto source', { cause: error });
+        }
+    }
+    /**
+     * Applies a prebuilt protobufjs Type for encode/decode.
+     * @param messageType - The protobufjs Type.
+     */
+    applyMessageType(messageType) {
+        const normalize = (name) => (name.startsWith('.') ? name.slice(1) : name);
+        const messageName = normalize(messageType.fullName);
+        this._protobufMessageName = messageName;
+        this._messageTypeString = `proto:${messageName}`;
+        this._protobufMessageType = messageType;
+    }
+    // ----------- //
+    // SUBSCRIBING //
+    // ----------- //
+    // ---------- //
+    // PUBLISHING //
+    // ---------- //
+    /**
+     * Publishes the topic.
+     * If a proto file path was provided, registers the schema first.
+     * @param properties - The properties to publish the topic with.
+     * @param id - The UID of the publisher. You must verify that the ID is not already in use.
+     * @returns A promise that resolves when the topic is published.
+     */
+    async publish(properties = {}, id) {
+        // Use unified in-flight protection from PubSubClient
+        // Key format: "publish:" prefix to avoid conflicts with schema registrations
+        const operationKey = `publish:${this.name}`;
+        return this.client.getOrCreateInFlightOperation(operationKey, async () => {
+            // Check if already publisher inside the in-flight operation to prevent race conditions
+            if (this.publisher) {
+                pubsubLogger.debug('Publish skipped', { topicName: this.name, reason: 'already publisher' });
+                return;
+            }
+            // If a schema source is provided and schema not yet registered, register it first
+            if (!this._schemaRegistered) {
+                try {
+                    if (this._providedMessageType) {
+                        await this.client.protobufSchemaManager.registerSchemaFromType(this._providedMessageType);
+                        this._schemaRegistered = true;
+                    }
+                    else if (this._protoSource) {
+                        await this.loadProtoSource(this._protoSource);
+                        this._schemaRegistered = true;
+                    }
+                    else if (this._protoFilePath) {
+                        await this.loadProtoSchema(this._protoFilePath);
+                        this._schemaRegistered = true;
+                    }
+                }
+                catch (error) {
+                    throw new Error('Failed to register protobuf schema before publishing', { cause: error });
+                }
+            }
+            // Use the message type string if available, otherwise fall back to generic 'protobuf'
+            const typeString = this._messageTypeString || this.typeInfo[1];
+            // Get or generate pubuid
+            const pubuid = id ?? this.client.messenger.getNextPubUID();
+            this._pubuid = pubuid;
+            this._publishProperties = properties;
+            pubsubLogger.debug('Topic published', { topicName: this.name, pubuid, properties, type: typeString });
+            // Publish with the correct type string using messenger directly
+            const publishParams = {
+                type: typeString,
+                name: this.name,
+                pubuid,
+                properties,
+            };
+            return await this.client.messenger.publish(publishParams);
+        });
+    }
+}
+
+/**
+ * JSON topic: public value is a parsed object; wire format is a JSON string with type `'json'`.
+ */
+class NetworkTablesJsonTopic extends NetworkTablesTopic {
+    /**
+     * Creates a new JSON topic.
+     * @param client - The client that owns the topic.
+     * @param name - The name of the topic.
+     * @param defaultValue - The default public value of the topic.
+     * @param options - Optional runtime validator for parsed JSON.
+     */
+    constructor(client, name, defaultValue, options) {
+        super(client, name, NetworkTablesTypeInfos.kJson, undefined);
+        if (this.decodedValue === undefined) {
+            this.decodedValue = null;
+        }
+        this.applyOptions({ defaultValue, validator: options?.validator });
+    }
+    /**
+     * Applies options to this topic. Used when returning a cached topic from getJsonTopic.
+     * A later defaultValue is ignored once a value exists (matches createTopic).
+     * A later `validator` replaces any previous validator because the topic is a singleton.
+     * @param options - The options to apply.
+     */
+    applyOptions(options) {
+        if (options?.validator !== undefined) {
+            this._validator = options.validator;
+        }
+        if (options?.defaultValue !== undefined && this.decodedValue == null) {
+            this.decodedValue = options.defaultValue;
+        }
+    }
+    maybeValidate(value) {
+        return (this._validator ? this._validator.parse(value) : value);
+    }
+    /**
+     * Gets the parsed JSON value of the topic.
+     * @returns The parsed JSON object, or null if no value has been set.
+     */
+    getValue() {
+        return this.decodedValue;
+    }
+    /**
+     * Sets the JSON value of the topic. The value is serialized with JSON.stringify for the wire.
+     * @param value - The object to publish.
+     */
+    setValue(value) {
+        if (!this.publisher) {
+            pubsubLogger.debug('Publisher check failed before setValue', { topicName: this.name });
+            throw new Error('Cannot set value on topic without being the publisher');
+        }
+        const validated = this.maybeValidate(value);
+        const encoded = JSON.stringify(validated);
+        this.decodedValue = validated;
+        this.setWireValue(encoded);
+        this.afterSetWireValue();
+    }
+    /**
+     * Updates the value of the topic from the wire JSON string.
+     * This should only be called by the PubSubClient.
+     * @param value - The wire-format JSON string.
+     * @param lastChangedTime - The server time of the last value change.
+     */
+    updateValue(value, lastChangedTime) {
+        const parsed = JSON.parse(value);
+        if (typeof parsed !== 'object' || parsed === null) {
+            throw new Error(`Bad JSON value: ${value}`);
+        }
+        this.decodedValue = this.maybeValidate(parsed);
+        super.updateValue(value, lastChangedTime);
+    }
+}
+
+/** SystemCore mDNS name (WPILib `SetServerFixed`). Use as a URI, not as a team mapping. */
+const SYSTEMCORE_MDNS_HOST = 'robot.local';
+const ROBORIO_MDNS = /^roborio-(\d+)-frc\.local$/i;
+const TEAM_IP = /^10\.(\d{1,3})\.(\d{1,3})\.2$/;
+/** WPILib maximum team number for `10.TE.AM.2` addressing. */
+const MAX_TEAM_NUMBER = 25599;
+/**
+ * Field/radio IPv4 for a team (`10.TE.AM.2`), matching WPILib `SetServerTeam`.
+ * Team 973 → `10.9.73.2`.
+ */
+function getTeamIpAddress(team) {
+    const n = Math.trunc(team);
+    if (!Number.isFinite(n) || n < 1 || n > MAX_TEAM_NUMBER) {
+        throw new Error(`Team number must be an integer from 1 to ${MAX_TEAM_NUMBER}`);
+    }
+    return `10.${Math.floor(n / 100)}.${n % 100}.2`;
+}
+/**
+ * Hostname used for a team-number connection.
+ * RoboRIO (default): `roborio-{team}-frc.local`.
+ * SystemCore: `10.TE.AM.2` (WPILib `SetServerTeam`). Use {@link SYSTEMCORE_MDNS_HOST} as a URI for `robot.local`.
+ */
+function getRobotAddress(team, platform = 'roborio') {
+    if (platform === 'systemcore') {
+        return getTeamIpAddress(team);
+    }
+    return `roborio-${team}-frc.local`;
+}
+/** Detects a RoboRIO mDNS name or SystemCore team IP. Other hosts return `{ platform: null, team: null }`. */
+function parseRobotAddress(host) {
+    const robo = host.match(ROBORIO_MDNS);
+    if (robo) {
+        return { platform: 'roborio', team: Number(robo[1]) };
+    }
+    const ip = host.match(TEAM_IP);
+    if (ip) {
+        const te = Number(ip[1]);
+        const am = Number(ip[2]);
+        if (te <= 255 && am <= 99) {
+            const team = te * 100 + am;
+            if (team >= 1 && team <= MAX_TEAM_NUMBER && getTeamIpAddress(team) === host) {
+                return { platform: 'systemcore', team };
+            }
+        }
+    }
+    return { platform: null, team: null };
+}
+/**
+ * Class for holding utility functions.
+ */
+class Util {
+    /**
+     * Get the DOM time in microseconds.
+     * @returns The current microseconds of the DOM.
+     */
+    static getMicros() {
+        return performance.now() * 1000;
+    }
+    /**
+     * Given a number, determine if it is a double
+     * @param x - A number.
+     * @returns Whether it is a double.
+     */
+    static isDouble(x) {
+        if (typeof x === 'number' && Number.isFinite(x) && !Number.isInteger(x)) {
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Create a binary message from a topic.
+     * @param pubuid - The topic's publisher UID.
+     * @param timestamp - The timestamp of the message, matching the server.
+     * @param data - The data.
+     * @param typeInfo - The type info.
+     * @returns The binary message.
+     */
+    static createBinaryMessage(pubuid, timestamp, data, typeInfo) {
+        return [pubuid, timestamp, typeInfo[0], data];
+    }
+    /**
+     * Create a server URL for connecting to the robot.
+     * @param uri - The URI of the robot.
+     * @param port - The port of NT server on the robot.
+     * @returns The server URL with a unique client ID.
+     */
+    static createServerUrl(uri, port) {
+        return `ws://${uri}:${port}/nt/ntcore-ts-${Math.floor(Math.random() * 1000)}`;
+    }
+    /**
+     * Get the hostname of a robot for a team number.
+     * @param team - The team number.
+     * @param platform - RoboRIO mDNS (default) or SystemCore team IP.
+     * @returns The hostname or IPv4 address.
+     */
+    static getRobotAddress(team, platform = 'roborio') {
+        return getRobotAddress(team, platform);
+    }
+}
+
+/** Socket for NetworkTables 4.1 */
+class NetworkTablesSocket {
+    get websocket() {
+        return this._websocket;
+    }
+    /**
+     * Creates a new NetworkTables socket.
+     * @param serverUrl - The URL of the server to connect to.
+     * @param onSocketOpen - Called when the socket is opened.
+     * @param onSocketClose - Called when the socket is closed.
+     * @param onTopicUpdate - Called when a topic is updated.
+     * @param onAnnounce - Called when a topic is announced.
+     * @param onUnannounce - Called when a topic is unannounced.
+     * @param onProperties - Called when a topic's properties are updated.
+     * @param autoConnect - Whether to automatically connect to the server.
+     */
+    constructor(serverUrl, onSocketOpen, onSocketClose, onTopicUpdate, onAnnounce, onUnannounce, onProperties, autoConnect) {
+        this.connectionListeners = new Set();
+        this.offset = 0;
+        this.bestRtt = -1;
+        /** True after the first valid RTT reply; required before control frames and strong value publishes. */
+        this.clockSynced = false;
+        this.connectionAttemptCount = 0;
+        this.lastConnectionLogTime = 0;
+        this.tearingDown = false;
+        this.connectionWaiters = new Map();
+        this.autoConnect = true;
+        this.messageQueue = [];
+        // Connect to the server using the provided URL
+        this._websocket = new WebSocket(serverUrl, [NetworkTablesSocket.PROTOCOL_V4_1, NetworkTablesSocket.PROTOCOL_V4_0]);
+        socketLogger.debug('Connection attempt started', {
+            serverUrl,
+            protocols: [NetworkTablesSocket.PROTOCOL_V4_1, NetworkTablesSocket.PROTOCOL_V4_0],
+            autoConnect,
+        });
+        this.serverUrl = serverUrl;
+        this.onSocketOpen = onSocketOpen;
+        this.onSocketClose = onSocketClose;
+        this.onTopicUpdate = onTopicUpdate;
+        this.onAnnounce = onAnnounce;
+        this.onUnannounce = onUnannounce;
+        this.onProperties = onProperties;
+        this.autoConnect = autoConnect;
+        this.init();
+    }
+    /**
+     * Gets the instance of the NetworkTables socket.
+     * @param serverUrl - The URL of the server to connect to.
+     * @param onSocketOpen - Called when the socket is opened.
+     * @param onSocketClose - Called when the socket is closed.
+     * @param onTopicUpdate - Called when a topic is updated.
+     * @param onAnnounce - Called when a topic is announced.
+     * @param onUnannounce - Called when a topic is unannounced.
+     * @param onProperties - Called when a topic's properties are updated.
+     * @param autoConnect - Whether to automatically connect to the server.
+     * @returns The instance of the NetworkTables socket.
+     */
+    static getInstance(serverUrl, onSocketOpen, onSocketClose, onTopicUpdate, onAnnounce, onUnannounce, onProperties, autoConnect = true) {
+        let instance = this.instances.get(serverUrl);
+        if (!instance) {
+            instance = new this(serverUrl, onSocketOpen, onSocketClose, onTopicUpdate, onAnnounce, onUnannounce, onProperties, autoConnect);
+            this.instances.set(serverUrl, instance);
+        }
+        return instance;
+    }
+    /**
+     * Initialization. This is done outside of the constructor to allow for
+     * the socket to refresh itself.
+     */
+    init() {
+        this.clearHeartbeatInterval();
+        this.clearIdleTimer();
+        if (this._websocket) {
+            const ws = this._websocket;
+            // Open handler
+            this._websocket.onopen = () => {
+                if (this._websocket !== ws)
+                    return;
+                // Reset connection attempt counter on successful connection
+                if (this.connectionAttemptCount > 0) {
+                    socketLogger.info('Connection restored', {
+                        attempts: this.connectionAttemptCount,
+                        protocol: this._websocket.protocol === 'v4.1.networktables.first.wpi.edu' ? 'NT 4.1' : 'NT 4.0',
+                    });
+                    this.connectionAttemptCount = 0;
+                }
+                else {
+                    if (this._websocket.protocol === 'v4.1.networktables.first.wpi.edu') {
+                        socketLogger.info('Connected on NT 4.1');
+                    }
+                    else {
+                        socketLogger.info('Connected on NT 4.0');
+                    }
+                }
+                // Spec: timestamp sync immediately after connect, before other control messages.
+                this.heartbeat();
+                this.resetIdleTimer();
+                // Periodic RTT pings for keepalive. Spec says 4.1 uses WebSocket PING, but Node/JS clients
+                // cannot send PING, so we use binary RTT for both 4.0 and 4.1.
+                this.heartbeatInterval = setInterval(() => {
+                    if (this.isSocketOpen()) {
+                        this.heartbeat();
+                    }
+                }, NetworkTablesSocket.RTT_PERIOD_MS);
+            };
+            // Close handler
+            this._websocket.onclose = (e) => {
+                if (this._websocket !== ws)
+                    return;
+                // Notify client and cancel heartbeat
+                this.resetClockSync();
+                this.clearHeartbeatInterval();
+                this.clearIdleTimer();
+                this.updateConnectionListeners();
+                this.onSocketClose();
+                // Increment connection attempt counter
+                this.connectionAttemptCount++;
+                const now = Date.now();
+                const timeSinceLastLog = now - this.lastConnectionLogTime;
+                const shouldLogFullDetails = this.connectionAttemptCount === 1 || timeSinceLastLog >= NetworkTablesSocket.CONNECTION_LOG_INTERVAL;
+                if (shouldLogFullDetails) {
+                    // Log full details on first attempt or every 10 seconds
+                    socketLogger.warn('Connection lost', {
+                        code: e.code,
+                        reason: e.reason || 'No reason provided',
+                        queuedMessages: this.messageQueue.length,
+                        attempt: this.connectionAttemptCount,
+                    });
+                    this.lastConnectionLogTime = now;
+                }
+                else {
+                    // Log concise message for repeated attempts
+                    socketLogger.debug('Reconnection attempt', {
+                        attempt: this.connectionAttemptCount,
+                        nextFullLogIn: Math.ceil((NetworkTablesSocket.CONNECTION_LOG_INTERVAL - timeSinceLastLog) / 1000) + 's',
+                    });
+                }
+                if (this.autoConnect && !this.tearingDown) {
+                    this.clearReconnectTimer();
+                    this.reconnectTimer = setTimeout(() => {
+                        this.reconnectTimer = undefined;
+                        if (!this.autoConnect || this.tearingDown)
+                            return;
+                        this._websocket = new WebSocket(this.serverUrl, [
+                            NetworkTablesSocket.PROTOCOL_V4_1,
+                            NetworkTablesSocket.PROTOCOL_V4_0,
+                        ]);
+                        this.init();
+                    }, NetworkTablesSocket.RECONNECT_TIMEOUT);
+                }
+            };
+            this._websocket.binaryType = 'arraybuffer';
+            // Set up event listeners for messages and errors
+            this._websocket.onmessage = (event) => {
+                if (this._websocket !== ws)
+                    return;
+                this.onMessage(event);
+            };
+            this._websocket.onerror = (event) => {
+                if (this._websocket !== ws)
+                    return;
+                this.onError(event);
+            };
+        }
+    }
+    /**
+     * Reset the socket and reconnect to the server.
+     * @param serverUrl - The URL of the server to connect to.
+     */
+    reinstantiate(serverUrl) {
+        socketLogger.info('Socket reinstantiation', { oldUrl: this.serverUrl, newUrl: serverUrl });
+        this.clearReconnectTimer();
+        this.clearHeartbeatInterval();
+        this.clearIdleTimer();
+        this.resetClockSync();
+        const previous = this._websocket;
+        previous.onopen = null;
+        previous.onclose = null;
+        previous.onmessage = null;
+        previous.onerror = null;
+        previous.close();
+        this.serverUrl = serverUrl;
+        this.updateConnectionListeners();
+        this._websocket = new WebSocket(this.serverUrl, [
+            NetworkTablesSocket.PROTOCOL_V4_1,
+            NetworkTablesSocket.PROTOCOL_V4_0,
+        ]);
+        this.init();
+    }
+    /**
+     * Returns whether the socket is open and the client clock is synchronized with the server.
+     * @returns Whether the robot connection is ready for control and value frames.
+     */
+    isConnected() {
+        return this.isSocketOpen() && this.clockSynced;
+    }
+    /**
+     * Returns whether the socket is connecting (including waiting for the first RTT).
+     * @returns Whether the robot connection is not yet ready.
+     */
+    isConnecting() {
+        return this._websocket.readyState === WebSocket.CONNECTING || (this.isSocketOpen() && !this.clockSynced);
+    }
+    /**
+     * Wait for the socket to connect.
+     * @returns A promise that resolves when the socket is connected.
+     */
+    waitForConnection() {
+        return new Promise((resolve, reject) => {
+            if (this.tearingDown) {
+                reject(new Error('Socket closed'));
+                return;
+            }
+            if (this.isConnected()) {
+                resolve();
+                return;
+            }
+            const listener = () => {
+                if (this.isConnected()) {
+                    this.connectionWaiters.delete(reject);
+                    this.removeConnectionListener(listener);
+                    resolve();
+                }
+            };
+            this.connectionWaiters.set(reject, listener);
+            this.addConnectionListener(listener);
+        });
+    }
+    /**
+     * Create a connection listener.
+     * @param callback - Called when the connection state changes.
+     * @param immediateNotify - When true, the callback is also invoked with the current connection state
+     *   on a microtask after this method returns, so the returned disposer can be used safely from that
+     *   first invocation (unlike a synchronous notify before return).
+     * @returns A function that removes the listener.
+     */
+    addConnectionListener(callback, immediateNotify) {
+        this.connectionListeners.add(callback);
+        socketLogger.debug('Connection listener added', {
+            totalListeners: this.connectionListeners.size,
+            immediateNotify,
+            currentState: this.isConnected(),
+        });
+        if (immediateNotify) {
+            queueMicrotask(() => {
+                if (!this.connectionListeners.has(callback))
+                    return;
+                callback(this.isConnected());
+            });
+        }
+        return () => this.removeConnectionListener(callback);
+    }
+    /**
+     * Remove a connection listener.
+     * @param callback - The callback to remove.
+     */
+    removeConnectionListener(callback) {
+        this.connectionListeners.delete(callback);
+        socketLogger.debug('Connection listener removed', { totalListeners: this.connectionListeners.size });
+    }
+    /**
+     * Get the best round-trip time to the server in milliseconds.
+     * @returns RTT in ms, or -1 if not connected or not yet measured.
+     */
+    getBestRttMs() {
+        if (!this.isConnected() || this.bestRtt < 0)
+            return -1;
+        return Math.round(this.bestRtt / 1000);
+    }
+    /**
+     * Updates all connection listeners with the current connection state.
+     */
+    updateConnectionListeners() {
+        this.connectionListeners.forEach((callback) => callback(this.isConnected()));
+    }
+    /**
+     * Stops auto-reconnecting to the server.
+     */
+    stopAutoConnect() {
+        socketLogger.info('Auto-connect disabled');
+        this.autoConnect = false;
+        this.clearReconnectTimer();
+    }
+    /**
+     * Starts auto-reconnecting to the server. If the socket is closed, opens a new connection.
+     */
+    startAutoConnect() {
+        socketLogger.info('Auto-connect enabled');
+        this.autoConnect = true;
+        if (this.tearingDown)
+            return;
+        const readyState = this._websocket.readyState;
+        if (readyState === WebSocket.CLOSED || readyState === WebSocket.CLOSING) {
+            this._websocket = new WebSocket(this.serverUrl, [
+                NetworkTablesSocket.PROTOCOL_V4_1,
+                NetworkTablesSocket.PROTOCOL_V4_0,
+            ]);
+            this.init();
+        }
+    }
+    clearReconnectTimer() {
+        if (this.reconnectTimer != null) {
+            clearTimeout(this.reconnectTimer);
+            this.reconnectTimer = undefined;
+        }
+    }
+    rejectConnectionWaiters() {
+        const error = new Error('Socket closed');
+        for (const [reject, listener] of this.connectionWaiters) {
+            this.removeConnectionListener(listener);
+            reject(error);
+        }
+        this.connectionWaiters.clear();
+    }
+    /**
+     * Handle a message from the websocket.
+     * @param event - The message event.
+     */
+    onMessage(event) {
+        this.resetIdleTimer();
+        if (event.data instanceof ArrayBuffer || event.data instanceof Uint8Array) {
+            socketLogger.debug('Binary frame received', { size: event.data.byteLength });
+            this.handleBinaryFrame(event.data);
+        }
+        else {
+            socketLogger.debug('Text frame received', {
+                size: typeof event.data === 'string' ? event.data.length : 'unknown',
+            });
+            this.handleTextFrame(event.data);
+        }
+    }
+    /**
+     * Handle an error from the websocket.
+     * @param event - The error event.
+     */
+    onError(event) {
+        // WebSocket errors typically precede close events, so we check if we should log
+        // The close handler will log the main connection failure message
+        // We only log error details if we haven't logged recently to avoid duplicate messages
+        const now = Date.now();
+        const timeSinceLastLog = now - this.lastConnectionLogTime;
+        // Only log if it's been a while since the last connection log (close handler handles most logging)
+        if (timeSinceLastLog >= NetworkTablesSocket.CONNECTION_LOG_INTERVAL) {
+            const errorMessage = typeof ErrorEvent !== 'undefined' && event instanceof ErrorEvent ? event.message : 'Connection error';
+            socketLogger.debug('WebSocket error occurred', {
+                error: errorMessage,
+                note: 'Connection close details will follow',
+            });
+        }
+        // Otherwise, the close handler will log the full details, so we suppress this
+    }
+    /**
+     * Handle a binary frame from the websocket.
+     * Uses sync decodeMulti (not async streams): we receive one complete frame per
+     * WebSocket message, so decodeMultiStream would add async overhead without benefit.
+     * @param frame - The frame.
+     */
+    handleBinaryFrame(frame) {
+        let messageCount = 0;
+        let heartbeatCount = 0;
+        let topicUpdateCount = 0;
+        let skippedCount = 0;
+        for (const decoded of decodeMulti(frame)) {
+            try {
+                const message = msgPackSchema.parse(decoded);
+                socketLogger.trace('Message schema validated', { topicId: message[0], typeNum: message[2] });
+                const messageData = {
+                    topicId: message[0],
+                    serverTime: message[1],
+                    typeNum: message[2],
+                    value: message[3],
+                };
+                messageCount++;
+                if (messageData.topicId === -1) {
+                    heartbeatCount++;
+                    this.handleRTT(messageData.serverTime, messageData.value);
+                }
+                else {
+                    topicUpdateCount++;
+                    this.onTopicUpdate(messageData);
+                }
+            }
+            catch (e) {
+                skippedCount++;
+                socketLogger.warn('Skipping malformed or invalid message in binary frame', {
+                    error: String(e),
+                    skippedInFrame: skippedCount,
+                });
+            }
+        }
+        socketLogger.debug('Binary frame processed', {
+            messageCount,
+            heartbeatCount,
+            topicUpdateCount,
+            skippedCount,
+        });
+    }
+    /**
+     * Handle a text frame from the websocket.
+     * @param frame - The frame.
+     */
+    handleTextFrame(frame) {
+        const messageData = JSON.parse(frame);
+        const messages = messageSchema.parse(messageData);
+        for (const message of messages) {
+            switch (message.method) {
+                case 'announce':
+                    this.onAnnounce(message.params);
+                    break;
+                case 'unannounce':
+                    this.onUnannounce(message.params);
+                    break;
+                case 'properties':
+                    this.onProperties(message.params);
+                    break;
+                default:
+                    socketLogger.warn('Client does not handle message method', { method: message.method });
+            }
+        }
+        socketLogger.debug('Text frame processed', { messageCount: messages.length });
+    }
+    /**
+     * Send a text frame to the server.
+     * @param message - The message to send.
+     */
+    sendTextFrame(message) {
+        // Send the message to the server
+        if (this.isConnected()) {
+            socketLogger.debug('Text frame sent', { method: message.method });
+            this._websocket.send(JSON.stringify([message]));
+        }
+        else {
+            socketLogger.debug('Message queued', {
+                method: message.method,
+                reason: 'not connected',
+                queueSize: this.messageQueue.length,
+            });
+            this.messageQueue.push(JSON.stringify([message]));
+        }
+    }
+    /**
+     * Function to send queued messages whenever the WebSocket connection is opened
+     */
+    sendQueuedMessages() {
+        if (this.isConnected()) {
+            const queuedCount = this.messageQueue.length;
+            if (queuedCount > 0) {
+                socketLogger.debug('Sending queued messages', { count: queuedCount });
+            }
+            while (this.messageQueue.length > 0) {
+                const message = this.messageQueue.shift();
+                if (message) {
+                    this._websocket.send(message);
+                }
+            }
+        }
+    }
+    /**
+     * Send a message to a topic.
+     * @param pubuid - The topic's publisher UID.
+     * @param value - The value to send.
+     * @param typeInfo - The type info for the value.
+     * @returns The time the message was sent, or -1 if not connected.
+     */
+    sendValueToTopic(pubuid, value, typeInfo) {
+        if (!this.isSocketOpen()) {
+            socketLogger.debug('sendValueToTopic skipped (not connected)', { pubuid, typeNum: typeInfo[0] });
+            return -1;
+        }
+        // Spec: do not send strong (non-RTT) values until the client clock is synchronized.
+        if (pubuid !== -1 && !this.clockSynced) {
+            socketLogger.debug('sendValueToTopic skipped (awaiting clock sync)', { pubuid, typeNum: typeInfo[0] });
+            return -1;
+        }
+        const time = pubuid === -1 ? 0 : Math.ceil(this.getServerTime());
+        const message = Util.createBinaryMessage(pubuid, time, value, typeInfo);
+        const cleanMsg = msgPackSchema.parse(message);
+        const framePubuid = cleanMsg[0];
+        const typeNum = cleanMsg[2];
+        // Send the message to the server (binary frames are never queued).
+        socketLogger.debug('Binary frame sent', { pubuid: framePubuid, typeNum });
+        this._websocket.send(encode(cleanMsg));
+        return time;
+    }
+    /**
+     * Send a timestamp ping to the server (topic id -1, timestamp 0, value = client microseconds).
+     */
+    heartbeat() {
+        if (!this.isSocketOpen()) {
+            return;
+        }
+        const clientTime = Math.round(Util.getMicros());
+        socketLogger.debug('Heartbeat sent', { time: clientTime });
+        const message = Util.createBinaryMessage(-1, 0, clientTime, NetworkTablesTypeInfos.kInteger);
+        const cleanMsg = msgPackSchema.parse(message);
+        this._websocket.send(encode(cleanMsg));
+    }
+    /**
+     * Handle a round trip time message from the server.
+     *
+     * RTT is `now - echoed client time` (the MessagePack value). Clock offset is updated only when
+     * this RTT is the best so far (Cristian's algorithm / NT spec).
+     * @param serverTime - Server timestamp from the reply.
+     * @param clientEcho - Client time echoed back from the ping.
+     */
+    handleRTT(serverTime, clientEcho) {
+        if (typeof clientEcho !== 'number' || !Number.isFinite(clientEcho)) {
+            socketLogger.warn('Ignoring RTT reply with non-numeric client echo', { clientEcho });
+            return;
+        }
+        const now = Util.getMicros();
+        const rtt = now - clientEcho;
+        if (rtt < 0) {
+            socketLogger.debug('Ignoring RTT with negative delta', { rtt, clientEcho, now });
+            return;
+        }
+        const wasUpdated = this.bestRtt < 0 || rtt < this.bestRtt;
+        if (wasUpdated) {
+            this.bestRtt = rtt;
+            this.offset = now - serverTime;
+        }
+        socketLogger.debug('RTT calculated', {
+            rtt,
+            bestRtt: this.bestRtt,
+            offset: this.offset,
+            serverTime,
+            clientEcho,
+            updated: wasUpdated,
+        });
+        this.completeHandshakeIfNeeded();
+    }
+    /**
+     * Get the current server time.
+     * @returns The current server time.
+     */
+    getServerTime() {
+        const clientTime = Util.getMicros();
+        const serverTime = clientTime - this.offset + this.bestRtt / 2;
+        socketLogger.trace('Server time calculated', {
+            clientTime,
+            offset: this.offset,
+            bestRtt: this.bestRtt,
+            serverTime,
+        });
+        return serverTime;
+    }
+    isSocketOpen() {
+        return this._websocket.readyState === WebSocket.OPEN;
+    }
+    resetClockSync() {
+        this.clockSynced = false;
+        this.bestRtt = -1;
+        this.offset = 0;
+    }
+    completeHandshakeIfNeeded() {
+        if (this.clockSynced || !this.isSocketOpen()) {
+            return;
+        }
+        this.clockSynced = true;
+        socketLogger.info('Robot Connected!');
+        // Re-subscribe/re-publish before notifying listeners so value sends cannot race ahead of publish frames.
+        this.onSocketOpen();
+        this.sendQueuedMessages();
+        this.updateConnectionListeners();
+    }
+    resetIdleTimer() {
+        this.clearIdleTimer();
+        if (this.tearingDown || !this.isSocketOpen()) {
+            return;
+        }
+        this.idleTimer = setTimeout(() => {
+            this.idleTimer = undefined;
+            if (this.tearingDown || !this.isSocketOpen()) {
+                return;
+            }
+            socketLogger.warn('No data for idle timeout, closing', { timeoutMs: NetworkTablesSocket.IDLE_TIMEOUT_MS });
+            this._websocket.close();
+        }, NetworkTablesSocket.IDLE_TIMEOUT_MS);
+    }
+    clearIdleTimer() {
+        if (this.idleTimer != null) {
+            clearTimeout(this.idleTimer);
+            this.idleTimer = undefined;
+        }
+    }
+    clearHeartbeatInterval() {
+        if (this.heartbeatInterval != null) {
+            clearInterval(this.heartbeatInterval);
+            this.heartbeatInterval = undefined;
+        }
+    }
+    /**
+     * Close the websocket connection.
+     */
+    close() {
+        this.tearingDown = true;
+        this.stopAutoConnect();
+        this.rejectConnectionWaiters();
+        this.clearHeartbeatInterval();
+        this.clearIdleTimer();
+        this.resetClockSync();
+        this._websocket.close();
+    }
+    /**
+     * Removes this socket from the singleton map so a later getInstance can create a new one.
+     */
+    releaseInstance() {
+        for (const [key, instance] of NetworkTablesSocket.instances) {
+            if (instance === this) {
+                NetworkTablesSocket.instances.delete(key);
+            }
+        }
+    }
+}
+NetworkTablesSocket.instances = new Map();
+NetworkTablesSocket.PROTOCOL_V4_0 = 'networktables.first.wpi.edu';
+NetworkTablesSocket.PROTOCOL_V4_1 = 'v4.1.networktables.first.wpi.edu';
+NetworkTablesSocket.RECONNECT_TIMEOUT = 1000;
+/** Timestamp keepalive period when WebSocket PING cannot be sent (NT 4.0 and JS 4.1). */
+NetworkTablesSocket.RTT_PERIOD_MS = 1000;
+/** Disconnect if no server frames arrive. Spec: ~3s when using timestamp messages for aliveness. */
+NetworkTablesSocket.IDLE_TIMEOUT_MS = 3000;
+NetworkTablesSocket.CONNECTION_LOG_INTERVAL = 10000; // Log full details every 10 seconds
+
+/** NetworkTables client. */
+class Messenger {
+    /**
+     * Gets the NetworkTablesSocket used by the Messenger.
+     * @returns The NetworkTablesSocket used by the Messenger.
+     */
+    get socket() {
+        return this._socket;
+    }
+    /**
+     * Creates a new NetworkTables client.
+     * @param serverUrl - The URL of the server to connect to.
+     * @param onTopicUpdate - Called when a topic is updated.
+     * @param onAnnounce - Called when a topic is announced.
+     * @param onUnannounce - Called when a topic is unannounced.
+     * @param onTopicProperties - Called when a topic's properties are updated.
+     */
+    constructor(serverUrl, onTopicUpdate, onAnnounce, onUnannounce, onTopicProperties) {
+        this.publications = new Map();
+        this.subscriptions = new Map();
+        this._currentPubUID = 0;
+        this._currentSubUID = 0;
+        /**
+         * Called when the socket opens.
+         */
+        this.onSocketOpen = () => {
+            const subscriptionCount = this.subscriptions.size;
+            const publicationCount = this.publications.size;
+            messengerLogger.debug('Subscribing all topics', { count: subscriptionCount });
+            // Send all subscriptions
+            this.subscriptions.forEach((params) => {
+                this.subscribe(params, true);
+            });
+            messengerLogger.debug('Publishing all topics', { count: publicationCount });
+            // Re-send publish frames best-effort on reconnect.
+            // Do not await announcements here (fire-and-forget) to avoid timers/rejections
+            // outliving the reconnect event.
+            this.publications.forEach((params) => {
+                this.sendPublishFrames(params);
+            });
+        };
+        /**
+         * Called when the socket closes.
+         */
+        this.onSocketClose = () => { };
+        this._onAnnounce = onAnnounce;
+        this._socket = NetworkTablesSocket.getInstance(serverUrl, this.onSocketOpen, this.onSocketClose, onTopicUpdate, onAnnounce, onUnannounce, onTopicProperties);
+    }
+    /**
+     * Gets the instance of the NetworkTables client.
+     * @param serverUrl - The URL of the server to connect to. This is not needed after the first call.
+     * @param onTopicUpdate - Called when a topic is updated.
+     * @param onAnnounce - Called when a topic is announced.
+     * @param onUnannounce - Called when a topic is unannounced.
+     * @param onTopicProperties - Called when a topic's properties are updated.
+     * @returns The instance of the NetworkTables client.
+     */
+    static getInstance(serverUrl, onTopicUpdate, onAnnounce, onUnannounce, onTopicProperties) {
+        let instance = this._instances.get(serverUrl);
+        if (!instance) {
+            instance = new this(serverUrl, onTopicUpdate, onAnnounce, onUnannounce, onTopicProperties);
+            this._instances.set(serverUrl, instance);
+        }
+        return instance;
+    }
+    /**
+     * Reinstantiates the messenger by resetting the socket with a new URL.
+     * @param serverUrl - The URL of the server to connect to.
+     */
+    reinstantiate(serverUrl) {
+        messengerLogger.info('Reinstantiating messenger', {
+            newUrl: serverUrl,
+            subscriptionCount: this.subscriptions.size,
+            publicationCount: this.publications.size,
+        });
+        this._socket.stopAutoConnect();
+        this._socket.reinstantiate(serverUrl);
+        this._socket.startAutoConnect();
+    }
+    parseAndFilterMessage(event, method) {
+        if (typeof event.data === 'string') {
+            messengerLogger.trace('Raw message received', { data: event.data });
+            const messageData = JSON.parse(event.data);
+            messengerLogger.trace('Message parsed from JSON', {
+                messageCount: Array.isArray(messageData) ? messageData.length : 1,
+            });
+            const messages = messageSchema.parse(messageData);
+            messengerLogger.trace('Message schema validated', { messageCount: messages.length });
+            const filtered = messages.filter((msg) => msg.method === method);
+            messengerLogger.trace('Message filtered by method', {
+                method,
+                inputCount: messages.length,
+                outputCount: filtered.length,
+            });
+            return filtered;
+        }
+        return [];
+    }
+    /**
+     * Publishes a topic to the server.
+     * @param params - The publication parameters.
+     * @param force - Whether to force the publication.
+     * @returns The announcement parameters.
+     */
+    async publish(params, force) {
+        return new Promise((resolve, reject) => {
+            // Check if the topic is already published
+            if (this.publications.has(params.pubuid) && !force) {
+                messengerLogger.debug('Publish rejected', {
+                    topicName: params.name,
+                    pubuid: params.pubuid,
+                    reason: 'already published',
+                });
+                reject(new Error('Topic is already published'));
+                return;
+            }
+            messengerLogger.debug('Publish request initiated', {
+                topicName: params.name,
+                pubuid: params.pubuid,
+                timeout: 3000,
+                force,
+            });
+            let timeoutId = null;
+            let resolved = false;
+            // Cleanup function to remove listener and clear timeouts
+            const cleanup = () => {
+                messengerLogger.trace('Cleanup: removing event listener and clearing timeouts', { topicName: params.name });
+                this.socket.websocket.removeEventListener('message', wsHandler);
+                if (timeoutId) {
+                    clearTimeout(timeoutId);
+                    messengerLogger.trace('Main timeout cleared', { topicName: params.name });
+                }
+            };
+            // Listen for the announcement
+            const resolver = (msg) => {
+                if (resolved) {
+                    return;
+                }
+                messengerLogger.trace('Promise resolver called', { topicName: params.name, pubuid: params.pubuid });
+                resolved = true;
+                cleanup();
+                // Add the topic to the list of published topics
+                this.publications.set(params.pubuid, params);
+                messengerLogger.debug('Topic published', { topicName: params.name, pubuid: params.pubuid });
+                resolve(msg);
+            };
+            // Rejector function to cleanup before rejecting
+            const rejector = (error) => {
+                if (resolved) {
+                    return;
+                }
+                messengerLogger.trace('Promise rejector called', { topicName: params.name, error: error.message });
+                resolved = true;
+                cleanup();
+                reject(error);
+            };
+            const wsHandler = (event) => {
+                const messages = this.parseAndFilterMessage(event, 'announce');
+                messengerLogger.debug('Messages filtered for announce', { count: messages.length });
+                for (const message of messages) {
+                    // Match by name and pubuid
+                    // We published with a pubuid, so we require the announcement to have the same pubuid
+                    // This ensures we get the publish-triggered announcement, not a subscription-triggered one
+                    // (per spec, server must respond to publish with announce containing pubuid)
+                    const nameMatches = message.params.name === params.name;
+                    const pubuidMatches = message.params.pubuid === params.pubuid;
+                    if (nameMatches && pubuidMatches) {
+                        messengerLogger.debug('Announcement received', {
+                            topicName: message.params.name,
+                            pubuid: message.params.pubuid,
+                            matched: true,
+                        });
+                        // Notify topic before resolving so callers can assume "publish() resolved" => "topic announced"
+                        this._onAnnounce(message.params);
+                        resolver(message);
+                        break;
+                    }
+                    // Fallback: topic announced by name but pubuid differs (e.g. robot published first).
+                    // Server may have announced from another client before our publish was processed.
+                    // Treat as success: merge our pubuid so the topic marks us as publisher, then resolve.
+                    if (nameMatches && !resolved) {
+                        messengerLogger.debug('Announcement received (name match, pubuid override)', {
+                            topicName: message.params.name,
+                            serverPubuid: message.params.pubuid,
+                            ourPubuid: params.pubuid,
+                        });
+                        const mergedParams = { ...message.params, pubuid: params.pubuid };
+                        this._onAnnounce(mergedParams);
+                        resolver({ ...message, params: mergedParams });
+                        break;
+                    }
+                }
+            };
+            messengerLogger.trace('Event listener attached', { topicName: params.name });
+            this.socket.websocket.addEventListener('message', wsHandler);
+            this.sendPublishFrames(params);
+            // Reject the promise if the topic is not announced within 3 seconds
+            this.socket
+                .waitForConnection()
+                .then(() => {
+                if (resolved) {
+                    return;
+                }
+                timeoutId = setTimeout(() => {
+                    rejector(new Error(`Topic ${params.name} was not announced within 3 seconds (3000ms)`));
+                }, 3000);
+            })
+                .catch((error) => {
+                rejector(error);
+            });
+        });
+    }
+    sendPublishFrames(params) {
+        const message = {
+            method: 'publish',
+            params,
+        };
+        this._socket.sendTextFrame(message);
+    }
+    /**
+     * Unpublishes a topic from the server.
+     * @param pubuid - The publication ID to unpublish.
+     */
+    unpublish(pubuid) {
+        // Check if the topic is not published
+        const params = this.publications.get(pubuid);
+        if (!this.publications.delete(pubuid))
+            return;
+        messengerLogger.debug('Topic unpublished', { pubuid, topicName: params?.name });
+        // Send the message to the server
+        const message = {
+            method: 'unpublish',
+            params: {
+                pubuid,
+            },
+        };
+        this._socket.sendTextFrame(message);
+    }
+    /**
+     * Subscribes to a topic.
+     * @param params - The subscription parameters.
+     * @param force - Whether to force the subscription.
+     */
+    subscribe(params, force) {
+        if (this.subscriptions.has(params.subuid) && !force) {
+            messengerLogger.debug('Subscription skipped', { subuid: params.subuid, reason: 'already exists' });
+            return;
+        }
+        if (force) {
+            messengerLogger.debug('Force subscribe', { subuid: params.subuid, topicNames: params.topics });
+        }
+        this.subscriptions.set(params.subuid, params);
+        messengerLogger.debug('Subscription created', {
+            subuid: params.subuid,
+            topicNames: params.topics,
+            prefix: params.options?.prefix || false,
+        });
+        // Create the message to send to the server
+        const message = {
+            method: 'subscribe',
+            params,
+        };
+        // Send the message to the server
+        this._socket.sendTextFrame(message);
+    }
+    /**
+     * Unsubscribes from a topic.
+     * @param subuid - The subscription ID to unsubscribe from.
+     */
+    unsubscribe(subuid) {
+        // Check if the topic is not subscribed
+        const params = this.subscriptions.get(subuid);
+        if (!this.subscriptions.has(subuid))
+            return;
+        // Remove the topic from the list of subscribed topics
+        this.subscriptions.delete(subuid);
+        messengerLogger.debug('Unsubscribed from topic', { subuid, topicNames: params?.topics });
+        // Send the message to the server
+        const message = {
+            method: 'unsubscribe',
+            params: {
+                subuid,
+            },
+        };
+        this._socket.sendTextFrame(message);
+    }
+    /**
+     * Sets the properties of a topic.
+     * @param params - The parameters to set
+     * @returns The new properties of the topic.
+     */
+    async setProperties(params) {
+        messengerLogger.debug('Properties update initiated', { topicName: params.name, update: params.update });
+        // Create the message to send to the server
+        const message = {
+            method: 'setproperties',
+            params,
+        };
+        return new Promise((resolve, reject) => {
+            let timeoutId = null;
+            // Cleanup function to remove listener and clear timeout
+            const cleanup = () => {
+                messengerLogger.trace('Cleanup: removing event listener and clearing timeout', { topicName: params.name });
+                this._socket.websocket.removeEventListener('message', wsHandler);
+                if (timeoutId) {
+                    clearTimeout(timeoutId);
+                    messengerLogger.trace('Timeout cleared', { topicName: params.name });
+                }
+                messengerLogger.debug('Cleanup performed', { topicName: params.name });
+            };
+            const resolver = (message) => {
+                messengerLogger.trace('Promise resolver called', { topicName: params.name });
+                cleanup();
+                messengerLogger.debug('Properties ack received', { topicName: params.name, ack: message.params.ack });
+                resolve(message);
+            };
+            // Rejector function to cleanup before rejecting
+            const rejector = (error) => {
+                messengerLogger.trace('Promise rejector called', { topicName: params.name, error: error.message });
+                cleanup();
+                reject(error);
+            };
+            const wsHandler = (event) => {
+                const messages = this.parseAndFilterMessage(event, 'properties');
+                messengerLogger.debug('Messages filtered for properties', { count: messages.length });
+                for (const message of messages) {
+                    if (message.params.name === params.name && message.params.ack) {
+                        messengerLogger.debug('Properties message matched', { topicName: params.name, ack: message.params.ack });
+                        resolver(message);
+                        break;
+                    }
+                }
+            };
+            this._socket.websocket.addEventListener('message', wsHandler);
+            // Send the message to the server
+            this._socket.sendTextFrame(message);
+            // Reject the promise if an ACK is not received within 3 seconds
+            this.socket
+                .waitForConnection()
+                .then(() => {
+                timeoutId = setTimeout(() => {
+                    rejector(new Error(`Properties for topic ${params.name} were not acknowledged within 3 seconds`));
+                }, 3000);
+            })
+                .catch((error) => {
+                rejector(error);
+            });
+        });
+    }
+    /**
+     * Send data to a topic.
+     * This should only be called by the PubSubClient.
+     * @param topic - The topic to update.
+     * @param value - The value to update the topic to.
+     * @returns The timestamp of the update, or -1 if the socket is not connected.
+     */
+    sendToTopic(topic, value) {
+        const typeInfo = topic.typeInfo;
+        if (!topic.publisher || topic.pubuid == null) {
+            throw new Error(`Topic ${topic.name} is not a publisher, so it cannot be updated`);
+        }
+        return this._socket.sendValueToTopic(topic.pubuid, value, typeInfo);
+    }
+    /**
+     * Gets the next available publisher UID.
+     * @returns The next available publisher UID.
+     */
+    getNextPubUID() {
+        const pubuid = this._currentPubUID++;
+        messengerLogger.debug('Next PubUID generated', { pubuid });
+        return pubuid;
+    }
+    /**
+     * Gets the next available subscriber UID.
+     * @returns The next available subscriber UID.
+     */
+    getNextSubUID() {
+        const subuid = this._currentSubUID++;
+        messengerLogger.debug('Next SubUID generated', { subuid });
+        return subuid;
+    }
+    /**
+     * Removes this messenger and its socket from their singleton maps.
+     */
+    releaseInstance() {
+        for (const [key, instance] of Messenger._instances) {
+            if (instance === this) {
+                Messenger._instances.delete(key);
+            }
+        }
+        this._socket.releaseInstance();
+    }
+}
+Messenger._instances = new Map();
+
+// When Node ESM loads CJS (protobufjs), the namespace may be { default: root }; support both shapes.
+const protobuf = protobufNs.default ?? protobufNs;
+/** Extract basename from a path string without Node's path module (works in browser and Node). */
+function basename(filePath) {
+    return filePath.replace(/^.*[/\\]/, '');
+}
+/** True when running under Node.js (filesystem APIs such as protobuf.load are available). */
+function isNodeRuntime() {
+    return typeof process !== 'undefined' && typeof process.versions?.node === 'string';
+}
+const MAX_PROTO_SOURCE_CHARS = 1000000;
+const MAX_PROTO_SCHEMA_BYTES = 1000000;
+/**
+ * Manages protobuf schema fetching and caching from NetworkTables.
+ * Schemas are automatically cached from `/.schema/proto:*` topics using a prefix subscription.
+ */
+class ProtobufSchemaManager {
+    constructor(client) {
+        this.schemaCache = new Map();
+        this.registeredSchemas = new Set();
+        this.fileDescriptorProtoType = protobuf.Root.fromJSON(descriptorJson).lookupType('google.protobuf.FileDescriptorProto');
+        this.client = client;
+        // Create a prefix topic for all schema topics
+        this.schemaPrefixTopic = new NetworkTablesPrefixTopic(client, '/.schema/proto:');
+        // Subscribe to all schema topics and automatically decode and cache them
+        this.schemaPrefixTopic.subscribe((value, params) => {
+            this.handleSchemaUpdate(value, params);
+        });
+    }
+    /**
+     * Handles schema updates from the prefix topic subscription.
+     * Automatically decodes and caches all schema files that arrive.
+     * @param value - The value of the schema update (null when a topic is unannounced).
+     * @param params - The parameters of the announce message.
+     */
+    handleSchemaUpdate(value, params) {
+        if (value == null)
+            return;
+        if (!ArrayBuffer.isView(value))
+            return;
+        if (value.byteLength > MAX_PROTO_SCHEMA_BYTES) {
+            pubsubLogger.debug('Rejected oversized protobuf schema', { name: params.name, byteLength: value.byteLength });
+            return;
+        }
+        const protoFileName = params.name.substring('/.schema/proto:'.length);
+        if (!protoFileName)
+            return;
+        try {
+            const decoded = this.fileDescriptorProtoType.decode(value);
+            const fd = this.fileDescriptorProtoType.toObject(decoded, {
+                enums: Number,
+                longs: String,
+                bytes: String,
+            });
+            const descriptorSet = { file: [fd] };
+            const schemaRoot = protobuf.Root.fromDescriptor(descriptorSet).resolveAll();
+            this.schemaCache.set(protoFileName, schemaRoot);
+            this.schemaCache.set(params.name, schemaRoot);
+        }
+        catch (error) {
+            pubsubLogger.debug('Failed to decode protobuf schema', { name: params.name, error });
+        }
+    }
+    /**
+     * Fetches a protobuf message type from the cache.
+     * Searches all loaded schemas in the cache to find one containing the requested message type.
+     * Returns null if the schema is not yet in cache (e.g. topic announced before schema topic arrived).
+     * @param messageName - The name of the protobuf message type (e.g., "frc.Pose2d").
+     * @returns The protobufjs Type, or null if not found in cache.
+     */
+    fetchMessageType(messageName) {
+        // Search all cached schemas for the requested message type
+        for (const schema of this.schemaCache.values()) {
+            try {
+                return schema.lookupType(messageName);
+            }
+            catch {
+                // lookupType throws if type not found, continue searching
+                continue;
+            }
+        }
+        return null;
+    }
+    /**
+     * Clears the schema cache.
+     */
+    clearCache() {
+        this.schemaCache.clear();
+    }
+    /**
+     * Gets the message name from a protobuf root.
+     * Auto-detects the first message type in the proto file.
+     * @param root - The protobuf root containing the schema.
+     * @returns The message name in format "package.MessageName" or "MessageName" if no package (no leading dot).
+     */
+    getMessageNameFromProto(root) {
+        // Get all nested types (messages) from the root
+        const nested = root.nested;
+        if (!nested) {
+            throw new Error('Proto file has no messages');
+        }
+        // protobufjs fullName includes a leading dot (e.g. ".networktables.TestData");
+        // NetworkTables type strings must be "proto:package.MessageName" with no leading dot.
+        const normalize = (name) => (name.startsWith('.') ? name.slice(1) : name);
+        // Find the first message type
+        for (const nestedObj of Object.values(nested)) {
+            if (nestedObj instanceof protobuf.Type) {
+                return normalize(nestedObj.fullName);
+            }
+            // If it's a namespace (package), recurse into it
+            if (nestedObj instanceof protobuf.Namespace) {
+                const message = this.findFirstMessage(nestedObj);
+                if (message) {
+                    return normalize(message.fullName);
+                }
+            }
+        }
+        throw new Error('No message type found in proto file');
+    }
+    /**
+     * Recursively finds the first message type in a namespace.
+     * @param namespace - The namespace to search.
+     * @returns The first message type found, or null.
+     */
+    findFirstMessage(namespace) {
+        for (const nestedObj of Object.values(namespace.nested || {})) {
+            if (nestedObj instanceof protobuf.Type) {
+                return nestedObj;
+            }
+            if (nestedObj instanceof protobuf.Namespace) {
+                const message = this.findFirstMessage(nestedObj);
+                if (message) {
+                    return message;
+                }
+            }
+        }
+        return null;
+    }
+    /**
+     * Registers a protobuf schema by loading a proto file and publishing it to NetworkTables.
+     * Node.js only — uses the filesystem. In the browser, use {@link registerSchemaFromSource} or
+     * {@link registerSchemaFromType} instead.
+     * @param protoFilePath - Path to the .proto file.
+     * @param messageName - Optional message name to use. If not provided, auto-detected from proto file.
+     * @returns A promise that resolves to the message name and schema root.
+     * @throws {Error} If called in a browser, or if the proto file cannot be loaded or schema cannot be registered.
+     */
+    async registerSchema(protoFilePath, messageName) {
+        if (!isNodeRuntime()) {
+            throw new Error(`protoFilePath ("${protoFilePath}") requires Node.js filesystem access. Use protoSource or messageType instead for browser environments.`);
+        }
+        const filename = basename(protoFilePath);
+        return this.registerRootFromLoader(filename, messageName, async () => {
+            try {
+                return await protobuf.load(protoFilePath);
+            }
+            catch (error) {
+                throw new Error(`Failed to load proto file "${protoFilePath}"`, { cause: error });
+            }
+        }, protoFilePath);
+    }
+    /**
+     * Parses a `.proto` source string without publishing (no filesystem).
+     * @param protoSource - The contents of a .proto file.
+     * @returns The detected message name and resolved root.
+     */
+    parseSource(protoSource) {
+        if (protoSource.length > MAX_PROTO_SOURCE_CHARS) {
+            throw new Error(`protoSource exceeds ${MAX_PROTO_SOURCE_CHARS} characters`);
+        }
+        try {
+            const parsed = protobuf.parse(protoSource);
+            const root = parsed.root.resolveAll();
+            const messageName = this.getMessageNameFromProto(root);
+            return { messageName, root };
+        }
+        catch (error) {
+            throw new Error('Failed to parse proto source', { cause: error });
+        }
+    }
+    async registerSchemaFromSource(protoSource, filename, messageName) {
+        const parsed = this.parseSource(protoSource);
+        const detectedMessageName = messageName || parsed.messageName;
+        const schemaFilename = filename ?? `${detectedMessageName}.proto`;
+        return this.publishRoot(parsed.root, schemaFilename, detectedMessageName);
+    }
+    /**
+     * Registers a protobuf schema from a prebuilt protobufjs Type (no filesystem). Safe in the browser.
+     * @param messageType - A protobufjs Type used for encode/decode.
+     * @param filename - Optional filename used for the schema topic (defaults to the message name).
+     * @returns A promise that resolves to the message name and schema root.
+     */
+    async registerSchemaFromType(messageType, filename) {
+        const normalize = (name) => (name.startsWith('.') ? name.slice(1) : name);
+        const detectedMessageName = normalize(messageType.fullName);
+        const schemaFilename = filename ?? `${detectedMessageName}.proto`;
+        return this.publishRoot(messageType.root, schemaFilename, detectedMessageName);
+    }
+    /**
+     * Loads a root then publishes it, sharing in-flight protection by schema topic name.
+     */
+    async registerRootFromLoader(filename, messageName, loadRoot, sourceLabel) {
+        const schemaTopicName = `/.schema/proto:${filename}`;
+        if (this.registeredSchemas.has(schemaTopicName)) {
+            const cachedRoot = this.schemaCache.get(schemaTopicName);
+            if (cachedRoot) {
+                const detectedMessageName = messageName || this.getMessageNameFromProto(cachedRoot);
+                return { messageName: detectedMessageName, root: cachedRoot };
+            }
+        }
+        const operationKey = `schema:${schemaTopicName}`;
+        return this.client.getOrCreateInFlightOperation(operationKey, async () => {
+            const root = await loadRoot();
+            return this.publishLoadedRoot(root, filename, messageName, sourceLabel);
+        });
+    }
+    /**
+     * Publishes an already-parsed root, sharing in-flight protection by schema topic name.
+     */
+    async publishRoot(root, filename, messageName) {
+        const schemaTopicName = `/.schema/proto:${filename}`;
+        if (this.registeredSchemas.has(schemaTopicName)) {
+            const cachedRoot = this.schemaCache.get(schemaTopicName);
+            if (cachedRoot) {
+                const detectedMessageName = messageName || this.getMessageNameFromProto(cachedRoot);
+                return { messageName: detectedMessageName, root: cachedRoot };
+            }
+        }
+        const operationKey = `schema:${schemaTopicName}`;
+        return this.client.getOrCreateInFlightOperation(operationKey, async () => {
+            return this.publishLoadedRoot(root, filename, messageName, filename);
+        });
+    }
+    /**
+     * Encodes a FileDescriptorProto from a root, publishes the schema topic, and caches it.
+     * Must be called inside an in-flight operation.
+     */
+    async publishLoadedRoot(root, filename, messageName, sourceLabel) {
+        const schemaTopicName = `/.schema/proto:${filename}`;
+        let encoded;
+        try {
+            const descriptor = root.toDescriptor('proto3');
+            if (!descriptor?.file?.length) {
+                throw new Error('No file descriptor found in proto');
+            }
+            const fileDescriptorProto = descriptor.file[0];
+            encoded = this.fileDescriptorProtoType.encode(fileDescriptorProto).finish();
+        }
+        catch (error) {
+            throw new Error(`Failed to extract/encode FileDescriptorProto from "${sourceLabel}"`, { cause: error });
+        }
+        const detectedMessageName = messageName || this.getMessageNameFromProto(root);
+        let schemaTopic = this.client.getTopicFromName(schemaTopicName);
+        if (!schemaTopic) {
+            schemaTopic = new NetworkTablesTopic(this.client, schemaTopicName, NetworkTablesTypeInfos.kUint8Array);
+        }
+        const pubuid = this.client.messenger.getNextPubUID();
+        schemaTopic['_pubuid'] = pubuid;
+        await this.client.messenger.publish({
+            name: schemaTopicName,
+            pubuid,
+            type: 'proto:FileDescriptorProto',
+            properties: { retained: true },
+        });
+        this.client.updateServer(schemaTopic, encoded);
+        this.schemaCache.set(schemaTopicName, root);
+        this.schemaCache.set(filename, root);
+        this.registeredSchemas.add(schemaTopicName);
+        return { messageName: detectedMessageName, root };
+    }
+}
+
+const STRUCT_SCHEMA_PREFIX = '/.schema/struct:';
+/**
+ * Manages struct schema fetching and caching from NetworkTables.
+ * Subscribes to `/.schema/struct:*` and parses/caches descriptors by type name.
+ */
+class StructSchemaManager {
+    constructor(client) {
+        this.parsedFieldsCache = new Map();
+        this.descriptorCache = new Map();
+        this.schemaStringCache = new Map();
+        this.pendingTypeNames = new Set();
+        /** Type names for which we have already published a schema topic (avoids redundant republish). */
+        this.publishedSchemaTypes = new Set();
+        this.client = client;
+        // Create a prefix topic for all struct schema topics
+        this.schemaPrefixTopic = new NetworkTablesPrefixTopic(client, STRUCT_SCHEMA_PREFIX);
+        // Subscribe to all schema topics and automatically decode and cache them
+        this.schemaPrefixTopic.subscribe((value, params) => {
+            this.handleSchemaUpdate(value, params);
+        });
+    }
+    /**
+     * Handles schema updates from the prefix topic subscription.
+     * Decodes UTF-8 bytes to string, parses schema, and caches descriptor when dependencies are ready.
+     * @param value - The value of the schema update (null when a topic is unannounced).
+     * @param params - The parameters of the announce message.
+     */
+    handleSchemaUpdate(value, params) {
+        if (value == null)
+            return;
+        if (!ArrayBuffer.isView(value))
+            return;
+        const typeName = params.name.substring(STRUCT_SCHEMA_PREFIX.length);
+        if (!typeName)
+            return;
+        const schemaString = new TextDecoder().decode(value);
+        this.schemaStringCache.set(typeName, schemaString);
+        let parsed;
+        try {
+            parsed = parseSchema(schemaString);
+        }
+        catch (err) {
+            pubsubLogger.debug('Failed to parse struct schema', { typeName, error: err });
+            return;
+        }
+        this.parsedFieldsCache.set(typeName, parsed);
+        this.pendingTypeNames.add(typeName);
+        this.tryBuildPending();
+    }
+    getNested(name) {
+        return this.descriptorCache.get(name) ?? getBuiltInDescriptor(name) ?? null;
+    }
+    tryBuildPending() {
+        while (this.pendingTypeNames.size > 0) {
+            let builtAny = false;
+            for (const typeName of this.pendingTypeNames) {
+                const fields = this.parsedFieldsCache.get(typeName);
+                if (!fields || this.descriptorCache.has(typeName))
+                    continue;
+                try {
+                    const descriptor = buildStructDescriptor(typeName, fields, (n) => this.getNested(n));
+                    this.descriptorCache.set(typeName, descriptor);
+                    this.descriptorCache.set(`struct:${typeName}`, descriptor);
+                    this.pendingTypeNames.delete(typeName);
+                    builtAny = true;
+                }
+                catch (err) {
+                    pubsubLogger.debug('Deferred struct descriptor build', { typeName, error: err });
+                }
+            }
+            if (!builtAny)
+                break;
+        }
+    }
+    /**
+     * Returns the struct descriptor for the given type name or type string (e.g. "Pose2d" or "struct:Pose2d").
+     * Returns null if not in cache and not a built-in (built-ins are resolved on first use).
+     */
+    fetchDescriptor(typeNameOrTypeString) {
+        const typeName = typeNameOrTypeString.startsWith('struct:') ? typeNameOrTypeString.slice(7) : typeNameOrTypeString;
+        const cached = this.descriptorCache.get(typeName) ?? this.descriptorCache.get(`struct:${typeName}`);
+        if (cached)
+            return cached;
+        const builtIn = getBuiltInDescriptor(typeName);
+        if (builtIn)
+            return builtIn;
+        return null;
+    }
+    hasSchema(typeString) {
+        return this.fetchDescriptor(typeString) != null;
+    }
+    clearCache() {
+        this.parsedFieldsCache.clear();
+        this.descriptorCache.clear();
+        this.schemaStringCache.clear();
+        this.pendingTypeNames.clear();
+        this.publishedSchemaTypes.clear();
+    }
+    /**
+     * Publishes nested struct schemas to NetworkTables (nested first), then the given descriptor's schema.
+     * Used when publishing a struct topic so subscribers can decode.
+     */
+    async addSchema(descriptor) {
+        const typeName = descriptor.typeName;
+        const schemaTopicName = `${STRUCT_SCHEMA_PREFIX}${typeName}`;
+        // Use unified in-flight protection from PubSubClient
+        // Key format: "schema:" prefix to avoid conflicts with topic publishes
+        const operationKey = `schema:${schemaTopicName}`;
+        await this.client.getOrCreateInFlightOperation(operationKey, async () => {
+            const nested = this.collectNestedTypeNames(descriptor);
+            for (const name of nested) {
+                await this.publishSchemaTopic(name);
+            }
+            await this.publishSchemaTopic(typeName);
+        });
+    }
+    collectNestedTypeNames(desc) {
+        const seen = new Set();
+        const out = [];
+        const visit = (d) => {
+            for (const f of d.fields) {
+                if (f.nestedDescriptor && !seen.has(f.nestedDescriptor.typeName)) {
+                    seen.add(f.nestedDescriptor.typeName);
+                    visit(f.nestedDescriptor);
+                    out.push(f.nestedDescriptor.typeName);
+                }
+            }
+        };
+        visit(desc);
+        return out;
+    }
+    async publishSchemaTopic(typeName) {
+        if (this.publishedSchemaTypes.has(typeName))
+            return;
+        const schemaTopicName = `${STRUCT_SCHEMA_PREFIX}${typeName}`;
+        const schemaString = this.schemaStringCache.get(typeName) ?? getBuiltInSchemaString(typeName);
+        if (!schemaString)
+            return;
+        const encodedSchema = new TextEncoder().encode(schemaString);
+        let topic = this.client.getTopicFromName(schemaTopicName);
+        if (!topic) {
+            topic = new NetworkTablesTopic(this.client, schemaTopicName, NetworkTablesTypeInfos.kStructSchema);
+        }
+        if (topic.typeInfo[1] === 'structschema') {
+            await topic.publish({ retained: true });
+            topic.setValue(encodedSchema);
+        }
+        else {
+            // Existing topic created with older code (e.g. type 'raw'); publish with custom type via messenger
+            const pubuid = this.client.messenger.getNextPubUID();
+            topic['_pubuid'] = pubuid;
+            await this.client.messenger.publish({
+                name: schemaTopicName,
+                pubuid,
+                type: 'structschema',
+                properties: { retained: true },
+            });
+            this.client.updateServer(topic, encodedSchema);
+        }
+        this.publishedSchemaTypes.add(typeName);
+    }
+}
+
+/** The client for the PubSub protocol. */
+class PubSubClient {
+    get messenger() {
+        return this._messenger;
+    }
+    get protobufSchemaManager() {
+        return this._protobufSchemaManager;
+    }
+    get structSchemaManager() {
+        return this._structSchemaManager;
+    }
+    constructor(serverUrl) {
+        // Unified in-flight operations tracking (schema registrations and topic publishes)
+        this.inFlightOperations = new Map();
+        this._isCleaningUp = false;
+        this.beforeUnloadHandler = () => {
+            this.cleanup();
+        };
+        /**
+         * Called by the messenger when a topic is updated.
+         * @param message - The message data.
+         */
+        this.onTopicUpdate = (message) => {
+            pubsubLogger.debug('Value update received', {
+                topicId: message.topicId,
+                typeNum: message.typeNum,
+                serverTime: message.serverTime,
+            });
+            const topic = this.getTopicFromId(message.topicId);
+            if (topic) {
+                pubsubLogger.trace('Raw value received', {
+                    topicId: message.topicId,
+                    value: message.value,
+                    typeNum: message.typeNum,
+                });
+                try {
+                    const validatedData = NetworkTablesTypeInfos.validateData(topic.typeInfo, message.value);
+                    pubsubLogger.debug('Value validated successfully', { topicName: topic.name, topicId: message.topicId });
+                    pubsubLogger.trace('Type validation details', {
+                        topicName: topic.name,
+                        expectedType: topic.typeInfo[1],
+                        receivedTypeNum: message.typeNum,
+                        validated: true,
+                    });
+                    pubsubLogger.debug('Value update applied to topic', { topicName: topic.name, topicId: message.topicId });
+                    topic.updateValue(validatedData, message.serverTime);
+                }
+                catch (e) {
+                    pubsubLogger.trace('Type validation failed', {
+                        topicName: topic.name,
+                        expectedType: topic.typeInfo[1],
+                        receivedTypeNum: message.typeNum,
+                        error: String(e),
+                    });
+                    pubsubLogger.warn('Skipping invalid value update for topic', {
+                        topicName: topic.name,
+                        topicId: message.topicId,
+                        error: String(e),
+                    });
+                    // Do not throw: allow remaining messages in the same binary frame to be processed
+                }
+            }
+            const knownTopic = this.getKnownTopicParams(message.topicId);
+            if (knownTopic) {
+                // Use topic's value when we have one so protobuf topics pass decoded value to prefix subscribers
+                const valueForPrefix = topic != null ? (topic.getValue() ?? message.value) : message.value;
+                let matchedPrefixCount = 0;
+                this.prefixTopics.forEach((prefixTopic) => {
+                    if (knownTopic.name.startsWith(prefixTopic.name)) {
+                        matchedPrefixCount++;
+                        pubsubLogger.debug('Prefix topic matched', { topicName: knownTopic.name, prefix: prefixTopic.name });
+                        prefixTopic.updateValue(knownTopic, valueForPrefix, message.serverTime);
+                    }
+                });
+                if (matchedPrefixCount > 0) {
+                    pubsubLogger.debug('Value update applied to prefix topics', {
+                        topicName: knownTopic.name,
+                        count: matchedPrefixCount,
+                    });
+                }
+            }
+            if (!topic && !knownTopic) {
+                // Buffer value update until announcement arrives (handles server sending value before announce).
+                this.pendingValueUpdates.set(message.topicId, message);
+                pubsubLogger.debug('Buffered value update for unknown topic', { topicId: message.topicId });
+            }
+        };
+        /**
+         * Called by the messenger when a topic is announced.
+         * @param params - The announce message parameters.
+         */
+        this.onTopicAnnounce = (params) => {
+            pubsubLogger.trace('Map operation: knownTopicParams.set', {
+                topicId: params.id,
+                topicName: params.name,
+                mapSizeBefore: this.knownTopicParams.size,
+            });
+            this.knownTopicParams.set(params.id, params);
+            pubsubLogger.trace('Map operation: knownTopicParams.set complete', { mapSizeAfter: this.knownTopicParams.size });
+            pubsubLogger.debug('Topic announced', { topicName: params.name, topicId: params.id, type: params.type });
+            // Announce to the topic
+            const topic = this.topics.get(params.name);
+            topic?.announce(params);
+            // Find all prefix topics that match the announced topic
+            let matchedPrefixCount = 0;
+            this.prefixTopics.forEach((prefixTopic) => {
+                if (params.name.startsWith(prefixTopic.name)) {
+                    matchedPrefixCount++;
+                    pubsubLogger.debug('Prefix topic matched', { topicName: params.name, prefix: prefixTopic.name });
+                    prefixTopic.announce(params);
+                }
+            });
+            if (this.prefixTopics.size > 0) {
+                pubsubLogger.debug('Prefix topics checked', {
+                    totalPrefixTopics: this.prefixTopics.size,
+                    matchedCount: matchedPrefixCount,
+                });
+            }
+            // Flush any value update that arrived before this announcement
+            const pendingMessage = this.pendingValueUpdates.get(params.id);
+            if (pendingMessage) {
+                this.pendingValueUpdates.delete(params.id);
+                this._deliverValueUpdate(params, pendingMessage);
+            }
+        };
+        /**
+         * Called by the messenger when a topic is unannounced.
+         * @param params - The unannounce message parameters.
+         */
+        this.onTopicUnannounce = (params) => {
+            const topic = this.topics.get(params.name);
+            this.pendingValueUpdates.delete(params.id);
+            if (!topic) {
+                pubsubLogger.debug('Topic was unannounced but does not exist', { topicName: params.name });
+                // Still clean up knownTopicParams even if topic doesn't exist locally
+                pubsubLogger.trace('Map operation: knownTopicParams.delete', {
+                    topicId: params.id,
+                    mapSizeBefore: this.knownTopicParams.size,
+                });
+                this.knownTopicParams.delete(params.id);
+                pubsubLogger.trace('Map operation: knownTopicParams.delete complete', {
+                    mapSizeAfter: this.knownTopicParams.size,
+                });
+                return;
+            }
+            pubsubLogger.debug('Topic unannounced', { topicName: params.name, topicId: topic.id });
+            topic.unannounce();
+            // Clean up knownTopicParams when topic is unannounced
+            pubsubLogger.trace('Map operation: knownTopicParams.delete', {
+                topicId: params.id,
+                mapSizeBefore: this.knownTopicParams.size,
+            });
+            this.knownTopicParams.delete(params.id);
+            pubsubLogger.trace('Map operation: knownTopicParams.delete complete', { mapSizeAfter: this.knownTopicParams.size });
+        };
+        /**
+         * Called by the messenger when a topic's properties are updated.
+         * @param params - The properties message parameters.
+         */
+        this.onTopicProperties = (params) => {
+            const topic = this.topics.get(params.name);
+            if (params.ack) {
+                if (!topic) {
+                    pubsubLogger.debug('Topic properties updated but does not exist', { topicName: params.name });
+                    return;
+                }
+                pubsubLogger.debug('Topic properties updated', { topicName: params.name, ack: params.ack });
+            }
+        };
+        this._messenger = Messenger.getInstance(serverUrl, this.onTopicUpdate, this.onTopicAnnounce, this.onTopicUnannounce, this.onTopicProperties);
+        this.topics = new Map();
+        this.prefixTopics = new Map();
+        this.knownTopicParams = new Map();
+        this.pendingValueUpdates = new Map();
+        this._protobufSchemaManager = new ProtobufSchemaManager(this);
+        this._structSchemaManager = new StructSchemaManager(this);
+        // When the connection drops, local server-side announcement state is no longer reliable.
+        // Clear known ids so outgoing updates can be safely queued until re-announced.
+        this._messenger.socket.addConnectionListener((isConnected) => {
+            if (isConnected) {
+                // Flush any latest-only queued outgoing values after reconnect.
+                // This is scheduled as a microtask so it happens after the socket's onopen handler
+                // has run (which re-sends publish frames). This ensures publish frames precede
+                // any value frames on the wire.
+                queueMicrotask(() => {
+                    this.topics.forEach((topic) => {
+                        try {
+                            topic.resendLatestValue();
+                        }
+                        catch (error) {
+                            pubsubLogger.warn('Failed to flush queued outgoing value after reconnect', {
+                                topicName: topic.name,
+                                error,
+                            });
+                        }
+                    });
+                });
+                return;
+            }
+            pubsubLogger.debug('Socket disconnected; clearing announcement state', {
+                topicCount: this.topics.size,
+                prefixTopicCount: this.prefixTopics.size,
+                knownTopicParams: this.knownTopicParams.size,
+            });
+            this.knownTopicParams.clear();
+            this.pendingValueUpdates.clear();
+            // Ensure disconnect cleanup never throws.
+            this.topics.forEach((topic) => {
+                try {
+                    topic.unannounce();
+                }
+                catch (error) {
+                    pubsubLogger.warn('Failed to unannounce topic during disconnect cleanup', { topicName: topic.name, error });
+                }
+            });
+            this.prefixTopics.forEach((prefixTopic) => {
+                try {
+                    prefixTopic.unannounce();
+                }
+                catch (error) {
+                    pubsubLogger.warn('Failed to unannounce prefix topic during disconnect cleanup', {
+                        prefix: prefixTopic.name,
+                        error,
+                    });
+                }
+            });
+        });
+        // In the DOM, auto-cleanup without overwriting an existing beforeunload handler
+        if (typeof window !== 'undefined') {
+            window.addEventListener('beforeunload', this.beforeUnloadHandler);
+        }
+    }
+    /**
+     * Gets the instance of the NetworkTables client.
+     * @param serverUrl - The URL of the server to connect to. This is not used after the first call.
+     * @returns The instance of the NetworkTables client.
+     */
+    static getInstance(serverUrl) {
+        let instance = this._instances.get(serverUrl);
+        if (!instance) {
+            instance = new PubSubClient(serverUrl);
+            this._instances.set(serverUrl, instance);
+        }
+        return instance;
+    }
+    /**
+     * Reinstantiates the client by resubscribing to all previously subscribed topics
+     * and republishing for all previously published topics.
+     * @param url - The URL of the server to connect to.
+     */
+    reinstantiate(url) {
+        pubsubLogger.info('Client reinstantiated', {
+            newUrl: url,
+            topicCount: this.topics.size,
+            prefixTopicCount: this.prefixTopics.size,
+        });
+        this._messenger.reinstantiate(url);
+        // Clear announcement state so ids are reacquired from the new connection.
+        this.knownTopicParams.clear();
+        this.pendingValueUpdates.clear();
+        // Ensure reinstantiation cleanup never throws (tests may register lightweight mocks).
+        this.topics.forEach((topic) => {
+            try {
+                topic.unannounce();
+            }
+            catch (error) {
+                pubsubLogger.warn('Failed to unannounce topic during reinstantiate', { topicName: topic.name, error });
+            }
+        });
+        this.prefixTopics.forEach((prefixTopic) => {
+            try {
+                prefixTopic.unannounce();
+            }
+            catch (error) {
+                pubsubLogger.warn('Failed to unannounce prefix topic during reinstantiate', {
+                    prefix: prefixTopic.name,
+                    error,
+                });
+            }
+        });
+        // Re-subscribe and re-publish local state for the new connection.
+        this.topics.forEach((topic) => {
+            topic.resubscribeAll(this);
+            if (topic.publisher) {
+                // Fire-and-forget but always handle rejections to avoid unhandled promises.
+                void Promise.resolve(topic.republish(this)).catch((error) => {
+                    pubsubLogger.warn('Topic republish failed during reinstantiate', { topicName: topic.name, error });
+                });
+            }
+        });
+        this.prefixTopics.forEach((prefixTopic) => {
+            prefixTopic.resubscribeAll(this);
+        });
+    }
+    /**
+     * Registers a topic with this PubSubClient.
+     * @param topic - The topic to register
+     */
+    registerTopic(topic) {
+        if (topic.isRegular()) {
+            if (this.topics.has(topic.name)) {
+                pubsubLogger.debug('Topic already exists check', { topicName: topic.name, exists: true });
+                throw new Error(`Topic ${topic.name} already exists. Cannot register a topic with the same name.`);
+            }
+            pubsubLogger.debug('Topic already exists check', { topicName: topic.name, exists: false });
+            this.topics.set(topic.name, topic);
+            pubsubLogger.debug('Topic registered', { topicName: topic.name, type: 'regular' });
+        }
+        else if (topic.isPrefix()) {
+            if (this.prefixTopics.has(topic.name)) {
+                pubsubLogger.debug('Prefix topic already exists check', { prefix: topic.name, exists: true });
+                throw new Error(`Prefix topic ${topic.name} already exists. Cannot register a topic with the same name.`);
+            }
+            pubsubLogger.debug('Prefix topic already exists check', { prefix: topic.name, exists: false });
+            this.prefixTopics.set(topic.name, topic);
+            pubsubLogger.debug('Prefix topic registered', { prefix: topic.name });
+        }
+    }
+    /**
+     * Delivers a value update to the regular topic (if any) and all matching prefix topics.
+     */
+    _deliverValueUpdate(knownTopic, message) {
+        const topic = this.topics.get(knownTopic.name);
+        if (topic) {
+            try {
+                const validatedData = NetworkTablesTypeInfos.validateData(topic.typeInfo, message.value);
+                topic.updateValue(validatedData, message.serverTime);
+                pubsubLogger.debug('Buffered value applied to topic', { topicName: knownTopic.name, topicId: message.topicId });
+            }
+            catch (e) {
+                pubsubLogger.trace('Buffered value validation failed for topic', {
+                    topicName: knownTopic.name,
+                    error: String(e),
+                });
+            }
+        }
+        const valueForPrefix = (topic != null ? (topic.getValue() ?? message.value) : message.value);
+        let matchedPrefixCount = 0;
+        this.prefixTopics.forEach((prefixTopic) => {
+            if (knownTopic.name.startsWith(prefixTopic.name)) {
+                matchedPrefixCount++;
+                prefixTopic.updateValue(knownTopic, valueForPrefix, message.serverTime);
+            }
+        });
+        if (matchedPrefixCount > 0) {
+            pubsubLogger.debug('Buffered value applied to prefix topics', {
+                topicName: knownTopic.name,
+                count: matchedPrefixCount,
+            });
+        }
+    }
+    /**
+     * Updates the value of a topic on the server.
+     * @param topic - The topic to update.
+     * @param value - The new value (wire format) to send.
+     */
+    updateServer(topic, value) {
+        this._messenger.sendToTopic(topic, value);
+    }
+    /**
+     * Notifies all prefix topics that match the given topic name of a local value update.
+     * Called when a regular/protobuf topic's setValue() runs so prefix subscribers (e.g. "all topics" table) see locally published values.
+     */
+    notifyPrefixTopicsForLocalUpdate(params, value) {
+        let matchedPrefixCount = 0;
+        this.prefixTopics.forEach((prefixTopic) => {
+            if (params.name.startsWith(prefixTopic.name)) {
+                matchedPrefixCount++;
+                pubsubLogger.debug('Prefix topic notified (local update)', {
+                    topicName: params.name,
+                    prefix: prefixTopic.name,
+                });
+                prefixTopic.updateValue(params, value, 0);
+            }
+        });
+        if (matchedPrefixCount > 0) {
+            pubsubLogger.debug('Local value applied to prefix topics', { topicName: params.name, count: matchedPrefixCount });
+        }
+    }
+    /**
+     * Gets the topic with the given ID.
+     * @param topicId - The ID of the topic to get.
+     * @returns The topic with the given ID, or null if no topic with that ID exists.
+     */
+    getTopicFromId(topicId) {
+        for (const topic of this.topics.values()) {
+            if (topic.id === topicId) {
+                pubsubLogger.debug('Topic found by ID', { topicId, topicName: topic.name });
+                return topic;
+            }
+        }
+        pubsubLogger.debug('Topic not found by ID', { topicId });
+        return null;
+    }
+    /**
+     * Gets the topic with the given name.
+     * @param topicName - The name of the topic to get.
+     * @returns The topic with the given name, or null if no topic with that name exists.
+     */
+    getTopicFromName(topicName) {
+        const topic = this.topics.get(topicName);
+        if (topic) {
+            pubsubLogger.debug('Topic found by name', { topicName });
+            return topic;
+        }
+        pubsubLogger.debug('Topic not found by name', { topicName });
+        return null;
+    }
+    /**
+     * Gets the topic with the given name.
+     * @param topicName - The name of the topic to get.
+     * @returns The topic with the given name, or null if no topic with that name exists.
+     */
+    getPrefixTopicFromName(topicName) {
+        return this.prefixTopics.get(topicName) ?? null;
+    }
+    /**
+     * Gets the known announcement parameters for a topic.
+     * @param id - The ID of the topic.
+     * @returns The known announcement parameters for the topic, or undefined if the topic is not known.
+     */
+    getKnownTopicParams(id) {
+        const params = this.knownTopicParams.get(id);
+        if (params) {
+            pubsubLogger.debug('Known topic params retrieved', { topicId: id, topicName: params.name });
+        }
+        else {
+            pubsubLogger.debug('Known topic params not found', { topicId: id });
+        }
+        return params;
+    }
+    /**
+     * Gets or creates an in-flight operation to prevent race conditions.
+     * If an operation with the same key is already in progress, returns the existing promise.
+     * Otherwise, creates a new operation and stores it.
+     * @param key - Unique key for the operation (e.g., "schema:/.schema/proto:filename" or "publish:/topic/name")
+     * @param operation - The async operation to execute
+     * @returns A promise that resolves to the operation result
+     * @throws Error if the client is cleaning up and no existing operation is found
+     */
+    getOrCreateInFlightOperation(key, operation) {
+        const existing = this.inFlightOperations.get(key);
+        if (existing) {
+            return existing;
+        }
+        // Prevent new operations from starting during cleanup
+        if (this._isCleaningUp) {
+            return Promise.reject(new Error('Cannot start new operation: client is cleaning up'));
+        }
+        const promise = (async () => {
+            try {
+                return await operation();
+            }
+            finally {
+                // Always cleanup, regardless of success or failure
+                // This allows retries if the operation failed
+                // Safe to delete even if map was cleared during cleanup (delete is a no-op on non-existent key)
+                this.inFlightOperations.delete(key);
+            }
+        })();
+        // Store the promise IMMEDIATELY so concurrent calls wait for the same operation
+        // This must happen synchronously before any await in the promise
+        this.inFlightOperations.set(key, promise);
+        return promise;
+    }
+    /**
+     * Cleans up the client by unsubscribing from all topics and stopping publishing for all topics.
+     * Prevents new in-flight operations from starting, but allows existing ones to complete naturally.
+     * The socket is closed immediately, which will cause any in-flight operations to fail.
+     */
+    cleanup() {
+        pubsubLogger.debug('Topic cleanup initiated', {
+            topicCount: this.topics.size,
+            prefixTopicCount: this.prefixTopics.size,
+            inFlightOperations: this.inFlightOperations.size,
+        });
+        // Prevent new operations from starting
+        this._isCleaningUp = true;
+        this.topics.forEach((topic) => {
+            topic.unsubscribeAll();
+            if (topic.pubuid != null) {
+                try {
+                    topic.unpublish();
+                }
+                catch {
+                    /* not publisher / already unpublished */
+                }
+            }
+        });
+        this.prefixTopics.forEach((prefixTopic) => {
+            prefixTopic.unsubscribeAll();
+        });
+        this._messenger.socket.close();
+        if (typeof window !== 'undefined') {
+            window.removeEventListener('beforeunload', this.beforeUnloadHandler);
+        }
+        // Clear the in-flight operations map
+        // Existing operations will complete/fail naturally when the socket closes
+        // Their finally blocks will try to delete from the map, but that's safe (no-op if already cleared)
+        this.inFlightOperations.clear();
+    }
+    /**
+     * Removes this client, its messenger, and its socket from their singleton maps.
+     * Call after {@link cleanup} so a later getInstance creates a fresh client.
+     */
+    releaseInstance() {
+        for (const [key, instance] of PubSubClient._instances) {
+            if (instance === this) {
+                PubSubClient._instances.delete(key);
+            }
+        }
+        this._messenger.releaseInstance();
+    }
+}
+PubSubClient._instances = new Map();
+
+function isZodType(value) {
+    return typeof value === 'object' && value !== null && typeof value.parse === 'function';
+}
+/**
+ * Returns true when the argument is a WPILib-style struct type descriptor (e.g. `Pose2d`).
+ * @param value - The value to check.
+ * @returns Whether the value is a struct type descriptor.
+ */
+function isStructTypeDescriptor(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        typeof value.typeName === 'string' &&
+        isZodType(value.schema));
+}
+/** Zod schema for {@link Translation2d}. */
+const Translation2dSchema = z.object({
+    x: z.number(),
+    y: z.number(),
+});
+/** WPILib-style `Translation2d.struct` descriptor. */
+const Translation2d = {
+    typeName: 'Translation2d',
+    schema: Translation2dSchema,
+};
+/** Zod schema for {@link Rotation2d}. */
+const Rotation2dSchema = z.object({
+    value: z.number(),
+});
+/** WPILib-style `Rotation2d.struct` descriptor. */
+const Rotation2d = {
+    typeName: 'Rotation2d',
+    schema: Rotation2dSchema,
+};
+/** Zod schema for {@link Pose2d}. */
+const Pose2dSchema = z.object({
+    translation: Translation2dSchema,
+    rotation: Rotation2dSchema,
+});
+/** WPILib-style `Pose2d.struct` descriptor. */
+const Pose2d = {
+    typeName: 'Pose2d',
+    schema: Pose2dSchema,
+};
+/** Zod schema for {@link Transform2d}. */
+const Transform2dSchema = z.object({
+    translation: Translation2dSchema,
+    rotation: Rotation2dSchema,
+});
+/** WPILib-style `Transform2d.struct` descriptor. */
+const Transform2d = {
+    typeName: 'Transform2d',
+    schema: Transform2dSchema,
+};
+/** Zod schema for {@link Twist2d}. */
+const Twist2dSchema = z.object({
+    dx: z.number(),
+    dy: z.number(),
+    dtheta: z.number(),
+});
+/** WPILib-style `Twist2d.struct` descriptor. */
+const Twist2d = {
+    typeName: 'Twist2d',
+    schema: Twist2dSchema,
+};
+/** Zod schema for {@link Translation3d}. */
+const Translation3dSchema = z.object({
+    x: z.number(),
+    y: z.number(),
+    z: z.number(),
+});
+/** WPILib-style `Translation3d.struct` descriptor. */
+const Translation3d = {
+    typeName: 'Translation3d',
+    schema: Translation3dSchema,
+};
+/** Zod schema for {@link Quaternion}. */
+const QuaternionSchema = z.object({
+    w: z.number(),
+    x: z.number(),
+    y: z.number(),
+    z: z.number(),
+});
+/** WPILib-style `Quaternion.struct` descriptor. */
+const Quaternion = {
+    typeName: 'Quaternion',
+    schema: QuaternionSchema,
+};
+/** Zod schema for {@link Rotation3d}. */
+const Rotation3dSchema = z.object({
+    q: QuaternionSchema,
+});
+/** WPILib-style `Rotation3d.struct` descriptor. */
+const Rotation3d = {
+    typeName: 'Rotation3d',
+    schema: Rotation3dSchema,
+};
+/** Zod schema for {@link Pose3d}. */
+const Pose3dSchema = z.object({
+    translation: Translation3dSchema,
+    rotation: Rotation3dSchema,
+});
+/** WPILib-style `Pose3d.struct` descriptor. */
+const Pose3d = {
+    typeName: 'Pose3d',
+    schema: Pose3dSchema,
+};
+/** Zod schema for {@link Transform3d}. */
+const Transform3dSchema = z.object({
+    translation: Translation3dSchema,
+    rotation: Rotation3dSchema,
+});
+/** WPILib-style `Transform3d.struct` descriptor. */
+const Transform3d = {
+    typeName: 'Transform3d',
+    schema: Transform3dSchema,
+};
+/** Zod schema for {@link Twist3d}. */
+const Twist3dSchema = z.object({
+    dx: z.number(),
+    dy: z.number(),
+    dz: z.number(),
+    rx: z.number(),
+    ry: z.number(),
+    rz: z.number(),
+});
+/** WPILib-style `Twist3d.struct` descriptor. */
+const Twist3d = {
+    typeName: 'Twist3d',
+    schema: Twist3dSchema,
+};
+
+/** NetworkTables class for interacting with NetworkTables over a WebSocket connection. */
+class NetworkTables {
+    /**
+     * Creates a new NetworkTables instance.
+     * @param props - The properties to use to create the instance.
+     * @throws Error if the team number or URI is not provided.
+     */
+    constructor(props) {
+        this.retainCount = 0;
+        if (props.team) {
+            this.uri = getRobotAddress(props.team, props.platform);
+            defaultLogger.debug('Instance created', {
+                team: props.team,
+                platform: props.platform ?? 'roborio',
+                uri: this.uri,
+                port: props.port,
+            });
+        }
+        else if (props.uri) {
+            this.uri = props.uri;
+            defaultLogger.debug('Instance created', { uri: this.uri, port: props.port });
+        }
+        else {
+            throw new Error('Must provide either a team number or URI.');
+        }
+        this.port = props.port;
+        NetworkTables._instances.set(`${this.uri}:${this.port}`, this);
+        this._client = PubSubClient.getInstance(Util.createServerUrl(this.uri, this.port));
+    }
+    /**
+     * Creates a new NetworkTables instance if it does not exist.
+     * @param team - The team number of the robot.
+     * @param port - The port to connect to the robot on. Defaults to 5810.
+     * @param platform - RoboRIO mDNS (`roborio-{team}-frc.local`, default) or SystemCore team IP (`10.TE.AM.2`).
+     * @returns The NetworkTables instance.
+     * @throws Error if the team number is not provided.
+     */
+    static getInstanceByTeam(team, port = 5810, platform = 'roborio') {
+        const uri = getRobotAddress(team, platform);
+        const key = `${uri}:${port}`;
+        let instance = this._instances.get(key);
+        if (!instance) {
+            instance = new this({ team, port, platform });
+        }
+        else {
+            defaultLogger.debug('Instance retrieved from cache', { team, platform, uri, port });
+        }
+        return instance;
+    }
+    /**
+     * Creates a new NetworkTables instance if it does not exist.
+     * @param uri - The URI of the robot.
+     * @param port - The port to connect to the robot on. Defaults to 5810.
+     * @returns The NetworkTables instance.
+     * @throws Error if the URI is not provided.
+     */
+    static getInstanceByURI(uri, port = 5810) {
+        const key = `${uri}:${port}`;
+        let instance = this._instances.get(key);
+        if (!instance) {
+            instance = new this({ uri, port });
+        }
+        else {
+            defaultLogger.debug('Instance retrieved from cache', { uri, port });
+        }
+        return instance;
+    }
+    /**
+     * Returns the URI of the server.
+     * @returns The robot address.
+     */
+    getURI() {
+        return this.uri;
+    }
+    /**
+     * Changes the URI of the server.
+     * @param uri - The new URI of the server.
+     * @param port - The port to connect to the server on. Defaults to 5810.
+     */
+    changeURI(uri, port = 5810) {
+        const oldUri = this.uri;
+        const oldPort = this.port;
+        defaultLogger.info('URI changed', { oldUri, oldPort, newUri: uri, newPort: port });
+        // Update instance map so getInstanceByURI/getInstanceByTeam return this instance for the new target
+        NetworkTables._instances.delete(`${oldUri}:${oldPort}`);
+        this.uri = uri;
+        this.port = port;
+        NetworkTables._instances.set(`${this.uri}:${this.port}`, this);
+        this._client.reinstantiate(Util.createServerUrl(uri, port));
+    }
+    /**
+     * Changes the server using a team number.
+     * @param team - The team number of the robot.
+     * @param port - The port to connect to the server on. Defaults to 5810.
+     * @param platform - RoboRIO mDNS (default) or SystemCore team IP.
+     */
+    changeTeam(team, port = 5810, platform = 'roborio') {
+        this.changeURI(getRobotAddress(team, platform), port);
+    }
+    /**
+     * Returns the port to connect to the robot on.
+     * @returns The port number.
+     */
+    getPort() {
+        return this.port;
+    }
+    /**
+     * Returns whether the robot is currently connected.
+     * @returns Whether the robot is connected.
+     */
+    isRobotConnected() {
+        return this._client.messenger.socket.isConnected();
+    }
+    /**
+     * Returns whether the robot is currently connecting.
+     * @returns Whether the robot is connecting.
+     */
+    isRobotConnecting() {
+        return this._client.messenger.socket.isConnecting();
+    }
+    /**
+     * Returns the best round-trip time to the robot in milliseconds.
+     * @returns RTT in ms, or -1 if not connected or not yet measured.
+     */
+    getRttMs() {
+        return this._client.messenger.socket.getBestRttMs();
+    }
+    /**
+     * Adds a listener for robot connection status updates.
+     * @param callback - The callback to call when the connection status changes.
+     * @param immediateNotify - When true, also notifies once with the current status on a microtask after
+     *   this method returns (so the returned disposer can be called from that first notification).
+     * @returns A function to remove the listener.
+     */
+    addRobotConnectionListener(callback, immediateNotify) {
+        defaultLogger.debug('Connection listener added', { immediateNotify, uri: this.uri, port: this.port });
+        return this._client.messenger.socket.addConnectionListener(callback, immediateNotify);
+    }
+    /**
+     * Stops automatic reconnection to the server. Use when the user dismisses the connection
+     * overlay (e.g. Escape) so the client does not keep trying to reconnect in the background.
+     */
+    stopAutoConnect() {
+        this._client.messenger.socket.stopAutoConnect();
+    }
+    /**
+     * Resumes automatic reconnection to the server after a previous call to stopAutoConnect.
+     */
+    startAutoConnect() {
+        this._client.messenger.socket.startAutoConnect();
+    }
+    /**
+     * Disconnects from the server, unsubscribes/unpublishes all topics, and drops this instance
+     * (and the underlying PubSubClient/Messenger/Socket singletons) so they do not leak.
+     */
+    close() {
+        defaultLogger.info('Closing NetworkTables instance', { uri: this.uri, port: this.port });
+        this.retainCount = 0;
+        this._client.cleanup();
+        this._client.releaseInstance();
+        NetworkTables._instances.delete(`${this.uri}:${this.port}`);
+    }
+    /**
+     * Increments the retain count used by NtcoreProvider so multiple trees can share
+     * this singleton without tearing it down on the first unmount.
+     */
+    retain() {
+        this.retainCount++;
+    }
+    /**
+     * Decrements the retain count and calls {@link close} when it reaches zero.
+     */
+    release() {
+        this.retainCount--;
+        if (this.retainCount <= 0) {
+            this.close();
+        }
+    }
+    createTopic(name, typeInfo, defaultValue) {
+        if (typeInfo === NetworkTablesTypeInfos.kProtobuf || typeInfo[1] === 'protobuf') {
+            throw new Error(`Protobuf types are not allowed in createTopic. Use getProtobufTopic('${name}', options) instead for proper encoding/decoding support.`);
+        }
+        if (typeof typeInfo[1] === 'string' && typeInfo[1].startsWith('struct:')) {
+            throw new Error(`Struct types are not allowed in createTopic. Use getStructTopic('${name}', options) instead for proper encoding/decoding support.`);
+        }
+        defaultLogger.debug('Topic created', { topicName: name, type: typeInfo[1] });
+        if (typeInfo === NetworkTablesTypeInfos.kJson || typeInfo[1] === 'json') {
+            return this.getJsonTopic(name, defaultValue);
+        }
+        return new NetworkTablesTopic(this._client, name, typeInfo, defaultValue);
+    }
+    /**
+     * Creates a boolean topic.
+     * @param name - Topic name (e.g. `/MyTable/Enabled`).
+     * @param defaultValue - Optional value shown before the first server update.
+     */
+    getBooleanTopic(name, defaultValue) {
+        return this.createTopic(name, NetworkTablesTypeInfos.kBoolean, defaultValue);
+    }
+    /**
+     * Creates a double (IEEE-754) topic.
+     * @param name - Topic name (e.g. `/MyTable/Gyro`).
+     * @param defaultValue - Optional value shown before the first server update.
+     */
+    getDoubleTopic(name, defaultValue) {
+        return this.createTopic(name, NetworkTablesTypeInfos.kDouble, defaultValue);
+    }
+    /**
+     * Creates an integer topic.
+     * @param name - Topic name.
+     * @param defaultValue - Optional value shown before the first server update.
+     */
+    getIntegerTopic(name, defaultValue) {
+        return this.createTopic(name, NetworkTablesTypeInfos.kInteger, defaultValue);
+    }
+    /**
+     * Creates a float topic.
+     * @param name - Topic name.
+     * @param defaultValue - Optional value shown before the first server update.
+     */
+    getFloatTopic(name, defaultValue) {
+        return this.createTopic(name, NetworkTablesTypeInfos.kFloat, defaultValue);
+    }
+    /**
+     * Creates a string topic.
+     * @param name - Topic name (e.g. `/MyTable/AutoMode`).
+     * @param defaultValue - Optional value shown before the first server update.
+     */
+    getStringTopic(name, defaultValue) {
+        return this.createTopic(name, NetworkTablesTypeInfos.kString, defaultValue);
+    }
+    /**
+     * Creates a boolean-array topic.
+     * @param name - Topic name.
+     * @param defaultValue - Optional value shown before the first server update.
+     */
+    getBooleanArrayTopic(name, defaultValue) {
+        return this.createTopic(name, NetworkTablesTypeInfos.kBooleanArray, defaultValue);
+    }
+    /**
+     * Creates a double-array topic.
+     * @param name - Topic name.
+     * @param defaultValue - Optional value shown before the first server update.
+     */
+    getDoubleArrayTopic(name, defaultValue) {
+        return this.createTopic(name, NetworkTablesTypeInfos.kDoubleArray, defaultValue);
+    }
+    /**
+     * Creates an integer-array topic.
+     * @param name - Topic name.
+     * @param defaultValue - Optional value shown before the first server update.
+     */
+    getIntegerArrayTopic(name, defaultValue) {
+        return this.createTopic(name, NetworkTablesTypeInfos.kIntegerArray, defaultValue);
+    }
+    /**
+     * Creates a float-array topic.
+     * @param name - Topic name.
+     * @param defaultValue - Optional value shown before the first server update.
+     */
+    getFloatArrayTopic(name, defaultValue) {
+        return this.createTopic(name, NetworkTablesTypeInfos.kFloatArray, defaultValue);
+    }
+    /**
+     * Creates a string-array topic.
+     * @param name - Topic name.
+     * @param defaultValue - Optional value shown before the first server update.
+     */
+    getStringArrayTopic(name, defaultValue) {
+        return this.createTopic(name, NetworkTablesTypeInfos.kStringArray, defaultValue);
+    }
+    /**
+     * Creates a raw (`uint8[]`) topic. Values are `Uint8Array`.
+     * @param name - Topic name.
+     * @param defaultValue - Optional value shown before the first server update.
+     */
+    getRawTopic(name, defaultValue) {
+        return this.createTopic(name, NetworkTablesTypeInfos.kUint8Array, defaultValue);
+    }
+    /**
+     * Creates a JSON topic with optional Zod validation.
+     * If a topic with the same name already exists, the existing instance is returned and options are applied.
+     * @param name - Topic name.
+     * @param defaultValue - Optional value shown before the first server update.
+     * @param options - Optional `validator` schema.
+     */
+    getJsonTopic(name, defaultValue, options) {
+        const existingTopic = this._client.getTopicFromName(name);
+        if (existingTopic instanceof NetworkTablesJsonTopic) {
+            existingTopic.applyOptions({
+                defaultValue,
+                validator: options?.validator,
+            });
+            return existingTopic;
+        }
+        return new NetworkTablesJsonTopic(this._client, name, defaultValue, options);
+    }
+    /**
+     * Creates a protobuf topic.
+     * If a topic with the same name already exists, the existing instance is returned and options are applied.
+     */
+    getProtobufTopic(name, options) {
+        const existingTopic = this._client.getTopicFromName(name);
+        if (existingTopic instanceof NetworkTablesProtobufTopic) {
+            existingTopic.applyOptions(options);
+            return existingTopic;
+        }
+        return new NetworkTablesProtobufTopic(this._client, name, options);
+    }
+    getStructTopic(name, typeOrOptions, maybeOptions) {
+        const options = isStructTypeDescriptor(typeOrOptions)
+            ? {
+                typeName: typeOrOptions.typeName,
+                validator: typeOrOptions.schema,
+                defaultValue: maybeOptions?.defaultValue,
+                schema: maybeOptions?.schema,
+            }
+            : (typeOrOptions ?? {});
+        const existingTopic = this._client.getTopicFromName(name);
+        if (existingTopic instanceof NetworkTablesStructTopic) {
+            if (options.typeName) {
+                const requestedType = `struct:${options.typeName}`;
+                const existingType = existingTopic.typeInfo[1];
+                if (existingType !== requestedType) {
+                    throw new Error(`getStructTopic: type mismatch for topic "${name}". ` +
+                        `Existing type "${existingType}" does not match requested typeName "${options.typeName}". ` +
+                        `A struct topic's type is immutable once created.`);
+                }
+            }
+            existingTopic.applyOptions(options);
+            return existingTopic;
+        }
+        if (!options.typeName) {
+            throw new Error(`getStructTopic: cannot create topic "${name}" without a type. Pass a descriptor (e.g. Pose2d) or { typeName }.`);
+        }
+        return new NetworkTablesStructTopic(this._client, name, options);
+    }
+    /**
+     * Creates a prefix topic (wildcard subscription).
+     * @param prefix - The prefix of the topic.
+     * @returns The topic.
+     */
+    getPrefixTopic(prefix) {
+        defaultLogger.debug('Prefix topic created', { prefix });
+        return new NetworkTablesPrefixTopic(this._client, prefix);
+    }
+    /**
+     * Sets the global log level for all modules.
+     * @param level - The log level to set.
+     */
+    static setLogLevel(level) {
+        setLogLevel(level);
+    }
+    /**
+     * Sets the log level for a specific module.
+     * @param module - The module name ('socket', 'messenger', 'pubsub', or 'default').
+     * @param level - The log level to set.
+     */
+    static setModuleLogLevel(module, level) {
+        setModuleLogLevel(module, level);
+    }
+    /**
+     * Gets the current log level for a specific module.
+     * @param module - The module name ('socket', 'messenger', 'pubsub', or 'default').
+     * @returns The current log level.
+     */
+    static getModuleLogLevel(module = 'default') {
+        return getModuleLogLevel(module);
+    }
+}
+/** The instance of the NetworkTables class. */
+NetworkTables._instances = new Map();
+
+export { BUILT_IN_STRUCT_TYPE_NAMES, LogLevel, NetworkTables, NetworkTablesJsonTopic, NetworkTablesPrefixTopic, NetworkTablesProtobufTopic, NetworkTablesStructTopic, NetworkTablesTopic, NetworkTablesTypeInfos, Pose2d, Pose2dSchema, Pose3d, Pose3dSchema, Quaternion, QuaternionSchema, Rotation2d, Rotation2dSchema, Rotation3d, Rotation3dSchema, SYSTEMCORE_MDNS_HOST, Transform2d, Transform2dSchema, Transform3d, Transform3dSchema, Translation2d, Translation2dSchema, Translation3d, Translation3dSchema, Twist2d, Twist2dSchema, Twist3d, Twist3dSchema, getBuiltInDescriptor, getModuleLogLevel, getRobotAddress, getTeamIpAddress, isStructTypeDescriptor, pack, parseRobotAddress, setLogLevel, setModuleLogLevel, unpack };
+//# sourceMappingURL=index.esm.js.map