@glubean/runner 0.1.28 → 0.1.29

package/dist/harness.js

@@ -6,11 +6,10 @@
  *   tsx harness.ts --testUrl=<url> --testId=<id>
  */
 import { parseArgs } from "node:util";
+import { AsyncLocalStorage } from "node:async_hooks";
 import { inferJsonSchema, truncateDeep } from "./schema_inference.js";
 /* eslint-enable no-var */
 import ky from "ky";
-import { classifyHostnameBlockReason, classifyIpBlockReason, isAllowedPort, isAllowedProtocol, isIpLiteral, resolveUrlPort, } from "./network_policy.js";
-import { applyResponseByteBudget } from "./network_budget.js";
 import { Expectation } from "@glubean/sdk/expect";
 // Global error handlers for async errors that escape try/catch
 process.on("uncaughtException", (error) => {
@@ -40,6 +39,7 @@ const { values: args } = parseArgs({
         testIds: { type: "string" },
         exportName: { type: "string" },
         exportNames: { type: "string" },
+        concurrency: { type: "string" },
         emitFullTrace: { type: "boolean", default: false },
         inferSchema: { type: "boolean", default: false },
         truncateArrays: { type: "boolean", default: false },
@@ -60,6 +60,12 @@ const testId = args.testId;
  * module-level state (e.g. shared `let` variables between tests).
  */
 const testIds = args.testIds ? args.testIds.split(",") : undefined;
+/**
+ * Max concurrency for parallel batch mode.
+ * When > 1 and testIds is set, parallel-marked tests run concurrently via p-queue.
+ * Default 1 (sequential).
+ */
+const batchConcurrency = Math.max(1, parseInt(args.concurrency, 10) || 1);
 /** Optional export name for fallback lookup (used by test.pick/test.each). */
 const exportName = args.exportName;
 /** Optional testId→exportName mapping for batch mode fallback (test.pick). */
@@ -118,39 +124,76 @@ function parseRuntimeTestMetadata(input) {
     return { id, tags };
 }
 const runtimeTest = parseRuntimeTestMetadata(contextData.test);
-function parseNetworkPolicy(input) {
-    if (!input || typeof input !== "object")
-        return undefined;
-    const candidate = input;
-    if (candidate.mode !== "shared_serverless")
-        return undefined;
-    const allowedPorts = Array.isArray(candidate.allowedPorts)
-        ? candidate.allowedPorts.filter((p) => typeof p === "number" && Number.isFinite(p) && p > 0 && p <= 65535).map((p) => Math.floor(p))
-        : [];
-    return {
-        mode: "shared_serverless",
-        maxRequests: Number(candidate.maxRequests) > 0 ? Math.floor(Number(candidate.maxRequests)) : 300,
-        maxConcurrentRequests: Number(candidate.maxConcurrentRequests) > 0
-            ? Math.floor(Number(candidate.maxConcurrentRequests))
-            : 20,
-        requestTimeoutMs: Number(candidate.requestTimeoutMs) > 0 ? Math.floor(Number(candidate.requestTimeoutMs)) : 30_000,
-        maxResponseBytes: Number(candidate.maxResponseBytes) > 0
-            ? Math.floor(Number(candidate.maxResponseBytes))
-            : 20 * 1024 * 1024,
-        allowedPorts: allowedPorts.length > 0 ? Array.from(new Set(allowedPorts)) : [80, 443, 8080, 8443],
-    };
-}
-const networkPolicy = parseNetworkPolicy(contextData.networkPolicy);
-// Memory monitoring state
+// Memory monitoring state (per-process — not isolated per-test)
 let peakMemoryBytes = 0;
 let memoryCheckInterval;
-// Step-level assertion tracking.
-// Reset before each step, incremented by ctx.assert on failure.
-let stepFailedAssertions = 0;
-let stepAssertionTotal = 0;
-// Current step index (null when not inside a step).
-// Used to tag log/assertion/trace/metric events with their containing step.
-let currentStepIndex = null;
+// ---------------------------------------------------------------------------
+// Per-test execution context via AsyncLocalStorage
+// ---------------------------------------------------------------------------
+/**
+ * Holds all mutable state scoped to a single test execution.
+ * Accessed via `testContext.getStore()!` from anywhere in the async call chain
+ * (ky hooks, globalFetch override, ctx.assert, etc.) without explicit passing.
+ *
+ * Analogous to Java's ThreadLocal but tracks Node.js async continuations.
+ */
+class TestRunContext {
+    testId;
+    // Step-level assertion tracking
+    stepFailedAssertions = 0;
+    stepAssertionTotal = 0;
+    currentStepIndex = null;
+    // HTTP request counters
+    httpRequestTotal = 0;
+    httpErrorTotal = 0;
+    // Runtime identity
+    testMeta;
+    constructor(testId, meta) {
+        this.testId = testId;
+        this.testMeta = meta;
+    }
+}
+const testContext = new AsyncLocalStorage();
+/**
+ * Get the current test's execution context.
+ * Returns undefined when not inside a test (e.g., module load phase).
+ */
+function currentTestCtx() {
+    return testContext.getStore();
+}
+// Accessor helpers — read from ALS when inside a test, safe defaults otherwise.
+// These replace direct reads of the old global variables.
+function getStepIndex() {
+    return currentTestCtx()?.currentStepIndex ?? null;
+}
+function getStepAssertionTotal() {
+    return currentTestCtx()?.stepAssertionTotal ?? 0;
+}
+function getStepFailedAssertions() {
+    return currentTestCtx()?.stepFailedAssertions ?? 0;
+}
+function incrAssertions(passed) {
+    const trc = currentTestCtx();
+    if (trc) {
+        trc.stepAssertionTotal++;
+        if (!passed)
+            trc.stepFailedAssertions++;
+    }
+}
+/**
+ * Emit a JSON event to stdout, auto-injecting `testId` when inside a test context.
+ * Use this for all test-scoped event output to ensure concurrent events can be
+ * attributed to the correct test.
+ */
+function emitEvent(event) {
+    const trc = currentTestCtx();
+    if (trc) {
+        console.log(JSON.stringify({ ...event, testId: trc.testId }));
+    }
+    else {
+        console.log(JSON.stringify(event));
+    }
+}
 /**
  * Start monitoring memory usage.
  * Samples memory every 100ms and tracks peak usage.
@@ -296,14 +339,14 @@ function runSchemaValidation(data, schema, label, severity) {
         issues = [{ message: "Schema has neither safeParse nor parse method" }];
     }
     // Emit schema_validation event (always, regardless of success/severity)
-    console.log(JSON.stringify({
+    emitEvent({
         type: "schema_validation",
         label,
         success,
         severity,
         ...(issues.length > 0 && { issues }),
-        ...(currentStepIndex !== null && { stepIndex: currentStepIndex }),
-    }));
+        ...(getStepIndex() !== null && { stepIndex: getStepIndex() }),
+    });
     if (!success) {
         const issuesSummary = issues
             .map((i) => {
@@ -379,18 +422,18 @@ const ctx = {
         },
         set: (key, value) => {
             sessionData[key] = value;
-            console.log(JSON.stringify({ type: "session:set", key, value, ts: Date.now() }));
+            emitEvent({ type: "session:set", key, value, ts: Date.now() });
         },
         entries: () => ({ ...sessionData }),
     },
     // Logging function
     log: (message, data) => {
-        console.log(JSON.stringify({
+        emitEvent({
             type: "log",
             message,
             data,
-            ...(currentStepIndex !== null && { stepIndex: currentStepIndex }),
-        }));
+            ...(getStepIndex() !== null && { stepIndex: getStepIndex() }),
+        });
     },
     // Assertion function with overloads
     // Overload 1: assert(condition: boolean, message?: string, details?: AssertionDetails)
@@ -420,19 +463,16 @@ const ctx = {
                 (passed ? "Assertion passed" : "Assertion failed");
         }
         // Track per-step assertion stats (used for step retry logic + step_end event)
-        stepAssertionTotal++;
-        if (!passed) {
-            stepFailedAssertions++;
-        }
-        console.log(JSON.stringify({
+        incrAssertions(passed);
+        emitEvent({
             type: "assertion",
             passed,
             message,
             // Truncate actual/expected on pass to save tokens; keep full on fail for debugging
             actual: passed && truncateArrays ? truncateDeep(actual) : actual,
             expected: passed && truncateArrays ? truncateDeep(expected) : expected,
-            ...(currentStepIndex !== null && { stepIndex: currentStepIndex }),
-        }));
+            ...(getStepIndex() !== null && { stepIndex: getStepIndex() }),
+        });
     },
     // Fluent assertion API (Jest-style, soft-by-default)
     expect: (actual) => {
@@ -448,12 +488,12 @@ const ctx = {
     // Warning function — soft check, never affects test pass/fail.
     // condition=true means OK; condition=false triggers warning.
     warn: (condition, message) => {
-        console.log(JSON.stringify({
+        emitEvent({
             type: "warning",
             condition,
             message,
-            ...(currentStepIndex !== null && { stepIndex: currentStepIndex }),
-        }));
+            ...(getStepIndex() !== null && { stepIndex: getStepIndex() }),
+        });
     },
     // Schema validation function
     validate: (data, schema, label, options) => {
@@ -462,11 +502,11 @@ const ctx = {
     },
     // API tracing function
     trace: (request) => {
-        console.log(JSON.stringify({
+        emitEvent({
             type: "trace",
             data: request,
-            ...(currentStepIndex !== null && { stepIndex: currentStepIndex }),
-        }));
+            ...(getStepIndex() !== null && { stepIndex: getStepIndex() }),
+        });
         // Backward compat: also emit as a typed action for timeline/filtering
         let pathname;
         try {
@@ -485,30 +525,30 @@ const ctx = {
     },
     // Action recording function
     action: (a) => {
-        console.log(JSON.stringify({
+        emitEvent({
             type: "action",
             data: a,
-            ...(currentStepIndex !== null && { stepIndex: currentStepIndex }),
-        }));
+            ...(getStepIndex() !== null && { stepIndex: getStepIndex() }),
+        });
     },
     // Structured event emission
     event: (ev) => {
-        console.log(JSON.stringify({
+        emitEvent({
             type: "event",
             data: ev,
-            ...(currentStepIndex !== null && { stepIndex: currentStepIndex }),
-        }));
+            ...(getStepIndex() !== null && { stepIndex: getStepIndex() }),
+        });
     },
     // Metric reporting function
     metric: (name, value, options) => {
-        console.log(JSON.stringify({
+        emitEvent({
             type: "metric",
             name,
             value,
             unit: options?.unit,
             tags: options?.tags,
-            ...(currentStepIndex !== null && { stepIndex: currentStepIndex }),
-        }));
+            ...(getStepIndex() !== null && { stepIndex: getStepIndex() }),
+        });
     },
     /**
      * Skip the current test with an optional reason.
@@ -525,11 +565,11 @@ const ctx = {
      */
     fail: (message) => {
         // Emit a failed assertion so the failure reason appears in events
-        console.log(JSON.stringify({
+        emitEvent({
             type: "assertion",
             passed: false,
             message,
-        }));
+        });
         throw new FailError(message);
     },
     /**
@@ -570,10 +610,7 @@ const ctx = {
      * @param ms Timeout in milliseconds
      */
     setTimeout: (ms) => {
-        console.log(JSON.stringify({
-            type: "timeout_update",
-            timeout: ms,
-        }));
+        emitEvent({ type: "timeout_update", timeout: ms });
     },
     /**
      * Current execution retry count (0 for first attempt).
@@ -594,17 +631,7 @@ const ctx = {
         return process.memoryUsage();
     },
 };
-// ---------------------------------------------------------------------------
-// Auto-tracing HTTP client (ctx.http) — powered by ky
-// ---------------------------------------------------------------------------
-// Track request start time. We use a simple variable instead of a WeakMap
-// because ky may clone/recreate the Request object between beforeRequest and
-// afterResponse hooks, breaking reference equality in a WeakMap.
-let lastRequestStartTime = 0;
-let httpRequestTotal = 0;
-let httpErrorTotal = 0;
-// Captured in beforeRequest when emitFullTrace is on
-let lastRequestBody = undefined;
+const requestTraceMap = new WeakMap();
 /** Max serialized body size (chars) to include in trace events. */
 const TRACE_BODY_MAX_SIZE = 1_048_576; // 1MB
 /**
@@ -650,187 +677,39 @@ function truncateBody(body) {
  * Reset per-test counters for file-level batch mode.
  * Called before each test when running multiple tests in a single process.
  */
+/**
+ * Reset per-process state between tests in batch mode.
+ * Per-test state is now handled by TestRunContext via AsyncLocalStorage —
+ * each test gets a fresh instance, so no reset is needed for those.
+ */
 function resetTestCounters() {
-    stepFailedAssertions = 0;
-    stepAssertionTotal = 0;
-    currentStepIndex = null;
-    httpRequestTotal = 0;
-    httpErrorTotal = 0;
     peakMemoryBytes = 0;
 }
-const MAX_NETWORK_WARNINGS_PER_CODE = 3;
-const networkWarningCounts = new Map();
-let networkRequestCount = 0;
-let networkInFlightCount = 0;
-let networkResponseBytes = 0;
-function emitNetworkWarning(code, message) {
-    const nextCount = (networkWarningCounts.get(code) ?? 0) + 1;
-    networkWarningCounts.set(code, nextCount);
-    if (nextCount <= MAX_NETWORK_WARNINGS_PER_CODE) {
-        ctx.warn(false, `[network_guard:${code}] ${message}`);
-    }
-    else if (nextCount === MAX_NETWORK_WARNINGS_PER_CODE + 1) {
-        ctx.warn(false, `[network_guard:${code}] further warnings suppressed`);
-    }
-}
-async function resolveHostIps(hostname) {
-    const dns = await import("node:dns/promises");
-    const ips = new Set();
-    try {
-        const aRecords = await dns.resolve4(hostname);
-        for (const ip of aRecords)
-            ips.add(ip);
-    }
-    catch {
-        // Ignore; try AAAA next.
-    }
-    try {
-        const aaaaRecords = await dns.resolve6(hostname);
-        for (const ip of aaaaRecords)
-            ips.add(ip);
-    }
-    catch {
-        // Ignore; caller decides behavior when no records are resolved.
-    }
-    return Array.from(ips);
-}
-function toRequestUrl(input) {
-    if (input instanceof Request)
-        return new URL(input.url);
-    if (input instanceof URL)
-        return input;
-    return new URL(input);
-}
-async function enforceNetworkPolicy(url) {
-    if (!networkPolicy)
-        return;
-    if (!isAllowedProtocol(url.protocol)) {
-        emitNetworkWarning("protocol_blocked", `Blocked protocol ${url.protocol} for ${url.href}`);
-        throw new Error(`Network policy blocked protocol ${url.protocol}. Only http/https are allowed.`);
-    }
-    const port = resolveUrlPort(url);
-    if (!isAllowedPort(port, networkPolicy.allowedPorts)) {
-        emitNetworkWarning("port_blocked", `Blocked port ${port} for ${url.href}`);
-        throw new Error(`Network policy blocked destination port ${port}.`);
-    }
-    const hostname = url.hostname.toLowerCase();
-    const hostnameReason = classifyHostnameBlockReason(hostname);
-    if (hostnameReason) {
-        emitNetworkWarning(hostnameReason, `Blocked hostname ${hostname} for ${url.href}`);
-        throw new Error(`Network policy blocked sensitive hostname ${hostname}.`);
-    }
-    if (isIpLiteral(hostname)) {
-        const ipReason = classifyIpBlockReason(hostname);
-        if (ipReason) {
-            emitNetworkWarning(ipReason, `Blocked destination IP ${hostname} for ${url.href}`);
-            throw new Error(`Network policy blocked destination IP ${hostname}.`);
-        }
-        return;
-    }
-    const resolvedIps = await resolveHostIps(hostname);
-    if (resolvedIps.length === 0) {
-        emitNetworkWarning("dns_resolution_failed", `Could not resolve ${hostname} for ${url.href}`);
-        throw new Error(`Network policy could not resolve host ${hostname}. Request denied.`);
-    }
-    for (const ip of resolvedIps) {
-        const ipReason = classifyIpBlockReason(ip);
-        if (ipReason) {
-            emitNetworkWarning(ipReason, `Blocked resolved IP ${ip} (${hostname}) for ${url.href}`);
-            throw new Error(`Network policy blocked resolved destination ${ip} for host ${hostname}.`);
-        }
-    }
-}
-const originalFetch = globalThis.fetch.bind(globalThis);
-globalThis.fetch = async (input, init) => {
-    if (!networkPolicy) {
-        return originalFetch(input, init);
-    }
-    const requestUrl = toRequestUrl(input);
-    if (networkRequestCount >= networkPolicy.maxRequests) {
-        emitNetworkWarning("request_limit_exceeded", `Request limit exceeded (${networkPolicy.maxRequests})`);
-        throw new Error(`Network policy exceeded max outbound requests (${networkPolicy.maxRequests}).`);
-    }
-    if (networkInFlightCount >= networkPolicy.maxConcurrentRequests) {
-        emitNetworkWarning("concurrency_limit_exceeded", `In-flight request limit exceeded (${networkPolicy.maxConcurrentRequests})`);
-        throw new Error(`Network policy exceeded max concurrent outbound requests (${networkPolicy.maxConcurrentRequests}).`);
-    }
-    // Reserve counters before await to avoid TOCTOU races when user code issues
-    // concurrent requests in a single Promise.all frame.
-    networkRequestCount++;
-    networkInFlightCount++;
-    const timeoutController = new AbortController();
-    let timedOutByPolicy = false;
-    const parentSignal = (() => {
-        if (!init || typeof init !== "object" || !("signal" in init)) {
-            return undefined;
-        }
-        const candidate = init.signal;
-        return candidate instanceof AbortSignal ? candidate : undefined;
-    })();
-    const onParentAbort = () => timeoutController.abort(parentSignal?.reason);
-    if (parentSignal) {
-        if (parentSignal.aborted) {
-            timeoutController.abort(parentSignal.reason);
-        }
-        else {
-            parentSignal.addEventListener("abort", onParentAbort, { once: true });
-        }
-    }
-    const timeoutId = setTimeout(() => {
-        timedOutByPolicy = true;
-        timeoutController.abort(new Error(`Network request timed out after ${networkPolicy.requestTimeoutMs}ms`));
-    }, networkPolicy.requestTimeoutMs);
-    try {
-        await enforceNetworkPolicy(requestUrl);
-        const response = await originalFetch(input, {
-            ...init,
-            signal: timeoutController.signal,
-        });
-        return applyResponseByteBudget(response, {
-            requestUrl,
-            maxResponseBytes: networkPolicy.maxResponseBytes,
-            getUsedResponseBytes: () => networkResponseBytes,
-            addUsedResponseBytes: (delta) => {
-                networkResponseBytes += delta;
-            },
-            emitWarning: emitNetworkWarning,
-        });
-    }
-    catch (error) {
-        if (error instanceof Error && error.name === "AbortError") {
-            if (timedOutByPolicy) {
-                throw new Error(`Network request timed out after ${networkPolicy.requestTimeoutMs}ms`);
-            }
-        }
-        throw error;
-    }
-    finally {
-        clearTimeout(timeoutId);
-        if (parentSignal) {
-            parentSignal.removeEventListener("abort", onParentAbort);
-        }
-        networkInFlightCount = Math.max(0, networkInFlightCount - 1);
-    }
-};
 const kyInstance = ky.create({
     throwHttpErrors: false,
     hooks: {
         beforeRequest: [
             (_request, options) => {
-                lastRequestStartTime = performance.now();
-                if (emitFullTrace) {
-                    // Capture request body from ky options before the request is sent
-                    lastRequestBody = options.json ?? options.body ?? undefined;
-                }
+                requestTraceMap.set(options, {
+                    startTime: performance.now(),
+                    body: emitFullTrace
+                        ? (options.json ?? options.body ?? undefined)
+                        : undefined,
+                });
             },
         ],
         afterResponse: [
             async (request, _options, response) => {
-                const duration = Math.round(performance.now() - lastRequestStartTime);
+                const trace = requestTraceMap.get(_options);
+                const duration = Math.round(performance.now() - (trace?.startTime ?? performance.now()));
                 // Increment HTTP counters for summary
-                httpRequestTotal++;
-                if (response.status >= 400) {
-                    httpErrorTotal++;
+                {
+                    const t = currentTestCtx();
+                    if (t) {
+                        t.httpRequestTotal++;
+                        if (response.status >= 400)
+                            t.httpErrorTotal++;
+                    }
                 }
                 // Build trace data — enriched when emitFullTrace is on
                 const traceData = {
@@ -846,8 +725,8 @@ const kyInstance = ky.create({
                 }
                 if (emitFullTrace) {
                     traceData.requestHeaders = Object.fromEntries(request.headers.entries());
-                    if (lastRequestBody !== undefined) {
-                        traceData.requestBody = truncateBody(lastRequestBody);
+                    if (trace?.body !== undefined) {
+                        traceData.requestBody = truncateBody(trace.body);
                     }
                     traceData.responseHeaders = Object.fromEntries(response.headers.entries());
                     // Clone the response to read the body without consuming the original stream
@@ -880,7 +759,7 @@ const kyInstance = ky.create({
                     catch {
                         // Ignore clone/parse errors — trace still emits without body
                     }
-                    lastRequestBody = undefined;
+                    // Per-request state is on the options object; no global cleanup needed.
                 }
                 ctx.trace(traceData);
                 // Auto-metric for response time
@@ -1028,7 +907,16 @@ globalThis.__glubeanRuntime = {
     vars: withEnvFallback(rawVars),
     secrets: withEnvFallback(rawSecrets),
     http: wrappedHttp,
-    test: runtimeTest,
+    // Getter: returns per-test metadata from ALS when inside a test,
+    // falls back to the initial runtimeTest (module load phase).
+    get test() {
+        return currentTestCtx()?.testMeta ?? runtimeTest;
+    },
+    set test(value) {
+        const trc = currentTestCtx();
+        if (trc)
+            trc.testMeta = value;
+    },
     action: ctx.action,
     event: ctx.event,
     log: ctx.log,
@@ -1058,25 +946,30 @@ try {
             session: ctx.session,
             log: ctx.log,
         };
-        try {
-            if (sessionMode === "setup") {
-                await def.setup(sessionCtx);
+        // Session setup/teardown needs an ALS context so network policy
+        // counters (in globalFetch override) work correctly.
+        const sessionTrc = new TestRunContext("__session__", { id: "__session__", tags: [] });
+        await testContext.run(sessionTrc, async () => {
+            try {
+                if (sessionMode === "setup") {
+                    await def.setup(sessionCtx);
+                }
+                else if (sessionMode === "teardown" && typeof def.teardown === "function") {
+                    await def.teardown(sessionCtx);
+                }
+                emitEvent({ type: "status", status: "completed" });
             }
-            else if (sessionMode === "teardown" && typeof def.teardown === "function") {
-                await def.teardown(sessionCtx);
+            catch (err) {
+                const message = err instanceof Error ? err.message : String(err);
+                const stack = err instanceof Error ? err.stack : undefined;
+                emitEvent({
+                    type: "status",
+                    status: "failed",
+                    error: message,
+                    ...(stack && { stack }),
+                });
             }
-            console.log(JSON.stringify({ type: "status", status: "completed" }));
-        }
-        catch (err) {
-            const message = err instanceof Error ? err.message : String(err);
-            const stack = err instanceof Error ? err.stack : undefined;
-            console.log(JSON.stringify({
-                type: "status",
-                status: "failed",
-                error: message,
-                ...(stack && { stack }),
-            }));
-        }
+        });
         process.exit(0);
     }
     // ── Normal test mode: testId or testIds required ──
@@ -1089,56 +982,51 @@ try {
     }
     if (testIds) {
         // ── File-level batch mode ──
-        // Run multiple tests sequentially in a single process.
-        // Module-level state (let variables) is preserved between tests.
+        // Runs multiple tests in a single process, preserving module-level state.
+        // When batchConcurrency > 1, tests run concurrently via p-queue
+        // (opt-in via test.each({ parallel: true }) + --concurrency flag).
         let hasFailure = false;
-        for (const id of testIds) {
+        const runOneTest = async (id) => {
             resetTestCounters();
             let testObj = findTestById(userModule, id);
-            // Fallback for non-deterministic tests (test.pick): the testId from
-            // discovery may differ from this run's random selection. Use the stable
-            // exportName to locate the test.
             if (!testObj && exportNamesMap[id]) {
                 testObj = findTestByExport(userModule, exportNamesMap[id]);
             }
             if (!testObj) {
-                console.log(JSON.stringify({
-                    type: "start",
-                    id,
-                    name: id,
-                }));
-                console.log(JSON.stringify({
-                    type: "status",
-                    status: "failed",
-                    id,
-                    error: `Test "${id}" not found in module`,
-                }));
+                console.log(JSON.stringify({ type: "start", id, name: id, testId: id }));
+                console.log(JSON.stringify({ type: "status", status: "failed", id, testId: id, error: `Test "${id}" not found in module` }));
                 hasFailure = true;
-                continue;
+                return;
             }
             try {
                 await executeNewTest(testObj);
             }
             catch (error) {
                 if (error instanceof SkipError) {
-                    console.log(JSON.stringify({
-                        type: "status",
-                        status: "skipped",
-                        id,
-                        reason: error.reason,
-                    }));
+                    console.log(JSON.stringify({ type: "status", status: "skipped", id, testId: id, reason: error.reason }));
                 }
                 else {
                     hasFailure = true;
                     console.log(JSON.stringify({
-                        type: "status",
-                        status: "failed",
-                        id,
+                        type: "status", status: "failed", id, testId: id,
                         error: error instanceof Error ? error.message : String(error),
                         stack: error instanceof Error ? error.stack : undefined,
                     }));
                 }
             }
+        };
+        if (batchConcurrency > 1) {
+            const { default: PQueue } = await import("p-queue");
+            const queue = new PQueue({ concurrency: batchConcurrency });
+            for (const id of testIds) {
+                void queue.add(() => runOneTest(id));
+            }
+            await queue.onIdle();
+        }
+        else {
+            for (const id of testIds) {
+                await runOneTest(id);
+            }
         }
         process.exit(hasFailure ? 1 : 0);
     }
@@ -1159,11 +1047,11 @@ try {
             }
             catch (error) {
                 if (error instanceof SkipError) {
-                    console.log(JSON.stringify({ type: "status", status: "skipped", id: resolved.id, reason: error.reason }));
+                    console.log(JSON.stringify({ type: "status", status: "skipped", id: resolved.id, testId: resolved.id, reason: error.reason }));
                 }
                 else {
                     hasFailure = true;
-                    console.log(JSON.stringify({ type: "status", status: "failed", id: resolved.id, error: error instanceof Error ? error.message : String(error), stack: error instanceof Error ? error.stack : undefined }));
+                    console.log(JSON.stringify({ type: "status", status: "failed", id: resolved.id, testId: resolved.id, error: error instanceof Error ? error.message : String(error), stack: error instanceof Error ? error.stack : undefined }));
                 }
             }
         }
@@ -1185,11 +1073,14 @@ try {
     }
 }
 catch (error) {
+    // Include testId when known (single test mode)
+    const tid = testId && testId !== "*" ? testId : undefined;
     // Check if this is a skip error
     if (error instanceof SkipError) {
         console.log(JSON.stringify({
             type: "status",
             status: "skipped",
+            ...(tid && { testId: tid }),
             reason: error.reason,
         }));
         process.exit(0); // Exit cleanly for skipped tests
@@ -1198,6 +1089,7 @@ catch (error) {
     console.log(JSON.stringify({
         type: "status",
         status: "failed",
+        ...(tid && { testId: tid }),
         error: error instanceof Error ? error.message : String(error),
         stack: error instanceof Error ? error.stack : undefined,
     }));
@@ -1274,222 +1166,231 @@ async function withFixtures(fixtures, baseCtx, runTest) {
  */
 async function executeNewTest(test) {
     const testTags = normalizeTestTags(test.meta.tags);
-    // Keep runtime metadata aligned with the actual resolved test before user code runs.
-    globalThis.__glubeanRuntime.test = {
-        id: test.meta.id,
-        tags: testTags,
-    };
-    console.log(JSON.stringify({
-        type: "start",
-        id: test.meta.id,
-        name: test.meta.name || test.meta.id,
-        tags: testTags,
-        ...(retryCount > 0 && { retryCount }),
-    }));
-    // Start memory monitoring
-    startMemoryMonitoring();
-    try {
-        // Core test body — receives the effective ctx (base or fixture-augmented)
-        const runTestBody = async (effectiveCtx) => {
-            if (test.type === "simple") {
-                if (!test.fn) {
-                    throw new Error(`Invalid test "${test.meta.id}": missing fn`);
-                }
-                await test.fn(effectiveCtx);
-            }
-            else {
-                let state = undefined;
-                let stepFailed = false;
-                try {
-                    if (test.setup) {
-                        console.log(JSON.stringify({
-                            type: "log",
-                            message: "Running setup...",
-                        }));
-                        state = await test.setup(effectiveCtx);
+    const testMeta = { id: test.meta.id, tags: testTags };
+    const trc = new TestRunContext(test.meta.id, testMeta);
+    // Run the test body inside an AsyncLocalStorage context so all
+    // downstream code (ctx.assert, ky hooks, globalFetch) can access
+    // the per-test state via currentTestCtx().
+    await testContext.run(trc, async () => {
+        // Runtime metadata is now served via ALS getter on __glubeanRuntime.test
+        emitEvent({
+            type: "start",
+            id: test.meta.id,
+            name: test.meta.name || test.meta.id,
+            tags: testTags,
+            ...(retryCount > 0 && { retryCount }),
+        });
+        // Start memory monitoring
+        startMemoryMonitoring();
+        try {
+            // Core test body — receives the effective ctx (base or fixture-augmented)
+            const runTestBody = async (effectiveCtx) => {
+                if (test.type === "simple") {
+                    if (!test.fn) {
+                        throw new Error(`Invalid test "${test.meta.id}": missing fn`);
                     }
-                    if (test.steps) {
-                        for (let i = 0; i < test.steps.length; i++) {
-                            const step = test.steps[i];
-                            // If a previous step failed, skip remaining steps
-                            if (stepFailed) {
-                                console.log(JSON.stringify({
-                                    type: "step_end",
+                    await test.fn(effectiveCtx);
+                }
+                else {
+                    let state = undefined;
+                    let stepFailed = false;
+                    try {
+                        if (test.setup) {
+                            emitEvent({
+                                type: "log",
+                                message: "Running setup...",
+                            });
+                            state = await test.setup(effectiveCtx);
+                        }
+                        if (test.steps) {
+                            for (let i = 0; i < test.steps.length; i++) {
+                                const step = test.steps[i];
+                                // If a previous step failed, skip remaining steps
+                                if (stepFailed) {
+                                    emitEvent({
+                                        type: "step_end",
+                                        index: i,
+                                        name: step.meta.name,
+                                        status: "skipped",
+                                        durationMs: 0,
+                                        assertions: 0,
+                                        failedAssertions: 0,
+                                    });
+                                    continue;
+                                }
+                                // Reset per-step assertion counters and set step scope
+                                {
+                                    const trc = currentTestCtx();
+                                    trc.stepFailedAssertions = 0;
+                                    trc.stepAssertionTotal = 0;
+                                    trc.currentStepIndex = i;
+                                }
+                                const stepStart = performance.now();
+                                emitEvent({
+                                    type: "step_start",
                                     index: i,
                                     name: step.meta.name,
-                                    status: "skipped",
-                                    durationMs: 0,
-                                    assertions: 0,
-                                    failedAssertions: 0,
-                                }));
-                                continue;
-                            }
-                            // Reset per-step assertion counters and set step scope
-                            stepFailedAssertions = 0;
-                            stepAssertionTotal = 0;
-                            currentStepIndex = i;
-                            const stepStart = performance.now();
-                            console.log(JSON.stringify({
-                                type: "step_start",
-                                index: i,
-                                name: step.meta.name,
-                                total: test.steps.length,
-                            }));
-                            let stepError;
-                            let stepReturnState = undefined;
-                            const retries = step.meta.retries;
-                            const configuredRetries = typeof retries === "number" && Number.isFinite(retries)
-                                ? Math.max(0, Math.floor(retries))
-                                : 0;
-                            const stepTimeout = step.meta.timeout;
-                            const configuredStepTimeout = typeof stepTimeout === "number" && Number.isFinite(stepTimeout)
-                                ? Math.floor(stepTimeout)
-                                : 0;
-                            const stepTimeoutMs = configuredStepTimeout > 0 ? configuredStepTimeout : undefined;
-                            const maxAttempts = configuredRetries + 1;
-                            let attemptsUsed = 0;
-                            let lastFailedAssertions = 0;
-                            let lastAssertions = 0;
-                            let timeoutFailure = false;
-                            for (let attempt = 1; attempt <= maxAttempts; attempt++) {
-                                attemptsUsed = attempt;
-                                stepError = undefined;
-                                stepReturnState = undefined;
-                                stepFailedAssertions = 0;
-                                stepAssertionTotal = 0;
-                                timeoutFailure = false;
-                                let stepTimeoutId;
-                                try {
-                                    const stepResult = step.fn(effectiveCtx, state);
-                                    // Note: timed-out step bodies cannot be force-cancelled in JS.
-                                    // We treat timeout as terminal (no further retries) to avoid
-                                    // overlapping attempts mutating shared step context.
-                                    const result = stepTimeoutMs === undefined ? await stepResult : await Promise.race([
-                                        stepResult,
-                                        new Promise((_, reject) => {
-                                            stepTimeoutId = setTimeout(() => {
-                                                reject(new StepTimeoutError(step.meta.name, stepTimeoutMs));
-                                            }, stepTimeoutMs);
-                                        }),
-                                    ]);
-                                    if (result !== undefined) {
-                                        state = result;
-                                        stepReturnState = result;
+                                    total: test.steps.length,
+                                });
+                                let stepError;
+                                let stepReturnState = undefined;
+                                const retries = step.meta.retries;
+                                const configuredRetries = typeof retries === "number" && Number.isFinite(retries)
+                                    ? Math.max(0, Math.floor(retries))
+                                    : 0;
+                                const stepTimeout = step.meta.timeout;
+                                const configuredStepTimeout = typeof stepTimeout === "number" && Number.isFinite(stepTimeout)
+                                    ? Math.floor(stepTimeout)
+                                    : 0;
+                                const stepTimeoutMs = configuredStepTimeout > 0 ? configuredStepTimeout : undefined;
+                                const maxAttempts = configuredRetries + 1;
+                                let attemptsUsed = 0;
+                                let lastFailedAssertions = 0;
+                                let lastAssertions = 0;
+                                let timeoutFailure = false;
+                                for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+                                    attemptsUsed = attempt;
+                                    stepError = undefined;
+                                    stepReturnState = undefined;
+                                    {
+                                        const trc = currentTestCtx();
+                                        trc.stepFailedAssertions = 0;
+                                        trc.stepAssertionTotal = 0;
                                     }
-                                }
-                                catch (err) {
-                                    stepError = err instanceof Error ? err.message : String(err);
-                                    timeoutFailure = err instanceof StepTimeoutError;
-                                }
-                                finally {
-                                    if (stepTimeoutId !== undefined) {
-                                        clearTimeout(stepTimeoutId);
+                                    timeoutFailure = false;
+                                    let stepTimeoutId;
+                                    try {
+                                        const stepResult = step.fn(effectiveCtx, state);
+                                        // Note: timed-out step bodies cannot be force-cancelled in JS.
+                                        // We treat timeout as terminal (no further retries) to avoid
+                                        // overlapping attempts mutating shared step context.
+                                        const result = stepTimeoutMs === undefined ? await stepResult : await Promise.race([
+                                            stepResult,
+                                            new Promise((_, reject) => {
+                                                stepTimeoutId = setTimeout(() => {
+                                                    reject(new StepTimeoutError(step.meta.name, stepTimeoutMs));
+                                                }, stepTimeoutMs);
+                                            }),
+                                        ]);
+                                        if (result !== undefined) {
+                                            state = result;
+                                            stepReturnState = result;
+                                        }
+                                    }
+                                    catch (err) {
+                                        stepError = err instanceof Error ? err.message : String(err);
+                                        timeoutFailure = err instanceof StepTimeoutError;
+                                    }
+                                    finally {
+                                        if (stepTimeoutId !== undefined) {
+                                            clearTimeout(stepTimeoutId);
+                                        }
+                                    }
+                                    lastFailedAssertions = getStepFailedAssertions();
+                                    lastAssertions = getStepAssertionTotal();
+                                    const attemptFailed = !!stepError || getStepFailedAssertions() > 0;
+                                    if (!attemptFailed) {
+                                        break;
+                                    }
+                                    // Timeouts are terminal to avoid overlapping attempts from
+                                    // dangling async operations in the timed-out step body.
+                                    if (timeoutFailure) {
+                                        break;
+                                    }
+                                    if (attempt < maxAttempts) {
+                                        const reason = stepError ? stepError : `${getStepFailedAssertions()} failed assertion(s)`;
+                                        emitEvent({
+                                            type: "log",
+                                            stepIndex: i,
+                                            message: `Retrying step "${step.meta.name}" (${attempt + 1}/${maxAttempts}) after failure: ${reason}`,
+                                        });
                                     }
                                 }
-                                lastFailedAssertions = stepFailedAssertions;
-                                lastAssertions = stepAssertionTotal;
-                                const attemptFailed = !!stepError || stepFailedAssertions > 0;
-                                if (!attemptFailed) {
-                                    break;
-                                }
-                                // Timeouts are terminal to avoid overlapping attempts from
-                                // dangling async operations in the timed-out step body.
-                                if (timeoutFailure) {
-                                    break;
-                                }
-                                if (attempt < maxAttempts) {
-                                    const reason = stepError ? stepError : `${stepFailedAssertions} failed assertion(s)`;
-                                    console.log(JSON.stringify({
-                                        type: "log",
-                                        stepIndex: i,
-                                        message: `Retrying step "${step.meta.name}" (${attempt + 1}/${maxAttempts}) after failure: ${reason}`,
-                                    }));
-                                }
-                            }
-                            const durationMs = Math.round(performance.now() - stepStart);
-                            const failed = !!stepError || lastFailedAssertions > 0;
-                            // Serialize return state with size guard (max 4 KB)
-                            let returnStatePayload = undefined;
-                            if (stepReturnState !== undefined) {
-                                try {
-                                    const serialized = JSON.stringify(stepReturnState);
-                                    if (serialized.length <= 4096) {
-                                        returnStatePayload = stepReturnState;
+                                const durationMs = Math.round(performance.now() - stepStart);
+                                const failed = !!stepError || lastFailedAssertions > 0;
+                                // Serialize return state with size guard (max 4 KB)
+                                let returnStatePayload = undefined;
+                                if (stepReturnState !== undefined) {
+                                    try {
+                                        const serialized = JSON.stringify(stepReturnState);
+                                        if (serialized.length <= 4096) {
+                                            returnStatePayload = stepReturnState;
+                                        }
+                                        else {
+                                            returnStatePayload = `[truncated: ${serialized.length} bytes]`;
+                                        }
                                     }
-                                    else {
-                                        returnStatePayload = `[truncated: ${serialized.length} bytes]`;
+                                    catch {
+                                        returnStatePayload = "[non-serializable]";
                                     }
                                 }
-                                catch {
-                                    returnStatePayload = "[non-serializable]";
+                                emitEvent({
+                                    type: "step_end",
+                                    index: i,
+                                    name: step.meta.name,
+                                    status: failed ? "failed" : "passed",
+                                    durationMs,
+                                    assertions: lastAssertions,
+                                    failedAssertions: lastFailedAssertions,
+                                    attempts: attemptsUsed,
+                                    retriesUsed: Math.max(0, attemptsUsed - 1),
+                                    ...(stepError && { error: stepError }),
+                                    ...(returnStatePayload !== undefined && {
+                                        returnState: returnStatePayload,
+                                    }),
+                                });
+                                currentTestCtx().currentStepIndex = null;
+                                if (failed) {
+                                    stepFailed = true;
+                                    // Don't throw here — let the loop continue to emit skip events
                                 }
                             }
-                            console.log(JSON.stringify({
-                                type: "step_end",
-                                index: i,
-                                name: step.meta.name,
-                                status: failed ? "failed" : "passed",
-                                durationMs,
-                                assertions: lastAssertions,
-                                failedAssertions: lastFailedAssertions,
-                                attempts: attemptsUsed,
-                                retriesUsed: Math.max(0, attemptsUsed - 1),
-                                ...(stepError && { error: stepError }),
-                                ...(returnStatePayload !== undefined && {
-                                    returnState: returnStatePayload,
-                                }),
-                            }));
-                            currentStepIndex = null;
-                            if (failed) {
-                                stepFailed = true;
-                                // Don't throw here — let the loop continue to emit skip events
-                            }
                         }
                     }
-                }
-                finally {
-                    if (test.teardown) {
-                        try {
-                            console.log(JSON.stringify({
-                                type: "log",
-                                message: "Running teardown...",
-                            }));
-                            await test.teardown(effectiveCtx, state);
-                        }
-                        catch (teardownError) {
-                            console.log(JSON.stringify({
-                                type: "log",
-                                message: `Teardown error: ${teardownError instanceof Error ? teardownError.message : String(teardownError)}`,
-                            }));
+                    finally {
+                        if (test.teardown) {
+                            try {
+                                emitEvent({
+                                    type: "log",
+                                    message: "Running teardown...",
+                                });
+                                await test.teardown(effectiveCtx, state);
+                            }
+                            catch (teardownError) {
+                                emitEvent({
+                                    type: "log",
+                                    message: `Teardown error: ${teardownError instanceof Error ? teardownError.message : String(teardownError)}`,
+                                });
+                            }
                         }
                     }
+                    // If any step failed (assertion or throw), mark overall test as failed
+                    if (stepFailed) {
+                        throw new Error("One or more steps failed");
+                    }
                 }
-                // If any step failed (assertion or throw), mark overall test as failed
-                if (stepFailed) {
-                    throw new Error("One or more steps failed");
-                }
+            };
+            // Resolve test.extend() fixtures (if any) and run the test body
+            if (test.fixtures && Object.keys(test.fixtures).length > 0) {
+                await withFixtures(test.fixtures, ctx, runTestBody);
             }
-        };
-        // Resolve test.extend() fixtures (if any) and run the test body
-        if (test.fixtures && Object.keys(test.fixtures).length > 0) {
-            await withFixtures(test.fixtures, ctx, runTestBody);
+            else {
+                await runTestBody(ctx);
+            }
+            // Stop monitoring and get peak memory
+            const peakBytes = stopMemoryMonitoring();
+            emitEvent({
+                type: "status",
+                status: "completed",
+                id: test.meta.id,
+                peakMemoryBytes: peakBytes,
+                peakMemoryMB: (peakBytes / 1024 / 1024).toFixed(2),
+            });
         }
-        else {
-            await runTestBody(ctx);
+        catch (error) {
+            stopMemoryMonitoring();
+            throw error;
         }
-        // Stop monitoring and get peak memory
-        const peakBytes = stopMemoryMonitoring();
-        console.log(JSON.stringify({
-            type: "status",
-            status: "completed",
-            id: test.meta.id,
-            peakMemoryBytes: peakBytes,
-            peakMemoryMB: (peakBytes / 1024 / 1024).toFixed(2),
-        }));
-    }
-    catch (error) {
-        stopMemoryMonitoring();
-        throw error;
-    }
+    }); // end testContext.run()
 }
 //# sourceMappingURL=harness.js.map