@glubean/runner 0.5.0 → 0.8.0

package/dist/harness.js

@@ -8,9 +8,17 @@
 import { parseArgs } from "node:util";
 import { AsyncLocalStorage } from "node:async_hooks";
 import { inferJsonSchema, truncateDeep } from "./schema_inference.js";
+import { USE_ENGINE, createEngineCore, runViaEngine, engineRoutesId } from "./engine-bridge.js";
 import { bootstrap } from "./bootstrap.js";
 import { loadProjectOverlays } from "@glubean/scanner";
 import { setRuntime, setExplicitInput, setBootstrapInput, setForceStandalone, } from "@glubean/sdk/internal";
+// Workflow executor — now node-only and owned by this package (plan 0007). The host
+// drives a built workflow via runWorkflow (invocation inversion) and attributes inline
+// ctx.http traces to the active node scope via __activeWorkflowNodeCtx (the ALS rebind).
+import { runWorkflow, WorkflowPhaseFailedError, __activeWorkflowNodeCtx, } from "./workflow/execute.js";
+// workflow per-node evidence → first-class timeline events; co-located with the
+// executor that emits those events (plan 0007), not in this generic harness.
+import { workflowEventToTimeline } from "./workflow/event-timeline.js";
 import ky from "ky";
 import { isTestBranchStep, isTestPollStep } from "@glubean/sdk";
 import { Expectation } from "@glubean/sdk/expect";
@@ -189,14 +197,57 @@ function incrAssertions(passed) {
  * Use this for all test-scoped event output to ensure concurrent events can be
  * attributed to the correct test.
  */
+/** Events that STEER THE PARENT while the test is still running — the
+ * executor re-arms the subprocess timeout on `timeout_update`, and
+ * ProjectRunner forwards `session:set` to sibling files. Holding them in the
+ * parallel buffer until the test finishes would defeat them (a long test
+ * would be killed at the OLD deadline — codex S2.12 R24 P2), so they bypass
+ * buffering. Out-of-order arrival is fine: both are keyed/merged by the
+ * parent, not attributed to a contiguous test block. */
+const CONTROL_EVENT_TYPES = new Set(["timeout_update", "session:set"]);
 function emitEvent(event) {
     const trc = currentTestCtx();
-    if (trc) {
-        console.log(JSON.stringify({ ...event, testId: trc.testId }));
+    const json = JSON.stringify(trc ? { ...event, testId: trc.testId } : event);
+    if (CONTROL_EVENT_TYPES.has(event.type)) {
+        console.log(json);
+        return;
     }
-    else {
-        console.log(JSON.stringify(event));
+    writeEventLine(json);
+}
+// ── Parallel-batch event buffering (codex S2.12 R22 P1) ─────────────────────
+// Under batchConcurrency > 1, tests run concurrently and their stdout events
+// would interleave — downstream collectors (CLI render, result JSON) keep
+// per-test state that assumes each test's start..status block is CONTIGUOUS.
+// Each parallel task runs inside this ALS with its own line buffer; the task
+// flushes the whole buffer atomically (sync loop — no awaits) when it
+// finishes. Sequential runs never enter the ALS: zero behavior change.
+const parallelEventBuffer = new AsyncLocalStorage();
+function writeEventLine(json) {
+    const buf = parallelEventBuffer.getStore();
+    if (buf)
+        buf.push(json);
+    else
+        console.log(json);
+}
+/**
+ * Write a wire event produced by the engine path (runner-on-engine, plan 0005).
+ * Mirrors emitEvent's control-event bypass, but the event already carries its
+ * testId (the engine path runs outside the testContext ALS, so testId is sourced
+ * from the engine event's own id, not currentTestCtx()).
+ */
+function emitEngineWire(ev) {
+    // Mirror the legacy ctx.session.set: update the subprocess-local sessionData so
+    // sibling tests in this process see it (batch mode), in addition to forwarding
+    // the control event to the parent (codex P2).
+    if (ev.type === "session:set") {
+        sessionData[ev.key] = ev.value;
+    }
+    const json = JSON.stringify(ev);
+    if (CONTROL_EVENT_TYPES.has(ev.type)) {
+        console.log(json);
+        return;
     }
+    writeEventLine(json);
 }
 /**
  * Start monitoring memory usage.
@@ -552,8 +603,18 @@ const ctx = {
             ...(getStepIndex() !== null && { stepIndex: getStepIndex() }),
         });
     },
-    // Structured event emission
+    // Structured event emission. The vNext workflow executor's per-node
+    // evidence (§17 #9) rides this channel as namespaced GlubeanEvents — the
+    // harness UNWRAPS the three known types into first-class timeline events
+    // (node id + grade reach generateSummary / the Cloud payload directly,
+    // not as a double-wrapped custom blob). Any other type — including other
+    // `workflow:*` names — stays a generic pass-through event.
     event: (ev) => {
+        const firstClass = workflowEventToTimeline(ev);
+        if (firstClass) {
+            emitEvent(firstClass);
+            return;
+        }
         emitEvent({
             type: "event",
             data: ev,
@@ -657,6 +718,24 @@ const ctx = {
     },
 };
 const requestTraceMap = new WeakMap();
+// Capture the outgoing request body for full-trace mode. ky 2 no longer exposes
+// `options.json`, so read it off a clone of the Request (parsed if JSON).
+async function captureRequestBody(request) {
+    try {
+        const text = await request.clone().text();
+        if (!text)
+            return undefined;
+        try {
+            return JSON.parse(text);
+        }
+        catch {
+            return text;
+        }
+    }
+    catch {
+        return undefined;
+    }
+}
 /** Max serialized body size (chars) to include in trace events. */
 const TRACE_BODY_MAX_SIZE = 1_048_576; // 1MB
 /**
@@ -722,18 +801,18 @@ const kyInstance = ky.create({
     retry: 0,
     hooks: {
         beforeRequest: [
-            (_request, options) => {
-                requestTraceMap.set(options, {
+            async ({ request, options }) => {
+                requestTraceMap.set(options.context, {
                     startTime: performance.now(),
-                    body: emitFullTrace
-                        ? (options.json ?? options.body ?? undefined)
-                        : undefined,
+                    body: emitFullTrace ? await captureRequestBody(request) : undefined,
                 });
             },
         ],
         afterResponse: [
-            async (request, _options, response) => {
-                const trace = requestTraceMap.get(_options);
+            async ({ request, options, response }) => {
+                // `request` here is the final (possibly hook-replaced) request — correct
+                // for the trace target; the trace state is keyed by the stable context.
+                const trace = requestTraceMap.get(options.context);
                 const duration = Math.round(performance.now() - (trace?.startTime ?? performance.now()));
                 // Increment HTTP counters for summary
                 {
@@ -807,17 +886,22 @@ const kyInstance = ky.create({
                     }
                     // Per-request state is on the options object; no global cleanup needed.
                 }
-                ctx.trace(traceData);
+                // Attribute to the active workflow node's scope when one is executing
+                // (the SDK's ctx.http rebind, §17 #10/#12): inline HTTP inside a
+                // workflow node promotes its grade and obeys the late-evidence
+                // quarantine. Outside a workflow node this is the closure ctx as ever.
+                const sink = __activeWorkflowNodeCtx() ?? ctx;
+                sink.trace(traceData);
                 // Auto-metric for response time
                 try {
                     const pathname = new URL(request.url).pathname;
-                    ctx.metric("http_duration_ms", duration, {
+                    sink.metric("http_duration_ms", duration, {
                         unit: "ms",
                         tags: { method: request.method, path: pathname },
                     });
                 }
                 catch {
-                    ctx.metric("http_duration_ms", duration, {
+                    sink.metric("http_duration_ms", duration, {
                         unit: "ms",
                         tags: { method: request.method },
                     });
@@ -844,6 +928,13 @@ function normalizeOptions(options) {
     if (!options)
         return options;
     const normalized = { ...options };
+    // ky 2 renamed `prefixUrl` → `prefix` (with the same join semantics we rely on
+    // for "users" / "/users"). Glubean keeps `prefixUrl` as its public option and
+    // translates here at the ky boundary (codex ky2 P2-5; not `baseUrl`).
+    if (normalized.prefixUrl !== undefined) {
+        normalized.prefix = normalized.prefixUrl;
+        delete normalized.prefixUrl;
+    }
     // Remove empty searchParams so ky doesn't append a bare '?'
     if (normalized.searchParams != null) {
         if (normalized.searchParams instanceof URLSearchParams) {
@@ -947,7 +1038,7 @@ function wrapKy(instance, label = "base") {
         const responseHeadersSchema = normalized?.schema?.responseHeaders;
         if (responseHeadersSchema) {
             const { schema, severity } = resolveSchemaEntry(responseHeadersSchema);
-            const headersHook = (_req, _opts, response) => {
+            const headersHook = ({ response }) => {
                 const headersObj = normalizeHeadersForValidation(response.headers);
                 runSchemaValidation(headersObj, schema, "response headers", severity);
             };
@@ -1007,6 +1098,28 @@ function withEnvFallback(explicit) {
         },
     });
 }
+// runner-on-engine (plan 0005): when GLUBEAN_USE_ENGINE=1 the engine drives the
+// run-loop (executeNewTest delegates to RunnerCore). Construct it BEFORE
+// setRuntime so RunnerCore's ALS carrier is the one the SDK runtime fallback gets
+// set on — module-load configure() and the engine's runWithRuntime() then share a
+// single carrier (plan 0005 §接缝设计 / codex P1-5). Default OFF → no behavior change.
+const engineCore = USE_ENGINE
+    ? createEngineCore(emitEngineWire, {
+        // Pass the SAME fallback Proxies the legacy ctx/runtime use (.env →
+        // process.env), so engine-mode ctx.vars/secrets keep the system-env fallback
+        // (codex P2 / plan 0005 §E). The engine layers per-run input over these
+        // without destroying the Proxy.
+        vars: withEnvFallback(rawVars),
+        secrets: withEnvFallback(rawSecrets),
+        // RAW vars (un-proxied) so ctx.vars.all() returns {...rawVars} exactly — legacy
+        // parity for empty/overlay vars (codex Phase-8 P2).
+        varsRaw: rawVars,
+        // Forward the trace policy so the engine's ky auto-trace capture matches legacy.
+        emitFullTrace: !!emitFullTrace,
+        inferSchema: !!inferSchema,
+        truncateArrays: !!truncateArrays,
+    })
+    : undefined;
 setRuntime({
     vars: withEnvFallback(rawVars),
     secrets: withEnvFallback(rawSecrets),
@@ -1269,8 +1382,8 @@ try {
                 testObj = findTestByExport(userModule, exportNamesMap[id]);
             }
             if (!testObj) {
-                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` }));
+                writeEventLine(JSON.stringify({ type: "start", id, name: id, testId: id }));
+                writeEventLine(JSON.stringify({ type: "status", status: "failed", id, testId: id, error: `Test "${id}" not found in module` }));
                 hasFailure = true;
                 return;
             }
@@ -1279,12 +1392,12 @@ try {
             }
             catch (error) {
                 if (error instanceof SkipError) {
-                    console.log(JSON.stringify({ type: "status", status: "skipped", id, testId: id, reason: error.reason }));
+                    writeEventLine(JSON.stringify({ type: "status", status: "skipped", id, testId: id, reason: error.reason }));
                 }
                 else {
                     hasFailure = true;
                     const reason = classifyErrorReason(error);
-                    console.log(JSON.stringify({
+                    writeEventLine(JSON.stringify({
                         type: "status", status: "failed", id, testId: id,
                         error: error instanceof Error ? error.message : String(error),
                         stack: error instanceof Error ? error.stack : undefined,
@@ -1334,7 +1447,20 @@ try {
             const { default: PQueue } = await import("p-queue");
             const queue = new PQueue({ concurrency: batchConcurrency });
             for (const id of expandedIds) {
-                void queue.add(() => runOneTest(id));
+                void queue.add(() => {
+                    const buf = [];
+                    return parallelEventBuffer.run(buf, async () => {
+                        try {
+                            await runOneTest(id);
+                        }
+                        finally {
+                            // Atomic flush: the loop is synchronous, so this test's whole
+                            // event block lands contiguously on stdout.
+                            for (const line of buf)
+                                console.log(line);
+                        }
+                    });
+                });
             }
             await queue.onIdle();
         }
@@ -1483,7 +1609,96 @@ async function withFixtures(fixtures, baseCtx, runTest) {
  *
  * @param test The Test object to execute
  */
+/**
+ * Structural gate for the engine path (plan 0005): Phase 0 routes ONLY simple
+ * tests. Steps stay on legacy until the engine emits step_start/step_end + per-step
+ * index/retry/timeout (Phase 1); branch/poll (Phase 2/3); test.extend() fixtures
+ * and workflow later. Routing a steps test now would lose its step timeline and
+ * skew summaries (codex P2). ctx-surface gaps (validate/metric/…) are managed by
+ * only exercising migrated features under the flag.
+ */
+function engineSupports(test) {
+    if (test.fixtures && Object.keys(test.fixtures).length > 0)
+        return false;
+    // Built workflow / contract wrappers are simple-shaped Tests, but their fn emits
+    // workflow:* events the LEGACY harness unwraps into node/poll timeline events (and
+    // inbound contract is node-only) — the browser-safe engine doesn't, so keep them on
+    // legacy even under route-all (codex Phase-3 P2; plan 0005 §scope). The SDK marks
+    // these wrappers with __glubean_kind.
+    if (test.__glubean_kind)
+        return false;
+    if (test.type === "simple")
+        return true;
+    if (test.type === "steps") {
+        // Linear steps + retry/timeout (Phase 1) + branch (Phase 2) + poll (Phase 3).
+        return stepsEngineSupported(test.steps ?? []);
+    }
+    return false;
+}
+function stepsEngineSupported(steps) {
+    for (const step of steps) {
+        // poll steps (Phase 3) are now engine-supported; recurse into branch cases for
+        // any still-unsupported shape (none today — kept as a structural guard).
+        if (isTestBranchStep(step)) {
+            for (const c of step.branch.cases)
+                if (!stepsEngineSupported(c.steps))
+                    return false;
+            if (!stepsEngineSupported(step.branch.default ?? []))
+                return false;
+        }
+    }
+    return true;
+}
 async function executeNewTest(test) {
+    // runner-on-engine (plan 0005): route to the engine only when (a) the engine is
+    // active, (b) this test id is on the per-test allowlist (GLUBEAN_ENGINE_TESTIDS;
+    // "*" = all at cutover) — so the flag never sends arbitrary production tests
+    // through an incomplete ctx (codex), and (c) the test's shape is supported. The
+    // engine owns its scope/carrier/per-event-id and runs OUTSIDE the legacy
+    // testContext ALS (testId comes from each event's own id). Anything else → legacy.
+    if (engineCore && engineRoutesId(test.meta.id) && engineSupports(test)) {
+        // Wrap with the same memory monitoring as the legacy path so the final status
+        // carries peakMemoryBytes/peakMemoryMB (codex P2).
+        startMemoryMonitoring();
+        const result = await runViaEngine(engineCore, test, { session: sessionData, retryCount });
+        const peakBytes = stopMemoryMonitoring();
+        // Status emission mirrors the legacy split: a throw re-raises so the dispatcher
+        // reports "failed" + exit 1 (the engine swallows throws into a result); success
+        // and skip emit their status here (plan 0005 / codex P2). A soft assertion
+        // failure is NOT a throw → it "completed" (pass/fail is derived from the
+        // assertion events downstream, as in the legacy path).
+        if (result.threw) {
+            const err = new Error(result.error ?? "test threw");
+            // Re-raise with the user's original name + stack so classifyErrorReason() and
+            // diagnostics match the legacy path (codex P2).
+            if (result.errorName)
+                err.name = result.errorName;
+            if (result.errorStack)
+                err.stack = result.errorStack;
+            throw err;
+        }
+        if (result.stepsFailed) {
+            // Node parity (harness.ts:2686): a steps test with any failed step throws after
+            // teardown so the dispatcher reports failed + exit 1 — unlike a simple test's
+            // soft assertion ("completes"). A branch-decision failure carries its own message.
+            throw new Error(result.stepsFailMessage ?? "One or more steps failed");
+        }
+        if (result.status === "skipped") {
+            // Re-raise a harness SkipError(reason) so the SAME dispatcher catch that
+            // handles a legacy ctx.skip() emits the skipped status (with `reason`) — byte
+            // parity with legacy, which throws skipRequest out to the dispatcher (plan 0005).
+            throw new SkipError(result.skipReason);
+        }
+        emitEngineWire({
+            type: "status",
+            status: "completed",
+            id: test.meta.id,
+            testId: test.meta.id,
+            peakMemoryBytes: peakBytes,
+            peakMemoryMB: (peakBytes / 1024 / 1024).toFixed(2),
+        });
+        return;
+    }
     const testTags = normalizeTestTags(test.meta.tags);
     const testMeta = { id: test.meta.id, tags: testTags };
     const trc = new TestRunContext(test.meta.id, testMeta);
@@ -1506,6 +1721,27 @@ async function executeNewTest(test) {
             // Core test body — receives the effective ctx (base or fixture-augmented)
             const runTestBody = async (effectiveCtx) => {
                 if (test.type === "simple") {
+                    // Invocation inversion (plan 0007): a built workflow is a first-class DEF, not a
+                    // self-executing test. The SDK marks the wrapper `__glubean_kind === "workflow"`
+                    // and attaches the Workflow IR to `__glubean_workflow`; the host run-loop drives
+                    // it through the workflow executor here — like RunnerCore.run() dispatches simple
+                    // vs steps. This replaces the SDK's old wfTest.fn (which called runWorkflow
+                    // itself); the VERDICT mapping is identical, just host-owned: a skipped run →
+                    // ctx.skip(reason) (throws GlubeanSkipError, caught by the same dispatcher); a
+                    // failed run → rethrow the cause so the dispatcher reports failed + exit 1.
+                    const wfIr = test.__glubean_workflow;
+                    if (wfIr) {
+                        const result = await runWorkflow(wfIr, effectiveCtx);
+                        if (result.status === "skipped") {
+                            // Prefer the user-authored runtime ctx.skip(reason), then the authored
+                            // meta.skip, then a generic fallback (parity with the old wfTest.fn).
+                            effectiveCtx.skip(result.skipReason ?? wfIr.meta.skip ?? `workflow "${wfIr.meta.id}" skipped`);
+                        }
+                        if (result.status === "failed") {
+                            throw result.error ?? new WorkflowPhaseFailedError(wfIr.meta.id, "workflow");
+                        }
+                        return;
+                    }
                     if (!test.fn) {
                         throw new Error(`Invalid test "${test.meta.id}": missing fn`);
                     }