@hla4ts/hla-api 0.1.0

package/src/callback-dispatcher.ts

@@ -0,0 +1,673 @@
+/**
+ * Callback Dispatcher
+ *
+ * This module handles decoding and dispatching of RTI callbacks to the
+ * FederateAmbassador implementation.
+ */
+
+import {
+  CallbackRequestCodec,
+  CallbackResponseCodec,
+  type CallbackRequest,
+  type CallbackResponse,
+  type CallbackSucceeded,
+} from "@hla4ts/proto";
+
+import type { FederateAmbassador } from "./federate-ambassador.ts";
+import {
+  convertObjectClassHandle,
+  convertAttributeHandle,
+  convertInteractionClassHandle,
+  convertObjectInstanceHandle,
+  convertFederateHandle,
+  convertTransportationTypeHandle,
+  convertLogicalTime,
+  convertMessageRetractionHandle,
+  convertAttributeHandleSet,
+  convertFederateHandleSet,
+  convertAttributeHandleValueMap,
+  convertParameterHandleValueMap,
+  convertFederationExecutionInformationSet,
+  convertFederationExecutionMemberInformationSet,
+  convertFederateHandleSaveStatusPairArray,
+  convertFederateRestoreStatusArray,
+  convertConveyedRegionSet,
+  convertOrderType,
+} from "./converters.ts";
+import { FederateInternalError, RTIinternalError } from "./exceptions.ts";
+import type { ExceptionData } from "@hla4ts/proto";
+
+/**
+ * Result of dispatching a callback.
+ */
+export interface CallbackDispatchResult {
+  /** Whether the callback was handled successfully */
+  success: boolean;
+  /** Error if the callback failed */
+  error?: Error;
+}
+
+/**
+ * Callback dispatcher that decodes and dispatches RTI callbacks.
+ */
+export class CallbackDispatcher {
+  private readonly _federateAmbassador: FederateAmbassador;
+
+  constructor(federateAmbassador: FederateAmbassador) {
+    this._federateAmbassador = federateAmbassador;
+  }
+
+  /**
+   * Decode a callback request from raw bytes.
+   */
+  decodeCallbackRequest(data: Uint8Array): CallbackRequest {
+    return CallbackRequestCodec.decode(data);
+  }
+
+  /**
+   * Encode a successful callback response.
+   */
+  encodeSuccessResponse(): Uint8Array {
+    const response: CallbackResponse = {
+      callbackSucceeded: {} as CallbackSucceeded,
+    };
+    return CallbackResponseCodec.encode(response).finish();
+  }
+
+  /**
+   * Encode a failed callback response.
+   */
+  encodeFailureResponse(error: Error): Uint8Array {
+    const exceptionData: ExceptionData = {
+      exceptionName: error.name || "FederateInternalError",
+      details: error.message || "Unknown error",
+    };
+    const response: CallbackResponse = {
+      callbackFailed: exceptionData,
+    };
+    return CallbackResponseCodec.encode(response).finish();
+  }
+
+  /**
+   * Dispatch a decoded callback request to the FederateAmbassador.
+   *
+   * @param callback - The decoded callback request
+   * @returns Result indicating success or failure
+   */
+  dispatchCallback(callback: CallbackRequest): CallbackDispatchResult {
+    const fa = this._federateAmbassador;
+
+    try {
+      // Connection Management
+      if (callback.connectionLost) {
+        fa.connectionLost?.(callback.connectionLost.faultDescription ?? "");
+        return { success: true };
+      }
+
+      // Federation Management
+      if (callback.reportFederationExecutions) {
+        fa.reportFederationExecutions?.(
+          convertFederationExecutionInformationSet(callback.reportFederationExecutions.report)
+        );
+        return { success: true };
+      }
+
+      if (callback.reportFederationExecutionMembers) {
+        fa.reportFederationExecutionMembers?.(
+          callback.reportFederationExecutionMembers.federationName ?? "",
+          convertFederationExecutionMemberInformationSet(callback.reportFederationExecutionMembers.report)
+        );
+        return { success: true };
+      }
+
+      if (callback.reportFederationExecutionDoesNotExist) {
+        fa.reportFederationExecutionDoesNotExist?.(
+          callback.reportFederationExecutionDoesNotExist.federationName ?? ""
+        );
+        return { success: true };
+      }
+
+      if (callback.federateResigned) {
+        fa.federateResigned?.(callback.federateResigned.reasonForResignDescription ?? "");
+        return { success: true };
+      }
+
+      // Synchronization Points
+      if (callback.synchronizationPointRegistrationSucceeded) {
+        fa.synchronizationPointRegistrationSucceeded?.(
+          callback.synchronizationPointRegistrationSucceeded.synchronizationPointLabel ?? ""
+        );
+        return { success: true };
+      }
+
+      if (callback.synchronizationPointRegistrationFailed) {
+        fa.synchronizationPointRegistrationFailed?.(
+          callback.synchronizationPointRegistrationFailed.synchronizationPointLabel ?? "",
+          callback.synchronizationPointRegistrationFailed.reason
+        );
+        return { success: true };
+      }
+
+      if (callback.announceSynchronizationPoint) {
+        fa.announceSynchronizationPoint?.(
+          callback.announceSynchronizationPoint.synchronizationPointLabel ?? "",
+          callback.announceSynchronizationPoint.userSuppliedTag ?? new Uint8Array(0)
+        );
+        return { success: true };
+      }
+
+      if (callback.federationSynchronized) {
+        fa.federationSynchronized?.(
+          callback.federationSynchronized.synchronizationPointLabel ?? "",
+          convertFederateHandleSet(callback.federationSynchronized.failedToSyncSet)
+        );
+        return { success: true };
+      }
+
+      // Save Services
+      if (callback.initiateFederateSave) {
+        fa.initiateFederateSave?.(callback.initiateFederateSave.label ?? "");
+        return { success: true };
+      }
+
+      if (callback.initiateFederateSaveWithTime) {
+        fa.initiateFederateSaveWithTime?.(
+          callback.initiateFederateSaveWithTime.label ?? "",
+          convertLogicalTime(callback.initiateFederateSaveWithTime.time)
+        );
+        return { success: true };
+      }
+
+      if (callback.federationSaved) {
+        fa.federationSaved?.();
+        return { success: true };
+      }
+
+      if (callback.federationNotSaved) {
+        fa.federationNotSaved?.(callback.federationNotSaved.reason);
+        return { success: true };
+      }
+
+      if (callback.federationSaveStatusResponse) {
+        fa.federationSaveStatusResponse?.(
+          convertFederateHandleSaveStatusPairArray(callback.federationSaveStatusResponse.response)
+        );
+        return { success: true };
+      }
+
+      // Restore Services
+      if (callback.requestFederationRestoreSucceeded) {
+        fa.requestFederationRestoreSucceeded?.(callback.requestFederationRestoreSucceeded.label ?? "");
+        return { success: true };
+      }
+
+      if (callback.requestFederationRestoreFailed) {
+        fa.requestFederationRestoreFailed?.(callback.requestFederationRestoreFailed.label ?? "");
+        return { success: true };
+      }
+
+      if (callback.federationRestoreBegun) {
+        fa.federationRestoreBegun?.();
+        return { success: true };
+      }
+
+      if (callback.initiateFederateRestore) {
+        fa.initiateFederateRestore?.(
+          callback.initiateFederateRestore.label ?? "",
+          callback.initiateFederateRestore.federateName ?? "",
+          convertFederateHandle(callback.initiateFederateRestore.postRestoreFederateHandle)
+        );
+        return { success: true };
+      }
+
+      if (callback.federationRestored) {
+        fa.federationRestored?.();
+        return { success: true };
+      }
+
+      if (callback.federationNotRestored) {
+        fa.federationNotRestored?.(callback.federationNotRestored.reason);
+        return { success: true };
+      }
+
+      if (callback.federationRestoreStatusResponse) {
+        fa.federationRestoreStatusResponse?.(
+          convertFederateRestoreStatusArray(callback.federationRestoreStatusResponse.response)
+        );
+        return { success: true };
+      }
+
+      // Declaration Management
+      if (callback.startRegistrationForObjectClass) {
+        fa.startRegistrationForObjectClass?.(
+          convertObjectClassHandle(callback.startRegistrationForObjectClass.objectClass)
+        );
+        return { success: true };
+      }
+
+      if (callback.stopRegistrationForObjectClass) {
+        fa.stopRegistrationForObjectClass?.(
+          convertObjectClassHandle(callback.stopRegistrationForObjectClass.objectClass)
+        );
+        return { success: true };
+      }
+
+      if (callback.turnInteractionsOn) {
+        fa.turnInteractionsOn?.(
+          convertInteractionClassHandle(callback.turnInteractionsOn.interactionClass)
+        );
+        return { success: true };
+      }
+
+      if (callback.turnInteractionsOff) {
+        fa.turnInteractionsOff?.(
+          convertInteractionClassHandle(callback.turnInteractionsOff.interactionClass)
+        );
+        return { success: true };
+      }
+
+      // Object Instance Name Reservation
+      if (callback.objectInstanceNameReservationSucceeded) {
+        fa.objectInstanceNameReservationSucceeded?.(
+          callback.objectInstanceNameReservationSucceeded.objectInstanceName ?? ""
+        );
+        return { success: true };
+      }
+
+      if (callback.objectInstanceNameReservationFailed) {
+        fa.objectInstanceNameReservationFailed?.(
+          callback.objectInstanceNameReservationFailed.objectInstanceName ?? ""
+        );
+        return { success: true };
+      }
+
+      if (callback.multipleObjectInstanceNameReservationSucceeded) {
+        fa.multipleObjectInstanceNameReservationSucceeded?.(
+          callback.multipleObjectInstanceNameReservationSucceeded.objectInstanceNames ?? []
+        );
+        return { success: true };
+      }
+
+      if (callback.multipleObjectInstanceNameReservationFailed) {
+        fa.multipleObjectInstanceNameReservationFailed?.(
+          callback.multipleObjectInstanceNameReservationFailed.objectInstanceNames ?? []
+        );
+        return { success: true };
+      }
+
+      // Object Discovery & Removal
+      if (callback.discoverObjectInstance) {
+        fa.discoverObjectInstance?.(
+          convertObjectInstanceHandle(callback.discoverObjectInstance.objectInstance),
+          convertObjectClassHandle(callback.discoverObjectInstance.objectClass),
+          callback.discoverObjectInstance.objectInstanceName ?? "",
+          convertFederateHandle(callback.discoverObjectInstance.producingFederate)
+        );
+        return { success: true };
+      }
+
+      if (callback.removeObjectInstance) {
+        fa.removeObjectInstance?.(
+          convertObjectInstanceHandle(callback.removeObjectInstance.objectInstance),
+          callback.removeObjectInstance.userSuppliedTag ?? new Uint8Array(0),
+          convertFederateHandle(callback.removeObjectInstance.producingFederate)
+        );
+        return { success: true };
+      }
+
+      if (callback.removeObjectInstanceWithTime) {
+        const cb = callback.removeObjectInstanceWithTime;
+        fa.removeObjectInstanceWithTime?.(
+          convertObjectInstanceHandle(cb.objectInstance),
+          cb.userSuppliedTag ?? new Uint8Array(0),
+          convertFederateHandle(cb.producingFederate),
+          convertLogicalTime(cb.time),
+          convertOrderType(cb.sentOrderType),
+          convertOrderType(cb.receivedOrderType),
+          cb.optionalRetraction ? convertMessageRetractionHandle(cb.optionalRetraction) : undefined
+        );
+        return { success: true };
+      }
+
+      // Attribute Updates
+      if (callback.reflectAttributeValues) {
+        const cb = callback.reflectAttributeValues;
+        fa.reflectAttributeValues?.(
+          convertObjectInstanceHandle(cb.objectInstance),
+          convertAttributeHandleValueMap(cb.attributeValues),
+          cb.userSuppliedTag ?? new Uint8Array(0),
+          convertTransportationTypeHandle(cb.transportationType),
+          convertFederateHandle(cb.producingFederate),
+          cb.optionalSentRegions ? convertConveyedRegionSet(cb.optionalSentRegions) : undefined
+        );
+        return { success: true };
+      }
+
+      if (callback.reflectAttributeValuesWithTime) {
+        const cb = callback.reflectAttributeValuesWithTime;
+        fa.reflectAttributeValuesWithTime?.(
+          convertObjectInstanceHandle(cb.objectInstance),
+          convertAttributeHandleValueMap(cb.attributeValues),
+          cb.userSuppliedTag ?? new Uint8Array(0),
+          convertTransportationTypeHandle(cb.transportationType),
+          convertFederateHandle(cb.producingFederate),
+          cb.optionalSentRegions ? convertConveyedRegionSet(cb.optionalSentRegions) : undefined,
+          convertLogicalTime(cb.time),
+          convertOrderType(cb.sentOrderType),
+          convertOrderType(cb.receivedOrderType),
+          cb.optionalRetraction ? convertMessageRetractionHandle(cb.optionalRetraction) : undefined
+        );
+        return { success: true };
+      }
+
+      // Interactions
+      if (callback.receiveInteraction) {
+        const cb = callback.receiveInteraction;
+        fa.receiveInteraction?.(
+          convertInteractionClassHandle(cb.interactionClass),
+          convertParameterHandleValueMap(cb.parameterValues),
+          cb.userSuppliedTag ?? new Uint8Array(0),
+          convertTransportationTypeHandle(cb.transportationType),
+          convertFederateHandle(cb.producingFederate),
+          cb.optionalSentRegions ? convertConveyedRegionSet(cb.optionalSentRegions) : undefined
+        );
+        return { success: true };
+      }
+
+      if (callback.receiveInteractionWithTime) {
+        const cb = callback.receiveInteractionWithTime;
+        fa.receiveInteractionWithTime?.(
+          convertInteractionClassHandle(cb.interactionClass),
+          convertParameterHandleValueMap(cb.parameterValues),
+          cb.userSuppliedTag ?? new Uint8Array(0),
+          convertTransportationTypeHandle(cb.transportationType),
+          convertFederateHandle(cb.producingFederate),
+          cb.optionalSentRegions ? convertConveyedRegionSet(cb.optionalSentRegions) : undefined,
+          convertLogicalTime(cb.time),
+          convertOrderType(cb.sentOrderType),
+          convertOrderType(cb.receivedOrderType),
+          cb.optionalRetraction ? convertMessageRetractionHandle(cb.optionalRetraction) : undefined
+        );
+        return { success: true };
+      }
+
+      if (callback.receiveDirectedInteraction) {
+        const cb = callback.receiveDirectedInteraction;
+        fa.receiveDirectedInteraction?.(
+          convertInteractionClassHandle(cb.interactionClass),
+          convertObjectInstanceHandle(cb.objectInstance),
+          convertParameterHandleValueMap(cb.parameterValues),
+          cb.userSuppliedTag ?? new Uint8Array(0),
+          convertTransportationTypeHandle(cb.transportationType),
+          convertFederateHandle(cb.producingFederate)
+        );
+        return { success: true };
+      }
+
+      if (callback.receiveDirectedInteractionWithTime) {
+        const cb = callback.receiveDirectedInteractionWithTime;
+        fa.receiveDirectedInteractionWithTime?.(
+          convertInteractionClassHandle(cb.interactionClass),
+          convertObjectInstanceHandle(cb.objectInstance),
+          convertParameterHandleValueMap(cb.parameterValues),
+          cb.userSuppliedTag ?? new Uint8Array(0),
+          convertTransportationTypeHandle(cb.transportationType),
+          convertFederateHandle(cb.producingFederate),
+          convertLogicalTime(cb.time),
+          convertOrderType(cb.sentOrderType),
+          convertOrderType(cb.receivedOrderType),
+          cb.optionalRetraction ? convertMessageRetractionHandle(cb.optionalRetraction) : undefined
+        );
+        return { success: true };
+      }
+
+      // Attribute Value Update Requests
+      if (callback.provideAttributeValueUpdate) {
+        fa.provideAttributeValueUpdate?.(
+          convertObjectInstanceHandle(callback.provideAttributeValueUpdate.objectInstance),
+          convertAttributeHandleSet(callback.provideAttributeValueUpdate.attributes),
+          callback.provideAttributeValueUpdate.userSuppliedTag ?? new Uint8Array(0)
+        );
+        return { success: true };
+      }
+
+      if (callback.turnUpdatesOnForObjectInstance) {
+        fa.turnUpdatesOnForObjectInstance?.(
+          convertObjectInstanceHandle(callback.turnUpdatesOnForObjectInstance.objectInstance),
+          convertAttributeHandleSet(callback.turnUpdatesOnForObjectInstance.attributes)
+        );
+        return { success: true };
+      }
+
+      if (callback.turnUpdatesOnForObjectInstanceWithRate) {
+        fa.turnUpdatesOnForObjectInstanceWithRate?.(
+          convertObjectInstanceHandle(callback.turnUpdatesOnForObjectInstanceWithRate.objectInstance),
+          convertAttributeHandleSet(callback.turnUpdatesOnForObjectInstanceWithRate.attributes),
+          callback.turnUpdatesOnForObjectInstanceWithRate.updateRateDesignator ?? ""
+        );
+        return { success: true };
+      }
+
+      if (callback.turnUpdatesOffForObjectInstance) {
+        fa.turnUpdatesOffForObjectInstance?.(
+          convertObjectInstanceHandle(callback.turnUpdatesOffForObjectInstance.objectInstance),
+          convertAttributeHandleSet(callback.turnUpdatesOffForObjectInstance.attributes)
+        );
+        return { success: true };
+      }
+
+      // Attribute Scope
+      if (callback.attributesInScope) {
+        fa.attributesInScope?.(
+          convertObjectInstanceHandle(callback.attributesInScope.objectInstance),
+          convertAttributeHandleSet(callback.attributesInScope.attributes)
+        );
+        return { success: true };
+      }
+
+      if (callback.attributesOutOfScope) {
+        fa.attributesOutOfScope?.(
+          convertObjectInstanceHandle(callback.attributesOutOfScope.objectInstance),
+          convertAttributeHandleSet(callback.attributesOutOfScope.attributes)
+        );
+        return { success: true };
+      }
+
+      // Ownership Management
+      if (callback.requestAttributeOwnershipAssumption) {
+        fa.requestAttributeOwnershipAssumption?.(
+          convertObjectInstanceHandle(callback.requestAttributeOwnershipAssumption.objectInstance),
+          convertAttributeHandleSet(callback.requestAttributeOwnershipAssumption.offeredAttributes),
+          callback.requestAttributeOwnershipAssumption.userSuppliedTag ?? new Uint8Array(0)
+        );
+        return { success: true };
+      }
+
+      if (callback.requestDivestitureConfirmation) {
+        fa.requestDivestitureConfirmation?.(
+          convertObjectInstanceHandle(callback.requestDivestitureConfirmation.objectInstance),
+          convertAttributeHandleSet(callback.requestDivestitureConfirmation.releasedAttributes)
+        );
+        return { success: true };
+      }
+
+      if (callback.attributeOwnershipAcquisitionNotification) {
+        fa.attributeOwnershipAcquisitionNotification?.(
+          convertObjectInstanceHandle(callback.attributeOwnershipAcquisitionNotification.objectInstance),
+          convertAttributeHandleSet(callback.attributeOwnershipAcquisitionNotification.securedAttributes),
+          callback.attributeOwnershipAcquisitionNotification.userSuppliedTag ?? new Uint8Array(0)
+        );
+        return { success: true };
+      }
+
+      if (callback.attributeOwnershipUnavailable) {
+        fa.attributeOwnershipUnavailable?.(
+          convertObjectInstanceHandle(callback.attributeOwnershipUnavailable.objectInstance),
+          convertAttributeHandleSet(callback.attributeOwnershipUnavailable.attributes)
+        );
+        return { success: true };
+      }
+
+      if (callback.requestAttributeOwnershipRelease) {
+        fa.requestAttributeOwnershipRelease?.(
+          convertObjectInstanceHandle(callback.requestAttributeOwnershipRelease.objectInstance),
+          convertAttributeHandleSet(callback.requestAttributeOwnershipRelease.candidateAttributes),
+          callback.requestAttributeOwnershipRelease.userSuppliedTag ?? new Uint8Array(0)
+        );
+        return { success: true };
+      }
+
+      if (callback.confirmAttributeOwnershipAcquisitionCancellation) {
+        fa.confirmAttributeOwnershipAcquisitionCancellation?.(
+          convertObjectInstanceHandle(callback.confirmAttributeOwnershipAcquisitionCancellation.objectInstance),
+          convertAttributeHandleSet(callback.confirmAttributeOwnershipAcquisitionCancellation.attributes)
+        );
+        return { success: true };
+      }
+
+      if (callback.informAttributeOwnership) {
+        // Note: InformAttributeOwnership in proto has 'attributes' and 'federate' (not single attribute and owner)
+        // For simplicity, we take first attribute if the callback expects a single one
+        const attrs = convertAttributeHandleSet(callback.informAttributeOwnership.attributes);
+        if (attrs.length > 0) {
+          fa.informAttributeOwnership?.(
+            convertObjectInstanceHandle(callback.informAttributeOwnership.objectInstance),
+            attrs[0],
+            convertFederateHandle(callback.informAttributeOwnership.federate)
+          );
+        }
+        return { success: true };
+      }
+
+      if (callback.attributeIsNotOwned) {
+        // Same note as above
+        const attrs = convertAttributeHandleSet(callback.attributeIsNotOwned.attributes);
+        if (attrs.length > 0) {
+          fa.attributeIsNotOwned?.(
+            convertObjectInstanceHandle(callback.attributeIsNotOwned.objectInstance),
+            attrs[0]
+          );
+        }
+        return { success: true };
+      }
+
+      if (callback.attributeIsOwnedByRTI) {
+        // Same note as above
+        const attrs = convertAttributeHandleSet(callback.attributeIsOwnedByRTI.attributes);
+        if (attrs.length > 0) {
+          fa.attributeIsOwnedByRTI?.(
+            convertObjectInstanceHandle(callback.attributeIsOwnedByRTI.objectInstance),
+            attrs[0]
+          );
+        }
+        return { success: true };
+      }
+
+      // Time Management
+      if (callback.timeRegulationEnabled) {
+        fa.timeRegulationEnabled?.(convertLogicalTime(callback.timeRegulationEnabled.time));
+        return { success: true };
+      }
+
+      if (callback.timeConstrainedEnabled) {
+        fa.timeConstrainedEnabled?.(convertLogicalTime(callback.timeConstrainedEnabled.time));
+        return { success: true };
+      }
+
+      if (callback.timeAdvanceGrant) {
+        fa.timeAdvanceGrant?.(convertLogicalTime(callback.timeAdvanceGrant.time));
+        return { success: true };
+      }
+
+      if (callback.flushQueueGrant) {
+        fa.flushQueueGrant?.(convertLogicalTime(callback.flushQueueGrant.time));
+        return { success: true };
+      }
+
+      if (callback.requestRetraction) {
+        fa.requestRetraction?.(
+          convertMessageRetractionHandle(callback.requestRetraction.retraction)
+        );
+        return { success: true };
+      }
+
+      // Transportation Type Changes
+      if (callback.confirmAttributeTransportationTypeChange) {
+        fa.confirmAttributeTransportationTypeChange?.(
+          convertObjectInstanceHandle(callback.confirmAttributeTransportationTypeChange.objectInstance),
+          convertAttributeHandleSet(callback.confirmAttributeTransportationTypeChange.attributes),
+          convertTransportationTypeHandle(callback.confirmAttributeTransportationTypeChange.transportationType)
+        );
+        return { success: true };
+      }
+
+      if (callback.reportAttributeTransportationType) {
+        fa.reportAttributeTransportationType?.(
+          convertObjectInstanceHandle(callback.reportAttributeTransportationType.objectInstance),
+          convertAttributeHandle(callback.reportAttributeTransportationType.attribute),
+          convertTransportationTypeHandle(callback.reportAttributeTransportationType.transportationType)
+        );
+        return { success: true };
+      }
+
+      if (callback.confirmInteractionTransportationTypeChange) {
+        fa.confirmInteractionTransportationTypeChange?.(
+          convertInteractionClassHandle(callback.confirmInteractionTransportationTypeChange.interactionClass),
+          convertTransportationTypeHandle(callback.confirmInteractionTransportationTypeChange.transportationType)
+        );
+        return { success: true };
+      }
+
+      if (callback.reportInteractionTransportationType) {
+        fa.reportInteractionTransportationType?.(
+          convertFederateHandle(callback.reportInteractionTransportationType.federate),
+          convertInteractionClassHandle(callback.reportInteractionTransportationType.interactionClass),
+          convertTransportationTypeHandle(callback.reportInteractionTransportationType.transportationType)
+        );
+        return { success: true };
+      }
+
+      // Unknown callback type
+      console.warn("[CallbackDispatcher] Unknown callback type received");
+      return { success: true }; // Don't fail on unknown callbacks
+
+    } catch (error) {
+      if (error instanceof FederateInternalError) {
+        return { success: false, error };
+      }
+      // Wrap other errors
+      const wrappedError = new RTIinternalError(
+        `Error dispatching callback: ${error instanceof Error ? error.message : String(error)}`
+      );
+      return { success: false, error: wrappedError };
+    }
+  }
+
+  /**
+   * Process a raw callback request and return the encoded response.
+   *
+   * This is the main entry point used by the RTI Ambassador.
+   *
+   * @param rawCallbackData - The raw protobuf-encoded callback request
+   * @returns The encoded callback response
+   */
+  processCallback(rawCallbackData: Uint8Array): Uint8Array {
+    try {
+      const callback = this.decodeCallbackRequest(rawCallbackData);
+      const result = this.dispatchCallback(callback);
+
+      if (result.success) {
+        return this.encodeSuccessResponse();
+      } else {
+        return this.encodeFailureResponse(result.error ?? new FederateInternalError("Unknown error"));
+      }
+    } catch (error) {
+      // Decoding error
+      return this.encodeFailureResponse(
+        new RTIinternalError(
+          `Failed to decode callback: ${error instanceof Error ? error.message : String(error)}`
+        )
+      );
+    }
+  }
+}