kwikqa 0.0.0-stage → 0.1.1

package/dist/pnp-resolver.mjs

@@ -0,0 +1,5 @@
+import { createRequire as __kwikqaCreateRequire } from "node:module";const require=__kwikqaCreateRequire(import.meta.url);
+import{createHash as k}from"node:crypto";import{lstatSync as v,readFileSync as j,realpathSync as s,statSync as y}from"node:fs";import u,{createRequire as E}from"node:module";import{dirname as L,isAbsolute as w,relative as M,sep as x}from"node:path";var F=16*1024*1024,A=/^[a-f0-9]{64}$/,I=new Map([["@playwright/test",["@playwright/test/cli"]],["@biomejs/biome",["@biomejs/biome/bin/biome"]],["prettier",["prettier/bin/prettier.cjs","prettier/bin/prettier.js"]],["typescript",["typescript/bin/tsc"]],["eslint",["eslint/bin/eslint.js"]]]);function g(t,e){let r=M(t,e);return r===""||!w(r)&&r!==".."&&!r.startsWith(`..${x}`)}var[d,i,a,p,f,...N]=process.argv.slice(2),b=I.get(f);if(N.length!==0||typeof d!="string"||typeof i!="string"||typeof a!="string"||typeof p!="string"||typeof f!="string"||[d,i,p].some(t=>!w(t)||t.includes("\0"))||!A.test(a)||b===void 0)process.stderr.write(`invalid resolver request
+`),process.exitCode=2;else try{let t=s(d),e=s(i),r=s(p),o=v(i);if(e!==i||o.isSymbolicLink()||!o.isFile()||o.size>F||!g(t,e)||!g(t,r))throw new Error("loader or issuer is unauthorized");let c=j(e);if(c.byteLength!==o.size||k("sha256").update(c).digest("hex")!==a)throw new Error("loader identity changed");let l=new u(e);l.filename=e,l.paths=u._nodeModulePaths(L(e)),l._compile(c.toString("utf8"),e);let h=E(r),m=s(h.resolve(`${f}/package.json`)),n;for(let S of b)try{n=s(h.resolve(S));break}catch{}if(n===void 0||!y(m).isFile()||!y(n).isFile())throw new Error("resolved package files are unavailable");process.stdout.write(`${JSON.stringify({manifestPath:m,entryPath:n,loaderSha256:a})}
+`)}catch{process.stderr.write(`package resolution failed
+`),process.exitCode=1}

package/dist/wdio-capture.d.mts

@@ -0,0 +1,11 @@
+export interface KwikqaRunSettings {
+  readonly rootDir?: string;
+  readonly reportDir?: string;
+  readonly captureDir?: string;
+  readonly grep?: string;
+  readonly noRetries?: boolean;
+  readonly keepReporters?: boolean;
+}
+
+/** The project's WebdriverIO config with KwikQA's reporter, and its capture hooks when asked. */
+export function withKwikqa<T extends object>(base: T, settings?: KwikqaRunSettings): T;

package/dist/wdio-capture.mjs

@@ -0,0 +1,261 @@
+// KwikQA's WebdriverIO run wrapper (KQA-081). `npx kwikqa analyze --capture` and `kwikqa
+// validate` run WebdriverIO through a generated config that imports the project's own wdio.conf
+// and passes it through withKwikqa(), which only adds to it:
+//
+// - KwikQA's reporter, so every attempt is recorded with its full suite path;
+// - with `capture`, hooks that record each failed attempt's page: the DOM (as KwikQA's snapshot
+//   tree), a screenshot, the WebdriverIO commands the test ran, and, over WebDriver BiDi, console
+//   messages and network responses;
+// - with `grep`, a Mocha or Jasmine filter that runs only the named test.
+//
+// The project's capabilities, services, and its own hooks all still run, in their order.
+/* global browser */
+import { mkdirSync, writeFileSync } from "node:fs";
+import { join, relative, resolve } from "node:path";
+import KwikqaWdioReporter from "./wdio-reporter.mjs";
+
+const MAX_LOG = 300;
+const MAX_TEXT = 2000;
+/**
+ * WebDriver and BiDi protocol calls WebdriverIO makes on a command's behalf. The log keeps the
+ * commands the test itself called, such as `$`, `click`, and `waitForExist`.
+ */
+const PROTOCOL_COMMAND =
+  /^(?:browsingContext|script|session|network|storage|input|log|emulation|webExtension)[A-Z]|^(?:element[A-Z]\w*|getElement\w*|findElements?\w*|navigateTo|executeScript|executeAsyncScript|takeScreenshot|takeElementScreenshot|getWindowHandles?|switchToFrame|switchToParentFrame|getTitle|getUrl|getPageSource|performActions|releaseActions)$/;
+
+function asArray(hook) {
+  if (hook === undefined || hook === null) return [];
+  return Array.isArray(hook) ? hook : [hook];
+}
+
+function fnv1a(text) {
+  let hash = 0x811c9dc5;
+  for (const byte of new TextEncoder().encode(text)) {
+    hash ^= byte;
+    hash = Math.imul(hash, 0x01000193) >>> 0;
+  }
+  return hash.toString(16).padStart(8, "0");
+}
+
+function summarize(value) {
+  if (value === undefined) return "";
+  if (typeof value === "string") return value.slice(0, 200);
+  try {
+    return JSON.stringify(value).slice(0, 200);
+  } catch {
+    return String(value).slice(0, 200);
+  }
+}
+
+/** Runs in the page: the DOM as `[TAG, {attributes}, ...children]`, text as strings. */
+function serializePage(maxNodes, maxText) {
+  const skipped = new Set(["SCRIPT", "STYLE", "NOSCRIPT", "TEMPLATE", "LINK", "META"]);
+  const FORM_FIELDS = new Set(["INPUT", "TEXTAREA", "SELECT"]);
+  let budget = maxNodes;
+  const visit = (node) => {
+    if (budget <= 0) return undefined;
+    if (node.nodeType === 3) {
+      const value = node.textContent || "";
+      return value.trim() === "" ? undefined : value.slice(0, maxText);
+    }
+    if (node.nodeType !== 1 || skipped.has(node.tagName)) return undefined;
+    budget -= 1;
+    const attributes = {};
+    for (const attribute of Array.from(node.attributes)) {
+      attributes[attribute.name] = String(attribute.value).slice(0, maxText);
+    }
+    if (FORM_FIELDS.has(node.tagName) && typeof node.value === "string") {
+      attributes.__playwright_value_ = node.value.slice(0, maxText);
+    }
+    if (node.checked === true) attributes.__playwright_checked_ = "true";
+    const children = [];
+    const childNodes = node.shadowRoot
+      ? [...Array.from(node.shadowRoot.childNodes), ...Array.from(node.childNodes)]
+      : Array.from(node.childNodes);
+    for (const child of childNodes) {
+      const value = visit(child);
+      if (value !== undefined) children.push(value);
+    }
+    return [node.tagName, attributes, ...children];
+  };
+  return {
+    url: location.href,
+    title: document.title,
+    viewport: { width: window.innerWidth, height: window.innerHeight },
+    dom: visit(document.documentElement),
+    truncated: budget <= 0,
+  };
+}
+
+export function withKwikqa(base, settings = {}) {
+  const cwd = process.cwd();
+  const captureDir = settings.captureDir ? resolve(cwd, settings.captureDir) : undefined;
+  const state = { commands: [], console: [], network: [], capturing: false };
+  const framework = base.framework || "mocha";
+  const config = {
+    ...base,
+    ...(settings.rootDir ? { rootDir: settings.rootDir } : {}),
+    reporters: [
+      ...(settings.keepReporters ? asArray(base.reporters) : []),
+      [KwikqaWdioReporter, { reportDir: settings.reportDir }],
+    ],
+  };
+  if (settings.noRetries) {
+    config.specFileRetries = 0;
+    if (framework === "mocha") config.mochaOpts = { ...(base.mochaOpts || {}), retries: 0 };
+    if (framework === "jasmine") config.jasmineOpts = { ...(base.jasmineOpts || {}) };
+  }
+  if (settings.grep) {
+    if (framework === "mocha")
+      config.mochaOpts = { ...(config.mochaOpts || base.mochaOpts || {}), grep: settings.grep };
+    if (framework === "jasmine")
+      config.jasmineOpts = {
+        ...(config.jasmineOpts || base.jasmineOpts || {}),
+        grep: settings.grep,
+      };
+  }
+  if (!captureDir) return config;
+
+  config.before = [
+    ...asArray(base.before),
+    async () => {
+      if (browser.isMultiremote || !browser.isBidi) return;
+      try {
+        await browser.sessionSubscribe({
+          events: ["log.entryAdded", "network.responseCompleted", "network.fetchError"],
+        });
+        browser.on("log.entryAdded", (entry) => {
+          if (state.console.length >= MAX_LOG) return;
+          if (entry.level === "error" || entry.level === "warn" || entry.type === "javascript") {
+            state.console.push({
+              level: entry.type === "javascript" ? "pageerror" : entry.level,
+              text: String(entry.text).slice(0, MAX_TEXT),
+            });
+          }
+        });
+        browser.on("network.responseCompleted", (event) => {
+          if (state.network.length >= MAX_LOG) return;
+          const request = event.request || {};
+          const response = event.response || {};
+          state.network.push({
+            method: request.method,
+            url: String(request.url || "").slice(0, MAX_TEXT),
+            status: response.status,
+          });
+        });
+        browser.on("network.fetchError", (event) => {
+          if (state.network.length >= MAX_LOG) return;
+          const request = event.request || {};
+          state.network.push({
+            method: request.method,
+            url: String(request.url || "").slice(0, MAX_TEXT),
+            failure: String(event.errorText || "failed"),
+          });
+        });
+      } catch {
+        // A driver without BiDi still gets DOM, screenshot, and command capture.
+      }
+    },
+  ];
+  config.beforeTest = [
+    ...asArray(base.beforeTest),
+    () => {
+      state.commands = [];
+      state.console = [];
+      state.network = [];
+      state.capturing = false;
+    },
+  ];
+  config.afterCommand = [
+    ...asArray(base.afterCommand),
+    (commandName, args, _result, error) => {
+      const name = String(commandName);
+      if (state.capturing || PROTOCOL_COMMAND.test(name)) return;
+      const entry = {
+        name,
+        message: (args || [])
+          .filter((arg) => typeof arg !== "function")
+          .map(summarize)
+          .join(", ")
+          .slice(0, MAX_TEXT),
+        state: error ? "failed" : "passed",
+        ...(error ? { error: String(error.message || error).slice(0, MAX_TEXT) } : {}),
+      };
+      // Waits poll the same few commands many times; one entry each, with a count, says the same.
+      const repeat = state.commands
+        .slice(-4)
+        .find(
+          (item) =>
+            item.name === entry.name &&
+            item.message === entry.message &&
+            item.state === entry.state,
+        );
+      if (repeat) {
+        repeat.repeated = (repeat.repeated || 1) + 1;
+        return;
+      }
+      if (state.commands.length >= MAX_LOG) state.commands.shift();
+      state.commands.push(entry);
+    },
+  ];
+  config.afterTest = [
+    ...asArray(base.afterTest),
+    async (test, _context, result) => {
+      if (result?.passed) return;
+      if (browser.isMultiremote) return;
+      state.capturing = true;
+      const spec = relative(cwd, test.file || "")
+        .split("\\")
+        .join("/");
+      const parent = typeof test.parent === "string" ? test.parent : "";
+      const titlePath = parent === "" ? [test.title] : [parent, test.title];
+      if (globalThis.__kwikqaWdioCaptures === undefined) globalThis.__kwikqaWdioCaptures = [];
+      const captures = globalThis.__kwikqaWdioCaptures;
+      const retry = captures.filter(
+        (item) => item.parent === parent && item.title === test.title,
+      ).length;
+      const key = `${spec.replace(/[^A-Za-z0-9]+/g, "_").slice(-60)}--${fnv1a(`${spec}\u0000${titlePath.join("\u0000")}`)}--${retry}`;
+      mkdirSync(captureDir, { recursive: true });
+      let page = {};
+      try {
+        page = await browser.execute(serializePage, 20000, MAX_TEXT);
+      } catch (error) {
+        page = { error: String(error?.message ? error.message : error) };
+      }
+      const screenshots = [];
+      try {
+        const screenshot = join(captureDir, `${key}.png`);
+        await browser.saveScreenshot(screenshot);
+        screenshots.push(screenshot);
+      } catch {
+        // A closed or crashed session has no page to photograph; the rest is still recorded.
+      }
+      const capture = {
+        schema: "kwikqa-capture",
+        schemaVersion: "1.0",
+        framework: "webdriverio",
+        spec,
+        titlePath,
+        retry,
+        url: page.url || "",
+        title: page.title || "",
+        ...(page.viewport ? { viewport: page.viewport } : {}),
+        dom: page.dom,
+        domTruncated: page.truncated === true,
+        ...(page.error ? { domError: page.error } : {}),
+        commands: state.commands,
+        console: state.console,
+        network: state.network.map((item) => ({
+          message: `${item.method || "GET"} ${item.status === undefined ? item.failure : item.status} ${item.url}`,
+          state: item.failure || (item.status ?? 0) >= 400 ? "failed" : "passed",
+          url: item.url,
+        })),
+        screenshots: screenshots.map((path) => ({ path, testFailure: true })),
+      };
+      const path = join(captureDir, `${key}.json`);
+      writeFileSync(path, `${JSON.stringify(capture)}\n`);
+      captures.push({ parent, title: test.title, path, screenshots });
+    },
+  ];
+  return config;
+}

package/dist/wdio-reporter.d.mts

@@ -0,0 +1,12 @@
+import type { EventEmitter } from "node:events";
+
+export interface KwikqaWdioReporterOptions {
+  /** Where each worker writes its report; `test-results/kwikqa` by default. */
+  readonly reportDir?: string;
+}
+
+/** KwikQA's WebdriverIO reporter: `reporters: [[KwikqaReporter, {}]]` in wdio.conf. */
+export default class KwikqaWdioReporter extends EventEmitter {
+  constructor(options?: KwikqaWdioReporterOptions);
+  readonly isSynchronised: boolean;
+}

package/dist/wdio-reporter.mjs

@@ -0,0 +1,243 @@
+// KwikQA's WebdriverIO reporter (KQA-081). Add it to wdio.conf:
+//
+//   import KwikqaReporter from "kwikqa/wdio-reporter";
+//   reporters: ["spec", [KwikqaReporter, {}]],
+//
+// Each worker writes one `kwikqa-test-report` JSON into `test-results/kwikqa/` (or the
+// `reportDir` option, or $KWIKQA_REPORT_DIR). Unlike @wdio/json-reporter it keeps the full suite
+// path, every retry attempt, and each failure's stack, so `npx kwikqa analyze --report
+// test-results/kwikqa` can tell nested tests apart. It has no dependencies and changes nothing
+// about how tests run.
+import { EventEmitter } from "node:events";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+
+const SCHEMA = "kwikqa-test-report";
+const SCHEMA_VERSION = "1.0";
+const CAPTURE_TYPE = "application/vnd.kwikqa.capture+json";
+
+function packageVersion(name, from) {
+  let directory = resolve(from);
+  for (;;) {
+    const manifest = join(directory, "node_modules", ...name.split("/"), "package.json");
+    if (existsSync(manifest)) {
+      try {
+        return JSON.parse(readFileSync(manifest, "utf8")).version;
+      } catch {
+        return undefined;
+      }
+    }
+    const parent = dirname(directory);
+    if (parent === directory) return undefined;
+    directory = parent;
+  }
+}
+
+function browserName(capabilities) {
+  if (!capabilities || typeof capabilities !== "object") return "";
+  if (typeof capabilities.browserName === "string") return capabilities.browserName;
+  const values = Object.values(capabilities);
+  if (values.length > 0 && values.every((value) => value && typeof value === "object")) {
+    return "multiremote";
+  }
+  return "";
+}
+
+function convertError(error) {
+  if (!error) return undefined;
+  const out = { message: String(error.message !== undefined ? error.message : error) };
+  if (error.name) out.name = String(error.name);
+  if (error.stack) out.stack = String(error.stack);
+  if (error.expected !== undefined || error.actual !== undefined) {
+    out.expected =
+      typeof error.expected === "string" ? error.expected : JSON.stringify(error.expected);
+    out.actual = typeof error.actual === "string" ? error.actual : JSON.stringify(error.actual);
+  }
+  return out;
+}
+
+function cleanFile(file) {
+  if (typeof file !== "string") return "";
+  if (file.startsWith("file://")) {
+    const path = decodeURIComponent(file.slice("file://".length));
+    return /^\/[A-Za-z]:\//.test(path) ? path.slice(1) : path;
+  }
+  return file;
+}
+
+export default class KwikqaWdioReporter extends EventEmitter {
+  constructor(options = {}) {
+    super();
+    this.options = options;
+    this.cwd = process.cwd();
+    this.reportDir = resolve(
+      this.cwd,
+      process.env.KWIKQA_REPORT_DIR || options.reportDir || "test-results/kwikqa",
+    );
+    this.startedAt = new Date();
+    this.suites = [];
+    this.tests = new Map();
+    this.errors = [];
+    this.cid = "0-0";
+    this.specs = [];
+    this.browser = "";
+    this.configFile = undefined;
+    this.on("runner:start", (runner) => {
+      this.cid = String(runner.cid || this.cid);
+      this.specs = (runner.specs || []).map(cleanFile);
+      this.browser = browserName(runner.capabilities);
+      const config = runner.config || {};
+      if (typeof config.configFilePath === "string") this.configFile = config.configFilePath;
+    });
+    this.on("suite:start", (suite) => {
+      if (suite.title) this.suites.push(String(suite.title));
+    });
+    this.on("suite:end", (suite) => {
+      if (suite.title && this.suites[this.suites.length - 1] === String(suite.title)) {
+        this.suites.pop();
+      }
+    });
+    this.on("test:start", (test) => this.open(test));
+    this.on("test:pass", (test) => this.close(test, "passed"));
+    this.on("test:fail", (test) => this.close(test, "failed", test.error));
+    this.on("test:retry", (test) => {
+      this.close(test, "failed", test.error);
+    });
+    this.on("test:pending", (test) => {
+      const entry = this.entry(test);
+      entry.attempts = [{ status: "skipped", retry: 0, duration: 0, errors: [], attachments: [] }];
+    });
+    this.on("hook:end", (hook) => {
+      if (!hook.error) return;
+      const failure = convertError(hook.error);
+      failure.message = `${hook.title}: ${failure.message}`;
+      const running = [...this.tests.values()].find((entry) =>
+        entry.attempts.some((attempt) => attempt.status === "interrupted"),
+      );
+      if (running) {
+        const attempt = running.attempts.find((item) => item.status === "interrupted");
+        attempt.status = "failed";
+        attempt.errors.push(failure);
+        return;
+      }
+      // A hook outside any test (before all, after all) fails under its own title.
+      const entry = this.entry({ title: String(hook.title), file: hook.file });
+      entry.attempts.push({
+        status: "failed",
+        retry: entry.attempts.length,
+        startTime: new Date().toISOString(),
+        duration: 0,
+        errors: [failure],
+        attachments: [],
+      });
+    });
+    this.on("runner:end", () => this.write());
+  }
+
+  get isSynchronised() {
+    return true;
+  }
+
+  entry(test) {
+    const titlePath = [...this.suites, String(test.title)];
+    const file = cleanFile(test.file) || this.specs[0] || "";
+    const key = `${file}\u0000${titlePath.join("\u0000")}`;
+    let entry = this.tests.get(key);
+    if (!entry) {
+      entry = { file, titlePath, project: this.browser, attempts: [] };
+      this.tests.set(key, entry);
+    }
+    return entry;
+  }
+
+  open(test) {
+    const entry = this.entry(test);
+    entry.attempts.push({
+      status: "interrupted",
+      retry: entry.attempts.length,
+      startTime: new Date().toISOString(),
+      duration: 0,
+      errors: [],
+      attachments: [],
+    });
+  }
+
+  close(test, status, error) {
+    const entry = this.entry(test);
+    let attempt = entry.attempts.findLast((item) => item.status === "interrupted");
+    if (!attempt) {
+      this.open(test);
+      attempt = entry.attempts[entry.attempts.length - 1];
+    }
+    attempt.status = status;
+    attempt.duration =
+      typeof test.duration === "number"
+        ? test.duration
+        : Date.now() - Date.parse(attempt.startTime);
+    const converted = convertError(error);
+    if (converted) attempt.errors.push(converted);
+  }
+
+  /** Captures written by KwikQA's capture hooks in this worker, matched to failed attempts in order. */
+  attachCaptures() {
+    const captures = globalThis.__kwikqaWdioCaptures || [];
+    const used = new Map();
+    for (const capture of captures) {
+      const key = `${capture.parent}\u0000${capture.title}`;
+      const index = used.get(key) || 0;
+      used.set(key, index + 1);
+      const entry = [...this.tests.values()].find(
+        (item) =>
+          item.titlePath[item.titlePath.length - 1] === capture.title &&
+          (item.titlePath.length < 2 ||
+            item.titlePath[item.titlePath.length - 2] === capture.parent),
+      );
+      if (!entry) continue;
+      const failed = entry.attempts.filter(
+        (attempt) => attempt.status !== "passed" && attempt.status !== "skipped",
+      );
+      const attempt = failed[index];
+      if (!attempt) continue;
+      attempt.attachments.push({
+        name: "kwikqa-capture",
+        contentType: CAPTURE_TYPE,
+        path: capture.path,
+      });
+      for (const screenshot of capture.screenshots || []) {
+        attempt.attachments.push({
+          name: "screenshot",
+          contentType: "image/png",
+          path: screenshot,
+        });
+      }
+    }
+  }
+
+  write() {
+    this.attachCaptures();
+    const tests = [...this.tests.values()];
+    const interrupted = tests.some((entry) =>
+      entry.attempts.some((attempt) => attempt.status === "interrupted"),
+    );
+    const version = packageVersion("webdriverio", this.cwd);
+    const report = {
+      schema: SCHEMA,
+      schemaVersion: SCHEMA_VERSION,
+      framework: "webdriverio",
+      ...(version === undefined ? {} : { frameworkVersion: version }),
+      rootDir: this.cwd,
+      ...(this.configFile === undefined ? {} : { configFile: this.configFile }),
+      startTime: this.startedAt.toISOString(),
+      duration: Date.now() - this.startedAt.getTime(),
+      interrupted,
+      projects: [{ id: this.browser, name: this.browser, retries: 0 }],
+      tests,
+      errors: this.errors,
+    };
+    mkdirSync(this.reportDir, { recursive: true });
+    writeFileSync(
+      join(this.reportDir, `wdio-${this.cid.replace(/[^A-Za-z0-9-]+/g, "_")}.json`),
+      `${JSON.stringify(report, null, 2)}\n`,
+    );
+  }
+}

package/package.json

@@ -1,6 +1,62 @@
 {
   "name": "kwikqa",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.1",
+  "description": "Evidence-backed diagnoses and safe, validated repairs for failing Playwright, Cypress, and WebdriverIO tests",
+  "license": "SEE LICENSE IN LICENSE",
+  "type": "module",
+  "keywords": [
+    "playwright",
+    "cypress",
+    "webdriverio",
+    "wdio",
+    "testing",
+    "flaky-tests",
+    "test-repair",
+    "e2e"
+  ],
+  "homepage": "https://kwikqa.com",
+  "bin": {
+    "kwikqa": "dist/kwikqa.mjs"
+  },
+  "exports": {
+    "./cypress-reporter": {
+      "types": "./dist/cypress-reporter.d.cts",
+      "default": "./dist/cypress-reporter.cjs"
+    },
+    "./wdio-reporter": {
+      "types": "./dist/wdio-reporter.d.mts",
+      "default": "./dist/wdio-reporter.mjs"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist",
+    "LICENSE",
+    "README.md"
+  ],
+  "packageManager": "pnpm@11.22.0",
+  "engines": {
+    "node": ">=20.11"
+  },
+  "scripts": {
+    "build": "node scripts/build.mjs",
+    "smoke": "node scripts/smoke.mjs",
+    "check": "corepack pnpm run format:check && corepack pnpm run lint && corepack pnpm run typecheck && corepack pnpm run test",
+    "format": "biome format --write .",
+    "format:check": "biome format .",
+    "lint": "biome lint .",
+    "typecheck": "tsc --pretty false",
+    "test": "vitest run",
+    "test:validation:labs": "vitest run tests/validation/labs-matrix.test.ts",
+    "prepublishOnly": "corepack pnpm run check && corepack pnpm run build && corepack pnpm run smoke"
+  },
+  "devDependencies": {
+    "@babel/parser": "7.29.9",
+    "@biomejs/biome": "2.5.10",
+    "@types/node": "26.2.0",
+    "esbuild": "0.28.1",
+    "fflate": "0.8.3",
+    "typescript": "7.0.2",
+    "vitest": "4.1.11"
+  }
+}