// but we need some way to correlate a given request with a specific response channel
        return Delivery.AllHandlers;
    }

    public Throwable getFailure() {
        return failure;
    }

    DefaultDeploymentStatus(boolean changed, @Nullable Throwable failure) {
        this.changed = changed;
        this.failure = failure;
    }

    @Override
    public Throwable getFailure() {
        return failure;
    }

    @Override
    public boolean hasChanged() {
        return changed;
    }

    @Override
    public String toString() {

     */
    void writeTo(int requestId, HttpExchange exchange) throws IOException;

    /**
     * Returns the failure, if any.
     */
    default RuntimeException getFailure() {
        throw new IllegalStateException();
    }

     */
    public abstract T getOrMapFailure(Function<Throwable, T> f);

    /**
     * Returns the failure for a failed result, or {@link Optional#empty()} otherwise.
     */
    public abstract Optional<Throwable> getFailure();

    /**
     * If the represented operation was successful, returns the result of applying the given
     * {@code Try}-bearing mapping function to the value, otherwise returns

                    Throwable failure = null;
                    try {
                        worker.execute(buildOperation, context);
                    } catch (Throwable t) {
                        if (context.getFailure() == null) {
                            context.failed(t);
                        }
                        failure = t;
                    }

            return;
        }

        // Need to perform the actual resolve
        ComponentIdResolveResult result = selector.resolve(allRejects);

        if (result.getFailure() != null) {
            results.register(selector, result);
            return;
        }

        results.replaceExistingResolutionsWithBetterResult(result, selector.isFromLock());

    @Nullable
    InternalDetails getDetails();

    @Nullable
    InternalContextualLabel getContextualLabel();

    List<InternalLocation> getLocations();

    @Nullable
    InternalFailure getFailure();

    InternalAdditionalData getAdditionalData();

        this.failure = failure;
    }

    @Override
    public boolean isFailure() {
        return true;
    }

    @Override
    public RuntimeException getFailure() {
        return failure;
    }

    @Override
    public void writeTo(int requestId, HttpExchange exchange) {
        throw new IllegalStateException();
    }

    boolean isSuccessful();

    /**
     * Returns the resolve failure, if any.
     */
    @Override
    @Nullable
    ArtifactResolveException getFailure();

    /**
     * @throws ArtifactResolveException If the resolution was unsuccessful.
     */
    @Override
    File getResult() throws ArtifactResolveException;

    /**

    boolean isSuccessful();

    /**
     * Returns the resolve failure, if any.
     */
    @Override
    @Nullable
    ArtifactResolveException getFailure();

    /**
     * @throws ArtifactResolveException If the resolution was unsuccessful.
     */
    @Override
    ResolvableArtifact getResult() throws ArtifactResolveException;

    /**