) : Codec<DefaultResolvableArtifact> {
    private
    val componentIdSerializer = ComponentIdentifierSerializer()

    override suspend fun WriteContext.encode(value: DefaultResolvableArtifact) {
        // Write the source artifact
        writeFile(value.file)
        IvyArtifactNameSerializer.INSTANCE.write(this, value.artifactName)

object BeanCodec : Codec<Any> {

    override suspend fun WriteContext.encode(value: Any) {
        encodePreservingIdentityOf(value) {
            val beanType = GeneratedSubclasses.unpackType(value)
            withBeanTrace(beanType) {
                writeBeanOf(beanType, value)
            }
        }
    }

    override suspend fun ReadContext.decode(): Any =
        decodePreservingIdentity { id ->

    override suspend fun WriteContext.encode(value: ComponentVariantIdentifier) {
        encodePreservingSharedIdentityOf(value) {
            write(value.componentId)
            write(value.attributes)
            writeCollection(value.capabilities.asSet())
        }
    }

    override suspend fun ReadContext.decode(): ComponentVariantIdentifier {
        return decodePreservingSharedIdentity {

    override suspend fun WriteContext.encode(value: PublishArtifactLocalArtifactMetadata) {
        write(value.componentIdentifier)
        value.publishArtifact.run {
            write(ImmutablePublishArtifact(name, extension, type, classifier, file))
        }
    }

    override suspend fun ReadContext.decode(): PublishArtifactLocalArtifactMetadata {

class CalculatedValueContainerCodec(
    private val calculatedValueContainerFactory: CalculatedValueContainerFactory
) : Codec<CalculatedValueContainer<Any, ValueCalculator<Any>>> {
    override suspend fun WriteContext.encode(value: CalculatedValueContainer<Any, ValueCalculator<Any>>) {
        encodePreservingSharedIdentityOf(value) {
            if (value.isFinalized) {
                writeBoolean(true)
                write(value.get())

object CachedEnvironmentStateCodec : Codec<ConfigurationCacheEnvironmentChangeTracker.CachedEnvironmentState> {

    override suspend fun WriteContext.encode(value: ConfigurationCacheEnvironmentChangeTracker.CachedEnvironmentState) {
        writeBoolean(value.cleared)

        writeCollection(value.updates) { update ->
            val keyString = update.key.toString()

private
enum class ReferenceType {
    SELF_REF,
    TASK_REF,
    PROHIBITED
}


object TaskReferenceCodec : Codec<Task> {

    override suspend fun WriteContext.encode(value: Task) = when {
        value === isolate.owner.delegate ->
            writeEnum(ReferenceType.SELF_REF)

        isTaskReferencesAllowed(value) -> {
            writeEnum(ReferenceType.TASK_REF)

class TransformedArtifactCodec(
    private val calculatedValueContainerFactory: CalculatedValueContainerFactory
) : Codec<TransformingAsyncArtifactListener.TransformedArtifact> {
    override suspend fun WriteContext.encode(value: TransformingAsyncArtifactListener.TransformedArtifact) {
        write(value.variantName)
        write(value.target)
        writeCollection(value.capabilities.asSet())
        write(value.artifact.id.componentIdentifier)

 */
object SerializedLambdaParametersCheckingCodec : Codec<SerializedLambda> {
    override suspend fun ReadContext.decode(): SerializedLambda {
        return decodeBean() as SerializedLambda
    }

    override suspend fun WriteContext.encode(value: SerializedLambda) {
        checkLambdaCapturedArgTypesAreSupported(value)
        encodeBean(value)
    }

    private

    override suspend fun WriteContext.encode(value: TransformStepSpec) {
        write(value.transformStep)
        if (value is TransformStepSpec.FileDependencies) {
            writeBoolean(true)
            write(value.files)
            write(value.configurationIdentity)
        } else {
            writeBoolean(false)
        }
    }

    override suspend fun ReadContext.decode(): TransformStepSpec {