playwright-codegen-pro-core 1.0.0

package/lib/server/recorder/recorderRunner.js

@@ -0,0 +1,138 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var recorderRunner_exports = {};
+__export(recorderRunner_exports, {
+  performAction: () => performAction,
+  toClickOptions: () => toClickOptions
+});
+module.exports = __toCommonJS(recorderRunner_exports);
+var import_utils = require("../../utils");
+var import_language = require("../codegen/language");
+var import_recorderUtils = require("./recorderUtils");
+var import_progress = require("../progress");
+async function performAction(pageAliases, actionInContext) {
+  const mainFrame = (0, import_recorderUtils.mainFrameForAction)(pageAliases, actionInContext);
+  const controller = new import_progress.ProgressController();
+  const kActionTimeout = 5e3;
+  return await controller.run((progress) => performActionImpl(progress, mainFrame, actionInContext), kActionTimeout);
+}
+async function performActionImpl(progress, mainFrame, actionInContext) {
+  const { action } = actionInContext;
+  if (action.name === "navigate") {
+    await mainFrame.goto(progress, action.url);
+    return;
+  }
+  if (action.name === "openPage")
+    throw Error("Not reached");
+  if (action.name === "closePage") {
+    await mainFrame._page.close();
+    return;
+  }
+  const selector = (0, import_recorderUtils.buildFullSelector)(actionInContext.frame.framePath, action.selector);
+  if (action.name === "click") {
+    const options = toClickOptions(action);
+    await mainFrame.click(progress, selector, { ...options, strict: true });
+    return;
+  }
+  if (action.name === "hover") {
+    await mainFrame.hover(progress, selector, { position: action.position, strict: true });
+    return;
+  }
+  if (action.name === "press") {
+    const modifiers = (0, import_language.toKeyboardModifiers)(action.modifiers);
+    const shortcut = [...modifiers, action.key].join("+");
+    await mainFrame.press(progress, selector, shortcut, { strict: true });
+    return;
+  }
+  if (action.name === "fill") {
+    await mainFrame.fill(progress, selector, action.text, { strict: true });
+    return;
+  }
+  if (action.name === "setInputFiles") {
+    await mainFrame.setInputFiles(progress, selector, { selector, payloads: [], strict: true });
+    return;
+  }
+  if (action.name === "check") {
+    await mainFrame.check(progress, selector, { strict: true });
+    return;
+  }
+  if (action.name === "uncheck") {
+    await mainFrame.uncheck(progress, selector, { strict: true });
+    return;
+  }
+  if (action.name === "select") {
+    const values = action.options.map((value) => ({ value }));
+    await mainFrame.selectOption(progress, selector, [], values, { strict: true });
+    return;
+  }
+  if (action.name === "assertChecked") {
+    await mainFrame.expect(progress, selector, {
+      selector,
+      expression: "to.be.checked",
+      expectedValue: { checked: action.checked },
+      isNot: !action.checked
+    });
+    return;
+  }
+  if (action.name === "assertText") {
+    await mainFrame.expect(progress, selector, {
+      selector,
+      expression: "to.have.text",
+      expectedText: (0, import_utils.serializeExpectedTextValues)([action.text], { matchSubstring: true, normalizeWhiteSpace: true }),
+      isNot: false
+    });
+    return;
+  }
+  if (action.name === "assertValue") {
+    await mainFrame.expect(progress, selector, {
+      selector,
+      expression: "to.have.value",
+      expectedValue: action.value,
+      isNot: false
+    });
+    return;
+  }
+  if (action.name === "assertVisible") {
+    await mainFrame.expect(progress, selector, {
+      selector,
+      expression: "to.be.visible",
+      isNot: false
+    });
+    return;
+  }
+  throw new Error("Internal error: unexpected action " + action.name);
+}
+function toClickOptions(action) {
+  const modifiers = (0, import_language.toKeyboardModifiers)(action.modifiers);
+  const options = {};
+  if (action.button !== "left")
+    options.button = action.button;
+  if (modifiers.length)
+    options.modifiers = modifiers;
+  if (action.clickCount > 1)
+    options.clickCount = action.clickCount;
+  if (action.position)
+    options.position = action.position;
+  return options;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  performAction,
+  toClickOptions
+});

package/lib/server/recorder/recorderSignalProcessor.js

@@ -0,0 +1,83 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var recorderSignalProcessor_exports = {};
+__export(recorderSignalProcessor_exports, {
+  RecorderSignalProcessor: () => RecorderSignalProcessor
+});
+module.exports = __toCommonJS(recorderSignalProcessor_exports);
+var import_debug = require("../utils/debug");
+var import_time = require("../../utils/isomorphic/time");
+var import_recorderUtils = require("./recorderUtils");
+class RecorderSignalProcessor {
+  constructor(actionSink) {
+    this._lastAction = null;
+    this._delegate = actionSink;
+  }
+  addAction(actionInContext) {
+    this._lastAction = actionInContext;
+    this._delegate.addAction(actionInContext);
+  }
+  signal(pageAlias, frame, signal) {
+    const timestamp = (0, import_time.monotonicTime)();
+    if (signal.name === "navigation" && frame._page.mainFrame() === frame) {
+      const lastAction = this._lastAction;
+      const signalThreshold = (0, import_debug.isUnderTest)() ? 500 : 5e3;
+      let generateGoto = false;
+      if (!lastAction)
+        generateGoto = true;
+      else if (lastAction.action.name !== "click" && lastAction.action.name !== "press" && lastAction.action.name !== "fill")
+        generateGoto = true;
+      else if (timestamp - lastAction.startTime > signalThreshold)
+        generateGoto = true;
+      if (generateGoto) {
+        this.addAction({
+          frame: {
+            pageGuid: frame._page.guid,
+            pageAlias,
+            framePath: []
+          },
+          action: {
+            name: "navigate",
+            url: frame.url(),
+            signals: []
+          },
+          startTime: timestamp,
+          endTime: timestamp
+        });
+      }
+      return;
+    }
+    (0, import_recorderUtils.generateFrameSelector)(frame).then((framePath) => {
+      const signalInContext = {
+        frame: {
+          pageGuid: frame._page.guid,
+          pageAlias,
+          framePath
+        },
+        signal,
+        timestamp
+      };
+      this._delegate.addSignal(signalInContext);
+    });
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  RecorderSignalProcessor
+});

package/lib/server/recorder/recorderUtils.js

@@ -0,0 +1,157 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var recorderUtils_exports = {};
+__export(recorderUtils_exports, {
+  buildFullSelector: () => buildFullSelector,
+  collapseActions: () => collapseActions,
+  frameForAction: () => frameForAction,
+  generateFrameSelector: () => generateFrameSelector,
+  mainFrameForAction: () => mainFrameForAction,
+  metadataToCallLog: () => metadataToCallLog,
+  shouldMergeAction: () => shouldMergeAction
+});
+module.exports = __toCommonJS(recorderUtils_exports);
+var import_protocolFormatter = require("../../utils/isomorphic/protocolFormatter");
+var import_utils = require("../../utils");
+var import_timeoutRunner = require("../../utils/isomorphic/timeoutRunner");
+function buildFullSelector(framePath, selector) {
+  return [...framePath, selector].join(" >> internal:control=enter-frame >> ");
+}
+function metadataToCallLog(metadata, status) {
+  const title = (0, import_protocolFormatter.renderTitleForCall)(metadata);
+  if (metadata.error)
+    status = "error";
+  const params = {
+    url: metadata.params?.url,
+    selector: metadata.params?.selector
+  };
+  let duration = metadata.endTime ? metadata.endTime - metadata.startTime : void 0;
+  if (typeof duration === "number" && metadata.pauseStartTime && metadata.pauseEndTime) {
+    duration -= metadata.pauseEndTime - metadata.pauseStartTime;
+    duration = Math.max(duration, 0);
+  }
+  const callLog = {
+    id: metadata.id,
+    messages: metadata.log,
+    title: title ?? "",
+    status,
+    error: metadata.error?.error?.message,
+    params,
+    duration
+  };
+  return callLog;
+}
+function mainFrameForAction(pageAliases, actionInContext) {
+  const pageAlias = actionInContext.frame.pageAlias;
+  const page = [...pageAliases.entries()].find(([, alias]) => pageAlias === alias)?.[0];
+  if (!page)
+    throw new Error(`Internal error: page ${pageAlias} not found in [${[...pageAliases.values()]}]`);
+  return page.mainFrame();
+}
+async function frameForAction(pageAliases, actionInContext, action) {
+  const pageAlias = actionInContext.frame.pageAlias;
+  const page = [...pageAliases.entries()].find(([, alias]) => pageAlias === alias)?.[0];
+  if (!page)
+    throw new Error("Internal error: page not found");
+  const fullSelector = buildFullSelector(actionInContext.frame.framePath, action.selector);
+  const result = await page.mainFrame().selectors.resolveFrameForSelector(fullSelector);
+  if (!result)
+    throw new Error("Internal error: frame not found");
+  return result.frame;
+}
+function isSameAction(a, b) {
+  return a.action.name === b.action.name && a.frame.pageAlias === b.frame.pageAlias && a.frame.framePath.join("|") === b.frame.framePath.join("|");
+}
+function isSameSelector(action, lastAction) {
+  return "selector" in action.action && "selector" in lastAction.action && action.action.selector === lastAction.action.selector;
+}
+function isShortlyAfter(action, lastAction) {
+  return action.startTime - lastAction.startTime < 500;
+}
+function shouldMergeAction(action, lastAction) {
+  if (!lastAction)
+    return false;
+  switch (action.action.name) {
+    case "fill":
+      return isSameAction(action, lastAction) && isSameSelector(action, lastAction);
+    case "navigate":
+      return isSameAction(action, lastAction);
+    case "click":
+      return isSameAction(action, lastAction) && isSameSelector(action, lastAction) && isShortlyAfter(action, lastAction) && action.action.clickCount > lastAction.action.clickCount;
+  }
+  return false;
+}
+function collapseActions(actions) {
+  const result = [];
+  for (const action of actions) {
+    const lastAction = result[result.length - 1];
+    const shouldMerge = shouldMergeAction(action, lastAction);
+    if (!shouldMerge) {
+      result.push(action);
+      continue;
+    }
+    const startTime = result[result.length - 1].startTime;
+    result[result.length - 1] = action;
+    result[result.length - 1].startTime = startTime;
+  }
+  return result;
+}
+async function generateFrameSelector(frame) {
+  const selectorPromises = [];
+  while (frame) {
+    const parent = frame.parentFrame();
+    if (!parent)
+      break;
+    selectorPromises.push(generateFrameSelectorInParent(parent, frame));
+    frame = parent;
+  }
+  const result = await Promise.all(selectorPromises);
+  return result.reverse();
+}
+async function generateFrameSelectorInParent(parent, frame) {
+  const result = await (0, import_timeoutRunner.raceAgainstDeadline)(async () => {
+    try {
+      const frameElement = await frame.frameElement();
+      if (!frameElement || !parent)
+        return;
+      const utility = await parent._utilityContext();
+      const injected = await utility.injectedScript();
+      const selector = await injected.evaluate((injected2, element) => {
+        return injected2.generateSelectorSimple(element);
+      }, frameElement);
+      return selector;
+    } catch (e) {
+    }
+  }, (0, import_utils.monotonicTime)() + 2e3);
+  if (!result.timedOut && result.result)
+    return result.result;
+  if (frame.name())
+    return `iframe[name=${(0, import_utils.quoteCSSAttributeValue)(frame.name())}]`;
+  return `iframe[src=${(0, import_utils.quoteCSSAttributeValue)(frame.url())}]`;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  buildFullSelector,
+  collapseActions,
+  frameForAction,
+  generateFrameSelector,
+  mainFrameForAction,
+  metadataToCallLog,
+  shouldMergeAction
+});

package/lib/server/recorder/sessionExporter.js

@@ -0,0 +1,40 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var sessionExporter_exports = {};
+__export(sessionExporter_exports, {
+  exportSession: () => exportSession
+});
+module.exports = __toCommonJS(sessionExporter_exports);
+var import_chat = require("./chat");
+var import_sessionRedactor = require("./sessionRedactor");
+var import_sessionPromptBuilder = require("./sessionPromptBuilder");
+async function exportSession(actions, options, _chatFactory) {
+  const redactedSession = (0, import_sessionRedactor.redactSession)(actions, options.pageHasWebSockets);
+  const prompt = (0, import_sessionPromptBuilder.buildPrompt)(redactedSession, options);
+  const wsEndpoint = options.wsEndpoint;
+  const chatInstance = _chatFactory ? _chatFactory(wsEndpoint) : new import_chat.Chat(wsEndpoint);
+  const code = await chatInstance.post(prompt);
+  if (!code)
+    throw new Error("AI generation failed \u2014 check wsEndpoint configuration");
+  return { code, warnings: redactedSession.warnings };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  exportSession
+});

package/lib/server/recorder/sessionPromptBuilder.js

@@ -0,0 +1,128 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var sessionPromptBuilder_exports = {};
+__export(sessionPromptBuilder_exports, {
+  buildPrompt: () => buildPrompt
+});
+module.exports = __toCommonJS(sessionPromptBuilder_exports);
+var import_path = __toESM(require("path"));
+function buildPrompt(session, options) {
+  const { actions, dataCreatingActions, hasWebSockets } = session;
+  const segments = [];
+  for (const action of actions) {
+    const a = action.action;
+    const url = a.name === "navigate" || a.name === "openPage" ? a.url : void 0;
+    if (a.name === "openPage" && a.url === "about:blank")
+      continue;
+    if (url || !segments.length)
+      segments.push({ url: url ?? "", actions: [action] });
+    else
+      segments[segments.length - 1].actions.push(action);
+  }
+  const relativeOutput = import_path.default.relative(process.cwd(), options.outputFile);
+  let sessionSection = "";
+  for (const seg of segments) {
+    if (seg.url)
+      sessionSection += `### Page: ${seg.url}
+`;
+    for (const ctx of seg.actions) {
+      const a = ctx.action;
+      const location = a.selector ? `${a.selector}` : a.url ?? "";
+      sessionSection += `- ${a.name}: ${location} at t=${ctx.startTime}ms
+`;
+      const direct = (ctx.networkEvents ?? []).filter((e) => e.bucket === "direct");
+      const pageLoad = (ctx.networkEvents ?? []).filter((e) => e.bucket === "pageLoad");
+      if (direct.length) {
+        sessionSection += `  API calls (direct):
+`;
+        for (const e of direct) {
+          const op = e.operationName ? ` (${e.operationName})` : "";
+          const payload = e.requestBodySnippet ? ` (payload: ${e.requestBodySnippet.slice(0, 200)}...)` : "";
+          const body = e.bodySnippet ? ` (body: ${e.bodySnippet.slice(0, 200)}...)` : "";
+          sessionSection += `    - ${e.method} ${e.url}${op}${payload} \u2192 ${e.status ?? "pending"}${body}
+`;
+        }
+      }
+      if (pageLoad.length) {
+        sessionSection += `  API calls (page load context):
+`;
+        for (const e of pageLoad)
+          sessionSection += `    - ${e.method} ${e.url} \u2192 ${e.status ?? "pending"}
+`;
+      }
+    }
+  }
+  let cleanupSection = "";
+  if (dataCreatingActions.length) {
+    cleanupSection = "## Data Created During Session\n";
+    for (const idx of dataCreatingActions) {
+      const ctx = actions[idx];
+      const creates = (ctx.networkEvents ?? []).filter((e) => e.bucket === "direct" && e.method === "POST" && e.status === 201);
+      for (const e of creates)
+        cleanupSection += `- Step ${idx + 1} (${ctx.action.name}): POST ${e.url} \u2192 201 Created. Add afterEach cleanup using the response ID.
+`;
+    }
+  } else {
+    cleanupSection = "## Data Created During Session\nNo data was created. No cleanup needed.\n";
+  }
+  const wsSection = hasWebSockets ? "## WebSocket Note\nThis page uses WebSocket connections. Assert on UI state changes that reflect server pushes rather than trying to intercept WS frames.\n\n" : "";
+  return `# Playwright Test Generation Request
+
+## Scenario
+Name: ${options.scenarioName}
+Target file: ${relativeOutput}
+
+## Recorded Session
+${sessionSection.trimEnd()}
+
+${cleanupSection}
+${wsSection}## Best Practices (follow exactly)
+- Do NOT use page.waitForTimeout(), page.waitForLoadState(), page.waitForNavigation()
+- DO use await expect(locator).toBeVisible() and similar waiting assertions
+- Prefer getByRole, getByLabel, getByPlaceholder, getByTestId over CSS selectors
+- Add a meaningful assertion BEFORE and AFTER each significant action
+- For actions with 'direct' API calls, wrap the click in Promise.all with waitForResponse
+- Never assert on auto-generated IDs, UUIDs, or timestamps from response bodies
+- Use process.env.TEST_* variables for any credentials (already done by redaction)
+- For data-creating actions (201), add afterEach cleanup using the response ID
+- Use randomised test data (append Date.now()) to avoid collision on re-runs
+- Structure as test.describe with one clear test per scenario
+
+## Output Format
+${options.mode === "clipboard" ? `Generate a complete Playwright test file in TypeScript.
+The file should start with: import { test, expect } from '@playwright/test';
+Save the result to: ${relativeOutput}` : `Return the TypeScript code as a raw JSON string. Your entire response must be valid JSON parseable by JSON.parse().
+Example: "import { test, expect } from '@playwright/test';\\n\\ntest.describe(..."
+Do not include any explanation, markdown fences, or wrapper objects.
+The code must start with: import { test, expect } from '@playwright/test';`}`;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  buildPrompt
+});

package/lib/server/recorder/sessionRedactor.js

@@ -0,0 +1,74 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var sessionRedactor_exports = {};
+__export(sessionRedactor_exports, {
+  redactSession: () => redactSession
+});
+module.exports = __toCommonJS(sessionRedactor_exports);
+function redactSession(actions, pageHasWebSockets) {
+  const warnings = [];
+  const dataCreatingActions = [];
+  const copy = JSON.parse(JSON.stringify(actions));
+  for (let i = 0; i < copy.length; i++) {
+    const ctx = copy[i];
+    const action = ctx.action;
+    if (action.name === "fill") {
+      const fill = action;
+      const label = `${fill.selector} ${ctx.description ?? ""}`;
+      if (/password|passwd|secret|credential|pin\b/i.test(label)) {
+        warnings.push(`Redacted password fill value in step ${i + 1} (${fill.selector})`);
+        fill.text = "process.env.TEST_PASSWORD || 'test-password'";
+      } else if (/token|api.?key|api.?secret|auth.?key/i.test(label)) {
+        warnings.push(`Redacted API key/token fill value in step ${i + 1} (${fill.selector})`);
+        fill.text = "process.env.TEST_API_KEY || 'test-api-key'";
+      } else if (/ssn|social.?security|card.?number|cvv/i.test(label)) {
+        warnings.push(`Redacted sensitive PII fill value in step ${i + 1} (${fill.selector})`);
+        fill.text = "'[REDACTED]'";
+      }
+    }
+    for (const event of ctx.networkEvents ?? []) {
+      if (event.requestBodySnippet) {
+        const before = event.requestBodySnippet;
+        event.requestBodySnippet = event.requestBodySnippet.replace(/"password"\s*:\s*"[^"]*"/g, '"password":"[redacted]"').replace(/"passwd"\s*:\s*"[^"]*"/g, '"passwd":"[redacted]"').replace(/"token"\s*:\s*"[^"]*"/g, '"token":"[redacted]"').replace(/"secret"\s*:\s*"[^"]*"/g, '"secret":"[redacted]"').replace(/Bearer\s+[A-Za-z0-9._\-]+/g, "Bearer [redacted]").replace(/"Authorization"\s*:\s*"[^"]*"/g, '"Authorization":"[redacted]"').replace(/\b[0-9]{4}[\s\-]?[0-9]{4}[\s\-]?[0-9]{4}[\s\-]?[0-9]{4}\b/g, "[card-redacted]");
+        if (event.requestBodySnippet !== before)
+          warnings.push(`Redacted sensitive data in ${event.method} ${event.url} request payload (step ${i + 1})`);
+      }
+      if (event.bodySnippet) {
+        const before = event.bodySnippet;
+        event.bodySnippet = event.bodySnippet.replace(/"password"\s*:\s*"[^"]*"/g, '"password":"[redacted]"').replace(/"passwd"\s*:\s*"[^"]*"/g, '"passwd":"[redacted]"').replace(/"token"\s*:\s*"[^"]*"/g, '"token":"[redacted]"').replace(/"secret"\s*:\s*"[^"]*"/g, '"secret":"[redacted]"').replace(/Bearer\s+[A-Za-z0-9._\-]+/g, "Bearer [redacted]").replace(/"Authorization"\s*:\s*"[^"]*"/g, '"Authorization":"[redacted]"').replace(/\b[0-9]{4}[\s\-]?[0-9]{4}[\s\-]?[0-9]{4}[\s\-]?[0-9]{4}\b/g, "[card-redacted]");
+        if (event.bodySnippet !== before)
+          warnings.push(`Redacted sensitive data in ${event.method} ${event.url} body (step ${i + 1})`);
+      }
+      if (event.bucket === "direct" && event.method === "POST" && event.status === 201) {
+        if (!dataCreatingActions.includes(i))
+          dataCreatingActions.push(i);
+      }
+    }
+  }
+  return {
+    actions: copy,
+    warnings,
+    hasWebSockets: pageHasWebSockets,
+    dataCreatingActions
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  redactSession
+});

package/lib/server/recorder/throttledFile.js

@@ -0,0 +1,57 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var throttledFile_exports = {};
+__export(throttledFile_exports, {
+  ThrottledFile: () => ThrottledFile
+});
+module.exports = __toCommonJS(throttledFile_exports);
+var import_fs = __toESM(require("fs"));
+class ThrottledFile {
+  constructor(file) {
+    this._file = file;
+  }
+  setContent(text) {
+    this._text = text;
+    if (!this._timer)
+      this._timer = setTimeout(() => this.flush(), 250);
+  }
+  flush() {
+    if (this._timer) {
+      clearTimeout(this._timer);
+      this._timer = void 0;
+    }
+    if (this._text)
+      import_fs.default.writeFileSync(this._file, this._text);
+    this._text = void 0;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ThrottledFile
+});