@WorkflowInterface
public interface OrderWorkflow {

    @WorkflowMethod
    OrderResult process(Order order);

    @SignalMethod
    void approve(String trackingNumber);
}

@ActivityInterface
public interface OrderActivities {

    @ActivityMethod
    ValidationResult validate(Order order);

    @ActivityMethod
    Shipment ship(Order order, String trackingNumber);
}

public class OrderWorkflowImpl implements OrderWorkflow {

    // Activity stub — created once, reused across invocations
    private final OrderActivities activities =
            Workflow.newActivityStub(OrderActivities.class);

    // Workflow state updated by signals
    private volatile String trackingNumber;

    @Override
    public OrderResult process(Order order) {
        ValidationResult v = activities.validate(order);
        if (!v.isValid()) {
            return OrderResult.rejected(v.reason());
        }

        // Park until approve() signal sets trackingNumber
        Workflow.await(() -> trackingNumber != null);

        Shipment shipment = activities.ship(order, trackingNumber);
        return OrderResult.completed(shipment);
    }

    @Override
    public void approve(String trackingNumber) {
        this.trackingNumber = trackingNumber;  // unblocks Workflow.await()
    }
}

public class OrderActivitiesImpl implements OrderActivities {

    @Override
    public ValidationResult validate(Order order) {
        // Any blocking I/O is fine here — runs on a virtual thread
        return inventoryService.check(order);
    }

    @Override
    public Shipment ship(Order order, String trackingNumber) {
        return shippingService.createShipment(order, trackingNumber);
    }
}

SharedLogService sharedLog = SharedLogService.open(
        SharedLogConfig.builder()
                .persistenceAdapter(new FileBasedPersistenceAdapter("/var/boudin"))
                .build());

Worker worker = Worker.newBuilder()
        .taskQueue("orders")
        .sharedLog(sharedLog)
        .build();

worker.registerWorkflow(OrderWorkflowImpl.class);
worker.registerActivities(new OrderActivitiesImpl());
worker.start();

WorkflowClient client = WorkflowClient.newInstance(sharedLog);

OrderWorkflow stub = client.newWorkflowStub(
        OrderWorkflow.class,
        WorkflowOptions.newBuilder()
                .taskQueue("orders")
                .workflowId("order-42")   // optional; random UUID if omitted
                .build());

// Blocks the calling thread until the workflow completes
OrderResult result = stub.process(new Order("ord-42", customer, items));

// From the same process
stub.approve("TRK-9871");

// From a different process (signal-only stub — does not start a new workflow)
WorkflowClient client = WorkflowClient.newInstance(sharedLog);
OrderWorkflow signalStub = client.newSignalOnlyStub(
        OrderWorkflow.class, "order-42", "orders");
signalStub.approve("TRK-9871");

Worker worker = Worker.newBuilder()
        .taskQueue("my-queue")
        .sharedLog(sharedLog)
        .build();

worker.registerWorkflow(MyWorkflowImpl.class);   // implementation class
worker.registerActivities(new MyActivitiesImpl()); // implementation instance
worker.start();

// Graceful shutdown
worker.close();

WorkflowClient client = WorkflowClient.newInstance(sharedLog);

// Start a workflow and block until it completes
MyWorkflow stub = client.newWorkflowStub(MyWorkflow.class, options);
Result r = stub.run(input);

// Send a signal to an already-running workflow (no new execution started)
MyWorkflow signalStub = client.newSignalOnlyStub(MyWorkflow.class, workflowId, taskQueue);
signalStub.mySignal(payload);

// Create a typed activity proxy (safe to store as a field)
MyActivities activities = Workflow.newActivityStub(MyActivities.class);
MyActivities activities = Workflow.newActivityStub(MyActivities.class, ActivityOptions.defaults());

// Block until condition is true (re-evaluated after each signal)
Workflow.await(() -> this.approved);

// Block with a timeout; returns false if timeout elapsed before condition became true
boolean inTime = Workflow.await(Duration.ofMinutes(10), () -> this.approved);

// Identity
String id    = Workflow.getWorkflowId();
String queue = Workflow.getTaskQueue();

WorkflowOptions options = WorkflowOptions.newBuilder()
        .taskQueue("orders")           // required
        .workflowId("order-42")        // optional; random UUID if omitted
        .workflowRunTimeout(Duration.ofHours(24))  // optional
        .build();

ActivityOptions actOpts = ActivityOptions.newBuilder()
        .taskQueue("heavy-tasks")      // optional; defaults to workflow's queue
        .startToCloseTimeout(Duration.ofSeconds(30))  // default: 10s
        .maxAttempts(3)                // default: 1
        .build();