From edf65c89a45b4a2e45943da94e3c7c87e1f64212 Mon Sep 17 00:00:00 2001 From: winterfx Date: Thu, 13 Aug 2026 10:00:50 +0800 Subject: [PATCH 1/4] refactor(scheduler): deliver deterministic tool via agent-compose workspace Replace the base64-chunked-env-var smuggling of the compiled draft-pr/ issue-triage tool bundles with agent-compose's native git `workspace`, checked out fresh into every scheduler sandbox. Removes the mktemp/ base64-decode dance from both scheduler scripts in favor of invoking the tool directly from $WORKSPACE/workflow-repo, and commits the plain esbuild bundles (agents/*/tool/main.mjs) alongside the existing generated scheduler.js artifacts, checked for staleness the same way. workspace.ref is pinned to a commit SHA (unlike skills/scheduler.script, which stay on `main`) because workspace refs are re-resolved on every new sandbox rather than snapshotted once at `agent-compose up` - a moving ref could otherwise serve a different tool commit mid-workflow across a single Issue/PR's multi-day lifecycle. Adds scripts/pin-workspace-ref.ts to re-stamp both workspace.ref fields to HEAD before a deploy. --- .prettierignore | 1 + agent-compose.yml | 12 + agents/draft-pr/scheduler.js | 30 +- agents/draft-pr/tool/main.mjs | 7957 ++++++++++++++++++++++++ agents/issue-triage/scheduler.js | 22 +- agents/issue-triage/tool/main.mjs | 6047 ++++++++++++++++++ package.json | 1 + scripts/build-tools.ts | 72 +- scripts/pin-workspace-ref.ts | 62 + src/schedulers/draft-pr.js | 30 +- src/schedulers/issue-triage.js | 22 +- test/build-tools.test.ts | 53 +- test/draft-pr-scheduler-script.test.ts | 13 +- test/scheduler-script.test.ts | 11 +- 14 files changed, 14184 insertions(+), 149 deletions(-) create mode 100644 agents/draft-pr/tool/main.mjs create mode 100644 agents/issue-triage/tool/main.mjs create mode 100644 scripts/pin-workspace-ref.ts diff --git a/.prettierignore b/.prettierignore index ea32a92..4fedb5a 100644 --- a/.prettierignore +++ b/.prettierignore @@ -1,2 +1,3 @@ dist/ agents/*/scheduler.js +agents/*/tool/main.mjs diff --git a/agent-compose.yml b/agent-compose.yml index fa86e0f..95f4d97 100644 --- a/agent-compose.yml +++ b/agent-compose.yml @@ -36,6 +36,12 @@ agents: ref: main path: agents/issue-triage + workspace: + provider: git + url: https://github.com/winterfx/engineering-agent-workflows.git + ref: 78db6672cbd38e07d10621f937d55f22c1fcfbab + target: workflow-repo + scheduler: enabled: true sandbox_policy: new @@ -80,6 +86,12 @@ agents: ref: main path: agents/draft-pr + workspace: + provider: git + url: https://github.com/winterfx/engineering-agent-workflows.git + ref: 78db6672cbd38e07d10621f937d55f22c1fcfbab + target: workflow-repo + scheduler: enabled: true sandbox_policy: new diff --git a/agents/draft-pr/scheduler.js b/agents/draft-pr/scheduler.js index 6414ccb..674b99f 100644 --- a/agents/draft-pr/scheduler.js +++ b/agents/draft-pr/scheduler.js @@ -4,9 +4,9 @@ const GITHUB_REVIEW_TOPIC = "webhook.github.pull_request_review"; const GITHUB_WORKFLOW_RUN_TOPIC = "webhook.github.workflow_run"; const READY_LABEL = "agent:ready"; const APPROVED_LABEL = "agent:approved"; -const WORKFLOW_TOOL_BASE64 = "var __defProp = Object.defineProperty;
var __export = (target, all) => {
  for (var name in all)
    __defProp(target, name, { get: all[name], enumerable: true });
};

// src/draft-pr/main.ts
import { readFile as readFile2 } from "node:fs/promises";
import path2 from "node:path";
import { fileURLToPath } from "node:url";

// src/github/app-auth.ts
import { sign } from "node:crypto";

// src/github/fetch-retry.ts
var MAX_ATTEMPTS = 3;
var RETRYABLE_STATUS_CODES = /* @__PURE__ */ new Set([502, 503, 504]);
async function fetchWithRetry(options) {
  const attempts = options.retryable ? MAX_ATTEMPTS : 1;
  let lastError;
  for (let attempt = 1; attempt <= attempts; attempt += 1) {
    try {
      const response = await options.request(options.input, options.init);
      if (attempt === attempts || !RETRYABLE_STATUS_CODES.has(response.status)) {
        return response;
      }
      await response.body?.cancel().catch(() => void 0);
    } catch (error) {
      lastError = error;
      if (attempt === attempts) {
        throw new Error(
          `${options.operation} transport failed after ${attemptLabel(attempts)}`,
          { cause: error }
        );
      }
    }
    await (options.sleep ?? sleep)(retryDelayMilliseconds(attempt));
  }
  throw new Error(`${options.operation} transport failed`, {
    cause: lastError
  });
}
function attemptLabel(attempts) {
  return `${attempts} ${attempts === 1 ? "attempt" : "attempts"}`;
}
function retryDelayMilliseconds(attempt) {
  const exponential = 250 * 2 ** (attempt - 1);
  return exponential + Math.floor(Math.random() * exponential);
}
function sleep(milliseconds) {
  return new Promise((resolve) => setTimeout(resolve, milliseconds));
}

// src/github/app-auth.ts
var DEFAULT_GITHUB_API_URL = "https://api.github.com";
var GITHUB_API_VERSION = "2022-11-28";
async function resolveGitHubToken(repository, env = process.env, dependencies = {}) {
  const configuredToken = env.GITHUB_TOKEN?.trim() ?? "";
  if (configuredToken) return configuredToken;
  const clientID = env.GITHUB_APP_CLIENT_ID?.trim() ?? "";
  const appID = env.GITHUB_APP_ID?.trim() ?? "";
  const privateKeyBase64 = env.GITHUB_APP_PRIVATE_KEY_BASE64?.trim() ?? "";
  const configuredInstallationID = env.GITHUB_APP_INSTALLATION_ID?.trim() ?? "";
  const hasAppConfiguration = Boolean(
    clientID || appID || privateKeyBase64 || configuredInstallationID
  );
  if (!hasAppConfiguration) return "";
  const issuer = clientID || appID;
  if (!issuer) {
    throw new Error(
      "GitHub App authentication requires GITHUB_APP_CLIENT_ID or GITHUB_APP_ID"
    );
  }
  if (!privateKeyBase64) {
    throw new Error(
      "GitHub App authentication requires GITHUB_APP_PRIVATE_KEY_BASE64"
    );
  }
  const privateKey = decodePrivateKey(privateKeyBase64);
  const jwt = createAppJWT(
    issuer,
    privateKey,
    dependencies.now?.() ?? Date.now()
  );
  const baseUrl = (env.GITHUB_API_URL?.trim() || DEFAULT_GITHUB_API_URL).replace(/\/+$/, "");
  const request = dependencies.fetch ?? fetch;
  const installationID = configuredInstallationID ? validateInstallationID(configuredInstallationID) : await findInstallationID(
    baseUrl,
    repository,
    jwt,
    request,
    dependencies.sleep
  );
  const tokenPath = `/app/installations/${installationID}/access_tokens`;
  const response = await fetchWithRetry({
    request,
    input: `${baseUrl}${tokenPath}`,
    init: {
      method: "POST",
      headers: appHeaders(jwt)
    },
    operation: `GitHub App POST ${tokenPath}`,
    retryable: true,
    ...dependencies.sleep ? { sleep: dependencies.sleep } : {}
  });
  if (!response.ok) {
    throw githubAppResponseError("installation token request", response);
  }
  const value = await response.json();
  const token = value.token?.trim() ?? "";
  if (!token) {
    throw new Error("GitHub App installation token response has no token");
  }
  return token;
}
function createAppJWT(issuer, privateKey, nowMilliseconds) {
  const now = Math.floor(nowMilliseconds / 1e3);
  const header = encodeJWTPart({ alg: "RS256", typ: "JWT" });
  const payload = encodeJWTPart({
    iat: now - 60,
    exp: now + 9 * 60,
    iss: issuer
  });
  const unsignedToken = `${header}.${payload}`;
  let signature;
  try {
    signature = sign("RSA-SHA256", Buffer.from(unsignedToken), privateKey);
  } catch {
    throw new Error(
      "GITHUB_APP_PRIVATE_KEY_BASE64 is not a valid RSA private key"
    );
  }
  return `${unsignedToken}.${signature.toString("base64url")}`;
}
async function findInstallationID(baseUrl, repository, jwt, request, sleepDependency) {
  const path3 = `/repos/${repositoryPath(repository)}/installation`;
  const response = await fetchWithRetry({
    request,
    input: `${baseUrl}${path3}`,
    init: {
      method: "GET",
      headers: appHeaders(jwt)
    },
    operation: `GitHub App GET ${path3}`,
    retryable: true,
    ...sleepDependency ? { sleep: sleepDependency } : {}
  });
  if (!response.ok) {
    throw githubAppResponseError("installation lookup", response);
  }
  const value = await response.json();
  if (!Number.isSafeInteger(value.id) || (value.id ?? 0) <= 0) {
    throw new Error("GitHub App installation response has no valid ID");
  }
  return String(value.id);
}
function appHeaders(jwt) {
  return {
    Accept: "application/vnd.github+json",
    Authorization: `Bearer ${jwt}`,
    "X-GitHub-Api-Version": GITHUB_API_VERSION,
    "User-Agent": "engineering-agent-workflows/github-app-auth"
  };
}
function decodePrivateKey(value) {
  let decoded;
  try {
    decoded = Buffer.from(value, "base64").toString("utf8").trim();
  } catch {
    throw new Error("GITHUB_APP_PRIVATE_KEY_BASE64 is not valid base64");
  }
  if (!/^-----BEGIN (?:RSA )?PRIVATE KEY-----/.test(decoded)) {
    throw new Error(
      "GITHUB_APP_PRIVATE_KEY_BASE64 must decode to a PEM private key"
    );
  }
  return decoded;
}
function validateInstallationID(value) {
  if (!/^[1-9][0-9]*$/.test(value)) {
    throw new Error("GITHUB_APP_INSTALLATION_ID must be a positive integer");
  }
  return value;
}
function repositoryPath(repository) {
  const parts = repository.split("/");
  if (parts.length !== 2 || parts.some((part) => !part.trim())) {
    throw new Error(`invalid GitHub repository: ${repository}`);
  }
  return parts.map(encodeURIComponent).join("/");
}
function encodeJWTPart(value) {
  return Buffer.from(JSON.stringify(value)).toString("base64url");
}
function githubAppResponseError(operation, response) {
  const status = `${response.status}${response.statusText ? ` ${response.statusText}` : ""}`;
  return new Error(`GitHub App ${operation} failed with ${status}`);
}

// src/issues/search.ts
function issueSearchText(title) {
  return title.replace(/^\[[^\]]+\]\s*:?\s*/, "").replace(/["'`:+(){}[\]\\]/g, " ").replace(/\s+/g, " ").trim().slice(0, 120);
}

// src/runtime/text.ts
function truncateText(value, max) {
  return value.length <= max ? value : value.slice(0, max);
}

// src/github/client.ts
var GitHubClient = class {
  #token;
  #baseUrl;
  #fetch;
  #sleep;
  constructor(options = {}) {
    this.#token = options.token?.trim() ?? "";
    this.#baseUrl = (options.baseUrl ?? "https://api.github.com").replace(
      /\/+$/,
      ""
    );
    this.#fetch = options.fetch ?? fetch;
    this.#sleep = options.sleep;
  }
  async getIssue(repository, issueNumber) {
    const issue2 = await this.#request(
      "GET",
      `/repos/${repositoryPath2(repository)}/issues/${issueNumber}`
    );
    if (issue2.pull_request) {
      throw new Error("GitHub pull request payload is not an Issue");
    }
    return normalizeIssue(issue2);
  }
  async searchCandidates(repository, issue2, limit) {
    const title = issueSearchText(issue2.title);
    if (!title) return [];
    const query = new URLSearchParams({
      q: `repo:${repository} is:issue in:title ${title}`,
      per_page: String(Math.min(Math.max(limit + 1, 1), 100))
    });
    const response = await this.#request(
      "GET",
      `/search/issues?${query.toString()}`
    );
    return (response.items ?? []).filter(
      (candidate) => candidate.number !== issue2.number && !candidate.pull_request
    ).slice(0, limit).map((candidate) => ({
      number: candidate.number,
      title: candidate.title,
      body: truncateText(candidate.body ?? "", 4e3),
      state: candidate.state,
      labels: labelNames(candidate.labels),
      url: candidate.html_url
    }));
  }
  async listComments(repository, issueNumber) {
    const comments = [];
    for (let page = 1; ; page += 1) {
      const batch = await this.#request(
        "GET",
        `/repos/${repositoryPath2(repository)}/issues/${issueNumber}/comments?per_page=100&page=${page}`
      );
      comments.push(...batch.map(normalizeComment));
      if (batch.length < 100) return comments;
    }
  }
  async ensureLabel(repository, name, color, description) {
    const path3 = `/repos/${repositoryPath2(repository)}/labels/${encodeURIComponent(name)}`;
    const response = await this.#rawRequest("GET", path3);
    if (response.ok) return;
    if (response.status !== 404) {
      throw await responseError("GET", path3, response);
    }
    await this.#request("POST", `/repos/${repositoryPath2(repository)}/labels`, {
      name,
      color: normalizeColor(color),
      description: description?.trim() || "Managed by engineering-agent-workflows"
    });
  }
  async getRepositoryDefaultBranch(repository) {
    const value = await this.#request(
      "GET",
      `/repos/${repositoryPath2(repository)}`
    );
    const branch = value.default_branch?.trim();
    if (!branch) throw new Error("GitHub repository has no default branch");
    return branch;
  }
  async getPullRequest(repository, pullRequestNumber) {
    const value = await this.#request(
      "GET",
      `/repos/${repositoryPath2(repository)}/pulls/${pullRequestNumber}`
    );
    return normalizePullRequest(value);
  }
  async listOpenPullRequests(repository) {
    const values = [];
    for (let page = 1; ; page += 1) {
      const batch = await this.#request(
        "GET",
        `/repos/${repositoryPath2(repository)}/pulls?state=open&per_page=100&page=${page}`
      );
      values.push(...batch.map(normalizePullRequest));
      if (batch.length < 100) return values;
    }
  }
  async listReviewComments(repository, pullRequestNumber) {
    const comments = [];
    for (let page = 1; ; page += 1) {
      const batch = await this.#request(
        "GET",
        `/repos/${repositoryPath2(repository)}/pulls/${pullRequestNumber}/comments?per_page=100&page=${page}`
      );
      comments.push(...batch.map(normalizeReviewComment));
      if (batch.length < 100) return comments;
    }
  }
  async getPullRequestReview(repository, pullRequestNumber, reviewId) {
    const review = await this.#request(
      "GET",
      `/repos/${repositoryPath2(repository)}/pulls/${pullRequestNumber}/reviews/${reviewId}`
    );
    return normalizePullRequestReview(review);
  }
  async listCheckRuns(repository, ref) {
    if (!/^[0-9a-f]{40}$/.test(ref)) {
      throw new Error("invalid GitHub check run ref");
    }
    const runs = [];
    for (let page = 1; ; page += 1) {
      const value = await this.#request(
        "GET",
        `/repos/${repositoryPath2(repository)}/commits/${ref}/check-runs?per_page=100&page=${page}`
      );
      const batch = value.check_runs ?? [];
      runs.push(...batch.map(normalizeCheckRun));
      if (batch.length < 100) return runs;
    }
  }
  async listCheckRunAnnotations(repository, checkRunId) {
    if (!Number.isSafeInteger(checkRunId) || checkRunId <= 0) {
      throw new Error("invalid GitHub check run ID");
    }
    const annotations = [];
    for (let page = 1; ; page += 1) {
      const batch = await this.#request(
        "GET",
        `/repos/${repositoryPath2(repository)}/check-runs/${checkRunId}/annotations?per_page=100&page=${page}`
      );
      annotations.push(...batch.map(normalizeCheckRunAnnotation));
      if (batch.length < 100) return annotations;
    }
  }
  async listOpenPullRequestsByHead(repository, branch) {
    const owner = repository.split("/")[0];
    const query = new URLSearchParams({
      state: "open",
      head: `${owner}:${branch}`,
      per_page: "100"
    });
    const values = await this.#request(
      "GET",
      `/repos/${repositoryPath2(repository)}/pulls?${query.toString()}`
    );
    return values.map(normalizePullRequest);
  }
  async createDraftPullRequest(repository, input) {
    const value = await this.#request(
      "POST",
      `/repos/${repositoryPath2(repository)}/pulls`,
      { ...input, draft: true }
    );
    return normalizePullRequest(value);
  }
  async addLabels(repository, issueNumber, labels) {
    if (labels.length === 0) return;
    await this.#request(
      "POST",
      `/repos/${repositoryPath2(repository)}/issues/${issueNumber}/labels`,
      { labels }
    );
  }
  async removeLabel(repository, issueNumber, label) {
    const path3 = `/repos/${repositoryPath2(repository)}/issues/${issueNumber}/labels/${encodeURIComponent(label)}`;
    const response = await this.#rawRequest("DELETE", path3);
    if (!response.ok && response.status !== 404) {
      throw await responseError("DELETE", path3, response);
    }
  }
  async createComment(repository, issueNumber, body) {
    const comment = await this.#request(
      "POST",
      `/repos/${repositoryPath2(repository)}/issues/${issueNumber}/comments`,
      { body }
    );
    return normalizeComment(comment);
  }
  async updateComment(repository, _issueNumber, commentID, body) {
    const comment = await this.#request(
      "PATCH",
      `/repos/${repositoryPath2(repository)}/issues/comments/${commentID}`,
      { body }
    );
    return normalizeComment(comment);
  }
  async #request(method, path3, body) {
    const response = await this.#rawRequest(method, path3, body);
    if (!response.ok) throw await responseError(method, path3, response);
    return await response.json();
  }
  #rawRequest(method, path3, body) {
    const headers = {
      Accept: "application/vnd.github+json",
      "X-GitHub-Api-Version": "2022-11-28",
      "User-Agent": "engineering-agent-workflows/issue-triage"
    };
    if (this.#token) headers.Authorization = `Bearer ${this.#token}`;
    if (body !== void 0) headers["Content-Type"] = "application/json";
    return fetchWithRetry({
      request: this.#fetch,
      input: `${this.#baseUrl}${path3}`,
      init: {
        method,
        headers,
        ...body === void 0 ? {} : { body: JSON.stringify(body) }
      },
      operation: `GitHub API ${method} ${path3}`,
      retryable: method === "GET",
      ...this.#sleep ? { sleep: this.#sleep } : {}
    });
  }
};
function repositoryPath2(repository) {
  const parts = repository.split("/");
  if (parts.length !== 2 || parts.some((part) => !part.trim())) {
    throw new Error(`invalid GitHub repository: ${repository}`);
  }
  return parts.map(encodeURIComponent).join("/");
}
function normalizeIssue(issue2) {
  return {
    number: issue2.number,
    title: issue2.title,
    body: issue2.body,
    state: issue2.state,
    htmlUrl: issue2.html_url,
    updatedAt: issue2.updated_at,
    labels: labelNames(issue2.labels),
    ...issue2.user ? { user: normalizeUser(issue2.user) } : {}
  };
}
function normalizeComment(comment) {
  return {
    id: comment.id,
    body: comment.body,
    ...comment.html_url ? { htmlUrl: comment.html_url } : {},
    ...comment.created_at ? { createdAt: comment.created_at } : {},
    ...comment.user ? { user: normalizeUser(comment.user) } : {}
  };
}
function normalizePullRequest(value) {
  return {
    number: value.number,
    url: value.html_url,
    state: value.state,
    draft: value.draft ?? false,
    head: value.head.ref,
    ...value.head.sha ? { headSha: value.head.sha } : {},
    ...value.head.repo?.full_name ? { headRepository: value.head.repo.full_name } : {},
    base: value.base.ref
  };
}
function normalizeReviewComment(comment) {
  return {
    id: comment.id,
    body: comment.body,
    path: comment.path,
    ...comment.user ? { user: normalizeUser(comment.user) } : {},
    ...comment.html_url ? { htmlUrl: comment.html_url } : {},
    ...comment.created_at ? { createdAt: comment.created_at } : {},
    ...comment.line != null ? { line: comment.line } : {},
    ...comment.original_line != null ? { originalLine: comment.original_line } : {},
    ...comment.start_line != null ? { startLine: comment.start_line } : {},
    ...comment.original_start_line != null ? { originalStartLine: comment.original_start_line } : {},
    ...comment.side ? { side: comment.side } : {},
    ...comment.start_side ? { startSide: comment.start_side } : {},
    ...comment.diff_hunk ? { diffHunk: comment.diff_hunk } : {},
    ...comment.commit_id ? { commitId: comment.commit_id } : {},
    ...comment.original_commit_id ? { originalCommitId: comment.original_commit_id } : {},
    ...comment.in_reply_to_id !== void 0 ? { inReplyToId: comment.in_reply_to_id } : {},
    ...comment.pull_request_review_id !== void 0 ? { pullRequestReviewId: comment.pull_request_review_id } : {}
  };
}
function normalizePullRequestReview(review) {
  return {
    id: review.id,
    body: review.body ?? "",
    state: review.state,
    commitId: review.commit_id,
    authorAssociation: review.author_association,
    ...review.user ? { user: normalizeUser(review.user) } : {},
    ...review.html_url ? { htmlUrl: review.html_url } : {},
    ...review.submitted_at ? { submittedAt: review.submitted_at } : {}
  };
}
function normalizeCheckRun(value) {
  const checkSuiteId = value.check_suite?.id;
  if (!Number.isSafeInteger(checkSuiteId) || checkSuiteId <= 0) {
    throw new Error(`GitHub check run ${value.id} has no valid check suite ID`);
  }
  return {
    id: value.id,
    checkSuiteId,
    name: truncateText(value.name ?? "", 300),
    status: value.status,
    ...value.conclusion ? { conclusion: value.conclusion } : {},
    ...value.html_url ? { htmlUrl: value.html_url } : {},
    output: {
      title: truncateText(value.output?.title ?? "", 1e3),
      summary: truncateText(value.output?.summary ?? "", 8e3),
      text: truncateText(value.output?.text ?? "", 8e3)
    }
  };
}
function normalizeCheckRunAnnotation(value) {
  return {
    path: truncateText(value.path ?? "", 1e3),
    startLine: value.start_line,
    endLine: value.end_line,
    level: truncateText(value.annotation_level ?? "", 50),
    message: truncateText(value.message ?? "", 2e3),
    ...value.title ? { title: truncateText(value.title, 500) } : {},
    ...value.raw_details ? { rawDetails: truncateText(value.raw_details, 4e3) } : {}
  };
}
function normalizeUser(user) {
  return {
    login: user.login,
    ...user.id !== void 0 ? { id: user.id } : {},
    ...user.type ? { type: user.type } : {}
  };
}
function labelNames(labels) {
  return labels.map((label) => typeof label === "string" ? label : label.name).filter((label) => label.trim() !== "");
}
function normalizeColor(color) {
  const normalized = color.trim().replace(/^#/, "");
  return /^[0-9a-f]{6}$/i.test(normalized) ? normalized : "ededed";
}
async function responseError(method, path3, response) {
  const text = await response.text().catch(() => "");
  return new Error(
    `GitHub API ${method} ${path3} failed with HTTP ${response.status}: ${truncateText(text, 1e3)}`
  );
}

// src/issues/types.ts
function isRepositorySlug(value) {
  return /^[^/\s]+\/[^/\s]+$/.test(value);
}

// src/runtime/cli.ts
function requiredArgumentValue(args, index, name) {
  const value = args[index]?.trim();
  if (!value) throw new Error(`${name} requires a value`);
  return value;
}
function envBoolean(value) {
  return ["1", "true", "yes", "on"].includes(value?.trim().toLowerCase() ?? "");
}

// src/runtime/errors.ts
function errorMessage(error) {
  return describeError(error, /* @__PURE__ */ new Set(), 0);
}
function describeError(error, seen, depth) {
  if (!(error instanceof Error)) return String(error);
  seen.add(error);
  const code = errorCode(error);
  const description = depth === 0 ? error.message : `${error.name}${code ? ` [${code}]` : ""}: ${error.message}`;
  if (depth >= 4 || error.cause === void 0 || seen.has(error.cause)) {
    return description;
  }
  return `${description}; cause: ${describeError(error.cause, seen, depth + 1)}`;
}
function errorCode(error) {
  if (!("code" in error)) return "";
  const value = error.code;
  return typeof value === "string" || typeof value === "number" ? String(value) : "";
}

// src/runtime/load-json.ts
import { readFile } from "node:fs/promises";
async function loadJsonFromCandidates(candidates, parse3, failureMessage) {
  let lastError;
  for (const candidate of candidates) {
    try {
      return parse3(JSON.parse(await readFile(candidate, "utf8")));
    } catch (error) {
      lastError = error;
    }
  }
  throw new Error(`${failureMessage}: ${errorMessage(lastError)}`);
}

// src/draft-pr/ci-tool.ts
import crypto3 from "node:crypto";

// src/draft-pr/ci-comment.ts
var CI_FIX_COMMENT_PREFIX = "<!-- engineering-agent-workflows:ci-fix:v1";
function findCiFixComment(comments, botLogin) {
  const expected = botLogin.trim().toLowerCase();
  return comments.find(
    (comment) => comment.user?.login.trim().toLowerCase() === expected && comment.body.startsWith(CI_FIX_COMMENT_PREFIX)
  );
}
function parseCiFixState(comment) {
  if (!comment) return emptyCiFixState();
  const marker = comment.body.split("\n", 1)[0] ?? "";
  const match = marker.match(
    /^<!-- engineering-agent-workflows:ci-fix:v1 suite=(\d+) attempts=(\d+) head=([0-9a-f]{40}|none) status=(fixing|fixed|no-change|needs-approval|failed) -->$/
  );
  if (!match) return emptyCiFixState();
  return {
    checkSuiteId: Number(match[1]),
    attempts: Number(match[2]),
    headSha: match[3] === "none" ? "" : match[3],
    status: match[4]
  };
}
function buildCiFixComment(state) {
  const marker = `${CI_FIX_COMMENT_PREFIX} suite=${state.checkSuiteId} attempts=${state.attempts} head=${state.headSha || "none"} status=${state.status} -->`;
  const messages = {
    fixing: "The Draft PR Agent is validating the latest failed CI checks.",
    fixed: "The Draft PR Agent pushed a validated fix for the failed CI checks.",
    "no-change": "The Draft PR Agent inspected the failed CI checks and made no code change.",
    "needs-approval": "Automatic CI fixes paused for maintainer review.",
    failed: "The Draft PR Agent could not complete the latest CI fix attempt."
  };
  return [marker, "## CI follow-up", "", messages[state.status]].join("\n");
}
function emptyCiFixState() {
  return {
    checkSuiteId: 0,
    attempts: 0,
    headSha: "",
    status: "fixed"
  };
}

// node_modules/zod/v4/core/core.js
var _a;
// @__NO_SIDE_EFFECTS__
function $constructor(name, initializer3, params) {
  function init(inst, def) {
    if (!inst._zod) {
      Object.defineProperty(inst, "_zod", {
        value: {
          def,
          constr: _,
          traits: /* @__PURE__ */ new Set()
        },
        enumerable: false
      });
    }
    if (inst._zod.traits.has(name)) {
      return;
    }
    inst._zod.traits.add(name);
    initializer3(inst, def);
    const proto = _.prototype;
    const keys = Object.keys(proto);
    for (let i = 0; i < keys.length; i++) {
      const k = keys[i];
      if (!(k in inst)) {
        inst[k] = proto[k].bind(inst);
      }
    }
  }
  const Parent = params?.Parent ?? Object;
  class Definition extends Parent {
  }
  Object.defineProperty(Definition, "name", { value: name });
  function _(def) {
    var _a3;
    const inst = params?.Parent ? new Definition() : this;
    init(inst, def);
    (_a3 = inst._zod).deferred ?? (_a3.deferred = []);
    for (const fn of inst._zod.deferred) {
      fn();
    }
    return inst;
  }
  Object.defineProperty(_, "init", { value: init });
  Object.defineProperty(_, Symbol.hasInstance, {
    value: (inst) => {
      if (params?.Parent && inst instanceof params.Parent)
        return true;
      return inst?._zod?.traits?.has(name);
    }
  });
  Object.defineProperty(_, "name", { value: name });
  return _;
}
var $ZodAsyncError = class extends Error {
  constructor() {
    super(`Encountered Promise during synchronous parse. Use .parseAsync() instead.`);
  }
};
var $ZodEncodeError = class extends Error {
  constructor(name) {
    super(`Encountered unidirectional transform during encode: ${name}`);
    this.name = "ZodEncodeError";
  }
};
(_a = globalThis).__zod_globalConfig ?? (_a.__zod_globalConfig = {});
var globalConfig = globalThis.__zod_globalConfig;
function config(newConfig) {
  if (newConfig)
    Object.assign(globalConfig, newConfig);
  return globalConfig;
}

// node_modules/zod/v4/core/util.js
var util_exports = {};
__export(util_exports, {
  BIGINT_FORMAT_RANGES: () => BIGINT_FORMAT_RANGES,
  Class: () => Class,
  NUMBER_FORMAT_RANGES: () => NUMBER_FORMAT_RANGES,
  aborted: () => aborted,
  allowsEval: () => allowsEval,
  assert: () => assert,
  assertEqual: () => assertEqual,
  assertIs: () => assertIs,
  assertNever: () => assertNever,
  assertNotEqual: () => assertNotEqual,
  assignProp: () => assignProp,
  base64ToUint8Array: () => base64ToUint8Array,
  base64urlToUint8Array: () => base64urlToUint8Array,
  cached: () => cached,
  captureStackTrace: () => captureStackTrace,
  cleanEnum: () => cleanEnum,
  cleanRegex: () => cleanRegex,
  clone: () => clone,
  cloneDef: () => cloneDef,
  createTransparentProxy: () => createTransparentProxy,
  defineLazy: () => defineLazy,
  esc: () => esc,
  escapeRegex: () => escapeRegex,
  explicitlyAborted: () => explicitlyAborted,
  extend: () => extend,
  finalizeIssue: () => finalizeIssue,
  floatSafeRemainder: () => floatSafeRemainder,
  getElementAtPath: () => getElementAtPath,
  getEnumValues: () => getEnumValues,
  getLengthableOrigin: () => getLengthableOrigin,
  getParsedType: () => getParsedType,
  getSizableOrigin: () => getSizableOrigin,
  hexToUint8Array: () => hexToUint8Array,
  isObject: () => isObject,
  isPlainObject: () => isPlainObject,
  issue: () => issue,
  joinValues: () => joinValues,
  jsonStringifyReplacer: () => jsonStringifyReplacer,
  merge: () => merge,
  mergeDefs: () => mergeDefs,
  normalizeParams: () => normalizeParams,
  nullish: () => nullish,
  numKeys: () => numKeys,
  objectClone: () => objectClone,
  omit: () => omit,
  optionalKeys: () => optionalKeys,
  parsedType: () => parsedType,
  partial: () => partial,
  pick: () => pick,
  prefixIssues: () => prefixIssues,
  primitiveTypes: () => primitiveTypes,
  promiseAllObject: () => promiseAllObject,
  propertyKeyTypes: () => propertyKeyTypes,
  randomString: () => randomString,
  required: () => required,
  safeExtend: () => safeExtend,
  shallowClone: () => shallowClone,
  slugify: () => slugify,
  stringifyPrimitive: () => stringifyPrimitive,
  uint8ArrayToBase64: () => uint8ArrayToBase64,
  uint8ArrayToBase64url: () => uint8ArrayToBase64url,
  uint8ArrayToHex: () => uint8ArrayToHex,
  unwrapMessage: () => unwrapMessage
});
function assertEqual(val) {
  return val;
}
function assertNotEqual(val) {
  return val;
}
function assertIs(_arg) {
}
function assertNever(_x) {
  throw new Error("Unexpected value in exhaustive check");
}
function assert(_) {
}
function getEnumValues(entries) {
  const numericValues = Object.values(entries).filter((v) => typeof v === "number");
  const values = Object.entries(entries).filter(([k, _]) => numericValues.indexOf(+k) === -1).map(([_, v]) => v);
  return values;
}
function joinValues(array2, separator = "|") {
  return array2.map((val) => stringifyPrimitive(val)).join(separator);
}
function jsonStringifyReplacer(_, value) {
  if (typeof value === "bigint")
    return value.toString();
  return value;
}
function cached(getter) {
  const set = false;
  return {
    get value() {
      if (!set) {
        const value = getter();
        Object.defineProperty(this, "value", { value });
        return value;
      }
      throw new Error("cached value already set");
    }
  };
}
function nullish(input) {
  return input === null || input === void 0;
}
function cleanRegex(source) {
  const start = source.startsWith("^") ? 1 : 0;
  const end = source.endsWith("$") ? source.length - 1 : source.length;
  return source.slice(start, end);
}
function floatSafeRemainder(val, step) {
  const ratio = val / step;
  const roundedRatio = Math.round(ratio);
  const tolerance = Number.EPSILON * Math.max(Math.abs(ratio), 1);
  if (Math.abs(ratio - roundedRatio) < tolerance)
    return 0;
  return ratio - roundedRatio;
}
var EVALUATING = /* @__PURE__ */ Symbol("evaluating");
function defineLazy(object2, key, getter) {
  let value = void 0;
  Object.defineProperty(object2, key, {
    get() {
      if (value === EVALUATING) {
        return void 0;
      }
      if (value === void 0) {
        value = EVALUATING;
        value = getter();
      }
      return value;
    },
    set(v) {
      Object.defineProperty(object2, key, {
        value: v
        // configurable: true,
      });
    },
    configurable: true
  });
}
function objectClone(obj) {
  return Object.create(Object.getPrototypeOf(obj), Object.getOwnPropertyDescriptors(obj));
}
function assignProp(target, prop, value) {
  Object.defineProperty(target, prop, {
    value,
    writable: true,
    enumerable: true,
    configurable: true
  });
}
function mergeDefs(...defs) {
  const mergedDescriptors = {};
  for (const def of defs) {
    const descriptors = Object.getOwnPropertyDescriptors(def);
    Object.assign(mergedDescriptors, descriptors);
  }
  return Object.defineProperties({}, mergedDescriptors);
}
function cloneDef(schema) {
  return mergeDefs(schema._zod.def);
}
function getElementAtPath(obj, path3) {
  if (!path3)
    return obj;
  return path3.reduce((acc, key) => acc?.[key], obj);
}
function promiseAllObject(promisesObj) {
  const keys = Object.keys(promisesObj);
  const promises = keys.map((key) => promisesObj[key]);
  return Promise.all(promises).then((results) => {
    const resolvedObj = {};
    for (let i = 0; i < keys.length; i++) {
      resolvedObj[keys[i]] = results[i];
    }
    return resolvedObj;
  });
}
function randomString(length = 10) {
  const chars = "abcdefghijklmnopqrstuvwxyz";
  let str = "";
  for (let i = 0; i < length; i++) {
    str += chars[Math.floor(Math.random() * chars.length)];
  }
  return str;
}
function esc(str) {
  return JSON.stringify(str);
}
function slugify(input) {
  return input.toLowerCase().trim().replace(/[^\w\s-]/g, "").replace(/[\s_-]+/g, "-").replace(/^-+|-+$/g, "");
}
var captureStackTrace = "captureStackTrace" in Error ? Error.captureStackTrace : (..._args) => {
};
function isObject(data) {
  return typeof data === "object" && data !== null && !Array.isArray(data);
}
var allowsEval = /* @__PURE__ */ cached(() => {
  if (globalConfig.jitless) {
    return false;
  }
  if (typeof navigator !== "undefined" && navigator?.userAgent?.includes("Cloudflare")) {
    return false;
  }
  try {
    const F = Function;
    new F("");
    return true;
  } catch (_) {
    return false;
  }
});
function isPlainObject(o) {
  if (isObject(o) === false)
    return false;
  const ctor = o.constructor;
  if (ctor === void 0)
    return true;
  if (typeof ctor !== "function")
    return true;
  const prot = ctor.prototype;
  if (isObject(prot) === false)
    return false;
  if (Object.prototype.hasOwnProperty.call(prot, "isPrototypeOf") === false) {
    return false;
  }
  return true;
}
function shallowClone(o) {
  if (isPlainObject(o))
    return { ...o };
  if (Array.isArray(o))
    return [...o];
  if (o instanceof Map)
    return new Map(o);
  if (o instanceof Set)
    return new Set(o);
  return o;
}
function numKeys(data) {
  let keyCount = 0;
  for (const key in data) {
    if (Object.prototype.hasOwnProperty.call(data, key)) {
      keyCount++;
    }
  }
  return keyCount;
}
var getParsedType = (data) => {
  const t = typeof data;
  switch (t) {
    case "undefined":
      return "undefined";
    case "string":
      return "string";
    case "number":
      return Number.isNaN(data) ? "nan" : "number";
    case "boolean":
      return "boolean";
    case "function":
      return "function";
    case "bigint":
      return "bigint";
    case "symbol":
      return "symbol";
    case "object":
      if (Array.isArray(data)) {
        return "array";
      }
      if (data === null) {
        return "null";
      }
      if (data.then && typeof data.then === "function" && data.catch && typeof data.catch === "function") {
        return "promise";
      }
      if (typeof Map !== "undefined" && data instanceof Map) {
        return "map";
      }
      if (typeof Set !== "undefined" && data instanceof Set) {
        return "set";
      }
      if (typeof Date !== "undefined" && data instanceof Date) {
        return "date";
      }
      if (typeof File !== "undefined" && data instanceof File) {
        return "file";
      }
      return "object";
    default:
      throw new Error(`Unknown data type: ${t}`);
  }
};
var propertyKeyTypes = /* @__PURE__ */ new Set(["string", "number", "symbol"]);
var primitiveTypes = /* @__PURE__ */ new Set([
  "string",
  "number",
  "bigint",
  "boolean",
  "symbol",
  "undefined"
]);
function escapeRegex(str) {
  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
}
function clone(inst, def, params) {
  const cl = new inst._zod.constr(def ?? inst._zod.def);
  if (!def || params?.parent)
    cl._zod.parent = inst;
  return cl;
}
function normalizeParams(_params) {
  const params = _params;
  if (!params)
    return {};
  if (typeof params === "string")
    return { error: () => params };
  if (params?.message !== void 0) {
    if (params?.error !== void 0)
      throw new Error("Cannot specify both `message` and `error` params");
    params.error = params.message;
  }
  delete params.message;
  if (typeof params.error === "string")
    return { ...params, error: () => params.error };
  return params;
}
function createTransparentProxy(getter) {
  let target;
  return new Proxy({}, {
    get(_, prop, receiver) {
      target ?? (target = getter());
      return Reflect.get(target, prop, receiver);
    },
    set(_, prop, value, receiver) {
      target ?? (target = getter());
      return Reflect.set(target, prop, value, receiver);
    },
    has(_, prop) {
      target ?? (target = getter());
      return Reflect.has(target, prop);
    },
    deleteProperty(_, prop) {
      target ?? (target = getter());
      return Reflect.deleteProperty(target, prop);
    },
    ownKeys(_) {
      target ?? (target = getter());
      return Reflect.ownKeys(target);
    },
    getOwnPropertyDescriptor(_, prop) {
      target ?? (target = getter());
      return Reflect.getOwnPropertyDescriptor(target, prop);
    },
    defineProperty(_, prop, descriptor) {
      target ?? (target = getter());
      return Reflect.defineProperty(target, prop, descriptor);
    }
  });
}
function stringifyPrimitive(value) {
  if (typeof value === "bigint")
    return value.toString() + "n";
  if (typeof value === "string")
    return `"${value}"`;
  return `${value}`;
}
function optionalKeys(shape) {
  return Object.keys(shape).filter((k) => {
    return shape[k]._zod.optin === "optional" && shape[k]._zod.optout === "optional";
  });
}
var NUMBER_FORMAT_RANGES = {
  safeint: [Number.MIN_SAFE_INTEGER, Number.MAX_SAFE_INTEGER],
  int32: [-2147483648, 2147483647],
  uint32: [0, 4294967295],
  float32: [-34028234663852886e22, 34028234663852886e22],
  float64: [-Number.MAX_VALUE, Number.MAX_VALUE]
};
var BIGINT_FORMAT_RANGES = {
  int64: [/* @__PURE__ */ BigInt("-9223372036854775808"), /* @__PURE__ */ BigInt("9223372036854775807")],
  uint64: [/* @__PURE__ */ BigInt(0), /* @__PURE__ */ BigInt("18446744073709551615")]
};
function pick(schema, mask) {
  const currDef = schema._zod.def;
  const checks = currDef.checks;
  const hasChecks = checks && checks.length > 0;
  if (hasChecks) {
    throw new Error(".pick() cannot be used on object schemas containing refinements");
  }
  const def = mergeDefs(schema._zod.def, {
    get shape() {
      const newShape = {};
      for (const key in mask) {
        if (!(key in currDef.shape)) {
          throw new Error(`Unrecognized key: "${key}"`);
        }
        if (!mask[key])
          continue;
        newShape[key] = currDef.shape[key];
      }
      assignProp(this, "shape", newShape);
      return newShape;
    },
    checks: []
  });
  return clone(schema, def);
}
function omit(schema, mask) {
  const currDef = schema._zod.def;
  const checks = currDef.checks;
  const hasChecks = checks && checks.length > 0;
  if (hasChecks) {
    throw new Error(".omit() cannot be used on object schemas containing refinements");
  }
  const def = mergeDefs(schema._zod.def, {
    get shape() {
      const newShape = { ...schema._zod.def.shape };
      for (const key in mask) {
        if (!(key in currDef.shape)) {
          throw new Error(`Unrecognized key: "${key}"`);
        }
        if (!mask[key])
          continue;
        delete newShape[key];
      }
      assignProp(this, "shape", newShape);
      return newShape;
    },
    checks: []
  });
  return clone(schema, def);
}
function extend(schema, shape) {
  if (!isPlainObject(shape)) {
    throw new Error("Invalid input to extend: expected a plain object");
  }
  const checks = schema._zod.def.checks;
  const hasChecks = checks && checks.length > 0;
  if (hasChecks) {
    const existingShape = schema._zod.def.shape;
    for (const key in shape) {
      if (Object.getOwnPropertyDescriptor(existingShape, key) !== void 0) {
        throw new Error("Cannot overwrite keys on object schemas containing refinements. Use `.safeExtend()` instead.");
      }
    }
  }
  const def = mergeDefs(schema._zod.def, {
    get shape() {
      const _shape = { ...schema._zod.def.shape, ...shape };
      assignProp(this, "shape", _shape);
      return _shape;
    }
  });
  return clone(schema, def);
}
function safeExtend(schema, shape) {
  if (!isPlainObject(shape)) {
    throw new Error("Invalid input to safeExtend: expected a plain object");
  }
  const def = mergeDefs(schema._zod.def, {
    get shape() {
      const _shape = { ...schema._zod.def.shape, ...shape };
      assignProp(this, "shape", _shape);
      return _shape;
    }
  });
  return clone(schema, def);
}
function merge(a, b) {
  if (a._zod.def.checks?.length) {
    throw new Error(".merge() cannot be used on object schemas containing refinements. Use .safeExtend() instead.");
  }
  const def = mergeDefs(a._zod.def, {
    get shape() {
      const _shape = { ...a._zod.def.shape, ...b._zod.def.shape };
      assignProp(this, "shape", _shape);
      return _shape;
    },
    get catchall() {
      return b._zod.def.catchall;
    },
    checks: b._zod.def.checks ?? []
  });
  return clone(a, def);
}
function partial(Class2, schema, mask) {
  const currDef = schema._zod.def;
  const checks = currDef.checks;
  const hasChecks = checks && checks.length > 0;
  if (hasChecks) {
    throw new Error(".partial() cannot be used on object schemas containing refinements");
  }
  const def = mergeDefs(schema._zod.def, {
    get shape() {
      const oldShape = schema._zod.def.shape;
      const shape = { ...oldShape };
      if (mask) {
        for (const key in mask) {
          if (!(key in oldShape)) {
            throw new Error(`Unrecognized key: "${key}"`);
          }
          if (!mask[key])
            continue;
          shape[key] = Class2 ? new Class2({
            type: "optional",
            innerType: oldShape[key]
          }) : oldShape[key];
        }
      } else {
        for (const key in oldShape) {
          shape[key] = Class2 ? new Class2({
            type: "optional",
            innerType: oldShape[key]
          }) : oldShape[key];
        }
      }
      assignProp(this, "shape", shape);
      return shape;
    },
    checks: []
  });
  return clone(schema, def);
}
function required(Class2, schema, mask) {
  const def = mergeDefs(schema._zod.def, {
    get shape() {
      const oldShape = schema._zod.def.shape;
      const shape = { ...oldShape };
      if (mask) {
        for (const key in mask) {
          if (!(key in shape)) {
            throw new Error(`Unrecognized key: "${key}"`);
          }
          if (!mask[key])
            continue;
          shape[key] = new Class2({
            type: "nonoptional",
            innerType: oldShape[key]
          });
        }
      } else {
        for (const key in oldShape) {
          shape[key] = new Class2({
            type: "nonoptional",
            innerType: oldShape[key]
          });
        }
      }
      assignProp(this, "shape", shape);
      return shape;
    }
  });
  return clone(schema, def);
}
function aborted(x, startIndex = 0) {
  if (x.aborted === true)
    return true;
  for (let i = startIndex; i < x.issues.length; i++) {
    if (x.issues[i]?.continue !== true) {
      return true;
    }
  }
  return false;
}
function explicitlyAborted(x, startIndex = 0) {
  if (x.aborted === true)
    return true;
  for (let i = startIndex; i < x.issues.length; i++) {
    if (x.issues[i]?.continue === false) {
      return true;
    }
  }
  return false;
}
function prefixIssues(path3, issues) {
  return issues.map((iss) => {
    var _a3;
    (_a3 = iss).path ?? (_a3.path = []);
    iss.path.unshift(path3);
    return iss;
  });
}
function unwrapMessage(message) {
  return typeof message === "string" ? message : message?.message;
}
function finalizeIssue(iss, ctx, config2) {
  const message = iss.message ? iss.message : unwrapMessage(iss.inst?._zod.def?.error?.(iss)) ?? unwrapMessage(ctx?.error?.(iss)) ?? unwrapMessage(config2.customError?.(iss)) ?? unwrapMessage(config2.localeError?.(iss)) ?? "Invalid input";
  const { inst: _inst, continue: _continue, input: _input, ...rest } = iss;
  rest.path ?? (rest.path = []);
  rest.message = message;
  if (ctx?.reportInput) {
    rest.input = _input;
  }
  return rest;
}
function getSizableOrigin(input) {
  if (input instanceof Set)
    return "set";
  if (input instanceof Map)
    return "map";
  if (input instanceof File)
    return "file";
  return "unknown";
}
function getLengthableOrigin(input) {
  if (Array.isArray(input))
    return "array";
  if (typeof input === "string")
    return "string";
  return "unknown";
}
function parsedType(data) {
  const t = typeof data;
  switch (t) {
    case "number": {
      return Number.isNaN(data) ? "nan" : "number";
    }
    case "object": {
      if (data === null) {
        return "null";
      }
      if (Array.isArray(data)) {
        return "array";
      }
      const obj = data;
      if (obj && Object.getPrototypeOf(obj) !== Object.prototype && "constructor" in obj && obj.constructor) {
        return obj.constructor.name;
      }
    }
  }
  return t;
}
function issue(...args) {
  const [iss, input, inst] = args;
  if (typeof iss === "string") {
    return {
      message: iss,
      code: "custom",
      input,
      inst
    };
  }
  return { ...iss };
}
function cleanEnum(obj) {
  return Object.entries(obj).filter(([k, _]) => {
    return Number.isNaN(Number.parseInt(k, 10));
  }).map((el) => el[1]);
}
function base64ToUint8Array(base642) {
  const binaryString = atob(base642);
  const bytes = new Uint8Array(binaryString.length);
  for (let i = 0; i < binaryString.length; i++) {
    bytes[i] = binaryString.charCodeAt(i);
  }
  return bytes;
}
function uint8ArrayToBase64(bytes) {
  let binaryString = "";
  for (let i = 0; i < bytes.length; i++) {
    binaryString += String.fromCharCode(bytes[i]);
  }
  return btoa(binaryString);
}
function base64urlToUint8Array(base64url2) {
  const base642 = base64url2.replace(/-/g, "+").replace(/_/g, "/");
  const padding = "=".repeat((4 - base642.length % 4) % 4);
  return base64ToUint8Array(base642 + padding);
}
function uint8ArrayToBase64url(bytes) {
  return uint8ArrayToBase64(bytes).replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
}
function hexToUint8Array(hex) {
  const cleanHex = hex.replace(/^0x/, "");
  if (cleanHex.length % 2 !== 0) {
    throw new Error("Invalid hex string length");
  }
  const bytes = new Uint8Array(cleanHex.length / 2);
  for (let i = 0; i < cleanHex.length; i += 2) {
    bytes[i / 2] = Number.parseInt(cleanHex.slice(i, i + 2), 16);
  }
  return bytes;
}
function uint8ArrayToHex(bytes) {
  return Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
}
var Class = class {
  constructor(..._args) {
  }
};

// node_modules/zod/v4/core/errors.js
var initializer = (inst, def) => {
  inst.name = "$ZodError";
  Object.defineProperty(inst, "_zod", {
    value: inst._zod,
    enumerable: false
  });
  Object.defineProperty(inst, "issues", {
    value: def,
    enumerable: false
  });
  inst.message = JSON.stringify(def, jsonStringifyReplacer, 2);
  Object.defineProperty(inst, "toString", {
    value: () => inst.message,
    enumerable: false
  });
};
var $ZodError = $constructor("$ZodError", initializer);
var $ZodRealError = $constructor("$ZodError", initializer, { Parent: Error });
function flattenError(error, mapper = (issue2) => issue2.message) {
  const fieldErrors = {};
  const formErrors = [];
  for (const sub of error.issues) {
    if (sub.path.length > 0) {
      fieldErrors[sub.path[0]] = fieldErrors[sub.path[0]] || [];
      fieldErrors[sub.path[0]].push(mapper(sub));
    } else {
      formErrors.push(mapper(sub));
    }
  }
  return { formErrors, fieldErrors };
}
function formatError(error, mapper = (issue2) => issue2.message) {
  const fieldErrors = { _errors: [] };
  const processError = (error2, path3 = []) => {
    for (const issue2 of error2.issues) {
      if (issue2.code === "invalid_union" && issue2.errors.length) {
        issue2.errors.map((issues) => processError({ issues }, [...path3, ...issue2.path]));
      } else if (issue2.code === "invalid_key") {
        processError({ issues: issue2.issues }, [...path3, ...issue2.path]);
      } else if (issue2.code === "invalid_element") {
        processError({ issues: issue2.issues }, [...path3, ...issue2.path]);
      } else {
        const fullpath = [...path3, ...issue2.path];
        if (fullpath.length === 0) {
          fieldErrors._errors.push(mapper(issue2));
        } else {
          let curr = fieldErrors;
          let i = 0;
          while (i < fullpath.length) {
            const el = fullpath[i];
            const terminal = i === fullpath.length - 1;
            if (!terminal) {
              curr[el] = curr[el] || { _errors: [] };
            } else {
              curr[el] = curr[el] || { _errors: [] };
              curr[el]._errors.push(mapper(issue2));
            }
            curr = curr[el];
            i++;
          }
        }
      }
    }
  };
  processError(error);
  return fieldErrors;
}

// node_modules/zod/v4/core/parse.js
var _parse = (_Err) => (schema, value, _ctx, _params) => {
  const ctx = _ctx ? { ..._ctx, async: false } : { async: false };
  const result = schema._zod.run({ value, issues: [] }, ctx);
  if (result instanceof Promise) {
    throw new $ZodAsyncError();
  }
  if (result.issues.length) {
    const e = new (_params?.Err ?? _Err)(result.issues.map((iss) => finalizeIssue(iss, ctx, config())));
    captureStackTrace(e, _params?.callee);
    throw e;
  }
  return result.value;
};
var _parseAsync = (_Err) => async (schema, value, _ctx, params) => {
  const ctx = _ctx ? { ..._ctx, async: true } : { async: true };
  let result = schema._zod.run({ value, issues: [] }, ctx);
  if (result instanceof Promise)
    result = await result;
  if (result.issues.length) {
    const e = new (params?.Err ?? _Err)(result.issues.map((iss) => finalizeIssue(iss, ctx, config())));
    captureStackTrace(e, params?.callee);
    throw e;
  }
  return result.value;
};
var _safeParse = (_Err) => (schema, value, _ctx) => {
  const ctx = _ctx ? { ..._ctx, async: false } : { async: false };
  const result = schema._zod.run({ value, issues: [] }, ctx);
  if (result instanceof Promise) {
    throw new $ZodAsyncError();
  }
  return result.issues.length ? {
    success: false,
    error: new (_Err ?? $ZodError)(result.issues.map((iss) => finalizeIssue(iss, ctx, config())))
  } : { success: true, data: result.value };
};
var safeParse = /* @__PURE__ */ _safeParse($ZodRealError);
var _safeParseAsync = (_Err) => async (schema, value, _ctx) => {
  const ctx = _ctx ? { ..._ctx, async: true } : { async: true };
  let result = schema._zod.run({ value, issues: [] }, ctx);
  if (result instanceof Promise)
    result = await result;
  return result.issues.length ? {
    success: false,
    error: new _Err(result.issues.map((iss) => finalizeIssue(iss, ctx, config())))
  } : { success: true, data: result.value };
};
var safeParseAsync = /* @__PURE__ */ _safeParseAsync($ZodRealError);
var _encode = (_Err) => (schema, value, _ctx) => {
  const ctx = _ctx ? { ..._ctx, direction: "backward" } : { direction: "backward" };
  return _parse(_Err)(schema, value, ctx);
};
var _decode = (_Err) => (schema, value, _ctx) => {
  return _parse(_Err)(schema, value, _ctx);
};
var _encodeAsync = (_Err) => async (schema, value, _ctx) => {
  const ctx = _ctx ? { ..._ctx, direction: "backward" } : { direction: "backward" };
  return _parseAsync(_Err)(schema, value, ctx);
};
var _decodeAsync = (_Err) => async (schema, value, _ctx) => {
  return _parseAsync(_Err)(schema, value, _ctx);
};
var _safeEncode = (_Err) => (schema, value, _ctx) => {
  const ctx = _ctx ? { ..._ctx, direction: "backward" } : { direction: "backward" };
  return _safeParse(_Err)(schema, value, ctx);
};
var _safeDecode = (_Err) => (schema, value, _ctx) => {
  return _safeParse(_Err)(schema, value, _ctx);
};
var _safeEncodeAsync = (_Err) => async (schema, value, _ctx) => {
  const ctx = _ctx ? { ..._ctx, direction: "backward" } : { direction: "backward" };
  return _safeParseAsync(_Err)(schema, value, ctx);
};
var _safeDecodeAsync = (_Err) => async (schema, value, _ctx) => {
  return _safeParseAsync(_Err)(schema, value, _ctx);
};

// node_modules/zod/v4/core/regexes.js
var cuid = /^[cC][0-9a-z]{6,}$/;
var cuid2 = /^[0-9a-z]+$/;
var ulid = /^[0-9A-HJKMNP-TV-Za-hjkmnp-tv-z]{26}$/;
var xid = /^[0-9a-vA-V]{20}$/;
var ksuid = /^[A-Za-z0-9]{27}$/;
var nanoid = /^[a-zA-Z0-9_-]{21}$/;
var duration = /^P(?:(\d+W)|(?!.*W)(?=\d|T\d)(\d+Y)?(\d+M)?(\d+D)?(T(?=\d)(\d+H)?(\d+M)?(\d+([.,]\d+)?S)?)?)$/;
var guid = /^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12})$/;
var uuid = (version2) => {
  if (!version2)
    return /^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-8][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$/;
  return new RegExp(`^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-${version2}[0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12})$`);
};
var email = /^(?!\.)(?!.*\.\.)([A-Za-z0-9_'+\-\.]*)[A-Za-z0-9_+-]@([A-Za-z0-9][A-Za-z0-9\-]*\.)+[A-Za-z]{2,}$/;
var _emoji = `^(\\p{Extended_Pictographic}|\\p{Emoji_Component})+$`;
function emoji() {
  return new RegExp(_emoji, "u");
}
var ipv4 = /^(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])$/;
var ipv6 = /^(([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:))$/;
var cidrv4 = /^((25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\/([0-9]|[1-2][0-9]|3[0-2])$/;
var cidrv6 = /^(([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}|::|([0-9a-fA-F]{1,4})?::([0-9a-fA-F]{1,4}:?){0,6})\/(12[0-8]|1[01][0-9]|[1-9]?[0-9])$/;
var base64 = /^$|^(?:[0-9a-zA-Z+/]{4})*(?:(?:[0-9a-zA-Z+/]{2}==)|(?:[0-9a-zA-Z+/]{3}=))?$/;
var base64url = /^[A-Za-z0-9_-]*$/;
var httpProtocol = /^https?$/;
var e164 = /^\+[1-9]\d{6,14}$/;
var dateSource = `(?:(?:\\d\\d[2468][048]|\\d\\d[13579][26]|\\d\\d0[48]|[02468][048]00|[13579][26]00)-02-29|\\d{4}-(?:(?:0[13578]|1[02])-(?:0[1-9]|[12]\\d|3[01])|(?:0[469]|11)-(?:0[1-9]|[12]\\d|30)|(?:02)-(?:0[1-9]|1\\d|2[0-8])))`;
var date = /* @__PURE__ */ new RegExp(`^${dateSource}$`);
function timeSource(args) {
  const hhmm = `(?:[01]\\d|2[0-3]):[0-5]\\d`;
  const regex = typeof args.precision === "number" ? args.precision === -1 ? `${hhmm}` : args.precision === 0 ? `${hhmm}:[0-5]\\d` : `${hhmm}:[0-5]\\d\\.\\d{${args.precision}}` : `${hhmm}(?::[0-5]\\d(?:\\.\\d+)?)?`;
  return regex;
}
function time(args) {
  return new RegExp(`^${timeSource(args)}$`);
}
function datetime(args) {
  const time3 = timeSource({ precision: args.precision });
  const opts = ["Z"];
  if (args.local)
    opts.push("");
  if (args.offset)
    opts.push(`([+-](?:[01]\\d|2[0-3]):[0-5]\\d)`);
  const timeRegex = `${time3}(?:${opts.join("|")})`;
  return new RegExp(`^${dateSource}T(?:${timeRegex})$`);
}
var string = (params) => {
  const regex = params ? `[\\s\\S]{${params?.minimum ?? 0},${params?.maximum ?? ""}}` : `[\\s\\S]*`;
  return new RegExp(`^${regex}$`);
};
var integer = /^-?\d+$/;
var number = /^-?\d+(?:\.\d+)?$/;
var lowercase = /^[^A-Z]*$/;
var uppercase = /^[^a-z]*$/;

// node_modules/zod/v4/core/checks.js
var $ZodCheck = /* @__PURE__ */ $constructor("$ZodCheck", (inst, def) => {
  var _a3;
  inst._zod ?? (inst._zod = {});
  inst._zod.def = def;
  (_a3 = inst._zod).onattach ?? (_a3.onattach = []);
});
var numericOriginMap = {
  number: "number",
  bigint: "bigint",
  object: "date"
};
var $ZodCheckLessThan = /* @__PURE__ */ $constructor("$ZodCheckLessThan", (inst, def) => {
  $ZodCheck.init(inst, def);
  const origin = numericOriginMap[typeof def.value];
  inst._zod.onattach.push((inst2) => {
    const bag = inst2._zod.bag;
    const curr = (def.inclusive ? bag.maximum : bag.exclusiveMaximum) ?? Number.POSITIVE_INFINITY;
    if (def.value < curr) {
      if (def.inclusive)
        bag.maximum = def.value;
      else
        bag.exclusiveMaximum = def.value;
    }
  });
  inst._zod.check = (payload) => {
    if (def.inclusive ? payload.value <= def.value : payload.value < def.value) {
      return;
    }
    payload.issues.push({
      origin,
      code: "too_big",
      maximum: typeof def.value === "object" ? def.value.getTime() : def.value,
      input: payload.value,
      inclusive: def.inclusive,
      inst,
      continue: !def.abort
    });
  };
});
var $ZodCheckGreaterThan = /* @__PURE__ */ $constructor("$ZodCheckGreaterThan", (inst, def) => {
  $ZodCheck.init(inst, def);
  const origin = numericOriginMap[typeof def.value];
  inst._zod.onattach.push((inst2) => {
    const bag = inst2._zod.bag;
    const curr = (def.inclusive ? bag.minimum : bag.exclusiveMinimum) ?? Number.NEGATIVE_INFINITY;
    if (def.value > curr) {
      if (def.inclusive)
        bag.minimum = def.value;
      else
        bag.exclusiveMinimum = def.value;
    }
  });
  inst._zod.check = (payload) => {
    if (def.inclusive ? payload.value >= def.value : payload.value > def.value) {
      return;
    }
    payload.issues.push({
      origin,
      code: "too_small",
      minimum: typeof def.value === "object" ? def.value.getTime() : def.value,
      input: payload.value,
      inclusive: def.inclusive,
      inst,
      continue: !def.abort
    });
  };
});
var $ZodCheckMultipleOf = /* @__PURE__ */ $constructor("$ZodCheckMultipleOf", (inst, def) => {
  $ZodCheck.init(inst, def);
  inst._zod.onattach.push((inst2) => {
    var _a3;
    (_a3 = inst2._zod.bag).multipleOf ?? (_a3.multipleOf = def.value);
  });
  inst._zod.check = (payload) => {
    if (typeof payload.value !== typeof def.value)
      throw new Error("Cannot mix number and bigint in multiple_of check.");
    const isMultiple = typeof payload.value === "bigint" ? payload.value % def.value === BigInt(0) : floatSafeRemainder(payload.value, def.value) === 0;
    if (isMultiple)
      return;
    payload.issues.push({
      origin: typeof payload.value,
      code: "not_multiple_of",
      divisor: def.value,
      input: payload.value,
      inst,
      continue: !def.abort
    });
  };
});
var $ZodCheckNumberFormat = /* @__PURE__ */ $constructor("$ZodCheckNumberFormat", (inst, def) => {
  $ZodCheck.init(inst, def);
  def.format = def.format || "float64";
  const isInt = def.format?.includes("int");
  const origin = isInt ? "int" : "number";
  const [minimum, maximum] = NUMBER_FORMAT_RANGES[def.format];
  inst._zod.onattach.push((inst2) => {
    const bag = inst2._zod.bag;
    bag.format = def.format;
    bag.minimum = minimum;
    bag.maximum = maximum;
    if (isInt)
      bag.pattern = integer;
  });
  inst._zod.check = (payload) => {
    const input = payload.value;
    if (isInt) {
      if (!Number.isInteger(input)) {
        payload.issues.push({
          expected: origin,
          format: def.format,
          code: "invalid_type",
          continue: false,
          input,
          inst
        });
        return;
      }
      if (!Number.isSafeInteger(input)) {
        if (input > 0) {
          payload.issues.push({
            input,
            code: "too_big",
            maximum: Number.MAX_SAFE_INTEGER,
            note: "Integers must be within the safe integer range.",
            inst,
            origin,
            inclusive: true,
            continue: !def.abort
          });
        } else {
          payload.issues.push({
            input,
            code: "too_small",
            minimum: Number.MIN_SAFE_INTEGER,
            note: "Integers must be within the safe integer range.",
            inst,
            origin,
            inclusive: true,
            continue: !def.abort
          });
        }
        return;
      }
    }
    if (input < minimum) {
      payload.issues.push({
        origin: "number",
        input,
        code: "too_small",
        minimum,
        inclusive: true,
        inst,
        continue: !def.abort
      });
    }
    if (input > maximum) {
      payload.issues.push({
        origin: "number",
        input,
        code: "too_big",
        maximum,
        inclusive: true,
        inst,
        continue: !def.abort
      });
    }
  };
});
var $ZodCheckMaxLength = /* @__PURE__ */ $constructor("$ZodCheckMaxLength", (inst, def) => {
  var _a3;
  $ZodCheck.init(inst, def);
  (_a3 = inst._zod.def).when ?? (_a3.when = (payload) => {
    const val = payload.value;
    return !nullish(val) && val.length !== void 0;
  });
  inst._zod.onattach.push((inst2) => {
    const curr = inst2._zod.bag.maximum ?? Number.POSITIVE_INFINITY;
    if (def.maximum < curr)
      inst2._zod.bag.maximum = def.maximum;
  });
  inst._zod.check = (payload) => {
    const input = payload.value;
    const length = input.length;
    if (length <= def.maximum)
      return;
    const origin = getLengthableOrigin(input);
    payload.issues.push({
      origin,
      code: "too_big",
      maximum: def.maximum,
      inclusive: true,
      input,
      inst,
      continue: !def.abort
    });
  };
});
var $ZodCheckMinLength = /* @__PURE__ */ $constructor("$ZodCheckMinLength", (inst, def) => {
  var _a3;
  $ZodCheck.init(inst, def);
  (_a3 = inst._zod.def).when ?? (_a3.when = (payload) => {
    const val = payload.value;
    return !nullish(val) && val.length !== void 0;
  });
  inst._zod.onattach.push((inst2) => {
    const curr = inst2._zod.bag.minimum ?? Number.NEGATIVE_INFINITY;
    if (def.minimum > curr)
      inst2._zod.bag.minimum = def.minimum;
  });
  inst._zod.check = (payload) => {
    const input = payload.value;
    const length = input.length;
    if (length >= def.minimum)
      return;
    const origin = getLengthableOrigin(input);
    payload.issues.push({
      origin,
      code: "too_small",
      minimum: def.minimum,
      inclusive: true,
      input,
      inst,
      continue: !def.abort
    });
  };
});
var $ZodCheckLengthEquals = /* @__PURE__ */ $constructor("$ZodCheckLengthEquals", (inst, def) => {
  var _a3;
  $ZodCheck.init(inst, def);
  (_a3 = inst._zod.def).when ?? (_a3.when = (payload) => {
    const val = payload.value;
    return !nullish(val) && val.length !== void 0;
  });
  inst._zod.onattach.push((inst2) => {
    const bag = inst2._zod.bag;
    bag.minimum = def.length;
    bag.maximum = def.length;
    bag.length = def.length;
  });
  inst._zod.check = (payload) => {
    const input = payload.value;
    const length = input.length;
    if (length === def.length)
      return;
    const origin = getLengthableOrigin(input);
    const tooBig = length > def.length;
    payload.issues.push({
      origin,
      ...tooBig ? { code: "too_big", maximum: def.length } : { code: "too_small", minimum: def.length },
      inclusive: true,
      exact: true,
      input: payload.value,
      inst,
      continue: !def.abort
    });
  };
});
var $ZodCheckStringFormat = /* @__PURE__ */ $constructor("$ZodCheckStringFormat", (inst, def) => {
  var _a3, _b;
  $ZodCheck.init(inst, def);
  inst._zod.onattach.push((inst2) => {
    const bag = inst2._zod.bag;
    bag.format = def.format;
    if (def.pattern) {
      bag.patterns ?? (bag.patterns = /* @__PURE__ */ new Set());
      bag.patterns.add(def.pattern);
    }
  });
  if (def.pattern)
    (_a3 = inst._zod).check ?? (_a3.check = (payload) => {
      def.pattern.lastIndex = 0;
      if (def.pattern.test(payload.value))
        return;
      payload.issues.push({
        origin: "string",
        code: "invalid_format",
        format: def.format,
        input: payload.value,
        ...def.pattern ? { pattern: def.pattern.toString() } : {},
        inst,
        continue: !def.abort
      });
    });
  else
    (_b = inst._zod).check ?? (_b.check = () => {
    });
});
var $ZodCheckRegex = /* @__PURE__ */ $constructor("$ZodCheckRegex", (inst, def) => {
  $ZodCheckStringFormat.init(inst, def);
  inst._zod.check = (payload) => {
    def.pattern.lastIndex = 0;
    if (def.pattern.test(payload.value))
      return;
    payload.issues.push({
      origin: "string",
      code: "invalid_format",
      format: "regex",
      input: payload.value,
      pattern: def.pattern.toString(),
      inst,
      continue: !def.abort
    });
  };
});
var $ZodCheckLowerCase = /* @__PURE__ */ $constructor("$ZodCheckLowerCase", (inst, def) => {
  def.pattern ?? (def.pattern = lowercase);
  $ZodCheckStringFormat.init(inst, def);
});
var $ZodCheckUpperCase = /* @__PURE__ */ $constructor("$ZodCheckUpperCase", (inst, def) => {
  def.pattern ?? (def.pattern = uppercase);
  $ZodCheckStringFormat.init(inst, def);
});
var $ZodCheckIncludes = /* @__PURE__ */ $constructor("$ZodCheckIncludes", (inst, def) => {
  $ZodCheck.init(inst, def);
  const escapedRegex = escapeRegex(def.includes);
  const pattern = new RegExp(typeof def.position === "number" ? `^.{${def.position}}${escapedRegex}` : escapedRegex);
  def.pattern = pattern;
  inst._zod.onattach.push((inst2) => {
    const bag = inst2._zod.bag;
    bag.patterns ?? (bag.patterns = /* @__PURE__ */ new Set());
    bag.patterns.add(pattern);
  });
  inst._zod.check = (payload) => {
    if (payload.value.includes(def.includes, def.position))
      return;
    payload.issues.push({
      origin: "string",
      code: "invalid_format",
      format: "includes",
      includes: def.includes,
      input: payload.value,
      inst,
      continue: !def.abort
    });
  };
});
var $ZodCheckStartsWith = /* @__PURE__ */ $constructor("$ZodCheckStartsWith", (inst, def) => {
  $ZodCheck.init(inst, def);
  const pattern = new RegExp(`^${escapeRegex(def.prefix)}.*`);
  def.pattern ?? (def.pattern = pattern);
  inst._zod.onattach.push((inst2) => {
    const bag = inst2._zod.bag;
    bag.patterns ?? (bag.patterns = /* @__PURE__ */ new Set());
    bag.patterns.add(pattern);
  });
  inst._zod.check = (payload) => {
    if (payload.value.startsWith(def.prefix))
      return;
    payload.issues.push({
      origin: "string",
      code: "invalid_format",
      format: "starts_with",
      prefix: def.prefix,
      input: payload.value,
      inst,
      continue: !def.abort
    });
  };
});
var $ZodCheckEndsWith = /* @__PURE__ */ $constructor("$ZodCheckEndsWith", (inst, def) => {
  $ZodCheck.init(inst, def);
  const pattern = new RegExp(`.*${escapeRegex(def.suffix)}$`);
  def.pattern ?? (def.pattern = pattern);
  inst._zod.onattach.push((inst2) => {
    const bag = inst2._zod.bag;
    bag.patterns ?? (bag.patterns = /* @__PURE__ */ new Set());
    bag.patterns.add(pattern);
  });
  inst._zod.check = (payload) => {
    if (payload.value.endsWith(def.suffix))
      return;
    payload.issues.push({
      origin: "string",
      code: "invalid_format",
      format: "ends_with",
      suffix: def.suffix,
      input: payload.value,
      inst,
      continue: !def.abort
    });
  };
});
var $ZodCheckOverwrite = /* @__PURE__ */ $constructor("$ZodCheckOverwrite", (inst, def) => {
  $ZodCheck.init(inst, def);
  inst._zod.check = (payload) => {
    payload.value = def.tx(payload.value);
  };
});

// node_modules/zod/v4/core/doc.js
var Doc = class {
  constructor(args = []) {
    this.content = [];
    this.indent = 0;
    if (this)
      this.args = args;
  }
  indented(fn) {
    this.indent += 1;
    fn(this);
    this.indent -= 1;
  }
  write(arg) {
    if (typeof arg === "function") {
      arg(this, { execution: "sync" });
      arg(this, { execution: "async" });
      return;
    }
    const content = arg;
    const lines = content.split("\n").filter((x) => x);
    const minIndent = Math.min(...lines.map((x) => x.length - x.trimStart().length));
    const dedented = lines.map((x) => x.slice(minIndent)).map((x) => " ".repeat(this.indent * 2) + x);
    for (const line of dedented) {
      this.content.push(line);
    }
  }
  compile() {
    const F = Function;
    const args = this?.args;
    const content = this?.content ?? [``];
    const lines = [...content.map((x) => `  ${x}`)];
    return new F(...args, lines.join("\n"));
  }
};

// node_modules/zod/v4/core/versions.js
var version = {
  major: 4,
  minor: 4,
  patch: 3
};

// node_modules/zod/v4/core/schemas.js
var $ZodType = /* @__PURE__ */ $constructor("$ZodType", (inst, def) => {
  var _a3;
  inst ?? (inst = {});
  inst._zod.def = def;
  inst._zod.bag = inst._zod.bag || {};
  inst._zod.version = version;
  const checks = [...inst._zod.def.checks ?? []];
  if (inst._zod.traits.has("$ZodCheck")) {
    checks.unshift(inst);
  }
  for (const ch of checks) {
    for (const fn of ch._zod.onattach) {
      fn(inst);
    }
  }
  if (checks.length === 0) {
    (_a3 = inst._zod).deferred ?? (_a3.deferred = []);
    inst._zod.deferred?.push(() => {
      inst._zod.run = inst._zod.parse;
    });
  } else {
    const runChecks = (payload, checks2, ctx) => {
      let isAborted = aborted(payload);
      let asyncResult;
      for (const ch of checks2) {
        if (ch._zod.def.when) {
          if (explicitlyAborted(payload))
            continue;
          const shouldRun = ch._zod.def.when(payload);
          if (!shouldRun)
            continue;
        } else if (isAborted) {
          continue;
        }
        const currLen = payload.issues.length;
        const _ = ch._zod.check(payload);
        if (_ instanceof Promise && ctx?.async === false) {
          throw new $ZodAsyncError();
        }
        if (asyncResult || _ instanceof Promise) {
          asyncResult = (asyncResult ?? Promise.resolve()).then(async () => {
            await _;
            const nextLen = payload.issues.length;
            if (nextLen === currLen)
              return;
            if (!isAborted)
              isAborted = aborted(payload, currLen);
          });
        } else {
          const nextLen = payload.issues.length;
          if (nextLen === currLen)
            continue;
          if (!isAborted)
            isAborted = aborted(payload, currLen);
        }
      }
      if (asyncResult) {
        return asyncResult.then(() => {
          return payload;
        });
      }
      return payload;
    };
    const handleCanaryResult = (canary, payload, ctx) => {
      if (aborted(canary)) {
        canary.aborted = true;
        return canary;
      }
      const checkResult = runChecks(payload, checks, ctx);
      if (checkResult instanceof Promise) {
        if (ctx.async === false)
          throw new $ZodAsyncError();
        return checkResult.then((checkResult2) => inst._zod.parse(checkResult2, ctx));
      }
      return inst._zod.parse(checkResult, ctx);
    };
    inst._zod.run = (payload, ctx) => {
      if (ctx.skipChecks) {
        return inst._zod.parse(payload, ctx);
      }
      if (ctx.direction === "backward") {
        const canary = inst._zod.parse({ value: payload.value, issues: [] }, { ...ctx, skipChecks: true });
        if (canary instanceof Promise) {
          return canary.then((canary2) => {
            return handleCanaryResult(canary2, payload, ctx);
          });
        }
        return handleCanaryResult(canary, payload, ctx);
      }
      const result = inst._zod.parse(payload, ctx);
      if (result instanceof Promise) {
        if (ctx.async === false)
          throw new $ZodAsyncError();
        return result.then((result2) => runChecks(result2, checks, ctx));
      }
      return runChecks(result, checks, ctx);
    };
  }
  defineLazy(inst, "~standard", () => ({
    validate: (value) => {
      try {
        const r = safeParse(inst, value);
        return r.success ? { value: r.data } : { issues: r.error?.issues };
      } catch (_) {
        return safeParseAsync(inst, value).then((r) => r.success ? { value: r.data } : { issues: r.error?.issues });
      }
    },
    vendor: "zod",
    version: 1
  }));
});
var $ZodString = /* @__PURE__ */ $constructor("$ZodString", (inst, def) => {
  $ZodType.init(inst, def);
  inst._zod.pattern = [...inst?._zod.bag?.patterns ?? []].pop() ?? string(inst._zod.bag);
  inst._zod.parse = (payload, _) => {
    if (def.coerce)
      try {
        payload.value = String(payload.value);
      } catch (_2) {
      }
    if (typeof payload.value === "string")
      return payload;
    payload.issues.push({
      expected: "string",
      code: "invalid_type",
      input: payload.value,
      inst
    });
    return payload;
  };
});
var $ZodStringFormat = /* @__PURE__ */ $constructor("$ZodStringFormat", (inst, def) => {
  $ZodCheckStringFormat.init(inst, def);
  $ZodString.init(inst, def);
});
var $ZodGUID = /* @__PURE__ */ $constructor("$ZodGUID", (inst, def) => {
  def.pattern ?? (def.pattern = guid);
  $ZodStringFormat.init(inst, def);
});
var $ZodUUID = /* @__PURE__ */ $constructor("$ZodUUID", (inst, def) => {
  if (def.version) {
    const versionMap = {
      v1: 1,
      v2: 2,
      v3: 3,
      v4: 4,
      v5: 5,
      v6: 6,
      v7: 7,
      v8: 8
    };
    const v = versionMap[def.version];
    if (v === void 0)
      throw new Error(`Invalid UUID version: "${def.version}"`);
    def.pattern ?? (def.pattern = uuid(v));
  } else
    def.pattern ?? (def.pattern = uuid());
  $ZodStringFormat.init(inst, def);
});
var $ZodEmail = /* @__PURE__ */ $constructor("$ZodEmail", (inst, def) => {
  def.pattern ?? (def.pattern = email);
  $ZodStringFormat.init(inst, def);
});
var $ZodURL = /* @__PURE__ */ $constructor("$ZodURL", (inst, def) => {
  $ZodStringFormat.init(inst, def);
  inst._zod.check = (payload) => {
    try {
      const trimmed = payload.value.trim();
      if (!def.normalize && def.protocol?.source === httpProtocol.source) {
        if (!/^https?:\/\//i.test(trimmed)) {
          payload.issues.push({
            code: "invalid_format",
            format: "url",
            note: "Invalid URL format",
            input: payload.value,
            inst,
            continue: !def.abort
          });
          return;
        }
      }
      const url = new URL(trimmed);
      if (def.hostname) {
        def.hostname.lastIndex = 0;
        if (!def.hostname.test(url.hostname)) {
          payload.issues.push({
            code: "invalid_format",
            format: "url",
            note: "Invalid hostname",
            pattern: def.hostname.source,
            input: payload.value,
            inst,
            continue: !def.abort
          });
        }
      }
      if (def.protocol) {
        def.protocol.lastIndex = 0;
        if (!def.protocol.test(url.protocol.endsWith(":") ? url.protocol.slice(0, -1) : url.protocol)) {
          payload.issues.push({
            code: "invalid_format",
            format: "url",
            note: "Invalid protocol",
            pattern: def.protocol.source,
            input: payload.value,
            inst,
            continue: !def.abort
          });
        }
      }
      if (def.normalize) {
        payload.value = url.href;
      } else {
        payload.value = trimmed;
      }
      return;
    } catch (_) {
      payload.issues.push({
        code: "invalid_format",
        format: "url",
        input: payload.value,
        inst,
        continue: !def.abort
      });
    }
  };
});
var $ZodEmoji = /* @__PURE__ */ $constructor("$ZodEmoji", (inst, def) => {
  def.pattern ?? (def.pattern = emoji());
  $ZodStringFormat.init(inst, def);
});
var $ZodNanoID = /* @__PURE__ */ $constructor("$ZodNanoID", (inst, def) => {
  def.pattern ?? (def.pattern = nanoid);
  $ZodStringFormat.init(inst, def);
});
var $ZodCUID = /* @__PURE__ */ $constructor("$ZodCUID", (inst, def) => {
  def.pattern ?? (def.pattern = cuid);
  $ZodStringFormat.init(inst, def);
});
var $ZodCUID2 = /* @__PURE__ */ $constructor("$ZodCUID2", (inst, def) => {
  def.pattern ?? (def.pattern = cuid2);
  $ZodStringFormat.init(inst, def);
});
var $ZodULID = /* @__PURE__ */ $constructor("$ZodULID", (inst, def) => {
  def.pattern ?? (def.pattern = ulid);
  $ZodStringFormat.init(inst, def);
});
var $ZodXID = /* @__PURE__ */ $constructor("$ZodXID", (inst, def) => {
  def.pattern ?? (def.pattern = xid);
  $ZodStringFormat.init(inst, def);
});
var $ZodKSUID = /* @__PURE__ */ $constructor("$ZodKSUID", (inst, def) => {
  def.pattern ?? (def.pattern = ksuid);
  $ZodStringFormat.init(inst, def);
});
var $ZodISODateTime = /* @__PURE__ */ $constructor("$ZodISODateTime", (inst, def) => {
  def.pattern ?? (def.pattern = datetime(def));
  $ZodStringFormat.init(inst, def);
});
var $ZodISODate = /* @__PURE__ */ $constructor("$ZodISODate", (inst, def) => {
  def.pattern ?? (def.pattern = date);
  $ZodStringFormat.init(inst, def);
});
var $ZodISOTime = /* @__PURE__ */ $constructor("$ZodISOTime", (inst, def) => {
  def.pattern ?? (def.pattern = time(def));
  $ZodStringFormat.init(inst, def);
});
var $ZodISODuration = /* @__PURE__ */ $constructor("$ZodISODuration", (inst, def) => {
  def.pattern ?? (def.pattern = duration);
  $ZodStringFormat.init(inst, def);
});
var $ZodIPv4 = /* @__PURE__ */ $constructor("$ZodIPv4", (inst, def) => {
  def.pattern ?? (def.pattern = ipv4);
  $ZodStringFormat.init(inst, def);
  inst._zod.bag.format = `ipv4`;
});
var $ZodIPv6 = /* @__PURE__ */ $constructor("$ZodIPv6", (inst, def) => {
  def.pattern ?? (def.pattern = ipv6);
  $ZodStringFormat.init(inst, def);
  inst._zod.bag.format = `ipv6`;
  inst._zod.check = (payload) => {
    try {
      new URL(`http://[${payload.value}]`);
    } catch {
      payload.issues.push({
        code: "invalid_format",
        format: "ipv6",
        input: payload.value,
        inst,
        continue: !def.abort
      });
    }
  };
});
var $ZodCIDRv4 = /* @__PURE__ */ $constructor("$ZodCIDRv4", (inst, def) => {
  def.pattern ?? (def.pattern = cidrv4);
  $ZodStringFormat.init(inst, def);
});
var $ZodCIDRv6 = /* @__PURE__ */ $constructor("$ZodCIDRv6", (inst, def) => {
  def.pattern ?? (def.pattern = cidrv6);
  $ZodStringFormat.init(inst, def);
  inst._zod.check = (payload) => {
    const parts = payload.value.split("/");
    try {
      if (parts.length !== 2)
        throw new Error();
      const [address, prefix] = parts;
      if (!prefix)
        throw new Error();
      const prefixNum = Number(prefix);
      if (`${prefixNum}` !== prefix)
        throw new Error();
      if (prefixNum < 0 || prefixNum > 128)
        throw new Error();
      new URL(`http://[${address}]`);
    } catch {
      payload.issues.push({
        code: "invalid_format",
        format: "cidrv6",
        input: payload.value,
        inst,
        continue: !def.abort
      });
    }
  };
});
function isValidBase64(data) {
  if (data === "")
    return true;
  if (/\s/.test(data))
    return false;
  if (data.length % 4 !== 0)
    return false;
  try {
    atob(data);
    return true;
  } catch {
    return false;
  }
}
var $ZodBase64 = /* @__PURE__ */ $constructor("$ZodBase64", (inst, def) => {
  def.pattern ?? (def.pattern = base64);
  $ZodStringFormat.init(inst, def);
  inst._zod.bag.contentEncoding = "base64";
  inst._zod.check = (payload) => {
    if (isValidBase64(payload.value))
      return;
    payload.issues.push({
      code: "invalid_format",
      format: "base64",
      input: payload.value,
      inst,
      continue: !def.abort
    });
  };
});
function isValidBase64URL(data) {
  if (!base64url.test(data))
    return false;
  const base642 = data.replace(/[-_]/g, (c) => c === "-" ? "+" : "/");
  const padded = base642.padEnd(Math.ceil(base642.length / 4) * 4, "=");
  return isValidBase64(padded);
}
var $ZodBase64URL = /* @__PURE__ */ $constructor("$ZodBase64URL", (inst, def) => {
  def.pattern ?? (def.pattern = base64url);
  $ZodStringFormat.init(inst, def);
  inst._zod.bag.contentEncoding = "base64url";
  inst._zod.check = (payload) => {
    if (isValidBase64URL(payload.value))
      return;
    payload.issues.push({
      code: "invalid_format",
      format: "base64url",
      input: payload.value,
      inst,
      continue: !def.abort
    });
  };
});
var $ZodE164 = /* @__PURE__ */ $constructor("$ZodE164", (inst, def) => {
  def.pattern ?? (def.pattern = e164);
  $ZodStringFormat.init(inst, def);
});
function isValidJWT(token, algorithm = null) {
  try {
    const tokensParts = token.split(".");
    if (tokensParts.length !== 3)
      return false;
    const [header] = tokensParts;
    if (!header)
      return false;
    const parsedHeader = JSON.parse(atob(header));
    if ("typ" in parsedHeader && parsedHeader?.typ !== "JWT")
      return false;
    if (!parsedHeader.alg)
      return false;
    if (algorithm && (!("alg" in parsedHeader) || parsedHeader.alg !== algorithm))
      return false;
    return true;
  } catch {
    return false;
  }
}
var $ZodJWT = /* @__PURE__ */ $constructor("$ZodJWT", (inst, def) => {
  $ZodStringFormat.init(inst, def);
  inst._zod.check = (payload) => {
    if (isValidJWT(payload.value, def.alg))
      return;
    payload.issues.push({
      code: "invalid_format",
      format: "jwt",
      input: payload.value,
      inst,
      continue: !def.abort
    });
  };
});
var $ZodNumber = /* @__PURE__ */ $constructor("$ZodNumber", (inst, def) => {
  $ZodType.init(inst, def);
  inst._zod.pattern = inst._zod.bag.pattern ?? number;
  inst._zod.parse = (payload, _ctx) => {
    if (def.coerce)
      try {
        payload.value = Number(payload.value);
      } catch (_) {
      }
    const input = payload.value;
    if (typeof input === "number" && !Number.isNaN(input) && Number.isFinite(input)) {
      return payload;
    }
    const received = typeof input === "number" ? Number.isNaN(input) ? "NaN" : !Number.isFinite(input) ? "Infinity" : void 0 : void 0;
    payload.issues.push({
      expected: "number",
      code: "invalid_type",
      input,
      inst,
      ...received ? { received } : {}
    });
    return payload;
  };
});
var $ZodNumberFormat = /* @__PURE__ */ $constructor("$ZodNumberFormat", (inst, def) => {
  $ZodCheckNumberFormat.init(inst, def);
  $ZodNumber.init(inst, def);
});
var $ZodUnknown = /* @__PURE__ */ $constructor("$ZodUnknown", (inst, def) => {
  $ZodType.init(inst, def);
  inst._zod.parse = (payload) => payload;
});
var $ZodNever = /* @__PURE__ */ $constructor("$ZodNever", (inst, def) => {
  $ZodType.init(inst, def);
  inst._zod.parse = (payload, _ctx) => {
    payload.issues.push({
      expected: "never",
      code: "invalid_type",
      input: payload.value,
      inst
    });
    return payload;
  };
});
function handleArrayResult(result, final, index) {
  if (result.issues.length) {
    final.issues.push(...prefixIssues(index, result.issues));
  }
  final.value[index] = result.value;
}
var $ZodArray = /* @__PURE__ */ $constructor("$ZodArray", (inst, def) => {
  $ZodType.init(inst, def);
  inst._zod.parse = (payload, ctx) => {
    const input = payload.value;
    if (!Array.isArray(input)) {
      payload.issues.push({
        expected: "array",
        code: "invalid_type",
        input,
        inst
      });
      return payload;
    }
    payload.value = Array(input.length);
    const proms = [];
    for (let i = 0; i < input.length; i++) {
      const item = input[i];
      const result = def.element._zod.run({
        value: item,
        issues: []
      }, ctx);
      if (result instanceof Promise) {
        proms.push(result.then((result2) => handleArrayResult(result2, payload, i)));
      } else {
        handleArrayResult(result, payload, i);
      }
    }
    if (proms.length) {
      return Promise.all(proms).then(() => payload);
    }
    return payload;
  };
});
function handlePropertyResult(result, final, key, input, isOptionalIn, isOptionalOut) {
  const isPresent = key in input;
  if (result.issues.length) {
    if (isOptionalIn && isOptionalOut && !isPresent) {
      return;
    }
    final.issues.push(...prefixIssues(key, result.issues));
  }
  if (!isPresent && !isOptionalIn) {
    if (!result.issues.length) {
      final.issues.push({
        code: "invalid_type",
        expected: "nonoptional",
        input: void 0,
        path: [key]
      });
    }
    return;
  }
  if (result.value === void 0) {
    if (isPresent) {
      final.value[key] = void 0;
    }
  } else {
    final.value[key] = result.value;
  }
}
function normalizeDef(def) {
  const keys = Object.keys(def.shape);
  for (const k of keys) {
    if (!def.shape?.[k]?._zod?.traits?.has("$ZodType")) {
      throw new Error(`Invalid element at key "${k}": expected a Zod schema`);
    }
  }
  const okeys = optionalKeys(def.shape);
  return {
    ...def,
    keys,
    keySet: new Set(keys),
    numKeys: keys.length,
    optionalKeys: new Set(okeys)
  };
}
function handleCatchall(proms, input, payload, ctx, def, inst) {
  const unrecognized = [];
  const keySet = def.keySet;
  const _catchall = def.catchall._zod;
  const t = _catchall.def.type;
  const isOptionalIn = _catchall.optin === "optional";
  const isOptionalOut = _catchall.optout === "optional";
  for (const key in input) {
    if (key === "__proto__")
      continue;
    if (keySet.has(key))
      continue;
    if (t === "never") {
      unrecognized.push(key);
      continue;
    }
    const r = _catchall.run({ value: input[key], issues: [] }, ctx);
    if (r instanceof Promise) {
      proms.push(r.then((r2) => handlePropertyResult(r2, payload, key, input, isOptionalIn, isOptionalOut)));
    } else {
      handlePropertyResult(r, payload, key, input, isOptionalIn, isOptionalOut);
    }
  }
  if (unrecognized.length) {
    payload.issues.push({
      code: "unrecognized_keys",
      keys: unrecognized,
      input,
      inst
    });
  }
  if (!proms.length)
    return payload;
  return Promise.all(proms).then(() => {
    return payload;
  });
}
var $ZodObject = /* @__PURE__ */ $constructor("$ZodObject", (inst, def) => {
  $ZodType.init(inst, def);
  const desc = Object.getOwnPropertyDescriptor(def, "shape");
  if (!desc?.get) {
    const sh = def.shape;
    Object.defineProperty(def, "shape", {
      get: () => {
        const newSh = { ...sh };
        Object.defineProperty(def, "shape", {
          value: newSh
        });
        return newSh;
      }
    });
  }
  const _normalized = cached(() => normalizeDef(def));
  defineLazy(inst._zod, "propValues", () => {
    const shape = def.shape;
    const propValues = {};
    for (const key in shape) {
      const field = shape[key]._zod;
      if (field.values) {
        propValues[key] ?? (propValues[key] = /* @__PURE__ */ new Set());
        for (const v of field.values)
          propValues[key].add(v);
      }
    }
    return propValues;
  });
  const isObject2 = isObject;
  const catchall = def.catchall;
  let value;
  inst._zod.parse = (payload, ctx) => {
    value ?? (value = _normalized.value);
    const input = payload.value;
    if (!isObject2(input)) {
      payload.issues.push({
        expected: "object",
        code: "invalid_type",
        input,
        inst
      });
      return payload;
    }
    payload.value = {};
    const proms = [];
    const shape = value.shape;
    for (const key of value.keys) {
      const el = shape[key];
      const isOptionalIn = el._zod.optin === "optional";
      const isOptionalOut = el._zod.optout === "optional";
      const r = el._zod.run({ value: input[key], issues: [] }, ctx);
      if (r instanceof Promise) {
        proms.push(r.then((r2) => handlePropertyResult(r2, payload, key, input, isOptionalIn, isOptionalOut)));
      } else {
        handlePropertyResult(r, payload, key, input, isOptionalIn, isOptionalOut);
      }
    }
    if (!catchall) {
      return proms.length ? Promise.all(proms).then(() => payload) : payload;
    }
    return handleCatchall(proms, input, payload, ctx, _normalized.value, inst);
  };
});
var $ZodObjectJIT = /* @__PURE__ */ $constructor("$ZodObjectJIT", (inst, def) => {
  $ZodObject.init(inst, def);
  const superParse = inst._zod.parse;
  const _normalized = cached(() => normalizeDef(def));
  const generateFastpass = (shape) => {
    const doc = new Doc(["shape", "payload", "ctx"]);
    const normalized = _normalized.value;
    const parseStr = (key) => {
      const k = esc(key);
      return `shape[${k}]._zod.run({ value: input[${k}], issues: [] }, ctx)`;
    };
    doc.write(`const input = payload.value;`);
    const ids = /* @__PURE__ */ Object.create(null);
    let counter = 0;
    for (const key of normalized.keys) {
      ids[key] = `key_${counter++}`;
    }
    doc.write(`const newResult = {};`);
    for (const key of normalized.keys) {
      const id = ids[key];
      const k = esc(key);
      const schema = shape[key];
      const isOptionalIn = schema?._zod?.optin === "optional";
      const isOptionalOut = schema?._zod?.optout === "optional";
      doc.write(`const ${id} = ${parseStr(key)};`);
      if (isOptionalIn && isOptionalOut) {
        doc.write(`
        if (${id}.issues.length) {
          if (${k} in input) {
            payload.issues = payload.issues.concat(${id}.issues.map(iss => ({
              ...iss,
              path: iss.path ? [${k}, ...iss.path] : [${k}]
            })));
          }
        }

        if (${id}.value === undefined) {
          if (${k} in input) {
            newResult[${k}] = undefined;
          }
        } else {
          newResult[${k}] = ${id}.value;
        }

      `);
      } else if (!isOptionalIn) {
        doc.write(`
        const ${id}_present = ${k} in input;
        if (${id}.issues.length) {
          payload.issues = payload.issues.concat(${id}.issues.map(iss => ({
            ...iss,
            path: iss.path ? [${k}, ...iss.path] : [${k}]
          })));
        }
        if (!${id}_present && !${id}.issues.length) {
          payload.issues.push({
            code: "invalid_type",
            expected: "nonoptional",
            input: undefined,
            path: [${k}]
          });
        }

        if (${id}_present) {
          if (${id}.value === undefined) {
            newResult[${k}] = undefined;
          } else {
            newResult[${k}] = ${id}.value;
          }
        }

      `);
      } else {
        doc.write(`
        if (${id}.issues.length) {
          payload.issues = payload.issues.concat(${id}.issues.map(iss => ({
            ...iss,
            path: iss.path ? [${k}, ...iss.path] : [${k}]
          })));
        }

        if (${id}.value === undefined) {
          if (${k} in input) {
            newResult[${k}] = undefined;
          }
        } else {
          newResult[${k}] = ${id}.value;
        }

      `);
      }
    }
    doc.write(`payload.value = newResult;`);
    doc.write(`return payload;`);
    const fn = doc.compile();
    return (payload, ctx) => fn(shape, payload, ctx);
  };
  let fastpass;
  const isObject2 = isObject;
  const jit = !globalConfig.jitless;
  const allowsEval2 = allowsEval;
  const fastEnabled = jit && allowsEval2.value;
  const catchall = def.catchall;
  let value;
  inst._zod.parse = (payload, ctx) => {
    value ?? (value = _normalized.value);
    const input = payload.value;
    if (!isObject2(input)) {
      payload.issues.push({
        expected: "object",
        code: "invalid_type",
        input,
        inst
      });
      return payload;
    }
    if (jit && fastEnabled && ctx?.async === false && ctx.jitless !== true) {
      if (!fastpass)
        fastpass = generateFastpass(def.shape);
      payload = fastpass(payload, ctx);
      if (!catchall)
        return payload;
      return handleCatchall([], input, payload, ctx, value, inst);
    }
    return superParse(payload, ctx);
  };
});
function handleUnionResults(results, final, inst, ctx) {
  for (const result of results) {
    if (result.issues.length === 0) {
      final.value = result.value;
      return final;
    }
  }
  const nonaborted = results.filter((r) => !aborted(r));
  if (nonaborted.length === 1) {
    final.value = nonaborted[0].value;
    return nonaborted[0];
  }
  final.issues.push({
    code: "invalid_union",
    input: final.value,
    inst,
    errors: results.map((result) => result.issues.map((iss) => finalizeIssue(iss, ctx, config())))
  });
  return final;
}
var $ZodUnion = /* @__PURE__ */ $constructor("$ZodUnion", (inst, def) => {
  $ZodType.init(inst, def);
  defineLazy(inst._zod, "optin", () => def.options.some((o) => o._zod.optin === "optional") ? "optional" : void 0);
  defineLazy(inst._zod, "optout", () => def.options.some((o) => o._zod.optout === "optional") ? "optional" : void 0);
  defineLazy(inst._zod, "values", () => {
    if (def.options.every((o) => o._zod.values)) {
      return new Set(def.options.flatMap((option) => Array.from(option._zod.values)));
    }
    return void 0;
  });
  defineLazy(inst._zod, "pattern", () => {
    if (def.options.every((o) => o._zod.pattern)) {
      const patterns = def.options.map((o) => o._zod.pattern);
      return new RegExp(`^(${patterns.map((p) => cleanRegex(p.source)).join("|")})$`);
    }
    return void 0;
  });
  const first = def.options.length === 1 ? def.options[0]._zod.run : null;
  inst._zod.parse = (payload, ctx) => {
    if (first) {
      return first(payload, ctx);
    }
    let async = false;
    const results = [];
    for (const option of def.options) {
      const result = option._zod.run({
        value: payload.value,
        issues: []
      }, ctx);
      if (result instanceof Promise) {
        results.push(result);
        async = true;
      } else {
        if (result.issues.length === 0)
          return result;
        results.push(result);
      }
    }
    if (!async)
      return handleUnionResults(results, payload, inst, ctx);
    return Promise.all(results).then((results2) => {
      return handleUnionResults(results2, payload, inst, ctx);
    });
  };
});
var $ZodIntersection = /* @__PURE__ */ $constructor("$ZodIntersection", (inst, def) => {
  $ZodType.init(inst, def);
  inst._zod.parse = (payload, ctx) => {
    const input = payload.value;
    const left = def.left._zod.run({ value: input, issues: [] }, ctx);
    const right = def.right._zod.run({ value: input, issues: [] }, ctx);
    const async = left instanceof Promise || right instanceof Promise;
    if (async) {
      return Promise.all([left, right]).then(([left2, right2]) => {
        return handleIntersectionResults(payload, left2, right2);
      });
    }
    return handleIntersectionResults(payload, left, right);
  };
});
function mergeValues(a, b) {
  if (a === b) {
    return { valid: true, data: a };
  }
  if (a instanceof Date && b instanceof Date && +a === +b) {
    return { valid: true, data: a };
  }
  if (isPlainObject(a) && isPlainObject(b)) {
    const bKeys = Object.keys(b);
    const sharedKeys = Object.keys(a).filter((key) => bKeys.indexOf(key) !== -1);
    const newObj = { ...a, ...b };
    for (const key of sharedKeys) {
      const sharedValue = mergeValues(a[key], b[key]);
      if (!sharedValue.valid) {
        return {
          valid: false,
          mergeErrorPath: [key, ...sharedValue.mergeErrorPath]
        };
      }
      newObj[key] = sharedValue.data;
    }
    return { valid: true, data: newObj };
  }
  if (Array.isArray(a) && Array.isArray(b)) {
    if (a.length !== b.length) {
      return { valid: false, mergeErrorPath: [] };
    }
    const newArray = [];
    for (let index = 0; index < a.length; index++) {
      const itemA = a[index];
      const itemB = b[index];
      const sharedValue = mergeValues(itemA, itemB);
      if (!sharedValue.valid) {
        return {
          valid: false,
          mergeErrorPath: [index, ...sharedValue.mergeErrorPath]
        };
      }
      newArray.push(sharedValue.data);
    }
    return { valid: true, data: newArray };
  }
  return { valid: false, mergeErrorPath: [] };
}
function handleIntersectionResults(result, left, right) {
  const unrecKeys = /* @__PURE__ */ new Map();
  let unrecIssue;
  for (const iss of left.issues) {
    if (iss.code === "unrecognized_keys") {
      unrecIssue ?? (unrecIssue = iss);
      for (const k of iss.keys) {
        if (!unrecKeys.has(k))
          unrecKeys.set(k, {});
        unrecKeys.get(k).l = true;
      }
    } else {
      result.issues.push(iss);
    }
  }
  for (const iss of right.issues) {
    if (iss.code === "unrecognized_keys") {
      for (const k of iss.keys) {
        if (!unrecKeys.has(k))
          unrecKeys.set(k, {});
        unrecKeys.get(k).r = true;
      }
    } else {
      result.issues.push(iss);
    }
  }
  const bothKeys = [...unrecKeys].filter(([, f]) => f.l && f.r).map(([k]) => k);
  if (bothKeys.length && unrecIssue) {
    result.issues.push({ ...unrecIssue, keys: bothKeys });
  }
  if (aborted(result))
    return result;
  const merged = mergeValues(left.value, right.value);
  if (!merged.valid) {
    throw new Error(`Unmergable intersection. Error path: ${JSON.stringify(merged.mergeErrorPath)}`);
  }
  result.value = merged.data;
  return result;
}
var $ZodRecord = /* @__PURE__ */ $constructor("$ZodRecord", (inst, def) => {
  $ZodType.init(inst, def);
  inst._zod.parse = (payload, ctx) => {
    const input = payload.value;
    if (!isPlainObject(input)) {
      payload.issues.push({
        expected: "record",
        code: "invalid_type",
        input,
        inst
      });
      return payload;
    }
    const proms = [];
    const values = def.keyType._zod.values;
    if (values) {
      payload.value = {};
      const recordKeys = /* @__PURE__ */ new Set();
      for (const key of values) {
        if (typeof key === "string" || typeof key === "number" || typeof key === "symbol") {
          recordKeys.add(typeof key === "number" ? key.toString() : key);
          const keyResult = def.keyType._zod.run({ value: key, issues: [] }, ctx);
          if (keyResult instanceof Promise) {
            throw new Error("Async schemas not supported in object keys currently");
          }
          if (keyResult.issues.length) {
            payload.issues.push({
              code: "invalid_key",
              origin: "record",
              issues: keyResult.issues.map((iss) => finalizeIssue(iss, ctx, config())),
              input: key,
              path: [key],
              inst
            });
            continue;
          }
          const outKey = keyResult.value;
          const result = def.valueType._zod.run({ value: input[key], issues: [] }, ctx);
          if (result instanceof Promise) {
            proms.push(result.then((result2) => {
              if (result2.issues.length) {
                payload.issues.push(...prefixIssues(key, result2.issues));
              }
              payload.value[outKey] = result2.value;
            }));
          } else {
            if (result.issues.length) {
              payload.issues.push(...prefixIssues(key, result.issues));
            }
            payload.value[outKey] = result.value;
          }
        }
      }
      let unrecognized;
      for (const key in input) {
        if (!recordKeys.has(key)) {
          unrecognized = unrecognized ?? [];
          unrecognized.push(key);
        }
      }
      if (unrecognized && unrecognized.length > 0) {
        payload.issues.push({
          code: "unrecognized_keys",
          input,
          inst,
          keys: unrecognized
        });
      }
    } else {
      payload.value = {};
      for (const key of Reflect.ownKeys(input)) {
        if (key === "__proto__")
          continue;
        if (!Object.prototype.propertyIsEnumerable.call(input, key))
          continue;
        let keyResult = def.keyType._zod.run({ value: key, issues: [] }, ctx);
        if (keyResult instanceof Promise) {
          throw new Error("Async schemas not supported in object keys currently");
        }
        const checkNumericKey = typeof key === "string" && number.test(key) && keyResult.issues.length;
        if (checkNumericKey) {
          const retryResult = def.keyType._zod.run({ value: Number(key), issues: [] }, ctx);
          if (retryResult instanceof Promise) {
            throw new Error("Async schemas not supported in object keys currently");
          }
          if (retryResult.issues.length === 0) {
            keyResult = retryResult;
          }
        }
        if (keyResult.issues.length) {
          if (def.mode === "loose") {
            payload.value[key] = input[key];
          } else {
            payload.issues.push({
              code: "invalid_key",
              origin: "record",
              issues: keyResult.issues.map((iss) => finalizeIssue(iss, ctx, config())),
              input: key,
              path: [key],
              inst
            });
          }
          continue;
        }
        const result = def.valueType._zod.run({ value: input[key], issues: [] }, ctx);
        if (result instanceof Promise) {
          proms.push(result.then((result2) => {
            if (result2.issues.length) {
              payload.issues.push(...prefixIssues(key, result2.issues));
            }
            payload.value[keyResult.value] = result2.value;
          }));
        } else {
          if (result.issues.length) {
            payload.issues.push(...prefixIssues(key, result.issues));
          }
          payload.value[keyResult.value] = result.value;
        }
      }
    }
    if (proms.length) {
      return Promise.all(proms).then(() => payload);
    }
    return payload;
  };
});
var $ZodEnum = /* @__PURE__ */ $constructor("$ZodEnum", (inst, def) => {
  $ZodType.init(inst, def);
  const values = getEnumValues(def.entries);
  const valuesSet = new Set(values);
  inst._zod.values = valuesSet;
  inst._zod.pattern = new RegExp(`^(${values.filter((k) => propertyKeyTypes.has(typeof k)).map((o) => typeof o === "string" ? escapeRegex(o) : o.toString()).join("|")})$`);
  inst._zod.parse = (payload, _ctx) => {
    const input = payload.value;
    if (valuesSet.has(input)) {
      return payload;
    }
    payload.issues.push({
      code: "invalid_value",
      values,
      input,
      inst
    });
    return payload;
  };
});
var $ZodTransform = /* @__PURE__ */ $constructor("$ZodTransform", (inst, def) => {
  $ZodType.init(inst, def);
  inst._zod.optin = "optional";
  inst._zod.parse = (payload, ctx) => {
    if (ctx.direction === "backward") {
      throw new $ZodEncodeError(inst.constructor.name);
    }
    const _out = def.transform(payload.value, payload);
    if (ctx.async) {
      const output = _out instanceof Promise ? _out : Promise.resolve(_out);
      return output.then((output2) => {
        payload.value = output2;
        payload.fallback = true;
        return payload;
      });
    }
    if (_out instanceof Promise) {
      throw new $ZodAsyncError();
    }
    payload.value = _out;
    payload.fallback = true;
    return payload;
  };
});
function handleOptionalResult(result, input) {
  if (input === void 0 && (result.issues.length || result.fallback)) {
    return { issues: [], value: void 0 };
  }
  return result;
}
var $ZodOptional = /* @__PURE__ */ $constructor("$ZodOptional", (inst, def) => {
  $ZodType.init(inst, def);
  inst._zod.optin = "optional";
  inst._zod.optout = "optional";
  defineLazy(inst._zod, "values", () => {
    return def.innerType._zod.values ? /* @__PURE__ */ new Set([...def.innerType._zod.values, void 0]) : void 0;
  });
  defineLazy(inst._zod, "pattern", () => {
    const pattern = def.innerType._zod.pattern;
    return pattern ? new RegExp(`^(${cleanRegex(pattern.source)})?$`) : void 0;
  });
  inst._zod.parse = (payload, ctx) => {
    if (def.innerType._zod.optin === "optional") {
      const input = payload.value;
      const result = def.innerType._zod.run(payload, ctx);
      if (result instanceof Promise)
        return result.then((r) => handleOptionalResult(r, input));
      return handleOptionalResult(result, input);
    }
    if (payload.value === void 0) {
      return payload;
    }
    return def.innerType._zod.run(payload, ctx);
  };
});
var $ZodExactOptional = /* @__PURE__ */ $constructor("$ZodExactOptional", (inst, def) => {
  $ZodOptional.init(inst, def);
  defineLazy(inst._zod, "values", () => def.innerType._zod.values);
  defineLazy(inst._zod, "pattern", () => def.innerType._zod.pattern);
  inst._zod.parse = (payload, ctx) => {
    return def.innerType._zod.run(payload, ctx);
  };
});
var $ZodNullable = /* @__PURE__ */ $constructor("$ZodNullable", (inst, def) => {
  $ZodType.init(inst, def);
  defineLazy(inst._zod, "optin", () => def.innerType._zod.optin);
  defineLazy(inst._zod, "optout", () => def.innerType._zod.optout);
  defineLazy(inst._zod, "pattern", () => {
    const pattern = def.innerType._zod.pattern;
    return pattern ? new RegExp(`^(${cleanRegex(pattern.source)}|null)$`) : void 0;
  });
  defineLazy(inst._zod, "values", () => {
    return def.innerType._zod.values ? /* @__PURE__ */ new Set([...def.innerType._zod.values, null]) : void 0;
  });
  inst._zod.parse = (payload, ctx) => {
    if (payload.value === null)
      return payload;
    return def.innerType._zod.run(payload, ctx);
  };
});
var $ZodDefault = /* @__PURE__ */ $constructor("$ZodDefault", (inst, def) => {
  $ZodType.init(inst, def);
  inst._zod.optin = "optional";
  defineLazy(inst._zod, "values", () => def.innerType._zod.values);
  inst._zod.parse = (payload, ctx) => {
    if (ctx.direction === "backward") {
      return def.innerType._zod.run(payload, ctx);
    }
    if (payload.value === void 0) {
      payload.value = def.defaultValue;
      return payload;
    }
    const result = def.innerType._zod.run(payload, ctx);
    if (result instanceof Promise) {
      return result.then((result2) => handleDefaultResult(result2, def));
    }
    return handleDefaultResult(result, def);
  };
});
function handleDefaultResult(payload, def) {
  if (payload.value === void 0) {
    payload.value = def.defaultValue;
  }
  return payload;
}
var $ZodPrefault = /* @__PURE__ */ $constructor("$ZodPrefault", (inst, def) => {
  $ZodType.init(inst, def);
  inst._zod.optin = "optional";
  defineLazy(inst._zod, "values", () => def.innerType._zod.values);
  inst._zod.parse = (payload, ctx) => {
    if (ctx.direction === "backward") {
      return def.innerType._zod.run(payload, ctx);
    }
    if (payload.value === void 0) {
      payload.value = def.defaultValue;
    }
    return def.innerType._zod.run(payload, ctx);
  };
});
var $ZodNonOptional = /* @__PURE__ */ $constructor("$ZodNonOptional", (inst, def) => {
  $ZodType.init(inst, def);
  defineLazy(inst._zod, "values", () => {
    const v = def.innerType._zod.values;
    return v ? new Set([...v].filter((x) => x !== void 0)) : void 0;
  });
  inst._zod.parse = (payload, ctx) => {
    const result = def.innerType._zod.run(payload, ctx);
    if (result instanceof Promise) {
      return result.then((result2) => handleNonOptionalResult(result2, inst));
    }
    return handleNonOptionalResult(result, inst);
  };
});
function handleNonOptionalResult(payload, inst) {
  if (!payload.issues.length && payload.value === void 0) {
    payload.issues.push({
      code: "invalid_type",
      expected: "nonoptional",
      input: payload.value,
      inst
    });
  }
  return payload;
}
var $ZodCatch = /* @__PURE__ */ $constructor("$ZodCatch", (inst, def) => {
  $ZodType.init(inst, def);
  inst._zod.optin = "optional";
  defineLazy(inst._zod, "optout", () => def.innerType._zod.optout);
  defineLazy(inst._zod, "values", () => def.innerType._zod.values);
  inst._zod.parse = (payload, ctx) => {
    if (ctx.direction === "backward") {
      return def.innerType._zod.run(payload, ctx);
    }
    const result = def.innerType._zod.run(payload, ctx);
    if (result instanceof Promise) {
      return result.then((result2) => {
        payload.value = result2.value;
        if (result2.issues.length) {
          payload.value = def.catchValue({
            ...payload,
            error: {
              issues: result2.issues.map((iss) => finalizeIssue(iss, ctx, config()))
            },
            input: payload.value
          });
          payload.issues = [];
          payload.fallback = true;
        }
        return payload;
      });
    }
    payload.value = result.value;
    if (result.issues.length) {
      payload.value = def.catchValue({
        ...payload,
        error: {
          issues: result.issues.map((iss) => finalizeIssue(iss, ctx, config()))
        },
        input: payload.value
      });
      payload.issues = [];
      payload.fallback = true;
    }
    return payload;
  };
});
var $ZodPipe = /* @__PURE__ */ $constructor("$ZodPipe", (inst, def) => {
  $ZodType.init(inst, def);
  defineLazy(inst._zod, "values", () => def.in._zod.values);
  defineLazy(inst._zod, "optin", () => def.in._zod.optin);
  defineLazy(inst._zod, "optout", () => def.out._zod.optout);
  defineLazy(inst._zod, "propValues", () => def.in._zod.propValues);
  inst._zod.parse = (payload, ctx) => {
    if (ctx.direction === "backward") {
      const right = def.out._zod.run(payload, ctx);
      if (right instanceof Promise) {
        return right.then((right2) => handlePipeResult(right2, def.in, ctx));
      }
      return handlePipeResult(right, def.in, ctx);
    }
    const left = def.in._zod.run(payload, ctx);
    if (left instanceof Promise) {
      return left.then((left2) => handlePipeResult(left2, def.out, ctx));
    }
    return handlePipeResult(left, def.out, ctx);
  };
});
function handlePipeResult(left, next, ctx) {
  if (left.issues.length) {
    left.aborted = true;
    return left;
  }
  return next._zod.run({ value: left.value, issues: left.issues, fallback: left.fallback }, ctx);
}
var $ZodReadonly = /* @__PURE__ */ $constructor("$ZodReadonly", (inst, def) => {
  $ZodType.init(inst, def);
  defineLazy(inst._zod, "propValues", () => def.innerType._zod.propValues);
  defineLazy(inst._zod, "values", () => def.innerType._zod.values);
  defineLazy(inst._zod, "optin", () => def.innerType?._zod?.optin);
  defineLazy(inst._zod, "optout", () => def.innerType?._zod?.optout);
  inst._zod.parse = (payload, ctx) => {
    if (ctx.direction === "backward") {
      return def.innerType._zod.run(payload, ctx);
    }
    const result = def.innerType._zod.run(payload, ctx);
    if (result instanceof Promise) {
      return result.then(handleReadonlyResult);
    }
    return handleReadonlyResult(result);
  };
});
function handleReadonlyResult(payload) {
  payload.value = Object.freeze(payload.value);
  return payload;
}
var $ZodCustom = /* @__PURE__ */ $constructor("$ZodCustom", (inst, def) => {
  $ZodCheck.init(inst, def);
  $ZodType.init(inst, def);
  inst._zod.parse = (payload, _) => {
    return payload;
  };
  inst._zod.check = (payload) => {
    const input = payload.value;
    const r = def.fn(input);
    if (r instanceof Promise) {
      return r.then((r2) => handleRefineResult(r2, payload, input, inst));
    }
    handleRefineResult(r, payload, input, inst);
    return;
  };
});
function handleRefineResult(result, payload, input, inst) {
  if (!result) {
    const _iss = {
      code: "custom",
      input,
      inst,
      // incorporates params.error into issue reporting
      path: [...inst._zod.def.path ?? []],
      // incorporates params.error into issue reporting
      continue: !inst._zod.def.abort
      // params: inst._zod.def.params,
    };
    if (inst._zod.def.params)
      _iss.params = inst._zod.def.params;
    payload.issues.push(issue(_iss));
  }
}

// node_modules/zod/v4/core/registries.js
var _a2;
var $ZodRegistry = class {
  constructor() {
    this._map = /* @__PURE__ */ new WeakMap();
    this._idmap = /* @__PURE__ */ new Map();
  }
  add(schema, ..._meta) {
    const meta2 = _meta[0];
    this._map.set(schema, meta2);
    if (meta2 && typeof meta2 === "object" && "id" in meta2) {
      this._idmap.set(meta2.id, schema);
    }
    return this;
  }
  clear() {
    this._map = /* @__PURE__ */ new WeakMap();
    this._idmap = /* @__PURE__ */ new Map();
    return this;
  }
  remove(schema) {
    const meta2 = this._map.get(schema);
    if (meta2 && typeof meta2 === "object" && "id" in meta2) {
      this._idmap.delete(meta2.id);
    }
    this._map.delete(schema);
    return this;
  }
  get(schema) {
    const p = schema._zod.parent;
    if (p) {
      const pm = { ...this.get(p) ?? {} };
      delete pm.id;
      const f = { ...pm, ...this._map.get(schema) };
      return Object.keys(f).length ? f : void 0;
    }
    return this._map.get(schema);
  }
  has(schema) {
    return this._map.has(schema);
  }
};
function registry() {
  return new $ZodRegistry();
}
(_a2 = globalThis).__zod_globalRegistry ?? (_a2.__zod_globalRegistry = registry());
var globalRegistry = globalThis.__zod_globalRegistry;

// node_modules/zod/v4/core/api.js
// @__NO_SIDE_EFFECTS__
function _string(Class2, params) {
  return new Class2({
    type: "string",
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _email(Class2, params) {
  return new Class2({
    type: "string",
    format: "email",
    check: "string_format",
    abort: false,
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _guid(Class2, params) {
  return new Class2({
    type: "string",
    format: "guid",
    check: "string_format",
    abort: false,
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _uuid(Class2, params) {
  return new Class2({
    type: "string",
    format: "uuid",
    check: "string_format",
    abort: false,
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _uuidv4(Class2, params) {
  return new Class2({
    type: "string",
    format: "uuid",
    check: "string_format",
    abort: false,
    version: "v4",
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _uuidv6(Class2, params) {
  return new Class2({
    type: "string",
    format: "uuid",
    check: "string_format",
    abort: false,
    version: "v6",
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _uuidv7(Class2, params) {
  return new Class2({
    type: "string",
    format: "uuid",
    check: "string_format",
    abort: false,
    version: "v7",
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _url(Class2, params) {
  return new Class2({
    type: "string",
    format: "url",
    check: "string_format",
    abort: false,
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _emoji2(Class2, params) {
  return new Class2({
    type: "string",
    format: "emoji",
    check: "string_format",
    abort: false,
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _nanoid(Class2, params) {
  return new Class2({
    type: "string",
    format: "nanoid",
    check: "string_format",
    abort: false,
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _cuid(Class2, params) {
  return new Class2({
    type: "string",
    format: "cuid",
    check: "string_format",
    abort: false,
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _cuid2(Class2, params) {
  return new Class2({
    type: "string",
    format: "cuid2",
    check: "string_format",
    abort: false,
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _ulid(Class2, params) {
  return new Class2({
    type: "string",
    format: "ulid",
    check: "string_format",
    abort: false,
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _xid(Class2, params) {
  return new Class2({
    type: "string",
    format: "xid",
    check: "string_format",
    abort: false,
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _ksuid(Class2, params) {
  return new Class2({
    type: "string",
    format: "ksuid",
    check: "string_format",
    abort: false,
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _ipv4(Class2, params) {
  return new Class2({
    type: "string",
    format: "ipv4",
    check: "string_format",
    abort: false,
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _ipv6(Class2, params) {
  return new Class2({
    type: "string",
    format: "ipv6",
    check: "string_format",
    abort: false,
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _cidrv4(Class2, params) {
  return new Class2({
    type: "string",
    format: "cidrv4",
    check: "string_format",
    abort: false,
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _cidrv6(Class2, params) {
  return new Class2({
    type: "string",
    format: "cidrv6",
    check: "string_format",
    abort: false,
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _base64(Class2, params) {
  return new Class2({
    type: "string",
    format: "base64",
    check: "string_format",
    abort: false,
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _base64url(Class2, params) {
  return new Class2({
    type: "string",
    format: "base64url",
    check: "string_format",
    abort: false,
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _e164(Class2, params) {
  return new Class2({
    type: "string",
    format: "e164",
    check: "string_format",
    abort: false,
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _jwt(Class2, params) {
  return new Class2({
    type: "string",
    format: "jwt",
    check: "string_format",
    abort: false,
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _isoDateTime(Class2, params) {
  return new Class2({
    type: "string",
    format: "datetime",
    check: "string_format",
    offset: false,
    local: false,
    precision: null,
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _isoDate(Class2, params) {
  return new Class2({
    type: "string",
    format: "date",
    check: "string_format",
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _isoTime(Class2, params) {
  return new Class2({
    type: "string",
    format: "time",
    check: "string_format",
    precision: null,
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _isoDuration(Class2, params) {
  return new Class2({
    type: "string",
    format: "duration",
    check: "string_format",
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _number(Class2, params) {
  return new Class2({
    type: "number",
    checks: [],
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _int(Class2, params) {
  return new Class2({
    type: "number",
    check: "number_format",
    abort: false,
    format: "safeint",
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _unknown(Class2) {
  return new Class2({
    type: "unknown"
  });
}
// @__NO_SIDE_EFFECTS__
function _never(Class2, params) {
  return new Class2({
    type: "never",
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _lt(value, params) {
  return new $ZodCheckLessThan({
    check: "less_than",
    ...normalizeParams(params),
    value,
    inclusive: false
  });
}
// @__NO_SIDE_EFFECTS__
function _lte(value, params) {
  return new $ZodCheckLessThan({
    check: "less_than",
    ...normalizeParams(params),
    value,
    inclusive: true
  });
}
// @__NO_SIDE_EFFECTS__
function _gt(value, params) {
  return new $ZodCheckGreaterThan({
    check: "greater_than",
    ...normalizeParams(params),
    value,
    inclusive: false
  });
}
// @__NO_SIDE_EFFECTS__
function _gte(value, params) {
  return new $ZodCheckGreaterThan({
    check: "greater_than",
    ...normalizeParams(params),
    value,
    inclusive: true
  });
}
// @__NO_SIDE_EFFECTS__
function _multipleOf(value, params) {
  return new $ZodCheckMultipleOf({
    check: "multiple_of",
    ...normalizeParams(params),
    value
  });
}
// @__NO_SIDE_EFFECTS__
function _maxLength(maximum, params) {
  const ch = new $ZodCheckMaxLength({
    check: "max_length",
    ...normalizeParams(params),
    maximum
  });
  return ch;
}
// @__NO_SIDE_EFFECTS__
function _minLength(minimum, params) {
  return new $ZodCheckMinLength({
    check: "min_length",
    ...normalizeParams(params),
    minimum
  });
}
// @__NO_SIDE_EFFECTS__
function _length(length, params) {
  return new $ZodCheckLengthEquals({
    check: "length_equals",
    ...normalizeParams(params),
    length
  });
}
// @__NO_SIDE_EFFECTS__
function _regex(pattern, params) {
  return new $ZodCheckRegex({
    check: "string_format",
    format: "regex",
    ...normalizeParams(params),
    pattern
  });
}
// @__NO_SIDE_EFFECTS__
function _lowercase(params) {
  return new $ZodCheckLowerCase({
    check: "string_format",
    format: "lowercase",
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _uppercase(params) {
  return new $ZodCheckUpperCase({
    check: "string_format",
    format: "uppercase",
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _includes(includes, params) {
  return new $ZodCheckIncludes({
    check: "string_format",
    format: "includes",
    ...normalizeParams(params),
    includes
  });
}
// @__NO_SIDE_EFFECTS__
function _startsWith(prefix, params) {
  return new $ZodCheckStartsWith({
    check: "string_format",
    format: "starts_with",
    ...normalizeParams(params),
    prefix
  });
}
// @__NO_SIDE_EFFECTS__
function _endsWith(suffix, params) {
  return new $ZodCheckEndsWith({
    check: "string_format",
    format: "ends_with",
    ...normalizeParams(params),
    suffix
  });
}
// @__NO_SIDE_EFFECTS__
function _overwrite(tx) {
  return new $ZodCheckOverwrite({
    check: "overwrite",
    tx
  });
}
// @__NO_SIDE_EFFECTS__
function _normalize(form) {
  return /* @__PURE__ */ _overwrite((input) => input.normalize(form));
}
// @__NO_SIDE_EFFECTS__
function _trim() {
  return /* @__PURE__ */ _overwrite((input) => input.trim());
}
// @__NO_SIDE_EFFECTS__
function _toLowerCase() {
  return /* @__PURE__ */ _overwrite((input) => input.toLowerCase());
}
// @__NO_SIDE_EFFECTS__
function _toUpperCase() {
  return /* @__PURE__ */ _overwrite((input) => input.toUpperCase());
}
// @__NO_SIDE_EFFECTS__
function _slugify() {
  return /* @__PURE__ */ _overwrite((input) => slugify(input));
}
// @__NO_SIDE_EFFECTS__
function _array(Class2, element, params) {
  return new Class2({
    type: "array",
    element,
    // get element() {
    //   return element;
    // },
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _refine(Class2, fn, _params) {
  const schema = new Class2({
    type: "custom",
    check: "custom",
    fn,
    ...normalizeParams(_params)
  });
  return schema;
}
// @__NO_SIDE_EFFECTS__
function _superRefine(fn, params) {
  const ch = /* @__PURE__ */ _check((payload) => {
    payload.addIssue = (issue2) => {
      if (typeof issue2 === "string") {
        payload.issues.push(issue(issue2, payload.value, ch._zod.def));
      } else {
        const _issue = issue2;
        if (_issue.fatal)
          _issue.continue = false;
        _issue.code ?? (_issue.code = "custom");
        _issue.input ?? (_issue.input = payload.value);
        _issue.inst ?? (_issue.inst = ch);
        _issue.continue ?? (_issue.continue = !ch._zod.def.abort);
        payload.issues.push(issue(_issue));
      }
    };
    return fn(payload.value, payload);
  }, params);
  return ch;
}
// @__NO_SIDE_EFFECTS__
function _check(fn, params) {
  const ch = new $ZodCheck({
    check: "custom",
    ...normalizeParams(params)
  });
  ch._zod.check = fn;
  return ch;
}

// node_modules/zod/v4/core/to-json-schema.js
function initializeContext(params) {
  let target = params?.target ?? "draft-2020-12";
  if (target === "draft-4")
    target = "draft-04";
  if (target === "draft-7")
    target = "draft-07";
  return {
    processors: params.processors ?? {},
    metadataRegistry: params?.metadata ?? globalRegistry,
    target,
    unrepresentable: params?.unrepresentable ?? "throw",
    override: params?.override ?? (() => {
    }),
    io: params?.io ?? "output",
    counter: 0,
    seen: /* @__PURE__ */ new Map(),
    cycles: params?.cycles ?? "ref",
    reused: params?.reused ?? "inline",
    external: params?.external ?? void 0
  };
}
function process2(schema, ctx, _params = { path: [], schemaPath: [] }) {
  var _a3;
  const def = schema._zod.def;
  const seen = ctx.seen.get(schema);
  if (seen) {
    seen.count++;
    const isCycle = _params.schemaPath.includes(schema);
    if (isCycle) {
      seen.cycle = _params.path;
    }
    return seen.schema;
  }
  const result = { schema: {}, count: 1, cycle: void 0, path: _params.path };
  ctx.seen.set(schema, result);
  const overrideSchema = schema._zod.toJSONSchema?.();
  if (overrideSchema) {
    result.schema = overrideSchema;
  } else {
    const params = {
      ..._params,
      schemaPath: [..._params.schemaPath, schema],
      path: _params.path
    };
    if (schema._zod.processJSONSchema) {
      schema._zod.processJSONSchema(ctx, result.schema, params);
    } else {
      const _json = result.schema;
      const processor = ctx.processors[def.type];
      if (!processor) {
        throw new Error(`[toJSONSchema]: Non-representable type encountered: ${def.type}`);
      }
      processor(schema, ctx, _json, params);
    }
    const parent = schema._zod.parent;
    if (parent) {
      if (!result.ref)
        result.ref = parent;
      process2(parent, ctx, params);
      ctx.seen.get(parent).isParent = true;
    }
  }
  const meta2 = ctx.metadataRegistry.get(schema);
  if (meta2)
    Object.assign(result.schema, meta2);
  if (ctx.io === "input" && isTransforming(schema)) {
    delete result.schema.examples;
    delete result.schema.default;
  }
  if (ctx.io === "input" && "_prefault" in result.schema)
    (_a3 = result.schema).default ?? (_a3.default = result.schema._prefault);
  delete result.schema._prefault;
  const _result = ctx.seen.get(schema);
  return _result.schema;
}
function extractDefs(ctx, schema) {
  const root = ctx.seen.get(schema);
  if (!root)
    throw new Error("Unprocessed schema. This is a bug in Zod.");
  const idToSchema = /* @__PURE__ */ new Map();
  for (const entry of ctx.seen.entries()) {
    const id = ctx.metadataRegistry.get(entry[0])?.id;
    if (id) {
      const existing = idToSchema.get(id);
      if (existing && existing !== entry[0]) {
        throw new Error(`Duplicate schema id "${id}" detected during JSON Schema conversion. Two different schemas cannot share the same id when converted together.`);
      }
      idToSchema.set(id, entry[0]);
    }
  }
  const makeURI = (entry) => {
    const defsSegment = ctx.target === "draft-2020-12" ? "$defs" : "definitions";
    if (ctx.external) {
      const externalId = ctx.external.registry.get(entry[0])?.id;
      const uriGenerator = ctx.external.uri ?? ((id2) => id2);
      if (externalId) {
        return { ref: uriGenerator(externalId) };
      }
      const id = entry[1].defId ?? entry[1].schema.id ?? `schema${ctx.counter++}`;
      entry[1].defId = id;
      return { defId: id, ref: `${uriGenerator("__shared")}#/${defsSegment}/${id}` };
    }
    if (entry[1] === root) {
      return { ref: "#" };
    }
    const uriPrefix = `#`;
    const defUriPrefix = `${uriPrefix}/${defsSegment}/`;
    const defId = entry[1].schema.id ?? `__schema${ctx.counter++}`;
    return { defId, ref: defUriPrefix + defId };
  };
  const extractToDef = (entry) => {
    if (entry[1].schema.$ref) {
      return;
    }
    const seen = entry[1];
    const { ref, defId } = makeURI(entry);
    seen.def = { ...seen.schema };
    if (defId)
      seen.defId = defId;
    const schema2 = seen.schema;
    for (const key in schema2) {
      delete schema2[key];
    }
    schema2.$ref = ref;
  };
  if (ctx.cycles === "throw") {
    for (const entry of ctx.seen.entries()) {
      const seen = entry[1];
      if (seen.cycle) {
        throw new Error(`Cycle detected: #/${seen.cycle?.join("/")}/<root>

Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.`);
      }
    }
  }
  for (const entry of ctx.seen.entries()) {
    const seen = entry[1];
    if (schema === entry[0]) {
      extractToDef(entry);
      continue;
    }
    if (ctx.external) {
      const ext = ctx.external.registry.get(entry[0])?.id;
      if (schema !== entry[0] && ext) {
        extractToDef(entry);
        continue;
      }
    }
    const id = ctx.metadataRegistry.get(entry[0])?.id;
    if (id) {
      extractToDef(entry);
      continue;
    }
    if (seen.cycle) {
      extractToDef(entry);
      continue;
    }
    if (seen.count > 1) {
      if (ctx.reused === "ref") {
        extractToDef(entry);
        continue;
      }
    }
  }
}
function finalize(ctx, schema) {
  const root = ctx.seen.get(schema);
  if (!root)
    throw new Error("Unprocessed schema. This is a bug in Zod.");
  const flattenRef = (zodSchema) => {
    const seen = ctx.seen.get(zodSchema);
    if (seen.ref === null)
      return;
    const schema2 = seen.def ?? seen.schema;
    const _cached = { ...schema2 };
    const ref = seen.ref;
    seen.ref = null;
    if (ref) {
      flattenRef(ref);
      const refSeen = ctx.seen.get(ref);
      const refSchema = refSeen.schema;
      if (refSchema.$ref && (ctx.target === "draft-07" || ctx.target === "draft-04" || ctx.target === "openapi-3.0")) {
        schema2.allOf = schema2.allOf ?? [];
        schema2.allOf.push(refSchema);
      } else {
        Object.assign(schema2, refSchema);
      }
      Object.assign(schema2, _cached);
      const isParentRef = zodSchema._zod.parent === ref;
      if (isParentRef) {
        for (const key in schema2) {
          if (key === "$ref" || key === "allOf")
            continue;
          if (!(key in _cached)) {
            delete schema2[key];
          }
        }
      }
      if (refSchema.$ref && refSeen.def) {
        for (const key in schema2) {
          if (key === "$ref" || key === "allOf")
            continue;
          if (key in refSeen.def && JSON.stringify(schema2[key]) === JSON.stringify(refSeen.def[key])) {
            delete schema2[key];
          }
        }
      }
    }
    const parent = zodSchema._zod.parent;
    if (parent && parent !== ref) {
      flattenRef(parent);
      const parentSeen = ctx.seen.get(parent);
      if (parentSeen?.schema.$ref) {
        schema2.$ref = parentSeen.schema.$ref;
        if (parentSeen.def) {
          for (const key in schema2) {
            if (key === "$ref" || key === "allOf")
              continue;
            if (key in parentSeen.def && JSON.stringify(schema2[key]) === JSON.stringify(parentSeen.def[key])) {
              delete schema2[key];
            }
          }
        }
      }
    }
    ctx.override({
      zodSchema,
      jsonSchema: schema2,
      path: seen.path ?? []
    });
  };
  for (const entry of [...ctx.seen.entries()].reverse()) {
    flattenRef(entry[0]);
  }
  const result = {};
  if (ctx.target === "draft-2020-12") {
    result.$schema = "https://json-schema.org/draft/2020-12/schema";
  } else if (ctx.target === "draft-07") {
    result.$schema = "http://json-schema.org/draft-07/schema#";
  } else if (ctx.target === "draft-04") {
    result.$schema = "http://json-schema.org/draft-04/schema#";
  } else if (ctx.target === "openapi-3.0") {
  } else {
  }
  if (ctx.external?.uri) {
    const id = ctx.external.registry.get(schema)?.id;
    if (!id)
      throw new Error("Schema is missing an `id` property");
    result.$id = ctx.external.uri(id);
  }
  Object.assign(result, root.def ?? root.schema);
  const rootMetaId = ctx.metadataRegistry.get(schema)?.id;
  if (rootMetaId !== void 0 && result.id === rootMetaId)
    delete result.id;
  const defs = ctx.external?.defs ?? {};
  for (const entry of ctx.seen.entries()) {
    const seen = entry[1];
    if (seen.def && seen.defId) {
      if (seen.def.id === seen.defId)
        delete seen.def.id;
      defs[seen.defId] = seen.def;
    }
  }
  if (ctx.external) {
  } else {
    if (Object.keys(defs).length > 0) {
      if (ctx.target === "draft-2020-12") {
        result.$defs = defs;
      } else {
        result.definitions = defs;
      }
    }
  }
  try {
    const finalized = JSON.parse(JSON.stringify(result));
    Object.defineProperty(finalized, "~standard", {
      value: {
        ...schema["~standard"],
        jsonSchema: {
          input: createStandardJSONSchemaMethod(schema, "input", ctx.processors),
          output: createStandardJSONSchemaMethod(schema, "output", ctx.processors)
        }
      },
      enumerable: false,
      writable: false
    });
    return finalized;
  } catch (_err) {
    throw new Error("Error converting schema to JSON.");
  }
}
function isTransforming(_schema, _ctx) {
  const ctx = _ctx ?? { seen: /* @__PURE__ */ new Set() };
  if (ctx.seen.has(_schema))
    return false;
  ctx.seen.add(_schema);
  const def = _schema._zod.def;
  if (def.type === "transform")
    return true;
  if (def.type === "array")
    return isTransforming(def.element, ctx);
  if (def.type === "set")
    return isTransforming(def.valueType, ctx);
  if (def.type === "lazy")
    return isTransforming(def.getter(), ctx);
  if (def.type === "promise" || def.type === "optional" || def.type === "nonoptional" || def.type === "nullable" || def.type === "readonly" || def.type === "default" || def.type === "prefault") {
    return isTransforming(def.innerType, ctx);
  }
  if (def.type === "intersection") {
    return isTransforming(def.left, ctx) || isTransforming(def.right, ctx);
  }
  if (def.type === "record" || def.type === "map") {
    return isTransforming(def.keyType, ctx) || isTransforming(def.valueType, ctx);
  }
  if (def.type === "pipe") {
    if (_schema._zod.traits.has("$ZodCodec"))
      return true;
    return isTransforming(def.in, ctx) || isTransforming(def.out, ctx);
  }
  if (def.type === "object") {
    for (const key in def.shape) {
      if (isTransforming(def.shape[key], ctx))
        return true;
    }
    return false;
  }
  if (def.type === "union") {
    for (const option of def.options) {
      if (isTransforming(option, ctx))
        return true;
    }
    return false;
  }
  if (def.type === "tuple") {
    for (const item of def.items) {
      if (isTransforming(item, ctx))
        return true;
    }
    if (def.rest && isTransforming(def.rest, ctx))
      return true;
    return false;
  }
  return false;
}
var createToJSONSchemaMethod = (schema, processors = {}) => (params) => {
  const ctx = initializeContext({ ...params, processors });
  process2(schema, ctx);
  extractDefs(ctx, schema);
  return finalize(ctx, schema);
};
var createStandardJSONSchemaMethod = (schema, io, processors = {}) => (params) => {
  const { libraryOptions, target } = params ?? {};
  const ctx = initializeContext({ ...libraryOptions ?? {}, target, io, processors });
  process2(schema, ctx);
  extractDefs(ctx, schema);
  return finalize(ctx, schema);
};

// node_modules/zod/v4/core/json-schema-processors.js
var formatMap = {
  guid: "uuid",
  url: "uri",
  datetime: "date-time",
  json_string: "json-string",
  regex: ""
  // do not set
};
var stringProcessor = (schema, ctx, _json, _params) => {
  const json = _json;
  json.type = "string";
  const { minimum, maximum, format, patterns, contentEncoding } = schema._zod.bag;
  if (typeof minimum === "number")
    json.minLength = minimum;
  if (typeof maximum === "number")
    json.maxLength = maximum;
  if (format) {
    json.format = formatMap[format] ?? format;
    if (json.format === "")
      delete json.format;
    if (format === "time") {
      delete json.format;
    }
  }
  if (contentEncoding)
    json.contentEncoding = contentEncoding;
  if (patterns && patterns.size > 0) {
    const regexes = [...patterns];
    if (regexes.length === 1)
      json.pattern = regexes[0].source;
    else if (regexes.length > 1) {
      json.allOf = [
        ...regexes.map((regex) => ({
          ...ctx.target === "draft-07" || ctx.target === "draft-04" || ctx.target === "openapi-3.0" ? { type: "string" } : {},
          pattern: regex.source
        }))
      ];
    }
  }
};
var numberProcessor = (schema, ctx, _json, _params) => {
  const json = _json;
  const { minimum, maximum, format, multipleOf, exclusiveMaximum, exclusiveMinimum } = schema._zod.bag;
  if (typeof format === "string" && format.includes("int"))
    json.type = "integer";
  else
    json.type = "number";
  const exMin = typeof exclusiveMinimum === "number" && exclusiveMinimum >= (minimum ?? Number.NEGATIVE_INFINITY);
  const exMax = typeof exclusiveMaximum === "number" && exclusiveMaximum <= (maximum ?? Number.POSITIVE_INFINITY);
  const legacy = ctx.target === "draft-04" || ctx.target === "openapi-3.0";
  if (exMin) {
    if (legacy) {
      json.minimum = exclusiveMinimum;
      json.exclusiveMinimum = true;
    } else {
      json.exclusiveMinimum = exclusiveMinimum;
    }
  } else if (typeof minimum === "number") {
    json.minimum = minimum;
  }
  if (exMax) {
    if (legacy) {
      json.maximum = exclusiveMaximum;
      json.exclusiveMaximum = true;
    } else {
      json.exclusiveMaximum = exclusiveMaximum;
    }
  } else if (typeof maximum === "number") {
    json.maximum = maximum;
  }
  if (typeof multipleOf === "number")
    json.multipleOf = multipleOf;
};
var neverProcessor = (_schema, _ctx, json, _params) => {
  json.not = {};
};
var unknownProcessor = (_schema, _ctx, _json, _params) => {
};
var enumProcessor = (schema, _ctx, json, _params) => {
  const def = schema._zod.def;
  const values = getEnumValues(def.entries);
  if (values.every((v) => typeof v === "number"))
    json.type = "number";
  if (values.every((v) => typeof v === "string"))
    json.type = "string";
  json.enum = values;
};
var customProcessor = (_schema, ctx, _json, _params) => {
  if (ctx.unrepresentable === "throw") {
    throw new Error("Custom types cannot be represented in JSON Schema");
  }
};
var transformProcessor = (_schema, ctx, _json, _params) => {
  if (ctx.unrepresentable === "throw") {
    throw new Error("Transforms cannot be represented in JSON Schema");
  }
};
var arrayProcessor = (schema, ctx, _json, params) => {
  const json = _json;
  const def = schema._zod.def;
  const { minimum, maximum } = schema._zod.bag;
  if (typeof minimum === "number")
    json.minItems = minimum;
  if (typeof maximum === "number")
    json.maxItems = maximum;
  json.type = "array";
  json.items = process2(def.element, ctx, {
    ...params,
    path: [...params.path, "items"]
  });
};
var objectProcessor = (schema, ctx, _json, params) => {
  const json = _json;
  const def = schema._zod.def;
  json.type = "object";
  json.properties = {};
  const shape = def.shape;
  for (const key in shape) {
    json.properties[key] = process2(shape[key], ctx, {
      ...params,
      path: [...params.path, "properties", key]
    });
  }
  const allKeys = new Set(Object.keys(shape));
  const requiredKeys = new Set([...allKeys].filter((key) => {
    const v = def.shape[key]._zod;
    if (ctx.io === "input") {
      return v.optin === void 0;
    } else {
      return v.optout === void 0;
    }
  }));
  if (requiredKeys.size > 0) {
    json.required = Array.from(requiredKeys);
  }
  if (def.catchall?._zod.def.type === "never") {
    json.additionalProperties = false;
  } else if (!def.catchall) {
    if (ctx.io === "output")
      json.additionalProperties = false;
  } else if (def.catchall) {
    json.additionalProperties = process2(def.catchall, ctx, {
      ...params,
      path: [...params.path, "additionalProperties"]
    });
  }
};
var unionProcessor = (schema, ctx, json, params) => {
  const def = schema._zod.def;
  const isExclusive = def.inclusive === false;
  const options = def.options.map((x, i) => process2(x, ctx, {
    ...params,
    path: [...params.path, isExclusive ? "oneOf" : "anyOf", i]
  }));
  if (isExclusive) {
    json.oneOf = options;
  } else {
    json.anyOf = options;
  }
};
var intersectionProcessor = (schema, ctx, json, params) => {
  const def = schema._zod.def;
  const a = process2(def.left, ctx, {
    ...params,
    path: [...params.path, "allOf", 0]
  });
  const b = process2(def.right, ctx, {
    ...params,
    path: [...params.path, "allOf", 1]
  });
  const isSimpleIntersection = (val) => "allOf" in val && Object.keys(val).length === 1;
  const allOf = [
    ...isSimpleIntersection(a) ? a.allOf : [a],
    ...isSimpleIntersection(b) ? b.allOf : [b]
  ];
  json.allOf = allOf;
};
var recordProcessor = (schema, ctx, _json, params) => {
  const json = _json;
  const def = schema._zod.def;
  json.type = "object";
  const keyType = def.keyType;
  const keyBag = keyType._zod.bag;
  const patterns = keyBag?.patterns;
  if (def.mode === "loose" && patterns && patterns.size > 0) {
    const valueSchema = process2(def.valueType, ctx, {
      ...params,
      path: [...params.path, "patternProperties", "*"]
    });
    json.patternProperties = {};
    for (const pattern of patterns) {
      json.patternProperties[pattern.source] = valueSchema;
    }
  } else {
    if (ctx.target === "draft-07" || ctx.target === "draft-2020-12") {
      json.propertyNames = process2(def.keyType, ctx, {
        ...params,
        path: [...params.path, "propertyNames"]
      });
    }
    json.additionalProperties = process2(def.valueType, ctx, {
      ...params,
      path: [...params.path, "additionalProperties"]
    });
  }
  const keyValues = keyType._zod.values;
  if (keyValues) {
    const validKeyValues = [...keyValues].filter((v) => typeof v === "string" || typeof v === "number");
    if (validKeyValues.length > 0) {
      json.required = validKeyValues;
    }
  }
};
var nullableProcessor = (schema, ctx, json, params) => {
  const def = schema._zod.def;
  const inner = process2(def.innerType, ctx, params);
  const seen = ctx.seen.get(schema);
  if (ctx.target === "openapi-3.0") {
    seen.ref = def.innerType;
    json.nullable = true;
  } else {
    json.anyOf = [inner, { type: "null" }];
  }
};
var nonoptionalProcessor = (schema, ctx, _json, params) => {
  const def = schema._zod.def;
  process2(def.innerType, ctx, params);
  const seen = ctx.seen.get(schema);
  seen.ref = def.innerType;
};
var defaultProcessor = (schema, ctx, json, params) => {
  const def = schema._zod.def;
  process2(def.innerType, ctx, params);
  const seen = ctx.seen.get(schema);
  seen.ref = def.innerType;
  json.default = JSON.parse(JSON.stringify(def.defaultValue));
};
var prefaultProcessor = (schema, ctx, json, params) => {
  const def = schema._zod.def;
  process2(def.innerType, ctx, params);
  const seen = ctx.seen.get(schema);
  seen.ref = def.innerType;
  if (ctx.io === "input")
    json._prefault = JSON.parse(JSON.stringify(def.defaultValue));
};
var catchProcessor = (schema, ctx, json, params) => {
  const def = schema._zod.def;
  process2(def.innerType, ctx, params);
  const seen = ctx.seen.get(schema);
  seen.ref = def.innerType;
  let catchValue;
  try {
    catchValue = def.catchValue(void 0);
  } catch {
    throw new Error("Dynamic catch values are not supported in JSON Schema");
  }
  json.default = catchValue;
};
var pipeProcessor = (schema, ctx, _json, params) => {
  const def = schema._zod.def;
  const inIsTransform = def.in._zod.traits.has("$ZodTransform");
  const innerType = ctx.io === "input" ? inIsTransform ? def.out : def.in : def.out;
  process2(innerType, ctx, params);
  const seen = ctx.seen.get(schema);
  seen.ref = innerType;
};
var readonlyProcessor = (schema, ctx, json, params) => {
  const def = schema._zod.def;
  process2(def.innerType, ctx, params);
  const seen = ctx.seen.get(schema);
  seen.ref = def.innerType;
  json.readOnly = true;
};
var optionalProcessor = (schema, ctx, _json, params) => {
  const def = schema._zod.def;
  process2(def.innerType, ctx, params);
  const seen = ctx.seen.get(schema);
  seen.ref = def.innerType;
};

// node_modules/zod/v4/classic/iso.js
var ZodISODateTime = /* @__PURE__ */ $constructor("ZodISODateTime", (inst, def) => {
  $ZodISODateTime.init(inst, def);
  ZodStringFormat.init(inst, def);
});
function datetime2(params) {
  return _isoDateTime(ZodISODateTime, params);
}
var ZodISODate = /* @__PURE__ */ $constructor("ZodISODate", (inst, def) => {
  $ZodISODate.init(inst, def);
  ZodStringFormat.init(inst, def);
});
function date2(params) {
  return _isoDate(ZodISODate, params);
}
var ZodISOTime = /* @__PURE__ */ $constructor("ZodISOTime", (inst, def) => {
  $ZodISOTime.init(inst, def);
  ZodStringFormat.init(inst, def);
});
function time2(params) {
  return _isoTime(ZodISOTime, params);
}
var ZodISODuration = /* @__PURE__ */ $constructor("ZodISODuration", (inst, def) => {
  $ZodISODuration.init(inst, def);
  ZodStringFormat.init(inst, def);
});
function duration2(params) {
  return _isoDuration(ZodISODuration, params);
}

// node_modules/zod/v4/classic/errors.js
var initializer2 = (inst, issues) => {
  $ZodError.init(inst, issues);
  inst.name = "ZodError";
  Object.defineProperties(inst, {
    format: {
      value: (mapper) => formatError(inst, mapper)
      // enumerable: false,
    },
    flatten: {
      value: (mapper) => flattenError(inst, mapper)
      // enumerable: false,
    },
    addIssue: {
      value: (issue2) => {
        inst.issues.push(issue2);
        inst.message = JSON.stringify(inst.issues, jsonStringifyReplacer, 2);
      }
      // enumerable: false,
    },
    addIssues: {
      value: (issues2) => {
        inst.issues.push(...issues2);
        inst.message = JSON.stringify(inst.issues, jsonStringifyReplacer, 2);
      }
      // enumerable: false,
    },
    isEmpty: {
      get() {
        return inst.issues.length === 0;
      }
      // enumerable: false,
    }
  });
};
var ZodRealError = /* @__PURE__ */ $constructor("ZodError", initializer2, {
  Parent: Error
});

// node_modules/zod/v4/classic/parse.js
var parse2 = /* @__PURE__ */ _parse(ZodRealError);
var parseAsync2 = /* @__PURE__ */ _parseAsync(ZodRealError);
var safeParse2 = /* @__PURE__ */ _safeParse(ZodRealError);
var safeParseAsync2 = /* @__PURE__ */ _safeParseAsync(ZodRealError);
var encode = /* @__PURE__ */ _encode(ZodRealError);
var decode = /* @__PURE__ */ _decode(ZodRealError);
var encodeAsync = /* @__PURE__ */ _encodeAsync(ZodRealError);
var decodeAsync = /* @__PURE__ */ _decodeAsync(ZodRealError);
var safeEncode = /* @__PURE__ */ _safeEncode(ZodRealError);
var safeDecode = /* @__PURE__ */ _safeDecode(ZodRealError);
var safeEncodeAsync = /* @__PURE__ */ _safeEncodeAsync(ZodRealError);
var safeDecodeAsync = /* @__PURE__ */ _safeDecodeAsync(ZodRealError);

// node_modules/zod/v4/classic/schemas.js
var _installedGroups = /* @__PURE__ */ new WeakMap();
function _installLazyMethods(inst, group, methods) {
  const proto = Object.getPrototypeOf(inst);
  let installed = _installedGroups.get(proto);
  if (!installed) {
    installed = /* @__PURE__ */ new Set();
    _installedGroups.set(proto, installed);
  }
  if (installed.has(group))
    return;
  installed.add(group);
  for (const key in methods) {
    const fn = methods[key];
    Object.defineProperty(proto, key, {
      configurable: true,
      enumerable: false,
      get() {
        const bound = fn.bind(this);
        Object.defineProperty(this, key, {
          configurable: true,
          writable: true,
          enumerable: true,
          value: bound
        });
        return bound;
      },
      set(v) {
        Object.defineProperty(this, key, {
          configurable: true,
          writable: true,
          enumerable: true,
          value: v
        });
      }
    });
  }
}
var ZodType = /* @__PURE__ */ $constructor("ZodType", (inst, def) => {
  $ZodType.init(inst, def);
  Object.assign(inst["~standard"], {
    jsonSchema: {
      input: createStandardJSONSchemaMethod(inst, "input"),
      output: createStandardJSONSchemaMethod(inst, "output")
    }
  });
  inst.toJSONSchema = createToJSONSchemaMethod(inst, {});
  inst.def = def;
  inst.type = def.type;
  Object.defineProperty(inst, "_def", { value: def });
  inst.parse = (data, params) => parse2(inst, data, params, { callee: inst.parse });
  inst.safeParse = (data, params) => safeParse2(inst, data, params);
  inst.parseAsync = async (data, params) => parseAsync2(inst, data, params, { callee: inst.parseAsync });
  inst.safeParseAsync = async (data, params) => safeParseAsync2(inst, data, params);
  inst.spa = inst.safeParseAsync;
  inst.encode = (data, params) => encode(inst, data, params);
  inst.decode = (data, params) => decode(inst, data, params);
  inst.encodeAsync = async (data, params) => encodeAsync(inst, data, params);
  inst.decodeAsync = async (data, params) => decodeAsync(inst, data, params);
  inst.safeEncode = (data, params) => safeEncode(inst, data, params);
  inst.safeDecode = (data, params) => safeDecode(inst, data, params);
  inst.safeEncodeAsync = async (data, params) => safeEncodeAsync(inst, data, params);
  inst.safeDecodeAsync = async (data, params) => safeDecodeAsync(inst, data, params);
  _installLazyMethods(inst, "ZodType", {
    check(...chks) {
      const def2 = this.def;
      return this.clone(util_exports.mergeDefs(def2, {
        checks: [
          ...def2.checks ?? [],
          ...chks.map((ch) => typeof ch === "function" ? { _zod: { check: ch, def: { check: "custom" }, onattach: [] } } : ch)
        ]
      }), { parent: true });
    },
    with(...chks) {
      return this.check(...chks);
    },
    clone(def2, params) {
      return clone(this, def2, params);
    },
    brand() {
      return this;
    },
    register(reg, meta2) {
      reg.add(this, meta2);
      return this;
    },
    refine(check, params) {
      return this.check(refine(check, params));
    },
    superRefine(refinement, params) {
      return this.check(superRefine(refinement, params));
    },
    overwrite(fn) {
      return this.check(_overwrite(fn));
    },
    optional() {
      return optional(this);
    },
    exactOptional() {
      return exactOptional(this);
    },
    nullable() {
      return nullable(this);
    },
    nullish() {
      return optional(nullable(this));
    },
    nonoptional(params) {
      return nonoptional(this, params);
    },
    array() {
      return array(this);
    },
    or(arg) {
      return union([this, arg]);
    },
    and(arg) {
      return intersection(this, arg);
    },
    transform(tx) {
      return pipe(this, transform(tx));
    },
    default(d) {
      return _default(this, d);
    },
    prefault(d) {
      return prefault(this, d);
    },
    catch(params) {
      return _catch(this, params);
    },
    pipe(target) {
      return pipe(this, target);
    },
    readonly() {
      return readonly(this);
    },
    describe(description) {
      const cl = this.clone();
      globalRegistry.add(cl, { description });
      return cl;
    },
    meta(...args) {
      if (args.length === 0)
        return globalRegistry.get(this);
      const cl = this.clone();
      globalRegistry.add(cl, args[0]);
      return cl;
    },
    isOptional() {
      return this.safeParse(void 0).success;
    },
    isNullable() {
      return this.safeParse(null).success;
    },
    apply(fn) {
      return fn(this);
    }
  });
  Object.defineProperty(inst, "description", {
    get() {
      return globalRegistry.get(inst)?.description;
    },
    configurable: true
  });
  return inst;
});
var _ZodString = /* @__PURE__ */ $constructor("_ZodString", (inst, def) => {
  $ZodString.init(inst, def);
  ZodType.init(inst, def);
  inst._zod.processJSONSchema = (ctx, json, params) => stringProcessor(inst, ctx, json, params);
  const bag = inst._zod.bag;
  inst.format = bag.format ?? null;
  inst.minLength = bag.minimum ?? null;
  inst.maxLength = bag.maximum ?? null;
  _installLazyMethods(inst, "_ZodString", {
    regex(...args) {
      return this.check(_regex(...args));
    },
    includes(...args) {
      return this.check(_includes(...args));
    },
    startsWith(...args) {
      return this.check(_startsWith(...args));
    },
    endsWith(...args) {
      return this.check(_endsWith(...args));
    },
    min(...args) {
      return this.check(_minLength(...args));
    },
    max(...args) {
      return this.check(_maxLength(...args));
    },
    length(...args) {
      return this.check(_length(...args));
    },
    nonempty(...args) {
      return this.check(_minLength(1, ...args));
    },
    lowercase(params) {
      return this.check(_lowercase(params));
    },
    uppercase(params) {
      return this.check(_uppercase(params));
    },
    trim() {
      return this.check(_trim());
    },
    normalize(...args) {
      return this.check(_normalize(...args));
    },
    toLowerCase() {
      return this.check(_toLowerCase());
    },
    toUpperCase() {
      return this.check(_toUpperCase());
    },
    slugify() {
      return this.check(_slugify());
    }
  });
});
var ZodString = /* @__PURE__ */ $constructor("ZodString", (inst, def) => {
  $ZodString.init(inst, def);
  _ZodString.init(inst, def);
  inst.email = (params) => inst.check(_email(ZodEmail, params));
  inst.url = (params) => inst.check(_url(ZodURL, params));
  inst.jwt = (params) => inst.check(_jwt(ZodJWT, params));
  inst.emoji = (params) => inst.check(_emoji2(ZodEmoji, params));
  inst.guid = (params) => inst.check(_guid(ZodGUID, params));
  inst.uuid = (params) => inst.check(_uuid(ZodUUID, params));
  inst.uuidv4 = (params) => inst.check(_uuidv4(ZodUUID, params));
  inst.uuidv6 = (params) => inst.check(_uuidv6(ZodUUID, params));
  inst.uuidv7 = (params) => inst.check(_uuidv7(ZodUUID, params));
  inst.nanoid = (params) => inst.check(_nanoid(ZodNanoID, params));
  inst.guid = (params) => inst.check(_guid(ZodGUID, params));
  inst.cuid = (params) => inst.check(_cuid(ZodCUID, params));
  inst.cuid2 = (params) => inst.check(_cuid2(ZodCUID2, params));
  inst.ulid = (params) => inst.check(_ulid(ZodULID, params));
  inst.base64 = (params) => inst.check(_base64(ZodBase64, params));
  inst.base64url = (params) => inst.check(_base64url(ZodBase64URL, params));
  inst.xid = (params) => inst.check(_xid(ZodXID, params));
  inst.ksuid = (params) => inst.check(_ksuid(ZodKSUID, params));
  inst.ipv4 = (params) => inst.check(_ipv4(ZodIPv4, params));
  inst.ipv6 = (params) => inst.check(_ipv6(ZodIPv6, params));
  inst.cidrv4 = (params) => inst.check(_cidrv4(ZodCIDRv4, params));
  inst.cidrv6 = (params) => inst.check(_cidrv6(ZodCIDRv6, params));
  inst.e164 = (params) => inst.check(_e164(ZodE164, params));
  inst.datetime = (params) => inst.check(datetime2(params));
  inst.date = (params) => inst.check(date2(params));
  inst.time = (params) => inst.check(time2(params));
  inst.duration = (params) => inst.check(duration2(params));
});
function string2(params) {
  return _string(ZodString, params);
}
var ZodStringFormat = /* @__PURE__ */ $constructor("ZodStringFormat", (inst, def) => {
  $ZodStringFormat.init(inst, def);
  _ZodString.init(inst, def);
});
var ZodEmail = /* @__PURE__ */ $constructor("ZodEmail", (inst, def) => {
  $ZodEmail.init(inst, def);
  ZodStringFormat.init(inst, def);
});
var ZodGUID = /* @__PURE__ */ $constructor("ZodGUID", (inst, def) => {
  $ZodGUID.init(inst, def);
  ZodStringFormat.init(inst, def);
});
var ZodUUID = /* @__PURE__ */ $constructor("ZodUUID", (inst, def) => {
  $ZodUUID.init(inst, def);
  ZodStringFormat.init(inst, def);
});
var ZodURL = /* @__PURE__ */ $constructor("ZodURL", (inst, def) => {
  $ZodURL.init(inst, def);
  ZodStringFormat.init(inst, def);
});
var ZodEmoji = /* @__PURE__ */ $constructor("ZodEmoji", (inst, def) => {
  $ZodEmoji.init(inst, def);
  ZodStringFormat.init(inst, def);
});
var ZodNanoID = /* @__PURE__ */ $constructor("ZodNanoID", (inst, def) => {
  $ZodNanoID.init(inst, def);
  ZodStringFormat.init(inst, def);
});
var ZodCUID = /* @__PURE__ */ $constructor("ZodCUID", (inst, def) => {
  $ZodCUID.init(inst, def);
  ZodStringFormat.init(inst, def);
});
var ZodCUID2 = /* @__PURE__ */ $constructor("ZodCUID2", (inst, def) => {
  $ZodCUID2.init(inst, def);
  ZodStringFormat.init(inst, def);
});
var ZodULID = /* @__PURE__ */ $constructor("ZodULID", (inst, def) => {
  $ZodULID.init(inst, def);
  ZodStringFormat.init(inst, def);
});
var ZodXID = /* @__PURE__ */ $constructor("ZodXID", (inst, def) => {
  $ZodXID.init(inst, def);
  ZodStringFormat.init(inst, def);
});
var ZodKSUID = /* @__PURE__ */ $constructor("ZodKSUID", (inst, def) => {
  $ZodKSUID.init(inst, def);
  ZodStringFormat.init(inst, def);
});
var ZodIPv4 = /* @__PURE__ */ $constructor("ZodIPv4", (inst, def) => {
  $ZodIPv4.init(inst, def);
  ZodStringFormat.init(inst, def);
});
var ZodIPv6 = /* @__PURE__ */ $constructor("ZodIPv6", (inst, def) => {
  $ZodIPv6.init(inst, def);
  ZodStringFormat.init(inst, def);
});
var ZodCIDRv4 = /* @__PURE__ */ $constructor("ZodCIDRv4", (inst, def) => {
  $ZodCIDRv4.init(inst, def);
  ZodStringFormat.init(inst, def);
});
var ZodCIDRv6 = /* @__PURE__ */ $constructor("ZodCIDRv6", (inst, def) => {
  $ZodCIDRv6.init(inst, def);
  ZodStringFormat.init(inst, def);
});
var ZodBase64 = /* @__PURE__ */ $constructor("ZodBase64", (inst, def) => {
  $ZodBase64.init(inst, def);
  ZodStringFormat.init(inst, def);
});
var ZodBase64URL = /* @__PURE__ */ $constructor("ZodBase64URL", (inst, def) => {
  $ZodBase64URL.init(inst, def);
  ZodStringFormat.init(inst, def);
});
var ZodE164 = /* @__PURE__ */ $constructor("ZodE164", (inst, def) => {
  $ZodE164.init(inst, def);
  ZodStringFormat.init(inst, def);
});
var ZodJWT = /* @__PURE__ */ $constructor("ZodJWT", (inst, def) => {
  $ZodJWT.init(inst, def);
  ZodStringFormat.init(inst, def);
});
var ZodNumber = /* @__PURE__ */ $constructor("ZodNumber", (inst, def) => {
  $ZodNumber.init(inst, def);
  ZodType.init(inst, def);
  inst._zod.processJSONSchema = (ctx, json, params) => numberProcessor(inst, ctx, json, params);
  _installLazyMethods(inst, "ZodNumber", {
    gt(value, params) {
      return this.check(_gt(value, params));
    },
    gte(value, params) {
      return this.check(_gte(value, params));
    },
    min(value, params) {
      return this.check(_gte(value, params));
    },
    lt(value, params) {
      return this.check(_lt(value, params));
    },
    lte(value, params) {
      return this.check(_lte(value, params));
    },
    max(value, params) {
      return this.check(_lte(value, params));
    },
    int(params) {
      return this.check(int(params));
    },
    safe(params) {
      return this.check(int(params));
    },
    positive(params) {
      return this.check(_gt(0, params));
    },
    nonnegative(params) {
      return this.check(_gte(0, params));
    },
    negative(params) {
      return this.check(_lt(0, params));
    },
    nonpositive(params) {
      return this.check(_lte(0, params));
    },
    multipleOf(value, params) {
      return this.check(_multipleOf(value, params));
    },
    step(value, params) {
      return this.check(_multipleOf(value, params));
    },
    finite() {
      return this;
    }
  });
  const bag = inst._zod.bag;
  inst.minValue = Math.max(bag.minimum ?? Number.NEGATIVE_INFINITY, bag.exclusiveMinimum ?? Number.NEGATIVE_INFINITY) ?? null;
  inst.maxValue = Math.min(bag.maximum ?? Number.POSITIVE_INFINITY, bag.exclusiveMaximum ?? Number.POSITIVE_INFINITY) ?? null;
  inst.isInt = (bag.format ?? "").includes("int") || Number.isSafeInteger(bag.multipleOf ?? 0.5);
  inst.isFinite = true;
  inst.format = bag.format ?? null;
});
function number2(params) {
  return _number(ZodNumber, params);
}
var ZodNumberFormat = /* @__PURE__ */ $constructor("ZodNumberFormat", (inst, def) => {
  $ZodNumberFormat.init(inst, def);
  ZodNumber.init(inst, def);
});
function int(params) {
  return _int(ZodNumberFormat, params);
}
var ZodUnknown = /* @__PURE__ */ $constructor("ZodUnknown", (inst, def) => {
  $ZodUnknown.init(inst, def);
  ZodType.init(inst, def);
  inst._zod.processJSONSchema = (ctx, json, params) => unknownProcessor(inst, ctx, json, params);
});
function unknown() {
  return _unknown(ZodUnknown);
}
var ZodNever = /* @__PURE__ */ $constructor("ZodNever", (inst, def) => {
  $ZodNever.init(inst, def);
  ZodType.init(inst, def);
  inst._zod.processJSONSchema = (ctx, json, params) => neverProcessor(inst, ctx, json, params);
});
function never(params) {
  return _never(ZodNever, params);
}
var ZodArray = /* @__PURE__ */ $constructor("ZodArray", (inst, def) => {
  $ZodArray.init(inst, def);
  ZodType.init(inst, def);
  inst._zod.processJSONSchema = (ctx, json, params) => arrayProcessor(inst, ctx, json, params);
  inst.element = def.element;
  _installLazyMethods(inst, "ZodArray", {
    min(n, params) {
      return this.check(_minLength(n, params));
    },
    nonempty(params) {
      return this.check(_minLength(1, params));
    },
    max(n, params) {
      return this.check(_maxLength(n, params));
    },
    length(n, params) {
      return this.check(_length(n, params));
    },
    unwrap() {
      return this.element;
    }
  });
});
function array(element, params) {
  return _array(ZodArray, element, params);
}
var ZodObject = /* @__PURE__ */ $constructor("ZodObject", (inst, def) => {
  $ZodObjectJIT.init(inst, def);
  ZodType.init(inst, def);
  inst._zod.processJSONSchema = (ctx, json, params) => objectProcessor(inst, ctx, json, params);
  util_exports.defineLazy(inst, "shape", () => {
    return def.shape;
  });
  _installLazyMethods(inst, "ZodObject", {
    keyof() {
      return _enum(Object.keys(this._zod.def.shape));
    },
    catchall(catchall) {
      return this.clone({ ...this._zod.def, catchall });
    },
    passthrough() {
      return this.clone({ ...this._zod.def, catchall: unknown() });
    },
    loose() {
      return this.clone({ ...this._zod.def, catchall: unknown() });
    },
    strict() {
      return this.clone({ ...this._zod.def, catchall: never() });
    },
    strip() {
      return this.clone({ ...this._zod.def, catchall: void 0 });
    },
    extend(incoming) {
      return util_exports.extend(this, incoming);
    },
    safeExtend(incoming) {
      return util_exports.safeExtend(this, incoming);
    },
    merge(other) {
      return util_exports.merge(this, other);
    },
    pick(mask) {
      return util_exports.pick(this, mask);
    },
    omit(mask) {
      return util_exports.omit(this, mask);
    },
    partial(...args) {
      return util_exports.partial(ZodOptional, this, args[0]);
    },
    required(...args) {
      return util_exports.required(ZodNonOptional, this, args[0]);
    }
  });
});
function object(shape, params) {
  const def = {
    type: "object",
    shape: shape ?? {},
    ...util_exports.normalizeParams(params)
  };
  return new ZodObject(def);
}
var ZodUnion = /* @__PURE__ */ $constructor("ZodUnion", (inst, def) => {
  $ZodUnion.init(inst, def);
  ZodType.init(inst, def);
  inst._zod.processJSONSchema = (ctx, json, params) => unionProcessor(inst, ctx, json, params);
  inst.options = def.options;
});
function union(options, params) {
  return new ZodUnion({
    type: "union",
    options,
    ...util_exports.normalizeParams(params)
  });
}
var ZodIntersection = /* @__PURE__ */ $constructor("ZodIntersection", (inst, def) => {
  $ZodIntersection.init(inst, def);
  ZodType.init(inst, def);
  inst._zod.processJSONSchema = (ctx, json, params) => intersectionProcessor(inst, ctx, json, params);
});
function intersection(left, right) {
  return new ZodIntersection({
    type: "intersection",
    left,
    right
  });
}
var ZodRecord = /* @__PURE__ */ $constructor("ZodRecord", (inst, def) => {
  $ZodRecord.init(inst, def);
  ZodType.init(inst, def);
  inst._zod.processJSONSchema = (ctx, json, params) => recordProcessor(inst, ctx, json, params);
  inst.keyType = def.keyType;
  inst.valueType = def.valueType;
});
function record(keyType, valueType, params) {
  if (!valueType || !valueType._zod) {
    return new ZodRecord({
      type: "record",
      keyType: string2(),
      valueType: keyType,
      ...util_exports.normalizeParams(valueType)
    });
  }
  return new ZodRecord({
    type: "record",
    keyType,
    valueType,
    ...util_exports.normalizeParams(params)
  });
}
var ZodEnum = /* @__PURE__ */ $constructor("ZodEnum", (inst, def) => {
  $ZodEnum.init(inst, def);
  ZodType.init(inst, def);
  inst._zod.processJSONSchema = (ctx, json, params) => enumProcessor(inst, ctx, json, params);
  inst.enum = def.entries;
  inst.options = Object.values(def.entries);
  const keys = new Set(Object.keys(def.entries));
  inst.extract = (values, params) => {
    const newEntries = {};
    for (const value of values) {
      if (keys.has(value)) {
        newEntries[value] = def.entries[value];
      } else
        throw new Error(`Key ${value} not found in enum`);
    }
    return new ZodEnum({
      ...def,
      checks: [],
      ...util_exports.normalizeParams(params),
      entries: newEntries
    });
  };
  inst.exclude = (values, params) => {
    const newEntries = { ...def.entries };
    for (const value of values) {
      if (keys.has(value)) {
        delete newEntries[value];
      } else
        throw new Error(`Key ${value} not found in enum`);
    }
    return new ZodEnum({
      ...def,
      checks: [],
      ...util_exports.normalizeParams(params),
      entries: newEntries
    });
  };
});
function _enum(values, params) {
  const entries = Array.isArray(values) ? Object.fromEntries(values.map((v) => [v, v])) : values;
  return new ZodEnum({
    type: "enum",
    entries,
    ...util_exports.normalizeParams(params)
  });
}
var ZodTransform = /* @__PURE__ */ $constructor("ZodTransform", (inst, def) => {
  $ZodTransform.init(inst, def);
  ZodType.init(inst, def);
  inst._zod.processJSONSchema = (ctx, json, params) => transformProcessor(inst, ctx, json, params);
  inst._zod.parse = (payload, _ctx) => {
    if (_ctx.direction === "backward") {
      throw new $ZodEncodeError(inst.constructor.name);
    }
    payload.addIssue = (issue2) => {
      if (typeof issue2 === "string") {
        payload.issues.push(util_exports.issue(issue2, payload.value, def));
      } else {
        const _issue = issue2;
        if (_issue.fatal)
          _issue.continue = false;
        _issue.code ?? (_issue.code = "custom");
        _issue.input ?? (_issue.input = payload.value);
        _issue.inst ?? (_issue.inst = inst);
        payload.issues.push(util_exports.issue(_issue));
      }
    };
    const output = def.transform(payload.value, payload);
    if (output instanceof Promise) {
      return output.then((output2) => {
        payload.value = output2;
        payload.fallback = true;
        return payload;
      });
    }
    payload.value = output;
    payload.fallback = true;
    return payload;
  };
});
function transform(fn) {
  return new ZodTransform({
    type: "transform",
    transform: fn
  });
}
var ZodOptional = /* @__PURE__ */ $constructor("ZodOptional", (inst, def) => {
  $ZodOptional.init(inst, def);
  ZodType.init(inst, def);
  inst._zod.processJSONSchema = (ctx, json, params) => optionalProcessor(inst, ctx, json, params);
  inst.unwrap = () => inst._zod.def.innerType;
});
function optional(innerType) {
  return new ZodOptional({
    type: "optional",
    innerType
  });
}
var ZodExactOptional = /* @__PURE__ */ $constructor("ZodExactOptional", (inst, def) => {
  $ZodExactOptional.init(inst, def);
  ZodType.init(inst, def);
  inst._zod.processJSONSchema = (ctx, json, params) => optionalProcessor(inst, ctx, json, params);
  inst.unwrap = () => inst._zod.def.innerType;
});
function exactOptional(innerType) {
  return new ZodExactOptional({
    type: "optional",
    innerType
  });
}
var ZodNullable = /* @__PURE__ */ $constructor("ZodNullable", (inst, def) => {
  $ZodNullable.init(inst, def);
  ZodType.init(inst, def);
  inst._zod.processJSONSchema = (ctx, json, params) => nullableProcessor(inst, ctx, json, params);
  inst.unwrap = () => inst._zod.def.innerType;
});
function nullable(innerType) {
  return new ZodNullable({
    type: "nullable",
    innerType
  });
}
var ZodDefault = /* @__PURE__ */ $constructor("ZodDefault", (inst, def) => {
  $ZodDefault.init(inst, def);
  ZodType.init(inst, def);
  inst._zod.processJSONSchema = (ctx, json, params) => defaultProcessor(inst, ctx, json, params);
  inst.unwrap = () => inst._zod.def.innerType;
  inst.removeDefault = inst.unwrap;
});
function _default(innerType, defaultValue) {
  return new ZodDefault({
    type: "default",
    innerType,
    get defaultValue() {
      return typeof defaultValue === "function" ? defaultValue() : util_exports.shallowClone(defaultValue);
    }
  });
}
var ZodPrefault = /* @__PURE__ */ $constructor("ZodPrefault", (inst, def) => {
  $ZodPrefault.init(inst, def);
  ZodType.init(inst, def);
  inst._zod.processJSONSchema = (ctx, json, params) => prefaultProcessor(inst, ctx, json, params);
  inst.unwrap = () => inst._zod.def.innerType;
});
function prefault(innerType, defaultValue) {
  return new ZodPrefault({
    type: "prefault",
    innerType,
    get defaultValue() {
      return typeof defaultValue === "function" ? defaultValue() : util_exports.shallowClone(defaultValue);
    }
  });
}
var ZodNonOptional = /* @__PURE__ */ $constructor("ZodNonOptional", (inst, def) => {
  $ZodNonOptional.init(inst, def);
  ZodType.init(inst, def);
  inst._zod.processJSONSchema = (ctx, json, params) => nonoptionalProcessor(inst, ctx, json, params);
  inst.unwrap = () => inst._zod.def.innerType;
});
function nonoptional(innerType, params) {
  return new ZodNonOptional({
    type: "nonoptional",
    innerType,
    ...util_exports.normalizeParams(params)
  });
}
var ZodCatch = /* @__PURE__ */ $constructor("ZodCatch", (inst, def) => {
  $ZodCatch.init(inst, def);
  ZodType.init(inst, def);
  inst._zod.processJSONSchema = (ctx, json, params) => catchProcessor(inst, ctx, json, params);
  inst.unwrap = () => inst._zod.def.innerType;
  inst.removeCatch = inst.unwrap;
});
function _catch(innerType, catchValue) {
  return new ZodCatch({
    type: "catch",
    innerType,
    catchValue: typeof catchValue === "function" ? catchValue : () => catchValue
  });
}
var ZodPipe = /* @__PURE__ */ $constructor("ZodPipe", (inst, def) => {
  $ZodPipe.init(inst, def);
  ZodType.init(inst, def);
  inst._zod.processJSONSchema = (ctx, json, params) => pipeProcessor(inst, ctx, json, params);
  inst.in = def.in;
  inst.out = def.out;
});
function pipe(in_, out) {
  return new ZodPipe({
    type: "pipe",
    in: in_,
    out
    // ...util.normalizeParams(params),
  });
}
var ZodReadonly = /* @__PURE__ */ $constructor("ZodReadonly", (inst, def) => {
  $ZodReadonly.init(inst, def);
  ZodType.init(inst, def);
  inst._zod.processJSONSchema = (ctx, json, params) => readonlyProcessor(inst, ctx, json, params);
  inst.unwrap = () => inst._zod.def.innerType;
});
function readonly(innerType) {
  return new ZodReadonly({
    type: "readonly",
    innerType
  });
}
var ZodCustom = /* @__PURE__ */ $constructor("ZodCustom", (inst, def) => {
  $ZodCustom.init(inst, def);
  ZodType.init(inst, def);
  inst._zod.processJSONSchema = (ctx, json, params) => customProcessor(inst, ctx, json, params);
});
function refine(fn, _params = {}) {
  return _refine(ZodCustom, fn, _params);
}
function superRefine(fn, params) {
  return _superRefine(fn, params);
}

// src/issues/fingerprint.ts
import crypto from "node:crypto";
var ISSUE_FINGERPRINT_PATTERN = /^[0-9a-f]{20}$/;
function issueFingerprint(issue2, comments = []) {
  return crypto.createHash("sha256").update(
    JSON.stringify({
      title: issue2.title.trim(),
      body: issue2.body ?? "",
      comments: comments.map((comment) => ({
        id: comment.id,
        body: comment.body,
        author: comment.user?.login ?? ""
      }))
    })
  ).digest("hex").slice(0, 20);
}

// src/draft-pr/schema.ts
var validationOverrideSchema = object({
  classification: _enum(["allowlisted_test_failure"]),
  source: _enum(["policy"]),
  reason: string2().min(1).max(1e3),
  failedCommands: array(string2().min(1).max(300)).min(1).max(20),
  allowedFailureCases: array(string2().min(1).max(300)).min(1).max(50)
});
function hasConsistentValidationOverride(analysis) {
  const override = analysis.validationOverride;
  if (!override) return false;
  const failedCommands = [
    ...new Set(
      analysis.tests.filter((test) => test.status === "failed").map((test) => test.command)
    )
  ];
  const overrideCommands = [...new Set(override.failedCommands)];
  return failedCommands.length > 0 && failedCommands.length === overrideCommands.length && failedCommands.every((command) => overrideCommands.includes(command));
}
var draftPrAnalysisSchema = object({
  outcome: _enum(["implemented", "needs_approval", "blocked", "no_change"]),
  prTitle: string2().max(120),
  summary: array(string2().min(1).max(500)).max(8),
  tests: array(
    object({
      command: string2().min(1).max(300),
      status: _enum(["passed", "failed", "not_run"]),
      details: string2().max(1e3)
    })
  ).max(20),
  risk: object({
    level: _enum(["low", "medium", "high"]),
    reasons: array(string2().min(1).max(500)).max(8)
  }),
  notes: array(string2().min(1).max(500)).max(8),
  validationOverride: validationOverrideSchema.optional()
});
var draftPrSubmissionSchema = object({
  issueFingerprint: string2().regex(ISSUE_FINGERPRINT_PATTERN),
  trigger: _enum(["ready", "approved"]),
  workspacePath: string2().min(1).max(2e3),
  branch: string2().min(1).max(250),
  baseBranch: string2().min(1).max(250),
  baseCommit: string2().regex(/^[0-9a-f]{40}$/),
  analysis: draftPrAnalysisSchema
});

// src/draft-pr/ci-schema.ts
var ciCheckReferenceSchema = object({
  checkRunId: number2().int().positive()
});
var ciFixAnalysisSchema = object({
  outcome: _enum(["fixed", "no_change", "needs_approval", "blocked"]),
  commitTitle: string2().max(120),
  summary: array(string2().min(1).max(500)).max(8),
  failures: array(
    object({
      checkRunId: number2().int().positive(),
      disposition: _enum(["fixed", "not_reproducible", "needs_approval"]),
      reason: string2().min(1).max(1e3)
    })
  ).min(1).max(100),
  tests: array(
    object({
      command: string2().min(1).max(300),
      status: _enum(["passed", "failed", "not_run"]),
      details: string2().max(1e3)
    })
  ).max(20),
  risk: object({
    level: _enum(["low", "medium", "high"]),
    reasons: array(string2().min(1).max(500)).max(8)
  }),
  notes: array(string2().min(1).max(500)).max(8),
  validationOverride: validationOverrideSchema.optional()
});
var ciFixSubmissionSchema = object({
  checkSuiteId: number2().int().positive(),
  failuresFingerprint: string2().regex(/^[0-9a-f]{20}$/),
  checkRefs: array(ciCheckReferenceSchema).min(1).max(100),
  workspacePath: string2().min(1).max(2e3),
  branch: string2().min(1).max(250),
  baseBranch: string2().min(1).max(250),
  expectedHeadSha: string2().regex(/^[0-9a-f]{40}$/),
  previousAttempts: number2().int().nonnegative(),
  analysis: ciFixAnalysisSchema
});

// src/draft-pr/policy.ts
var draftPrPolicySchema = object({
  version: number2().int().positive(),
  readyLabel: string2().min(1),
  approvedLabel: string2().min(1),
  runningLabel: string2().min(1),
  needsApprovalLabel: string2().min(1),
  prOpenLabel: string2().min(1),
  failedLabel: string2().min(1),
  skipLabels: array(string2().min(1)),
  blockedLabels: array(string2().min(1)),
  branchPrefix: string2().regex(/^[a-zA-Z0-9._/-]+$/),
  maxChangedFiles: number2().int().positive().max(1e3),
  maxChangedLines: number2().int().positive().max(1e5),
  maxReviewComments: number2().int().positive().max(100),
  maxValidationFixIterations: number2().int().positive().max(20),
  maxFixIterations: number2().int().positive().max(20),
  requiredValidationGates: array(
    _enum(["task-prepare", "task-lint", "task-test-unit"])
  ).min(1),
  allowedValidationFailureCases: array(string2().min(1).max(300)).max(50),
  approvalPathPrefixes: array(string2().min(1)),
  labelColors: record(string2(), string2().regex(/^[0-9a-fA-F]{6}$/))
});
function requiresApproval(analysis, inspection, approved, policy) {
  if (approved) return [];
  const reasons = [];
  if (analysis.risk.level === "high") {
    reasons.push("the implementation reports high risk");
  }
  if (inspection.changedFiles.length > policy.maxChangedFiles) {
    reasons.push(
      `the change touches ${inspection.changedFiles.length} files (limit ${policy.maxChangedFiles})`
    );
  }
  const changedLines = inspection.additions + inspection.deletions;
  if (changedLines > policy.maxChangedLines) {
    reasons.push(
      `the change modifies ${changedLines} lines (limit ${policy.maxChangedLines})`
    );
  }
  const sensitivePaths = inspection.changedFiles.filter(
    (file) => policy.approvalPathPrefixes.some((prefix) => file.startsWith(prefix))
  );
  if (sensitivePaths.length > 0) {
    reasons.push(
      `the change touches approval-gated paths: ${sensitivePaths.slice(0, 5).join(", ")}`
    );
  }
  return reasons;
}
function hasLabel(labels, expected) {
  const normalized = expected.trim().toLowerCase();
  return labels.some((label) => label.trim().toLowerCase() === normalized);
}
function hasAnyLabel(labels, expected) {
  return expected.some((label) => hasLabel(labels, label));
}

// src/draft-pr/repository.ts
function repositoryCloneUrl(serverUrl, repository) {
  const base = new URL(serverUrl);
  if (base.protocol !== "https:") {
    throw new Error("GitHub server URL must use HTTPS");
  }
  base.pathname = `${base.pathname.replace(/\/$/, "")}/${repository}.git`;
  base.search = "";
  base.hash = "";
  return base.toString();
}
function sanitizeTitle(value) {
  return value.replace(/[\r\n]+/g, " ").replace(/\s+/g, " ").trim().slice(0, 120);
}
function assertAllowedRepository(repository, allowed) {
  if (!allowed.trim()) {
    throw new Error("Draft PR repository allowlist is required");
  }
  if (repository.trim().toLowerCase() !== allowed.trim().toLowerCase()) {
    throw new Error("repository is outside the Draft PR allowlist");
  }
}

// src/draft-pr/workspace.ts
import crypto2 from "node:crypto";
import { spawn } from "node:child_process";
import {
  chmod,
  lstat,
  mkdir,
  mkdtemp,
  rm,
  stat,
  writeFile
} from "node:fs/promises";
import { isIP } from "node:net";
import os from "node:os";
import path from "node:path";
var DraftPrWorkspaceLockError = class extends Error {
  constructor(target) {
    super(`another Draft PR run already holds the ${target} lock`);
    this.name = "DraftPrWorkspaceLockError";
  }
};
var GitDraftPrWorkspace = class {
  #root;
  #token;
  #authorName;
  #authorEmail;
  #gitCurlResolve;
  #lockTtlMs;
  constructor(options) {
    this.#root = path.resolve(options.root);
    this.#token = options.token.trim();
    this.#authorName = options.authorName.trim();
    this.#authorEmail = options.authorEmail.trim();
    this.#gitCurlResolve = options.gitCurlResolve?.trim() ?? "";
    this.#lockTtlMs = options.lockTtlMs ?? 4 * 60 * 60 * 1e3;
    if (!this.#token)
      throw new Error("GitHub token is required for Git workspace preparation");
    if (!this.#authorName || !this.#authorEmail) {
      throw new Error("Git author name and email are required");
    }
    gitCurlResolveEnvironment(this.#gitCurlResolve);
  }
  async prepare(input) {
    validateCloneUrl(input.cloneUrl);
    validateGitRef(input.baseBranch, "base branch");
    validateGitRef(input.branch, "working branch");
    const paths = this.#paths(input.repository, "issue", input.issueNumber);
    await mkdir(path.dirname(paths.lock), { recursive: true });
    await this.#acquireLock(paths.lock);
    try {
      await rm(paths.workspace, { recursive: true, force: true });
      await mkdir(path.dirname(paths.workspace), { recursive: true });
      const env = await this.#authenticatedGitEnvironment();
      await runGit(
        [
          "clone",
          "--no-tags",
          "--depth=1",
          "--branch",
          input.baseBranch,
          "--",
          input.cloneUrl,
          paths.workspace
        ],
        { cwd: this.#root, env }
      );
      const existing = await runGit(
        ["ls-remote", "--heads", "origin", `refs/heads/${input.branch}`],
        { cwd: paths.workspace, env }
      );
      if (existing.stdout.trim()) {
        throw new Error(`remote branch already exists: ${input.branch}`);
      }
      await runGit(["checkout", "-b", input.branch], {
        cwd: paths.workspace,
        env
      });
      const baseCommit = (await runGit(["rev-parse", "HEAD"], { cwd: paths.workspace, env })).stdout.trim();
      return {
        path: paths.workspace,
        branch: input.branch,
        baseBranch: input.baseBranch,
        baseCommit
      };
    } catch (error) {
      await this.cleanup(input.repository, input.issueNumber);
      throw error;
    }
  }
  async prepareReview(input) {
    validateCloneUrl(input.cloneUrl);
    validateGitRef(input.baseBranch, "base branch");
    validateGitRef(input.branch, "Pull Request branch");
    if (!/^[0-9a-f]{40}$/.test(input.expectedHeadSha)) {
      throw new Error("invalid expected Pull Request head SHA");
    }
    const paths = this.#paths(input.repository, "pr", input.pullRequestNumber);
    await mkdir(path.dirname(paths.lock), { recursive: true });
    await this.#acquireLock(paths.lock, "Pull Request");
    try {
      await rm(paths.workspace, { recursive: true, force: true });
      await mkdir(path.dirname(paths.workspace), { recursive: true });
      const env = await this.#authenticatedGitEnvironment();
      await runGit(
        [
          "clone",
          "--no-tags",
          "--depth=1",
          "--branch",
          input.branch,
          "--",
          input.cloneUrl,
          paths.workspace
        ],
        { cwd: this.#root, env }
      );
      const headCommit = (await runGit(["rev-parse", "HEAD"], { cwd: paths.workspace, env })).stdout.trim();
      if (headCommit !== input.expectedHeadSha) {
        throw new Error(
          "Pull Request head changed during workspace preparation"
        );
      }
      return {
        path: paths.workspace,
        branch: input.branch,
        baseBranch: input.baseBranch,
        baseCommit: headCommit
      };
    } catch (error) {
      await this.cleanupReview(input.repository, input.pullRequestNumber);
      throw error;
    }
  }
  async inspect(workspacePath) {
    return inspectDraftPrWorkspace(this.#root, workspacePath);
  }
  async commitAndPush(workspacePath, branch, title, cloneUrl) {
    const resolved = this.#assertWorkspacePath(workspacePath);
    validateGitRef(branch, "working branch");
    validateCloneUrl(cloneUrl);
    await this.#writeTrustedGitConfig(resolved, cloneUrl);
    const localEnv = this.#localGitEnvironment();
    await runGit(
      [
        "-c",
        `user.name=${this.#authorName}`,
        "-c",
        `user.email=${this.#authorEmail}`,
        "-c",
        "core.hooksPath=/dev/null",
        "commit",
        "-m",
        title
      ],
      { cwd: resolved, env: localEnv }
    );
    const authenticatedEnv = await this.#authenticatedGitEnvironment();
    await runGit(
      [
        "-c",
        "core.hooksPath=/dev/null",
        "-c",
        "credential.helper=",
        "push",
        "--no-verify",
        "--set-upstream",
        "origin",
        branch
      ],
      {
        cwd: resolved,
        env: authenticatedEnv
      }
    );
    return (await runGit(["rev-parse", "HEAD"], { cwd: resolved, env: localEnv })).stdout.trim();
  }
  async cleanup(repository, issueNumber) {
    const paths = this.#paths(repository, "issue", issueNumber);
    await rm(paths.workspace, { recursive: true, force: true });
    await rm(paths.lock, { recursive: true, force: true });
  }
  async cleanupReview(repository, pullRequestNumber) {
    const paths = this.#paths(repository, "pr", pullRequestNumber);
    await rm(paths.workspace, { recursive: true, force: true });
    await rm(paths.lock, { recursive: true, force: true });
  }
  #paths(repository, kind, number3) {
    if (!Number.isSafeInteger(number3) || number3 <= 0) {
      throw new Error(
        `${kind === "issue" ? "Issue" : "Pull Request"} number must be a positive integer`
      );
    }
    const key = crypto2.createHash("sha256").update(repository.trim().toLowerCase()).digest("hex").slice(0, 16);
    return {
      workspace: path.join(
        this.#root,
        "repositories",
        key,
        `${kind}-${number3}`
      ),
      lock: path.join(this.#root, ".locks", `${key}-${kind}-${number3}`)
    };
  }
  #assertWorkspacePath(value) {
    const resolved = path.resolve(value);
    const expectedPrefix = `${path.join(this.#root, "repositories")}${path.sep}`;
    if (!resolved.startsWith(expectedPrefix)) {
      throw new Error("workspace path is outside the configured Draft PR root");
    }
    return resolved;
  }
  async #acquireLock(lockPath, target = "Issue") {
    try {
      await mkdir(lockPath);
      return;
    } catch (error) {
      if (!isAlreadyExists(error)) throw error;
    }
    const info = await stat(lockPath);
    if (Date.now() - info.mtimeMs <= this.#lockTtlMs) {
      throw new DraftPrWorkspaceLockError(target);
    }
    await rm(lockPath, { recursive: true, force: true });
    await mkdir(lockPath);
  }
  #localGitEnvironment() {
    return {
      PATH: process.env.PATH,
      HOME: process.env.HOME,
      LANG: process.env.LANG ?? "C.UTF-8",
      GIT_CONFIG_NOSYSTEM: "1",
      GIT_CONFIG_GLOBAL: "/dev/null",
      GIT_TERMINAL_PROMPT: "0",
      ...gitCurlResolveEnvironment(this.#gitCurlResolve)
    };
  }
  async #authenticatedGitEnvironment() {
    await mkdir(this.#root, { recursive: true });
    const askPass = path.join(this.#root, ".git-askpass.sh");
    await writeFile(
      askPass,
      [
        "#!/bin/sh",
        'case "$1" in',
        '  *Username*) printf "%s" "x-access-token" ;;',
        '  *) printf "%s" "$DRAFT_PR_GIT_TOKEN" ;;',
        "esac",
        ""
      ].join("\n"),
      { mode: 448 }
    );
    await chmod(askPass, 448);
    return {
      ...this.#localGitEnvironment(),
      GIT_ASKPASS: askPass,
      DRAFT_PR_GIT_TOKEN: this.#token
    };
  }
  async #writeTrustedGitConfig(workspacePath, cloneUrl) {
    const gitDirectory = path.join(workspacePath, ".git");
    const gitDirectoryInfo = await lstat(gitDirectory);
    if (!gitDirectoryInfo.isDirectory() || gitDirectoryInfo.isSymbolicLink()) {
      throw new Error("prepared workspace .git directory was replaced");
    }
    const configPath = path.join(gitDirectory, "config");
    const configInfo = await lstat(configPath);
    if (!configInfo.isFile() || configInfo.isSymbolicLink()) {
      throw new Error("prepared workspace Git config was replaced");
    }
    await writeFile(
      configPath,
      [
        "[core]",
        "	repositoryformatversion = 0",
        "	filemode = true",
        "	bare = false",
        "	logallrefupdates = true",
        "	hooksPath = /dev/null",
        '[remote "origin"]',
        `	url = ${cloneUrl}`,
        "	fetch = +refs/heads/*:refs/remotes/origin/*",
        ""
      ].join("\n"),
      { mode: 384 }
    );
  }
};
async function inspectDraftPrWorkspace(root, workspacePath) {
  const resolved = assertWorkspacePath(root, workspacePath);
  const env = localGitEnvironment();
  await runGit(["add", "-A"], { cwd: resolved, env });
  const [head, tree, names, stats, check, diff] = await Promise.all([
    runGit(["rev-parse", "HEAD"], { cwd: resolved, env }),
    runGit(["write-tree"], { cwd: resolved, env }),
    runGit(["diff", "--cached", "--name-only", "-z"], {
      cwd: resolved,
      env
    }),
    runGit(["diff", "--cached", "--numstat"], { cwd: resolved, env }),
    runGit(["diff", "--cached", "--check"], {
      cwd: resolved,
      env,
      allowFailure: true
    }),
    runGit(
      [
        "diff",
        "--cached",
        "--unified=0",
        "--no-color",
        "--no-ext-diff",
        "--no-textconv"
      ],
      {
        cwd: resolved,
        env,
        maxOutputBytes: 8 * 1024 * 1024
      }
    )
  ]);
  const changedFiles = names.stdout.split("\0").filter(Boolean);
  let additions = 0;
  let deletions = 0;
  for (const line of stats.stdout.split("\n")) {
    const [added, deleted] = line.split("	");
    if (/^\d+$/.test(added ?? "")) additions += Number(added);
    if (/^\d+$/.test(deleted ?? "")) deletions += Number(deleted);
  }
  return {
    headCommit: head.stdout.trim(),
    changeFingerprint: tree.stdout.trim(),
    changedFiles,
    additions,
    deletions,
    diffCheckPassed: check.exitCode === 0,
    secretFindingPaths: scanAddedLinesForSecrets(diff.stdout)
  };
}
async function fingerprintDraftPrWorkspace(root, workspacePath) {
  const resolved = assertWorkspacePath(root, workspacePath);
  const temporaryDirectory = await mkdtemp(
    path.join(os.tmpdir(), "draft-pr-index-")
  );
  try {
    const env = {
      ...localGitEnvironment(),
      GIT_INDEX_FILE: path.join(temporaryDirectory, "index")
    };
    await runGit(["read-tree", "HEAD"], { cwd: resolved, env });
    await runGit(["add", "-A"], { cwd: resolved, env });
    const [head, tree] = await Promise.all([
      runGit(["rev-parse", "HEAD"], { cwd: resolved, env }),
      runGit(["write-tree"], { cwd: resolved, env })
    ]);
    return {
      headCommit: head.stdout.trim(),
      changeFingerprint: tree.stdout.trim()
    };
  } finally {
    await rm(temporaryDirectory, { recursive: true, force: true });
  }
}
function assertWorkspacePath(root, value) {
  const resolvedRoot = path.resolve(root);
  const resolved = path.resolve(value);
  const expectedPrefix = `${path.join(resolvedRoot, "repositories")}${path.sep}`;
  if (!resolved.startsWith(expectedPrefix)) {
    throw new Error("workspace path is outside the configured Draft PR root");
  }
  return resolved;
}
function localGitEnvironment() {
  return {
    PATH: process.env.PATH,
    HOME: process.env.HOME,
    LANG: process.env.LANG ?? "C.UTF-8",
    GIT_CONFIG_NOSYSTEM: "1",
    GIT_CONFIG_GLOBAL: "/dev/null",
    GIT_TERMINAL_PROMPT: "0"
  };
}
function gitCurlResolveEnvironment(value) {
  const normalized = value?.trim() ?? "";
  if (!normalized) return {};
  const [host, port, address, ...extra] = normalized.split(":");
  if (host !== "github.com" || port !== "443" || isIP(address ?? "") !== 4 || extra.length > 0) {
    throw new Error("Draft PR Git curl resolve must use github.com:443:<IPv4>");
  }
  return {
    GIT_CONFIG_COUNT: "1",
    GIT_CONFIG_KEY_0: "http.curloptResolve",
    GIT_CONFIG_VALUE_0: normalized
  };
}
async function runGit(args, options) {
  const safeArgs = options.cwd ? ["-c", `safe.directory=${options.cwd}`, ...args] : args;
  return new Promise((resolve, reject) => {
    const child = spawn("git", safeArgs, {
      cwd: options.cwd,
      env: options.env,
      stdio: ["ignore", "pipe", "pipe"]
    });
    const max = options.maxOutputBytes ?? 2 * 1024 * 1024;
    let stdout = "";
    let stderr = "";
    let size = 0;
    child.stdout.setEncoding("utf8");
    child.stderr.setEncoding("utf8");
    child.stdout.on("data", (chunk) => {
      size += Buffer.byteLength(chunk);
      if (size <= max) stdout += chunk;
    });
    child.stderr.on("data", (chunk) => {
      size += Buffer.byteLength(chunk);
      if (size <= max) stderr += chunk;
    });
    child.on("error", reject);
    child.on("close", (code) => {
      const exitCode = code ?? 1;
      if (size > max) {
        reject(new Error("git command output exceeded the configured limit"));
      } else if (exitCode !== 0 && !options.allowFailure) {
        reject(
          new Error(
            `git ${args[0] ?? "command"} failed: ${stderr.trim().slice(-2e3)}`
          )
        );
      } else {
        resolve({ stdout, stderr, exitCode });
      }
    });
  });
}
function validateCloneUrl(value) {
  const url = new URL(value);
  if (url.protocol !== "https:" || url.username || url.password) {
    throw new Error("Draft PR clone URL must be credential-free HTTPS");
  }
}
function validateGitRef(value, name) {
  if (!/^[A-Za-z0-9][A-Za-z0-9._/-]*$/.test(value) || value.includes("..") || value.includes("//") || value.endsWith("/") || value.endsWith(".lock")) {
    throw new Error(`invalid ${name}: ${value}`);
  }
}
function scanAddedLinesForSecrets(diff) {
  const findings = /* @__PURE__ */ new Set();
  let currentPath = "unknown";
  const patterns = [
    /-----BEGIN [A-Z ]*PRIVATE KEY-----/,
    /\bghp_[A-Za-z0-9]{30,}\b/,
    /\bgithub_pat_[A-Za-z0-9_]{30,}\b/,
    /\bAKIA[0-9A-Z]{16}\b/,
    /Authorization:\s*Bearer\s+[A-Za-z0-9._-]{20,}/i
  ];
  for (const line of diff.split("\n")) {
    if (line.startsWith("+++ b/")) currentPath = line.slice(6);
    if (!line.startsWith("+") || line.startsWith("+++")) continue;
    if (patterns.some((pattern) => pattern.test(line)))
      findings.add(currentPath);
  }
  return [...findings].sort();
}
function isAlreadyExists(error) {
  return typeof error === "object" && error !== null && "code" in error && error.code === "EEXIST";
}

// src/draft-pr/ci-tool.ts
var FAILED_CONCLUSIONS = /* @__PURE__ */ new Set([
  "action_required",
  "failure",
  "startup_failure",
  "timed_out"
]);
var MAX_ANNOTATIONS_PER_CHECK = 50;
async function prepareCiFix(repository, pullRequestNumber, expectedHeadSha, checkSuiteId, dependencies) {
  assertAllowedRepository(repository, dependencies.allowedRepository);
  requireBotIdentity(dependencies);
  validateEventTarget(expectedHeadSha, checkSuiteId);
  const [pullRequest, comments] = await Promise.all([
    dependencies.provider.getPullRequest(repository, pullRequestNumber),
    dependencies.provider.listComments(repository, pullRequestNumber)
  ]);
  const reason = ineligibleReason(pullRequest, repository, dependencies);
  if (reason) {
    return skipped(repository, pullRequestNumber, checkSuiteId, reason);
  }
  if (pullRequest.headSha !== expectedHeadSha) {
    return skipped(
      repository,
      pullRequestNumber,
      checkSuiteId,
      "CI event is for a stale Pull Request head"
    );
  }
  const state = ciState(comments, dependencies);
  if (state.checkSuiteId === checkSuiteId && ["no-change", "needs-approval"].includes(state.status)) {
    return skipped(
      repository,
      pullRequestNumber,
      checkSuiteId,
      "CI check suite was already processed"
    );
  }
  if (state.attempts >= dependencies.policy.maxFixIterations) {
    if (dependencies.apply) {
      await upsertCiState(
        repository,
        pullRequestNumber,
        {
          checkSuiteId,
          attempts: state.attempts,
          headSha: expectedHeadSha,
          status: "needs-approval"
        },
        comments,
        dependencies
      );
    }
    return skipped(
      repository,
      pullRequestNumber,
      checkSuiteId,
      "automatic CI fix iteration limit reached"
    );
  }
  const failures = await loadFailures(
    repository,
    expectedHeadSha,
    checkSuiteId,
    dependencies
  );
  if (failures.length === 0) {
    return skipped(
      repository,
      pullRequestNumber,
      checkSuiteId,
      "check suite has no supported failed checks"
    );
  }
  let prepared;
  try {
    prepared = await dependencies.workspace.prepareReview({
      repository,
      pullRequestNumber,
      cloneUrl: repositoryCloneUrl(dependencies.serverUrl, repository),
      baseBranch: pullRequest.base,
      branch: pullRequest.head,
      expectedHeadSha
    });
  } catch (error) {
    if (error instanceof DraftPrWorkspaceLockError) {
      return skipped(
        repository,
        pullRequestNumber,
        checkSuiteId,
        "another Pull Request fix run holds the workspace lock"
      );
    }
    throw error;
  }
  if (dependencies.apply) {
    await upsertCiState(
      repository,
      pullRequestNumber,
      {
        checkSuiteId,
        attempts: state.attempts,
        headSha: expectedHeadSha,
        status: "fixing"
      },
      comments,
      dependencies
    );
  }
  return {
    ok: true,
    repository,
    pullRequestNumber,
    checkSuiteId,
    workspacePath: prepared.path,
    branch: prepared.branch,
    baseBranch: prepared.baseBranch,
    expectedHeadSha: prepared.baseCommit,
    failuresFingerprint: fingerprintFailures(failures),
    previousAttempts: state.attempts,
    failures
  };
}
async function applyCiFix(repository, pullRequestNumber, submissionInput, dependencies) {
  assertAllowedRepository(repository, dependencies.allowedRepository);
  requireBotIdentity(dependencies);
  const submission = ciFixSubmissionSchema.parse(submissionInput);
  const [pullRequest, comments, failures] = await Promise.all([
    dependencies.provider.getPullRequest(repository, pullRequestNumber),
    dependencies.provider.listComments(repository, pullRequestNumber),
    loadFailures(
      repository,
      submission.expectedHeadSha,
      submission.checkSuiteId,
      dependencies
    )
  ]);
  const reason = ineligibleReason(pullRequest, repository, dependencies);
  if (reason) throw new Error(reason);
  if (pullRequest.headSha !== submission.expectedHeadSha) {
    throw new Error("Pull Request head changed after CI fix preparation");
  }
  const expectedIds = submission.checkRefs.map((value) => value.checkRunId);
  const actualIds = failures.map((value) => value.checkRunId);
  if (new Set(expectedIds).size !== expectedIds.length || expectedIds.length !== actualIds.length || expectedIds.some((id, index) => id !== actualIds[index]) || fingerprintFailures(failures) !== submission.failuresFingerprint) {
    throw new Error("failed CI checks changed after fix preparation");
  }
  validateFailureCoverage(submission.analysis, expectedIds);
  const inspection = await dependencies.workspace.inspect(
    submission.workspacePath
  );
  if (inspection.headCommit !== submission.expectedHeadSha) {
    throw new Error("the Agent committed or moved HEAD in the CI workspace");
  }
  const nextAttempts = submission.previousAttempts + 1;
  if (submission.analysis.outcome !== "fixed") {
    if (inspection.changedFiles.length > 0) {
      throw new Error(
        `${submission.analysis.outcome} CI result contains changes`
      );
    }
    if (submission.analysis.outcome === "no_change" && submission.analysis.failures.some(
      (failure) => failure.disposition !== "not_reproducible"
    )) {
      throw new Error(
        "no_change CI result requires every failure to be not reproducible"
      );
    }
    const status = submission.analysis.outcome === "needs_approval" ? "needs-approval" : submission.analysis.outcome === "no_change" ? "no-change" : "failed";
    await finishWithoutPush(
      repository,
      pullRequestNumber,
      submission,
      nextAttempts,
      status,
      comments,
      dependencies
    );
    return {
      ok: true,
      repository,
      pullRequestNumber,
      applied: dependencies.apply,
      outcome: submission.analysis.outcome,
      inspection
    };
  }
  validateFixedAnalysis(submission.analysis, inspection);
  const approvalReasons = requiresApproval(
    submission.analysis,
    inspection,
    false,
    dependencies.policy
  );
  if (approvalReasons.length > 0) {
    await finishWithoutPush(
      repository,
      pullRequestNumber,
      submission,
      nextAttempts,
      "needs-approval",
      comments,
      dependencies
    );
    return {
      ok: true,
      repository,
      pullRequestNumber,
      applied: dependencies.apply,
      outcome: "needs_approval",
      inspection
    };
  }
  if (!dependencies.apply) {
    await dependencies.workspace.cleanupReview(repository, pullRequestNumber);
    return {
      ok: true,
      repository,
      pullRequestNumber,
      applied: false,
      outcome: "fixed",
      inspection
    };
  }
  const commit = await dependencies.workspace.commitAndPush(
    submission.workspacePath,
    submission.branch,
    sanitizeTitle(submission.analysis.commitTitle),
    repositoryCloneUrl(dependencies.serverUrl, repository)
  );
  await upsertCiState(
    repository,
    pullRequestNumber,
    {
      checkSuiteId: submission.checkSuiteId,
      attempts: nextAttempts,
      headSha: commit,
      status: "fixed"
    },
    comments,
    dependencies
  );
  await dependencies.workspace.cleanupReview(repository, pullRequestNumber);
  return {
    ok: true,
    repository,
    pullRequestNumber,
    applied: true,
    outcome: "fixed",
    commit,
    inspection
  };
}
async function failCiFix(repository, pullRequestNumber, checkSuiteId, attempts, headSha, dependencies) {
  assertAllowedRepository(repository, dependencies.allowedRepository);
  try {
    if (dependencies.apply) {
      const comments = await dependencies.provider.listComments(
        repository,
        pullRequestNumber
      );
      await upsertCiState(
        repository,
        pullRequestNumber,
        {
          checkSuiteId,
          attempts,
          headSha,
          status: "failed"
        },
        comments,
        dependencies
      );
    }
  } finally {
    await dependencies.workspace.cleanupReview(repository, pullRequestNumber);
  }
  return {
    ok: true,
    repository,
    pullRequestNumber,
    applied: dependencies.apply,
    outcome: "failed"
  };
}
async function loadFailures(repository, headSha, checkSuiteId, dependencies) {
  const runs = (await dependencies.provider.listCheckRuns(repository, headSha)).filter(
    (run) => run.checkSuiteId === checkSuiteId && run.status === "completed" && FAILED_CONCLUSIONS.has(run.conclusion ?? "")
  ).sort((left, right) => left.id - right.id);
  if (runs.length > dependencies.policy.maxReviewComments) {
    throw new Error(
      `CI check suite has ${runs.length} failed checks (limit ${dependencies.policy.maxReviewComments})`
    );
  }
  return Promise.all(
    runs.map(async (run) => ({
      checkRunId: run.id,
      name: run.name,
      conclusion: run.conclusion,
      ...run.htmlUrl ? { htmlUrl: run.htmlUrl } : {},
      output: run.output,
      annotations: (await dependencies.provider.listCheckRunAnnotations(repository, run.id)).slice(0, MAX_ANNOTATIONS_PER_CHECK)
    }))
  );
}
function fingerprintFailures(failures) {
  return crypto3.createHash("sha256").update(JSON.stringify(failures)).digest("hex").slice(0, 20);
}
function validateFailureCoverage(analysis, expectedIds) {
  const actual = analysis.failures.map((failure) => failure.checkRunId);
  if (new Set(actual).size !== actual.length || actual.length !== expectedIds.length || actual.some((id, index) => id !== expectedIds[index])) {
    throw new Error(
      "CI fix analysis must address every failed check exactly once"
    );
  }
  if (analysis.outcome === "fixed" && analysis.failures.some(
    (failure) => failure.disposition === "needs_approval"
  )) {
    throw new Error("fixed CI result cannot contain approval-gated failures");
  }
}
function validateFixedAnalysis(analysis, inspection) {
  if (inspection.changedFiles.length === 0) {
    throw new Error("fixed CI result contains no repository changes");
  }
  if (!inspection.diffCheckPassed) {
    throw new Error("CI fix failed git diff --check");
  }
  if (inspection.secretFindingPaths.length > 0) {
    throw new Error("CI fix contains potential credential material");
  }
  if (analysis.validationOverride && !hasConsistentValidationOverride(analysis)) {
    throw new Error("fixed CI result has an inconsistent validation override");
  }
  if (analysis.tests.some((test) => test.status === "failed") && !hasConsistentValidationOverride(analysis)) {
    throw new Error("fixed CI result reports a failed validation command");
  }
}
function ineligibleReason(pullRequest, repository, dependencies) {
  if (pullRequest.state.toLowerCase() !== "open")
    return "Pull Request is not open";
  if (!pullRequest.head.startsWith(dependencies.policy.branchPrefix)) {
    return "Pull Request branch is not managed by the Draft PR Agent";
  }
  if (pullRequest.headRepository?.trim().toLowerCase() !== repository.trim().toLowerCase()) {
    return "Pull Request head repository is not the allowlisted repository";
  }
  if (!pullRequest.headSha || !/^[0-9a-f]{40}$/.test(pullRequest.headSha)) {
    return "Pull Request has no valid head SHA";
  }
  return void 0;
}
function validateEventTarget(headSha, checkSuiteId) {
  if (!/^[0-9a-f]{40}$/.test(headSha)) {
    throw new Error("invalid CI event head SHA");
  }
  if (!Number.isSafeInteger(checkSuiteId) || checkSuiteId <= 0) {
    throw new Error("invalid CI check suite ID");
  }
}
function ciState(comments, dependencies) {
  return parseCiFixState(
    findCiFixComment(comments, dependencies.botLogin?.trim() ?? "")
  );
}
async function finishWithoutPush(repository, pullRequestNumber, submission, attempts, status, comments, dependencies) {
  if (dependencies.apply) {
    await upsertCiState(
      repository,
      pullRequestNumber,
      {
        checkSuiteId: submission.checkSuiteId,
        attempts,
        headSha: submission.expectedHeadSha,
        status
      },
      comments,
      dependencies
    );
  }
  await dependencies.workspace.cleanupReview(repository, pullRequestNumber);
}
async function upsertCiState(repository, pullRequestNumber, state, comments, dependencies) {
  const botLogin = dependencies.botLogin?.trim() ?? "";
  if (!botLogin) throw new Error("GitHub bot login is required in apply mode");
  const existing = findCiFixComment(comments, botLogin);
  const body = buildCiFixComment(state);
  if (existing) {
    await dependencies.provider.updateComment(
      repository,
      pullRequestNumber,
      existing.id,
      body
    );
  } else {
    await dependencies.provider.createComment(
      repository,
      pullRequestNumber,
      body
    );
  }
}
function requireBotIdentity(dependencies) {
  if (dependencies.apply && !dependencies.botLogin?.trim()) {
    throw new Error("GitHub bot login is required for CI fixes in apply mode");
  }
}
function skipped(repository, pullRequestNumber, checkSuiteId, reason) {
  return {
    ok: true,
    skipped: true,
    reason,
    repository,
    pullRequestNumber,
    checkSuiteId
  };
}

// src/draft-pr/review-tool.ts
import crypto4 from "node:crypto";

// src/draft-pr/review-comment.ts
var REVIEW_FIX_COMMENT_PREFIX = "<!-- engineering-agent-workflows:review-fix:v";
var REVIEW_FIX_COMMENT_V2_PREFIX = `${REVIEW_FIX_COMMENT_PREFIX}2`;
var REVIEW_FIX_COMMENT_V3_PREFIX = `${REVIEW_FIX_COMMENT_PREFIX}3`;
function findReviewFixComment(comments, botLogin) {
  const expected = botLogin.trim().toLowerCase();
  return comments.find(
    (comment) => comment.user?.login.trim().toLowerCase() === expected && comment.body.startsWith(REVIEW_FIX_COMMENT_PREFIX)
  );
}
function parseReviewFixState(comment) {
  if (!comment) return emptyReviewFixState();
  const marker = comment.body.split("\n", 1)[0] ?? "";
  const v3Match = marker.match(
    /^<!-- engineering-agent-workflows:review-fix:v3 review=(\d+) iterations=(\d+) head=([0-9a-f]{40}|none) status=(fixing|fixed|no-change|needs-approval|failed) -->$/
  );
  if (v3Match) {
    return {
      reviewCursor: Number(v3Match[1]),
      iterations: Number(v3Match[2]),
      headSha: v3Match[3] === "none" ? "" : v3Match[3],
      status: v3Match[4]
    };
  }
  const v2Match = marker.match(
    /^<!-- engineering-agent-workflows:review-fix:v2 conversation=(\d+) review=(\d+) iterations=(\d+) head=([0-9a-f]{40}|none) status=(fixing|fixed|no-change|needs-approval|failed) -->$/
  );
  if (v2Match) {
    return {
      // v2 stored Conversation and inline Review Comment IDs, not Review IDs.
      // Start the v3 Review cursor at zero so the first formal change request
      // after upgrading is never skipped because the ID namespaces differ.
      reviewCursor: 0,
      iterations: Number(v2Match[3]),
      headSha: v2Match[4] === "none" ? "" : v2Match[4],
      status: v2Match[5]
    };
  }
  const v1Match = marker.match(
    /^<!-- engineering-agent-workflows:review-fix:v1 cursor=(\d+) iterations=(\d+) head=([0-9a-f]{40}|none) status=(fixing|fixed|no-change|needs-approval|failed) -->$/
  );
  if (!v1Match) return emptyReviewFixState();
  return {
    reviewCursor: 0,
    iterations: Number(v1Match[2]),
    headSha: v1Match[3] === "none" ? "" : v1Match[3],
    status: v1Match[4]
  };
}
function buildReviewFixComment(state) {
  const marker = `${REVIEW_FIX_COMMENT_V3_PREFIX} review=${state.reviewCursor} iterations=${state.iterations} head=${state.headSha || "none"} status=${state.status} -->`;
  const messages = {
    fixing: "The Draft PR Agent is validating a requested change.",
    fixed: "The Draft PR Agent pushed a validated fix for the latest requested changes.",
    "no-change": "The Draft PR Agent verified the latest requested changes and made no code change.",
    "needs-approval": "Automatic Review fixes paused for maintainer approval.",
    failed: "The Draft PR Agent could not complete the latest Review fix attempt."
  };
  return [marker, "## Review follow-up", "", messages[state.status]].join("\n");
}
function emptyReviewFixState() {
  return {
    reviewCursor: 0,
    iterations: 0,
    headSha: "",
    status: "fixed"
  };
}

// src/draft-pr/review-schema.ts
var reviewFindingSourceSchema = _enum(["review", "review_comment"]);
var reviewFindingReferenceSchema = object({
  source: reviewFindingSourceSchema,
  commentId: number2().int().positive()
});
var reviewTestSchema = object({
  command: string2().min(1).max(300),
  status: _enum(["passed", "failed", "not_run"]),
  details: string2().max(1e3)
});
var reviewFixAnalysisSchema = object({
  outcome: _enum(["fixed", "no_change", "needs_approval", "blocked"]),
  commitTitle: string2().max(120),
  summary: array(string2().min(1).max(500)).max(8),
  findings: array(
    object({
      source: reviewFindingSourceSchema,
      commentId: number2().int().positive(),
      disposition: _enum(["fixed", "not_reproducible", "needs_approval"]),
      reason: string2().min(1).max(1e3)
    })
  ).max(100),
  tests: array(reviewTestSchema).max(20),
  risk: object({
    level: _enum(["low", "medium", "high"]),
    reasons: array(string2().min(1).max(500)).max(8)
  }),
  notes: array(string2().min(1).max(500)).max(8),
  validationOverride: validationOverrideSchema.optional()
});
var reviewFixSubmissionSchema = object({
  reviewId: number2().int().positive(),
  reviewFingerprint: string2().regex(/^[0-9a-f]{20}$/),
  findingRefs: array(reviewFindingReferenceSchema).min(1).max(100),
  workspacePath: string2().min(1).max(2e3),
  branch: string2().min(1).max(250),
  baseBranch: string2().min(1).max(250),
  expectedHeadSha: string2().regex(/^[0-9a-f]{40}$/),
  previousReviewCursor: number2().int().nonnegative(),
  previousIterations: number2().int().nonnegative(),
  analysis: reviewFixAnalysisSchema
});

// src/draft-pr/review-tool.ts
async function prepareReviewFix(repository, pullRequestNumber, reviewId, dependencies) {
  assertAllowedRepository(repository, dependencies.allowedRepository);
  requireReviewBotIdentity(dependencies);
  const [pullRequest, review, conversationComments, reviewComments] = await Promise.all([
    dependencies.provider.getPullRequest(repository, pullRequestNumber),
    dependencies.provider.getPullRequestReview(
      repository,
      pullRequestNumber,
      reviewId
    ),
    dependencies.provider.listComments(repository, pullRequestNumber),
    dependencies.provider.listReviewComments(repository, pullRequestNumber)
  ]);
  const reason = ineligibleReason2(pullRequest, repository, dependencies);
  if (reason) return skipped2(repository, pullRequestNumber, reason);
  const reviewReason = ineligibleReviewReason(review, pullRequest);
  if (reviewReason) return skipped2(repository, pullRequestNumber, reviewReason);
  const state = reviewState(conversationComments, dependencies);
  if (review.id <= state.reviewCursor) {
    return skipped2(
      repository,
      pullRequestNumber,
      "Pull Request Review was already processed"
    );
  }
  const findings = findingsForReview(review, reviewComments);
  if (findings.length === 0) {
    return skipped2(repository, pullRequestNumber, "Review has no findings");
  }
  if (findings.length > dependencies.policy.maxReviewComments) {
    if (dependencies.apply) {
      await upsertReviewState(
        repository,
        pullRequestNumber,
        {
          reviewCursor: state.reviewCursor,
          iterations: state.iterations,
          headSha: pullRequest.headSha,
          status: "needs-approval"
        },
        conversationComments,
        dependencies
      );
    }
    return skipped2(
      repository,
      pullRequestNumber,
      `Review has ${findings.length} findings, exceeding the automatic limit of ${dependencies.policy.maxReviewComments}`
    );
  }
  if (state.iterations >= dependencies.policy.maxFixIterations) {
    if (dependencies.apply) {
      await upsertReviewState(
        repository,
        pullRequestNumber,
        {
          reviewCursor: state.reviewCursor,
          iterations: state.iterations,
          headSha: pullRequest.headSha,
          status: "needs-approval"
        },
        conversationComments,
        dependencies
      );
    }
    return skipped2(
      repository,
      pullRequestNumber,
      "automatic Review fix iteration limit reached"
    );
  }
  let prepared;
  try {
    prepared = await dependencies.workspace.prepareReview({
      repository,
      pullRequestNumber,
      cloneUrl: repositoryCloneUrl(dependencies.serverUrl, repository),
      baseBranch: pullRequest.base,
      branch: pullRequest.head,
      expectedHeadSha: pullRequest.headSha
    });
  } catch (error) {
    if (error instanceof DraftPrWorkspaceLockError) {
      return skipped2(
        repository,
        pullRequestNumber,
        "another review fix run holds the Pull Request lock"
      );
    }
    throw error;
  }
  if (dependencies.apply) {
    await upsertReviewState(
      repository,
      pullRequestNumber,
      {
        reviewCursor: state.reviewCursor,
        iterations: state.iterations,
        headSha: pullRequest.headSha,
        status: "fixing"
      },
      conversationComments,
      dependencies
    );
  }
  return {
    ok: true,
    repository,
    pullRequestNumber,
    workspacePath: prepared.path,
    branch: prepared.branch,
    baseBranch: prepared.baseBranch,
    expectedHeadSha: prepared.baseCommit,
    reviewId: review.id,
    reviewFingerprint: fingerprintFindings(findings),
    previousReviewCursor: state.reviewCursor,
    previousIterations: state.iterations,
    findings: findings.map((value) => toFinding(value))
  };
}
async function applyReviewFix(repository, pullRequestNumber, submissionInput, dependencies) {
  assertAllowedRepository(repository, dependencies.allowedRepository);
  requireReviewBotIdentity(dependencies);
  const submission = reviewFixSubmissionSchema.parse(submissionInput);
  const [pullRequest, review, conversationComments, reviewComments] = await Promise.all([
    dependencies.provider.getPullRequest(repository, pullRequestNumber),
    dependencies.provider.getPullRequestReview(
      repository,
      pullRequestNumber,
      submission.reviewId
    ),
    dependencies.provider.listComments(repository, pullRequestNumber),
    dependencies.provider.listReviewComments(repository, pullRequestNumber)
  ]);
  const reason = ineligibleReason2(pullRequest, repository, dependencies);
  if (reason) throw new Error(reason);
  const reviewReason = ineligibleReviewReason(review, pullRequest);
  if (reviewReason) throw new Error(reviewReason);
  if (pullRequest.headSha !== submission.expectedHeadSha) {
    throw new Error("Pull Request head changed after review fix preparation");
  }
  const expectedKeys = submission.findingRefs.map(findingKey);
  const preparedFindings = findingsForReview(review, reviewComments);
  if (new Set(expectedKeys).size !== expectedKeys.length || preparedFindings.length !== submission.findingRefs.length || preparedFindings.some(
    (value) => !expectedKeys.includes(findingKey(value))
  ) || fingerprintFindings(preparedFindings) !== submission.reviewFingerprint) {
    throw new Error("Pull Request Review changed after fix preparation");
  }
  const inspection = await dependencies.workspace.inspect(
    submission.workspacePath
  );
  if (inspection.headCommit !== submission.expectedHeadSha) {
    throw new Error(
      "the Agent committed or moved HEAD in the review workspace"
    );
  }
  validateFindingCoverage(submission.analysis, submission.findingRefs);
  const nextIterations = submission.previousIterations + 1;
  const nextReviewCursor = Math.max(
    submission.previousReviewCursor,
    submission.reviewId
  );
  if (submission.analysis.outcome !== "fixed") {
    if (submission.analysis.outcome === "no_change" && inspection.changedFiles.length > 0) {
      throw new Error("no_change review result contains repository changes");
    }
    const status = submission.analysis.outcome === "needs_approval" ? "needs-approval" : submission.analysis.outcome === "no_change" ? "no-change" : "failed";
    await finishWithoutPush2(
      repository,
      pullRequestNumber,
      nextReviewCursor,
      nextIterations,
      submission.expectedHeadSha,
      status,
      conversationComments,
      dependencies
    );
    return {
      ok: true,
      repository,
      pullRequestNumber,
      applied: dependencies.apply,
      outcome: submission.analysis.outcome,
      inspection
    };
  }
  validateFixedReview(submission.analysis, inspection);
  const approvalReasons = requiresApproval(
    submission.analysis,
    inspection,
    false,
    dependencies.policy
  );
  if (approvalReasons.length > 0) {
    await finishWithoutPush2(
      repository,
      pullRequestNumber,
      nextReviewCursor,
      nextIterations,
      submission.expectedHeadSha,
      "needs-approval",
      conversationComments,
      dependencies
    );
    return {
      ok: true,
      repository,
      pullRequestNumber,
      applied: dependencies.apply,
      outcome: "needs_approval",
      inspection
    };
  }
  if (!dependencies.apply) {
    await dependencies.workspace.cleanupReview(repository, pullRequestNumber);
    return {
      ok: true,
      repository,
      pullRequestNumber,
      applied: false,
      outcome: "fixed",
      inspection
    };
  }
  const commitTitle = sanitizeTitle(submission.analysis.commitTitle);
  const commit = await dependencies.workspace.commitAndPush(
    submission.workspacePath,
    submission.branch,
    commitTitle,
    repositoryCloneUrl(dependencies.serverUrl, repository)
  );
  await upsertReviewState(
    repository,
    pullRequestNumber,
    {
      reviewCursor: nextReviewCursor,
      iterations: nextIterations,
      headSha: commit,
      status: "fixed"
    },
    conversationComments,
    dependencies
  );
  await dependencies.workspace.cleanupReview(repository, pullRequestNumber);
  return {
    ok: true,
    repository,
    pullRequestNumber,
    applied: true,
    outcome: "fixed",
    commit,
    inspection
  };
}
async function failReviewFix(repository, pullRequestNumber, reviewCursor, iterations, headSha, dependencies) {
  assertAllowedRepository(repository, dependencies.allowedRepository);
  try {
    if (dependencies.apply) {
      const comments = await dependencies.provider.listComments(
        repository,
        pullRequestNumber
      );
      await upsertReviewState(
        repository,
        pullRequestNumber,
        {
          reviewCursor,
          iterations,
          headSha,
          status: "failed"
        },
        comments,
        dependencies
      );
    }
  } finally {
    await dependencies.workspace.cleanupReview(repository, pullRequestNumber);
  }
  return {
    ok: true,
    repository,
    pullRequestNumber,
    applied: dependencies.apply,
    outcome: "failed"
  };
}
function findingsForReview(review, reviewComments) {
  const findings = [];
  if (review.body.trim()) {
    findings.push({
      source: "review",
      id: review.id,
      body: review.body,
      ...review.htmlUrl ? { htmlUrl: review.htmlUrl } : {},
      ...review.submittedAt ? { createdAt: review.submittedAt } : {},
      review
    });
  }
  findings.push(
    ...reviewComments.filter(
      (comment) => comment.pullRequestReviewId === review.id && !comment.inReplyToId && sameUser(comment.user, review.user)
    ).map((comment) => ({
      source: "review_comment",
      id: comment.id,
      body: comment.body,
      ...comment.htmlUrl ? { htmlUrl: comment.htmlUrl } : {},
      ...comment.createdAt ? { createdAt: comment.createdAt } : {},
      comment
    }))
  );
  return findings.sort(compareSourcedFindings);
}
function ineligibleReason2(pullRequest, repository, dependencies) {
  if (pullRequest.state.toLowerCase() !== "open")
    return "Pull Request is not open";
  if (!pullRequest.draft) return "Pull Request is not a Draft";
  if (!pullRequest.head.startsWith(dependencies.policy.branchPrefix)) {
    return "Pull Request branch is not managed by the Draft PR Agent";
  }
  if (pullRequest.headRepository?.trim().toLowerCase() !== repository.trim().toLowerCase()) {
    return "Pull Request head repository is not the allowlisted repository";
  }
  if (!pullRequest.headSha || !/^[0-9a-f]{40}$/.test(pullRequest.headSha)) {
    return "Pull Request has no valid head SHA";
  }
  return void 0;
}
function ineligibleReviewReason(review, pullRequest) {
  if (review.state.trim().toLowerCase() !== "changes_requested") {
    return "Pull Request Review is not a change request";
  }
  if (!review.user?.login.trim()) return "Pull Request Review has no author";
  if (!trustedReviewerAssociation(review.authorAssociation)) {
    return "Pull Request Review author is not a trusted repository member";
  }
  if (review.commitId !== pullRequest.headSha) {
    return "Pull Request Review targets a stale head";
  }
  return void 0;
}
function trustedReviewerAssociation(value) {
  return ["owner", "member", "collaborator"].includes(
    value.trim().toLowerCase()
  );
}
function sameUser(left, right) {
  if (!left || !right) return false;
  if (left.id !== void 0 && right.id !== void 0)
    return left.id === right.id;
  return left.login.trim().toLowerCase() === right.login.trim().toLowerCase();
}
function validateFindingCoverage(analysis, expectedFindings) {
  const actual = analysis.findings.map(findingKey);
  const expected = expectedFindings.map(findingKey);
  if (new Set(actual).size !== actual.length || actual.length !== expected.length || expected.some((key) => !actual.includes(key))) {
    throw new Error("review result must address every prepared finding once");
  }
  if (analysis.outcome === "fixed" && analysis.findings.some(
    (finding) => finding.disposition === "needs_approval"
  )) {
    throw new Error(
      "fixed review result cannot contain approval-gated findings"
    );
  }
  if (analysis.outcome === "no_change" && analysis.findings.some(
    (finding) => finding.disposition !== "not_reproducible"
  )) {
    throw new Error(
      "no_change review result requires every finding to be not reproducible"
    );
  }
}
function validateFixedReview(analysis, inspection) {
  if (!sanitizeTitle(analysis.commitTitle)) {
    throw new Error("fixed review result requires a commit title");
  }
  if (inspection.changedFiles.length === 0) {
    throw new Error("fixed review result requires a non-empty change");
  }
  if (!inspection.diffCheckPassed) {
    throw new Error("git diff --check rejected the review fix");
  }
  if (inspection.secretFindingPaths.length > 0) {
    throw new Error(
      `possible credential material detected in: ${inspection.secretFindingPaths.join(", ")}`
    );
  }
  if (analysis.validationOverride && !hasConsistentValidationOverride(analysis)) {
    throw new Error(
      "fixed review result has an inconsistent validation override"
    );
  }
  if (analysis.tests.some((test) => test.status === "failed") && !hasConsistentValidationOverride(analysis)) {
    throw new Error("fixed review result reports a failed validation command");
  }
}
async function finishWithoutPush2(repository, pullRequestNumber, reviewCursor, iterations, headSha, status, comments, dependencies) {
  if (dependencies.apply) {
    await upsertReviewState(
      repository,
      pullRequestNumber,
      { reviewCursor, iterations, headSha, status },
      comments,
      dependencies
    );
  }
  await dependencies.workspace.cleanupReview(repository, pullRequestNumber);
}
async function upsertReviewState(repository, pullRequestNumber, state, comments, dependencies) {
  const botLogin = dependencies.botLogin?.trim();
  if (!botLogin)
    throw new Error("Draft PR bot login is required in apply mode");
  const body = buildReviewFixComment(state);
  const existing = findReviewFixComment(comments, botLogin);
  if (existing) {
    await dependencies.provider.updateComment(
      repository,
      pullRequestNumber,
      existing.id,
      body
    );
  } else {
    await dependencies.provider.createComment(
      repository,
      pullRequestNumber,
      body
    );
  }
}
function reviewState(comments, dependencies) {
  const botLogin = dependencies.botLogin?.trim();
  if (!botLogin) return parseReviewFixState(void 0);
  return parseReviewFixState(findReviewFixComment(comments, botLogin));
}
function fingerprintFindings(findings) {
  return crypto4.createHash("sha256").update(
    JSON.stringify(
      findings.map(({ source, id, body, review, comment }) => ({
        source,
        id,
        body,
        author: (review?.user ?? comment?.user)?.login ?? "",
        authorId: (review?.user ?? comment?.user)?.id ?? null,
        ...review ? {
          state: review.state,
          commitId: review.commitId,
          authorAssociation: review.authorAssociation
        } : {},
        ...comment ? {
          path: comment.path,
          line: comment.line ?? null,
          originalLine: comment.originalLine ?? null,
          diffHunk: comment.diffHunk ?? "",
          commitId: comment.commitId ?? ""
        } : {}
      }))
    )
  ).digest("hex").slice(0, 20);
}
function toFinding({
  source,
  id,
  body,
  htmlUrl,
  createdAt,
  comment
}) {
  return {
    source,
    commentId: id,
    body: truncateText(body, 4e3),
    ...htmlUrl ? { htmlUrl } : {},
    ...createdAt ? { createdAt } : {},
    ...comment?.path ? { path: comment.path } : {},
    ...comment?.line !== void 0 ? { line: comment.line } : {},
    ...comment?.originalLine !== void 0 ? { originalLine: comment.originalLine } : {},
    ...comment?.startLine !== void 0 ? { startLine: comment.startLine } : {},
    ...comment?.originalStartLine !== void 0 ? { originalStartLine: comment.originalStartLine } : {},
    ...comment?.side ? { side: comment.side } : {},
    ...comment?.startSide ? { startSide: comment.startSide } : {},
    ...comment?.diffHunk ? { diffHunk: truncateText(comment.diffHunk, 8e3) } : {},
    ...comment?.commitId ? { commitId: comment.commitId } : {},
    ...comment?.originalCommitId ? { originalCommitId: comment.originalCommitId } : {},
    ...comment?.inReplyToId !== void 0 ? { inReplyToId: comment.inReplyToId } : {},
    ...comment?.pullRequestReviewId !== void 0 ? { pullRequestReviewId: comment.pullRequestReviewId } : {}
  };
}
function compareSourcedFindings(left, right) {
  const sourceOrder = { review: 0, review_comment: 1 };
  return sourceOrder[left.source] - sourceOrder[right.source] || left.id - right.id;
}
function findingKey(value) {
  const commentId = "id" in value ? value.id : value.commentId;
  return `${value.source}:${commentId}`;
}
function skipped2(repository, pullRequestNumber, reason) {
  return { ok: true, skipped: true, reason, repository, pullRequestNumber };
}
function requireReviewBotIdentity(dependencies) {
  if (dependencies.apply && !dependencies.botLogin?.trim()) {
    throw new Error("Draft PR bot login is required in apply mode");
  }
}

// src/runtime/target-binding.ts
function assertBoundTarget(options) {
  const expectedRepository = options.expectedRepository?.trim() ?? "";
  const expectedTargetText = options.expectedTarget?.trim() ?? "";
  if (!expectedRepository && !expectedTargetText) {
    if (options.apply) throw new Error(options.errors.missing);
    return;
  }
  if (!expectedRepository || !expectedTargetText) {
    throw new Error(options.errors.incomplete);
  }
  const expectedTarget = Number(expectedTargetText);
  if (!isRepositorySlug(expectedRepository) || !Number.isSafeInteger(expectedTarget) || expectedTarget <= 0) {
    throw new Error(options.errors.invalid);
  }
  if (options.repository !== expectedRepository || options.targetNumber !== expectedTarget) {
    throw new Error(
      options.errors.mismatch(expectedRepository, expectedTarget)
    );
  }
}

// src/draft-pr/target.ts
function assertBoundReviewTarget(repository, pullRequestNumber, apply, environment) {
  assertBoundTarget({
    repository,
    targetNumber: pullRequestNumber,
    apply,
    expectedRepository: environment.DRAFT_PR_EXPECTED_REPOSITORY,
    expectedTarget: environment.DRAFT_PR_EXPECTED_PULL_REQUEST,
    errors: {
      missing: "Draft PR review apply mode requires a scheduler-bound Pull Request target",
      incomplete: "incomplete scheduler-bound Draft PR review target",
      invalid: "invalid scheduler-bound Draft PR review target",
      mismatch: () => `requested Pull Request ${repository}#${pullRequestNumber} does not match the scheduler-bound review target`
    }
  });
}
function assertBoundDraftPrTarget(repository, issueNumber, apply, environment) {
  assertBoundTarget({
    repository,
    targetNumber: issueNumber,
    apply,
    expectedRepository: environment.DRAFT_PR_EXPECTED_REPOSITORY,
    expectedTarget: environment.DRAFT_PR_EXPECTED_ISSUE,
    errors: {
      missing: "Draft PR apply mode requires a scheduler-bound Issue target",
      incomplete: "incomplete scheduler-bound Draft PR target",
      invalid: "invalid scheduler-bound Draft PR target",
      mismatch: () => `requested Issue ${repository}#${issueNumber} does not match the scheduler-bound Draft PR target`
    }
  });
}

// src/issues/managed-comments.ts
var ISSUE_TRIAGE_COMMENT_PREFIX = "<!-- engineering-agent-workflows:issue-triage:v1";
function isIssueTriageComment(body) {
  return body.startsWith(ISSUE_TRIAGE_COMMENT_PREFIX);
}

// src/draft-pr/comment.ts
var DRAFT_PR_COMMENT_PREFIX = "<!-- engineering-agent-workflows:draft-pr:v1";
function draftPrCommentMarker(issueNumber) {
  return `${DRAFT_PR_COMMENT_PREFIX} issue=${issueNumber} -->`;
}
function findDraftPrComment(comments, botLogin) {
  const expected = botLogin.trim().toLowerCase();
  return comments.find(
    (comment) => comment.user?.login.trim().toLowerCase() === expected && comment.body.startsWith(DRAFT_PR_COMMENT_PREFIX)
  );
}
function buildDraftPrStatusComment(issueNumber, status, details = {}) {
  const lines = [draftPrCommentMarker(issueNumber), "## Draft PR agent", ""];
  if (status === "running") {
    lines.push("The repository development Agent has claimed this Issue.");
  } else if (status === "needs-approval") {
    lines.push("Implementation paused for maintainer approval.");
  } else if (status === "pr-open") {
    lines.push(
      details.pullRequestUrl ? `Draft Pull Request: ${details.pullRequestUrl}` : "A Draft Pull Request was created."
    );
  } else if (status === "dry-run") {
    lines.push("Dry run completed; no branch or Pull Request was created.");
  } else {
    lines.push(
      "The repository development Agent could not prepare a Draft PR."
    );
  }
  const reasons = (details.reasons ?? []).map(sanitizeFailureReason).filter(Boolean);
  if (reasons.length > 0) {
    lines.push("", "### Attention", "");
    for (const reason of reasons.slice(0, 8)) lines.push(`- ${reason}`);
  }
  const message = sanitizeLine(details.message ?? "");
  if (message) lines.push("", message);
  return lines.join("\n");
}
function sanitizeLine(value) {
  return value.replace(/<!--[\s\S]*?-->/g, "").replace(/[\r\n]+/g, " ").replace(/\s+/g, " ").trim().slice(0, 500);
}
function sanitizeFailureReason(value) {
  return sanitizeLine(value).replace(
    /\b(?:gh[pousr]_[A-Za-z0-9]{20,}|github_pat_[A-Za-z0-9_]{20,})\b/g,
    "<redacted-token>"
  ).replace(/(Authorization\s*:\s*)(?:Bearer|token)\s+\S+/gi, "$1<redacted>").replace(/(https?:\/\/)[^\s/@:]+:[^\s/@]+@/gi, "$1<redacted>@").replace(/([?&](?:access_token|token)=)[^&\s]+/gi, "$1<redacted>").slice(0, 500);
}

// src/draft-pr/tool.ts
async function prepareDraftPr(repository, issueNumber, trigger, dependencies) {
  assertAllowedRepository(repository, dependencies.allowedRepository);
  const issue2 = await dependencies.provider.getIssue(repository, issueNumber);
  const reason = ineligibleReason3(issue2, trigger, dependencies.policy);
  if (reason) {
    return {
      ok: true,
      skipped: true,
      reason,
      repository,
      issueNumber,
      trigger,
      approved: trigger === "approved"
    };
  }
  const branch = `${dependencies.policy.branchPrefix}${issueNumber}`;
  const existingPullRequests = await dependencies.provider.listOpenPullRequestsByHead(repository, branch);
  if (existingPullRequests.length > 0) {
    return {
      ok: true,
      skipped: true,
      reason: `an open Pull Request already exists for ${branch}`,
      repository,
      issueNumber,
      trigger,
      approved: trigger === "approved"
    };
  }
  const [baseBranch, comments] = await Promise.all([
    dependencies.provider.getRepositoryDefaultBranch(repository),
    dependencies.provider.listComments(repository, issueNumber)
  ]);
  const contextComments = selectContextComments(
    comments,
    dependencies.botLogin
  );
  const fingerprint = issueFingerprint(issue2, contextComments);
  let preparedWorkspace;
  try {
    preparedWorkspace = await dependencies.workspace.prepare({
      repository,
      issueNumber,
      cloneUrl: repositoryCloneUrl(dependencies.serverUrl, repository),
      baseBranch,
      branch
    });
    if (dependencies.apply) {
      const botLogin = requiredBotLogin(dependencies.botLogin);
      await claimIssue(
        repository,
        issueNumber,
        trigger,
        dependencies,
        botLogin
      );
    }
  } catch (error) {
    if (error instanceof DraftPrWorkspaceLockError) {
      return {
        ok: true,
        skipped: true,
        reason: error.message,
        repository,
        issueNumber,
        trigger,
        approved: trigger === "approved"
      };
    }
    await dependencies.workspace.cleanup(repository, issueNumber);
    throw error;
  }
  return {
    ok: true,
    repository,
    issueNumber,
    trigger,
    approved: trigger === "approved",
    issueFingerprint: fingerprint,
    issue: issue2,
    comments: contextComments,
    workspacePath: preparedWorkspace.path,
    branch: preparedWorkspace.branch,
    baseBranch: preparedWorkspace.baseBranch,
    baseCommit: preparedWorkspace.baseCommit
  };
}
async function applyDraftPr(repository, issueNumber, submissionInput, dependencies) {
  assertAllowedRepository(repository, dependencies.allowedRepository);
  const submission = draftPrSubmissionSchema.parse(submissionInput);
  const [issue2, comments] = await Promise.all([
    dependencies.provider.getIssue(repository, issueNumber),
    dependencies.provider.listComments(repository, issueNumber)
  ]);
  const contextComments = selectContextComments(
    comments,
    dependencies.botLogin
  );
  if (issueFingerprint(issue2, contextComments) !== submission.issueFingerprint) {
    throw new Error("Issue changed after the Draft PR Agent started");
  }
  if (issue2.state.toLowerCase() !== "open") {
    throw new Error("Issue is no longer open");
  }
  const inspection = await dependencies.workspace.inspect(
    submission.workspacePath
  );
  if (inspection.headCommit !== submission.baseCommit) {
    throw new Error(
      "the Agent committed or moved HEAD inside the prepared workspace"
    );
  }
  const analysis = submission.analysis;
  if (analysis.outcome !== "implemented") {
    const reasons = analysis.outcome === "needs_approval" ? outcomeReasons(analysis) : failureReasons(analysis);
    if (analysis.outcome === "needs_approval") {
      await transitionNeedsApproval(
        repository,
        issueNumber,
        reasons,
        dependencies
      );
    } else {
      await transitionFailed(repository, issueNumber, reasons, dependencies);
    }
    await dependencies.workspace.cleanup(repository, issueNumber);
    return {
      ok: true,
      repository,
      issueNumber,
      applied: dependencies.apply,
      outcome: analysis.outcome,
      branch: submission.branch,
      inspection
    };
  }
  validateImplementedAnalysis(analysis, inspection);
  const approvalReasons = requiresApproval(
    analysis,
    inspection,
    submission.trigger === "approved",
    dependencies.policy
  );
  if (approvalReasons.length > 0) {
    await transitionNeedsApproval(
      repository,
      issueNumber,
      approvalReasons,
      dependencies
    );
    await dependencies.workspace.cleanup(repository, issueNumber);
    return {
      ok: true,
      repository,
      issueNumber,
      applied: dependencies.apply,
      outcome: "needs_approval",
      branch: submission.branch,
      inspection
    };
  }
  const title = sanitizeTitle(analysis.prTitle);
  const body = buildPullRequestBody(issueNumber, analysis);
  if (!dependencies.apply) {
    await dependencies.workspace.cleanup(repository, issueNumber);
    return {
      ok: true,
      repository,
      issueNumber,
      applied: false,
      outcome: "implemented",
      branch: submission.branch,
      proposedTitle: title,
      proposedBody: body,
      inspection
    };
  }
  const commit = await dependencies.workspace.commitAndPush(
    submission.workspacePath,
    submission.branch,
    title,
    repositoryCloneUrl(dependencies.serverUrl, repository)
  );
  const pullRequest = await dependencies.provider.createDraftPullRequest(
    repository,
    {
      title,
      body,
      head: submission.branch,
      base: submission.baseBranch
    }
  );
  await transitionPullRequestOpen(
    repository,
    issueNumber,
    pullRequest.url,
    dependencies
  );
  await dependencies.workspace.cleanup(repository, issueNumber);
  return {
    ok: true,
    repository,
    issueNumber,
    applied: true,
    outcome: "implemented",
    branch: submission.branch,
    commit,
    pullRequestNumber: pullRequest.number,
    pullRequestUrl: pullRequest.url,
    inspection
  };
}
async function failDraftPr(repository, issueNumber, message, dependencies) {
  assertAllowedRepository(repository, dependencies.allowedRepository);
  try {
    if (dependencies.apply) {
      await transitionFailed(repository, issueNumber, [message], dependencies);
    }
  } finally {
    await dependencies.workspace.cleanup(repository, issueNumber);
  }
  return {
    ok: true,
    repository,
    issueNumber,
    applied: dependencies.apply,
    outcome: "failed"
  };
}
function ineligibleReason3(issue2, trigger, policy) {
  if (issue2.state.toLowerCase() !== "open") return "Issue is not open";
  if (hasAnyLabel(issue2.labels, policy.skipLabels)) {
    return "Issue has a configured skip label";
  }
  if (hasAnyLabel(issue2.labels, policy.blockedLabels)) {
    return "Issue has a label that blocks Draft PR execution";
  }
  const triggerLabel = trigger === "approved" ? policy.approvedLabel : policy.readyLabel;
  if (!hasLabel(issue2.labels, triggerLabel)) {
    return `Issue does not have ${triggerLabel}`;
  }
  if (trigger === "approved" && !hasLabel(issue2.labels, policy.needsApprovalLabel)) {
    return `Issue does not have ${policy.needsApprovalLabel}`;
  }
  return void 0;
}
async function claimIssue(repository, issueNumber, trigger, dependencies, botLogin) {
  const policy = dependencies.policy;
  await ensureWorkflowLabels(repository, [policy.runningLabel], dependencies);
  await dependencies.provider.addLabels(repository, issueNumber, [
    policy.runningLabel
  ]);
  await dependencies.provider.removeLabel(
    repository,
    issueNumber,
    trigger === "approved" ? policy.approvedLabel : policy.readyLabel
  );
  await dependencies.provider.removeLabel(
    repository,
    issueNumber,
    policy.failedLabel
  );
  if (trigger === "approved") {
    await dependencies.provider.removeLabel(
      repository,
      issueNumber,
      policy.needsApprovalLabel
    );
  }
  await upsertStatusComment(
    repository,
    issueNumber,
    buildDraftPrStatusComment(issueNumber, "running"),
    dependencies,
    botLogin
  );
}
async function transitionNeedsApproval(repository, issueNumber, reasons, dependencies) {
  if (!dependencies.apply) return;
  const botLogin = requiredBotLogin(dependencies.botLogin);
  const policy = dependencies.policy;
  await ensureWorkflowLabels(
    repository,
    [policy.needsApprovalLabel],
    dependencies
  );
  await dependencies.provider.addLabels(repository, issueNumber, [
    policy.needsApprovalLabel
  ]);
  await dependencies.provider.removeLabel(
    repository,
    issueNumber,
    policy.runningLabel
  );
  await upsertStatusComment(
    repository,
    issueNumber,
    buildDraftPrStatusComment(issueNumber, "needs-approval", { reasons }),
    dependencies,
    botLogin
  );
}
async function transitionFailed(repository, issueNumber, reasons, dependencies) {
  if (!dependencies.apply) return;
  const botLogin = requiredBotLogin(dependencies.botLogin);
  const policy = dependencies.policy;
  await ensureWorkflowLabels(repository, [policy.failedLabel], dependencies);
  await dependencies.provider.addLabels(repository, issueNumber, [
    policy.failedLabel
  ]);
  await dependencies.provider.removeLabel(
    repository,
    issueNumber,
    policy.runningLabel
  );
  await upsertStatusComment(
    repository,
    issueNumber,
    buildDraftPrStatusComment(issueNumber, "failed", { reasons }),
    dependencies,
    botLogin
  );
}
async function transitionPullRequestOpen(repository, issueNumber, pullRequestUrl, dependencies) {
  const botLogin = requiredBotLogin(dependencies.botLogin);
  const policy = dependencies.policy;
  await ensureWorkflowLabels(repository, [policy.prOpenLabel], dependencies);
  await dependencies.provider.addLabels(repository, issueNumber, [
    policy.prOpenLabel
  ]);
  await dependencies.provider.removeLabel(
    repository,
    issueNumber,
    policy.runningLabel
  );
  await upsertStatusComment(
    repository,
    issueNumber,
    buildDraftPrStatusComment(issueNumber, "pr-open", { pullRequestUrl }),
    dependencies,
    botLogin
  );
}
async function ensureWorkflowLabels(repository, labels, dependencies) {
  for (const label of labels) {
    await dependencies.provider.ensureLabel(
      repository,
      label,
      dependencies.policy.labelColors[label] ?? "ededed"
    );
  }
}
async function upsertStatusComment(repository, issueNumber, body, dependencies, botLogin) {
  const comments = await dependencies.provider.listComments(
    repository,
    issueNumber
  );
  const existing = findDraftPrComment(comments, botLogin);
  if (existing) {
    await dependencies.provider.updateComment(
      repository,
      issueNumber,
      existing.id,
      body
    );
  } else {
    await dependencies.provider.createComment(repository, issueNumber, body);
  }
}
function selectContextComments(comments, botLogin) {
  const expectedBot = botLogin?.trim().toLowerCase();
  return comments.filter((comment) => {
    const managedBot = expectedBot && comment.user?.login.trim().toLowerCase() === expectedBot;
    return !(managedBot && (comment.body.startsWith(DRAFT_PR_COMMENT_PREFIX) || isIssueTriageComment(comment.body)));
  }).sort((left, right) => left.id - right.id).slice(-50).map((comment) => ({
    ...comment,
    body: truncateText(comment.body, 4e3)
  }));
}
function validateImplementedAnalysis(analysis, inspection) {
  if (!sanitizeTitle(analysis.prTitle)) {
    throw new Error("implemented result requires a Pull Request title");
  }
  if (inspection.changedFiles.length === 0) {
    throw new Error(
      "implemented result requires a non-empty repository change"
    );
  }
  if (!inspection.diffCheckPassed) {
    throw new Error("git diff --check rejected the repository change");
  }
  if (inspection.secretFindingPaths.length > 0) {
    throw new Error(
      `possible credential material detected in: ${inspection.secretFindingPaths.join(", ")}`
    );
  }
  if (analysis.validationOverride && !hasConsistentValidationOverride(analysis)) {
    throw new Error(
      "implemented result has an inconsistent validation override"
    );
  }
  if (analysis.tests.some((test) => test.status === "failed") && !hasConsistentValidationOverride(analysis)) {
    throw new Error("implemented result reports a failed validation command");
  }
}
function outcomeReasons(analysis) {
  return [
    ...analysis.risk.reasons,
    ...analysis.notes,
    ...analysis.summary
  ].slice(0, 8);
}
function failureReasons(analysis) {
  const validationFailures = analysis.tests.filter((test) => test.status === "failed" || test.status === "not_run").map((test) => {
    const prefix = test.status === "failed" ? "Validation failed" : "Validation not run";
    return `${prefix}: ${test.command}${test.details ? ` \u2014 ${test.details}` : ""}`;
  });
  return [
    ...validationFailures,
    ...analysis.risk.reasons,
    ...analysis.notes,
    ...analysis.summary
  ].slice(0, 8);
}
function buildPullRequestBody(issueNumber, analysis) {
  const lines = [`Closes #${issueNumber}`, "", "## Summary", ""];
  for (const item of analysis.summary) lines.push(`- ${sanitizeLine2(item)}`);
  lines.push("", "## Validation", "");
  if (analysis.tests.length === 0) {
    lines.push("- Not reported.");
  } else {
    for (const test of analysis.tests) {
      lines.push(
        `- \`${sanitizeCode(test.command)}\` \u2014 ${test.status}${test.details ? `: ${sanitizeLine2(test.details)}` : ""}`
      );
    }
  }
  if (analysis.validationOverride) {
    lines.push(
      "",
      "## Validation override",
      "",
      `- Classification: \`${analysis.validationOverride.classification}\``,
      `- Source: \`${analysis.validationOverride.source}\``,
      `- Reason: ${sanitizeLine2(analysis.validationOverride.reason)}`
    );
  }
  lines.push("", "## Risk", "", `- Level: \`${analysis.risk.level}\``);
  for (const reason of analysis.risk.reasons) {
    lines.push(`- ${sanitizeLine2(reason)}`);
  }
  if (analysis.notes.length > 0) {
    lines.push("", "## Notes", "");
    for (const note of analysis.notes) lines.push(`- ${sanitizeLine2(note)}`);
  }
  lines.push(
    "",
    "_Prepared by the repository development Agent and opened as a Draft Pull Request for maintainer review._"
  );
  return lines.join("\n");
}
function sanitizeLine2(value) {
  return value.replace(/<!--[\s\S]*?-->/g, "").replace(/[\r\n]+/g, " ").replace(/\s+/g, " ").trim().slice(0, 500);
}
function sanitizeCode(value) {
  return sanitizeLine2(value).replace(/`/g, "'");
}
function requiredBotLogin(value) {
  const normalized = value?.trim();
  if (!normalized)
    throw new Error("Draft PR bot login is required in apply mode");
  return normalized;
}

// src/draft-pr/main.ts
async function main() {
  const options = parseArguments(process.argv.slice(2));
  const apply = envBoolean(process.env.DRAFT_PR_APPLY);
  const allowedRepository = process.env.DRAFT_PR_ALLOWED_REPOSITORY?.trim() || process.env.GITHUB_ALLOWED_REPOSITORY?.trim() || "";
  if (["prepare", "inspect-validation", "apply", "fail"].includes(options.command)) {
    assertBoundDraftPrTarget(
      options.repository,
      options.issueNumber,
      apply,
      process.env
    );
  } else {
    assertBoundReviewTarget(
      options.repository,
      options.pullRequestNumber,
      apply,
      process.env
    );
  }
  if (options.command === "inspect-validation") {
    assertAllowedRepository(options.repository, allowedRepository);
    const result2 = await fingerprintDraftPrWorkspace(
      process.env.DRAFT_PR_WORKSPACE_ROOT?.trim() || "/draft-pr-workspaces",
      options.workspacePath
    );
    process.stdout.write(`${JSON.stringify(result2, null, 2)}
`);
    return;
  }
  const policy = await loadPolicy();
  const token = await resolveGitHubToken(options.repository);
  const provider = new GitHubClient({
    ...token ? { token } : {},
    ...process.env.GITHUB_API_URL ? { baseUrl: process.env.GITHUB_API_URL } : {}
  });
  const workspace = new GitDraftPrWorkspace({
    root: process.env.DRAFT_PR_WORKSPACE_ROOT?.trim() || "/draft-pr-workspaces",
    token,
    authorName: process.env.DRAFT_PR_GIT_AUTHOR_NAME?.trim() || "engineering-agent-workflows",
    authorEmail: process.env.DRAFT_PR_GIT_AUTHOR_EMAIL?.trim() || "engineering-agent-workflows@users.noreply.github.com",
    ...process.env.DRAFT_PR_GIT_CURL_RESOLVE ? { gitCurlResolve: process.env.DRAFT_PR_GIT_CURL_RESOLVE } : {}
  });
  const dependencies = {
    provider,
    workspace,
    policy,
    allowedRepository,
    serverUrl: process.env.GITHUB_SERVER_URL?.trim() || "https://github.com",
    apply,
    ...process.env.GITHUB_BOT_LOGIN ? { botLogin: process.env.GITHUB_BOT_LOGIN } : {}
  };
  const result = options.command === "prepare" ? await prepareDraftPr(
    options.repository,
    options.issueNumber,
    options.trigger,
    dependencies
  ) : options.command === "apply" ? await applyDraftPr(
    options.repository,
    options.issueNumber,
    JSON.parse(
      await readFile2(options.analysisFile, "utf8")
    ),
    dependencies
  ) : options.command === "fail" ? await failDraftPr(
    options.repository,
    options.issueNumber,
    options.message ?? "Draft PR Agent execution failed",
    dependencies
  ) : options.command === "prepare-review" ? await prepareReviewFix(
    options.repository,
    options.pullRequestNumber,
    options.reviewId,
    dependencies
  ) : options.command === "apply-review" ? await applyReviewFix(
    options.repository,
    options.pullRequestNumber,
    JSON.parse(
      await readFile2(options.analysisFile, "utf8")
    ),
    dependencies
  ) : options.command === "fail-review" ? await failReviewFix(
    options.repository,
    options.pullRequestNumber,
    options.reviewCursor ?? 0,
    options.iterations ?? 0,
    options.headSha ?? "",
    dependencies
  ) : options.command === "prepare-ci" ? await prepareCiFix(
    options.repository,
    options.pullRequestNumber,
    options.headSha ?? "",
    options.checkSuiteId ?? 0,
    dependencies
  ) : options.command === "apply-ci" ? await applyCiFix(
    options.repository,
    options.pullRequestNumber,
    JSON.parse(
      await readFile2(options.analysisFile, "utf8")
    ),
    dependencies
  ) : await failCiFix(
    options.repository,
    options.pullRequestNumber,
    options.checkSuiteId ?? 0,
    options.attempts ?? 0,
    options.headSha ?? "",
    dependencies
  );
  process.stdout.write(`${JSON.stringify(result, null, 2)}
`);
}
async function loadPolicy() {
  const embedded = process.env.WORKFLOW_POLICY_JSON?.trim();
  if (embedded) {
    try {
      return draftPrPolicySchema.parse(JSON.parse(embedded));
    } catch (error) {
      throw new Error(
        `failed to load embedded Draft PR policy: ${errorMessage(error)}`
      );
    }
  }
  return loadJsonFromCandidates(
    [
      fileURLToPath(new URL("../policy.json", import.meta.url)),
      path2.resolve("agents/draft-pr/policy.json")
    ],
    (value) => draftPrPolicySchema.parse(value),
    "failed to load Draft PR policy"
  );
}
function parseArguments(args) {
  const command = args.shift();
  if (command !== "prepare" && command !== "inspect-validation" && command !== "apply" && command !== "fail" && command !== "prepare-review" && command !== "apply-review" && command !== "fail-review" && command !== "prepare-ci" && command !== "apply-ci" && command !== "fail-ci") {
    throw new Error("invalid Draft PR tool command");
  }
  let repository = "";
  let issueNumber = 0;
  let pullRequestNumber = 0;
  let trigger = "";
  let analysisFile = "";
  let message = "";
  let reviewId = 0;
  let reviewCursor = 0;
  let iterations = 0;
  let headSha = "";
  let checkSuiteId = 0;
  let attempts = 0;
  let workspacePath = "";
  for (let index = 0; index < args.length; index += 1) {
    const argument = args[index];
    if (argument === "--repository") {
      repository = requiredArgumentValue(args, ++index, argument);
    } else if (argument === "--issue") {
      issueNumber = Number(requiredArgumentValue(args, ++index, argument));
    } else if (argument === "--pull-request") {
      pullRequestNumber = Number(
        requiredArgumentValue(args, ++index, argument)
      );
    } else if (argument === "--trigger") {
      trigger = requiredArgumentValue(args, ++index, argument);
    } else if (argument === "--analysis") {
      analysisFile = requiredArgumentValue(args, ++index, argument);
    } else if (argument === "--message") {
      message = requiredArgumentValue(args, ++index, argument);
    } else if (argument === "--review") {
      reviewId = Number(requiredArgumentValue(args, ++index, argument));
    } else if (argument === "--review-cursor") {
      reviewCursor = Number(requiredArgumentValue(args, ++index, argument));
    } else if (argument === "--iterations") {
      iterations = Number(requiredArgumentValue(args, ++index, argument));
    } else if (argument === "--head") {
      headSha = requiredArgumentValue(args, ++index, argument);
    } else if (argument === "--check-suite") {
      checkSuiteId = Number(requiredArgumentValue(args, ++index, argument));
    } else if (argument === "--attempts") {
      attempts = Number(requiredArgumentValue(args, ++index, argument));
    } else if (argument === "--workspace") {
      workspacePath = requiredArgumentValue(args, ++index, argument);
    } else {
      throw new Error(`unknown argument: ${argument}`);
    }
  }
  if (!isRepositorySlug(repository)) {
    throw new Error("--repository must use owner/repository format");
  }
  if (["prepare", "inspect-validation", "apply", "fail"].includes(command) && (!Number.isSafeInteger(issueNumber) || issueNumber <= 0)) {
    throw new Error("--issue must be a positive integer");
  }
  if ([
    "prepare-review",
    "apply-review",
    "fail-review",
    "prepare-ci",
    "apply-ci",
    "fail-ci"
  ].includes(command) && (!Number.isSafeInteger(pullRequestNumber) || pullRequestNumber <= 0)) {
    throw new Error("--pull-request must be a positive integer");
  }
  if (command === "prepare" && trigger !== "ready" && trigger !== "approved") {
    throw new Error("prepare requires --trigger ready or approved");
  }
  if (command === "inspect-validation" && !workspacePath) {
    throw new Error("inspect-validation requires --workspace");
  }
  if (command === "prepare-review" && (!Number.isSafeInteger(reviewId) || reviewId <= 0)) {
    throw new Error("prepare-review requires --review");
  }
  if ((command === "apply" || command === "apply-review" || command === "apply-ci") && !analysisFile) {
    throw new Error(`${command} requires --analysis`);
  }
  return {
    command,
    repository,
    ...issueNumber ? { issueNumber } : {},
    ...pullRequestNumber ? { pullRequestNumber } : {},
    ...trigger === "ready" || trigger === "approved" ? { trigger } : {},
    ...analysisFile ? { analysisFile } : {},
    ...message ? { message } : {},
    ...reviewId ? { reviewId } : {},
    ...reviewCursor ? { reviewCursor } : {},
    ...iterations ? { iterations } : {},
    ...headSha ? { headSha } : {},
    ...Number.isSafeInteger(checkSuiteId) && checkSuiteId > 0 ? { checkSuiteId } : {},
    ...Number.isSafeInteger(attempts) && attempts >= 0 ? { attempts } : {},
    ...workspacePath ? { workspacePath } : {}
  };
}
main().catch((error) => {
  process.stderr.write(`draft-pr failed: ${errorMessage(error)}
`);
  process.exitCode = 1;
});
"; const WORKFLOW_POLICY_JSON = "{\"version\":1,\"readyLabel\":\"agent:ready\",\"approvedLabel\":\"agent:approved\",\"runningLabel\":\"agent:running\",\"needsApprovalLabel\":\"agent:needs-approval\",\"prOpenLabel\":\"agent:pr-open\",\"failedLabel\":\"agent:failed\",\"skipLabels\":[\"skip-triage\"],\"blockedLabels\":[\"duplicate\",\"agent:pr-open\",\"agent:running\"],\"branchPrefix\":\"codex/issue-\",\"maxChangedFiles\":40,\"maxChangedLines\":1500,\"maxReviewComments\":50,\"maxValidationFixIterations\":2,\"maxFixIterations\":3,\"requiredValidationGates\":[\"task-prepare\",\"task-lint\",\"task-test-unit\"],\"allowedValidationFailureCases\":[\"TestConfigStoreCRUDCoverageWorkflows\",\"TestIntegrationConfigStoreCRUDCoverageWorkflows\",\"TestE2EConfigStoreCRUDCoverageWorkflows\",\"runtime command execution > injects runtime path environment into user commands\"],\"approvalPathPrefixes\":[\".github/workflows/\",\"migrations/\",\"db/migrations/\",\"database/migrations/\",\"pkg/auth/\",\"src/auth/\",\"security/\",\"deploy/\",\"release/\"],\"labelColors\":{\"agent:ready\":\"1d76db\",\"agent:approved\":\"0e8a16\",\"agent:running\":\"fbca04\",\"agent:needs-approval\":\"d93f0b\",\"agent:pr-open\":\"5319e7\",\"agent:failed\":\"b60205\"}}"; -const WORKFLOW_TOOL_CHUNK_SIZE = 60000; +const WORKFLOW_TOOL_PATH = + "$WORKSPACE/workflow-repo/agents/draft-pr/tool/main.mjs"; const WORKSPACE_VOLUME = { type: "bind", source: "./.draft-pr-workspaces", @@ -14,19 +14,6 @@ const WORKSPACE_VOLUME = { readOnly: false, }; -function workflowToolEnvironment() { - const env = {}; - for ( - let offset = 0, index = 0; - offset < WORKFLOW_TOOL_BASE64.length; - offset += WORKFLOW_TOOL_CHUNK_SIZE, index += 1 - ) { - env[`WORKFLOW_TOOL_CHUNK_${String(index).padStart(4, "0")}`] = - WORKFLOW_TOOL_BASE64.slice(offset, offset + WORKFLOW_TOOL_CHUNK_SIZE); - } - return env; -} - function agentWorkspaceVolume(workspacePath) { const prefix = "/draft-pr-workspaces/repositories/"; if ( @@ -303,17 +290,12 @@ function validateAgentWorkspaceWithRetry(workspacePath) { function runDeterministicTool(script, env, label) { const result = scheduler.shell( - [ - "set -eu", - 'workflow_tool_dir="$(mktemp -d)"', - 'workflow_tool="$workflow_tool_dir/draft-pr.mjs"', - 'node -e \'const fs=require("node:fs"); const source=Object.keys(process.env).filter((key)=>key.startsWith("WORKFLOW_TOOL_CHUNK_")).sort().map((key)=>process.env[key]).join(""); fs.writeFileSync(process.argv[1], Buffer.from(source, "base64"))\' "$workflow_tool"', - 'export DRAFT_PR_TOOL="$workflow_tool"', - script, - ].join("\n"), + ["set -eu", `export DRAFT_PR_TOOL="${WORKFLOW_TOOL_PATH}"`, script].join( + "\n", + ), { sandboxPolicy: "new", - env: { ...env, WORKFLOW_POLICY_JSON, ...workflowToolEnvironment() }, + env: { ...env, WORKFLOW_POLICY_JSON }, volumes: [WORKSPACE_VOLUME], maxOutputBytes: 4 * 1024 * 1024, }, diff --git a/agents/draft-pr/tool/main.mjs b/agents/draft-pr/tool/main.mjs new file mode 100644 index 0000000..00ad31a --- /dev/null +++ b/agents/draft-pr/tool/main.mjs @@ -0,0 +1,7957 @@ +// Generated by scripts/build-tools.ts. Do not edit directly. +var __defProp = Object.defineProperty; +var __export = (target, all) => { + for (var name in all) + __defProp(target, name, { get: all[name], enumerable: true }); +}; + +// src/draft-pr/main.ts +import { readFile as readFile2 } from "node:fs/promises"; +import path2 from "node:path"; +import { fileURLToPath } from "node:url"; + +// src/github/app-auth.ts +import { sign } from "node:crypto"; + +// src/github/fetch-retry.ts +var MAX_ATTEMPTS = 3; +var RETRYABLE_STATUS_CODES = /* @__PURE__ */ new Set([502, 503, 504]); +async function fetchWithRetry(options) { + const attempts = options.retryable ? MAX_ATTEMPTS : 1; + let lastError; + for (let attempt = 1; attempt <= attempts; attempt += 1) { + try { + const response = await options.request(options.input, options.init); + if (attempt === attempts || !RETRYABLE_STATUS_CODES.has(response.status)) { + return response; + } + await response.body?.cancel().catch(() => void 0); + } catch (error) { + lastError = error; + if (attempt === attempts) { + throw new Error( + `${options.operation} transport failed after ${attemptLabel(attempts)}`, + { cause: error } + ); + } + } + await (options.sleep ?? sleep)(retryDelayMilliseconds(attempt)); + } + throw new Error(`${options.operation} transport failed`, { + cause: lastError + }); +} +function attemptLabel(attempts) { + return `${attempts} ${attempts === 1 ? "attempt" : "attempts"}`; +} +function retryDelayMilliseconds(attempt) { + const exponential = 250 * 2 ** (attempt - 1); + return exponential + Math.floor(Math.random() * exponential); +} +function sleep(milliseconds) { + return new Promise((resolve) => setTimeout(resolve, milliseconds)); +} + +// src/github/app-auth.ts +var DEFAULT_GITHUB_API_URL = "https://api.github.com"; +var GITHUB_API_VERSION = "2022-11-28"; +async function resolveGitHubToken(repository, env = process.env, dependencies = {}) { + const configuredToken = env.GITHUB_TOKEN?.trim() ?? ""; + if (configuredToken) return configuredToken; + const clientID = env.GITHUB_APP_CLIENT_ID?.trim() ?? ""; + const appID = env.GITHUB_APP_ID?.trim() ?? ""; + const privateKeyBase64 = env.GITHUB_APP_PRIVATE_KEY_BASE64?.trim() ?? ""; + const configuredInstallationID = env.GITHUB_APP_INSTALLATION_ID?.trim() ?? ""; + const hasAppConfiguration = Boolean( + clientID || appID || privateKeyBase64 || configuredInstallationID + ); + if (!hasAppConfiguration) return ""; + const issuer = clientID || appID; + if (!issuer) { + throw new Error( + "GitHub App authentication requires GITHUB_APP_CLIENT_ID or GITHUB_APP_ID" + ); + } + if (!privateKeyBase64) { + throw new Error( + "GitHub App authentication requires GITHUB_APP_PRIVATE_KEY_BASE64" + ); + } + const privateKey = decodePrivateKey(privateKeyBase64); + const jwt = createAppJWT( + issuer, + privateKey, + dependencies.now?.() ?? Date.now() + ); + const baseUrl = (env.GITHUB_API_URL?.trim() || DEFAULT_GITHUB_API_URL).replace(/\/+$/, ""); + const request = dependencies.fetch ?? fetch; + const installationID = configuredInstallationID ? validateInstallationID(configuredInstallationID) : await findInstallationID( + baseUrl, + repository, + jwt, + request, + dependencies.sleep + ); + const tokenPath = `/app/installations/${installationID}/access_tokens`; + const response = await fetchWithRetry({ + request, + input: `${baseUrl}${tokenPath}`, + init: { + method: "POST", + headers: appHeaders(jwt) + }, + operation: `GitHub App POST ${tokenPath}`, + retryable: true, + ...dependencies.sleep ? { sleep: dependencies.sleep } : {} + }); + if (!response.ok) { + throw githubAppResponseError("installation token request", response); + } + const value = await response.json(); + const token = value.token?.trim() ?? ""; + if (!token) { + throw new Error("GitHub App installation token response has no token"); + } + return token; +} +function createAppJWT(issuer, privateKey, nowMilliseconds) { + const now = Math.floor(nowMilliseconds / 1e3); + const header = encodeJWTPart({ alg: "RS256", typ: "JWT" }); + const payload = encodeJWTPart({ + iat: now - 60, + exp: now + 9 * 60, + iss: issuer + }); + const unsignedToken = `${header}.${payload}`; + let signature; + try { + signature = sign("RSA-SHA256", Buffer.from(unsignedToken), privateKey); + } catch { + throw new Error( + "GITHUB_APP_PRIVATE_KEY_BASE64 is not a valid RSA private key" + ); + } + return `${unsignedToken}.${signature.toString("base64url")}`; +} +async function findInstallationID(baseUrl, repository, jwt, request, sleepDependency) { + const path3 = `/repos/${repositoryPath(repository)}/installation`; + const response = await fetchWithRetry({ + request, + input: `${baseUrl}${path3}`, + init: { + method: "GET", + headers: appHeaders(jwt) + }, + operation: `GitHub App GET ${path3}`, + retryable: true, + ...sleepDependency ? { sleep: sleepDependency } : {} + }); + if (!response.ok) { + throw githubAppResponseError("installation lookup", response); + } + const value = await response.json(); + if (!Number.isSafeInteger(value.id) || (value.id ?? 0) <= 0) { + throw new Error("GitHub App installation response has no valid ID"); + } + return String(value.id); +} +function appHeaders(jwt) { + return { + Accept: "application/vnd.github+json", + Authorization: `Bearer ${jwt}`, + "X-GitHub-Api-Version": GITHUB_API_VERSION, + "User-Agent": "engineering-agent-workflows/github-app-auth" + }; +} +function decodePrivateKey(value) { + let decoded; + try { + decoded = Buffer.from(value, "base64").toString("utf8").trim(); + } catch { + throw new Error("GITHUB_APP_PRIVATE_KEY_BASE64 is not valid base64"); + } + if (!/^-----BEGIN (?:RSA )?PRIVATE KEY-----/.test(decoded)) { + throw new Error( + "GITHUB_APP_PRIVATE_KEY_BASE64 must decode to a PEM private key" + ); + } + return decoded; +} +function validateInstallationID(value) { + if (!/^[1-9][0-9]*$/.test(value)) { + throw new Error("GITHUB_APP_INSTALLATION_ID must be a positive integer"); + } + return value; +} +function repositoryPath(repository) { + const parts = repository.split("/"); + if (parts.length !== 2 || parts.some((part) => !part.trim())) { + throw new Error(`invalid GitHub repository: ${repository}`); + } + return parts.map(encodeURIComponent).join("/"); +} +function encodeJWTPart(value) { + return Buffer.from(JSON.stringify(value)).toString("base64url"); +} +function githubAppResponseError(operation, response) { + const status = `${response.status}${response.statusText ? ` ${response.statusText}` : ""}`; + return new Error(`GitHub App ${operation} failed with ${status}`); +} + +// src/issues/search.ts +function issueSearchText(title) { + return title.replace(/^\[[^\]]+\]\s*:?\s*/, "").replace(/["'`:+(){}[\]\\]/g, " ").replace(/\s+/g, " ").trim().slice(0, 120); +} + +// src/runtime/text.ts +function truncateText(value, max) { + return value.length <= max ? value : value.slice(0, max); +} + +// src/github/client.ts +var GitHubClient = class { + #token; + #baseUrl; + #fetch; + #sleep; + constructor(options = {}) { + this.#token = options.token?.trim() ?? ""; + this.#baseUrl = (options.baseUrl ?? "https://api.github.com").replace( + /\/+$/, + "" + ); + this.#fetch = options.fetch ?? fetch; + this.#sleep = options.sleep; + } + async getIssue(repository, issueNumber) { + const issue2 = await this.#request( + "GET", + `/repos/${repositoryPath2(repository)}/issues/${issueNumber}` + ); + if (issue2.pull_request) { + throw new Error("GitHub pull request payload is not an Issue"); + } + return normalizeIssue(issue2); + } + async searchCandidates(repository, issue2, limit) { + const title = issueSearchText(issue2.title); + if (!title) return []; + const query = new URLSearchParams({ + q: `repo:${repository} is:issue in:title ${title}`, + per_page: String(Math.min(Math.max(limit + 1, 1), 100)) + }); + const response = await this.#request( + "GET", + `/search/issues?${query.toString()}` + ); + return (response.items ?? []).filter( + (candidate) => candidate.number !== issue2.number && !candidate.pull_request + ).slice(0, limit).map((candidate) => ({ + number: candidate.number, + title: candidate.title, + body: truncateText(candidate.body ?? "", 4e3), + state: candidate.state, + labels: labelNames(candidate.labels), + url: candidate.html_url + })); + } + async listComments(repository, issueNumber) { + const comments = []; + for (let page = 1; ; page += 1) { + const batch = await this.#request( + "GET", + `/repos/${repositoryPath2(repository)}/issues/${issueNumber}/comments?per_page=100&page=${page}` + ); + comments.push(...batch.map(normalizeComment)); + if (batch.length < 100) return comments; + } + } + async ensureLabel(repository, name, color, description) { + const path3 = `/repos/${repositoryPath2(repository)}/labels/${encodeURIComponent(name)}`; + const response = await this.#rawRequest("GET", path3); + if (response.ok) return; + if (response.status !== 404) { + throw await responseError("GET", path3, response); + } + await this.#request("POST", `/repos/${repositoryPath2(repository)}/labels`, { + name, + color: normalizeColor(color), + description: description?.trim() || "Managed by engineering-agent-workflows" + }); + } + async getRepositoryDefaultBranch(repository) { + const value = await this.#request( + "GET", + `/repos/${repositoryPath2(repository)}` + ); + const branch = value.default_branch?.trim(); + if (!branch) throw new Error("GitHub repository has no default branch"); + return branch; + } + async getPullRequest(repository, pullRequestNumber) { + const value = await this.#request( + "GET", + `/repos/${repositoryPath2(repository)}/pulls/${pullRequestNumber}` + ); + return normalizePullRequest(value); + } + async listOpenPullRequests(repository) { + const values = []; + for (let page = 1; ; page += 1) { + const batch = await this.#request( + "GET", + `/repos/${repositoryPath2(repository)}/pulls?state=open&per_page=100&page=${page}` + ); + values.push(...batch.map(normalizePullRequest)); + if (batch.length < 100) return values; + } + } + async listReviewComments(repository, pullRequestNumber) { + const comments = []; + for (let page = 1; ; page += 1) { + const batch = await this.#request( + "GET", + `/repos/${repositoryPath2(repository)}/pulls/${pullRequestNumber}/comments?per_page=100&page=${page}` + ); + comments.push(...batch.map(normalizeReviewComment)); + if (batch.length < 100) return comments; + } + } + async getPullRequestReview(repository, pullRequestNumber, reviewId) { + const review = await this.#request( + "GET", + `/repos/${repositoryPath2(repository)}/pulls/${pullRequestNumber}/reviews/${reviewId}` + ); + return normalizePullRequestReview(review); + } + async listCheckRuns(repository, ref) { + if (!/^[0-9a-f]{40}$/.test(ref)) { + throw new Error("invalid GitHub check run ref"); + } + const runs = []; + for (let page = 1; ; page += 1) { + const value = await this.#request( + "GET", + `/repos/${repositoryPath2(repository)}/commits/${ref}/check-runs?per_page=100&page=${page}` + ); + const batch = value.check_runs ?? []; + runs.push(...batch.map(normalizeCheckRun)); + if (batch.length < 100) return runs; + } + } + async listCheckRunAnnotations(repository, checkRunId) { + if (!Number.isSafeInteger(checkRunId) || checkRunId <= 0) { + throw new Error("invalid GitHub check run ID"); + } + const annotations = []; + for (let page = 1; ; page += 1) { + const batch = await this.#request( + "GET", + `/repos/${repositoryPath2(repository)}/check-runs/${checkRunId}/annotations?per_page=100&page=${page}` + ); + annotations.push(...batch.map(normalizeCheckRunAnnotation)); + if (batch.length < 100) return annotations; + } + } + async listOpenPullRequestsByHead(repository, branch) { + const owner = repository.split("/")[0]; + const query = new URLSearchParams({ + state: "open", + head: `${owner}:${branch}`, + per_page: "100" + }); + const values = await this.#request( + "GET", + `/repos/${repositoryPath2(repository)}/pulls?${query.toString()}` + ); + return values.map(normalizePullRequest); + } + async createDraftPullRequest(repository, input) { + const value = await this.#request( + "POST", + `/repos/${repositoryPath2(repository)}/pulls`, + { ...input, draft: true } + ); + return normalizePullRequest(value); + } + async addLabels(repository, issueNumber, labels) { + if (labels.length === 0) return; + await this.#request( + "POST", + `/repos/${repositoryPath2(repository)}/issues/${issueNumber}/labels`, + { labels } + ); + } + async removeLabel(repository, issueNumber, label) { + const path3 = `/repos/${repositoryPath2(repository)}/issues/${issueNumber}/labels/${encodeURIComponent(label)}`; + const response = await this.#rawRequest("DELETE", path3); + if (!response.ok && response.status !== 404) { + throw await responseError("DELETE", path3, response); + } + } + async createComment(repository, issueNumber, body) { + const comment = await this.#request( + "POST", + `/repos/${repositoryPath2(repository)}/issues/${issueNumber}/comments`, + { body } + ); + return normalizeComment(comment); + } + async updateComment(repository, _issueNumber, commentID, body) { + const comment = await this.#request( + "PATCH", + `/repos/${repositoryPath2(repository)}/issues/comments/${commentID}`, + { body } + ); + return normalizeComment(comment); + } + async #request(method, path3, body) { + const response = await this.#rawRequest(method, path3, body); + if (!response.ok) throw await responseError(method, path3, response); + return await response.json(); + } + #rawRequest(method, path3, body) { + const headers = { + Accept: "application/vnd.github+json", + "X-GitHub-Api-Version": "2022-11-28", + "User-Agent": "engineering-agent-workflows/issue-triage" + }; + if (this.#token) headers.Authorization = `Bearer ${this.#token}`; + if (body !== void 0) headers["Content-Type"] = "application/json"; + return fetchWithRetry({ + request: this.#fetch, + input: `${this.#baseUrl}${path3}`, + init: { + method, + headers, + ...body === void 0 ? {} : { body: JSON.stringify(body) } + }, + operation: `GitHub API ${method} ${path3}`, + retryable: method === "GET", + ...this.#sleep ? { sleep: this.#sleep } : {} + }); + } +}; +function repositoryPath2(repository) { + const parts = repository.split("/"); + if (parts.length !== 2 || parts.some((part) => !part.trim())) { + throw new Error(`invalid GitHub repository: ${repository}`); + } + return parts.map(encodeURIComponent).join("/"); +} +function normalizeIssue(issue2) { + return { + number: issue2.number, + title: issue2.title, + body: issue2.body, + state: issue2.state, + htmlUrl: issue2.html_url, + updatedAt: issue2.updated_at, + labels: labelNames(issue2.labels), + ...issue2.user ? { user: normalizeUser(issue2.user) } : {} + }; +} +function normalizeComment(comment) { + return { + id: comment.id, + body: comment.body, + ...comment.html_url ? { htmlUrl: comment.html_url } : {}, + ...comment.created_at ? { createdAt: comment.created_at } : {}, + ...comment.user ? { user: normalizeUser(comment.user) } : {} + }; +} +function normalizePullRequest(value) { + return { + number: value.number, + url: value.html_url, + state: value.state, + draft: value.draft ?? false, + head: value.head.ref, + ...value.head.sha ? { headSha: value.head.sha } : {}, + ...value.head.repo?.full_name ? { headRepository: value.head.repo.full_name } : {}, + base: value.base.ref + }; +} +function normalizeReviewComment(comment) { + return { + id: comment.id, + body: comment.body, + path: comment.path, + ...comment.user ? { user: normalizeUser(comment.user) } : {}, + ...comment.html_url ? { htmlUrl: comment.html_url } : {}, + ...comment.created_at ? { createdAt: comment.created_at } : {}, + ...comment.line != null ? { line: comment.line } : {}, + ...comment.original_line != null ? { originalLine: comment.original_line } : {}, + ...comment.start_line != null ? { startLine: comment.start_line } : {}, + ...comment.original_start_line != null ? { originalStartLine: comment.original_start_line } : {}, + ...comment.side ? { side: comment.side } : {}, + ...comment.start_side ? { startSide: comment.start_side } : {}, + ...comment.diff_hunk ? { diffHunk: comment.diff_hunk } : {}, + ...comment.commit_id ? { commitId: comment.commit_id } : {}, + ...comment.original_commit_id ? { originalCommitId: comment.original_commit_id } : {}, + ...comment.in_reply_to_id !== void 0 ? { inReplyToId: comment.in_reply_to_id } : {}, + ...comment.pull_request_review_id !== void 0 ? { pullRequestReviewId: comment.pull_request_review_id } : {} + }; +} +function normalizePullRequestReview(review) { + return { + id: review.id, + body: review.body ?? "", + state: review.state, + commitId: review.commit_id, + authorAssociation: review.author_association, + ...review.user ? { user: normalizeUser(review.user) } : {}, + ...review.html_url ? { htmlUrl: review.html_url } : {}, + ...review.submitted_at ? { submittedAt: review.submitted_at } : {} + }; +} +function normalizeCheckRun(value) { + const checkSuiteId = value.check_suite?.id; + if (!Number.isSafeInteger(checkSuiteId) || checkSuiteId <= 0) { + throw new Error(`GitHub check run ${value.id} has no valid check suite ID`); + } + return { + id: value.id, + checkSuiteId, + name: truncateText(value.name ?? "", 300), + status: value.status, + ...value.conclusion ? { conclusion: value.conclusion } : {}, + ...value.html_url ? { htmlUrl: value.html_url } : {}, + output: { + title: truncateText(value.output?.title ?? "", 1e3), + summary: truncateText(value.output?.summary ?? "", 8e3), + text: truncateText(value.output?.text ?? "", 8e3) + } + }; +} +function normalizeCheckRunAnnotation(value) { + return { + path: truncateText(value.path ?? "", 1e3), + startLine: value.start_line, + endLine: value.end_line, + level: truncateText(value.annotation_level ?? "", 50), + message: truncateText(value.message ?? "", 2e3), + ...value.title ? { title: truncateText(value.title, 500) } : {}, + ...value.raw_details ? { rawDetails: truncateText(value.raw_details, 4e3) } : {} + }; +} +function normalizeUser(user) { + return { + login: user.login, + ...user.id !== void 0 ? { id: user.id } : {}, + ...user.type ? { type: user.type } : {} + }; +} +function labelNames(labels) { + return labels.map((label) => typeof label === "string" ? label : label.name).filter((label) => label.trim() !== ""); +} +function normalizeColor(color) { + const normalized = color.trim().replace(/^#/, ""); + return /^[0-9a-f]{6}$/i.test(normalized) ? normalized : "ededed"; +} +async function responseError(method, path3, response) { + const text = await response.text().catch(() => ""); + return new Error( + `GitHub API ${method} ${path3} failed with HTTP ${response.status}: ${truncateText(text, 1e3)}` + ); +} + +// src/issues/types.ts +function isRepositorySlug(value) { + return /^[^/\s]+\/[^/\s]+$/.test(value); +} + +// src/runtime/cli.ts +function requiredArgumentValue(args, index, name) { + const value = args[index]?.trim(); + if (!value) throw new Error(`${name} requires a value`); + return value; +} +function envBoolean(value) { + return ["1", "true", "yes", "on"].includes(value?.trim().toLowerCase() ?? ""); +} + +// src/runtime/errors.ts +function errorMessage(error) { + return describeError(error, /* @__PURE__ */ new Set(), 0); +} +function describeError(error, seen, depth) { + if (!(error instanceof Error)) return String(error); + seen.add(error); + const code = errorCode(error); + const description = depth === 0 ? error.message : `${error.name}${code ? ` [${code}]` : ""}: ${error.message}`; + if (depth >= 4 || error.cause === void 0 || seen.has(error.cause)) { + return description; + } + return `${description}; cause: ${describeError(error.cause, seen, depth + 1)}`; +} +function errorCode(error) { + if (!("code" in error)) return ""; + const value = error.code; + return typeof value === "string" || typeof value === "number" ? String(value) : ""; +} + +// src/runtime/load-json.ts +import { readFile } from "node:fs/promises"; +async function loadJsonFromCandidates(candidates, parse3, failureMessage) { + let lastError; + for (const candidate of candidates) { + try { + return parse3(JSON.parse(await readFile(candidate, "utf8"))); + } catch (error) { + lastError = error; + } + } + throw new Error(`${failureMessage}: ${errorMessage(lastError)}`); +} + +// src/draft-pr/ci-tool.ts +import crypto3 from "node:crypto"; + +// src/draft-pr/ci-comment.ts +var CI_FIX_COMMENT_PREFIX = "$/ + ); + if (!match) return emptyCiFixState(); + return { + checkSuiteId: Number(match[1]), + attempts: Number(match[2]), + headSha: match[3] === "none" ? "" : match[3], + status: match[4] + }; +} +function buildCiFixComment(state) { + const marker = `${CI_FIX_COMMENT_PREFIX} suite=${state.checkSuiteId} attempts=${state.attempts} head=${state.headSha || "none"} status=${state.status} -->`; + const messages = { + fixing: "The Draft PR Agent is validating the latest failed CI checks.", + fixed: "The Draft PR Agent pushed a validated fix for the failed CI checks.", + "no-change": "The Draft PR Agent inspected the failed CI checks and made no code change.", + "needs-approval": "Automatic CI fixes paused for maintainer review.", + failed: "The Draft PR Agent could not complete the latest CI fix attempt." + }; + return [marker, "## CI follow-up", "", messages[state.status]].join("\n"); +} +function emptyCiFixState() { + return { + checkSuiteId: 0, + attempts: 0, + headSha: "", + status: "fixed" + }; +} + +// node_modules/zod/v4/core/core.js +var _a; +// @__NO_SIDE_EFFECTS__ +function $constructor(name, initializer3, params) { + function init(inst, def) { + if (!inst._zod) { + Object.defineProperty(inst, "_zod", { + value: { + def, + constr: _, + traits: /* @__PURE__ */ new Set() + }, + enumerable: false + }); + } + if (inst._zod.traits.has(name)) { + return; + } + inst._zod.traits.add(name); + initializer3(inst, def); + const proto = _.prototype; + const keys = Object.keys(proto); + for (let i = 0; i < keys.length; i++) { + const k = keys[i]; + if (!(k in inst)) { + inst[k] = proto[k].bind(inst); + } + } + } + const Parent = params?.Parent ?? Object; + class Definition extends Parent { + } + Object.defineProperty(Definition, "name", { value: name }); + function _(def) { + var _a3; + const inst = params?.Parent ? new Definition() : this; + init(inst, def); + (_a3 = inst._zod).deferred ?? (_a3.deferred = []); + for (const fn of inst._zod.deferred) { + fn(); + } + return inst; + } + Object.defineProperty(_, "init", { value: init }); + Object.defineProperty(_, Symbol.hasInstance, { + value: (inst) => { + if (params?.Parent && inst instanceof params.Parent) + return true; + return inst?._zod?.traits?.has(name); + } + }); + Object.defineProperty(_, "name", { value: name }); + return _; +} +var $ZodAsyncError = class extends Error { + constructor() { + super(`Encountered Promise during synchronous parse. Use .parseAsync() instead.`); + } +}; +var $ZodEncodeError = class extends Error { + constructor(name) { + super(`Encountered unidirectional transform during encode: ${name}`); + this.name = "ZodEncodeError"; + } +}; +(_a = globalThis).__zod_globalConfig ?? (_a.__zod_globalConfig = {}); +var globalConfig = globalThis.__zod_globalConfig; +function config(newConfig) { + if (newConfig) + Object.assign(globalConfig, newConfig); + return globalConfig; +} + +// node_modules/zod/v4/core/util.js +var util_exports = {}; +__export(util_exports, { + BIGINT_FORMAT_RANGES: () => BIGINT_FORMAT_RANGES, + Class: () => Class, + NUMBER_FORMAT_RANGES: () => NUMBER_FORMAT_RANGES, + aborted: () => aborted, + allowsEval: () => allowsEval, + assert: () => assert, + assertEqual: () => assertEqual, + assertIs: () => assertIs, + assertNever: () => assertNever, + assertNotEqual: () => assertNotEqual, + assignProp: () => assignProp, + base64ToUint8Array: () => base64ToUint8Array, + base64urlToUint8Array: () => base64urlToUint8Array, + cached: () => cached, + captureStackTrace: () => captureStackTrace, + cleanEnum: () => cleanEnum, + cleanRegex: () => cleanRegex, + clone: () => clone, + cloneDef: () => cloneDef, + createTransparentProxy: () => createTransparentProxy, + defineLazy: () => defineLazy, + esc: () => esc, + escapeRegex: () => escapeRegex, + explicitlyAborted: () => explicitlyAborted, + extend: () => extend, + finalizeIssue: () => finalizeIssue, + floatSafeRemainder: () => floatSafeRemainder, + getElementAtPath: () => getElementAtPath, + getEnumValues: () => getEnumValues, + getLengthableOrigin: () => getLengthableOrigin, + getParsedType: () => getParsedType, + getSizableOrigin: () => getSizableOrigin, + hexToUint8Array: () => hexToUint8Array, + isObject: () => isObject, + isPlainObject: () => isPlainObject, + issue: () => issue, + joinValues: () => joinValues, + jsonStringifyReplacer: () => jsonStringifyReplacer, + merge: () => merge, + mergeDefs: () => mergeDefs, + normalizeParams: () => normalizeParams, + nullish: () => nullish, + numKeys: () => numKeys, + objectClone: () => objectClone, + omit: () => omit, + optionalKeys: () => optionalKeys, + parsedType: () => parsedType, + partial: () => partial, + pick: () => pick, + prefixIssues: () => prefixIssues, + primitiveTypes: () => primitiveTypes, + promiseAllObject: () => promiseAllObject, + propertyKeyTypes: () => propertyKeyTypes, + randomString: () => randomString, + required: () => required, + safeExtend: () => safeExtend, + shallowClone: () => shallowClone, + slugify: () => slugify, + stringifyPrimitive: () => stringifyPrimitive, + uint8ArrayToBase64: () => uint8ArrayToBase64, + uint8ArrayToBase64url: () => uint8ArrayToBase64url, + uint8ArrayToHex: () => uint8ArrayToHex, + unwrapMessage: () => unwrapMessage +}); +function assertEqual(val) { + return val; +} +function assertNotEqual(val) { + return val; +} +function assertIs(_arg) { +} +function assertNever(_x) { + throw new Error("Unexpected value in exhaustive check"); +} +function assert(_) { +} +function getEnumValues(entries) { + const numericValues = Object.values(entries).filter((v) => typeof v === "number"); + const values = Object.entries(entries).filter(([k, _]) => numericValues.indexOf(+k) === -1).map(([_, v]) => v); + return values; +} +function joinValues(array2, separator = "|") { + return array2.map((val) => stringifyPrimitive(val)).join(separator); +} +function jsonStringifyReplacer(_, value) { + if (typeof value === "bigint") + return value.toString(); + return value; +} +function cached(getter) { + const set = false; + return { + get value() { + if (!set) { + const value = getter(); + Object.defineProperty(this, "value", { value }); + return value; + } + throw new Error("cached value already set"); + } + }; +} +function nullish(input) { + return input === null || input === void 0; +} +function cleanRegex(source) { + const start = source.startsWith("^") ? 1 : 0; + const end = source.endsWith("$") ? source.length - 1 : source.length; + return source.slice(start, end); +} +function floatSafeRemainder(val, step) { + const ratio = val / step; + const roundedRatio = Math.round(ratio); + const tolerance = Number.EPSILON * Math.max(Math.abs(ratio), 1); + if (Math.abs(ratio - roundedRatio) < tolerance) + return 0; + return ratio - roundedRatio; +} +var EVALUATING = /* @__PURE__ */ Symbol("evaluating"); +function defineLazy(object2, key, getter) { + let value = void 0; + Object.defineProperty(object2, key, { + get() { + if (value === EVALUATING) { + return void 0; + } + if (value === void 0) { + value = EVALUATING; + value = getter(); + } + return value; + }, + set(v) { + Object.defineProperty(object2, key, { + value: v + // configurable: true, + }); + }, + configurable: true + }); +} +function objectClone(obj) { + return Object.create(Object.getPrototypeOf(obj), Object.getOwnPropertyDescriptors(obj)); +} +function assignProp(target, prop, value) { + Object.defineProperty(target, prop, { + value, + writable: true, + enumerable: true, + configurable: true + }); +} +function mergeDefs(...defs) { + const mergedDescriptors = {}; + for (const def of defs) { + const descriptors = Object.getOwnPropertyDescriptors(def); + Object.assign(mergedDescriptors, descriptors); + } + return Object.defineProperties({}, mergedDescriptors); +} +function cloneDef(schema) { + return mergeDefs(schema._zod.def); +} +function getElementAtPath(obj, path3) { + if (!path3) + return obj; + return path3.reduce((acc, key) => acc?.[key], obj); +} +function promiseAllObject(promisesObj) { + const keys = Object.keys(promisesObj); + const promises = keys.map((key) => promisesObj[key]); + return Promise.all(promises).then((results) => { + const resolvedObj = {}; + for (let i = 0; i < keys.length; i++) { + resolvedObj[keys[i]] = results[i]; + } + return resolvedObj; + }); +} +function randomString(length = 10) { + const chars = "abcdefghijklmnopqrstuvwxyz"; + let str = ""; + for (let i = 0; i < length; i++) { + str += chars[Math.floor(Math.random() * chars.length)]; + } + return str; +} +function esc(str) { + return JSON.stringify(str); +} +function slugify(input) { + return input.toLowerCase().trim().replace(/[^\w\s-]/g, "").replace(/[\s_-]+/g, "-").replace(/^-+|-+$/g, ""); +} +var captureStackTrace = "captureStackTrace" in Error ? Error.captureStackTrace : (..._args) => { +}; +function isObject(data) { + return typeof data === "object" && data !== null && !Array.isArray(data); +} +var allowsEval = /* @__PURE__ */ cached(() => { + if (globalConfig.jitless) { + return false; + } + if (typeof navigator !== "undefined" && navigator?.userAgent?.includes("Cloudflare")) { + return false; + } + try { + const F = Function; + new F(""); + return true; + } catch (_) { + return false; + } +}); +function isPlainObject(o) { + if (isObject(o) === false) + return false; + const ctor = o.constructor; + if (ctor === void 0) + return true; + if (typeof ctor !== "function") + return true; + const prot = ctor.prototype; + if (isObject(prot) === false) + return false; + if (Object.prototype.hasOwnProperty.call(prot, "isPrototypeOf") === false) { + return false; + } + return true; +} +function shallowClone(o) { + if (isPlainObject(o)) + return { ...o }; + if (Array.isArray(o)) + return [...o]; + if (o instanceof Map) + return new Map(o); + if (o instanceof Set) + return new Set(o); + return o; +} +function numKeys(data) { + let keyCount = 0; + for (const key in data) { + if (Object.prototype.hasOwnProperty.call(data, key)) { + keyCount++; + } + } + return keyCount; +} +var getParsedType = (data) => { + const t = typeof data; + switch (t) { + case "undefined": + return "undefined"; + case "string": + return "string"; + case "number": + return Number.isNaN(data) ? "nan" : "number"; + case "boolean": + return "boolean"; + case "function": + return "function"; + case "bigint": + return "bigint"; + case "symbol": + return "symbol"; + case "object": + if (Array.isArray(data)) { + return "array"; + } + if (data === null) { + return "null"; + } + if (data.then && typeof data.then === "function" && data.catch && typeof data.catch === "function") { + return "promise"; + } + if (typeof Map !== "undefined" && data instanceof Map) { + return "map"; + } + if (typeof Set !== "undefined" && data instanceof Set) { + return "set"; + } + if (typeof Date !== "undefined" && data instanceof Date) { + return "date"; + } + if (typeof File !== "undefined" && data instanceof File) { + return "file"; + } + return "object"; + default: + throw new Error(`Unknown data type: ${t}`); + } +}; +var propertyKeyTypes = /* @__PURE__ */ new Set(["string", "number", "symbol"]); +var primitiveTypes = /* @__PURE__ */ new Set([ + "string", + "number", + "bigint", + "boolean", + "symbol", + "undefined" +]); +function escapeRegex(str) { + return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"); +} +function clone(inst, def, params) { + const cl = new inst._zod.constr(def ?? inst._zod.def); + if (!def || params?.parent) + cl._zod.parent = inst; + return cl; +} +function normalizeParams(_params) { + const params = _params; + if (!params) + return {}; + if (typeof params === "string") + return { error: () => params }; + if (params?.message !== void 0) { + if (params?.error !== void 0) + throw new Error("Cannot specify both `message` and `error` params"); + params.error = params.message; + } + delete params.message; + if (typeof params.error === "string") + return { ...params, error: () => params.error }; + return params; +} +function createTransparentProxy(getter) { + let target; + return new Proxy({}, { + get(_, prop, receiver) { + target ?? (target = getter()); + return Reflect.get(target, prop, receiver); + }, + set(_, prop, value, receiver) { + target ?? (target = getter()); + return Reflect.set(target, prop, value, receiver); + }, + has(_, prop) { + target ?? (target = getter()); + return Reflect.has(target, prop); + }, + deleteProperty(_, prop) { + target ?? (target = getter()); + return Reflect.deleteProperty(target, prop); + }, + ownKeys(_) { + target ?? (target = getter()); + return Reflect.ownKeys(target); + }, + getOwnPropertyDescriptor(_, prop) { + target ?? (target = getter()); + return Reflect.getOwnPropertyDescriptor(target, prop); + }, + defineProperty(_, prop, descriptor) { + target ?? (target = getter()); + return Reflect.defineProperty(target, prop, descriptor); + } + }); +} +function stringifyPrimitive(value) { + if (typeof value === "bigint") + return value.toString() + "n"; + if (typeof value === "string") + return `"${value}"`; + return `${value}`; +} +function optionalKeys(shape) { + return Object.keys(shape).filter((k) => { + return shape[k]._zod.optin === "optional" && shape[k]._zod.optout === "optional"; + }); +} +var NUMBER_FORMAT_RANGES = { + safeint: [Number.MIN_SAFE_INTEGER, Number.MAX_SAFE_INTEGER], + int32: [-2147483648, 2147483647], + uint32: [0, 4294967295], + float32: [-34028234663852886e22, 34028234663852886e22], + float64: [-Number.MAX_VALUE, Number.MAX_VALUE] +}; +var BIGINT_FORMAT_RANGES = { + int64: [/* @__PURE__ */ BigInt("-9223372036854775808"), /* @__PURE__ */ BigInt("9223372036854775807")], + uint64: [/* @__PURE__ */ BigInt(0), /* @__PURE__ */ BigInt("18446744073709551615")] +}; +function pick(schema, mask) { + const currDef = schema._zod.def; + const checks = currDef.checks; + const hasChecks = checks && checks.length > 0; + if (hasChecks) { + throw new Error(".pick() cannot be used on object schemas containing refinements"); + } + const def = mergeDefs(schema._zod.def, { + get shape() { + const newShape = {}; + for (const key in mask) { + if (!(key in currDef.shape)) { + throw new Error(`Unrecognized key: "${key}"`); + } + if (!mask[key]) + continue; + newShape[key] = currDef.shape[key]; + } + assignProp(this, "shape", newShape); + return newShape; + }, + checks: [] + }); + return clone(schema, def); +} +function omit(schema, mask) { + const currDef = schema._zod.def; + const checks = currDef.checks; + const hasChecks = checks && checks.length > 0; + if (hasChecks) { + throw new Error(".omit() cannot be used on object schemas containing refinements"); + } + const def = mergeDefs(schema._zod.def, { + get shape() { + const newShape = { ...schema._zod.def.shape }; + for (const key in mask) { + if (!(key in currDef.shape)) { + throw new Error(`Unrecognized key: "${key}"`); + } + if (!mask[key]) + continue; + delete newShape[key]; + } + assignProp(this, "shape", newShape); + return newShape; + }, + checks: [] + }); + return clone(schema, def); +} +function extend(schema, shape) { + if (!isPlainObject(shape)) { + throw new Error("Invalid input to extend: expected a plain object"); + } + const checks = schema._zod.def.checks; + const hasChecks = checks && checks.length > 0; + if (hasChecks) { + const existingShape = schema._zod.def.shape; + for (const key in shape) { + if (Object.getOwnPropertyDescriptor(existingShape, key) !== void 0) { + throw new Error("Cannot overwrite keys on object schemas containing refinements. Use `.safeExtend()` instead."); + } + } + } + const def = mergeDefs(schema._zod.def, { + get shape() { + const _shape = { ...schema._zod.def.shape, ...shape }; + assignProp(this, "shape", _shape); + return _shape; + } + }); + return clone(schema, def); +} +function safeExtend(schema, shape) { + if (!isPlainObject(shape)) { + throw new Error("Invalid input to safeExtend: expected a plain object"); + } + const def = mergeDefs(schema._zod.def, { + get shape() { + const _shape = { ...schema._zod.def.shape, ...shape }; + assignProp(this, "shape", _shape); + return _shape; + } + }); + return clone(schema, def); +} +function merge(a, b) { + if (a._zod.def.checks?.length) { + throw new Error(".merge() cannot be used on object schemas containing refinements. Use .safeExtend() instead."); + } + const def = mergeDefs(a._zod.def, { + get shape() { + const _shape = { ...a._zod.def.shape, ...b._zod.def.shape }; + assignProp(this, "shape", _shape); + return _shape; + }, + get catchall() { + return b._zod.def.catchall; + }, + checks: b._zod.def.checks ?? [] + }); + return clone(a, def); +} +function partial(Class2, schema, mask) { + const currDef = schema._zod.def; + const checks = currDef.checks; + const hasChecks = checks && checks.length > 0; + if (hasChecks) { + throw new Error(".partial() cannot be used on object schemas containing refinements"); + } + const def = mergeDefs(schema._zod.def, { + get shape() { + const oldShape = schema._zod.def.shape; + const shape = { ...oldShape }; + if (mask) { + for (const key in mask) { + if (!(key in oldShape)) { + throw new Error(`Unrecognized key: "${key}"`); + } + if (!mask[key]) + continue; + shape[key] = Class2 ? new Class2({ + type: "optional", + innerType: oldShape[key] + }) : oldShape[key]; + } + } else { + for (const key in oldShape) { + shape[key] = Class2 ? new Class2({ + type: "optional", + innerType: oldShape[key] + }) : oldShape[key]; + } + } + assignProp(this, "shape", shape); + return shape; + }, + checks: [] + }); + return clone(schema, def); +} +function required(Class2, schema, mask) { + const def = mergeDefs(schema._zod.def, { + get shape() { + const oldShape = schema._zod.def.shape; + const shape = { ...oldShape }; + if (mask) { + for (const key in mask) { + if (!(key in shape)) { + throw new Error(`Unrecognized key: "${key}"`); + } + if (!mask[key]) + continue; + shape[key] = new Class2({ + type: "nonoptional", + innerType: oldShape[key] + }); + } + } else { + for (const key in oldShape) { + shape[key] = new Class2({ + type: "nonoptional", + innerType: oldShape[key] + }); + } + } + assignProp(this, "shape", shape); + return shape; + } + }); + return clone(schema, def); +} +function aborted(x, startIndex = 0) { + if (x.aborted === true) + return true; + for (let i = startIndex; i < x.issues.length; i++) { + if (x.issues[i]?.continue !== true) { + return true; + } + } + return false; +} +function explicitlyAborted(x, startIndex = 0) { + if (x.aborted === true) + return true; + for (let i = startIndex; i < x.issues.length; i++) { + if (x.issues[i]?.continue === false) { + return true; + } + } + return false; +} +function prefixIssues(path3, issues) { + return issues.map((iss) => { + var _a3; + (_a3 = iss).path ?? (_a3.path = []); + iss.path.unshift(path3); + return iss; + }); +} +function unwrapMessage(message) { + return typeof message === "string" ? message : message?.message; +} +function finalizeIssue(iss, ctx, config2) { + const message = iss.message ? iss.message : unwrapMessage(iss.inst?._zod.def?.error?.(iss)) ?? unwrapMessage(ctx?.error?.(iss)) ?? unwrapMessage(config2.customError?.(iss)) ?? unwrapMessage(config2.localeError?.(iss)) ?? "Invalid input"; + const { inst: _inst, continue: _continue, input: _input, ...rest } = iss; + rest.path ?? (rest.path = []); + rest.message = message; + if (ctx?.reportInput) { + rest.input = _input; + } + return rest; +} +function getSizableOrigin(input) { + if (input instanceof Set) + return "set"; + if (input instanceof Map) + return "map"; + if (input instanceof File) + return "file"; + return "unknown"; +} +function getLengthableOrigin(input) { + if (Array.isArray(input)) + return "array"; + if (typeof input === "string") + return "string"; + return "unknown"; +} +function parsedType(data) { + const t = typeof data; + switch (t) { + case "number": { + return Number.isNaN(data) ? "nan" : "number"; + } + case "object": { + if (data === null) { + return "null"; + } + if (Array.isArray(data)) { + return "array"; + } + const obj = data; + if (obj && Object.getPrototypeOf(obj) !== Object.prototype && "constructor" in obj && obj.constructor) { + return obj.constructor.name; + } + } + } + return t; +} +function issue(...args) { + const [iss, input, inst] = args; + if (typeof iss === "string") { + return { + message: iss, + code: "custom", + input, + inst + }; + } + return { ...iss }; +} +function cleanEnum(obj) { + return Object.entries(obj).filter(([k, _]) => { + return Number.isNaN(Number.parseInt(k, 10)); + }).map((el) => el[1]); +} +function base64ToUint8Array(base642) { + const binaryString = atob(base642); + const bytes = new Uint8Array(binaryString.length); + for (let i = 0; i < binaryString.length; i++) { + bytes[i] = binaryString.charCodeAt(i); + } + return bytes; +} +function uint8ArrayToBase64(bytes) { + let binaryString = ""; + for (let i = 0; i < bytes.length; i++) { + binaryString += String.fromCharCode(bytes[i]); + } + return btoa(binaryString); +} +function base64urlToUint8Array(base64url2) { + const base642 = base64url2.replace(/-/g, "+").replace(/_/g, "/"); + const padding = "=".repeat((4 - base642.length % 4) % 4); + return base64ToUint8Array(base642 + padding); +} +function uint8ArrayToBase64url(bytes) { + return uint8ArrayToBase64(bytes).replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, ""); +} +function hexToUint8Array(hex) { + const cleanHex = hex.replace(/^0x/, ""); + if (cleanHex.length % 2 !== 0) { + throw new Error("Invalid hex string length"); + } + const bytes = new Uint8Array(cleanHex.length / 2); + for (let i = 0; i < cleanHex.length; i += 2) { + bytes[i / 2] = Number.parseInt(cleanHex.slice(i, i + 2), 16); + } + return bytes; +} +function uint8ArrayToHex(bytes) { + return Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join(""); +} +var Class = class { + constructor(..._args) { + } +}; + +// node_modules/zod/v4/core/errors.js +var initializer = (inst, def) => { + inst.name = "$ZodError"; + Object.defineProperty(inst, "_zod", { + value: inst._zod, + enumerable: false + }); + Object.defineProperty(inst, "issues", { + value: def, + enumerable: false + }); + inst.message = JSON.stringify(def, jsonStringifyReplacer, 2); + Object.defineProperty(inst, "toString", { + value: () => inst.message, + enumerable: false + }); +}; +var $ZodError = $constructor("$ZodError", initializer); +var $ZodRealError = $constructor("$ZodError", initializer, { Parent: Error }); +function flattenError(error, mapper = (issue2) => issue2.message) { + const fieldErrors = {}; + const formErrors = []; + for (const sub of error.issues) { + if (sub.path.length > 0) { + fieldErrors[sub.path[0]] = fieldErrors[sub.path[0]] || []; + fieldErrors[sub.path[0]].push(mapper(sub)); + } else { + formErrors.push(mapper(sub)); + } + } + return { formErrors, fieldErrors }; +} +function formatError(error, mapper = (issue2) => issue2.message) { + const fieldErrors = { _errors: [] }; + const processError = (error2, path3 = []) => { + for (const issue2 of error2.issues) { + if (issue2.code === "invalid_union" && issue2.errors.length) { + issue2.errors.map((issues) => processError({ issues }, [...path3, ...issue2.path])); + } else if (issue2.code === "invalid_key") { + processError({ issues: issue2.issues }, [...path3, ...issue2.path]); + } else if (issue2.code === "invalid_element") { + processError({ issues: issue2.issues }, [...path3, ...issue2.path]); + } else { + const fullpath = [...path3, ...issue2.path]; + if (fullpath.length === 0) { + fieldErrors._errors.push(mapper(issue2)); + } else { + let curr = fieldErrors; + let i = 0; + while (i < fullpath.length) { + const el = fullpath[i]; + const terminal = i === fullpath.length - 1; + if (!terminal) { + curr[el] = curr[el] || { _errors: [] }; + } else { + curr[el] = curr[el] || { _errors: [] }; + curr[el]._errors.push(mapper(issue2)); + } + curr = curr[el]; + i++; + } + } + } + } + }; + processError(error); + return fieldErrors; +} + +// node_modules/zod/v4/core/parse.js +var _parse = (_Err) => (schema, value, _ctx, _params) => { + const ctx = _ctx ? { ..._ctx, async: false } : { async: false }; + const result = schema._zod.run({ value, issues: [] }, ctx); + if (result instanceof Promise) { + throw new $ZodAsyncError(); + } + if (result.issues.length) { + const e = new (_params?.Err ?? _Err)(result.issues.map((iss) => finalizeIssue(iss, ctx, config()))); + captureStackTrace(e, _params?.callee); + throw e; + } + return result.value; +}; +var _parseAsync = (_Err) => async (schema, value, _ctx, params) => { + const ctx = _ctx ? { ..._ctx, async: true } : { async: true }; + let result = schema._zod.run({ value, issues: [] }, ctx); + if (result instanceof Promise) + result = await result; + if (result.issues.length) { + const e = new (params?.Err ?? _Err)(result.issues.map((iss) => finalizeIssue(iss, ctx, config()))); + captureStackTrace(e, params?.callee); + throw e; + } + return result.value; +}; +var _safeParse = (_Err) => (schema, value, _ctx) => { + const ctx = _ctx ? { ..._ctx, async: false } : { async: false }; + const result = schema._zod.run({ value, issues: [] }, ctx); + if (result instanceof Promise) { + throw new $ZodAsyncError(); + } + return result.issues.length ? { + success: false, + error: new (_Err ?? $ZodError)(result.issues.map((iss) => finalizeIssue(iss, ctx, config()))) + } : { success: true, data: result.value }; +}; +var safeParse = /* @__PURE__ */ _safeParse($ZodRealError); +var _safeParseAsync = (_Err) => async (schema, value, _ctx) => { + const ctx = _ctx ? { ..._ctx, async: true } : { async: true }; + let result = schema._zod.run({ value, issues: [] }, ctx); + if (result instanceof Promise) + result = await result; + return result.issues.length ? { + success: false, + error: new _Err(result.issues.map((iss) => finalizeIssue(iss, ctx, config()))) + } : { success: true, data: result.value }; +}; +var safeParseAsync = /* @__PURE__ */ _safeParseAsync($ZodRealError); +var _encode = (_Err) => (schema, value, _ctx) => { + const ctx = _ctx ? { ..._ctx, direction: "backward" } : { direction: "backward" }; + return _parse(_Err)(schema, value, ctx); +}; +var _decode = (_Err) => (schema, value, _ctx) => { + return _parse(_Err)(schema, value, _ctx); +}; +var _encodeAsync = (_Err) => async (schema, value, _ctx) => { + const ctx = _ctx ? { ..._ctx, direction: "backward" } : { direction: "backward" }; + return _parseAsync(_Err)(schema, value, ctx); +}; +var _decodeAsync = (_Err) => async (schema, value, _ctx) => { + return _parseAsync(_Err)(schema, value, _ctx); +}; +var _safeEncode = (_Err) => (schema, value, _ctx) => { + const ctx = _ctx ? { ..._ctx, direction: "backward" } : { direction: "backward" }; + return _safeParse(_Err)(schema, value, ctx); +}; +var _safeDecode = (_Err) => (schema, value, _ctx) => { + return _safeParse(_Err)(schema, value, _ctx); +}; +var _safeEncodeAsync = (_Err) => async (schema, value, _ctx) => { + const ctx = _ctx ? { ..._ctx, direction: "backward" } : { direction: "backward" }; + return _safeParseAsync(_Err)(schema, value, ctx); +}; +var _safeDecodeAsync = (_Err) => async (schema, value, _ctx) => { + return _safeParseAsync(_Err)(schema, value, _ctx); +}; + +// node_modules/zod/v4/core/regexes.js +var cuid = /^[cC][0-9a-z]{6,}$/; +var cuid2 = /^[0-9a-z]+$/; +var ulid = /^[0-9A-HJKMNP-TV-Za-hjkmnp-tv-z]{26}$/; +var xid = /^[0-9a-vA-V]{20}$/; +var ksuid = /^[A-Za-z0-9]{27}$/; +var nanoid = /^[a-zA-Z0-9_-]{21}$/; +var duration = /^P(?:(\d+W)|(?!.*W)(?=\d|T\d)(\d+Y)?(\d+M)?(\d+D)?(T(?=\d)(\d+H)?(\d+M)?(\d+([.,]\d+)?S)?)?)$/; +var guid = /^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12})$/; +var uuid = (version2) => { + if (!version2) + return /^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-8][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$/; + return new RegExp(`^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-${version2}[0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12})$`); +}; +var email = /^(?!\.)(?!.*\.\.)([A-Za-z0-9_'+\-\.]*)[A-Za-z0-9_+-]@([A-Za-z0-9][A-Za-z0-9\-]*\.)+[A-Za-z]{2,}$/; +var _emoji = `^(\\p{Extended_Pictographic}|\\p{Emoji_Component})+$`; +function emoji() { + return new RegExp(_emoji, "u"); +} +var ipv4 = /^(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])$/; +var ipv6 = /^(([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:))$/; +var cidrv4 = /^((25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\/([0-9]|[1-2][0-9]|3[0-2])$/; +var cidrv6 = /^(([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}|::|([0-9a-fA-F]{1,4})?::([0-9a-fA-F]{1,4}:?){0,6})\/(12[0-8]|1[01][0-9]|[1-9]?[0-9])$/; +var base64 = /^$|^(?:[0-9a-zA-Z+/]{4})*(?:(?:[0-9a-zA-Z+/]{2}==)|(?:[0-9a-zA-Z+/]{3}=))?$/; +var base64url = /^[A-Za-z0-9_-]*$/; +var httpProtocol = /^https?$/; +var e164 = /^\+[1-9]\d{6,14}$/; +var dateSource = `(?:(?:\\d\\d[2468][048]|\\d\\d[13579][26]|\\d\\d0[48]|[02468][048]00|[13579][26]00)-02-29|\\d{4}-(?:(?:0[13578]|1[02])-(?:0[1-9]|[12]\\d|3[01])|(?:0[469]|11)-(?:0[1-9]|[12]\\d|30)|(?:02)-(?:0[1-9]|1\\d|2[0-8])))`; +var date = /* @__PURE__ */ new RegExp(`^${dateSource}$`); +function timeSource(args) { + const hhmm = `(?:[01]\\d|2[0-3]):[0-5]\\d`; + const regex = typeof args.precision === "number" ? args.precision === -1 ? `${hhmm}` : args.precision === 0 ? `${hhmm}:[0-5]\\d` : `${hhmm}:[0-5]\\d\\.\\d{${args.precision}}` : `${hhmm}(?::[0-5]\\d(?:\\.\\d+)?)?`; + return regex; +} +function time(args) { + return new RegExp(`^${timeSource(args)}$`); +} +function datetime(args) { + const time3 = timeSource({ precision: args.precision }); + const opts = ["Z"]; + if (args.local) + opts.push(""); + if (args.offset) + opts.push(`([+-](?:[01]\\d|2[0-3]):[0-5]\\d)`); + const timeRegex = `${time3}(?:${opts.join("|")})`; + return new RegExp(`^${dateSource}T(?:${timeRegex})$`); +} +var string = (params) => { + const regex = params ? `[\\s\\S]{${params?.minimum ?? 0},${params?.maximum ?? ""}}` : `[\\s\\S]*`; + return new RegExp(`^${regex}$`); +}; +var integer = /^-?\d+$/; +var number = /^-?\d+(?:\.\d+)?$/; +var lowercase = /^[^A-Z]*$/; +var uppercase = /^[^a-z]*$/; + +// node_modules/zod/v4/core/checks.js +var $ZodCheck = /* @__PURE__ */ $constructor("$ZodCheck", (inst, def) => { + var _a3; + inst._zod ?? (inst._zod = {}); + inst._zod.def = def; + (_a3 = inst._zod).onattach ?? (_a3.onattach = []); +}); +var numericOriginMap = { + number: "number", + bigint: "bigint", + object: "date" +}; +var $ZodCheckLessThan = /* @__PURE__ */ $constructor("$ZodCheckLessThan", (inst, def) => { + $ZodCheck.init(inst, def); + const origin = numericOriginMap[typeof def.value]; + inst._zod.onattach.push((inst2) => { + const bag = inst2._zod.bag; + const curr = (def.inclusive ? bag.maximum : bag.exclusiveMaximum) ?? Number.POSITIVE_INFINITY; + if (def.value < curr) { + if (def.inclusive) + bag.maximum = def.value; + else + bag.exclusiveMaximum = def.value; + } + }); + inst._zod.check = (payload) => { + if (def.inclusive ? payload.value <= def.value : payload.value < def.value) { + return; + } + payload.issues.push({ + origin, + code: "too_big", + maximum: typeof def.value === "object" ? def.value.getTime() : def.value, + input: payload.value, + inclusive: def.inclusive, + inst, + continue: !def.abort + }); + }; +}); +var $ZodCheckGreaterThan = /* @__PURE__ */ $constructor("$ZodCheckGreaterThan", (inst, def) => { + $ZodCheck.init(inst, def); + const origin = numericOriginMap[typeof def.value]; + inst._zod.onattach.push((inst2) => { + const bag = inst2._zod.bag; + const curr = (def.inclusive ? bag.minimum : bag.exclusiveMinimum) ?? Number.NEGATIVE_INFINITY; + if (def.value > curr) { + if (def.inclusive) + bag.minimum = def.value; + else + bag.exclusiveMinimum = def.value; + } + }); + inst._zod.check = (payload) => { + if (def.inclusive ? payload.value >= def.value : payload.value > def.value) { + return; + } + payload.issues.push({ + origin, + code: "too_small", + minimum: typeof def.value === "object" ? def.value.getTime() : def.value, + input: payload.value, + inclusive: def.inclusive, + inst, + continue: !def.abort + }); + }; +}); +var $ZodCheckMultipleOf = /* @__PURE__ */ $constructor("$ZodCheckMultipleOf", (inst, def) => { + $ZodCheck.init(inst, def); + inst._zod.onattach.push((inst2) => { + var _a3; + (_a3 = inst2._zod.bag).multipleOf ?? (_a3.multipleOf = def.value); + }); + inst._zod.check = (payload) => { + if (typeof payload.value !== typeof def.value) + throw new Error("Cannot mix number and bigint in multiple_of check."); + const isMultiple = typeof payload.value === "bigint" ? payload.value % def.value === BigInt(0) : floatSafeRemainder(payload.value, def.value) === 0; + if (isMultiple) + return; + payload.issues.push({ + origin: typeof payload.value, + code: "not_multiple_of", + divisor: def.value, + input: payload.value, + inst, + continue: !def.abort + }); + }; +}); +var $ZodCheckNumberFormat = /* @__PURE__ */ $constructor("$ZodCheckNumberFormat", (inst, def) => { + $ZodCheck.init(inst, def); + def.format = def.format || "float64"; + const isInt = def.format?.includes("int"); + const origin = isInt ? "int" : "number"; + const [minimum, maximum] = NUMBER_FORMAT_RANGES[def.format]; + inst._zod.onattach.push((inst2) => { + const bag = inst2._zod.bag; + bag.format = def.format; + bag.minimum = minimum; + bag.maximum = maximum; + if (isInt) + bag.pattern = integer; + }); + inst._zod.check = (payload) => { + const input = payload.value; + if (isInt) { + if (!Number.isInteger(input)) { + payload.issues.push({ + expected: origin, + format: def.format, + code: "invalid_type", + continue: false, + input, + inst + }); + return; + } + if (!Number.isSafeInteger(input)) { + if (input > 0) { + payload.issues.push({ + input, + code: "too_big", + maximum: Number.MAX_SAFE_INTEGER, + note: "Integers must be within the safe integer range.", + inst, + origin, + inclusive: true, + continue: !def.abort + }); + } else { + payload.issues.push({ + input, + code: "too_small", + minimum: Number.MIN_SAFE_INTEGER, + note: "Integers must be within the safe integer range.", + inst, + origin, + inclusive: true, + continue: !def.abort + }); + } + return; + } + } + if (input < minimum) { + payload.issues.push({ + origin: "number", + input, + code: "too_small", + minimum, + inclusive: true, + inst, + continue: !def.abort + }); + } + if (input > maximum) { + payload.issues.push({ + origin: "number", + input, + code: "too_big", + maximum, + inclusive: true, + inst, + continue: !def.abort + }); + } + }; +}); +var $ZodCheckMaxLength = /* @__PURE__ */ $constructor("$ZodCheckMaxLength", (inst, def) => { + var _a3; + $ZodCheck.init(inst, def); + (_a3 = inst._zod.def).when ?? (_a3.when = (payload) => { + const val = payload.value; + return !nullish(val) && val.length !== void 0; + }); + inst._zod.onattach.push((inst2) => { + const curr = inst2._zod.bag.maximum ?? Number.POSITIVE_INFINITY; + if (def.maximum < curr) + inst2._zod.bag.maximum = def.maximum; + }); + inst._zod.check = (payload) => { + const input = payload.value; + const length = input.length; + if (length <= def.maximum) + return; + const origin = getLengthableOrigin(input); + payload.issues.push({ + origin, + code: "too_big", + maximum: def.maximum, + inclusive: true, + input, + inst, + continue: !def.abort + }); + }; +}); +var $ZodCheckMinLength = /* @__PURE__ */ $constructor("$ZodCheckMinLength", (inst, def) => { + var _a3; + $ZodCheck.init(inst, def); + (_a3 = inst._zod.def).when ?? (_a3.when = (payload) => { + const val = payload.value; + return !nullish(val) && val.length !== void 0; + }); + inst._zod.onattach.push((inst2) => { + const curr = inst2._zod.bag.minimum ?? Number.NEGATIVE_INFINITY; + if (def.minimum > curr) + inst2._zod.bag.minimum = def.minimum; + }); + inst._zod.check = (payload) => { + const input = payload.value; + const length = input.length; + if (length >= def.minimum) + return; + const origin = getLengthableOrigin(input); + payload.issues.push({ + origin, + code: "too_small", + minimum: def.minimum, + inclusive: true, + input, + inst, + continue: !def.abort + }); + }; +}); +var $ZodCheckLengthEquals = /* @__PURE__ */ $constructor("$ZodCheckLengthEquals", (inst, def) => { + var _a3; + $ZodCheck.init(inst, def); + (_a3 = inst._zod.def).when ?? (_a3.when = (payload) => { + const val = payload.value; + return !nullish(val) && val.length !== void 0; + }); + inst._zod.onattach.push((inst2) => { + const bag = inst2._zod.bag; + bag.minimum = def.length; + bag.maximum = def.length; + bag.length = def.length; + }); + inst._zod.check = (payload) => { + const input = payload.value; + const length = input.length; + if (length === def.length) + return; + const origin = getLengthableOrigin(input); + const tooBig = length > def.length; + payload.issues.push({ + origin, + ...tooBig ? { code: "too_big", maximum: def.length } : { code: "too_small", minimum: def.length }, + inclusive: true, + exact: true, + input: payload.value, + inst, + continue: !def.abort + }); + }; +}); +var $ZodCheckStringFormat = /* @__PURE__ */ $constructor("$ZodCheckStringFormat", (inst, def) => { + var _a3, _b; + $ZodCheck.init(inst, def); + inst._zod.onattach.push((inst2) => { + const bag = inst2._zod.bag; + bag.format = def.format; + if (def.pattern) { + bag.patterns ?? (bag.patterns = /* @__PURE__ */ new Set()); + bag.patterns.add(def.pattern); + } + }); + if (def.pattern) + (_a3 = inst._zod).check ?? (_a3.check = (payload) => { + def.pattern.lastIndex = 0; + if (def.pattern.test(payload.value)) + return; + payload.issues.push({ + origin: "string", + code: "invalid_format", + format: def.format, + input: payload.value, + ...def.pattern ? { pattern: def.pattern.toString() } : {}, + inst, + continue: !def.abort + }); + }); + else + (_b = inst._zod).check ?? (_b.check = () => { + }); +}); +var $ZodCheckRegex = /* @__PURE__ */ $constructor("$ZodCheckRegex", (inst, def) => { + $ZodCheckStringFormat.init(inst, def); + inst._zod.check = (payload) => { + def.pattern.lastIndex = 0; + if (def.pattern.test(payload.value)) + return; + payload.issues.push({ + origin: "string", + code: "invalid_format", + format: "regex", + input: payload.value, + pattern: def.pattern.toString(), + inst, + continue: !def.abort + }); + }; +}); +var $ZodCheckLowerCase = /* @__PURE__ */ $constructor("$ZodCheckLowerCase", (inst, def) => { + def.pattern ?? (def.pattern = lowercase); + $ZodCheckStringFormat.init(inst, def); +}); +var $ZodCheckUpperCase = /* @__PURE__ */ $constructor("$ZodCheckUpperCase", (inst, def) => { + def.pattern ?? (def.pattern = uppercase); + $ZodCheckStringFormat.init(inst, def); +}); +var $ZodCheckIncludes = /* @__PURE__ */ $constructor("$ZodCheckIncludes", (inst, def) => { + $ZodCheck.init(inst, def); + const escapedRegex = escapeRegex(def.includes); + const pattern = new RegExp(typeof def.position === "number" ? `^.{${def.position}}${escapedRegex}` : escapedRegex); + def.pattern = pattern; + inst._zod.onattach.push((inst2) => { + const bag = inst2._zod.bag; + bag.patterns ?? (bag.patterns = /* @__PURE__ */ new Set()); + bag.patterns.add(pattern); + }); + inst._zod.check = (payload) => { + if (payload.value.includes(def.includes, def.position)) + return; + payload.issues.push({ + origin: "string", + code: "invalid_format", + format: "includes", + includes: def.includes, + input: payload.value, + inst, + continue: !def.abort + }); + }; +}); +var $ZodCheckStartsWith = /* @__PURE__ */ $constructor("$ZodCheckStartsWith", (inst, def) => { + $ZodCheck.init(inst, def); + const pattern = new RegExp(`^${escapeRegex(def.prefix)}.*`); + def.pattern ?? (def.pattern = pattern); + inst._zod.onattach.push((inst2) => { + const bag = inst2._zod.bag; + bag.patterns ?? (bag.patterns = /* @__PURE__ */ new Set()); + bag.patterns.add(pattern); + }); + inst._zod.check = (payload) => { + if (payload.value.startsWith(def.prefix)) + return; + payload.issues.push({ + origin: "string", + code: "invalid_format", + format: "starts_with", + prefix: def.prefix, + input: payload.value, + inst, + continue: !def.abort + }); + }; +}); +var $ZodCheckEndsWith = /* @__PURE__ */ $constructor("$ZodCheckEndsWith", (inst, def) => { + $ZodCheck.init(inst, def); + const pattern = new RegExp(`.*${escapeRegex(def.suffix)}$`); + def.pattern ?? (def.pattern = pattern); + inst._zod.onattach.push((inst2) => { + const bag = inst2._zod.bag; + bag.patterns ?? (bag.patterns = /* @__PURE__ */ new Set()); + bag.patterns.add(pattern); + }); + inst._zod.check = (payload) => { + if (payload.value.endsWith(def.suffix)) + return; + payload.issues.push({ + origin: "string", + code: "invalid_format", + format: "ends_with", + suffix: def.suffix, + input: payload.value, + inst, + continue: !def.abort + }); + }; +}); +var $ZodCheckOverwrite = /* @__PURE__ */ $constructor("$ZodCheckOverwrite", (inst, def) => { + $ZodCheck.init(inst, def); + inst._zod.check = (payload) => { + payload.value = def.tx(payload.value); + }; +}); + +// node_modules/zod/v4/core/doc.js +var Doc = class { + constructor(args = []) { + this.content = []; + this.indent = 0; + if (this) + this.args = args; + } + indented(fn) { + this.indent += 1; + fn(this); + this.indent -= 1; + } + write(arg) { + if (typeof arg === "function") { + arg(this, { execution: "sync" }); + arg(this, { execution: "async" }); + return; + } + const content = arg; + const lines = content.split("\n").filter((x) => x); + const minIndent = Math.min(...lines.map((x) => x.length - x.trimStart().length)); + const dedented = lines.map((x) => x.slice(minIndent)).map((x) => " ".repeat(this.indent * 2) + x); + for (const line of dedented) { + this.content.push(line); + } + } + compile() { + const F = Function; + const args = this?.args; + const content = this?.content ?? [``]; + const lines = [...content.map((x) => ` ${x}`)]; + return new F(...args, lines.join("\n")); + } +}; + +// node_modules/zod/v4/core/versions.js +var version = { + major: 4, + minor: 4, + patch: 3 +}; + +// node_modules/zod/v4/core/schemas.js +var $ZodType = /* @__PURE__ */ $constructor("$ZodType", (inst, def) => { + var _a3; + inst ?? (inst = {}); + inst._zod.def = def; + inst._zod.bag = inst._zod.bag || {}; + inst._zod.version = version; + const checks = [...inst._zod.def.checks ?? []]; + if (inst._zod.traits.has("$ZodCheck")) { + checks.unshift(inst); + } + for (const ch of checks) { + for (const fn of ch._zod.onattach) { + fn(inst); + } + } + if (checks.length === 0) { + (_a3 = inst._zod).deferred ?? (_a3.deferred = []); + inst._zod.deferred?.push(() => { + inst._zod.run = inst._zod.parse; + }); + } else { + const runChecks = (payload, checks2, ctx) => { + let isAborted = aborted(payload); + let asyncResult; + for (const ch of checks2) { + if (ch._zod.def.when) { + if (explicitlyAborted(payload)) + continue; + const shouldRun = ch._zod.def.when(payload); + if (!shouldRun) + continue; + } else if (isAborted) { + continue; + } + const currLen = payload.issues.length; + const _ = ch._zod.check(payload); + if (_ instanceof Promise && ctx?.async === false) { + throw new $ZodAsyncError(); + } + if (asyncResult || _ instanceof Promise) { + asyncResult = (asyncResult ?? Promise.resolve()).then(async () => { + await _; + const nextLen = payload.issues.length; + if (nextLen === currLen) + return; + if (!isAborted) + isAborted = aborted(payload, currLen); + }); + } else { + const nextLen = payload.issues.length; + if (nextLen === currLen) + continue; + if (!isAborted) + isAborted = aborted(payload, currLen); + } + } + if (asyncResult) { + return asyncResult.then(() => { + return payload; + }); + } + return payload; + }; + const handleCanaryResult = (canary, payload, ctx) => { + if (aborted(canary)) { + canary.aborted = true; + return canary; + } + const checkResult = runChecks(payload, checks, ctx); + if (checkResult instanceof Promise) { + if (ctx.async === false) + throw new $ZodAsyncError(); + return checkResult.then((checkResult2) => inst._zod.parse(checkResult2, ctx)); + } + return inst._zod.parse(checkResult, ctx); + }; + inst._zod.run = (payload, ctx) => { + if (ctx.skipChecks) { + return inst._zod.parse(payload, ctx); + } + if (ctx.direction === "backward") { + const canary = inst._zod.parse({ value: payload.value, issues: [] }, { ...ctx, skipChecks: true }); + if (canary instanceof Promise) { + return canary.then((canary2) => { + return handleCanaryResult(canary2, payload, ctx); + }); + } + return handleCanaryResult(canary, payload, ctx); + } + const result = inst._zod.parse(payload, ctx); + if (result instanceof Promise) { + if (ctx.async === false) + throw new $ZodAsyncError(); + return result.then((result2) => runChecks(result2, checks, ctx)); + } + return runChecks(result, checks, ctx); + }; + } + defineLazy(inst, "~standard", () => ({ + validate: (value) => { + try { + const r = safeParse(inst, value); + return r.success ? { value: r.data } : { issues: r.error?.issues }; + } catch (_) { + return safeParseAsync(inst, value).then((r) => r.success ? { value: r.data } : { issues: r.error?.issues }); + } + }, + vendor: "zod", + version: 1 + })); +}); +var $ZodString = /* @__PURE__ */ $constructor("$ZodString", (inst, def) => { + $ZodType.init(inst, def); + inst._zod.pattern = [...inst?._zod.bag?.patterns ?? []].pop() ?? string(inst._zod.bag); + inst._zod.parse = (payload, _) => { + if (def.coerce) + try { + payload.value = String(payload.value); + } catch (_2) { + } + if (typeof payload.value === "string") + return payload; + payload.issues.push({ + expected: "string", + code: "invalid_type", + input: payload.value, + inst + }); + return payload; + }; +}); +var $ZodStringFormat = /* @__PURE__ */ $constructor("$ZodStringFormat", (inst, def) => { + $ZodCheckStringFormat.init(inst, def); + $ZodString.init(inst, def); +}); +var $ZodGUID = /* @__PURE__ */ $constructor("$ZodGUID", (inst, def) => { + def.pattern ?? (def.pattern = guid); + $ZodStringFormat.init(inst, def); +}); +var $ZodUUID = /* @__PURE__ */ $constructor("$ZodUUID", (inst, def) => { + if (def.version) { + const versionMap = { + v1: 1, + v2: 2, + v3: 3, + v4: 4, + v5: 5, + v6: 6, + v7: 7, + v8: 8 + }; + const v = versionMap[def.version]; + if (v === void 0) + throw new Error(`Invalid UUID version: "${def.version}"`); + def.pattern ?? (def.pattern = uuid(v)); + } else + def.pattern ?? (def.pattern = uuid()); + $ZodStringFormat.init(inst, def); +}); +var $ZodEmail = /* @__PURE__ */ $constructor("$ZodEmail", (inst, def) => { + def.pattern ?? (def.pattern = email); + $ZodStringFormat.init(inst, def); +}); +var $ZodURL = /* @__PURE__ */ $constructor("$ZodURL", (inst, def) => { + $ZodStringFormat.init(inst, def); + inst._zod.check = (payload) => { + try { + const trimmed = payload.value.trim(); + if (!def.normalize && def.protocol?.source === httpProtocol.source) { + if (!/^https?:\/\//i.test(trimmed)) { + payload.issues.push({ + code: "invalid_format", + format: "url", + note: "Invalid URL format", + input: payload.value, + inst, + continue: !def.abort + }); + return; + } + } + const url = new URL(trimmed); + if (def.hostname) { + def.hostname.lastIndex = 0; + if (!def.hostname.test(url.hostname)) { + payload.issues.push({ + code: "invalid_format", + format: "url", + note: "Invalid hostname", + pattern: def.hostname.source, + input: payload.value, + inst, + continue: !def.abort + }); + } + } + if (def.protocol) { + def.protocol.lastIndex = 0; + if (!def.protocol.test(url.protocol.endsWith(":") ? url.protocol.slice(0, -1) : url.protocol)) { + payload.issues.push({ + code: "invalid_format", + format: "url", + note: "Invalid protocol", + pattern: def.protocol.source, + input: payload.value, + inst, + continue: !def.abort + }); + } + } + if (def.normalize) { + payload.value = url.href; + } else { + payload.value = trimmed; + } + return; + } catch (_) { + payload.issues.push({ + code: "invalid_format", + format: "url", + input: payload.value, + inst, + continue: !def.abort + }); + } + }; +}); +var $ZodEmoji = /* @__PURE__ */ $constructor("$ZodEmoji", (inst, def) => { + def.pattern ?? (def.pattern = emoji()); + $ZodStringFormat.init(inst, def); +}); +var $ZodNanoID = /* @__PURE__ */ $constructor("$ZodNanoID", (inst, def) => { + def.pattern ?? (def.pattern = nanoid); + $ZodStringFormat.init(inst, def); +}); +var $ZodCUID = /* @__PURE__ */ $constructor("$ZodCUID", (inst, def) => { + def.pattern ?? (def.pattern = cuid); + $ZodStringFormat.init(inst, def); +}); +var $ZodCUID2 = /* @__PURE__ */ $constructor("$ZodCUID2", (inst, def) => { + def.pattern ?? (def.pattern = cuid2); + $ZodStringFormat.init(inst, def); +}); +var $ZodULID = /* @__PURE__ */ $constructor("$ZodULID", (inst, def) => { + def.pattern ?? (def.pattern = ulid); + $ZodStringFormat.init(inst, def); +}); +var $ZodXID = /* @__PURE__ */ $constructor("$ZodXID", (inst, def) => { + def.pattern ?? (def.pattern = xid); + $ZodStringFormat.init(inst, def); +}); +var $ZodKSUID = /* @__PURE__ */ $constructor("$ZodKSUID", (inst, def) => { + def.pattern ?? (def.pattern = ksuid); + $ZodStringFormat.init(inst, def); +}); +var $ZodISODateTime = /* @__PURE__ */ $constructor("$ZodISODateTime", (inst, def) => { + def.pattern ?? (def.pattern = datetime(def)); + $ZodStringFormat.init(inst, def); +}); +var $ZodISODate = /* @__PURE__ */ $constructor("$ZodISODate", (inst, def) => { + def.pattern ?? (def.pattern = date); + $ZodStringFormat.init(inst, def); +}); +var $ZodISOTime = /* @__PURE__ */ $constructor("$ZodISOTime", (inst, def) => { + def.pattern ?? (def.pattern = time(def)); + $ZodStringFormat.init(inst, def); +}); +var $ZodISODuration = /* @__PURE__ */ $constructor("$ZodISODuration", (inst, def) => { + def.pattern ?? (def.pattern = duration); + $ZodStringFormat.init(inst, def); +}); +var $ZodIPv4 = /* @__PURE__ */ $constructor("$ZodIPv4", (inst, def) => { + def.pattern ?? (def.pattern = ipv4); + $ZodStringFormat.init(inst, def); + inst._zod.bag.format = `ipv4`; +}); +var $ZodIPv6 = /* @__PURE__ */ $constructor("$ZodIPv6", (inst, def) => { + def.pattern ?? (def.pattern = ipv6); + $ZodStringFormat.init(inst, def); + inst._zod.bag.format = `ipv6`; + inst._zod.check = (payload) => { + try { + new URL(`http://[${payload.value}]`); + } catch { + payload.issues.push({ + code: "invalid_format", + format: "ipv6", + input: payload.value, + inst, + continue: !def.abort + }); + } + }; +}); +var $ZodCIDRv4 = /* @__PURE__ */ $constructor("$ZodCIDRv4", (inst, def) => { + def.pattern ?? (def.pattern = cidrv4); + $ZodStringFormat.init(inst, def); +}); +var $ZodCIDRv6 = /* @__PURE__ */ $constructor("$ZodCIDRv6", (inst, def) => { + def.pattern ?? (def.pattern = cidrv6); + $ZodStringFormat.init(inst, def); + inst._zod.check = (payload) => { + const parts = payload.value.split("/"); + try { + if (parts.length !== 2) + throw new Error(); + const [address, prefix] = parts; + if (!prefix) + throw new Error(); + const prefixNum = Number(prefix); + if (`${prefixNum}` !== prefix) + throw new Error(); + if (prefixNum < 0 || prefixNum > 128) + throw new Error(); + new URL(`http://[${address}]`); + } catch { + payload.issues.push({ + code: "invalid_format", + format: "cidrv6", + input: payload.value, + inst, + continue: !def.abort + }); + } + }; +}); +function isValidBase64(data) { + if (data === "") + return true; + if (/\s/.test(data)) + return false; + if (data.length % 4 !== 0) + return false; + try { + atob(data); + return true; + } catch { + return false; + } +} +var $ZodBase64 = /* @__PURE__ */ $constructor("$ZodBase64", (inst, def) => { + def.pattern ?? (def.pattern = base64); + $ZodStringFormat.init(inst, def); + inst._zod.bag.contentEncoding = "base64"; + inst._zod.check = (payload) => { + if (isValidBase64(payload.value)) + return; + payload.issues.push({ + code: "invalid_format", + format: "base64", + input: payload.value, + inst, + continue: !def.abort + }); + }; +}); +function isValidBase64URL(data) { + if (!base64url.test(data)) + return false; + const base642 = data.replace(/[-_]/g, (c) => c === "-" ? "+" : "/"); + const padded = base642.padEnd(Math.ceil(base642.length / 4) * 4, "="); + return isValidBase64(padded); +} +var $ZodBase64URL = /* @__PURE__ */ $constructor("$ZodBase64URL", (inst, def) => { + def.pattern ?? (def.pattern = base64url); + $ZodStringFormat.init(inst, def); + inst._zod.bag.contentEncoding = "base64url"; + inst._zod.check = (payload) => { + if (isValidBase64URL(payload.value)) + return; + payload.issues.push({ + code: "invalid_format", + format: "base64url", + input: payload.value, + inst, + continue: !def.abort + }); + }; +}); +var $ZodE164 = /* @__PURE__ */ $constructor("$ZodE164", (inst, def) => { + def.pattern ?? (def.pattern = e164); + $ZodStringFormat.init(inst, def); +}); +function isValidJWT(token, algorithm = null) { + try { + const tokensParts = token.split("."); + if (tokensParts.length !== 3) + return false; + const [header] = tokensParts; + if (!header) + return false; + const parsedHeader = JSON.parse(atob(header)); + if ("typ" in parsedHeader && parsedHeader?.typ !== "JWT") + return false; + if (!parsedHeader.alg) + return false; + if (algorithm && (!("alg" in parsedHeader) || parsedHeader.alg !== algorithm)) + return false; + return true; + } catch { + return false; + } +} +var $ZodJWT = /* @__PURE__ */ $constructor("$ZodJWT", (inst, def) => { + $ZodStringFormat.init(inst, def); + inst._zod.check = (payload) => { + if (isValidJWT(payload.value, def.alg)) + return; + payload.issues.push({ + code: "invalid_format", + format: "jwt", + input: payload.value, + inst, + continue: !def.abort + }); + }; +}); +var $ZodNumber = /* @__PURE__ */ $constructor("$ZodNumber", (inst, def) => { + $ZodType.init(inst, def); + inst._zod.pattern = inst._zod.bag.pattern ?? number; + inst._zod.parse = (payload, _ctx) => { + if (def.coerce) + try { + payload.value = Number(payload.value); + } catch (_) { + } + const input = payload.value; + if (typeof input === "number" && !Number.isNaN(input) && Number.isFinite(input)) { + return payload; + } + const received = typeof input === "number" ? Number.isNaN(input) ? "NaN" : !Number.isFinite(input) ? "Infinity" : void 0 : void 0; + payload.issues.push({ + expected: "number", + code: "invalid_type", + input, + inst, + ...received ? { received } : {} + }); + return payload; + }; +}); +var $ZodNumberFormat = /* @__PURE__ */ $constructor("$ZodNumberFormat", (inst, def) => { + $ZodCheckNumberFormat.init(inst, def); + $ZodNumber.init(inst, def); +}); +var $ZodUnknown = /* @__PURE__ */ $constructor("$ZodUnknown", (inst, def) => { + $ZodType.init(inst, def); + inst._zod.parse = (payload) => payload; +}); +var $ZodNever = /* @__PURE__ */ $constructor("$ZodNever", (inst, def) => { + $ZodType.init(inst, def); + inst._zod.parse = (payload, _ctx) => { + payload.issues.push({ + expected: "never", + code: "invalid_type", + input: payload.value, + inst + }); + return payload; + }; +}); +function handleArrayResult(result, final, index) { + if (result.issues.length) { + final.issues.push(...prefixIssues(index, result.issues)); + } + final.value[index] = result.value; +} +var $ZodArray = /* @__PURE__ */ $constructor("$ZodArray", (inst, def) => { + $ZodType.init(inst, def); + inst._zod.parse = (payload, ctx) => { + const input = payload.value; + if (!Array.isArray(input)) { + payload.issues.push({ + expected: "array", + code: "invalid_type", + input, + inst + }); + return payload; + } + payload.value = Array(input.length); + const proms = []; + for (let i = 0; i < input.length; i++) { + const item = input[i]; + const result = def.element._zod.run({ + value: item, + issues: [] + }, ctx); + if (result instanceof Promise) { + proms.push(result.then((result2) => handleArrayResult(result2, payload, i))); + } else { + handleArrayResult(result, payload, i); + } + } + if (proms.length) { + return Promise.all(proms).then(() => payload); + } + return payload; + }; +}); +function handlePropertyResult(result, final, key, input, isOptionalIn, isOptionalOut) { + const isPresent = key in input; + if (result.issues.length) { + if (isOptionalIn && isOptionalOut && !isPresent) { + return; + } + final.issues.push(...prefixIssues(key, result.issues)); + } + if (!isPresent && !isOptionalIn) { + if (!result.issues.length) { + final.issues.push({ + code: "invalid_type", + expected: "nonoptional", + input: void 0, + path: [key] + }); + } + return; + } + if (result.value === void 0) { + if (isPresent) { + final.value[key] = void 0; + } + } else { + final.value[key] = result.value; + } +} +function normalizeDef(def) { + const keys = Object.keys(def.shape); + for (const k of keys) { + if (!def.shape?.[k]?._zod?.traits?.has("$ZodType")) { + throw new Error(`Invalid element at key "${k}": expected a Zod schema`); + } + } + const okeys = optionalKeys(def.shape); + return { + ...def, + keys, + keySet: new Set(keys), + numKeys: keys.length, + optionalKeys: new Set(okeys) + }; +} +function handleCatchall(proms, input, payload, ctx, def, inst) { + const unrecognized = []; + const keySet = def.keySet; + const _catchall = def.catchall._zod; + const t = _catchall.def.type; + const isOptionalIn = _catchall.optin === "optional"; + const isOptionalOut = _catchall.optout === "optional"; + for (const key in input) { + if (key === "__proto__") + continue; + if (keySet.has(key)) + continue; + if (t === "never") { + unrecognized.push(key); + continue; + } + const r = _catchall.run({ value: input[key], issues: [] }, ctx); + if (r instanceof Promise) { + proms.push(r.then((r2) => handlePropertyResult(r2, payload, key, input, isOptionalIn, isOptionalOut))); + } else { + handlePropertyResult(r, payload, key, input, isOptionalIn, isOptionalOut); + } + } + if (unrecognized.length) { + payload.issues.push({ + code: "unrecognized_keys", + keys: unrecognized, + input, + inst + }); + } + if (!proms.length) + return payload; + return Promise.all(proms).then(() => { + return payload; + }); +} +var $ZodObject = /* @__PURE__ */ $constructor("$ZodObject", (inst, def) => { + $ZodType.init(inst, def); + const desc = Object.getOwnPropertyDescriptor(def, "shape"); + if (!desc?.get) { + const sh = def.shape; + Object.defineProperty(def, "shape", { + get: () => { + const newSh = { ...sh }; + Object.defineProperty(def, "shape", { + value: newSh + }); + return newSh; + } + }); + } + const _normalized = cached(() => normalizeDef(def)); + defineLazy(inst._zod, "propValues", () => { + const shape = def.shape; + const propValues = {}; + for (const key in shape) { + const field = shape[key]._zod; + if (field.values) { + propValues[key] ?? (propValues[key] = /* @__PURE__ */ new Set()); + for (const v of field.values) + propValues[key].add(v); + } + } + return propValues; + }); + const isObject2 = isObject; + const catchall = def.catchall; + let value; + inst._zod.parse = (payload, ctx) => { + value ?? (value = _normalized.value); + const input = payload.value; + if (!isObject2(input)) { + payload.issues.push({ + expected: "object", + code: "invalid_type", + input, + inst + }); + return payload; + } + payload.value = {}; + const proms = []; + const shape = value.shape; + for (const key of value.keys) { + const el = shape[key]; + const isOptionalIn = el._zod.optin === "optional"; + const isOptionalOut = el._zod.optout === "optional"; + const r = el._zod.run({ value: input[key], issues: [] }, ctx); + if (r instanceof Promise) { + proms.push(r.then((r2) => handlePropertyResult(r2, payload, key, input, isOptionalIn, isOptionalOut))); + } else { + handlePropertyResult(r, payload, key, input, isOptionalIn, isOptionalOut); + } + } + if (!catchall) { + return proms.length ? Promise.all(proms).then(() => payload) : payload; + } + return handleCatchall(proms, input, payload, ctx, _normalized.value, inst); + }; +}); +var $ZodObjectJIT = /* @__PURE__ */ $constructor("$ZodObjectJIT", (inst, def) => { + $ZodObject.init(inst, def); + const superParse = inst._zod.parse; + const _normalized = cached(() => normalizeDef(def)); + const generateFastpass = (shape) => { + const doc = new Doc(["shape", "payload", "ctx"]); + const normalized = _normalized.value; + const parseStr = (key) => { + const k = esc(key); + return `shape[${k}]._zod.run({ value: input[${k}], issues: [] }, ctx)`; + }; + doc.write(`const input = payload.value;`); + const ids = /* @__PURE__ */ Object.create(null); + let counter = 0; + for (const key of normalized.keys) { + ids[key] = `key_${counter++}`; + } + doc.write(`const newResult = {};`); + for (const key of normalized.keys) { + const id = ids[key]; + const k = esc(key); + const schema = shape[key]; + const isOptionalIn = schema?._zod?.optin === "optional"; + const isOptionalOut = schema?._zod?.optout === "optional"; + doc.write(`const ${id} = ${parseStr(key)};`); + if (isOptionalIn && isOptionalOut) { + doc.write(` + if (${id}.issues.length) { + if (${k} in input) { + payload.issues = payload.issues.concat(${id}.issues.map(iss => ({ + ...iss, + path: iss.path ? [${k}, ...iss.path] : [${k}] + }))); + } + } + + if (${id}.value === undefined) { + if (${k} in input) { + newResult[${k}] = undefined; + } + } else { + newResult[${k}] = ${id}.value; + } + + `); + } else if (!isOptionalIn) { + doc.write(` + const ${id}_present = ${k} in input; + if (${id}.issues.length) { + payload.issues = payload.issues.concat(${id}.issues.map(iss => ({ + ...iss, + path: iss.path ? [${k}, ...iss.path] : [${k}] + }))); + } + if (!${id}_present && !${id}.issues.length) { + payload.issues.push({ + code: "invalid_type", + expected: "nonoptional", + input: undefined, + path: [${k}] + }); + } + + if (${id}_present) { + if (${id}.value === undefined) { + newResult[${k}] = undefined; + } else { + newResult[${k}] = ${id}.value; + } + } + + `); + } else { + doc.write(` + if (${id}.issues.length) { + payload.issues = payload.issues.concat(${id}.issues.map(iss => ({ + ...iss, + path: iss.path ? [${k}, ...iss.path] : [${k}] + }))); + } + + if (${id}.value === undefined) { + if (${k} in input) { + newResult[${k}] = undefined; + } + } else { + newResult[${k}] = ${id}.value; + } + + `); + } + } + doc.write(`payload.value = newResult;`); + doc.write(`return payload;`); + const fn = doc.compile(); + return (payload, ctx) => fn(shape, payload, ctx); + }; + let fastpass; + const isObject2 = isObject; + const jit = !globalConfig.jitless; + const allowsEval2 = allowsEval; + const fastEnabled = jit && allowsEval2.value; + const catchall = def.catchall; + let value; + inst._zod.parse = (payload, ctx) => { + value ?? (value = _normalized.value); + const input = payload.value; + if (!isObject2(input)) { + payload.issues.push({ + expected: "object", + code: "invalid_type", + input, + inst + }); + return payload; + } + if (jit && fastEnabled && ctx?.async === false && ctx.jitless !== true) { + if (!fastpass) + fastpass = generateFastpass(def.shape); + payload = fastpass(payload, ctx); + if (!catchall) + return payload; + return handleCatchall([], input, payload, ctx, value, inst); + } + return superParse(payload, ctx); + }; +}); +function handleUnionResults(results, final, inst, ctx) { + for (const result of results) { + if (result.issues.length === 0) { + final.value = result.value; + return final; + } + } + const nonaborted = results.filter((r) => !aborted(r)); + if (nonaborted.length === 1) { + final.value = nonaborted[0].value; + return nonaborted[0]; + } + final.issues.push({ + code: "invalid_union", + input: final.value, + inst, + errors: results.map((result) => result.issues.map((iss) => finalizeIssue(iss, ctx, config()))) + }); + return final; +} +var $ZodUnion = /* @__PURE__ */ $constructor("$ZodUnion", (inst, def) => { + $ZodType.init(inst, def); + defineLazy(inst._zod, "optin", () => def.options.some((o) => o._zod.optin === "optional") ? "optional" : void 0); + defineLazy(inst._zod, "optout", () => def.options.some((o) => o._zod.optout === "optional") ? "optional" : void 0); + defineLazy(inst._zod, "values", () => { + if (def.options.every((o) => o._zod.values)) { + return new Set(def.options.flatMap((option) => Array.from(option._zod.values))); + } + return void 0; + }); + defineLazy(inst._zod, "pattern", () => { + if (def.options.every((o) => o._zod.pattern)) { + const patterns = def.options.map((o) => o._zod.pattern); + return new RegExp(`^(${patterns.map((p) => cleanRegex(p.source)).join("|")})$`); + } + return void 0; + }); + const first = def.options.length === 1 ? def.options[0]._zod.run : null; + inst._zod.parse = (payload, ctx) => { + if (first) { + return first(payload, ctx); + } + let async = false; + const results = []; + for (const option of def.options) { + const result = option._zod.run({ + value: payload.value, + issues: [] + }, ctx); + if (result instanceof Promise) { + results.push(result); + async = true; + } else { + if (result.issues.length === 0) + return result; + results.push(result); + } + } + if (!async) + return handleUnionResults(results, payload, inst, ctx); + return Promise.all(results).then((results2) => { + return handleUnionResults(results2, payload, inst, ctx); + }); + }; +}); +var $ZodIntersection = /* @__PURE__ */ $constructor("$ZodIntersection", (inst, def) => { + $ZodType.init(inst, def); + inst._zod.parse = (payload, ctx) => { + const input = payload.value; + const left = def.left._zod.run({ value: input, issues: [] }, ctx); + const right = def.right._zod.run({ value: input, issues: [] }, ctx); + const async = left instanceof Promise || right instanceof Promise; + if (async) { + return Promise.all([left, right]).then(([left2, right2]) => { + return handleIntersectionResults(payload, left2, right2); + }); + } + return handleIntersectionResults(payload, left, right); + }; +}); +function mergeValues(a, b) { + if (a === b) { + return { valid: true, data: a }; + } + if (a instanceof Date && b instanceof Date && +a === +b) { + return { valid: true, data: a }; + } + if (isPlainObject(a) && isPlainObject(b)) { + const bKeys = Object.keys(b); + const sharedKeys = Object.keys(a).filter((key) => bKeys.indexOf(key) !== -1); + const newObj = { ...a, ...b }; + for (const key of sharedKeys) { + const sharedValue = mergeValues(a[key], b[key]); + if (!sharedValue.valid) { + return { + valid: false, + mergeErrorPath: [key, ...sharedValue.mergeErrorPath] + }; + } + newObj[key] = sharedValue.data; + } + return { valid: true, data: newObj }; + } + if (Array.isArray(a) && Array.isArray(b)) { + if (a.length !== b.length) { + return { valid: false, mergeErrorPath: [] }; + } + const newArray = []; + for (let index = 0; index < a.length; index++) { + const itemA = a[index]; + const itemB = b[index]; + const sharedValue = mergeValues(itemA, itemB); + if (!sharedValue.valid) { + return { + valid: false, + mergeErrorPath: [index, ...sharedValue.mergeErrorPath] + }; + } + newArray.push(sharedValue.data); + } + return { valid: true, data: newArray }; + } + return { valid: false, mergeErrorPath: [] }; +} +function handleIntersectionResults(result, left, right) { + const unrecKeys = /* @__PURE__ */ new Map(); + let unrecIssue; + for (const iss of left.issues) { + if (iss.code === "unrecognized_keys") { + unrecIssue ?? (unrecIssue = iss); + for (const k of iss.keys) { + if (!unrecKeys.has(k)) + unrecKeys.set(k, {}); + unrecKeys.get(k).l = true; + } + } else { + result.issues.push(iss); + } + } + for (const iss of right.issues) { + if (iss.code === "unrecognized_keys") { + for (const k of iss.keys) { + if (!unrecKeys.has(k)) + unrecKeys.set(k, {}); + unrecKeys.get(k).r = true; + } + } else { + result.issues.push(iss); + } + } + const bothKeys = [...unrecKeys].filter(([, f]) => f.l && f.r).map(([k]) => k); + if (bothKeys.length && unrecIssue) { + result.issues.push({ ...unrecIssue, keys: bothKeys }); + } + if (aborted(result)) + return result; + const merged = mergeValues(left.value, right.value); + if (!merged.valid) { + throw new Error(`Unmergable intersection. Error path: ${JSON.stringify(merged.mergeErrorPath)}`); + } + result.value = merged.data; + return result; +} +var $ZodRecord = /* @__PURE__ */ $constructor("$ZodRecord", (inst, def) => { + $ZodType.init(inst, def); + inst._zod.parse = (payload, ctx) => { + const input = payload.value; + if (!isPlainObject(input)) { + payload.issues.push({ + expected: "record", + code: "invalid_type", + input, + inst + }); + return payload; + } + const proms = []; + const values = def.keyType._zod.values; + if (values) { + payload.value = {}; + const recordKeys = /* @__PURE__ */ new Set(); + for (const key of values) { + if (typeof key === "string" || typeof key === "number" || typeof key === "symbol") { + recordKeys.add(typeof key === "number" ? key.toString() : key); + const keyResult = def.keyType._zod.run({ value: key, issues: [] }, ctx); + if (keyResult instanceof Promise) { + throw new Error("Async schemas not supported in object keys currently"); + } + if (keyResult.issues.length) { + payload.issues.push({ + code: "invalid_key", + origin: "record", + issues: keyResult.issues.map((iss) => finalizeIssue(iss, ctx, config())), + input: key, + path: [key], + inst + }); + continue; + } + const outKey = keyResult.value; + const result = def.valueType._zod.run({ value: input[key], issues: [] }, ctx); + if (result instanceof Promise) { + proms.push(result.then((result2) => { + if (result2.issues.length) { + payload.issues.push(...prefixIssues(key, result2.issues)); + } + payload.value[outKey] = result2.value; + })); + } else { + if (result.issues.length) { + payload.issues.push(...prefixIssues(key, result.issues)); + } + payload.value[outKey] = result.value; + } + } + } + let unrecognized; + for (const key in input) { + if (!recordKeys.has(key)) { + unrecognized = unrecognized ?? []; + unrecognized.push(key); + } + } + if (unrecognized && unrecognized.length > 0) { + payload.issues.push({ + code: "unrecognized_keys", + input, + inst, + keys: unrecognized + }); + } + } else { + payload.value = {}; + for (const key of Reflect.ownKeys(input)) { + if (key === "__proto__") + continue; + if (!Object.prototype.propertyIsEnumerable.call(input, key)) + continue; + let keyResult = def.keyType._zod.run({ value: key, issues: [] }, ctx); + if (keyResult instanceof Promise) { + throw new Error("Async schemas not supported in object keys currently"); + } + const checkNumericKey = typeof key === "string" && number.test(key) && keyResult.issues.length; + if (checkNumericKey) { + const retryResult = def.keyType._zod.run({ value: Number(key), issues: [] }, ctx); + if (retryResult instanceof Promise) { + throw new Error("Async schemas not supported in object keys currently"); + } + if (retryResult.issues.length === 0) { + keyResult = retryResult; + } + } + if (keyResult.issues.length) { + if (def.mode === "loose") { + payload.value[key] = input[key]; + } else { + payload.issues.push({ + code: "invalid_key", + origin: "record", + issues: keyResult.issues.map((iss) => finalizeIssue(iss, ctx, config())), + input: key, + path: [key], + inst + }); + } + continue; + } + const result = def.valueType._zod.run({ value: input[key], issues: [] }, ctx); + if (result instanceof Promise) { + proms.push(result.then((result2) => { + if (result2.issues.length) { + payload.issues.push(...prefixIssues(key, result2.issues)); + } + payload.value[keyResult.value] = result2.value; + })); + } else { + if (result.issues.length) { + payload.issues.push(...prefixIssues(key, result.issues)); + } + payload.value[keyResult.value] = result.value; + } + } + } + if (proms.length) { + return Promise.all(proms).then(() => payload); + } + return payload; + }; +}); +var $ZodEnum = /* @__PURE__ */ $constructor("$ZodEnum", (inst, def) => { + $ZodType.init(inst, def); + const values = getEnumValues(def.entries); + const valuesSet = new Set(values); + inst._zod.values = valuesSet; + inst._zod.pattern = new RegExp(`^(${values.filter((k) => propertyKeyTypes.has(typeof k)).map((o) => typeof o === "string" ? escapeRegex(o) : o.toString()).join("|")})$`); + inst._zod.parse = (payload, _ctx) => { + const input = payload.value; + if (valuesSet.has(input)) { + return payload; + } + payload.issues.push({ + code: "invalid_value", + values, + input, + inst + }); + return payload; + }; +}); +var $ZodTransform = /* @__PURE__ */ $constructor("$ZodTransform", (inst, def) => { + $ZodType.init(inst, def); + inst._zod.optin = "optional"; + inst._zod.parse = (payload, ctx) => { + if (ctx.direction === "backward") { + throw new $ZodEncodeError(inst.constructor.name); + } + const _out = def.transform(payload.value, payload); + if (ctx.async) { + const output = _out instanceof Promise ? _out : Promise.resolve(_out); + return output.then((output2) => { + payload.value = output2; + payload.fallback = true; + return payload; + }); + } + if (_out instanceof Promise) { + throw new $ZodAsyncError(); + } + payload.value = _out; + payload.fallback = true; + return payload; + }; +}); +function handleOptionalResult(result, input) { + if (input === void 0 && (result.issues.length || result.fallback)) { + return { issues: [], value: void 0 }; + } + return result; +} +var $ZodOptional = /* @__PURE__ */ $constructor("$ZodOptional", (inst, def) => { + $ZodType.init(inst, def); + inst._zod.optin = "optional"; + inst._zod.optout = "optional"; + defineLazy(inst._zod, "values", () => { + return def.innerType._zod.values ? /* @__PURE__ */ new Set([...def.innerType._zod.values, void 0]) : void 0; + }); + defineLazy(inst._zod, "pattern", () => { + const pattern = def.innerType._zod.pattern; + return pattern ? new RegExp(`^(${cleanRegex(pattern.source)})?$`) : void 0; + }); + inst._zod.parse = (payload, ctx) => { + if (def.innerType._zod.optin === "optional") { + const input = payload.value; + const result = def.innerType._zod.run(payload, ctx); + if (result instanceof Promise) + return result.then((r) => handleOptionalResult(r, input)); + return handleOptionalResult(result, input); + } + if (payload.value === void 0) { + return payload; + } + return def.innerType._zod.run(payload, ctx); + }; +}); +var $ZodExactOptional = /* @__PURE__ */ $constructor("$ZodExactOptional", (inst, def) => { + $ZodOptional.init(inst, def); + defineLazy(inst._zod, "values", () => def.innerType._zod.values); + defineLazy(inst._zod, "pattern", () => def.innerType._zod.pattern); + inst._zod.parse = (payload, ctx) => { + return def.innerType._zod.run(payload, ctx); + }; +}); +var $ZodNullable = /* @__PURE__ */ $constructor("$ZodNullable", (inst, def) => { + $ZodType.init(inst, def); + defineLazy(inst._zod, "optin", () => def.innerType._zod.optin); + defineLazy(inst._zod, "optout", () => def.innerType._zod.optout); + defineLazy(inst._zod, "pattern", () => { + const pattern = def.innerType._zod.pattern; + return pattern ? new RegExp(`^(${cleanRegex(pattern.source)}|null)$`) : void 0; + }); + defineLazy(inst._zod, "values", () => { + return def.innerType._zod.values ? /* @__PURE__ */ new Set([...def.innerType._zod.values, null]) : void 0; + }); + inst._zod.parse = (payload, ctx) => { + if (payload.value === null) + return payload; + return def.innerType._zod.run(payload, ctx); + }; +}); +var $ZodDefault = /* @__PURE__ */ $constructor("$ZodDefault", (inst, def) => { + $ZodType.init(inst, def); + inst._zod.optin = "optional"; + defineLazy(inst._zod, "values", () => def.innerType._zod.values); + inst._zod.parse = (payload, ctx) => { + if (ctx.direction === "backward") { + return def.innerType._zod.run(payload, ctx); + } + if (payload.value === void 0) { + payload.value = def.defaultValue; + return payload; + } + const result = def.innerType._zod.run(payload, ctx); + if (result instanceof Promise) { + return result.then((result2) => handleDefaultResult(result2, def)); + } + return handleDefaultResult(result, def); + }; +}); +function handleDefaultResult(payload, def) { + if (payload.value === void 0) { + payload.value = def.defaultValue; + } + return payload; +} +var $ZodPrefault = /* @__PURE__ */ $constructor("$ZodPrefault", (inst, def) => { + $ZodType.init(inst, def); + inst._zod.optin = "optional"; + defineLazy(inst._zod, "values", () => def.innerType._zod.values); + inst._zod.parse = (payload, ctx) => { + if (ctx.direction === "backward") { + return def.innerType._zod.run(payload, ctx); + } + if (payload.value === void 0) { + payload.value = def.defaultValue; + } + return def.innerType._zod.run(payload, ctx); + }; +}); +var $ZodNonOptional = /* @__PURE__ */ $constructor("$ZodNonOptional", (inst, def) => { + $ZodType.init(inst, def); + defineLazy(inst._zod, "values", () => { + const v = def.innerType._zod.values; + return v ? new Set([...v].filter((x) => x !== void 0)) : void 0; + }); + inst._zod.parse = (payload, ctx) => { + const result = def.innerType._zod.run(payload, ctx); + if (result instanceof Promise) { + return result.then((result2) => handleNonOptionalResult(result2, inst)); + } + return handleNonOptionalResult(result, inst); + }; +}); +function handleNonOptionalResult(payload, inst) { + if (!payload.issues.length && payload.value === void 0) { + payload.issues.push({ + code: "invalid_type", + expected: "nonoptional", + input: payload.value, + inst + }); + } + return payload; +} +var $ZodCatch = /* @__PURE__ */ $constructor("$ZodCatch", (inst, def) => { + $ZodType.init(inst, def); + inst._zod.optin = "optional"; + defineLazy(inst._zod, "optout", () => def.innerType._zod.optout); + defineLazy(inst._zod, "values", () => def.innerType._zod.values); + inst._zod.parse = (payload, ctx) => { + if (ctx.direction === "backward") { + return def.innerType._zod.run(payload, ctx); + } + const result = def.innerType._zod.run(payload, ctx); + if (result instanceof Promise) { + return result.then((result2) => { + payload.value = result2.value; + if (result2.issues.length) { + payload.value = def.catchValue({ + ...payload, + error: { + issues: result2.issues.map((iss) => finalizeIssue(iss, ctx, config())) + }, + input: payload.value + }); + payload.issues = []; + payload.fallback = true; + } + return payload; + }); + } + payload.value = result.value; + if (result.issues.length) { + payload.value = def.catchValue({ + ...payload, + error: { + issues: result.issues.map((iss) => finalizeIssue(iss, ctx, config())) + }, + input: payload.value + }); + payload.issues = []; + payload.fallback = true; + } + return payload; + }; +}); +var $ZodPipe = /* @__PURE__ */ $constructor("$ZodPipe", (inst, def) => { + $ZodType.init(inst, def); + defineLazy(inst._zod, "values", () => def.in._zod.values); + defineLazy(inst._zod, "optin", () => def.in._zod.optin); + defineLazy(inst._zod, "optout", () => def.out._zod.optout); + defineLazy(inst._zod, "propValues", () => def.in._zod.propValues); + inst._zod.parse = (payload, ctx) => { + if (ctx.direction === "backward") { + const right = def.out._zod.run(payload, ctx); + if (right instanceof Promise) { + return right.then((right2) => handlePipeResult(right2, def.in, ctx)); + } + return handlePipeResult(right, def.in, ctx); + } + const left = def.in._zod.run(payload, ctx); + if (left instanceof Promise) { + return left.then((left2) => handlePipeResult(left2, def.out, ctx)); + } + return handlePipeResult(left, def.out, ctx); + }; +}); +function handlePipeResult(left, next, ctx) { + if (left.issues.length) { + left.aborted = true; + return left; + } + return next._zod.run({ value: left.value, issues: left.issues, fallback: left.fallback }, ctx); +} +var $ZodReadonly = /* @__PURE__ */ $constructor("$ZodReadonly", (inst, def) => { + $ZodType.init(inst, def); + defineLazy(inst._zod, "propValues", () => def.innerType._zod.propValues); + defineLazy(inst._zod, "values", () => def.innerType._zod.values); + defineLazy(inst._zod, "optin", () => def.innerType?._zod?.optin); + defineLazy(inst._zod, "optout", () => def.innerType?._zod?.optout); + inst._zod.parse = (payload, ctx) => { + if (ctx.direction === "backward") { + return def.innerType._zod.run(payload, ctx); + } + const result = def.innerType._zod.run(payload, ctx); + if (result instanceof Promise) { + return result.then(handleReadonlyResult); + } + return handleReadonlyResult(result); + }; +}); +function handleReadonlyResult(payload) { + payload.value = Object.freeze(payload.value); + return payload; +} +var $ZodCustom = /* @__PURE__ */ $constructor("$ZodCustom", (inst, def) => { + $ZodCheck.init(inst, def); + $ZodType.init(inst, def); + inst._zod.parse = (payload, _) => { + return payload; + }; + inst._zod.check = (payload) => { + const input = payload.value; + const r = def.fn(input); + if (r instanceof Promise) { + return r.then((r2) => handleRefineResult(r2, payload, input, inst)); + } + handleRefineResult(r, payload, input, inst); + return; + }; +}); +function handleRefineResult(result, payload, input, inst) { + if (!result) { + const _iss = { + code: "custom", + input, + inst, + // incorporates params.error into issue reporting + path: [...inst._zod.def.path ?? []], + // incorporates params.error into issue reporting + continue: !inst._zod.def.abort + // params: inst._zod.def.params, + }; + if (inst._zod.def.params) + _iss.params = inst._zod.def.params; + payload.issues.push(issue(_iss)); + } +} + +// node_modules/zod/v4/core/registries.js +var _a2; +var $ZodRegistry = class { + constructor() { + this._map = /* @__PURE__ */ new WeakMap(); + this._idmap = /* @__PURE__ */ new Map(); + } + add(schema, ..._meta) { + const meta2 = _meta[0]; + this._map.set(schema, meta2); + if (meta2 && typeof meta2 === "object" && "id" in meta2) { + this._idmap.set(meta2.id, schema); + } + return this; + } + clear() { + this._map = /* @__PURE__ */ new WeakMap(); + this._idmap = /* @__PURE__ */ new Map(); + return this; + } + remove(schema) { + const meta2 = this._map.get(schema); + if (meta2 && typeof meta2 === "object" && "id" in meta2) { + this._idmap.delete(meta2.id); + } + this._map.delete(schema); + return this; + } + get(schema) { + const p = schema._zod.parent; + if (p) { + const pm = { ...this.get(p) ?? {} }; + delete pm.id; + const f = { ...pm, ...this._map.get(schema) }; + return Object.keys(f).length ? f : void 0; + } + return this._map.get(schema); + } + has(schema) { + return this._map.has(schema); + } +}; +function registry() { + return new $ZodRegistry(); +} +(_a2 = globalThis).__zod_globalRegistry ?? (_a2.__zod_globalRegistry = registry()); +var globalRegistry = globalThis.__zod_globalRegistry; + +// node_modules/zod/v4/core/api.js +// @__NO_SIDE_EFFECTS__ +function _string(Class2, params) { + return new Class2({ + type: "string", + ...normalizeParams(params) + }); +} +// @__NO_SIDE_EFFECTS__ +function _email(Class2, params) { + return new Class2({ + type: "string", + format: "email", + check: "string_format", + abort: false, + ...normalizeParams(params) + }); +} +// @__NO_SIDE_EFFECTS__ +function _guid(Class2, params) { + return new Class2({ + type: "string", + format: "guid", + check: "string_format", + abort: false, + ...normalizeParams(params) + }); +} +// @__NO_SIDE_EFFECTS__ +function _uuid(Class2, params) { + return new Class2({ + type: "string", + format: "uuid", + check: "string_format", + abort: false, + ...normalizeParams(params) + }); +} +// @__NO_SIDE_EFFECTS__ +function _uuidv4(Class2, params) { + return new Class2({ + type: "string", + format: "uuid", + check: "string_format", + abort: false, + version: "v4", + ...normalizeParams(params) + }); +} +// @__NO_SIDE_EFFECTS__ +function _uuidv6(Class2, params) { + return new Class2({ + type: "string", + format: "uuid", + check: "string_format", + abort: false, + version: "v6", + ...normalizeParams(params) + }); +} +// @__NO_SIDE_EFFECTS__ +function _uuidv7(Class2, params) { + return new Class2({ + type: "string", + format: "uuid", + check: "string_format", + abort: false, + version: "v7", + ...normalizeParams(params) + }); +} +// @__NO_SIDE_EFFECTS__ +function _url(Class2, params) { + return new Class2({ + type: "string", + format: "url", + check: "string_format", + abort: false, + ...normalizeParams(params) + }); +} +// @__NO_SIDE_EFFECTS__ +function _emoji2(Class2, params) { + return new Class2({ + type: "string", + format: "emoji", + check: "string_format", + abort: false, + ...normalizeParams(params) + }); +} +// @__NO_SIDE_EFFECTS__ +function _nanoid(Class2, params) { + return new Class2({ + type: "string", + format: "nanoid", + check: "string_format", + abort: false, + ...normalizeParams(params) + }); +} +// @__NO_SIDE_EFFECTS__ +function _cuid(Class2, params) { + return new Class2({ + type: "string", + format: "cuid", + check: "string_format", + abort: false, + ...normalizeParams(params) + }); +} +// @__NO_SIDE_EFFECTS__ +function _cuid2(Class2, params) { + return new Class2({ + type: "string", + format: "cuid2", + check: "string_format", + abort: false, + ...normalizeParams(params) + }); +} +// @__NO_SIDE_EFFECTS__ +function _ulid(Class2, params) { + return new Class2({ + type: "string", + format: "ulid", + check: "string_format", + abort: false, + ...normalizeParams(params) + }); +} +// @__NO_SIDE_EFFECTS__ +function _xid(Class2, params) { + return new Class2({ + type: "string", + format: "xid", + check: "string_format", + abort: false, + ...normalizeParams(params) + }); +} +// @__NO_SIDE_EFFECTS__ +function _ksuid(Class2, params) { + return new Class2({ + type: "string", + format: "ksuid", + check: "string_format", + abort: false, + ...normalizeParams(params) + }); +} +// @__NO_SIDE_EFFECTS__ +function _ipv4(Class2, params) { + return new Class2({ + type: "string", + format: "ipv4", + check: "string_format", + abort: false, + ...normalizeParams(params) + }); +} +// @__NO_SIDE_EFFECTS__ +function _ipv6(Class2, params) { + return new Class2({ + type: "string", + format: "ipv6", + check: "string_format", + abort: false, + ...normalizeParams(params) + }); +} +// @__NO_SIDE_EFFECTS__ +function _cidrv4(Class2, params) { + return new Class2({ + type: "string", + format: "cidrv4", + check: "string_format", + abort: false, + ...normalizeParams(params) + }); +} +// @__NO_SIDE_EFFECTS__ +function _cidrv6(Class2, params) { + return new Class2({ + type: "string", + format: "cidrv6", + check: "string_format", + abort: false, + ...normalizeParams(params) + }); +} +// @__NO_SIDE_EFFECTS__ +function _base64(Class2, params) { + return new Class2({ + type: "string", + format: "base64", + check: "string_format", + abort: false, + ...normalizeParams(params) + }); +} +// @__NO_SIDE_EFFECTS__ +function _base64url(Class2, params) { + return new Class2({ + type: "string", + format: "base64url", + check: "string_format", + abort: false, + ...normalizeParams(params) + }); +} +// @__NO_SIDE_EFFECTS__ +function _e164(Class2, params) { + return new Class2({ + type: "string", + format: "e164", + check: "string_format", + abort: false, + ...normalizeParams(params) + }); +} +// @__NO_SIDE_EFFECTS__ +function _jwt(Class2, params) { + return new Class2({ + type: "string", + format: "jwt", + check: "string_format", + abort: false, + ...normalizeParams(params) + }); +} +// @__NO_SIDE_EFFECTS__ +function _isoDateTime(Class2, params) { + return new Class2({ + type: "string", + format: "datetime", + check: "string_format", + offset: false, + local: false, + precision: null, + ...normalizeParams(params) + }); +} +// @__NO_SIDE_EFFECTS__ +function _isoDate(Class2, params) { + return new Class2({ + type: "string", + format: "date", + check: "string_format", + ...normalizeParams(params) + }); +} +// @__NO_SIDE_EFFECTS__ +function _isoTime(Class2, params) { + return new Class2({ + type: "string", + format: "time", + check: "string_format", + precision: null, + ...normalizeParams(params) + }); +} +// @__NO_SIDE_EFFECTS__ +function _isoDuration(Class2, params) { + return new Class2({ + type: "string", + format: "duration", + check: "string_format", + ...normalizeParams(params) + }); +} +// @__NO_SIDE_EFFECTS__ +function _number(Class2, params) { + return new Class2({ + type: "number", + checks: [], + ...normalizeParams(params) + }); +} +// @__NO_SIDE_EFFECTS__ +function _int(Class2, params) { + return new Class2({ + type: "number", + check: "number_format", + abort: false, + format: "safeint", + ...normalizeParams(params) + }); +} +// @__NO_SIDE_EFFECTS__ +function _unknown(Class2) { + return new Class2({ + type: "unknown" + }); +} +// @__NO_SIDE_EFFECTS__ +function _never(Class2, params) { + return new Class2({ + type: "never", + ...normalizeParams(params) + }); +} +// @__NO_SIDE_EFFECTS__ +function _lt(value, params) { + return new $ZodCheckLessThan({ + check: "less_than", + ...normalizeParams(params), + value, + inclusive: false + }); +} +// @__NO_SIDE_EFFECTS__ +function _lte(value, params) { + return new $ZodCheckLessThan({ + check: "less_than", + ...normalizeParams(params), + value, + inclusive: true + }); +} +// @__NO_SIDE_EFFECTS__ +function _gt(value, params) { + return new $ZodCheckGreaterThan({ + check: "greater_than", + ...normalizeParams(params), + value, + inclusive: false + }); +} +// @__NO_SIDE_EFFECTS__ +function _gte(value, params) { + return new $ZodCheckGreaterThan({ + check: "greater_than", + ...normalizeParams(params), + value, + inclusive: true + }); +} +// @__NO_SIDE_EFFECTS__ +function _multipleOf(value, params) { + return new $ZodCheckMultipleOf({ + check: "multiple_of", + ...normalizeParams(params), + value + }); +} +// @__NO_SIDE_EFFECTS__ +function _maxLength(maximum, params) { + const ch = new $ZodCheckMaxLength({ + check: "max_length", + ...normalizeParams(params), + maximum + }); + return ch; +} +// @__NO_SIDE_EFFECTS__ +function _minLength(minimum, params) { + return new $ZodCheckMinLength({ + check: "min_length", + ...normalizeParams(params), + minimum + }); +} +// @__NO_SIDE_EFFECTS__ +function _length(length, params) { + return new $ZodCheckLengthEquals({ + check: "length_equals", + ...normalizeParams(params), + length + }); +} +// @__NO_SIDE_EFFECTS__ +function _regex(pattern, params) { + return new $ZodCheckRegex({ + check: "string_format", + format: "regex", + ...normalizeParams(params), + pattern + }); +} +// @__NO_SIDE_EFFECTS__ +function _lowercase(params) { + return new $ZodCheckLowerCase({ + check: "string_format", + format: "lowercase", + ...normalizeParams(params) + }); +} +// @__NO_SIDE_EFFECTS__ +function _uppercase(params) { + return new $ZodCheckUpperCase({ + check: "string_format", + format: "uppercase", + ...normalizeParams(params) + }); +} +// @__NO_SIDE_EFFECTS__ +function _includes(includes, params) { + return new $ZodCheckIncludes({ + check: "string_format", + format: "includes", + ...normalizeParams(params), + includes + }); +} +// @__NO_SIDE_EFFECTS__ +function _startsWith(prefix, params) { + return new $ZodCheckStartsWith({ + check: "string_format", + format: "starts_with", + ...normalizeParams(params), + prefix + }); +} +// @__NO_SIDE_EFFECTS__ +function _endsWith(suffix, params) { + return new $ZodCheckEndsWith({ + check: "string_format", + format: "ends_with", + ...normalizeParams(params), + suffix + }); +} +// @__NO_SIDE_EFFECTS__ +function _overwrite(tx) { + return new $ZodCheckOverwrite({ + check: "overwrite", + tx + }); +} +// @__NO_SIDE_EFFECTS__ +function _normalize(form) { + return /* @__PURE__ */ _overwrite((input) => input.normalize(form)); +} +// @__NO_SIDE_EFFECTS__ +function _trim() { + return /* @__PURE__ */ _overwrite((input) => input.trim()); +} +// @__NO_SIDE_EFFECTS__ +function _toLowerCase() { + return /* @__PURE__ */ _overwrite((input) => input.toLowerCase()); +} +// @__NO_SIDE_EFFECTS__ +function _toUpperCase() { + return /* @__PURE__ */ _overwrite((input) => input.toUpperCase()); +} +// @__NO_SIDE_EFFECTS__ +function _slugify() { + return /* @__PURE__ */ _overwrite((input) => slugify(input)); +} +// @__NO_SIDE_EFFECTS__ +function _array(Class2, element, params) { + return new Class2({ + type: "array", + element, + // get element() { + // return element; + // }, + ...normalizeParams(params) + }); +} +// @__NO_SIDE_EFFECTS__ +function _refine(Class2, fn, _params) { + const schema = new Class2({ + type: "custom", + check: "custom", + fn, + ...normalizeParams(_params) + }); + return schema; +} +// @__NO_SIDE_EFFECTS__ +function _superRefine(fn, params) { + const ch = /* @__PURE__ */ _check((payload) => { + payload.addIssue = (issue2) => { + if (typeof issue2 === "string") { + payload.issues.push(issue(issue2, payload.value, ch._zod.def)); + } else { + const _issue = issue2; + if (_issue.fatal) + _issue.continue = false; + _issue.code ?? (_issue.code = "custom"); + _issue.input ?? (_issue.input = payload.value); + _issue.inst ?? (_issue.inst = ch); + _issue.continue ?? (_issue.continue = !ch._zod.def.abort); + payload.issues.push(issue(_issue)); + } + }; + return fn(payload.value, payload); + }, params); + return ch; +} +// @__NO_SIDE_EFFECTS__ +function _check(fn, params) { + const ch = new $ZodCheck({ + check: "custom", + ...normalizeParams(params) + }); + ch._zod.check = fn; + return ch; +} + +// node_modules/zod/v4/core/to-json-schema.js +function initializeContext(params) { + let target = params?.target ?? "draft-2020-12"; + if (target === "draft-4") + target = "draft-04"; + if (target === "draft-7") + target = "draft-07"; + return { + processors: params.processors ?? {}, + metadataRegistry: params?.metadata ?? globalRegistry, + target, + unrepresentable: params?.unrepresentable ?? "throw", + override: params?.override ?? (() => { + }), + io: params?.io ?? "output", + counter: 0, + seen: /* @__PURE__ */ new Map(), + cycles: params?.cycles ?? "ref", + reused: params?.reused ?? "inline", + external: params?.external ?? void 0 + }; +} +function process2(schema, ctx, _params = { path: [], schemaPath: [] }) { + var _a3; + const def = schema._zod.def; + const seen = ctx.seen.get(schema); + if (seen) { + seen.count++; + const isCycle = _params.schemaPath.includes(schema); + if (isCycle) { + seen.cycle = _params.path; + } + return seen.schema; + } + const result = { schema: {}, count: 1, cycle: void 0, path: _params.path }; + ctx.seen.set(schema, result); + const overrideSchema = schema._zod.toJSONSchema?.(); + if (overrideSchema) { + result.schema = overrideSchema; + } else { + const params = { + ..._params, + schemaPath: [..._params.schemaPath, schema], + path: _params.path + }; + if (schema._zod.processJSONSchema) { + schema._zod.processJSONSchema(ctx, result.schema, params); + } else { + const _json = result.schema; + const processor = ctx.processors[def.type]; + if (!processor) { + throw new Error(`[toJSONSchema]: Non-representable type encountered: ${def.type}`); + } + processor(schema, ctx, _json, params); + } + const parent = schema._zod.parent; + if (parent) { + if (!result.ref) + result.ref = parent; + process2(parent, ctx, params); + ctx.seen.get(parent).isParent = true; + } + } + const meta2 = ctx.metadataRegistry.get(schema); + if (meta2) + Object.assign(result.schema, meta2); + if (ctx.io === "input" && isTransforming(schema)) { + delete result.schema.examples; + delete result.schema.default; + } + if (ctx.io === "input" && "_prefault" in result.schema) + (_a3 = result.schema).default ?? (_a3.default = result.schema._prefault); + delete result.schema._prefault; + const _result = ctx.seen.get(schema); + return _result.schema; +} +function extractDefs(ctx, schema) { + const root = ctx.seen.get(schema); + if (!root) + throw new Error("Unprocessed schema. This is a bug in Zod."); + const idToSchema = /* @__PURE__ */ new Map(); + for (const entry of ctx.seen.entries()) { + const id = ctx.metadataRegistry.get(entry[0])?.id; + if (id) { + const existing = idToSchema.get(id); + if (existing && existing !== entry[0]) { + throw new Error(`Duplicate schema id "${id}" detected during JSON Schema conversion. Two different schemas cannot share the same id when converted together.`); + } + idToSchema.set(id, entry[0]); + } + } + const makeURI = (entry) => { + const defsSegment = ctx.target === "draft-2020-12" ? "$defs" : "definitions"; + if (ctx.external) { + const externalId = ctx.external.registry.get(entry[0])?.id; + const uriGenerator = ctx.external.uri ?? ((id2) => id2); + if (externalId) { + return { ref: uriGenerator(externalId) }; + } + const id = entry[1].defId ?? entry[1].schema.id ?? `schema${ctx.counter++}`; + entry[1].defId = id; + return { defId: id, ref: `${uriGenerator("__shared")}#/${defsSegment}/${id}` }; + } + if (entry[1] === root) { + return { ref: "#" }; + } + const uriPrefix = `#`; + const defUriPrefix = `${uriPrefix}/${defsSegment}/`; + const defId = entry[1].schema.id ?? `__schema${ctx.counter++}`; + return { defId, ref: defUriPrefix + defId }; + }; + const extractToDef = (entry) => { + if (entry[1].schema.$ref) { + return; + } + const seen = entry[1]; + const { ref, defId } = makeURI(entry); + seen.def = { ...seen.schema }; + if (defId) + seen.defId = defId; + const schema2 = seen.schema; + for (const key in schema2) { + delete schema2[key]; + } + schema2.$ref = ref; + }; + if (ctx.cycles === "throw") { + for (const entry of ctx.seen.entries()) { + const seen = entry[1]; + if (seen.cycle) { + throw new Error(`Cycle detected: #/${seen.cycle?.join("/")}/ + +Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.`); + } + } + } + for (const entry of ctx.seen.entries()) { + const seen = entry[1]; + if (schema === entry[0]) { + extractToDef(entry); + continue; + } + if (ctx.external) { + const ext = ctx.external.registry.get(entry[0])?.id; + if (schema !== entry[0] && ext) { + extractToDef(entry); + continue; + } + } + const id = ctx.metadataRegistry.get(entry[0])?.id; + if (id) { + extractToDef(entry); + continue; + } + if (seen.cycle) { + extractToDef(entry); + continue; + } + if (seen.count > 1) { + if (ctx.reused === "ref") { + extractToDef(entry); + continue; + } + } + } +} +function finalize(ctx, schema) { + const root = ctx.seen.get(schema); + if (!root) + throw new Error("Unprocessed schema. This is a bug in Zod."); + const flattenRef = (zodSchema) => { + const seen = ctx.seen.get(zodSchema); + if (seen.ref === null) + return; + const schema2 = seen.def ?? seen.schema; + const _cached = { ...schema2 }; + const ref = seen.ref; + seen.ref = null; + if (ref) { + flattenRef(ref); + const refSeen = ctx.seen.get(ref); + const refSchema = refSeen.schema; + if (refSchema.$ref && (ctx.target === "draft-07" || ctx.target === "draft-04" || ctx.target === "openapi-3.0")) { + schema2.allOf = schema2.allOf ?? []; + schema2.allOf.push(refSchema); + } else { + Object.assign(schema2, refSchema); + } + Object.assign(schema2, _cached); + const isParentRef = zodSchema._zod.parent === ref; + if (isParentRef) { + for (const key in schema2) { + if (key === "$ref" || key === "allOf") + continue; + if (!(key in _cached)) { + delete schema2[key]; + } + } + } + if (refSchema.$ref && refSeen.def) { + for (const key in schema2) { + if (key === "$ref" || key === "allOf") + continue; + if (key in refSeen.def && JSON.stringify(schema2[key]) === JSON.stringify(refSeen.def[key])) { + delete schema2[key]; + } + } + } + } + const parent = zodSchema._zod.parent; + if (parent && parent !== ref) { + flattenRef(parent); + const parentSeen = ctx.seen.get(parent); + if (parentSeen?.schema.$ref) { + schema2.$ref = parentSeen.schema.$ref; + if (parentSeen.def) { + for (const key in schema2) { + if (key === "$ref" || key === "allOf") + continue; + if (key in parentSeen.def && JSON.stringify(schema2[key]) === JSON.stringify(parentSeen.def[key])) { + delete schema2[key]; + } + } + } + } + } + ctx.override({ + zodSchema, + jsonSchema: schema2, + path: seen.path ?? [] + }); + }; + for (const entry of [...ctx.seen.entries()].reverse()) { + flattenRef(entry[0]); + } + const result = {}; + if (ctx.target === "draft-2020-12") { + result.$schema = "https://json-schema.org/draft/2020-12/schema"; + } else if (ctx.target === "draft-07") { + result.$schema = "http://json-schema.org/draft-07/schema#"; + } else if (ctx.target === "draft-04") { + result.$schema = "http://json-schema.org/draft-04/schema#"; + } else if (ctx.target === "openapi-3.0") { + } else { + } + if (ctx.external?.uri) { + const id = ctx.external.registry.get(schema)?.id; + if (!id) + throw new Error("Schema is missing an `id` property"); + result.$id = ctx.external.uri(id); + } + Object.assign(result, root.def ?? root.schema); + const rootMetaId = ctx.metadataRegistry.get(schema)?.id; + if (rootMetaId !== void 0 && result.id === rootMetaId) + delete result.id; + const defs = ctx.external?.defs ?? {}; + for (const entry of ctx.seen.entries()) { + const seen = entry[1]; + if (seen.def && seen.defId) { + if (seen.def.id === seen.defId) + delete seen.def.id; + defs[seen.defId] = seen.def; + } + } + if (ctx.external) { + } else { + if (Object.keys(defs).length > 0) { + if (ctx.target === "draft-2020-12") { + result.$defs = defs; + } else { + result.definitions = defs; + } + } + } + try { + const finalized = JSON.parse(JSON.stringify(result)); + Object.defineProperty(finalized, "~standard", { + value: { + ...schema["~standard"], + jsonSchema: { + input: createStandardJSONSchemaMethod(schema, "input", ctx.processors), + output: createStandardJSONSchemaMethod(schema, "output", ctx.processors) + } + }, + enumerable: false, + writable: false + }); + return finalized; + } catch (_err) { + throw new Error("Error converting schema to JSON."); + } +} +function isTransforming(_schema, _ctx) { + const ctx = _ctx ?? { seen: /* @__PURE__ */ new Set() }; + if (ctx.seen.has(_schema)) + return false; + ctx.seen.add(_schema); + const def = _schema._zod.def; + if (def.type === "transform") + return true; + if (def.type === "array") + return isTransforming(def.element, ctx); + if (def.type === "set") + return isTransforming(def.valueType, ctx); + if (def.type === "lazy") + return isTransforming(def.getter(), ctx); + if (def.type === "promise" || def.type === "optional" || def.type === "nonoptional" || def.type === "nullable" || def.type === "readonly" || def.type === "default" || def.type === "prefault") { + return isTransforming(def.innerType, ctx); + } + if (def.type === "intersection") { + return isTransforming(def.left, ctx) || isTransforming(def.right, ctx); + } + if (def.type === "record" || def.type === "map") { + return isTransforming(def.keyType, ctx) || isTransforming(def.valueType, ctx); + } + if (def.type === "pipe") { + if (_schema._zod.traits.has("$ZodCodec")) + return true; + return isTransforming(def.in, ctx) || isTransforming(def.out, ctx); + } + if (def.type === "object") { + for (const key in def.shape) { + if (isTransforming(def.shape[key], ctx)) + return true; + } + return false; + } + if (def.type === "union") { + for (const option of def.options) { + if (isTransforming(option, ctx)) + return true; + } + return false; + } + if (def.type === "tuple") { + for (const item of def.items) { + if (isTransforming(item, ctx)) + return true; + } + if (def.rest && isTransforming(def.rest, ctx)) + return true; + return false; + } + return false; +} +var createToJSONSchemaMethod = (schema, processors = {}) => (params) => { + const ctx = initializeContext({ ...params, processors }); + process2(schema, ctx); + extractDefs(ctx, schema); + return finalize(ctx, schema); +}; +var createStandardJSONSchemaMethod = (schema, io, processors = {}) => (params) => { + const { libraryOptions, target } = params ?? {}; + const ctx = initializeContext({ ...libraryOptions ?? {}, target, io, processors }); + process2(schema, ctx); + extractDefs(ctx, schema); + return finalize(ctx, schema); +}; + +// node_modules/zod/v4/core/json-schema-processors.js +var formatMap = { + guid: "uuid", + url: "uri", + datetime: "date-time", + json_string: "json-string", + regex: "" + // do not set +}; +var stringProcessor = (schema, ctx, _json, _params) => { + const json = _json; + json.type = "string"; + const { minimum, maximum, format, patterns, contentEncoding } = schema._zod.bag; + if (typeof minimum === "number") + json.minLength = minimum; + if (typeof maximum === "number") + json.maxLength = maximum; + if (format) { + json.format = formatMap[format] ?? format; + if (json.format === "") + delete json.format; + if (format === "time") { + delete json.format; + } + } + if (contentEncoding) + json.contentEncoding = contentEncoding; + if (patterns && patterns.size > 0) { + const regexes = [...patterns]; + if (regexes.length === 1) + json.pattern = regexes[0].source; + else if (regexes.length > 1) { + json.allOf = [ + ...regexes.map((regex) => ({ + ...ctx.target === "draft-07" || ctx.target === "draft-04" || ctx.target === "openapi-3.0" ? { type: "string" } : {}, + pattern: regex.source + })) + ]; + } + } +}; +var numberProcessor = (schema, ctx, _json, _params) => { + const json = _json; + const { minimum, maximum, format, multipleOf, exclusiveMaximum, exclusiveMinimum } = schema._zod.bag; + if (typeof format === "string" && format.includes("int")) + json.type = "integer"; + else + json.type = "number"; + const exMin = typeof exclusiveMinimum === "number" && exclusiveMinimum >= (minimum ?? Number.NEGATIVE_INFINITY); + const exMax = typeof exclusiveMaximum === "number" && exclusiveMaximum <= (maximum ?? Number.POSITIVE_INFINITY); + const legacy = ctx.target === "draft-04" || ctx.target === "openapi-3.0"; + if (exMin) { + if (legacy) { + json.minimum = exclusiveMinimum; + json.exclusiveMinimum = true; + } else { + json.exclusiveMinimum = exclusiveMinimum; + } + } else if (typeof minimum === "number") { + json.minimum = minimum; + } + if (exMax) { + if (legacy) { + json.maximum = exclusiveMaximum; + json.exclusiveMaximum = true; + } else { + json.exclusiveMaximum = exclusiveMaximum; + } + } else if (typeof maximum === "number") { + json.maximum = maximum; + } + if (typeof multipleOf === "number") + json.multipleOf = multipleOf; +}; +var neverProcessor = (_schema, _ctx, json, _params) => { + json.not = {}; +}; +var unknownProcessor = (_schema, _ctx, _json, _params) => { +}; +var enumProcessor = (schema, _ctx, json, _params) => { + const def = schema._zod.def; + const values = getEnumValues(def.entries); + if (values.every((v) => typeof v === "number")) + json.type = "number"; + if (values.every((v) => typeof v === "string")) + json.type = "string"; + json.enum = values; +}; +var customProcessor = (_schema, ctx, _json, _params) => { + if (ctx.unrepresentable === "throw") { + throw new Error("Custom types cannot be represented in JSON Schema"); + } +}; +var transformProcessor = (_schema, ctx, _json, _params) => { + if (ctx.unrepresentable === "throw") { + throw new Error("Transforms cannot be represented in JSON Schema"); + } +}; +var arrayProcessor = (schema, ctx, _json, params) => { + const json = _json; + const def = schema._zod.def; + const { minimum, maximum } = schema._zod.bag; + if (typeof minimum === "number") + json.minItems = minimum; + if (typeof maximum === "number") + json.maxItems = maximum; + json.type = "array"; + json.items = process2(def.element, ctx, { + ...params, + path: [...params.path, "items"] + }); +}; +var objectProcessor = (schema, ctx, _json, params) => { + const json = _json; + const def = schema._zod.def; + json.type = "object"; + json.properties = {}; + const shape = def.shape; + for (const key in shape) { + json.properties[key] = process2(shape[key], ctx, { + ...params, + path: [...params.path, "properties", key] + }); + } + const allKeys = new Set(Object.keys(shape)); + const requiredKeys = new Set([...allKeys].filter((key) => { + const v = def.shape[key]._zod; + if (ctx.io === "input") { + return v.optin === void 0; + } else { + return v.optout === void 0; + } + })); + if (requiredKeys.size > 0) { + json.required = Array.from(requiredKeys); + } + if (def.catchall?._zod.def.type === "never") { + json.additionalProperties = false; + } else if (!def.catchall) { + if (ctx.io === "output") + json.additionalProperties = false; + } else if (def.catchall) { + json.additionalProperties = process2(def.catchall, ctx, { + ...params, + path: [...params.path, "additionalProperties"] + }); + } +}; +var unionProcessor = (schema, ctx, json, params) => { + const def = schema._zod.def; + const isExclusive = def.inclusive === false; + const options = def.options.map((x, i) => process2(x, ctx, { + ...params, + path: [...params.path, isExclusive ? "oneOf" : "anyOf", i] + })); + if (isExclusive) { + json.oneOf = options; + } else { + json.anyOf = options; + } +}; +var intersectionProcessor = (schema, ctx, json, params) => { + const def = schema._zod.def; + const a = process2(def.left, ctx, { + ...params, + path: [...params.path, "allOf", 0] + }); + const b = process2(def.right, ctx, { + ...params, + path: [...params.path, "allOf", 1] + }); + const isSimpleIntersection = (val) => "allOf" in val && Object.keys(val).length === 1; + const allOf = [ + ...isSimpleIntersection(a) ? a.allOf : [a], + ...isSimpleIntersection(b) ? b.allOf : [b] + ]; + json.allOf = allOf; +}; +var recordProcessor = (schema, ctx, _json, params) => { + const json = _json; + const def = schema._zod.def; + json.type = "object"; + const keyType = def.keyType; + const keyBag = keyType._zod.bag; + const patterns = keyBag?.patterns; + if (def.mode === "loose" && patterns && patterns.size > 0) { + const valueSchema = process2(def.valueType, ctx, { + ...params, + path: [...params.path, "patternProperties", "*"] + }); + json.patternProperties = {}; + for (const pattern of patterns) { + json.patternProperties[pattern.source] = valueSchema; + } + } else { + if (ctx.target === "draft-07" || ctx.target === "draft-2020-12") { + json.propertyNames = process2(def.keyType, ctx, { + ...params, + path: [...params.path, "propertyNames"] + }); + } + json.additionalProperties = process2(def.valueType, ctx, { + ...params, + path: [...params.path, "additionalProperties"] + }); + } + const keyValues = keyType._zod.values; + if (keyValues) { + const validKeyValues = [...keyValues].filter((v) => typeof v === "string" || typeof v === "number"); + if (validKeyValues.length > 0) { + json.required = validKeyValues; + } + } +}; +var nullableProcessor = (schema, ctx, json, params) => { + const def = schema._zod.def; + const inner = process2(def.innerType, ctx, params); + const seen = ctx.seen.get(schema); + if (ctx.target === "openapi-3.0") { + seen.ref = def.innerType; + json.nullable = true; + } else { + json.anyOf = [inner, { type: "null" }]; + } +}; +var nonoptionalProcessor = (schema, ctx, _json, params) => { + const def = schema._zod.def; + process2(def.innerType, ctx, params); + const seen = ctx.seen.get(schema); + seen.ref = def.innerType; +}; +var defaultProcessor = (schema, ctx, json, params) => { + const def = schema._zod.def; + process2(def.innerType, ctx, params); + const seen = ctx.seen.get(schema); + seen.ref = def.innerType; + json.default = JSON.parse(JSON.stringify(def.defaultValue)); +}; +var prefaultProcessor = (schema, ctx, json, params) => { + const def = schema._zod.def; + process2(def.innerType, ctx, params); + const seen = ctx.seen.get(schema); + seen.ref = def.innerType; + if (ctx.io === "input") + json._prefault = JSON.parse(JSON.stringify(def.defaultValue)); +}; +var catchProcessor = (schema, ctx, json, params) => { + const def = schema._zod.def; + process2(def.innerType, ctx, params); + const seen = ctx.seen.get(schema); + seen.ref = def.innerType; + let catchValue; + try { + catchValue = def.catchValue(void 0); + } catch { + throw new Error("Dynamic catch values are not supported in JSON Schema"); + } + json.default = catchValue; +}; +var pipeProcessor = (schema, ctx, _json, params) => { + const def = schema._zod.def; + const inIsTransform = def.in._zod.traits.has("$ZodTransform"); + const innerType = ctx.io === "input" ? inIsTransform ? def.out : def.in : def.out; + process2(innerType, ctx, params); + const seen = ctx.seen.get(schema); + seen.ref = innerType; +}; +var readonlyProcessor = (schema, ctx, json, params) => { + const def = schema._zod.def; + process2(def.innerType, ctx, params); + const seen = ctx.seen.get(schema); + seen.ref = def.innerType; + json.readOnly = true; +}; +var optionalProcessor = (schema, ctx, _json, params) => { + const def = schema._zod.def; + process2(def.innerType, ctx, params); + const seen = ctx.seen.get(schema); + seen.ref = def.innerType; +}; + +// node_modules/zod/v4/classic/iso.js +var ZodISODateTime = /* @__PURE__ */ $constructor("ZodISODateTime", (inst, def) => { + $ZodISODateTime.init(inst, def); + ZodStringFormat.init(inst, def); +}); +function datetime2(params) { + return _isoDateTime(ZodISODateTime, params); +} +var ZodISODate = /* @__PURE__ */ $constructor("ZodISODate", (inst, def) => { + $ZodISODate.init(inst, def); + ZodStringFormat.init(inst, def); +}); +function date2(params) { + return _isoDate(ZodISODate, params); +} +var ZodISOTime = /* @__PURE__ */ $constructor("ZodISOTime", (inst, def) => { + $ZodISOTime.init(inst, def); + ZodStringFormat.init(inst, def); +}); +function time2(params) { + return _isoTime(ZodISOTime, params); +} +var ZodISODuration = /* @__PURE__ */ $constructor("ZodISODuration", (inst, def) => { + $ZodISODuration.init(inst, def); + ZodStringFormat.init(inst, def); +}); +function duration2(params) { + return _isoDuration(ZodISODuration, params); +} + +// node_modules/zod/v4/classic/errors.js +var initializer2 = (inst, issues) => { + $ZodError.init(inst, issues); + inst.name = "ZodError"; + Object.defineProperties(inst, { + format: { + value: (mapper) => formatError(inst, mapper) + // enumerable: false, + }, + flatten: { + value: (mapper) => flattenError(inst, mapper) + // enumerable: false, + }, + addIssue: { + value: (issue2) => { + inst.issues.push(issue2); + inst.message = JSON.stringify(inst.issues, jsonStringifyReplacer, 2); + } + // enumerable: false, + }, + addIssues: { + value: (issues2) => { + inst.issues.push(...issues2); + inst.message = JSON.stringify(inst.issues, jsonStringifyReplacer, 2); + } + // enumerable: false, + }, + isEmpty: { + get() { + return inst.issues.length === 0; + } + // enumerable: false, + } + }); +}; +var ZodRealError = /* @__PURE__ */ $constructor("ZodError", initializer2, { + Parent: Error +}); + +// node_modules/zod/v4/classic/parse.js +var parse2 = /* @__PURE__ */ _parse(ZodRealError); +var parseAsync2 = /* @__PURE__ */ _parseAsync(ZodRealError); +var safeParse2 = /* @__PURE__ */ _safeParse(ZodRealError); +var safeParseAsync2 = /* @__PURE__ */ _safeParseAsync(ZodRealError); +var encode = /* @__PURE__ */ _encode(ZodRealError); +var decode = /* @__PURE__ */ _decode(ZodRealError); +var encodeAsync = /* @__PURE__ */ _encodeAsync(ZodRealError); +var decodeAsync = /* @__PURE__ */ _decodeAsync(ZodRealError); +var safeEncode = /* @__PURE__ */ _safeEncode(ZodRealError); +var safeDecode = /* @__PURE__ */ _safeDecode(ZodRealError); +var safeEncodeAsync = /* @__PURE__ */ _safeEncodeAsync(ZodRealError); +var safeDecodeAsync = /* @__PURE__ */ _safeDecodeAsync(ZodRealError); + +// node_modules/zod/v4/classic/schemas.js +var _installedGroups = /* @__PURE__ */ new WeakMap(); +function _installLazyMethods(inst, group, methods) { + const proto = Object.getPrototypeOf(inst); + let installed = _installedGroups.get(proto); + if (!installed) { + installed = /* @__PURE__ */ new Set(); + _installedGroups.set(proto, installed); + } + if (installed.has(group)) + return; + installed.add(group); + for (const key in methods) { + const fn = methods[key]; + Object.defineProperty(proto, key, { + configurable: true, + enumerable: false, + get() { + const bound = fn.bind(this); + Object.defineProperty(this, key, { + configurable: true, + writable: true, + enumerable: true, + value: bound + }); + return bound; + }, + set(v) { + Object.defineProperty(this, key, { + configurable: true, + writable: true, + enumerable: true, + value: v + }); + } + }); + } +} +var ZodType = /* @__PURE__ */ $constructor("ZodType", (inst, def) => { + $ZodType.init(inst, def); + Object.assign(inst["~standard"], { + jsonSchema: { + input: createStandardJSONSchemaMethod(inst, "input"), + output: createStandardJSONSchemaMethod(inst, "output") + } + }); + inst.toJSONSchema = createToJSONSchemaMethod(inst, {}); + inst.def = def; + inst.type = def.type; + Object.defineProperty(inst, "_def", { value: def }); + inst.parse = (data, params) => parse2(inst, data, params, { callee: inst.parse }); + inst.safeParse = (data, params) => safeParse2(inst, data, params); + inst.parseAsync = async (data, params) => parseAsync2(inst, data, params, { callee: inst.parseAsync }); + inst.safeParseAsync = async (data, params) => safeParseAsync2(inst, data, params); + inst.spa = inst.safeParseAsync; + inst.encode = (data, params) => encode(inst, data, params); + inst.decode = (data, params) => decode(inst, data, params); + inst.encodeAsync = async (data, params) => encodeAsync(inst, data, params); + inst.decodeAsync = async (data, params) => decodeAsync(inst, data, params); + inst.safeEncode = (data, params) => safeEncode(inst, data, params); + inst.safeDecode = (data, params) => safeDecode(inst, data, params); + inst.safeEncodeAsync = async (data, params) => safeEncodeAsync(inst, data, params); + inst.safeDecodeAsync = async (data, params) => safeDecodeAsync(inst, data, params); + _installLazyMethods(inst, "ZodType", { + check(...chks) { + const def2 = this.def; + return this.clone(util_exports.mergeDefs(def2, { + checks: [ + ...def2.checks ?? [], + ...chks.map((ch) => typeof ch === "function" ? { _zod: { check: ch, def: { check: "custom" }, onattach: [] } } : ch) + ] + }), { parent: true }); + }, + with(...chks) { + return this.check(...chks); + }, + clone(def2, params) { + return clone(this, def2, params); + }, + brand() { + return this; + }, + register(reg, meta2) { + reg.add(this, meta2); + return this; + }, + refine(check, params) { + return this.check(refine(check, params)); + }, + superRefine(refinement, params) { + return this.check(superRefine(refinement, params)); + }, + overwrite(fn) { + return this.check(_overwrite(fn)); + }, + optional() { + return optional(this); + }, + exactOptional() { + return exactOptional(this); + }, + nullable() { + return nullable(this); + }, + nullish() { + return optional(nullable(this)); + }, + nonoptional(params) { + return nonoptional(this, params); + }, + array() { + return array(this); + }, + or(arg) { + return union([this, arg]); + }, + and(arg) { + return intersection(this, arg); + }, + transform(tx) { + return pipe(this, transform(tx)); + }, + default(d) { + return _default(this, d); + }, + prefault(d) { + return prefault(this, d); + }, + catch(params) { + return _catch(this, params); + }, + pipe(target) { + return pipe(this, target); + }, + readonly() { + return readonly(this); + }, + describe(description) { + const cl = this.clone(); + globalRegistry.add(cl, { description }); + return cl; + }, + meta(...args) { + if (args.length === 0) + return globalRegistry.get(this); + const cl = this.clone(); + globalRegistry.add(cl, args[0]); + return cl; + }, + isOptional() { + return this.safeParse(void 0).success; + }, + isNullable() { + return this.safeParse(null).success; + }, + apply(fn) { + return fn(this); + } + }); + Object.defineProperty(inst, "description", { + get() { + return globalRegistry.get(inst)?.description; + }, + configurable: true + }); + return inst; +}); +var _ZodString = /* @__PURE__ */ $constructor("_ZodString", (inst, def) => { + $ZodString.init(inst, def); + ZodType.init(inst, def); + inst._zod.processJSONSchema = (ctx, json, params) => stringProcessor(inst, ctx, json, params); + const bag = inst._zod.bag; + inst.format = bag.format ?? null; + inst.minLength = bag.minimum ?? null; + inst.maxLength = bag.maximum ?? null; + _installLazyMethods(inst, "_ZodString", { + regex(...args) { + return this.check(_regex(...args)); + }, + includes(...args) { + return this.check(_includes(...args)); + }, + startsWith(...args) { + return this.check(_startsWith(...args)); + }, + endsWith(...args) { + return this.check(_endsWith(...args)); + }, + min(...args) { + return this.check(_minLength(...args)); + }, + max(...args) { + return this.check(_maxLength(...args)); + }, + length(...args) { + return this.check(_length(...args)); + }, + nonempty(...args) { + return this.check(_minLength(1, ...args)); + }, + lowercase(params) { + return this.check(_lowercase(params)); + }, + uppercase(params) { + return this.check(_uppercase(params)); + }, + trim() { + return this.check(_trim()); + }, + normalize(...args) { + return this.check(_normalize(...args)); + }, + toLowerCase() { + return this.check(_toLowerCase()); + }, + toUpperCase() { + return this.check(_toUpperCase()); + }, + slugify() { + return this.check(_slugify()); + } + }); +}); +var ZodString = /* @__PURE__ */ $constructor("ZodString", (inst, def) => { + $ZodString.init(inst, def); + _ZodString.init(inst, def); + inst.email = (params) => inst.check(_email(ZodEmail, params)); + inst.url = (params) => inst.check(_url(ZodURL, params)); + inst.jwt = (params) => inst.check(_jwt(ZodJWT, params)); + inst.emoji = (params) => inst.check(_emoji2(ZodEmoji, params)); + inst.guid = (params) => inst.check(_guid(ZodGUID, params)); + inst.uuid = (params) => inst.check(_uuid(ZodUUID, params)); + inst.uuidv4 = (params) => inst.check(_uuidv4(ZodUUID, params)); + inst.uuidv6 = (params) => inst.check(_uuidv6(ZodUUID, params)); + inst.uuidv7 = (params) => inst.check(_uuidv7(ZodUUID, params)); + inst.nanoid = (params) => inst.check(_nanoid(ZodNanoID, params)); + inst.guid = (params) => inst.check(_guid(ZodGUID, params)); + inst.cuid = (params) => inst.check(_cuid(ZodCUID, params)); + inst.cuid2 = (params) => inst.check(_cuid2(ZodCUID2, params)); + inst.ulid = (params) => inst.check(_ulid(ZodULID, params)); + inst.base64 = (params) => inst.check(_base64(ZodBase64, params)); + inst.base64url = (params) => inst.check(_base64url(ZodBase64URL, params)); + inst.xid = (params) => inst.check(_xid(ZodXID, params)); + inst.ksuid = (params) => inst.check(_ksuid(ZodKSUID, params)); + inst.ipv4 = (params) => inst.check(_ipv4(ZodIPv4, params)); + inst.ipv6 = (params) => inst.check(_ipv6(ZodIPv6, params)); + inst.cidrv4 = (params) => inst.check(_cidrv4(ZodCIDRv4, params)); + inst.cidrv6 = (params) => inst.check(_cidrv6(ZodCIDRv6, params)); + inst.e164 = (params) => inst.check(_e164(ZodE164, params)); + inst.datetime = (params) => inst.check(datetime2(params)); + inst.date = (params) => inst.check(date2(params)); + inst.time = (params) => inst.check(time2(params)); + inst.duration = (params) => inst.check(duration2(params)); +}); +function string2(params) { + return _string(ZodString, params); +} +var ZodStringFormat = /* @__PURE__ */ $constructor("ZodStringFormat", (inst, def) => { + $ZodStringFormat.init(inst, def); + _ZodString.init(inst, def); +}); +var ZodEmail = /* @__PURE__ */ $constructor("ZodEmail", (inst, def) => { + $ZodEmail.init(inst, def); + ZodStringFormat.init(inst, def); +}); +var ZodGUID = /* @__PURE__ */ $constructor("ZodGUID", (inst, def) => { + $ZodGUID.init(inst, def); + ZodStringFormat.init(inst, def); +}); +var ZodUUID = /* @__PURE__ */ $constructor("ZodUUID", (inst, def) => { + $ZodUUID.init(inst, def); + ZodStringFormat.init(inst, def); +}); +var ZodURL = /* @__PURE__ */ $constructor("ZodURL", (inst, def) => { + $ZodURL.init(inst, def); + ZodStringFormat.init(inst, def); +}); +var ZodEmoji = /* @__PURE__ */ $constructor("ZodEmoji", (inst, def) => { + $ZodEmoji.init(inst, def); + ZodStringFormat.init(inst, def); +}); +var ZodNanoID = /* @__PURE__ */ $constructor("ZodNanoID", (inst, def) => { + $ZodNanoID.init(inst, def); + ZodStringFormat.init(inst, def); +}); +var ZodCUID = /* @__PURE__ */ $constructor("ZodCUID", (inst, def) => { + $ZodCUID.init(inst, def); + ZodStringFormat.init(inst, def); +}); +var ZodCUID2 = /* @__PURE__ */ $constructor("ZodCUID2", (inst, def) => { + $ZodCUID2.init(inst, def); + ZodStringFormat.init(inst, def); +}); +var ZodULID = /* @__PURE__ */ $constructor("ZodULID", (inst, def) => { + $ZodULID.init(inst, def); + ZodStringFormat.init(inst, def); +}); +var ZodXID = /* @__PURE__ */ $constructor("ZodXID", (inst, def) => { + $ZodXID.init(inst, def); + ZodStringFormat.init(inst, def); +}); +var ZodKSUID = /* @__PURE__ */ $constructor("ZodKSUID", (inst, def) => { + $ZodKSUID.init(inst, def); + ZodStringFormat.init(inst, def); +}); +var ZodIPv4 = /* @__PURE__ */ $constructor("ZodIPv4", (inst, def) => { + $ZodIPv4.init(inst, def); + ZodStringFormat.init(inst, def); +}); +var ZodIPv6 = /* @__PURE__ */ $constructor("ZodIPv6", (inst, def) => { + $ZodIPv6.init(inst, def); + ZodStringFormat.init(inst, def); +}); +var ZodCIDRv4 = /* @__PURE__ */ $constructor("ZodCIDRv4", (inst, def) => { + $ZodCIDRv4.init(inst, def); + ZodStringFormat.init(inst, def); +}); +var ZodCIDRv6 = /* @__PURE__ */ $constructor("ZodCIDRv6", (inst, def) => { + $ZodCIDRv6.init(inst, def); + ZodStringFormat.init(inst, def); +}); +var ZodBase64 = /* @__PURE__ */ $constructor("ZodBase64", (inst, def) => { + $ZodBase64.init(inst, def); + ZodStringFormat.init(inst, def); +}); +var ZodBase64URL = /* @__PURE__ */ $constructor("ZodBase64URL", (inst, def) => { + $ZodBase64URL.init(inst, def); + ZodStringFormat.init(inst, def); +}); +var ZodE164 = /* @__PURE__ */ $constructor("ZodE164", (inst, def) => { + $ZodE164.init(inst, def); + ZodStringFormat.init(inst, def); +}); +var ZodJWT = /* @__PURE__ */ $constructor("ZodJWT", (inst, def) => { + $ZodJWT.init(inst, def); + ZodStringFormat.init(inst, def); +}); +var ZodNumber = /* @__PURE__ */ $constructor("ZodNumber", (inst, def) => { + $ZodNumber.init(inst, def); + ZodType.init(inst, def); + inst._zod.processJSONSchema = (ctx, json, params) => numberProcessor(inst, ctx, json, params); + _installLazyMethods(inst, "ZodNumber", { + gt(value, params) { + return this.check(_gt(value, params)); + }, + gte(value, params) { + return this.check(_gte(value, params)); + }, + min(value, params) { + return this.check(_gte(value, params)); + }, + lt(value, params) { + return this.check(_lt(value, params)); + }, + lte(value, params) { + return this.check(_lte(value, params)); + }, + max(value, params) { + return this.check(_lte(value, params)); + }, + int(params) { + return this.check(int(params)); + }, + safe(params) { + return this.check(int(params)); + }, + positive(params) { + return this.check(_gt(0, params)); + }, + nonnegative(params) { + return this.check(_gte(0, params)); + }, + negative(params) { + return this.check(_lt(0, params)); + }, + nonpositive(params) { + return this.check(_lte(0, params)); + }, + multipleOf(value, params) { + return this.check(_multipleOf(value, params)); + }, + step(value, params) { + return this.check(_multipleOf(value, params)); + }, + finite() { + return this; + } + }); + const bag = inst._zod.bag; + inst.minValue = Math.max(bag.minimum ?? Number.NEGATIVE_INFINITY, bag.exclusiveMinimum ?? Number.NEGATIVE_INFINITY) ?? null; + inst.maxValue = Math.min(bag.maximum ?? Number.POSITIVE_INFINITY, bag.exclusiveMaximum ?? Number.POSITIVE_INFINITY) ?? null; + inst.isInt = (bag.format ?? "").includes("int") || Number.isSafeInteger(bag.multipleOf ?? 0.5); + inst.isFinite = true; + inst.format = bag.format ?? null; +}); +function number2(params) { + return _number(ZodNumber, params); +} +var ZodNumberFormat = /* @__PURE__ */ $constructor("ZodNumberFormat", (inst, def) => { + $ZodNumberFormat.init(inst, def); + ZodNumber.init(inst, def); +}); +function int(params) { + return _int(ZodNumberFormat, params); +} +var ZodUnknown = /* @__PURE__ */ $constructor("ZodUnknown", (inst, def) => { + $ZodUnknown.init(inst, def); + ZodType.init(inst, def); + inst._zod.processJSONSchema = (ctx, json, params) => unknownProcessor(inst, ctx, json, params); +}); +function unknown() { + return _unknown(ZodUnknown); +} +var ZodNever = /* @__PURE__ */ $constructor("ZodNever", (inst, def) => { + $ZodNever.init(inst, def); + ZodType.init(inst, def); + inst._zod.processJSONSchema = (ctx, json, params) => neverProcessor(inst, ctx, json, params); +}); +function never(params) { + return _never(ZodNever, params); +} +var ZodArray = /* @__PURE__ */ $constructor("ZodArray", (inst, def) => { + $ZodArray.init(inst, def); + ZodType.init(inst, def); + inst._zod.processJSONSchema = (ctx, json, params) => arrayProcessor(inst, ctx, json, params); + inst.element = def.element; + _installLazyMethods(inst, "ZodArray", { + min(n, params) { + return this.check(_minLength(n, params)); + }, + nonempty(params) { + return this.check(_minLength(1, params)); + }, + max(n, params) { + return this.check(_maxLength(n, params)); + }, + length(n, params) { + return this.check(_length(n, params)); + }, + unwrap() { + return this.element; + } + }); +}); +function array(element, params) { + return _array(ZodArray, element, params); +} +var ZodObject = /* @__PURE__ */ $constructor("ZodObject", (inst, def) => { + $ZodObjectJIT.init(inst, def); + ZodType.init(inst, def); + inst._zod.processJSONSchema = (ctx, json, params) => objectProcessor(inst, ctx, json, params); + util_exports.defineLazy(inst, "shape", () => { + return def.shape; + }); + _installLazyMethods(inst, "ZodObject", { + keyof() { + return _enum(Object.keys(this._zod.def.shape)); + }, + catchall(catchall) { + return this.clone({ ...this._zod.def, catchall }); + }, + passthrough() { + return this.clone({ ...this._zod.def, catchall: unknown() }); + }, + loose() { + return this.clone({ ...this._zod.def, catchall: unknown() }); + }, + strict() { + return this.clone({ ...this._zod.def, catchall: never() }); + }, + strip() { + return this.clone({ ...this._zod.def, catchall: void 0 }); + }, + extend(incoming) { + return util_exports.extend(this, incoming); + }, + safeExtend(incoming) { + return util_exports.safeExtend(this, incoming); + }, + merge(other) { + return util_exports.merge(this, other); + }, + pick(mask) { + return util_exports.pick(this, mask); + }, + omit(mask) { + return util_exports.omit(this, mask); + }, + partial(...args) { + return util_exports.partial(ZodOptional, this, args[0]); + }, + required(...args) { + return util_exports.required(ZodNonOptional, this, args[0]); + } + }); +}); +function object(shape, params) { + const def = { + type: "object", + shape: shape ?? {}, + ...util_exports.normalizeParams(params) + }; + return new ZodObject(def); +} +var ZodUnion = /* @__PURE__ */ $constructor("ZodUnion", (inst, def) => { + $ZodUnion.init(inst, def); + ZodType.init(inst, def); + inst._zod.processJSONSchema = (ctx, json, params) => unionProcessor(inst, ctx, json, params); + inst.options = def.options; +}); +function union(options, params) { + return new ZodUnion({ + type: "union", + options, + ...util_exports.normalizeParams(params) + }); +} +var ZodIntersection = /* @__PURE__ */ $constructor("ZodIntersection", (inst, def) => { + $ZodIntersection.init(inst, def); + ZodType.init(inst, def); + inst._zod.processJSONSchema = (ctx, json, params) => intersectionProcessor(inst, ctx, json, params); +}); +function intersection(left, right) { + return new ZodIntersection({ + type: "intersection", + left, + right + }); +} +var ZodRecord = /* @__PURE__ */ $constructor("ZodRecord", (inst, def) => { + $ZodRecord.init(inst, def); + ZodType.init(inst, def); + inst._zod.processJSONSchema = (ctx, json, params) => recordProcessor(inst, ctx, json, params); + inst.keyType = def.keyType; + inst.valueType = def.valueType; +}); +function record(keyType, valueType, params) { + if (!valueType || !valueType._zod) { + return new ZodRecord({ + type: "record", + keyType: string2(), + valueType: keyType, + ...util_exports.normalizeParams(valueType) + }); + } + return new ZodRecord({ + type: "record", + keyType, + valueType, + ...util_exports.normalizeParams(params) + }); +} +var ZodEnum = /* @__PURE__ */ $constructor("ZodEnum", (inst, def) => { + $ZodEnum.init(inst, def); + ZodType.init(inst, def); + inst._zod.processJSONSchema = (ctx, json, params) => enumProcessor(inst, ctx, json, params); + inst.enum = def.entries; + inst.options = Object.values(def.entries); + const keys = new Set(Object.keys(def.entries)); + inst.extract = (values, params) => { + const newEntries = {}; + for (const value of values) { + if (keys.has(value)) { + newEntries[value] = def.entries[value]; + } else + throw new Error(`Key ${value} not found in enum`); + } + return new ZodEnum({ + ...def, + checks: [], + ...util_exports.normalizeParams(params), + entries: newEntries + }); + }; + inst.exclude = (values, params) => { + const newEntries = { ...def.entries }; + for (const value of values) { + if (keys.has(value)) { + delete newEntries[value]; + } else + throw new Error(`Key ${value} not found in enum`); + } + return new ZodEnum({ + ...def, + checks: [], + ...util_exports.normalizeParams(params), + entries: newEntries + }); + }; +}); +function _enum(values, params) { + const entries = Array.isArray(values) ? Object.fromEntries(values.map((v) => [v, v])) : values; + return new ZodEnum({ + type: "enum", + entries, + ...util_exports.normalizeParams(params) + }); +} +var ZodTransform = /* @__PURE__ */ $constructor("ZodTransform", (inst, def) => { + $ZodTransform.init(inst, def); + ZodType.init(inst, def); + inst._zod.processJSONSchema = (ctx, json, params) => transformProcessor(inst, ctx, json, params); + inst._zod.parse = (payload, _ctx) => { + if (_ctx.direction === "backward") { + throw new $ZodEncodeError(inst.constructor.name); + } + payload.addIssue = (issue2) => { + if (typeof issue2 === "string") { + payload.issues.push(util_exports.issue(issue2, payload.value, def)); + } else { + const _issue = issue2; + if (_issue.fatal) + _issue.continue = false; + _issue.code ?? (_issue.code = "custom"); + _issue.input ?? (_issue.input = payload.value); + _issue.inst ?? (_issue.inst = inst); + payload.issues.push(util_exports.issue(_issue)); + } + }; + const output = def.transform(payload.value, payload); + if (output instanceof Promise) { + return output.then((output2) => { + payload.value = output2; + payload.fallback = true; + return payload; + }); + } + payload.value = output; + payload.fallback = true; + return payload; + }; +}); +function transform(fn) { + return new ZodTransform({ + type: "transform", + transform: fn + }); +} +var ZodOptional = /* @__PURE__ */ $constructor("ZodOptional", (inst, def) => { + $ZodOptional.init(inst, def); + ZodType.init(inst, def); + inst._zod.processJSONSchema = (ctx, json, params) => optionalProcessor(inst, ctx, json, params); + inst.unwrap = () => inst._zod.def.innerType; +}); +function optional(innerType) { + return new ZodOptional({ + type: "optional", + innerType + }); +} +var ZodExactOptional = /* @__PURE__ */ $constructor("ZodExactOptional", (inst, def) => { + $ZodExactOptional.init(inst, def); + ZodType.init(inst, def); + inst._zod.processJSONSchema = (ctx, json, params) => optionalProcessor(inst, ctx, json, params); + inst.unwrap = () => inst._zod.def.innerType; +}); +function exactOptional(innerType) { + return new ZodExactOptional({ + type: "optional", + innerType + }); +} +var ZodNullable = /* @__PURE__ */ $constructor("ZodNullable", (inst, def) => { + $ZodNullable.init(inst, def); + ZodType.init(inst, def); + inst._zod.processJSONSchema = (ctx, json, params) => nullableProcessor(inst, ctx, json, params); + inst.unwrap = () => inst._zod.def.innerType; +}); +function nullable(innerType) { + return new ZodNullable({ + type: "nullable", + innerType + }); +} +var ZodDefault = /* @__PURE__ */ $constructor("ZodDefault", (inst, def) => { + $ZodDefault.init(inst, def); + ZodType.init(inst, def); + inst._zod.processJSONSchema = (ctx, json, params) => defaultProcessor(inst, ctx, json, params); + inst.unwrap = () => inst._zod.def.innerType; + inst.removeDefault = inst.unwrap; +}); +function _default(innerType, defaultValue) { + return new ZodDefault({ + type: "default", + innerType, + get defaultValue() { + return typeof defaultValue === "function" ? defaultValue() : util_exports.shallowClone(defaultValue); + } + }); +} +var ZodPrefault = /* @__PURE__ */ $constructor("ZodPrefault", (inst, def) => { + $ZodPrefault.init(inst, def); + ZodType.init(inst, def); + inst._zod.processJSONSchema = (ctx, json, params) => prefaultProcessor(inst, ctx, json, params); + inst.unwrap = () => inst._zod.def.innerType; +}); +function prefault(innerType, defaultValue) { + return new ZodPrefault({ + type: "prefault", + innerType, + get defaultValue() { + return typeof defaultValue === "function" ? defaultValue() : util_exports.shallowClone(defaultValue); + } + }); +} +var ZodNonOptional = /* @__PURE__ */ $constructor("ZodNonOptional", (inst, def) => { + $ZodNonOptional.init(inst, def); + ZodType.init(inst, def); + inst._zod.processJSONSchema = (ctx, json, params) => nonoptionalProcessor(inst, ctx, json, params); + inst.unwrap = () => inst._zod.def.innerType; +}); +function nonoptional(innerType, params) { + return new ZodNonOptional({ + type: "nonoptional", + innerType, + ...util_exports.normalizeParams(params) + }); +} +var ZodCatch = /* @__PURE__ */ $constructor("ZodCatch", (inst, def) => { + $ZodCatch.init(inst, def); + ZodType.init(inst, def); + inst._zod.processJSONSchema = (ctx, json, params) => catchProcessor(inst, ctx, json, params); + inst.unwrap = () => inst._zod.def.innerType; + inst.removeCatch = inst.unwrap; +}); +function _catch(innerType, catchValue) { + return new ZodCatch({ + type: "catch", + innerType, + catchValue: typeof catchValue === "function" ? catchValue : () => catchValue + }); +} +var ZodPipe = /* @__PURE__ */ $constructor("ZodPipe", (inst, def) => { + $ZodPipe.init(inst, def); + ZodType.init(inst, def); + inst._zod.processJSONSchema = (ctx, json, params) => pipeProcessor(inst, ctx, json, params); + inst.in = def.in; + inst.out = def.out; +}); +function pipe(in_, out) { + return new ZodPipe({ + type: "pipe", + in: in_, + out + // ...util.normalizeParams(params), + }); +} +var ZodReadonly = /* @__PURE__ */ $constructor("ZodReadonly", (inst, def) => { + $ZodReadonly.init(inst, def); + ZodType.init(inst, def); + inst._zod.processJSONSchema = (ctx, json, params) => readonlyProcessor(inst, ctx, json, params); + inst.unwrap = () => inst._zod.def.innerType; +}); +function readonly(innerType) { + return new ZodReadonly({ + type: "readonly", + innerType + }); +} +var ZodCustom = /* @__PURE__ */ $constructor("ZodCustom", (inst, def) => { + $ZodCustom.init(inst, def); + ZodType.init(inst, def); + inst._zod.processJSONSchema = (ctx, json, params) => customProcessor(inst, ctx, json, params); +}); +function refine(fn, _params = {}) { + return _refine(ZodCustom, fn, _params); +} +function superRefine(fn, params) { + return _superRefine(fn, params); +} + +// src/issues/fingerprint.ts +import crypto from "node:crypto"; +var ISSUE_FINGERPRINT_PATTERN = /^[0-9a-f]{20}$/; +function issueFingerprint(issue2, comments = []) { + return crypto.createHash("sha256").update( + JSON.stringify({ + title: issue2.title.trim(), + body: issue2.body ?? "", + comments: comments.map((comment) => ({ + id: comment.id, + body: comment.body, + author: comment.user?.login ?? "" + })) + }) + ).digest("hex").slice(0, 20); +} + +// src/draft-pr/schema.ts +var validationOverrideSchema = object({ + classification: _enum(["allowlisted_test_failure"]), + source: _enum(["policy"]), + reason: string2().min(1).max(1e3), + failedCommands: array(string2().min(1).max(300)).min(1).max(20), + allowedFailureCases: array(string2().min(1).max(300)).min(1).max(50) +}); +function hasConsistentValidationOverride(analysis) { + const override = analysis.validationOverride; + if (!override) return false; + const failedCommands = [ + ...new Set( + analysis.tests.filter((test) => test.status === "failed").map((test) => test.command) + ) + ]; + const overrideCommands = [...new Set(override.failedCommands)]; + return failedCommands.length > 0 && failedCommands.length === overrideCommands.length && failedCommands.every((command) => overrideCommands.includes(command)); +} +var draftPrAnalysisSchema = object({ + outcome: _enum(["implemented", "needs_approval", "blocked", "no_change"]), + prTitle: string2().max(120), + summary: array(string2().min(1).max(500)).max(8), + tests: array( + object({ + command: string2().min(1).max(300), + status: _enum(["passed", "failed", "not_run"]), + details: string2().max(1e3) + }) + ).max(20), + risk: object({ + level: _enum(["low", "medium", "high"]), + reasons: array(string2().min(1).max(500)).max(8) + }), + notes: array(string2().min(1).max(500)).max(8), + validationOverride: validationOverrideSchema.optional() +}); +var draftPrSubmissionSchema = object({ + issueFingerprint: string2().regex(ISSUE_FINGERPRINT_PATTERN), + trigger: _enum(["ready", "approved"]), + workspacePath: string2().min(1).max(2e3), + branch: string2().min(1).max(250), + baseBranch: string2().min(1).max(250), + baseCommit: string2().regex(/^[0-9a-f]{40}$/), + analysis: draftPrAnalysisSchema +}); + +// src/draft-pr/ci-schema.ts +var ciCheckReferenceSchema = object({ + checkRunId: number2().int().positive() +}); +var ciFixAnalysisSchema = object({ + outcome: _enum(["fixed", "no_change", "needs_approval", "blocked"]), + commitTitle: string2().max(120), + summary: array(string2().min(1).max(500)).max(8), + failures: array( + object({ + checkRunId: number2().int().positive(), + disposition: _enum(["fixed", "not_reproducible", "needs_approval"]), + reason: string2().min(1).max(1e3) + }) + ).min(1).max(100), + tests: array( + object({ + command: string2().min(1).max(300), + status: _enum(["passed", "failed", "not_run"]), + details: string2().max(1e3) + }) + ).max(20), + risk: object({ + level: _enum(["low", "medium", "high"]), + reasons: array(string2().min(1).max(500)).max(8) + }), + notes: array(string2().min(1).max(500)).max(8), + validationOverride: validationOverrideSchema.optional() +}); +var ciFixSubmissionSchema = object({ + checkSuiteId: number2().int().positive(), + failuresFingerprint: string2().regex(/^[0-9a-f]{20}$/), + checkRefs: array(ciCheckReferenceSchema).min(1).max(100), + workspacePath: string2().min(1).max(2e3), + branch: string2().min(1).max(250), + baseBranch: string2().min(1).max(250), + expectedHeadSha: string2().regex(/^[0-9a-f]{40}$/), + previousAttempts: number2().int().nonnegative(), + analysis: ciFixAnalysisSchema +}); + +// src/draft-pr/policy.ts +var draftPrPolicySchema = object({ + version: number2().int().positive(), + readyLabel: string2().min(1), + approvedLabel: string2().min(1), + runningLabel: string2().min(1), + needsApprovalLabel: string2().min(1), + prOpenLabel: string2().min(1), + failedLabel: string2().min(1), + skipLabels: array(string2().min(1)), + blockedLabels: array(string2().min(1)), + branchPrefix: string2().regex(/^[a-zA-Z0-9._/-]+$/), + maxChangedFiles: number2().int().positive().max(1e3), + maxChangedLines: number2().int().positive().max(1e5), + maxReviewComments: number2().int().positive().max(100), + maxValidationFixIterations: number2().int().positive().max(20), + maxFixIterations: number2().int().positive().max(20), + requiredValidationGates: array( + _enum(["task-prepare", "task-lint", "task-test-unit"]) + ).min(1), + allowedValidationFailureCases: array(string2().min(1).max(300)).max(50), + approvalPathPrefixes: array(string2().min(1)), + labelColors: record(string2(), string2().regex(/^[0-9a-fA-F]{6}$/)) +}); +function requiresApproval(analysis, inspection, approved, policy) { + if (approved) return []; + const reasons = []; + if (analysis.risk.level === "high") { + reasons.push("the implementation reports high risk"); + } + if (inspection.changedFiles.length > policy.maxChangedFiles) { + reasons.push( + `the change touches ${inspection.changedFiles.length} files (limit ${policy.maxChangedFiles})` + ); + } + const changedLines = inspection.additions + inspection.deletions; + if (changedLines > policy.maxChangedLines) { + reasons.push( + `the change modifies ${changedLines} lines (limit ${policy.maxChangedLines})` + ); + } + const sensitivePaths = inspection.changedFiles.filter( + (file) => policy.approvalPathPrefixes.some((prefix) => file.startsWith(prefix)) + ); + if (sensitivePaths.length > 0) { + reasons.push( + `the change touches approval-gated paths: ${sensitivePaths.slice(0, 5).join(", ")}` + ); + } + return reasons; +} +function hasLabel(labels, expected) { + const normalized = expected.trim().toLowerCase(); + return labels.some((label) => label.trim().toLowerCase() === normalized); +} +function hasAnyLabel(labels, expected) { + return expected.some((label) => hasLabel(labels, label)); +} + +// src/draft-pr/repository.ts +function repositoryCloneUrl(serverUrl, repository) { + const base = new URL(serverUrl); + if (base.protocol !== "https:") { + throw new Error("GitHub server URL must use HTTPS"); + } + base.pathname = `${base.pathname.replace(/\/$/, "")}/${repository}.git`; + base.search = ""; + base.hash = ""; + return base.toString(); +} +function sanitizeTitle(value) { + return value.replace(/[\r\n]+/g, " ").replace(/\s+/g, " ").trim().slice(0, 120); +} +function assertAllowedRepository(repository, allowed) { + if (!allowed.trim()) { + throw new Error("Draft PR repository allowlist is required"); + } + if (repository.trim().toLowerCase() !== allowed.trim().toLowerCase()) { + throw new Error("repository is outside the Draft PR allowlist"); + } +} + +// src/draft-pr/workspace.ts +import crypto2 from "node:crypto"; +import { spawn } from "node:child_process"; +import { + chmod, + lstat, + mkdir, + mkdtemp, + rm, + stat, + writeFile +} from "node:fs/promises"; +import { isIP } from "node:net"; +import os from "node:os"; +import path from "node:path"; +var DraftPrWorkspaceLockError = class extends Error { + constructor(target) { + super(`another Draft PR run already holds the ${target} lock`); + this.name = "DraftPrWorkspaceLockError"; + } +}; +var GitDraftPrWorkspace = class { + #root; + #token; + #authorName; + #authorEmail; + #gitCurlResolve; + #lockTtlMs; + constructor(options) { + this.#root = path.resolve(options.root); + this.#token = options.token.trim(); + this.#authorName = options.authorName.trim(); + this.#authorEmail = options.authorEmail.trim(); + this.#gitCurlResolve = options.gitCurlResolve?.trim() ?? ""; + this.#lockTtlMs = options.lockTtlMs ?? 4 * 60 * 60 * 1e3; + if (!this.#token) + throw new Error("GitHub token is required for Git workspace preparation"); + if (!this.#authorName || !this.#authorEmail) { + throw new Error("Git author name and email are required"); + } + gitCurlResolveEnvironment(this.#gitCurlResolve); + } + async prepare(input) { + validateCloneUrl(input.cloneUrl); + validateGitRef(input.baseBranch, "base branch"); + validateGitRef(input.branch, "working branch"); + const paths = this.#paths(input.repository, "issue", input.issueNumber); + await mkdir(path.dirname(paths.lock), { recursive: true }); + await this.#acquireLock(paths.lock); + try { + await rm(paths.workspace, { recursive: true, force: true }); + await mkdir(path.dirname(paths.workspace), { recursive: true }); + const env = await this.#authenticatedGitEnvironment(); + await runGit( + [ + "clone", + "--no-tags", + "--depth=1", + "--branch", + input.baseBranch, + "--", + input.cloneUrl, + paths.workspace + ], + { cwd: this.#root, env } + ); + const existing = await runGit( + ["ls-remote", "--heads", "origin", `refs/heads/${input.branch}`], + { cwd: paths.workspace, env } + ); + if (existing.stdout.trim()) { + throw new Error(`remote branch already exists: ${input.branch}`); + } + await runGit(["checkout", "-b", input.branch], { + cwd: paths.workspace, + env + }); + const baseCommit = (await runGit(["rev-parse", "HEAD"], { cwd: paths.workspace, env })).stdout.trim(); + return { + path: paths.workspace, + branch: input.branch, + baseBranch: input.baseBranch, + baseCommit + }; + } catch (error) { + await this.cleanup(input.repository, input.issueNumber); + throw error; + } + } + async prepareReview(input) { + validateCloneUrl(input.cloneUrl); + validateGitRef(input.baseBranch, "base branch"); + validateGitRef(input.branch, "Pull Request branch"); + if (!/^[0-9a-f]{40}$/.test(input.expectedHeadSha)) { + throw new Error("invalid expected Pull Request head SHA"); + } + const paths = this.#paths(input.repository, "pr", input.pullRequestNumber); + await mkdir(path.dirname(paths.lock), { recursive: true }); + await this.#acquireLock(paths.lock, "Pull Request"); + try { + await rm(paths.workspace, { recursive: true, force: true }); + await mkdir(path.dirname(paths.workspace), { recursive: true }); + const env = await this.#authenticatedGitEnvironment(); + await runGit( + [ + "clone", + "--no-tags", + "--depth=1", + "--branch", + input.branch, + "--", + input.cloneUrl, + paths.workspace + ], + { cwd: this.#root, env } + ); + const headCommit = (await runGit(["rev-parse", "HEAD"], { cwd: paths.workspace, env })).stdout.trim(); + if (headCommit !== input.expectedHeadSha) { + throw new Error( + "Pull Request head changed during workspace preparation" + ); + } + return { + path: paths.workspace, + branch: input.branch, + baseBranch: input.baseBranch, + baseCommit: headCommit + }; + } catch (error) { + await this.cleanupReview(input.repository, input.pullRequestNumber); + throw error; + } + } + async inspect(workspacePath) { + return inspectDraftPrWorkspace(this.#root, workspacePath); + } + async commitAndPush(workspacePath, branch, title, cloneUrl) { + const resolved = this.#assertWorkspacePath(workspacePath); + validateGitRef(branch, "working branch"); + validateCloneUrl(cloneUrl); + await this.#writeTrustedGitConfig(resolved, cloneUrl); + const localEnv = this.#localGitEnvironment(); + await runGit( + [ + "-c", + `user.name=${this.#authorName}`, + "-c", + `user.email=${this.#authorEmail}`, + "-c", + "core.hooksPath=/dev/null", + "commit", + "-m", + title + ], + { cwd: resolved, env: localEnv } + ); + const authenticatedEnv = await this.#authenticatedGitEnvironment(); + await runGit( + [ + "-c", + "core.hooksPath=/dev/null", + "-c", + "credential.helper=", + "push", + "--no-verify", + "--set-upstream", + "origin", + branch + ], + { + cwd: resolved, + env: authenticatedEnv + } + ); + return (await runGit(["rev-parse", "HEAD"], { cwd: resolved, env: localEnv })).stdout.trim(); + } + async cleanup(repository, issueNumber) { + const paths = this.#paths(repository, "issue", issueNumber); + await rm(paths.workspace, { recursive: true, force: true }); + await rm(paths.lock, { recursive: true, force: true }); + } + async cleanupReview(repository, pullRequestNumber) { + const paths = this.#paths(repository, "pr", pullRequestNumber); + await rm(paths.workspace, { recursive: true, force: true }); + await rm(paths.lock, { recursive: true, force: true }); + } + #paths(repository, kind, number3) { + if (!Number.isSafeInteger(number3) || number3 <= 0) { + throw new Error( + `${kind === "issue" ? "Issue" : "Pull Request"} number must be a positive integer` + ); + } + const key = crypto2.createHash("sha256").update(repository.trim().toLowerCase()).digest("hex").slice(0, 16); + return { + workspace: path.join( + this.#root, + "repositories", + key, + `${kind}-${number3}` + ), + lock: path.join(this.#root, ".locks", `${key}-${kind}-${number3}`) + }; + } + #assertWorkspacePath(value) { + const resolved = path.resolve(value); + const expectedPrefix = `${path.join(this.#root, "repositories")}${path.sep}`; + if (!resolved.startsWith(expectedPrefix)) { + throw new Error("workspace path is outside the configured Draft PR root"); + } + return resolved; + } + async #acquireLock(lockPath, target = "Issue") { + try { + await mkdir(lockPath); + return; + } catch (error) { + if (!isAlreadyExists(error)) throw error; + } + const info = await stat(lockPath); + if (Date.now() - info.mtimeMs <= this.#lockTtlMs) { + throw new DraftPrWorkspaceLockError(target); + } + await rm(lockPath, { recursive: true, force: true }); + await mkdir(lockPath); + } + #localGitEnvironment() { + return { + PATH: process.env.PATH, + HOME: process.env.HOME, + LANG: process.env.LANG ?? "C.UTF-8", + GIT_CONFIG_NOSYSTEM: "1", + GIT_CONFIG_GLOBAL: "/dev/null", + GIT_TERMINAL_PROMPT: "0", + ...gitCurlResolveEnvironment(this.#gitCurlResolve) + }; + } + async #authenticatedGitEnvironment() { + await mkdir(this.#root, { recursive: true }); + const askPass = path.join(this.#root, ".git-askpass.sh"); + await writeFile( + askPass, + [ + "#!/bin/sh", + 'case "$1" in', + ' *Username*) printf "%s" "x-access-token" ;;', + ' *) printf "%s" "$DRAFT_PR_GIT_TOKEN" ;;', + "esac", + "" + ].join("\n"), + { mode: 448 } + ); + await chmod(askPass, 448); + return { + ...this.#localGitEnvironment(), + GIT_ASKPASS: askPass, + DRAFT_PR_GIT_TOKEN: this.#token + }; + } + async #writeTrustedGitConfig(workspacePath, cloneUrl) { + const gitDirectory = path.join(workspacePath, ".git"); + const gitDirectoryInfo = await lstat(gitDirectory); + if (!gitDirectoryInfo.isDirectory() || gitDirectoryInfo.isSymbolicLink()) { + throw new Error("prepared workspace .git directory was replaced"); + } + const configPath = path.join(gitDirectory, "config"); + const configInfo = await lstat(configPath); + if (!configInfo.isFile() || configInfo.isSymbolicLink()) { + throw new Error("prepared workspace Git config was replaced"); + } + await writeFile( + configPath, + [ + "[core]", + " repositoryformatversion = 0", + " filemode = true", + " bare = false", + " logallrefupdates = true", + " hooksPath = /dev/null", + '[remote "origin"]', + ` url = ${cloneUrl}`, + " fetch = +refs/heads/*:refs/remotes/origin/*", + "" + ].join("\n"), + { mode: 384 } + ); + } +}; +async function inspectDraftPrWorkspace(root, workspacePath) { + const resolved = assertWorkspacePath(root, workspacePath); + const env = localGitEnvironment(); + await runGit(["add", "-A"], { cwd: resolved, env }); + const [head, tree, names, stats, check, diff] = await Promise.all([ + runGit(["rev-parse", "HEAD"], { cwd: resolved, env }), + runGit(["write-tree"], { cwd: resolved, env }), + runGit(["diff", "--cached", "--name-only", "-z"], { + cwd: resolved, + env + }), + runGit(["diff", "--cached", "--numstat"], { cwd: resolved, env }), + runGit(["diff", "--cached", "--check"], { + cwd: resolved, + env, + allowFailure: true + }), + runGit( + [ + "diff", + "--cached", + "--unified=0", + "--no-color", + "--no-ext-diff", + "--no-textconv" + ], + { + cwd: resolved, + env, + maxOutputBytes: 8 * 1024 * 1024 + } + ) + ]); + const changedFiles = names.stdout.split("\0").filter(Boolean); + let additions = 0; + let deletions = 0; + for (const line of stats.stdout.split("\n")) { + const [added, deleted] = line.split(" "); + if (/^\d+$/.test(added ?? "")) additions += Number(added); + if (/^\d+$/.test(deleted ?? "")) deletions += Number(deleted); + } + return { + headCommit: head.stdout.trim(), + changeFingerprint: tree.stdout.trim(), + changedFiles, + additions, + deletions, + diffCheckPassed: check.exitCode === 0, + secretFindingPaths: scanAddedLinesForSecrets(diff.stdout) + }; +} +async function fingerprintDraftPrWorkspace(root, workspacePath) { + const resolved = assertWorkspacePath(root, workspacePath); + const temporaryDirectory = await mkdtemp( + path.join(os.tmpdir(), "draft-pr-index-") + ); + try { + const env = { + ...localGitEnvironment(), + GIT_INDEX_FILE: path.join(temporaryDirectory, "index") + }; + await runGit(["read-tree", "HEAD"], { cwd: resolved, env }); + await runGit(["add", "-A"], { cwd: resolved, env }); + const [head, tree] = await Promise.all([ + runGit(["rev-parse", "HEAD"], { cwd: resolved, env }), + runGit(["write-tree"], { cwd: resolved, env }) + ]); + return { + headCommit: head.stdout.trim(), + changeFingerprint: tree.stdout.trim() + }; + } finally { + await rm(temporaryDirectory, { recursive: true, force: true }); + } +} +function assertWorkspacePath(root, value) { + const resolvedRoot = path.resolve(root); + const resolved = path.resolve(value); + const expectedPrefix = `${path.join(resolvedRoot, "repositories")}${path.sep}`; + if (!resolved.startsWith(expectedPrefix)) { + throw new Error("workspace path is outside the configured Draft PR root"); + } + return resolved; +} +function localGitEnvironment() { + return { + PATH: process.env.PATH, + HOME: process.env.HOME, + LANG: process.env.LANG ?? "C.UTF-8", + GIT_CONFIG_NOSYSTEM: "1", + GIT_CONFIG_GLOBAL: "/dev/null", + GIT_TERMINAL_PROMPT: "0" + }; +} +function gitCurlResolveEnvironment(value) { + const normalized = value?.trim() ?? ""; + if (!normalized) return {}; + const [host, port, address, ...extra] = normalized.split(":"); + if (host !== "github.com" || port !== "443" || isIP(address ?? "") !== 4 || extra.length > 0) { + throw new Error("Draft PR Git curl resolve must use github.com:443:"); + } + return { + GIT_CONFIG_COUNT: "1", + GIT_CONFIG_KEY_0: "http.curloptResolve", + GIT_CONFIG_VALUE_0: normalized + }; +} +async function runGit(args, options) { + const safeArgs = options.cwd ? ["-c", `safe.directory=${options.cwd}`, ...args] : args; + return new Promise((resolve, reject) => { + const child = spawn("git", safeArgs, { + cwd: options.cwd, + env: options.env, + stdio: ["ignore", "pipe", "pipe"] + }); + const max = options.maxOutputBytes ?? 2 * 1024 * 1024; + let stdout = ""; + let stderr = ""; + let size = 0; + child.stdout.setEncoding("utf8"); + child.stderr.setEncoding("utf8"); + child.stdout.on("data", (chunk) => { + size += Buffer.byteLength(chunk); + if (size <= max) stdout += chunk; + }); + child.stderr.on("data", (chunk) => { + size += Buffer.byteLength(chunk); + if (size <= max) stderr += chunk; + }); + child.on("error", reject); + child.on("close", (code) => { + const exitCode = code ?? 1; + if (size > max) { + reject(new Error("git command output exceeded the configured limit")); + } else if (exitCode !== 0 && !options.allowFailure) { + reject( + new Error( + `git ${args[0] ?? "command"} failed: ${stderr.trim().slice(-2e3)}` + ) + ); + } else { + resolve({ stdout, stderr, exitCode }); + } + }); + }); +} +function validateCloneUrl(value) { + const url = new URL(value); + if (url.protocol !== "https:" || url.username || url.password) { + throw new Error("Draft PR clone URL must be credential-free HTTPS"); + } +} +function validateGitRef(value, name) { + if (!/^[A-Za-z0-9][A-Za-z0-9._/-]*$/.test(value) || value.includes("..") || value.includes("//") || value.endsWith("/") || value.endsWith(".lock")) { + throw new Error(`invalid ${name}: ${value}`); + } +} +function scanAddedLinesForSecrets(diff) { + const findings = /* @__PURE__ */ new Set(); + let currentPath = "unknown"; + const patterns = [ + /-----BEGIN [A-Z ]*PRIVATE KEY-----/, + /\bghp_[A-Za-z0-9]{30,}\b/, + /\bgithub_pat_[A-Za-z0-9_]{30,}\b/, + /\bAKIA[0-9A-Z]{16}\b/, + /Authorization:\s*Bearer\s+[A-Za-z0-9._-]{20,}/i + ]; + for (const line of diff.split("\n")) { + if (line.startsWith("+++ b/")) currentPath = line.slice(6); + if (!line.startsWith("+") || line.startsWith("+++")) continue; + if (patterns.some((pattern) => pattern.test(line))) + findings.add(currentPath); + } + return [...findings].sort(); +} +function isAlreadyExists(error) { + return typeof error === "object" && error !== null && "code" in error && error.code === "EEXIST"; +} + +// src/draft-pr/ci-tool.ts +var FAILED_CONCLUSIONS = /* @__PURE__ */ new Set([ + "action_required", + "failure", + "startup_failure", + "timed_out" +]); +var MAX_ANNOTATIONS_PER_CHECK = 50; +async function prepareCiFix(repository, pullRequestNumber, expectedHeadSha, checkSuiteId, dependencies) { + assertAllowedRepository(repository, dependencies.allowedRepository); + requireBotIdentity(dependencies); + validateEventTarget(expectedHeadSha, checkSuiteId); + const [pullRequest, comments] = await Promise.all([ + dependencies.provider.getPullRequest(repository, pullRequestNumber), + dependencies.provider.listComments(repository, pullRequestNumber) + ]); + const reason = ineligibleReason(pullRequest, repository, dependencies); + if (reason) { + return skipped(repository, pullRequestNumber, checkSuiteId, reason); + } + if (pullRequest.headSha !== expectedHeadSha) { + return skipped( + repository, + pullRequestNumber, + checkSuiteId, + "CI event is for a stale Pull Request head" + ); + } + const state = ciState(comments, dependencies); + if (state.checkSuiteId === checkSuiteId && ["no-change", "needs-approval"].includes(state.status)) { + return skipped( + repository, + pullRequestNumber, + checkSuiteId, + "CI check suite was already processed" + ); + } + if (state.attempts >= dependencies.policy.maxFixIterations) { + if (dependencies.apply) { + await upsertCiState( + repository, + pullRequestNumber, + { + checkSuiteId, + attempts: state.attempts, + headSha: expectedHeadSha, + status: "needs-approval" + }, + comments, + dependencies + ); + } + return skipped( + repository, + pullRequestNumber, + checkSuiteId, + "automatic CI fix iteration limit reached" + ); + } + const failures = await loadFailures( + repository, + expectedHeadSha, + checkSuiteId, + dependencies + ); + if (failures.length === 0) { + return skipped( + repository, + pullRequestNumber, + checkSuiteId, + "check suite has no supported failed checks" + ); + } + let prepared; + try { + prepared = await dependencies.workspace.prepareReview({ + repository, + pullRequestNumber, + cloneUrl: repositoryCloneUrl(dependencies.serverUrl, repository), + baseBranch: pullRequest.base, + branch: pullRequest.head, + expectedHeadSha + }); + } catch (error) { + if (error instanceof DraftPrWorkspaceLockError) { + return skipped( + repository, + pullRequestNumber, + checkSuiteId, + "another Pull Request fix run holds the workspace lock" + ); + } + throw error; + } + if (dependencies.apply) { + await upsertCiState( + repository, + pullRequestNumber, + { + checkSuiteId, + attempts: state.attempts, + headSha: expectedHeadSha, + status: "fixing" + }, + comments, + dependencies + ); + } + return { + ok: true, + repository, + pullRequestNumber, + checkSuiteId, + workspacePath: prepared.path, + branch: prepared.branch, + baseBranch: prepared.baseBranch, + expectedHeadSha: prepared.baseCommit, + failuresFingerprint: fingerprintFailures(failures), + previousAttempts: state.attempts, + failures + }; +} +async function applyCiFix(repository, pullRequestNumber, submissionInput, dependencies) { + assertAllowedRepository(repository, dependencies.allowedRepository); + requireBotIdentity(dependencies); + const submission = ciFixSubmissionSchema.parse(submissionInput); + const [pullRequest, comments, failures] = await Promise.all([ + dependencies.provider.getPullRequest(repository, pullRequestNumber), + dependencies.provider.listComments(repository, pullRequestNumber), + loadFailures( + repository, + submission.expectedHeadSha, + submission.checkSuiteId, + dependencies + ) + ]); + const reason = ineligibleReason(pullRequest, repository, dependencies); + if (reason) throw new Error(reason); + if (pullRequest.headSha !== submission.expectedHeadSha) { + throw new Error("Pull Request head changed after CI fix preparation"); + } + const expectedIds = submission.checkRefs.map((value) => value.checkRunId); + const actualIds = failures.map((value) => value.checkRunId); + if (new Set(expectedIds).size !== expectedIds.length || expectedIds.length !== actualIds.length || expectedIds.some((id, index) => id !== actualIds[index]) || fingerprintFailures(failures) !== submission.failuresFingerprint) { + throw new Error("failed CI checks changed after fix preparation"); + } + validateFailureCoverage(submission.analysis, expectedIds); + const inspection = await dependencies.workspace.inspect( + submission.workspacePath + ); + if (inspection.headCommit !== submission.expectedHeadSha) { + throw new Error("the Agent committed or moved HEAD in the CI workspace"); + } + const nextAttempts = submission.previousAttempts + 1; + if (submission.analysis.outcome !== "fixed") { + if (inspection.changedFiles.length > 0) { + throw new Error( + `${submission.analysis.outcome} CI result contains changes` + ); + } + if (submission.analysis.outcome === "no_change" && submission.analysis.failures.some( + (failure) => failure.disposition !== "not_reproducible" + )) { + throw new Error( + "no_change CI result requires every failure to be not reproducible" + ); + } + const status = submission.analysis.outcome === "needs_approval" ? "needs-approval" : submission.analysis.outcome === "no_change" ? "no-change" : "failed"; + await finishWithoutPush( + repository, + pullRequestNumber, + submission, + nextAttempts, + status, + comments, + dependencies + ); + return { + ok: true, + repository, + pullRequestNumber, + applied: dependencies.apply, + outcome: submission.analysis.outcome, + inspection + }; + } + validateFixedAnalysis(submission.analysis, inspection); + const approvalReasons = requiresApproval( + submission.analysis, + inspection, + false, + dependencies.policy + ); + if (approvalReasons.length > 0) { + await finishWithoutPush( + repository, + pullRequestNumber, + submission, + nextAttempts, + "needs-approval", + comments, + dependencies + ); + return { + ok: true, + repository, + pullRequestNumber, + applied: dependencies.apply, + outcome: "needs_approval", + inspection + }; + } + if (!dependencies.apply) { + await dependencies.workspace.cleanupReview(repository, pullRequestNumber); + return { + ok: true, + repository, + pullRequestNumber, + applied: false, + outcome: "fixed", + inspection + }; + } + const commit = await dependencies.workspace.commitAndPush( + submission.workspacePath, + submission.branch, + sanitizeTitle(submission.analysis.commitTitle), + repositoryCloneUrl(dependencies.serverUrl, repository) + ); + await upsertCiState( + repository, + pullRequestNumber, + { + checkSuiteId: submission.checkSuiteId, + attempts: nextAttempts, + headSha: commit, + status: "fixed" + }, + comments, + dependencies + ); + await dependencies.workspace.cleanupReview(repository, pullRequestNumber); + return { + ok: true, + repository, + pullRequestNumber, + applied: true, + outcome: "fixed", + commit, + inspection + }; +} +async function failCiFix(repository, pullRequestNumber, checkSuiteId, attempts, headSha, dependencies) { + assertAllowedRepository(repository, dependencies.allowedRepository); + try { + if (dependencies.apply) { + const comments = await dependencies.provider.listComments( + repository, + pullRequestNumber + ); + await upsertCiState( + repository, + pullRequestNumber, + { + checkSuiteId, + attempts, + headSha, + status: "failed" + }, + comments, + dependencies + ); + } + } finally { + await dependencies.workspace.cleanupReview(repository, pullRequestNumber); + } + return { + ok: true, + repository, + pullRequestNumber, + applied: dependencies.apply, + outcome: "failed" + }; +} +async function loadFailures(repository, headSha, checkSuiteId, dependencies) { + const runs = (await dependencies.provider.listCheckRuns(repository, headSha)).filter( + (run) => run.checkSuiteId === checkSuiteId && run.status === "completed" && FAILED_CONCLUSIONS.has(run.conclusion ?? "") + ).sort((left, right) => left.id - right.id); + if (runs.length > dependencies.policy.maxReviewComments) { + throw new Error( + `CI check suite has ${runs.length} failed checks (limit ${dependencies.policy.maxReviewComments})` + ); + } + return Promise.all( + runs.map(async (run) => ({ + checkRunId: run.id, + name: run.name, + conclusion: run.conclusion, + ...run.htmlUrl ? { htmlUrl: run.htmlUrl } : {}, + output: run.output, + annotations: (await dependencies.provider.listCheckRunAnnotations(repository, run.id)).slice(0, MAX_ANNOTATIONS_PER_CHECK) + })) + ); +} +function fingerprintFailures(failures) { + return crypto3.createHash("sha256").update(JSON.stringify(failures)).digest("hex").slice(0, 20); +} +function validateFailureCoverage(analysis, expectedIds) { + const actual = analysis.failures.map((failure) => failure.checkRunId); + if (new Set(actual).size !== actual.length || actual.length !== expectedIds.length || actual.some((id, index) => id !== expectedIds[index])) { + throw new Error( + "CI fix analysis must address every failed check exactly once" + ); + } + if (analysis.outcome === "fixed" && analysis.failures.some( + (failure) => failure.disposition === "needs_approval" + )) { + throw new Error("fixed CI result cannot contain approval-gated failures"); + } +} +function validateFixedAnalysis(analysis, inspection) { + if (inspection.changedFiles.length === 0) { + throw new Error("fixed CI result contains no repository changes"); + } + if (!inspection.diffCheckPassed) { + throw new Error("CI fix failed git diff --check"); + } + if (inspection.secretFindingPaths.length > 0) { + throw new Error("CI fix contains potential credential material"); + } + if (analysis.validationOverride && !hasConsistentValidationOverride(analysis)) { + throw new Error("fixed CI result has an inconsistent validation override"); + } + if (analysis.tests.some((test) => test.status === "failed") && !hasConsistentValidationOverride(analysis)) { + throw new Error("fixed CI result reports a failed validation command"); + } +} +function ineligibleReason(pullRequest, repository, dependencies) { + if (pullRequest.state.toLowerCase() !== "open") + return "Pull Request is not open"; + if (!pullRequest.head.startsWith(dependencies.policy.branchPrefix)) { + return "Pull Request branch is not managed by the Draft PR Agent"; + } + if (pullRequest.headRepository?.trim().toLowerCase() !== repository.trim().toLowerCase()) { + return "Pull Request head repository is not the allowlisted repository"; + } + if (!pullRequest.headSha || !/^[0-9a-f]{40}$/.test(pullRequest.headSha)) { + return "Pull Request has no valid head SHA"; + } + return void 0; +} +function validateEventTarget(headSha, checkSuiteId) { + if (!/^[0-9a-f]{40}$/.test(headSha)) { + throw new Error("invalid CI event head SHA"); + } + if (!Number.isSafeInteger(checkSuiteId) || checkSuiteId <= 0) { + throw new Error("invalid CI check suite ID"); + } +} +function ciState(comments, dependencies) { + return parseCiFixState( + findCiFixComment(comments, dependencies.botLogin?.trim() ?? "") + ); +} +async function finishWithoutPush(repository, pullRequestNumber, submission, attempts, status, comments, dependencies) { + if (dependencies.apply) { + await upsertCiState( + repository, + pullRequestNumber, + { + checkSuiteId: submission.checkSuiteId, + attempts, + headSha: submission.expectedHeadSha, + status + }, + comments, + dependencies + ); + } + await dependencies.workspace.cleanupReview(repository, pullRequestNumber); +} +async function upsertCiState(repository, pullRequestNumber, state, comments, dependencies) { + const botLogin = dependencies.botLogin?.trim() ?? ""; + if (!botLogin) throw new Error("GitHub bot login is required in apply mode"); + const existing = findCiFixComment(comments, botLogin); + const body = buildCiFixComment(state); + if (existing) { + await dependencies.provider.updateComment( + repository, + pullRequestNumber, + existing.id, + body + ); + } else { + await dependencies.provider.createComment( + repository, + pullRequestNumber, + body + ); + } +} +function requireBotIdentity(dependencies) { + if (dependencies.apply && !dependencies.botLogin?.trim()) { + throw new Error("GitHub bot login is required for CI fixes in apply mode"); + } +} +function skipped(repository, pullRequestNumber, checkSuiteId, reason) { + return { + ok: true, + skipped: true, + reason, + repository, + pullRequestNumber, + checkSuiteId + }; +} + +// src/draft-pr/review-tool.ts +import crypto4 from "node:crypto"; + +// src/draft-pr/review-comment.ts +var REVIEW_FIX_COMMENT_PREFIX = "$/ + ); + if (v3Match) { + return { + reviewCursor: Number(v3Match[1]), + iterations: Number(v3Match[2]), + headSha: v3Match[3] === "none" ? "" : v3Match[3], + status: v3Match[4] + }; + } + const v2Match = marker.match( + /^$/ + ); + if (v2Match) { + return { + // v2 stored Conversation and inline Review Comment IDs, not Review IDs. + // Start the v3 Review cursor at zero so the first formal change request + // after upgrading is never skipped because the ID namespaces differ. + reviewCursor: 0, + iterations: Number(v2Match[3]), + headSha: v2Match[4] === "none" ? "" : v2Match[4], + status: v2Match[5] + }; + } + const v1Match = marker.match( + /^$/ + ); + if (!v1Match) return emptyReviewFixState(); + return { + reviewCursor: 0, + iterations: Number(v1Match[2]), + headSha: v1Match[3] === "none" ? "" : v1Match[3], + status: v1Match[4] + }; +} +function buildReviewFixComment(state) { + const marker = `${REVIEW_FIX_COMMENT_V3_PREFIX} review=${state.reviewCursor} iterations=${state.iterations} head=${state.headSha || "none"} status=${state.status} -->`; + const messages = { + fixing: "The Draft PR Agent is validating a requested change.", + fixed: "The Draft PR Agent pushed a validated fix for the latest requested changes.", + "no-change": "The Draft PR Agent verified the latest requested changes and made no code change.", + "needs-approval": "Automatic Review fixes paused for maintainer approval.", + failed: "The Draft PR Agent could not complete the latest Review fix attempt." + }; + return [marker, "## Review follow-up", "", messages[state.status]].join("\n"); +} +function emptyReviewFixState() { + return { + reviewCursor: 0, + iterations: 0, + headSha: "", + status: "fixed" + }; +} + +// src/draft-pr/review-schema.ts +var reviewFindingSourceSchema = _enum(["review", "review_comment"]); +var reviewFindingReferenceSchema = object({ + source: reviewFindingSourceSchema, + commentId: number2().int().positive() +}); +var reviewTestSchema = object({ + command: string2().min(1).max(300), + status: _enum(["passed", "failed", "not_run"]), + details: string2().max(1e3) +}); +var reviewFixAnalysisSchema = object({ + outcome: _enum(["fixed", "no_change", "needs_approval", "blocked"]), + commitTitle: string2().max(120), + summary: array(string2().min(1).max(500)).max(8), + findings: array( + object({ + source: reviewFindingSourceSchema, + commentId: number2().int().positive(), + disposition: _enum(["fixed", "not_reproducible", "needs_approval"]), + reason: string2().min(1).max(1e3) + }) + ).max(100), + tests: array(reviewTestSchema).max(20), + risk: object({ + level: _enum(["low", "medium", "high"]), + reasons: array(string2().min(1).max(500)).max(8) + }), + notes: array(string2().min(1).max(500)).max(8), + validationOverride: validationOverrideSchema.optional() +}); +var reviewFixSubmissionSchema = object({ + reviewId: number2().int().positive(), + reviewFingerprint: string2().regex(/^[0-9a-f]{20}$/), + findingRefs: array(reviewFindingReferenceSchema).min(1).max(100), + workspacePath: string2().min(1).max(2e3), + branch: string2().min(1).max(250), + baseBranch: string2().min(1).max(250), + expectedHeadSha: string2().regex(/^[0-9a-f]{40}$/), + previousReviewCursor: number2().int().nonnegative(), + previousIterations: number2().int().nonnegative(), + analysis: reviewFixAnalysisSchema +}); + +// src/draft-pr/review-tool.ts +async function prepareReviewFix(repository, pullRequestNumber, reviewId, dependencies) { + assertAllowedRepository(repository, dependencies.allowedRepository); + requireReviewBotIdentity(dependencies); + const [pullRequest, review, conversationComments, reviewComments] = await Promise.all([ + dependencies.provider.getPullRequest(repository, pullRequestNumber), + dependencies.provider.getPullRequestReview( + repository, + pullRequestNumber, + reviewId + ), + dependencies.provider.listComments(repository, pullRequestNumber), + dependencies.provider.listReviewComments(repository, pullRequestNumber) + ]); + const reason = ineligibleReason2(pullRequest, repository, dependencies); + if (reason) return skipped2(repository, pullRequestNumber, reason); + const reviewReason = ineligibleReviewReason(review, pullRequest); + if (reviewReason) return skipped2(repository, pullRequestNumber, reviewReason); + const state = reviewState(conversationComments, dependencies); + if (review.id <= state.reviewCursor) { + return skipped2( + repository, + pullRequestNumber, + "Pull Request Review was already processed" + ); + } + const findings = findingsForReview(review, reviewComments); + if (findings.length === 0) { + return skipped2(repository, pullRequestNumber, "Review has no findings"); + } + if (findings.length > dependencies.policy.maxReviewComments) { + if (dependencies.apply) { + await upsertReviewState( + repository, + pullRequestNumber, + { + reviewCursor: state.reviewCursor, + iterations: state.iterations, + headSha: pullRequest.headSha, + status: "needs-approval" + }, + conversationComments, + dependencies + ); + } + return skipped2( + repository, + pullRequestNumber, + `Review has ${findings.length} findings, exceeding the automatic limit of ${dependencies.policy.maxReviewComments}` + ); + } + if (state.iterations >= dependencies.policy.maxFixIterations) { + if (dependencies.apply) { + await upsertReviewState( + repository, + pullRequestNumber, + { + reviewCursor: state.reviewCursor, + iterations: state.iterations, + headSha: pullRequest.headSha, + status: "needs-approval" + }, + conversationComments, + dependencies + ); + } + return skipped2( + repository, + pullRequestNumber, + "automatic Review fix iteration limit reached" + ); + } + let prepared; + try { + prepared = await dependencies.workspace.prepareReview({ + repository, + pullRequestNumber, + cloneUrl: repositoryCloneUrl(dependencies.serverUrl, repository), + baseBranch: pullRequest.base, + branch: pullRequest.head, + expectedHeadSha: pullRequest.headSha + }); + } catch (error) { + if (error instanceof DraftPrWorkspaceLockError) { + return skipped2( + repository, + pullRequestNumber, + "another review fix run holds the Pull Request lock" + ); + } + throw error; + } + if (dependencies.apply) { + await upsertReviewState( + repository, + pullRequestNumber, + { + reviewCursor: state.reviewCursor, + iterations: state.iterations, + headSha: pullRequest.headSha, + status: "fixing" + }, + conversationComments, + dependencies + ); + } + return { + ok: true, + repository, + pullRequestNumber, + workspacePath: prepared.path, + branch: prepared.branch, + baseBranch: prepared.baseBranch, + expectedHeadSha: prepared.baseCommit, + reviewId: review.id, + reviewFingerprint: fingerprintFindings(findings), + previousReviewCursor: state.reviewCursor, + previousIterations: state.iterations, + findings: findings.map((value) => toFinding(value)) + }; +} +async function applyReviewFix(repository, pullRequestNumber, submissionInput, dependencies) { + assertAllowedRepository(repository, dependencies.allowedRepository); + requireReviewBotIdentity(dependencies); + const submission = reviewFixSubmissionSchema.parse(submissionInput); + const [pullRequest, review, conversationComments, reviewComments] = await Promise.all([ + dependencies.provider.getPullRequest(repository, pullRequestNumber), + dependencies.provider.getPullRequestReview( + repository, + pullRequestNumber, + submission.reviewId + ), + dependencies.provider.listComments(repository, pullRequestNumber), + dependencies.provider.listReviewComments(repository, pullRequestNumber) + ]); + const reason = ineligibleReason2(pullRequest, repository, dependencies); + if (reason) throw new Error(reason); + const reviewReason = ineligibleReviewReason(review, pullRequest); + if (reviewReason) throw new Error(reviewReason); + if (pullRequest.headSha !== submission.expectedHeadSha) { + throw new Error("Pull Request head changed after review fix preparation"); + } + const expectedKeys = submission.findingRefs.map(findingKey); + const preparedFindings = findingsForReview(review, reviewComments); + if (new Set(expectedKeys).size !== expectedKeys.length || preparedFindings.length !== submission.findingRefs.length || preparedFindings.some( + (value) => !expectedKeys.includes(findingKey(value)) + ) || fingerprintFindings(preparedFindings) !== submission.reviewFingerprint) { + throw new Error("Pull Request Review changed after fix preparation"); + } + const inspection = await dependencies.workspace.inspect( + submission.workspacePath + ); + if (inspection.headCommit !== submission.expectedHeadSha) { + throw new Error( + "the Agent committed or moved HEAD in the review workspace" + ); + } + validateFindingCoverage(submission.analysis, submission.findingRefs); + const nextIterations = submission.previousIterations + 1; + const nextReviewCursor = Math.max( + submission.previousReviewCursor, + submission.reviewId + ); + if (submission.analysis.outcome !== "fixed") { + if (submission.analysis.outcome === "no_change" && inspection.changedFiles.length > 0) { + throw new Error("no_change review result contains repository changes"); + } + const status = submission.analysis.outcome === "needs_approval" ? "needs-approval" : submission.analysis.outcome === "no_change" ? "no-change" : "failed"; + await finishWithoutPush2( + repository, + pullRequestNumber, + nextReviewCursor, + nextIterations, + submission.expectedHeadSha, + status, + conversationComments, + dependencies + ); + return { + ok: true, + repository, + pullRequestNumber, + applied: dependencies.apply, + outcome: submission.analysis.outcome, + inspection + }; + } + validateFixedReview(submission.analysis, inspection); + const approvalReasons = requiresApproval( + submission.analysis, + inspection, + false, + dependencies.policy + ); + if (approvalReasons.length > 0) { + await finishWithoutPush2( + repository, + pullRequestNumber, + nextReviewCursor, + nextIterations, + submission.expectedHeadSha, + "needs-approval", + conversationComments, + dependencies + ); + return { + ok: true, + repository, + pullRequestNumber, + applied: dependencies.apply, + outcome: "needs_approval", + inspection + }; + } + if (!dependencies.apply) { + await dependencies.workspace.cleanupReview(repository, pullRequestNumber); + return { + ok: true, + repository, + pullRequestNumber, + applied: false, + outcome: "fixed", + inspection + }; + } + const commitTitle = sanitizeTitle(submission.analysis.commitTitle); + const commit = await dependencies.workspace.commitAndPush( + submission.workspacePath, + submission.branch, + commitTitle, + repositoryCloneUrl(dependencies.serverUrl, repository) + ); + await upsertReviewState( + repository, + pullRequestNumber, + { + reviewCursor: nextReviewCursor, + iterations: nextIterations, + headSha: commit, + status: "fixed" + }, + conversationComments, + dependencies + ); + await dependencies.workspace.cleanupReview(repository, pullRequestNumber); + return { + ok: true, + repository, + pullRequestNumber, + applied: true, + outcome: "fixed", + commit, + inspection + }; +} +async function failReviewFix(repository, pullRequestNumber, reviewCursor, iterations, headSha, dependencies) { + assertAllowedRepository(repository, dependencies.allowedRepository); + try { + if (dependencies.apply) { + const comments = await dependencies.provider.listComments( + repository, + pullRequestNumber + ); + await upsertReviewState( + repository, + pullRequestNumber, + { + reviewCursor, + iterations, + headSha, + status: "failed" + }, + comments, + dependencies + ); + } + } finally { + await dependencies.workspace.cleanupReview(repository, pullRequestNumber); + } + return { + ok: true, + repository, + pullRequestNumber, + applied: dependencies.apply, + outcome: "failed" + }; +} +function findingsForReview(review, reviewComments) { + const findings = []; + if (review.body.trim()) { + findings.push({ + source: "review", + id: review.id, + body: review.body, + ...review.htmlUrl ? { htmlUrl: review.htmlUrl } : {}, + ...review.submittedAt ? { createdAt: review.submittedAt } : {}, + review + }); + } + findings.push( + ...reviewComments.filter( + (comment) => comment.pullRequestReviewId === review.id && !comment.inReplyToId && sameUser(comment.user, review.user) + ).map((comment) => ({ + source: "review_comment", + id: comment.id, + body: comment.body, + ...comment.htmlUrl ? { htmlUrl: comment.htmlUrl } : {}, + ...comment.createdAt ? { createdAt: comment.createdAt } : {}, + comment + })) + ); + return findings.sort(compareSourcedFindings); +} +function ineligibleReason2(pullRequest, repository, dependencies) { + if (pullRequest.state.toLowerCase() !== "open") + return "Pull Request is not open"; + if (!pullRequest.draft) return "Pull Request is not a Draft"; + if (!pullRequest.head.startsWith(dependencies.policy.branchPrefix)) { + return "Pull Request branch is not managed by the Draft PR Agent"; + } + if (pullRequest.headRepository?.trim().toLowerCase() !== repository.trim().toLowerCase()) { + return "Pull Request head repository is not the allowlisted repository"; + } + if (!pullRequest.headSha || !/^[0-9a-f]{40}$/.test(pullRequest.headSha)) { + return "Pull Request has no valid head SHA"; + } + return void 0; +} +function ineligibleReviewReason(review, pullRequest) { + if (review.state.trim().toLowerCase() !== "changes_requested") { + return "Pull Request Review is not a change request"; + } + if (!review.user?.login.trim()) return "Pull Request Review has no author"; + if (!trustedReviewerAssociation(review.authorAssociation)) { + return "Pull Request Review author is not a trusted repository member"; + } + if (review.commitId !== pullRequest.headSha) { + return "Pull Request Review targets a stale head"; + } + return void 0; +} +function trustedReviewerAssociation(value) { + return ["owner", "member", "collaborator"].includes( + value.trim().toLowerCase() + ); +} +function sameUser(left, right) { + if (!left || !right) return false; + if (left.id !== void 0 && right.id !== void 0) + return left.id === right.id; + return left.login.trim().toLowerCase() === right.login.trim().toLowerCase(); +} +function validateFindingCoverage(analysis, expectedFindings) { + const actual = analysis.findings.map(findingKey); + const expected = expectedFindings.map(findingKey); + if (new Set(actual).size !== actual.length || actual.length !== expected.length || expected.some((key) => !actual.includes(key))) { + throw new Error("review result must address every prepared finding once"); + } + if (analysis.outcome === "fixed" && analysis.findings.some( + (finding) => finding.disposition === "needs_approval" + )) { + throw new Error( + "fixed review result cannot contain approval-gated findings" + ); + } + if (analysis.outcome === "no_change" && analysis.findings.some( + (finding) => finding.disposition !== "not_reproducible" + )) { + throw new Error( + "no_change review result requires every finding to be not reproducible" + ); + } +} +function validateFixedReview(analysis, inspection) { + if (!sanitizeTitle(analysis.commitTitle)) { + throw new Error("fixed review result requires a commit title"); + } + if (inspection.changedFiles.length === 0) { + throw new Error("fixed review result requires a non-empty change"); + } + if (!inspection.diffCheckPassed) { + throw new Error("git diff --check rejected the review fix"); + } + if (inspection.secretFindingPaths.length > 0) { + throw new Error( + `possible credential material detected in: ${inspection.secretFindingPaths.join(", ")}` + ); + } + if (analysis.validationOverride && !hasConsistentValidationOverride(analysis)) { + throw new Error( + "fixed review result has an inconsistent validation override" + ); + } + if (analysis.tests.some((test) => test.status === "failed") && !hasConsistentValidationOverride(analysis)) { + throw new Error("fixed review result reports a failed validation command"); + } +} +async function finishWithoutPush2(repository, pullRequestNumber, reviewCursor, iterations, headSha, status, comments, dependencies) { + if (dependencies.apply) { + await upsertReviewState( + repository, + pullRequestNumber, + { reviewCursor, iterations, headSha, status }, + comments, + dependencies + ); + } + await dependencies.workspace.cleanupReview(repository, pullRequestNumber); +} +async function upsertReviewState(repository, pullRequestNumber, state, comments, dependencies) { + const botLogin = dependencies.botLogin?.trim(); + if (!botLogin) + throw new Error("Draft PR bot login is required in apply mode"); + const body = buildReviewFixComment(state); + const existing = findReviewFixComment(comments, botLogin); + if (existing) { + await dependencies.provider.updateComment( + repository, + pullRequestNumber, + existing.id, + body + ); + } else { + await dependencies.provider.createComment( + repository, + pullRequestNumber, + body + ); + } +} +function reviewState(comments, dependencies) { + const botLogin = dependencies.botLogin?.trim(); + if (!botLogin) return parseReviewFixState(void 0); + return parseReviewFixState(findReviewFixComment(comments, botLogin)); +} +function fingerprintFindings(findings) { + return crypto4.createHash("sha256").update( + JSON.stringify( + findings.map(({ source, id, body, review, comment }) => ({ + source, + id, + body, + author: (review?.user ?? comment?.user)?.login ?? "", + authorId: (review?.user ?? comment?.user)?.id ?? null, + ...review ? { + state: review.state, + commitId: review.commitId, + authorAssociation: review.authorAssociation + } : {}, + ...comment ? { + path: comment.path, + line: comment.line ?? null, + originalLine: comment.originalLine ?? null, + diffHunk: comment.diffHunk ?? "", + commitId: comment.commitId ?? "" + } : {} + })) + ) + ).digest("hex").slice(0, 20); +} +function toFinding({ + source, + id, + body, + htmlUrl, + createdAt, + comment +}) { + return { + source, + commentId: id, + body: truncateText(body, 4e3), + ...htmlUrl ? { htmlUrl } : {}, + ...createdAt ? { createdAt } : {}, + ...comment?.path ? { path: comment.path } : {}, + ...comment?.line !== void 0 ? { line: comment.line } : {}, + ...comment?.originalLine !== void 0 ? { originalLine: comment.originalLine } : {}, + ...comment?.startLine !== void 0 ? { startLine: comment.startLine } : {}, + ...comment?.originalStartLine !== void 0 ? { originalStartLine: comment.originalStartLine } : {}, + ...comment?.side ? { side: comment.side } : {}, + ...comment?.startSide ? { startSide: comment.startSide } : {}, + ...comment?.diffHunk ? { diffHunk: truncateText(comment.diffHunk, 8e3) } : {}, + ...comment?.commitId ? { commitId: comment.commitId } : {}, + ...comment?.originalCommitId ? { originalCommitId: comment.originalCommitId } : {}, + ...comment?.inReplyToId !== void 0 ? { inReplyToId: comment.inReplyToId } : {}, + ...comment?.pullRequestReviewId !== void 0 ? { pullRequestReviewId: comment.pullRequestReviewId } : {} + }; +} +function compareSourcedFindings(left, right) { + const sourceOrder = { review: 0, review_comment: 1 }; + return sourceOrder[left.source] - sourceOrder[right.source] || left.id - right.id; +} +function findingKey(value) { + const commentId = "id" in value ? value.id : value.commentId; + return `${value.source}:${commentId}`; +} +function skipped2(repository, pullRequestNumber, reason) { + return { ok: true, skipped: true, reason, repository, pullRequestNumber }; +} +function requireReviewBotIdentity(dependencies) { + if (dependencies.apply && !dependencies.botLogin?.trim()) { + throw new Error("Draft PR bot login is required in apply mode"); + } +} + +// src/runtime/target-binding.ts +function assertBoundTarget(options) { + const expectedRepository = options.expectedRepository?.trim() ?? ""; + const expectedTargetText = options.expectedTarget?.trim() ?? ""; + if (!expectedRepository && !expectedTargetText) { + if (options.apply) throw new Error(options.errors.missing); + return; + } + if (!expectedRepository || !expectedTargetText) { + throw new Error(options.errors.incomplete); + } + const expectedTarget = Number(expectedTargetText); + if (!isRepositorySlug(expectedRepository) || !Number.isSafeInteger(expectedTarget) || expectedTarget <= 0) { + throw new Error(options.errors.invalid); + } + if (options.repository !== expectedRepository || options.targetNumber !== expectedTarget) { + throw new Error( + options.errors.mismatch(expectedRepository, expectedTarget) + ); + } +} + +// src/draft-pr/target.ts +function assertBoundReviewTarget(repository, pullRequestNumber, apply, environment) { + assertBoundTarget({ + repository, + targetNumber: pullRequestNumber, + apply, + expectedRepository: environment.DRAFT_PR_EXPECTED_REPOSITORY, + expectedTarget: environment.DRAFT_PR_EXPECTED_PULL_REQUEST, + errors: { + missing: "Draft PR review apply mode requires a scheduler-bound Pull Request target", + incomplete: "incomplete scheduler-bound Draft PR review target", + invalid: "invalid scheduler-bound Draft PR review target", + mismatch: () => `requested Pull Request ${repository}#${pullRequestNumber} does not match the scheduler-bound review target` + } + }); +} +function assertBoundDraftPrTarget(repository, issueNumber, apply, environment) { + assertBoundTarget({ + repository, + targetNumber: issueNumber, + apply, + expectedRepository: environment.DRAFT_PR_EXPECTED_REPOSITORY, + expectedTarget: environment.DRAFT_PR_EXPECTED_ISSUE, + errors: { + missing: "Draft PR apply mode requires a scheduler-bound Issue target", + incomplete: "incomplete scheduler-bound Draft PR target", + invalid: "invalid scheduler-bound Draft PR target", + mismatch: () => `requested Issue ${repository}#${issueNumber} does not match the scheduler-bound Draft PR target` + } + }); +} + +// src/issues/managed-comments.ts +var ISSUE_TRIAGE_COMMENT_PREFIX = "`; +} +function findDraftPrComment(comments, botLogin) { + const expected = botLogin.trim().toLowerCase(); + return comments.find( + (comment) => comment.user?.login.trim().toLowerCase() === expected && comment.body.startsWith(DRAFT_PR_COMMENT_PREFIX) + ); +} +function buildDraftPrStatusComment(issueNumber, status, details = {}) { + const lines = [draftPrCommentMarker(issueNumber), "## Draft PR agent", ""]; + if (status === "running") { + lines.push("The repository development Agent has claimed this Issue."); + } else if (status === "needs-approval") { + lines.push("Implementation paused for maintainer approval."); + } else if (status === "pr-open") { + lines.push( + details.pullRequestUrl ? `Draft Pull Request: ${details.pullRequestUrl}` : "A Draft Pull Request was created." + ); + } else if (status === "dry-run") { + lines.push("Dry run completed; no branch or Pull Request was created."); + } else { + lines.push( + "The repository development Agent could not prepare a Draft PR." + ); + } + const reasons = (details.reasons ?? []).map(sanitizeFailureReason).filter(Boolean); + if (reasons.length > 0) { + lines.push("", "### Attention", ""); + for (const reason of reasons.slice(0, 8)) lines.push(`- ${reason}`); + } + const message = sanitizeLine(details.message ?? ""); + if (message) lines.push("", message); + return lines.join("\n"); +} +function sanitizeLine(value) { + return value.replace(//g, "").replace(/[\r\n]+/g, " ").replace(/\s+/g, " ").trim().slice(0, 500); +} +function sanitizeFailureReason(value) { + return sanitizeLine(value).replace( + /\b(?:gh[pousr]_[A-Za-z0-9]{20,}|github_pat_[A-Za-z0-9_]{20,})\b/g, + "" + ).replace(/(Authorization\s*:\s*)(?:Bearer|token)\s+\S+/gi, "$1").replace(/(https?:\/\/)[^\s/@:]+:[^\s/@]+@/gi, "$1@").replace(/([?&](?:access_token|token)=)[^&\s]+/gi, "$1").slice(0, 500); +} + +// src/draft-pr/tool.ts +async function prepareDraftPr(repository, issueNumber, trigger, dependencies) { + assertAllowedRepository(repository, dependencies.allowedRepository); + const issue2 = await dependencies.provider.getIssue(repository, issueNumber); + const reason = ineligibleReason3(issue2, trigger, dependencies.policy); + if (reason) { + return { + ok: true, + skipped: true, + reason, + repository, + issueNumber, + trigger, + approved: trigger === "approved" + }; + } + const branch = `${dependencies.policy.branchPrefix}${issueNumber}`; + const existingPullRequests = await dependencies.provider.listOpenPullRequestsByHead(repository, branch); + if (existingPullRequests.length > 0) { + return { + ok: true, + skipped: true, + reason: `an open Pull Request already exists for ${branch}`, + repository, + issueNumber, + trigger, + approved: trigger === "approved" + }; + } + const [baseBranch, comments] = await Promise.all([ + dependencies.provider.getRepositoryDefaultBranch(repository), + dependencies.provider.listComments(repository, issueNumber) + ]); + const contextComments = selectContextComments( + comments, + dependencies.botLogin + ); + const fingerprint = issueFingerprint(issue2, contextComments); + let preparedWorkspace; + try { + preparedWorkspace = await dependencies.workspace.prepare({ + repository, + issueNumber, + cloneUrl: repositoryCloneUrl(dependencies.serverUrl, repository), + baseBranch, + branch + }); + if (dependencies.apply) { + const botLogin = requiredBotLogin(dependencies.botLogin); + await claimIssue( + repository, + issueNumber, + trigger, + dependencies, + botLogin + ); + } + } catch (error) { + if (error instanceof DraftPrWorkspaceLockError) { + return { + ok: true, + skipped: true, + reason: error.message, + repository, + issueNumber, + trigger, + approved: trigger === "approved" + }; + } + await dependencies.workspace.cleanup(repository, issueNumber); + throw error; + } + return { + ok: true, + repository, + issueNumber, + trigger, + approved: trigger === "approved", + issueFingerprint: fingerprint, + issue: issue2, + comments: contextComments, + workspacePath: preparedWorkspace.path, + branch: preparedWorkspace.branch, + baseBranch: preparedWorkspace.baseBranch, + baseCommit: preparedWorkspace.baseCommit + }; +} +async function applyDraftPr(repository, issueNumber, submissionInput, dependencies) { + assertAllowedRepository(repository, dependencies.allowedRepository); + const submission = draftPrSubmissionSchema.parse(submissionInput); + const [issue2, comments] = await Promise.all([ + dependencies.provider.getIssue(repository, issueNumber), + dependencies.provider.listComments(repository, issueNumber) + ]); + const contextComments = selectContextComments( + comments, + dependencies.botLogin + ); + if (issueFingerprint(issue2, contextComments) !== submission.issueFingerprint) { + throw new Error("Issue changed after the Draft PR Agent started"); + } + if (issue2.state.toLowerCase() !== "open") { + throw new Error("Issue is no longer open"); + } + const inspection = await dependencies.workspace.inspect( + submission.workspacePath + ); + if (inspection.headCommit !== submission.baseCommit) { + throw new Error( + "the Agent committed or moved HEAD inside the prepared workspace" + ); + } + const analysis = submission.analysis; + if (analysis.outcome !== "implemented") { + const reasons = analysis.outcome === "needs_approval" ? outcomeReasons(analysis) : failureReasons(analysis); + if (analysis.outcome === "needs_approval") { + await transitionNeedsApproval( + repository, + issueNumber, + reasons, + dependencies + ); + } else { + await transitionFailed(repository, issueNumber, reasons, dependencies); + } + await dependencies.workspace.cleanup(repository, issueNumber); + return { + ok: true, + repository, + issueNumber, + applied: dependencies.apply, + outcome: analysis.outcome, + branch: submission.branch, + inspection + }; + } + validateImplementedAnalysis(analysis, inspection); + const approvalReasons = requiresApproval( + analysis, + inspection, + submission.trigger === "approved", + dependencies.policy + ); + if (approvalReasons.length > 0) { + await transitionNeedsApproval( + repository, + issueNumber, + approvalReasons, + dependencies + ); + await dependencies.workspace.cleanup(repository, issueNumber); + return { + ok: true, + repository, + issueNumber, + applied: dependencies.apply, + outcome: "needs_approval", + branch: submission.branch, + inspection + }; + } + const title = sanitizeTitle(analysis.prTitle); + const body = buildPullRequestBody(issueNumber, analysis); + if (!dependencies.apply) { + await dependencies.workspace.cleanup(repository, issueNumber); + return { + ok: true, + repository, + issueNumber, + applied: false, + outcome: "implemented", + branch: submission.branch, + proposedTitle: title, + proposedBody: body, + inspection + }; + } + const commit = await dependencies.workspace.commitAndPush( + submission.workspacePath, + submission.branch, + title, + repositoryCloneUrl(dependencies.serverUrl, repository) + ); + const pullRequest = await dependencies.provider.createDraftPullRequest( + repository, + { + title, + body, + head: submission.branch, + base: submission.baseBranch + } + ); + await transitionPullRequestOpen( + repository, + issueNumber, + pullRequest.url, + dependencies + ); + await dependencies.workspace.cleanup(repository, issueNumber); + return { + ok: true, + repository, + issueNumber, + applied: true, + outcome: "implemented", + branch: submission.branch, + commit, + pullRequestNumber: pullRequest.number, + pullRequestUrl: pullRequest.url, + inspection + }; +} +async function failDraftPr(repository, issueNumber, message, dependencies) { + assertAllowedRepository(repository, dependencies.allowedRepository); + try { + if (dependencies.apply) { + await transitionFailed(repository, issueNumber, [message], dependencies); + } + } finally { + await dependencies.workspace.cleanup(repository, issueNumber); + } + return { + ok: true, + repository, + issueNumber, + applied: dependencies.apply, + outcome: "failed" + }; +} +function ineligibleReason3(issue2, trigger, policy) { + if (issue2.state.toLowerCase() !== "open") return "Issue is not open"; + if (hasAnyLabel(issue2.labels, policy.skipLabels)) { + return "Issue has a configured skip label"; + } + if (hasAnyLabel(issue2.labels, policy.blockedLabels)) { + return "Issue has a label that blocks Draft PR execution"; + } + const triggerLabel = trigger === "approved" ? policy.approvedLabel : policy.readyLabel; + if (!hasLabel(issue2.labels, triggerLabel)) { + return `Issue does not have ${triggerLabel}`; + } + if (trigger === "approved" && !hasLabel(issue2.labels, policy.needsApprovalLabel)) { + return `Issue does not have ${policy.needsApprovalLabel}`; + } + return void 0; +} +async function claimIssue(repository, issueNumber, trigger, dependencies, botLogin) { + const policy = dependencies.policy; + await ensureWorkflowLabels(repository, [policy.runningLabel], dependencies); + await dependencies.provider.addLabels(repository, issueNumber, [ + policy.runningLabel + ]); + await dependencies.provider.removeLabel( + repository, + issueNumber, + trigger === "approved" ? policy.approvedLabel : policy.readyLabel + ); + await dependencies.provider.removeLabel( + repository, + issueNumber, + policy.failedLabel + ); + if (trigger === "approved") { + await dependencies.provider.removeLabel( + repository, + issueNumber, + policy.needsApprovalLabel + ); + } + await upsertStatusComment( + repository, + issueNumber, + buildDraftPrStatusComment(issueNumber, "running"), + dependencies, + botLogin + ); +} +async function transitionNeedsApproval(repository, issueNumber, reasons, dependencies) { + if (!dependencies.apply) return; + const botLogin = requiredBotLogin(dependencies.botLogin); + const policy = dependencies.policy; + await ensureWorkflowLabels( + repository, + [policy.needsApprovalLabel], + dependencies + ); + await dependencies.provider.addLabels(repository, issueNumber, [ + policy.needsApprovalLabel + ]); + await dependencies.provider.removeLabel( + repository, + issueNumber, + policy.runningLabel + ); + await upsertStatusComment( + repository, + issueNumber, + buildDraftPrStatusComment(issueNumber, "needs-approval", { reasons }), + dependencies, + botLogin + ); +} +async function transitionFailed(repository, issueNumber, reasons, dependencies) { + if (!dependencies.apply) return; + const botLogin = requiredBotLogin(dependencies.botLogin); + const policy = dependencies.policy; + await ensureWorkflowLabels(repository, [policy.failedLabel], dependencies); + await dependencies.provider.addLabels(repository, issueNumber, [ + policy.failedLabel + ]); + await dependencies.provider.removeLabel( + repository, + issueNumber, + policy.runningLabel + ); + await upsertStatusComment( + repository, + issueNumber, + buildDraftPrStatusComment(issueNumber, "failed", { reasons }), + dependencies, + botLogin + ); +} +async function transitionPullRequestOpen(repository, issueNumber, pullRequestUrl, dependencies) { + const botLogin = requiredBotLogin(dependencies.botLogin); + const policy = dependencies.policy; + await ensureWorkflowLabels(repository, [policy.prOpenLabel], dependencies); + await dependencies.provider.addLabels(repository, issueNumber, [ + policy.prOpenLabel + ]); + await dependencies.provider.removeLabel( + repository, + issueNumber, + policy.runningLabel + ); + await upsertStatusComment( + repository, + issueNumber, + buildDraftPrStatusComment(issueNumber, "pr-open", { pullRequestUrl }), + dependencies, + botLogin + ); +} +async function ensureWorkflowLabels(repository, labels, dependencies) { + for (const label of labels) { + await dependencies.provider.ensureLabel( + repository, + label, + dependencies.policy.labelColors[label] ?? "ededed" + ); + } +} +async function upsertStatusComment(repository, issueNumber, body, dependencies, botLogin) { + const comments = await dependencies.provider.listComments( + repository, + issueNumber + ); + const existing = findDraftPrComment(comments, botLogin); + if (existing) { + await dependencies.provider.updateComment( + repository, + issueNumber, + existing.id, + body + ); + } else { + await dependencies.provider.createComment(repository, issueNumber, body); + } +} +function selectContextComments(comments, botLogin) { + const expectedBot = botLogin?.trim().toLowerCase(); + return comments.filter((comment) => { + const managedBot = expectedBot && comment.user?.login.trim().toLowerCase() === expectedBot; + return !(managedBot && (comment.body.startsWith(DRAFT_PR_COMMENT_PREFIX) || isIssueTriageComment(comment.body))); + }).sort((left, right) => left.id - right.id).slice(-50).map((comment) => ({ + ...comment, + body: truncateText(comment.body, 4e3) + })); +} +function validateImplementedAnalysis(analysis, inspection) { + if (!sanitizeTitle(analysis.prTitle)) { + throw new Error("implemented result requires a Pull Request title"); + } + if (inspection.changedFiles.length === 0) { + throw new Error( + "implemented result requires a non-empty repository change" + ); + } + if (!inspection.diffCheckPassed) { + throw new Error("git diff --check rejected the repository change"); + } + if (inspection.secretFindingPaths.length > 0) { + throw new Error( + `possible credential material detected in: ${inspection.secretFindingPaths.join(", ")}` + ); + } + if (analysis.validationOverride && !hasConsistentValidationOverride(analysis)) { + throw new Error( + "implemented result has an inconsistent validation override" + ); + } + if (analysis.tests.some((test) => test.status === "failed") && !hasConsistentValidationOverride(analysis)) { + throw new Error("implemented result reports a failed validation command"); + } +} +function outcomeReasons(analysis) { + return [ + ...analysis.risk.reasons, + ...analysis.notes, + ...analysis.summary + ].slice(0, 8); +} +function failureReasons(analysis) { + const validationFailures = analysis.tests.filter((test) => test.status === "failed" || test.status === "not_run").map((test) => { + const prefix = test.status === "failed" ? "Validation failed" : "Validation not run"; + return `${prefix}: ${test.command}${test.details ? ` \u2014 ${test.details}` : ""}`; + }); + return [ + ...validationFailures, + ...analysis.risk.reasons, + ...analysis.notes, + ...analysis.summary + ].slice(0, 8); +} +function buildPullRequestBody(issueNumber, analysis) { + const lines = [`Closes #${issueNumber}`, "", "## Summary", ""]; + for (const item of analysis.summary) lines.push(`- ${sanitizeLine2(item)}`); + lines.push("", "## Validation", ""); + if (analysis.tests.length === 0) { + lines.push("- Not reported."); + } else { + for (const test of analysis.tests) { + lines.push( + `- \`${sanitizeCode(test.command)}\` \u2014 ${test.status}${test.details ? `: ${sanitizeLine2(test.details)}` : ""}` + ); + } + } + if (analysis.validationOverride) { + lines.push( + "", + "## Validation override", + "", + `- Classification: \`${analysis.validationOverride.classification}\``, + `- Source: \`${analysis.validationOverride.source}\``, + `- Reason: ${sanitizeLine2(analysis.validationOverride.reason)}` + ); + } + lines.push("", "## Risk", "", `- Level: \`${analysis.risk.level}\``); + for (const reason of analysis.risk.reasons) { + lines.push(`- ${sanitizeLine2(reason)}`); + } + if (analysis.notes.length > 0) { + lines.push("", "## Notes", ""); + for (const note of analysis.notes) lines.push(`- ${sanitizeLine2(note)}`); + } + lines.push( + "", + "_Prepared by the repository development Agent and opened as a Draft Pull Request for maintainer review._" + ); + return lines.join("\n"); +} +function sanitizeLine2(value) { + return value.replace(//g, "").replace(/[\r\n]+/g, " ").replace(/\s+/g, " ").trim().slice(0, 500); +} +function sanitizeCode(value) { + return sanitizeLine2(value).replace(/`/g, "'"); +} +function requiredBotLogin(value) { + const normalized = value?.trim(); + if (!normalized) + throw new Error("Draft PR bot login is required in apply mode"); + return normalized; +} + +// src/draft-pr/main.ts +async function main() { + const options = parseArguments(process.argv.slice(2)); + const apply = envBoolean(process.env.DRAFT_PR_APPLY); + const allowedRepository = process.env.DRAFT_PR_ALLOWED_REPOSITORY?.trim() || process.env.GITHUB_ALLOWED_REPOSITORY?.trim() || ""; + if (["prepare", "inspect-validation", "apply", "fail"].includes(options.command)) { + assertBoundDraftPrTarget( + options.repository, + options.issueNumber, + apply, + process.env + ); + } else { + assertBoundReviewTarget( + options.repository, + options.pullRequestNumber, + apply, + process.env + ); + } + if (options.command === "inspect-validation") { + assertAllowedRepository(options.repository, allowedRepository); + const result2 = await fingerprintDraftPrWorkspace( + process.env.DRAFT_PR_WORKSPACE_ROOT?.trim() || "/draft-pr-workspaces", + options.workspacePath + ); + process.stdout.write(`${JSON.stringify(result2, null, 2)} +`); + return; + } + const policy = await loadPolicy(); + const token = await resolveGitHubToken(options.repository); + const provider = new GitHubClient({ + ...token ? { token } : {}, + ...process.env.GITHUB_API_URL ? { baseUrl: process.env.GITHUB_API_URL } : {} + }); + const workspace = new GitDraftPrWorkspace({ + root: process.env.DRAFT_PR_WORKSPACE_ROOT?.trim() || "/draft-pr-workspaces", + token, + authorName: process.env.DRAFT_PR_GIT_AUTHOR_NAME?.trim() || "engineering-agent-workflows", + authorEmail: process.env.DRAFT_PR_GIT_AUTHOR_EMAIL?.trim() || "engineering-agent-workflows@users.noreply.github.com", + ...process.env.DRAFT_PR_GIT_CURL_RESOLVE ? { gitCurlResolve: process.env.DRAFT_PR_GIT_CURL_RESOLVE } : {} + }); + const dependencies = { + provider, + workspace, + policy, + allowedRepository, + serverUrl: process.env.GITHUB_SERVER_URL?.trim() || "https://github.com", + apply, + ...process.env.GITHUB_BOT_LOGIN ? { botLogin: process.env.GITHUB_BOT_LOGIN } : {} + }; + const result = options.command === "prepare" ? await prepareDraftPr( + options.repository, + options.issueNumber, + options.trigger, + dependencies + ) : options.command === "apply" ? await applyDraftPr( + options.repository, + options.issueNumber, + JSON.parse( + await readFile2(options.analysisFile, "utf8") + ), + dependencies + ) : options.command === "fail" ? await failDraftPr( + options.repository, + options.issueNumber, + options.message ?? "Draft PR Agent execution failed", + dependencies + ) : options.command === "prepare-review" ? await prepareReviewFix( + options.repository, + options.pullRequestNumber, + options.reviewId, + dependencies + ) : options.command === "apply-review" ? await applyReviewFix( + options.repository, + options.pullRequestNumber, + JSON.parse( + await readFile2(options.analysisFile, "utf8") + ), + dependencies + ) : options.command === "fail-review" ? await failReviewFix( + options.repository, + options.pullRequestNumber, + options.reviewCursor ?? 0, + options.iterations ?? 0, + options.headSha ?? "", + dependencies + ) : options.command === "prepare-ci" ? await prepareCiFix( + options.repository, + options.pullRequestNumber, + options.headSha ?? "", + options.checkSuiteId ?? 0, + dependencies + ) : options.command === "apply-ci" ? await applyCiFix( + options.repository, + options.pullRequestNumber, + JSON.parse( + await readFile2(options.analysisFile, "utf8") + ), + dependencies + ) : await failCiFix( + options.repository, + options.pullRequestNumber, + options.checkSuiteId ?? 0, + options.attempts ?? 0, + options.headSha ?? "", + dependencies + ); + process.stdout.write(`${JSON.stringify(result, null, 2)} +`); +} +async function loadPolicy() { + const embedded = process.env.WORKFLOW_POLICY_JSON?.trim(); + if (embedded) { + try { + return draftPrPolicySchema.parse(JSON.parse(embedded)); + } catch (error) { + throw new Error( + `failed to load embedded Draft PR policy: ${errorMessage(error)}` + ); + } + } + return loadJsonFromCandidates( + [ + fileURLToPath(new URL("../policy.json", import.meta.url)), + path2.resolve("agents/draft-pr/policy.json") + ], + (value) => draftPrPolicySchema.parse(value), + "failed to load Draft PR policy" + ); +} +function parseArguments(args) { + const command = args.shift(); + if (command !== "prepare" && command !== "inspect-validation" && command !== "apply" && command !== "fail" && command !== "prepare-review" && command !== "apply-review" && command !== "fail-review" && command !== "prepare-ci" && command !== "apply-ci" && command !== "fail-ci") { + throw new Error("invalid Draft PR tool command"); + } + let repository = ""; + let issueNumber = 0; + let pullRequestNumber = 0; + let trigger = ""; + let analysisFile = ""; + let message = ""; + let reviewId = 0; + let reviewCursor = 0; + let iterations = 0; + let headSha = ""; + let checkSuiteId = 0; + let attempts = 0; + let workspacePath = ""; + for (let index = 0; index < args.length; index += 1) { + const argument = args[index]; + if (argument === "--repository") { + repository = requiredArgumentValue(args, ++index, argument); + } else if (argument === "--issue") { + issueNumber = Number(requiredArgumentValue(args, ++index, argument)); + } else if (argument === "--pull-request") { + pullRequestNumber = Number( + requiredArgumentValue(args, ++index, argument) + ); + } else if (argument === "--trigger") { + trigger = requiredArgumentValue(args, ++index, argument); + } else if (argument === "--analysis") { + analysisFile = requiredArgumentValue(args, ++index, argument); + } else if (argument === "--message") { + message = requiredArgumentValue(args, ++index, argument); + } else if (argument === "--review") { + reviewId = Number(requiredArgumentValue(args, ++index, argument)); + } else if (argument === "--review-cursor") { + reviewCursor = Number(requiredArgumentValue(args, ++index, argument)); + } else if (argument === "--iterations") { + iterations = Number(requiredArgumentValue(args, ++index, argument)); + } else if (argument === "--head") { + headSha = requiredArgumentValue(args, ++index, argument); + } else if (argument === "--check-suite") { + checkSuiteId = Number(requiredArgumentValue(args, ++index, argument)); + } else if (argument === "--attempts") { + attempts = Number(requiredArgumentValue(args, ++index, argument)); + } else if (argument === "--workspace") { + workspacePath = requiredArgumentValue(args, ++index, argument); + } else { + throw new Error(`unknown argument: ${argument}`); + } + } + if (!isRepositorySlug(repository)) { + throw new Error("--repository must use owner/repository format"); + } + if (["prepare", "inspect-validation", "apply", "fail"].includes(command) && (!Number.isSafeInteger(issueNumber) || issueNumber <= 0)) { + throw new Error("--issue must be a positive integer"); + } + if ([ + "prepare-review", + "apply-review", + "fail-review", + "prepare-ci", + "apply-ci", + "fail-ci" + ].includes(command) && (!Number.isSafeInteger(pullRequestNumber) || pullRequestNumber <= 0)) { + throw new Error("--pull-request must be a positive integer"); + } + if (command === "prepare" && trigger !== "ready" && trigger !== "approved") { + throw new Error("prepare requires --trigger ready or approved"); + } + if (command === "inspect-validation" && !workspacePath) { + throw new Error("inspect-validation requires --workspace"); + } + if (command === "prepare-review" && (!Number.isSafeInteger(reviewId) || reviewId <= 0)) { + throw new Error("prepare-review requires --review"); + } + if ((command === "apply" || command === "apply-review" || command === "apply-ci") && !analysisFile) { + throw new Error(`${command} requires --analysis`); + } + return { + command, + repository, + ...issueNumber ? { issueNumber } : {}, + ...pullRequestNumber ? { pullRequestNumber } : {}, + ...trigger === "ready" || trigger === "approved" ? { trigger } : {}, + ...analysisFile ? { analysisFile } : {}, + ...message ? { message } : {}, + ...reviewId ? { reviewId } : {}, + ...reviewCursor ? { reviewCursor } : {}, + ...iterations ? { iterations } : {}, + ...headSha ? { headSha } : {}, + ...Number.isSafeInteger(checkSuiteId) && checkSuiteId > 0 ? { checkSuiteId } : {}, + ...Number.isSafeInteger(attempts) && attempts >= 0 ? { attempts } : {}, + ...workspacePath ? { workspacePath } : {} + }; +} +main().catch((error) => { + process.stderr.write(`draft-pr failed: ${errorMessage(error)} +`); + process.exitCode = 1; +}); diff --git a/agents/issue-triage/scheduler.js b/agents/issue-triage/scheduler.js index acac795..2d432e0 100644 --- a/agents/issue-triage/scheduler.js +++ b/agents/issue-triage/scheduler.js @@ -10,22 +10,9 @@ const GITHUB_ISSUE_ACTIONS = [ ]; const GITHUB_COMMENT_ACTIONS = ["created", "edited", "deleted"]; const GITHUB_TRIAGE_CONTROL_LABEL = "skip-triage"; -const WORKFLOW_TOOL_BASE64 = "var __defProp = Object.defineProperty;
var __export = (target, all) => {
  for (var name in all)
    __defProp(target, name, { get: all[name], enumerable: true });
};

// src/issue-triage/main.ts
import { readFile as readFile2 } from "node:fs/promises";
import path from "node:path";
import { fileURLToPath } from "node:url";

// src/github/app-auth.ts
import { sign } from "node:crypto";

// src/github/fetch-retry.ts
var MAX_ATTEMPTS = 3;
var RETRYABLE_STATUS_CODES = /* @__PURE__ */ new Set([502, 503, 504]);
async function fetchWithRetry(options) {
  const attempts = options.retryable ? MAX_ATTEMPTS : 1;
  let lastError;
  for (let attempt = 1; attempt <= attempts; attempt += 1) {
    try {
      const response = await options.request(options.input, options.init);
      if (attempt === attempts || !RETRYABLE_STATUS_CODES.has(response.status)) {
        return response;
      }
      await response.body?.cancel().catch(() => void 0);
    } catch (error) {
      lastError = error;
      if (attempt === attempts) {
        throw new Error(
          `${options.operation} transport failed after ${attemptLabel(attempts)}`,
          { cause: error }
        );
      }
    }
    await (options.sleep ?? sleep)(retryDelayMilliseconds(attempt));
  }
  throw new Error(`${options.operation} transport failed`, {
    cause: lastError
  });
}
function attemptLabel(attempts) {
  return `${attempts} ${attempts === 1 ? "attempt" : "attempts"}`;
}
function retryDelayMilliseconds(attempt) {
  const exponential = 250 * 2 ** (attempt - 1);
  return exponential + Math.floor(Math.random() * exponential);
}
function sleep(milliseconds) {
  return new Promise((resolve) => setTimeout(resolve, milliseconds));
}

// src/github/app-auth.ts
var DEFAULT_GITHUB_API_URL = "https://api.github.com";
var GITHUB_API_VERSION = "2022-11-28";
async function resolveGitHubToken(repository, env = process.env, dependencies = {}) {
  const configuredToken = env.GITHUB_TOKEN?.trim() ?? "";
  if (configuredToken) return configuredToken;
  const clientID = env.GITHUB_APP_CLIENT_ID?.trim() ?? "";
  const appID = env.GITHUB_APP_ID?.trim() ?? "";
  const privateKeyBase64 = env.GITHUB_APP_PRIVATE_KEY_BASE64?.trim() ?? "";
  const configuredInstallationID = env.GITHUB_APP_INSTALLATION_ID?.trim() ?? "";
  const hasAppConfiguration = Boolean(
    clientID || appID || privateKeyBase64 || configuredInstallationID
  );
  if (!hasAppConfiguration) return "";
  const issuer = clientID || appID;
  if (!issuer) {
    throw new Error(
      "GitHub App authentication requires GITHUB_APP_CLIENT_ID or GITHUB_APP_ID"
    );
  }
  if (!privateKeyBase64) {
    throw new Error(
      "GitHub App authentication requires GITHUB_APP_PRIVATE_KEY_BASE64"
    );
  }
  const privateKey = decodePrivateKey(privateKeyBase64);
  const jwt = createAppJWT(
    issuer,
    privateKey,
    dependencies.now?.() ?? Date.now()
  );
  const baseUrl = (env.GITHUB_API_URL?.trim() || DEFAULT_GITHUB_API_URL).replace(/\/+$/, "");
  const request = dependencies.fetch ?? fetch;
  const installationID = configuredInstallationID ? validateInstallationID(configuredInstallationID) : await findInstallationID(
    baseUrl,
    repository,
    jwt,
    request,
    dependencies.sleep
  );
  const tokenPath = `/app/installations/${installationID}/access_tokens`;
  const response = await fetchWithRetry({
    request,
    input: `${baseUrl}${tokenPath}`,
    init: {
      method: "POST",
      headers: appHeaders(jwt)
    },
    operation: `GitHub App POST ${tokenPath}`,
    retryable: true,
    ...dependencies.sleep ? { sleep: dependencies.sleep } : {}
  });
  if (!response.ok) {
    throw githubAppResponseError("installation token request", response);
  }
  const value = await response.json();
  const token = value.token?.trim() ?? "";
  if (!token) {
    throw new Error("GitHub App installation token response has no token");
  }
  return token;
}
function createAppJWT(issuer, privateKey, nowMilliseconds) {
  const now = Math.floor(nowMilliseconds / 1e3);
  const header = encodeJWTPart({ alg: "RS256", typ: "JWT" });
  const payload = encodeJWTPart({
    iat: now - 60,
    exp: now + 9 * 60,
    iss: issuer
  });
  const unsignedToken = `${header}.${payload}`;
  let signature;
  try {
    signature = sign("RSA-SHA256", Buffer.from(unsignedToken), privateKey);
  } catch {
    throw new Error(
      "GITHUB_APP_PRIVATE_KEY_BASE64 is not a valid RSA private key"
    );
  }
  return `${unsignedToken}.${signature.toString("base64url")}`;
}
async function findInstallationID(baseUrl, repository, jwt, request, sleepDependency) {
  const path2 = `/repos/${repositoryPath(repository)}/installation`;
  const response = await fetchWithRetry({
    request,
    input: `${baseUrl}${path2}`,
    init: {
      method: "GET",
      headers: appHeaders(jwt)
    },
    operation: `GitHub App GET ${path2}`,
    retryable: true,
    ...sleepDependency ? { sleep: sleepDependency } : {}
  });
  if (!response.ok) {
    throw githubAppResponseError("installation lookup", response);
  }
  const value = await response.json();
  if (!Number.isSafeInteger(value.id) || (value.id ?? 0) <= 0) {
    throw new Error("GitHub App installation response has no valid ID");
  }
  return String(value.id);
}
function appHeaders(jwt) {
  return {
    Accept: "application/vnd.github+json",
    Authorization: `Bearer ${jwt}`,
    "X-GitHub-Api-Version": GITHUB_API_VERSION,
    "User-Agent": "engineering-agent-workflows/github-app-auth"
  };
}
function decodePrivateKey(value) {
  let decoded;
  try {
    decoded = Buffer.from(value, "base64").toString("utf8").trim();
  } catch {
    throw new Error("GITHUB_APP_PRIVATE_KEY_BASE64 is not valid base64");
  }
  if (!/^-----BEGIN (?:RSA )?PRIVATE KEY-----/.test(decoded)) {
    throw new Error(
      "GITHUB_APP_PRIVATE_KEY_BASE64 must decode to a PEM private key"
    );
  }
  return decoded;
}
function validateInstallationID(value) {
  if (!/^[1-9][0-9]*$/.test(value)) {
    throw new Error("GITHUB_APP_INSTALLATION_ID must be a positive integer");
  }
  return value;
}
function repositoryPath(repository) {
  const parts = repository.split("/");
  if (parts.length !== 2 || parts.some((part) => !part.trim())) {
    throw new Error(`invalid GitHub repository: ${repository}`);
  }
  return parts.map(encodeURIComponent).join("/");
}
function encodeJWTPart(value) {
  return Buffer.from(JSON.stringify(value)).toString("base64url");
}
function githubAppResponseError(operation, response) {
  const status = `${response.status}${response.statusText ? ` ${response.statusText}` : ""}`;
  return new Error(`GitHub App ${operation} failed with ${status}`);
}

// src/issues/search.ts
function issueSearchText(title) {
  return title.replace(/^\[[^\]]+\]\s*:?\s*/, "").replace(/["'`:+(){}[\]\\]/g, " ").replace(/\s+/g, " ").trim().slice(0, 120);
}

// src/runtime/text.ts
function truncateText(value, max) {
  return value.length <= max ? value : value.slice(0, max);
}

// src/github/client.ts
var GitHubClient = class {
  #token;
  #baseUrl;
  #fetch;
  #sleep;
  constructor(options = {}) {
    this.#token = options.token?.trim() ?? "";
    this.#baseUrl = (options.baseUrl ?? "https://api.github.com").replace(
      /\/+$/,
      ""
    );
    this.#fetch = options.fetch ?? fetch;
    this.#sleep = options.sleep;
  }
  async getIssue(repository, issueNumber) {
    const issue2 = await this.#request(
      "GET",
      `/repos/${repositoryPath2(repository)}/issues/${issueNumber}`
    );
    if (issue2.pull_request) {
      throw new Error("GitHub pull request payload is not an Issue");
    }
    return normalizeIssue(issue2);
  }
  async searchCandidates(repository, issue2, limit) {
    const title = issueSearchText(issue2.title);
    if (!title) return [];
    const query = new URLSearchParams({
      q: `repo:${repository} is:issue in:title ${title}`,
      per_page: String(Math.min(Math.max(limit + 1, 1), 100))
    });
    const response = await this.#request(
      "GET",
      `/search/issues?${query.toString()}`
    );
    return (response.items ?? []).filter(
      (candidate) => candidate.number !== issue2.number && !candidate.pull_request
    ).slice(0, limit).map((candidate) => ({
      number: candidate.number,
      title: candidate.title,
      body: truncateText(candidate.body ?? "", 4e3),
      state: candidate.state,
      labels: labelNames(candidate.labels),
      url: candidate.html_url
    }));
  }
  async listComments(repository, issueNumber) {
    const comments = [];
    for (let page = 1; ; page += 1) {
      const batch = await this.#request(
        "GET",
        `/repos/${repositoryPath2(repository)}/issues/${issueNumber}/comments?per_page=100&page=${page}`
      );
      comments.push(...batch.map(normalizeComment));
      if (batch.length < 100) return comments;
    }
  }
  async ensureLabel(repository, name, color, description) {
    const path2 = `/repos/${repositoryPath2(repository)}/labels/${encodeURIComponent(name)}`;
    const response = await this.#rawRequest("GET", path2);
    if (response.ok) return;
    if (response.status !== 404) {
      throw await responseError("GET", path2, response);
    }
    await this.#request("POST", `/repos/${repositoryPath2(repository)}/labels`, {
      name,
      color: normalizeColor(color),
      description: description?.trim() || "Managed by engineering-agent-workflows"
    });
  }
  async getRepositoryDefaultBranch(repository) {
    const value = await this.#request(
      "GET",
      `/repos/${repositoryPath2(repository)}`
    );
    const branch = value.default_branch?.trim();
    if (!branch) throw new Error("GitHub repository has no default branch");
    return branch;
  }
  async getPullRequest(repository, pullRequestNumber) {
    const value = await this.#request(
      "GET",
      `/repos/${repositoryPath2(repository)}/pulls/${pullRequestNumber}`
    );
    return normalizePullRequest(value);
  }
  async listOpenPullRequests(repository) {
    const values = [];
    for (let page = 1; ; page += 1) {
      const batch = await this.#request(
        "GET",
        `/repos/${repositoryPath2(repository)}/pulls?state=open&per_page=100&page=${page}`
      );
      values.push(...batch.map(normalizePullRequest));
      if (batch.length < 100) return values;
    }
  }
  async listReviewComments(repository, pullRequestNumber) {
    const comments = [];
    for (let page = 1; ; page += 1) {
      const batch = await this.#request(
        "GET",
        `/repos/${repositoryPath2(repository)}/pulls/${pullRequestNumber}/comments?per_page=100&page=${page}`
      );
      comments.push(...batch.map(normalizeReviewComment));
      if (batch.length < 100) return comments;
    }
  }
  async getPullRequestReview(repository, pullRequestNumber, reviewId) {
    const review = await this.#request(
      "GET",
      `/repos/${repositoryPath2(repository)}/pulls/${pullRequestNumber}/reviews/${reviewId}`
    );
    return normalizePullRequestReview(review);
  }
  async listCheckRuns(repository, ref) {
    if (!/^[0-9a-f]{40}$/.test(ref)) {
      throw new Error("invalid GitHub check run ref");
    }
    const runs = [];
    for (let page = 1; ; page += 1) {
      const value = await this.#request(
        "GET",
        `/repos/${repositoryPath2(repository)}/commits/${ref}/check-runs?per_page=100&page=${page}`
      );
      const batch = value.check_runs ?? [];
      runs.push(...batch.map(normalizeCheckRun));
      if (batch.length < 100) return runs;
    }
  }
  async listCheckRunAnnotations(repository, checkRunId) {
    if (!Number.isSafeInteger(checkRunId) || checkRunId <= 0) {
      throw new Error("invalid GitHub check run ID");
    }
    const annotations = [];
    for (let page = 1; ; page += 1) {
      const batch = await this.#request(
        "GET",
        `/repos/${repositoryPath2(repository)}/check-runs/${checkRunId}/annotations?per_page=100&page=${page}`
      );
      annotations.push(...batch.map(normalizeCheckRunAnnotation));
      if (batch.length < 100) return annotations;
    }
  }
  async listOpenPullRequestsByHead(repository, branch) {
    const owner = repository.split("/")[0];
    const query = new URLSearchParams({
      state: "open",
      head: `${owner}:${branch}`,
      per_page: "100"
    });
    const values = await this.#request(
      "GET",
      `/repos/${repositoryPath2(repository)}/pulls?${query.toString()}`
    );
    return values.map(normalizePullRequest);
  }
  async createDraftPullRequest(repository, input) {
    const value = await this.#request(
      "POST",
      `/repos/${repositoryPath2(repository)}/pulls`,
      { ...input, draft: true }
    );
    return normalizePullRequest(value);
  }
  async addLabels(repository, issueNumber, labels) {
    if (labels.length === 0) return;
    await this.#request(
      "POST",
      `/repos/${repositoryPath2(repository)}/issues/${issueNumber}/labels`,
      { labels }
    );
  }
  async removeLabel(repository, issueNumber, label) {
    const path2 = `/repos/${repositoryPath2(repository)}/issues/${issueNumber}/labels/${encodeURIComponent(label)}`;
    const response = await this.#rawRequest("DELETE", path2);
    if (!response.ok && response.status !== 404) {
      throw await responseError("DELETE", path2, response);
    }
  }
  async createComment(repository, issueNumber, body) {
    const comment = await this.#request(
      "POST",
      `/repos/${repositoryPath2(repository)}/issues/${issueNumber}/comments`,
      { body }
    );
    return normalizeComment(comment);
  }
  async updateComment(repository, _issueNumber, commentID, body) {
    const comment = await this.#request(
      "PATCH",
      `/repos/${repositoryPath2(repository)}/issues/comments/${commentID}`,
      { body }
    );
    return normalizeComment(comment);
  }
  async #request(method, path2, body) {
    const response = await this.#rawRequest(method, path2, body);
    if (!response.ok) throw await responseError(method, path2, response);
    return await response.json();
  }
  #rawRequest(method, path2, body) {
    const headers = {
      Accept: "application/vnd.github+json",
      "X-GitHub-Api-Version": "2022-11-28",
      "User-Agent": "engineering-agent-workflows/issue-triage"
    };
    if (this.#token) headers.Authorization = `Bearer ${this.#token}`;
    if (body !== void 0) headers["Content-Type"] = "application/json";
    return fetchWithRetry({
      request: this.#fetch,
      input: `${this.#baseUrl}${path2}`,
      init: {
        method,
        headers,
        ...body === void 0 ? {} : { body: JSON.stringify(body) }
      },
      operation: `GitHub API ${method} ${path2}`,
      retryable: method === "GET",
      ...this.#sleep ? { sleep: this.#sleep } : {}
    });
  }
};
function repositoryPath2(repository) {
  const parts = repository.split("/");
  if (parts.length !== 2 || parts.some((part) => !part.trim())) {
    throw new Error(`invalid GitHub repository: ${repository}`);
  }
  return parts.map(encodeURIComponent).join("/");
}
function normalizeIssue(issue2) {
  return {
    number: issue2.number,
    title: issue2.title,
    body: issue2.body,
    state: issue2.state,
    htmlUrl: issue2.html_url,
    updatedAt: issue2.updated_at,
    labels: labelNames(issue2.labels),
    ...issue2.user ? { user: normalizeUser(issue2.user) } : {}
  };
}
function normalizeComment(comment) {
  return {
    id: comment.id,
    body: comment.body,
    ...comment.html_url ? { htmlUrl: comment.html_url } : {},
    ...comment.created_at ? { createdAt: comment.created_at } : {},
    ...comment.user ? { user: normalizeUser(comment.user) } : {}
  };
}
function normalizePullRequest(value) {
  return {
    number: value.number,
    url: value.html_url,
    state: value.state,
    draft: value.draft ?? false,
    head: value.head.ref,
    ...value.head.sha ? { headSha: value.head.sha } : {},
    ...value.head.repo?.full_name ? { headRepository: value.head.repo.full_name } : {},
    base: value.base.ref
  };
}
function normalizeReviewComment(comment) {
  return {
    id: comment.id,
    body: comment.body,
    path: comment.path,
    ...comment.user ? { user: normalizeUser(comment.user) } : {},
    ...comment.html_url ? { htmlUrl: comment.html_url } : {},
    ...comment.created_at ? { createdAt: comment.created_at } : {},
    ...comment.line != null ? { line: comment.line } : {},
    ...comment.original_line != null ? { originalLine: comment.original_line } : {},
    ...comment.start_line != null ? { startLine: comment.start_line } : {},
    ...comment.original_start_line != null ? { originalStartLine: comment.original_start_line } : {},
    ...comment.side ? { side: comment.side } : {},
    ...comment.start_side ? { startSide: comment.start_side } : {},
    ...comment.diff_hunk ? { diffHunk: comment.diff_hunk } : {},
    ...comment.commit_id ? { commitId: comment.commit_id } : {},
    ...comment.original_commit_id ? { originalCommitId: comment.original_commit_id } : {},
    ...comment.in_reply_to_id !== void 0 ? { inReplyToId: comment.in_reply_to_id } : {},
    ...comment.pull_request_review_id !== void 0 ? { pullRequestReviewId: comment.pull_request_review_id } : {}
  };
}
function normalizePullRequestReview(review) {
  return {
    id: review.id,
    body: review.body ?? "",
    state: review.state,
    commitId: review.commit_id,
    authorAssociation: review.author_association,
    ...review.user ? { user: normalizeUser(review.user) } : {},
    ...review.html_url ? { htmlUrl: review.html_url } : {},
    ...review.submitted_at ? { submittedAt: review.submitted_at } : {}
  };
}
function normalizeCheckRun(value) {
  const checkSuiteId = value.check_suite?.id;
  if (!Number.isSafeInteger(checkSuiteId) || checkSuiteId <= 0) {
    throw new Error(`GitHub check run ${value.id} has no valid check suite ID`);
  }
  return {
    id: value.id,
    checkSuiteId,
    name: truncateText(value.name ?? "", 300),
    status: value.status,
    ...value.conclusion ? { conclusion: value.conclusion } : {},
    ...value.html_url ? { htmlUrl: value.html_url } : {},
    output: {
      title: truncateText(value.output?.title ?? "", 1e3),
      summary: truncateText(value.output?.summary ?? "", 8e3),
      text: truncateText(value.output?.text ?? "", 8e3)
    }
  };
}
function normalizeCheckRunAnnotation(value) {
  return {
    path: truncateText(value.path ?? "", 1e3),
    startLine: value.start_line,
    endLine: value.end_line,
    level: truncateText(value.annotation_level ?? "", 50),
    message: truncateText(value.message ?? "", 2e3),
    ...value.title ? { title: truncateText(value.title, 500) } : {},
    ...value.raw_details ? { rawDetails: truncateText(value.raw_details, 4e3) } : {}
  };
}
function normalizeUser(user) {
  return {
    login: user.login,
    ...user.id !== void 0 ? { id: user.id } : {},
    ...user.type ? { type: user.type } : {}
  };
}
function labelNames(labels) {
  return labels.map((label) => typeof label === "string" ? label : label.name).filter((label) => label.trim() !== "");
}
function normalizeColor(color) {
  const normalized = color.trim().replace(/^#/, "");
  return /^[0-9a-f]{6}$/i.test(normalized) ? normalized : "ededed";
}
async function responseError(method, path2, response) {
  const text = await response.text().catch(() => "");
  return new Error(
    `GitHub API ${method} ${path2} failed with HTTP ${response.status}: ${truncateText(text, 1e3)}`
  );
}

// src/issues/types.ts
function isRepositorySlug(value) {
  return /^[^/\s]+\/[^/\s]+$/.test(value);
}

// src/runtime/cli.ts
function requiredArgumentValue(args, index, name) {
  const value = args[index]?.trim();
  if (!value) throw new Error(`${name} requires a value`);
  return value;
}
function envBoolean(value) {
  return ["1", "true", "yes", "on"].includes(value?.trim().toLowerCase() ?? "");
}

// src/runtime/errors.ts
function errorMessage(error) {
  return describeError(error, /* @__PURE__ */ new Set(), 0);
}
function describeError(error, seen, depth) {
  if (!(error instanceof Error)) return String(error);
  seen.add(error);
  const code = errorCode(error);
  const description = depth === 0 ? error.message : `${error.name}${code ? ` [${code}]` : ""}: ${error.message}`;
  if (depth >= 4 || error.cause === void 0 || seen.has(error.cause)) {
    return description;
  }
  return `${description}; cause: ${describeError(error.cause, seen, depth + 1)}`;
}
function errorCode(error) {
  if (!("code" in error)) return "";
  const value = error.code;
  return typeof value === "string" || typeof value === "number" ? String(value) : "";
}

// src/runtime/load-json.ts
import { readFile } from "node:fs/promises";
async function loadJsonFromCandidates(candidates, parse3, failureMessage) {
  let lastError;
  for (const candidate of candidates) {
    try {
      return parse3(JSON.parse(await readFile(candidate, "utf8")));
    } catch (error) {
      lastError = error;
    }
  }
  throw new Error(`${failureMessage}: ${errorMessage(lastError)}`);
}

// node_modules/zod/v4/core/core.js
var _a;
// @__NO_SIDE_EFFECTS__
function $constructor(name, initializer3, params) {
  function init(inst, def) {
    if (!inst._zod) {
      Object.defineProperty(inst, "_zod", {
        value: {
          def,
          constr: _,
          traits: /* @__PURE__ */ new Set()
        },
        enumerable: false
      });
    }
    if (inst._zod.traits.has(name)) {
      return;
    }
    inst._zod.traits.add(name);
    initializer3(inst, def);
    const proto = _.prototype;
    const keys = Object.keys(proto);
    for (let i = 0; i < keys.length; i++) {
      const k = keys[i];
      if (!(k in inst)) {
        inst[k] = proto[k].bind(inst);
      }
    }
  }
  const Parent = params?.Parent ?? Object;
  class Definition extends Parent {
  }
  Object.defineProperty(Definition, "name", { value: name });
  function _(def) {
    var _a3;
    const inst = params?.Parent ? new Definition() : this;
    init(inst, def);
    (_a3 = inst._zod).deferred ?? (_a3.deferred = []);
    for (const fn of inst._zod.deferred) {
      fn();
    }
    return inst;
  }
  Object.defineProperty(_, "init", { value: init });
  Object.defineProperty(_, Symbol.hasInstance, {
    value: (inst) => {
      if (params?.Parent && inst instanceof params.Parent)
        return true;
      return inst?._zod?.traits?.has(name);
    }
  });
  Object.defineProperty(_, "name", { value: name });
  return _;
}
var $ZodAsyncError = class extends Error {
  constructor() {
    super(`Encountered Promise during synchronous parse. Use .parseAsync() instead.`);
  }
};
var $ZodEncodeError = class extends Error {
  constructor(name) {
    super(`Encountered unidirectional transform during encode: ${name}`);
    this.name = "ZodEncodeError";
  }
};
(_a = globalThis).__zod_globalConfig ?? (_a.__zod_globalConfig = {});
var globalConfig = globalThis.__zod_globalConfig;
function config(newConfig) {
  if (newConfig)
    Object.assign(globalConfig, newConfig);
  return globalConfig;
}

// node_modules/zod/v4/core/util.js
var util_exports = {};
__export(util_exports, {
  BIGINT_FORMAT_RANGES: () => BIGINT_FORMAT_RANGES,
  Class: () => Class,
  NUMBER_FORMAT_RANGES: () => NUMBER_FORMAT_RANGES,
  aborted: () => aborted,
  allowsEval: () => allowsEval,
  assert: () => assert,
  assertEqual: () => assertEqual,
  assertIs: () => assertIs,
  assertNever: () => assertNever,
  assertNotEqual: () => assertNotEqual,
  assignProp: () => assignProp,
  base64ToUint8Array: () => base64ToUint8Array,
  base64urlToUint8Array: () => base64urlToUint8Array,
  cached: () => cached,
  captureStackTrace: () => captureStackTrace,
  cleanEnum: () => cleanEnum,
  cleanRegex: () => cleanRegex,
  clone: () => clone,
  cloneDef: () => cloneDef,
  createTransparentProxy: () => createTransparentProxy,
  defineLazy: () => defineLazy,
  esc: () => esc,
  escapeRegex: () => escapeRegex,
  explicitlyAborted: () => explicitlyAborted,
  extend: () => extend,
  finalizeIssue: () => finalizeIssue,
  floatSafeRemainder: () => floatSafeRemainder,
  getElementAtPath: () => getElementAtPath,
  getEnumValues: () => getEnumValues,
  getLengthableOrigin: () => getLengthableOrigin,
  getParsedType: () => getParsedType,
  getSizableOrigin: () => getSizableOrigin,
  hexToUint8Array: () => hexToUint8Array,
  isObject: () => isObject,
  isPlainObject: () => isPlainObject,
  issue: () => issue,
  joinValues: () => joinValues,
  jsonStringifyReplacer: () => jsonStringifyReplacer,
  merge: () => merge,
  mergeDefs: () => mergeDefs,
  normalizeParams: () => normalizeParams,
  nullish: () => nullish,
  numKeys: () => numKeys,
  objectClone: () => objectClone,
  omit: () => omit,
  optionalKeys: () => optionalKeys,
  parsedType: () => parsedType,
  partial: () => partial,
  pick: () => pick,
  prefixIssues: () => prefixIssues,
  primitiveTypes: () => primitiveTypes,
  promiseAllObject: () => promiseAllObject,
  propertyKeyTypes: () => propertyKeyTypes,
  randomString: () => randomString,
  required: () => required,
  safeExtend: () => safeExtend,
  shallowClone: () => shallowClone,
  slugify: () => slugify,
  stringifyPrimitive: () => stringifyPrimitive,
  uint8ArrayToBase64: () => uint8ArrayToBase64,
  uint8ArrayToBase64url: () => uint8ArrayToBase64url,
  uint8ArrayToHex: () => uint8ArrayToHex,
  unwrapMessage: () => unwrapMessage
});
function assertEqual(val) {
  return val;
}
function assertNotEqual(val) {
  return val;
}
function assertIs(_arg) {
}
function assertNever(_x) {
  throw new Error("Unexpected value in exhaustive check");
}
function assert(_) {
}
function getEnumValues(entries) {
  const numericValues = Object.values(entries).filter((v) => typeof v === "number");
  const values = Object.entries(entries).filter(([k, _]) => numericValues.indexOf(+k) === -1).map(([_, v]) => v);
  return values;
}
function joinValues(array2, separator = "|") {
  return array2.map((val) => stringifyPrimitive(val)).join(separator);
}
function jsonStringifyReplacer(_, value) {
  if (typeof value === "bigint")
    return value.toString();
  return value;
}
function cached(getter) {
  const set = false;
  return {
    get value() {
      if (!set) {
        const value = getter();
        Object.defineProperty(this, "value", { value });
        return value;
      }
      throw new Error("cached value already set");
    }
  };
}
function nullish(input) {
  return input === null || input === void 0;
}
function cleanRegex(source) {
  const start = source.startsWith("^") ? 1 : 0;
  const end = source.endsWith("$") ? source.length - 1 : source.length;
  return source.slice(start, end);
}
function floatSafeRemainder(val, step) {
  const ratio = val / step;
  const roundedRatio = Math.round(ratio);
  const tolerance = Number.EPSILON * Math.max(Math.abs(ratio), 1);
  if (Math.abs(ratio - roundedRatio) < tolerance)
    return 0;
  return ratio - roundedRatio;
}
var EVALUATING = /* @__PURE__ */ Symbol("evaluating");
function defineLazy(object2, key, getter) {
  let value = void 0;
  Object.defineProperty(object2, key, {
    get() {
      if (value === EVALUATING) {
        return void 0;
      }
      if (value === void 0) {
        value = EVALUATING;
        value = getter();
      }
      return value;
    },
    set(v) {
      Object.defineProperty(object2, key, {
        value: v
        // configurable: true,
      });
    },
    configurable: true
  });
}
function objectClone(obj) {
  return Object.create(Object.getPrototypeOf(obj), Object.getOwnPropertyDescriptors(obj));
}
function assignProp(target, prop, value) {
  Object.defineProperty(target, prop, {
    value,
    writable: true,
    enumerable: true,
    configurable: true
  });
}
function mergeDefs(...defs) {
  const mergedDescriptors = {};
  for (const def of defs) {
    const descriptors = Object.getOwnPropertyDescriptors(def);
    Object.assign(mergedDescriptors, descriptors);
  }
  return Object.defineProperties({}, mergedDescriptors);
}
function cloneDef(schema) {
  return mergeDefs(schema._zod.def);
}
function getElementAtPath(obj, path2) {
  if (!path2)
    return obj;
  return path2.reduce((acc, key) => acc?.[key], obj);
}
function promiseAllObject(promisesObj) {
  const keys = Object.keys(promisesObj);
  const promises = keys.map((key) => promisesObj[key]);
  return Promise.all(promises).then((results) => {
    const resolvedObj = {};
    for (let i = 0; i < keys.length; i++) {
      resolvedObj[keys[i]] = results[i];
    }
    return resolvedObj;
  });
}
function randomString(length = 10) {
  const chars = "abcdefghijklmnopqrstuvwxyz";
  let str = "";
  for (let i = 0; i < length; i++) {
    str += chars[Math.floor(Math.random() * chars.length)];
  }
  return str;
}
function esc(str) {
  return JSON.stringify(str);
}
function slugify(input) {
  return input.toLowerCase().trim().replace(/[^\w\s-]/g, "").replace(/[\s_-]+/g, "-").replace(/^-+|-+$/g, "");
}
var captureStackTrace = "captureStackTrace" in Error ? Error.captureStackTrace : (..._args) => {
};
function isObject(data) {
  return typeof data === "object" && data !== null && !Array.isArray(data);
}
var allowsEval = /* @__PURE__ */ cached(() => {
  if (globalConfig.jitless) {
    return false;
  }
  if (typeof navigator !== "undefined" && navigator?.userAgent?.includes("Cloudflare")) {
    return false;
  }
  try {
    const F = Function;
    new F("");
    return true;
  } catch (_) {
    return false;
  }
});
function isPlainObject(o) {
  if (isObject(o) === false)
    return false;
  const ctor = o.constructor;
  if (ctor === void 0)
    return true;
  if (typeof ctor !== "function")
    return true;
  const prot = ctor.prototype;
  if (isObject(prot) === false)
    return false;
  if (Object.prototype.hasOwnProperty.call(prot, "isPrototypeOf") === false) {
    return false;
  }
  return true;
}
function shallowClone(o) {
  if (isPlainObject(o))
    return { ...o };
  if (Array.isArray(o))
    return [...o];
  if (o instanceof Map)
    return new Map(o);
  if (o instanceof Set)
    return new Set(o);
  return o;
}
function numKeys(data) {
  let keyCount = 0;
  for (const key in data) {
    if (Object.prototype.hasOwnProperty.call(data, key)) {
      keyCount++;
    }
  }
  return keyCount;
}
var getParsedType = (data) => {
  const t = typeof data;
  switch (t) {
    case "undefined":
      return "undefined";
    case "string":
      return "string";
    case "number":
      return Number.isNaN(data) ? "nan" : "number";
    case "boolean":
      return "boolean";
    case "function":
      return "function";
    case "bigint":
      return "bigint";
    case "symbol":
      return "symbol";
    case "object":
      if (Array.isArray(data)) {
        return "array";
      }
      if (data === null) {
        return "null";
      }
      if (data.then && typeof data.then === "function" && data.catch && typeof data.catch === "function") {
        return "promise";
      }
      if (typeof Map !== "undefined" && data instanceof Map) {
        return "map";
      }
      if (typeof Set !== "undefined" && data instanceof Set) {
        return "set";
      }
      if (typeof Date !== "undefined" && data instanceof Date) {
        return "date";
      }
      if (typeof File !== "undefined" && data instanceof File) {
        return "file";
      }
      return "object";
    default:
      throw new Error(`Unknown data type: ${t}`);
  }
};
var propertyKeyTypes = /* @__PURE__ */ new Set(["string", "number", "symbol"]);
var primitiveTypes = /* @__PURE__ */ new Set([
  "string",
  "number",
  "bigint",
  "boolean",
  "symbol",
  "undefined"
]);
function escapeRegex(str) {
  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
}
function clone(inst, def, params) {
  const cl = new inst._zod.constr(def ?? inst._zod.def);
  if (!def || params?.parent)
    cl._zod.parent = inst;
  return cl;
}
function normalizeParams(_params) {
  const params = _params;
  if (!params)
    return {};
  if (typeof params === "string")
    return { error: () => params };
  if (params?.message !== void 0) {
    if (params?.error !== void 0)
      throw new Error("Cannot specify both `message` and `error` params");
    params.error = params.message;
  }
  delete params.message;
  if (typeof params.error === "string")
    return { ...params, error: () => params.error };
  return params;
}
function createTransparentProxy(getter) {
  let target;
  return new Proxy({}, {
    get(_, prop, receiver) {
      target ?? (target = getter());
      return Reflect.get(target, prop, receiver);
    },
    set(_, prop, value, receiver) {
      target ?? (target = getter());
      return Reflect.set(target, prop, value, receiver);
    },
    has(_, prop) {
      target ?? (target = getter());
      return Reflect.has(target, prop);
    },
    deleteProperty(_, prop) {
      target ?? (target = getter());
      return Reflect.deleteProperty(target, prop);
    },
    ownKeys(_) {
      target ?? (target = getter());
      return Reflect.ownKeys(target);
    },
    getOwnPropertyDescriptor(_, prop) {
      target ?? (target = getter());
      return Reflect.getOwnPropertyDescriptor(target, prop);
    },
    defineProperty(_, prop, descriptor) {
      target ?? (target = getter());
      return Reflect.defineProperty(target, prop, descriptor);
    }
  });
}
function stringifyPrimitive(value) {
  if (typeof value === "bigint")
    return value.toString() + "n";
  if (typeof value === "string")
    return `"${value}"`;
  return `${value}`;
}
function optionalKeys(shape) {
  return Object.keys(shape).filter((k) => {
    return shape[k]._zod.optin === "optional" && shape[k]._zod.optout === "optional";
  });
}
var NUMBER_FORMAT_RANGES = {
  safeint: [Number.MIN_SAFE_INTEGER, Number.MAX_SAFE_INTEGER],
  int32: [-2147483648, 2147483647],
  uint32: [0, 4294967295],
  float32: [-34028234663852886e22, 34028234663852886e22],
  float64: [-Number.MAX_VALUE, Number.MAX_VALUE]
};
var BIGINT_FORMAT_RANGES = {
  int64: [/* @__PURE__ */ BigInt("-9223372036854775808"), /* @__PURE__ */ BigInt("9223372036854775807")],
  uint64: [/* @__PURE__ */ BigInt(0), /* @__PURE__ */ BigInt("18446744073709551615")]
};
function pick(schema, mask) {
  const currDef = schema._zod.def;
  const checks = currDef.checks;
  const hasChecks = checks && checks.length > 0;
  if (hasChecks) {
    throw new Error(".pick() cannot be used on object schemas containing refinements");
  }
  const def = mergeDefs(schema._zod.def, {
    get shape() {
      const newShape = {};
      for (const key in mask) {
        if (!(key in currDef.shape)) {
          throw new Error(`Unrecognized key: "${key}"`);
        }
        if (!mask[key])
          continue;
        newShape[key] = currDef.shape[key];
      }
      assignProp(this, "shape", newShape);
      return newShape;
    },
    checks: []
  });
  return clone(schema, def);
}
function omit(schema, mask) {
  const currDef = schema._zod.def;
  const checks = currDef.checks;
  const hasChecks = checks && checks.length > 0;
  if (hasChecks) {
    throw new Error(".omit() cannot be used on object schemas containing refinements");
  }
  const def = mergeDefs(schema._zod.def, {
    get shape() {
      const newShape = { ...schema._zod.def.shape };
      for (const key in mask) {
        if (!(key in currDef.shape)) {
          throw new Error(`Unrecognized key: "${key}"`);
        }
        if (!mask[key])
          continue;
        delete newShape[key];
      }
      assignProp(this, "shape", newShape);
      return newShape;
    },
    checks: []
  });
  return clone(schema, def);
}
function extend(schema, shape) {
  if (!isPlainObject(shape)) {
    throw new Error("Invalid input to extend: expected a plain object");
  }
  const checks = schema._zod.def.checks;
  const hasChecks = checks && checks.length > 0;
  if (hasChecks) {
    const existingShape = schema._zod.def.shape;
    for (const key in shape) {
      if (Object.getOwnPropertyDescriptor(existingShape, key) !== void 0) {
        throw new Error("Cannot overwrite keys on object schemas containing refinements. Use `.safeExtend()` instead.");
      }
    }
  }
  const def = mergeDefs(schema._zod.def, {
    get shape() {
      const _shape = { ...schema._zod.def.shape, ...shape };
      assignProp(this, "shape", _shape);
      return _shape;
    }
  });
  return clone(schema, def);
}
function safeExtend(schema, shape) {
  if (!isPlainObject(shape)) {
    throw new Error("Invalid input to safeExtend: expected a plain object");
  }
  const def = mergeDefs(schema._zod.def, {
    get shape() {
      const _shape = { ...schema._zod.def.shape, ...shape };
      assignProp(this, "shape", _shape);
      return _shape;
    }
  });
  return clone(schema, def);
}
function merge(a, b) {
  if (a._zod.def.checks?.length) {
    throw new Error(".merge() cannot be used on object schemas containing refinements. Use .safeExtend() instead.");
  }
  const def = mergeDefs(a._zod.def, {
    get shape() {
      const _shape = { ...a._zod.def.shape, ...b._zod.def.shape };
      assignProp(this, "shape", _shape);
      return _shape;
    },
    get catchall() {
      return b._zod.def.catchall;
    },
    checks: b._zod.def.checks ?? []
  });
  return clone(a, def);
}
function partial(Class2, schema, mask) {
  const currDef = schema._zod.def;
  const checks = currDef.checks;
  const hasChecks = checks && checks.length > 0;
  if (hasChecks) {
    throw new Error(".partial() cannot be used on object schemas containing refinements");
  }
  const def = mergeDefs(schema._zod.def, {
    get shape() {
      const oldShape = schema._zod.def.shape;
      const shape = { ...oldShape };
      if (mask) {
        for (const key in mask) {
          if (!(key in oldShape)) {
            throw new Error(`Unrecognized key: "${key}"`);
          }
          if (!mask[key])
            continue;
          shape[key] = Class2 ? new Class2({
            type: "optional",
            innerType: oldShape[key]
          }) : oldShape[key];
        }
      } else {
        for (const key in oldShape) {
          shape[key] = Class2 ? new Class2({
            type: "optional",
            innerType: oldShape[key]
          }) : oldShape[key];
        }
      }
      assignProp(this, "shape", shape);
      return shape;
    },
    checks: []
  });
  return clone(schema, def);
}
function required(Class2, schema, mask) {
  const def = mergeDefs(schema._zod.def, {
    get shape() {
      const oldShape = schema._zod.def.shape;
      const shape = { ...oldShape };
      if (mask) {
        for (const key in mask) {
          if (!(key in shape)) {
            throw new Error(`Unrecognized key: "${key}"`);
          }
          if (!mask[key])
            continue;
          shape[key] = new Class2({
            type: "nonoptional",
            innerType: oldShape[key]
          });
        }
      } else {
        for (const key in oldShape) {
          shape[key] = new Class2({
            type: "nonoptional",
            innerType: oldShape[key]
          });
        }
      }
      assignProp(this, "shape", shape);
      return shape;
    }
  });
  return clone(schema, def);
}
function aborted(x, startIndex = 0) {
  if (x.aborted === true)
    return true;
  for (let i = startIndex; i < x.issues.length; i++) {
    if (x.issues[i]?.continue !== true) {
      return true;
    }
  }
  return false;
}
function explicitlyAborted(x, startIndex = 0) {
  if (x.aborted === true)
    return true;
  for (let i = startIndex; i < x.issues.length; i++) {
    if (x.issues[i]?.continue === false) {
      return true;
    }
  }
  return false;
}
function prefixIssues(path2, issues) {
  return issues.map((iss) => {
    var _a3;
    (_a3 = iss).path ?? (_a3.path = []);
    iss.path.unshift(path2);
    return iss;
  });
}
function unwrapMessage(message) {
  return typeof message === "string" ? message : message?.message;
}
function finalizeIssue(iss, ctx, config2) {
  const message = iss.message ? iss.message : unwrapMessage(iss.inst?._zod.def?.error?.(iss)) ?? unwrapMessage(ctx?.error?.(iss)) ?? unwrapMessage(config2.customError?.(iss)) ?? unwrapMessage(config2.localeError?.(iss)) ?? "Invalid input";
  const { inst: _inst, continue: _continue, input: _input, ...rest } = iss;
  rest.path ?? (rest.path = []);
  rest.message = message;
  if (ctx?.reportInput) {
    rest.input = _input;
  }
  return rest;
}
function getSizableOrigin(input) {
  if (input instanceof Set)
    return "set";
  if (input instanceof Map)
    return "map";
  if (input instanceof File)
    return "file";
  return "unknown";
}
function getLengthableOrigin(input) {
  if (Array.isArray(input))
    return "array";
  if (typeof input === "string")
    return "string";
  return "unknown";
}
function parsedType(data) {
  const t = typeof data;
  switch (t) {
    case "number": {
      return Number.isNaN(data) ? "nan" : "number";
    }
    case "object": {
      if (data === null) {
        return "null";
      }
      if (Array.isArray(data)) {
        return "array";
      }
      const obj = data;
      if (obj && Object.getPrototypeOf(obj) !== Object.prototype && "constructor" in obj && obj.constructor) {
        return obj.constructor.name;
      }
    }
  }
  return t;
}
function issue(...args) {
  const [iss, input, inst] = args;
  if (typeof iss === "string") {
    return {
      message: iss,
      code: "custom",
      input,
      inst
    };
  }
  return { ...iss };
}
function cleanEnum(obj) {
  return Object.entries(obj).filter(([k, _]) => {
    return Number.isNaN(Number.parseInt(k, 10));
  }).map((el) => el[1]);
}
function base64ToUint8Array(base642) {
  const binaryString = atob(base642);
  const bytes = new Uint8Array(binaryString.length);
  for (let i = 0; i < binaryString.length; i++) {
    bytes[i] = binaryString.charCodeAt(i);
  }
  return bytes;
}
function uint8ArrayToBase64(bytes) {
  let binaryString = "";
  for (let i = 0; i < bytes.length; i++) {
    binaryString += String.fromCharCode(bytes[i]);
  }
  return btoa(binaryString);
}
function base64urlToUint8Array(base64url2) {
  const base642 = base64url2.replace(/-/g, "+").replace(/_/g, "/");
  const padding = "=".repeat((4 - base642.length % 4) % 4);
  return base64ToUint8Array(base642 + padding);
}
function uint8ArrayToBase64url(bytes) {
  return uint8ArrayToBase64(bytes).replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
}
function hexToUint8Array(hex) {
  const cleanHex = hex.replace(/^0x/, "");
  if (cleanHex.length % 2 !== 0) {
    throw new Error("Invalid hex string length");
  }
  const bytes = new Uint8Array(cleanHex.length / 2);
  for (let i = 0; i < cleanHex.length; i += 2) {
    bytes[i / 2] = Number.parseInt(cleanHex.slice(i, i + 2), 16);
  }
  return bytes;
}
function uint8ArrayToHex(bytes) {
  return Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
}
var Class = class {
  constructor(..._args) {
  }
};

// node_modules/zod/v4/core/errors.js
var initializer = (inst, def) => {
  inst.name = "$ZodError";
  Object.defineProperty(inst, "_zod", {
    value: inst._zod,
    enumerable: false
  });
  Object.defineProperty(inst, "issues", {
    value: def,
    enumerable: false
  });
  inst.message = JSON.stringify(def, jsonStringifyReplacer, 2);
  Object.defineProperty(inst, "toString", {
    value: () => inst.message,
    enumerable: false
  });
};
var $ZodError = $constructor("$ZodError", initializer);
var $ZodRealError = $constructor("$ZodError", initializer, { Parent: Error });
function flattenError(error, mapper = (issue2) => issue2.message) {
  const fieldErrors = {};
  const formErrors = [];
  for (const sub of error.issues) {
    if (sub.path.length > 0) {
      fieldErrors[sub.path[0]] = fieldErrors[sub.path[0]] || [];
      fieldErrors[sub.path[0]].push(mapper(sub));
    } else {
      formErrors.push(mapper(sub));
    }
  }
  return { formErrors, fieldErrors };
}
function formatError(error, mapper = (issue2) => issue2.message) {
  const fieldErrors = { _errors: [] };
  const processError = (error2, path2 = []) => {
    for (const issue2 of error2.issues) {
      if (issue2.code === "invalid_union" && issue2.errors.length) {
        issue2.errors.map((issues) => processError({ issues }, [...path2, ...issue2.path]));
      } else if (issue2.code === "invalid_key") {
        processError({ issues: issue2.issues }, [...path2, ...issue2.path]);
      } else if (issue2.code === "invalid_element") {
        processError({ issues: issue2.issues }, [...path2, ...issue2.path]);
      } else {
        const fullpath = [...path2, ...issue2.path];
        if (fullpath.length === 0) {
          fieldErrors._errors.push(mapper(issue2));
        } else {
          let curr = fieldErrors;
          let i = 0;
          while (i < fullpath.length) {
            const el = fullpath[i];
            const terminal = i === fullpath.length - 1;
            if (!terminal) {
              curr[el] = curr[el] || { _errors: [] };
            } else {
              curr[el] = curr[el] || { _errors: [] };
              curr[el]._errors.push(mapper(issue2));
            }
            curr = curr[el];
            i++;
          }
        }
      }
    }
  };
  processError(error);
  return fieldErrors;
}

// node_modules/zod/v4/core/parse.js
var _parse = (_Err) => (schema, value, _ctx, _params) => {
  const ctx = _ctx ? { ..._ctx, async: false } : { async: false };
  const result = schema._zod.run({ value, issues: [] }, ctx);
  if (result instanceof Promise) {
    throw new $ZodAsyncError();
  }
  if (result.issues.length) {
    const e = new (_params?.Err ?? _Err)(result.issues.map((iss) => finalizeIssue(iss, ctx, config())));
    captureStackTrace(e, _params?.callee);
    throw e;
  }
  return result.value;
};
var _parseAsync = (_Err) => async (schema, value, _ctx, params) => {
  const ctx = _ctx ? { ..._ctx, async: true } : { async: true };
  let result = schema._zod.run({ value, issues: [] }, ctx);
  if (result instanceof Promise)
    result = await result;
  if (result.issues.length) {
    const e = new (params?.Err ?? _Err)(result.issues.map((iss) => finalizeIssue(iss, ctx, config())));
    captureStackTrace(e, params?.callee);
    throw e;
  }
  return result.value;
};
var _safeParse = (_Err) => (schema, value, _ctx) => {
  const ctx = _ctx ? { ..._ctx, async: false } : { async: false };
  const result = schema._zod.run({ value, issues: [] }, ctx);
  if (result instanceof Promise) {
    throw new $ZodAsyncError();
  }
  return result.issues.length ? {
    success: false,
    error: new (_Err ?? $ZodError)(result.issues.map((iss) => finalizeIssue(iss, ctx, config())))
  } : { success: true, data: result.value };
};
var safeParse = /* @__PURE__ */ _safeParse($ZodRealError);
var _safeParseAsync = (_Err) => async (schema, value, _ctx) => {
  const ctx = _ctx ? { ..._ctx, async: true } : { async: true };
  let result = schema._zod.run({ value, issues: [] }, ctx);
  if (result instanceof Promise)
    result = await result;
  return result.issues.length ? {
    success: false,
    error: new _Err(result.issues.map((iss) => finalizeIssue(iss, ctx, config())))
  } : { success: true, data: result.value };
};
var safeParseAsync = /* @__PURE__ */ _safeParseAsync($ZodRealError);
var _encode = (_Err) => (schema, value, _ctx) => {
  const ctx = _ctx ? { ..._ctx, direction: "backward" } : { direction: "backward" };
  return _parse(_Err)(schema, value, ctx);
};
var _decode = (_Err) => (schema, value, _ctx) => {
  return _parse(_Err)(schema, value, _ctx);
};
var _encodeAsync = (_Err) => async (schema, value, _ctx) => {
  const ctx = _ctx ? { ..._ctx, direction: "backward" } : { direction: "backward" };
  return _parseAsync(_Err)(schema, value, ctx);
};
var _decodeAsync = (_Err) => async (schema, value, _ctx) => {
  return _parseAsync(_Err)(schema, value, _ctx);
};
var _safeEncode = (_Err) => (schema, value, _ctx) => {
  const ctx = _ctx ? { ..._ctx, direction: "backward" } : { direction: "backward" };
  return _safeParse(_Err)(schema, value, ctx);
};
var _safeDecode = (_Err) => (schema, value, _ctx) => {
  return _safeParse(_Err)(schema, value, _ctx);
};
var _safeEncodeAsync = (_Err) => async (schema, value, _ctx) => {
  const ctx = _ctx ? { ..._ctx, direction: "backward" } : { direction: "backward" };
  return _safeParseAsync(_Err)(schema, value, ctx);
};
var _safeDecodeAsync = (_Err) => async (schema, value, _ctx) => {
  return _safeParseAsync(_Err)(schema, value, _ctx);
};

// node_modules/zod/v4/core/regexes.js
var cuid = /^[cC][0-9a-z]{6,}$/;
var cuid2 = /^[0-9a-z]+$/;
var ulid = /^[0-9A-HJKMNP-TV-Za-hjkmnp-tv-z]{26}$/;
var xid = /^[0-9a-vA-V]{20}$/;
var ksuid = /^[A-Za-z0-9]{27}$/;
var nanoid = /^[a-zA-Z0-9_-]{21}$/;
var duration = /^P(?:(\d+W)|(?!.*W)(?=\d|T\d)(\d+Y)?(\d+M)?(\d+D)?(T(?=\d)(\d+H)?(\d+M)?(\d+([.,]\d+)?S)?)?)$/;
var guid = /^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12})$/;
var uuid = (version2) => {
  if (!version2)
    return /^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-8][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$/;
  return new RegExp(`^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-${version2}[0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12})$`);
};
var email = /^(?!\.)(?!.*\.\.)([A-Za-z0-9_'+\-\.]*)[A-Za-z0-9_+-]@([A-Za-z0-9][A-Za-z0-9\-]*\.)+[A-Za-z]{2,}$/;
var _emoji = `^(\\p{Extended_Pictographic}|\\p{Emoji_Component})+$`;
function emoji() {
  return new RegExp(_emoji, "u");
}
var ipv4 = /^(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])$/;
var ipv6 = /^(([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:))$/;
var cidrv4 = /^((25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\/([0-9]|[1-2][0-9]|3[0-2])$/;
var cidrv6 = /^(([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}|::|([0-9a-fA-F]{1,4})?::([0-9a-fA-F]{1,4}:?){0,6})\/(12[0-8]|1[01][0-9]|[1-9]?[0-9])$/;
var base64 = /^$|^(?:[0-9a-zA-Z+/]{4})*(?:(?:[0-9a-zA-Z+/]{2}==)|(?:[0-9a-zA-Z+/]{3}=))?$/;
var base64url = /^[A-Za-z0-9_-]*$/;
var httpProtocol = /^https?$/;
var e164 = /^\+[1-9]\d{6,14}$/;
var dateSource = `(?:(?:\\d\\d[2468][048]|\\d\\d[13579][26]|\\d\\d0[48]|[02468][048]00|[13579][26]00)-02-29|\\d{4}-(?:(?:0[13578]|1[02])-(?:0[1-9]|[12]\\d|3[01])|(?:0[469]|11)-(?:0[1-9]|[12]\\d|30)|(?:02)-(?:0[1-9]|1\\d|2[0-8])))`;
var date = /* @__PURE__ */ new RegExp(`^${dateSource}$`);
function timeSource(args) {
  const hhmm = `(?:[01]\\d|2[0-3]):[0-5]\\d`;
  const regex = typeof args.precision === "number" ? args.precision === -1 ? `${hhmm}` : args.precision === 0 ? `${hhmm}:[0-5]\\d` : `${hhmm}:[0-5]\\d\\.\\d{${args.precision}}` : `${hhmm}(?::[0-5]\\d(?:\\.\\d+)?)?`;
  return regex;
}
function time(args) {
  return new RegExp(`^${timeSource(args)}$`);
}
function datetime(args) {
  const time3 = timeSource({ precision: args.precision });
  const opts = ["Z"];
  if (args.local)
    opts.push("");
  if (args.offset)
    opts.push(`([+-](?:[01]\\d|2[0-3]):[0-5]\\d)`);
  const timeRegex = `${time3}(?:${opts.join("|")})`;
  return new RegExp(`^${dateSource}T(?:${timeRegex})$`);
}
var string = (params) => {
  const regex = params ? `[\\s\\S]{${params?.minimum ?? 0},${params?.maximum ?? ""}}` : `[\\s\\S]*`;
  return new RegExp(`^${regex}$`);
};
var integer = /^-?\d+$/;
var number = /^-?\d+(?:\.\d+)?$/;
var boolean = /^(?:true|false)$/i;
var lowercase = /^[^A-Z]*$/;
var uppercase = /^[^a-z]*$/;

// node_modules/zod/v4/core/checks.js
var $ZodCheck = /* @__PURE__ */ $constructor("$ZodCheck", (inst, def) => {
  var _a3;
  inst._zod ?? (inst._zod = {});
  inst._zod.def = def;
  (_a3 = inst._zod).onattach ?? (_a3.onattach = []);
});
var numericOriginMap = {
  number: "number",
  bigint: "bigint",
  object: "date"
};
var $ZodCheckLessThan = /* @__PURE__ */ $constructor("$ZodCheckLessThan", (inst, def) => {
  $ZodCheck.init(inst, def);
  const origin = numericOriginMap[typeof def.value];
  inst._zod.onattach.push((inst2) => {
    const bag = inst2._zod.bag;
    const curr = (def.inclusive ? bag.maximum : bag.exclusiveMaximum) ?? Number.POSITIVE_INFINITY;
    if (def.value < curr) {
      if (def.inclusive)
        bag.maximum = def.value;
      else
        bag.exclusiveMaximum = def.value;
    }
  });
  inst._zod.check = (payload) => {
    if (def.inclusive ? payload.value <= def.value : payload.value < def.value) {
      return;
    }
    payload.issues.push({
      origin,
      code: "too_big",
      maximum: typeof def.value === "object" ? def.value.getTime() : def.value,
      input: payload.value,
      inclusive: def.inclusive,
      inst,
      continue: !def.abort
    });
  };
});
var $ZodCheckGreaterThan = /* @__PURE__ */ $constructor("$ZodCheckGreaterThan", (inst, def) => {
  $ZodCheck.init(inst, def);
  const origin = numericOriginMap[typeof def.value];
  inst._zod.onattach.push((inst2) => {
    const bag = inst2._zod.bag;
    const curr = (def.inclusive ? bag.minimum : bag.exclusiveMinimum) ?? Number.NEGATIVE_INFINITY;
    if (def.value > curr) {
      if (def.inclusive)
        bag.minimum = def.value;
      else
        bag.exclusiveMinimum = def.value;
    }
  });
  inst._zod.check = (payload) => {
    if (def.inclusive ? payload.value >= def.value : payload.value > def.value) {
      return;
    }
    payload.issues.push({
      origin,
      code: "too_small",
      minimum: typeof def.value === "object" ? def.value.getTime() : def.value,
      input: payload.value,
      inclusive: def.inclusive,
      inst,
      continue: !def.abort
    });
  };
});
var $ZodCheckMultipleOf = /* @__PURE__ */ $constructor("$ZodCheckMultipleOf", (inst, def) => {
  $ZodCheck.init(inst, def);
  inst._zod.onattach.push((inst2) => {
    var _a3;
    (_a3 = inst2._zod.bag).multipleOf ?? (_a3.multipleOf = def.value);
  });
  inst._zod.check = (payload) => {
    if (typeof payload.value !== typeof def.value)
      throw new Error("Cannot mix number and bigint in multiple_of check.");
    const isMultiple = typeof payload.value === "bigint" ? payload.value % def.value === BigInt(0) : floatSafeRemainder(payload.value, def.value) === 0;
    if (isMultiple)
      return;
    payload.issues.push({
      origin: typeof payload.value,
      code: "not_multiple_of",
      divisor: def.value,
      input: payload.value,
      inst,
      continue: !def.abort
    });
  };
});
var $ZodCheckNumberFormat = /* @__PURE__ */ $constructor("$ZodCheckNumberFormat", (inst, def) => {
  $ZodCheck.init(inst, def);
  def.format = def.format || "float64";
  const isInt = def.format?.includes("int");
  const origin = isInt ? "int" : "number";
  const [minimum, maximum] = NUMBER_FORMAT_RANGES[def.format];
  inst._zod.onattach.push((inst2) => {
    const bag = inst2._zod.bag;
    bag.format = def.format;
    bag.minimum = minimum;
    bag.maximum = maximum;
    if (isInt)
      bag.pattern = integer;
  });
  inst._zod.check = (payload) => {
    const input = payload.value;
    if (isInt) {
      if (!Number.isInteger(input)) {
        payload.issues.push({
          expected: origin,
          format: def.format,
          code: "invalid_type",
          continue: false,
          input,
          inst
        });
        return;
      }
      if (!Number.isSafeInteger(input)) {
        if (input > 0) {
          payload.issues.push({
            input,
            code: "too_big",
            maximum: Number.MAX_SAFE_INTEGER,
            note: "Integers must be within the safe integer range.",
            inst,
            origin,
            inclusive: true,
            continue: !def.abort
          });
        } else {
          payload.issues.push({
            input,
            code: "too_small",
            minimum: Number.MIN_SAFE_INTEGER,
            note: "Integers must be within the safe integer range.",
            inst,
            origin,
            inclusive: true,
            continue: !def.abort
          });
        }
        return;
      }
    }
    if (input < minimum) {
      payload.issues.push({
        origin: "number",
        input,
        code: "too_small",
        minimum,
        inclusive: true,
        inst,
        continue: !def.abort
      });
    }
    if (input > maximum) {
      payload.issues.push({
        origin: "number",
        input,
        code: "too_big",
        maximum,
        inclusive: true,
        inst,
        continue: !def.abort
      });
    }
  };
});
var $ZodCheckMaxLength = /* @__PURE__ */ $constructor("$ZodCheckMaxLength", (inst, def) => {
  var _a3;
  $ZodCheck.init(inst, def);
  (_a3 = inst._zod.def).when ?? (_a3.when = (payload) => {
    const val = payload.value;
    return !nullish(val) && val.length !== void 0;
  });
  inst._zod.onattach.push((inst2) => {
    const curr = inst2._zod.bag.maximum ?? Number.POSITIVE_INFINITY;
    if (def.maximum < curr)
      inst2._zod.bag.maximum = def.maximum;
  });
  inst._zod.check = (payload) => {
    const input = payload.value;
    const length = input.length;
    if (length <= def.maximum)
      return;
    const origin = getLengthableOrigin(input);
    payload.issues.push({
      origin,
      code: "too_big",
      maximum: def.maximum,
      inclusive: true,
      input,
      inst,
      continue: !def.abort
    });
  };
});
var $ZodCheckMinLength = /* @__PURE__ */ $constructor("$ZodCheckMinLength", (inst, def) => {
  var _a3;
  $ZodCheck.init(inst, def);
  (_a3 = inst._zod.def).when ?? (_a3.when = (payload) => {
    const val = payload.value;
    return !nullish(val) && val.length !== void 0;
  });
  inst._zod.onattach.push((inst2) => {
    const curr = inst2._zod.bag.minimum ?? Number.NEGATIVE_INFINITY;
    if (def.minimum > curr)
      inst2._zod.bag.minimum = def.minimum;
  });
  inst._zod.check = (payload) => {
    const input = payload.value;
    const length = input.length;
    if (length >= def.minimum)
      return;
    const origin = getLengthableOrigin(input);
    payload.issues.push({
      origin,
      code: "too_small",
      minimum: def.minimum,
      inclusive: true,
      input,
      inst,
      continue: !def.abort
    });
  };
});
var $ZodCheckLengthEquals = /* @__PURE__ */ $constructor("$ZodCheckLengthEquals", (inst, def) => {
  var _a3;
  $ZodCheck.init(inst, def);
  (_a3 = inst._zod.def).when ?? (_a3.when = (payload) => {
    const val = payload.value;
    return !nullish(val) && val.length !== void 0;
  });
  inst._zod.onattach.push((inst2) => {
    const bag = inst2._zod.bag;
    bag.minimum = def.length;
    bag.maximum = def.length;
    bag.length = def.length;
  });
  inst._zod.check = (payload) => {
    const input = payload.value;
    const length = input.length;
    if (length === def.length)
      return;
    const origin = getLengthableOrigin(input);
    const tooBig = length > def.length;
    payload.issues.push({
      origin,
      ...tooBig ? { code: "too_big", maximum: def.length } : { code: "too_small", minimum: def.length },
      inclusive: true,
      exact: true,
      input: payload.value,
      inst,
      continue: !def.abort
    });
  };
});
var $ZodCheckStringFormat = /* @__PURE__ */ $constructor("$ZodCheckStringFormat", (inst, def) => {
  var _a3, _b;
  $ZodCheck.init(inst, def);
  inst._zod.onattach.push((inst2) => {
    const bag = inst2._zod.bag;
    bag.format = def.format;
    if (def.pattern) {
      bag.patterns ?? (bag.patterns = /* @__PURE__ */ new Set());
      bag.patterns.add(def.pattern);
    }
  });
  if (def.pattern)
    (_a3 = inst._zod).check ?? (_a3.check = (payload) => {
      def.pattern.lastIndex = 0;
      if (def.pattern.test(payload.value))
        return;
      payload.issues.push({
        origin: "string",
        code: "invalid_format",
        format: def.format,
        input: payload.value,
        ...def.pattern ? { pattern: def.pattern.toString() } : {},
        inst,
        continue: !def.abort
      });
    });
  else
    (_b = inst._zod).check ?? (_b.check = () => {
    });
});
var $ZodCheckRegex = /* @__PURE__ */ $constructor("$ZodCheckRegex", (inst, def) => {
  $ZodCheckStringFormat.init(inst, def);
  inst._zod.check = (payload) => {
    def.pattern.lastIndex = 0;
    if (def.pattern.test(payload.value))
      return;
    payload.issues.push({
      origin: "string",
      code: "invalid_format",
      format: "regex",
      input: payload.value,
      pattern: def.pattern.toString(),
      inst,
      continue: !def.abort
    });
  };
});
var $ZodCheckLowerCase = /* @__PURE__ */ $constructor("$ZodCheckLowerCase", (inst, def) => {
  def.pattern ?? (def.pattern = lowercase);
  $ZodCheckStringFormat.init(inst, def);
});
var $ZodCheckUpperCase = /* @__PURE__ */ $constructor("$ZodCheckUpperCase", (inst, def) => {
  def.pattern ?? (def.pattern = uppercase);
  $ZodCheckStringFormat.init(inst, def);
});
var $ZodCheckIncludes = /* @__PURE__ */ $constructor("$ZodCheckIncludes", (inst, def) => {
  $ZodCheck.init(inst, def);
  const escapedRegex = escapeRegex(def.includes);
  const pattern = new RegExp(typeof def.position === "number" ? `^.{${def.position}}${escapedRegex}` : escapedRegex);
  def.pattern = pattern;
  inst._zod.onattach.push((inst2) => {
    const bag = inst2._zod.bag;
    bag.patterns ?? (bag.patterns = /* @__PURE__ */ new Set());
    bag.patterns.add(pattern);
  });
  inst._zod.check = (payload) => {
    if (payload.value.includes(def.includes, def.position))
      return;
    payload.issues.push({
      origin: "string",
      code: "invalid_format",
      format: "includes",
      includes: def.includes,
      input: payload.value,
      inst,
      continue: !def.abort
    });
  };
});
var $ZodCheckStartsWith = /* @__PURE__ */ $constructor("$ZodCheckStartsWith", (inst, def) => {
  $ZodCheck.init(inst, def);
  const pattern = new RegExp(`^${escapeRegex(def.prefix)}.*`);
  def.pattern ?? (def.pattern = pattern);
  inst._zod.onattach.push((inst2) => {
    const bag = inst2._zod.bag;
    bag.patterns ?? (bag.patterns = /* @__PURE__ */ new Set());
    bag.patterns.add(pattern);
  });
  inst._zod.check = (payload) => {
    if (payload.value.startsWith(def.prefix))
      return;
    payload.issues.push({
      origin: "string",
      code: "invalid_format",
      format: "starts_with",
      prefix: def.prefix,
      input: payload.value,
      inst,
      continue: !def.abort
    });
  };
});
var $ZodCheckEndsWith = /* @__PURE__ */ $constructor("$ZodCheckEndsWith", (inst, def) => {
  $ZodCheck.init(inst, def);
  const pattern = new RegExp(`.*${escapeRegex(def.suffix)}$`);
  def.pattern ?? (def.pattern = pattern);
  inst._zod.onattach.push((inst2) => {
    const bag = inst2._zod.bag;
    bag.patterns ?? (bag.patterns = /* @__PURE__ */ new Set());
    bag.patterns.add(pattern);
  });
  inst._zod.check = (payload) => {
    if (payload.value.endsWith(def.suffix))
      return;
    payload.issues.push({
      origin: "string",
      code: "invalid_format",
      format: "ends_with",
      suffix: def.suffix,
      input: payload.value,
      inst,
      continue: !def.abort
    });
  };
});
var $ZodCheckOverwrite = /* @__PURE__ */ $constructor("$ZodCheckOverwrite", (inst, def) => {
  $ZodCheck.init(inst, def);
  inst._zod.check = (payload) => {
    payload.value = def.tx(payload.value);
  };
});

// node_modules/zod/v4/core/doc.js
var Doc = class {
  constructor(args = []) {
    this.content = [];
    this.indent = 0;
    if (this)
      this.args = args;
  }
  indented(fn) {
    this.indent += 1;
    fn(this);
    this.indent -= 1;
  }
  write(arg) {
    if (typeof arg === "function") {
      arg(this, { execution: "sync" });
      arg(this, { execution: "async" });
      return;
    }
    const content = arg;
    const lines = content.split("\n").filter((x) => x);
    const minIndent = Math.min(...lines.map((x) => x.length - x.trimStart().length));
    const dedented = lines.map((x) => x.slice(minIndent)).map((x) => " ".repeat(this.indent * 2) + x);
    for (const line of dedented) {
      this.content.push(line);
    }
  }
  compile() {
    const F = Function;
    const args = this?.args;
    const content = this?.content ?? [``];
    const lines = [...content.map((x) => `  ${x}`)];
    return new F(...args, lines.join("\n"));
  }
};

// node_modules/zod/v4/core/versions.js
var version = {
  major: 4,
  minor: 4,
  patch: 3
};

// node_modules/zod/v4/core/schemas.js
var $ZodType = /* @__PURE__ */ $constructor("$ZodType", (inst, def) => {
  var _a3;
  inst ?? (inst = {});
  inst._zod.def = def;
  inst._zod.bag = inst._zod.bag || {};
  inst._zod.version = version;
  const checks = [...inst._zod.def.checks ?? []];
  if (inst._zod.traits.has("$ZodCheck")) {
    checks.unshift(inst);
  }
  for (const ch of checks) {
    for (const fn of ch._zod.onattach) {
      fn(inst);
    }
  }
  if (checks.length === 0) {
    (_a3 = inst._zod).deferred ?? (_a3.deferred = []);
    inst._zod.deferred?.push(() => {
      inst._zod.run = inst._zod.parse;
    });
  } else {
    const runChecks = (payload, checks2, ctx) => {
      let isAborted = aborted(payload);
      let asyncResult;
      for (const ch of checks2) {
        if (ch._zod.def.when) {
          if (explicitlyAborted(payload))
            continue;
          const shouldRun = ch._zod.def.when(payload);
          if (!shouldRun)
            continue;
        } else if (isAborted) {
          continue;
        }
        const currLen = payload.issues.length;
        const _ = ch._zod.check(payload);
        if (_ instanceof Promise && ctx?.async === false) {
          throw new $ZodAsyncError();
        }
        if (asyncResult || _ instanceof Promise) {
          asyncResult = (asyncResult ?? Promise.resolve()).then(async () => {
            await _;
            const nextLen = payload.issues.length;
            if (nextLen === currLen)
              return;
            if (!isAborted)
              isAborted = aborted(payload, currLen);
          });
        } else {
          const nextLen = payload.issues.length;
          if (nextLen === currLen)
            continue;
          if (!isAborted)
            isAborted = aborted(payload, currLen);
        }
      }
      if (asyncResult) {
        return asyncResult.then(() => {
          return payload;
        });
      }
      return payload;
    };
    const handleCanaryResult = (canary, payload, ctx) => {
      if (aborted(canary)) {
        canary.aborted = true;
        return canary;
      }
      const checkResult = runChecks(payload, checks, ctx);
      if (checkResult instanceof Promise) {
        if (ctx.async === false)
          throw new $ZodAsyncError();
        return checkResult.then((checkResult2) => inst._zod.parse(checkResult2, ctx));
      }
      return inst._zod.parse(checkResult, ctx);
    };
    inst._zod.run = (payload, ctx) => {
      if (ctx.skipChecks) {
        return inst._zod.parse(payload, ctx);
      }
      if (ctx.direction === "backward") {
        const canary = inst._zod.parse({ value: payload.value, issues: [] }, { ...ctx, skipChecks: true });
        if (canary instanceof Promise) {
          return canary.then((canary2) => {
            return handleCanaryResult(canary2, payload, ctx);
          });
        }
        return handleCanaryResult(canary, payload, ctx);
      }
      const result = inst._zod.parse(payload, ctx);
      if (result instanceof Promise) {
        if (ctx.async === false)
          throw new $ZodAsyncError();
        return result.then((result2) => runChecks(result2, checks, ctx));
      }
      return runChecks(result, checks, ctx);
    };
  }
  defineLazy(inst, "~standard", () => ({
    validate: (value) => {
      try {
        const r = safeParse(inst, value);
        return r.success ? { value: r.data } : { issues: r.error?.issues };
      } catch (_) {
        return safeParseAsync(inst, value).then((r) => r.success ? { value: r.data } : { issues: r.error?.issues });
      }
    },
    vendor: "zod",
    version: 1
  }));
});
var $ZodString = /* @__PURE__ */ $constructor("$ZodString", (inst, def) => {
  $ZodType.init(inst, def);
  inst._zod.pattern = [...inst?._zod.bag?.patterns ?? []].pop() ?? string(inst._zod.bag);
  inst._zod.parse = (payload, _) => {
    if (def.coerce)
      try {
        payload.value = String(payload.value);
      } catch (_2) {
      }
    if (typeof payload.value === "string")
      return payload;
    payload.issues.push({
      expected: "string",
      code: "invalid_type",
      input: payload.value,
      inst
    });
    return payload;
  };
});
var $ZodStringFormat = /* @__PURE__ */ $constructor("$ZodStringFormat", (inst, def) => {
  $ZodCheckStringFormat.init(inst, def);
  $ZodString.init(inst, def);
});
var $ZodGUID = /* @__PURE__ */ $constructor("$ZodGUID", (inst, def) => {
  def.pattern ?? (def.pattern = guid);
  $ZodStringFormat.init(inst, def);
});
var $ZodUUID = /* @__PURE__ */ $constructor("$ZodUUID", (inst, def) => {
  if (def.version) {
    const versionMap = {
      v1: 1,
      v2: 2,
      v3: 3,
      v4: 4,
      v5: 5,
      v6: 6,
      v7: 7,
      v8: 8
    };
    const v = versionMap[def.version];
    if (v === void 0)
      throw new Error(`Invalid UUID version: "${def.version}"`);
    def.pattern ?? (def.pattern = uuid(v));
  } else
    def.pattern ?? (def.pattern = uuid());
  $ZodStringFormat.init(inst, def);
});
var $ZodEmail = /* @__PURE__ */ $constructor("$ZodEmail", (inst, def) => {
  def.pattern ?? (def.pattern = email);
  $ZodStringFormat.init(inst, def);
});
var $ZodURL = /* @__PURE__ */ $constructor("$ZodURL", (inst, def) => {
  $ZodStringFormat.init(inst, def);
  inst._zod.check = (payload) => {
    try {
      const trimmed = payload.value.trim();
      if (!def.normalize && def.protocol?.source === httpProtocol.source) {
        if (!/^https?:\/\//i.test(trimmed)) {
          payload.issues.push({
            code: "invalid_format",
            format: "url",
            note: "Invalid URL format",
            input: payload.value,
            inst,
            continue: !def.abort
          });
          return;
        }
      }
      const url = new URL(trimmed);
      if (def.hostname) {
        def.hostname.lastIndex = 0;
        if (!def.hostname.test(url.hostname)) {
          payload.issues.push({
            code: "invalid_format",
            format: "url",
            note: "Invalid hostname",
            pattern: def.hostname.source,
            input: payload.value,
            inst,
            continue: !def.abort
          });
        }
      }
      if (def.protocol) {
        def.protocol.lastIndex = 0;
        if (!def.protocol.test(url.protocol.endsWith(":") ? url.protocol.slice(0, -1) : url.protocol)) {
          payload.issues.push({
            code: "invalid_format",
            format: "url",
            note: "Invalid protocol",
            pattern: def.protocol.source,
            input: payload.value,
            inst,
            continue: !def.abort
          });
        }
      }
      if (def.normalize) {
        payload.value = url.href;
      } else {
        payload.value = trimmed;
      }
      return;
    } catch (_) {
      payload.issues.push({
        code: "invalid_format",
        format: "url",
        input: payload.value,
        inst,
        continue: !def.abort
      });
    }
  };
});
var $ZodEmoji = /* @__PURE__ */ $constructor("$ZodEmoji", (inst, def) => {
  def.pattern ?? (def.pattern = emoji());
  $ZodStringFormat.init(inst, def);
});
var $ZodNanoID = /* @__PURE__ */ $constructor("$ZodNanoID", (inst, def) => {
  def.pattern ?? (def.pattern = nanoid);
  $ZodStringFormat.init(inst, def);
});
var $ZodCUID = /* @__PURE__ */ $constructor("$ZodCUID", (inst, def) => {
  def.pattern ?? (def.pattern = cuid);
  $ZodStringFormat.init(inst, def);
});
var $ZodCUID2 = /* @__PURE__ */ $constructor("$ZodCUID2", (inst, def) => {
  def.pattern ?? (def.pattern = cuid2);
  $ZodStringFormat.init(inst, def);
});
var $ZodULID = /* @__PURE__ */ $constructor("$ZodULID", (inst, def) => {
  def.pattern ?? (def.pattern = ulid);
  $ZodStringFormat.init(inst, def);
});
var $ZodXID = /* @__PURE__ */ $constructor("$ZodXID", (inst, def) => {
  def.pattern ?? (def.pattern = xid);
  $ZodStringFormat.init(inst, def);
});
var $ZodKSUID = /* @__PURE__ */ $constructor("$ZodKSUID", (inst, def) => {
  def.pattern ?? (def.pattern = ksuid);
  $ZodStringFormat.init(inst, def);
});
var $ZodISODateTime = /* @__PURE__ */ $constructor("$ZodISODateTime", (inst, def) => {
  def.pattern ?? (def.pattern = datetime(def));
  $ZodStringFormat.init(inst, def);
});
var $ZodISODate = /* @__PURE__ */ $constructor("$ZodISODate", (inst, def) => {
  def.pattern ?? (def.pattern = date);
  $ZodStringFormat.init(inst, def);
});
var $ZodISOTime = /* @__PURE__ */ $constructor("$ZodISOTime", (inst, def) => {
  def.pattern ?? (def.pattern = time(def));
  $ZodStringFormat.init(inst, def);
});
var $ZodISODuration = /* @__PURE__ */ $constructor("$ZodISODuration", (inst, def) => {
  def.pattern ?? (def.pattern = duration);
  $ZodStringFormat.init(inst, def);
});
var $ZodIPv4 = /* @__PURE__ */ $constructor("$ZodIPv4", (inst, def) => {
  def.pattern ?? (def.pattern = ipv4);
  $ZodStringFormat.init(inst, def);
  inst._zod.bag.format = `ipv4`;
});
var $ZodIPv6 = /* @__PURE__ */ $constructor("$ZodIPv6", (inst, def) => {
  def.pattern ?? (def.pattern = ipv6);
  $ZodStringFormat.init(inst, def);
  inst._zod.bag.format = `ipv6`;
  inst._zod.check = (payload) => {
    try {
      new URL(`http://[${payload.value}]`);
    } catch {
      payload.issues.push({
        code: "invalid_format",
        format: "ipv6",
        input: payload.value,
        inst,
        continue: !def.abort
      });
    }
  };
});
var $ZodCIDRv4 = /* @__PURE__ */ $constructor("$ZodCIDRv4", (inst, def) => {
  def.pattern ?? (def.pattern = cidrv4);
  $ZodStringFormat.init(inst, def);
});
var $ZodCIDRv6 = /* @__PURE__ */ $constructor("$ZodCIDRv6", (inst, def) => {
  def.pattern ?? (def.pattern = cidrv6);
  $ZodStringFormat.init(inst, def);
  inst._zod.check = (payload) => {
    const parts = payload.value.split("/");
    try {
      if (parts.length !== 2)
        throw new Error();
      const [address, prefix] = parts;
      if (!prefix)
        throw new Error();
      const prefixNum = Number(prefix);
      if (`${prefixNum}` !== prefix)
        throw new Error();
      if (prefixNum < 0 || prefixNum > 128)
        throw new Error();
      new URL(`http://[${address}]`);
    } catch {
      payload.issues.push({
        code: "invalid_format",
        format: "cidrv6",
        input: payload.value,
        inst,
        continue: !def.abort
      });
    }
  };
});
function isValidBase64(data) {
  if (data === "")
    return true;
  if (/\s/.test(data))
    return false;
  if (data.length % 4 !== 0)
    return false;
  try {
    atob(data);
    return true;
  } catch {
    return false;
  }
}
var $ZodBase64 = /* @__PURE__ */ $constructor("$ZodBase64", (inst, def) => {
  def.pattern ?? (def.pattern = base64);
  $ZodStringFormat.init(inst, def);
  inst._zod.bag.contentEncoding = "base64";
  inst._zod.check = (payload) => {
    if (isValidBase64(payload.value))
      return;
    payload.issues.push({
      code: "invalid_format",
      format: "base64",
      input: payload.value,
      inst,
      continue: !def.abort
    });
  };
});
function isValidBase64URL(data) {
  if (!base64url.test(data))
    return false;
  const base642 = data.replace(/[-_]/g, (c) => c === "-" ? "+" : "/");
  const padded = base642.padEnd(Math.ceil(base642.length / 4) * 4, "=");
  return isValidBase64(padded);
}
var $ZodBase64URL = /* @__PURE__ */ $constructor("$ZodBase64URL", (inst, def) => {
  def.pattern ?? (def.pattern = base64url);
  $ZodStringFormat.init(inst, def);
  inst._zod.bag.contentEncoding = "base64url";
  inst._zod.check = (payload) => {
    if (isValidBase64URL(payload.value))
      return;
    payload.issues.push({
      code: "invalid_format",
      format: "base64url",
      input: payload.value,
      inst,
      continue: !def.abort
    });
  };
});
var $ZodE164 = /* @__PURE__ */ $constructor("$ZodE164", (inst, def) => {
  def.pattern ?? (def.pattern = e164);
  $ZodStringFormat.init(inst, def);
});
function isValidJWT(token, algorithm = null) {
  try {
    const tokensParts = token.split(".");
    if (tokensParts.length !== 3)
      return false;
    const [header] = tokensParts;
    if (!header)
      return false;
    const parsedHeader = JSON.parse(atob(header));
    if ("typ" in parsedHeader && parsedHeader?.typ !== "JWT")
      return false;
    if (!parsedHeader.alg)
      return false;
    if (algorithm && (!("alg" in parsedHeader) || parsedHeader.alg !== algorithm))
      return false;
    return true;
  } catch {
    return false;
  }
}
var $ZodJWT = /* @__PURE__ */ $constructor("$ZodJWT", (inst, def) => {
  $ZodStringFormat.init(inst, def);
  inst._zod.check = (payload) => {
    if (isValidJWT(payload.value, def.alg))
      return;
    payload.issues.push({
      code: "invalid_format",
      format: "jwt",
      input: payload.value,
      inst,
      continue: !def.abort
    });
  };
});
var $ZodNumber = /* @__PURE__ */ $constructor("$ZodNumber", (inst, def) => {
  $ZodType.init(inst, def);
  inst._zod.pattern = inst._zod.bag.pattern ?? number;
  inst._zod.parse = (payload, _ctx) => {
    if (def.coerce)
      try {
        payload.value = Number(payload.value);
      } catch (_) {
      }
    const input = payload.value;
    if (typeof input === "number" && !Number.isNaN(input) && Number.isFinite(input)) {
      return payload;
    }
    const received = typeof input === "number" ? Number.isNaN(input) ? "NaN" : !Number.isFinite(input) ? "Infinity" : void 0 : void 0;
    payload.issues.push({
      expected: "number",
      code: "invalid_type",
      input,
      inst,
      ...received ? { received } : {}
    });
    return payload;
  };
});
var $ZodNumberFormat = /* @__PURE__ */ $constructor("$ZodNumberFormat", (inst, def) => {
  $ZodCheckNumberFormat.init(inst, def);
  $ZodNumber.init(inst, def);
});
var $ZodBoolean = /* @__PURE__ */ $constructor("$ZodBoolean", (inst, def) => {
  $ZodType.init(inst, def);
  inst._zod.pattern = boolean;
  inst._zod.parse = (payload, _ctx) => {
    if (def.coerce)
      try {
        payload.value = Boolean(payload.value);
      } catch (_) {
      }
    const input = payload.value;
    if (typeof input === "boolean")
      return payload;
    payload.issues.push({
      expected: "boolean",
      code: "invalid_type",
      input,
      inst
    });
    return payload;
  };
});
var $ZodUnknown = /* @__PURE__ */ $constructor("$ZodUnknown", (inst, def) => {
  $ZodType.init(inst, def);
  inst._zod.parse = (payload) => payload;
});
var $ZodNever = /* @__PURE__ */ $constructor("$ZodNever", (inst, def) => {
  $ZodType.init(inst, def);
  inst._zod.parse = (payload, _ctx) => {
    payload.issues.push({
      expected: "never",
      code: "invalid_type",
      input: payload.value,
      inst
    });
    return payload;
  };
});
function handleArrayResult(result, final, index) {
  if (result.issues.length) {
    final.issues.push(...prefixIssues(index, result.issues));
  }
  final.value[index] = result.value;
}
var $ZodArray = /* @__PURE__ */ $constructor("$ZodArray", (inst, def) => {
  $ZodType.init(inst, def);
  inst._zod.parse = (payload, ctx) => {
    const input = payload.value;
    if (!Array.isArray(input)) {
      payload.issues.push({
        expected: "array",
        code: "invalid_type",
        input,
        inst
      });
      return payload;
    }
    payload.value = Array(input.length);
    const proms = [];
    for (let i = 0; i < input.length; i++) {
      const item = input[i];
      const result = def.element._zod.run({
        value: item,
        issues: []
      }, ctx);
      if (result instanceof Promise) {
        proms.push(result.then((result2) => handleArrayResult(result2, payload, i)));
      } else {
        handleArrayResult(result, payload, i);
      }
    }
    if (proms.length) {
      return Promise.all(proms).then(() => payload);
    }
    return payload;
  };
});
function handlePropertyResult(result, final, key, input, isOptionalIn, isOptionalOut) {
  const isPresent = key in input;
  if (result.issues.length) {
    if (isOptionalIn && isOptionalOut && !isPresent) {
      return;
    }
    final.issues.push(...prefixIssues(key, result.issues));
  }
  if (!isPresent && !isOptionalIn) {
    if (!result.issues.length) {
      final.issues.push({
        code: "invalid_type",
        expected: "nonoptional",
        input: void 0,
        path: [key]
      });
    }
    return;
  }
  if (result.value === void 0) {
    if (isPresent) {
      final.value[key] = void 0;
    }
  } else {
    final.value[key] = result.value;
  }
}
function normalizeDef(def) {
  const keys = Object.keys(def.shape);
  for (const k of keys) {
    if (!def.shape?.[k]?._zod?.traits?.has("$ZodType")) {
      throw new Error(`Invalid element at key "${k}": expected a Zod schema`);
    }
  }
  const okeys = optionalKeys(def.shape);
  return {
    ...def,
    keys,
    keySet: new Set(keys),
    numKeys: keys.length,
    optionalKeys: new Set(okeys)
  };
}
function handleCatchall(proms, input, payload, ctx, def, inst) {
  const unrecognized = [];
  const keySet = def.keySet;
  const _catchall = def.catchall._zod;
  const t = _catchall.def.type;
  const isOptionalIn = _catchall.optin === "optional";
  const isOptionalOut = _catchall.optout === "optional";
  for (const key in input) {
    if (key === "__proto__")
      continue;
    if (keySet.has(key))
      continue;
    if (t === "never") {
      unrecognized.push(key);
      continue;
    }
    const r = _catchall.run({ value: input[key], issues: [] }, ctx);
    if (r instanceof Promise) {
      proms.push(r.then((r2) => handlePropertyResult(r2, payload, key, input, isOptionalIn, isOptionalOut)));
    } else {
      handlePropertyResult(r, payload, key, input, isOptionalIn, isOptionalOut);
    }
  }
  if (unrecognized.length) {
    payload.issues.push({
      code: "unrecognized_keys",
      keys: unrecognized,
      input,
      inst
    });
  }
  if (!proms.length)
    return payload;
  return Promise.all(proms).then(() => {
    return payload;
  });
}
var $ZodObject = /* @__PURE__ */ $constructor("$ZodObject", (inst, def) => {
  $ZodType.init(inst, def);
  const desc = Object.getOwnPropertyDescriptor(def, "shape");
  if (!desc?.get) {
    const sh = def.shape;
    Object.defineProperty(def, "shape", {
      get: () => {
        const newSh = { ...sh };
        Object.defineProperty(def, "shape", {
          value: newSh
        });
        return newSh;
      }
    });
  }
  const _normalized = cached(() => normalizeDef(def));
  defineLazy(inst._zod, "propValues", () => {
    const shape = def.shape;
    const propValues = {};
    for (const key in shape) {
      const field = shape[key]._zod;
      if (field.values) {
        propValues[key] ?? (propValues[key] = /* @__PURE__ */ new Set());
        for (const v of field.values)
          propValues[key].add(v);
      }
    }
    return propValues;
  });
  const isObject2 = isObject;
  const catchall = def.catchall;
  let value;
  inst._zod.parse = (payload, ctx) => {
    value ?? (value = _normalized.value);
    const input = payload.value;
    if (!isObject2(input)) {
      payload.issues.push({
        expected: "object",
        code: "invalid_type",
        input,
        inst
      });
      return payload;
    }
    payload.value = {};
    const proms = [];
    const shape = value.shape;
    for (const key of value.keys) {
      const el = shape[key];
      const isOptionalIn = el._zod.optin === "optional";
      const isOptionalOut = el._zod.optout === "optional";
      const r = el._zod.run({ value: input[key], issues: [] }, ctx);
      if (r instanceof Promise) {
        proms.push(r.then((r2) => handlePropertyResult(r2, payload, key, input, isOptionalIn, isOptionalOut)));
      } else {
        handlePropertyResult(r, payload, key, input, isOptionalIn, isOptionalOut);
      }
    }
    if (!catchall) {
      return proms.length ? Promise.all(proms).then(() => payload) : payload;
    }
    return handleCatchall(proms, input, payload, ctx, _normalized.value, inst);
  };
});
var $ZodObjectJIT = /* @__PURE__ */ $constructor("$ZodObjectJIT", (inst, def) => {
  $ZodObject.init(inst, def);
  const superParse = inst._zod.parse;
  const _normalized = cached(() => normalizeDef(def));
  const generateFastpass = (shape) => {
    const doc = new Doc(["shape", "payload", "ctx"]);
    const normalized = _normalized.value;
    const parseStr = (key) => {
      const k = esc(key);
      return `shape[${k}]._zod.run({ value: input[${k}], issues: [] }, ctx)`;
    };
    doc.write(`const input = payload.value;`);
    const ids = /* @__PURE__ */ Object.create(null);
    let counter = 0;
    for (const key of normalized.keys) {
      ids[key] = `key_${counter++}`;
    }
    doc.write(`const newResult = {};`);
    for (const key of normalized.keys) {
      const id = ids[key];
      const k = esc(key);
      const schema = shape[key];
      const isOptionalIn = schema?._zod?.optin === "optional";
      const isOptionalOut = schema?._zod?.optout === "optional";
      doc.write(`const ${id} = ${parseStr(key)};`);
      if (isOptionalIn && isOptionalOut) {
        doc.write(`
        if (${id}.issues.length) {
          if (${k} in input) {
            payload.issues = payload.issues.concat(${id}.issues.map(iss => ({
              ...iss,
              path: iss.path ? [${k}, ...iss.path] : [${k}]
            })));
          }
        }

        if (${id}.value === undefined) {
          if (${k} in input) {
            newResult[${k}] = undefined;
          }
        } else {
          newResult[${k}] = ${id}.value;
        }

      `);
      } else if (!isOptionalIn) {
        doc.write(`
        const ${id}_present = ${k} in input;
        if (${id}.issues.length) {
          payload.issues = payload.issues.concat(${id}.issues.map(iss => ({
            ...iss,
            path: iss.path ? [${k}, ...iss.path] : [${k}]
          })));
        }
        if (!${id}_present && !${id}.issues.length) {
          payload.issues.push({
            code: "invalid_type",
            expected: "nonoptional",
            input: undefined,
            path: [${k}]
          });
        }

        if (${id}_present) {
          if (${id}.value === undefined) {
            newResult[${k}] = undefined;
          } else {
            newResult[${k}] = ${id}.value;
          }
        }

      `);
      } else {
        doc.write(`
        if (${id}.issues.length) {
          payload.issues = payload.issues.concat(${id}.issues.map(iss => ({
            ...iss,
            path: iss.path ? [${k}, ...iss.path] : [${k}]
          })));
        }

        if (${id}.value === undefined) {
          if (${k} in input) {
            newResult[${k}] = undefined;
          }
        } else {
          newResult[${k}] = ${id}.value;
        }

      `);
      }
    }
    doc.write(`payload.value = newResult;`);
    doc.write(`return payload;`);
    const fn = doc.compile();
    return (payload, ctx) => fn(shape, payload, ctx);
  };
  let fastpass;
  const isObject2 = isObject;
  const jit = !globalConfig.jitless;
  const allowsEval2 = allowsEval;
  const fastEnabled = jit && allowsEval2.value;
  const catchall = def.catchall;
  let value;
  inst._zod.parse = (payload, ctx) => {
    value ?? (value = _normalized.value);
    const input = payload.value;
    if (!isObject2(input)) {
      payload.issues.push({
        expected: "object",
        code: "invalid_type",
        input,
        inst
      });
      return payload;
    }
    if (jit && fastEnabled && ctx?.async === false && ctx.jitless !== true) {
      if (!fastpass)
        fastpass = generateFastpass(def.shape);
      payload = fastpass(payload, ctx);
      if (!catchall)
        return payload;
      return handleCatchall([], input, payload, ctx, value, inst);
    }
    return superParse(payload, ctx);
  };
});
function handleUnionResults(results, final, inst, ctx) {
  for (const result of results) {
    if (result.issues.length === 0) {
      final.value = result.value;
      return final;
    }
  }
  const nonaborted = results.filter((r) => !aborted(r));
  if (nonaborted.length === 1) {
    final.value = nonaborted[0].value;
    return nonaborted[0];
  }
  final.issues.push({
    code: "invalid_union",
    input: final.value,
    inst,
    errors: results.map((result) => result.issues.map((iss) => finalizeIssue(iss, ctx, config())))
  });
  return final;
}
var $ZodUnion = /* @__PURE__ */ $constructor("$ZodUnion", (inst, def) => {
  $ZodType.init(inst, def);
  defineLazy(inst._zod, "optin", () => def.options.some((o) => o._zod.optin === "optional") ? "optional" : void 0);
  defineLazy(inst._zod, "optout", () => def.options.some((o) => o._zod.optout === "optional") ? "optional" : void 0);
  defineLazy(inst._zod, "values", () => {
    if (def.options.every((o) => o._zod.values)) {
      return new Set(def.options.flatMap((option) => Array.from(option._zod.values)));
    }
    return void 0;
  });
  defineLazy(inst._zod, "pattern", () => {
    if (def.options.every((o) => o._zod.pattern)) {
      const patterns = def.options.map((o) => o._zod.pattern);
      return new RegExp(`^(${patterns.map((p) => cleanRegex(p.source)).join("|")})$`);
    }
    return void 0;
  });
  const first = def.options.length === 1 ? def.options[0]._zod.run : null;
  inst._zod.parse = (payload, ctx) => {
    if (first) {
      return first(payload, ctx);
    }
    let async = false;
    const results = [];
    for (const option of def.options) {
      const result = option._zod.run({
        value: payload.value,
        issues: []
      }, ctx);
      if (result instanceof Promise) {
        results.push(result);
        async = true;
      } else {
        if (result.issues.length === 0)
          return result;
        results.push(result);
      }
    }
    if (!async)
      return handleUnionResults(results, payload, inst, ctx);
    return Promise.all(results).then((results2) => {
      return handleUnionResults(results2, payload, inst, ctx);
    });
  };
});
var $ZodIntersection = /* @__PURE__ */ $constructor("$ZodIntersection", (inst, def) => {
  $ZodType.init(inst, def);
  inst._zod.parse = (payload, ctx) => {
    const input = payload.value;
    const left = def.left._zod.run({ value: input, issues: [] }, ctx);
    const right = def.right._zod.run({ value: input, issues: [] }, ctx);
    const async = left instanceof Promise || right instanceof Promise;
    if (async) {
      return Promise.all([left, right]).then(([left2, right2]) => {
        return handleIntersectionResults(payload, left2, right2);
      });
    }
    return handleIntersectionResults(payload, left, right);
  };
});
function mergeValues(a, b) {
  if (a === b) {
    return { valid: true, data: a };
  }
  if (a instanceof Date && b instanceof Date && +a === +b) {
    return { valid: true, data: a };
  }
  if (isPlainObject(a) && isPlainObject(b)) {
    const bKeys = Object.keys(b);
    const sharedKeys = Object.keys(a).filter((key) => bKeys.indexOf(key) !== -1);
    const newObj = { ...a, ...b };
    for (const key of sharedKeys) {
      const sharedValue = mergeValues(a[key], b[key]);
      if (!sharedValue.valid) {
        return {
          valid: false,
          mergeErrorPath: [key, ...sharedValue.mergeErrorPath]
        };
      }
      newObj[key] = sharedValue.data;
    }
    return { valid: true, data: newObj };
  }
  if (Array.isArray(a) && Array.isArray(b)) {
    if (a.length !== b.length) {
      return { valid: false, mergeErrorPath: [] };
    }
    const newArray = [];
    for (let index = 0; index < a.length; index++) {
      const itemA = a[index];
      const itemB = b[index];
      const sharedValue = mergeValues(itemA, itemB);
      if (!sharedValue.valid) {
        return {
          valid: false,
          mergeErrorPath: [index, ...sharedValue.mergeErrorPath]
        };
      }
      newArray.push(sharedValue.data);
    }
    return { valid: true, data: newArray };
  }
  return { valid: false, mergeErrorPath: [] };
}
function handleIntersectionResults(result, left, right) {
  const unrecKeys = /* @__PURE__ */ new Map();
  let unrecIssue;
  for (const iss of left.issues) {
    if (iss.code === "unrecognized_keys") {
      unrecIssue ?? (unrecIssue = iss);
      for (const k of iss.keys) {
        if (!unrecKeys.has(k))
          unrecKeys.set(k, {});
        unrecKeys.get(k).l = true;
      }
    } else {
      result.issues.push(iss);
    }
  }
  for (const iss of right.issues) {
    if (iss.code === "unrecognized_keys") {
      for (const k of iss.keys) {
        if (!unrecKeys.has(k))
          unrecKeys.set(k, {});
        unrecKeys.get(k).r = true;
      }
    } else {
      result.issues.push(iss);
    }
  }
  const bothKeys = [...unrecKeys].filter(([, f]) => f.l && f.r).map(([k]) => k);
  if (bothKeys.length && unrecIssue) {
    result.issues.push({ ...unrecIssue, keys: bothKeys });
  }
  if (aborted(result))
    return result;
  const merged = mergeValues(left.value, right.value);
  if (!merged.valid) {
    throw new Error(`Unmergable intersection. Error path: ${JSON.stringify(merged.mergeErrorPath)}`);
  }
  result.value = merged.data;
  return result;
}
var $ZodRecord = /* @__PURE__ */ $constructor("$ZodRecord", (inst, def) => {
  $ZodType.init(inst, def);
  inst._zod.parse = (payload, ctx) => {
    const input = payload.value;
    if (!isPlainObject(input)) {
      payload.issues.push({
        expected: "record",
        code: "invalid_type",
        input,
        inst
      });
      return payload;
    }
    const proms = [];
    const values = def.keyType._zod.values;
    if (values) {
      payload.value = {};
      const recordKeys = /* @__PURE__ */ new Set();
      for (const key of values) {
        if (typeof key === "string" || typeof key === "number" || typeof key === "symbol") {
          recordKeys.add(typeof key === "number" ? key.toString() : key);
          const keyResult = def.keyType._zod.run({ value: key, issues: [] }, ctx);
          if (keyResult instanceof Promise) {
            throw new Error("Async schemas not supported in object keys currently");
          }
          if (keyResult.issues.length) {
            payload.issues.push({
              code: "invalid_key",
              origin: "record",
              issues: keyResult.issues.map((iss) => finalizeIssue(iss, ctx, config())),
              input: key,
              path: [key],
              inst
            });
            continue;
          }
          const outKey = keyResult.value;
          const result = def.valueType._zod.run({ value: input[key], issues: [] }, ctx);
          if (result instanceof Promise) {
            proms.push(result.then((result2) => {
              if (result2.issues.length) {
                payload.issues.push(...prefixIssues(key, result2.issues));
              }
              payload.value[outKey] = result2.value;
            }));
          } else {
            if (result.issues.length) {
              payload.issues.push(...prefixIssues(key, result.issues));
            }
            payload.value[outKey] = result.value;
          }
        }
      }
      let unrecognized;
      for (const key in input) {
        if (!recordKeys.has(key)) {
          unrecognized = unrecognized ?? [];
          unrecognized.push(key);
        }
      }
      if (unrecognized && unrecognized.length > 0) {
        payload.issues.push({
          code: "unrecognized_keys",
          input,
          inst,
          keys: unrecognized
        });
      }
    } else {
      payload.value = {};
      for (const key of Reflect.ownKeys(input)) {
        if (key === "__proto__")
          continue;
        if (!Object.prototype.propertyIsEnumerable.call(input, key))
          continue;
        let keyResult = def.keyType._zod.run({ value: key, issues: [] }, ctx);
        if (keyResult instanceof Promise) {
          throw new Error("Async schemas not supported in object keys currently");
        }
        const checkNumericKey = typeof key === "string" && number.test(key) && keyResult.issues.length;
        if (checkNumericKey) {
          const retryResult = def.keyType._zod.run({ value: Number(key), issues: [] }, ctx);
          if (retryResult instanceof Promise) {
            throw new Error("Async schemas not supported in object keys currently");
          }
          if (retryResult.issues.length === 0) {
            keyResult = retryResult;
          }
        }
        if (keyResult.issues.length) {
          if (def.mode === "loose") {
            payload.value[key] = input[key];
          } else {
            payload.issues.push({
              code: "invalid_key",
              origin: "record",
              issues: keyResult.issues.map((iss) => finalizeIssue(iss, ctx, config())),
              input: key,
              path: [key],
              inst
            });
          }
          continue;
        }
        const result = def.valueType._zod.run({ value: input[key], issues: [] }, ctx);
        if (result instanceof Promise) {
          proms.push(result.then((result2) => {
            if (result2.issues.length) {
              payload.issues.push(...prefixIssues(key, result2.issues));
            }
            payload.value[keyResult.value] = result2.value;
          }));
        } else {
          if (result.issues.length) {
            payload.issues.push(...prefixIssues(key, result.issues));
          }
          payload.value[keyResult.value] = result.value;
        }
      }
    }
    if (proms.length) {
      return Promise.all(proms).then(() => payload);
    }
    return payload;
  };
});
var $ZodEnum = /* @__PURE__ */ $constructor("$ZodEnum", (inst, def) => {
  $ZodType.init(inst, def);
  const values = getEnumValues(def.entries);
  const valuesSet = new Set(values);
  inst._zod.values = valuesSet;
  inst._zod.pattern = new RegExp(`^(${values.filter((k) => propertyKeyTypes.has(typeof k)).map((o) => typeof o === "string" ? escapeRegex(o) : o.toString()).join("|")})$`);
  inst._zod.parse = (payload, _ctx) => {
    const input = payload.value;
    if (valuesSet.has(input)) {
      return payload;
    }
    payload.issues.push({
      code: "invalid_value",
      values,
      input,
      inst
    });
    return payload;
  };
});
var $ZodTransform = /* @__PURE__ */ $constructor("$ZodTransform", (inst, def) => {
  $ZodType.init(inst, def);
  inst._zod.optin = "optional";
  inst._zod.parse = (payload, ctx) => {
    if (ctx.direction === "backward") {
      throw new $ZodEncodeError(inst.constructor.name);
    }
    const _out = def.transform(payload.value, payload);
    if (ctx.async) {
      const output = _out instanceof Promise ? _out : Promise.resolve(_out);
      return output.then((output2) => {
        payload.value = output2;
        payload.fallback = true;
        return payload;
      });
    }
    if (_out instanceof Promise) {
      throw new $ZodAsyncError();
    }
    payload.value = _out;
    payload.fallback = true;
    return payload;
  };
});
function handleOptionalResult(result, input) {
  if (input === void 0 && (result.issues.length || result.fallback)) {
    return { issues: [], value: void 0 };
  }
  return result;
}
var $ZodOptional = /* @__PURE__ */ $constructor("$ZodOptional", (inst, def) => {
  $ZodType.init(inst, def);
  inst._zod.optin = "optional";
  inst._zod.optout = "optional";
  defineLazy(inst._zod, "values", () => {
    return def.innerType._zod.values ? /* @__PURE__ */ new Set([...def.innerType._zod.values, void 0]) : void 0;
  });
  defineLazy(inst._zod, "pattern", () => {
    const pattern = def.innerType._zod.pattern;
    return pattern ? new RegExp(`^(${cleanRegex(pattern.source)})?$`) : void 0;
  });
  inst._zod.parse = (payload, ctx) => {
    if (def.innerType._zod.optin === "optional") {
      const input = payload.value;
      const result = def.innerType._zod.run(payload, ctx);
      if (result instanceof Promise)
        return result.then((r) => handleOptionalResult(r, input));
      return handleOptionalResult(result, input);
    }
    if (payload.value === void 0) {
      return payload;
    }
    return def.innerType._zod.run(payload, ctx);
  };
});
var $ZodExactOptional = /* @__PURE__ */ $constructor("$ZodExactOptional", (inst, def) => {
  $ZodOptional.init(inst, def);
  defineLazy(inst._zod, "values", () => def.innerType._zod.values);
  defineLazy(inst._zod, "pattern", () => def.innerType._zod.pattern);
  inst._zod.parse = (payload, ctx) => {
    return def.innerType._zod.run(payload, ctx);
  };
});
var $ZodNullable = /* @__PURE__ */ $constructor("$ZodNullable", (inst, def) => {
  $ZodType.init(inst, def);
  defineLazy(inst._zod, "optin", () => def.innerType._zod.optin);
  defineLazy(inst._zod, "optout", () => def.innerType._zod.optout);
  defineLazy(inst._zod, "pattern", () => {
    const pattern = def.innerType._zod.pattern;
    return pattern ? new RegExp(`^(${cleanRegex(pattern.source)}|null)$`) : void 0;
  });
  defineLazy(inst._zod, "values", () => {
    return def.innerType._zod.values ? /* @__PURE__ */ new Set([...def.innerType._zod.values, null]) : void 0;
  });
  inst._zod.parse = (payload, ctx) => {
    if (payload.value === null)
      return payload;
    return def.innerType._zod.run(payload, ctx);
  };
});
var $ZodDefault = /* @__PURE__ */ $constructor("$ZodDefault", (inst, def) => {
  $ZodType.init(inst, def);
  inst._zod.optin = "optional";
  defineLazy(inst._zod, "values", () => def.innerType._zod.values);
  inst._zod.parse = (payload, ctx) => {
    if (ctx.direction === "backward") {
      return def.innerType._zod.run(payload, ctx);
    }
    if (payload.value === void 0) {
      payload.value = def.defaultValue;
      return payload;
    }
    const result = def.innerType._zod.run(payload, ctx);
    if (result instanceof Promise) {
      return result.then((result2) => handleDefaultResult(result2, def));
    }
    return handleDefaultResult(result, def);
  };
});
function handleDefaultResult(payload, def) {
  if (payload.value === void 0) {
    payload.value = def.defaultValue;
  }
  return payload;
}
var $ZodPrefault = /* @__PURE__ */ $constructor("$ZodPrefault", (inst, def) => {
  $ZodType.init(inst, def);
  inst._zod.optin = "optional";
  defineLazy(inst._zod, "values", () => def.innerType._zod.values);
  inst._zod.parse = (payload, ctx) => {
    if (ctx.direction === "backward") {
      return def.innerType._zod.run(payload, ctx);
    }
    if (payload.value === void 0) {
      payload.value = def.defaultValue;
    }
    return def.innerType._zod.run(payload, ctx);
  };
});
var $ZodNonOptional = /* @__PURE__ */ $constructor("$ZodNonOptional", (inst, def) => {
  $ZodType.init(inst, def);
  defineLazy(inst._zod, "values", () => {
    const v = def.innerType._zod.values;
    return v ? new Set([...v].filter((x) => x !== void 0)) : void 0;
  });
  inst._zod.parse = (payload, ctx) => {
    const result = def.innerType._zod.run(payload, ctx);
    if (result instanceof Promise) {
      return result.then((result2) => handleNonOptionalResult(result2, inst));
    }
    return handleNonOptionalResult(result, inst);
  };
});
function handleNonOptionalResult(payload, inst) {
  if (!payload.issues.length && payload.value === void 0) {
    payload.issues.push({
      code: "invalid_type",
      expected: "nonoptional",
      input: payload.value,
      inst
    });
  }
  return payload;
}
var $ZodCatch = /* @__PURE__ */ $constructor("$ZodCatch", (inst, def) => {
  $ZodType.init(inst, def);
  inst._zod.optin = "optional";
  defineLazy(inst._zod, "optout", () => def.innerType._zod.optout);
  defineLazy(inst._zod, "values", () => def.innerType._zod.values);
  inst._zod.parse = (payload, ctx) => {
    if (ctx.direction === "backward") {
      return def.innerType._zod.run(payload, ctx);
    }
    const result = def.innerType._zod.run(payload, ctx);
    if (result instanceof Promise) {
      return result.then((result2) => {
        payload.value = result2.value;
        if (result2.issues.length) {
          payload.value = def.catchValue({
            ...payload,
            error: {
              issues: result2.issues.map((iss) => finalizeIssue(iss, ctx, config()))
            },
            input: payload.value
          });
          payload.issues = [];
          payload.fallback = true;
        }
        return payload;
      });
    }
    payload.value = result.value;
    if (result.issues.length) {
      payload.value = def.catchValue({
        ...payload,
        error: {
          issues: result.issues.map((iss) => finalizeIssue(iss, ctx, config()))
        },
        input: payload.value
      });
      payload.issues = [];
      payload.fallback = true;
    }
    return payload;
  };
});
var $ZodPipe = /* @__PURE__ */ $constructor("$ZodPipe", (inst, def) => {
  $ZodType.init(inst, def);
  defineLazy(inst._zod, "values", () => def.in._zod.values);
  defineLazy(inst._zod, "optin", () => def.in._zod.optin);
  defineLazy(inst._zod, "optout", () => def.out._zod.optout);
  defineLazy(inst._zod, "propValues", () => def.in._zod.propValues);
  inst._zod.parse = (payload, ctx) => {
    if (ctx.direction === "backward") {
      const right = def.out._zod.run(payload, ctx);
      if (right instanceof Promise) {
        return right.then((right2) => handlePipeResult(right2, def.in, ctx));
      }
      return handlePipeResult(right, def.in, ctx);
    }
    const left = def.in._zod.run(payload, ctx);
    if (left instanceof Promise) {
      return left.then((left2) => handlePipeResult(left2, def.out, ctx));
    }
    return handlePipeResult(left, def.out, ctx);
  };
});
function handlePipeResult(left, next, ctx) {
  if (left.issues.length) {
    left.aborted = true;
    return left;
  }
  return next._zod.run({ value: left.value, issues: left.issues, fallback: left.fallback }, ctx);
}
var $ZodReadonly = /* @__PURE__ */ $constructor("$ZodReadonly", (inst, def) => {
  $ZodType.init(inst, def);
  defineLazy(inst._zod, "propValues", () => def.innerType._zod.propValues);
  defineLazy(inst._zod, "values", () => def.innerType._zod.values);
  defineLazy(inst._zod, "optin", () => def.innerType?._zod?.optin);
  defineLazy(inst._zod, "optout", () => def.innerType?._zod?.optout);
  inst._zod.parse = (payload, ctx) => {
    if (ctx.direction === "backward") {
      return def.innerType._zod.run(payload, ctx);
    }
    const result = def.innerType._zod.run(payload, ctx);
    if (result instanceof Promise) {
      return result.then(handleReadonlyResult);
    }
    return handleReadonlyResult(result);
  };
});
function handleReadonlyResult(payload) {
  payload.value = Object.freeze(payload.value);
  return payload;
}
var $ZodCustom = /* @__PURE__ */ $constructor("$ZodCustom", (inst, def) => {
  $ZodCheck.init(inst, def);
  $ZodType.init(inst, def);
  inst._zod.parse = (payload, _) => {
    return payload;
  };
  inst._zod.check = (payload) => {
    const input = payload.value;
    const r = def.fn(input);
    if (r instanceof Promise) {
      return r.then((r2) => handleRefineResult(r2, payload, input, inst));
    }
    handleRefineResult(r, payload, input, inst);
    return;
  };
});
function handleRefineResult(result, payload, input, inst) {
  if (!result) {
    const _iss = {
      code: "custom",
      input,
      inst,
      // incorporates params.error into issue reporting
      path: [...inst._zod.def.path ?? []],
      // incorporates params.error into issue reporting
      continue: !inst._zod.def.abort
      // params: inst._zod.def.params,
    };
    if (inst._zod.def.params)
      _iss.params = inst._zod.def.params;
    payload.issues.push(issue(_iss));
  }
}

// node_modules/zod/v4/core/registries.js
var _a2;
var $ZodRegistry = class {
  constructor() {
    this._map = /* @__PURE__ */ new WeakMap();
    this._idmap = /* @__PURE__ */ new Map();
  }
  add(schema, ..._meta) {
    const meta2 = _meta[0];
    this._map.set(schema, meta2);
    if (meta2 && typeof meta2 === "object" && "id" in meta2) {
      this._idmap.set(meta2.id, schema);
    }
    return this;
  }
  clear() {
    this._map = /* @__PURE__ */ new WeakMap();
    this._idmap = /* @__PURE__ */ new Map();
    return this;
  }
  remove(schema) {
    const meta2 = this._map.get(schema);
    if (meta2 && typeof meta2 === "object" && "id" in meta2) {
      this._idmap.delete(meta2.id);
    }
    this._map.delete(schema);
    return this;
  }
  get(schema) {
    const p = schema._zod.parent;
    if (p) {
      const pm = { ...this.get(p) ?? {} };
      delete pm.id;
      const f = { ...pm, ...this._map.get(schema) };
      return Object.keys(f).length ? f : void 0;
    }
    return this._map.get(schema);
  }
  has(schema) {
    return this._map.has(schema);
  }
};
function registry() {
  return new $ZodRegistry();
}
(_a2 = globalThis).__zod_globalRegistry ?? (_a2.__zod_globalRegistry = registry());
var globalRegistry = globalThis.__zod_globalRegistry;

// node_modules/zod/v4/core/api.js
// @__NO_SIDE_EFFECTS__
function _string(Class2, params) {
  return new Class2({
    type: "string",
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _email(Class2, params) {
  return new Class2({
    type: "string",
    format: "email",
    check: "string_format",
    abort: false,
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _guid(Class2, params) {
  return new Class2({
    type: "string",
    format: "guid",
    check: "string_format",
    abort: false,
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _uuid(Class2, params) {
  return new Class2({
    type: "string",
    format: "uuid",
    check: "string_format",
    abort: false,
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _uuidv4(Class2, params) {
  return new Class2({
    type: "string",
    format: "uuid",
    check: "string_format",
    abort: false,
    version: "v4",
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _uuidv6(Class2, params) {
  return new Class2({
    type: "string",
    format: "uuid",
    check: "string_format",
    abort: false,
    version: "v6",
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _uuidv7(Class2, params) {
  return new Class2({
    type: "string",
    format: "uuid",
    check: "string_format",
    abort: false,
    version: "v7",
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _url(Class2, params) {
  return new Class2({
    type: "string",
    format: "url",
    check: "string_format",
    abort: false,
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _emoji2(Class2, params) {
  return new Class2({
    type: "string",
    format: "emoji",
    check: "string_format",
    abort: false,
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _nanoid(Class2, params) {
  return new Class2({
    type: "string",
    format: "nanoid",
    check: "string_format",
    abort: false,
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _cuid(Class2, params) {
  return new Class2({
    type: "string",
    format: "cuid",
    check: "string_format",
    abort: false,
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _cuid2(Class2, params) {
  return new Class2({
    type: "string",
    format: "cuid2",
    check: "string_format",
    abort: false,
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _ulid(Class2, params) {
  return new Class2({
    type: "string",
    format: "ulid",
    check: "string_format",
    abort: false,
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _xid(Class2, params) {
  return new Class2({
    type: "string",
    format: "xid",
    check: "string_format",
    abort: false,
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _ksuid(Class2, params) {
  return new Class2({
    type: "string",
    format: "ksuid",
    check: "string_format",
    abort: false,
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _ipv4(Class2, params) {
  return new Class2({
    type: "string",
    format: "ipv4",
    check: "string_format",
    abort: false,
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _ipv6(Class2, params) {
  return new Class2({
    type: "string",
    format: "ipv6",
    check: "string_format",
    abort: false,
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _cidrv4(Class2, params) {
  return new Class2({
    type: "string",
    format: "cidrv4",
    check: "string_format",
    abort: false,
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _cidrv6(Class2, params) {
  return new Class2({
    type: "string",
    format: "cidrv6",
    check: "string_format",
    abort: false,
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _base64(Class2, params) {
  return new Class2({
    type: "string",
    format: "base64",
    check: "string_format",
    abort: false,
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _base64url(Class2, params) {
  return new Class2({
    type: "string",
    format: "base64url",
    check: "string_format",
    abort: false,
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _e164(Class2, params) {
  return new Class2({
    type: "string",
    format: "e164",
    check: "string_format",
    abort: false,
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _jwt(Class2, params) {
  return new Class2({
    type: "string",
    format: "jwt",
    check: "string_format",
    abort: false,
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _isoDateTime(Class2, params) {
  return new Class2({
    type: "string",
    format: "datetime",
    check: "string_format",
    offset: false,
    local: false,
    precision: null,
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _isoDate(Class2, params) {
  return new Class2({
    type: "string",
    format: "date",
    check: "string_format",
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _isoTime(Class2, params) {
  return new Class2({
    type: "string",
    format: "time",
    check: "string_format",
    precision: null,
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _isoDuration(Class2, params) {
  return new Class2({
    type: "string",
    format: "duration",
    check: "string_format",
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _number(Class2, params) {
  return new Class2({
    type: "number",
    checks: [],
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _int(Class2, params) {
  return new Class2({
    type: "number",
    check: "number_format",
    abort: false,
    format: "safeint",
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _boolean(Class2, params) {
  return new Class2({
    type: "boolean",
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _unknown(Class2) {
  return new Class2({
    type: "unknown"
  });
}
// @__NO_SIDE_EFFECTS__
function _never(Class2, params) {
  return new Class2({
    type: "never",
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _lt(value, params) {
  return new $ZodCheckLessThan({
    check: "less_than",
    ...normalizeParams(params),
    value,
    inclusive: false
  });
}
// @__NO_SIDE_EFFECTS__
function _lte(value, params) {
  return new $ZodCheckLessThan({
    check: "less_than",
    ...normalizeParams(params),
    value,
    inclusive: true
  });
}
// @__NO_SIDE_EFFECTS__
function _gt(value, params) {
  return new $ZodCheckGreaterThan({
    check: "greater_than",
    ...normalizeParams(params),
    value,
    inclusive: false
  });
}
// @__NO_SIDE_EFFECTS__
function _gte(value, params) {
  return new $ZodCheckGreaterThan({
    check: "greater_than",
    ...normalizeParams(params),
    value,
    inclusive: true
  });
}
// @__NO_SIDE_EFFECTS__
function _multipleOf(value, params) {
  return new $ZodCheckMultipleOf({
    check: "multiple_of",
    ...normalizeParams(params),
    value
  });
}
// @__NO_SIDE_EFFECTS__
function _maxLength(maximum, params) {
  const ch = new $ZodCheckMaxLength({
    check: "max_length",
    ...normalizeParams(params),
    maximum
  });
  return ch;
}
// @__NO_SIDE_EFFECTS__
function _minLength(minimum, params) {
  return new $ZodCheckMinLength({
    check: "min_length",
    ...normalizeParams(params),
    minimum
  });
}
// @__NO_SIDE_EFFECTS__
function _length(length, params) {
  return new $ZodCheckLengthEquals({
    check: "length_equals",
    ...normalizeParams(params),
    length
  });
}
// @__NO_SIDE_EFFECTS__
function _regex(pattern, params) {
  return new $ZodCheckRegex({
    check: "string_format",
    format: "regex",
    ...normalizeParams(params),
    pattern
  });
}
// @__NO_SIDE_EFFECTS__
function _lowercase(params) {
  return new $ZodCheckLowerCase({
    check: "string_format",
    format: "lowercase",
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _uppercase(params) {
  return new $ZodCheckUpperCase({
    check: "string_format",
    format: "uppercase",
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _includes(includes, params) {
  return new $ZodCheckIncludes({
    check: "string_format",
    format: "includes",
    ...normalizeParams(params),
    includes
  });
}
// @__NO_SIDE_EFFECTS__
function _startsWith(prefix, params) {
  return new $ZodCheckStartsWith({
    check: "string_format",
    format: "starts_with",
    ...normalizeParams(params),
    prefix
  });
}
// @__NO_SIDE_EFFECTS__
function _endsWith(suffix, params) {
  return new $ZodCheckEndsWith({
    check: "string_format",
    format: "ends_with",
    ...normalizeParams(params),
    suffix
  });
}
// @__NO_SIDE_EFFECTS__
function _overwrite(tx) {
  return new $ZodCheckOverwrite({
    check: "overwrite",
    tx
  });
}
// @__NO_SIDE_EFFECTS__
function _normalize(form) {
  return /* @__PURE__ */ _overwrite((input) => input.normalize(form));
}
// @__NO_SIDE_EFFECTS__
function _trim() {
  return /* @__PURE__ */ _overwrite((input) => input.trim());
}
// @__NO_SIDE_EFFECTS__
function _toLowerCase() {
  return /* @__PURE__ */ _overwrite((input) => input.toLowerCase());
}
// @__NO_SIDE_EFFECTS__
function _toUpperCase() {
  return /* @__PURE__ */ _overwrite((input) => input.toUpperCase());
}
// @__NO_SIDE_EFFECTS__
function _slugify() {
  return /* @__PURE__ */ _overwrite((input) => slugify(input));
}
// @__NO_SIDE_EFFECTS__
function _array(Class2, element, params) {
  return new Class2({
    type: "array",
    element,
    // get element() {
    //   return element;
    // },
    ...normalizeParams(params)
  });
}
// @__NO_SIDE_EFFECTS__
function _refine(Class2, fn, _params) {
  const schema = new Class2({
    type: "custom",
    check: "custom",
    fn,
    ...normalizeParams(_params)
  });
  return schema;
}
// @__NO_SIDE_EFFECTS__
function _superRefine(fn, params) {
  const ch = /* @__PURE__ */ _check((payload) => {
    payload.addIssue = (issue2) => {
      if (typeof issue2 === "string") {
        payload.issues.push(issue(issue2, payload.value, ch._zod.def));
      } else {
        const _issue = issue2;
        if (_issue.fatal)
          _issue.continue = false;
        _issue.code ?? (_issue.code = "custom");
        _issue.input ?? (_issue.input = payload.value);
        _issue.inst ?? (_issue.inst = ch);
        _issue.continue ?? (_issue.continue = !ch._zod.def.abort);
        payload.issues.push(issue(_issue));
      }
    };
    return fn(payload.value, payload);
  }, params);
  return ch;
}
// @__NO_SIDE_EFFECTS__
function _check(fn, params) {
  const ch = new $ZodCheck({
    check: "custom",
    ...normalizeParams(params)
  });
  ch._zod.check = fn;
  return ch;
}

// node_modules/zod/v4/core/to-json-schema.js
function initializeContext(params) {
  let target = params?.target ?? "draft-2020-12";
  if (target === "draft-4")
    target = "draft-04";
  if (target === "draft-7")
    target = "draft-07";
  return {
    processors: params.processors ?? {},
    metadataRegistry: params?.metadata ?? globalRegistry,
    target,
    unrepresentable: params?.unrepresentable ?? "throw",
    override: params?.override ?? (() => {
    }),
    io: params?.io ?? "output",
    counter: 0,
    seen: /* @__PURE__ */ new Map(),
    cycles: params?.cycles ?? "ref",
    reused: params?.reused ?? "inline",
    external: params?.external ?? void 0
  };
}
function process2(schema, ctx, _params = { path: [], schemaPath: [] }) {
  var _a3;
  const def = schema._zod.def;
  const seen = ctx.seen.get(schema);
  if (seen) {
    seen.count++;
    const isCycle = _params.schemaPath.includes(schema);
    if (isCycle) {
      seen.cycle = _params.path;
    }
    return seen.schema;
  }
  const result = { schema: {}, count: 1, cycle: void 0, path: _params.path };
  ctx.seen.set(schema, result);
  const overrideSchema = schema._zod.toJSONSchema?.();
  if (overrideSchema) {
    result.schema = overrideSchema;
  } else {
    const params = {
      ..._params,
      schemaPath: [..._params.schemaPath, schema],
      path: _params.path
    };
    if (schema._zod.processJSONSchema) {
      schema._zod.processJSONSchema(ctx, result.schema, params);
    } else {
      const _json = result.schema;
      const processor = ctx.processors[def.type];
      if (!processor) {
        throw new Error(`[toJSONSchema]: Non-representable type encountered: ${def.type}`);
      }
      processor(schema, ctx, _json, params);
    }
    const parent = schema._zod.parent;
    if (parent) {
      if (!result.ref)
        result.ref = parent;
      process2(parent, ctx, params);
      ctx.seen.get(parent).isParent = true;
    }
  }
  const meta2 = ctx.metadataRegistry.get(schema);
  if (meta2)
    Object.assign(result.schema, meta2);
  if (ctx.io === "input" && isTransforming(schema)) {
    delete result.schema.examples;
    delete result.schema.default;
  }
  if (ctx.io === "input" && "_prefault" in result.schema)
    (_a3 = result.schema).default ?? (_a3.default = result.schema._prefault);
  delete result.schema._prefault;
  const _result = ctx.seen.get(schema);
  return _result.schema;
}
function extractDefs(ctx, schema) {
  const root = ctx.seen.get(schema);
  if (!root)
    throw new Error("Unprocessed schema. This is a bug in Zod.");
  const idToSchema = /* @__PURE__ */ new Map();
  for (const entry of ctx.seen.entries()) {
    const id = ctx.metadataRegistry.get(entry[0])?.id;
    if (id) {
      const existing = idToSchema.get(id);
      if (existing && existing !== entry[0]) {
        throw new Error(`Duplicate schema id "${id}" detected during JSON Schema conversion. Two different schemas cannot share the same id when converted together.`);
      }
      idToSchema.set(id, entry[0]);
    }
  }
  const makeURI = (entry) => {
    const defsSegment = ctx.target === "draft-2020-12" ? "$defs" : "definitions";
    if (ctx.external) {
      const externalId = ctx.external.registry.get(entry[0])?.id;
      const uriGenerator = ctx.external.uri ?? ((id2) => id2);
      if (externalId) {
        return { ref: uriGenerator(externalId) };
      }
      const id = entry[1].defId ?? entry[1].schema.id ?? `schema${ctx.counter++}`;
      entry[1].defId = id;
      return { defId: id, ref: `${uriGenerator("__shared")}#/${defsSegment}/${id}` };
    }
    if (entry[1] === root) {
      return { ref: "#" };
    }
    const uriPrefix = `#`;
    const defUriPrefix = `${uriPrefix}/${defsSegment}/`;
    const defId = entry[1].schema.id ?? `__schema${ctx.counter++}`;
    return { defId, ref: defUriPrefix + defId };
  };
  const extractToDef = (entry) => {
    if (entry[1].schema.$ref) {
      return;
    }
    const seen = entry[1];
    const { ref, defId } = makeURI(entry);
    seen.def = { ...seen.schema };
    if (defId)
      seen.defId = defId;
    const schema2 = seen.schema;
    for (const key in schema2) {
      delete schema2[key];
    }
    schema2.$ref = ref;
  };
  if (ctx.cycles === "throw") {
    for (const entry of ctx.seen.entries()) {
      const seen = entry[1];
      if (seen.cycle) {
        throw new Error(`Cycle detected: #/${seen.cycle?.join("/")}/<root>

Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.`);
      }
    }
  }
  for (const entry of ctx.seen.entries()) {
    const seen = entry[1];
    if (schema === entry[0]) {
      extractToDef(entry);
      continue;
    }
    if (ctx.external) {
      const ext = ctx.external.registry.get(entry[0])?.id;
      if (schema !== entry[0] && ext) {
        extractToDef(entry);
        continue;
      }
    }
    const id = ctx.metadataRegistry.get(entry[0])?.id;
    if (id) {
      extractToDef(entry);
      continue;
    }
    if (seen.cycle) {
      extractToDef(entry);
      continue;
    }
    if (seen.count > 1) {
      if (ctx.reused === "ref") {
        extractToDef(entry);
        continue;
      }
    }
  }
}
function finalize(ctx, schema) {
  const root = ctx.seen.get(schema);
  if (!root)
    throw new Error("Unprocessed schema. This is a bug in Zod.");
  const flattenRef = (zodSchema) => {
    const seen = ctx.seen.get(zodSchema);
    if (seen.ref === null)
      return;
    const schema2 = seen.def ?? seen.schema;
    const _cached = { ...schema2 };
    const ref = seen.ref;
    seen.ref = null;
    if (ref) {
      flattenRef(ref);
      const refSeen = ctx.seen.get(ref);
      const refSchema = refSeen.schema;
      if (refSchema.$ref && (ctx.target === "draft-07" || ctx.target === "draft-04" || ctx.target === "openapi-3.0")) {
        schema2.allOf = schema2.allOf ?? [];
        schema2.allOf.push(refSchema);
      } else {
        Object.assign(schema2, refSchema);
      }
      Object.assign(schema2, _cached);
      const isParentRef = zodSchema._zod.parent === ref;
      if (isParentRef) {
        for (const key in schema2) {
          if (key === "$ref" || key === "allOf")
            continue;
          if (!(key in _cached)) {
            delete schema2[key];
          }
        }
      }
      if (refSchema.$ref && refSeen.def) {
        for (const key in schema2) {
          if (key === "$ref" || key === "allOf")
            continue;
          if (key in refSeen.def && JSON.stringify(schema2[key]) === JSON.stringify(refSeen.def[key])) {
            delete schema2[key];
          }
        }
      }
    }
    const parent = zodSchema._zod.parent;
    if (parent && parent !== ref) {
      flattenRef(parent);
      const parentSeen = ctx.seen.get(parent);
      if (parentSeen?.schema.$ref) {
        schema2.$ref = parentSeen.schema.$ref;
        if (parentSeen.def) {
          for (const key in schema2) {
            if (key === "$ref" || key === "allOf")
              continue;
            if (key in parentSeen.def && JSON.stringify(schema2[key]) === JSON.stringify(parentSeen.def[key])) {
              delete schema2[key];
            }
          }
        }
      }
    }
    ctx.override({
      zodSchema,
      jsonSchema: schema2,
      path: seen.path ?? []
    });
  };
  for (const entry of [...ctx.seen.entries()].reverse()) {
    flattenRef(entry[0]);
  }
  const result = {};
  if (ctx.target === "draft-2020-12") {
    result.$schema = "https://json-schema.org/draft/2020-12/schema";
  } else if (ctx.target === "draft-07") {
    result.$schema = "http://json-schema.org/draft-07/schema#";
  } else if (ctx.target === "draft-04") {
    result.$schema = "http://json-schema.org/draft-04/schema#";
  } else if (ctx.target === "openapi-3.0") {
  } else {
  }
  if (ctx.external?.uri) {
    const id = ctx.external.registry.get(schema)?.id;
    if (!id)
      throw new Error("Schema is missing an `id` property");
    result.$id = ctx.external.uri(id);
  }
  Object.assign(result, root.def ?? root.schema);
  const rootMetaId = ctx.metadataRegistry.get(schema)?.id;
  if (rootMetaId !== void 0 && result.id === rootMetaId)
    delete result.id;
  const defs = ctx.external?.defs ?? {};
  for (const entry of ctx.seen.entries()) {
    const seen = entry[1];
    if (seen.def && seen.defId) {
      if (seen.def.id === seen.defId)
        delete seen.def.id;
      defs[seen.defId] = seen.def;
    }
  }
  if (ctx.external) {
  } else {
    if (Object.keys(defs).length > 0) {
      if (ctx.target === "draft-2020-12") {
        result.$defs = defs;
      } else {
        result.definitions = defs;
      }
    }
  }
  try {
    const finalized = JSON.parse(JSON.stringify(result));
    Object.defineProperty(finalized, "~standard", {
      value: {
        ...schema["~standard"],
        jsonSchema: {
          input: createStandardJSONSchemaMethod(schema, "input", ctx.processors),
          output: createStandardJSONSchemaMethod(schema, "output", ctx.processors)
        }
      },
      enumerable: false,
      writable: false
    });
    return finalized;
  } catch (_err) {
    throw new Error("Error converting schema to JSON.");
  }
}
function isTransforming(_schema, _ctx) {
  const ctx = _ctx ?? { seen: /* @__PURE__ */ new Set() };
  if (ctx.seen.has(_schema))
    return false;
  ctx.seen.add(_schema);
  const def = _schema._zod.def;
  if (def.type === "transform")
    return true;
  if (def.type === "array")
    return isTransforming(def.element, ctx);
  if (def.type === "set")
    return isTransforming(def.valueType, ctx);
  if (def.type === "lazy")
    return isTransforming(def.getter(), ctx);
  if (def.type === "promise" || def.type === "optional" || def.type === "nonoptional" || def.type === "nullable" || def.type === "readonly" || def.type === "default" || def.type === "prefault") {
    return isTransforming(def.innerType, ctx);
  }
  if (def.type === "intersection") {
    return isTransforming(def.left, ctx) || isTransforming(def.right, ctx);
  }
  if (def.type === "record" || def.type === "map") {
    return isTransforming(def.keyType, ctx) || isTransforming(def.valueType, ctx);
  }
  if (def.type === "pipe") {
    if (_schema._zod.traits.has("$ZodCodec"))
      return true;
    return isTransforming(def.in, ctx) || isTransforming(def.out, ctx);
  }
  if (def.type === "object") {
    for (const key in def.shape) {
      if (isTransforming(def.shape[key], ctx))
        return true;
    }
    return false;
  }
  if (def.type === "union") {
    for (const option of def.options) {
      if (isTransforming(option, ctx))
        return true;
    }
    return false;
  }
  if (def.type === "tuple") {
    for (const item of def.items) {
      if (isTransforming(item, ctx))
        return true;
    }
    if (def.rest && isTransforming(def.rest, ctx))
      return true;
    return false;
  }
  return false;
}
var createToJSONSchemaMethod = (schema, processors = {}) => (params) => {
  const ctx = initializeContext({ ...params, processors });
  process2(schema, ctx);
  extractDefs(ctx, schema);
  return finalize(ctx, schema);
};
var createStandardJSONSchemaMethod = (schema, io, processors = {}) => (params) => {
  const { libraryOptions, target } = params ?? {};
  const ctx = initializeContext({ ...libraryOptions ?? {}, target, io, processors });
  process2(schema, ctx);
  extractDefs(ctx, schema);
  return finalize(ctx, schema);
};

// node_modules/zod/v4/core/json-schema-processors.js
var formatMap = {
  guid: "uuid",
  url: "uri",
  datetime: "date-time",
  json_string: "json-string",
  regex: ""
  // do not set
};
var stringProcessor = (schema, ctx, _json, _params) => {
  const json = _json;
  json.type = "string";
  const { minimum, maximum, format, patterns, contentEncoding } = schema._zod.bag;
  if (typeof minimum === "number")
    json.minLength = minimum;
  if (typeof maximum === "number")
    json.maxLength = maximum;
  if (format) {
    json.format = formatMap[format] ?? format;
    if (json.format === "")
      delete json.format;
    if (format === "time") {
      delete json.format;
    }
  }
  if (contentEncoding)
    json.contentEncoding = contentEncoding;
  if (patterns && patterns.size > 0) {
    const regexes = [...patterns];
    if (regexes.length === 1)
      json.pattern = regexes[0].source;
    else if (regexes.length > 1) {
      json.allOf = [
        ...regexes.map((regex) => ({
          ...ctx.target === "draft-07" || ctx.target === "draft-04" || ctx.target === "openapi-3.0" ? { type: "string" } : {},
          pattern: regex.source
        }))
      ];
    }
  }
};
var numberProcessor = (schema, ctx, _json, _params) => {
  const json = _json;
  const { minimum, maximum, format, multipleOf, exclusiveMaximum, exclusiveMinimum } = schema._zod.bag;
  if (typeof format === "string" && format.includes("int"))
    json.type = "integer";
  else
    json.type = "number";
  const exMin = typeof exclusiveMinimum === "number" && exclusiveMinimum >= (minimum ?? Number.NEGATIVE_INFINITY);
  const exMax = typeof exclusiveMaximum === "number" && exclusiveMaximum <= (maximum ?? Number.POSITIVE_INFINITY);
  const legacy = ctx.target === "draft-04" || ctx.target === "openapi-3.0";
  if (exMin) {
    if (legacy) {
      json.minimum = exclusiveMinimum;
      json.exclusiveMinimum = true;
    } else {
      json.exclusiveMinimum = exclusiveMinimum;
    }
  } else if (typeof minimum === "number") {
    json.minimum = minimum;
  }
  if (exMax) {
    if (legacy) {
      json.maximum = exclusiveMaximum;
      json.exclusiveMaximum = true;
    } else {
      json.exclusiveMaximum = exclusiveMaximum;
    }
  } else if (typeof maximum === "number") {
    json.maximum = maximum;
  }
  if (typeof multipleOf === "number")
    json.multipleOf = multipleOf;
};
var booleanProcessor = (_schema, _ctx, json, _params) => {
  json.type = "boolean";
};
var neverProcessor = (_schema, _ctx, json, _params) => {
  json.not = {};
};
var unknownProcessor = (_schema, _ctx, _json, _params) => {
};
var enumProcessor = (schema, _ctx, json, _params) => {
  const def = schema._zod.def;
  const values = getEnumValues(def.entries);
  if (values.every((v) => typeof v === "number"))
    json.type = "number";
  if (values.every((v) => typeof v === "string"))
    json.type = "string";
  json.enum = values;
};
var customProcessor = (_schema, ctx, _json, _params) => {
  if (ctx.unrepresentable === "throw") {
    throw new Error("Custom types cannot be represented in JSON Schema");
  }
};
var transformProcessor = (_schema, ctx, _json, _params) => {
  if (ctx.unrepresentable === "throw") {
    throw new Error("Transforms cannot be represented in JSON Schema");
  }
};
var arrayProcessor = (schema, ctx, _json, params) => {
  const json = _json;
  const def = schema._zod.def;
  const { minimum, maximum } = schema._zod.bag;
  if (typeof minimum === "number")
    json.minItems = minimum;
  if (typeof maximum === "number")
    json.maxItems = maximum;
  json.type = "array";
  json.items = process2(def.element, ctx, {
    ...params,
    path: [...params.path, "items"]
  });
};
var objectProcessor = (schema, ctx, _json, params) => {
  const json = _json;
  const def = schema._zod.def;
  json.type = "object";
  json.properties = {};
  const shape = def.shape;
  for (const key in shape) {
    json.properties[key] = process2(shape[key], ctx, {
      ...params,
      path: [...params.path, "properties", key]
    });
  }
  const allKeys = new Set(Object.keys(shape));
  const requiredKeys = new Set([...allKeys].filter((key) => {
    const v = def.shape[key]._zod;
    if (ctx.io === "input") {
      return v.optin === void 0;
    } else {
      return v.optout === void 0;
    }
  }));
  if (requiredKeys.size > 0) {
    json.required = Array.from(requiredKeys);
  }
  if (def.catchall?._zod.def.type === "never") {
    json.additionalProperties = false;
  } else if (!def.catchall) {
    if (ctx.io === "output")
      json.additionalProperties = false;
  } else if (def.catchall) {
    json.additionalProperties = process2(def.catchall, ctx, {
      ...params,
      path: [...params.path, "additionalProperties"]
    });
  }
};
var unionProcessor = (schema, ctx, json, params) => {
  const def = schema._zod.def;
  const isExclusive = def.inclusive === false;
  const options = def.options.map((x, i) => process2(x, ctx, {
    ...params,
    path: [...params.path, isExclusive ? "oneOf" : "anyOf", i]
  }));
  if (isExclusive) {
    json.oneOf = options;
  } else {
    json.anyOf = options;
  }
};
var intersectionProcessor = (schema, ctx, json, params) => {
  const def = schema._zod.def;
  const a = process2(def.left, ctx, {
    ...params,
    path: [...params.path, "allOf", 0]
  });
  const b = process2(def.right, ctx, {
    ...params,
    path: [...params.path, "allOf", 1]
  });
  const isSimpleIntersection = (val) => "allOf" in val && Object.keys(val).length === 1;
  const allOf = [
    ...isSimpleIntersection(a) ? a.allOf : [a],
    ...isSimpleIntersection(b) ? b.allOf : [b]
  ];
  json.allOf = allOf;
};
var recordProcessor = (schema, ctx, _json, params) => {
  const json = _json;
  const def = schema._zod.def;
  json.type = "object";
  const keyType = def.keyType;
  const keyBag = keyType._zod.bag;
  const patterns = keyBag?.patterns;
  if (def.mode === "loose" && patterns && patterns.size > 0) {
    const valueSchema = process2(def.valueType, ctx, {
      ...params,
      path: [...params.path, "patternProperties", "*"]
    });
    json.patternProperties = {};
    for (const pattern of patterns) {
      json.patternProperties[pattern.source] = valueSchema;
    }
  } else {
    if (ctx.target === "draft-07" || ctx.target === "draft-2020-12") {
      json.propertyNames = process2(def.keyType, ctx, {
        ...params,
        path: [...params.path, "propertyNames"]
      });
    }
    json.additionalProperties = process2(def.valueType, ctx, {
      ...params,
      path: [...params.path, "additionalProperties"]
    });
  }
  const keyValues = keyType._zod.values;
  if (keyValues) {
    const validKeyValues = [...keyValues].filter((v) => typeof v === "string" || typeof v === "number");
    if (validKeyValues.length > 0) {
      json.required = validKeyValues;
    }
  }
};
var nullableProcessor = (schema, ctx, json, params) => {
  const def = schema._zod.def;
  const inner = process2(def.innerType, ctx, params);
  const seen = ctx.seen.get(schema);
  if (ctx.target === "openapi-3.0") {
    seen.ref = def.innerType;
    json.nullable = true;
  } else {
    json.anyOf = [inner, { type: "null" }];
  }
};
var nonoptionalProcessor = (schema, ctx, _json, params) => {
  const def = schema._zod.def;
  process2(def.innerType, ctx, params);
  const seen = ctx.seen.get(schema);
  seen.ref = def.innerType;
};
var defaultProcessor = (schema, ctx, json, params) => {
  const def = schema._zod.def;
  process2(def.innerType, ctx, params);
  const seen = ctx.seen.get(schema);
  seen.ref = def.innerType;
  json.default = JSON.parse(JSON.stringify(def.defaultValue));
};
var prefaultProcessor = (schema, ctx, json, params) => {
  const def = schema._zod.def;
  process2(def.innerType, ctx, params);
  const seen = ctx.seen.get(schema);
  seen.ref = def.innerType;
  if (ctx.io === "input")
    json._prefault = JSON.parse(JSON.stringify(def.defaultValue));
};
var catchProcessor = (schema, ctx, json, params) => {
  const def = schema._zod.def;
  process2(def.innerType, ctx, params);
  const seen = ctx.seen.get(schema);
  seen.ref = def.innerType;
  let catchValue;
  try {
    catchValue = def.catchValue(void 0);
  } catch {
    throw new Error("Dynamic catch values are not supported in JSON Schema");
  }
  json.default = catchValue;
};
var pipeProcessor = (schema, ctx, _json, params) => {
  const def = schema._zod.def;
  const inIsTransform = def.in._zod.traits.has("$ZodTransform");
  const innerType = ctx.io === "input" ? inIsTransform ? def.out : def.in : def.out;
  process2(innerType, ctx, params);
  const seen = ctx.seen.get(schema);
  seen.ref = innerType;
};
var readonlyProcessor = (schema, ctx, json, params) => {
  const def = schema._zod.def;
  process2(def.innerType, ctx, params);
  const seen = ctx.seen.get(schema);
  seen.ref = def.innerType;
  json.readOnly = true;
};
var optionalProcessor = (schema, ctx, _json, params) => {
  const def = schema._zod.def;
  process2(def.innerType, ctx, params);
  const seen = ctx.seen.get(schema);
  seen.ref = def.innerType;
};

// node_modules/zod/v4/classic/iso.js
var ZodISODateTime = /* @__PURE__ */ $constructor("ZodISODateTime", (inst, def) => {
  $ZodISODateTime.init(inst, def);
  ZodStringFormat.init(inst, def);
});
function datetime2(params) {
  return _isoDateTime(ZodISODateTime, params);
}
var ZodISODate = /* @__PURE__ */ $constructor("ZodISODate", (inst, def) => {
  $ZodISODate.init(inst, def);
  ZodStringFormat.init(inst, def);
});
function date2(params) {
  return _isoDate(ZodISODate, params);
}
var ZodISOTime = /* @__PURE__ */ $constructor("ZodISOTime", (inst, def) => {
  $ZodISOTime.init(inst, def);
  ZodStringFormat.init(inst, def);
});
function time2(params) {
  return _isoTime(ZodISOTime, params);
}
var ZodISODuration = /* @__PURE__ */ $constructor("ZodISODuration", (inst, def) => {
  $ZodISODuration.init(inst, def);
  ZodStringFormat.init(inst, def);
});
function duration2(params) {
  return _isoDuration(ZodISODuration, params);
}

// node_modules/zod/v4/classic/errors.js
var initializer2 = (inst, issues) => {
  $ZodError.init(inst, issues);
  inst.name = "ZodError";
  Object.defineProperties(inst, {
    format: {
      value: (mapper) => formatError(inst, mapper)
      // enumerable: false,
    },
    flatten: {
      value: (mapper) => flattenError(inst, mapper)
      // enumerable: false,
    },
    addIssue: {
      value: (issue2) => {
        inst.issues.push(issue2);
        inst.message = JSON.stringify(inst.issues, jsonStringifyReplacer, 2);
      }
      // enumerable: false,
    },
    addIssues: {
      value: (issues2) => {
        inst.issues.push(...issues2);
        inst.message = JSON.stringify(inst.issues, jsonStringifyReplacer, 2);
      }
      // enumerable: false,
    },
    isEmpty: {
      get() {
        return inst.issues.length === 0;
      }
      // enumerable: false,
    }
  });
};
var ZodRealError = /* @__PURE__ */ $constructor("ZodError", initializer2, {
  Parent: Error
});

// node_modules/zod/v4/classic/parse.js
var parse2 = /* @__PURE__ */ _parse(ZodRealError);
var parseAsync2 = /* @__PURE__ */ _parseAsync(ZodRealError);
var safeParse2 = /* @__PURE__ */ _safeParse(ZodRealError);
var safeParseAsync2 = /* @__PURE__ */ _safeParseAsync(ZodRealError);
var encode = /* @__PURE__ */ _encode(ZodRealError);
var decode = /* @__PURE__ */ _decode(ZodRealError);
var encodeAsync = /* @__PURE__ */ _encodeAsync(ZodRealError);
var decodeAsync = /* @__PURE__ */ _decodeAsync(ZodRealError);
var safeEncode = /* @__PURE__ */ _safeEncode(ZodRealError);
var safeDecode = /* @__PURE__ */ _safeDecode(ZodRealError);
var safeEncodeAsync = /* @__PURE__ */ _safeEncodeAsync(ZodRealError);
var safeDecodeAsync = /* @__PURE__ */ _safeDecodeAsync(ZodRealError);

// node_modules/zod/v4/classic/schemas.js
var _installedGroups = /* @__PURE__ */ new WeakMap();
function _installLazyMethods(inst, group, methods) {
  const proto = Object.getPrototypeOf(inst);
  let installed = _installedGroups.get(proto);
  if (!installed) {
    installed = /* @__PURE__ */ new Set();
    _installedGroups.set(proto, installed);
  }
  if (installed.has(group))
    return;
  installed.add(group);
  for (const key in methods) {
    const fn = methods[key];
    Object.defineProperty(proto, key, {
      configurable: true,
      enumerable: false,
      get() {
        const bound = fn.bind(this);
        Object.defineProperty(this, key, {
          configurable: true,
          writable: true,
          enumerable: true,
          value: bound
        });
        return bound;
      },
      set(v) {
        Object.defineProperty(this, key, {
          configurable: true,
          writable: true,
          enumerable: true,
          value: v
        });
      }
    });
  }
}
var ZodType = /* @__PURE__ */ $constructor("ZodType", (inst, def) => {
  $ZodType.init(inst, def);
  Object.assign(inst["~standard"], {
    jsonSchema: {
      input: createStandardJSONSchemaMethod(inst, "input"),
      output: createStandardJSONSchemaMethod(inst, "output")
    }
  });
  inst.toJSONSchema = createToJSONSchemaMethod(inst, {});
  inst.def = def;
  inst.type = def.type;
  Object.defineProperty(inst, "_def", { value: def });
  inst.parse = (data, params) => parse2(inst, data, params, { callee: inst.parse });
  inst.safeParse = (data, params) => safeParse2(inst, data, params);
  inst.parseAsync = async (data, params) => parseAsync2(inst, data, params, { callee: inst.parseAsync });
  inst.safeParseAsync = async (data, params) => safeParseAsync2(inst, data, params);
  inst.spa = inst.safeParseAsync;
  inst.encode = (data, params) => encode(inst, data, params);
  inst.decode = (data, params) => decode(inst, data, params);
  inst.encodeAsync = async (data, params) => encodeAsync(inst, data, params);
  inst.decodeAsync = async (data, params) => decodeAsync(inst, data, params);
  inst.safeEncode = (data, params) => safeEncode(inst, data, params);
  inst.safeDecode = (data, params) => safeDecode(inst, data, params);
  inst.safeEncodeAsync = async (data, params) => safeEncodeAsync(inst, data, params);
  inst.safeDecodeAsync = async (data, params) => safeDecodeAsync(inst, data, params);
  _installLazyMethods(inst, "ZodType", {
    check(...chks) {
      const def2 = this.def;
      return this.clone(util_exports.mergeDefs(def2, {
        checks: [
          ...def2.checks ?? [],
          ...chks.map((ch) => typeof ch === "function" ? { _zod: { check: ch, def: { check: "custom" }, onattach: [] } } : ch)
        ]
      }), { parent: true });
    },
    with(...chks) {
      return this.check(...chks);
    },
    clone(def2, params) {
      return clone(this, def2, params);
    },
    brand() {
      return this;
    },
    register(reg, meta2) {
      reg.add(this, meta2);
      return this;
    },
    refine(check, params) {
      return this.check(refine(check, params));
    },
    superRefine(refinement, params) {
      return this.check(superRefine(refinement, params));
    },
    overwrite(fn) {
      return this.check(_overwrite(fn));
    },
    optional() {
      return optional(this);
    },
    exactOptional() {
      return exactOptional(this);
    },
    nullable() {
      return nullable(this);
    },
    nullish() {
      return optional(nullable(this));
    },
    nonoptional(params) {
      return nonoptional(this, params);
    },
    array() {
      return array(this);
    },
    or(arg) {
      return union([this, arg]);
    },
    and(arg) {
      return intersection(this, arg);
    },
    transform(tx) {
      return pipe(this, transform(tx));
    },
    default(d) {
      return _default(this, d);
    },
    prefault(d) {
      return prefault(this, d);
    },
    catch(params) {
      return _catch(this, params);
    },
    pipe(target) {
      return pipe(this, target);
    },
    readonly() {
      return readonly(this);
    },
    describe(description) {
      const cl = this.clone();
      globalRegistry.add(cl, { description });
      return cl;
    },
    meta(...args) {
      if (args.length === 0)
        return globalRegistry.get(this);
      const cl = this.clone();
      globalRegistry.add(cl, args[0]);
      return cl;
    },
    isOptional() {
      return this.safeParse(void 0).success;
    },
    isNullable() {
      return this.safeParse(null).success;
    },
    apply(fn) {
      return fn(this);
    }
  });
  Object.defineProperty(inst, "description", {
    get() {
      return globalRegistry.get(inst)?.description;
    },
    configurable: true
  });
  return inst;
});
var _ZodString = /* @__PURE__ */ $constructor("_ZodString", (inst, def) => {
  $ZodString.init(inst, def);
  ZodType.init(inst, def);
  inst._zod.processJSONSchema = (ctx, json, params) => stringProcessor(inst, ctx, json, params);
  const bag = inst._zod.bag;
  inst.format = bag.format ?? null;
  inst.minLength = bag.minimum ?? null;
  inst.maxLength = bag.maximum ?? null;
  _installLazyMethods(inst, "_ZodString", {
    regex(...args) {
      return this.check(_regex(...args));
    },
    includes(...args) {
      return this.check(_includes(...args));
    },
    startsWith(...args) {
      return this.check(_startsWith(...args));
    },
    endsWith(...args) {
      return this.check(_endsWith(...args));
    },
    min(...args) {
      return this.check(_minLength(...args));
    },
    max(...args) {
      return this.check(_maxLength(...args));
    },
    length(...args) {
      return this.check(_length(...args));
    },
    nonempty(...args) {
      return this.check(_minLength(1, ...args));
    },
    lowercase(params) {
      return this.check(_lowercase(params));
    },
    uppercase(params) {
      return this.check(_uppercase(params));
    },
    trim() {
      return this.check(_trim());
    },
    normalize(...args) {
      return this.check(_normalize(...args));
    },
    toLowerCase() {
      return this.check(_toLowerCase());
    },
    toUpperCase() {
      return this.check(_toUpperCase());
    },
    slugify() {
      return this.check(_slugify());
    }
  });
});
var ZodString = /* @__PURE__ */ $constructor("ZodString", (inst, def) => {
  $ZodString.init(inst, def);
  _ZodString.init(inst, def);
  inst.email = (params) => inst.check(_email(ZodEmail, params));
  inst.url = (params) => inst.check(_url(ZodURL, params));
  inst.jwt = (params) => inst.check(_jwt(ZodJWT, params));
  inst.emoji = (params) => inst.check(_emoji2(ZodEmoji, params));
  inst.guid = (params) => inst.check(_guid(ZodGUID, params));
  inst.uuid = (params) => inst.check(_uuid(ZodUUID, params));
  inst.uuidv4 = (params) => inst.check(_uuidv4(ZodUUID, params));
  inst.uuidv6 = (params) => inst.check(_uuidv6(ZodUUID, params));
  inst.uuidv7 = (params) => inst.check(_uuidv7(ZodUUID, params));
  inst.nanoid = (params) => inst.check(_nanoid(ZodNanoID, params));
  inst.guid = (params) => inst.check(_guid(ZodGUID, params));
  inst.cuid = (params) => inst.check(_cuid(ZodCUID, params));
  inst.cuid2 = (params) => inst.check(_cuid2(ZodCUID2, params));
  inst.ulid = (params) => inst.check(_ulid(ZodULID, params));
  inst.base64 = (params) => inst.check(_base64(ZodBase64, params));
  inst.base64url = (params) => inst.check(_base64url(ZodBase64URL, params));
  inst.xid = (params) => inst.check(_xid(ZodXID, params));
  inst.ksuid = (params) => inst.check(_ksuid(ZodKSUID, params));
  inst.ipv4 = (params) => inst.check(_ipv4(ZodIPv4, params));
  inst.ipv6 = (params) => inst.check(_ipv6(ZodIPv6, params));
  inst.cidrv4 = (params) => inst.check(_cidrv4(ZodCIDRv4, params));
  inst.cidrv6 = (params) => inst.check(_cidrv6(ZodCIDRv6, params));
  inst.e164 = (params) => inst.check(_e164(ZodE164, params));
  inst.datetime = (params) => inst.check(datetime2(params));
  inst.date = (params) => inst.check(date2(params));
  inst.time = (params) => inst.check(time2(params));
  inst.duration = (params) => inst.check(duration2(params));
});
function string2(params) {
  return _string(ZodString, params);
}
var ZodStringFormat = /* @__PURE__ */ $constructor("ZodStringFormat", (inst, def) => {
  $ZodStringFormat.init(inst, def);
  _ZodString.init(inst, def);
});
var ZodEmail = /* @__PURE__ */ $constructor("ZodEmail", (inst, def) => {
  $ZodEmail.init(inst, def);
  ZodStringFormat.init(inst, def);
});
var ZodGUID = /* @__PURE__ */ $constructor("ZodGUID", (inst, def) => {
  $ZodGUID.init(inst, def);
  ZodStringFormat.init(inst, def);
});
var ZodUUID = /* @__PURE__ */ $constructor("ZodUUID", (inst, def) => {
  $ZodUUID.init(inst, def);
  ZodStringFormat.init(inst, def);
});
var ZodURL = /* @__PURE__ */ $constructor("ZodURL", (inst, def) => {
  $ZodURL.init(inst, def);
  ZodStringFormat.init(inst, def);
});
var ZodEmoji = /* @__PURE__ */ $constructor("ZodEmoji", (inst, def) => {
  $ZodEmoji.init(inst, def);
  ZodStringFormat.init(inst, def);
});
var ZodNanoID = /* @__PURE__ */ $constructor("ZodNanoID", (inst, def) => {
  $ZodNanoID.init(inst, def);
  ZodStringFormat.init(inst, def);
});
var ZodCUID = /* @__PURE__ */ $constructor("ZodCUID", (inst, def) => {
  $ZodCUID.init(inst, def);
  ZodStringFormat.init(inst, def);
});
var ZodCUID2 = /* @__PURE__ */ $constructor("ZodCUID2", (inst, def) => {
  $ZodCUID2.init(inst, def);
  ZodStringFormat.init(inst, def);
});
var ZodULID = /* @__PURE__ */ $constructor("ZodULID", (inst, def) => {
  $ZodULID.init(inst, def);
  ZodStringFormat.init(inst, def);
});
var ZodXID = /* @__PURE__ */ $constructor("ZodXID", (inst, def) => {
  $ZodXID.init(inst, def);
  ZodStringFormat.init(inst, def);
});
var ZodKSUID = /* @__PURE__ */ $constructor("ZodKSUID", (inst, def) => {
  $ZodKSUID.init(inst, def);
  ZodStringFormat.init(inst, def);
});
var ZodIPv4 = /* @__PURE__ */ $constructor("ZodIPv4", (inst, def) => {
  $ZodIPv4.init(inst, def);
  ZodStringFormat.init(inst, def);
});
var ZodIPv6 = /* @__PURE__ */ $constructor("ZodIPv6", (inst, def) => {
  $ZodIPv6.init(inst, def);
  ZodStringFormat.init(inst, def);
});
var ZodCIDRv4 = /* @__PURE__ */ $constructor("ZodCIDRv4", (inst, def) => {
  $ZodCIDRv4.init(inst, def);
  ZodStringFormat.init(inst, def);
});
var ZodCIDRv6 = /* @__PURE__ */ $constructor("ZodCIDRv6", (inst, def) => {
  $ZodCIDRv6.init(inst, def);
  ZodStringFormat.init(inst, def);
});
var ZodBase64 = /* @__PURE__ */ $constructor("ZodBase64", (inst, def) => {
  $ZodBase64.init(inst, def);
  ZodStringFormat.init(inst, def);
});
var ZodBase64URL = /* @__PURE__ */ $constructor("ZodBase64URL", (inst, def) => {
  $ZodBase64URL.init(inst, def);
  ZodStringFormat.init(inst, def);
});
var ZodE164 = /* @__PURE__ */ $constructor("ZodE164", (inst, def) => {
  $ZodE164.init(inst, def);
  ZodStringFormat.init(inst, def);
});
var ZodJWT = /* @__PURE__ */ $constructor("ZodJWT", (inst, def) => {
  $ZodJWT.init(inst, def);
  ZodStringFormat.init(inst, def);
});
var ZodNumber = /* @__PURE__ */ $constructor("ZodNumber", (inst, def) => {
  $ZodNumber.init(inst, def);
  ZodType.init(inst, def);
  inst._zod.processJSONSchema = (ctx, json, params) => numberProcessor(inst, ctx, json, params);
  _installLazyMethods(inst, "ZodNumber", {
    gt(value, params) {
      return this.check(_gt(value, params));
    },
    gte(value, params) {
      return this.check(_gte(value, params));
    },
    min(value, params) {
      return this.check(_gte(value, params));
    },
    lt(value, params) {
      return this.check(_lt(value, params));
    },
    lte(value, params) {
      return this.check(_lte(value, params));
    },
    max(value, params) {
      return this.check(_lte(value, params));
    },
    int(params) {
      return this.check(int(params));
    },
    safe(params) {
      return this.check(int(params));
    },
    positive(params) {
      return this.check(_gt(0, params));
    },
    nonnegative(params) {
      return this.check(_gte(0, params));
    },
    negative(params) {
      return this.check(_lt(0, params));
    },
    nonpositive(params) {
      return this.check(_lte(0, params));
    },
    multipleOf(value, params) {
      return this.check(_multipleOf(value, params));
    },
    step(value, params) {
      return this.check(_multipleOf(value, params));
    },
    finite() {
      return this;
    }
  });
  const bag = inst._zod.bag;
  inst.minValue = Math.max(bag.minimum ?? Number.NEGATIVE_INFINITY, bag.exclusiveMinimum ?? Number.NEGATIVE_INFINITY) ?? null;
  inst.maxValue = Math.min(bag.maximum ?? Number.POSITIVE_INFINITY, bag.exclusiveMaximum ?? Number.POSITIVE_INFINITY) ?? null;
  inst.isInt = (bag.format ?? "").includes("int") || Number.isSafeInteger(bag.multipleOf ?? 0.5);
  inst.isFinite = true;
  inst.format = bag.format ?? null;
});
function number2(params) {
  return _number(ZodNumber, params);
}
var ZodNumberFormat = /* @__PURE__ */ $constructor("ZodNumberFormat", (inst, def) => {
  $ZodNumberFormat.init(inst, def);
  ZodNumber.init(inst, def);
});
function int(params) {
  return _int(ZodNumberFormat, params);
}
var ZodBoolean = /* @__PURE__ */ $constructor("ZodBoolean", (inst, def) => {
  $ZodBoolean.init(inst, def);
  ZodType.init(inst, def);
  inst._zod.processJSONSchema = (ctx, json, params) => booleanProcessor(inst, ctx, json, params);
});
function boolean2(params) {
  return _boolean(ZodBoolean, params);
}
var ZodUnknown = /* @__PURE__ */ $constructor("ZodUnknown", (inst, def) => {
  $ZodUnknown.init(inst, def);
  ZodType.init(inst, def);
  inst._zod.processJSONSchema = (ctx, json, params) => unknownProcessor(inst, ctx, json, params);
});
function unknown() {
  return _unknown(ZodUnknown);
}
var ZodNever = /* @__PURE__ */ $constructor("ZodNever", (inst, def) => {
  $ZodNever.init(inst, def);
  ZodType.init(inst, def);
  inst._zod.processJSONSchema = (ctx, json, params) => neverProcessor(inst, ctx, json, params);
});
function never(params) {
  return _never(ZodNever, params);
}
var ZodArray = /* @__PURE__ */ $constructor("ZodArray", (inst, def) => {
  $ZodArray.init(inst, def);
  ZodType.init(inst, def);
  inst._zod.processJSONSchema = (ctx, json, params) => arrayProcessor(inst, ctx, json, params);
  inst.element = def.element;
  _installLazyMethods(inst, "ZodArray", {
    min(n, params) {
      return this.check(_minLength(n, params));
    },
    nonempty(params) {
      return this.check(_minLength(1, params));
    },
    max(n, params) {
      return this.check(_maxLength(n, params));
    },
    length(n, params) {
      return this.check(_length(n, params));
    },
    unwrap() {
      return this.element;
    }
  });
});
function array(element, params) {
  return _array(ZodArray, element, params);
}
var ZodObject = /* @__PURE__ */ $constructor("ZodObject", (inst, def) => {
  $ZodObjectJIT.init(inst, def);
  ZodType.init(inst, def);
  inst._zod.processJSONSchema = (ctx, json, params) => objectProcessor(inst, ctx, json, params);
  util_exports.defineLazy(inst, "shape", () => {
    return def.shape;
  });
  _installLazyMethods(inst, "ZodObject", {
    keyof() {
      return _enum(Object.keys(this._zod.def.shape));
    },
    catchall(catchall) {
      return this.clone({ ...this._zod.def, catchall });
    },
    passthrough() {
      return this.clone({ ...this._zod.def, catchall: unknown() });
    },
    loose() {
      return this.clone({ ...this._zod.def, catchall: unknown() });
    },
    strict() {
      return this.clone({ ...this._zod.def, catchall: never() });
    },
    strip() {
      return this.clone({ ...this._zod.def, catchall: void 0 });
    },
    extend(incoming) {
      return util_exports.extend(this, incoming);
    },
    safeExtend(incoming) {
      return util_exports.safeExtend(this, incoming);
    },
    merge(other) {
      return util_exports.merge(this, other);
    },
    pick(mask) {
      return util_exports.pick(this, mask);
    },
    omit(mask) {
      return util_exports.omit(this, mask);
    },
    partial(...args) {
      return util_exports.partial(ZodOptional, this, args[0]);
    },
    required(...args) {
      return util_exports.required(ZodNonOptional, this, args[0]);
    }
  });
});
function object(shape, params) {
  const def = {
    type: "object",
    shape: shape ?? {},
    ...util_exports.normalizeParams(params)
  };
  return new ZodObject(def);
}
var ZodUnion = /* @__PURE__ */ $constructor("ZodUnion", (inst, def) => {
  $ZodUnion.init(inst, def);
  ZodType.init(inst, def);
  inst._zod.processJSONSchema = (ctx, json, params) => unionProcessor(inst, ctx, json, params);
  inst.options = def.options;
});
function union(options, params) {
  return new ZodUnion({
    type: "union",
    options,
    ...util_exports.normalizeParams(params)
  });
}
var ZodIntersection = /* @__PURE__ */ $constructor("ZodIntersection", (inst, def) => {
  $ZodIntersection.init(inst, def);
  ZodType.init(inst, def);
  inst._zod.processJSONSchema = (ctx, json, params) => intersectionProcessor(inst, ctx, json, params);
});
function intersection(left, right) {
  return new ZodIntersection({
    type: "intersection",
    left,
    right
  });
}
var ZodRecord = /* @__PURE__ */ $constructor("ZodRecord", (inst, def) => {
  $ZodRecord.init(inst, def);
  ZodType.init(inst, def);
  inst._zod.processJSONSchema = (ctx, json, params) => recordProcessor(inst, ctx, json, params);
  inst.keyType = def.keyType;
  inst.valueType = def.valueType;
});
function record(keyType, valueType, params) {
  if (!valueType || !valueType._zod) {
    return new ZodRecord({
      type: "record",
      keyType: string2(),
      valueType: keyType,
      ...util_exports.normalizeParams(valueType)
    });
  }
  return new ZodRecord({
    type: "record",
    keyType,
    valueType,
    ...util_exports.normalizeParams(params)
  });
}
var ZodEnum = /* @__PURE__ */ $constructor("ZodEnum", (inst, def) => {
  $ZodEnum.init(inst, def);
  ZodType.init(inst, def);
  inst._zod.processJSONSchema = (ctx, json, params) => enumProcessor(inst, ctx, json, params);
  inst.enum = def.entries;
  inst.options = Object.values(def.entries);
  const keys = new Set(Object.keys(def.entries));
  inst.extract = (values, params) => {
    const newEntries = {};
    for (const value of values) {
      if (keys.has(value)) {
        newEntries[value] = def.entries[value];
      } else
        throw new Error(`Key ${value} not found in enum`);
    }
    return new ZodEnum({
      ...def,
      checks: [],
      ...util_exports.normalizeParams(params),
      entries: newEntries
    });
  };
  inst.exclude = (values, params) => {
    const newEntries = { ...def.entries };
    for (const value of values) {
      if (keys.has(value)) {
        delete newEntries[value];
      } else
        throw new Error(`Key ${value} not found in enum`);
    }
    return new ZodEnum({
      ...def,
      checks: [],
      ...util_exports.normalizeParams(params),
      entries: newEntries
    });
  };
});
function _enum(values, params) {
  const entries = Array.isArray(values) ? Object.fromEntries(values.map((v) => [v, v])) : values;
  return new ZodEnum({
    type: "enum",
    entries,
    ...util_exports.normalizeParams(params)
  });
}
var ZodTransform = /* @__PURE__ */ $constructor("ZodTransform", (inst, def) => {
  $ZodTransform.init(inst, def);
  ZodType.init(inst, def);
  inst._zod.processJSONSchema = (ctx, json, params) => transformProcessor(inst, ctx, json, params);
  inst._zod.parse = (payload, _ctx) => {
    if (_ctx.direction === "backward") {
      throw new $ZodEncodeError(inst.constructor.name);
    }
    payload.addIssue = (issue2) => {
      if (typeof issue2 === "string") {
        payload.issues.push(util_exports.issue(issue2, payload.value, def));
      } else {
        const _issue = issue2;
        if (_issue.fatal)
          _issue.continue = false;
        _issue.code ?? (_issue.code = "custom");
        _issue.input ?? (_issue.input = payload.value);
        _issue.inst ?? (_issue.inst = inst);
        payload.issues.push(util_exports.issue(_issue));
      }
    };
    const output = def.transform(payload.value, payload);
    if (output instanceof Promise) {
      return output.then((output2) => {
        payload.value = output2;
        payload.fallback = true;
        return payload;
      });
    }
    payload.value = output;
    payload.fallback = true;
    return payload;
  };
});
function transform(fn) {
  return new ZodTransform({
    type: "transform",
    transform: fn
  });
}
var ZodOptional = /* @__PURE__ */ $constructor("ZodOptional", (inst, def) => {
  $ZodOptional.init(inst, def);
  ZodType.init(inst, def);
  inst._zod.processJSONSchema = (ctx, json, params) => optionalProcessor(inst, ctx, json, params);
  inst.unwrap = () => inst._zod.def.innerType;
});
function optional(innerType) {
  return new ZodOptional({
    type: "optional",
    innerType
  });
}
var ZodExactOptional = /* @__PURE__ */ $constructor("ZodExactOptional", (inst, def) => {
  $ZodExactOptional.init(inst, def);
  ZodType.init(inst, def);
  inst._zod.processJSONSchema = (ctx, json, params) => optionalProcessor(inst, ctx, json, params);
  inst.unwrap = () => inst._zod.def.innerType;
});
function exactOptional(innerType) {
  return new ZodExactOptional({
    type: "optional",
    innerType
  });
}
var ZodNullable = /* @__PURE__ */ $constructor("ZodNullable", (inst, def) => {
  $ZodNullable.init(inst, def);
  ZodType.init(inst, def);
  inst._zod.processJSONSchema = (ctx, json, params) => nullableProcessor(inst, ctx, json, params);
  inst.unwrap = () => inst._zod.def.innerType;
});
function nullable(innerType) {
  return new ZodNullable({
    type: "nullable",
    innerType
  });
}
var ZodDefault = /* @__PURE__ */ $constructor("ZodDefault", (inst, def) => {
  $ZodDefault.init(inst, def);
  ZodType.init(inst, def);
  inst._zod.processJSONSchema = (ctx, json, params) => defaultProcessor(inst, ctx, json, params);
  inst.unwrap = () => inst._zod.def.innerType;
  inst.removeDefault = inst.unwrap;
});
function _default(innerType, defaultValue) {
  return new ZodDefault({
    type: "default",
    innerType,
    get defaultValue() {
      return typeof defaultValue === "function" ? defaultValue() : util_exports.shallowClone(defaultValue);
    }
  });
}
var ZodPrefault = /* @__PURE__ */ $constructor("ZodPrefault", (inst, def) => {
  $ZodPrefault.init(inst, def);
  ZodType.init(inst, def);
  inst._zod.processJSONSchema = (ctx, json, params) => prefaultProcessor(inst, ctx, json, params);
  inst.unwrap = () => inst._zod.def.innerType;
});
function prefault(innerType, defaultValue) {
  return new ZodPrefault({
    type: "prefault",
    innerType,
    get defaultValue() {
      return typeof defaultValue === "function" ? defaultValue() : util_exports.shallowClone(defaultValue);
    }
  });
}
var ZodNonOptional = /* @__PURE__ */ $constructor("ZodNonOptional", (inst, def) => {
  $ZodNonOptional.init(inst, def);
  ZodType.init(inst, def);
  inst._zod.processJSONSchema = (ctx, json, params) => nonoptionalProcessor(inst, ctx, json, params);
  inst.unwrap = () => inst._zod.def.innerType;
});
function nonoptional(innerType, params) {
  return new ZodNonOptional({
    type: "nonoptional",
    innerType,
    ...util_exports.normalizeParams(params)
  });
}
var ZodCatch = /* @__PURE__ */ $constructor("ZodCatch", (inst, def) => {
  $ZodCatch.init(inst, def);
  ZodType.init(inst, def);
  inst._zod.processJSONSchema = (ctx, json, params) => catchProcessor(inst, ctx, json, params);
  inst.unwrap = () => inst._zod.def.innerType;
  inst.removeCatch = inst.unwrap;
});
function _catch(innerType, catchValue) {
  return new ZodCatch({
    type: "catch",
    innerType,
    catchValue: typeof catchValue === "function" ? catchValue : () => catchValue
  });
}
var ZodPipe = /* @__PURE__ */ $constructor("ZodPipe", (inst, def) => {
  $ZodPipe.init(inst, def);
  ZodType.init(inst, def);
  inst._zod.processJSONSchema = (ctx, json, params) => pipeProcessor(inst, ctx, json, params);
  inst.in = def.in;
  inst.out = def.out;
});
function pipe(in_, out) {
  return new ZodPipe({
    type: "pipe",
    in: in_,
    out
    // ...util.normalizeParams(params),
  });
}
var ZodReadonly = /* @__PURE__ */ $constructor("ZodReadonly", (inst, def) => {
  $ZodReadonly.init(inst, def);
  ZodType.init(inst, def);
  inst._zod.processJSONSchema = (ctx, json, params) => readonlyProcessor(inst, ctx, json, params);
  inst.unwrap = () => inst._zod.def.innerType;
});
function readonly(innerType) {
  return new ZodReadonly({
    type: "readonly",
    innerType
  });
}
var ZodCustom = /* @__PURE__ */ $constructor("ZodCustom", (inst, def) => {
  $ZodCustom.init(inst, def);
  ZodType.init(inst, def);
  inst._zod.processJSONSchema = (ctx, json, params) => customProcessor(inst, ctx, json, params);
});
function refine(fn, _params = {}) {
  return _refine(ZodCustom, fn, _params);
}
function superRefine(fn, params) {
  return _superRefine(fn, params);
}

// src/issue-triage/policy.ts
var triagePolicySchema = object({
  version: number2().int().positive(),
  duplicateConfidenceThreshold: number2().min(0).max(1),
  classificationConfidenceThreshold: number2().min(0).max(1),
  priorityConfidenceThreshold: number2().min(0).max(1),
  maxCandidates: number2().int().min(0).max(100),
  maxRelatedIssues: number2().int().min(0).max(20),
  skipLabels: array(string2().min(1)),
  managedLabelPrefixes: array(string2().min(1)),
  classificationLabels: object({
    bug: string2().min(1),
    enhancement: string2().min(1),
    documentation: string2().min(1),
    question: string2().min(1)
  }),
  labelColors: record(string2(), string2().regex(/^[0-9a-fA-F]{6}$/)),
  labelDescriptions: record(string2(), string2().min(1).max(100))
});
function calculatePriority(analysis, policy) {
  const { facts } = analysis;
  if (facts.securityImpact === "critical" || facts.dataLoss === true || facts.environment === "production" && facts.productionImpact === "outage") {
    return "P0";
  }
  if (facts.securityImpact === "high" || facts.releaseBlocker === true || facts.environment === "production" && facts.coreFlowBlocked === true && facts.workaround === "none") {
    return "P1";
  }
  if (analysis.priorityConfidence < policy.priorityConfidenceThreshold) {
    return "pending";
  }
  const lacksImpactEvidence = facts.productionImpact === "unknown" && facts.affectedScope === "unknown" && facts.slaRisk === null && facts.releaseBlocker === null;
  if (lacksImpactEvidence) {
    return "pending";
  }
  if (facts.productionImpact === "degraded" || facts.affectedScope === "many" || facts.affectedScope === "all" || facts.slaRisk === true || facts.coreFlowBlocked === true) {
    return "P2";
  }
  return "P3";
}
function makeDecision(analysis, candidates, policy, existingLabels = []) {
  const candidateNumbers = new Set(
    candidates.map((candidate) => candidate.number)
  );
  const duplicate = analysis.duplicate;
  const duplicateIssueNumber = duplicate.issueNumber !== null && duplicate.confidence >= policy.duplicateConfidenceThreshold && candidateNumbers.has(duplicate.issueNumber) ? duplicate.issueNumber : null;
  const relatedIssues = analysis.relatedIssues.filter(
    (related) => candidateNumbers.has(related.issueNumber) && related.issueNumber !== duplicateIssueNumber
  ).filter(
    (related, index, all) => all.findIndex(
      (candidate) => candidate.issueNumber === related.issueNumber
    ) === index
  ).slice(0, policy.maxRelatedIssues);
  const priority = calculatePriority(analysis, policy);
  const classification = resolveClassification(
    analysis,
    existingLabels,
    policy
  );
  const labels = [
    `priority:${priority}`,
    analysis.missingInformation.length > 0 ? "triage:needs-info" : "triage:done"
  ];
  if (classification.source === "analysis" && classification.label) {
    labels.push(classification.label);
  }
  if (duplicateIssueNumber !== null) {
    labels.push("duplicate");
  }
  return {
    analysis,
    classification,
    priority,
    labels: [...new Set(labels)],
    duplicateIssueNumber,
    relatedIssues
  };
}
function resolveClassification(analysis, existingLabels, policy) {
  const configuredLabels = Object.values(policy.classificationLabels);
  const normalizedConfigured = new Map(
    configuredLabels.map((label) => [label.trim().toLowerCase(), label])
  );
  const existingClassificationLabels = [
    ...new Set(
      existingLabels.map((label) => normalizedConfigured.get(label.trim().toLowerCase())).filter((label) => Boolean(label))
    )
  ];
  if (existingClassificationLabels.length === 1) {
    return { label: existingClassificationLabels[0], source: "existing" };
  }
  if (existingClassificationLabels.length > 1) {
    return { label: null, source: "conflict" };
  }
  if (analysis.issueType === "unknown" || analysis.classificationConfidence < policy.classificationConfidenceThreshold) {
    return { label: null, source: "unknown" };
  }
  return {
    label: policy.classificationLabels[analysis.issueType],
    source: "analysis"
  };
}
function mergeManagedLabels(existing, desired, managedPrefixes) {
  const preserved = existing.filter(
    (label) => !managedPrefixes.some((prefix) => label.startsWith(prefix))
  );
  return [.../* @__PURE__ */ new Set([...preserved, ...desired])];
}

// src/runtime/target-binding.ts
function assertBoundTarget(options) {
  const expectedRepository = options.expectedRepository?.trim() ?? "";
  const expectedTargetText = options.expectedTarget?.trim() ?? "";
  if (!expectedRepository && !expectedTargetText) {
    if (options.apply) throw new Error(options.errors.missing);
    return;
  }
  if (!expectedRepository || !expectedTargetText) {
    throw new Error(options.errors.incomplete);
  }
  const expectedTarget = Number(expectedTargetText);
  if (!isRepositorySlug(expectedRepository) || !Number.isSafeInteger(expectedTarget) || expectedTarget <= 0) {
    throw new Error(options.errors.invalid);
  }
  if (options.repository !== expectedRepository || options.targetNumber !== expectedTarget) {
    throw new Error(
      options.errors.mismatch(expectedRepository, expectedTarget)
    );
  }
}

// src/issue-triage/target.ts
function assertBoundIssueTarget(repository, issueNumber, apply, environment) {
  assertBoundTarget({
    repository,
    targetNumber: issueNumber,
    apply,
    expectedRepository: environment.ISSUE_TRIAGE_EXPECTED_REPOSITORY,
    expectedTarget: environment.ISSUE_TRIAGE_EXPECTED_ISSUE,
    errors: {
      missing: "apply mode requires a scheduler-bound Issue target; set ISSUE_TRIAGE_EXPECTED_REPOSITORY and ISSUE_TRIAGE_EXPECTED_ISSUE",
      incomplete: "incomplete scheduler-bound Issue target",
      invalid: "invalid scheduler-bound Issue target",
      mismatch: (expectedRepository, expectedIssueNumber) => `requested Issue ${repository}#${issueNumber} does not match scheduler-bound target ${expectedRepository}#${expectedIssueNumber}`
    }
  });
}

// src/issues/fingerprint.ts
import crypto from "node:crypto";
var ISSUE_FINGERPRINT_PATTERN = /^[0-9a-f]{20}$/;
function issueFingerprint(issue2, comments = []) {
  return crypto.createHash("sha256").update(
    JSON.stringify({
      title: issue2.title.trim(),
      body: issue2.body ?? "",
      comments: comments.map((comment) => ({
        id: comment.id,
        body: comment.body,
        author: comment.user?.login ?? ""
      }))
    })
  ).digest("hex").slice(0, 20);
}

// src/issues/managed-comments.ts
var ISSUE_TRIAGE_COMMENT_PREFIX = "<!-- engineering-agent-workflows:issue-triage:v1";
function isIssueTriageComment(body) {
  return body.startsWith(ISSUE_TRIAGE_COMMENT_PREFIX);
}

// src/issue-triage/comment.ts
var COMMENT_MARKER_PREFIX = ISSUE_TRIAGE_COMMENT_PREFIX;
function commentMarker(issueNumber, fingerprint) {
  return `${COMMENT_MARKER_PREFIX} issue=${issueNumber} fingerprint=${fingerprint} -->`;
}
function buildTriageComment(issueNumber, fingerprint, decision) {
  const analysis = decision.analysis;
  const lines = [
    commentMarker(issueNumber, fingerprint),
    "## Issue triage",
    "",
    "### Classification",
    "",
    `- Type: \`${classificationText(decision)}\``,
    `- Priority: \`${decision.priority}\``,
    `- Priority basis: ${analysis.priorityReason}`
  ];
  if (decision.duplicateIssueNumber !== null) {
    lines.push(
      "",
      "### Possible duplicate",
      "",
      `- #${decision.duplicateIssueNumber}: ${analysis.duplicate.reason}`
    );
  }
  if (decision.relatedIssues.length > 0) {
    lines.push("", "### Related issues", "");
    for (const related of decision.relatedIssues) {
      lines.push(`- #${related.issueNumber}: ${related.reason}`);
    }
  }
  if (analysis.missingInformation.length > 0) {
    lines.push("", "### Information needed", "");
    for (const missing of analysis.missingInformation) {
      lines.push(`- ${missing}`);
    }
  }
  lines.push(
    "",
    "### Maintainer next step",
    "",
    "- When this Issue is ready for implementation, a maintainer can add the `agent:ready` label. The Agent will open a Draft Pull Request and will not merge it automatically.",
    "- Add `skip-triage` to opt out of automated triage.",
    "",
    "_This is an automated initial assessment based on the Issue text and related candidates; no repository code was inspected._"
  );
  return lines.join("\n");
}
function classificationText(decision) {
  if (decision.classification.label) return decision.classification.label;
  return decision.classification.source === "conflict" ? "unresolved (conflicting existing labels)" : "unknown";
}

// src/issue-triage/schema.ts
var unknownBoolean = boolean2().nullable();
var triageAnalysisSchema = object({
  issueType: _enum([
    "bug",
    "enhancement",
    "documentation",
    "question",
    "unknown"
  ]),
  classificationConfidence: number2().min(0).max(1),
  priorityConfidence: number2().min(0).max(1),
  facts: object({
    environment: _enum(["production", "non-production", "unknown"]),
    productionImpact: _enum(["none", "degraded", "outage", "unknown"]),
    securityImpact: _enum(["none", "low", "high", "critical", "unknown"]),
    dataLoss: unknownBoolean,
    coreFlowBlocked: unknownBoolean,
    workaround: _enum(["available", "none", "unknown"]),
    affectedScope: _enum(["single", "limited", "many", "all", "unknown"]),
    slaRisk: unknownBoolean,
    releaseBlocker: unknownBoolean
  }),
  duplicate: object({
    issueNumber: number2().int().positive().nullable(),
    confidence: number2().min(0).max(1),
    reason: string2().max(2e3)
  }),
  relatedIssues: array(
    object({
      issueNumber: number2().int().positive(),
      reason: string2().min(1).max(1e3)
    })
  ).max(10),
  missingInformation: array(string2().min(1).max(1e3)).max(10),
  priorityReason: string2().min(1).max(2e3)
});
var triageSubmissionSchema = object({
  issueFingerprint: string2().regex(ISSUE_FINGERPRINT_PATTERN),
  analysis: triageAnalysisSchema
});

// src/issue-triage/tool.ts
async function prepareIssueTriage(repository, issueNumber, dependencies) {
  const issue2 = await dependencies.issues.getIssue(repository, issueNumber);
  if (hasSkipLabel(issue2.labels, dependencies.policy.skipLabels)) {
    return {
      ok: true,
      skipped: true,
      reason: "issue has a configured skip-triage label",
      repository,
      issueNumber,
      issueFingerprint: issueFingerprint(issue2)
    };
  }
  const comments = await dependencies.issues.listComments(
    repository,
    issueNumber
  );
  const contextComments = selectContextComments(
    comments,
    dependencies.botLogin
  );
  const fingerprint = issueFingerprint(issue2, contextComments);
  if (hasCurrentTriageComment(
    comments,
    issueNumber,
    fingerprint,
    dependencies.botLogin
  )) {
    return {
      ok: true,
      skipped: true,
      reason: "issue content already triaged",
      repository,
      issueNumber,
      issueFingerprint: fingerprint
    };
  }
  const { candidates, warnings } = await loadCandidates(
    dependencies.issues,
    repository,
    issue2,
    dependencies.policy.maxCandidates
  );
  return {
    ok: true,
    repository,
    issueNumber,
    issueFingerprint: fingerprint,
    issue: issue2,
    comments: contextComments,
    candidates,
    ...warnings.length > 0 ? { warnings } : {}
  };
}
async function applyIssueTriage(repository, issueNumber, submissionInput, apply, dependencies) {
  const submission = triageSubmissionSchema.parse(submissionInput);
  const issue2 = await dependencies.issues.getIssue(repository, issueNumber);
  if (hasSkipLabel(issue2.labels, dependencies.policy.skipLabels)) {
    return {
      ok: true,
      skipped: true,
      reason: "issue has a configured skip-triage label",
      repository,
      issueNumber,
      applied: false
    };
  }
  const botLogin = requiredBotLogin(apply, dependencies.botLogin);
  const comments = await dependencies.issues.listComments(
    repository,
    issueNumber
  );
  const contextComments = selectContextComments(comments, botLogin);
  const currentFingerprint = issueFingerprint(issue2, contextComments);
  if (currentFingerprint !== submission.issueFingerprint) {
    throw new Error(
      "issue changed after analysis; run the prepare command again before applying"
    );
  }
  if (hasCurrentTriageComment(comments, issueNumber, currentFingerprint, botLogin)) {
    return {
      ok: true,
      skipped: true,
      reason: "issue content already triaged",
      repository,
      issueNumber,
      applied: false
    };
  }
  const { candidates, warnings } = await loadCandidates(
    dependencies.issues,
    repository,
    issue2,
    dependencies.policy.maxCandidates
  );
  const decision = makeDecision(
    submission.analysis,
    candidates,
    dependencies.policy,
    issue2.labels
  );
  const proposedComment = buildTriageComment(
    issueNumber,
    currentFingerprint,
    decision
  );
  const desiredLabels = mergeManagedLabels(
    issue2.labels,
    decision.labels,
    dependencies.policy.managedLabelPrefixes
  );
  const existingLabels = issue2.labels;
  const labelsToAdd = desiredLabels.filter(
    (label) => !existingLabels.includes(label)
  );
  const labelsToRemove = existingLabels.filter(
    (label) => isManagedLabel(label, dependencies.policy.managedLabelPrefixes) && !desiredLabels.includes(label)
  );
  const existingComment = findTriageComment(comments, botLogin);
  if (!apply) {
    return {
      ok: true,
      repository,
      issueNumber,
      applied: false,
      commentAction: "dry-run",
      decision,
      proposedComment,
      ...warnings.length > 0 ? { warnings } : {}
    };
  }
  await ensureLabels(
    dependencies.issues,
    repository,
    decision.labels,
    dependencies.policy
  );
  await dependencies.issues.addLabels(repository, issueNumber, labelsToAdd);
  for (const label of labelsToRemove) {
    await dependencies.issues.removeLabel(repository, issueNumber, label);
  }
  let commentAction = "unchanged";
  if (!existingComment) {
    await dependencies.issues.createComment(
      repository,
      issueNumber,
      proposedComment
    );
    commentAction = "created";
  } else if (existingComment.body !== proposedComment) {
    await dependencies.issues.updateComment(
      repository,
      issueNumber,
      existingComment.id,
      proposedComment
    );
    commentAction = "updated";
  }
  return {
    ok: true,
    repository,
    issueNumber,
    applied: true,
    commentAction,
    decision,
    ...warnings.length > 0 ? { warnings } : {}
  };
}
async function loadCandidates(issues, repository, issue2, limit) {
  try {
    return {
      candidates: await issues.searchCandidates(repository, issue2, limit),
      warnings: []
    };
  } catch (error) {
    return {
      candidates: [],
      warnings: [
        `candidate search failed; duplicate claims will be rejected: ${errorMessage(error)}`
      ]
    };
  }
}
function hasCurrentTriageComment(comments, issueNumber, fingerprint, botLogin) {
  const marker = commentMarker(issueNumber, fingerprint);
  return comments.some(
    (comment) => isManagedTriageComment(comment, botLogin) && (comment.body === marker || comment.body.startsWith(`${marker}
`))
  );
}
function findTriageComment(comments, botLogin) {
  return comments.find(
    (comment) => isManagedTriageComment(comment, botLogin) && isIssueTriageComment(comment.body)
  );
}
function isManagedTriageComment(comment, botLogin) {
  const expectedLogin = botLogin?.trim().toLowerCase();
  return Boolean(
    expectedLogin && comment.user?.login.toLowerCase() === expectedLogin
  );
}
function selectContextComments(comments, botLogin) {
  return comments.filter(
    (comment) => !isManagedTriageComment(comment, botLogin) || !isIssueTriageComment(comment.body)
  ).sort((left, right) => left.id - right.id).slice(-50).map((comment) => ({
    ...comment,
    body: truncateText(comment.body, 4e3)
  }));
}
function requiredBotLogin(apply, botLogin) {
  const normalized = botLogin?.trim();
  if (apply && !normalized) {
    throw new Error("provider bot username is required in apply mode");
  }
  return normalized || void 0;
}
function isManagedLabel(label, managedPrefixes) {
  return managedPrefixes.some((prefix) => label.startsWith(prefix));
}
function hasSkipLabel(labels, skipLabels) {
  const normalizedSkipLabels = new Set(
    skipLabels.map((label) => label.trim().toLowerCase())
  );
  return labels.some(
    (label) => normalizedSkipLabels.has(label.trim().toLowerCase())
  );
}
async function ensureLabels(issues, repository, labels, policy) {
  for (const label of labels) {
    await issues.ensureLabel(
      repository,
      label,
      policy.labelColors[label] ?? "ededed",
      policy.labelDescriptions[label]
    );
  }
}

// src/issue-triage/main.ts
async function main() {
  const options = parseArguments(process.argv.slice(2));
  const policy = await loadPolicy();
  const apply = envBoolean(process.env.ISSUE_TRIAGE_APPLY);
  assertBoundIssueTarget(
    options.repository,
    options.issueNumber,
    apply,
    process.env
  );
  const token = await resolveGitHubToken(options.repository);
  const issues = new GitHubClient({
    ...token ? { token } : {},
    ...process.env.GITHUB_API_URL ? { baseUrl: process.env.GITHUB_API_URL } : {}
  });
  const dependencies = {
    issues,
    policy,
    ...process.env.GITHUB_BOT_LOGIN ? { botLogin: process.env.GITHUB_BOT_LOGIN } : {}
  };
  const result = options.command === "prepare" ? await prepareIssueTriage(
    options.repository,
    options.issueNumber,
    dependencies
  ) : await applyIssueTriage(
    options.repository,
    options.issueNumber,
    JSON.parse(await readFile2(options.analysisFile, "utf8")),
    apply,
    dependencies
  );
  process.stdout.write(`${JSON.stringify(result, null, 2)}
`);
}
async function loadPolicy() {
  const embedded = process.env.WORKFLOW_POLICY_JSON?.trim();
  if (embedded) {
    try {
      return triagePolicySchema.parse(JSON.parse(embedded));
    } catch (error) {
      throw new Error(
        `failed to load embedded triage policy: ${errorMessage(error)}`
      );
    }
  }
  return loadJsonFromCandidates(
    [
      fileURLToPath(new URL("../policy.json", import.meta.url)),
      path.resolve("agents/issue-triage/policy.json")
    ],
    (value) => triagePolicySchema.parse(value),
    "failed to load issue triage policy"
  );
}
function parseArguments(args) {
  const command = args.shift();
  if (command !== "prepare" && command !== "apply") {
    throw new Error("first argument must be prepare or apply");
  }
  let repository = "";
  let issueNumber = 0;
  let analysisFile = "";
  for (let index = 0; index < args.length; index += 1) {
    const argument = args[index];
    if (argument === "--repository") {
      repository = requiredArgumentValue(args, ++index, argument);
    } else if (argument === "--issue") {
      const raw = requiredArgumentValue(args, ++index, argument);
      issueNumber = Number.parseInt(raw, 10);
      if (!Number.isSafeInteger(issueNumber) || issueNumber <= 0) {
        throw new Error("--issue must be a positive integer");
      }
    } else if (argument === "--analysis") {
      analysisFile = requiredArgumentValue(args, ++index, argument);
    } else {
      throw new Error(`unknown argument: ${argument}`);
    }
  }
  if (!isRepositorySlug(repository)) {
    throw new Error("--repository must use owner/repository format");
  }
  if (issueNumber <= 0) throw new Error("--issue is required");
  if (command === "apply" && !analysisFile) {
    throw new Error("--analysis is required for apply");
  }
  return {
    command,
    repository,
    issueNumber,
    ...analysisFile ? { analysisFile } : {}
  };
}
main().catch((error) => {
  process.stderr.write(`issue triage failed: ${errorMessage(error)}
`);
  process.exitCode = 1;
});
"; const WORKFLOW_POLICY_JSON = "{\"version\":1,\"duplicateConfidenceThreshold\":0.92,\"classificationConfidenceThreshold\":0.75,\"priorityConfidenceThreshold\":0.8,\"maxCandidates\":20,\"maxRelatedIssues\":5,\"skipLabels\":[\"skip-triage\"],\"managedLabelPrefixes\":[\"priority:\",\"triage:\"],\"classificationLabels\":{\"bug\":\"bug\",\"enhancement\":\"enhancement\",\"documentation\":\"documentation\",\"question\":\"question\"},\"labelColors\":{\"bug\":\"d73a4a\",\"documentation\":\"0075ca\",\"enhancement\":\"a2eeef\",\"question\":\"d876e3\",\"priority:P0\":\"b60205\",\"priority:P1\":\"d93f0b\",\"priority:P2\":\"fbca04\",\"priority:P3\":\"0e8a16\",\"priority:pending\":\"c5def5\",\"triage:done\":\"0e8a16\",\"triage:needs-info\":\"fbca04\",\"duplicate\":\"cfd3d7\"},\"labelDescriptions\":{\"bug\":\"Something isn't working\",\"documentation\":\"Improvements or additions to documentation\",\"enhancement\":\"New feature or request\",\"question\":\"Further information is requested\",\"priority:P0\":\"Automated triage: critical and immediate impact\",\"priority:P1\":\"Automated triage: high-priority impact\",\"priority:P2\":\"Automated triage: significant impact\",\"priority:P3\":\"Automated triage: supported low-impact work\",\"priority:pending\":\"Automated triage: priority needs more evidence\",\"triage:done\":\"Automated initial triage completed\",\"triage:needs-info\":\"Automated triage needs reporter information\",\"duplicate\":\"This issue or pull request already exists\"}}"; -const WORKFLOW_TOOL_CHUNK_SIZE = 60000; - -function workflowToolEnvironment() { - const env = {}; - for ( - let offset = 0, index = 0; - offset < WORKFLOW_TOOL_BASE64.length; - offset += WORKFLOW_TOOL_CHUNK_SIZE, index += 1 - ) { - env[`WORKFLOW_TOOL_CHUNK_${String(index).padStart(4, "0")}`] = - WORKFLOW_TOOL_BASE64.slice(offset, offset + WORKFLOW_TOOL_CHUNK_SIZE); - } - return env; -} +const WORKFLOW_TOOL_PATH = + "$WORKSPACE/workflow-repo/agents/issue-triage/tool/main.mjs"; const ANALYSIS_SCHEMA = { type: "object", @@ -119,9 +106,7 @@ function runTool(command, repository, issueNumber, submission, senderLogin) { const result = scheduler.shell( [ "set -eu", - 'workflow_tool_dir="$(mktemp -d)"', - 'workflow_tool="$workflow_tool_dir/issue-triage.mjs"', - 'node -e \'const fs=require("node:fs"); const source=Object.keys(process.env).filter((key)=>key.startsWith("WORKFLOW_TOOL_CHUNK_")).sort().map((key)=>process.env[key]).join(""); fs.writeFileSync(process.argv[1], Buffer.from(source, "base64"))\' "$workflow_tool"', + `workflow_tool="${WORKFLOW_TOOL_PATH}"`, 'sender_login=$(printf "%s" "$TRIAGE_SENDER_LOGIN" | tr "[:upper:]" "[:lower:]")', 'bot_login=$(printf "%s" "${GITHUB_BOT_LOGIN:-}" | tr "[:upper:]" "[:lower:]")', 'allowed_repository="${GITHUB_ALLOWED_REPOSITORY:-}"', @@ -147,7 +132,6 @@ function runTool(command, repository, issueNumber, submission, senderLogin) { TRIAGE_REPOSITORY: repository, TRIAGE_ISSUE: String(issueNumber), WORKFLOW_POLICY_JSON, - ...workflowToolEnvironment(), TRIAGE_SUBMISSION: submission ? JSON.stringify(submission) : "", TRIAGE_SENDER_LOGIN: senderLogin || "", }, diff --git a/agents/issue-triage/tool/main.mjs b/agents/issue-triage/tool/main.mjs new file mode 100644 index 0000000..365be08 --- /dev/null +++ b/agents/issue-triage/tool/main.mjs @@ -0,0 +1,6047 @@ +// Generated by scripts/build-tools.ts. Do not edit directly. +var __defProp = Object.defineProperty; +var __export = (target, all) => { + for (var name in all) + __defProp(target, name, { get: all[name], enumerable: true }); +}; + +// src/issue-triage/main.ts +import { readFile as readFile2 } from "node:fs/promises"; +import path from "node:path"; +import { fileURLToPath } from "node:url"; + +// src/github/app-auth.ts +import { sign } from "node:crypto"; + +// src/github/fetch-retry.ts +var MAX_ATTEMPTS = 3; +var RETRYABLE_STATUS_CODES = /* @__PURE__ */ new Set([502, 503, 504]); +async function fetchWithRetry(options) { + const attempts = options.retryable ? MAX_ATTEMPTS : 1; + let lastError; + for (let attempt = 1; attempt <= attempts; attempt += 1) { + try { + const response = await options.request(options.input, options.init); + if (attempt === attempts || !RETRYABLE_STATUS_CODES.has(response.status)) { + return response; + } + await response.body?.cancel().catch(() => void 0); + } catch (error) { + lastError = error; + if (attempt === attempts) { + throw new Error( + `${options.operation} transport failed after ${attemptLabel(attempts)}`, + { cause: error } + ); + } + } + await (options.sleep ?? sleep)(retryDelayMilliseconds(attempt)); + } + throw new Error(`${options.operation} transport failed`, { + cause: lastError + }); +} +function attemptLabel(attempts) { + return `${attempts} ${attempts === 1 ? "attempt" : "attempts"}`; +} +function retryDelayMilliseconds(attempt) { + const exponential = 250 * 2 ** (attempt - 1); + return exponential + Math.floor(Math.random() * exponential); +} +function sleep(milliseconds) { + return new Promise((resolve) => setTimeout(resolve, milliseconds)); +} + +// src/github/app-auth.ts +var DEFAULT_GITHUB_API_URL = "https://api.github.com"; +var GITHUB_API_VERSION = "2022-11-28"; +async function resolveGitHubToken(repository, env = process.env, dependencies = {}) { + const configuredToken = env.GITHUB_TOKEN?.trim() ?? ""; + if (configuredToken) return configuredToken; + const clientID = env.GITHUB_APP_CLIENT_ID?.trim() ?? ""; + const appID = env.GITHUB_APP_ID?.trim() ?? ""; + const privateKeyBase64 = env.GITHUB_APP_PRIVATE_KEY_BASE64?.trim() ?? ""; + const configuredInstallationID = env.GITHUB_APP_INSTALLATION_ID?.trim() ?? ""; + const hasAppConfiguration = Boolean( + clientID || appID || privateKeyBase64 || configuredInstallationID + ); + if (!hasAppConfiguration) return ""; + const issuer = clientID || appID; + if (!issuer) { + throw new Error( + "GitHub App authentication requires GITHUB_APP_CLIENT_ID or GITHUB_APP_ID" + ); + } + if (!privateKeyBase64) { + throw new Error( + "GitHub App authentication requires GITHUB_APP_PRIVATE_KEY_BASE64" + ); + } + const privateKey = decodePrivateKey(privateKeyBase64); + const jwt = createAppJWT( + issuer, + privateKey, + dependencies.now?.() ?? Date.now() + ); + const baseUrl = (env.GITHUB_API_URL?.trim() || DEFAULT_GITHUB_API_URL).replace(/\/+$/, ""); + const request = dependencies.fetch ?? fetch; + const installationID = configuredInstallationID ? validateInstallationID(configuredInstallationID) : await findInstallationID( + baseUrl, + repository, + jwt, + request, + dependencies.sleep + ); + const tokenPath = `/app/installations/${installationID}/access_tokens`; + const response = await fetchWithRetry({ + request, + input: `${baseUrl}${tokenPath}`, + init: { + method: "POST", + headers: appHeaders(jwt) + }, + operation: `GitHub App POST ${tokenPath}`, + retryable: true, + ...dependencies.sleep ? { sleep: dependencies.sleep } : {} + }); + if (!response.ok) { + throw githubAppResponseError("installation token request", response); + } + const value = await response.json(); + const token = value.token?.trim() ?? ""; + if (!token) { + throw new Error("GitHub App installation token response has no token"); + } + return token; +} +function createAppJWT(issuer, privateKey, nowMilliseconds) { + const now = Math.floor(nowMilliseconds / 1e3); + const header = encodeJWTPart({ alg: "RS256", typ: "JWT" }); + const payload = encodeJWTPart({ + iat: now - 60, + exp: now + 9 * 60, + iss: issuer + }); + const unsignedToken = `${header}.${payload}`; + let signature; + try { + signature = sign("RSA-SHA256", Buffer.from(unsignedToken), privateKey); + } catch { + throw new Error( + "GITHUB_APP_PRIVATE_KEY_BASE64 is not a valid RSA private key" + ); + } + return `${unsignedToken}.${signature.toString("base64url")}`; +} +async function findInstallationID(baseUrl, repository, jwt, request, sleepDependency) { + const path2 = `/repos/${repositoryPath(repository)}/installation`; + const response = await fetchWithRetry({ + request, + input: `${baseUrl}${path2}`, + init: { + method: "GET", + headers: appHeaders(jwt) + }, + operation: `GitHub App GET ${path2}`, + retryable: true, + ...sleepDependency ? { sleep: sleepDependency } : {} + }); + if (!response.ok) { + throw githubAppResponseError("installation lookup", response); + } + const value = await response.json(); + if (!Number.isSafeInteger(value.id) || (value.id ?? 0) <= 0) { + throw new Error("GitHub App installation response has no valid ID"); + } + return String(value.id); +} +function appHeaders(jwt) { + return { + Accept: "application/vnd.github+json", + Authorization: `Bearer ${jwt}`, + "X-GitHub-Api-Version": GITHUB_API_VERSION, + "User-Agent": "engineering-agent-workflows/github-app-auth" + }; +} +function decodePrivateKey(value) { + let decoded; + try { + decoded = Buffer.from(value, "base64").toString("utf8").trim(); + } catch { + throw new Error("GITHUB_APP_PRIVATE_KEY_BASE64 is not valid base64"); + } + if (!/^-----BEGIN (?:RSA )?PRIVATE KEY-----/.test(decoded)) { + throw new Error( + "GITHUB_APP_PRIVATE_KEY_BASE64 must decode to a PEM private key" + ); + } + return decoded; +} +function validateInstallationID(value) { + if (!/^[1-9][0-9]*$/.test(value)) { + throw new Error("GITHUB_APP_INSTALLATION_ID must be a positive integer"); + } + return value; +} +function repositoryPath(repository) { + const parts = repository.split("/"); + if (parts.length !== 2 || parts.some((part) => !part.trim())) { + throw new Error(`invalid GitHub repository: ${repository}`); + } + return parts.map(encodeURIComponent).join("/"); +} +function encodeJWTPart(value) { + return Buffer.from(JSON.stringify(value)).toString("base64url"); +} +function githubAppResponseError(operation, response) { + const status = `${response.status}${response.statusText ? ` ${response.statusText}` : ""}`; + return new Error(`GitHub App ${operation} failed with ${status}`); +} + +// src/issues/search.ts +function issueSearchText(title) { + return title.replace(/^\[[^\]]+\]\s*:?\s*/, "").replace(/["'`:+(){}[\]\\]/g, " ").replace(/\s+/g, " ").trim().slice(0, 120); +} + +// src/runtime/text.ts +function truncateText(value, max) { + return value.length <= max ? value : value.slice(0, max); +} + +// src/github/client.ts +var GitHubClient = class { + #token; + #baseUrl; + #fetch; + #sleep; + constructor(options = {}) { + this.#token = options.token?.trim() ?? ""; + this.#baseUrl = (options.baseUrl ?? "https://api.github.com").replace( + /\/+$/, + "" + ); + this.#fetch = options.fetch ?? fetch; + this.#sleep = options.sleep; + } + async getIssue(repository, issueNumber) { + const issue2 = await this.#request( + "GET", + `/repos/${repositoryPath2(repository)}/issues/${issueNumber}` + ); + if (issue2.pull_request) { + throw new Error("GitHub pull request payload is not an Issue"); + } + return normalizeIssue(issue2); + } + async searchCandidates(repository, issue2, limit) { + const title = issueSearchText(issue2.title); + if (!title) return []; + const query = new URLSearchParams({ + q: `repo:${repository} is:issue in:title ${title}`, + per_page: String(Math.min(Math.max(limit + 1, 1), 100)) + }); + const response = await this.#request( + "GET", + `/search/issues?${query.toString()}` + ); + return (response.items ?? []).filter( + (candidate) => candidate.number !== issue2.number && !candidate.pull_request + ).slice(0, limit).map((candidate) => ({ + number: candidate.number, + title: candidate.title, + body: truncateText(candidate.body ?? "", 4e3), + state: candidate.state, + labels: labelNames(candidate.labels), + url: candidate.html_url + })); + } + async listComments(repository, issueNumber) { + const comments = []; + for (let page = 1; ; page += 1) { + const batch = await this.#request( + "GET", + `/repos/${repositoryPath2(repository)}/issues/${issueNumber}/comments?per_page=100&page=${page}` + ); + comments.push(...batch.map(normalizeComment)); + if (batch.length < 100) return comments; + } + } + async ensureLabel(repository, name, color, description) { + const path2 = `/repos/${repositoryPath2(repository)}/labels/${encodeURIComponent(name)}`; + const response = await this.#rawRequest("GET", path2); + if (response.ok) return; + if (response.status !== 404) { + throw await responseError("GET", path2, response); + } + await this.#request("POST", `/repos/${repositoryPath2(repository)}/labels`, { + name, + color: normalizeColor(color), + description: description?.trim() || "Managed by engineering-agent-workflows" + }); + } + async getRepositoryDefaultBranch(repository) { + const value = await this.#request( + "GET", + `/repos/${repositoryPath2(repository)}` + ); + const branch = value.default_branch?.trim(); + if (!branch) throw new Error("GitHub repository has no default branch"); + return branch; + } + async getPullRequest(repository, pullRequestNumber) { + const value = await this.#request( + "GET", + `/repos/${repositoryPath2(repository)}/pulls/${pullRequestNumber}` + ); + return normalizePullRequest(value); + } + async listOpenPullRequests(repository) { + const values = []; + for (let page = 1; ; page += 1) { + const batch = await this.#request( + "GET", + `/repos/${repositoryPath2(repository)}/pulls?state=open&per_page=100&page=${page}` + ); + values.push(...batch.map(normalizePullRequest)); + if (batch.length < 100) return values; + } + } + async listReviewComments(repository, pullRequestNumber) { + const comments = []; + for (let page = 1; ; page += 1) { + const batch = await this.#request( + "GET", + `/repos/${repositoryPath2(repository)}/pulls/${pullRequestNumber}/comments?per_page=100&page=${page}` + ); + comments.push(...batch.map(normalizeReviewComment)); + if (batch.length < 100) return comments; + } + } + async getPullRequestReview(repository, pullRequestNumber, reviewId) { + const review = await this.#request( + "GET", + `/repos/${repositoryPath2(repository)}/pulls/${pullRequestNumber}/reviews/${reviewId}` + ); + return normalizePullRequestReview(review); + } + async listCheckRuns(repository, ref) { + if (!/^[0-9a-f]{40}$/.test(ref)) { + throw new Error("invalid GitHub check run ref"); + } + const runs = []; + for (let page = 1; ; page += 1) { + const value = await this.#request( + "GET", + `/repos/${repositoryPath2(repository)}/commits/${ref}/check-runs?per_page=100&page=${page}` + ); + const batch = value.check_runs ?? []; + runs.push(...batch.map(normalizeCheckRun)); + if (batch.length < 100) return runs; + } + } + async listCheckRunAnnotations(repository, checkRunId) { + if (!Number.isSafeInteger(checkRunId) || checkRunId <= 0) { + throw new Error("invalid GitHub check run ID"); + } + const annotations = []; + for (let page = 1; ; page += 1) { + const batch = await this.#request( + "GET", + `/repos/${repositoryPath2(repository)}/check-runs/${checkRunId}/annotations?per_page=100&page=${page}` + ); + annotations.push(...batch.map(normalizeCheckRunAnnotation)); + if (batch.length < 100) return annotations; + } + } + async listOpenPullRequestsByHead(repository, branch) { + const owner = repository.split("/")[0]; + const query = new URLSearchParams({ + state: "open", + head: `${owner}:${branch}`, + per_page: "100" + }); + const values = await this.#request( + "GET", + `/repos/${repositoryPath2(repository)}/pulls?${query.toString()}` + ); + return values.map(normalizePullRequest); + } + async createDraftPullRequest(repository, input) { + const value = await this.#request( + "POST", + `/repos/${repositoryPath2(repository)}/pulls`, + { ...input, draft: true } + ); + return normalizePullRequest(value); + } + async addLabels(repository, issueNumber, labels) { + if (labels.length === 0) return; + await this.#request( + "POST", + `/repos/${repositoryPath2(repository)}/issues/${issueNumber}/labels`, + { labels } + ); + } + async removeLabel(repository, issueNumber, label) { + const path2 = `/repos/${repositoryPath2(repository)}/issues/${issueNumber}/labels/${encodeURIComponent(label)}`; + const response = await this.#rawRequest("DELETE", path2); + if (!response.ok && response.status !== 404) { + throw await responseError("DELETE", path2, response); + } + } + async createComment(repository, issueNumber, body) { + const comment = await this.#request( + "POST", + `/repos/${repositoryPath2(repository)}/issues/${issueNumber}/comments`, + { body } + ); + return normalizeComment(comment); + } + async updateComment(repository, _issueNumber, commentID, body) { + const comment = await this.#request( + "PATCH", + `/repos/${repositoryPath2(repository)}/issues/comments/${commentID}`, + { body } + ); + return normalizeComment(comment); + } + async #request(method, path2, body) { + const response = await this.#rawRequest(method, path2, body); + if (!response.ok) throw await responseError(method, path2, response); + return await response.json(); + } + #rawRequest(method, path2, body) { + const headers = { + Accept: "application/vnd.github+json", + "X-GitHub-Api-Version": "2022-11-28", + "User-Agent": "engineering-agent-workflows/issue-triage" + }; + if (this.#token) headers.Authorization = `Bearer ${this.#token}`; + if (body !== void 0) headers["Content-Type"] = "application/json"; + return fetchWithRetry({ + request: this.#fetch, + input: `${this.#baseUrl}${path2}`, + init: { + method, + headers, + ...body === void 0 ? {} : { body: JSON.stringify(body) } + }, + operation: `GitHub API ${method} ${path2}`, + retryable: method === "GET", + ...this.#sleep ? { sleep: this.#sleep } : {} + }); + } +}; +function repositoryPath2(repository) { + const parts = repository.split("/"); + if (parts.length !== 2 || parts.some((part) => !part.trim())) { + throw new Error(`invalid GitHub repository: ${repository}`); + } + return parts.map(encodeURIComponent).join("/"); +} +function normalizeIssue(issue2) { + return { + number: issue2.number, + title: issue2.title, + body: issue2.body, + state: issue2.state, + htmlUrl: issue2.html_url, + updatedAt: issue2.updated_at, + labels: labelNames(issue2.labels), + ...issue2.user ? { user: normalizeUser(issue2.user) } : {} + }; +} +function normalizeComment(comment) { + return { + id: comment.id, + body: comment.body, + ...comment.html_url ? { htmlUrl: comment.html_url } : {}, + ...comment.created_at ? { createdAt: comment.created_at } : {}, + ...comment.user ? { user: normalizeUser(comment.user) } : {} + }; +} +function normalizePullRequest(value) { + return { + number: value.number, + url: value.html_url, + state: value.state, + draft: value.draft ?? false, + head: value.head.ref, + ...value.head.sha ? { headSha: value.head.sha } : {}, + ...value.head.repo?.full_name ? { headRepository: value.head.repo.full_name } : {}, + base: value.base.ref + }; +} +function normalizeReviewComment(comment) { + return { + id: comment.id, + body: comment.body, + path: comment.path, + ...comment.user ? { user: normalizeUser(comment.user) } : {}, + ...comment.html_url ? { htmlUrl: comment.html_url } : {}, + ...comment.created_at ? { createdAt: comment.created_at } : {}, + ...comment.line != null ? { line: comment.line } : {}, + ...comment.original_line != null ? { originalLine: comment.original_line } : {}, + ...comment.start_line != null ? { startLine: comment.start_line } : {}, + ...comment.original_start_line != null ? { originalStartLine: comment.original_start_line } : {}, + ...comment.side ? { side: comment.side } : {}, + ...comment.start_side ? { startSide: comment.start_side } : {}, + ...comment.diff_hunk ? { diffHunk: comment.diff_hunk } : {}, + ...comment.commit_id ? { commitId: comment.commit_id } : {}, + ...comment.original_commit_id ? { originalCommitId: comment.original_commit_id } : {}, + ...comment.in_reply_to_id !== void 0 ? { inReplyToId: comment.in_reply_to_id } : {}, + ...comment.pull_request_review_id !== void 0 ? { pullRequestReviewId: comment.pull_request_review_id } : {} + }; +} +function normalizePullRequestReview(review) { + return { + id: review.id, + body: review.body ?? "", + state: review.state, + commitId: review.commit_id, + authorAssociation: review.author_association, + ...review.user ? { user: normalizeUser(review.user) } : {}, + ...review.html_url ? { htmlUrl: review.html_url } : {}, + ...review.submitted_at ? { submittedAt: review.submitted_at } : {} + }; +} +function normalizeCheckRun(value) { + const checkSuiteId = value.check_suite?.id; + if (!Number.isSafeInteger(checkSuiteId) || checkSuiteId <= 0) { + throw new Error(`GitHub check run ${value.id} has no valid check suite ID`); + } + return { + id: value.id, + checkSuiteId, + name: truncateText(value.name ?? "", 300), + status: value.status, + ...value.conclusion ? { conclusion: value.conclusion } : {}, + ...value.html_url ? { htmlUrl: value.html_url } : {}, + output: { + title: truncateText(value.output?.title ?? "", 1e3), + summary: truncateText(value.output?.summary ?? "", 8e3), + text: truncateText(value.output?.text ?? "", 8e3) + } + }; +} +function normalizeCheckRunAnnotation(value) { + return { + path: truncateText(value.path ?? "", 1e3), + startLine: value.start_line, + endLine: value.end_line, + level: truncateText(value.annotation_level ?? "", 50), + message: truncateText(value.message ?? "", 2e3), + ...value.title ? { title: truncateText(value.title, 500) } : {}, + ...value.raw_details ? { rawDetails: truncateText(value.raw_details, 4e3) } : {} + }; +} +function normalizeUser(user) { + return { + login: user.login, + ...user.id !== void 0 ? { id: user.id } : {}, + ...user.type ? { type: user.type } : {} + }; +} +function labelNames(labels) { + return labels.map((label) => typeof label === "string" ? label : label.name).filter((label) => label.trim() !== ""); +} +function normalizeColor(color) { + const normalized = color.trim().replace(/^#/, ""); + return /^[0-9a-f]{6}$/i.test(normalized) ? normalized : "ededed"; +} +async function responseError(method, path2, response) { + const text = await response.text().catch(() => ""); + return new Error( + `GitHub API ${method} ${path2} failed with HTTP ${response.status}: ${truncateText(text, 1e3)}` + ); +} + +// src/issues/types.ts +function isRepositorySlug(value) { + return /^[^/\s]+\/[^/\s]+$/.test(value); +} + +// src/runtime/cli.ts +function requiredArgumentValue(args, index, name) { + const value = args[index]?.trim(); + if (!value) throw new Error(`${name} requires a value`); + return value; +} +function envBoolean(value) { + return ["1", "true", "yes", "on"].includes(value?.trim().toLowerCase() ?? ""); +} + +// src/runtime/errors.ts +function errorMessage(error) { + return describeError(error, /* @__PURE__ */ new Set(), 0); +} +function describeError(error, seen, depth) { + if (!(error instanceof Error)) return String(error); + seen.add(error); + const code = errorCode(error); + const description = depth === 0 ? error.message : `${error.name}${code ? ` [${code}]` : ""}: ${error.message}`; + if (depth >= 4 || error.cause === void 0 || seen.has(error.cause)) { + return description; + } + return `${description}; cause: ${describeError(error.cause, seen, depth + 1)}`; +} +function errorCode(error) { + if (!("code" in error)) return ""; + const value = error.code; + return typeof value === "string" || typeof value === "number" ? String(value) : ""; +} + +// src/runtime/load-json.ts +import { readFile } from "node:fs/promises"; +async function loadJsonFromCandidates(candidates, parse3, failureMessage) { + let lastError; + for (const candidate of candidates) { + try { + return parse3(JSON.parse(await readFile(candidate, "utf8"))); + } catch (error) { + lastError = error; + } + } + throw new Error(`${failureMessage}: ${errorMessage(lastError)}`); +} + +// node_modules/zod/v4/core/core.js +var _a; +// @__NO_SIDE_EFFECTS__ +function $constructor(name, initializer3, params) { + function init(inst, def) { + if (!inst._zod) { + Object.defineProperty(inst, "_zod", { + value: { + def, + constr: _, + traits: /* @__PURE__ */ new Set() + }, + enumerable: false + }); + } + if (inst._zod.traits.has(name)) { + return; + } + inst._zod.traits.add(name); + initializer3(inst, def); + const proto = _.prototype; + const keys = Object.keys(proto); + for (let i = 0; i < keys.length; i++) { + const k = keys[i]; + if (!(k in inst)) { + inst[k] = proto[k].bind(inst); + } + } + } + const Parent = params?.Parent ?? Object; + class Definition extends Parent { + } + Object.defineProperty(Definition, "name", { value: name }); + function _(def) { + var _a3; + const inst = params?.Parent ? new Definition() : this; + init(inst, def); + (_a3 = inst._zod).deferred ?? (_a3.deferred = []); + for (const fn of inst._zod.deferred) { + fn(); + } + return inst; + } + Object.defineProperty(_, "init", { value: init }); + Object.defineProperty(_, Symbol.hasInstance, { + value: (inst) => { + if (params?.Parent && inst instanceof params.Parent) + return true; + return inst?._zod?.traits?.has(name); + } + }); + Object.defineProperty(_, "name", { value: name }); + return _; +} +var $ZodAsyncError = class extends Error { + constructor() { + super(`Encountered Promise during synchronous parse. Use .parseAsync() instead.`); + } +}; +var $ZodEncodeError = class extends Error { + constructor(name) { + super(`Encountered unidirectional transform during encode: ${name}`); + this.name = "ZodEncodeError"; + } +}; +(_a = globalThis).__zod_globalConfig ?? (_a.__zod_globalConfig = {}); +var globalConfig = globalThis.__zod_globalConfig; +function config(newConfig) { + if (newConfig) + Object.assign(globalConfig, newConfig); + return globalConfig; +} + +// node_modules/zod/v4/core/util.js +var util_exports = {}; +__export(util_exports, { + BIGINT_FORMAT_RANGES: () => BIGINT_FORMAT_RANGES, + Class: () => Class, + NUMBER_FORMAT_RANGES: () => NUMBER_FORMAT_RANGES, + aborted: () => aborted, + allowsEval: () => allowsEval, + assert: () => assert, + assertEqual: () => assertEqual, + assertIs: () => assertIs, + assertNever: () => assertNever, + assertNotEqual: () => assertNotEqual, + assignProp: () => assignProp, + base64ToUint8Array: () => base64ToUint8Array, + base64urlToUint8Array: () => base64urlToUint8Array, + cached: () => cached, + captureStackTrace: () => captureStackTrace, + cleanEnum: () => cleanEnum, + cleanRegex: () => cleanRegex, + clone: () => clone, + cloneDef: () => cloneDef, + createTransparentProxy: () => createTransparentProxy, + defineLazy: () => defineLazy, + esc: () => esc, + escapeRegex: () => escapeRegex, + explicitlyAborted: () => explicitlyAborted, + extend: () => extend, + finalizeIssue: () => finalizeIssue, + floatSafeRemainder: () => floatSafeRemainder, + getElementAtPath: () => getElementAtPath, + getEnumValues: () => getEnumValues, + getLengthableOrigin: () => getLengthableOrigin, + getParsedType: () => getParsedType, + getSizableOrigin: () => getSizableOrigin, + hexToUint8Array: () => hexToUint8Array, + isObject: () => isObject, + isPlainObject: () => isPlainObject, + issue: () => issue, + joinValues: () => joinValues, + jsonStringifyReplacer: () => jsonStringifyReplacer, + merge: () => merge, + mergeDefs: () => mergeDefs, + normalizeParams: () => normalizeParams, + nullish: () => nullish, + numKeys: () => numKeys, + objectClone: () => objectClone, + omit: () => omit, + optionalKeys: () => optionalKeys, + parsedType: () => parsedType, + partial: () => partial, + pick: () => pick, + prefixIssues: () => prefixIssues, + primitiveTypes: () => primitiveTypes, + promiseAllObject: () => promiseAllObject, + propertyKeyTypes: () => propertyKeyTypes, + randomString: () => randomString, + required: () => required, + safeExtend: () => safeExtend, + shallowClone: () => shallowClone, + slugify: () => slugify, + stringifyPrimitive: () => stringifyPrimitive, + uint8ArrayToBase64: () => uint8ArrayToBase64, + uint8ArrayToBase64url: () => uint8ArrayToBase64url, + uint8ArrayToHex: () => uint8ArrayToHex, + unwrapMessage: () => unwrapMessage +}); +function assertEqual(val) { + return val; +} +function assertNotEqual(val) { + return val; +} +function assertIs(_arg) { +} +function assertNever(_x) { + throw new Error("Unexpected value in exhaustive check"); +} +function assert(_) { +} +function getEnumValues(entries) { + const numericValues = Object.values(entries).filter((v) => typeof v === "number"); + const values = Object.entries(entries).filter(([k, _]) => numericValues.indexOf(+k) === -1).map(([_, v]) => v); + return values; +} +function joinValues(array2, separator = "|") { + return array2.map((val) => stringifyPrimitive(val)).join(separator); +} +function jsonStringifyReplacer(_, value) { + if (typeof value === "bigint") + return value.toString(); + return value; +} +function cached(getter) { + const set = false; + return { + get value() { + if (!set) { + const value = getter(); + Object.defineProperty(this, "value", { value }); + return value; + } + throw new Error("cached value already set"); + } + }; +} +function nullish(input) { + return input === null || input === void 0; +} +function cleanRegex(source) { + const start = source.startsWith("^") ? 1 : 0; + const end = source.endsWith("$") ? source.length - 1 : source.length; + return source.slice(start, end); +} +function floatSafeRemainder(val, step) { + const ratio = val / step; + const roundedRatio = Math.round(ratio); + const tolerance = Number.EPSILON * Math.max(Math.abs(ratio), 1); + if (Math.abs(ratio - roundedRatio) < tolerance) + return 0; + return ratio - roundedRatio; +} +var EVALUATING = /* @__PURE__ */ Symbol("evaluating"); +function defineLazy(object2, key, getter) { + let value = void 0; + Object.defineProperty(object2, key, { + get() { + if (value === EVALUATING) { + return void 0; + } + if (value === void 0) { + value = EVALUATING; + value = getter(); + } + return value; + }, + set(v) { + Object.defineProperty(object2, key, { + value: v + // configurable: true, + }); + }, + configurable: true + }); +} +function objectClone(obj) { + return Object.create(Object.getPrototypeOf(obj), Object.getOwnPropertyDescriptors(obj)); +} +function assignProp(target, prop, value) { + Object.defineProperty(target, prop, { + value, + writable: true, + enumerable: true, + configurable: true + }); +} +function mergeDefs(...defs) { + const mergedDescriptors = {}; + for (const def of defs) { + const descriptors = Object.getOwnPropertyDescriptors(def); + Object.assign(mergedDescriptors, descriptors); + } + return Object.defineProperties({}, mergedDescriptors); +} +function cloneDef(schema) { + return mergeDefs(schema._zod.def); +} +function getElementAtPath(obj, path2) { + if (!path2) + return obj; + return path2.reduce((acc, key) => acc?.[key], obj); +} +function promiseAllObject(promisesObj) { + const keys = Object.keys(promisesObj); + const promises = keys.map((key) => promisesObj[key]); + return Promise.all(promises).then((results) => { + const resolvedObj = {}; + for (let i = 0; i < keys.length; i++) { + resolvedObj[keys[i]] = results[i]; + } + return resolvedObj; + }); +} +function randomString(length = 10) { + const chars = "abcdefghijklmnopqrstuvwxyz"; + let str = ""; + for (let i = 0; i < length; i++) { + str += chars[Math.floor(Math.random() * chars.length)]; + } + return str; +} +function esc(str) { + return JSON.stringify(str); +} +function slugify(input) { + return input.toLowerCase().trim().replace(/[^\w\s-]/g, "").replace(/[\s_-]+/g, "-").replace(/^-+|-+$/g, ""); +} +var captureStackTrace = "captureStackTrace" in Error ? Error.captureStackTrace : (..._args) => { +}; +function isObject(data) { + return typeof data === "object" && data !== null && !Array.isArray(data); +} +var allowsEval = /* @__PURE__ */ cached(() => { + if (globalConfig.jitless) { + return false; + } + if (typeof navigator !== "undefined" && navigator?.userAgent?.includes("Cloudflare")) { + return false; + } + try { + const F = Function; + new F(""); + return true; + } catch (_) { + return false; + } +}); +function isPlainObject(o) { + if (isObject(o) === false) + return false; + const ctor = o.constructor; + if (ctor === void 0) + return true; + if (typeof ctor !== "function") + return true; + const prot = ctor.prototype; + if (isObject(prot) === false) + return false; + if (Object.prototype.hasOwnProperty.call(prot, "isPrototypeOf") === false) { + return false; + } + return true; +} +function shallowClone(o) { + if (isPlainObject(o)) + return { ...o }; + if (Array.isArray(o)) + return [...o]; + if (o instanceof Map) + return new Map(o); + if (o instanceof Set) + return new Set(o); + return o; +} +function numKeys(data) { + let keyCount = 0; + for (const key in data) { + if (Object.prototype.hasOwnProperty.call(data, key)) { + keyCount++; + } + } + return keyCount; +} +var getParsedType = (data) => { + const t = typeof data; + switch (t) { + case "undefined": + return "undefined"; + case "string": + return "string"; + case "number": + return Number.isNaN(data) ? "nan" : "number"; + case "boolean": + return "boolean"; + case "function": + return "function"; + case "bigint": + return "bigint"; + case "symbol": + return "symbol"; + case "object": + if (Array.isArray(data)) { + return "array"; + } + if (data === null) { + return "null"; + } + if (data.then && typeof data.then === "function" && data.catch && typeof data.catch === "function") { + return "promise"; + } + if (typeof Map !== "undefined" && data instanceof Map) { + return "map"; + } + if (typeof Set !== "undefined" && data instanceof Set) { + return "set"; + } + if (typeof Date !== "undefined" && data instanceof Date) { + return "date"; + } + if (typeof File !== "undefined" && data instanceof File) { + return "file"; + } + return "object"; + default: + throw new Error(`Unknown data type: ${t}`); + } +}; +var propertyKeyTypes = /* @__PURE__ */ new Set(["string", "number", "symbol"]); +var primitiveTypes = /* @__PURE__ */ new Set([ + "string", + "number", + "bigint", + "boolean", + "symbol", + "undefined" +]); +function escapeRegex(str) { + return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"); +} +function clone(inst, def, params) { + const cl = new inst._zod.constr(def ?? inst._zod.def); + if (!def || params?.parent) + cl._zod.parent = inst; + return cl; +} +function normalizeParams(_params) { + const params = _params; + if (!params) + return {}; + if (typeof params === "string") + return { error: () => params }; + if (params?.message !== void 0) { + if (params?.error !== void 0) + throw new Error("Cannot specify both `message` and `error` params"); + params.error = params.message; + } + delete params.message; + if (typeof params.error === "string") + return { ...params, error: () => params.error }; + return params; +} +function createTransparentProxy(getter) { + let target; + return new Proxy({}, { + get(_, prop, receiver) { + target ?? (target = getter()); + return Reflect.get(target, prop, receiver); + }, + set(_, prop, value, receiver) { + target ?? (target = getter()); + return Reflect.set(target, prop, value, receiver); + }, + has(_, prop) { + target ?? (target = getter()); + return Reflect.has(target, prop); + }, + deleteProperty(_, prop) { + target ?? (target = getter()); + return Reflect.deleteProperty(target, prop); + }, + ownKeys(_) { + target ?? (target = getter()); + return Reflect.ownKeys(target); + }, + getOwnPropertyDescriptor(_, prop) { + target ?? (target = getter()); + return Reflect.getOwnPropertyDescriptor(target, prop); + }, + defineProperty(_, prop, descriptor) { + target ?? (target = getter()); + return Reflect.defineProperty(target, prop, descriptor); + } + }); +} +function stringifyPrimitive(value) { + if (typeof value === "bigint") + return value.toString() + "n"; + if (typeof value === "string") + return `"${value}"`; + return `${value}`; +} +function optionalKeys(shape) { + return Object.keys(shape).filter((k) => { + return shape[k]._zod.optin === "optional" && shape[k]._zod.optout === "optional"; + }); +} +var NUMBER_FORMAT_RANGES = { + safeint: [Number.MIN_SAFE_INTEGER, Number.MAX_SAFE_INTEGER], + int32: [-2147483648, 2147483647], + uint32: [0, 4294967295], + float32: [-34028234663852886e22, 34028234663852886e22], + float64: [-Number.MAX_VALUE, Number.MAX_VALUE] +}; +var BIGINT_FORMAT_RANGES = { + int64: [/* @__PURE__ */ BigInt("-9223372036854775808"), /* @__PURE__ */ BigInt("9223372036854775807")], + uint64: [/* @__PURE__ */ BigInt(0), /* @__PURE__ */ BigInt("18446744073709551615")] +}; +function pick(schema, mask) { + const currDef = schema._zod.def; + const checks = currDef.checks; + const hasChecks = checks && checks.length > 0; + if (hasChecks) { + throw new Error(".pick() cannot be used on object schemas containing refinements"); + } + const def = mergeDefs(schema._zod.def, { + get shape() { + const newShape = {}; + for (const key in mask) { + if (!(key in currDef.shape)) { + throw new Error(`Unrecognized key: "${key}"`); + } + if (!mask[key]) + continue; + newShape[key] = currDef.shape[key]; + } + assignProp(this, "shape", newShape); + return newShape; + }, + checks: [] + }); + return clone(schema, def); +} +function omit(schema, mask) { + const currDef = schema._zod.def; + const checks = currDef.checks; + const hasChecks = checks && checks.length > 0; + if (hasChecks) { + throw new Error(".omit() cannot be used on object schemas containing refinements"); + } + const def = mergeDefs(schema._zod.def, { + get shape() { + const newShape = { ...schema._zod.def.shape }; + for (const key in mask) { + if (!(key in currDef.shape)) { + throw new Error(`Unrecognized key: "${key}"`); + } + if (!mask[key]) + continue; + delete newShape[key]; + } + assignProp(this, "shape", newShape); + return newShape; + }, + checks: [] + }); + return clone(schema, def); +} +function extend(schema, shape) { + if (!isPlainObject(shape)) { + throw new Error("Invalid input to extend: expected a plain object"); + } + const checks = schema._zod.def.checks; + const hasChecks = checks && checks.length > 0; + if (hasChecks) { + const existingShape = schema._zod.def.shape; + for (const key in shape) { + if (Object.getOwnPropertyDescriptor(existingShape, key) !== void 0) { + throw new Error("Cannot overwrite keys on object schemas containing refinements. Use `.safeExtend()` instead."); + } + } + } + const def = mergeDefs(schema._zod.def, { + get shape() { + const _shape = { ...schema._zod.def.shape, ...shape }; + assignProp(this, "shape", _shape); + return _shape; + } + }); + return clone(schema, def); +} +function safeExtend(schema, shape) { + if (!isPlainObject(shape)) { + throw new Error("Invalid input to safeExtend: expected a plain object"); + } + const def = mergeDefs(schema._zod.def, { + get shape() { + const _shape = { ...schema._zod.def.shape, ...shape }; + assignProp(this, "shape", _shape); + return _shape; + } + }); + return clone(schema, def); +} +function merge(a, b) { + if (a._zod.def.checks?.length) { + throw new Error(".merge() cannot be used on object schemas containing refinements. Use .safeExtend() instead."); + } + const def = mergeDefs(a._zod.def, { + get shape() { + const _shape = { ...a._zod.def.shape, ...b._zod.def.shape }; + assignProp(this, "shape", _shape); + return _shape; + }, + get catchall() { + return b._zod.def.catchall; + }, + checks: b._zod.def.checks ?? [] + }); + return clone(a, def); +} +function partial(Class2, schema, mask) { + const currDef = schema._zod.def; + const checks = currDef.checks; + const hasChecks = checks && checks.length > 0; + if (hasChecks) { + throw new Error(".partial() cannot be used on object schemas containing refinements"); + } + const def = mergeDefs(schema._zod.def, { + get shape() { + const oldShape = schema._zod.def.shape; + const shape = { ...oldShape }; + if (mask) { + for (const key in mask) { + if (!(key in oldShape)) { + throw new Error(`Unrecognized key: "${key}"`); + } + if (!mask[key]) + continue; + shape[key] = Class2 ? new Class2({ + type: "optional", + innerType: oldShape[key] + }) : oldShape[key]; + } + } else { + for (const key in oldShape) { + shape[key] = Class2 ? new Class2({ + type: "optional", + innerType: oldShape[key] + }) : oldShape[key]; + } + } + assignProp(this, "shape", shape); + return shape; + }, + checks: [] + }); + return clone(schema, def); +} +function required(Class2, schema, mask) { + const def = mergeDefs(schema._zod.def, { + get shape() { + const oldShape = schema._zod.def.shape; + const shape = { ...oldShape }; + if (mask) { + for (const key in mask) { + if (!(key in shape)) { + throw new Error(`Unrecognized key: "${key}"`); + } + if (!mask[key]) + continue; + shape[key] = new Class2({ + type: "nonoptional", + innerType: oldShape[key] + }); + } + } else { + for (const key in oldShape) { + shape[key] = new Class2({ + type: "nonoptional", + innerType: oldShape[key] + }); + } + } + assignProp(this, "shape", shape); + return shape; + } + }); + return clone(schema, def); +} +function aborted(x, startIndex = 0) { + if (x.aborted === true) + return true; + for (let i = startIndex; i < x.issues.length; i++) { + if (x.issues[i]?.continue !== true) { + return true; + } + } + return false; +} +function explicitlyAborted(x, startIndex = 0) { + if (x.aborted === true) + return true; + for (let i = startIndex; i < x.issues.length; i++) { + if (x.issues[i]?.continue === false) { + return true; + } + } + return false; +} +function prefixIssues(path2, issues) { + return issues.map((iss) => { + var _a3; + (_a3 = iss).path ?? (_a3.path = []); + iss.path.unshift(path2); + return iss; + }); +} +function unwrapMessage(message) { + return typeof message === "string" ? message : message?.message; +} +function finalizeIssue(iss, ctx, config2) { + const message = iss.message ? iss.message : unwrapMessage(iss.inst?._zod.def?.error?.(iss)) ?? unwrapMessage(ctx?.error?.(iss)) ?? unwrapMessage(config2.customError?.(iss)) ?? unwrapMessage(config2.localeError?.(iss)) ?? "Invalid input"; + const { inst: _inst, continue: _continue, input: _input, ...rest } = iss; + rest.path ?? (rest.path = []); + rest.message = message; + if (ctx?.reportInput) { + rest.input = _input; + } + return rest; +} +function getSizableOrigin(input) { + if (input instanceof Set) + return "set"; + if (input instanceof Map) + return "map"; + if (input instanceof File) + return "file"; + return "unknown"; +} +function getLengthableOrigin(input) { + if (Array.isArray(input)) + return "array"; + if (typeof input === "string") + return "string"; + return "unknown"; +} +function parsedType(data) { + const t = typeof data; + switch (t) { + case "number": { + return Number.isNaN(data) ? "nan" : "number"; + } + case "object": { + if (data === null) { + return "null"; + } + if (Array.isArray(data)) { + return "array"; + } + const obj = data; + if (obj && Object.getPrototypeOf(obj) !== Object.prototype && "constructor" in obj && obj.constructor) { + return obj.constructor.name; + } + } + } + return t; +} +function issue(...args) { + const [iss, input, inst] = args; + if (typeof iss === "string") { + return { + message: iss, + code: "custom", + input, + inst + }; + } + return { ...iss }; +} +function cleanEnum(obj) { + return Object.entries(obj).filter(([k, _]) => { + return Number.isNaN(Number.parseInt(k, 10)); + }).map((el) => el[1]); +} +function base64ToUint8Array(base642) { + const binaryString = atob(base642); + const bytes = new Uint8Array(binaryString.length); + for (let i = 0; i < binaryString.length; i++) { + bytes[i] = binaryString.charCodeAt(i); + } + return bytes; +} +function uint8ArrayToBase64(bytes) { + let binaryString = ""; + for (let i = 0; i < bytes.length; i++) { + binaryString += String.fromCharCode(bytes[i]); + } + return btoa(binaryString); +} +function base64urlToUint8Array(base64url2) { + const base642 = base64url2.replace(/-/g, "+").replace(/_/g, "/"); + const padding = "=".repeat((4 - base642.length % 4) % 4); + return base64ToUint8Array(base642 + padding); +} +function uint8ArrayToBase64url(bytes) { + return uint8ArrayToBase64(bytes).replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, ""); +} +function hexToUint8Array(hex) { + const cleanHex = hex.replace(/^0x/, ""); + if (cleanHex.length % 2 !== 0) { + throw new Error("Invalid hex string length"); + } + const bytes = new Uint8Array(cleanHex.length / 2); + for (let i = 0; i < cleanHex.length; i += 2) { + bytes[i / 2] = Number.parseInt(cleanHex.slice(i, i + 2), 16); + } + return bytes; +} +function uint8ArrayToHex(bytes) { + return Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join(""); +} +var Class = class { + constructor(..._args) { + } +}; + +// node_modules/zod/v4/core/errors.js +var initializer = (inst, def) => { + inst.name = "$ZodError"; + Object.defineProperty(inst, "_zod", { + value: inst._zod, + enumerable: false + }); + Object.defineProperty(inst, "issues", { + value: def, + enumerable: false + }); + inst.message = JSON.stringify(def, jsonStringifyReplacer, 2); + Object.defineProperty(inst, "toString", { + value: () => inst.message, + enumerable: false + }); +}; +var $ZodError = $constructor("$ZodError", initializer); +var $ZodRealError = $constructor("$ZodError", initializer, { Parent: Error }); +function flattenError(error, mapper = (issue2) => issue2.message) { + const fieldErrors = {}; + const formErrors = []; + for (const sub of error.issues) { + if (sub.path.length > 0) { + fieldErrors[sub.path[0]] = fieldErrors[sub.path[0]] || []; + fieldErrors[sub.path[0]].push(mapper(sub)); + } else { + formErrors.push(mapper(sub)); + } + } + return { formErrors, fieldErrors }; +} +function formatError(error, mapper = (issue2) => issue2.message) { + const fieldErrors = { _errors: [] }; + const processError = (error2, path2 = []) => { + for (const issue2 of error2.issues) { + if (issue2.code === "invalid_union" && issue2.errors.length) { + issue2.errors.map((issues) => processError({ issues }, [...path2, ...issue2.path])); + } else if (issue2.code === "invalid_key") { + processError({ issues: issue2.issues }, [...path2, ...issue2.path]); + } else if (issue2.code === "invalid_element") { + processError({ issues: issue2.issues }, [...path2, ...issue2.path]); + } else { + const fullpath = [...path2, ...issue2.path]; + if (fullpath.length === 0) { + fieldErrors._errors.push(mapper(issue2)); + } else { + let curr = fieldErrors; + let i = 0; + while (i < fullpath.length) { + const el = fullpath[i]; + const terminal = i === fullpath.length - 1; + if (!terminal) { + curr[el] = curr[el] || { _errors: [] }; + } else { + curr[el] = curr[el] || { _errors: [] }; + curr[el]._errors.push(mapper(issue2)); + } + curr = curr[el]; + i++; + } + } + } + } + }; + processError(error); + return fieldErrors; +} + +// node_modules/zod/v4/core/parse.js +var _parse = (_Err) => (schema, value, _ctx, _params) => { + const ctx = _ctx ? { ..._ctx, async: false } : { async: false }; + const result = schema._zod.run({ value, issues: [] }, ctx); + if (result instanceof Promise) { + throw new $ZodAsyncError(); + } + if (result.issues.length) { + const e = new (_params?.Err ?? _Err)(result.issues.map((iss) => finalizeIssue(iss, ctx, config()))); + captureStackTrace(e, _params?.callee); + throw e; + } + return result.value; +}; +var _parseAsync = (_Err) => async (schema, value, _ctx, params) => { + const ctx = _ctx ? { ..._ctx, async: true } : { async: true }; + let result = schema._zod.run({ value, issues: [] }, ctx); + if (result instanceof Promise) + result = await result; + if (result.issues.length) { + const e = new (params?.Err ?? _Err)(result.issues.map((iss) => finalizeIssue(iss, ctx, config()))); + captureStackTrace(e, params?.callee); + throw e; + } + return result.value; +}; +var _safeParse = (_Err) => (schema, value, _ctx) => { + const ctx = _ctx ? { ..._ctx, async: false } : { async: false }; + const result = schema._zod.run({ value, issues: [] }, ctx); + if (result instanceof Promise) { + throw new $ZodAsyncError(); + } + return result.issues.length ? { + success: false, + error: new (_Err ?? $ZodError)(result.issues.map((iss) => finalizeIssue(iss, ctx, config()))) + } : { success: true, data: result.value }; +}; +var safeParse = /* @__PURE__ */ _safeParse($ZodRealError); +var _safeParseAsync = (_Err) => async (schema, value, _ctx) => { + const ctx = _ctx ? { ..._ctx, async: true } : { async: true }; + let result = schema._zod.run({ value, issues: [] }, ctx); + if (result instanceof Promise) + result = await result; + return result.issues.length ? { + success: false, + error: new _Err(result.issues.map((iss) => finalizeIssue(iss, ctx, config()))) + } : { success: true, data: result.value }; +}; +var safeParseAsync = /* @__PURE__ */ _safeParseAsync($ZodRealError); +var _encode = (_Err) => (schema, value, _ctx) => { + const ctx = _ctx ? { ..._ctx, direction: "backward" } : { direction: "backward" }; + return _parse(_Err)(schema, value, ctx); +}; +var _decode = (_Err) => (schema, value, _ctx) => { + return _parse(_Err)(schema, value, _ctx); +}; +var _encodeAsync = (_Err) => async (schema, value, _ctx) => { + const ctx = _ctx ? { ..._ctx, direction: "backward" } : { direction: "backward" }; + return _parseAsync(_Err)(schema, value, ctx); +}; +var _decodeAsync = (_Err) => async (schema, value, _ctx) => { + return _parseAsync(_Err)(schema, value, _ctx); +}; +var _safeEncode = (_Err) => (schema, value, _ctx) => { + const ctx = _ctx ? { ..._ctx, direction: "backward" } : { direction: "backward" }; + return _safeParse(_Err)(schema, value, ctx); +}; +var _safeDecode = (_Err) => (schema, value, _ctx) => { + return _safeParse(_Err)(schema, value, _ctx); +}; +var _safeEncodeAsync = (_Err) => async (schema, value, _ctx) => { + const ctx = _ctx ? { ..._ctx, direction: "backward" } : { direction: "backward" }; + return _safeParseAsync(_Err)(schema, value, ctx); +}; +var _safeDecodeAsync = (_Err) => async (schema, value, _ctx) => { + return _safeParseAsync(_Err)(schema, value, _ctx); +}; + +// node_modules/zod/v4/core/regexes.js +var cuid = /^[cC][0-9a-z]{6,}$/; +var cuid2 = /^[0-9a-z]+$/; +var ulid = /^[0-9A-HJKMNP-TV-Za-hjkmnp-tv-z]{26}$/; +var xid = /^[0-9a-vA-V]{20}$/; +var ksuid = /^[A-Za-z0-9]{27}$/; +var nanoid = /^[a-zA-Z0-9_-]{21}$/; +var duration = /^P(?:(\d+W)|(?!.*W)(?=\d|T\d)(\d+Y)?(\d+M)?(\d+D)?(T(?=\d)(\d+H)?(\d+M)?(\d+([.,]\d+)?S)?)?)$/; +var guid = /^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12})$/; +var uuid = (version2) => { + if (!version2) + return /^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-8][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$/; + return new RegExp(`^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-${version2}[0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12})$`); +}; +var email = /^(?!\.)(?!.*\.\.)([A-Za-z0-9_'+\-\.]*)[A-Za-z0-9_+-]@([A-Za-z0-9][A-Za-z0-9\-]*\.)+[A-Za-z]{2,}$/; +var _emoji = `^(\\p{Extended_Pictographic}|\\p{Emoji_Component})+$`; +function emoji() { + return new RegExp(_emoji, "u"); +} +var ipv4 = /^(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])$/; +var ipv6 = /^(([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:))$/; +var cidrv4 = /^((25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\/([0-9]|[1-2][0-9]|3[0-2])$/; +var cidrv6 = /^(([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}|::|([0-9a-fA-F]{1,4})?::([0-9a-fA-F]{1,4}:?){0,6})\/(12[0-8]|1[01][0-9]|[1-9]?[0-9])$/; +var base64 = /^$|^(?:[0-9a-zA-Z+/]{4})*(?:(?:[0-9a-zA-Z+/]{2}==)|(?:[0-9a-zA-Z+/]{3}=))?$/; +var base64url = /^[A-Za-z0-9_-]*$/; +var httpProtocol = /^https?$/; +var e164 = /^\+[1-9]\d{6,14}$/; +var dateSource = `(?:(?:\\d\\d[2468][048]|\\d\\d[13579][26]|\\d\\d0[48]|[02468][048]00|[13579][26]00)-02-29|\\d{4}-(?:(?:0[13578]|1[02])-(?:0[1-9]|[12]\\d|3[01])|(?:0[469]|11)-(?:0[1-9]|[12]\\d|30)|(?:02)-(?:0[1-9]|1\\d|2[0-8])))`; +var date = /* @__PURE__ */ new RegExp(`^${dateSource}$`); +function timeSource(args) { + const hhmm = `(?:[01]\\d|2[0-3]):[0-5]\\d`; + const regex = typeof args.precision === "number" ? args.precision === -1 ? `${hhmm}` : args.precision === 0 ? `${hhmm}:[0-5]\\d` : `${hhmm}:[0-5]\\d\\.\\d{${args.precision}}` : `${hhmm}(?::[0-5]\\d(?:\\.\\d+)?)?`; + return regex; +} +function time(args) { + return new RegExp(`^${timeSource(args)}$`); +} +function datetime(args) { + const time3 = timeSource({ precision: args.precision }); + const opts = ["Z"]; + if (args.local) + opts.push(""); + if (args.offset) + opts.push(`([+-](?:[01]\\d|2[0-3]):[0-5]\\d)`); + const timeRegex = `${time3}(?:${opts.join("|")})`; + return new RegExp(`^${dateSource}T(?:${timeRegex})$`); +} +var string = (params) => { + const regex = params ? `[\\s\\S]{${params?.minimum ?? 0},${params?.maximum ?? ""}}` : `[\\s\\S]*`; + return new RegExp(`^${regex}$`); +}; +var integer = /^-?\d+$/; +var number = /^-?\d+(?:\.\d+)?$/; +var boolean = /^(?:true|false)$/i; +var lowercase = /^[^A-Z]*$/; +var uppercase = /^[^a-z]*$/; + +// node_modules/zod/v4/core/checks.js +var $ZodCheck = /* @__PURE__ */ $constructor("$ZodCheck", (inst, def) => { + var _a3; + inst._zod ?? (inst._zod = {}); + inst._zod.def = def; + (_a3 = inst._zod).onattach ?? (_a3.onattach = []); +}); +var numericOriginMap = { + number: "number", + bigint: "bigint", + object: "date" +}; +var $ZodCheckLessThan = /* @__PURE__ */ $constructor("$ZodCheckLessThan", (inst, def) => { + $ZodCheck.init(inst, def); + const origin = numericOriginMap[typeof def.value]; + inst._zod.onattach.push((inst2) => { + const bag = inst2._zod.bag; + const curr = (def.inclusive ? bag.maximum : bag.exclusiveMaximum) ?? Number.POSITIVE_INFINITY; + if (def.value < curr) { + if (def.inclusive) + bag.maximum = def.value; + else + bag.exclusiveMaximum = def.value; + } + }); + inst._zod.check = (payload) => { + if (def.inclusive ? payload.value <= def.value : payload.value < def.value) { + return; + } + payload.issues.push({ + origin, + code: "too_big", + maximum: typeof def.value === "object" ? def.value.getTime() : def.value, + input: payload.value, + inclusive: def.inclusive, + inst, + continue: !def.abort + }); + }; +}); +var $ZodCheckGreaterThan = /* @__PURE__ */ $constructor("$ZodCheckGreaterThan", (inst, def) => { + $ZodCheck.init(inst, def); + const origin = numericOriginMap[typeof def.value]; + inst._zod.onattach.push((inst2) => { + const bag = inst2._zod.bag; + const curr = (def.inclusive ? bag.minimum : bag.exclusiveMinimum) ?? Number.NEGATIVE_INFINITY; + if (def.value > curr) { + if (def.inclusive) + bag.minimum = def.value; + else + bag.exclusiveMinimum = def.value; + } + }); + inst._zod.check = (payload) => { + if (def.inclusive ? payload.value >= def.value : payload.value > def.value) { + return; + } + payload.issues.push({ + origin, + code: "too_small", + minimum: typeof def.value === "object" ? def.value.getTime() : def.value, + input: payload.value, + inclusive: def.inclusive, + inst, + continue: !def.abort + }); + }; +}); +var $ZodCheckMultipleOf = /* @__PURE__ */ $constructor("$ZodCheckMultipleOf", (inst, def) => { + $ZodCheck.init(inst, def); + inst._zod.onattach.push((inst2) => { + var _a3; + (_a3 = inst2._zod.bag).multipleOf ?? (_a3.multipleOf = def.value); + }); + inst._zod.check = (payload) => { + if (typeof payload.value !== typeof def.value) + throw new Error("Cannot mix number and bigint in multiple_of check."); + const isMultiple = typeof payload.value === "bigint" ? payload.value % def.value === BigInt(0) : floatSafeRemainder(payload.value, def.value) === 0; + if (isMultiple) + return; + payload.issues.push({ + origin: typeof payload.value, + code: "not_multiple_of", + divisor: def.value, + input: payload.value, + inst, + continue: !def.abort + }); + }; +}); +var $ZodCheckNumberFormat = /* @__PURE__ */ $constructor("$ZodCheckNumberFormat", (inst, def) => { + $ZodCheck.init(inst, def); + def.format = def.format || "float64"; + const isInt = def.format?.includes("int"); + const origin = isInt ? "int" : "number"; + const [minimum, maximum] = NUMBER_FORMAT_RANGES[def.format]; + inst._zod.onattach.push((inst2) => { + const bag = inst2._zod.bag; + bag.format = def.format; + bag.minimum = minimum; + bag.maximum = maximum; + if (isInt) + bag.pattern = integer; + }); + inst._zod.check = (payload) => { + const input = payload.value; + if (isInt) { + if (!Number.isInteger(input)) { + payload.issues.push({ + expected: origin, + format: def.format, + code: "invalid_type", + continue: false, + input, + inst + }); + return; + } + if (!Number.isSafeInteger(input)) { + if (input > 0) { + payload.issues.push({ + input, + code: "too_big", + maximum: Number.MAX_SAFE_INTEGER, + note: "Integers must be within the safe integer range.", + inst, + origin, + inclusive: true, + continue: !def.abort + }); + } else { + payload.issues.push({ + input, + code: "too_small", + minimum: Number.MIN_SAFE_INTEGER, + note: "Integers must be within the safe integer range.", + inst, + origin, + inclusive: true, + continue: !def.abort + }); + } + return; + } + } + if (input < minimum) { + payload.issues.push({ + origin: "number", + input, + code: "too_small", + minimum, + inclusive: true, + inst, + continue: !def.abort + }); + } + if (input > maximum) { + payload.issues.push({ + origin: "number", + input, + code: "too_big", + maximum, + inclusive: true, + inst, + continue: !def.abort + }); + } + }; +}); +var $ZodCheckMaxLength = /* @__PURE__ */ $constructor("$ZodCheckMaxLength", (inst, def) => { + var _a3; + $ZodCheck.init(inst, def); + (_a3 = inst._zod.def).when ?? (_a3.when = (payload) => { + const val = payload.value; + return !nullish(val) && val.length !== void 0; + }); + inst._zod.onattach.push((inst2) => { + const curr = inst2._zod.bag.maximum ?? Number.POSITIVE_INFINITY; + if (def.maximum < curr) + inst2._zod.bag.maximum = def.maximum; + }); + inst._zod.check = (payload) => { + const input = payload.value; + const length = input.length; + if (length <= def.maximum) + return; + const origin = getLengthableOrigin(input); + payload.issues.push({ + origin, + code: "too_big", + maximum: def.maximum, + inclusive: true, + input, + inst, + continue: !def.abort + }); + }; +}); +var $ZodCheckMinLength = /* @__PURE__ */ $constructor("$ZodCheckMinLength", (inst, def) => { + var _a3; + $ZodCheck.init(inst, def); + (_a3 = inst._zod.def).when ?? (_a3.when = (payload) => { + const val = payload.value; + return !nullish(val) && val.length !== void 0; + }); + inst._zod.onattach.push((inst2) => { + const curr = inst2._zod.bag.minimum ?? Number.NEGATIVE_INFINITY; + if (def.minimum > curr) + inst2._zod.bag.minimum = def.minimum; + }); + inst._zod.check = (payload) => { + const input = payload.value; + const length = input.length; + if (length >= def.minimum) + return; + const origin = getLengthableOrigin(input); + payload.issues.push({ + origin, + code: "too_small", + minimum: def.minimum, + inclusive: true, + input, + inst, + continue: !def.abort + }); + }; +}); +var $ZodCheckLengthEquals = /* @__PURE__ */ $constructor("$ZodCheckLengthEquals", (inst, def) => { + var _a3; + $ZodCheck.init(inst, def); + (_a3 = inst._zod.def).when ?? (_a3.when = (payload) => { + const val = payload.value; + return !nullish(val) && val.length !== void 0; + }); + inst._zod.onattach.push((inst2) => { + const bag = inst2._zod.bag; + bag.minimum = def.length; + bag.maximum = def.length; + bag.length = def.length; + }); + inst._zod.check = (payload) => { + const input = payload.value; + const length = input.length; + if (length === def.length) + return; + const origin = getLengthableOrigin(input); + const tooBig = length > def.length; + payload.issues.push({ + origin, + ...tooBig ? { code: "too_big", maximum: def.length } : { code: "too_small", minimum: def.length }, + inclusive: true, + exact: true, + input: payload.value, + inst, + continue: !def.abort + }); + }; +}); +var $ZodCheckStringFormat = /* @__PURE__ */ $constructor("$ZodCheckStringFormat", (inst, def) => { + var _a3, _b; + $ZodCheck.init(inst, def); + inst._zod.onattach.push((inst2) => { + const bag = inst2._zod.bag; + bag.format = def.format; + if (def.pattern) { + bag.patterns ?? (bag.patterns = /* @__PURE__ */ new Set()); + bag.patterns.add(def.pattern); + } + }); + if (def.pattern) + (_a3 = inst._zod).check ?? (_a3.check = (payload) => { + def.pattern.lastIndex = 0; + if (def.pattern.test(payload.value)) + return; + payload.issues.push({ + origin: "string", + code: "invalid_format", + format: def.format, + input: payload.value, + ...def.pattern ? { pattern: def.pattern.toString() } : {}, + inst, + continue: !def.abort + }); + }); + else + (_b = inst._zod).check ?? (_b.check = () => { + }); +}); +var $ZodCheckRegex = /* @__PURE__ */ $constructor("$ZodCheckRegex", (inst, def) => { + $ZodCheckStringFormat.init(inst, def); + inst._zod.check = (payload) => { + def.pattern.lastIndex = 0; + if (def.pattern.test(payload.value)) + return; + payload.issues.push({ + origin: "string", + code: "invalid_format", + format: "regex", + input: payload.value, + pattern: def.pattern.toString(), + inst, + continue: !def.abort + }); + }; +}); +var $ZodCheckLowerCase = /* @__PURE__ */ $constructor("$ZodCheckLowerCase", (inst, def) => { + def.pattern ?? (def.pattern = lowercase); + $ZodCheckStringFormat.init(inst, def); +}); +var $ZodCheckUpperCase = /* @__PURE__ */ $constructor("$ZodCheckUpperCase", (inst, def) => { + def.pattern ?? (def.pattern = uppercase); + $ZodCheckStringFormat.init(inst, def); +}); +var $ZodCheckIncludes = /* @__PURE__ */ $constructor("$ZodCheckIncludes", (inst, def) => { + $ZodCheck.init(inst, def); + const escapedRegex = escapeRegex(def.includes); + const pattern = new RegExp(typeof def.position === "number" ? `^.{${def.position}}${escapedRegex}` : escapedRegex); + def.pattern = pattern; + inst._zod.onattach.push((inst2) => { + const bag = inst2._zod.bag; + bag.patterns ?? (bag.patterns = /* @__PURE__ */ new Set()); + bag.patterns.add(pattern); + }); + inst._zod.check = (payload) => { + if (payload.value.includes(def.includes, def.position)) + return; + payload.issues.push({ + origin: "string", + code: "invalid_format", + format: "includes", + includes: def.includes, + input: payload.value, + inst, + continue: !def.abort + }); + }; +}); +var $ZodCheckStartsWith = /* @__PURE__ */ $constructor("$ZodCheckStartsWith", (inst, def) => { + $ZodCheck.init(inst, def); + const pattern = new RegExp(`^${escapeRegex(def.prefix)}.*`); + def.pattern ?? (def.pattern = pattern); + inst._zod.onattach.push((inst2) => { + const bag = inst2._zod.bag; + bag.patterns ?? (bag.patterns = /* @__PURE__ */ new Set()); + bag.patterns.add(pattern); + }); + inst._zod.check = (payload) => { + if (payload.value.startsWith(def.prefix)) + return; + payload.issues.push({ + origin: "string", + code: "invalid_format", + format: "starts_with", + prefix: def.prefix, + input: payload.value, + inst, + continue: !def.abort + }); + }; +}); +var $ZodCheckEndsWith = /* @__PURE__ */ $constructor("$ZodCheckEndsWith", (inst, def) => { + $ZodCheck.init(inst, def); + const pattern = new RegExp(`.*${escapeRegex(def.suffix)}$`); + def.pattern ?? (def.pattern = pattern); + inst._zod.onattach.push((inst2) => { + const bag = inst2._zod.bag; + bag.patterns ?? (bag.patterns = /* @__PURE__ */ new Set()); + bag.patterns.add(pattern); + }); + inst._zod.check = (payload) => { + if (payload.value.endsWith(def.suffix)) + return; + payload.issues.push({ + origin: "string", + code: "invalid_format", + format: "ends_with", + suffix: def.suffix, + input: payload.value, + inst, + continue: !def.abort + }); + }; +}); +var $ZodCheckOverwrite = /* @__PURE__ */ $constructor("$ZodCheckOverwrite", (inst, def) => { + $ZodCheck.init(inst, def); + inst._zod.check = (payload) => { + payload.value = def.tx(payload.value); + }; +}); + +// node_modules/zod/v4/core/doc.js +var Doc = class { + constructor(args = []) { + this.content = []; + this.indent = 0; + if (this) + this.args = args; + } + indented(fn) { + this.indent += 1; + fn(this); + this.indent -= 1; + } + write(arg) { + if (typeof arg === "function") { + arg(this, { execution: "sync" }); + arg(this, { execution: "async" }); + return; + } + const content = arg; + const lines = content.split("\n").filter((x) => x); + const minIndent = Math.min(...lines.map((x) => x.length - x.trimStart().length)); + const dedented = lines.map((x) => x.slice(minIndent)).map((x) => " ".repeat(this.indent * 2) + x); + for (const line of dedented) { + this.content.push(line); + } + } + compile() { + const F = Function; + const args = this?.args; + const content = this?.content ?? [``]; + const lines = [...content.map((x) => ` ${x}`)]; + return new F(...args, lines.join("\n")); + } +}; + +// node_modules/zod/v4/core/versions.js +var version = { + major: 4, + minor: 4, + patch: 3 +}; + +// node_modules/zod/v4/core/schemas.js +var $ZodType = /* @__PURE__ */ $constructor("$ZodType", (inst, def) => { + var _a3; + inst ?? (inst = {}); + inst._zod.def = def; + inst._zod.bag = inst._zod.bag || {}; + inst._zod.version = version; + const checks = [...inst._zod.def.checks ?? []]; + if (inst._zod.traits.has("$ZodCheck")) { + checks.unshift(inst); + } + for (const ch of checks) { + for (const fn of ch._zod.onattach) { + fn(inst); + } + } + if (checks.length === 0) { + (_a3 = inst._zod).deferred ?? (_a3.deferred = []); + inst._zod.deferred?.push(() => { + inst._zod.run = inst._zod.parse; + }); + } else { + const runChecks = (payload, checks2, ctx) => { + let isAborted = aborted(payload); + let asyncResult; + for (const ch of checks2) { + if (ch._zod.def.when) { + if (explicitlyAborted(payload)) + continue; + const shouldRun = ch._zod.def.when(payload); + if (!shouldRun) + continue; + } else if (isAborted) { + continue; + } + const currLen = payload.issues.length; + const _ = ch._zod.check(payload); + if (_ instanceof Promise && ctx?.async === false) { + throw new $ZodAsyncError(); + } + if (asyncResult || _ instanceof Promise) { + asyncResult = (asyncResult ?? Promise.resolve()).then(async () => { + await _; + const nextLen = payload.issues.length; + if (nextLen === currLen) + return; + if (!isAborted) + isAborted = aborted(payload, currLen); + }); + } else { + const nextLen = payload.issues.length; + if (nextLen === currLen) + continue; + if (!isAborted) + isAborted = aborted(payload, currLen); + } + } + if (asyncResult) { + return asyncResult.then(() => { + return payload; + }); + } + return payload; + }; + const handleCanaryResult = (canary, payload, ctx) => { + if (aborted(canary)) { + canary.aborted = true; + return canary; + } + const checkResult = runChecks(payload, checks, ctx); + if (checkResult instanceof Promise) { + if (ctx.async === false) + throw new $ZodAsyncError(); + return checkResult.then((checkResult2) => inst._zod.parse(checkResult2, ctx)); + } + return inst._zod.parse(checkResult, ctx); + }; + inst._zod.run = (payload, ctx) => { + if (ctx.skipChecks) { + return inst._zod.parse(payload, ctx); + } + if (ctx.direction === "backward") { + const canary = inst._zod.parse({ value: payload.value, issues: [] }, { ...ctx, skipChecks: true }); + if (canary instanceof Promise) { + return canary.then((canary2) => { + return handleCanaryResult(canary2, payload, ctx); + }); + } + return handleCanaryResult(canary, payload, ctx); + } + const result = inst._zod.parse(payload, ctx); + if (result instanceof Promise) { + if (ctx.async === false) + throw new $ZodAsyncError(); + return result.then((result2) => runChecks(result2, checks, ctx)); + } + return runChecks(result, checks, ctx); + }; + } + defineLazy(inst, "~standard", () => ({ + validate: (value) => { + try { + const r = safeParse(inst, value); + return r.success ? { value: r.data } : { issues: r.error?.issues }; + } catch (_) { + return safeParseAsync(inst, value).then((r) => r.success ? { value: r.data } : { issues: r.error?.issues }); + } + }, + vendor: "zod", + version: 1 + })); +}); +var $ZodString = /* @__PURE__ */ $constructor("$ZodString", (inst, def) => { + $ZodType.init(inst, def); + inst._zod.pattern = [...inst?._zod.bag?.patterns ?? []].pop() ?? string(inst._zod.bag); + inst._zod.parse = (payload, _) => { + if (def.coerce) + try { + payload.value = String(payload.value); + } catch (_2) { + } + if (typeof payload.value === "string") + return payload; + payload.issues.push({ + expected: "string", + code: "invalid_type", + input: payload.value, + inst + }); + return payload; + }; +}); +var $ZodStringFormat = /* @__PURE__ */ $constructor("$ZodStringFormat", (inst, def) => { + $ZodCheckStringFormat.init(inst, def); + $ZodString.init(inst, def); +}); +var $ZodGUID = /* @__PURE__ */ $constructor("$ZodGUID", (inst, def) => { + def.pattern ?? (def.pattern = guid); + $ZodStringFormat.init(inst, def); +}); +var $ZodUUID = /* @__PURE__ */ $constructor("$ZodUUID", (inst, def) => { + if (def.version) { + const versionMap = { + v1: 1, + v2: 2, + v3: 3, + v4: 4, + v5: 5, + v6: 6, + v7: 7, + v8: 8 + }; + const v = versionMap[def.version]; + if (v === void 0) + throw new Error(`Invalid UUID version: "${def.version}"`); + def.pattern ?? (def.pattern = uuid(v)); + } else + def.pattern ?? (def.pattern = uuid()); + $ZodStringFormat.init(inst, def); +}); +var $ZodEmail = /* @__PURE__ */ $constructor("$ZodEmail", (inst, def) => { + def.pattern ?? (def.pattern = email); + $ZodStringFormat.init(inst, def); +}); +var $ZodURL = /* @__PURE__ */ $constructor("$ZodURL", (inst, def) => { + $ZodStringFormat.init(inst, def); + inst._zod.check = (payload) => { + try { + const trimmed = payload.value.trim(); + if (!def.normalize && def.protocol?.source === httpProtocol.source) { + if (!/^https?:\/\//i.test(trimmed)) { + payload.issues.push({ + code: "invalid_format", + format: "url", + note: "Invalid URL format", + input: payload.value, + inst, + continue: !def.abort + }); + return; + } + } + const url = new URL(trimmed); + if (def.hostname) { + def.hostname.lastIndex = 0; + if (!def.hostname.test(url.hostname)) { + payload.issues.push({ + code: "invalid_format", + format: "url", + note: "Invalid hostname", + pattern: def.hostname.source, + input: payload.value, + inst, + continue: !def.abort + }); + } + } + if (def.protocol) { + def.protocol.lastIndex = 0; + if (!def.protocol.test(url.protocol.endsWith(":") ? url.protocol.slice(0, -1) : url.protocol)) { + payload.issues.push({ + code: "invalid_format", + format: "url", + note: "Invalid protocol", + pattern: def.protocol.source, + input: payload.value, + inst, + continue: !def.abort + }); + } + } + if (def.normalize) { + payload.value = url.href; + } else { + payload.value = trimmed; + } + return; + } catch (_) { + payload.issues.push({ + code: "invalid_format", + format: "url", + input: payload.value, + inst, + continue: !def.abort + }); + } + }; +}); +var $ZodEmoji = /* @__PURE__ */ $constructor("$ZodEmoji", (inst, def) => { + def.pattern ?? (def.pattern = emoji()); + $ZodStringFormat.init(inst, def); +}); +var $ZodNanoID = /* @__PURE__ */ $constructor("$ZodNanoID", (inst, def) => { + def.pattern ?? (def.pattern = nanoid); + $ZodStringFormat.init(inst, def); +}); +var $ZodCUID = /* @__PURE__ */ $constructor("$ZodCUID", (inst, def) => { + def.pattern ?? (def.pattern = cuid); + $ZodStringFormat.init(inst, def); +}); +var $ZodCUID2 = /* @__PURE__ */ $constructor("$ZodCUID2", (inst, def) => { + def.pattern ?? (def.pattern = cuid2); + $ZodStringFormat.init(inst, def); +}); +var $ZodULID = /* @__PURE__ */ $constructor("$ZodULID", (inst, def) => { + def.pattern ?? (def.pattern = ulid); + $ZodStringFormat.init(inst, def); +}); +var $ZodXID = /* @__PURE__ */ $constructor("$ZodXID", (inst, def) => { + def.pattern ?? (def.pattern = xid); + $ZodStringFormat.init(inst, def); +}); +var $ZodKSUID = /* @__PURE__ */ $constructor("$ZodKSUID", (inst, def) => { + def.pattern ?? (def.pattern = ksuid); + $ZodStringFormat.init(inst, def); +}); +var $ZodISODateTime = /* @__PURE__ */ $constructor("$ZodISODateTime", (inst, def) => { + def.pattern ?? (def.pattern = datetime(def)); + $ZodStringFormat.init(inst, def); +}); +var $ZodISODate = /* @__PURE__ */ $constructor("$ZodISODate", (inst, def) => { + def.pattern ?? (def.pattern = date); + $ZodStringFormat.init(inst, def); +}); +var $ZodISOTime = /* @__PURE__ */ $constructor("$ZodISOTime", (inst, def) => { + def.pattern ?? (def.pattern = time(def)); + $ZodStringFormat.init(inst, def); +}); +var $ZodISODuration = /* @__PURE__ */ $constructor("$ZodISODuration", (inst, def) => { + def.pattern ?? (def.pattern = duration); + $ZodStringFormat.init(inst, def); +}); +var $ZodIPv4 = /* @__PURE__ */ $constructor("$ZodIPv4", (inst, def) => { + def.pattern ?? (def.pattern = ipv4); + $ZodStringFormat.init(inst, def); + inst._zod.bag.format = `ipv4`; +}); +var $ZodIPv6 = /* @__PURE__ */ $constructor("$ZodIPv6", (inst, def) => { + def.pattern ?? (def.pattern = ipv6); + $ZodStringFormat.init(inst, def); + inst._zod.bag.format = `ipv6`; + inst._zod.check = (payload) => { + try { + new URL(`http://[${payload.value}]`); + } catch { + payload.issues.push({ + code: "invalid_format", + format: "ipv6", + input: payload.value, + inst, + continue: !def.abort + }); + } + }; +}); +var $ZodCIDRv4 = /* @__PURE__ */ $constructor("$ZodCIDRv4", (inst, def) => { + def.pattern ?? (def.pattern = cidrv4); + $ZodStringFormat.init(inst, def); +}); +var $ZodCIDRv6 = /* @__PURE__ */ $constructor("$ZodCIDRv6", (inst, def) => { + def.pattern ?? (def.pattern = cidrv6); + $ZodStringFormat.init(inst, def); + inst._zod.check = (payload) => { + const parts = payload.value.split("/"); + try { + if (parts.length !== 2) + throw new Error(); + const [address, prefix] = parts; + if (!prefix) + throw new Error(); + const prefixNum = Number(prefix); + if (`${prefixNum}` !== prefix) + throw new Error(); + if (prefixNum < 0 || prefixNum > 128) + throw new Error(); + new URL(`http://[${address}]`); + } catch { + payload.issues.push({ + code: "invalid_format", + format: "cidrv6", + input: payload.value, + inst, + continue: !def.abort + }); + } + }; +}); +function isValidBase64(data) { + if (data === "") + return true; + if (/\s/.test(data)) + return false; + if (data.length % 4 !== 0) + return false; + try { + atob(data); + return true; + } catch { + return false; + } +} +var $ZodBase64 = /* @__PURE__ */ $constructor("$ZodBase64", (inst, def) => { + def.pattern ?? (def.pattern = base64); + $ZodStringFormat.init(inst, def); + inst._zod.bag.contentEncoding = "base64"; + inst._zod.check = (payload) => { + if (isValidBase64(payload.value)) + return; + payload.issues.push({ + code: "invalid_format", + format: "base64", + input: payload.value, + inst, + continue: !def.abort + }); + }; +}); +function isValidBase64URL(data) { + if (!base64url.test(data)) + return false; + const base642 = data.replace(/[-_]/g, (c) => c === "-" ? "+" : "/"); + const padded = base642.padEnd(Math.ceil(base642.length / 4) * 4, "="); + return isValidBase64(padded); +} +var $ZodBase64URL = /* @__PURE__ */ $constructor("$ZodBase64URL", (inst, def) => { + def.pattern ?? (def.pattern = base64url); + $ZodStringFormat.init(inst, def); + inst._zod.bag.contentEncoding = "base64url"; + inst._zod.check = (payload) => { + if (isValidBase64URL(payload.value)) + return; + payload.issues.push({ + code: "invalid_format", + format: "base64url", + input: payload.value, + inst, + continue: !def.abort + }); + }; +}); +var $ZodE164 = /* @__PURE__ */ $constructor("$ZodE164", (inst, def) => { + def.pattern ?? (def.pattern = e164); + $ZodStringFormat.init(inst, def); +}); +function isValidJWT(token, algorithm = null) { + try { + const tokensParts = token.split("."); + if (tokensParts.length !== 3) + return false; + const [header] = tokensParts; + if (!header) + return false; + const parsedHeader = JSON.parse(atob(header)); + if ("typ" in parsedHeader && parsedHeader?.typ !== "JWT") + return false; + if (!parsedHeader.alg) + return false; + if (algorithm && (!("alg" in parsedHeader) || parsedHeader.alg !== algorithm)) + return false; + return true; + } catch { + return false; + } +} +var $ZodJWT = /* @__PURE__ */ $constructor("$ZodJWT", (inst, def) => { + $ZodStringFormat.init(inst, def); + inst._zod.check = (payload) => { + if (isValidJWT(payload.value, def.alg)) + return; + payload.issues.push({ + code: "invalid_format", + format: "jwt", + input: payload.value, + inst, + continue: !def.abort + }); + }; +}); +var $ZodNumber = /* @__PURE__ */ $constructor("$ZodNumber", (inst, def) => { + $ZodType.init(inst, def); + inst._zod.pattern = inst._zod.bag.pattern ?? number; + inst._zod.parse = (payload, _ctx) => { + if (def.coerce) + try { + payload.value = Number(payload.value); + } catch (_) { + } + const input = payload.value; + if (typeof input === "number" && !Number.isNaN(input) && Number.isFinite(input)) { + return payload; + } + const received = typeof input === "number" ? Number.isNaN(input) ? "NaN" : !Number.isFinite(input) ? "Infinity" : void 0 : void 0; + payload.issues.push({ + expected: "number", + code: "invalid_type", + input, + inst, + ...received ? { received } : {} + }); + return payload; + }; +}); +var $ZodNumberFormat = /* @__PURE__ */ $constructor("$ZodNumberFormat", (inst, def) => { + $ZodCheckNumberFormat.init(inst, def); + $ZodNumber.init(inst, def); +}); +var $ZodBoolean = /* @__PURE__ */ $constructor("$ZodBoolean", (inst, def) => { + $ZodType.init(inst, def); + inst._zod.pattern = boolean; + inst._zod.parse = (payload, _ctx) => { + if (def.coerce) + try { + payload.value = Boolean(payload.value); + } catch (_) { + } + const input = payload.value; + if (typeof input === "boolean") + return payload; + payload.issues.push({ + expected: "boolean", + code: "invalid_type", + input, + inst + }); + return payload; + }; +}); +var $ZodUnknown = /* @__PURE__ */ $constructor("$ZodUnknown", (inst, def) => { + $ZodType.init(inst, def); + inst._zod.parse = (payload) => payload; +}); +var $ZodNever = /* @__PURE__ */ $constructor("$ZodNever", (inst, def) => { + $ZodType.init(inst, def); + inst._zod.parse = (payload, _ctx) => { + payload.issues.push({ + expected: "never", + code: "invalid_type", + input: payload.value, + inst + }); + return payload; + }; +}); +function handleArrayResult(result, final, index) { + if (result.issues.length) { + final.issues.push(...prefixIssues(index, result.issues)); + } + final.value[index] = result.value; +} +var $ZodArray = /* @__PURE__ */ $constructor("$ZodArray", (inst, def) => { + $ZodType.init(inst, def); + inst._zod.parse = (payload, ctx) => { + const input = payload.value; + if (!Array.isArray(input)) { + payload.issues.push({ + expected: "array", + code: "invalid_type", + input, + inst + }); + return payload; + } + payload.value = Array(input.length); + const proms = []; + for (let i = 0; i < input.length; i++) { + const item = input[i]; + const result = def.element._zod.run({ + value: item, + issues: [] + }, ctx); + if (result instanceof Promise) { + proms.push(result.then((result2) => handleArrayResult(result2, payload, i))); + } else { + handleArrayResult(result, payload, i); + } + } + if (proms.length) { + return Promise.all(proms).then(() => payload); + } + return payload; + }; +}); +function handlePropertyResult(result, final, key, input, isOptionalIn, isOptionalOut) { + const isPresent = key in input; + if (result.issues.length) { + if (isOptionalIn && isOptionalOut && !isPresent) { + return; + } + final.issues.push(...prefixIssues(key, result.issues)); + } + if (!isPresent && !isOptionalIn) { + if (!result.issues.length) { + final.issues.push({ + code: "invalid_type", + expected: "nonoptional", + input: void 0, + path: [key] + }); + } + return; + } + if (result.value === void 0) { + if (isPresent) { + final.value[key] = void 0; + } + } else { + final.value[key] = result.value; + } +} +function normalizeDef(def) { + const keys = Object.keys(def.shape); + for (const k of keys) { + if (!def.shape?.[k]?._zod?.traits?.has("$ZodType")) { + throw new Error(`Invalid element at key "${k}": expected a Zod schema`); + } + } + const okeys = optionalKeys(def.shape); + return { + ...def, + keys, + keySet: new Set(keys), + numKeys: keys.length, + optionalKeys: new Set(okeys) + }; +} +function handleCatchall(proms, input, payload, ctx, def, inst) { + const unrecognized = []; + const keySet = def.keySet; + const _catchall = def.catchall._zod; + const t = _catchall.def.type; + const isOptionalIn = _catchall.optin === "optional"; + const isOptionalOut = _catchall.optout === "optional"; + for (const key in input) { + if (key === "__proto__") + continue; + if (keySet.has(key)) + continue; + if (t === "never") { + unrecognized.push(key); + continue; + } + const r = _catchall.run({ value: input[key], issues: [] }, ctx); + if (r instanceof Promise) { + proms.push(r.then((r2) => handlePropertyResult(r2, payload, key, input, isOptionalIn, isOptionalOut))); + } else { + handlePropertyResult(r, payload, key, input, isOptionalIn, isOptionalOut); + } + } + if (unrecognized.length) { + payload.issues.push({ + code: "unrecognized_keys", + keys: unrecognized, + input, + inst + }); + } + if (!proms.length) + return payload; + return Promise.all(proms).then(() => { + return payload; + }); +} +var $ZodObject = /* @__PURE__ */ $constructor("$ZodObject", (inst, def) => { + $ZodType.init(inst, def); + const desc = Object.getOwnPropertyDescriptor(def, "shape"); + if (!desc?.get) { + const sh = def.shape; + Object.defineProperty(def, "shape", { + get: () => { + const newSh = { ...sh }; + Object.defineProperty(def, "shape", { + value: newSh + }); + return newSh; + } + }); + } + const _normalized = cached(() => normalizeDef(def)); + defineLazy(inst._zod, "propValues", () => { + const shape = def.shape; + const propValues = {}; + for (const key in shape) { + const field = shape[key]._zod; + if (field.values) { + propValues[key] ?? (propValues[key] = /* @__PURE__ */ new Set()); + for (const v of field.values) + propValues[key].add(v); + } + } + return propValues; + }); + const isObject2 = isObject; + const catchall = def.catchall; + let value; + inst._zod.parse = (payload, ctx) => { + value ?? (value = _normalized.value); + const input = payload.value; + if (!isObject2(input)) { + payload.issues.push({ + expected: "object", + code: "invalid_type", + input, + inst + }); + return payload; + } + payload.value = {}; + const proms = []; + const shape = value.shape; + for (const key of value.keys) { + const el = shape[key]; + const isOptionalIn = el._zod.optin === "optional"; + const isOptionalOut = el._zod.optout === "optional"; + const r = el._zod.run({ value: input[key], issues: [] }, ctx); + if (r instanceof Promise) { + proms.push(r.then((r2) => handlePropertyResult(r2, payload, key, input, isOptionalIn, isOptionalOut))); + } else { + handlePropertyResult(r, payload, key, input, isOptionalIn, isOptionalOut); + } + } + if (!catchall) { + return proms.length ? Promise.all(proms).then(() => payload) : payload; + } + return handleCatchall(proms, input, payload, ctx, _normalized.value, inst); + }; +}); +var $ZodObjectJIT = /* @__PURE__ */ $constructor("$ZodObjectJIT", (inst, def) => { + $ZodObject.init(inst, def); + const superParse = inst._zod.parse; + const _normalized = cached(() => normalizeDef(def)); + const generateFastpass = (shape) => { + const doc = new Doc(["shape", "payload", "ctx"]); + const normalized = _normalized.value; + const parseStr = (key) => { + const k = esc(key); + return `shape[${k}]._zod.run({ value: input[${k}], issues: [] }, ctx)`; + }; + doc.write(`const input = payload.value;`); + const ids = /* @__PURE__ */ Object.create(null); + let counter = 0; + for (const key of normalized.keys) { + ids[key] = `key_${counter++}`; + } + doc.write(`const newResult = {};`); + for (const key of normalized.keys) { + const id = ids[key]; + const k = esc(key); + const schema = shape[key]; + const isOptionalIn = schema?._zod?.optin === "optional"; + const isOptionalOut = schema?._zod?.optout === "optional"; + doc.write(`const ${id} = ${parseStr(key)};`); + if (isOptionalIn && isOptionalOut) { + doc.write(` + if (${id}.issues.length) { + if (${k} in input) { + payload.issues = payload.issues.concat(${id}.issues.map(iss => ({ + ...iss, + path: iss.path ? [${k}, ...iss.path] : [${k}] + }))); + } + } + + if (${id}.value === undefined) { + if (${k} in input) { + newResult[${k}] = undefined; + } + } else { + newResult[${k}] = ${id}.value; + } + + `); + } else if (!isOptionalIn) { + doc.write(` + const ${id}_present = ${k} in input; + if (${id}.issues.length) { + payload.issues = payload.issues.concat(${id}.issues.map(iss => ({ + ...iss, + path: iss.path ? [${k}, ...iss.path] : [${k}] + }))); + } + if (!${id}_present && !${id}.issues.length) { + payload.issues.push({ + code: "invalid_type", + expected: "nonoptional", + input: undefined, + path: [${k}] + }); + } + + if (${id}_present) { + if (${id}.value === undefined) { + newResult[${k}] = undefined; + } else { + newResult[${k}] = ${id}.value; + } + } + + `); + } else { + doc.write(` + if (${id}.issues.length) { + payload.issues = payload.issues.concat(${id}.issues.map(iss => ({ + ...iss, + path: iss.path ? [${k}, ...iss.path] : [${k}] + }))); + } + + if (${id}.value === undefined) { + if (${k} in input) { + newResult[${k}] = undefined; + } + } else { + newResult[${k}] = ${id}.value; + } + + `); + } + } + doc.write(`payload.value = newResult;`); + doc.write(`return payload;`); + const fn = doc.compile(); + return (payload, ctx) => fn(shape, payload, ctx); + }; + let fastpass; + const isObject2 = isObject; + const jit = !globalConfig.jitless; + const allowsEval2 = allowsEval; + const fastEnabled = jit && allowsEval2.value; + const catchall = def.catchall; + let value; + inst._zod.parse = (payload, ctx) => { + value ?? (value = _normalized.value); + const input = payload.value; + if (!isObject2(input)) { + payload.issues.push({ + expected: "object", + code: "invalid_type", + input, + inst + }); + return payload; + } + if (jit && fastEnabled && ctx?.async === false && ctx.jitless !== true) { + if (!fastpass) + fastpass = generateFastpass(def.shape); + payload = fastpass(payload, ctx); + if (!catchall) + return payload; + return handleCatchall([], input, payload, ctx, value, inst); + } + return superParse(payload, ctx); + }; +}); +function handleUnionResults(results, final, inst, ctx) { + for (const result of results) { + if (result.issues.length === 0) { + final.value = result.value; + return final; + } + } + const nonaborted = results.filter((r) => !aborted(r)); + if (nonaborted.length === 1) { + final.value = nonaborted[0].value; + return nonaborted[0]; + } + final.issues.push({ + code: "invalid_union", + input: final.value, + inst, + errors: results.map((result) => result.issues.map((iss) => finalizeIssue(iss, ctx, config()))) + }); + return final; +} +var $ZodUnion = /* @__PURE__ */ $constructor("$ZodUnion", (inst, def) => { + $ZodType.init(inst, def); + defineLazy(inst._zod, "optin", () => def.options.some((o) => o._zod.optin === "optional") ? "optional" : void 0); + defineLazy(inst._zod, "optout", () => def.options.some((o) => o._zod.optout === "optional") ? "optional" : void 0); + defineLazy(inst._zod, "values", () => { + if (def.options.every((o) => o._zod.values)) { + return new Set(def.options.flatMap((option) => Array.from(option._zod.values))); + } + return void 0; + }); + defineLazy(inst._zod, "pattern", () => { + if (def.options.every((o) => o._zod.pattern)) { + const patterns = def.options.map((o) => o._zod.pattern); + return new RegExp(`^(${patterns.map((p) => cleanRegex(p.source)).join("|")})$`); + } + return void 0; + }); + const first = def.options.length === 1 ? def.options[0]._zod.run : null; + inst._zod.parse = (payload, ctx) => { + if (first) { + return first(payload, ctx); + } + let async = false; + const results = []; + for (const option of def.options) { + const result = option._zod.run({ + value: payload.value, + issues: [] + }, ctx); + if (result instanceof Promise) { + results.push(result); + async = true; + } else { + if (result.issues.length === 0) + return result; + results.push(result); + } + } + if (!async) + return handleUnionResults(results, payload, inst, ctx); + return Promise.all(results).then((results2) => { + return handleUnionResults(results2, payload, inst, ctx); + }); + }; +}); +var $ZodIntersection = /* @__PURE__ */ $constructor("$ZodIntersection", (inst, def) => { + $ZodType.init(inst, def); + inst._zod.parse = (payload, ctx) => { + const input = payload.value; + const left = def.left._zod.run({ value: input, issues: [] }, ctx); + const right = def.right._zod.run({ value: input, issues: [] }, ctx); + const async = left instanceof Promise || right instanceof Promise; + if (async) { + return Promise.all([left, right]).then(([left2, right2]) => { + return handleIntersectionResults(payload, left2, right2); + }); + } + return handleIntersectionResults(payload, left, right); + }; +}); +function mergeValues(a, b) { + if (a === b) { + return { valid: true, data: a }; + } + if (a instanceof Date && b instanceof Date && +a === +b) { + return { valid: true, data: a }; + } + if (isPlainObject(a) && isPlainObject(b)) { + const bKeys = Object.keys(b); + const sharedKeys = Object.keys(a).filter((key) => bKeys.indexOf(key) !== -1); + const newObj = { ...a, ...b }; + for (const key of sharedKeys) { + const sharedValue = mergeValues(a[key], b[key]); + if (!sharedValue.valid) { + return { + valid: false, + mergeErrorPath: [key, ...sharedValue.mergeErrorPath] + }; + } + newObj[key] = sharedValue.data; + } + return { valid: true, data: newObj }; + } + if (Array.isArray(a) && Array.isArray(b)) { + if (a.length !== b.length) { + return { valid: false, mergeErrorPath: [] }; + } + const newArray = []; + for (let index = 0; index < a.length; index++) { + const itemA = a[index]; + const itemB = b[index]; + const sharedValue = mergeValues(itemA, itemB); + if (!sharedValue.valid) { + return { + valid: false, + mergeErrorPath: [index, ...sharedValue.mergeErrorPath] + }; + } + newArray.push(sharedValue.data); + } + return { valid: true, data: newArray }; + } + return { valid: false, mergeErrorPath: [] }; +} +function handleIntersectionResults(result, left, right) { + const unrecKeys = /* @__PURE__ */ new Map(); + let unrecIssue; + for (const iss of left.issues) { + if (iss.code === "unrecognized_keys") { + unrecIssue ?? (unrecIssue = iss); + for (const k of iss.keys) { + if (!unrecKeys.has(k)) + unrecKeys.set(k, {}); + unrecKeys.get(k).l = true; + } + } else { + result.issues.push(iss); + } + } + for (const iss of right.issues) { + if (iss.code === "unrecognized_keys") { + for (const k of iss.keys) { + if (!unrecKeys.has(k)) + unrecKeys.set(k, {}); + unrecKeys.get(k).r = true; + } + } else { + result.issues.push(iss); + } + } + const bothKeys = [...unrecKeys].filter(([, f]) => f.l && f.r).map(([k]) => k); + if (bothKeys.length && unrecIssue) { + result.issues.push({ ...unrecIssue, keys: bothKeys }); + } + if (aborted(result)) + return result; + const merged = mergeValues(left.value, right.value); + if (!merged.valid) { + throw new Error(`Unmergable intersection. Error path: ${JSON.stringify(merged.mergeErrorPath)}`); + } + result.value = merged.data; + return result; +} +var $ZodRecord = /* @__PURE__ */ $constructor("$ZodRecord", (inst, def) => { + $ZodType.init(inst, def); + inst._zod.parse = (payload, ctx) => { + const input = payload.value; + if (!isPlainObject(input)) { + payload.issues.push({ + expected: "record", + code: "invalid_type", + input, + inst + }); + return payload; + } + const proms = []; + const values = def.keyType._zod.values; + if (values) { + payload.value = {}; + const recordKeys = /* @__PURE__ */ new Set(); + for (const key of values) { + if (typeof key === "string" || typeof key === "number" || typeof key === "symbol") { + recordKeys.add(typeof key === "number" ? key.toString() : key); + const keyResult = def.keyType._zod.run({ value: key, issues: [] }, ctx); + if (keyResult instanceof Promise) { + throw new Error("Async schemas not supported in object keys currently"); + } + if (keyResult.issues.length) { + payload.issues.push({ + code: "invalid_key", + origin: "record", + issues: keyResult.issues.map((iss) => finalizeIssue(iss, ctx, config())), + input: key, + path: [key], + inst + }); + continue; + } + const outKey = keyResult.value; + const result = def.valueType._zod.run({ value: input[key], issues: [] }, ctx); + if (result instanceof Promise) { + proms.push(result.then((result2) => { + if (result2.issues.length) { + payload.issues.push(...prefixIssues(key, result2.issues)); + } + payload.value[outKey] = result2.value; + })); + } else { + if (result.issues.length) { + payload.issues.push(...prefixIssues(key, result.issues)); + } + payload.value[outKey] = result.value; + } + } + } + let unrecognized; + for (const key in input) { + if (!recordKeys.has(key)) { + unrecognized = unrecognized ?? []; + unrecognized.push(key); + } + } + if (unrecognized && unrecognized.length > 0) { + payload.issues.push({ + code: "unrecognized_keys", + input, + inst, + keys: unrecognized + }); + } + } else { + payload.value = {}; + for (const key of Reflect.ownKeys(input)) { + if (key === "__proto__") + continue; + if (!Object.prototype.propertyIsEnumerable.call(input, key)) + continue; + let keyResult = def.keyType._zod.run({ value: key, issues: [] }, ctx); + if (keyResult instanceof Promise) { + throw new Error("Async schemas not supported in object keys currently"); + } + const checkNumericKey = typeof key === "string" && number.test(key) && keyResult.issues.length; + if (checkNumericKey) { + const retryResult = def.keyType._zod.run({ value: Number(key), issues: [] }, ctx); + if (retryResult instanceof Promise) { + throw new Error("Async schemas not supported in object keys currently"); + } + if (retryResult.issues.length === 0) { + keyResult = retryResult; + } + } + if (keyResult.issues.length) { + if (def.mode === "loose") { + payload.value[key] = input[key]; + } else { + payload.issues.push({ + code: "invalid_key", + origin: "record", + issues: keyResult.issues.map((iss) => finalizeIssue(iss, ctx, config())), + input: key, + path: [key], + inst + }); + } + continue; + } + const result = def.valueType._zod.run({ value: input[key], issues: [] }, ctx); + if (result instanceof Promise) { + proms.push(result.then((result2) => { + if (result2.issues.length) { + payload.issues.push(...prefixIssues(key, result2.issues)); + } + payload.value[keyResult.value] = result2.value; + })); + } else { + if (result.issues.length) { + payload.issues.push(...prefixIssues(key, result.issues)); + } + payload.value[keyResult.value] = result.value; + } + } + } + if (proms.length) { + return Promise.all(proms).then(() => payload); + } + return payload; + }; +}); +var $ZodEnum = /* @__PURE__ */ $constructor("$ZodEnum", (inst, def) => { + $ZodType.init(inst, def); + const values = getEnumValues(def.entries); + const valuesSet = new Set(values); + inst._zod.values = valuesSet; + inst._zod.pattern = new RegExp(`^(${values.filter((k) => propertyKeyTypes.has(typeof k)).map((o) => typeof o === "string" ? escapeRegex(o) : o.toString()).join("|")})$`); + inst._zod.parse = (payload, _ctx) => { + const input = payload.value; + if (valuesSet.has(input)) { + return payload; + } + payload.issues.push({ + code: "invalid_value", + values, + input, + inst + }); + return payload; + }; +}); +var $ZodTransform = /* @__PURE__ */ $constructor("$ZodTransform", (inst, def) => { + $ZodType.init(inst, def); + inst._zod.optin = "optional"; + inst._zod.parse = (payload, ctx) => { + if (ctx.direction === "backward") { + throw new $ZodEncodeError(inst.constructor.name); + } + const _out = def.transform(payload.value, payload); + if (ctx.async) { + const output = _out instanceof Promise ? _out : Promise.resolve(_out); + return output.then((output2) => { + payload.value = output2; + payload.fallback = true; + return payload; + }); + } + if (_out instanceof Promise) { + throw new $ZodAsyncError(); + } + payload.value = _out; + payload.fallback = true; + return payload; + }; +}); +function handleOptionalResult(result, input) { + if (input === void 0 && (result.issues.length || result.fallback)) { + return { issues: [], value: void 0 }; + } + return result; +} +var $ZodOptional = /* @__PURE__ */ $constructor("$ZodOptional", (inst, def) => { + $ZodType.init(inst, def); + inst._zod.optin = "optional"; + inst._zod.optout = "optional"; + defineLazy(inst._zod, "values", () => { + return def.innerType._zod.values ? /* @__PURE__ */ new Set([...def.innerType._zod.values, void 0]) : void 0; + }); + defineLazy(inst._zod, "pattern", () => { + const pattern = def.innerType._zod.pattern; + return pattern ? new RegExp(`^(${cleanRegex(pattern.source)})?$`) : void 0; + }); + inst._zod.parse = (payload, ctx) => { + if (def.innerType._zod.optin === "optional") { + const input = payload.value; + const result = def.innerType._zod.run(payload, ctx); + if (result instanceof Promise) + return result.then((r) => handleOptionalResult(r, input)); + return handleOptionalResult(result, input); + } + if (payload.value === void 0) { + return payload; + } + return def.innerType._zod.run(payload, ctx); + }; +}); +var $ZodExactOptional = /* @__PURE__ */ $constructor("$ZodExactOptional", (inst, def) => { + $ZodOptional.init(inst, def); + defineLazy(inst._zod, "values", () => def.innerType._zod.values); + defineLazy(inst._zod, "pattern", () => def.innerType._zod.pattern); + inst._zod.parse = (payload, ctx) => { + return def.innerType._zod.run(payload, ctx); + }; +}); +var $ZodNullable = /* @__PURE__ */ $constructor("$ZodNullable", (inst, def) => { + $ZodType.init(inst, def); + defineLazy(inst._zod, "optin", () => def.innerType._zod.optin); + defineLazy(inst._zod, "optout", () => def.innerType._zod.optout); + defineLazy(inst._zod, "pattern", () => { + const pattern = def.innerType._zod.pattern; + return pattern ? new RegExp(`^(${cleanRegex(pattern.source)}|null)$`) : void 0; + }); + defineLazy(inst._zod, "values", () => { + return def.innerType._zod.values ? /* @__PURE__ */ new Set([...def.innerType._zod.values, null]) : void 0; + }); + inst._zod.parse = (payload, ctx) => { + if (payload.value === null) + return payload; + return def.innerType._zod.run(payload, ctx); + }; +}); +var $ZodDefault = /* @__PURE__ */ $constructor("$ZodDefault", (inst, def) => { + $ZodType.init(inst, def); + inst._zod.optin = "optional"; + defineLazy(inst._zod, "values", () => def.innerType._zod.values); + inst._zod.parse = (payload, ctx) => { + if (ctx.direction === "backward") { + return def.innerType._zod.run(payload, ctx); + } + if (payload.value === void 0) { + payload.value = def.defaultValue; + return payload; + } + const result = def.innerType._zod.run(payload, ctx); + if (result instanceof Promise) { + return result.then((result2) => handleDefaultResult(result2, def)); + } + return handleDefaultResult(result, def); + }; +}); +function handleDefaultResult(payload, def) { + if (payload.value === void 0) { + payload.value = def.defaultValue; + } + return payload; +} +var $ZodPrefault = /* @__PURE__ */ $constructor("$ZodPrefault", (inst, def) => { + $ZodType.init(inst, def); + inst._zod.optin = "optional"; + defineLazy(inst._zod, "values", () => def.innerType._zod.values); + inst._zod.parse = (payload, ctx) => { + if (ctx.direction === "backward") { + return def.innerType._zod.run(payload, ctx); + } + if (payload.value === void 0) { + payload.value = def.defaultValue; + } + return def.innerType._zod.run(payload, ctx); + }; +}); +var $ZodNonOptional = /* @__PURE__ */ $constructor("$ZodNonOptional", (inst, def) => { + $ZodType.init(inst, def); + defineLazy(inst._zod, "values", () => { + const v = def.innerType._zod.values; + return v ? new Set([...v].filter((x) => x !== void 0)) : void 0; + }); + inst._zod.parse = (payload, ctx) => { + const result = def.innerType._zod.run(payload, ctx); + if (result instanceof Promise) { + return result.then((result2) => handleNonOptionalResult(result2, inst)); + } + return handleNonOptionalResult(result, inst); + }; +}); +function handleNonOptionalResult(payload, inst) { + if (!payload.issues.length && payload.value === void 0) { + payload.issues.push({ + code: "invalid_type", + expected: "nonoptional", + input: payload.value, + inst + }); + } + return payload; +} +var $ZodCatch = /* @__PURE__ */ $constructor("$ZodCatch", (inst, def) => { + $ZodType.init(inst, def); + inst._zod.optin = "optional"; + defineLazy(inst._zod, "optout", () => def.innerType._zod.optout); + defineLazy(inst._zod, "values", () => def.innerType._zod.values); + inst._zod.parse = (payload, ctx) => { + if (ctx.direction === "backward") { + return def.innerType._zod.run(payload, ctx); + } + const result = def.innerType._zod.run(payload, ctx); + if (result instanceof Promise) { + return result.then((result2) => { + payload.value = result2.value; + if (result2.issues.length) { + payload.value = def.catchValue({ + ...payload, + error: { + issues: result2.issues.map((iss) => finalizeIssue(iss, ctx, config())) + }, + input: payload.value + }); + payload.issues = []; + payload.fallback = true; + } + return payload; + }); + } + payload.value = result.value; + if (result.issues.length) { + payload.value = def.catchValue({ + ...payload, + error: { + issues: result.issues.map((iss) => finalizeIssue(iss, ctx, config())) + }, + input: payload.value + }); + payload.issues = []; + payload.fallback = true; + } + return payload; + }; +}); +var $ZodPipe = /* @__PURE__ */ $constructor("$ZodPipe", (inst, def) => { + $ZodType.init(inst, def); + defineLazy(inst._zod, "values", () => def.in._zod.values); + defineLazy(inst._zod, "optin", () => def.in._zod.optin); + defineLazy(inst._zod, "optout", () => def.out._zod.optout); + defineLazy(inst._zod, "propValues", () => def.in._zod.propValues); + inst._zod.parse = (payload, ctx) => { + if (ctx.direction === "backward") { + const right = def.out._zod.run(payload, ctx); + if (right instanceof Promise) { + return right.then((right2) => handlePipeResult(right2, def.in, ctx)); + } + return handlePipeResult(right, def.in, ctx); + } + const left = def.in._zod.run(payload, ctx); + if (left instanceof Promise) { + return left.then((left2) => handlePipeResult(left2, def.out, ctx)); + } + return handlePipeResult(left, def.out, ctx); + }; +}); +function handlePipeResult(left, next, ctx) { + if (left.issues.length) { + left.aborted = true; + return left; + } + return next._zod.run({ value: left.value, issues: left.issues, fallback: left.fallback }, ctx); +} +var $ZodReadonly = /* @__PURE__ */ $constructor("$ZodReadonly", (inst, def) => { + $ZodType.init(inst, def); + defineLazy(inst._zod, "propValues", () => def.innerType._zod.propValues); + defineLazy(inst._zod, "values", () => def.innerType._zod.values); + defineLazy(inst._zod, "optin", () => def.innerType?._zod?.optin); + defineLazy(inst._zod, "optout", () => def.innerType?._zod?.optout); + inst._zod.parse = (payload, ctx) => { + if (ctx.direction === "backward") { + return def.innerType._zod.run(payload, ctx); + } + const result = def.innerType._zod.run(payload, ctx); + if (result instanceof Promise) { + return result.then(handleReadonlyResult); + } + return handleReadonlyResult(result); + }; +}); +function handleReadonlyResult(payload) { + payload.value = Object.freeze(payload.value); + return payload; +} +var $ZodCustom = /* @__PURE__ */ $constructor("$ZodCustom", (inst, def) => { + $ZodCheck.init(inst, def); + $ZodType.init(inst, def); + inst._zod.parse = (payload, _) => { + return payload; + }; + inst._zod.check = (payload) => { + const input = payload.value; + const r = def.fn(input); + if (r instanceof Promise) { + return r.then((r2) => handleRefineResult(r2, payload, input, inst)); + } + handleRefineResult(r, payload, input, inst); + return; + }; +}); +function handleRefineResult(result, payload, input, inst) { + if (!result) { + const _iss = { + code: "custom", + input, + inst, + // incorporates params.error into issue reporting + path: [...inst._zod.def.path ?? []], + // incorporates params.error into issue reporting + continue: !inst._zod.def.abort + // params: inst._zod.def.params, + }; + if (inst._zod.def.params) + _iss.params = inst._zod.def.params; + payload.issues.push(issue(_iss)); + } +} + +// node_modules/zod/v4/core/registries.js +var _a2; +var $ZodRegistry = class { + constructor() { + this._map = /* @__PURE__ */ new WeakMap(); + this._idmap = /* @__PURE__ */ new Map(); + } + add(schema, ..._meta) { + const meta2 = _meta[0]; + this._map.set(schema, meta2); + if (meta2 && typeof meta2 === "object" && "id" in meta2) { + this._idmap.set(meta2.id, schema); + } + return this; + } + clear() { + this._map = /* @__PURE__ */ new WeakMap(); + this._idmap = /* @__PURE__ */ new Map(); + return this; + } + remove(schema) { + const meta2 = this._map.get(schema); + if (meta2 && typeof meta2 === "object" && "id" in meta2) { + this._idmap.delete(meta2.id); + } + this._map.delete(schema); + return this; + } + get(schema) { + const p = schema._zod.parent; + if (p) { + const pm = { ...this.get(p) ?? {} }; + delete pm.id; + const f = { ...pm, ...this._map.get(schema) }; + return Object.keys(f).length ? f : void 0; + } + return this._map.get(schema); + } + has(schema) { + return this._map.has(schema); + } +}; +function registry() { + return new $ZodRegistry(); +} +(_a2 = globalThis).__zod_globalRegistry ?? (_a2.__zod_globalRegistry = registry()); +var globalRegistry = globalThis.__zod_globalRegistry; + +// node_modules/zod/v4/core/api.js +// @__NO_SIDE_EFFECTS__ +function _string(Class2, params) { + return new Class2({ + type: "string", + ...normalizeParams(params) + }); +} +// @__NO_SIDE_EFFECTS__ +function _email(Class2, params) { + return new Class2({ + type: "string", + format: "email", + check: "string_format", + abort: false, + ...normalizeParams(params) + }); +} +// @__NO_SIDE_EFFECTS__ +function _guid(Class2, params) { + return new Class2({ + type: "string", + format: "guid", + check: "string_format", + abort: false, + ...normalizeParams(params) + }); +} +// @__NO_SIDE_EFFECTS__ +function _uuid(Class2, params) { + return new Class2({ + type: "string", + format: "uuid", + check: "string_format", + abort: false, + ...normalizeParams(params) + }); +} +// @__NO_SIDE_EFFECTS__ +function _uuidv4(Class2, params) { + return new Class2({ + type: "string", + format: "uuid", + check: "string_format", + abort: false, + version: "v4", + ...normalizeParams(params) + }); +} +// @__NO_SIDE_EFFECTS__ +function _uuidv6(Class2, params) { + return new Class2({ + type: "string", + format: "uuid", + check: "string_format", + abort: false, + version: "v6", + ...normalizeParams(params) + }); +} +// @__NO_SIDE_EFFECTS__ +function _uuidv7(Class2, params) { + return new Class2({ + type: "string", + format: "uuid", + check: "string_format", + abort: false, + version: "v7", + ...normalizeParams(params) + }); +} +// @__NO_SIDE_EFFECTS__ +function _url(Class2, params) { + return new Class2({ + type: "string", + format: "url", + check: "string_format", + abort: false, + ...normalizeParams(params) + }); +} +// @__NO_SIDE_EFFECTS__ +function _emoji2(Class2, params) { + return new Class2({ + type: "string", + format: "emoji", + check: "string_format", + abort: false, + ...normalizeParams(params) + }); +} +// @__NO_SIDE_EFFECTS__ +function _nanoid(Class2, params) { + return new Class2({ + type: "string", + format: "nanoid", + check: "string_format", + abort: false, + ...normalizeParams(params) + }); +} +// @__NO_SIDE_EFFECTS__ +function _cuid(Class2, params) { + return new Class2({ + type: "string", + format: "cuid", + check: "string_format", + abort: false, + ...normalizeParams(params) + }); +} +// @__NO_SIDE_EFFECTS__ +function _cuid2(Class2, params) { + return new Class2({ + type: "string", + format: "cuid2", + check: "string_format", + abort: false, + ...normalizeParams(params) + }); +} +// @__NO_SIDE_EFFECTS__ +function _ulid(Class2, params) { + return new Class2({ + type: "string", + format: "ulid", + check: "string_format", + abort: false, + ...normalizeParams(params) + }); +} +// @__NO_SIDE_EFFECTS__ +function _xid(Class2, params) { + return new Class2({ + type: "string", + format: "xid", + check: "string_format", + abort: false, + ...normalizeParams(params) + }); +} +// @__NO_SIDE_EFFECTS__ +function _ksuid(Class2, params) { + return new Class2({ + type: "string", + format: "ksuid", + check: "string_format", + abort: false, + ...normalizeParams(params) + }); +} +// @__NO_SIDE_EFFECTS__ +function _ipv4(Class2, params) { + return new Class2({ + type: "string", + format: "ipv4", + check: "string_format", + abort: false, + ...normalizeParams(params) + }); +} +// @__NO_SIDE_EFFECTS__ +function _ipv6(Class2, params) { + return new Class2({ + type: "string", + format: "ipv6", + check: "string_format", + abort: false, + ...normalizeParams(params) + }); +} +// @__NO_SIDE_EFFECTS__ +function _cidrv4(Class2, params) { + return new Class2({ + type: "string", + format: "cidrv4", + check: "string_format", + abort: false, + ...normalizeParams(params) + }); +} +// @__NO_SIDE_EFFECTS__ +function _cidrv6(Class2, params) { + return new Class2({ + type: "string", + format: "cidrv6", + check: "string_format", + abort: false, + ...normalizeParams(params) + }); +} +// @__NO_SIDE_EFFECTS__ +function _base64(Class2, params) { + return new Class2({ + type: "string", + format: "base64", + check: "string_format", + abort: false, + ...normalizeParams(params) + }); +} +// @__NO_SIDE_EFFECTS__ +function _base64url(Class2, params) { + return new Class2({ + type: "string", + format: "base64url", + check: "string_format", + abort: false, + ...normalizeParams(params) + }); +} +// @__NO_SIDE_EFFECTS__ +function _e164(Class2, params) { + return new Class2({ + type: "string", + format: "e164", + check: "string_format", + abort: false, + ...normalizeParams(params) + }); +} +// @__NO_SIDE_EFFECTS__ +function _jwt(Class2, params) { + return new Class2({ + type: "string", + format: "jwt", + check: "string_format", + abort: false, + ...normalizeParams(params) + }); +} +// @__NO_SIDE_EFFECTS__ +function _isoDateTime(Class2, params) { + return new Class2({ + type: "string", + format: "datetime", + check: "string_format", + offset: false, + local: false, + precision: null, + ...normalizeParams(params) + }); +} +// @__NO_SIDE_EFFECTS__ +function _isoDate(Class2, params) { + return new Class2({ + type: "string", + format: "date", + check: "string_format", + ...normalizeParams(params) + }); +} +// @__NO_SIDE_EFFECTS__ +function _isoTime(Class2, params) { + return new Class2({ + type: "string", + format: "time", + check: "string_format", + precision: null, + ...normalizeParams(params) + }); +} +// @__NO_SIDE_EFFECTS__ +function _isoDuration(Class2, params) { + return new Class2({ + type: "string", + format: "duration", + check: "string_format", + ...normalizeParams(params) + }); +} +// @__NO_SIDE_EFFECTS__ +function _number(Class2, params) { + return new Class2({ + type: "number", + checks: [], + ...normalizeParams(params) + }); +} +// @__NO_SIDE_EFFECTS__ +function _int(Class2, params) { + return new Class2({ + type: "number", + check: "number_format", + abort: false, + format: "safeint", + ...normalizeParams(params) + }); +} +// @__NO_SIDE_EFFECTS__ +function _boolean(Class2, params) { + return new Class2({ + type: "boolean", + ...normalizeParams(params) + }); +} +// @__NO_SIDE_EFFECTS__ +function _unknown(Class2) { + return new Class2({ + type: "unknown" + }); +} +// @__NO_SIDE_EFFECTS__ +function _never(Class2, params) { + return new Class2({ + type: "never", + ...normalizeParams(params) + }); +} +// @__NO_SIDE_EFFECTS__ +function _lt(value, params) { + return new $ZodCheckLessThan({ + check: "less_than", + ...normalizeParams(params), + value, + inclusive: false + }); +} +// @__NO_SIDE_EFFECTS__ +function _lte(value, params) { + return new $ZodCheckLessThan({ + check: "less_than", + ...normalizeParams(params), + value, + inclusive: true + }); +} +// @__NO_SIDE_EFFECTS__ +function _gt(value, params) { + return new $ZodCheckGreaterThan({ + check: "greater_than", + ...normalizeParams(params), + value, + inclusive: false + }); +} +// @__NO_SIDE_EFFECTS__ +function _gte(value, params) { + return new $ZodCheckGreaterThan({ + check: "greater_than", + ...normalizeParams(params), + value, + inclusive: true + }); +} +// @__NO_SIDE_EFFECTS__ +function _multipleOf(value, params) { + return new $ZodCheckMultipleOf({ + check: "multiple_of", + ...normalizeParams(params), + value + }); +} +// @__NO_SIDE_EFFECTS__ +function _maxLength(maximum, params) { + const ch = new $ZodCheckMaxLength({ + check: "max_length", + ...normalizeParams(params), + maximum + }); + return ch; +} +// @__NO_SIDE_EFFECTS__ +function _minLength(minimum, params) { + return new $ZodCheckMinLength({ + check: "min_length", + ...normalizeParams(params), + minimum + }); +} +// @__NO_SIDE_EFFECTS__ +function _length(length, params) { + return new $ZodCheckLengthEquals({ + check: "length_equals", + ...normalizeParams(params), + length + }); +} +// @__NO_SIDE_EFFECTS__ +function _regex(pattern, params) { + return new $ZodCheckRegex({ + check: "string_format", + format: "regex", + ...normalizeParams(params), + pattern + }); +} +// @__NO_SIDE_EFFECTS__ +function _lowercase(params) { + return new $ZodCheckLowerCase({ + check: "string_format", + format: "lowercase", + ...normalizeParams(params) + }); +} +// @__NO_SIDE_EFFECTS__ +function _uppercase(params) { + return new $ZodCheckUpperCase({ + check: "string_format", + format: "uppercase", + ...normalizeParams(params) + }); +} +// @__NO_SIDE_EFFECTS__ +function _includes(includes, params) { + return new $ZodCheckIncludes({ + check: "string_format", + format: "includes", + ...normalizeParams(params), + includes + }); +} +// @__NO_SIDE_EFFECTS__ +function _startsWith(prefix, params) { + return new $ZodCheckStartsWith({ + check: "string_format", + format: "starts_with", + ...normalizeParams(params), + prefix + }); +} +// @__NO_SIDE_EFFECTS__ +function _endsWith(suffix, params) { + return new $ZodCheckEndsWith({ + check: "string_format", + format: "ends_with", + ...normalizeParams(params), + suffix + }); +} +// @__NO_SIDE_EFFECTS__ +function _overwrite(tx) { + return new $ZodCheckOverwrite({ + check: "overwrite", + tx + }); +} +// @__NO_SIDE_EFFECTS__ +function _normalize(form) { + return /* @__PURE__ */ _overwrite((input) => input.normalize(form)); +} +// @__NO_SIDE_EFFECTS__ +function _trim() { + return /* @__PURE__ */ _overwrite((input) => input.trim()); +} +// @__NO_SIDE_EFFECTS__ +function _toLowerCase() { + return /* @__PURE__ */ _overwrite((input) => input.toLowerCase()); +} +// @__NO_SIDE_EFFECTS__ +function _toUpperCase() { + return /* @__PURE__ */ _overwrite((input) => input.toUpperCase()); +} +// @__NO_SIDE_EFFECTS__ +function _slugify() { + return /* @__PURE__ */ _overwrite((input) => slugify(input)); +} +// @__NO_SIDE_EFFECTS__ +function _array(Class2, element, params) { + return new Class2({ + type: "array", + element, + // get element() { + // return element; + // }, + ...normalizeParams(params) + }); +} +// @__NO_SIDE_EFFECTS__ +function _refine(Class2, fn, _params) { + const schema = new Class2({ + type: "custom", + check: "custom", + fn, + ...normalizeParams(_params) + }); + return schema; +} +// @__NO_SIDE_EFFECTS__ +function _superRefine(fn, params) { + const ch = /* @__PURE__ */ _check((payload) => { + payload.addIssue = (issue2) => { + if (typeof issue2 === "string") { + payload.issues.push(issue(issue2, payload.value, ch._zod.def)); + } else { + const _issue = issue2; + if (_issue.fatal) + _issue.continue = false; + _issue.code ?? (_issue.code = "custom"); + _issue.input ?? (_issue.input = payload.value); + _issue.inst ?? (_issue.inst = ch); + _issue.continue ?? (_issue.continue = !ch._zod.def.abort); + payload.issues.push(issue(_issue)); + } + }; + return fn(payload.value, payload); + }, params); + return ch; +} +// @__NO_SIDE_EFFECTS__ +function _check(fn, params) { + const ch = new $ZodCheck({ + check: "custom", + ...normalizeParams(params) + }); + ch._zod.check = fn; + return ch; +} + +// node_modules/zod/v4/core/to-json-schema.js +function initializeContext(params) { + let target = params?.target ?? "draft-2020-12"; + if (target === "draft-4") + target = "draft-04"; + if (target === "draft-7") + target = "draft-07"; + return { + processors: params.processors ?? {}, + metadataRegistry: params?.metadata ?? globalRegistry, + target, + unrepresentable: params?.unrepresentable ?? "throw", + override: params?.override ?? (() => { + }), + io: params?.io ?? "output", + counter: 0, + seen: /* @__PURE__ */ new Map(), + cycles: params?.cycles ?? "ref", + reused: params?.reused ?? "inline", + external: params?.external ?? void 0 + }; +} +function process2(schema, ctx, _params = { path: [], schemaPath: [] }) { + var _a3; + const def = schema._zod.def; + const seen = ctx.seen.get(schema); + if (seen) { + seen.count++; + const isCycle = _params.schemaPath.includes(schema); + if (isCycle) { + seen.cycle = _params.path; + } + return seen.schema; + } + const result = { schema: {}, count: 1, cycle: void 0, path: _params.path }; + ctx.seen.set(schema, result); + const overrideSchema = schema._zod.toJSONSchema?.(); + if (overrideSchema) { + result.schema = overrideSchema; + } else { + const params = { + ..._params, + schemaPath: [..._params.schemaPath, schema], + path: _params.path + }; + if (schema._zod.processJSONSchema) { + schema._zod.processJSONSchema(ctx, result.schema, params); + } else { + const _json = result.schema; + const processor = ctx.processors[def.type]; + if (!processor) { + throw new Error(`[toJSONSchema]: Non-representable type encountered: ${def.type}`); + } + processor(schema, ctx, _json, params); + } + const parent = schema._zod.parent; + if (parent) { + if (!result.ref) + result.ref = parent; + process2(parent, ctx, params); + ctx.seen.get(parent).isParent = true; + } + } + const meta2 = ctx.metadataRegistry.get(schema); + if (meta2) + Object.assign(result.schema, meta2); + if (ctx.io === "input" && isTransforming(schema)) { + delete result.schema.examples; + delete result.schema.default; + } + if (ctx.io === "input" && "_prefault" in result.schema) + (_a3 = result.schema).default ?? (_a3.default = result.schema._prefault); + delete result.schema._prefault; + const _result = ctx.seen.get(schema); + return _result.schema; +} +function extractDefs(ctx, schema) { + const root = ctx.seen.get(schema); + if (!root) + throw new Error("Unprocessed schema. This is a bug in Zod."); + const idToSchema = /* @__PURE__ */ new Map(); + for (const entry of ctx.seen.entries()) { + const id = ctx.metadataRegistry.get(entry[0])?.id; + if (id) { + const existing = idToSchema.get(id); + if (existing && existing !== entry[0]) { + throw new Error(`Duplicate schema id "${id}" detected during JSON Schema conversion. Two different schemas cannot share the same id when converted together.`); + } + idToSchema.set(id, entry[0]); + } + } + const makeURI = (entry) => { + const defsSegment = ctx.target === "draft-2020-12" ? "$defs" : "definitions"; + if (ctx.external) { + const externalId = ctx.external.registry.get(entry[0])?.id; + const uriGenerator = ctx.external.uri ?? ((id2) => id2); + if (externalId) { + return { ref: uriGenerator(externalId) }; + } + const id = entry[1].defId ?? entry[1].schema.id ?? `schema${ctx.counter++}`; + entry[1].defId = id; + return { defId: id, ref: `${uriGenerator("__shared")}#/${defsSegment}/${id}` }; + } + if (entry[1] === root) { + return { ref: "#" }; + } + const uriPrefix = `#`; + const defUriPrefix = `${uriPrefix}/${defsSegment}/`; + const defId = entry[1].schema.id ?? `__schema${ctx.counter++}`; + return { defId, ref: defUriPrefix + defId }; + }; + const extractToDef = (entry) => { + if (entry[1].schema.$ref) { + return; + } + const seen = entry[1]; + const { ref, defId } = makeURI(entry); + seen.def = { ...seen.schema }; + if (defId) + seen.defId = defId; + const schema2 = seen.schema; + for (const key in schema2) { + delete schema2[key]; + } + schema2.$ref = ref; + }; + if (ctx.cycles === "throw") { + for (const entry of ctx.seen.entries()) { + const seen = entry[1]; + if (seen.cycle) { + throw new Error(`Cycle detected: #/${seen.cycle?.join("/")}/ + +Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.`); + } + } + } + for (const entry of ctx.seen.entries()) { + const seen = entry[1]; + if (schema === entry[0]) { + extractToDef(entry); + continue; + } + if (ctx.external) { + const ext = ctx.external.registry.get(entry[0])?.id; + if (schema !== entry[0] && ext) { + extractToDef(entry); + continue; + } + } + const id = ctx.metadataRegistry.get(entry[0])?.id; + if (id) { + extractToDef(entry); + continue; + } + if (seen.cycle) { + extractToDef(entry); + continue; + } + if (seen.count > 1) { + if (ctx.reused === "ref") { + extractToDef(entry); + continue; + } + } + } +} +function finalize(ctx, schema) { + const root = ctx.seen.get(schema); + if (!root) + throw new Error("Unprocessed schema. This is a bug in Zod."); + const flattenRef = (zodSchema) => { + const seen = ctx.seen.get(zodSchema); + if (seen.ref === null) + return; + const schema2 = seen.def ?? seen.schema; + const _cached = { ...schema2 }; + const ref = seen.ref; + seen.ref = null; + if (ref) { + flattenRef(ref); + const refSeen = ctx.seen.get(ref); + const refSchema = refSeen.schema; + if (refSchema.$ref && (ctx.target === "draft-07" || ctx.target === "draft-04" || ctx.target === "openapi-3.0")) { + schema2.allOf = schema2.allOf ?? []; + schema2.allOf.push(refSchema); + } else { + Object.assign(schema2, refSchema); + } + Object.assign(schema2, _cached); + const isParentRef = zodSchema._zod.parent === ref; + if (isParentRef) { + for (const key in schema2) { + if (key === "$ref" || key === "allOf") + continue; + if (!(key in _cached)) { + delete schema2[key]; + } + } + } + if (refSchema.$ref && refSeen.def) { + for (const key in schema2) { + if (key === "$ref" || key === "allOf") + continue; + if (key in refSeen.def && JSON.stringify(schema2[key]) === JSON.stringify(refSeen.def[key])) { + delete schema2[key]; + } + } + } + } + const parent = zodSchema._zod.parent; + if (parent && parent !== ref) { + flattenRef(parent); + const parentSeen = ctx.seen.get(parent); + if (parentSeen?.schema.$ref) { + schema2.$ref = parentSeen.schema.$ref; + if (parentSeen.def) { + for (const key in schema2) { + if (key === "$ref" || key === "allOf") + continue; + if (key in parentSeen.def && JSON.stringify(schema2[key]) === JSON.stringify(parentSeen.def[key])) { + delete schema2[key]; + } + } + } + } + } + ctx.override({ + zodSchema, + jsonSchema: schema2, + path: seen.path ?? [] + }); + }; + for (const entry of [...ctx.seen.entries()].reverse()) { + flattenRef(entry[0]); + } + const result = {}; + if (ctx.target === "draft-2020-12") { + result.$schema = "https://json-schema.org/draft/2020-12/schema"; + } else if (ctx.target === "draft-07") { + result.$schema = "http://json-schema.org/draft-07/schema#"; + } else if (ctx.target === "draft-04") { + result.$schema = "http://json-schema.org/draft-04/schema#"; + } else if (ctx.target === "openapi-3.0") { + } else { + } + if (ctx.external?.uri) { + const id = ctx.external.registry.get(schema)?.id; + if (!id) + throw new Error("Schema is missing an `id` property"); + result.$id = ctx.external.uri(id); + } + Object.assign(result, root.def ?? root.schema); + const rootMetaId = ctx.metadataRegistry.get(schema)?.id; + if (rootMetaId !== void 0 && result.id === rootMetaId) + delete result.id; + const defs = ctx.external?.defs ?? {}; + for (const entry of ctx.seen.entries()) { + const seen = entry[1]; + if (seen.def && seen.defId) { + if (seen.def.id === seen.defId) + delete seen.def.id; + defs[seen.defId] = seen.def; + } + } + if (ctx.external) { + } else { + if (Object.keys(defs).length > 0) { + if (ctx.target === "draft-2020-12") { + result.$defs = defs; + } else { + result.definitions = defs; + } + } + } + try { + const finalized = JSON.parse(JSON.stringify(result)); + Object.defineProperty(finalized, "~standard", { + value: { + ...schema["~standard"], + jsonSchema: { + input: createStandardJSONSchemaMethod(schema, "input", ctx.processors), + output: createStandardJSONSchemaMethod(schema, "output", ctx.processors) + } + }, + enumerable: false, + writable: false + }); + return finalized; + } catch (_err) { + throw new Error("Error converting schema to JSON."); + } +} +function isTransforming(_schema, _ctx) { + const ctx = _ctx ?? { seen: /* @__PURE__ */ new Set() }; + if (ctx.seen.has(_schema)) + return false; + ctx.seen.add(_schema); + const def = _schema._zod.def; + if (def.type === "transform") + return true; + if (def.type === "array") + return isTransforming(def.element, ctx); + if (def.type === "set") + return isTransforming(def.valueType, ctx); + if (def.type === "lazy") + return isTransforming(def.getter(), ctx); + if (def.type === "promise" || def.type === "optional" || def.type === "nonoptional" || def.type === "nullable" || def.type === "readonly" || def.type === "default" || def.type === "prefault") { + return isTransforming(def.innerType, ctx); + } + if (def.type === "intersection") { + return isTransforming(def.left, ctx) || isTransforming(def.right, ctx); + } + if (def.type === "record" || def.type === "map") { + return isTransforming(def.keyType, ctx) || isTransforming(def.valueType, ctx); + } + if (def.type === "pipe") { + if (_schema._zod.traits.has("$ZodCodec")) + return true; + return isTransforming(def.in, ctx) || isTransforming(def.out, ctx); + } + if (def.type === "object") { + for (const key in def.shape) { + if (isTransforming(def.shape[key], ctx)) + return true; + } + return false; + } + if (def.type === "union") { + for (const option of def.options) { + if (isTransforming(option, ctx)) + return true; + } + return false; + } + if (def.type === "tuple") { + for (const item of def.items) { + if (isTransforming(item, ctx)) + return true; + } + if (def.rest && isTransforming(def.rest, ctx)) + return true; + return false; + } + return false; +} +var createToJSONSchemaMethod = (schema, processors = {}) => (params) => { + const ctx = initializeContext({ ...params, processors }); + process2(schema, ctx); + extractDefs(ctx, schema); + return finalize(ctx, schema); +}; +var createStandardJSONSchemaMethod = (schema, io, processors = {}) => (params) => { + const { libraryOptions, target } = params ?? {}; + const ctx = initializeContext({ ...libraryOptions ?? {}, target, io, processors }); + process2(schema, ctx); + extractDefs(ctx, schema); + return finalize(ctx, schema); +}; + +// node_modules/zod/v4/core/json-schema-processors.js +var formatMap = { + guid: "uuid", + url: "uri", + datetime: "date-time", + json_string: "json-string", + regex: "" + // do not set +}; +var stringProcessor = (schema, ctx, _json, _params) => { + const json = _json; + json.type = "string"; + const { minimum, maximum, format, patterns, contentEncoding } = schema._zod.bag; + if (typeof minimum === "number") + json.minLength = minimum; + if (typeof maximum === "number") + json.maxLength = maximum; + if (format) { + json.format = formatMap[format] ?? format; + if (json.format === "") + delete json.format; + if (format === "time") { + delete json.format; + } + } + if (contentEncoding) + json.contentEncoding = contentEncoding; + if (patterns && patterns.size > 0) { + const regexes = [...patterns]; + if (regexes.length === 1) + json.pattern = regexes[0].source; + else if (regexes.length > 1) { + json.allOf = [ + ...regexes.map((regex) => ({ + ...ctx.target === "draft-07" || ctx.target === "draft-04" || ctx.target === "openapi-3.0" ? { type: "string" } : {}, + pattern: regex.source + })) + ]; + } + } +}; +var numberProcessor = (schema, ctx, _json, _params) => { + const json = _json; + const { minimum, maximum, format, multipleOf, exclusiveMaximum, exclusiveMinimum } = schema._zod.bag; + if (typeof format === "string" && format.includes("int")) + json.type = "integer"; + else + json.type = "number"; + const exMin = typeof exclusiveMinimum === "number" && exclusiveMinimum >= (minimum ?? Number.NEGATIVE_INFINITY); + const exMax = typeof exclusiveMaximum === "number" && exclusiveMaximum <= (maximum ?? Number.POSITIVE_INFINITY); + const legacy = ctx.target === "draft-04" || ctx.target === "openapi-3.0"; + if (exMin) { + if (legacy) { + json.minimum = exclusiveMinimum; + json.exclusiveMinimum = true; + } else { + json.exclusiveMinimum = exclusiveMinimum; + } + } else if (typeof minimum === "number") { + json.minimum = minimum; + } + if (exMax) { + if (legacy) { + json.maximum = exclusiveMaximum; + json.exclusiveMaximum = true; + } else { + json.exclusiveMaximum = exclusiveMaximum; + } + } else if (typeof maximum === "number") { + json.maximum = maximum; + } + if (typeof multipleOf === "number") + json.multipleOf = multipleOf; +}; +var booleanProcessor = (_schema, _ctx, json, _params) => { + json.type = "boolean"; +}; +var neverProcessor = (_schema, _ctx, json, _params) => { + json.not = {}; +}; +var unknownProcessor = (_schema, _ctx, _json, _params) => { +}; +var enumProcessor = (schema, _ctx, json, _params) => { + const def = schema._zod.def; + const values = getEnumValues(def.entries); + if (values.every((v) => typeof v === "number")) + json.type = "number"; + if (values.every((v) => typeof v === "string")) + json.type = "string"; + json.enum = values; +}; +var customProcessor = (_schema, ctx, _json, _params) => { + if (ctx.unrepresentable === "throw") { + throw new Error("Custom types cannot be represented in JSON Schema"); + } +}; +var transformProcessor = (_schema, ctx, _json, _params) => { + if (ctx.unrepresentable === "throw") { + throw new Error("Transforms cannot be represented in JSON Schema"); + } +}; +var arrayProcessor = (schema, ctx, _json, params) => { + const json = _json; + const def = schema._zod.def; + const { minimum, maximum } = schema._zod.bag; + if (typeof minimum === "number") + json.minItems = minimum; + if (typeof maximum === "number") + json.maxItems = maximum; + json.type = "array"; + json.items = process2(def.element, ctx, { + ...params, + path: [...params.path, "items"] + }); +}; +var objectProcessor = (schema, ctx, _json, params) => { + const json = _json; + const def = schema._zod.def; + json.type = "object"; + json.properties = {}; + const shape = def.shape; + for (const key in shape) { + json.properties[key] = process2(shape[key], ctx, { + ...params, + path: [...params.path, "properties", key] + }); + } + const allKeys = new Set(Object.keys(shape)); + const requiredKeys = new Set([...allKeys].filter((key) => { + const v = def.shape[key]._zod; + if (ctx.io === "input") { + return v.optin === void 0; + } else { + return v.optout === void 0; + } + })); + if (requiredKeys.size > 0) { + json.required = Array.from(requiredKeys); + } + if (def.catchall?._zod.def.type === "never") { + json.additionalProperties = false; + } else if (!def.catchall) { + if (ctx.io === "output") + json.additionalProperties = false; + } else if (def.catchall) { + json.additionalProperties = process2(def.catchall, ctx, { + ...params, + path: [...params.path, "additionalProperties"] + }); + } +}; +var unionProcessor = (schema, ctx, json, params) => { + const def = schema._zod.def; + const isExclusive = def.inclusive === false; + const options = def.options.map((x, i) => process2(x, ctx, { + ...params, + path: [...params.path, isExclusive ? "oneOf" : "anyOf", i] + })); + if (isExclusive) { + json.oneOf = options; + } else { + json.anyOf = options; + } +}; +var intersectionProcessor = (schema, ctx, json, params) => { + const def = schema._zod.def; + const a = process2(def.left, ctx, { + ...params, + path: [...params.path, "allOf", 0] + }); + const b = process2(def.right, ctx, { + ...params, + path: [...params.path, "allOf", 1] + }); + const isSimpleIntersection = (val) => "allOf" in val && Object.keys(val).length === 1; + const allOf = [ + ...isSimpleIntersection(a) ? a.allOf : [a], + ...isSimpleIntersection(b) ? b.allOf : [b] + ]; + json.allOf = allOf; +}; +var recordProcessor = (schema, ctx, _json, params) => { + const json = _json; + const def = schema._zod.def; + json.type = "object"; + const keyType = def.keyType; + const keyBag = keyType._zod.bag; + const patterns = keyBag?.patterns; + if (def.mode === "loose" && patterns && patterns.size > 0) { + const valueSchema = process2(def.valueType, ctx, { + ...params, + path: [...params.path, "patternProperties", "*"] + }); + json.patternProperties = {}; + for (const pattern of patterns) { + json.patternProperties[pattern.source] = valueSchema; + } + } else { + if (ctx.target === "draft-07" || ctx.target === "draft-2020-12") { + json.propertyNames = process2(def.keyType, ctx, { + ...params, + path: [...params.path, "propertyNames"] + }); + } + json.additionalProperties = process2(def.valueType, ctx, { + ...params, + path: [...params.path, "additionalProperties"] + }); + } + const keyValues = keyType._zod.values; + if (keyValues) { + const validKeyValues = [...keyValues].filter((v) => typeof v === "string" || typeof v === "number"); + if (validKeyValues.length > 0) { + json.required = validKeyValues; + } + } +}; +var nullableProcessor = (schema, ctx, json, params) => { + const def = schema._zod.def; + const inner = process2(def.innerType, ctx, params); + const seen = ctx.seen.get(schema); + if (ctx.target === "openapi-3.0") { + seen.ref = def.innerType; + json.nullable = true; + } else { + json.anyOf = [inner, { type: "null" }]; + } +}; +var nonoptionalProcessor = (schema, ctx, _json, params) => { + const def = schema._zod.def; + process2(def.innerType, ctx, params); + const seen = ctx.seen.get(schema); + seen.ref = def.innerType; +}; +var defaultProcessor = (schema, ctx, json, params) => { + const def = schema._zod.def; + process2(def.innerType, ctx, params); + const seen = ctx.seen.get(schema); + seen.ref = def.innerType; + json.default = JSON.parse(JSON.stringify(def.defaultValue)); +}; +var prefaultProcessor = (schema, ctx, json, params) => { + const def = schema._zod.def; + process2(def.innerType, ctx, params); + const seen = ctx.seen.get(schema); + seen.ref = def.innerType; + if (ctx.io === "input") + json._prefault = JSON.parse(JSON.stringify(def.defaultValue)); +}; +var catchProcessor = (schema, ctx, json, params) => { + const def = schema._zod.def; + process2(def.innerType, ctx, params); + const seen = ctx.seen.get(schema); + seen.ref = def.innerType; + let catchValue; + try { + catchValue = def.catchValue(void 0); + } catch { + throw new Error("Dynamic catch values are not supported in JSON Schema"); + } + json.default = catchValue; +}; +var pipeProcessor = (schema, ctx, _json, params) => { + const def = schema._zod.def; + const inIsTransform = def.in._zod.traits.has("$ZodTransform"); + const innerType = ctx.io === "input" ? inIsTransform ? def.out : def.in : def.out; + process2(innerType, ctx, params); + const seen = ctx.seen.get(schema); + seen.ref = innerType; +}; +var readonlyProcessor = (schema, ctx, json, params) => { + const def = schema._zod.def; + process2(def.innerType, ctx, params); + const seen = ctx.seen.get(schema); + seen.ref = def.innerType; + json.readOnly = true; +}; +var optionalProcessor = (schema, ctx, _json, params) => { + const def = schema._zod.def; + process2(def.innerType, ctx, params); + const seen = ctx.seen.get(schema); + seen.ref = def.innerType; +}; + +// node_modules/zod/v4/classic/iso.js +var ZodISODateTime = /* @__PURE__ */ $constructor("ZodISODateTime", (inst, def) => { + $ZodISODateTime.init(inst, def); + ZodStringFormat.init(inst, def); +}); +function datetime2(params) { + return _isoDateTime(ZodISODateTime, params); +} +var ZodISODate = /* @__PURE__ */ $constructor("ZodISODate", (inst, def) => { + $ZodISODate.init(inst, def); + ZodStringFormat.init(inst, def); +}); +function date2(params) { + return _isoDate(ZodISODate, params); +} +var ZodISOTime = /* @__PURE__ */ $constructor("ZodISOTime", (inst, def) => { + $ZodISOTime.init(inst, def); + ZodStringFormat.init(inst, def); +}); +function time2(params) { + return _isoTime(ZodISOTime, params); +} +var ZodISODuration = /* @__PURE__ */ $constructor("ZodISODuration", (inst, def) => { + $ZodISODuration.init(inst, def); + ZodStringFormat.init(inst, def); +}); +function duration2(params) { + return _isoDuration(ZodISODuration, params); +} + +// node_modules/zod/v4/classic/errors.js +var initializer2 = (inst, issues) => { + $ZodError.init(inst, issues); + inst.name = "ZodError"; + Object.defineProperties(inst, { + format: { + value: (mapper) => formatError(inst, mapper) + // enumerable: false, + }, + flatten: { + value: (mapper) => flattenError(inst, mapper) + // enumerable: false, + }, + addIssue: { + value: (issue2) => { + inst.issues.push(issue2); + inst.message = JSON.stringify(inst.issues, jsonStringifyReplacer, 2); + } + // enumerable: false, + }, + addIssues: { + value: (issues2) => { + inst.issues.push(...issues2); + inst.message = JSON.stringify(inst.issues, jsonStringifyReplacer, 2); + } + // enumerable: false, + }, + isEmpty: { + get() { + return inst.issues.length === 0; + } + // enumerable: false, + } + }); +}; +var ZodRealError = /* @__PURE__ */ $constructor("ZodError", initializer2, { + Parent: Error +}); + +// node_modules/zod/v4/classic/parse.js +var parse2 = /* @__PURE__ */ _parse(ZodRealError); +var parseAsync2 = /* @__PURE__ */ _parseAsync(ZodRealError); +var safeParse2 = /* @__PURE__ */ _safeParse(ZodRealError); +var safeParseAsync2 = /* @__PURE__ */ _safeParseAsync(ZodRealError); +var encode = /* @__PURE__ */ _encode(ZodRealError); +var decode = /* @__PURE__ */ _decode(ZodRealError); +var encodeAsync = /* @__PURE__ */ _encodeAsync(ZodRealError); +var decodeAsync = /* @__PURE__ */ _decodeAsync(ZodRealError); +var safeEncode = /* @__PURE__ */ _safeEncode(ZodRealError); +var safeDecode = /* @__PURE__ */ _safeDecode(ZodRealError); +var safeEncodeAsync = /* @__PURE__ */ _safeEncodeAsync(ZodRealError); +var safeDecodeAsync = /* @__PURE__ */ _safeDecodeAsync(ZodRealError); + +// node_modules/zod/v4/classic/schemas.js +var _installedGroups = /* @__PURE__ */ new WeakMap(); +function _installLazyMethods(inst, group, methods) { + const proto = Object.getPrototypeOf(inst); + let installed = _installedGroups.get(proto); + if (!installed) { + installed = /* @__PURE__ */ new Set(); + _installedGroups.set(proto, installed); + } + if (installed.has(group)) + return; + installed.add(group); + for (const key in methods) { + const fn = methods[key]; + Object.defineProperty(proto, key, { + configurable: true, + enumerable: false, + get() { + const bound = fn.bind(this); + Object.defineProperty(this, key, { + configurable: true, + writable: true, + enumerable: true, + value: bound + }); + return bound; + }, + set(v) { + Object.defineProperty(this, key, { + configurable: true, + writable: true, + enumerable: true, + value: v + }); + } + }); + } +} +var ZodType = /* @__PURE__ */ $constructor("ZodType", (inst, def) => { + $ZodType.init(inst, def); + Object.assign(inst["~standard"], { + jsonSchema: { + input: createStandardJSONSchemaMethod(inst, "input"), + output: createStandardJSONSchemaMethod(inst, "output") + } + }); + inst.toJSONSchema = createToJSONSchemaMethod(inst, {}); + inst.def = def; + inst.type = def.type; + Object.defineProperty(inst, "_def", { value: def }); + inst.parse = (data, params) => parse2(inst, data, params, { callee: inst.parse }); + inst.safeParse = (data, params) => safeParse2(inst, data, params); + inst.parseAsync = async (data, params) => parseAsync2(inst, data, params, { callee: inst.parseAsync }); + inst.safeParseAsync = async (data, params) => safeParseAsync2(inst, data, params); + inst.spa = inst.safeParseAsync; + inst.encode = (data, params) => encode(inst, data, params); + inst.decode = (data, params) => decode(inst, data, params); + inst.encodeAsync = async (data, params) => encodeAsync(inst, data, params); + inst.decodeAsync = async (data, params) => decodeAsync(inst, data, params); + inst.safeEncode = (data, params) => safeEncode(inst, data, params); + inst.safeDecode = (data, params) => safeDecode(inst, data, params); + inst.safeEncodeAsync = async (data, params) => safeEncodeAsync(inst, data, params); + inst.safeDecodeAsync = async (data, params) => safeDecodeAsync(inst, data, params); + _installLazyMethods(inst, "ZodType", { + check(...chks) { + const def2 = this.def; + return this.clone(util_exports.mergeDefs(def2, { + checks: [ + ...def2.checks ?? [], + ...chks.map((ch) => typeof ch === "function" ? { _zod: { check: ch, def: { check: "custom" }, onattach: [] } } : ch) + ] + }), { parent: true }); + }, + with(...chks) { + return this.check(...chks); + }, + clone(def2, params) { + return clone(this, def2, params); + }, + brand() { + return this; + }, + register(reg, meta2) { + reg.add(this, meta2); + return this; + }, + refine(check, params) { + return this.check(refine(check, params)); + }, + superRefine(refinement, params) { + return this.check(superRefine(refinement, params)); + }, + overwrite(fn) { + return this.check(_overwrite(fn)); + }, + optional() { + return optional(this); + }, + exactOptional() { + return exactOptional(this); + }, + nullable() { + return nullable(this); + }, + nullish() { + return optional(nullable(this)); + }, + nonoptional(params) { + return nonoptional(this, params); + }, + array() { + return array(this); + }, + or(arg) { + return union([this, arg]); + }, + and(arg) { + return intersection(this, arg); + }, + transform(tx) { + return pipe(this, transform(tx)); + }, + default(d) { + return _default(this, d); + }, + prefault(d) { + return prefault(this, d); + }, + catch(params) { + return _catch(this, params); + }, + pipe(target) { + return pipe(this, target); + }, + readonly() { + return readonly(this); + }, + describe(description) { + const cl = this.clone(); + globalRegistry.add(cl, { description }); + return cl; + }, + meta(...args) { + if (args.length === 0) + return globalRegistry.get(this); + const cl = this.clone(); + globalRegistry.add(cl, args[0]); + return cl; + }, + isOptional() { + return this.safeParse(void 0).success; + }, + isNullable() { + return this.safeParse(null).success; + }, + apply(fn) { + return fn(this); + } + }); + Object.defineProperty(inst, "description", { + get() { + return globalRegistry.get(inst)?.description; + }, + configurable: true + }); + return inst; +}); +var _ZodString = /* @__PURE__ */ $constructor("_ZodString", (inst, def) => { + $ZodString.init(inst, def); + ZodType.init(inst, def); + inst._zod.processJSONSchema = (ctx, json, params) => stringProcessor(inst, ctx, json, params); + const bag = inst._zod.bag; + inst.format = bag.format ?? null; + inst.minLength = bag.minimum ?? null; + inst.maxLength = bag.maximum ?? null; + _installLazyMethods(inst, "_ZodString", { + regex(...args) { + return this.check(_regex(...args)); + }, + includes(...args) { + return this.check(_includes(...args)); + }, + startsWith(...args) { + return this.check(_startsWith(...args)); + }, + endsWith(...args) { + return this.check(_endsWith(...args)); + }, + min(...args) { + return this.check(_minLength(...args)); + }, + max(...args) { + return this.check(_maxLength(...args)); + }, + length(...args) { + return this.check(_length(...args)); + }, + nonempty(...args) { + return this.check(_minLength(1, ...args)); + }, + lowercase(params) { + return this.check(_lowercase(params)); + }, + uppercase(params) { + return this.check(_uppercase(params)); + }, + trim() { + return this.check(_trim()); + }, + normalize(...args) { + return this.check(_normalize(...args)); + }, + toLowerCase() { + return this.check(_toLowerCase()); + }, + toUpperCase() { + return this.check(_toUpperCase()); + }, + slugify() { + return this.check(_slugify()); + } + }); +}); +var ZodString = /* @__PURE__ */ $constructor("ZodString", (inst, def) => { + $ZodString.init(inst, def); + _ZodString.init(inst, def); + inst.email = (params) => inst.check(_email(ZodEmail, params)); + inst.url = (params) => inst.check(_url(ZodURL, params)); + inst.jwt = (params) => inst.check(_jwt(ZodJWT, params)); + inst.emoji = (params) => inst.check(_emoji2(ZodEmoji, params)); + inst.guid = (params) => inst.check(_guid(ZodGUID, params)); + inst.uuid = (params) => inst.check(_uuid(ZodUUID, params)); + inst.uuidv4 = (params) => inst.check(_uuidv4(ZodUUID, params)); + inst.uuidv6 = (params) => inst.check(_uuidv6(ZodUUID, params)); + inst.uuidv7 = (params) => inst.check(_uuidv7(ZodUUID, params)); + inst.nanoid = (params) => inst.check(_nanoid(ZodNanoID, params)); + inst.guid = (params) => inst.check(_guid(ZodGUID, params)); + inst.cuid = (params) => inst.check(_cuid(ZodCUID, params)); + inst.cuid2 = (params) => inst.check(_cuid2(ZodCUID2, params)); + inst.ulid = (params) => inst.check(_ulid(ZodULID, params)); + inst.base64 = (params) => inst.check(_base64(ZodBase64, params)); + inst.base64url = (params) => inst.check(_base64url(ZodBase64URL, params)); + inst.xid = (params) => inst.check(_xid(ZodXID, params)); + inst.ksuid = (params) => inst.check(_ksuid(ZodKSUID, params)); + inst.ipv4 = (params) => inst.check(_ipv4(ZodIPv4, params)); + inst.ipv6 = (params) => inst.check(_ipv6(ZodIPv6, params)); + inst.cidrv4 = (params) => inst.check(_cidrv4(ZodCIDRv4, params)); + inst.cidrv6 = (params) => inst.check(_cidrv6(ZodCIDRv6, params)); + inst.e164 = (params) => inst.check(_e164(ZodE164, params)); + inst.datetime = (params) => inst.check(datetime2(params)); + inst.date = (params) => inst.check(date2(params)); + inst.time = (params) => inst.check(time2(params)); + inst.duration = (params) => inst.check(duration2(params)); +}); +function string2(params) { + return _string(ZodString, params); +} +var ZodStringFormat = /* @__PURE__ */ $constructor("ZodStringFormat", (inst, def) => { + $ZodStringFormat.init(inst, def); + _ZodString.init(inst, def); +}); +var ZodEmail = /* @__PURE__ */ $constructor("ZodEmail", (inst, def) => { + $ZodEmail.init(inst, def); + ZodStringFormat.init(inst, def); +}); +var ZodGUID = /* @__PURE__ */ $constructor("ZodGUID", (inst, def) => { + $ZodGUID.init(inst, def); + ZodStringFormat.init(inst, def); +}); +var ZodUUID = /* @__PURE__ */ $constructor("ZodUUID", (inst, def) => { + $ZodUUID.init(inst, def); + ZodStringFormat.init(inst, def); +}); +var ZodURL = /* @__PURE__ */ $constructor("ZodURL", (inst, def) => { + $ZodURL.init(inst, def); + ZodStringFormat.init(inst, def); +}); +var ZodEmoji = /* @__PURE__ */ $constructor("ZodEmoji", (inst, def) => { + $ZodEmoji.init(inst, def); + ZodStringFormat.init(inst, def); +}); +var ZodNanoID = /* @__PURE__ */ $constructor("ZodNanoID", (inst, def) => { + $ZodNanoID.init(inst, def); + ZodStringFormat.init(inst, def); +}); +var ZodCUID = /* @__PURE__ */ $constructor("ZodCUID", (inst, def) => { + $ZodCUID.init(inst, def); + ZodStringFormat.init(inst, def); +}); +var ZodCUID2 = /* @__PURE__ */ $constructor("ZodCUID2", (inst, def) => { + $ZodCUID2.init(inst, def); + ZodStringFormat.init(inst, def); +}); +var ZodULID = /* @__PURE__ */ $constructor("ZodULID", (inst, def) => { + $ZodULID.init(inst, def); + ZodStringFormat.init(inst, def); +}); +var ZodXID = /* @__PURE__ */ $constructor("ZodXID", (inst, def) => { + $ZodXID.init(inst, def); + ZodStringFormat.init(inst, def); +}); +var ZodKSUID = /* @__PURE__ */ $constructor("ZodKSUID", (inst, def) => { + $ZodKSUID.init(inst, def); + ZodStringFormat.init(inst, def); +}); +var ZodIPv4 = /* @__PURE__ */ $constructor("ZodIPv4", (inst, def) => { + $ZodIPv4.init(inst, def); + ZodStringFormat.init(inst, def); +}); +var ZodIPv6 = /* @__PURE__ */ $constructor("ZodIPv6", (inst, def) => { + $ZodIPv6.init(inst, def); + ZodStringFormat.init(inst, def); +}); +var ZodCIDRv4 = /* @__PURE__ */ $constructor("ZodCIDRv4", (inst, def) => { + $ZodCIDRv4.init(inst, def); + ZodStringFormat.init(inst, def); +}); +var ZodCIDRv6 = /* @__PURE__ */ $constructor("ZodCIDRv6", (inst, def) => { + $ZodCIDRv6.init(inst, def); + ZodStringFormat.init(inst, def); +}); +var ZodBase64 = /* @__PURE__ */ $constructor("ZodBase64", (inst, def) => { + $ZodBase64.init(inst, def); + ZodStringFormat.init(inst, def); +}); +var ZodBase64URL = /* @__PURE__ */ $constructor("ZodBase64URL", (inst, def) => { + $ZodBase64URL.init(inst, def); + ZodStringFormat.init(inst, def); +}); +var ZodE164 = /* @__PURE__ */ $constructor("ZodE164", (inst, def) => { + $ZodE164.init(inst, def); + ZodStringFormat.init(inst, def); +}); +var ZodJWT = /* @__PURE__ */ $constructor("ZodJWT", (inst, def) => { + $ZodJWT.init(inst, def); + ZodStringFormat.init(inst, def); +}); +var ZodNumber = /* @__PURE__ */ $constructor("ZodNumber", (inst, def) => { + $ZodNumber.init(inst, def); + ZodType.init(inst, def); + inst._zod.processJSONSchema = (ctx, json, params) => numberProcessor(inst, ctx, json, params); + _installLazyMethods(inst, "ZodNumber", { + gt(value, params) { + return this.check(_gt(value, params)); + }, + gte(value, params) { + return this.check(_gte(value, params)); + }, + min(value, params) { + return this.check(_gte(value, params)); + }, + lt(value, params) { + return this.check(_lt(value, params)); + }, + lte(value, params) { + return this.check(_lte(value, params)); + }, + max(value, params) { + return this.check(_lte(value, params)); + }, + int(params) { + return this.check(int(params)); + }, + safe(params) { + return this.check(int(params)); + }, + positive(params) { + return this.check(_gt(0, params)); + }, + nonnegative(params) { + return this.check(_gte(0, params)); + }, + negative(params) { + return this.check(_lt(0, params)); + }, + nonpositive(params) { + return this.check(_lte(0, params)); + }, + multipleOf(value, params) { + return this.check(_multipleOf(value, params)); + }, + step(value, params) { + return this.check(_multipleOf(value, params)); + }, + finite() { + return this; + } + }); + const bag = inst._zod.bag; + inst.minValue = Math.max(bag.minimum ?? Number.NEGATIVE_INFINITY, bag.exclusiveMinimum ?? Number.NEGATIVE_INFINITY) ?? null; + inst.maxValue = Math.min(bag.maximum ?? Number.POSITIVE_INFINITY, bag.exclusiveMaximum ?? Number.POSITIVE_INFINITY) ?? null; + inst.isInt = (bag.format ?? "").includes("int") || Number.isSafeInteger(bag.multipleOf ?? 0.5); + inst.isFinite = true; + inst.format = bag.format ?? null; +}); +function number2(params) { + return _number(ZodNumber, params); +} +var ZodNumberFormat = /* @__PURE__ */ $constructor("ZodNumberFormat", (inst, def) => { + $ZodNumberFormat.init(inst, def); + ZodNumber.init(inst, def); +}); +function int(params) { + return _int(ZodNumberFormat, params); +} +var ZodBoolean = /* @__PURE__ */ $constructor("ZodBoolean", (inst, def) => { + $ZodBoolean.init(inst, def); + ZodType.init(inst, def); + inst._zod.processJSONSchema = (ctx, json, params) => booleanProcessor(inst, ctx, json, params); +}); +function boolean2(params) { + return _boolean(ZodBoolean, params); +} +var ZodUnknown = /* @__PURE__ */ $constructor("ZodUnknown", (inst, def) => { + $ZodUnknown.init(inst, def); + ZodType.init(inst, def); + inst._zod.processJSONSchema = (ctx, json, params) => unknownProcessor(inst, ctx, json, params); +}); +function unknown() { + return _unknown(ZodUnknown); +} +var ZodNever = /* @__PURE__ */ $constructor("ZodNever", (inst, def) => { + $ZodNever.init(inst, def); + ZodType.init(inst, def); + inst._zod.processJSONSchema = (ctx, json, params) => neverProcessor(inst, ctx, json, params); +}); +function never(params) { + return _never(ZodNever, params); +} +var ZodArray = /* @__PURE__ */ $constructor("ZodArray", (inst, def) => { + $ZodArray.init(inst, def); + ZodType.init(inst, def); + inst._zod.processJSONSchema = (ctx, json, params) => arrayProcessor(inst, ctx, json, params); + inst.element = def.element; + _installLazyMethods(inst, "ZodArray", { + min(n, params) { + return this.check(_minLength(n, params)); + }, + nonempty(params) { + return this.check(_minLength(1, params)); + }, + max(n, params) { + return this.check(_maxLength(n, params)); + }, + length(n, params) { + return this.check(_length(n, params)); + }, + unwrap() { + return this.element; + } + }); +}); +function array(element, params) { + return _array(ZodArray, element, params); +} +var ZodObject = /* @__PURE__ */ $constructor("ZodObject", (inst, def) => { + $ZodObjectJIT.init(inst, def); + ZodType.init(inst, def); + inst._zod.processJSONSchema = (ctx, json, params) => objectProcessor(inst, ctx, json, params); + util_exports.defineLazy(inst, "shape", () => { + return def.shape; + }); + _installLazyMethods(inst, "ZodObject", { + keyof() { + return _enum(Object.keys(this._zod.def.shape)); + }, + catchall(catchall) { + return this.clone({ ...this._zod.def, catchall }); + }, + passthrough() { + return this.clone({ ...this._zod.def, catchall: unknown() }); + }, + loose() { + return this.clone({ ...this._zod.def, catchall: unknown() }); + }, + strict() { + return this.clone({ ...this._zod.def, catchall: never() }); + }, + strip() { + return this.clone({ ...this._zod.def, catchall: void 0 }); + }, + extend(incoming) { + return util_exports.extend(this, incoming); + }, + safeExtend(incoming) { + return util_exports.safeExtend(this, incoming); + }, + merge(other) { + return util_exports.merge(this, other); + }, + pick(mask) { + return util_exports.pick(this, mask); + }, + omit(mask) { + return util_exports.omit(this, mask); + }, + partial(...args) { + return util_exports.partial(ZodOptional, this, args[0]); + }, + required(...args) { + return util_exports.required(ZodNonOptional, this, args[0]); + } + }); +}); +function object(shape, params) { + const def = { + type: "object", + shape: shape ?? {}, + ...util_exports.normalizeParams(params) + }; + return new ZodObject(def); +} +var ZodUnion = /* @__PURE__ */ $constructor("ZodUnion", (inst, def) => { + $ZodUnion.init(inst, def); + ZodType.init(inst, def); + inst._zod.processJSONSchema = (ctx, json, params) => unionProcessor(inst, ctx, json, params); + inst.options = def.options; +}); +function union(options, params) { + return new ZodUnion({ + type: "union", + options, + ...util_exports.normalizeParams(params) + }); +} +var ZodIntersection = /* @__PURE__ */ $constructor("ZodIntersection", (inst, def) => { + $ZodIntersection.init(inst, def); + ZodType.init(inst, def); + inst._zod.processJSONSchema = (ctx, json, params) => intersectionProcessor(inst, ctx, json, params); +}); +function intersection(left, right) { + return new ZodIntersection({ + type: "intersection", + left, + right + }); +} +var ZodRecord = /* @__PURE__ */ $constructor("ZodRecord", (inst, def) => { + $ZodRecord.init(inst, def); + ZodType.init(inst, def); + inst._zod.processJSONSchema = (ctx, json, params) => recordProcessor(inst, ctx, json, params); + inst.keyType = def.keyType; + inst.valueType = def.valueType; +}); +function record(keyType, valueType, params) { + if (!valueType || !valueType._zod) { + return new ZodRecord({ + type: "record", + keyType: string2(), + valueType: keyType, + ...util_exports.normalizeParams(valueType) + }); + } + return new ZodRecord({ + type: "record", + keyType, + valueType, + ...util_exports.normalizeParams(params) + }); +} +var ZodEnum = /* @__PURE__ */ $constructor("ZodEnum", (inst, def) => { + $ZodEnum.init(inst, def); + ZodType.init(inst, def); + inst._zod.processJSONSchema = (ctx, json, params) => enumProcessor(inst, ctx, json, params); + inst.enum = def.entries; + inst.options = Object.values(def.entries); + const keys = new Set(Object.keys(def.entries)); + inst.extract = (values, params) => { + const newEntries = {}; + for (const value of values) { + if (keys.has(value)) { + newEntries[value] = def.entries[value]; + } else + throw new Error(`Key ${value} not found in enum`); + } + return new ZodEnum({ + ...def, + checks: [], + ...util_exports.normalizeParams(params), + entries: newEntries + }); + }; + inst.exclude = (values, params) => { + const newEntries = { ...def.entries }; + for (const value of values) { + if (keys.has(value)) { + delete newEntries[value]; + } else + throw new Error(`Key ${value} not found in enum`); + } + return new ZodEnum({ + ...def, + checks: [], + ...util_exports.normalizeParams(params), + entries: newEntries + }); + }; +}); +function _enum(values, params) { + const entries = Array.isArray(values) ? Object.fromEntries(values.map((v) => [v, v])) : values; + return new ZodEnum({ + type: "enum", + entries, + ...util_exports.normalizeParams(params) + }); +} +var ZodTransform = /* @__PURE__ */ $constructor("ZodTransform", (inst, def) => { + $ZodTransform.init(inst, def); + ZodType.init(inst, def); + inst._zod.processJSONSchema = (ctx, json, params) => transformProcessor(inst, ctx, json, params); + inst._zod.parse = (payload, _ctx) => { + if (_ctx.direction === "backward") { + throw new $ZodEncodeError(inst.constructor.name); + } + payload.addIssue = (issue2) => { + if (typeof issue2 === "string") { + payload.issues.push(util_exports.issue(issue2, payload.value, def)); + } else { + const _issue = issue2; + if (_issue.fatal) + _issue.continue = false; + _issue.code ?? (_issue.code = "custom"); + _issue.input ?? (_issue.input = payload.value); + _issue.inst ?? (_issue.inst = inst); + payload.issues.push(util_exports.issue(_issue)); + } + }; + const output = def.transform(payload.value, payload); + if (output instanceof Promise) { + return output.then((output2) => { + payload.value = output2; + payload.fallback = true; + return payload; + }); + } + payload.value = output; + payload.fallback = true; + return payload; + }; +}); +function transform(fn) { + return new ZodTransform({ + type: "transform", + transform: fn + }); +} +var ZodOptional = /* @__PURE__ */ $constructor("ZodOptional", (inst, def) => { + $ZodOptional.init(inst, def); + ZodType.init(inst, def); + inst._zod.processJSONSchema = (ctx, json, params) => optionalProcessor(inst, ctx, json, params); + inst.unwrap = () => inst._zod.def.innerType; +}); +function optional(innerType) { + return new ZodOptional({ + type: "optional", + innerType + }); +} +var ZodExactOptional = /* @__PURE__ */ $constructor("ZodExactOptional", (inst, def) => { + $ZodExactOptional.init(inst, def); + ZodType.init(inst, def); + inst._zod.processJSONSchema = (ctx, json, params) => optionalProcessor(inst, ctx, json, params); + inst.unwrap = () => inst._zod.def.innerType; +}); +function exactOptional(innerType) { + return new ZodExactOptional({ + type: "optional", + innerType + }); +} +var ZodNullable = /* @__PURE__ */ $constructor("ZodNullable", (inst, def) => { + $ZodNullable.init(inst, def); + ZodType.init(inst, def); + inst._zod.processJSONSchema = (ctx, json, params) => nullableProcessor(inst, ctx, json, params); + inst.unwrap = () => inst._zod.def.innerType; +}); +function nullable(innerType) { + return new ZodNullable({ + type: "nullable", + innerType + }); +} +var ZodDefault = /* @__PURE__ */ $constructor("ZodDefault", (inst, def) => { + $ZodDefault.init(inst, def); + ZodType.init(inst, def); + inst._zod.processJSONSchema = (ctx, json, params) => defaultProcessor(inst, ctx, json, params); + inst.unwrap = () => inst._zod.def.innerType; + inst.removeDefault = inst.unwrap; +}); +function _default(innerType, defaultValue) { + return new ZodDefault({ + type: "default", + innerType, + get defaultValue() { + return typeof defaultValue === "function" ? defaultValue() : util_exports.shallowClone(defaultValue); + } + }); +} +var ZodPrefault = /* @__PURE__ */ $constructor("ZodPrefault", (inst, def) => { + $ZodPrefault.init(inst, def); + ZodType.init(inst, def); + inst._zod.processJSONSchema = (ctx, json, params) => prefaultProcessor(inst, ctx, json, params); + inst.unwrap = () => inst._zod.def.innerType; +}); +function prefault(innerType, defaultValue) { + return new ZodPrefault({ + type: "prefault", + innerType, + get defaultValue() { + return typeof defaultValue === "function" ? defaultValue() : util_exports.shallowClone(defaultValue); + } + }); +} +var ZodNonOptional = /* @__PURE__ */ $constructor("ZodNonOptional", (inst, def) => { + $ZodNonOptional.init(inst, def); + ZodType.init(inst, def); + inst._zod.processJSONSchema = (ctx, json, params) => nonoptionalProcessor(inst, ctx, json, params); + inst.unwrap = () => inst._zod.def.innerType; +}); +function nonoptional(innerType, params) { + return new ZodNonOptional({ + type: "nonoptional", + innerType, + ...util_exports.normalizeParams(params) + }); +} +var ZodCatch = /* @__PURE__ */ $constructor("ZodCatch", (inst, def) => { + $ZodCatch.init(inst, def); + ZodType.init(inst, def); + inst._zod.processJSONSchema = (ctx, json, params) => catchProcessor(inst, ctx, json, params); + inst.unwrap = () => inst._zod.def.innerType; + inst.removeCatch = inst.unwrap; +}); +function _catch(innerType, catchValue) { + return new ZodCatch({ + type: "catch", + innerType, + catchValue: typeof catchValue === "function" ? catchValue : () => catchValue + }); +} +var ZodPipe = /* @__PURE__ */ $constructor("ZodPipe", (inst, def) => { + $ZodPipe.init(inst, def); + ZodType.init(inst, def); + inst._zod.processJSONSchema = (ctx, json, params) => pipeProcessor(inst, ctx, json, params); + inst.in = def.in; + inst.out = def.out; +}); +function pipe(in_, out) { + return new ZodPipe({ + type: "pipe", + in: in_, + out + // ...util.normalizeParams(params), + }); +} +var ZodReadonly = /* @__PURE__ */ $constructor("ZodReadonly", (inst, def) => { + $ZodReadonly.init(inst, def); + ZodType.init(inst, def); + inst._zod.processJSONSchema = (ctx, json, params) => readonlyProcessor(inst, ctx, json, params); + inst.unwrap = () => inst._zod.def.innerType; +}); +function readonly(innerType) { + return new ZodReadonly({ + type: "readonly", + innerType + }); +} +var ZodCustom = /* @__PURE__ */ $constructor("ZodCustom", (inst, def) => { + $ZodCustom.init(inst, def); + ZodType.init(inst, def); + inst._zod.processJSONSchema = (ctx, json, params) => customProcessor(inst, ctx, json, params); +}); +function refine(fn, _params = {}) { + return _refine(ZodCustom, fn, _params); +} +function superRefine(fn, params) { + return _superRefine(fn, params); +} + +// src/issue-triage/policy.ts +var triagePolicySchema = object({ + version: number2().int().positive(), + duplicateConfidenceThreshold: number2().min(0).max(1), + classificationConfidenceThreshold: number2().min(0).max(1), + priorityConfidenceThreshold: number2().min(0).max(1), + maxCandidates: number2().int().min(0).max(100), + maxRelatedIssues: number2().int().min(0).max(20), + skipLabels: array(string2().min(1)), + managedLabelPrefixes: array(string2().min(1)), + classificationLabels: object({ + bug: string2().min(1), + enhancement: string2().min(1), + documentation: string2().min(1), + question: string2().min(1) + }), + labelColors: record(string2(), string2().regex(/^[0-9a-fA-F]{6}$/)), + labelDescriptions: record(string2(), string2().min(1).max(100)) +}); +function calculatePriority(analysis, policy) { + const { facts } = analysis; + if (facts.securityImpact === "critical" || facts.dataLoss === true || facts.environment === "production" && facts.productionImpact === "outage") { + return "P0"; + } + if (facts.securityImpact === "high" || facts.releaseBlocker === true || facts.environment === "production" && facts.coreFlowBlocked === true && facts.workaround === "none") { + return "P1"; + } + if (analysis.priorityConfidence < policy.priorityConfidenceThreshold) { + return "pending"; + } + const lacksImpactEvidence = facts.productionImpact === "unknown" && facts.affectedScope === "unknown" && facts.slaRisk === null && facts.releaseBlocker === null; + if (lacksImpactEvidence) { + return "pending"; + } + if (facts.productionImpact === "degraded" || facts.affectedScope === "many" || facts.affectedScope === "all" || facts.slaRisk === true || facts.coreFlowBlocked === true) { + return "P2"; + } + return "P3"; +} +function makeDecision(analysis, candidates, policy, existingLabels = []) { + const candidateNumbers = new Set( + candidates.map((candidate) => candidate.number) + ); + const duplicate = analysis.duplicate; + const duplicateIssueNumber = duplicate.issueNumber !== null && duplicate.confidence >= policy.duplicateConfidenceThreshold && candidateNumbers.has(duplicate.issueNumber) ? duplicate.issueNumber : null; + const relatedIssues = analysis.relatedIssues.filter( + (related) => candidateNumbers.has(related.issueNumber) && related.issueNumber !== duplicateIssueNumber + ).filter( + (related, index, all) => all.findIndex( + (candidate) => candidate.issueNumber === related.issueNumber + ) === index + ).slice(0, policy.maxRelatedIssues); + const priority = calculatePriority(analysis, policy); + const classification = resolveClassification( + analysis, + existingLabels, + policy + ); + const labels = [ + `priority:${priority}`, + analysis.missingInformation.length > 0 ? "triage:needs-info" : "triage:done" + ]; + if (classification.source === "analysis" && classification.label) { + labels.push(classification.label); + } + if (duplicateIssueNumber !== null) { + labels.push("duplicate"); + } + return { + analysis, + classification, + priority, + labels: [...new Set(labels)], + duplicateIssueNumber, + relatedIssues + }; +} +function resolveClassification(analysis, existingLabels, policy) { + const configuredLabels = Object.values(policy.classificationLabels); + const normalizedConfigured = new Map( + configuredLabels.map((label) => [label.trim().toLowerCase(), label]) + ); + const existingClassificationLabels = [ + ...new Set( + existingLabels.map((label) => normalizedConfigured.get(label.trim().toLowerCase())).filter((label) => Boolean(label)) + ) + ]; + if (existingClassificationLabels.length === 1) { + return { label: existingClassificationLabels[0], source: "existing" }; + } + if (existingClassificationLabels.length > 1) { + return { label: null, source: "conflict" }; + } + if (analysis.issueType === "unknown" || analysis.classificationConfidence < policy.classificationConfidenceThreshold) { + return { label: null, source: "unknown" }; + } + return { + label: policy.classificationLabels[analysis.issueType], + source: "analysis" + }; +} +function mergeManagedLabels(existing, desired, managedPrefixes) { + const preserved = existing.filter( + (label) => !managedPrefixes.some((prefix) => label.startsWith(prefix)) + ); + return [.../* @__PURE__ */ new Set([...preserved, ...desired])]; +} + +// src/runtime/target-binding.ts +function assertBoundTarget(options) { + const expectedRepository = options.expectedRepository?.trim() ?? ""; + const expectedTargetText = options.expectedTarget?.trim() ?? ""; + if (!expectedRepository && !expectedTargetText) { + if (options.apply) throw new Error(options.errors.missing); + return; + } + if (!expectedRepository || !expectedTargetText) { + throw new Error(options.errors.incomplete); + } + const expectedTarget = Number(expectedTargetText); + if (!isRepositorySlug(expectedRepository) || !Number.isSafeInteger(expectedTarget) || expectedTarget <= 0) { + throw new Error(options.errors.invalid); + } + if (options.repository !== expectedRepository || options.targetNumber !== expectedTarget) { + throw new Error( + options.errors.mismatch(expectedRepository, expectedTarget) + ); + } +} + +// src/issue-triage/target.ts +function assertBoundIssueTarget(repository, issueNumber, apply, environment) { + assertBoundTarget({ + repository, + targetNumber: issueNumber, + apply, + expectedRepository: environment.ISSUE_TRIAGE_EXPECTED_REPOSITORY, + expectedTarget: environment.ISSUE_TRIAGE_EXPECTED_ISSUE, + errors: { + missing: "apply mode requires a scheduler-bound Issue target; set ISSUE_TRIAGE_EXPECTED_REPOSITORY and ISSUE_TRIAGE_EXPECTED_ISSUE", + incomplete: "incomplete scheduler-bound Issue target", + invalid: "invalid scheduler-bound Issue target", + mismatch: (expectedRepository, expectedIssueNumber) => `requested Issue ${repository}#${issueNumber} does not match scheduler-bound target ${expectedRepository}#${expectedIssueNumber}` + } + }); +} + +// src/issues/fingerprint.ts +import crypto from "node:crypto"; +var ISSUE_FINGERPRINT_PATTERN = /^[0-9a-f]{20}$/; +function issueFingerprint(issue2, comments = []) { + return crypto.createHash("sha256").update( + JSON.stringify({ + title: issue2.title.trim(), + body: issue2.body ?? "", + comments: comments.map((comment) => ({ + id: comment.id, + body: comment.body, + author: comment.user?.login ?? "" + })) + }) + ).digest("hex").slice(0, 20); +} + +// src/issues/managed-comments.ts +var ISSUE_TRIAGE_COMMENT_PREFIX = "`; +} +function buildTriageComment(issueNumber, fingerprint, decision) { + const analysis = decision.analysis; + const lines = [ + commentMarker(issueNumber, fingerprint), + "## Issue triage", + "", + "### Classification", + "", + `- Type: \`${classificationText(decision)}\``, + `- Priority: \`${decision.priority}\``, + `- Priority basis: ${analysis.priorityReason}` + ]; + if (decision.duplicateIssueNumber !== null) { + lines.push( + "", + "### Possible duplicate", + "", + `- #${decision.duplicateIssueNumber}: ${analysis.duplicate.reason}` + ); + } + if (decision.relatedIssues.length > 0) { + lines.push("", "### Related issues", ""); + for (const related of decision.relatedIssues) { + lines.push(`- #${related.issueNumber}: ${related.reason}`); + } + } + if (analysis.missingInformation.length > 0) { + lines.push("", "### Information needed", ""); + for (const missing of analysis.missingInformation) { + lines.push(`- ${missing}`); + } + } + lines.push( + "", + "### Maintainer next step", + "", + "- When this Issue is ready for implementation, a maintainer can add the `agent:ready` label. The Agent will open a Draft Pull Request and will not merge it automatically.", + "- Add `skip-triage` to opt out of automated triage.", + "", + "_This is an automated initial assessment based on the Issue text and related candidates; no repository code was inspected._" + ); + return lines.join("\n"); +} +function classificationText(decision) { + if (decision.classification.label) return decision.classification.label; + return decision.classification.source === "conflict" ? "unresolved (conflicting existing labels)" : "unknown"; +} + +// src/issue-triage/schema.ts +var unknownBoolean = boolean2().nullable(); +var triageAnalysisSchema = object({ + issueType: _enum([ + "bug", + "enhancement", + "documentation", + "question", + "unknown" + ]), + classificationConfidence: number2().min(0).max(1), + priorityConfidence: number2().min(0).max(1), + facts: object({ + environment: _enum(["production", "non-production", "unknown"]), + productionImpact: _enum(["none", "degraded", "outage", "unknown"]), + securityImpact: _enum(["none", "low", "high", "critical", "unknown"]), + dataLoss: unknownBoolean, + coreFlowBlocked: unknownBoolean, + workaround: _enum(["available", "none", "unknown"]), + affectedScope: _enum(["single", "limited", "many", "all", "unknown"]), + slaRisk: unknownBoolean, + releaseBlocker: unknownBoolean + }), + duplicate: object({ + issueNumber: number2().int().positive().nullable(), + confidence: number2().min(0).max(1), + reason: string2().max(2e3) + }), + relatedIssues: array( + object({ + issueNumber: number2().int().positive(), + reason: string2().min(1).max(1e3) + }) + ).max(10), + missingInformation: array(string2().min(1).max(1e3)).max(10), + priorityReason: string2().min(1).max(2e3) +}); +var triageSubmissionSchema = object({ + issueFingerprint: string2().regex(ISSUE_FINGERPRINT_PATTERN), + analysis: triageAnalysisSchema +}); + +// src/issue-triage/tool.ts +async function prepareIssueTriage(repository, issueNumber, dependencies) { + const issue2 = await dependencies.issues.getIssue(repository, issueNumber); + if (hasSkipLabel(issue2.labels, dependencies.policy.skipLabels)) { + return { + ok: true, + skipped: true, + reason: "issue has a configured skip-triage label", + repository, + issueNumber, + issueFingerprint: issueFingerprint(issue2) + }; + } + const comments = await dependencies.issues.listComments( + repository, + issueNumber + ); + const contextComments = selectContextComments( + comments, + dependencies.botLogin + ); + const fingerprint = issueFingerprint(issue2, contextComments); + if (hasCurrentTriageComment( + comments, + issueNumber, + fingerprint, + dependencies.botLogin + )) { + return { + ok: true, + skipped: true, + reason: "issue content already triaged", + repository, + issueNumber, + issueFingerprint: fingerprint + }; + } + const { candidates, warnings } = await loadCandidates( + dependencies.issues, + repository, + issue2, + dependencies.policy.maxCandidates + ); + return { + ok: true, + repository, + issueNumber, + issueFingerprint: fingerprint, + issue: issue2, + comments: contextComments, + candidates, + ...warnings.length > 0 ? { warnings } : {} + }; +} +async function applyIssueTriage(repository, issueNumber, submissionInput, apply, dependencies) { + const submission = triageSubmissionSchema.parse(submissionInput); + const issue2 = await dependencies.issues.getIssue(repository, issueNumber); + if (hasSkipLabel(issue2.labels, dependencies.policy.skipLabels)) { + return { + ok: true, + skipped: true, + reason: "issue has a configured skip-triage label", + repository, + issueNumber, + applied: false + }; + } + const botLogin = requiredBotLogin(apply, dependencies.botLogin); + const comments = await dependencies.issues.listComments( + repository, + issueNumber + ); + const contextComments = selectContextComments(comments, botLogin); + const currentFingerprint = issueFingerprint(issue2, contextComments); + if (currentFingerprint !== submission.issueFingerprint) { + throw new Error( + "issue changed after analysis; run the prepare command again before applying" + ); + } + if (hasCurrentTriageComment(comments, issueNumber, currentFingerprint, botLogin)) { + return { + ok: true, + skipped: true, + reason: "issue content already triaged", + repository, + issueNumber, + applied: false + }; + } + const { candidates, warnings } = await loadCandidates( + dependencies.issues, + repository, + issue2, + dependencies.policy.maxCandidates + ); + const decision = makeDecision( + submission.analysis, + candidates, + dependencies.policy, + issue2.labels + ); + const proposedComment = buildTriageComment( + issueNumber, + currentFingerprint, + decision + ); + const desiredLabels = mergeManagedLabels( + issue2.labels, + decision.labels, + dependencies.policy.managedLabelPrefixes + ); + const existingLabels = issue2.labels; + const labelsToAdd = desiredLabels.filter( + (label) => !existingLabels.includes(label) + ); + const labelsToRemove = existingLabels.filter( + (label) => isManagedLabel(label, dependencies.policy.managedLabelPrefixes) && !desiredLabels.includes(label) + ); + const existingComment = findTriageComment(comments, botLogin); + if (!apply) { + return { + ok: true, + repository, + issueNumber, + applied: false, + commentAction: "dry-run", + decision, + proposedComment, + ...warnings.length > 0 ? { warnings } : {} + }; + } + await ensureLabels( + dependencies.issues, + repository, + decision.labels, + dependencies.policy + ); + await dependencies.issues.addLabels(repository, issueNumber, labelsToAdd); + for (const label of labelsToRemove) { + await dependencies.issues.removeLabel(repository, issueNumber, label); + } + let commentAction = "unchanged"; + if (!existingComment) { + await dependencies.issues.createComment( + repository, + issueNumber, + proposedComment + ); + commentAction = "created"; + } else if (existingComment.body !== proposedComment) { + await dependencies.issues.updateComment( + repository, + issueNumber, + existingComment.id, + proposedComment + ); + commentAction = "updated"; + } + return { + ok: true, + repository, + issueNumber, + applied: true, + commentAction, + decision, + ...warnings.length > 0 ? { warnings } : {} + }; +} +async function loadCandidates(issues, repository, issue2, limit) { + try { + return { + candidates: await issues.searchCandidates(repository, issue2, limit), + warnings: [] + }; + } catch (error) { + return { + candidates: [], + warnings: [ + `candidate search failed; duplicate claims will be rejected: ${errorMessage(error)}` + ] + }; + } +} +function hasCurrentTriageComment(comments, issueNumber, fingerprint, botLogin) { + const marker = commentMarker(issueNumber, fingerprint); + return comments.some( + (comment) => isManagedTriageComment(comment, botLogin) && (comment.body === marker || comment.body.startsWith(`${marker} +`)) + ); +} +function findTriageComment(comments, botLogin) { + return comments.find( + (comment) => isManagedTriageComment(comment, botLogin) && isIssueTriageComment(comment.body) + ); +} +function isManagedTriageComment(comment, botLogin) { + const expectedLogin = botLogin?.trim().toLowerCase(); + return Boolean( + expectedLogin && comment.user?.login.toLowerCase() === expectedLogin + ); +} +function selectContextComments(comments, botLogin) { + return comments.filter( + (comment) => !isManagedTriageComment(comment, botLogin) || !isIssueTriageComment(comment.body) + ).sort((left, right) => left.id - right.id).slice(-50).map((comment) => ({ + ...comment, + body: truncateText(comment.body, 4e3) + })); +} +function requiredBotLogin(apply, botLogin) { + const normalized = botLogin?.trim(); + if (apply && !normalized) { + throw new Error("provider bot username is required in apply mode"); + } + return normalized || void 0; +} +function isManagedLabel(label, managedPrefixes) { + return managedPrefixes.some((prefix) => label.startsWith(prefix)); +} +function hasSkipLabel(labels, skipLabels) { + const normalizedSkipLabels = new Set( + skipLabels.map((label) => label.trim().toLowerCase()) + ); + return labels.some( + (label) => normalizedSkipLabels.has(label.trim().toLowerCase()) + ); +} +async function ensureLabels(issues, repository, labels, policy) { + for (const label of labels) { + await issues.ensureLabel( + repository, + label, + policy.labelColors[label] ?? "ededed", + policy.labelDescriptions[label] + ); + } +} + +// src/issue-triage/main.ts +async function main() { + const options = parseArguments(process.argv.slice(2)); + const policy = await loadPolicy(); + const apply = envBoolean(process.env.ISSUE_TRIAGE_APPLY); + assertBoundIssueTarget( + options.repository, + options.issueNumber, + apply, + process.env + ); + const token = await resolveGitHubToken(options.repository); + const issues = new GitHubClient({ + ...token ? { token } : {}, + ...process.env.GITHUB_API_URL ? { baseUrl: process.env.GITHUB_API_URL } : {} + }); + const dependencies = { + issues, + policy, + ...process.env.GITHUB_BOT_LOGIN ? { botLogin: process.env.GITHUB_BOT_LOGIN } : {} + }; + const result = options.command === "prepare" ? await prepareIssueTriage( + options.repository, + options.issueNumber, + dependencies + ) : await applyIssueTriage( + options.repository, + options.issueNumber, + JSON.parse(await readFile2(options.analysisFile, "utf8")), + apply, + dependencies + ); + process.stdout.write(`${JSON.stringify(result, null, 2)} +`); +} +async function loadPolicy() { + const embedded = process.env.WORKFLOW_POLICY_JSON?.trim(); + if (embedded) { + try { + return triagePolicySchema.parse(JSON.parse(embedded)); + } catch (error) { + throw new Error( + `failed to load embedded triage policy: ${errorMessage(error)}` + ); + } + } + return loadJsonFromCandidates( + [ + fileURLToPath(new URL("../policy.json", import.meta.url)), + path.resolve("agents/issue-triage/policy.json") + ], + (value) => triagePolicySchema.parse(value), + "failed to load issue triage policy" + ); +} +function parseArguments(args) { + const command = args.shift(); + if (command !== "prepare" && command !== "apply") { + throw new Error("first argument must be prepare or apply"); + } + let repository = ""; + let issueNumber = 0; + let analysisFile = ""; + for (let index = 0; index < args.length; index += 1) { + const argument = args[index]; + if (argument === "--repository") { + repository = requiredArgumentValue(args, ++index, argument); + } else if (argument === "--issue") { + const raw = requiredArgumentValue(args, ++index, argument); + issueNumber = Number.parseInt(raw, 10); + if (!Number.isSafeInteger(issueNumber) || issueNumber <= 0) { + throw new Error("--issue must be a positive integer"); + } + } else if (argument === "--analysis") { + analysisFile = requiredArgumentValue(args, ++index, argument); + } else { + throw new Error(`unknown argument: ${argument}`); + } + } + if (!isRepositorySlug(repository)) { + throw new Error("--repository must use owner/repository format"); + } + if (issueNumber <= 0) throw new Error("--issue is required"); + if (command === "apply" && !analysisFile) { + throw new Error("--analysis is required for apply"); + } + return { + command, + repository, + issueNumber, + ...analysisFile ? { analysisFile } : {} + }; +} +main().catch((error) => { + process.stderr.write(`issue triage failed: ${errorMessage(error)} +`); + process.exitCode = 1; +}); diff --git a/package.json b/package.json index 0493017..7e1ed58 100644 --- a/package.json +++ b/package.json @@ -13,6 +13,7 @@ "build:check": "tsx scripts/build-tools.ts --check", "check": "npm run format:check && npm run typecheck && npm test && npm run build:check", "format": "prettier --write .", + "pin-workspace-ref": "tsx scripts/pin-workspace-ref.ts", "format:check": "prettier --check .", "start": "tsx src/issue-triage/main.ts", "start:draft-pr": "tsx src/draft-pr/main.ts", diff --git a/scripts/build-tools.ts b/scripts/build-tools.ts index 0332464..140d7ba 100644 --- a/scripts/build-tools.ts +++ b/scripts/build-tools.ts @@ -1,11 +1,12 @@ -import { readFile, writeFile } from "node:fs/promises"; +import { mkdir, readFile, writeFile } from "node:fs/promises"; import path from "node:path"; import { fileURLToPath } from "node:url"; import { build } from "esbuild"; const repositoryRoot = fileURLToPath(new URL("../", import.meta.url)); -const workflowToolPlaceholder = "__WORKFLOW_TOOL_BASE64__"; const workflowPolicyPlaceholder = "__WORKFLOW_POLICY_JSON__"; +const generatedFileBanner = + "// Generated by scripts/build-tools.ts. Do not edit directly."; const buildTargets = { "issue-triage": { @@ -13,12 +14,14 @@ const buildTargets = { schedulerSource: "src/schedulers/issue-triage.js", policySource: "agents/issue-triage/policy.json", outfile: "agents/issue-triage/scheduler.js", + toolOutfile: "agents/issue-triage/tool/main.mjs", }, "draft-pr": { entryPoint: "src/draft-pr/main.ts", schedulerSource: "src/schedulers/draft-pr.js", policySource: "agents/draft-pr/policy.json", outfile: "agents/draft-pr/scheduler.js", + toolOutfile: "agents/draft-pr/tool/main.mjs", }, } as const; @@ -35,26 +38,19 @@ export function normalizeGeneratedSource(source: string): string { export function renderSchedulerArtifact( schedulerSource: string, - workflowToolSource: string, workflowPolicySource: string, ): string { - let generated = replaceExactlyOnce( + const generated = replaceExactlyOnce( schedulerSource, - workflowToolPlaceholder, - Buffer.from(normalizeGeneratedSource(workflowToolSource), "utf8").toString( - "base64", - ), - ); - generated = replaceExactlyOnce( - generated, workflowPolicyPlaceholder, JSON.stringify(JSON.parse(workflowPolicySource)), ); + return normalizeGeneratedSource([generatedFileBanner, generated].join("\n")); +} + +export function renderToolArtifact(workflowToolSource: string): string { return normalizeGeneratedSource( - [ - "// Generated by scripts/build-tools.ts. Do not edit directly.", - generated, - ].join("\n"), + [generatedFileBanner, workflowToolSource].join("\n"), ); } @@ -87,6 +83,29 @@ export function parseBuildArguments(args: string[]): BuildOptions { return { check, targets: targets as BuildTargetName[] }; } +async function writeOrCheck( + relativePath: string, + generated: string, + check: boolean, +): Promise { + const outfile = path.join(repositoryRoot, relativePath); + + if (!check) { + await mkdir(path.dirname(outfile), { recursive: true }); + await writeFile(outfile, generated); + process.stdout.write(`built ${relativePath}\n`); + return true; + } + + const current = await readFile(outfile, "utf8").catch(() => ""); + if (current === generated) { + process.stdout.write(`checked ${relativePath}\n`); + return true; + } + process.stderr.write(`stale ${relativePath}\n`); + return false; +} + async function buildTarget( targetName: BuildTargetName, check: boolean, @@ -113,26 +132,17 @@ async function buildTarget( path.join(repositoryRoot, target.policySource), "utf8", ); - const generated = renderSchedulerArtifact( + const generatedScheduler = renderSchedulerArtifact( schedulerSource, - output.text, policySource, ); - const outfile = path.join(repositoryRoot, target.outfile); + const generatedTool = renderToolArtifact(output.text); - if (!check) { - await writeFile(outfile, generated); - process.stdout.write(`built ${target.outfile}\n`); - return true; - } - - const current = await readFile(outfile, "utf8"); - if (current === generated) { - process.stdout.write(`checked ${target.outfile}\n`); - return true; - } - process.stderr.write(`stale ${target.outfile}\n`); - return false; + const [schedulerMatched, toolMatched] = await Promise.all([ + writeOrCheck(target.outfile, generatedScheduler, check), + writeOrCheck(target.toolOutfile, generatedTool, check), + ]); + return schedulerMatched && toolMatched; } export async function runBuild(options: BuildOptions): Promise { diff --git a/scripts/pin-workspace-ref.ts b/scripts/pin-workspace-ref.ts new file mode 100644 index 0000000..95c71d1 --- /dev/null +++ b/scripts/pin-workspace-ref.ts @@ -0,0 +1,62 @@ +import { execFileSync } from "node:child_process"; +import { readFile, writeFile } from "node:fs/promises"; +import path from "node:path"; +import { fileURLToPath } from "node:url"; + +const repositoryRoot = fileURLToPath(new URL("../", import.meta.url)); +const composePath = path.join(repositoryRoot, "agent-compose.yml"); + +// Matches the `ref:` line of an `agents..workspace` block by its fixed +// position immediately before that block's `target: workflow-repo` line. +// Other `ref:` fields in this file (skills, scheduler.script) are followed +// by a `path:` line instead and are intentionally left untouched — see the +// design note in agent-compose.yml history for why only workspace.ref is +// pinned to a commit SHA. +const workspaceRefPattern = + /( {6}ref: )[0-9a-f]{40}(\n {6}target: workflow-repo\n)/g; + +export function pinWorkspaceRefs( + compose: string, + sha: string, +): { updated: string; count: number } { + if (!/^[0-9a-f]{40}$/.test(sha)) { + throw new Error(`expected a 40-character commit SHA, got: ${sha}`); + } + let count = 0; + const updated = compose.replace( + workspaceRefPattern, + (_match, prefix, suffix) => { + count += 1; + return `${prefix}${sha}${suffix}`; + }, + ); + return { updated, count }; +} + +async function main(): Promise { + const sha = execFileSync("git", ["rev-parse", "HEAD"], { + cwd: repositoryRoot, + encoding: "utf8", + }).trim(); + const compose = await readFile(composePath, "utf8"); + const { updated, count } = pinWorkspaceRefs(compose, sha); + if (count === 0) { + throw new Error( + "no agents.*.workspace.ref fields found in agent-compose.yml", + ); + } + await writeFile(composePath, updated); + process.stdout.write(`pinned ${count} workspace.ref field(s) to ${sha}\n`); +} + +if ( + process.argv[1] && + path.resolve(process.argv[1]) === path.resolve(fileURLToPath(import.meta.url)) +) { + main().catch((error: unknown) => { + process.stderr.write( + `${error instanceof Error ? error.message : String(error)}\n`, + ); + process.exitCode = 1; + }); +} diff --git a/src/schedulers/draft-pr.js b/src/schedulers/draft-pr.js index 97ca0d5..6df4f74 100644 --- a/src/schedulers/draft-pr.js +++ b/src/schedulers/draft-pr.js @@ -3,9 +3,9 @@ const GITHUB_REVIEW_TOPIC = "webhook.github.pull_request_review"; const GITHUB_WORKFLOW_RUN_TOPIC = "webhook.github.workflow_run"; const READY_LABEL = "agent:ready"; const APPROVED_LABEL = "agent:approved"; -const WORKFLOW_TOOL_BASE64 = "__WORKFLOW_TOOL_BASE64__"; const WORKFLOW_POLICY_JSON = "__WORKFLOW_POLICY_JSON__"; -const WORKFLOW_TOOL_CHUNK_SIZE = 60000; +const WORKFLOW_TOOL_PATH = + "$WORKSPACE/workflow-repo/agents/draft-pr/tool/main.mjs"; const WORKSPACE_VOLUME = { type: "bind", source: "./.draft-pr-workspaces", @@ -13,19 +13,6 @@ const WORKSPACE_VOLUME = { readOnly: false, }; -function workflowToolEnvironment() { - const env = {}; - for ( - let offset = 0, index = 0; - offset < WORKFLOW_TOOL_BASE64.length; - offset += WORKFLOW_TOOL_CHUNK_SIZE, index += 1 - ) { - env[`WORKFLOW_TOOL_CHUNK_${String(index).padStart(4, "0")}`] = - WORKFLOW_TOOL_BASE64.slice(offset, offset + WORKFLOW_TOOL_CHUNK_SIZE); - } - return env; -} - function agentWorkspaceVolume(workspacePath) { const prefix = "/draft-pr-workspaces/repositories/"; if ( @@ -302,17 +289,12 @@ function validateAgentWorkspaceWithRetry(workspacePath) { function runDeterministicTool(script, env, label) { const result = scheduler.shell( - [ - "set -eu", - 'workflow_tool_dir="$(mktemp -d)"', - 'workflow_tool="$workflow_tool_dir/draft-pr.mjs"', - 'node -e \'const fs=require("node:fs"); const source=Object.keys(process.env).filter((key)=>key.startsWith("WORKFLOW_TOOL_CHUNK_")).sort().map((key)=>process.env[key]).join(""); fs.writeFileSync(process.argv[1], Buffer.from(source, "base64"))\' "$workflow_tool"', - 'export DRAFT_PR_TOOL="$workflow_tool"', - script, - ].join("\n"), + ["set -eu", `export DRAFT_PR_TOOL="${WORKFLOW_TOOL_PATH}"`, script].join( + "\n", + ), { sandboxPolicy: "new", - env: { ...env, WORKFLOW_POLICY_JSON, ...workflowToolEnvironment() }, + env: { ...env, WORKFLOW_POLICY_JSON }, volumes: [WORKSPACE_VOLUME], maxOutputBytes: 4 * 1024 * 1024, }, diff --git a/src/schedulers/issue-triage.js b/src/schedulers/issue-triage.js index 25cff3c..f96fba9 100644 --- a/src/schedulers/issue-triage.js +++ b/src/schedulers/issue-triage.js @@ -9,22 +9,9 @@ const GITHUB_ISSUE_ACTIONS = [ ]; const GITHUB_COMMENT_ACTIONS = ["created", "edited", "deleted"]; const GITHUB_TRIAGE_CONTROL_LABEL = "skip-triage"; -const WORKFLOW_TOOL_BASE64 = "__WORKFLOW_TOOL_BASE64__"; const WORKFLOW_POLICY_JSON = "__WORKFLOW_POLICY_JSON__"; -const WORKFLOW_TOOL_CHUNK_SIZE = 60000; - -function workflowToolEnvironment() { - const env = {}; - for ( - let offset = 0, index = 0; - offset < WORKFLOW_TOOL_BASE64.length; - offset += WORKFLOW_TOOL_CHUNK_SIZE, index += 1 - ) { - env[`WORKFLOW_TOOL_CHUNK_${String(index).padStart(4, "0")}`] = - WORKFLOW_TOOL_BASE64.slice(offset, offset + WORKFLOW_TOOL_CHUNK_SIZE); - } - return env; -} +const WORKFLOW_TOOL_PATH = + "$WORKSPACE/workflow-repo/agents/issue-triage/tool/main.mjs"; const ANALYSIS_SCHEMA = { type: "object", @@ -118,9 +105,7 @@ function runTool(command, repository, issueNumber, submission, senderLogin) { const result = scheduler.shell( [ "set -eu", - 'workflow_tool_dir="$(mktemp -d)"', - 'workflow_tool="$workflow_tool_dir/issue-triage.mjs"', - 'node -e \'const fs=require("node:fs"); const source=Object.keys(process.env).filter((key)=>key.startsWith("WORKFLOW_TOOL_CHUNK_")).sort().map((key)=>process.env[key]).join(""); fs.writeFileSync(process.argv[1], Buffer.from(source, "base64"))\' "$workflow_tool"', + `workflow_tool="${WORKFLOW_TOOL_PATH}"`, 'sender_login=$(printf "%s" "$TRIAGE_SENDER_LOGIN" | tr "[:upper:]" "[:lower:]")', 'bot_login=$(printf "%s" "${GITHUB_BOT_LOGIN:-}" | tr "[:upper:]" "[:lower:]")', 'allowed_repository="${GITHUB_ALLOWED_REPOSITORY:-}"', @@ -146,7 +131,6 @@ function runTool(command, repository, issueNumber, submission, senderLogin) { TRIAGE_REPOSITORY: repository, TRIAGE_ISSUE: String(issueNumber), WORKFLOW_POLICY_JSON, - ...workflowToolEnvironment(), TRIAGE_SUBMISSION: submission ? JSON.stringify(submission) : "", TRIAGE_SENDER_LOGIN: senderLogin || "", }, diff --git a/test/build-tools.test.ts b/test/build-tools.test.ts index 3a0e83f..48eb490 100644 --- a/test/build-tools.test.ts +++ b/test/build-tools.test.ts @@ -4,6 +4,7 @@ import { normalizeGeneratedSource, parseBuildArguments, renderSchedulerArtifact, + renderToolArtifact, } from "../scripts/build-tools.js"; describe("generated Scheduler artifact build", () => { @@ -60,32 +61,32 @@ describe("generated Scheduler artifact build", () => { ); }); - it("embeds one deterministic tool bundle in a scheduler artifact", () => { + it("embeds the deterministic tool policy in a scheduler artifact", () => { const artifact = renderSchedulerArtifact( - [ - 'const WORKFLOW_TOOL_BASE64 = "__WORKFLOW_TOOL_BASE64__";', - 'const WORKFLOW_POLICY_JSON = "__WORKFLOW_POLICY_JSON__";', - "", - ].join("\n"), - 'process.stdout.write("ready");\n', + ['const WORKFLOW_POLICY_JSON = "__WORKFLOW_POLICY_JSON__";', ""].join( + "\n", + ), '{"enabled":true}\n', ); expect(artifact).toContain("Generated by scripts/build-tools.ts"); - expect(artifact).toContain( - `const WORKFLOW_TOOL_BASE64 = ${JSON.stringify(Buffer.from('process.stdout.write("ready");\n').toString("base64"))};`, - ); - expect(artifact).not.toContain("__WORKFLOW_TOOL_BASE64__"); expect(artifact).toContain( 'const WORKFLOW_POLICY_JSON = "{\\\"enabled\\\":true}";', ); expect(artifact).not.toContain("__WORKFLOW_POLICY_JSON__"); - expect(() => - renderSchedulerArtifact("const value = 1;", "tool", "{}"), - ).toThrow("exactly one __WORKFLOW_TOOL_BASE64__ placeholder"); + expect(() => renderSchedulerArtifact("const value = 1;", "{}")).toThrow( + "exactly one __WORKFLOW_POLICY_JSON__ placeholder", + ); + }); + + it("renders a standalone tool artifact with the generated-file banner", () => { + const artifact = renderToolArtifact('process.stdout.write("ready");\n'); + + expect(artifact).toContain("Generated by scripts/build-tools.ts"); + expect(artifact).toContain('process.stdout.write("ready");'); }); - it("keeps the generated bundles free of the Zod locale catalog", async () => { + it("keeps the generated scheduler artifacts free of the tool bundle and Zod locale catalog", async () => { const bundles = await Promise.all([ readFile( new URL("../agents/issue-triage/scheduler.js", import.meta.url), @@ -99,10 +100,28 @@ describe("generated Scheduler artifact build", () => { for (const bundle of bundles) { expect(bundle).toContain("Generated by scripts/build-tools.ts"); - expect(bundle).toContain("WORKFLOW_TOOL_BASE64"); expect(bundle).toContain("WORKFLOW_POLICY_JSON"); - expect(bundle).not.toContain("__WORKFLOW_TOOL_BASE64__"); expect(bundle).not.toContain("__WORKFLOW_POLICY_JSON__"); + expect(bundle).not.toContain("WORKFLOW_TOOL_BASE64"); + expect(bundle).not.toContain("WORKFLOW_TOOL_CHUNK_"); + expect(bundle).not.toContain("node_modules/zod/v4/locales/"); + } + }); + + it("delivers the tool bundle as a standalone committed file, free of the Zod locale catalog", async () => { + const bundles = await Promise.all([ + readFile( + new URL("../agents/issue-triage/tool/main.mjs", import.meta.url), + "utf8", + ), + readFile( + new URL("../agents/draft-pr/tool/main.mjs", import.meta.url), + "utf8", + ), + ]); + + for (const bundle of bundles) { + expect(bundle).toContain("Generated by scripts/build-tools.ts"); expect(bundle).not.toContain("node_modules/zod/v4/locales/"); } }); diff --git a/test/draft-pr-scheduler-script.test.ts b/test/draft-pr-scheduler-script.test.ts index c88d45e..7266cb2 100644 --- a/test/draft-pr-scheduler-script.test.ts +++ b/test/draft-pr-scheduler-script.test.ts @@ -7,7 +7,6 @@ describe("Draft PR Scheduler script", () => { const handlers = new Map unknown>(); const commands: string[] = []; let agentOptions: Record = {}; - let toolChunks: string[] = []; let workflowPolicyJson = ""; const shellCalls: Array<{ script: string; @@ -32,10 +31,6 @@ describe("Draft PR Scheduler script", () => { shellCalls.push({ script, options }); commands.push(schedulerCommand(options.env)); workflowPolicyJson = options.env.WORKFLOW_POLICY_JSON ?? ""; - toolChunks = Object.entries(options.env) - .filter(([name]) => name.startsWith("WORKFLOW_TOOL_CHUNK_")) - .sort(([left], [right]) => left.localeCompare(right)) - .map(([, value]) => value); const result = options.env.DRAFT_PR_COMMAND === "prepare" ? { @@ -178,8 +173,12 @@ describe("Draft PR Scheduler script", () => { }), ); expect(workspaceValidation?.options.volumes).toEqual(agentOptions.volumes); - expect(toolChunks.length).toBeGreaterThan(1); - expect(toolChunks.every((chunk) => chunk.length <= 60000)).toBe(true); + const toolInvocation = shellCalls.find( + ({ options }) => options.env.DRAFT_PR_COMMAND === "prepare", + ); + expect(toolInvocation?.script).toContain( + 'export DRAFT_PR_TOOL="$WORKSPACE/workflow-repo/agents/draft-pr/tool/main.mjs"', + ); expect(JSON.parse(workflowPolicyJson)).toEqual( expect.objectContaining({ version: 1, diff --git a/test/scheduler-script.test.ts b/test/scheduler-script.test.ts index a69a1f6..1d31409 100644 --- a/test/scheduler-script.test.ts +++ b/test/scheduler-script.test.ts @@ -7,7 +7,6 @@ describe("GitHub Issue triage scheduler script", () => { const handlers = new Map unknown>(); let shellScript = ""; let senderLogin = ""; - let toolChunks: string[] = []; let workflowPolicyJson = ""; const context = vm.createContext({ scheduler: { @@ -22,10 +21,6 @@ describe("GitHub Issue triage scheduler script", () => { shellScript = script; senderLogin = options.env.TRIAGE_SENDER_LOGIN ?? ""; workflowPolicyJson = options.env.WORKFLOW_POLICY_JSON ?? ""; - toolChunks = Object.entries(options.env) - .filter(([name]) => name.startsWith("WORKFLOW_TOOL_CHUNK_")) - .sort(([left], [right]) => left.localeCompare(right)) - .map(([, value]) => value); return { success: true, stdout: JSON.stringify({ @@ -61,9 +56,9 @@ describe("GitHub Issue triage scheduler script", () => { }); expect(senderLogin).toBe("triage-bot"); expect(shellScript).toContain("GITHUB_BOT_LOGIN"); - expect(shellScript).toContain('Buffer.from(source, "base64")'); - expect(toolChunks.length).toBeGreaterThan(1); - expect(toolChunks.every((chunk) => chunk.length <= 60000)).toBe(true); + expect(shellScript).toContain( + "$WORKSPACE/workflow-repo/agents/issue-triage/tool/main.mjs", + ); expect(JSON.parse(workflowPolicyJson)).toEqual( expect.objectContaining({ version: 1 }), ); From ce2f5c2c0cb49d1d20cf71a4fdd251255007774c Mon Sep 17 00:00:00 2001 From: winterfx Date: Thu, 13 Aug 2026 10:41:51 +0800 Subject: [PATCH 2/4] refactor(agent-compose): track workspace.ref on main, drop ref pinning Accept the mid-workflow drift risk instead of pinning workspace.ref to a commit SHA: both agents' workspace now tracks main like skills and scheduler.script already do, removing the pin-workspace-ref manual pre-deploy step and its script. --- agent-compose.yml | 4 +-- package.json | 1 - scripts/pin-workspace-ref.ts | 62 ------------------------------------ 3 files changed, 2 insertions(+), 65 deletions(-) delete mode 100644 scripts/pin-workspace-ref.ts diff --git a/agent-compose.yml b/agent-compose.yml index 95f4d97..3f30dd3 100644 --- a/agent-compose.yml +++ b/agent-compose.yml @@ -39,7 +39,7 @@ agents: workspace: provider: git url: https://github.com/winterfx/engineering-agent-workflows.git - ref: 78db6672cbd38e07d10621f937d55f22c1fcfbab + ref: main target: workflow-repo scheduler: @@ -89,7 +89,7 @@ agents: workspace: provider: git url: https://github.com/winterfx/engineering-agent-workflows.git - ref: 78db6672cbd38e07d10621f937d55f22c1fcfbab + ref: main target: workflow-repo scheduler: diff --git a/package.json b/package.json index 7e1ed58..0493017 100644 --- a/package.json +++ b/package.json @@ -13,7 +13,6 @@ "build:check": "tsx scripts/build-tools.ts --check", "check": "npm run format:check && npm run typecheck && npm test && npm run build:check", "format": "prettier --write .", - "pin-workspace-ref": "tsx scripts/pin-workspace-ref.ts", "format:check": "prettier --check .", "start": "tsx src/issue-triage/main.ts", "start:draft-pr": "tsx src/draft-pr/main.ts", diff --git a/scripts/pin-workspace-ref.ts b/scripts/pin-workspace-ref.ts deleted file mode 100644 index 95c71d1..0000000 --- a/scripts/pin-workspace-ref.ts +++ /dev/null @@ -1,62 +0,0 @@ -import { execFileSync } from "node:child_process"; -import { readFile, writeFile } from "node:fs/promises"; -import path from "node:path"; -import { fileURLToPath } from "node:url"; - -const repositoryRoot = fileURLToPath(new URL("../", import.meta.url)); -const composePath = path.join(repositoryRoot, "agent-compose.yml"); - -// Matches the `ref:` line of an `agents..workspace` block by its fixed -// position immediately before that block's `target: workflow-repo` line. -// Other `ref:` fields in this file (skills, scheduler.script) are followed -// by a `path:` line instead and are intentionally left untouched — see the -// design note in agent-compose.yml history for why only workspace.ref is -// pinned to a commit SHA. -const workspaceRefPattern = - /( {6}ref: )[0-9a-f]{40}(\n {6}target: workflow-repo\n)/g; - -export function pinWorkspaceRefs( - compose: string, - sha: string, -): { updated: string; count: number } { - if (!/^[0-9a-f]{40}$/.test(sha)) { - throw new Error(`expected a 40-character commit SHA, got: ${sha}`); - } - let count = 0; - const updated = compose.replace( - workspaceRefPattern, - (_match, prefix, suffix) => { - count += 1; - return `${prefix}${sha}${suffix}`; - }, - ); - return { updated, count }; -} - -async function main(): Promise { - const sha = execFileSync("git", ["rev-parse", "HEAD"], { - cwd: repositoryRoot, - encoding: "utf8", - }).trim(); - const compose = await readFile(composePath, "utf8"); - const { updated, count } = pinWorkspaceRefs(compose, sha); - if (count === 0) { - throw new Error( - "no agents.*.workspace.ref fields found in agent-compose.yml", - ); - } - await writeFile(composePath, updated); - process.stdout.write(`pinned ${count} workspace.ref field(s) to ${sha}\n`); -} - -if ( - process.argv[1] && - path.resolve(process.argv[1]) === path.resolve(fileURLToPath(import.meta.url)) -) { - main().catch((error: unknown) => { - process.stderr.write( - `${error instanceof Error ? error.message : String(error)}\n`, - ); - process.exitCode = 1; - }); -} From 25d02247639092e10a901ccbe92917d100ebc45c Mon Sep 17 00:00:00 2001 From: winterfx Date: Thu, 13 Aug 2026 11:02:25 +0800 Subject: [PATCH 3/4] refactor(build-tools): centralize the tool workspace path, tidy build script Address findings from a /simplify pass over the workspace-tool-delivery diff: - Derive the WORKFLOW_TOOL_PATH baked into each scheduler.js from a single workspaceToolTarget constant + placeholder substitution (matching the existing WORKFLOW_POLICY_JSON pattern), instead of hand-typing the same "$WORKSPACE/workflow-repo/agents//tool/ main.mjs" literal separately in build-tools.ts and each scheduler source file. - Extract withGeneratedFileBanner() so renderSchedulerArtifact and renderToolArtifact stop duplicating the banner-wrapping expression. - Parallelize the schedulerSource/policySource reads in buildTarget with Promise.all, matching the existing writeOrCheck parallelism. Not changed: agent-compose.yml's workspace/skills/scheduler.script still declare the same repo URL/ref three times per agent (a review pass flagged this as a duplicate git checkout per sandbox) - fixing that would mean deciding whether `skills` and `workspace` can share one checkout, which needs deeper agent-compose provisioning behavior than the docs settle (skill refs resolve "during an agent run", which may or may not populate the sandbox filesystem the same way workspace does for plain scheduler.shell() calls). Left as a follow-up. --- agents/draft-pr/scheduler.js | 3 +-- agents/issue-triage/scheduler.js | 3 +-- scripts/build-tools.ts | 38 +++++++++++++++++++++----------- src/schedulers/draft-pr.js | 3 +-- src/schedulers/issue-triage.js | 3 +-- test/build-tools.test.ts | 21 +++++++++++++----- 6 files changed, 44 insertions(+), 27 deletions(-) diff --git a/agents/draft-pr/scheduler.js b/agents/draft-pr/scheduler.js index 674b99f..8b806dc 100644 --- a/agents/draft-pr/scheduler.js +++ b/agents/draft-pr/scheduler.js @@ -5,8 +5,7 @@ const GITHUB_WORKFLOW_RUN_TOPIC = "webhook.github.workflow_run"; const READY_LABEL = "agent:ready"; const APPROVED_LABEL = "agent:approved"; const WORKFLOW_POLICY_JSON = "{\"version\":1,\"readyLabel\":\"agent:ready\",\"approvedLabel\":\"agent:approved\",\"runningLabel\":\"agent:running\",\"needsApprovalLabel\":\"agent:needs-approval\",\"prOpenLabel\":\"agent:pr-open\",\"failedLabel\":\"agent:failed\",\"skipLabels\":[\"skip-triage\"],\"blockedLabels\":[\"duplicate\",\"agent:pr-open\",\"agent:running\"],\"branchPrefix\":\"codex/issue-\",\"maxChangedFiles\":40,\"maxChangedLines\":1500,\"maxReviewComments\":50,\"maxValidationFixIterations\":2,\"maxFixIterations\":3,\"requiredValidationGates\":[\"task-prepare\",\"task-lint\",\"task-test-unit\"],\"allowedValidationFailureCases\":[\"TestConfigStoreCRUDCoverageWorkflows\",\"TestIntegrationConfigStoreCRUDCoverageWorkflows\",\"TestE2EConfigStoreCRUDCoverageWorkflows\",\"runtime command execution > injects runtime path environment into user commands\"],\"approvalPathPrefixes\":[\".github/workflows/\",\"migrations/\",\"db/migrations/\",\"database/migrations/\",\"pkg/auth/\",\"src/auth/\",\"security/\",\"deploy/\",\"release/\"],\"labelColors\":{\"agent:ready\":\"1d76db\",\"agent:approved\":\"0e8a16\",\"agent:running\":\"fbca04\",\"agent:needs-approval\":\"d93f0b\",\"agent:pr-open\":\"5319e7\",\"agent:failed\":\"b60205\"}}"; -const WORKFLOW_TOOL_PATH = - "$WORKSPACE/workflow-repo/agents/draft-pr/tool/main.mjs"; +const WORKFLOW_TOOL_PATH = "$WORKSPACE/workflow-repo/agents/draft-pr/tool/main.mjs"; const WORKSPACE_VOLUME = { type: "bind", source: "./.draft-pr-workspaces", diff --git a/agents/issue-triage/scheduler.js b/agents/issue-triage/scheduler.js index 2d432e0..96edbb6 100644 --- a/agents/issue-triage/scheduler.js +++ b/agents/issue-triage/scheduler.js @@ -11,8 +11,7 @@ const GITHUB_ISSUE_ACTIONS = [ const GITHUB_COMMENT_ACTIONS = ["created", "edited", "deleted"]; const GITHUB_TRIAGE_CONTROL_LABEL = "skip-triage"; const WORKFLOW_POLICY_JSON = "{\"version\":1,\"duplicateConfidenceThreshold\":0.92,\"classificationConfidenceThreshold\":0.75,\"priorityConfidenceThreshold\":0.8,\"maxCandidates\":20,\"maxRelatedIssues\":5,\"skipLabels\":[\"skip-triage\"],\"managedLabelPrefixes\":[\"priority:\",\"triage:\"],\"classificationLabels\":{\"bug\":\"bug\",\"enhancement\":\"enhancement\",\"documentation\":\"documentation\",\"question\":\"question\"},\"labelColors\":{\"bug\":\"d73a4a\",\"documentation\":\"0075ca\",\"enhancement\":\"a2eeef\",\"question\":\"d876e3\",\"priority:P0\":\"b60205\",\"priority:P1\":\"d93f0b\",\"priority:P2\":\"fbca04\",\"priority:P3\":\"0e8a16\",\"priority:pending\":\"c5def5\",\"triage:done\":\"0e8a16\",\"triage:needs-info\":\"fbca04\",\"duplicate\":\"cfd3d7\"},\"labelDescriptions\":{\"bug\":\"Something isn't working\",\"documentation\":\"Improvements or additions to documentation\",\"enhancement\":\"New feature or request\",\"question\":\"Further information is requested\",\"priority:P0\":\"Automated triage: critical and immediate impact\",\"priority:P1\":\"Automated triage: high-priority impact\",\"priority:P2\":\"Automated triage: significant impact\",\"priority:P3\":\"Automated triage: supported low-impact work\",\"priority:pending\":\"Automated triage: priority needs more evidence\",\"triage:done\":\"Automated initial triage completed\",\"triage:needs-info\":\"Automated triage needs reporter information\",\"duplicate\":\"This issue or pull request already exists\"}}"; -const WORKFLOW_TOOL_PATH = - "$WORKSPACE/workflow-repo/agents/issue-triage/tool/main.mjs"; +const WORKFLOW_TOOL_PATH = "$WORKSPACE/workflow-repo/agents/issue-triage/tool/main.mjs"; const ANALYSIS_SCHEMA = { type: "object", diff --git a/scripts/build-tools.ts b/scripts/build-tools.ts index 140d7ba..fe16fbc 100644 --- a/scripts/build-tools.ts +++ b/scripts/build-tools.ts @@ -5,8 +5,11 @@ import { build } from "esbuild"; const repositoryRoot = fileURLToPath(new URL("../", import.meta.url)); const workflowPolicyPlaceholder = "__WORKFLOW_POLICY_JSON__"; +const workflowToolPathPlaceholder = "__WORKFLOW_TOOL_PATH__"; const generatedFileBanner = "// Generated by scripts/build-tools.ts. Do not edit directly."; +// Must match every agents..workspace.target in agent-compose.yml. +const workspaceToolTarget = "workflow-repo"; const buildTargets = { "issue-triage": { @@ -25,6 +28,10 @@ const buildTargets = { }, } as const; +function toolPath(toolOutfile: string): string { + return `$WORKSPACE/${workspaceToolTarget}/${toolOutfile}`; +} + export type BuildTargetName = keyof typeof buildTargets; export interface BuildOptions { @@ -39,19 +46,27 @@ export function normalizeGeneratedSource(source: string): string { export function renderSchedulerArtifact( schedulerSource: string, workflowPolicySource: string, + workflowToolPath: string, ): string { - const generated = replaceExactlyOnce( + let generated = replaceExactlyOnce( schedulerSource, workflowPolicyPlaceholder, JSON.stringify(JSON.parse(workflowPolicySource)), ); - return normalizeGeneratedSource([generatedFileBanner, generated].join("\n")); + generated = replaceExactlyOnce( + generated, + workflowToolPathPlaceholder, + workflowToolPath, + ); + return withGeneratedFileBanner(generated); } export function renderToolArtifact(workflowToolSource: string): string { - return normalizeGeneratedSource( - [generatedFileBanner, workflowToolSource].join("\n"), - ); + return withGeneratedFileBanner(workflowToolSource); +} + +function withGeneratedFileBanner(source: string): string { + return normalizeGeneratedSource([generatedFileBanner, source].join("\n")); } function replaceExactlyOnce( @@ -124,17 +139,14 @@ async function buildTarget( }); const output = result.outputFiles?.[0]; if (!output) throw new Error(`esbuild produced no output for ${targetName}`); - const schedulerSource = await readFile( - path.join(repositoryRoot, target.schedulerSource), - "utf8", - ); - const policySource = await readFile( - path.join(repositoryRoot, target.policySource), - "utf8", - ); + const [schedulerSource, policySource] = await Promise.all([ + readFile(path.join(repositoryRoot, target.schedulerSource), "utf8"), + readFile(path.join(repositoryRoot, target.policySource), "utf8"), + ]); const generatedScheduler = renderSchedulerArtifact( schedulerSource, policySource, + toolPath(target.toolOutfile), ); const generatedTool = renderToolArtifact(output.text); diff --git a/src/schedulers/draft-pr.js b/src/schedulers/draft-pr.js index 6df4f74..cb9db56 100644 --- a/src/schedulers/draft-pr.js +++ b/src/schedulers/draft-pr.js @@ -4,8 +4,7 @@ const GITHUB_WORKFLOW_RUN_TOPIC = "webhook.github.workflow_run"; const READY_LABEL = "agent:ready"; const APPROVED_LABEL = "agent:approved"; const WORKFLOW_POLICY_JSON = "__WORKFLOW_POLICY_JSON__"; -const WORKFLOW_TOOL_PATH = - "$WORKSPACE/workflow-repo/agents/draft-pr/tool/main.mjs"; +const WORKFLOW_TOOL_PATH = "__WORKFLOW_TOOL_PATH__"; const WORKSPACE_VOLUME = { type: "bind", source: "./.draft-pr-workspaces", diff --git a/src/schedulers/issue-triage.js b/src/schedulers/issue-triage.js index f96fba9..6aec2a8 100644 --- a/src/schedulers/issue-triage.js +++ b/src/schedulers/issue-triage.js @@ -10,8 +10,7 @@ const GITHUB_ISSUE_ACTIONS = [ const GITHUB_COMMENT_ACTIONS = ["created", "edited", "deleted"]; const GITHUB_TRIAGE_CONTROL_LABEL = "skip-triage"; const WORKFLOW_POLICY_JSON = "__WORKFLOW_POLICY_JSON__"; -const WORKFLOW_TOOL_PATH = - "$WORKSPACE/workflow-repo/agents/issue-triage/tool/main.mjs"; +const WORKFLOW_TOOL_PATH = "__WORKFLOW_TOOL_PATH__"; const ANALYSIS_SCHEMA = { type: "object", diff --git a/test/build-tools.test.ts b/test/build-tools.test.ts index 48eb490..5377149 100644 --- a/test/build-tools.test.ts +++ b/test/build-tools.test.ts @@ -61,12 +61,15 @@ describe("generated Scheduler artifact build", () => { ); }); - it("embeds the deterministic tool policy in a scheduler artifact", () => { + it("embeds the deterministic tool policy and path in a scheduler artifact", () => { const artifact = renderSchedulerArtifact( - ['const WORKFLOW_POLICY_JSON = "__WORKFLOW_POLICY_JSON__";', ""].join( - "\n", - ), + [ + 'const WORKFLOW_POLICY_JSON = "__WORKFLOW_POLICY_JSON__";', + 'const WORKFLOW_TOOL_PATH = "__WORKFLOW_TOOL_PATH__";', + "", + ].join("\n"), '{"enabled":true}\n', + "$WORKSPACE/workflow-repo/agents/draft-pr/tool/main.mjs", ); expect(artifact).toContain("Generated by scripts/build-tools.ts"); @@ -74,9 +77,13 @@ describe("generated Scheduler artifact build", () => { 'const WORKFLOW_POLICY_JSON = "{\\\"enabled\\\":true}";', ); expect(artifact).not.toContain("__WORKFLOW_POLICY_JSON__"); - expect(() => renderSchedulerArtifact("const value = 1;", "{}")).toThrow( - "exactly one __WORKFLOW_POLICY_JSON__ placeholder", + expect(artifact).toContain( + 'const WORKFLOW_TOOL_PATH = "$WORKSPACE/workflow-repo/agents/draft-pr/tool/main.mjs";', ); + expect(artifact).not.toContain("__WORKFLOW_TOOL_PATH__"); + expect(() => + renderSchedulerArtifact("const value = 1;", "{}", "tool-path"), + ).toThrow("exactly one __WORKFLOW_POLICY_JSON__ placeholder"); }); it("renders a standalone tool artifact with the generated-file banner", () => { @@ -102,6 +109,8 @@ describe("generated Scheduler artifact build", () => { expect(bundle).toContain("Generated by scripts/build-tools.ts"); expect(bundle).toContain("WORKFLOW_POLICY_JSON"); expect(bundle).not.toContain("__WORKFLOW_POLICY_JSON__"); + expect(bundle).toContain("WORKFLOW_TOOL_PATH"); + expect(bundle).not.toContain("__WORKFLOW_TOOL_PATH__"); expect(bundle).not.toContain("WORKFLOW_TOOL_BASE64"); expect(bundle).not.toContain("WORKFLOW_TOOL_CHUNK_"); expect(bundle).not.toContain("node_modules/zod/v4/locales/"); From a06129f0710280ed43734f89648dbdf356ab3041 Mon Sep 17 00:00:00 2001 From: winterfx Date: Thu, 13 Aug 2026 15:25:24 +0800 Subject: [PATCH 4/4] chore(hooks): auto-rebuild tool bundles on commit Add a pre-commit hook that reruns `npm run build` and re-stages agents/*/tool/main.mjs and agents/*/scheduler.js whenever staged src/ changes would make them stale, so contributors only need to edit the TypeScript sources by hand. CI's `build:check` remains the backstop for --no-verify commits or environments without the hook enabled. Wired up via package.json's "prepare" script so `npm install` sets core.hooksPath automatically. Co-Authored-By: Claude Sonnet 5 --- .githooks/pre-commit | 15 +++++++++++++++ package.json | 1 + 2 files changed, 16 insertions(+) create mode 100755 .githooks/pre-commit diff --git a/.githooks/pre-commit b/.githooks/pre-commit new file mode 100755 index 0000000..f64c14b --- /dev/null +++ b/.githooks/pre-commit @@ -0,0 +1,15 @@ +#!/usr/bin/env bash +# Installed via `core.hooksPath` (see package.json "prepare" script). +# Rebuilds and re-stages the committed agents/*/tool/main.mjs and +# agents/*/scheduler.js bundles whenever staged src/ changes would make +# them stale, so `npm run build` never has to be run by hand. +set -euo pipefail + +if git diff --cached --name-only --diff-filter=ACM | grep -q '^src/'; then + npm run build --silent + git add \ + agents/issue-triage/tool/main.mjs \ + agents/draft-pr/tool/main.mjs \ + agents/issue-triage/scheduler.js \ + agents/draft-pr/scheduler.js +fi diff --git a/package.json b/package.json index 0493017..fffffc5 100644 --- a/package.json +++ b/package.json @@ -7,6 +7,7 @@ "node": ">=20" }, "scripts": { + "prepare": "git config core.hooksPath .githooks", "build": "tsx scripts/build-tools.ts", "build:issue-triage": "tsx scripts/build-tools.ts issue-triage", "build:draft-pr": "tsx scripts/build-tools.ts draft-pr",