donobu 5.62.0 → 5.63.0

package/dist/esm/lib/test/testExtension.js

@@ -447,7 +447,9 @@ exports.test = test_1.test.extend({
         // sources are captured into the flow's logBuffer. In Studio-launched flows
         // this is done by WebTargetInspector.initialize(), but that method is not
         // called during test runs, so we wire the listeners up here directly.
-        (0, PageLogListeners_1.registerPageLogListeners)(page);
+        // Bound explicitly to this flow's buffer so routing does not depend on the
+        // ambient ALS context surviving until the events fire.
+        (0, PageLogListeners_1.registerPageLogListeners)(page, { flowId, logBuffer });
         // Bind the Playwright-provided `use` callback to an async resource so that
         // any microtasks scheduled inside the test body keep the flow logging
         // context. Without this, Playwright may re-use earlier async resources that

package/dist/esm/main.d.ts

@@ -79,6 +79,7 @@ export * from './utils/JsonSchemaUtils';
 export * from './utils/JsonUtils';
 export * from './utils/Logger';
 export * from './utils/MiscUtils';
+export * from './utils/PageLogListeners';
 export * from './utils/PlaywrightUtils';
 export * from './utils/TargetUtils';
 export * from './utils/TemplateInterpolator';

package/dist/esm/main.js

@@ -111,6 +111,7 @@ __exportStar(require("./utils/JsonSchemaUtils"), exports);
 __exportStar(require("./utils/JsonUtils"), exports);
 __exportStar(require("./utils/Logger"), exports);
 __exportStar(require("./utils/MiscUtils"), exports);
+__exportStar(require("./utils/PageLogListeners"), exports);
 __exportStar(require("./utils/PlaywrightUtils"), exports);
 __exportStar(require("./utils/TargetUtils"), exports);
 __exportStar(require("./utils/TemplateInterpolator"), exports);

package/dist/esm/persistence/flows/FlowsPersistence.d.ts

@@ -21,6 +21,13 @@ export declare const WELL_KNOWN_FILE_IDS: {
     readonly donobuTestResult: "donobu-test-result.json";
     /** Generated remediation plan consumed by Studio and admin tooling. */
     readonly treatmentPlan: "treatment-plan.json";
+    /**
+     * Collab peer-link: written under the primary flow of a multi-user test run
+     * to enumerate the secondary flows belonging to the same run and the
+     * artifact fileIds persisted for each. Shape (versioned):
+     * `{ version: 1, peers: [{ role, flowId, files: { <label>: <fileId> } }] }`.
+     */
+    readonly collabPeers: "donobu-collab-peers.json";
     /** Failure-triage artifacts persisted alongside a test flow. */
     readonly triage: {
         /** Serialized GPT triage evidence and heuristic assessment. */

package/dist/esm/persistence/flows/FlowsPersistence.js

@@ -18,6 +18,13 @@ exports.WELL_KNOWN_FILE_IDS = {
     donobuTestResult: 'donobu-test-result.json',
     /** Generated remediation plan consumed by Studio and admin tooling. */
     treatmentPlan: 'treatment-plan.json',
+    /**
+     * Collab peer-link: written under the primary flow of a multi-user test run
+     * to enumerate the secondary flows belonging to the same run and the
+     * artifact fileIds persisted for each. Shape (versioned):
+     * `{ version: 1, peers: [{ role, flowId, files: { <label>: <fileId> } }] }`.
+     */
+    collabPeers: 'donobu-collab-peers.json',
     /** Failure-triage artifacts persisted alongside a test flow. */
     triage: {
         /** Serialized GPT triage evidence and heuristic assessment. */

package/dist/esm/utils/Logger.d.ts

@@ -2,6 +2,28 @@ import { AsyncLocalStorage } from 'async_hooks';
 import winston from 'winston';
 import type { FlowLogBuffer } from '../utils/FlowLogBuffer';
 export declare const loggingContext: AsyncLocalStorage<unknown>;
+/**
+ * Symbol key for flow-routing metadata carried on a log info object itself.
+ *
+ * Winston loggers are Transform streams: under backpressure, an entry may be
+ * format-transformed and delivered to transports on a *later* event-loop
+ * turn, in whatever async context happens to be live at drain time. Routing
+ * that resolves its destination via AsyncLocalStorage at delivery time
+ * therefore breaks under synchronous log bursts (a few hundred entries in
+ * one tick): entries land in the wrong flow's buffer, stamped with the wrong
+ * flowId. Callers that must guarantee attribution (e.g. page listeners bound
+ * to a specific flow — see registerPageLogListeners) attach
+ * `{ flowId, logBuffer }` under this key in the log call's meta;
+ * {@link FlowLogBufferTransport} and the flowId format prefer it over the
+ * ambient context. Symbol-keyed so it survives winston's object spreads but
+ * is invisible to JSON serialization (file transports, persisted logs).
+ */
+export declare const FLOW_LOG_ROUTING: unique symbol;
+/** Value shape carried under {@link FLOW_LOG_ROUTING}. */
+export interface FlowLogRouting {
+    flowId: string;
+    logBuffer: FlowLogBuffer;
+}
 /**
  * ###################################################################################
  * # WARNING! Only use this function within the context of Playwright test fixtures! #

package/dist/esm/utils/Logger.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.networkLogger = exports.browserLogger = exports.accessLogger = exports.appLogger = exports.loggingContext = void 0;
+exports.networkLogger = exports.browserLogger = exports.accessLogger = exports.appLogger = exports.FLOW_LOG_ROUTING = exports.loggingContext = void 0;
 exports.setProcessLocalFlowId = setProcessLocalFlowId;
 exports.setProcessLocalLogBuffer = setProcessLocalLogBuffer;
 exports.logErrorWithoutStack = logErrorWithoutStack;
@@ -69,10 +69,32 @@ const errorAwareFormat = winston_1.default.format((info) => {
 });
 exports.loggingContext = new async_hooks_1.AsyncLocalStorage();
 /**
- * Custom Winston transport that routes log entries into the per-flow
- * {@link FlowLogBuffer} stored in the {@link loggingContext} async local
- * storage. Each logger instance creates its own transport tagged with the
- * appropriate source so the buffer knows the origin.
+ * Symbol key for flow-routing metadata carried on a log info object itself.
+ *
+ * Winston loggers are Transform streams: under backpressure, an entry may be
+ * format-transformed and delivered to transports on a *later* event-loop
+ * turn, in whatever async context happens to be live at drain time. Routing
+ * that resolves its destination via AsyncLocalStorage at delivery time
+ * therefore breaks under synchronous log bursts (a few hundred entries in
+ * one tick): entries land in the wrong flow's buffer, stamped with the wrong
+ * flowId. Callers that must guarantee attribution (e.g. page listeners bound
+ * to a specific flow — see registerPageLogListeners) attach
+ * `{ flowId, logBuffer }` under this key in the log call's meta;
+ * {@link FlowLogBufferTransport} and the flowId format prefer it over the
+ * ambient context. Symbol-keyed so it survives winston's object spreads but
+ * is invisible to JSON serialization (file transports, persisted logs).
+ */
+exports.FLOW_LOG_ROUTING = Symbol('donobu.flowLogRouting');
+function getInfoRouting(info) {
+    return info[exports.FLOW_LOG_ROUTING];
+}
+/**
+ * Custom Winston transport that routes log entries into a per-flow
+ * {@link FlowLogBuffer}: the one carried on the entry itself via
+ * {@link FLOW_LOG_ROUTING} when present, otherwise the one stored in the
+ * {@link loggingContext} async local storage. Each logger instance creates
+ * its own transport tagged with the appropriate source so the buffer knows
+ * the origin.
  */
 class FlowLogBufferTransport extends winston_transport_1.default {
     constructor(source) {
@@ -81,9 +103,13 @@ class FlowLogBufferTransport extends winston_transport_1.default {
     }
     log(info, callback) {
         const store = exports.loggingContext.getStore();
-        const buffer = store?.logBuffer || processLocalLogBuffer;
+        const buffer = getInfoRouting(info)?.logBuffer ||
+            store?.logBuffer ||
+            processLocalLogBuffer;
         if (buffer) {
-            buffer.push({ ...info, source: this.source });
+            const entry = { ...info, source: this.source };
+            delete entry[exports.FLOW_LOG_ROUTING];
+            buffer.push(entry);
         }
         callback();
     }
@@ -111,12 +137,14 @@ function setProcessLocalFlowId(flowId) {
 function setProcessLocalLogBuffer(buffer) {
     processLocalLogBuffer = buffer;
 }
-// Format to add the currently running flow's ID (if any) from AsyncLocalStorage
+// Format to add the currently running flow's ID (if any). Prefers routing
+// carried on the entry itself (immune to winston's deferred transform under
+// backpressure — see FLOW_LOG_ROUTING), then the AsyncLocalStorage store,
+// then the process-local slot for logs emitted before the ALS store is
+// available (see note above).
 const flowIdFormat = winston_1.default.format((info) => {
     const store = exports.loggingContext.getStore();
-    // We prefer the ALS-provided ID but fall back to the process-local slot for
-    // logs emitted before the ALS store is available (see note above).
-    const flowId = store?.flowId || processLocalFlowId || '-';
+    const flowId = getInfoRouting(info)?.flowId || store?.flowId || processLocalFlowId || '-';
     return {
         ...info,
         flowId,

package/dist/esm/utils/PageLogListeners.d.ts

@@ -1,15 +1,35 @@
 import type { Page } from 'playwright';
+import type { FlowLogBuffer } from './FlowLogBuffer';
 /**
- * Registers Playwright page event listeners that route browser console messages
- * and network request/response data to the {@link browserLogger} and
- * {@link networkLogger} Winston loggers. These loggers include a
- * {@link FlowLogBufferTransport} that captures entries into the per-flow
- * log buffer (when one is available via AsyncLocalStorage or the process-local
- * fallback).
+ * Explicit log destination for {@link registerPageLogListeners}.
+ */
+export interface PageLogListenerOptions {
+    /** Flow ID stamped onto every captured entry. */
+    flowId: string;
+    /** Buffer the captured entries are routed into. */
+    logBuffer: FlowLogBuffer;
+}
+/**
+ * Registers Playwright page event listeners that route browser console
+ * messages and network request/response data to the {@link browserLogger}
+ * and {@link networkLogger} Winston loggers, whose
+ * {@link FlowLogBufferTransport} captures entries into a per-flow log
+ * buffer. Called from both {@link WebTargetInspector.handleNewPage}
+ * (Studio-launched flows) and the Playwright test extension fixture.
+ *
+ * By default, entries are routed by the ambient AsyncLocalStorage logging
+ * context (or the process-local fallback). Pass `opts` to bind this page's
+ * listeners to an explicit flow + buffer instead. That binding is required
+ * whenever one test drives multiple pages with distinct flows (e.g.
+ * multi-user collab tests): the ambient context belongs to the primary
+ * page's flow, so an unbound secondary page would leak its entries —
+ * stamped with the wrong flowId — into the primary flow's buffer.
  *
- * This function is called from both {@link WebTargetInspector.handleNewPage}
- * (Studio-launched flows) and the Playwright test extension fixture, ensuring
- * identical logging behaviour across both runtime contexts.
+ * The binding is stamped onto each entry's meta at emit time (see
+ * {@link FLOW_LOG_ROUTING}) rather than scoped via AsyncLocalStorage:
+ * winston defers format + transport delivery under backpressure, so
+ * ALS-based scoping would resolve against whatever context is live at drain
+ * time and silently misroute entries during synchronous log bursts.
  */
-export declare function registerPageLogListeners(page: Page): void;
+export declare function registerPageLogListeners(page: Page, opts?: PageLogListenerOptions): void;
 //# sourceMappingURL=PageLogListeners.d.ts.map

package/dist/esm/utils/PageLogListeners.js

@@ -3,18 +3,34 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.registerPageLogListeners = registerPageLogListeners;
 const Logger_1 = require("./Logger");
 /**
- * Registers Playwright page event listeners that route browser console messages
- * and network request/response data to the {@link browserLogger} and
- * {@link networkLogger} Winston loggers. These loggers include a
- * {@link FlowLogBufferTransport} that captures entries into the per-flow
- * log buffer (when one is available via AsyncLocalStorage or the process-local
- * fallback).
+ * Registers Playwright page event listeners that route browser console
+ * messages and network request/response data to the {@link browserLogger}
+ * and {@link networkLogger} Winston loggers, whose
+ * {@link FlowLogBufferTransport} captures entries into a per-flow log
+ * buffer. Called from both {@link WebTargetInspector.handleNewPage}
+ * (Studio-launched flows) and the Playwright test extension fixture.
  *
- * This function is called from both {@link WebTargetInspector.handleNewPage}
- * (Studio-launched flows) and the Playwright test extension fixture, ensuring
- * identical logging behaviour across both runtime contexts.
+ * By default, entries are routed by the ambient AsyncLocalStorage logging
+ * context (or the process-local fallback). Pass `opts` to bind this page's
+ * listeners to an explicit flow + buffer instead. That binding is required
+ * whenever one test drives multiple pages with distinct flows (e.g.
+ * multi-user collab tests): the ambient context belongs to the primary
+ * page's flow, so an unbound secondary page would leak its entries —
+ * stamped with the wrong flowId — into the primary flow's buffer.
+ *
+ * The binding is stamped onto each entry's meta at emit time (see
+ * {@link FLOW_LOG_ROUTING}) rather than scoped via AsyncLocalStorage:
+ * winston defers format + transport delivery under backpressure, so
+ * ALS-based scoping would resolve against whatever context is live at drain
+ * time and silently misroute entries during synchronous log bursts.
  */
-function registerPageLogListeners(page) {
+function registerPageLogListeners(page, opts) {
+    const routing = opts
+        ? { [Logger_1.FLOW_LOG_ROUTING]: { flowId: opts.flowId, logBuffer: opts.logBuffer } }
+        : undefined;
+    // Merge the routing stamp into a log call's meta. Leaves the unbound
+    // call path byte-identical (meta stays undefined when both are absent).
+    const stamp = (meta) => routing ? { ...meta, ...routing } : meta;
     page.on('console', (msg) => {
         const { url, lineNumber, columnNumber } = msg.location();
         const hasSourceLocation = lineNumber !== 0 || columnNumber !== 0;
@@ -25,24 +41,24 @@ function registerPageLogListeners(page) {
             : undefined;
         switch (msg.type()) {
             case 'error':
-                Logger_1.browserLogger.error(msg.text(), meta);
+                Logger_1.browserLogger.error(msg.text(), stamp(meta));
                 break;
             case 'warning':
-                Logger_1.browserLogger.warn(msg.text(), meta);
+                Logger_1.browserLogger.warn(msg.text(), stamp(meta));
                 break;
             case 'debug':
-                Logger_1.browserLogger.debug(msg.text(), meta);
+                Logger_1.browserLogger.debug(msg.text(), stamp(meta));
                 break;
             default:
-                Logger_1.browserLogger.info(msg.text(), meta);
+                Logger_1.browserLogger.info(msg.text(), stamp(meta));
                 break;
         }
     });
     page.on('pageerror', (error) => {
-        Logger_1.browserLogger.error(error.message, {
+        Logger_1.browserLogger.error(error.message, stamp({
             stack: error.stack,
             url: page.url(),
-        });
+        }));
     });
     // Fallback timing: track request start times keyed by the Request object
     // itself (via WeakMap) so concurrent requests to the same URL don't collide.
@@ -71,24 +87,24 @@ function registerPageLogListeners(page) {
             resourceType: request.resourceType(),
         };
         if (status >= 500) {
-            Logger_1.networkLogger.error(request.url(), meta);
+            Logger_1.networkLogger.error(request.url(), stamp(meta));
         }
         else if (status >= 400) {
-            Logger_1.networkLogger.warn(request.url(), meta);
+            Logger_1.networkLogger.warn(request.url(), stamp(meta));
         }
         else {
-            Logger_1.networkLogger.info(request.url(), meta);
+            Logger_1.networkLogger.info(request.url(), stamp(meta));
         }
     });
     page.on('requestfailed', (request) => {
         const duration = getDuration(request);
-        Logger_1.networkLogger.error(`${request.url()} FAILED: ${request.failure()?.errorText}`, {
+        Logger_1.networkLogger.error(`${request.url()} FAILED: ${request.failure()?.errorText}`, stamp({
             method: request.method(),
             url: request.url(),
             resourceType: request.resourceType(),
             failureReason: request.failure()?.errorText,
             duration,
-        });
+        }));
     });
 }
 //# sourceMappingURL=PageLogListeners.js.map

package/dist/lib/test/testExtension.js

@@ -447,7 +447,9 @@ exports.test = test_1.test.extend({
         // sources are captured into the flow's logBuffer. In Studio-launched flows
         // this is done by WebTargetInspector.initialize(), but that method is not
         // called during test runs, so we wire the listeners up here directly.
-        (0, PageLogListeners_1.registerPageLogListeners)(page);
+        // Bound explicitly to this flow's buffer so routing does not depend on the
+        // ambient ALS context surviving until the events fire.
+        (0, PageLogListeners_1.registerPageLogListeners)(page, { flowId, logBuffer });
         // Bind the Playwright-provided `use` callback to an async resource so that
         // any microtasks scheduled inside the test body keep the flow logging
         // context. Without this, Playwright may re-use earlier async resources that

package/dist/main.d.ts

@@ -79,6 +79,7 @@ export * from './utils/JsonSchemaUtils';
 export * from './utils/JsonUtils';
 export * from './utils/Logger';
 export * from './utils/MiscUtils';
+export * from './utils/PageLogListeners';
 export * from './utils/PlaywrightUtils';
 export * from './utils/TargetUtils';
 export * from './utils/TemplateInterpolator';

package/dist/main.js

@@ -111,6 +111,7 @@ __exportStar(require("./utils/JsonSchemaUtils"), exports);
 __exportStar(require("./utils/JsonUtils"), exports);
 __exportStar(require("./utils/Logger"), exports);
 __exportStar(require("./utils/MiscUtils"), exports);
+__exportStar(require("./utils/PageLogListeners"), exports);
 __exportStar(require("./utils/PlaywrightUtils"), exports);
 __exportStar(require("./utils/TargetUtils"), exports);
 __exportStar(require("./utils/TemplateInterpolator"), exports);

package/dist/persistence/flows/FlowsPersistence.d.ts

@@ -21,6 +21,13 @@ export declare const WELL_KNOWN_FILE_IDS: {
     readonly donobuTestResult: "donobu-test-result.json";
     /** Generated remediation plan consumed by Studio and admin tooling. */
     readonly treatmentPlan: "treatment-plan.json";
+    /**
+     * Collab peer-link: written under the primary flow of a multi-user test run
+     * to enumerate the secondary flows belonging to the same run and the
+     * artifact fileIds persisted for each. Shape (versioned):
+     * `{ version: 1, peers: [{ role, flowId, files: { <label>: <fileId> } }] }`.
+     */
+    readonly collabPeers: "donobu-collab-peers.json";
     /** Failure-triage artifacts persisted alongside a test flow. */
     readonly triage: {
         /** Serialized GPT triage evidence and heuristic assessment. */

package/dist/persistence/flows/FlowsPersistence.js

@@ -18,6 +18,13 @@ exports.WELL_KNOWN_FILE_IDS = {
     donobuTestResult: 'donobu-test-result.json',
     /** Generated remediation plan consumed by Studio and admin tooling. */
     treatmentPlan: 'treatment-plan.json',
+    /**
+     * Collab peer-link: written under the primary flow of a multi-user test run
+     * to enumerate the secondary flows belonging to the same run and the
+     * artifact fileIds persisted for each. Shape (versioned):
+     * `{ version: 1, peers: [{ role, flowId, files: { <label>: <fileId> } }] }`.
+     */
+    collabPeers: 'donobu-collab-peers.json',
     /** Failure-triage artifacts persisted alongside a test flow. */
     triage: {
         /** Serialized GPT triage evidence and heuristic assessment. */

package/dist/utils/Logger.d.ts

@@ -2,6 +2,28 @@ import { AsyncLocalStorage } from 'async_hooks';
 import winston from 'winston';
 import type { FlowLogBuffer } from '../utils/FlowLogBuffer';
 export declare const loggingContext: AsyncLocalStorage<unknown>;
+/**
+ * Symbol key for flow-routing metadata carried on a log info object itself.
+ *
+ * Winston loggers are Transform streams: under backpressure, an entry may be
+ * format-transformed and delivered to transports on a *later* event-loop
+ * turn, in whatever async context happens to be live at drain time. Routing
+ * that resolves its destination via AsyncLocalStorage at delivery time
+ * therefore breaks under synchronous log bursts (a few hundred entries in
+ * one tick): entries land in the wrong flow's buffer, stamped with the wrong
+ * flowId. Callers that must guarantee attribution (e.g. page listeners bound
+ * to a specific flow — see registerPageLogListeners) attach
+ * `{ flowId, logBuffer }` under this key in the log call's meta;
+ * {@link FlowLogBufferTransport} and the flowId format prefer it over the
+ * ambient context. Symbol-keyed so it survives winston's object spreads but
+ * is invisible to JSON serialization (file transports, persisted logs).
+ */
+export declare const FLOW_LOG_ROUTING: unique symbol;
+/** Value shape carried under {@link FLOW_LOG_ROUTING}. */
+export interface FlowLogRouting {
+    flowId: string;
+    logBuffer: FlowLogBuffer;
+}
 /**
  * ###################################################################################
  * # WARNING! Only use this function within the context of Playwright test fixtures! #

package/dist/utils/Logger.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.networkLogger = exports.browserLogger = exports.accessLogger = exports.appLogger = exports.loggingContext = void 0;
+exports.networkLogger = exports.browserLogger = exports.accessLogger = exports.appLogger = exports.FLOW_LOG_ROUTING = exports.loggingContext = void 0;
 exports.setProcessLocalFlowId = setProcessLocalFlowId;
 exports.setProcessLocalLogBuffer = setProcessLocalLogBuffer;
 exports.logErrorWithoutStack = logErrorWithoutStack;
@@ -69,10 +69,32 @@ const errorAwareFormat = winston_1.default.format((info) => {
 });
 exports.loggingContext = new async_hooks_1.AsyncLocalStorage();
 /**
- * Custom Winston transport that routes log entries into the per-flow
- * {@link FlowLogBuffer} stored in the {@link loggingContext} async local
- * storage. Each logger instance creates its own transport tagged with the
- * appropriate source so the buffer knows the origin.
+ * Symbol key for flow-routing metadata carried on a log info object itself.
+ *
+ * Winston loggers are Transform streams: under backpressure, an entry may be
+ * format-transformed and delivered to transports on a *later* event-loop
+ * turn, in whatever async context happens to be live at drain time. Routing
+ * that resolves its destination via AsyncLocalStorage at delivery time
+ * therefore breaks under synchronous log bursts (a few hundred entries in
+ * one tick): entries land in the wrong flow's buffer, stamped with the wrong
+ * flowId. Callers that must guarantee attribution (e.g. page listeners bound
+ * to a specific flow — see registerPageLogListeners) attach
+ * `{ flowId, logBuffer }` under this key in the log call's meta;
+ * {@link FlowLogBufferTransport} and the flowId format prefer it over the
+ * ambient context. Symbol-keyed so it survives winston's object spreads but
+ * is invisible to JSON serialization (file transports, persisted logs).
+ */
+exports.FLOW_LOG_ROUTING = Symbol('donobu.flowLogRouting');
+function getInfoRouting(info) {
+    return info[exports.FLOW_LOG_ROUTING];
+}
+/**
+ * Custom Winston transport that routes log entries into a per-flow
+ * {@link FlowLogBuffer}: the one carried on the entry itself via
+ * {@link FLOW_LOG_ROUTING} when present, otherwise the one stored in the
+ * {@link loggingContext} async local storage. Each logger instance creates
+ * its own transport tagged with the appropriate source so the buffer knows
+ * the origin.
  */
 class FlowLogBufferTransport extends winston_transport_1.default {
     constructor(source) {
@@ -81,9 +103,13 @@ class FlowLogBufferTransport extends winston_transport_1.default {
     }
     log(info, callback) {
         const store = exports.loggingContext.getStore();
-        const buffer = store?.logBuffer || processLocalLogBuffer;
+        const buffer = getInfoRouting(info)?.logBuffer ||
+            store?.logBuffer ||
+            processLocalLogBuffer;
         if (buffer) {
-            buffer.push({ ...info, source: this.source });
+            const entry = { ...info, source: this.source };
+            delete entry[exports.FLOW_LOG_ROUTING];
+            buffer.push(entry);
         }
         callback();
     }
@@ -111,12 +137,14 @@ function setProcessLocalFlowId(flowId) {
 function setProcessLocalLogBuffer(buffer) {
     processLocalLogBuffer = buffer;
 }
-// Format to add the currently running flow's ID (if any) from AsyncLocalStorage
+// Format to add the currently running flow's ID (if any). Prefers routing
+// carried on the entry itself (immune to winston's deferred transform under
+// backpressure — see FLOW_LOG_ROUTING), then the AsyncLocalStorage store,
+// then the process-local slot for logs emitted before the ALS store is
+// available (see note above).
 const flowIdFormat = winston_1.default.format((info) => {
     const store = exports.loggingContext.getStore();
-    // We prefer the ALS-provided ID but fall back to the process-local slot for
-    // logs emitted before the ALS store is available (see note above).
-    const flowId = store?.flowId || processLocalFlowId || '-';
+    const flowId = getInfoRouting(info)?.flowId || store?.flowId || processLocalFlowId || '-';
     return {
         ...info,
         flowId,

package/dist/utils/PageLogListeners.d.ts

@@ -1,15 +1,35 @@
 import type { Page } from 'playwright';
+import type { FlowLogBuffer } from './FlowLogBuffer';
 /**
- * Registers Playwright page event listeners that route browser console messages
- * and network request/response data to the {@link browserLogger} and
- * {@link networkLogger} Winston loggers. These loggers include a
- * {@link FlowLogBufferTransport} that captures entries into the per-flow
- * log buffer (when one is available via AsyncLocalStorage or the process-local
- * fallback).
+ * Explicit log destination for {@link registerPageLogListeners}.
+ */
+export interface PageLogListenerOptions {
+    /** Flow ID stamped onto every captured entry. */
+    flowId: string;
+    /** Buffer the captured entries are routed into. */
+    logBuffer: FlowLogBuffer;
+}
+/**
+ * Registers Playwright page event listeners that route browser console
+ * messages and network request/response data to the {@link browserLogger}
+ * and {@link networkLogger} Winston loggers, whose
+ * {@link FlowLogBufferTransport} captures entries into a per-flow log
+ * buffer. Called from both {@link WebTargetInspector.handleNewPage}
+ * (Studio-launched flows) and the Playwright test extension fixture.
+ *
+ * By default, entries are routed by the ambient AsyncLocalStorage logging
+ * context (or the process-local fallback). Pass `opts` to bind this page's
+ * listeners to an explicit flow + buffer instead. That binding is required
+ * whenever one test drives multiple pages with distinct flows (e.g.
+ * multi-user collab tests): the ambient context belongs to the primary
+ * page's flow, so an unbound secondary page would leak its entries —
+ * stamped with the wrong flowId — into the primary flow's buffer.
  *
- * This function is called from both {@link WebTargetInspector.handleNewPage}
- * (Studio-launched flows) and the Playwright test extension fixture, ensuring
- * identical logging behaviour across both runtime contexts.
+ * The binding is stamped onto each entry's meta at emit time (see
+ * {@link FLOW_LOG_ROUTING}) rather than scoped via AsyncLocalStorage:
+ * winston defers format + transport delivery under backpressure, so
+ * ALS-based scoping would resolve against whatever context is live at drain
+ * time and silently misroute entries during synchronous log bursts.
  */
-export declare function registerPageLogListeners(page: Page): void;
+export declare function registerPageLogListeners(page: Page, opts?: PageLogListenerOptions): void;
 //# sourceMappingURL=PageLogListeners.d.ts.map

package/dist/utils/PageLogListeners.js

@@ -3,18 +3,34 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.registerPageLogListeners = registerPageLogListeners;
 const Logger_1 = require("./Logger");
 /**
- * Registers Playwright page event listeners that route browser console messages
- * and network request/response data to the {@link browserLogger} and
- * {@link networkLogger} Winston loggers. These loggers include a
- * {@link FlowLogBufferTransport} that captures entries into the per-flow
- * log buffer (when one is available via AsyncLocalStorage or the process-local
- * fallback).
+ * Registers Playwright page event listeners that route browser console
+ * messages and network request/response data to the {@link browserLogger}
+ * and {@link networkLogger} Winston loggers, whose
+ * {@link FlowLogBufferTransport} captures entries into a per-flow log
+ * buffer. Called from both {@link WebTargetInspector.handleNewPage}
+ * (Studio-launched flows) and the Playwright test extension fixture.
  *
- * This function is called from both {@link WebTargetInspector.handleNewPage}
- * (Studio-launched flows) and the Playwright test extension fixture, ensuring
- * identical logging behaviour across both runtime contexts.
+ * By default, entries are routed by the ambient AsyncLocalStorage logging
+ * context (or the process-local fallback). Pass `opts` to bind this page's
+ * listeners to an explicit flow + buffer instead. That binding is required
+ * whenever one test drives multiple pages with distinct flows (e.g.
+ * multi-user collab tests): the ambient context belongs to the primary
+ * page's flow, so an unbound secondary page would leak its entries —
+ * stamped with the wrong flowId — into the primary flow's buffer.
+ *
+ * The binding is stamped onto each entry's meta at emit time (see
+ * {@link FLOW_LOG_ROUTING}) rather than scoped via AsyncLocalStorage:
+ * winston defers format + transport delivery under backpressure, so
+ * ALS-based scoping would resolve against whatever context is live at drain
+ * time and silently misroute entries during synchronous log bursts.
  */
-function registerPageLogListeners(page) {
+function registerPageLogListeners(page, opts) {
+    const routing = opts
+        ? { [Logger_1.FLOW_LOG_ROUTING]: { flowId: opts.flowId, logBuffer: opts.logBuffer } }
+        : undefined;
+    // Merge the routing stamp into a log call's meta. Leaves the unbound
+    // call path byte-identical (meta stays undefined when both are absent).
+    const stamp = (meta) => routing ? { ...meta, ...routing } : meta;
     page.on('console', (msg) => {
         const { url, lineNumber, columnNumber } = msg.location();
         const hasSourceLocation = lineNumber !== 0 || columnNumber !== 0;
@@ -25,24 +41,24 @@ function registerPageLogListeners(page) {
             : undefined;
         switch (msg.type()) {
             case 'error':
-                Logger_1.browserLogger.error(msg.text(), meta);
+                Logger_1.browserLogger.error(msg.text(), stamp(meta));
                 break;
             case 'warning':
-                Logger_1.browserLogger.warn(msg.text(), meta);
+                Logger_1.browserLogger.warn(msg.text(), stamp(meta));
                 break;
             case 'debug':
-                Logger_1.browserLogger.debug(msg.text(), meta);
+                Logger_1.browserLogger.debug(msg.text(), stamp(meta));
                 break;
             default:
-                Logger_1.browserLogger.info(msg.text(), meta);
+                Logger_1.browserLogger.info(msg.text(), stamp(meta));
                 break;
         }
     });
     page.on('pageerror', (error) => {
-        Logger_1.browserLogger.error(error.message, {
+        Logger_1.browserLogger.error(error.message, stamp({
             stack: error.stack,
             url: page.url(),
-        });
+        }));
     });
     // Fallback timing: track request start times keyed by the Request object
     // itself (via WeakMap) so concurrent requests to the same URL don't collide.
@@ -71,24 +87,24 @@ function registerPageLogListeners(page) {
             resourceType: request.resourceType(),
         };
         if (status >= 500) {
-            Logger_1.networkLogger.error(request.url(), meta);
+            Logger_1.networkLogger.error(request.url(), stamp(meta));
         }
         else if (status >= 400) {
-            Logger_1.networkLogger.warn(request.url(), meta);
+            Logger_1.networkLogger.warn(request.url(), stamp(meta));
         }
         else {
-            Logger_1.networkLogger.info(request.url(), meta);
+            Logger_1.networkLogger.info(request.url(), stamp(meta));
         }
     });
     page.on('requestfailed', (request) => {
         const duration = getDuration(request);
-        Logger_1.networkLogger.error(`${request.url()} FAILED: ${request.failure()?.errorText}`, {
+        Logger_1.networkLogger.error(`${request.url()} FAILED: ${request.failure()?.errorText}`, stamp({
             method: request.method(),
             url: request.url(),
             resourceType: request.resourceType(),
             failureReason: request.failure()?.errorText,
             duration,
-        });
+        }));
     });
 }
 //# sourceMappingURL=PageLogListeners.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "donobu",
-  "version": "5.62.0",
+  "version": "5.63.0",
   "description": "Create browser automations with an LLM agent and replay them as Playwright scripts.",
   "main": "dist/main.js",
   "module": "dist/esm/main.js",