[tyffical]

Motivation

• Each call has its own process, so calls can run in parallel, as in production.
• Parallel calls need log lines that name their call.
• Failures should reach app code as in a deployed app.
• Ticket: APPS-2961 Run local backend functions in parallel, with per-call realtime console logs.
• Stack order, merged bottom up:
  1. [APPS-2961] Refactor: move local execution's side-effect-free helpers into their own module #604
  2. [APPS-2961] Update: run each local backend function call in a fresh process #608
  3. [APPS-2961] Add: limit local call processes with Node's permission model #617
  4. This PR
  5. [APPS-2961] Add: CI matrix running local execution against real Vite 7 and 8 installs #606

Architecture

sequenceDiagram
    participant App as App frontend (dev client)
    participant D as Vite dev server
    participant C1 as Call 1 process
    participant C2 as Call 2 process
    participant API as Datadog API
    App->>D: executeAction (call 1)
    App->>D: executeAction (call 2)
    D->>API: One runtime-context lookup, shared by both calls
    API-->>D: Runtime context ($)
    par Calls run in parallel, no local limit
        D->>C1: start
        C1-->>D: Log lines, printed as [fn#35;1] ...
    and
        D->>C2: start
        C2-->>D: Log lines, printed as [fn#35;2] ...
    end
    C1->>D: $.Actions call fails
    D-->>C1: Rejects with the platform's bare string
    C1->>D: result
    D-->>App: 200 with the result
    C2->>D: Uncaught error
    D-->>App: 500 {error: "Execution failed: #lt;message#gt;"}
    Note over App: The dev client throws BackendFunctionError("Execution failed: #lt;message#gt;")

Loading

Changes

10 changes across local-execution-process.ts, dev-server.ts, local-execution-shared.ts, dev-server-transport.ts, the README and tests

What changed	File
Runs calls in parallel, with no local limit, and removes the one-at-a-time queue.	local-execution-process.ts, local-execution.ts
Prefixes each logged line with [<function>#N].	local-execution-process.ts
Carries thrown strings and failure detail across IPC.	local-execution-process.ts, local-execution-child.ts, local-execution-protocol.ts
Concurrent calls share one runtime context query.	dev-server.ts
Rejects a failed $.Actions call with the platform's bare string.	dev-server.ts
Reports an uncaught failure as Execution failed: <stack or value>.	dev-server.ts, local-execution-shared.ts, local-execution-child.ts
Rejects invalid $.Actions calls with deployed-wording strings.	local-execution-shared.ts
Throws the response's error, else the status and body.	dev-server-transport.ts
Documents parallel calls, the shared query and log prefixes.	README.md
Tests each change.	local-execution-process.integration.test.ts, dev-server.test.ts, execute-backend-function.test.ts

QA Instructions

• Local parallel checks pass through a real Vite 6.4.3 dev server on Node 20.19.4, verified at 00ec61cb, as are the staging checks in a Datadog staging org.
• Parallel calls and [logLines#N] prefixes also pass through real Vite 7.3.7 and 8.3.3 dev servers in the suite from [APPS-2961] Add: CI matrix running local execution against real Vite 7 and 8 installs #606, verified on Node 20.19.4 and 24.22.1 with this branch's packed plugin at 71953bda, which adds only CI and that suite on top.

Check	Result	Evidence
Parallel calls	Three 1.5 s calls and one failing call finish in about 2 s	qa-parallel.mjs
Log prefixes	Every line carries its call's [<function>#N]	qa-parallel.mjs
One failing call	Only it returns 500 Execution failed: Error: qa boom …; the others return 200	qa-parallel.mjs
Overlapping runtime context lookups	One Datadog query for all four calls	qa-parallel.mjs
Processes	Every call's process and the dev server exit	qa-parallel.mjs
No connection	a connection is required for …	run.sh
No arguments or inputs	No arguments provided …, or … must have an inputs field that is an object	run.sh
Unknown connection	rpc error: code = NotFound …	run.sh
Real read-only connection	Resolves	run.sh
Uncaught failure	BackendFunctionError: Execution failed: <message or stack>	transport-run.sh

yarn typecheck:all  # Expected: exit 0
yarn lint           # Expected: exit 0
yarn cli integrity  # Expected: exit 0, no changes
TMPDIR=/private/tmp yarn test:unit packages/plugins/apps  # Expected: all pass

Local parallel-call harness and raw output

• Fixture, in an app whose node_modules/vite links to the repo's Vite, with the plugin built by yarn workspace @datadog/vite-plugin build:

// src/parallel.backend.ts
export async function sleepAndLog(ms: number, label: string) {
    console.log(`start ${label}`);
    await new Promise((resolve) => setTimeout(resolve, ms));
    console.error(`end ${label}`);
    return { label, pid: process.pid };
}

export async function failing() {
    console.log('about to fail');
    throw new Error('qa boom');
}

// qa-parallel.mjs
// Usage: node qa-parallel.mjs <worktree> <app-dir>
// Starts a real Vite dev server with the built @datadog/vite-plugin, answers the Datadog runtime
// context query in-process (fake keys, no network), fires 3 sleepAndLog calls and 1 failing call
// at once to /__dd/executeAction, and prints timings, responses, query count and child pids.
import path from 'node:path';
import { pathToFileURL } from 'node:url';

const [worktree, appDir] = process.argv.slice(2);
const realFetch = globalThis.fetch;
let runtimeContextQueries = 0;
globalThis.fetch = async (input, init) => {
    const url = String(input instanceof Request ? input.url : input);
    if (url.endsWith('/api/v2/app-builder/queries/preview-async')) {
        runtimeContextQueries += 1;
        // Datadog's own latency, so calls that arrive together overlap their queries.
        await new Promise((resolve) => setTimeout(resolve, Number(process.env.QA_LATENCY_MS ?? 0)));
        return Response.json({ data: { id: 'qa-receipt' } });
    }
    if (url.includes('/api/v2/app-builder/queries/execution-long-polling/')) {
        const data = { Source: { initiator: { id: 'qa-user', orgId: 'qa-org' }, runAsUser: { id: 'qa-user', orgId: 'qa-org' } } };
        return Response.json({ data: { attributes: { done: true, outputs: { data } } } });
    }
    return realFetch(input, init);
};
process.env.BUILD_PLUGINS_ENV = 'test';
process.env.DD_API_KEY = 'qa-fake-api-key';
process.env.DD_APP_KEY = 'qa-fake-app-key';

const vite = await import(pathToFileURL(path.join(worktree, 'node_modules/vite/dist/node/index.js')).href);
const { datadogVitePlugin } = await import(
    pathToFileURL(path.join(worktree, 'packages/published/vite-plugin/dist/src/index.mjs')).href
);
const server = await vite.createServer({
    configFile: false,
    root: appDir,
    logLevel: 'error',
    server: { port: 0, strictPort: false, hmr: false },
    optimizeDeps: { noDiscovery: true },
    plugins: [datadogVitePlugin({ auth: { site: 'datadoghq.com' }, apps: { enable: true } })],
});
await server.listen();
const baseUrl = `http://localhost:${server.httpServer.address().port}`;
console.log(`QA dev server pid ${process.pid} at ${baseUrl}`);

const proxy = await (await realFetch(`${baseUrl}/src/parallel.backend.ts`)).text();
const names = Object.fromEntries(
    [...proxy.matchAll(/executeBackendFunction\("([^"]+)"/g)].map((m) => [m[1].split('.').pop(), m[1]]),
);
const call = async (fn, args) => {
    const startedAt = Date.now();
    const response = await realFetch(`${baseUrl}/__dd/executeAction`, {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify({ functionName: names[fn], args }),
    });
    return { fn, args, status: response.status, body: await response.text(), ms: Date.now() - startedAt };
};

const startedAt = Date.now();
const results = await Promise.all([
    call('sleepAndLog', [1500, 'a']),
    call('sleepAndLog', [1500, 'b']),
    call('failing', []),
    call('sleepAndLog', [1500, 'c']),
]);
const wallMs = Date.now() - startedAt;
for (const result of results) console.log('RESULT', JSON.stringify(result));
console.log(`WALL ${wallMs}ms for 3 x 1500ms calls plus 1 failing call`);
console.log(`RUNTIME_CONTEXT_QUERIES ${runtimeContextQueries}`);
const pids = results.filter((r) => r.status === 200).map((r) => JSON.parse(r.body).result.data.pid);
console.log(`CHILD_PIDS ${pids.join(' ')}`);
await server.close();

# From the repo root, so Volta picks its pinned Node 20.19.4
QA_LATENCY_MS=300 node qa-parallel.mjs "$PWD" ./qa-app > qa-run.log 2>&1
for p in $(grep "^CHILD_PIDS" qa-run.log | cut -d" " -f2-); do ps -p "$p" >/dev/null && echo "pid $p alive" || echo "pid $p gone"; done

QA dev server pid 26855 at http://localhost:5173
[warn|vite|apps] Local execution on Node.js 20.19.4 can't provide `import.meta.resolve` inside the sandbox; production runs Node 24. Upgrade to Node 22.15+ to match it.
[sleepAndLog#1] start c
[sleepAndLog#2] start a
[failing#4] about to fail
[sleepAndLog#3] start b
[sleepAndLog#1] end c
[sleepAndLog#2] end a
[sleepAndLog#3] end b
RESULT {"fn":"sleepAndLog","args":[1500,"a"],"status":200,"body":"{\"success\":true,\"result\":{\"data\":{\"label\":\"a\",\"pid\":26860}}}","ms":2127}
RESULT {"fn":"sleepAndLog","args":[1500,"b"],"status":200,"body":"{\"success\":true,\"result\":{\"data\":{\"label\":\"b\",\"pid\":26861}}}","ms":2172}
RESULT {"fn":"failing","args":[],"status":500,"body":"{\"success\":false,\"error\":\"Execution failed: Error: qa boom\\n    at failing (…/qa-app/src/parallel.backend.ts:10:11)…\"}","ms":649}
RESULT {"fn":"sleepAndLog","args":[1500,"c"],"status":200,"body":"{\"success\":true,\"result\":{\"data\":{\"label\":\"c\",\"pid\":26859}}}","ms":2109}
WALL 2173ms for 3 x 1500ms calls plus 1 failing call
RUNTIME_CONTEXT_QUERIES 1
CHILD_PIDS 26860 26861 26859
pid 26860 gone
pid 26861 gone
pid 26859 gone
pid 26855 gone

Staging fixtures, helper scripts and raw output

• Fixtures, in an app with the packed plugin:

// src/parity.backend.ts
import { listMonitors } from '@datadog/action-catalog/dd/monitor';
import { list } from '@datadog/action-catalog/github/pulls';

declare const $: any;

function describe(err: unknown) {
    return err instanceof Error ? { type: 'Error', message: err.message } : { type: typeof err, value: err };
}

async function attempt(call: () => Promise<unknown>) {
    try {
        const value = await call();
        return { resolved: Array.isArray(value) ? `array of ${value.length}` : typeof value };
    } catch (err) {
        return describe(err);
    }
}

export async function missingConnection() {
    return attempt(() => $.Actions.github.pulls.list({ inputs: { owner: 'DataDog', repo: 'datadog-agent' } }));
}

export async function missingConnectionTyped() {
    return attempt(() => list({ inputs: { owner: 'DataDog', repo: 'datadog-agent' } } as any));
}

export async function noArguments() {
    return attempt(() => $.Actions.github.pulls.list());
}

export async function missingInputs() {
    return attempt(() => $.Actions.github.pulls.list({ owner: 'DataDog', repo: 'datadog-agent' }));
}

export async function fakeConnection() {
    return attempt(() => listMonitors({ inputs: { limit: 1 }, connectionId: '00000000-0000-0000-0000-000000000000' }));
}

export async function unlistedConnection() {
    return attempt(() => $.Actions.dd.monitor.listMonitors({ inputs: { limit: 1 }, connectionId: 'qa-unlisted-connection' }));
}

export async function realConnection() {
    return attempt(() => listMonitors({ inputs: { limit: 1 }, connectionId: '<read-only-connection-id>' }));
}

// src/parityUncaught.backend.ts
declare const $: any;

export async function uncaughtMissingConnection() {
    return $.Actions.github.pulls.list({ inputs: { owner: 'DataDog', repo: 'datadog-agent' } });
}

export async function uncaughtString() {
    const failure = 'plain string failure';
    throw failure;
}

// src/uncaughtError.backend.ts
export async function uncaughtError() {
    throw new TypeError('plain error x');
}

• Runner and request logger:

# run.sh
#!/usr/bin/env bash
# Usage (with DD_API_KEY and DD_APP_KEY for a Datadog staging org): run.sh <app-dir> <port> <out-prefix> <fixture>:<fn> ...
# Starts the app's Vite dev server in development mode, POSTs each function to /__dd/executeAction,
# records full response bodies, then stops the server by its own PID.
set -u
APP="$1"; PORT="$2"; OUT="$3"; shift 3
D="$(cd "$(dirname "$0")" && pwd)"
NET_LOG="$OUT.net.log"; VITE_LOG="$OUT.vite.log"; RESP="$OUT.responses.txt"
: > "$NET_LOG"; : > "$RESP"
cd "$APP" || exit 1
if [ -n "$(lsof -ti tcp:$PORT -sTCP:LISTEN)" ]; then echo "port $PORT is busy"; exit 1; fi
env -u DD_OAUTH_ACCESS_TOKEN -u DATADOG_OAUTH_ACCESS_TOKEN DD_SITE=<staging site> QA_NET_LOG="$NET_LOG" \
    NODE_OPTIONS="--import $D/log-requests.mjs" \
    node node_modules/vite/bin/vite.js --mode development --port "$PORT" --strictPort < /dev/null > "$VITE_LOG" 2>&1 &
VPID=$!
echo "vite pid $VPID" >> "$RESP"
for _ in $(seq 1 90); do curl -s -o /dev/null "http://localhost:$PORT/" && break; sleep 1; done
for spec in "$@"; do
  ROUTE=executeAction; TAG=""
  case "$spec" in cloud:*) ROUTE=executeActionViaCloud; TAG="cloud-"; spec="${spec#cloud:}";; esac
  fixture="${spec%%:*}"; fn="${spec#*:}"
  module="$(curl -s "http://localhost:$PORT/src/$fixture.backend.ts")"
  if ! printf %s "$module" | grep -q executeBackendFunction; then
    echo "$fixture: rejected by transform: $(printf %s "$module" | head -c 600)" >> "$RESP"; continue
  fi
  FN="$(printf %s "src/$fixture" | shasum -a 256 | cut -d' ' -f1).$fn"
  echo "=== $ROUTE $fixture.$fn" >> "$RESP"
  curl -s -m 180 -D "$OUT.$TAG$fn.headers" -o "$OUT.$TAG$fn.body" -w 'HTTP %{http_code}\n' -X POST -H 'Content-Type: application/json' \
    -d "{\"functionName\":\"$FN\",\"args\":[]}" "http://localhost:$PORT/__dd/$ROUTE" >> "$RESP"
  cat "$OUT.$TAG$fn.body" >> "$RESP"; echo >> "$RESP"
done
LPID="$(lsof -ti tcp:$PORT -sTCP:LISTEN)"
echo "listener pid $LPID" >> "$RESP"
kill "$VPID" $LPID 2>/dev/null
sleep 3
for p in $VPID $LPID; do if kill -0 "$p" 2>/dev/null; then echo "pid $p still alive" >> "$RESP"; else echo "pid $p stopped" >> "$RESP"; fi; done

// log-requests.mjs, which run.sh preloads to log each Datadog request and long-poll body
// Preloaded with --import: logs method, URL and status of every fetch, plus the request body of
// preview-async POSTs and the response body of every long-poll, to $QA_NET_LOG.
import { appendFileSync } from 'node:fs';

const realFetch = globalThis.fetch;
const log = (line) => appendFileSync(process.env.QA_NET_LOG, line + '\n');
globalThis.fetch = async (input, init) => {
    const url = typeof input === 'string' ? input : input instanceof URL ? input.href : input.url;
    const method = init?.method ?? (typeof input === 'object' && 'method' in input ? input.method : 'GET');
    if (url.includes('preview-async') && typeof init?.body === 'string') {
        try {
            const spec = JSON.parse(init.body).data.attributes.query.properties.spec;
            const shown = spec.inputs?.script ? { ...spec, inputs: { ...spec.inputs, script: '<script>' } } : spec;
            log(`REQ ${method} ${url.split('?')[0]} spec=${JSON.stringify(shown)}`);
        } catch {
            log(`REQ ${method} ${url.split('?')[0]} <unparsed body>`);
        }
    }
    const res = await realFetch(input, init);
    if (url.includes('execution-long-polling')) {
        const text = await res.clone().text();
        log(`RES ${res.status} ${url.split('?')[0].replace(/execution-long-polling\/.*/, 'execution-long-polling/<receipt>')} body=${text.slice(0, 400)}`);
    } else {
        log(`RES ${res.status} ${method} ${url.split('?')[0]}`);
    }
    return res;
};

DD_API_KEY=<staging API key> DD_APP_KEY=<staging app key> bash run.sh ./qa-app 5774 out/after parity:missingConnection parity:missingConnectionTyped parity:noArguments parity:missingInputs parity:fakeConnection parity:unlistedConnection parity:realConnection parityUncaught:uncaughtMissingConnection parityUncaught:uncaughtString uncaughtError:uncaughtError

vite pid 28154
=== executeAction parity.missingConnection
HTTP 200
{"success":true,"result":{"data":{"type":"string","value":"a connection is required for com.datadoghq.github.pulls"}}}
=== executeAction parity.missingConnectionTyped
HTTP 200
{"success":true,"result":{"data":{"type":"string","value":"a connection is required for com.datadoghq.github.pulls"}}}
=== executeAction parity.noArguments
HTTP 200
{"success":true,"result":{"data":{"type":"string","value":"No arguments provided to action $.Actions.github.pulls.list"}}}
=== executeAction parity.missingInputs
HTTP 200
{"success":true,"result":{"data":{"type":"string","value":"First argument to action $.Actions.github.pulls.list must have an inputs field that is an object"}}}
=== executeAction parity.fakeConnection
HTTP 200
{"success":true,"result":{"data":{"type":"string","value":"rpc error: code = NotFound desc = connection not found"}}}
=== executeAction parity.unlistedConnection
HTTP 200
{"success":true,"result":{"data":{"type":"string","value":"Action $.Actions.dd.monitor.listMonitors used connection \"qa-unlisted-connection\", which is not in this function's allowed connections: [00000000-0000-0000-0000-000000000000, <read-only-connection-id>]"}}}
=== executeAction parity.realConnection
HTTP 200
{"success":true,"result":{"data":{"resolved":"object"}}}
=== executeAction parityUncaught.uncaughtMissingConnection
HTTP 500
{"success":false,"error":"Execution failed: a connection is required for com.datadoghq.github.pulls"}
=== executeAction parityUncaught.uncaughtString
HTTP 500
{"success":false,"error":"Execution failed: plain string failure"}
=== executeAction uncaughtError.uncaughtError
HTTP 500
{"success":false,"error":"Execution failed: TypeError: plain error x\n    at uncaughtError (/tmp/qa/qa-app/src/uncaughtError.backend.ts?dd-local-exec:3:11)\n    at file:///tmp/qa/qa-app/node_modules/@datadog/vite-plugin/dist/src/local-execution-child.mjs:1:17287\n    at m (file:///tmp/qa/qa-app/node_modules/@datadog/vite-plugin/dist/src/local-execution-child.mjs:1:701)\n    at Vt (file:///tmp/qa/qa-app/node_modules/@datadog/vite-plugin/dist/src/local-execution-child.mjs:1:17280)\n    at processTicksAndRejections (node:internal/process/task_queues:95:5)\n    at file:///tmp/qa/qa-app/node_modules/@datadog/vite-plugin/dist/src/local-execution-child.mjs:1:15433"}
listener pid 28154
pid 28154 stopped
pid 28154 stopped

• Through executeBackendFunction:

// transport-harness.mjs
// Calls backend functions through the plugin's own packed client runtime, the code app frontends use.
import { createHash } from 'node:crypto';
import { pathToFileURL } from 'node:url';

const [runtimePath, origin, ...specs] = process.argv.slice(2);
const realFetch = globalThis.fetch;
globalThis.fetch = async (url, init) => {
    try {
        return await realFetch(new URL(url, origin), init);
    } catch (error) {
        console.log(JSON.stringify({ fetchFailure: String(error.cause ?? error) }));
        throw error;
    }
};
await import(pathToFileURL(runtimePath).href);
for (const spec of specs) {
    const [fixture, fn] = spec.split(':');
    const name = `${createHash('sha256').update(`src/${fixture}`).digest('hex')}.${fn}`;
    try {
        const data = await globalThis.DD_APPS_RUNTIME.executeBackendFunction(name, []);
        console.log(JSON.stringify({ spec, resolved: data }));
    } catch (error) {
        console.log(JSON.stringify({ spec, name: error.name, message: error.message, statusCode: error.statusCode }));
    }
}

# transport-run.sh
#!/usr/bin/env bash
# Usage (with DD_API_KEY and DD_APP_KEY for a Datadog staging org): transport-run.sh <app-dir> <port> <out-file> <fixture>:<fn> ...
set -u
APP="$1"; PORT="$2"; OUT="$3"; shift 3
D="$(cd "$(dirname "$0")" && pwd)"
cd "$APP" || exit 1
if [ -n "$(lsof -ti tcp:$PORT -sTCP:LISTEN)" ]; then echo "port $PORT is busy"; exit 1; fi
env -u DD_OAUTH_ACCESS_TOKEN -u DATADOG_OAUTH_ACCESS_TOKEN DD_SITE=<staging site> \
    node node_modules/vite/bin/vite.js --mode development --port "$PORT" --strictPort < /dev/null > "$OUT.vite.log" 2>&1 &
VPID=$!
for _ in $(seq 1 90); do curl -s -o /dev/null "http://localhost:$PORT/" && break; sleep 1; done
for spec in "$@"; do curl -s -o /dev/null "http://localhost:$PORT/src/${spec%%:*}.backend.ts"; done
node "$D/transport-harness.mjs" "$APP/node_modules/@datadog/vite-plugin/dist/src/apps-runtime.mjs" "http://localhost:$PORT" "$@" > "$OUT" 2>&1
LPID="$(lsof -ti tcp:$PORT -sTCP:LISTEN)"
kill "$VPID" $LPID 2>/dev/null
sleep 3
for p in $VPID $LPID; do if kill -0 "$p" 2>/dev/null; then echo "pid $p still alive" >> "$OUT"; fi; done

DD_API_KEY=<staging API key> DD_APP_KEY=<staging app key> bash transport-run.sh ./qa-app 5773 out/transport.txt parityUncaught:uncaughtMissingConnection parityUncaught:uncaughtString uncaughtError:uncaughtError parity:realConnection getGreeting:getGreeting

{"spec":"parityUncaught:uncaughtMissingConnection","name":"BackendFunctionError","message":"Execution failed: a connection is required for com.datadoghq.github.pulls","statusCode":500}
{"spec":"parityUncaught:uncaughtString","name":"BackendFunctionError","message":"Execution failed: plain string failure","statusCode":500}
{"spec":"uncaughtError:uncaughtError","name":"BackendFunctionError","message":"Execution failed: TypeError: plain error x\n    at uncaughtError (/tmp/qa/qa-app/src/uncaughtError.backend.ts?dd-local-exec:3:11)\n    at file:///tmp/qa/qa-app/node_modules/@datadog/vite-plugin/dist/src/local-execution-child.mjs:1:17287\n    at m (file:///tmp/qa/qa-app/node_modules/@datadog/vite-plugin/dist/src/local-execution-child.mjs:1:701)\n    at Vt (file:///tmp/qa/qa-app/node_modules/@datadog/vite-plugin/dist/src/local-execution-child.mjs:1:17280)\n    at processTicksAndRejections (node:internal/process/task_queues:95:5)\n    at file:///tmp/qa/qa-app/node_modules/@datadog/vite-plugin/dist/src/local-execution-child.mjs:1:15433","statusCode":500}
{"spec":"parity:realConnection","resolved":{"resolved":"object"}}
{"spec":"getGreeting:getGreeting","resolved":"Hello, undefined! This greeting ran as a backend function."}

Blast Radius

• Local development only.
• Error changes reach every local path, dev:verify included.
• No feature flag. Low risk: a burst of calls starts that many processes.

Out of Scope / Follow-ups

1 item deferred

Item	Status	Next step
The dev server's own lines about a call (timeouts, exits, $.Actions failures) lack its prefix.	Deferred	Add it.

Documentation

• Node.js child processes

🤖 Generated with Claude Code

[github-actions]

Live Debugger Runtime Benchmark

SDK-loaded dormant-probe runtime overhead, measured against an uninstrumented bundle in the same browser session.

Browser	Workload	Quality	Per-call overhead upper
chrome	Hot	clean	<= 2.55 ns
chrome	Tiny	clean	<= 0.02 ns
firefox	Hot	clean	<= 9.77 ns
firefox	Tiny	clean	<= 0.03 ns
safari	Hot	clean	<= 5.44 ns
safari	Tiny	clean	<= 0.39 ns

What do the Tiny and Hot workloads represent?

Browser Debugger SDK: 7.16.2 · built 2026-10-27 · S3 ETag 872de873

Full diagnostics

browser  workload  quality  per-call overhead upper  overhead upper          95% CI        A/A diag        block CI  acf(1)   baseline  instrumented                        samples
-------  --------  -------  -----------------------  --------------  --------------  --------------  --------------  ------  ---------  ------------  -----------------------------
chrome   Hot       clean                 <= 2.55 ns        <= 5.14%   2.52..2.55 ns  -0.02..0.01 ns   2.52..2.55 ns    0.19  52.735 ms     55.428 ms  102 (trim 20%, outliers 4.9%)
chrome   Tiny      clean                 <= 0.02 ns        <= 0.21%  -0.02..0.01 ns  -0.01..0.01 ns  -0.01..0.02 ns   -0.17  56.330 ms     56.387 ms  102 (trim 20%, outliers 7.8%)
firefox  Hot       clean                 <= 9.77 ns       <= 38.80%   9.75..9.77 ns  -0.00..0.01 ns   9.75..9.77 ns   -0.00  39.800 ms     55.240 ms  102 (trim 20%, outliers 6.9%)
firefox  Tiny      clean                 <= 0.03 ns        <= 0.24%   0.02..0.03 ns  -0.01..0.00 ns   0.02..0.03 ns   -0.14  53.750 ms     53.860 ms  102 (trim 20%, outliers 6.9%)
safari   Hot       clean                 <= 5.44 ns       <= 21.74%   5.42..5.44 ns  -0.00..0.01 ns   5.42..5.44 ns    0.07  45.300 ms     55.140 ms  102 (trim 20%, outliers 3.9%)
safari   Tiny      clean                 <= 0.39 ns       <= 10.30%   0.37..0.38 ns  -0.00..0.00 ns   0.37..0.39 ns    0.05  51.420 ms     56.600 ms  102 (trim 20%, outliers 6.9%)

Raw samples are in the live-debugger-runtime-bench-results artifact.

[tyffical]

@codex review

[chatgpt-codex-connector]

Codex Review Summary

This comment shows the latest Codex review activity on this pull request.

Review	Status	Commit	Review trigger
📝 Code Review	✅ Completed 2026-10-22T18:50:01.782740Z	cf49bfa	Manual request

ℹ️ About Codex in GitHub

Your team has set up Codex to review pull requests in this repo. Reviews are triggered when you

• Open a pull request for review
• Mark a draft as ready
• Comment "@codex review" or "@codex security review".

Codex reacts with 👀 while any review is running, comments if it has suggestions, and reacts with 👍 once all reviews finish with no findings.

[chatgpt-codex-connector]

💡 Codex Review

Here are some automated review suggestions for this pull request.

Reviewed commit: 401268c033

ℹ️ About Codex in GitHub

Your team has set up Codex to review pull requests in this repo. Reviews are triggered when you

• Open a pull request for review
• Mark a draft as ready
• Comment "@codex review".

If Codex has suggestions, it will comment; otherwise it will react with 👍.

Codex can also answer questions or update the PR. Try commenting "@codex address that feedback".

[Copilot]

🟢 Approval recommended

No blocking issues were identified in concurrency accounting, query sharing, error handling, logging, or regression coverage.

No open issues 🎉

What changed in this PR

Builds on process isolation to run local backend calls concurrently on Vite 6+, while preserving serial execution for the in-process fallback.

Changes:

• Allows up to 25 concurrent calls, returning HTTP 429 when full.
• Adds per-call log prefixes and shares in-flight runtime-context queries.
• Updates regression tests and local-execution documentation.

File	Description
packages/​plugins/​apps/​src/​vite/​local-execution.ts	Makes the in-process queue helper private.
packages/​plugins/​apps/​src/​vite/​local-execution-process.ts	Adds concurrency limits and per-call log prefixes.
packages/​plugins/​apps/​src/​vite/​local-execution-process.test.ts	Tests parallelism, slot release, isolation, and logging.
packages/​plugins/​apps/​src/​vite/​dev-server.ts	Shares context queries and handles HTTP 429 responses.
packages/​plugins/​apps/​src/​vite/​dev-server.test.ts	Tests query sharing, refresh, and concurrency errors.
packages/​plugins/​apps/​README.md	Documents concurrent execution and prefixed logs.

_{Review effort: Balanced}

[oliverli]

Approved. The change is correct. I added two optional nits.

[tyffical]

@codex review