@datadisco/qa 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 DataDisco, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,99 @@
+# @datadisco/qa
+
+CI companion for [DataDisco QA](https://datadisco.com) — PR-triggered persona
+simulation ("confirmation testing for agentic teams").
+
+> **Status: pre-release.** The commands below are wired to the DataDisco QA
+> API but the package is not published to npm yet. Pin to the git repo, or
+> wait for the first tagged release.
+
+## Why this exists
+
+The DataDisco QA GitHub App needs **zero** customer-side install for the
+common path: it resolves each PR's preview deploy from GitHub
+`deployment_status` events (or a configured URL pattern) and posts a
+"DataDisco QA — persona simulation" check run. This CLI covers the cases the
+App can't see:
+
+| Command                                   | For teams that…                                                                                              |
+| ----------------------------------------- | ------------------------------------------------------------------------------------------------------------ |
+| `datadisco-qa report-preview --url <url>` | deploy previews without emitting GitHub Deployment events — report the URL from CI so the pending run starts |
+| `datadisco-qa wait --pr <n>`              | want a pipeline step to block on the QA verdict instead of relying on branch protection                      |
+| `datadisco-qa tunnel --port <port>`       | want to run personas against a build served on their own machine                                             |
+
+## Authentication
+
+Every command needs a **workspace API token** (create one under
+_Workspace settings → Integrations → API tokens_). Pass it with
+`--api-token` or the `DATADISCO_API_TOKEN` env var. The API base URL defaults
+to the hosted app and is overridable with `--api-url` / `DATADISCO_API_URL`.
+
+```sh
+export DATADISCO_API_TOKEN=ddqa_xxx
+```
+
+## Commands
+
+### `report-preview`
+
+Report the deployed preview URL for a PR head SHA so its pending QA run leaves
+`PENDING_PREVIEW` and starts. In GitHub Actions, `--repo`, `--pr`, and `--sha`
+are auto-detected from the `pull_request` event.
+
+```sh
+datadisco-qa report-preview --url https://pr-482.preview.acme.dev
+# explicit outside Actions:
+datadisco-qa report-preview \
+  --url https://pr-482.preview.acme.dev \
+  --repo acme/site --pr 482 --sha "$GIT_SHA"
+```
+
+### `wait`
+
+Block until the PR's QA run reaches a verdict, printing each phase transition.
+Polls every 15s; `--timeout` (minutes, default 30) caps the wait.
+
+```sh
+datadisco-qa wait --pr 482
+```
+
+**Exit codes** (so pipelines can branch on the outcome):
+
+| Code | Meaning                                        |
+| ---- | ---------------------------------------------- |
+| `0`  | Passed, or passed with warnings (non-blocking) |
+| `1`  | Blocked — one or more blocker findings         |
+| `3`  | Run failed before reaching a verdict           |
+| `4`  | No preview deploy arrived; run timed out       |
+| `5`  | `wait` gave up after `--timeout`               |
+
+Superseded / cancelled runs exit `0` — a newer commit's run governs the gate.
+
+### `tunnel`
+
+Expose a locally served build over an HTTPS tunnel and start a QA run against
+it — no preview deploy required. `--repo` and `--sha` default to the local git
+origin remote and `HEAD`; `--pr` is required. Bring your own tunnel with
+`--url` instead of `--port`. Blocks on the verdict unless `--no-wait` is given.
+
+```sh
+datadisco-qa tunnel --port 5173 --pr 482
+```
+
+## Development
+
+```sh
+npm install
+npm test
+npm run build   # tsup → dist/cli.js
+node dist/cli.js --help
+```
+
+Same toolchain as [datadisco-mcp](https://github.com/Data-Disco-Inc/datadisco-mcp):
+tsup, vitest, oxlint/oxfmt, cac.
+
+## Publishing (later)
+
+1. Bump the version and tag.
+2. `npm publish` (publishConfig is already `access: public`).
+3. Ship the companion GitHub Action (`Data-Disco-Inc/qa-action`) that wraps this CLI.

package/dist/cli.js

@@ -0,0 +1,458 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { cac } from "cac";
+import pc2 from "picocolors";
+
+// src/config.ts
+var DEFAULT_API_URL = "https://www.datadisco.com";
+var API_TOKEN_ENV_KEY = "DATADISCO_API_TOKEN";
+var ConfigError = class extends Error {
+};
+function resolveConfig(input = {}) {
+  const env = input.env ?? process.env;
+  const apiUrl = input.apiUrl || env.DATADISCO_API_URL || DEFAULT_API_URL;
+  const apiToken = input.apiToken || env[API_TOKEN_ENV_KEY];
+  if (!apiToken) {
+    throw new ConfigError(`Missing API token: pass --api-token or set ${API_TOKEN_ENV_KEY}.`);
+  }
+  if (!apiUrl.startsWith("https://")) {
+    throw new ConfigError(`API url must be https, got "${apiUrl}".`);
+  }
+  return { apiUrl, apiToken };
+}
+function assertValidPreviewUrl(url) {
+  let parsed;
+  try {
+    parsed = new URL(url);
+  } catch {
+    throw new ConfigError(`Preview url is not a valid URL: "${url}".`);
+  }
+  if (parsed.protocol !== "https:") {
+    throw new ConfigError(`Preview url must be https, got "${url}".`);
+  }
+}
+
+// src/context.ts
+import { readFileSync } from "fs";
+var REPO_PATTERN = /^[^/\s]+\/[^/\s]+$/;
+var PR_REF_PATTERN = /^refs\/pull\/(\d+)\//;
+function resolvePrContext(input = {}) {
+  const env = input.env ?? process.env;
+  const payload = loadEventPayload(input, env);
+  return {
+    repo: resolveRepo(input, env),
+    prNumber: resolvePrNumber(input, env, payload)
+  };
+}
+function resolveRunContext(input = {}) {
+  const env = input.env ?? process.env;
+  const payload = loadEventPayload(input, env);
+  return {
+    repo: resolveRepo(input, env),
+    prNumber: resolvePrNumber(input, env, payload),
+    headSha: resolveHeadSha(input, env, payload)
+  };
+}
+function resolveRepo(input, env = {}) {
+  const repo = input.repo ?? env.GITHUB_REPOSITORY;
+  if (!repo) {
+    throw new ConfigError(
+      "Repository not set: pass --repo owner/name (auto-detected from $GITHUB_REPOSITORY in GitHub Actions)."
+    );
+  }
+  if (!REPO_PATTERN.test(repo)) {
+    throw new ConfigError(`--repo must look like "owner/name", got "${repo}".`);
+  }
+  return repo;
+}
+function resolvePrNumber(input, env = {}, payload) {
+  const candidate = input.pr ?? parsePrFromRef(env.GITHUB_REF) ?? payload.prNumber;
+  const prNumber = Number(candidate);
+  if (candidate === void 0 || !Number.isInteger(prNumber) || prNumber <= 0) {
+    throw new ConfigError(
+      "Pull request number not set: pass --pr <number> (auto-detected from the pull_request event in GitHub Actions)."
+    );
+  }
+  return prNumber;
+}
+function resolveHeadSha(input, env = {}, payload) {
+  const headSha = input.sha ?? payload.headSha ?? env.GITHUB_SHA;
+  if (!headSha) {
+    throw new ConfigError(
+      "Head SHA not set: pass --sha <sha> (the commit the preview was built from)."
+    );
+  }
+  return headSha;
+}
+function parsePrFromRef(ref) {
+  const match = ref?.match(PR_REF_PATTERN);
+  return match ? match[1] : void 0;
+}
+function loadEventPayload(input, env = {}) {
+  const read = input.readEventPayload ?? (() => readEventFile(env.GITHUB_EVENT_PATH));
+  const raw = safeRead(read);
+  if (!isRecord(raw)) return {};
+  const pullRequest = isRecord(raw.pull_request) ? raw.pull_request : void 0;
+  const head = isRecord(pullRequest?.head) ? pullRequest.head : void 0;
+  return {
+    prNumber: numberOrUndefined(pullRequest?.number ?? raw.number),
+    headSha: stringOrUndefined(head?.sha)
+  };
+}
+function readEventFile(path) {
+  if (!path) return void 0;
+  return JSON.parse(readFileSync(path, "utf8"));
+}
+function safeRead(read) {
+  try {
+    return read();
+  } catch {
+    return void 0;
+  }
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function numberOrUndefined(value) {
+  return typeof value === "number" ? value : void 0;
+}
+function stringOrUndefined(value) {
+  return typeof value === "string" ? value : void 0;
+}
+
+// src/api.ts
+var REPORT_PREVIEW_PATH = "/api/qa/report-preview";
+var RUN_STATUS_PATH = "/api/qa/run-status";
+function createApiClient(config, fetchImpl = fetch) {
+  return {
+    reportPreview: (params) => reportPreview(config, params, fetchImpl),
+    getRunStatus: (params) => getRunStatus(config, params, fetchImpl)
+  };
+}
+async function reportPreview(config, params, fetchImpl) {
+  const response = await fetchImpl(joinUrl(config.apiUrl, REPORT_PREVIEW_PATH), {
+    method: "POST",
+    headers: {
+      authorization: `Bearer ${config.apiToken}`,
+      "content-type": "application/json"
+    },
+    body: JSON.stringify({
+      repo: params.repo,
+      prNumber: params.prNumber,
+      headSha: params.headSha,
+      url: params.url
+    })
+  });
+  const payload = await readJson(response);
+  if (response.ok && isString(payload.runId)) {
+    return { ok: true, runId: payload.runId };
+  }
+  return { ok: false, status: response.status, error: errorMessage(payload) };
+}
+async function getRunStatus(config, params, fetchImpl) {
+  const url = new URL(joinUrl(config.apiUrl, RUN_STATUS_PATH));
+  url.searchParams.set("repo", params.repo);
+  url.searchParams.set("prNumber", String(params.prNumber));
+  const response = await fetchImpl(url.toString(), {
+    headers: { authorization: `Bearer ${config.apiToken}` }
+  });
+  const payload = await readJson(response);
+  if (response.ok && isRunStatus(payload.run)) {
+    return { ok: true, run: payload.run };
+  }
+  return { ok: false, status: response.status, error: errorMessage(payload) };
+}
+function joinUrl(base, path) {
+  return `${base.replace(/\/+$/, "")}${path}`;
+}
+async function readJson(response) {
+  try {
+    const parsed = await response.json();
+    return isRecord2(parsed) ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+function errorMessage(payload) {
+  return isString(payload.error) ? payload.error : "Request failed.";
+}
+function isRecord2(value) {
+  return typeof value === "object" && value !== null;
+}
+function isString(value) {
+  return typeof value === "string";
+}
+function isRunStatus(value) {
+  return isRecord2(value) && isString(value.id) && isString(value.status) && typeof value.blockerCount === "number";
+}
+
+// src/logger.ts
+import pc from "picocolors";
+var consoleLogger = {
+  info: (message) => console.error(message),
+  success: (message) => console.error(pc.green(message)),
+  warn: (message) => console.error(pc.yellow(message)),
+  error: (message) => console.error(pc.red(message))
+};
+var LEVEL_LOGGERS = {
+  success: (logger, message) => logger.success(message),
+  warn: (logger, message) => logger.warn(message),
+  error: (logger, message) => logger.error(message)
+};
+function logAtLevel(logger, level, message) {
+  LEVEL_LOGGERS[level](logger, message);
+}
+
+// src/commands/deps.ts
+var defaultDeps = {
+  createApi: (config) => createApiClient(config),
+  logger: consoleLogger,
+  sleep: (ms) => new Promise((resolve) => setTimeout(resolve, ms)),
+  now: () => Date.now()
+};
+
+// src/commands/report-preview.ts
+async function runReportPreview(options, deps = defaultDeps) {
+  if (!options.url) {
+    deps.logger.error("--url is required (the deployed preview URL).");
+    return 1;
+  }
+  assertValidPreviewUrl(options.url);
+  const config = resolveConfig(options);
+  const context = resolveRunContext(options);
+  const api = deps.createApi(config);
+  const outcome = await api.reportPreview({ ...context, url: options.url });
+  if (!outcome.ok) {
+    deps.logger.error(`Could not report preview URL: ${outcome.error}`);
+    return 1;
+  }
+  deps.logger.success(
+    `Preview reported for ${context.repo}#${context.prNumber} \u2014 QA run ${outcome.runId} queued.`
+  );
+  return 0;
+}
+
+// src/git.ts
+import { execFileSync } from "child_process";
+var defaultRunner = (args) => execFileSync("git", args, { encoding: "utf8" }).trim();
+function detectRepoFullName(run2 = defaultRunner) {
+  const remote = tryGit(run2, ["remote", "get-url", "origin"]);
+  return remote ? parseRepoFromRemote(remote) : void 0;
+}
+function detectHeadSha(run2 = defaultRunner) {
+  return tryGit(run2, ["rev-parse", "HEAD"]);
+}
+function parseRepoFromRemote(remote) {
+  const match = remote.match(/github\.com[:/]([^/\s]+\/[^/\s]+?)(?:\.git)?$/);
+  return match ? match[1] : void 0;
+}
+function tryGit(run2, args) {
+  try {
+    return run2(args) || void 0;
+  } catch {
+    return void 0;
+  }
+}
+
+// src/tunnel-provider.ts
+import localtunnel from "localtunnel";
+async function openTunnel(port) {
+  const tunnel = await localtunnel({ port });
+  return { url: tunnel.url, close: () => tunnel.close() };
+}
+
+// src/verdict.ts
+var EXIT_CODE = {
+  PASSED: 0,
+  BLOCKED: 1,
+  RUN_FAILED: 3,
+  TIMED_OUT: 4,
+  WAIT_TIMEOUT: 5
+};
+var TERMINAL_STATUSES = /* @__PURE__ */ new Set(["COMPLETED", "FAILED", "TIMED_OUT", "SUPERSEDED", "CANCELLED"]);
+function isTerminalStatus(status) {
+  return TERMINAL_STATUSES.has(status);
+}
+function resolveVerdictOutcome(run2) {
+  switch (run2.status) {
+    case "COMPLETED":
+      return completedOutcome(run2);
+    case "FAILED":
+      return {
+        exitCode: EXIT_CODE.RUN_FAILED,
+        level: "error",
+        headline: run2.statusMessage ?? "QA run failed before reaching a verdict."
+      };
+    case "TIMED_OUT":
+      return {
+        exitCode: EXIT_CODE.TIMED_OUT,
+        level: "error",
+        headline: run2.statusMessage ?? "No preview deploy arrived before the run timed out."
+      };
+    case "SUPERSEDED":
+      return {
+        exitCode: EXIT_CODE.PASSED,
+        level: "warn",
+        headline: "A newer commit superseded this run \u2014 its verdict governs."
+      };
+    case "CANCELLED":
+      return {
+        exitCode: EXIT_CODE.PASSED,
+        level: "warn",
+        headline: run2.statusMessage ?? "QA run was cancelled."
+      };
+    default:
+      return {
+        exitCode: EXIT_CODE.RUN_FAILED,
+        level: "error",
+        headline: `Unexpected terminal status "${run2.status}".`
+      };
+  }
+}
+function completedOutcome(run2) {
+  const counts = `${run2.blockerCount} blocker(s), ${run2.warningCount} warning(s), ${run2.passedCount} passed`;
+  if (run2.verdict === "BLOCKED") {
+    return {
+      exitCode: EXIT_CODE.BLOCKED,
+      level: "error",
+      headline: `QA blocked the merge \u2014 ${counts}.`
+    };
+  }
+  if (run2.verdict === "PASSED_WITH_WARNINGS") {
+    return {
+      exitCode: EXIT_CODE.PASSED,
+      level: "warn",
+      headline: `QA passed with warnings \u2014 ${counts}.`
+    };
+  }
+  return {
+    exitCode: EXIT_CODE.PASSED,
+    level: "success",
+    headline: `QA passed \u2014 ${counts}.`
+  };
+}
+
+// src/commands/wait-loop.ts
+var DEFAULT_TIMEOUT_MINUTES = 30;
+var POLL_INTERVAL_MS = 15e3;
+var MINUTE_MS = 6e4;
+async function waitForVerdict(api, context, deps, timeoutMs) {
+  const deadline = deps.now() + timeoutMs;
+  deps.logger.info(`Waiting for QA verdict on ${context.repo}#${context.prNumber}\u2026`);
+  let lastStatus;
+  while (true) {
+    const outcome = await api.getRunStatus(context);
+    if (outcome.ok) {
+      if (outcome.run.status !== lastStatus) {
+        deps.logger.info(`  ${statusLine(outcome.run)}`);
+        lastStatus = outcome.run.status;
+      }
+      if (isTerminalStatus(outcome.run.status)) {
+        const verdict = resolveVerdictOutcome(outcome.run);
+        logAtLevel(deps.logger, verdict.level, verdict.headline);
+        return verdict.exitCode;
+      }
+    } else if (outcome.status !== 404) {
+      deps.logger.error(`Could not read QA run status: ${outcome.error}`);
+      return 1;
+    }
+    if (deps.now() >= deadline) {
+      deps.logger.error(
+        `Timed out after ${Math.round(timeoutMs / MINUTE_MS)} min waiting for a verdict.`
+      );
+      return EXIT_CODE.WAIT_TIMEOUT;
+    }
+    await deps.sleep(POLL_INTERVAL_MS);
+  }
+}
+function resolveTimeoutMs(timeout) {
+  if (timeout === void 0) return DEFAULT_TIMEOUT_MINUTES * MINUTE_MS;
+  const minutes = Number(timeout);
+  if (!Number.isFinite(minutes) || minutes <= 0) {
+    throw new ConfigError(`--timeout must be a positive number of minutes, got "${timeout}".`);
+  }
+  return minutes * MINUTE_MS;
+}
+function statusLine(run2) {
+  return run2.statusMessage ? `${run2.status} \u2014 ${run2.statusMessage}` : run2.status;
+}
+
+// src/commands/tunnel.ts
+var defaultTunnelDeps = {
+  ...defaultDeps,
+  openTunnel,
+  detectRepo: () => detectRepoFullName(),
+  detectHeadSha: () => detectHeadSha()
+};
+async function runTunnel(options, deps = defaultTunnelDeps) {
+  const config = resolveConfig(options);
+  const context = resolveRunContext({
+    repo: options.repo ?? deps.detectRepo(),
+    pr: options.pr,
+    sha: options.sha ?? deps.detectHeadSha(),
+    env: {}
+  });
+  const api = deps.createApi(config);
+  const tunnel = await resolvePublicTunnel(options, deps);
+  try {
+    assertValidPreviewUrl(tunnel.url);
+    deps.logger.info(`Exposing local build at ${tunnel.url}`);
+    const reported = await api.reportPreview({ ...context, url: tunnel.url });
+    if (!reported.ok) {
+      deps.logger.error(`Could not start QA run: ${reported.error}`);
+      return 1;
+    }
+    deps.logger.success(`QA run ${reported.runId} queued for ${context.repo}#${context.prNumber}.`);
+    if (options.wait === false) return 0;
+    return await waitForVerdict(api, context, deps, resolveTimeoutMs(options.timeout));
+  } finally {
+    tunnel.close();
+  }
+}
+function resolvePublicTunnel(options, deps) {
+  if (options.url) {
+    return Promise.resolve({
+      url: options.url,
+      close: () => {
+      }
+    });
+  }
+  const port = Number(options.port);
+  if (!Number.isInteger(port) || port <= 0) {
+    throw new ConfigError(
+      "--port <number> is required to open a tunnel (or pass --url for an externally managed tunnel)."
+    );
+  }
+  return deps.openTunnel(port);
+}
+
+// src/commands/wait.ts
+async function runWait(options, deps = defaultDeps) {
+  const config = resolveConfig(options);
+  const context = resolvePrContext(options);
+  const api = deps.createApi(config);
+  return waitForVerdict(api, context, deps, resolveTimeoutMs(options.timeout));
+}
+
+// src/cli.ts
+var cli = cac("datadisco-qa");
+cli.command("report-preview", "Report a PR's preview-deploy URL so its pending QA run can start").option("--url <url>", "The deployed preview URL for the PR head SHA").option("--repo <owner/name>", "Repository the PR belongs to").option("--pr <number>", "Pull request number").option("--sha <sha>", "Head SHA the preview was built from").option("--api-url <url>", "DataDisco API base URL").option("--api-token <token>", "Workspace API token (or DATADISCO_API_TOKEN)").action((options) => run(() => runReportPreview(options)));
+cli.command("wait", "Block until the PR's QA run reaches a verdict").option("--repo <owner/name>", "Repository the PR belongs to").option("--pr <number>", "Pull request number").option("--timeout <minutes>", "Give up after this many minutes (default 30)").option("--api-url <url>", "DataDisco API base URL").option("--api-token <token>", "Workspace API token (or DATADISCO_API_TOKEN)").action((options) => run(() => runWait(options)));
+cli.command("tunnel", "Expose a local build and start a QA run against it").option("--port <port>", "Local port serving the build").option("--url <url>", "Use an externally managed tunnel URL instead of --port").option("--repo <owner/name>", "Repository (defaults to the git origin remote)").option("--pr <number>", "Pull request number").option("--sha <sha>", "Head SHA (defaults to the local git HEAD)").option("--no-wait", "Queue the run and exit without waiting for a verdict").option("--timeout <minutes>", "Give up waiting after this many minutes").option("--api-url <url>", "DataDisco API base URL").option("--api-token <token>", "Workspace API token (or DATADISCO_API_TOKEN)").action((options) => run(() => runTunnel(options)));
+async function run(command) {
+  try {
+    process.exitCode = await command();
+  } catch (error) {
+    if (error instanceof ConfigError) {
+      console.error(pc2.red(error.message));
+      process.exitCode = 1;
+      return;
+    }
+    console.error(pc2.red(error instanceof Error ? error.message : String(error)));
+    process.exitCode = 1;
+  }
+}
+cli.help();
+cli.version("0.0.1");
+cli.parse();

package/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "@datadisco/qa",
+  "version": "0.1.0",
+  "description": "CI companion for DataDisco QA — report preview URLs, wait on persona-simulation gates, and tunnel local builds into QA runs.",
+  "keywords": [
+    "ci",
+    "datadisco",
+    "persona",
+    "preview",
+    "qa",
+    "testing"
+  ],
+  "homepage": "https://github.com/Data-Disco-Inc/datadisco-qa#readme",
+  "bugs": "https://github.com/Data-Disco-Inc/datadisco-qa/issues",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Data-Disco-Inc/datadisco-qa.git"
+  },
+  "bin": {
+    "datadisco-qa": "dist/cli.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "typecheck": "tsc --noEmit",
+    "lint": "oxlint",
+    "format": "oxfmt",
+    "format:check": "oxfmt --check",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "prepare": "npm run build"
+  },
+  "dependencies": {
+    "cac": "^7.0.0",
+    "localtunnel": "^2.0.2",
+    "picocolors": "^1.1.1"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "oxfmt": "^0.55.0",
+    "oxlint": "^1.70.0",
+    "tsup": "^8.5.1",
+    "typescript": "^6.0.3",
+    "vitest": "^4.1.9"
+  },
+  "engines": {
+    "node": ">=20.19.0"
+  }
+}