Java on Cloudflare Workers

package com.example;

import dev.gmitch215.bytebox.*;

public class HelloWorker implements Worker {
    @Override
    public Response fetch(Request request, Env env, ExecutionCtx ctx) {
        return Bytebox.response("hello from Java");
    }
}

plugins {
    java
    id("dev.gmitch215.bytebox") version "1.0.0"
}

repositories {
        mavenCentral()
}

dependencies { 
        implementation("dev.gmitch215:bytebox-core:1.0.0") 
}

// ...

bytebox {
    handlerClass = "com.example.HelloWorker" // to handler class

    wrangler {
        name = "hello-world" // name of cfw
        compatibilityDate = "2026-08-22" // compatibility date of cfw
    }
}

./gradlew buildWorker # build wrangler.jsonc, webassembly module, entrypoint
./gradlew workerDeploy # run wrangler deploy to logged-in account

bytebox {
    bindings {
        kv()                             // KV
        kv("SESSIONS") { id = "abc123" } // an explicit name and a remote id
        d1()                             // DB
        r2()                             // BLOB
        durableObject("Counter")         // DO_COUNTER
    }
}

bytebox {
    bindings(KV, D1, D1, KV) // KV, DB, DB_2, KV_2
}

@JsonType
public record Order(String sku, int quantity, long total, List<String> tags) { // ... }

Order order = request.json(Order.class);
return Bytebox.json(order, Order.class);

byte[] wire = Serial.encode(order);
Order back = Serial.decode(wire, Order.class);

ZonedDateTime local = Instant.now().atZone(ZoneId.of("America/New_York"));
HttpResponse<String> answer = HttpClient.newHttpClient()
    .send(HttpRequest.newBuilder(URI.create("https://example.com")).build(), ofString());

package com.example;

import dev.gmitch215.bytebox.Bytebox;
import dev.gmitch215.bytebox.Env;
import dev.gmitch215.bytebox.ExecutionCtx;
import dev.gmitch215.bytebox.Request;
import dev.gmitch215.bytebox.Response;
import dev.gmitch215.bytebox.Worker;
import java.io.IOException;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.time.Duration;
import java.time.Instant;
import java.time.LocalDate;
import java.time.ZoneId;
import java.time.ZonedDateTime;
import java.time.format.DateTimeFormatter;
import java.time.temporal.ChronoUnit;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * Ordinary Java, on a platform that has none of it.
 *
 * <p>Nothing here is a bytebox API. It is {@code java.time}, {@code java.net.http},
 * {@code java.util.regex} and {@code String.format}, written the way they are written anywhere, and
 * the compiler points each reference at an implementation that works on this runtime. That is what
 * makes an unmodified library compile: the library does not know it is being retargeted.
 *
 * <p>What each one costs, and where each one differs from a JVM, is in the technical report. The two
 * differences worth knowing at the call site are here as comments.
 */
public class StandardLibraryWorker implements Worker {

    private static final Pattern SINCE = Pattern.compile("since=(?<date>\\d{4}-\\d{2}-\\d{2})");

    private static final HttpClient CLIENT = HttpClient.newBuilder()
        .connectTimeout(Duration.ofSeconds(5))
        .build();

    @Override
    public Response fetch(Request request, Env env, ExecutionCtx ctx) {
        LocalDate since = LocalDate.of(2026, 1, 1);
        Matcher asked = SINCE.matcher(request.getUrl());
        if (asked.find()) since = LocalDate.parse(asked.group("date"));

        // the clock is pinned between I/O, so this is the time the invocation began and does not move
        Instant now = Instant.now();
        ZonedDateTime local = now.atZone(ZoneId.of("America/New_York"));
        long days = ChronoUnit.DAYS.between(since, local.toLocalDate());

        StringBuilder body = new StringBuilder();
        body.append(local.format(DateTimeFormatter.ISO_OFFSET_DATE_TIME)).append('\n');
        // %,d groups every three digits here, which is right for the locales that group in threes
        body.append(String.format("%,d days since %s%n", days, since));
        body.append(String.format("%-12s %8.2f%%%n", "elapsed", (days * 100.0) / 365));
        body.append(upstream()).append('\n');

        return Bytebox.response(body.toString());
    }

    /** A request through the modern client, which is {@code fetch} underneath and suspends the fiber. */
    private String upstream() {
        try {
            HttpResponse<String> answer = CLIENT.send(
                HttpRequest.newBuilder(URI.create("https://example.com/"))
                    .header("Accept", "text/html")
                    .timeout(Duration.ofSeconds(3))
                    .build(),
                HttpResponse.BodyHandlers.ofString()
            );
            return String.format(
                "upstream %d, %,d bytes",
                answer.statusCode(),
                answer.body().length()
            );
        } catch (IOException | InterruptedException failed) {
            return "upstream unreachable: " + failed.getMessage();
        }
    }
}

bytebox {
    npm("nanoid", "^5.0.9")
    npmBindings("nanoid")
}

@JSBody(
    params = "size",
    imports = @JSBodyImport(alias = "nanoid", fromModule = "nanoid"),
    script = "return nanoid.nanoid(size);"
)
private static native String id(int size);

dependencies {
        implementation("com.example:foo:1.0.0")
}

package com.example;

import dev.gmitch215.bytebox.Bytebox;
import dev.gmitch215.bytebox.Cron;
import dev.gmitch215.bytebox.Env;
import dev.gmitch215.bytebox.ExecutionCtx;
import dev.gmitch215.bytebox.Scheduled;
import dev.gmitch215.bytebox.builtin.Clock;

/**
 * A Worker with no HTTP handler at all.
 *
 * <p>Implementing only {@code Scheduled} means the generated Worker exports only {@code scheduled},
 * and the generated configuration carries only the trigger. Nothing is exported for a trigger the
 * handler does not implement.
 *
 * <p>An account gets 5 Cron Triggers on the free plan and 250 on paid, counted across every Worker
 * rather than per Worker. A scheduled invocation gets 15 minutes rather than a request's allowance,
 * and a throw is logged without a retry.
 */
public class NightlyWorker implements Scheduled {

    @Override
    public void scheduled(Cron cron, Env env, ExecutionCtx ctx) {
        Bytebox.log("fired for " + cron.expression() + ", due at " + Clock.iso(cron.scheduledAt()));
        env.kv().put("last-run", Clock.isoNow());
    }
}

package com.example;

import dev.gmitch215.bytebox.Bytebox;
import dev.gmitch215.bytebox.Env;
import dev.gmitch215.bytebox.ExecutionCtx;
import dev.gmitch215.bytebox.Request;
import dev.gmitch215.bytebox.Response;
import dev.gmitch215.bytebox.Worker;
import dev.gmitch215.bytebox.binding.DurableObjectNamespace;
import dev.gmitch215.bytebox.js.TSObject;

/**
 * Routes to a Durable Object, which is where state that has to be exact belongs.
 *
 * <p>One instance per id, in one place, so two requests for the same id reach the same instance and
 * see each other's writes. That is the difference from the kv-counter sample, where two regions can
 * both read the same value and both write the next one.
 *
 * <p>The Durable Object class itself is JavaScript: it extends Cloudflare's own base class, which is
 * a JavaScript class the runtime instantiates. What Java owns is the routing and the calls.
 */
public class CounterWorker implements Worker {

    @Override
    public Response fetch(Request request, Env env, ExecutionCtx ctx) {
        DurableObjectNamespace counters = env.durableObject("DO_COUNTER");

        // the id is derived from the path, so every path gets its own instance
        var counter = counters.byName(request.path());
        TSObject count = counter.rpc("increment");

        return Bytebox.response(request.path() + " is at " + count.asInt() + "\n");
    }
}