computer: raise the JavaScript backend default limits

The starting defaults were tuned conservatively and proved too tight in
practice. Raise the execution timeout ceiling to three minutes and the
default to sixty seconds, the source and input byte ceilings to one
mebibyte each, the retention window to sixty minutes, the concurrent
execution ceiling to twenty-four, and the concurrent capability call
ceiling to thirty-two. Update the backend documentation to match and
keep the concurrency-cap test pinned to a single execution so it still
exercises the ceiling.

Author: aron-cf

docs/17_isolate_javascript.md

@@ -14,8 +14,8 @@ const workspace = new Workspace({
       loader: env.LOADER,
       root: "/workspace",
       access: "read-write",
-      defaultTimeoutMs: 10_000,
-      maxTimeoutMs: 30_000,
+      defaultTimeoutMs: 60_000,
+      maxTimeoutMs: 180_000,
       globalOutbound: null,
       modules: {
         "math-kit": `export const double = value => value * 2;`,
@@ -81,11 +81,11 @@ Workspace parses the graph before loading the Worker, confines every durable pat
 
 ## Execution limits and retention
 
-The backend admits one execution at a time by default. A concurrent start fails with `EEXEC_BUSY` instead of creating an unbounded number of Dynamic Workers. Set `maxConcurrentExecutions` only after measuring the Durable Object and Worker Loader limits for the deployment.
+The backend admits up to twenty-four executions at a time by default. A concurrent start past that ceiling fails with `EEXEC_BUSY` instead of creating an unbounded number of Dynamic Workers. Adjust `maxConcurrentExecutions` after measuring the Durable Object and Worker Loader limits for the deployment.
 
 Each execution also bounds log events, active event subscribers, directory entries per read, concurrent and total capability calls, and cumulative capability request and response bytes. The corresponding `maxLogEvents`, `maxExecutionSubscribers`, `maxDirectoryEntries`, and `max*Capability*` options may be lowered for public workloads. Directory reads apply their limit in SQLite before materializing rows. Requests are checked inside the isolate before Workers RPC and again by the host.
 
-Completed execution records remain available for replay for five minutes by default. The backend also keeps at most 100 completed records. Configure these bounds with `retentionMs` and `maxRetainedExecutions`. Completed records leave the in-memory active set immediately; replay reads them from SQLite.
+Completed execution records remain available for replay for sixty minutes by default. The backend also keeps at most 100 completed records. Configure these bounds with `retentionMs` and `maxRetainedExecutions`. Completed records leave the in-memory active set immediately; replay reads them from SQLite.
 
 Cancellation stops new host capability calls, disposes the Dynamic Worker, and waits for host calls that were already accepted. Exit 130 is published only after those calls settle. Normal completion uses the same drain rule, so an unawaited capability call cannot mutate the workspace after exit 0.
 

packages/computer/src/backends/worker-javascript/worker-javascript.test.ts

@@ -384,6 +384,7 @@ describe("WorkerJavaScriptBackend", () => {
       waitUntil,
       backends: [
         new WorkerJavaScriptBackend({
+          maxConcurrentExecutions: 1,
           loader: {
             load() {
               return {

packages/computer/src/backends/worker-javascript/worker-javascript.ts

@@ -144,12 +144,12 @@ export class WorkerJavaScriptBackend implements WorkspaceModuleBackend {
 
   constructor(options: WorkerJavaScriptBackendOptions) {
     this.id = options.id ?? "worker-javascript";
-    const maxTimeoutMs = options.maxTimeoutMs ?? 30_000;
-    const defaultTimeoutMs = options.defaultTimeoutMs ?? Math.min(10_000, maxTimeoutMs);
+    const maxTimeoutMs = options.maxTimeoutMs ?? 180_000;
+    const defaultTimeoutMs = options.defaultTimeoutMs ?? Math.min(60_000, maxTimeoutMs);
     assertPositiveFinite(maxTimeoutMs, "maxTimeoutMs");
     assertPositiveFinite(defaultTimeoutMs, "defaultTimeoutMs");
-    assertPositiveFinite(options.maxSourceBytes ?? 256 * 1024, "maxSourceBytes");
-    assertPositiveFinite(options.maxInputBytes ?? 256 * 1024, "maxInputBytes");
+    assertPositiveFinite(options.maxSourceBytes ?? 1024 * 1024, "maxSourceBytes");
+    assertPositiveFinite(options.maxInputBytes ?? 1024 * 1024, "maxInputBytes");
     assertPositiveFinite(options.maxStdinBytes ?? 256 * 1024, "maxStdinBytes");
     assertPositiveFinite(options.maxEnvBytes ?? 1024 * 1024, "maxEnvBytes");
     assertPositiveFinite(options.maxResultBytes ?? 1024 * 1024, "maxResultBytes");
@@ -158,7 +158,7 @@ export class WorkerJavaScriptBackend implements WorkspaceModuleBackend {
     assertPositiveFinite(options.maxCapabilityBytes ?? 1024 * 1024, "maxCapabilityBytes");
     assertPositiveFinite(options.maxHostCallMs ?? maxTimeoutMs, "maxHostCallMs");
     assertPositiveInteger(
-      options.maxConcurrentCapabilityCalls ?? 16,
+      options.maxConcurrentCapabilityCalls ?? 32,
       "maxConcurrentCapabilityCalls",
     );
     assertPositiveInteger(options.maxCapabilityCalls ?? 256, "maxCapabilityCalls");
@@ -171,9 +171,9 @@ export class WorkerJavaScriptBackend implements WorkspaceModuleBackend {
       "maxCapabilityResponseBytes",
     );
     assertPositiveInteger(options.maxDirectoryEntries ?? 1024, "maxDirectoryEntries");
-    assertPositiveInteger(options.maxConcurrentExecutions ?? 1, "maxConcurrentExecutions");
+    assertPositiveInteger(options.maxConcurrentExecutions ?? 24, "maxConcurrentExecutions");
     assertPositiveInteger(options.maxExecutionSubscribers ?? 8, "maxExecutionSubscribers");
-    assertPositiveFinite(options.retentionMs ?? 5 * 60_000, "retentionMs");
+    assertPositiveFinite(options.retentionMs ?? 60 * 60_000, "retentionMs");
     assertPositiveInteger(options.maxRetainedExecutions ?? 100, "maxRetainedExecutions");
     if ((options.maxCapabilityBytes ?? 1024 * 1024) < 256) {
       throw new Error("WorkerJavaScriptBackend maxCapabilityBytes must be at least 256 bytes.");
@@ -191,23 +191,23 @@ export class WorkerJavaScriptBackend implements WorkspaceModuleBackend {
       access: options.access ?? "read-write",
       defaultTimeoutMs,
       maxTimeoutMs,
-      maxSourceBytes: options.maxSourceBytes ?? 256 * 1024,
-      maxInputBytes: options.maxInputBytes ?? 256 * 1024,
+      maxSourceBytes: options.maxSourceBytes ?? 1024 * 1024,
+      maxInputBytes: options.maxInputBytes ?? 1024 * 1024,
       maxStdinBytes: options.maxStdinBytes ?? 256 * 1024,
       maxEnvBytes: options.maxEnvBytes ?? 1024 * 1024,
       maxResultBytes: options.maxResultBytes ?? 1024 * 1024,
       maxLogBytes: options.maxLogBytes ?? 256 * 1024,
       maxLogEvents: options.maxLogEvents ?? 1024,
       maxCapabilityBytes: options.maxCapabilityBytes ?? 1024 * 1024,
       maxHostCallMs: options.maxHostCallMs ?? maxTimeoutMs,
-      maxConcurrentCapabilityCalls: options.maxConcurrentCapabilityCalls ?? 16,
+      maxConcurrentCapabilityCalls: options.maxConcurrentCapabilityCalls ?? 32,
       maxCapabilityCalls: options.maxCapabilityCalls ?? 256,
       maxCapabilityRequestBytes: options.maxCapabilityRequestBytes ?? 8 * 1024 * 1024,
       maxCapabilityResponseBytes: options.maxCapabilityResponseBytes ?? 8 * 1024 * 1024,
       maxDirectoryEntries: options.maxDirectoryEntries ?? 1024,
-      maxConcurrentExecutions: options.maxConcurrentExecutions ?? 1,
+      maxConcurrentExecutions: options.maxConcurrentExecutions ?? 24,
       maxExecutionSubscribers: options.maxExecutionSubscribers ?? 8,
-      retentionMs: options.retentionMs ?? 5 * 60_000,
+      retentionMs: options.retentionMs ?? 60 * 60_000,
       maxRetainedExecutions: options.maxRetainedExecutions ?? 100,
       compatibilityDate,
       compatibilityFlags: options.compatibilityFlags ?? ["nodejs_compat"],