Errors

General Error Variables

The following error variables are defined with the prefix Err and are used for general-purpose error handling:

Protocol Error Types

The following error types are defined to represent specific protocol error scenarios. Each type wraps error codes and provides methods for error handling and inspection:

Relationship with QUIC errors

The concrete MOQ error types map directly onto the QUIC error primitives:

• moqt.SessionError wraps *quic.ApplicationError and represents errors that affect the whole QUIC connection (session-level errors).
• moqt.AnnounceError, moqt.SubscribeError, and moqt.GroupError each wrap *quic.StreamError and represent errors that occur on individual QUIC streams (stream-level errors).

This mapping allows protocol-specific error types to be propagated over QUIC using the appropriate QUIC error mechanism.

Each error type implements the error interface and works with Go’s standard error utilities (errors.Is, errors.As).

Built-in Error Codes

Error codes for each custom error type are summarized below. Click each section to toggle visibility.

Error Handling

Implementations in gomoqt/moqt return specific error types for different error scenarios. You can use type assertions to handle these errors accordingly.

• Example: When moqt.TrackWriter returns an error

    var subErr *moqt.SubscribeError
    if errors.As(err, &subErr) {
        // Handle SubscribeError
    }

Error Propagation

You can get context.Context via Context method implementated in gomoqt/moqt such as moqt.TrackReader or moqt.Session. moqt.Cause function is provided to access to the root cause of an error propagation and to parse the cause as a MOQ error if it is a QUIC error. This is because the context.Context holds the original QUIC error and context.Cause returns the cause as is.

func Cause(ctx context.Context) error

Example: Get MOQ cause from context.Context

    var ctx context.Context

    var cause error
    cause = moqt.Cause(ctx)

To get the MOQ cause from a context, use errors.As function with corresponding error type.

Example: When moqt.TrackWriter’s context is canceled

    var tw *moqt.TrackWriter
    ctx := tw.Context()

    if err := moqt.Cause(ctx); err != nil {
        var subErr *moqt.SubscribeError
        if errors.As(err, &subErr) {
            // Handle SubscribeError
        }

        var sessErr *moqt.SessionError
        if errors.As(err, &sessErr) {
            // Handle SessionError
        }
    }