fun initializeCommands() {
    val itemStackPredicateType = object : TypeToken<ItemStackPredicateArgument>() {}
    val itemStackPredicateSetType = TypeToken.get(TypeFactory.parameterizedClass(Set::class.java, ItemStackPredicateArgument::class.java))

    manager.parserRegistry().registerParserSupplier(itemStackPredicateType) {
        FabricArgumentParsers.contextual(ItemPredicateArgumentType::itemPredicate)
    }
    manager.parserRegistry().registerParserSupplier(itemStackPredicateSetType) { parameters ->
        SetArgument.SetParser(parameters, itemStackPredicateType, manager)
    }
val manager = FabricClientCommandManager(
//        AsyncCommandCoordinator.builder<ClientCommand>()
//            .withAsynchronousParsing()
//            .withExecutor(scheduledThreadPool)
//            .build(),
        CommandExecutionCoordinator.simpleCoordinator(),
        ::ClientCommand,
        ClientCommand::source
    )

    MinecraftExceptionHandler<ClientCommand>()
        .withDefaultHandlers()
        .withDecorator { message: Component -> messagePrefix.append(message) }
        .apply(manager, AudienceProvider.nativeAudience<ClientCommand>())

    val annotationParser = AnnotationParser<ClientCommand>(manager) { SimpleCommandMeta.empty() }.apply {
        installCoroutineSupport()
    }

    annotationParser.parse(
        UtilCommands()
    )
}



data class ClientCommand(val source: FabricClientCommandSource) : ForwardingAudience.Single {
    private val audience: Audience = FabricClientAudiences.of().audience()

    override fun audience(): Audience = audience
}



@CommandMethod("altoclef")
class UtilCommands {
    @CommandMethod("deposit <items>")
    @CommandDescription("Deposit ALL of our items")
    fun deposit(
        command: ClientCommand,
        @Argument("items")
        items: Set<ItemPredicateArgumentType.ItemStackPredicateArgument>, // TODO: we need a custom parser for this (also probably a wrapper class)
    ) {
        val validItems = Registries.ITEM.filter { item ->
            items.any { it.test(item.defaultStack) }
        }
        val itemTarget = ItemTarget(validItems.toTypedArray())
        itemTarget.infinite()

        runUserTask(StoreInAnyContainerTask(false, itemTarget))
    }
}