mason4agents 0.1.0

package/dist/pi/extension.js

@@ -0,0 +1,4301 @@
+// @bun
+var __defProp = Object.defineProperty;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+
+// src/pi/cli.ts
+import { spawn } from "child_process";
+
+// src/pi/binary.ts
+import { accessSync, constants, existsSync, statSync } from "fs";
+import { dirname, join, resolve } from "path";
+import { fileURLToPath } from "url";
+function resolveMasonBinary(env = process.env, startUrl = import.meta.url) {
+  return resolveMasonBinaryDetailed(env, startUrl).path;
+}
+function resolveMasonBinaryDetailed(env = process.env, startUrl = import.meta.url) {
+  if (env.MASON4AGENTS_BIN && env.MASON4AGENTS_BIN.length > 0) {
+    const explicit = resolve(env.MASON4AGENTS_BIN);
+    if (!existsSync(explicit)) {
+      throw new Error(`MASON4AGENTS_BIN points to a missing file: ${explicit}`);
+    }
+    const stat = statSync(explicit);
+    if (!stat.isFile()) {
+      throw new Error(`MASON4AGENTS_BIN points to a non-file path: ${explicit}`);
+    }
+    if (process.platform !== "win32" && (stat.mode & 73) === 0) {
+      throw new Error(`MASON4AGENTS_BIN points to a non-executable file: ${explicit}`);
+    }
+    return { path: explicit, source: "env" };
+  }
+  const root = packageRoot(startUrl);
+  for (const candidate of bundledCandidates(root)) {
+    if (existsSync(candidate) && isExecutable(candidate)) {
+      return { path: candidate, source: "bundled" };
+    }
+  }
+  for (const candidate of developmentCandidates(root)) {
+    if (existsSync(candidate) && isExecutable(candidate)) {
+      return { path: candidate, source: "development" };
+    }
+  }
+  throw new Error(`Unable to locate mason4agents native binary. Set MASON4AGENTS_BIN or build crates/mason4agents.`);
+}
+function isExecutable(filePath) {
+  if (process.platform === "win32") {
+    return existsSync(filePath) && statSync(filePath).isFile();
+  }
+  try {
+    return statSync(filePath).isFile() && (accessSync(filePath, constants.X_OK), true);
+  } catch {
+    return false;
+  }
+}
+function packageRoot(startUrl = import.meta.url) {
+  let dir = dirname(fileURLToPath(startUrl));
+  for (let i = 0;i < 8; i += 1) {
+    if (existsSync(join(dir, "package.json"))) {
+      return dir;
+    }
+    const parent = dirname(dir);
+    if (parent === dir) {
+      break;
+    }
+    dir = parent;
+  }
+  return resolve(dirname(fileURLToPath(startUrl)), "..", "..");
+}
+function bundledCandidates(root) {
+  const platform = process.platform;
+  const arch = normalizeArch(process.arch);
+  const exe = platform === "win32" ? ".exe" : "";
+  const candidates = [
+    join(root, "native", `mason4agents-${platform}-${arch}${exe}`),
+    join(root, "native", `mason4agents${exe}`),
+    join(root, "dist", "native", `mason4agents-${platform}-${arch}${exe}`),
+    join(root, "dist", "native", `mason4agents${exe}`)
+  ];
+  if (platform === "win32") {
+    candidates.unshift(join(root, "native", `mason4agents-${platform}-${arch}`), join(root, "dist", "native", `mason4agents-${platform}-${arch}`));
+  }
+  return candidates;
+}
+function developmentCandidates(root) {
+  const exe = process.platform === "win32" ? ".exe" : "";
+  return [
+    join(root, "target", "debug", "mason4agents" + exe),
+    join(root, "target", "release", "mason4agents" + exe),
+    join(root, "..", "target", "debug", "mason4agents" + exe),
+    join(root, "..", "target", "release", "mason4agents" + exe)
+  ];
+}
+function normalizeArch(arch) {
+  if (arch === "x64")
+    return "x64";
+  if (arch === "arm64")
+    return "arm64";
+  return arch;
+}
+
+// src/pi/cli.ts
+class MasonCliError extends Error {
+  code;
+  details;
+  stderr;
+  constructor(message, code, details, stderr) {
+    super(message);
+    this.name = "MasonCliError";
+    this.code = code;
+    this.details = details;
+    this.stderr = stderr;
+  }
+}
+function createCliBridge(binary) {
+  return {
+    run(args, options) {
+      return runCliJson(binary ?? resolveMasonBinary(), args, options);
+    }
+  };
+}
+function runCliJson(binary, args, options = {}) {
+  const finalArgs = args.includes("--json") ? args : [...args, "--json"];
+  if (options.signal?.aborted) {
+    return Promise.reject(new MasonCliError("mason4agents command aborted before start", "aborted", undefined, ""));
+  }
+  return new Promise((resolve2, reject) => {
+    const child = spawn(binary, finalArgs, { stdio: ["ignore", "pipe", "pipe"], env: process.env });
+    let stdout = "";
+    let stderr = "";
+    let settled = false;
+    const abort = () => {
+      if (settled)
+        return;
+      child.kill("SIGTERM");
+      settled = true;
+      reject(new MasonCliError("mason4agents command aborted", "aborted", undefined, stderr));
+    };
+    options.signal?.addEventListener("abort", abort, { once: true });
+    child.stdout.setEncoding("utf8");
+    child.stderr.setEncoding("utf8");
+    child.stdout.on("data", (chunk) => {
+      stdout += chunk;
+    });
+    child.stderr.on("data", (chunk) => {
+      stderr += chunk;
+    });
+    child.on("error", (err) => {
+      if (settled)
+        return;
+      settled = true;
+      options.signal?.removeEventListener("abort", abort);
+      reject(err);
+    });
+    child.on("close", (code) => {
+      if (settled)
+        return;
+      settled = true;
+      options.signal?.removeEventListener("abort", abort);
+      let parsed;
+      if (code === 0 || stdout.startsWith("{")) {
+        try {
+          parsed = parseJson(stdout, stderr);
+        } catch (err) {
+          reject(err);
+          return;
+        }
+      }
+      if (code === 0 && isOkEnvelope(parsed)) {
+        resolve2(parsed.data);
+        return;
+      }
+      if (code === 0) {
+        resolve2(parsed);
+        return;
+      }
+      if (isErrorEnvelope(parsed)) {
+        reject(new MasonCliError(parsed.error.message, parsed.error.code, parsed, stderr));
+        return;
+      }
+      reject(new MasonCliError(stderr || `mason4agents exited with code ${code ?? -1}`, "command_failed", parsed, stderr));
+    });
+  });
+}
+function parseJson(stdout, stderr) {
+  try {
+    return JSON.parse(stdout);
+  } catch (cause) {
+    throw new MasonCliError(`mason4agents produced invalid JSON on stdout: ${cause.message}`, "invalid_json", stdout, stderr);
+  }
+}
+function isOkEnvelope(value) {
+  return typeof value === "object" && value !== null && value.ok === true && "data" in value;
+}
+function isErrorEnvelope(value) {
+  if (typeof value !== "object" || value === null)
+    return false;
+  const envelope = value;
+  if (envelope.ok !== false || typeof envelope.error !== "object" || envelope.error === null)
+    return false;
+  const error = envelope.error;
+  return typeof error.code === "string" && typeof error.message === "string";
+}
+
+// src/pi/mason-render.ts
+var TABLE_SEPARATOR = "  ";
+var DEFAULT_MAX_ROWS = 24;
+function usageDisplay() {
+  return {
+    kind: "usage",
+    title: "mason4agents commands",
+    lines: [
+      "/mason                                      open interactive panel",
+      "/mason refresh [--registry <source>]",
+      "/mason search [query] [--category <category>] [--language <language>] [--registry <source>]",
+      "/mason list [--installed] [--outdated] [--registry <source>]",
+      "/mason installed                             alias for list --installed",
+      "/mason outdated                              alias for list --outdated",
+      "/mason install <pkg[@version]>... [--registry <source>] [--allow-build-scripts]",
+      "/mason uninstall <pkg>...",
+      "/mason update [pkg...] [--registry <source>] [--allow-build-scripts]",
+      "/mason which <executable>",
+      "/mason bin-dir",
+      "/mason env --shell bash|zsh|fish|powershell|cmd|json",
+      "/mason doctor",
+      "",
+      "Table views: use / to filter, \u2191/\u2193 or PgUp/PgDn to scroll, q or Esc to close."
+    ]
+  };
+}
+function errorDisplay(title, message, lines = []) {
+  return { kind: "error", title, message, lines };
+}
+function modelForResult(kind, data, title) {
+  switch (kind) {
+    case "packages":
+      return packageTable(title, data);
+    case "installed":
+      return installedTable(title, data);
+    case "install":
+      return installTable(title, data);
+    case "uninstall":
+      return uninstallTable(title, data);
+    case "which":
+      return whichSummary(title, data);
+    case "bin-dir":
+      return binDirSummary(title, data);
+    case "env":
+      return envSummary(title, data);
+    case "doctor":
+      return doctorSummary(title, data);
+    case "refresh":
+      return refreshSummary(title, data);
+  }
+}
+function renderDisplay(model, options) {
+  const width = normalizeWidth(options.width);
+  switch (model.kind) {
+    case "table":
+      return renderTableDisplay(model, width, options);
+    case "summary":
+      return renderTextDisplay(model.title, model.lines, width);
+    case "usage":
+      return renderTextDisplay(model.title, model.lines, width);
+    case "error": {
+      const lines = [`Error: ${model.message}`, ...model.lines ?? []];
+      return renderTextDisplay(model.title, lines, width);
+    }
+  }
+}
+function renderDisplayText(model, width = 120) {
+  return renderDisplay(model, { width, maxRows: 100 }).join(`
+`);
+}
+function modelSupportsFiltering(model) {
+  return model.kind === "table" && model.searchable;
+}
+function packageTable(title, data) {
+  const rows = Array.isArray(data) ? data.map(packageRow) : [];
+  const display = {
+    kind: "table",
+    title,
+    columns: [
+      { label: "Name", minWidth: 8, maxWidth: 28 },
+      { label: "Version", minWidth: 7, maxWidth: 16 },
+      { label: "Status", minWidth: 8, maxWidth: 12 },
+      { label: "Installed", minWidth: 9, maxWidth: 16 },
+      { label: "Languages", minWidth: 9, maxWidth: 18 },
+      { label: "Categories", minWidth: 10, maxWidth: 18 },
+      { label: "Description", minWidth: 12, maxWidth: 48 }
+    ],
+    rows,
+    emptyMessage: Array.isArray(data) ? "No packages found." : "Unexpected package list response.",
+    searchable: true
+  };
+  return display;
+}
+function installedTable(title, data) {
+  const rows = Array.isArray(data) ? data.map(installedRow) : [];
+  return {
+    kind: "table",
+    title,
+    columns: [
+      { label: "Name", minWidth: 8, maxWidth: 30 },
+      { label: "Version", minWidth: 7, maxWidth: 16 },
+      { label: "Bins", minWidth: 4, maxWidth: 32 },
+      { label: "Installed At", minWidth: 12, maxWidth: 24 }
+    ],
+    rows,
+    emptyMessage: Array.isArray(data) ? "No packages installed." : "Unexpected installed package response.",
+    searchable: true
+  };
+}
+function installTable(title, data) {
+  if (!Array.isArray(data))
+    return summaryFromUnknown(title, data);
+  return {
+    kind: "table",
+    title,
+    columns: [
+      { label: "Package", minWidth: 8, maxWidth: 30 },
+      { label: "Version", minWidth: 7, maxWidth: 16 },
+      { label: "Source", minWidth: 8, maxWidth: 36 },
+      { label: "Bins", minWidth: 4, maxWidth: 32 },
+      { label: "Package Dir", minWidth: 11, maxWidth: 48 }
+    ],
+    rows: data.map(installRow),
+    emptyMessage: "Nothing to install or update.",
+    searchable: true
+  };
+}
+function uninstallTable(title, data) {
+  if (!Array.isArray(data))
+    return summaryFromUnknown(title, data);
+  return {
+    kind: "table",
+    title,
+    columns: [
+      { label: "Package", minWidth: 8, maxWidth: 32 },
+      { label: "Result", minWidth: 7, maxWidth: 16 }
+    ],
+    rows: data.map(uninstallRow),
+    emptyMessage: "Nothing to uninstall.",
+    searchable: true
+  };
+}
+function whichSummary(title, data) {
+  if (!isRecord(data))
+    return summaryFromUnknown(title, data);
+  const executable = stringValue(data.executable) || "<unknown>";
+  const path = stringValue(data.path);
+  const pkg = stringValue(data.package);
+  const lines = path.length > 0 ? [`${executable}: ${path}`, pkg.length > 0 ? `Package: ${pkg}` : ""] : [`${executable}: not found`, pkg.length > 0 ? `Package: ${pkg}` : ""];
+  return { kind: "summary", title, lines: lines.filter((line) => line.length > 0) };
+}
+function binDirSummary(title, data) {
+  if (isRecord(data)) {
+    const binDir = stringValue(data.bin_dir);
+    if (binDir.length > 0)
+      return { kind: "summary", title, lines: [`Bin dir: ${binDir}`] };
+  }
+  if (typeof data === "string")
+    return { kind: "summary", title, lines: [`Bin dir: ${data}`] };
+  return summaryFromUnknown(title, data);
+}
+function envSummary(title, data) {
+  if (!isRecord(data))
+    return summaryFromUnknown(title, data);
+  const shell = stringValue(data.shell);
+  if (shell.length > 0)
+    return { kind: "summary", title, lines: [shell] };
+  const path = stringValue(data.PATH);
+  if (path.length > 0)
+    return { kind: "summary", title, lines: [`PATH=${path}`] };
+  return summaryFromUnknown(title, data);
+}
+function refreshSummary(title, data) {
+  if (!isRecord(data))
+    return summaryFromUnknown(title, data);
+  return {
+    kind: "summary",
+    title,
+    lines: [
+      `Source: ${stringValue(data.source) || "-"}`,
+      `Packages: ${stringValue(data.package_count) || "0"}`,
+      `Cache: ${stringValue(data.cache_file) || "-"}`,
+      `Checksum: ${stringValue(data.checksum) || "-"}`
+    ]
+  };
+}
+function doctorSummary(title, data) {
+  if (!isRecord(data))
+    return summaryFromUnknown(title, data);
+  const lines = [];
+  const paths = recordValue(data.paths);
+  if (paths) {
+    pushLine(lines, "Bin dir", paths.bin_dir);
+    pushLine(lines, "Bin dir exists", yesNo(paths.bin_dir_exists));
+    pushLine(lines, "Data writable", yesNo(paths.data_dir_writable));
+  }
+  const registry = recordValue(data.registry);
+  if (registry) {
+    if (registry.cache_present === true) {
+      lines.push(`Registry cache: ${stringValue(registry.package_count) || "0"} packages`);
+    } else {
+      lines.push(`Registry cache: ${stringValue(registry.error) || "missing"}`);
+    }
+  }
+  const pathEnv = recordValue(data.path_env);
+  if (pathEnv) {
+    pushLine(lines, "PATH contains bin", yesNo(pathEnv.contains_bin_dir));
+    pushLine(lines, "PATH bin first", yesNo(pathEnv.bin_dir_first));
+  }
+  const managers = Array.isArray(data.managers) ? data.managers : [];
+  if (managers.length > 0) {
+    lines.push("Managers:");
+    for (const manager of managers) {
+      if (!isRecord(manager))
+        continue;
+      const name = stringValue(manager.source_type) || "<unknown>";
+      lines.push(`  ${name}: ${manager.available === true ? "installed" : "missing"}`);
+    }
+  }
+  lines.push(`Overall: ${data.ok === true ? "ok" : "needs attention"}`);
+  return { kind: "summary", title, lines };
+}
+function summaryFromUnknown(title, data) {
+  return { kind: "summary", title, lines: summarizeUnknown(data) };
+}
+function packageRow(value) {
+  if (!isRecord(value))
+    return [String(value), "", "", "", "", "", ""];
+  return [
+    stringValue(value.name) || "<unknown>",
+    stringValue(value.version) || "-",
+    packageStatus(value),
+    stringValue(value.installed_version) || "-",
+    stringList(value.languages),
+    stringList(value.categories),
+    stringValue(value.description)
+  ];
+}
+function installedRow(value) {
+  if (!isRecord(value))
+    return [String(value), "", "", ""];
+  return [
+    stringValue(value.name) || "<unknown>",
+    stringValue(value.version) || "-",
+    keyList(value.bins),
+    stringValue(value.installed_at) || "-"
+  ];
+}
+function installRow(value) {
+  if (!isRecord(value))
+    return [String(value), "", "", "", ""];
+  return [
+    stringValue(value.package) || "<unknown>",
+    stringValue(value.version) || "-",
+    stringValue(value.source_id) || "-",
+    keyList(value.bins),
+    stringValue(value.package_dir) || "-"
+  ];
+}
+function uninstallRow(value) {
+  if (!isRecord(value))
+    return [String(value), ""];
+  return [stringValue(value.package) || "<unknown>", value.removed === true ? "removed" : "not installed"];
+}
+function packageStatus(value) {
+  if (value.deprecated === true)
+    return "deprecated";
+  if (value.installed === true && value.outdated === true)
+    return "outdated";
+  if (value.installed === true)
+    return "installed";
+  return "available";
+}
+function renderTableDisplay(model, width, options) {
+  const filter = options.filter?.trim() ?? "";
+  const filteredRows = filterTableRows(model.rows, filter);
+  const maxRows = Math.max(1, Math.floor(options.maxRows ?? DEFAULT_MAX_ROWS));
+  const maxScroll = Math.max(0, filteredRows.length - maxRows);
+  const scroll = clamp(Math.floor(options.scroll ?? 0), 0, maxScroll);
+  const end = Math.min(filteredRows.length, scroll + maxRows);
+  const titleParts = [`${model.title} \u2014 ${filteredRows.length}/${model.rows.length}`];
+  if (filter.length > 0)
+    titleParts.push(`filter: ${filter}`);
+  const lines = [truncateToWidth(titleParts.join("  "), width)];
+  if (model.subtitle && model.subtitle.length > 0)
+    lines.push(truncateToWidth(model.subtitle, width));
+  if (filteredRows.length === 0) {
+    lines.push(truncateToWidth(model.emptyMessage, width));
+    return lines;
+  }
+  const visibleRows = filteredRows.slice(scroll, end);
+  const layout = computeColumnLayout(model.columns, visibleRows, width);
+  lines.push(formatTableRow(model.columns.map((column) => column.label), layout, width));
+  lines.push(truncateToWidth(layout.separator, width));
+  for (const row of visibleRows)
+    lines.push(formatTableRow(row, layout, width));
+  const range = `showing ${scroll + 1}-${end} of ${filteredRows.length}`;
+  const help = model.searchable ? `${range}  / filter  \u2191\u2193 scroll  q close` : `${range}  \u2191\u2193 scroll  q close`;
+  lines.push(truncateToWidth(help, width));
+  if (model.footer) {
+    for (const line of model.footer)
+      lines.push(truncateToWidth(line, width));
+  }
+  return lines;
+}
+function renderTextDisplay(title, textLines, width) {
+  const lines = [truncateToWidth(title, width)];
+  for (const line of textLines)
+    lines.push(truncateToWidth(line, width));
+  return lines;
+}
+function filterTableRows(rows, filter) {
+  if (filter.length === 0)
+    return rows;
+  const needle = filter.toLocaleLowerCase();
+  return rows.filter((row) => row.join(" ").toLocaleLowerCase().includes(needle));
+}
+function computeColumnLayout(columns, rows, width) {
+  if (columns.length === 0)
+    return { widths: [width], separator: "" };
+  let count = columns.length;
+  while (count > 1 && minimumTableWidth(columns, count) > width)
+    count -= 1;
+  const widths = [];
+  for (let index = 0;index < count; index += 1) {
+    const column = columns[index];
+    const minWidth = columnMinWidth(column);
+    const maxWidth = Math.max(minWidth, column.maxWidth ?? 80);
+    let desired = clamp(column.label.length, minWidth, maxWidth);
+    for (const row of rows) {
+      desired = Math.max(desired, clamp((row[index] ?? "").length, minWidth, maxWidth));
+    }
+    widths.push(desired);
+  }
+  let total = widths.reduce((sum, value) => sum + value, 0) + TABLE_SEPARATOR.length * Math.max(0, count - 1);
+  while (total > width && widths.some((value, index) => value > columnMinWidth(columns[index]))) {
+    let widest = 0;
+    for (let index = 1;index < widths.length; index += 1) {
+      if (widths[index] > widths[widest])
+        widest = index;
+    }
+    const minWidth = columnMinWidth(columns[widest]);
+    if (widths[widest] <= minWidth)
+      break;
+    widths[widest] = widths[widest] - 1;
+    total -= 1;
+  }
+  if (total > width && widths.length === 1)
+    widths[0] = width;
+  return { widths, separator: "\u2500".repeat(Math.min(width, Math.max(1, total))) };
+}
+function minimumTableWidth(columns, count) {
+  let total = TABLE_SEPARATOR.length * Math.max(0, count - 1);
+  for (let index = 0;index < count; index += 1)
+    total += columnMinWidth(columns[index]);
+  return total;
+}
+function columnMinWidth(column) {
+  return Math.max(1, column.minWidth ?? Math.min(8, Math.max(1, column.label.length)));
+}
+function formatTableRow(row, layout, width) {
+  const cells = layout.widths.map((cellWidth, index) => padRight(truncateToWidth(row[index] ?? "", cellWidth), cellWidth));
+  return truncateToWidth(cells.join(TABLE_SEPARATOR), width);
+}
+function truncateToWidth(value, width) {
+  if (width <= 0)
+    return "";
+  if (value.length <= width)
+    return value;
+  if (width === 1)
+    return value.slice(0, 1);
+  return `${value.slice(0, width - 1)}\u2026`;
+}
+function padRight(value, width) {
+  if (value.length >= width)
+    return value;
+  return value + " ".repeat(width - value.length);
+}
+function normalizeWidth(width) {
+  if (!Number.isFinite(width))
+    return 80;
+  return Math.max(1, Math.floor(width));
+}
+function clamp(value, min, max) {
+  return Math.min(max, Math.max(min, value));
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function recordValue(value) {
+  return isRecord(value) ? value : undefined;
+}
+function stringValue(value) {
+  if (value === null || value === undefined)
+    return "";
+  if (typeof value === "string")
+    return value;
+  if (typeof value === "number" || typeof value === "boolean")
+    return String(value);
+  return "";
+}
+function stringList(value) {
+  if (!Array.isArray(value))
+    return "";
+  return value.map(stringValue).filter((item) => item.length > 0).join(",");
+}
+function keyList(value) {
+  if (!isRecord(value))
+    return "";
+  return Object.keys(value).join(",");
+}
+function yesNo(value) {
+  if (value === true)
+    return "yes";
+  if (value === false)
+    return "no";
+  return stringValue(value) || "unknown";
+}
+function pushLine(lines, label, value) {
+  const rendered = stringValue(value);
+  if (rendered.length > 0)
+    lines.push(`${label}: ${rendered}`);
+}
+function summarizeUnknown(value) {
+  if (value === null || value === undefined)
+    return ["No data returned."];
+  if (typeof value === "string" || typeof value === "number" || typeof value === "boolean")
+    return [String(value)];
+  if (Array.isArray(value))
+    return [`${value.length} item(s) returned.`];
+  if (!isRecord(value))
+    return [String(value)];
+  const lines = [];
+  for (const [key, child] of Object.entries(value)) {
+    if (child === null || child === undefined) {
+      lines.push(`${key}: -`);
+    } else if (typeof child === "string" || typeof child === "number" || typeof child === "boolean") {
+      lines.push(`${key}: ${String(child)}`);
+    } else if (Array.isArray(child)) {
+      lines.push(`${key}: ${child.length} item(s)`);
+    } else {
+      lines.push(`${key}: object`);
+    }
+  }
+  return lines.length > 0 ? lines : ["No displayable fields returned."];
+}
+
+// src/pi/mason-command.ts
+class MasonCommandInputError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "MasonCommandInputError";
+  }
+}
+var SHELLS = new Set(["bash", "zsh", "fish", "powershell", "cmd", "json"]);
+async function executeMasonCommand(input, bridge, options = {}) {
+  let parsed;
+  try {
+    parsed = parseMasonCommandInput(input);
+  } catch (err) {
+    return errorDisplay("mason4agents", messageFromError(err), usageDisplay().lines);
+  }
+  if (parsed.kind === "usage")
+    return usageDisplay();
+  try {
+    const data = await bridge.run(parsed.argv, options);
+    return modelForResult(parsed.resultKind, data, parsed.title);
+  } catch (err) {
+    return errorDisplay(parsed.title, messageFromError(err));
+  }
+}
+function parseMasonCommandInput(input) {
+  const tokens = tokenizeMasonArgs(input);
+  if (tokens.length === 0 || tokens[0] === "help" || tokens[0] === "--help" || tokens[0] === "-h")
+    return { kind: "usage" };
+  return parseMasonCommandTokens(tokens);
+}
+function parseMasonCommandTokens(tokens) {
+  const command = tokens[0];
+  if (!command)
+    return { kind: "usage" };
+  if (command === "help" || command === "--help" || command === "-h")
+    return { kind: "usage" };
+  const rest = tokens.slice(1);
+  switch (command) {
+    case "refresh":
+      return parseRefresh(rest);
+    case "search":
+      return parseSearch(rest);
+    case "list":
+      return parseList(rest);
+    case "installed":
+      return parseInstalled(rest);
+    case "outdated":
+      return parseOutdated(rest);
+    case "install":
+      return parseInstall(rest);
+    case "uninstall":
+      return parseUninstall(rest);
+    case "update":
+      return parseUpdate(rest);
+    case "which":
+      return parseWhich(rest);
+    case "bin-dir":
+      return parseNoArgCommand("bin-dir", rest, ["bin-dir"], "bin-dir", "mason bin-dir");
+    case "env":
+      return parseEnv(rest);
+    case "doctor":
+      return parseNoArgCommand("doctor", rest, ["doctor"], "doctor", "mason doctor");
+    default:
+      throw new MasonCommandInputError(`Unknown /mason subcommand: ${command}`);
+  }
+}
+function tokenizeMasonArgs(input) {
+  const tokens = [];
+  let current = "";
+  let quote;
+  let escaped = false;
+  for (let index = 0;index < input.length; index += 1) {
+    const char = input[index];
+    if (escaped) {
+      current += char;
+      escaped = false;
+      continue;
+    }
+    if (char === "\\") {
+      escaped = true;
+      continue;
+    }
+    if (quote) {
+      if (char === quote) {
+        quote = undefined;
+      } else {
+        current += char;
+      }
+      continue;
+    }
+    if (char === "'" || char === '"') {
+      quote = char;
+      continue;
+    }
+    if (isWhitespace(char)) {
+      if (current.length > 0) {
+        tokens.push(current);
+        current = "";
+      }
+      continue;
+    }
+    current += char;
+  }
+  if (escaped)
+    current += "\\";
+  if (quote)
+    throw new MasonCommandInputError("Unterminated quoted string.");
+  if (current.length > 0)
+    tokens.push(current);
+  return tokens;
+}
+function parseRefresh(tokens) {
+  let registry;
+  for (let index = 0;index < tokens.length; index += 1) {
+    const token = tokens[index];
+    if (isHelp(token))
+      return usageAsError("refresh");
+    const option = readOption(tokens, index, "--registry");
+    if (option) {
+      registry = option.value;
+      index = option.nextIndex;
+      continue;
+    }
+    throw new MasonCommandInputError(`refresh does not accept positional argument: ${token}`);
+  }
+  const argv = ["refresh"];
+  pushOption(argv, "--registry", registry);
+  return command("refresh", argv, "refresh", "mason refresh");
+}
+function parseSearch(tokens) {
+  let query;
+  let category;
+  let language;
+  let registry;
+  for (let index = 0;index < tokens.length; index += 1) {
+    const token = tokens[index];
+    if (isHelp(token))
+      return usageAsError("search");
+    const categoryOption = readOption(tokens, index, "--category");
+    if (categoryOption) {
+      category = categoryOption.value;
+      index = categoryOption.nextIndex;
+      continue;
+    }
+    const languageOption = readOption(tokens, index, "--language");
+    if (languageOption) {
+      language = languageOption.value;
+      index = languageOption.nextIndex;
+      continue;
+    }
+    const registryOption = readOption(tokens, index, "--registry");
+    if (registryOption) {
+      registry = registryOption.value;
+      index = registryOption.nextIndex;
+      continue;
+    }
+    rejectUnknownOption(token);
+    if (query !== undefined)
+      throw new MasonCommandInputError("search accepts at most one query; quote spaces if needed.");
+    query = token;
+  }
+  const argv = ["search"];
+  if (query && query.length > 0)
+    argv.push(query);
+  pushOption(argv, "--category", category);
+  pushOption(argv, "--language", language);
+  pushOption(argv, "--registry", registry);
+  const title = language && language.length > 0 ? `mason search${query ? ` ${query}` : ""} language=${language}` : `mason search${query ? ` ${query}` : ""}`;
+  return command("search", argv, "packages", title);
+}
+function parseList(tokens) {
+  let installed = false;
+  let outdated = false;
+  let registry;
+  for (let index = 0;index < tokens.length; index += 1) {
+    const token = tokens[index];
+    if (isHelp(token))
+      return usageAsError("list");
+    if (token === "--installed") {
+      installed = true;
+      continue;
+    }
+    if (token === "--outdated") {
+      outdated = true;
+      continue;
+    }
+    const registryOption = readOption(tokens, index, "--registry");
+    if (registryOption) {
+      registry = registryOption.value;
+      index = registryOption.nextIndex;
+      continue;
+    }
+    rejectUnknownOption(token);
+    throw new MasonCommandInputError(`list does not accept positional argument: ${token}`);
+  }
+  if (installed && outdated)
+    throw new MasonCommandInputError("list cannot combine --installed and --outdated.");
+  const argv = ["list"];
+  if (installed)
+    argv.push("--installed");
+  if (outdated)
+    argv.push("--outdated");
+  pushOption(argv, "--registry", registry);
+  if (installed)
+    return command("list", argv, "installed", "mason list --installed");
+  return command("list", argv, "packages", outdated ? "mason list --outdated" : "mason list");
+}
+function parseInstalled(tokens) {
+  if (tokens.length > 0)
+    rejectUnexpectedArgs("installed", tokens);
+  return command("installed", ["list", "--installed"], "installed", "mason installed");
+}
+function parseOutdated(tokens) {
+  let registry;
+  for (let index = 0;index < tokens.length; index += 1) {
+    const token = tokens[index];
+    const registryOption = readOption(tokens, index, "--registry");
+    if (registryOption) {
+      registry = registryOption.value;
+      index = registryOption.nextIndex;
+      continue;
+    }
+    rejectUnknownOption(token);
+    throw new MasonCommandInputError(`outdated does not accept positional argument: ${token}`);
+  }
+  const argv = ["list", "--outdated"];
+  pushOption(argv, "--registry", registry);
+  return command("outdated", argv, "packages", "mason outdated");
+}
+function parseInstall(tokens) {
+  const parsed = parsePackageCommand("install", tokens, true);
+  if (parsed.packages.length === 0)
+    throw new MasonCommandInputError("install requires at least one package.");
+  const argv = ["install", ...parsed.packages];
+  pushOption(argv, "--registry", parsed.registry);
+  if (parsed.allowBuildScripts)
+    argv.push("--allow-build-scripts");
+  return command("install", argv, "install", "mason install");
+}
+function parseUninstall(tokens) {
+  const packages = parsePlainPositionals("uninstall", tokens);
+  if (packages.length === 0)
+    throw new MasonCommandInputError("uninstall requires at least one package.");
+  return command("uninstall", ["uninstall", ...packages], "uninstall", "mason uninstall");
+}
+function parseUpdate(tokens) {
+  const parsed = parsePackageCommand("update", tokens, true);
+  const argv = ["update", ...parsed.packages];
+  pushOption(argv, "--registry", parsed.registry);
+  if (parsed.allowBuildScripts)
+    argv.push("--allow-build-scripts");
+  return command("update", argv, "install", "mason update");
+}
+function parseWhich(tokens) {
+  const positionals = parsePlainPositionals("which", tokens);
+  if (positionals.length !== 1)
+    throw new MasonCommandInputError("which requires exactly one executable.");
+  return command("which", ["which", positionals[0]], "which", `mason which ${positionals[0]}`);
+}
+function parseEnv(tokens) {
+  let shell;
+  for (let index = 0;index < tokens.length; index += 1) {
+    const token = tokens[index];
+    if (isHelp(token))
+      return usageAsError("env");
+    const shellOption = readOption(tokens, index, "--shell");
+    if (shellOption) {
+      shell = shellOption.value;
+      index = shellOption.nextIndex;
+      continue;
+    }
+    rejectUnknownOption(token);
+    throw new MasonCommandInputError(`env does not accept positional argument: ${token}`);
+  }
+  if (!shell)
+    throw new MasonCommandInputError("env requires --shell bash|zsh|fish|powershell|cmd|json.");
+  if (!SHELLS.has(shell))
+    throw new MasonCommandInputError(`Unsupported shell: ${shell}`);
+  return command("env", ["env", "--shell", shell], "env", `mason env --shell ${shell}`);
+}
+function parseNoArgCommand(commandName, tokens, argv, resultKind, title) {
+  if (tokens.length > 0)
+    rejectUnexpectedArgs(commandName, tokens);
+  return command(commandName, argv, resultKind, title);
+}
+function parsePackageCommand(commandName, tokens, allowRegistry) {
+  const packages = [];
+  let registry;
+  let allowBuildScripts = false;
+  for (let index = 0;index < tokens.length; index += 1) {
+    const token = tokens[index];
+    if (isHelp(token))
+      return usageAsError(commandName);
+    if (token === "--allow-build-scripts") {
+      allowBuildScripts = true;
+      continue;
+    }
+    if (allowRegistry) {
+      const registryOption = readOption(tokens, index, "--registry");
+      if (registryOption) {
+        registry = registryOption.value;
+        index = registryOption.nextIndex;
+        continue;
+      }
+    }
+    rejectUnknownOption(token);
+    packages.push(token);
+  }
+  const result = { packages, allowBuildScripts };
+  if (registry !== undefined)
+    result.registry = registry;
+  return result;
+}
+function parsePlainPositionals(commandName, tokens) {
+  const positionals = [];
+  for (const token of tokens) {
+    if (isHelp(token))
+      return usageAsError(commandName);
+    rejectUnknownOption(token);
+    positionals.push(token);
+  }
+  return positionals;
+}
+function command(commandName, argv, resultKind, title) {
+  return { kind: "command", command: commandName, argv, resultKind, title };
+}
+function pushOption(argv, name, value) {
+  if (value !== undefined && value.length > 0)
+    argv.push(name, value);
+}
+function readOption(tokens, index, name) {
+  const token = tokens[index];
+  if (token === name) {
+    const value = tokens[index + 1];
+    if (value === undefined || value.startsWith("--"))
+      throw new MasonCommandInputError(`${name} requires a value.`);
+    return { value, nextIndex: index + 1 };
+  }
+  const prefix = `${name}=`;
+  if (token.startsWith(prefix)) {
+    const value = token.slice(prefix.length);
+    if (value.length === 0)
+      throw new MasonCommandInputError(`${name} requires a value.`);
+    return { value, nextIndex: index };
+  }
+  return;
+}
+function rejectUnknownOption(token) {
+  if (token.startsWith("--"))
+    throw new MasonCommandInputError(`Unknown option: ${token}`);
+}
+function rejectUnexpectedArgs(commandName, tokens) {
+  throw new MasonCommandInputError(`${commandName} does not accept arguments: ${tokens.join(" ")}`);
+}
+function usageAsError(commandName) {
+  throw new MasonCommandInputError(`Use /mason help for ${commandName} usage.`);
+}
+function isHelp(token) {
+  return token === "--help" || token === "-h";
+}
+function isWhitespace(char) {
+  return char === " " || char === "\t" || char === `
+` || char === "\r";
+}
+function messageFromError(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+
+// src/pi/mason-panel.ts
+var PANEL_COMMANDS = [
+  { id: "search", label: "search", inputLabel: "query" },
+  { id: "list", label: "list" },
+  { id: "installed", label: "installed" },
+  { id: "install", label: "install", inputLabel: "packages" },
+  { id: "uninstall", label: "uninstall", inputLabel: "packages" },
+  { id: "update", label: "update", inputLabel: "packages" },
+  { id: "which", label: "which", inputLabel: "executable" },
+  { id: "refresh", label: "refresh" },
+  { id: "doctor", label: "doctor" },
+  { id: "env", label: "env", inputLabel: "shell" },
+  { id: "bin-dir", label: "bin-dir" }
+];
+var SHELLS2 = new Set(["bash", "zsh", "fish", "powershell", "cmd", "json"]);
+function createMasonPanel(bridge) {
+  const state = {
+    command: "search",
+    commandIndex: 0,
+    query: "",
+    category: undefined,
+    language: undefined,
+    inputs: {
+      search: "",
+      list: "",
+      installed: "",
+      install: "",
+      uninstall: "",
+      update: "",
+      which: "",
+      refresh: "",
+      doctor: "",
+      env: "bash",
+      "bin-dir": ""
+    },
+    filter: "",
+    scroll: 0,
+    loading: false,
+    edit: undefined,
+    model: modelForResult("packages", [], "mason search"),
+    packages: []
+  };
+  async function execute(planned) {
+    state.loading = true;
+    state.model = { kind: "summary", title: planned.title, lines: ["Loading..."] };
+    try {
+      const data = await bridge.run(planned.argv);
+      state.lastAction = data;
+      state.model = modelForResult(planned.resultKind, data, planned.title);
+      state.packages = Array.isArray(data) && (planned.resultKind === "packages" || planned.resultKind === "installed") ? data : state.packages;
+    } catch (err) {
+      state.model = errorDisplay(planned.title, messageFromError2(err));
+    } finally {
+      state.loading = false;
+    }
+    return state;
+  }
+  const panel = {
+    title: "mason4agents",
+    state,
+    async refresh() {
+      const refreshResult = await bridge.run(["refresh"]);
+      state.lastAction = refreshResult;
+      return this.search(state.query, { category: state.category, language: state.language });
+    },
+    async search(query = "", filters = { category: undefined, language: undefined }) {
+      state.commandIndex = commandIndex("search");
+      state.command = "search";
+      state.query = query;
+      state.inputs.search = query;
+      state.category = filters.category;
+      state.language = filters.language;
+      return execute(buildSearchInvocation(state));
+    },
+    async install(packages) {
+      state.lastAction = await bridge.run(["install", ...packages]);
+      return this.search(state.query, { category: state.category, language: state.language });
+    },
+    async uninstall(packages) {
+      state.lastAction = await bridge.run(["uninstall", ...packages]);
+      return this.search(state.query, { category: state.category, language: state.language });
+    },
+    async update(packages = []) {
+      state.lastAction = await bridge.run(["update", ...packages]);
+      return this.search(state.query, { category: state.category, language: state.language });
+    },
+    async doctor() {
+      state.commandIndex = commandIndex("doctor");
+      state.command = "doctor";
+      return execute({ argv: ["doctor"], resultKind: "doctor", title: "mason doctor" });
+    },
+    async runCurrent() {
+      try {
+        return await execute(buildInvocation(state));
+      } catch (err) {
+        state.model = errorDisplay("mason4agents", messageFromError2(err));
+        return state;
+      }
+    },
+    async handleInput(key) {
+      if (state.edit) {
+        await handleEditKey(state, key, () => panel.runCurrent());
+        return;
+      }
+      if (isCloseKey(key))
+        return "close";
+      if (isNextCommandKey(key)) {
+        selectCommand(state, state.commandIndex + 1);
+        await panel.runCurrent();
+        return;
+      }
+      if (isPreviousCommandKey(key)) {
+        selectCommand(state, state.commandIndex - 1);
+        await panel.runCurrent();
+        return;
+      }
+      if (key === "/") {
+        state.edit = { kind: "filter", draft: state.filter };
+        return;
+      }
+      if ((key === "l" || key === "L") && state.command === "search") {
+        state.edit = { kind: "language", draft: state.language ?? "" };
+        return;
+      }
+      if (key === "e" && currentCommand(state).inputLabel) {
+        state.edit = { kind: "input", draft: state.inputs[state.command] };
+        return;
+      }
+      if (isScrollDownKey(key)) {
+        state.scroll += 1;
+        return;
+      }
+      if (isScrollUpKey(key)) {
+        state.scroll = Math.max(0, state.scroll - 1);
+        return;
+      }
+      if (isPageDownKey(key)) {
+        state.scroll += 10;
+        return;
+      }
+      if (isPageUpKey(key)) {
+        state.scroll = Math.max(0, state.scroll - 10);
+        return;
+      }
+      if (isEnterKey(key)) {
+        await panel.runCurrent();
+        return;
+      }
+    },
+    render() {
+      return renderPanelLines(state, 120).join(`
+`);
+    },
+    renderLines(width) {
+      return renderPanelLines(state, width);
+    }
+  };
+  return panel;
+}
+async function openMasonPanel(ctx, bridge) {
+  const panel = createMasonPanel(bridge);
+  await panel.runCurrent();
+  const anyCtx = ctx;
+  if (anyCtx.hasUI !== false && typeof anyCtx.ui?.custom === "function") {
+    await anyCtx.ui.custom((tui, _theme, _keybindings, done) => ({
+      render(width) {
+        return panel.renderLines(width);
+      },
+      handleInput(key) {
+        panel.handleInput(key).then((result) => {
+          if (result === "close") {
+            done(undefined);
+          } else {
+            requestTuiRender(tui);
+          }
+        });
+      },
+      invalidate() {}
+    }));
+  }
+  return panel;
+}
+function buildInvocation(state) {
+  switch (state.command) {
+    case "search":
+      return buildSearchInvocation(state);
+    case "list":
+      return { argv: ["list"], resultKind: "packages", title: "mason list" };
+    case "installed":
+      return { argv: ["list", "--installed"], resultKind: "installed", title: "mason installed" };
+    case "install": {
+      const packages = splitInput(state.inputs.install);
+      if (packages.length === 0)
+        throw new MasonCommandInputError("install requires package names. Press e to enter packages.");
+      return { argv: ["install", ...packages], resultKind: "install", title: "mason install" };
+    }
+    case "uninstall": {
+      const packages = splitInput(state.inputs.uninstall);
+      if (packages.length === 0)
+        throw new MasonCommandInputError("uninstall requires package names. Press e to enter packages.");
+      return { argv: ["uninstall", ...packages], resultKind: "uninstall", title: "mason uninstall" };
+    }
+    case "update":
+      return { argv: ["update", ...splitInput(state.inputs.update)], resultKind: "install", title: "mason update" };
+    case "which": {
+      const executable = splitInput(state.inputs.which);
+      if (executable.length !== 1)
+        throw new MasonCommandInputError("which requires one executable. Press e to enter it.");
+      return { argv: ["which", executable[0]], resultKind: "which", title: `mason which ${executable[0]}` };
+    }
+    case "refresh":
+      return { argv: ["refresh"], resultKind: "refresh", title: "mason refresh" };
+    case "doctor":
+      return { argv: ["doctor"], resultKind: "doctor", title: "mason doctor" };
+    case "env": {
+      const shell = state.inputs.env.trim() || "bash";
+      if (!SHELLS2.has(shell))
+        throw new MasonCommandInputError("env shell must be one of bash, zsh, fish, powershell, cmd, json.");
+      return { argv: ["env", "--shell", shell], resultKind: "env", title: `mason env --shell ${shell}` };
+    }
+    case "bin-dir":
+      return { argv: ["bin-dir"], resultKind: "bin-dir", title: "mason bin-dir" };
+  }
+}
+function buildSearchInvocation(state) {
+  const query = state.inputs.search.trim();
+  state.query = query;
+  const argv = ["search"];
+  if (query.length > 0)
+    argv.push(query);
+  if (state.category)
+    argv.push("--category", state.category);
+  if (state.language && state.language.trim().length > 0)
+    argv.push("--language", state.language.trim());
+  const title = state.language && state.language.trim().length > 0 ? `mason search${query ? ` ${query}` : ""} language=${state.language.trim()}` : `mason search${query ? ` ${query}` : ""}`;
+  return { argv, resultKind: "packages", title };
+}
+function renderPanelLines(state, width) {
+  const safeWidth = Math.max(1, Math.floor(width));
+  const lines = [
+    truncateToWidth2("mason4agents package manager", safeWidth),
+    truncateToWidth2(renderCommandTabs(state), safeWidth),
+    truncateToWidth2(renderStateLine(state), safeWidth)
+  ];
+  if (state.edit)
+    lines.push(truncateToWidth2(`${state.edit.kind}> ${state.edit.draft}`, safeWidth));
+  lines.push("");
+  const output = renderDisplay(state.model, { width: safeWidth, filter: state.filter, scroll: state.scroll, maxRows: 18 });
+  lines.push(...output);
+  lines.push("");
+  lines.push(truncateToWidth2("Keys: \u2190/\u2192 or Tab command  Enter run  e edit  / filter  l language  \u2191/\u2193 scroll  q/Esc close", safeWidth));
+  return lines.map((line) => truncateToWidth2(line, safeWidth));
+}
+function renderCommandTabs(state) {
+  return PANEL_COMMANDS.map((command2, index) => index === state.commandIndex ? `[${command2.label}]` : ` ${command2.label} `).join(" ");
+}
+function renderStateLine(state) {
+  const command2 = currentCommand(state);
+  const parts = [`command=${command2.label}`];
+  if (command2.inputLabel) {
+    const value = state.inputs[state.command];
+    parts.push(`${command2.inputLabel}=${value.length > 0 ? value : "-"}`);
+  }
+  if (state.command === "search")
+    parts.push(`language=${state.language && state.language.length > 0 ? state.language : "-"}`);
+  if (state.filter.length > 0)
+    parts.push(`filter=${state.filter}`);
+  if (state.loading)
+    parts.push("loading");
+  return parts.join("  ");
+}
+function handleEditKey(state, key, runCurrent) {
+  const edit = state.edit;
+  if (!edit)
+    return;
+  if (isEnterKey(key)) {
+    const draft = edit.draft.trim();
+    if (edit.kind === "filter") {
+      state.filter = draft;
+      state.scroll = 0;
+      state.edit = undefined;
+      return;
+    }
+    if (edit.kind === "language") {
+      state.language = draft.length > 0 ? draft : undefined;
+      state.scroll = 0;
+      state.edit = undefined;
+      return runCurrent();
+    }
+    state.inputs[state.command] = draft;
+    if (state.command === "search")
+      state.query = draft;
+    state.scroll = 0;
+    state.edit = undefined;
+    return runCurrent();
+  }
+  if (isCloseKey(key)) {
+    state.edit = undefined;
+    return;
+  }
+  if (key === "\b" || key === "\x7F" || key === "backspace") {
+    edit.draft = edit.draft.slice(0, -1);
+    return;
+  }
+  if (key.length === 1 && key >= " ")
+    edit.draft += key;
+}
+function selectCommand(state, nextIndex) {
+  const count = PANEL_COMMANDS.length;
+  state.commandIndex = (nextIndex % count + count) % count;
+  state.command = PANEL_COMMANDS[state.commandIndex].id;
+  state.scroll = 0;
+  state.filter = "";
+  state.edit = undefined;
+}
+function currentCommand(state) {
+  return PANEL_COMMANDS[state.commandIndex];
+}
+function commandIndex(command2) {
+  return PANEL_COMMANDS.findIndex((item) => item.id === command2);
+}
+function splitInput(input) {
+  return tokenizeMasonArgs(input.trim());
+}
+function messageFromError2(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+function truncateToWidth2(value, width) {
+  if (value.length <= width)
+    return value;
+  if (width <= 1)
+    return value.slice(0, width);
+  return `${value.slice(0, width - 1)}\u2026`;
+}
+function isCloseKey(key) {
+  return key === "q" || key === "\x1B" || key === "escape" || key === "esc";
+}
+function isEnterKey(key) {
+  return key === "\r" || key === `
+` || key === "enter" || key === "return";
+}
+function isNextCommandKey(key) {
+  return key === "tab" || key === "right" || key === "\x1B[C";
+}
+function isPreviousCommandKey(key) {
+  return key === "shift+tab" || key === "left" || key === "\x1B[D";
+}
+function isScrollDownKey(key) {
+  return key === "down" || key === "j" || key === "\x1B[B";
+}
+function isScrollUpKey(key) {
+  return key === "up" || key === "k" || key === "\x1B[A";
+}
+function isPageDownKey(key) {
+  return key === "pagedown" || key === "\x1B[6~";
+}
+function isPageUpKey(key) {
+  return key === "pageup" || key === "\x1B[5~";
+}
+function requestTuiRender(tui) {
+  if (typeof tui !== "object" || tui === null)
+    return;
+  const candidate = tui;
+  if (typeof candidate.requestRender === "function") {
+    candidate.requestRender(true);
+  } else if (typeof candidate.invalidate === "function") {
+    candidate.invalidate();
+  }
+}
+
+// node_modules/@sinclair/typebox/build/esm/type/guard/value.mjs
+var exports_value = {};
+__export(exports_value, {
+  IsUndefined: () => IsUndefined,
+  IsUint8Array: () => IsUint8Array,
+  IsSymbol: () => IsSymbol,
+  IsString: () => IsString,
+  IsRegExp: () => IsRegExp,
+  IsObject: () => IsObject,
+  IsNumber: () => IsNumber,
+  IsNull: () => IsNull,
+  IsIterator: () => IsIterator,
+  IsFunction: () => IsFunction,
+  IsDate: () => IsDate,
+  IsBoolean: () => IsBoolean,
+  IsBigInt: () => IsBigInt,
+  IsAsyncIterator: () => IsAsyncIterator,
+  IsArray: () => IsArray,
+  HasPropertyKey: () => HasPropertyKey
+});
+function HasPropertyKey(value, key) {
+  return key in value;
+}
+function IsAsyncIterator(value) {
+  return IsObject(value) && !IsArray(value) && !IsUint8Array(value) && Symbol.asyncIterator in value;
+}
+function IsArray(value) {
+  return Array.isArray(value);
+}
+function IsBigInt(value) {
+  return typeof value === "bigint";
+}
+function IsBoolean(value) {
+  return typeof value === "boolean";
+}
+function IsDate(value) {
+  return value instanceof globalThis.Date;
+}
+function IsFunction(value) {
+  return typeof value === "function";
+}
+function IsIterator(value) {
+  return IsObject(value) && !IsArray(value) && !IsUint8Array(value) && Symbol.iterator in value;
+}
+function IsNull(value) {
+  return value === null;
+}
+function IsNumber(value) {
+  return typeof value === "number";
+}
+function IsObject(value) {
+  return typeof value === "object" && value !== null;
+}
+function IsRegExp(value) {
+  return value instanceof globalThis.RegExp;
+}
+function IsString(value) {
+  return typeof value === "string";
+}
+function IsSymbol(value) {
+  return typeof value === "symbol";
+}
+function IsUint8Array(value) {
+  return value instanceof globalThis.Uint8Array;
+}
+function IsUndefined(value) {
+  return value === undefined;
+}
+
+// node_modules/@sinclair/typebox/build/esm/type/clone/value.mjs
+function ArrayType(value) {
+  return value.map((value2) => Visit(value2));
+}
+function DateType(value) {
+  return new Date(value.getTime());
+}
+function Uint8ArrayType(value) {
+  return new Uint8Array(value);
+}
+function RegExpType(value) {
+  return new RegExp(value.source, value.flags);
+}
+function ObjectType(value) {
+  const result = {};
+  for (const key of Object.getOwnPropertyNames(value)) {
+    result[key] = Visit(value[key]);
+  }
+  for (const key of Object.getOwnPropertySymbols(value)) {
+    result[key] = Visit(value[key]);
+  }
+  return result;
+}
+function Visit(value) {
+  return IsArray(value) ? ArrayType(value) : IsDate(value) ? DateType(value) : IsUint8Array(value) ? Uint8ArrayType(value) : IsRegExp(value) ? RegExpType(value) : IsObject(value) ? ObjectType(value) : value;
+}
+function Clone(value) {
+  return Visit(value);
+}
+
+// node_modules/@sinclair/typebox/build/esm/type/clone/type.mjs
+function CloneType(schema, options) {
+  return options === undefined ? Clone(schema) : Clone({ ...options, ...schema });
+}
+
+// node_modules/@sinclair/typebox/build/esm/value/guard/guard.mjs
+function IsObject2(value) {
+  return value !== null && typeof value === "object";
+}
+function IsArray2(value) {
+  return globalThis.Array.isArray(value) && !globalThis.ArrayBuffer.isView(value);
+}
+function IsUndefined2(value) {
+  return value === undefined;
+}
+function IsNumber2(value) {
+  return typeof value === "number";
+}
+
+// node_modules/@sinclair/typebox/build/esm/system/policy.mjs
+var TypeSystemPolicy;
+(function(TypeSystemPolicy2) {
+  TypeSystemPolicy2.InstanceMode = "default";
+  TypeSystemPolicy2.ExactOptionalPropertyTypes = false;
+  TypeSystemPolicy2.AllowArrayObject = false;
+  TypeSystemPolicy2.AllowNaN = false;
+  TypeSystemPolicy2.AllowNullVoid = false;
+  function IsExactOptionalProperty(value, key) {
+    return TypeSystemPolicy2.ExactOptionalPropertyTypes ? key in value : value[key] !== undefined;
+  }
+  TypeSystemPolicy2.IsExactOptionalProperty = IsExactOptionalProperty;
+  function IsObjectLike(value) {
+    const isObject = IsObject2(value);
+    return TypeSystemPolicy2.AllowArrayObject ? isObject : isObject && !IsArray2(value);
+  }
+  TypeSystemPolicy2.IsObjectLike = IsObjectLike;
+  function IsRecordLike(value) {
+    return IsObjectLike(value) && !(value instanceof Date) && !(value instanceof Uint8Array);
+  }
+  TypeSystemPolicy2.IsRecordLike = IsRecordLike;
+  function IsNumberLike(value) {
+    return TypeSystemPolicy2.AllowNaN ? IsNumber2(value) : Number.isFinite(value);
+  }
+  TypeSystemPolicy2.IsNumberLike = IsNumberLike;
+  function IsVoidLike(value) {
+    const isUndefined = IsUndefined2(value);
+    return TypeSystemPolicy2.AllowNullVoid ? isUndefined || value === null : isUndefined;
+  }
+  TypeSystemPolicy2.IsVoidLike = IsVoidLike;
+})(TypeSystemPolicy || (TypeSystemPolicy = {}));
+
+// node_modules/@sinclair/typebox/build/esm/type/create/immutable.mjs
+function ImmutableArray(value) {
+  return globalThis.Object.freeze(value).map((value2) => Immutable(value2));
+}
+function ImmutableDate(value) {
+  return value;
+}
+function ImmutableUint8Array(value) {
+  return value;
+}
+function ImmutableRegExp(value) {
+  return value;
+}
+function ImmutableObject(value) {
+  const result = {};
+  for (const key of Object.getOwnPropertyNames(value)) {
+    result[key] = Immutable(value[key]);
+  }
+  for (const key of Object.getOwnPropertySymbols(value)) {
+    result[key] = Immutable(value[key]);
+  }
+  return globalThis.Object.freeze(result);
+}
+function Immutable(value) {
+  return IsArray(value) ? ImmutableArray(value) : IsDate(value) ? ImmutableDate(value) : IsUint8Array(value) ? ImmutableUint8Array(value) : IsRegExp(value) ? ImmutableRegExp(value) : IsObject(value) ? ImmutableObject(value) : value;
+}
+
+// node_modules/@sinclair/typebox/build/esm/type/create/type.mjs
+function CreateType(schema, options) {
+  const result = options !== undefined ? { ...options, ...schema } : schema;
+  switch (TypeSystemPolicy.InstanceMode) {
+    case "freeze":
+      return Immutable(result);
+    case "clone":
+      return Clone(result);
+    default:
+      return result;
+  }
+}
+
+// node_modules/@sinclair/typebox/build/esm/type/error/error.mjs
+class TypeBoxError extends Error {
+  constructor(message) {
+    super(message);
+  }
+}
+
+// node_modules/@sinclair/typebox/build/esm/type/symbols/symbols.mjs
+var TransformKind = Symbol.for("TypeBox.Transform");
+var ReadonlyKind = Symbol.for("TypeBox.Readonly");
+var OptionalKind = Symbol.for("TypeBox.Optional");
+var Hint = Symbol.for("TypeBox.Hint");
+var Kind = Symbol.for("TypeBox.Kind");
+
+// node_modules/@sinclair/typebox/build/esm/type/guard/kind.mjs
+function IsReadonly(value) {
+  return IsObject(value) && value[ReadonlyKind] === "Readonly";
+}
+function IsOptional(value) {
+  return IsObject(value) && value[OptionalKind] === "Optional";
+}
+function IsAny(value) {
+  return IsKindOf(value, "Any");
+}
+function IsArgument(value) {
+  return IsKindOf(value, "Argument");
+}
+function IsArray3(value) {
+  return IsKindOf(value, "Array");
+}
+function IsAsyncIterator2(value) {
+  return IsKindOf(value, "AsyncIterator");
+}
+function IsBigInt2(value) {
+  return IsKindOf(value, "BigInt");
+}
+function IsBoolean2(value) {
+  return IsKindOf(value, "Boolean");
+}
+function IsComputed(value) {
+  return IsKindOf(value, "Computed");
+}
+function IsConstructor(value) {
+  return IsKindOf(value, "Constructor");
+}
+function IsDate2(value) {
+  return IsKindOf(value, "Date");
+}
+function IsFunction2(value) {
+  return IsKindOf(value, "Function");
+}
+function IsInteger(value) {
+  return IsKindOf(value, "Integer");
+}
+function IsIntersect(value) {
+  return IsKindOf(value, "Intersect");
+}
+function IsIterator2(value) {
+  return IsKindOf(value, "Iterator");
+}
+function IsKindOf(value, kind) {
+  return IsObject(value) && Kind in value && value[Kind] === kind;
+}
+function IsLiteralValue(value) {
+  return IsBoolean(value) || IsNumber(value) || IsString(value);
+}
+function IsLiteral(value) {
+  return IsKindOf(value, "Literal");
+}
+function IsMappedKey(value) {
+  return IsKindOf(value, "MappedKey");
+}
+function IsMappedResult(value) {
+  return IsKindOf(value, "MappedResult");
+}
+function IsNever(value) {
+  return IsKindOf(value, "Never");
+}
+function IsNot(value) {
+  return IsKindOf(value, "Not");
+}
+function IsNull2(value) {
+  return IsKindOf(value, "Null");
+}
+function IsNumber3(value) {
+  return IsKindOf(value, "Number");
+}
+function IsObject3(value) {
+  return IsKindOf(value, "Object");
+}
+function IsPromise(value) {
+  return IsKindOf(value, "Promise");
+}
+function IsRecord(value) {
+  return IsKindOf(value, "Record");
+}
+function IsRef(value) {
+  return IsKindOf(value, "Ref");
+}
+function IsRegExp2(value) {
+  return IsKindOf(value, "RegExp");
+}
+function IsString2(value) {
+  return IsKindOf(value, "String");
+}
+function IsSymbol2(value) {
+  return IsKindOf(value, "Symbol");
+}
+function IsTemplateLiteral(value) {
+  return IsKindOf(value, "TemplateLiteral");
+}
+function IsThis(value) {
+  return IsKindOf(value, "This");
+}
+function IsTransform(value) {
+  return IsObject(value) && TransformKind in value;
+}
+function IsTuple(value) {
+  return IsKindOf(value, "Tuple");
+}
+function IsUndefined3(value) {
+  return IsKindOf(value, "Undefined");
+}
+function IsUnion(value) {
+  return IsKindOf(value, "Union");
+}
+function IsUint8Array2(value) {
+  return IsKindOf(value, "Uint8Array");
+}
+function IsUnknown(value) {
+  return IsKindOf(value, "Unknown");
+}
+function IsUnsafe(value) {
+  return IsKindOf(value, "Unsafe");
+}
+function IsVoid(value) {
+  return IsKindOf(value, "Void");
+}
+function IsKind(value) {
+  return IsObject(value) && Kind in value && IsString(value[Kind]);
+}
+function IsSchema(value) {
+  return IsAny(value) || IsArgument(value) || IsArray3(value) || IsBoolean2(value) || IsBigInt2(value) || IsAsyncIterator2(value) || IsComputed(value) || IsConstructor(value) || IsDate2(value) || IsFunction2(value) || IsInteger(value) || IsIntersect(value) || IsIterator2(value) || IsLiteral(value) || IsMappedKey(value) || IsMappedResult(value) || IsNever(value) || IsNot(value) || IsNull2(value) || IsNumber3(value) || IsObject3(value) || IsPromise(value) || IsRecord(value) || IsRef(value) || IsRegExp2(value) || IsString2(value) || IsSymbol2(value) || IsTemplateLiteral(value) || IsThis(value) || IsTuple(value) || IsUndefined3(value) || IsUnion(value) || IsUint8Array2(value) || IsUnknown(value) || IsUnsafe(value) || IsVoid(value) || IsKind(value);
+}
+// node_modules/@sinclair/typebox/build/esm/type/guard/type.mjs
+var exports_type = {};
+__export(exports_type, {
+  TypeGuardUnknownTypeError: () => TypeGuardUnknownTypeError,
+  IsVoid: () => IsVoid2,
+  IsUnsafe: () => IsUnsafe2,
+  IsUnknown: () => IsUnknown2,
+  IsUnionLiteral: () => IsUnionLiteral,
+  IsUnion: () => IsUnion2,
+  IsUndefined: () => IsUndefined4,
+  IsUint8Array: () => IsUint8Array3,
+  IsTuple: () => IsTuple2,
+  IsTransform: () => IsTransform2,
+  IsThis: () => IsThis2,
+  IsTemplateLiteral: () => IsTemplateLiteral2,
+  IsSymbol: () => IsSymbol3,
+  IsString: () => IsString3,
+  IsSchema: () => IsSchema2,
+  IsRegExp: () => IsRegExp3,
+  IsRef: () => IsRef2,
+  IsRecursive: () => IsRecursive,
+  IsRecord: () => IsRecord2,
+  IsReadonly: () => IsReadonly2,
+  IsProperties: () => IsProperties,
+  IsPromise: () => IsPromise2,
+  IsOptional: () => IsOptional2,
+  IsObject: () => IsObject4,
+  IsNumber: () => IsNumber4,
+  IsNull: () => IsNull3,
+  IsNot: () => IsNot2,
+  IsNever: () => IsNever2,
+  IsMappedResult: () => IsMappedResult2,
+  IsMappedKey: () => IsMappedKey2,
+  IsLiteralValue: () => IsLiteralValue2,
+  IsLiteralString: () => IsLiteralString,
+  IsLiteralNumber: () => IsLiteralNumber,
+  IsLiteralBoolean: () => IsLiteralBoolean,
+  IsLiteral: () => IsLiteral2,
+  IsKindOf: () => IsKindOf2,
+  IsKind: () => IsKind2,
+  IsIterator: () => IsIterator3,
+  IsIntersect: () => IsIntersect2,
+  IsInteger: () => IsInteger2,
+  IsImport: () => IsImport,
+  IsFunction: () => IsFunction3,
+  IsDate: () => IsDate3,
+  IsConstructor: () => IsConstructor2,
+  IsComputed: () => IsComputed2,
+  IsBoolean: () => IsBoolean3,
+  IsBigInt: () => IsBigInt3,
+  IsAsyncIterator: () => IsAsyncIterator3,
+  IsArray: () => IsArray4,
+  IsArgument: () => IsArgument2,
+  IsAny: () => IsAny2
+});
+class TypeGuardUnknownTypeError extends TypeBoxError {
+}
+var KnownTypes = [
+  "Argument",
+  "Any",
+  "Array",
+  "AsyncIterator",
+  "BigInt",
+  "Boolean",
+  "Computed",
+  "Constructor",
+  "Date",
+  "Enum",
+  "Function",
+  "Integer",
+  "Intersect",
+  "Iterator",
+  "Literal",
+  "MappedKey",
+  "MappedResult",
+  "Not",
+  "Null",
+  "Number",
+  "Object",
+  "Promise",
+  "Record",
+  "Ref",
+  "RegExp",
+  "String",
+  "Symbol",
+  "TemplateLiteral",
+  "This",
+  "Tuple",
+  "Undefined",
+  "Union",
+  "Uint8Array",
+  "Unknown",
+  "Void"
+];
+function IsPattern(value) {
+  try {
+    new RegExp(value);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function IsControlCharacterFree(value) {
+  if (!IsString(value))
+    return false;
+  for (let i = 0;i < value.length; i++) {
+    const code = value.charCodeAt(i);
+    if (code >= 7 && code <= 13 || code === 27 || code === 127) {
+      return false;
+    }
+  }
+  return true;
+}
+function IsAdditionalProperties(value) {
+  return IsOptionalBoolean(value) || IsSchema2(value);
+}
+function IsOptionalBigInt(value) {
+  return IsUndefined(value) || IsBigInt(value);
+}
+function IsOptionalNumber(value) {
+  return IsUndefined(value) || IsNumber(value);
+}
+function IsOptionalBoolean(value) {
+  return IsUndefined(value) || IsBoolean(value);
+}
+function IsOptionalString(value) {
+  return IsUndefined(value) || IsString(value);
+}
+function IsOptionalPattern(value) {
+  return IsUndefined(value) || IsString(value) && IsControlCharacterFree(value) && IsPattern(value);
+}
+function IsOptionalFormat(value) {
+  return IsUndefined(value) || IsString(value) && IsControlCharacterFree(value);
+}
+function IsOptionalSchema(value) {
+  return IsUndefined(value) || IsSchema2(value);
+}
+function IsReadonly2(value) {
+  return IsObject(value) && value[ReadonlyKind] === "Readonly";
+}
+function IsOptional2(value) {
+  return IsObject(value) && value[OptionalKind] === "Optional";
+}
+function IsAny2(value) {
+  return IsKindOf2(value, "Any") && IsOptionalString(value.$id);
+}
+function IsArgument2(value) {
+  return IsKindOf2(value, "Argument") && IsNumber(value.index);
+}
+function IsArray4(value) {
+  return IsKindOf2(value, "Array") && value.type === "array" && IsOptionalString(value.$id) && IsSchema2(value.items) && IsOptionalNumber(value.minItems) && IsOptionalNumber(value.maxItems) && IsOptionalBoolean(value.uniqueItems) && IsOptionalSchema(value.contains) && IsOptionalNumber(value.minContains) && IsOptionalNumber(value.maxContains);
+}
+function IsAsyncIterator3(value) {
+  return IsKindOf2(value, "AsyncIterator") && value.type === "AsyncIterator" && IsOptionalString(value.$id) && IsSchema2(value.items);
+}
+function IsBigInt3(value) {
+  return IsKindOf2(value, "BigInt") && value.type === "bigint" && IsOptionalString(value.$id) && IsOptionalBigInt(value.exclusiveMaximum) && IsOptionalBigInt(value.exclusiveMinimum) && IsOptionalBigInt(value.maximum) && IsOptionalBigInt(value.minimum) && IsOptionalBigInt(value.multipleOf);
+}
+function IsBoolean3(value) {
+  return IsKindOf2(value, "Boolean") && value.type === "boolean" && IsOptionalString(value.$id);
+}
+function IsComputed2(value) {
+  return IsKindOf2(value, "Computed") && IsString(value.target) && IsArray(value.parameters) && value.parameters.every((schema) => IsSchema2(schema));
+}
+function IsConstructor2(value) {
+  return IsKindOf2(value, "Constructor") && value.type === "Constructor" && IsOptionalString(value.$id) && IsArray(value.parameters) && value.parameters.every((schema) => IsSchema2(schema)) && IsSchema2(value.returns);
+}
+function IsDate3(value) {
+  return IsKindOf2(value, "Date") && value.type === "Date" && IsOptionalString(value.$id) && IsOptionalNumber(value.exclusiveMaximumTimestamp) && IsOptionalNumber(value.exclusiveMinimumTimestamp) && IsOptionalNumber(value.maximumTimestamp) && IsOptionalNumber(value.minimumTimestamp) && IsOptionalNumber(value.multipleOfTimestamp);
+}
+function IsFunction3(value) {
+  return IsKindOf2(value, "Function") && value.type === "Function" && IsOptionalString(value.$id) && IsArray(value.parameters) && value.parameters.every((schema) => IsSchema2(schema)) && IsSchema2(value.returns);
+}
+function IsImport(value) {
+  return IsKindOf2(value, "Import") && HasPropertyKey(value, "$defs") && IsObject(value.$defs) && IsProperties(value.$defs) && HasPropertyKey(value, "$ref") && IsString(value.$ref) && value.$ref in value.$defs;
+}
+function IsInteger2(value) {
+  return IsKindOf2(value, "Integer") && value.type === "integer" && IsOptionalString(value.$id) && IsOptionalNumber(value.exclusiveMaximum) && IsOptionalNumber(value.exclusiveMinimum) && IsOptionalNumber(value.maximum) && IsOptionalNumber(value.minimum) && IsOptionalNumber(value.multipleOf);
+}
+function IsProperties(value) {
+  return IsObject(value) && Object.entries(value).every(([key, schema]) => IsControlCharacterFree(key) && IsSchema2(schema));
+}
+function IsIntersect2(value) {
+  return IsKindOf2(value, "Intersect") && (IsString(value.type) && value.type !== "object" ? false : true) && IsArray(value.allOf) && value.allOf.every((schema) => IsSchema2(schema) && !IsTransform2(schema)) && IsOptionalString(value.type) && (IsOptionalBoolean(value.unevaluatedProperties) || IsOptionalSchema(value.unevaluatedProperties)) && IsOptionalString(value.$id);
+}
+function IsIterator3(value) {
+  return IsKindOf2(value, "Iterator") && value.type === "Iterator" && IsOptionalString(value.$id) && IsSchema2(value.items);
+}
+function IsKindOf2(value, kind) {
+  return IsObject(value) && Kind in value && value[Kind] === kind;
+}
+function IsLiteralString(value) {
+  return IsLiteral2(value) && IsString(value.const);
+}
+function IsLiteralNumber(value) {
+  return IsLiteral2(value) && IsNumber(value.const);
+}
+function IsLiteralBoolean(value) {
+  return IsLiteral2(value) && IsBoolean(value.const);
+}
+function IsLiteral2(value) {
+  return IsKindOf2(value, "Literal") && IsOptionalString(value.$id) && IsLiteralValue2(value.const);
+}
+function IsLiteralValue2(value) {
+  return IsBoolean(value) || IsNumber(value) || IsString(value);
+}
+function IsMappedKey2(value) {
+  return IsKindOf2(value, "MappedKey") && IsArray(value.keys) && value.keys.every((key) => IsNumber(key) || IsString(key));
+}
+function IsMappedResult2(value) {
+  return IsKindOf2(value, "MappedResult") && IsProperties(value.properties);
+}
+function IsNever2(value) {
+  return IsKindOf2(value, "Never") && IsObject(value.not) && Object.getOwnPropertyNames(value.not).length === 0;
+}
+function IsNot2(value) {
+  return IsKindOf2(value, "Not") && IsSchema2(value.not);
+}
+function IsNull3(value) {
+  return IsKindOf2(value, "Null") && value.type === "null" && IsOptionalString(value.$id);
+}
+function IsNumber4(value) {
+  return IsKindOf2(value, "Number") && value.type === "number" && IsOptionalString(value.$id) && IsOptionalNumber(value.exclusiveMaximum) && IsOptionalNumber(value.exclusiveMinimum) && IsOptionalNumber(value.maximum) && IsOptionalNumber(value.minimum) && IsOptionalNumber(value.multipleOf);
+}
+function IsObject4(value) {
+  return IsKindOf2(value, "Object") && value.type === "object" && IsOptionalString(value.$id) && IsProperties(value.properties) && IsAdditionalProperties(value.additionalProperties) && IsOptionalNumber(value.minProperties) && IsOptionalNumber(value.maxProperties);
+}
+function IsPromise2(value) {
+  return IsKindOf2(value, "Promise") && value.type === "Promise" && IsOptionalString(value.$id) && IsSchema2(value.item);
+}
+function IsRecord2(value) {
+  return IsKindOf2(value, "Record") && value.type === "object" && IsOptionalString(value.$id) && IsAdditionalProperties(value.additionalProperties) && IsObject(value.patternProperties) && ((schema) => {
+    const keys = Object.getOwnPropertyNames(schema.patternProperties);
+    return keys.length === 1 && IsPattern(keys[0]) && IsObject(schema.patternProperties) && IsSchema2(schema.patternProperties[keys[0]]);
+  })(value);
+}
+function IsRecursive(value) {
+  return IsObject(value) && Hint in value && value[Hint] === "Recursive";
+}
+function IsRef2(value) {
+  return IsKindOf2(value, "Ref") && IsOptionalString(value.$id) && IsString(value.$ref);
+}
+function IsRegExp3(value) {
+  return IsKindOf2(value, "RegExp") && IsOptionalString(value.$id) && IsString(value.source) && IsString(value.flags) && IsOptionalNumber(value.maxLength) && IsOptionalNumber(value.minLength);
+}
+function IsString3(value) {
+  return IsKindOf2(value, "String") && value.type === "string" && IsOptionalString(value.$id) && IsOptionalNumber(value.minLength) && IsOptionalNumber(value.maxLength) && IsOptionalPattern(value.pattern) && IsOptionalFormat(value.format);
+}
+function IsSymbol3(value) {
+  return IsKindOf2(value, "Symbol") && value.type === "symbol" && IsOptionalString(value.$id);
+}
+function IsTemplateLiteral2(value) {
+  return IsKindOf2(value, "TemplateLiteral") && value.type === "string" && IsString(value.pattern) && value.pattern[0] === "^" && value.pattern[value.pattern.length - 1] === "$";
+}
+function IsThis2(value) {
+  return IsKindOf2(value, "This") && IsOptionalString(value.$id) && IsString(value.$ref);
+}
+function IsTransform2(value) {
+  return IsObject(value) && TransformKind in value;
+}
+function IsTuple2(value) {
+  return IsKindOf2(value, "Tuple") && value.type === "array" && IsOptionalString(value.$id) && IsNumber(value.minItems) && IsNumber(value.maxItems) && value.minItems === value.maxItems && (IsUndefined(value.items) && IsUndefined(value.additionalItems) && value.minItems === 0 || IsArray(value.items) && value.items.every((schema) => IsSchema2(schema)));
+}
+function IsUndefined4(value) {
+  return IsKindOf2(value, "Undefined") && value.type === "undefined" && IsOptionalString(value.$id);
+}
+function IsUnionLiteral(value) {
+  return IsUnion2(value) && value.anyOf.every((schema) => IsLiteralString(schema) || IsLiteralNumber(schema));
+}
+function IsUnion2(value) {
+  return IsKindOf2(value, "Union") && IsOptionalString(value.$id) && IsObject(value) && IsArray(value.anyOf) && value.anyOf.every((schema) => IsSchema2(schema));
+}
+function IsUint8Array3(value) {
+  return IsKindOf2(value, "Uint8Array") && value.type === "Uint8Array" && IsOptionalString(value.$id) && IsOptionalNumber(value.minByteLength) && IsOptionalNumber(value.maxByteLength);
+}
+function IsUnknown2(value) {
+  return IsKindOf2(value, "Unknown") && IsOptionalString(value.$id);
+}
+function IsUnsafe2(value) {
+  return IsKindOf2(value, "Unsafe");
+}
+function IsVoid2(value) {
+  return IsKindOf2(value, "Void") && value.type === "void" && IsOptionalString(value.$id);
+}
+function IsKind2(value) {
+  return IsObject(value) && Kind in value && IsString(value[Kind]) && !KnownTypes.includes(value[Kind]);
+}
+function IsSchema2(value) {
+  return IsObject(value) && (IsAny2(value) || IsArgument2(value) || IsArray4(value) || IsBoolean3(value) || IsBigInt3(value) || IsAsyncIterator3(value) || IsComputed2(value) || IsConstructor2(value) || IsDate3(value) || IsFunction3(value) || IsInteger2(value) || IsIntersect2(value) || IsIterator3(value) || IsLiteral2(value) || IsMappedKey2(value) || IsMappedResult2(value) || IsNever2(value) || IsNot2(value) || IsNull3(value) || IsNumber4(value) || IsObject4(value) || IsPromise2(value) || IsRecord2(value) || IsRef2(value) || IsRegExp3(value) || IsString3(value) || IsSymbol3(value) || IsTemplateLiteral2(value) || IsThis2(value) || IsTuple2(value) || IsUndefined4(value) || IsUnion2(value) || IsUint8Array3(value) || IsUnknown2(value) || IsUnsafe2(value) || IsVoid2(value) || IsKind2(value));
+}
+// node_modules/@sinclair/typebox/build/esm/type/patterns/patterns.mjs
+var PatternBoolean = "(true|false)";
+var PatternNumber = "(0|[1-9][0-9]*)";
+var PatternString = "(.*)";
+var PatternNever = "(?!.*)";
+var PatternBooleanExact = `^${PatternBoolean}$`;
+var PatternNumberExact = `^${PatternNumber}$`;
+var PatternStringExact = `^${PatternString}$`;
+var PatternNeverExact = `^${PatternNever}$`;
+
+// node_modules/@sinclair/typebox/build/esm/type/sets/set.mjs
+function SetIncludes(T, S) {
+  return T.includes(S);
+}
+function SetDistinct(T) {
+  return [...new Set(T)];
+}
+function SetIntersect(T, S) {
+  return T.filter((L) => S.includes(L));
+}
+function SetIntersectManyResolve(T, Init) {
+  return T.reduce((Acc, L) => {
+    return SetIntersect(Acc, L);
+  }, Init);
+}
+function SetIntersectMany(T) {
+  return T.length === 1 ? T[0] : T.length > 1 ? SetIntersectManyResolve(T.slice(1), T[0]) : [];
+}
+function SetUnionMany(T) {
+  const Acc = [];
+  for (const L of T)
+    Acc.push(...L);
+  return Acc;
+}
+
+// node_modules/@sinclair/typebox/build/esm/type/any/any.mjs
+function Any(options) {
+  return CreateType({ [Kind]: "Any" }, options);
+}
+
+// node_modules/@sinclair/typebox/build/esm/type/array/array.mjs
+function Array2(items, options) {
+  return CreateType({ [Kind]: "Array", type: "array", items }, options);
+}
+
+// node_modules/@sinclair/typebox/build/esm/type/argument/argument.mjs
+function Argument(index) {
+  return CreateType({ [Kind]: "Argument", index });
+}
+
+// node_modules/@sinclair/typebox/build/esm/type/async-iterator/async-iterator.mjs
+function AsyncIterator(items, options) {
+  return CreateType({ [Kind]: "AsyncIterator", type: "AsyncIterator", items }, options);
+}
+
+// node_modules/@sinclair/typebox/build/esm/type/computed/computed.mjs
+function Computed(target, parameters, options) {
+  return CreateType({ [Kind]: "Computed", target, parameters }, options);
+}
+
+// node_modules/@sinclair/typebox/build/esm/type/discard/discard.mjs
+function DiscardKey(value, key) {
+  const { [key]: _, ...rest } = value;
+  return rest;
+}
+function Discard(value, keys) {
+  return keys.reduce((acc, key) => DiscardKey(acc, key), value);
+}
+
+// node_modules/@sinclair/typebox/build/esm/type/never/never.mjs
+function Never(options) {
+  return CreateType({ [Kind]: "Never", not: {} }, options);
+}
+
+// node_modules/@sinclair/typebox/build/esm/type/mapped/mapped-result.mjs
+function MappedResult(properties) {
+  return CreateType({
+    [Kind]: "MappedResult",
+    properties
+  });
+}
+
+// node_modules/@sinclair/typebox/build/esm/type/constructor/constructor.mjs
+function Constructor(parameters, returns, options) {
+  return CreateType({ [Kind]: "Constructor", type: "Constructor", parameters, returns }, options);
+}
+
+// node_modules/@sinclair/typebox/build/esm/type/function/function.mjs
+function Function(parameters, returns, options) {
+  return CreateType({ [Kind]: "Function", type: "Function", parameters, returns }, options);
+}
+
+// node_modules/@sinclair/typebox/build/esm/type/union/union-create.mjs
+function UnionCreate(T, options) {
+  return CreateType({ [Kind]: "Union", anyOf: T }, options);
+}
+
+// node_modules/@sinclair/typebox/build/esm/type/union/union-evaluated.mjs
+function IsUnionOptional(types) {
+  return types.some((type) => IsOptional(type));
+}
+function RemoveOptionalFromRest(types) {
+  return types.map((left) => IsOptional(left) ? RemoveOptionalFromType(left) : left);
+}
+function RemoveOptionalFromType(T) {
+  return Discard(T, [OptionalKind]);
+}
+function ResolveUnion(types, options) {
+  const isOptional = IsUnionOptional(types);
+  return isOptional ? Optional(UnionCreate(RemoveOptionalFromRest(types), options)) : UnionCreate(RemoveOptionalFromRest(types), options);
+}
+function UnionEvaluated(T, options) {
+  return T.length === 1 ? CreateType(T[0], options) : T.length === 0 ? Never(options) : ResolveUnion(T, options);
+}
+
+// node_modules/@sinclair/typebox/build/esm/type/union/union.mjs
+function Union(types, options) {
+  return types.length === 0 ? Never(options) : types.length === 1 ? CreateType(types[0], options) : UnionCreate(types, options);
+}
+
+// node_modules/@sinclair/typebox/build/esm/type/template-literal/parse.mjs
+class TemplateLiteralParserError extends TypeBoxError {
+}
+function Unescape(pattern) {
+  return pattern.replace(/\\\$/g, "$").replace(/\\\*/g, "*").replace(/\\\^/g, "^").replace(/\\\|/g, "|").replace(/\\\(/g, "(").replace(/\\\)/g, ")");
+}
+function IsNonEscaped(pattern, index, char) {
+  return pattern[index] === char && pattern.charCodeAt(index - 1) !== 92;
+}
+function IsOpenParen(pattern, index) {
+  return IsNonEscaped(pattern, index, "(");
+}
+function IsCloseParen(pattern, index) {
+  return IsNonEscaped(pattern, index, ")");
+}
+function IsSeparator(pattern, index) {
+  return IsNonEscaped(pattern, index, "|");
+}
+function IsGroup(pattern) {
+  if (!(IsOpenParen(pattern, 0) && IsCloseParen(pattern, pattern.length - 1)))
+    return false;
+  let count = 0;
+  for (let index = 0;index < pattern.length; index++) {
+    if (IsOpenParen(pattern, index))
+      count += 1;
+    if (IsCloseParen(pattern, index))
+      count -= 1;
+    if (count === 0 && index !== pattern.length - 1)
+      return false;
+  }
+  return true;
+}
+function InGroup(pattern) {
+  return pattern.slice(1, pattern.length - 1);
+}
+function IsPrecedenceOr(pattern) {
+  let count = 0;
+  for (let index = 0;index < pattern.length; index++) {
+    if (IsOpenParen(pattern, index))
+      count += 1;
+    if (IsCloseParen(pattern, index))
+      count -= 1;
+    if (IsSeparator(pattern, index) && count === 0)
+      return true;
+  }
+  return false;
+}
+function IsPrecedenceAnd(pattern) {
+  for (let index = 0;index < pattern.length; index++) {
+    if (IsOpenParen(pattern, index))
+      return true;
+  }
+  return false;
+}
+function Or(pattern) {
+  let [count, start] = [0, 0];
+  const expressions = [];
+  for (let index = 0;index < pattern.length; index++) {
+    if (IsOpenParen(pattern, index))
+      count += 1;
+    if (IsCloseParen(pattern, index))
+      count -= 1;
+    if (IsSeparator(pattern, index) && count === 0) {
+      const range2 = pattern.slice(start, index);
+      if (range2.length > 0)
+        expressions.push(TemplateLiteralParse(range2));
+      start = index + 1;
+    }
+  }
+  const range = pattern.slice(start);
+  if (range.length > 0)
+    expressions.push(TemplateLiteralParse(range));
+  if (expressions.length === 0)
+    return { type: "const", const: "" };
+  if (expressions.length === 1)
+    return expressions[0];
+  return { type: "or", expr: expressions };
+}
+function And(pattern) {
+  function Group(value, index) {
+    if (!IsOpenParen(value, index))
+      throw new TemplateLiteralParserError(`TemplateLiteralParser: Index must point to open parens`);
+    let count = 0;
+    for (let scan = index;scan < value.length; scan++) {
+      if (IsOpenParen(value, scan))
+        count += 1;
+      if (IsCloseParen(value, scan))
+        count -= 1;
+      if (count === 0)
+        return [index, scan];
+    }
+    throw new TemplateLiteralParserError(`TemplateLiteralParser: Unclosed group parens in expression`);
+  }
+  function Range(pattern2, index) {
+    for (let scan = index;scan < pattern2.length; scan++) {
+      if (IsOpenParen(pattern2, scan))
+        return [index, scan];
+    }
+    return [index, pattern2.length];
+  }
+  const expressions = [];
+  for (let index = 0;index < pattern.length; index++) {
+    if (IsOpenParen(pattern, index)) {
+      const [start, end] = Group(pattern, index);
+      const range = pattern.slice(start, end + 1);
+      expressions.push(TemplateLiteralParse(range));
+      index = end;
+    } else {
+      const [start, end] = Range(pattern, index);
+      const range = pattern.slice(start, end);
+      if (range.length > 0)
+        expressions.push(TemplateLiteralParse(range));
+      index = end - 1;
+    }
+  }
+  return expressions.length === 0 ? { type: "const", const: "" } : expressions.length === 1 ? expressions[0] : { type: "and", expr: expressions };
+}
+function TemplateLiteralParse(pattern) {
+  return IsGroup(pattern) ? TemplateLiteralParse(InGroup(pattern)) : IsPrecedenceOr(pattern) ? Or(pattern) : IsPrecedenceAnd(pattern) ? And(pattern) : { type: "const", const: Unescape(pattern) };
+}
+function TemplateLiteralParseExact(pattern) {
+  return TemplateLiteralParse(pattern.slice(1, pattern.length - 1));
+}
+
+// node_modules/@sinclair/typebox/build/esm/type/template-literal/finite.mjs
+class TemplateLiteralFiniteError extends TypeBoxError {
+}
+function IsNumberExpression(expression) {
+  return expression.type === "or" && expression.expr.length === 2 && expression.expr[0].type === "const" && expression.expr[0].const === "0" && expression.expr[1].type === "const" && expression.expr[1].const === "[1-9][0-9]*";
+}
+function IsBooleanExpression(expression) {
+  return expression.type === "or" && expression.expr.length === 2 && expression.expr[0].type === "const" && expression.expr[0].const === "true" && expression.expr[1].type === "const" && expression.expr[1].const === "false";
+}
+function IsStringExpression(expression) {
+  return expression.type === "const" && expression.const === ".*";
+}
+function IsTemplateLiteralExpressionFinite(expression) {
+  return IsNumberExpression(expression) || IsStringExpression(expression) ? false : IsBooleanExpression(expression) ? true : expression.type === "and" ? expression.expr.every((expr) => IsTemplateLiteralExpressionFinite(expr)) : expression.type === "or" ? expression.expr.every((expr) => IsTemplateLiteralExpressionFinite(expr)) : expression.type === "const" ? true : (() => {
+    throw new TemplateLiteralFiniteError(`Unknown expression type`);
+  })();
+}
+function IsTemplateLiteralFinite(schema) {
+  const expression = TemplateLiteralParseExact(schema.pattern);
+  return IsTemplateLiteralExpressionFinite(expression);
+}
+
+// node_modules/@sinclair/typebox/build/esm/type/template-literal/generate.mjs
+class TemplateLiteralGenerateError extends TypeBoxError {
+}
+function* GenerateReduce(buffer) {
+  if (buffer.length === 1)
+    return yield* buffer[0];
+  for (const left of buffer[0]) {
+    for (const right of GenerateReduce(buffer.slice(1))) {
+      yield `${left}${right}`;
+    }
+  }
+}
+function* GenerateAnd(expression) {
+  return yield* GenerateReduce(expression.expr.map((expr) => [...TemplateLiteralExpressionGenerate(expr)]));
+}
+function* GenerateOr(expression) {
+  for (const expr of expression.expr)
+    yield* TemplateLiteralExpressionGenerate(expr);
+}
+function* GenerateConst(expression) {
+  return yield expression.const;
+}
+function* TemplateLiteralExpressionGenerate(expression) {
+  return expression.type === "and" ? yield* GenerateAnd(expression) : expression.type === "or" ? yield* GenerateOr(expression) : expression.type === "const" ? yield* GenerateConst(expression) : (() => {
+    throw new TemplateLiteralGenerateError("Unknown expression");
+  })();
+}
+function TemplateLiteralGenerate(schema) {
+  const expression = TemplateLiteralParseExact(schema.pattern);
+  return IsTemplateLiteralExpressionFinite(expression) ? [...TemplateLiteralExpressionGenerate(expression)] : [];
+}
+
+// node_modules/@sinclair/typebox/build/esm/type/literal/literal.mjs
+function Literal(value, options) {
+  return CreateType({
+    [Kind]: "Literal",
+    const: value,
+    type: typeof value
+  }, options);
+}
+
+// node_modules/@sinclair/typebox/build/esm/type/boolean/boolean.mjs
+function Boolean(options) {
+  return CreateType({ [Kind]: "Boolean", type: "boolean" }, options);
+}
+
+// node_modules/@sinclair/typebox/build/esm/type/bigint/bigint.mjs
+function BigInt(options) {
+  return CreateType({ [Kind]: "BigInt", type: "bigint" }, options);
+}
+
+// node_modules/@sinclair/typebox/build/esm/type/number/number.mjs
+function Number2(options) {
+  return CreateType({ [Kind]: "Number", type: "number" }, options);
+}
+
+// node_modules/@sinclair/typebox/build/esm/type/string/string.mjs
+function String2(options) {
+  return CreateType({ [Kind]: "String", type: "string" }, options);
+}
+
+// node_modules/@sinclair/typebox/build/esm/type/template-literal/syntax.mjs
+function* FromUnion(syntax) {
+  const trim = syntax.trim().replace(/"|'/g, "");
+  return trim === "boolean" ? yield Boolean() : trim === "number" ? yield Number2() : trim === "bigint" ? yield BigInt() : trim === "string" ? yield String2() : yield (() => {
+    const literals = trim.split("|").map((literal) => Literal(literal.trim()));
+    return literals.length === 0 ? Never() : literals.length === 1 ? literals[0] : UnionEvaluated(literals);
+  })();
+}
+function* FromTerminal(syntax) {
+  if (syntax[1] !== "{") {
+    const L = Literal("$");
+    const R = FromSyntax(syntax.slice(1));
+    return yield* [L, ...R];
+  }
+  for (let i = 2;i < syntax.length; i++) {
+    if (syntax[i] === "}") {
+      const L = FromUnion(syntax.slice(2, i));
+      const R = FromSyntax(syntax.slice(i + 1));
+      return yield* [...L, ...R];
+    }
+  }
+  yield Literal(syntax);
+}
+function* FromSyntax(syntax) {
+  for (let i = 0;i < syntax.length; i++) {
+    if (syntax[i] === "$") {
+      const L = Literal(syntax.slice(0, i));
+      const R = FromTerminal(syntax.slice(i));
+      return yield* [L, ...R];
+    }
+  }
+  yield Literal(syntax);
+}
+function TemplateLiteralSyntax(syntax) {
+  return [...FromSyntax(syntax)];
+}
+
+// node_modules/@sinclair/typebox/build/esm/type/template-literal/pattern.mjs
+class TemplateLiteralPatternError extends TypeBoxError {
+}
+function Escape(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function Visit2(schema, acc) {
+  return IsTemplateLiteral(schema) ? schema.pattern.slice(1, schema.pattern.length - 1) : IsUnion(schema) ? `(${schema.anyOf.map((schema2) => Visit2(schema2, acc)).join("|")})` : IsNumber3(schema) ? `${acc}${PatternNumber}` : IsInteger(schema) ? `${acc}${PatternNumber}` : IsBigInt2(schema) ? `${acc}${PatternNumber}` : IsString2(schema) ? `${acc}${PatternString}` : IsLiteral(schema) ? `${acc}${Escape(schema.const.toString())}` : IsBoolean2(schema) ? `${acc}${PatternBoolean}` : (() => {
+    throw new TemplateLiteralPatternError(`Unexpected Kind '${schema[Kind]}'`);
+  })();
+}
+function TemplateLiteralPattern(kinds) {
+  return `^${kinds.map((schema) => Visit2(schema, "")).join("")}$`;
+}
+
+// node_modules/@sinclair/typebox/build/esm/type/template-literal/union.mjs
+function TemplateLiteralToUnion(schema) {
+  const R = TemplateLiteralGenerate(schema);
+  const L = R.map((S) => Literal(S));
+  return UnionEvaluated(L);
+}
+
+// node_modules/@sinclair/typebox/build/esm/type/template-literal/template-literal.mjs
+function TemplateLiteral(unresolved, options) {
+  const pattern = IsString(unresolved) ? TemplateLiteralPattern(TemplateLiteralSyntax(unresolved)) : TemplateLiteralPattern(unresolved);
+  return CreateType({ [Kind]: "TemplateLiteral", type: "string", pattern }, options);
+}
+
+// node_modules/@sinclair/typebox/build/esm/type/indexed/indexed-property-keys.mjs
+function FromTemplateLiteral(templateLiteral) {
+  const keys = TemplateLiteralGenerate(templateLiteral);
+  return keys.map((key) => key.toString());
+}
+function FromUnion2(types) {
+  const result = [];
+  for (const type of types)
+    result.push(...IndexPropertyKeys(type));
+  return result;
+}
+function FromLiteral(literalValue) {
+  return [literalValue.toString()];
+}
+function IndexPropertyKeys(type) {
+  return [...new Set(IsTemplateLiteral(type) ? FromTemplateLiteral(type) : IsUnion(type) ? FromUnion2(type.anyOf) : IsLiteral(type) ? FromLiteral(type.const) : IsNumber3(type) ? ["[number]"] : IsInteger(type) ? ["[number]"] : [])];
+}
+
+// node_modules/@sinclair/typebox/build/esm/type/indexed/indexed-from-mapped-result.mjs
+function FromProperties(type, properties, options) {
+  const result = {};
+  for (const K2 of Object.getOwnPropertyNames(properties)) {
+    result[K2] = Index(type, IndexPropertyKeys(properties[K2]), options);
+  }
+  return result;
+}
+function FromMappedResult(type, mappedResult, options) {
+  return FromProperties(type, mappedResult.properties, options);
+}
+function IndexFromMappedResult(type, mappedResult, options) {
+  const properties = FromMappedResult(type, mappedResult, options);
+  return MappedResult(properties);
+}
+
+// node_modules/@sinclair/typebox/build/esm/type/indexed/indexed.mjs
+function FromRest(types, key) {
+  return types.map((type) => IndexFromPropertyKey(type, key));
+}
+function FromIntersectRest(types) {
+  return types.filter((type) => !IsNever(type));
+}
+function FromIntersect(types, key) {
+  return IntersectEvaluated(FromIntersectRest(FromRest(types, key)));
+}
+function FromUnionRest(types) {
+  return types.some((L) => IsNever(L)) ? [] : types;
+}
+function FromUnion3(types, key) {
+  return UnionEvaluated(FromUnionRest(FromRest(types, key)));
+}
+function FromTuple(types, key) {
+  return key in types ? types[key] : key === "[number]" ? UnionEvaluated(types) : Never();
+}
+function FromArray(type, key) {
+  return key === "[number]" ? type : Never();
+}
+function FromProperty(properties, propertyKey) {
+  return propertyKey in properties ? properties[propertyKey] : Never();
+}
+function IndexFromPropertyKey(type, propertyKey) {
+  return IsIntersect(type) ? FromIntersect(type.allOf, propertyKey) : IsUnion(type) ? FromUnion3(type.anyOf, propertyKey) : IsTuple(type) ? FromTuple(type.items ?? [], propertyKey) : IsArray3(type) ? FromArray(type.items, propertyKey) : IsObject3(type) ? FromProperty(type.properties, propertyKey) : Never();
+}
+function IndexFromPropertyKeys(type, propertyKeys) {
+  return propertyKeys.map((propertyKey) => IndexFromPropertyKey(type, propertyKey));
+}
+function FromSchema(type, propertyKeys) {
+  return UnionEvaluated(IndexFromPropertyKeys(type, propertyKeys));
+}
+function Index(type, key, options) {
+  if (IsRef(type) || IsRef(key)) {
+    const error = `Index types using Ref parameters require both Type and Key to be of TSchema`;
+    if (!IsSchema(type) || !IsSchema(key))
+      throw new TypeBoxError(error);
+    return Computed("Index", [type, key]);
+  }
+  if (IsMappedResult(key))
+    return IndexFromMappedResult(type, key, options);
+  if (IsMappedKey(key))
+    return IndexFromMappedKey(type, key, options);
+  return CreateType(IsSchema(key) ? FromSchema(type, IndexPropertyKeys(key)) : FromSchema(type, key), options);
+}
+
+// node_modules/@sinclair/typebox/build/esm/type/indexed/indexed-from-mapped-key.mjs
+function MappedIndexPropertyKey(type, key, options) {
+  return { [key]: Index(type, [key], Clone(options)) };
+}
+function MappedIndexPropertyKeys(type, propertyKeys, options) {
+  return propertyKeys.reduce((result, left) => {
+    return { ...result, ...MappedIndexPropertyKey(type, left, options) };
+  }, {});
+}
+function MappedIndexProperties(type, mappedKey, options) {
+  return MappedIndexPropertyKeys(type, mappedKey.keys, options);
+}
+function IndexFromMappedKey(type, mappedKey, options) {
+  const properties = MappedIndexProperties(type, mappedKey, options);
+  return MappedResult(properties);
+}
+
+// node_modules/@sinclair/typebox/build/esm/type/iterator/iterator.mjs
+function Iterator(items, options) {
+  return CreateType({ [Kind]: "Iterator", type: "Iterator", items }, options);
+}
+
+// node_modules/@sinclair/typebox/build/esm/type/object/object.mjs
+function RequiredArray(properties) {
+  return globalThis.Object.keys(properties).filter((key) => !IsOptional(properties[key]));
+}
+function _Object(properties, options) {
+  const required = RequiredArray(properties);
+  const schema = required.length > 0 ? { [Kind]: "Object", type: "object", required, properties } : { [Kind]: "Object", type: "object", properties };
+  return CreateType(schema, options);
+}
+var Object2 = _Object;
+
+// node_modules/@sinclair/typebox/build/esm/type/promise/promise.mjs
+function Promise2(item, options) {
+  return CreateType({ [Kind]: "Promise", type: "Promise", item }, options);
+}
+
+// node_modules/@sinclair/typebox/build/esm/type/readonly/readonly.mjs
+function RemoveReadonly(schema) {
+  return CreateType(Discard(schema, [ReadonlyKind]));
+}
+function AddReadonly(schema) {
+  return CreateType({ ...schema, [ReadonlyKind]: "Readonly" });
+}
+function ReadonlyWithFlag(schema, F) {
+  return F === false ? RemoveReadonly(schema) : AddReadonly(schema);
+}
+function Readonly(schema, enable) {
+  const F = enable ?? true;
+  return IsMappedResult(schema) ? ReadonlyFromMappedResult(schema, F) : ReadonlyWithFlag(schema, F);
+}
+
+// node_modules/@sinclair/typebox/build/esm/type/readonly/readonly-from-mapped-result.mjs
+function FromProperties2(K, F) {
+  const Acc = {};
+  for (const K2 of globalThis.Object.getOwnPropertyNames(K))
+    Acc[K2] = Readonly(K[K2], F);
+  return Acc;
+}
+function FromMappedResult2(R, F) {
+  return FromProperties2(R.properties, F);
+}
+function ReadonlyFromMappedResult(R, F) {
+  const P = FromMappedResult2(R, F);
+  return MappedResult(P);
+}
+
+// node_modules/@sinclair/typebox/build/esm/type/tuple/tuple.mjs
+function Tuple(types, options) {
+  return CreateType(types.length > 0 ? { [Kind]: "Tuple", type: "array", items: types, additionalItems: false, minItems: types.length, maxItems: types.length } : { [Kind]: "Tuple", type: "array", minItems: types.length, maxItems: types.length }, options);
+}
+
+// node_modules/@sinclair/typebox/build/esm/type/mapped/mapped.mjs
+function FromMappedResult3(K, P) {
+  return K in P ? FromSchemaType(K, P[K]) : MappedResult(P);
+}
+function MappedKeyToKnownMappedResultProperties(K) {
+  return { [K]: Literal(K) };
+}
+function MappedKeyToUnknownMappedResultProperties(P) {
+  const Acc = {};
+  for (const L of P)
+    Acc[L] = Literal(L);
+  return Acc;
+}
+function MappedKeyToMappedResultProperties(K, P) {
+  return SetIncludes(P, K) ? MappedKeyToKnownMappedResultProperties(K) : MappedKeyToUnknownMappedResultProperties(P);
+}
+function FromMappedKey(K, P) {
+  const R = MappedKeyToMappedResultProperties(K, P);
+  return FromMappedResult3(K, R);
+}
+function FromRest2(K, T) {
+  return T.map((L) => FromSchemaType(K, L));
+}
+function FromProperties3(K, T) {
+  const Acc = {};
+  for (const K2 of globalThis.Object.getOwnPropertyNames(T))
+    Acc[K2] = FromSchemaType(K, T[K2]);
+  return Acc;
+}
+function FromSchemaType(K, T) {
+  const options = { ...T };
+  return IsOptional(T) ? Optional(FromSchemaType(K, Discard(T, [OptionalKind]))) : IsReadonly(T) ? Readonly(FromSchemaType(K, Discard(T, [ReadonlyKind]))) : IsMappedResult(T) ? FromMappedResult3(K, T.properties) : IsMappedKey(T) ? FromMappedKey(K, T.keys) : IsConstructor(T) ? Constructor(FromRest2(K, T.parameters), FromSchemaType(K, T.returns), options) : IsFunction2(T) ? Function(FromRest2(K, T.parameters), FromSchemaType(K, T.returns), options) : IsAsyncIterator2(T) ? AsyncIterator(FromSchemaType(K, T.items), options) : IsIterator2(T) ? Iterator(FromSchemaType(K, T.items), options) : IsIntersect(T) ? Intersect(FromRest2(K, T.allOf), options) : IsUnion(T) ? Union(FromRest2(K, T.anyOf), options) : IsTuple(T) ? Tuple(FromRest2(K, T.items ?? []), options) : IsObject3(T) ? Object2(FromProperties3(K, T.properties), options) : IsArray3(T) ? Array2(FromSchemaType(K, T.items), options) : IsPromise(T) ? Promise2(FromSchemaType(K, T.item), options) : T;
+}
+function MappedFunctionReturnType(K, T) {
+  const Acc = {};
+  for (const L of K)
+    Acc[L] = FromSchemaType(L, T);
+  return Acc;
+}
+function Mapped(key, map, options) {
+  const K = IsSchema(key) ? IndexPropertyKeys(key) : key;
+  const RT = map({ [Kind]: "MappedKey", keys: K });
+  const R = MappedFunctionReturnType(K, RT);
+  return Object2(R, options);
+}
+
+// node_modules/@sinclair/typebox/build/esm/type/optional/optional.mjs
+function RemoveOptional(schema) {
+  return CreateType(Discard(schema, [OptionalKind]));
+}
+function AddOptional(schema) {
+  return CreateType({ ...schema, [OptionalKind]: "Optional" });
+}
+function OptionalWithFlag(schema, F) {
+  return F === false ? RemoveOptional(schema) : AddOptional(schema);
+}
+function Optional(schema, enable) {
+  const F = enable ?? true;
+  return IsMappedResult(schema) ? OptionalFromMappedResult(schema, F) : OptionalWithFlag(schema, F);
+}
+
+// node_modules/@sinclair/typebox/build/esm/type/optional/optional-from-mapped-result.mjs
+function FromProperties4(P, F) {
+  const Acc = {};
+  for (const K2 of globalThis.Object.getOwnPropertyNames(P))
+    Acc[K2] = Optional(P[K2], F);
+  return Acc;
+}
+function FromMappedResult4(R, F) {
+  return FromProperties4(R.properties, F);
+}
+function OptionalFromMappedResult(R, F) {
+  const P = FromMappedResult4(R, F);
+  return MappedResult(P);
+}
+
+// node_modules/@sinclair/typebox/build/esm/type/intersect/intersect-create.mjs
+function IntersectCreate(T, options = {}) {
+  const allObjects = T.every((schema) => IsObject3(schema));
+  const clonedUnevaluatedProperties = IsSchema(options.unevaluatedProperties) ? { unevaluatedProperties: options.unevaluatedProperties } : {};
+  return CreateType(options.unevaluatedProperties === false || IsSchema(options.unevaluatedProperties) || allObjects ? { ...clonedUnevaluatedProperties, [Kind]: "Intersect", type: "object", allOf: T } : { ...clonedUnevaluatedProperties, [Kind]: "Intersect", allOf: T }, options);
+}
+
+// node_modules/@sinclair/typebox/build/esm/type/intersect/intersect-evaluated.mjs
+function IsIntersectOptional(types) {
+  return types.every((left) => IsOptional(left));
+}
+function RemoveOptionalFromType2(type) {
+  return Discard(type, [OptionalKind]);
+}
+function RemoveOptionalFromRest2(types) {
+  return types.map((left) => IsOptional(left) ? RemoveOptionalFromType2(left) : left);
+}
+function ResolveIntersect(types, options) {
+  return IsIntersectOptional(types) ? Optional(IntersectCreate(RemoveOptionalFromRest2(types), options)) : IntersectCreate(RemoveOptionalFromRest2(types), options);
+}
+function IntersectEvaluated(types, options = {}) {
+  if (types.length === 1)
+    return CreateType(types[0], options);
+  if (types.length === 0)
+    return Never(options);
+  if (types.some((schema) => IsTransform(schema)))
+    throw new Error("Cannot intersect transform types");
+  return ResolveIntersect(types, options);
+}
+
+// node_modules/@sinclair/typebox/build/esm/type/intersect/intersect.mjs
+function Intersect(types, options) {
+  if (types.length === 1)
+    return CreateType(types[0], options);
+  if (types.length === 0)
+    return Never(options);
+  if (types.some((schema) => IsTransform(schema)))
+    throw new Error("Cannot intersect transform types");
+  return IntersectCreate(types, options);
+}
+
+// node_modules/@sinclair/typebox/build/esm/type/ref/ref.mjs
+function Ref(...args) {
+  const [$ref, options] = typeof args[0] === "string" ? [args[0], args[1]] : [args[0].$id, args[1]];
+  if (typeof $ref !== "string")
+    throw new TypeBoxError("Ref: $ref must be a string");
+  return CreateType({ [Kind]: "Ref", $ref }, options);
+}
+
+// node_modules/@sinclair/typebox/build/esm/type/awaited/awaited.mjs
+function FromComputed(target, parameters) {
+  return Computed("Awaited", [Computed(target, parameters)]);
+}
+function FromRef($ref) {
+  return Computed("Awaited", [Ref($ref)]);
+}
+function FromIntersect2(types) {
+  return Intersect(FromRest3(types));
+}
+function FromUnion4(types) {
+  return Union(FromRest3(types));
+}
+function FromPromise(type) {
+  return Awaited(type);
+}
+function FromRest3(types) {
+  return types.map((type) => Awaited(type));
+}
+function Awaited(type, options) {
+  return CreateType(IsComputed(type) ? FromComputed(type.target, type.parameters) : IsIntersect(type) ? FromIntersect2(type.allOf) : IsUnion(type) ? FromUnion4(type.anyOf) : IsPromise(type) ? FromPromise(type.item) : IsRef(type) ? FromRef(type.$ref) : type, options);
+}
+
+// node_modules/@sinclair/typebox/build/esm/type/keyof/keyof-property-keys.mjs
+function FromRest4(types) {
+  const result = [];
+  for (const L of types)
+    result.push(KeyOfPropertyKeys(L));
+  return result;
+}
+function FromIntersect3(types) {
+  const propertyKeysArray = FromRest4(types);
+  const propertyKeys = SetUnionMany(propertyKeysArray);
+  return propertyKeys;
+}
+function FromUnion5(types) {
+  const propertyKeysArray = FromRest4(types);
+  const propertyKeys = SetIntersectMany(propertyKeysArray);
+  return propertyKeys;
+}
+function FromTuple2(types) {
+  return types.map((_, indexer) => indexer.toString());
+}
+function FromArray2(_) {
+  return ["[number]"];
+}
+function FromProperties5(T) {
+  return globalThis.Object.getOwnPropertyNames(T);
+}
+function FromPatternProperties(patternProperties) {
+  if (!includePatternProperties)
+    return [];
+  const patternPropertyKeys = globalThis.Object.getOwnPropertyNames(patternProperties);
+  return patternPropertyKeys.map((key) => {
+    return key[0] === "^" && key[key.length - 1] === "$" ? key.slice(1, key.length - 1) : key;
+  });
+}
+function KeyOfPropertyKeys(type) {
+  return IsIntersect(type) ? FromIntersect3(type.allOf) : IsUnion(type) ? FromUnion5(type.anyOf) : IsTuple(type) ? FromTuple2(type.items ?? []) : IsArray3(type) ? FromArray2(type.items) : IsObject3(type) ? FromProperties5(type.properties) : IsRecord(type) ? FromPatternProperties(type.patternProperties) : [];
+}
+var includePatternProperties = false;
+
+// node_modules/@sinclair/typebox/build/esm/type/keyof/keyof.mjs
+function FromComputed2(target, parameters) {
+  return Computed("KeyOf", [Computed(target, parameters)]);
+}
+function FromRef2($ref) {
+  return Computed("KeyOf", [Ref($ref)]);
+}
+function KeyOfFromType(type, options) {
+  const propertyKeys = KeyOfPropertyKeys(type);
+  const propertyKeyTypes = KeyOfPropertyKeysToRest(propertyKeys);
+  const result = UnionEvaluated(propertyKeyTypes);
+  return CreateType(result, options);
+}
+function KeyOfPropertyKeysToRest(propertyKeys) {
+  return propertyKeys.map((L) => L === "[number]" ? Number2() : Literal(L));
+}
+function KeyOf(type, options) {
+  return IsComputed(type) ? FromComputed2(type.target, type.parameters) : IsRef(type) ? FromRef2(type.$ref) : IsMappedResult(type) ? KeyOfFromMappedResult(type, options) : KeyOfFromType(type, options);
+}
+
+// node_modules/@sinclair/typebox/build/esm/type/keyof/keyof-from-mapped-result.mjs
+function FromProperties6(properties, options) {
+  const result = {};
+  for (const K2 of globalThis.Object.getOwnPropertyNames(properties))
+    result[K2] = KeyOf(properties[K2], Clone(options));
+  return result;
+}
+function FromMappedResult5(mappedResult, options) {
+  return FromProperties6(mappedResult.properties, options);
+}
+function KeyOfFromMappedResult(mappedResult, options) {
+  const properties = FromMappedResult5(mappedResult, options);
+  return MappedResult(properties);
+}
+
+// node_modules/@sinclair/typebox/build/esm/type/composite/composite.mjs
+function CompositeKeys(T) {
+  const Acc = [];
+  for (const L of T)
+    Acc.push(...KeyOfPropertyKeys(L));
+  return SetDistinct(Acc);
+}
+function FilterNever(T) {
+  return T.filter((L) => !IsNever(L));
+}
+function CompositeProperty(T, K) {
+  const Acc = [];
+  for (const L of T)
+    Acc.push(...IndexFromPropertyKeys(L, [K]));
+  return FilterNever(Acc);
+}
+function CompositeProperties(T, K) {
+  const Acc = {};
+  for (const L of K) {
+    Acc[L] = IntersectEvaluated(CompositeProperty(T, L));
+  }
+  return Acc;
+}
+function Composite(T, options) {
+  const K = CompositeKeys(T);
+  const P = CompositeProperties(T, K);
+  const R = Object2(P, options);
+  return R;
+}
+
+// node_modules/@sinclair/typebox/build/esm/type/date/date.mjs
+function Date2(options) {
+  return CreateType({ [Kind]: "Date", type: "Date" }, options);
+}
+
+// node_modules/@sinclair/typebox/build/esm/type/null/null.mjs
+function Null(options) {
+  return CreateType({ [Kind]: "Null", type: "null" }, options);
+}
+
+// node_modules/@sinclair/typebox/build/esm/type/symbol/symbol.mjs
+function Symbol2(options) {
+  return CreateType({ [Kind]: "Symbol", type: "symbol" }, options);
+}
+
+// node_modules/@sinclair/typebox/build/esm/type/undefined/undefined.mjs
+function Undefined(options) {
+  return CreateType({ [Kind]: "Undefined", type: "undefined" }, options);
+}
+
+// node_modules/@sinclair/typebox/build/esm/type/uint8array/uint8array.mjs
+function Uint8Array2(options) {
+  return CreateType({ [Kind]: "Uint8Array", type: "Uint8Array" }, options);
+}
+
+// node_modules/@sinclair/typebox/build/esm/type/unknown/unknown.mjs
+function Unknown(options) {
+  return CreateType({ [Kind]: "Unknown" }, options);
+}
+
+// node_modules/@sinclair/typebox/build/esm/type/const/const.mjs
+function FromArray3(T) {
+  return T.map((L) => FromValue(L, false));
+}
+function FromProperties7(value) {
+  const Acc = {};
+  for (const K of globalThis.Object.getOwnPropertyNames(value))
+    Acc[K] = Readonly(FromValue(value[K], false));
+  return Acc;
+}
+function ConditionalReadonly(T, root) {
+  return root === true ? T : Readonly(T);
+}
+function FromValue(value, root) {
+  return IsAsyncIterator(value) ? ConditionalReadonly(Any(), root) : IsIterator(value) ? ConditionalReadonly(Any(), root) : IsArray(value) ? Readonly(Tuple(FromArray3(value))) : IsUint8Array(value) ? Uint8Array2() : IsDate(value) ? Date2() : IsObject(value) ? ConditionalReadonly(Object2(FromProperties7(value)), root) : IsFunction(value) ? ConditionalReadonly(Function([], Unknown()), root) : IsUndefined(value) ? Undefined() : IsNull(value) ? Null() : IsSymbol(value) ? Symbol2() : IsBigInt(value) ? BigInt() : IsNumber(value) ? Literal(value) : IsBoolean(value) ? Literal(value) : IsString(value) ? Literal(value) : Object2({});
+}
+function Const(T, options) {
+  return CreateType(FromValue(T, true), options);
+}
+
+// node_modules/@sinclair/typebox/build/esm/type/constructor-parameters/constructor-parameters.mjs
+function ConstructorParameters(schema, options) {
+  return IsConstructor(schema) ? Tuple(schema.parameters, options) : Never(options);
+}
+
+// node_modules/@sinclair/typebox/build/esm/type/enum/enum.mjs
+function Enum(item, options) {
+  if (IsUndefined(item))
+    throw new Error("Enum undefined or empty");
+  const values1 = globalThis.Object.getOwnPropertyNames(item).filter((key) => isNaN(key)).map((key) => item[key]);
+  const values2 = [...new Set(values1)];
+  const anyOf = values2.map((value) => Literal(value));
+  return Union(anyOf, { ...options, [Hint]: "Enum" });
+}
+
+// node_modules/@sinclair/typebox/build/esm/type/extends/extends-check.mjs
+class ExtendsResolverError extends TypeBoxError {
+}
+var ExtendsResult;
+(function(ExtendsResult2) {
+  ExtendsResult2[ExtendsResult2["Union"] = 0] = "Union";
+  ExtendsResult2[ExtendsResult2["True"] = 1] = "True";
+  ExtendsResult2[ExtendsResult2["False"] = 2] = "False";
+})(ExtendsResult || (ExtendsResult = {}));
+function IntoBooleanResult(result) {
+  return result === ExtendsResult.False ? result : ExtendsResult.True;
+}
+function Throw(message) {
+  throw new ExtendsResolverError(message);
+}
+function IsStructuralRight(right) {
+  return exports_type.IsNever(right) || exports_type.IsIntersect(right) || exports_type.IsUnion(right) || exports_type.IsUnknown(right) || exports_type.IsAny(right);
+}
+function StructuralRight(left, right) {
+  return exports_type.IsNever(right) ? FromNeverRight(left, right) : exports_type.IsIntersect(right) ? FromIntersectRight(left, right) : exports_type.IsUnion(right) ? FromUnionRight(left, right) : exports_type.IsUnknown(right) ? FromUnknownRight(left, right) : exports_type.IsAny(right) ? FromAnyRight(left, right) : Throw("StructuralRight");
+}
+function FromAnyRight(left, right) {
+  return ExtendsResult.True;
+}
+function FromAny(left, right) {
+  return exports_type.IsIntersect(right) ? FromIntersectRight(left, right) : exports_type.IsUnion(right) && right.anyOf.some((schema) => exports_type.IsAny(schema) || exports_type.IsUnknown(schema)) ? ExtendsResult.True : exports_type.IsUnion(right) ? ExtendsResult.Union : exports_type.IsUnknown(right) ? ExtendsResult.True : exports_type.IsAny(right) ? ExtendsResult.True : ExtendsResult.Union;
+}
+function FromArrayRight(left, right) {
+  return exports_type.IsUnknown(left) ? ExtendsResult.False : exports_type.IsAny(left) ? ExtendsResult.Union : exports_type.IsNever(left) ? ExtendsResult.True : ExtendsResult.False;
+}
+function FromArray4(left, right) {
+  return exports_type.IsObject(right) && IsObjectArrayLike(right) ? ExtendsResult.True : IsStructuralRight(right) ? StructuralRight(left, right) : !exports_type.IsArray(right) ? ExtendsResult.False : IntoBooleanResult(Visit3(left.items, right.items));
+}
+function FromAsyncIterator(left, right) {
+  return IsStructuralRight(right) ? StructuralRight(left, right) : !exports_type.IsAsyncIterator(right) ? ExtendsResult.False : IntoBooleanResult(Visit3(left.items, right.items));
+}
+function FromBigInt(left, right) {
+  return IsStructuralRight(right) ? StructuralRight(left, right) : exports_type.IsObject(right) ? FromObjectRight(left, right) : exports_type.IsRecord(right) ? FromRecordRight(left, right) : exports_type.IsBigInt(right) ? ExtendsResult.True : ExtendsResult.False;
+}
+function FromBooleanRight(left, right) {
+  return exports_type.IsLiteralBoolean(left) ? ExtendsResult.True : exports_type.IsBoolean(left) ? ExtendsResult.True : ExtendsResult.False;
+}
+function FromBoolean(left, right) {
+  return IsStructuralRight(right) ? StructuralRight(left, right) : exports_type.IsObject(right) ? FromObjectRight(left, right) : exports_type.IsRecord(right) ? FromRecordRight(left, right) : exports_type.IsBoolean(right) ? ExtendsResult.True : ExtendsResult.False;
+}
+function FromConstructor(left, right) {
+  return IsStructuralRight(right) ? StructuralRight(left, right) : exports_type.IsObject(right) ? FromObjectRight(left, right) : !exports_type.IsConstructor(right) ? ExtendsResult.False : left.parameters.length > right.parameters.length ? ExtendsResult.False : !left.parameters.every((schema, index) => IntoBooleanResult(Visit3(right.parameters[index], schema)) === ExtendsResult.True) ? ExtendsResult.False : IntoBooleanResult(Visit3(left.returns, right.returns));
+}
+function FromDate(left, right) {
+  return IsStructuralRight(right) ? StructuralRight(left, right) : exports_type.IsObject(right) ? FromObjectRight(left, right) : exports_type.IsRecord(right) ? FromRecordRight(left, right) : exports_type.IsDate(right) ? ExtendsResult.True : ExtendsResult.False;
+}
+function FromFunction(left, right) {
+  return IsStructuralRight(right) ? StructuralRight(left, right) : exports_type.IsObject(right) ? FromObjectRight(left, right) : !exports_type.IsFunction(right) ? ExtendsResult.False : left.parameters.length > right.parameters.length ? ExtendsResult.False : !left.parameters.every((schema, index) => IntoBooleanResult(Visit3(right.parameters[index], schema)) === ExtendsResult.True) ? ExtendsResult.False : IntoBooleanResult(Visit3(left.returns, right.returns));
+}
+function FromIntegerRight(left, right) {
+  return exports_type.IsLiteral(left) && exports_value.IsNumber(left.const) ? ExtendsResult.True : exports_type.IsNumber(left) || exports_type.IsInteger(left) ? ExtendsResult.True : ExtendsResult.False;
+}
+function FromInteger(left, right) {
+  return exports_type.IsInteger(right) || exports_type.IsNumber(right) ? ExtendsResult.True : IsStructuralRight(right) ? StructuralRight(left, right) : exports_type.IsObject(right) ? FromObjectRight(left, right) : exports_type.IsRecord(right) ? FromRecordRight(left, right) : ExtendsResult.False;
+}
+function FromIntersectRight(left, right) {
+  return right.allOf.every((schema) => Visit3(left, schema) === ExtendsResult.True) ? ExtendsResult.True : ExtendsResult.False;
+}
+function FromIntersect4(left, right) {
+  return left.allOf.some((schema) => Visit3(schema, right) === ExtendsResult.True) ? ExtendsResult.True : ExtendsResult.False;
+}
+function FromIterator(left, right) {
+  return IsStructuralRight(right) ? StructuralRight(left, right) : !exports_type.IsIterator(right) ? ExtendsResult.False : IntoBooleanResult(Visit3(left.items, right.items));
+}
+function FromLiteral2(left, right) {
+  return exports_type.IsLiteral(right) && right.const === left.const ? ExtendsResult.True : IsStructuralRight(right) ? StructuralRight(left, right) : exports_type.IsObject(right) ? FromObjectRight(left, right) : exports_type.IsRecord(right) ? FromRecordRight(left, right) : exports_type.IsString(right) ? FromStringRight(left, right) : exports_type.IsNumber(right) ? FromNumberRight(left, right) : exports_type.IsInteger(right) ? FromIntegerRight(left, right) : exports_type.IsBoolean(right) ? FromBooleanRight(left, right) : ExtendsResult.False;
+}
+function FromNeverRight(left, right) {
+  return ExtendsResult.False;
+}
+function FromNever(left, right) {
+  return ExtendsResult.True;
+}
+function UnwrapTNot(schema) {
+  let [current, depth] = [schema, 0];
+  while (true) {
+    if (!exports_type.IsNot(current))
+      break;
+    current = current.not;
+    depth += 1;
+  }
+  return depth % 2 === 0 ? current : Unknown();
+}
+function FromNot(left, right) {
+  return exports_type.IsNot(left) ? Visit3(UnwrapTNot(left), right) : exports_type.IsNot(right) ? Visit3(left, UnwrapTNot(right)) : Throw("Invalid fallthrough for Not");
+}
+function FromNull(left, right) {
+  return IsStructuralRight(right) ? StructuralRight(left, right) : exports_type.IsObject(right) ? FromObjectRight(left, right) : exports_type.IsRecord(right) ? FromRecordRight(left, right) : exports_type.IsNull(right) ? ExtendsResult.True : ExtendsResult.False;
+}
+function FromNumberRight(left, right) {
+  return exports_type.IsLiteralNumber(left) ? ExtendsResult.True : exports_type.IsNumber(left) || exports_type.IsInteger(left) ? ExtendsResult.True : ExtendsResult.False;
+}
+function FromNumber(left, right) {
+  return IsStructuralRight(right) ? StructuralRight(left, right) : exports_type.IsObject(right) ? FromObjectRight(left, right) : exports_type.IsRecord(right) ? FromRecordRight(left, right) : exports_type.IsInteger(right) || exports_type.IsNumber(right) ? ExtendsResult.True : ExtendsResult.False;
+}
+function IsObjectPropertyCount(schema, count) {
+  return Object.getOwnPropertyNames(schema.properties).length === count;
+}
+function IsObjectStringLike(schema) {
+  return IsObjectArrayLike(schema);
+}
+function IsObjectSymbolLike(schema) {
+  return IsObjectPropertyCount(schema, 0) || IsObjectPropertyCount(schema, 1) && "description" in schema.properties && exports_type.IsUnion(schema.properties.description) && schema.properties.description.anyOf.length === 2 && (exports_type.IsString(schema.properties.description.anyOf[0]) && exports_type.IsUndefined(schema.properties.description.anyOf[1]) || exports_type.IsString(schema.properties.description.anyOf[1]) && exports_type.IsUndefined(schema.properties.description.anyOf[0]));
+}
+function IsObjectNumberLike(schema) {
+  return IsObjectPropertyCount(schema, 0);
+}
+function IsObjectBooleanLike(schema) {
+  return IsObjectPropertyCount(schema, 0);
+}
+function IsObjectBigIntLike(schema) {
+  return IsObjectPropertyCount(schema, 0);
+}
+function IsObjectDateLike(schema) {
+  return IsObjectPropertyCount(schema, 0);
+}
+function IsObjectUint8ArrayLike(schema) {
+  return IsObjectArrayLike(schema);
+}
+function IsObjectFunctionLike(schema) {
+  const length = Number2();
+  return IsObjectPropertyCount(schema, 0) || IsObjectPropertyCount(schema, 1) && "length" in schema.properties && IntoBooleanResult(Visit3(schema.properties["length"], length)) === ExtendsResult.True;
+}
+function IsObjectConstructorLike(schema) {
+  return IsObjectPropertyCount(schema, 0);
+}
+function IsObjectArrayLike(schema) {
+  const length = Number2();
+  return IsObjectPropertyCount(schema, 0) || IsObjectPropertyCount(schema, 1) && "length" in schema.properties && IntoBooleanResult(Visit3(schema.properties["length"], length)) === ExtendsResult.True;
+}
+function IsObjectPromiseLike(schema) {
+  const then = Function([Any()], Any());
+  return IsObjectPropertyCount(schema, 0) || IsObjectPropertyCount(schema, 1) && "then" in schema.properties && IntoBooleanResult(Visit3(schema.properties["then"], then)) === ExtendsResult.True;
+}
+function Property(left, right) {
+  return Visit3(left, right) === ExtendsResult.False ? ExtendsResult.False : exports_type.IsOptional(left) && !exports_type.IsOptional(right) ? ExtendsResult.False : ExtendsResult.True;
+}
+function FromObjectRight(left, right) {
+  return exports_type.IsUnknown(left) ? ExtendsResult.False : exports_type.IsAny(left) ? ExtendsResult.Union : exports_type.IsNever(left) || exports_type.IsLiteralString(left) && IsObjectStringLike(right) || exports_type.IsLiteralNumber(left) && IsObjectNumberLike(right) || exports_type.IsLiteralBoolean(left) && IsObjectBooleanLike(right) || exports_type.IsSymbol(left) && IsObjectSymbolLike(right) || exports_type.IsBigInt(left) && IsObjectBigIntLike(right) || exports_type.IsString(left) && IsObjectStringLike(right) || exports_type.IsSymbol(left) && IsObjectSymbolLike(right) || exports_type.IsNumber(left) && IsObjectNumberLike(right) || exports_type.IsInteger(left) && IsObjectNumberLike(right) || exports_type.IsBoolean(left) && IsObjectBooleanLike(right) || exports_type.IsUint8Array(left) && IsObjectUint8ArrayLike(right) || exports_type.IsDate(left) && IsObjectDateLike(right) || exports_type.IsConstructor(left) && IsObjectConstructorLike(right) || exports_type.IsFunction(left) && IsObjectFunctionLike(right) ? ExtendsResult.True : exports_type.IsRecord(left) && exports_type.IsString(RecordKey(left)) ? (() => {
+    return right[Hint] === "Record" ? ExtendsResult.True : ExtendsResult.False;
+  })() : exports_type.IsRecord(left) && exports_type.IsNumber(RecordKey(left)) ? (() => {
+    return IsObjectPropertyCount(right, 0) ? ExtendsResult.True : ExtendsResult.False;
+  })() : ExtendsResult.False;
+}
+function FromObject(left, right) {
+  return IsStructuralRight(right) ? StructuralRight(left, right) : exports_type.IsRecord(right) ? FromRecordRight(left, right) : !exports_type.IsObject(right) ? ExtendsResult.False : (() => {
+    for (const key of Object.getOwnPropertyNames(right.properties)) {
+      if (!(key in left.properties) && !exports_type.IsOptional(right.properties[key])) {
+        return ExtendsResult.False;
+      }
+      if (exports_type.IsOptional(right.properties[key])) {
+        return ExtendsResult.True;
+      }
+      if (Property(left.properties[key], right.properties[key]) === ExtendsResult.False) {
+        return ExtendsResult.False;
+      }
+    }
+    return ExtendsResult.True;
+  })();
+}
+function FromPromise2(left, right) {
+  return IsStructuralRight(right) ? StructuralRight(left, right) : exports_type.IsObject(right) && IsObjectPromiseLike(right) ? ExtendsResult.True : !exports_type.IsPromise(right) ? ExtendsResult.False : IntoBooleanResult(Visit3(left.item, right.item));
+}
+function RecordKey(schema) {
+  return PatternNumberExact in schema.patternProperties ? Number2() : (PatternStringExact in schema.patternProperties) ? String2() : Throw("Unknown record key pattern");
+}
+function RecordValue(schema) {
+  return PatternNumberExact in schema.patternProperties ? schema.patternProperties[PatternNumberExact] : (PatternStringExact in schema.patternProperties) ? schema.patternProperties[PatternStringExact] : Throw("Unable to get record value schema");
+}
+function FromRecordRight(left, right) {
+  const [Key, Value] = [RecordKey(right), RecordValue(right)];
+  return exports_type.IsLiteralString(left) && exports_type.IsNumber(Key) && IntoBooleanResult(Visit3(left, Value)) === ExtendsResult.True ? ExtendsResult.True : exports_type.IsUint8Array(left) && exports_type.IsNumber(Key) ? Visit3(left, Value) : exports_type.IsString(left) && exports_type.IsNumber(Key) ? Visit3(left, Value) : exports_type.IsArray(left) && exports_type.IsNumber(Key) ? Visit3(left, Value) : exports_type.IsObject(left) ? (() => {
+    for (const key of Object.getOwnPropertyNames(left.properties)) {
+      if (Property(Value, left.properties[key]) === ExtendsResult.False) {
+        return ExtendsResult.False;
+      }
+    }
+    return ExtendsResult.True;
+  })() : ExtendsResult.False;
+}
+function FromRecord(left, right) {
+  return IsStructuralRight(right) ? StructuralRight(left, right) : exports_type.IsObject(right) ? FromObjectRight(left, right) : !exports_type.IsRecord(right) ? ExtendsResult.False : Visit3(RecordValue(left), RecordValue(right));
+}
+function FromRegExp(left, right) {
+  const L = exports_type.IsRegExp(left) ? String2() : left;
+  const R = exports_type.IsRegExp(right) ? String2() : right;
+  return Visit3(L, R);
+}
+function FromStringRight(left, right) {
+  return exports_type.IsLiteral(left) && exports_value.IsString(left.const) ? ExtendsResult.True : exports_type.IsString(left) ? ExtendsResult.True : ExtendsResult.False;
+}
+function FromString(left, right) {
+  return IsStructuralRight(right) ? StructuralRight(left, right) : exports_type.IsObject(right) ? FromObjectRight(left, right) : exports_type.IsRecord(right) ? FromRecordRight(left, right) : exports_type.IsString(right) ? ExtendsResult.True : ExtendsResult.False;
+}
+function FromSymbol(left, right) {
+  return IsStructuralRight(right) ? StructuralRight(left, right) : exports_type.IsObject(right) ? FromObjectRight(left, right) : exports_type.IsRecord(right) ? FromRecordRight(left, right) : exports_type.IsSymbol(right) ? ExtendsResult.True : ExtendsResult.False;
+}
+function FromTemplateLiteral2(left, right) {
+  return exports_type.IsTemplateLiteral(left) ? Visit3(TemplateLiteralToUnion(left), right) : exports_type.IsTemplateLiteral(right) ? Visit3(left, TemplateLiteralToUnion(right)) : Throw("Invalid fallthrough for TemplateLiteral");
+}
+function IsArrayOfTuple(left, right) {
+  return exports_type.IsArray(right) && left.items !== undefined && left.items.every((schema) => Visit3(schema, right.items) === ExtendsResult.True);
+}
+function FromTupleRight(left, right) {
+  return exports_type.IsNever(left) ? ExtendsResult.True : exports_type.IsUnknown(left) ? ExtendsResult.False : exports_type.IsAny(left) ? ExtendsResult.Union : ExtendsResult.False;
+}
+function FromTuple3(left, right) {
+  return IsStructuralRight(right) ? StructuralRight(left, right) : exports_type.IsObject(right) && IsObjectArrayLike(right) ? ExtendsResult.True : exports_type.IsArray(right) && IsArrayOfTuple(left, right) ? ExtendsResult.True : !exports_type.IsTuple(right) ? ExtendsResult.False : exports_value.IsUndefined(left.items) && !exports_value.IsUndefined(right.items) || !exports_value.IsUndefined(left.items) && exports_value.IsUndefined(right.items) ? ExtendsResult.False : exports_value.IsUndefined(left.items) && !exports_value.IsUndefined(right.items) ? ExtendsResult.True : left.items.every((schema, index) => Visit3(schema, right.items[index]) === ExtendsResult.True) ? ExtendsResult.True : ExtendsResult.False;
+}
+function FromUint8Array(left, right) {
+  return IsStructuralRight(right) ? StructuralRight(left, right) : exports_type.IsObject(right) ? FromObjectRight(left, right) : exports_type.IsRecord(right) ? FromRecordRight(left, right) : exports_type.IsUint8Array(right) ? ExtendsResult.True : ExtendsResult.False;
+}
+function FromUndefined(left, right) {
+  return IsStructuralRight(right) ? StructuralRight(left, right) : exports_type.IsObject(right) ? FromObjectRight(left, right) : exports_type.IsRecord(right) ? FromRecordRight(left, right) : exports_type.IsVoid(right) ? FromVoidRight(left, right) : exports_type.IsUndefined(right) ? ExtendsResult.True : ExtendsResult.False;
+}
+function FromUnionRight(left, right) {
+  return right.anyOf.some((schema) => Visit3(left, schema) === ExtendsResult.True) ? ExtendsResult.True : ExtendsResult.False;
+}
+function FromUnion6(left, right) {
+  return left.anyOf.every((schema) => Visit3(schema, right) === ExtendsResult.True) ? ExtendsResult.True : ExtendsResult.False;
+}
+function FromUnknownRight(left, right) {
+  return ExtendsResult.True;
+}
+function FromUnknown(left, right) {
+  return exports_type.IsNever(right) ? FromNeverRight(left, right) : exports_type.IsIntersect(right) ? FromIntersectRight(left, right) : exports_type.IsUnion(right) ? FromUnionRight(left, right) : exports_type.IsAny(right) ? FromAnyRight(left, right) : exports_type.IsString(right) ? FromStringRight(left, right) : exports_type.IsNumber(right) ? FromNumberRight(left, right) : exports_type.IsInteger(right) ? FromIntegerRight(left, right) : exports_type.IsBoolean(right) ? FromBooleanRight(left, right) : exports_type.IsArray(right) ? FromArrayRight(left, right) : exports_type.IsTuple(right) ? FromTupleRight(left, right) : exports_type.IsObject(right) ? FromObjectRight(left, right) : exports_type.IsUnknown(right) ? ExtendsResult.True : ExtendsResult.False;
+}
+function FromVoidRight(left, right) {
+  return exports_type.IsUndefined(left) ? ExtendsResult.True : exports_type.IsUndefined(left) ? ExtendsResult.True : ExtendsResult.False;
+}
+function FromVoid(left, right) {
+  return exports_type.IsIntersect(right) ? FromIntersectRight(left, right) : exports_type.IsUnion(right) ? FromUnionRight(left, right) : exports_type.IsUnknown(right) ? FromUnknownRight(left, right) : exports_type.IsAny(right) ? FromAnyRight(left, right) : exports_type.IsObject(right) ? FromObjectRight(left, right) : exports_type.IsVoid(right) ? ExtendsResult.True : ExtendsResult.False;
+}
+function Visit3(left, right) {
+  return exports_type.IsTemplateLiteral(left) || exports_type.IsTemplateLiteral(right) ? FromTemplateLiteral2(left, right) : exports_type.IsRegExp(left) || exports_type.IsRegExp(right) ? FromRegExp(left, right) : exports_type.IsNot(left) || exports_type.IsNot(right) ? FromNot(left, right) : exports_type.IsAny(left) ? FromAny(left, right) : exports_type.IsArray(left) ? FromArray4(left, right) : exports_type.IsBigInt(left) ? FromBigInt(left, right) : exports_type.IsBoolean(left) ? FromBoolean(left, right) : exports_type.IsAsyncIterator(left) ? FromAsyncIterator(left, right) : exports_type.IsConstructor(left) ? FromConstructor(left, right) : exports_type.IsDate(left) ? FromDate(left, right) : exports_type.IsFunction(left) ? FromFunction(left, right) : exports_type.IsInteger(left) ? FromInteger(left, right) : exports_type.IsIntersect(left) ? FromIntersect4(left, right) : exports_type.IsIterator(left) ? FromIterator(left, right) : exports_type.IsLiteral(left) ? FromLiteral2(left, right) : exports_type.IsNever(left) ? FromNever(left, right) : exports_type.IsNull(left) ? FromNull(left, right) : exports_type.IsNumber(left) ? FromNumber(left, right) : exports_type.IsObject(left) ? FromObject(left, right) : exports_type.IsRecord(left) ? FromRecord(left, right) : exports_type.IsString(left) ? FromString(left, right) : exports_type.IsSymbol(left) ? FromSymbol(left, right) : exports_type.IsTuple(left) ? FromTuple3(left, right) : exports_type.IsPromise(left) ? FromPromise2(left, right) : exports_type.IsUint8Array(left) ? FromUint8Array(left, right) : exports_type.IsUndefined(left) ? FromUndefined(left, right) : exports_type.IsUnion(left) ? FromUnion6(left, right) : exports_type.IsUnknown(left) ? FromUnknown(left, right) : exports_type.IsVoid(left) ? FromVoid(left, right) : Throw(`Unknown left type operand '${left[Kind]}'`);
+}
+function ExtendsCheck(left, right) {
+  return Visit3(left, right);
+}
+
+// node_modules/@sinclair/typebox/build/esm/type/extends/extends-from-mapped-result.mjs
+function FromProperties8(P, Right, True, False, options) {
+  const Acc = {};
+  for (const K2 of globalThis.Object.getOwnPropertyNames(P))
+    Acc[K2] = Extends(P[K2], Right, True, False, Clone(options));
+  return Acc;
+}
+function FromMappedResult6(Left, Right, True, False, options) {
+  return FromProperties8(Left.properties, Right, True, False, options);
+}
+function ExtendsFromMappedResult(Left, Right, True, False, options) {
+  const P = FromMappedResult6(Left, Right, True, False, options);
+  return MappedResult(P);
+}
+
+// node_modules/@sinclair/typebox/build/esm/type/extends/extends.mjs
+function ExtendsResolve(left, right, trueType, falseType) {
+  const R = ExtendsCheck(left, right);
+  return R === ExtendsResult.Union ? Union([trueType, falseType]) : R === ExtendsResult.True ? trueType : falseType;
+}
+function Extends(L, R, T, F, options) {
+  return IsMappedResult(L) ? ExtendsFromMappedResult(L, R, T, F, options) : IsMappedKey(L) ? CreateType(ExtendsFromMappedKey(L, R, T, F, options)) : CreateType(ExtendsResolve(L, R, T, F), options);
+}
+
+// node_modules/@sinclair/typebox/build/esm/type/extends/extends-from-mapped-key.mjs
+function FromPropertyKey(K, U, L, R, options) {
+  return {
+    [K]: Extends(Literal(K), U, L, R, Clone(options))
+  };
+}
+function FromPropertyKeys(K, U, L, R, options) {
+  return K.reduce((Acc, LK) => {
+    return { ...Acc, ...FromPropertyKey(LK, U, L, R, options) };
+  }, {});
+}
+function FromMappedKey2(K, U, L, R, options) {
+  return FromPropertyKeys(K.keys, U, L, R, options);
+}
+function ExtendsFromMappedKey(T, U, L, R, options) {
+  const P = FromMappedKey2(T, U, L, R, options);
+  return MappedResult(P);
+}
+
+// node_modules/@sinclair/typebox/build/esm/type/exclude/exclude-from-template-literal.mjs
+function ExcludeFromTemplateLiteral(L, R) {
+  return Exclude(TemplateLiteralToUnion(L), R);
+}
+
+// node_modules/@sinclair/typebox/build/esm/type/exclude/exclude.mjs
+function ExcludeRest(L, R) {
+  const excluded = L.filter((inner) => ExtendsCheck(inner, R) === ExtendsResult.False);
+  return excluded.length === 1 ? excluded[0] : Union(excluded);
+}
+function Exclude(L, R, options = {}) {
+  if (IsTemplateLiteral(L))
+    return CreateType(ExcludeFromTemplateLiteral(L, R), options);
+  if (IsMappedResult(L))
+    return CreateType(ExcludeFromMappedResult(L, R), options);
+  return CreateType(IsUnion(L) ? ExcludeRest(L.anyOf, R) : ExtendsCheck(L, R) !== ExtendsResult.False ? Never() : L, options);
+}
+
+// node_modules/@sinclair/typebox/build/esm/type/exclude/exclude-from-mapped-result.mjs
+function FromProperties9(P, U) {
+  const Acc = {};
+  for (const K2 of globalThis.Object.getOwnPropertyNames(P))
+    Acc[K2] = Exclude(P[K2], U);
+  return Acc;
+}
+function FromMappedResult7(R, T) {
+  return FromProperties9(R.properties, T);
+}
+function ExcludeFromMappedResult(R, T) {
+  const P = FromMappedResult7(R, T);
+  return MappedResult(P);
+}
+
+// node_modules/@sinclair/typebox/build/esm/type/extract/extract-from-template-literal.mjs
+function ExtractFromTemplateLiteral(L, R) {
+  return Extract(TemplateLiteralToUnion(L), R);
+}
+
+// node_modules/@sinclair/typebox/build/esm/type/extract/extract.mjs
+function ExtractRest(L, R) {
+  const extracted = L.filter((inner) => ExtendsCheck(inner, R) !== ExtendsResult.False);
+  return extracted.length === 1 ? extracted[0] : Union(extracted);
+}
+function Extract(L, R, options) {
+  if (IsTemplateLiteral(L))
+    return CreateType(ExtractFromTemplateLiteral(L, R), options);
+  if (IsMappedResult(L))
+    return CreateType(ExtractFromMappedResult(L, R), options);
+  return CreateType(IsUnion(L) ? ExtractRest(L.anyOf, R) : ExtendsCheck(L, R) !== ExtendsResult.False ? L : Never(), options);
+}
+
+// node_modules/@sinclair/typebox/build/esm/type/extract/extract-from-mapped-result.mjs
+function FromProperties10(P, T) {
+  const Acc = {};
+  for (const K2 of globalThis.Object.getOwnPropertyNames(P))
+    Acc[K2] = Extract(P[K2], T);
+  return Acc;
+}
+function FromMappedResult8(R, T) {
+  return FromProperties10(R.properties, T);
+}
+function ExtractFromMappedResult(R, T) {
+  const P = FromMappedResult8(R, T);
+  return MappedResult(P);
+}
+
+// node_modules/@sinclair/typebox/build/esm/type/instance-type/instance-type.mjs
+function InstanceType(schema, options) {
+  return IsConstructor(schema) ? CreateType(schema.returns, options) : Never(options);
+}
+
+// node_modules/@sinclair/typebox/build/esm/type/readonly-optional/readonly-optional.mjs
+function ReadonlyOptional(schema) {
+  return Readonly(Optional(schema));
+}
+
+// node_modules/@sinclair/typebox/build/esm/type/record/record.mjs
+function RecordCreateFromPattern(pattern, T, options) {
+  return CreateType({ [Kind]: "Record", type: "object", patternProperties: { [pattern]: T } }, options);
+}
+function RecordCreateFromKeys(K, T, options) {
+  const result = {};
+  for (const K2 of K)
+    result[K2] = T;
+  return Object2(result, { ...options, [Hint]: "Record" });
+}
+function FromTemplateLiteralKey(K, T, options) {
+  return IsTemplateLiteralFinite(K) ? RecordCreateFromKeys(IndexPropertyKeys(K), T, options) : RecordCreateFromPattern(K.pattern, T, options);
+}
+function FromUnionKey(key, type, options) {
+  return RecordCreateFromKeys(IndexPropertyKeys(Union(key)), type, options);
+}
+function FromLiteralKey(key, type, options) {
+  return RecordCreateFromKeys([key.toString()], type, options);
+}
+function FromRegExpKey(key, type, options) {
+  return RecordCreateFromPattern(key.source, type, options);
+}
+function FromStringKey(key, type, options) {
+  const pattern = IsUndefined(key.pattern) ? PatternStringExact : key.pattern;
+  return RecordCreateFromPattern(pattern, type, options);
+}
+function FromAnyKey(_, type, options) {
+  return RecordCreateFromPattern(PatternStringExact, type, options);
+}
+function FromNeverKey(_key, type, options) {
+  return RecordCreateFromPattern(PatternNeverExact, type, options);
+}
+function FromBooleanKey(_key, type, options) {
+  return Object2({ true: type, false: type }, options);
+}
+function FromIntegerKey(_key, type, options) {
+  return RecordCreateFromPattern(PatternNumberExact, type, options);
+}
+function FromNumberKey(_, type, options) {
+  return RecordCreateFromPattern(PatternNumberExact, type, options);
+}
+function Record(key, type, options = {}) {
+  return IsUnion(key) ? FromUnionKey(key.anyOf, type, options) : IsTemplateLiteral(key) ? FromTemplateLiteralKey(key, type, options) : IsLiteral(key) ? FromLiteralKey(key.const, type, options) : IsBoolean2(key) ? FromBooleanKey(key, type, options) : IsInteger(key) ? FromIntegerKey(key, type, options) : IsNumber3(key) ? FromNumberKey(key, type, options) : IsRegExp2(key) ? FromRegExpKey(key, type, options) : IsString2(key) ? FromStringKey(key, type, options) : IsAny(key) ? FromAnyKey(key, type, options) : IsNever(key) ? FromNeverKey(key, type, options) : Never(options);
+}
+function RecordPattern(record) {
+  return globalThis.Object.getOwnPropertyNames(record.patternProperties)[0];
+}
+function RecordKey2(type) {
+  const pattern = RecordPattern(type);
+  return pattern === PatternStringExact ? String2() : pattern === PatternNumberExact ? Number2() : String2({ pattern });
+}
+function RecordValue2(type) {
+  return type.patternProperties[RecordPattern(type)];
+}
+
+// node_modules/@sinclair/typebox/build/esm/type/instantiate/instantiate.mjs
+function FromConstructor2(args, type) {
+  type.parameters = FromTypes(args, type.parameters);
+  type.returns = FromType(args, type.returns);
+  return type;
+}
+function FromFunction2(args, type) {
+  type.parameters = FromTypes(args, type.parameters);
+  type.returns = FromType(args, type.returns);
+  return type;
+}
+function FromIntersect5(args, type) {
+  type.allOf = FromTypes(args, type.allOf);
+  return type;
+}
+function FromUnion7(args, type) {
+  type.anyOf = FromTypes(args, type.anyOf);
+  return type;
+}
+function FromTuple4(args, type) {
+  if (IsUndefined(type.items))
+    return type;
+  type.items = FromTypes(args, type.items);
+  return type;
+}
+function FromArray5(args, type) {
+  type.items = FromType(args, type.items);
+  return type;
+}
+function FromAsyncIterator2(args, type) {
+  type.items = FromType(args, type.items);
+  return type;
+}
+function FromIterator2(args, type) {
+  type.items = FromType(args, type.items);
+  return type;
+}
+function FromPromise3(args, type) {
+  type.item = FromType(args, type.item);
+  return type;
+}
+function FromObject2(args, type) {
+  const mappedProperties = FromProperties11(args, type.properties);
+  return { ...type, ...Object2(mappedProperties) };
+}
+function FromRecord2(args, type) {
+  const mappedKey = FromType(args, RecordKey2(type));
+  const mappedValue = FromType(args, RecordValue2(type));
+  const result = Record(mappedKey, mappedValue);
+  return { ...type, ...result };
+}
+function FromArgument(args, argument) {
+  return argument.index in args ? args[argument.index] : Unknown();
+}
+function FromProperty2(args, type) {
+  const isReadonly = IsReadonly(type);
+  const isOptional = IsOptional(type);
+  const mapped = FromType(args, type);
+  return isReadonly && isOptional ? ReadonlyOptional(mapped) : isReadonly && !isOptional ? Readonly(mapped) : !isReadonly && isOptional ? Optional(mapped) : mapped;
+}
+function FromProperties11(args, properties) {
+  return globalThis.Object.getOwnPropertyNames(properties).reduce((result, key) => {
+    return { ...result, [key]: FromProperty2(args, properties[key]) };
+  }, {});
+}
+function FromTypes(args, types) {
+  return types.map((type) => FromType(args, type));
+}
+function FromType(args, type) {
+  return IsConstructor(type) ? FromConstructor2(args, type) : IsFunction2(type) ? FromFunction2(args, type) : IsIntersect(type) ? FromIntersect5(args, type) : IsUnion(type) ? FromUnion7(args, type) : IsTuple(type) ? FromTuple4(args, type) : IsArray3(type) ? FromArray5(args, type) : IsAsyncIterator2(type) ? FromAsyncIterator2(args, type) : IsIterator2(type) ? FromIterator2(args, type) : IsPromise(type) ? FromPromise3(args, type) : IsObject3(type) ? FromObject2(args, type) : IsRecord(type) ? FromRecord2(args, type) : IsArgument(type) ? FromArgument(args, type) : type;
+}
+function Instantiate(type, args) {
+  return FromType(args, CloneType(type));
+}
+
+// node_modules/@sinclair/typebox/build/esm/type/integer/integer.mjs
+function Integer(options) {
+  return CreateType({ [Kind]: "Integer", type: "integer" }, options);
+}
+
+// node_modules/@sinclair/typebox/build/esm/type/intrinsic/intrinsic-from-mapped-key.mjs
+function MappedIntrinsicPropertyKey(K, M, options) {
+  return {
+    [K]: Intrinsic(Literal(K), M, Clone(options))
+  };
+}
+function MappedIntrinsicPropertyKeys(K, M, options) {
+  const result = K.reduce((Acc, L) => {
+    return { ...Acc, ...MappedIntrinsicPropertyKey(L, M, options) };
+  }, {});
+  return result;
+}
+function MappedIntrinsicProperties(T, M, options) {
+  return MappedIntrinsicPropertyKeys(T["keys"], M, options);
+}
+function IntrinsicFromMappedKey(T, M, options) {
+  const P = MappedIntrinsicProperties(T, M, options);
+  return MappedResult(P);
+}
+
+// node_modules/@sinclair/typebox/build/esm/type/intrinsic/intrinsic.mjs
+function ApplyUncapitalize(value) {
+  const [first, rest] = [value.slice(0, 1), value.slice(1)];
+  return [first.toLowerCase(), rest].join("");
+}
+function ApplyCapitalize(value) {
+  const [first, rest] = [value.slice(0, 1), value.slice(1)];
+  return [first.toUpperCase(), rest].join("");
+}
+function ApplyUppercase(value) {
+  return value.toUpperCase();
+}
+function ApplyLowercase(value) {
+  return value.toLowerCase();
+}
+function FromTemplateLiteral3(schema, mode, options) {
+  const expression = TemplateLiteralParseExact(schema.pattern);
+  const finite = IsTemplateLiteralExpressionFinite(expression);
+  if (!finite)
+    return { ...schema, pattern: FromLiteralValue(schema.pattern, mode) };
+  const strings = [...TemplateLiteralExpressionGenerate(expression)];
+  const literals = strings.map((value) => Literal(value));
+  const mapped = FromRest5(literals, mode);
+  const union = Union(mapped);
+  return TemplateLiteral([union], options);
+}
+function FromLiteralValue(value, mode) {
+  return typeof value === "string" ? mode === "Uncapitalize" ? ApplyUncapitalize(value) : mode === "Capitalize" ? ApplyCapitalize(value) : mode === "Uppercase" ? ApplyUppercase(value) : mode === "Lowercase" ? ApplyLowercase(value) : value : value.toString();
+}
+function FromRest5(T, M) {
+  return T.map((L) => Intrinsic(L, M));
+}
+function Intrinsic(schema, mode, options = {}) {
+  return IsMappedKey(schema) ? IntrinsicFromMappedKey(schema, mode, options) : IsTemplateLiteral(schema) ? FromTemplateLiteral3(schema, mode, options) : IsUnion(schema) ? Union(FromRest5(schema.anyOf, mode), options) : IsLiteral(schema) ? Literal(FromLiteralValue(schema.const, mode), options) : CreateType(schema, options);
+}
+
+// node_modules/@sinclair/typebox/build/esm/type/intrinsic/capitalize.mjs
+function Capitalize(T, options = {}) {
+  return Intrinsic(T, "Capitalize", options);
+}
+
+// node_modules/@sinclair/typebox/build/esm/type/intrinsic/lowercase.mjs
+function Lowercase(T, options = {}) {
+  return Intrinsic(T, "Lowercase", options);
+}
+
+// node_modules/@sinclair/typebox/build/esm/type/intrinsic/uncapitalize.mjs
+function Uncapitalize(T, options = {}) {
+  return Intrinsic(T, "Uncapitalize", options);
+}
+
+// node_modules/@sinclair/typebox/build/esm/type/intrinsic/uppercase.mjs
+function Uppercase(T, options = {}) {
+  return Intrinsic(T, "Uppercase", options);
+}
+
+// node_modules/@sinclair/typebox/build/esm/type/omit/omit-from-mapped-result.mjs
+function FromProperties12(properties, propertyKeys, options) {
+  const result = {};
+  for (const K2 of globalThis.Object.getOwnPropertyNames(properties))
+    result[K2] = Omit(properties[K2], propertyKeys, Clone(options));
+  return result;
+}
+function FromMappedResult9(mappedResult, propertyKeys, options) {
+  return FromProperties12(mappedResult.properties, propertyKeys, options);
+}
+function OmitFromMappedResult(mappedResult, propertyKeys, options) {
+  const properties = FromMappedResult9(mappedResult, propertyKeys, options);
+  return MappedResult(properties);
+}
+
+// node_modules/@sinclair/typebox/build/esm/type/omit/omit.mjs
+function FromIntersect6(types, propertyKeys) {
+  return types.map((type) => OmitResolve(type, propertyKeys));
+}
+function FromUnion8(types, propertyKeys) {
+  return types.map((type) => OmitResolve(type, propertyKeys));
+}
+function FromProperty3(properties, key) {
+  const { [key]: _, ...R } = properties;
+  return R;
+}
+function FromProperties13(properties, propertyKeys) {
+  return propertyKeys.reduce((T, K2) => FromProperty3(T, K2), properties);
+}
+function FromObject3(type, propertyKeys, properties) {
+  const options = Discard(type, [TransformKind, "$id", "required", "properties"]);
+  const mappedProperties = FromProperties13(properties, propertyKeys);
+  return Object2(mappedProperties, options);
+}
+function UnionFromPropertyKeys(propertyKeys) {
+  const result = propertyKeys.reduce((result2, key) => IsLiteralValue(key) ? [...result2, Literal(key)] : result2, []);
+  return Union(result);
+}
+function OmitResolve(type, propertyKeys) {
+  return IsIntersect(type) ? Intersect(FromIntersect6(type.allOf, propertyKeys)) : IsUnion(type) ? Union(FromUnion8(type.anyOf, propertyKeys)) : IsObject3(type) ? FromObject3(type, propertyKeys, type.properties) : Object2({});
+}
+function Omit(type, key, options) {
+  const typeKey = IsArray(key) ? UnionFromPropertyKeys(key) : key;
+  const propertyKeys = IsSchema(key) ? IndexPropertyKeys(key) : key;
+  const isTypeRef = IsRef(type);
+  const isKeyRef = IsRef(key);
+  return IsMappedResult(type) ? OmitFromMappedResult(type, propertyKeys, options) : IsMappedKey(key) ? OmitFromMappedKey(type, key, options) : isTypeRef && isKeyRef ? Computed("Omit", [type, typeKey], options) : !isTypeRef && isKeyRef ? Computed("Omit", [type, typeKey], options) : isTypeRef && !isKeyRef ? Computed("Omit", [type, typeKey], options) : CreateType({ ...OmitResolve(type, propertyKeys), ...options });
+}
+
+// node_modules/@sinclair/typebox/build/esm/type/omit/omit-from-mapped-key.mjs
+function FromPropertyKey2(type, key, options) {
+  return { [key]: Omit(type, [key], Clone(options)) };
+}
+function FromPropertyKeys2(type, propertyKeys, options) {
+  return propertyKeys.reduce((Acc, LK) => {
+    return { ...Acc, ...FromPropertyKey2(type, LK, options) };
+  }, {});
+}
+function FromMappedKey3(type, mappedKey, options) {
+  return FromPropertyKeys2(type, mappedKey.keys, options);
+}
+function OmitFromMappedKey(type, mappedKey, options) {
+  const properties = FromMappedKey3(type, mappedKey, options);
+  return MappedResult(properties);
+}
+
+// node_modules/@sinclair/typebox/build/esm/type/pick/pick-from-mapped-result.mjs
+function FromProperties14(properties, propertyKeys, options) {
+  const result = {};
+  for (const K2 of globalThis.Object.getOwnPropertyNames(properties))
+    result[K2] = Pick(properties[K2], propertyKeys, Clone(options));
+  return result;
+}
+function FromMappedResult10(mappedResult, propertyKeys, options) {
+  return FromProperties14(mappedResult.properties, propertyKeys, options);
+}
+function PickFromMappedResult(mappedResult, propertyKeys, options) {
+  const properties = FromMappedResult10(mappedResult, propertyKeys, options);
+  return MappedResult(properties);
+}
+
+// node_modules/@sinclair/typebox/build/esm/type/pick/pick.mjs
+function FromIntersect7(types, propertyKeys) {
+  return types.map((type) => PickResolve(type, propertyKeys));
+}
+function FromUnion9(types, propertyKeys) {
+  return types.map((type) => PickResolve(type, propertyKeys));
+}
+function FromProperties15(properties, propertyKeys) {
+  const result = {};
+  for (const K2 of propertyKeys)
+    if (K2 in properties)
+      result[K2] = properties[K2];
+  return result;
+}
+function FromObject4(Type, keys, properties) {
+  const options = Discard(Type, [TransformKind, "$id", "required", "properties"]);
+  const mappedProperties = FromProperties15(properties, keys);
+  return Object2(mappedProperties, options);
+}
+function UnionFromPropertyKeys2(propertyKeys) {
+  const result = propertyKeys.reduce((result2, key) => IsLiteralValue(key) ? [...result2, Literal(key)] : result2, []);
+  return Union(result);
+}
+function PickResolve(type, propertyKeys) {
+  return IsIntersect(type) ? Intersect(FromIntersect7(type.allOf, propertyKeys)) : IsUnion(type) ? Union(FromUnion9(type.anyOf, propertyKeys)) : IsObject3(type) ? FromObject4(type, propertyKeys, type.properties) : Object2({});
+}
+function Pick(type, key, options) {
+  const typeKey = IsArray(key) ? UnionFromPropertyKeys2(key) : key;
+  const propertyKeys = IsSchema(key) ? IndexPropertyKeys(key) : key;
+  const isTypeRef = IsRef(type);
+  const isKeyRef = IsRef(key);
+  return IsMappedResult(type) ? PickFromMappedResult(type, propertyKeys, options) : IsMappedKey(key) ? PickFromMappedKey(type, key, options) : isTypeRef && isKeyRef ? Computed("Pick", [type, typeKey], options) : !isTypeRef && isKeyRef ? Computed("Pick", [type, typeKey], options) : isTypeRef && !isKeyRef ? Computed("Pick", [type, typeKey], options) : CreateType({ ...PickResolve(type, propertyKeys), ...options });
+}
+
+// node_modules/@sinclair/typebox/build/esm/type/pick/pick-from-mapped-key.mjs
+function FromPropertyKey3(type, key, options) {
+  return {
+    [key]: Pick(type, [key], Clone(options))
+  };
+}
+function FromPropertyKeys3(type, propertyKeys, options) {
+  return propertyKeys.reduce((result, leftKey) => {
+    return { ...result, ...FromPropertyKey3(type, leftKey, options) };
+  }, {});
+}
+function FromMappedKey4(type, mappedKey, options) {
+  return FromPropertyKeys3(type, mappedKey.keys, options);
+}
+function PickFromMappedKey(type, mappedKey, options) {
+  const properties = FromMappedKey4(type, mappedKey, options);
+  return MappedResult(properties);
+}
+
+// node_modules/@sinclair/typebox/build/esm/type/partial/partial.mjs
+function FromComputed3(target, parameters) {
+  return Computed("Partial", [Computed(target, parameters)]);
+}
+function FromRef3($ref) {
+  return Computed("Partial", [Ref($ref)]);
+}
+function FromProperties16(properties) {
+  const partialProperties = {};
+  for (const K of globalThis.Object.getOwnPropertyNames(properties))
+    partialProperties[K] = Optional(properties[K]);
+  return partialProperties;
+}
+function FromObject5(type, properties) {
+  const options = Discard(type, [TransformKind, "$id", "required", "properties"]);
+  const mappedProperties = FromProperties16(properties);
+  return Object2(mappedProperties, options);
+}
+function FromRest6(types) {
+  return types.map((type) => PartialResolve(type));
+}
+function PartialResolve(type) {
+  return IsComputed(type) ? FromComputed3(type.target, type.parameters) : IsRef(type) ? FromRef3(type.$ref) : IsIntersect(type) ? Intersect(FromRest6(type.allOf)) : IsUnion(type) ? Union(FromRest6(type.anyOf)) : IsObject3(type) ? FromObject5(type, type.properties) : IsBigInt2(type) ? type : IsBoolean2(type) ? type : IsInteger(type) ? type : IsLiteral(type) ? type : IsNull2(type) ? type : IsNumber3(type) ? type : IsString2(type) ? type : IsSymbol2(type) ? type : IsUndefined3(type) ? type : Object2({});
+}
+function Partial(type, options) {
+  if (IsMappedResult(type)) {
+    return PartialFromMappedResult(type, options);
+  } else {
+    return CreateType({ ...PartialResolve(type), ...options });
+  }
+}
+
+// node_modules/@sinclair/typebox/build/esm/type/partial/partial-from-mapped-result.mjs
+function FromProperties17(K, options) {
+  const Acc = {};
+  for (const K2 of globalThis.Object.getOwnPropertyNames(K))
+    Acc[K2] = Partial(K[K2], Clone(options));
+  return Acc;
+}
+function FromMappedResult11(R, options) {
+  return FromProperties17(R.properties, options);
+}
+function PartialFromMappedResult(R, options) {
+  const P = FromMappedResult11(R, options);
+  return MappedResult(P);
+}
+
+// node_modules/@sinclair/typebox/build/esm/type/required/required.mjs
+function FromComputed4(target, parameters) {
+  return Computed("Required", [Computed(target, parameters)]);
+}
+function FromRef4($ref) {
+  return Computed("Required", [Ref($ref)]);
+}
+function FromProperties18(properties) {
+  const requiredProperties = {};
+  for (const K of globalThis.Object.getOwnPropertyNames(properties))
+    requiredProperties[K] = Discard(properties[K], [OptionalKind]);
+  return requiredProperties;
+}
+function FromObject6(type, properties) {
+  const options = Discard(type, [TransformKind, "$id", "required", "properties"]);
+  const mappedProperties = FromProperties18(properties);
+  return Object2(mappedProperties, options);
+}
+function FromRest7(types) {
+  return types.map((type) => RequiredResolve(type));
+}
+function RequiredResolve(type) {
+  return IsComputed(type) ? FromComputed4(type.target, type.parameters) : IsRef(type) ? FromRef4(type.$ref) : IsIntersect(type) ? Intersect(FromRest7(type.allOf)) : IsUnion(type) ? Union(FromRest7(type.anyOf)) : IsObject3(type) ? FromObject6(type, type.properties) : IsBigInt2(type) ? type : IsBoolean2(type) ? type : IsInteger(type) ? type : IsLiteral(type) ? type : IsNull2(type) ? type : IsNumber3(type) ? type : IsString2(type) ? type : IsSymbol2(type) ? type : IsUndefined3(type) ? type : Object2({});
+}
+function Required(type, options) {
+  if (IsMappedResult(type)) {
+    return RequiredFromMappedResult(type, options);
+  } else {
+    return CreateType({ ...RequiredResolve(type), ...options });
+  }
+}
+
+// node_modules/@sinclair/typebox/build/esm/type/required/required-from-mapped-result.mjs
+function FromProperties19(P, options) {
+  const Acc = {};
+  for (const K2 of globalThis.Object.getOwnPropertyNames(P))
+    Acc[K2] = Required(P[K2], options);
+  return Acc;
+}
+function FromMappedResult12(R, options) {
+  return FromProperties19(R.properties, options);
+}
+function RequiredFromMappedResult(R, options) {
+  const P = FromMappedResult12(R, options);
+  return MappedResult(P);
+}
+
+// node_modules/@sinclair/typebox/build/esm/type/module/compute.mjs
+function DereferenceParameters(moduleProperties, types) {
+  return types.map((type) => {
+    return IsRef(type) ? Dereference(moduleProperties, type.$ref) : FromType2(moduleProperties, type);
+  });
+}
+function Dereference(moduleProperties, ref) {
+  return ref in moduleProperties ? IsRef(moduleProperties[ref]) ? Dereference(moduleProperties, moduleProperties[ref].$ref) : FromType2(moduleProperties, moduleProperties[ref]) : Never();
+}
+function FromAwaited(parameters) {
+  return Awaited(parameters[0]);
+}
+function FromIndex(parameters) {
+  return Index(parameters[0], parameters[1]);
+}
+function FromKeyOf(parameters) {
+  return KeyOf(parameters[0]);
+}
+function FromPartial(parameters) {
+  return Partial(parameters[0]);
+}
+function FromOmit(parameters) {
+  return Omit(parameters[0], parameters[1]);
+}
+function FromPick(parameters) {
+  return Pick(parameters[0], parameters[1]);
+}
+function FromRequired(parameters) {
+  return Required(parameters[0]);
+}
+function FromComputed5(moduleProperties, target, parameters) {
+  const dereferenced = DereferenceParameters(moduleProperties, parameters);
+  return target === "Awaited" ? FromAwaited(dereferenced) : target === "Index" ? FromIndex(dereferenced) : target === "KeyOf" ? FromKeyOf(dereferenced) : target === "Partial" ? FromPartial(dereferenced) : target === "Omit" ? FromOmit(dereferenced) : target === "Pick" ? FromPick(dereferenced) : target === "Required" ? FromRequired(dereferenced) : Never();
+}
+function FromArray6(moduleProperties, type) {
+  return Array2(FromType2(moduleProperties, type));
+}
+function FromAsyncIterator3(moduleProperties, type) {
+  return AsyncIterator(FromType2(moduleProperties, type));
+}
+function FromConstructor3(moduleProperties, parameters, instanceType) {
+  return Constructor(FromTypes2(moduleProperties, parameters), FromType2(moduleProperties, instanceType));
+}
+function FromFunction3(moduleProperties, parameters, returnType) {
+  return Function(FromTypes2(moduleProperties, parameters), FromType2(moduleProperties, returnType));
+}
+function FromIntersect8(moduleProperties, types) {
+  return Intersect(FromTypes2(moduleProperties, types));
+}
+function FromIterator3(moduleProperties, type) {
+  return Iterator(FromType2(moduleProperties, type));
+}
+function FromObject7(moduleProperties, properties) {
+  return Object2(globalThis.Object.keys(properties).reduce((result, key) => {
+    return { ...result, [key]: FromType2(moduleProperties, properties[key]) };
+  }, {}));
+}
+function FromRecord3(moduleProperties, type) {
+  const [value, pattern] = [FromType2(moduleProperties, RecordValue2(type)), RecordPattern(type)];
+  const result = CloneType(type);
+  result.patternProperties[pattern] = value;
+  return result;
+}
+function FromTransform(moduleProperties, transform) {
+  return IsRef(transform) ? { ...Dereference(moduleProperties, transform.$ref), [TransformKind]: transform[TransformKind] } : transform;
+}
+function FromTuple5(moduleProperties, types) {
+  return Tuple(FromTypes2(moduleProperties, types));
+}
+function FromUnion10(moduleProperties, types) {
+  return Union(FromTypes2(moduleProperties, types));
+}
+function FromTypes2(moduleProperties, types) {
+  return types.map((type) => FromType2(moduleProperties, type));
+}
+function FromType2(moduleProperties, type) {
+  return IsOptional(type) ? CreateType(FromType2(moduleProperties, Discard(type, [OptionalKind])), type) : IsReadonly(type) ? CreateType(FromType2(moduleProperties, Discard(type, [ReadonlyKind])), type) : IsTransform(type) ? CreateType(FromTransform(moduleProperties, type), type) : IsArray3(type) ? CreateType(FromArray6(moduleProperties, type.items), type) : IsAsyncIterator2(type) ? CreateType(FromAsyncIterator3(moduleProperties, type.items), type) : IsComputed(type) ? CreateType(FromComputed5(moduleProperties, type.target, type.parameters)) : IsConstructor(type) ? CreateType(FromConstructor3(moduleProperties, type.parameters, type.returns), type) : IsFunction2(type) ? CreateType(FromFunction3(moduleProperties, type.parameters, type.returns), type) : IsIntersect(type) ? CreateType(FromIntersect8(moduleProperties, type.allOf), type) : IsIterator2(type) ? CreateType(FromIterator3(moduleProperties, type.items), type) : IsObject3(type) ? CreateType(FromObject7(moduleProperties, type.properties), type) : IsRecord(type) ? CreateType(FromRecord3(moduleProperties, type)) : IsTuple(type) ? CreateType(FromTuple5(moduleProperties, type.items || []), type) : IsUnion(type) ? CreateType(FromUnion10(moduleProperties, type.anyOf), type) : type;
+}
+function ComputeType(moduleProperties, key) {
+  return key in moduleProperties ? FromType2(moduleProperties, moduleProperties[key]) : Never();
+}
+function ComputeModuleProperties(moduleProperties) {
+  return globalThis.Object.getOwnPropertyNames(moduleProperties).reduce((result, key) => {
+    return { ...result, [key]: ComputeType(moduleProperties, key) };
+  }, {});
+}
+
+// node_modules/@sinclair/typebox/build/esm/type/module/module.mjs
+class TModule {
+  constructor($defs) {
+    const computed = ComputeModuleProperties($defs);
+    const identified = this.WithIdentifiers(computed);
+    this.$defs = identified;
+  }
+  Import(key, options) {
+    const $defs = { ...this.$defs, [key]: CreateType(this.$defs[key], options) };
+    return CreateType({ [Kind]: "Import", $defs, $ref: key });
+  }
+  WithIdentifiers($defs) {
+    return globalThis.Object.getOwnPropertyNames($defs).reduce((result, key) => {
+      return { ...result, [key]: { ...$defs[key], $id: key } };
+    }, {});
+  }
+}
+function Module(properties) {
+  return new TModule(properties);
+}
+
+// node_modules/@sinclair/typebox/build/esm/type/not/not.mjs
+function Not(type, options) {
+  return CreateType({ [Kind]: "Not", not: type }, options);
+}
+
+// node_modules/@sinclair/typebox/build/esm/type/parameters/parameters.mjs
+function Parameters(schema, options) {
+  return IsFunction2(schema) ? Tuple(schema.parameters, options) : Never();
+}
+
+// node_modules/@sinclair/typebox/build/esm/type/recursive/recursive.mjs
+var Ordinal = 0;
+function Recursive(callback, options = {}) {
+  if (IsUndefined(options.$id))
+    options.$id = `T${Ordinal++}`;
+  const thisType = CloneType(callback({ [Kind]: "This", $ref: `${options.$id}` }));
+  thisType.$id = options.$id;
+  return CreateType({ [Hint]: "Recursive", ...thisType }, options);
+}
+
+// node_modules/@sinclair/typebox/build/esm/type/regexp/regexp.mjs
+function RegExp2(unresolved, options) {
+  const expr = IsString(unresolved) ? new globalThis.RegExp(unresolved) : unresolved;
+  return CreateType({ [Kind]: "RegExp", type: "RegExp", source: expr.source, flags: expr.flags }, options);
+}
+
+// node_modules/@sinclair/typebox/build/esm/type/rest/rest.mjs
+function RestResolve(T) {
+  return IsIntersect(T) ? T.allOf : IsUnion(T) ? T.anyOf : IsTuple(T) ? T.items ?? [] : [];
+}
+function Rest(T) {
+  return RestResolve(T);
+}
+
+// node_modules/@sinclair/typebox/build/esm/type/return-type/return-type.mjs
+function ReturnType(schema, options) {
+  return IsFunction2(schema) ? CreateType(schema.returns, options) : Never(options);
+}
+
+// node_modules/@sinclair/typebox/build/esm/type/transform/transform.mjs
+class TransformDecodeBuilder {
+  constructor(schema) {
+    this.schema = schema;
+  }
+  Decode(decode) {
+    return new TransformEncodeBuilder(this.schema, decode);
+  }
+}
+
+class TransformEncodeBuilder {
+  constructor(schema, decode) {
+    this.schema = schema;
+    this.decode = decode;
+  }
+  EncodeTransform(encode, schema) {
+    const Encode = (value) => schema[TransformKind].Encode(encode(value));
+    const Decode = (value) => this.decode(schema[TransformKind].Decode(value));
+    const Codec = { Encode, Decode };
+    return { ...schema, [TransformKind]: Codec };
+  }
+  EncodeSchema(encode, schema) {
+    const Codec = { Decode: this.decode, Encode: encode };
+    return { ...schema, [TransformKind]: Codec };
+  }
+  Encode(encode) {
+    return IsTransform(this.schema) ? this.EncodeTransform(encode, this.schema) : this.EncodeSchema(encode, this.schema);
+  }
+}
+function Transform(schema) {
+  return new TransformDecodeBuilder(schema);
+}
+
+// node_modules/@sinclair/typebox/build/esm/type/unsafe/unsafe.mjs
+function Unsafe(options = {}) {
+  return CreateType({ [Kind]: options[Kind] ?? "Unsafe" }, options);
+}
+
+// node_modules/@sinclair/typebox/build/esm/type/void/void.mjs
+function Void(options) {
+  return CreateType({ [Kind]: "Void", type: "void" }, options);
+}
+
+// node_modules/@sinclair/typebox/build/esm/type/type/type.mjs
+var exports_type2 = {};
+__export(exports_type2, {
+  Void: () => Void,
+  Uppercase: () => Uppercase,
+  Unsafe: () => Unsafe,
+  Unknown: () => Unknown,
+  Union: () => Union,
+  Undefined: () => Undefined,
+  Uncapitalize: () => Uncapitalize,
+  Uint8Array: () => Uint8Array2,
+  Tuple: () => Tuple,
+  Transform: () => Transform,
+  TemplateLiteral: () => TemplateLiteral,
+  Symbol: () => Symbol2,
+  String: () => String2,
+  ReturnType: () => ReturnType,
+  Rest: () => Rest,
+  Required: () => Required,
+  RegExp: () => RegExp2,
+  Ref: () => Ref,
+  Recursive: () => Recursive,
+  Record: () => Record,
+  ReadonlyOptional: () => ReadonlyOptional,
+  Readonly: () => Readonly,
+  Promise: () => Promise2,
+  Pick: () => Pick,
+  Partial: () => Partial,
+  Parameters: () => Parameters,
+  Optional: () => Optional,
+  Omit: () => Omit,
+  Object: () => Object2,
+  Number: () => Number2,
+  Null: () => Null,
+  Not: () => Not,
+  Never: () => Never,
+  Module: () => Module,
+  Mapped: () => Mapped,
+  Lowercase: () => Lowercase,
+  Literal: () => Literal,
+  KeyOf: () => KeyOf,
+  Iterator: () => Iterator,
+  Intersect: () => Intersect,
+  Integer: () => Integer,
+  Instantiate: () => Instantiate,
+  InstanceType: () => InstanceType,
+  Index: () => Index,
+  Function: () => Function,
+  Extract: () => Extract,
+  Extends: () => Extends,
+  Exclude: () => Exclude,
+  Enum: () => Enum,
+  Date: () => Date2,
+  ConstructorParameters: () => ConstructorParameters,
+  Constructor: () => Constructor,
+  Const: () => Const,
+  Composite: () => Composite,
+  Capitalize: () => Capitalize,
+  Boolean: () => Boolean,
+  BigInt: () => BigInt,
+  Awaited: () => Awaited,
+  AsyncIterator: () => AsyncIterator,
+  Array: () => Array2,
+  Argument: () => Argument,
+  Any: () => Any
+});
+
+// node_modules/@sinclair/typebox/build/esm/type/type/index.mjs
+var Type = exports_type2;
+
+// src/pi/pi-tools.ts
+function createPiTools(bridge) {
+  return [
+    tool("mason_list", "mason list", "List Mason packages", listSchema(), async (input, options) => {
+      const args = validateObject(input);
+      const argv = ["list"];
+      if (args.installed === true)
+        argv.push("--installed");
+      if (args.outdated === true)
+        argv.push("--outdated");
+      return result(await bridge.run(argv, options));
+    }),
+    tool("mason_search", "mason search", "Search Mason Registry packages", searchSchema(), async (input, options) => {
+      const args = validateObject(input);
+      const argv = ["search"];
+      if (typeof args.query === "string" && args.query.length > 0)
+        argv.push(args.query);
+      if (typeof args.category === "string" && args.category.length > 0)
+        argv.push("--category", args.category);
+      if (typeof args.language === "string" && args.language.length > 0)
+        argv.push("--language", args.language);
+      return result(await bridge.run(argv, options));
+    }),
+    tool("mason_install", "mason install", "Install Mason packages", installSchema(), async (input, options) => {
+      const args = validateObject(input);
+      const packages = validateStringArray(args.packages, "packages");
+      const argv = ["install", ...packages];
+      if (typeof args.registry === "string" && args.registry.length > 0)
+        argv.push("--registry", args.registry);
+      if (args.allow_build_scripts === true)
+        argv.push("--allow-build-scripts");
+      return result(await bridge.run(argv, options));
+    }),
+    tool("mason_uninstall", "mason uninstall", "Uninstall Mason packages", uninstallSchema(), async (input, options) => {
+      const args = validateObject(input);
+      const packages = validateStringArray(args.packages, "packages");
+      return result(await bridge.run(["uninstall", ...packages], options));
+    }),
+    tool("mason_update", "mason update", "Update Mason packages", updateSchema(), async (input, options) => {
+      const args = validateObject(input);
+      const packages = args.packages === undefined || Array.isArray(args.packages) && args.packages.length === 0 ? [] : validateStringArray(args.packages, "packages");
+      const argv = ["update", ...packages];
+      if (typeof args.registry === "string" && args.registry.length > 0)
+        argv.push("--registry", args.registry);
+      if (args.allow_build_scripts === true)
+        argv.push("--allow-build-scripts");
+      return result(await bridge.run(argv, options));
+    }),
+    tool("mason_which", "mason which", "Resolve an installed executable", whichSchema(), async (input, options) => {
+      const args = validateObject(input);
+      if (typeof args.executable !== "string" || args.executable.length === 0)
+        throw new Error("executable must be a non-empty string");
+      return result(await bridge.run(["which", args.executable], options));
+    }),
+    tool("mason_env", "mason env", "Print PATH setup for shells", envSchema(), async (input, options) => {
+      const args = validateObject(input);
+      const shell = typeof args.shell === "string" && args.shell.length > 0 ? args.shell : "json";
+      return result(await bridge.run(["env", "--shell", shell], options));
+    })
+  ];
+}
+function registerPiTools(ctx, bridge) {
+  const tools = createPiTools(bridge);
+  for (const definition of tools) {
+    registerTool(ctx, definition);
+  }
+  return tools;
+}
+function tool(name, label, description, parameters, executor) {
+  return {
+    name,
+    label,
+    description,
+    promptSnippet: description,
+    parameters,
+    execute(_toolCallId, params, signal) {
+      return signal ? executor(params, { signal }) : executor(params);
+    }
+  };
+}
+function registerTool(ctx, definition) {
+  const anyCtx = ctx;
+  if (typeof anyCtx.registerTool === "function") {
+    anyCtx.registerTool(definition);
+  } else if (typeof anyCtx.tools?.registerTool === "function") {
+    anyCtx.tools.registerTool(definition);
+  } else if (typeof anyCtx.tools?.register === "function") {
+    anyCtx.tools.register(definition);
+  }
+}
+function result(details) {
+  return { content: [{ type: "text", text: JSON.stringify(details, null, 2) }], details };
+}
+function validateObject(input) {
+  if (input === undefined || input === null)
+    return {};
+  if (typeof input !== "object" || Array.isArray(input))
+    throw new Error("tool input must be an object");
+  return input;
+}
+function validateStringArray(value, name) {
+  if (!Array.isArray(value) || value.length === 0 || value.some((item) => typeof item !== "string" || item.length === 0)) {
+    throw new Error(`${name} must be a non-empty string array`);
+  }
+  return value;
+}
+function listSchema() {
+  return Type.Object({ installed: Type.Optional(Type.Boolean()), outdated: Type.Optional(Type.Boolean()) }, { additionalProperties: false });
+}
+function searchSchema() {
+  return Type.Object({ query: Type.Optional(Type.String()), category: Type.Optional(Type.String()), language: Type.Optional(Type.String()) }, { additionalProperties: false });
+}
+function installSchema() {
+  return Type.Object({ packages: Type.Array(Type.String(), { minItems: 1 }), registry: Type.Optional(Type.String()), allow_build_scripts: Type.Optional(Type.Boolean()) }, { additionalProperties: false, required: ["packages"] });
+}
+function uninstallSchema() {
+  return Type.Object({ packages: Type.Array(Type.String(), { minItems: 1 }) }, { additionalProperties: false, required: ["packages"] });
+}
+function updateSchema() {
+  return Type.Object({ packages: Type.Optional(Type.Array(Type.String())), registry: Type.Optional(Type.String()), allow_build_scripts: Type.Optional(Type.Boolean()) }, { additionalProperties: false });
+}
+function whichSchema() {
+  return Type.Object({ executable: Type.String() }, { additionalProperties: false, required: ["executable"] });
+}
+function envSchema() {
+  return Type.Object({ shell: Type.Optional(Type.Union([Type.Literal("bash"), Type.Literal("zsh"), Type.Literal("fish"), Type.Literal("powershell"), Type.Literal("cmd"), Type.Literal("json")])) }, { additionalProperties: false });
+}
+
+// src/pi/path-env.ts
+import { mkdirSync } from "fs";
+import { join as join2, delimiter } from "path";
+function masonDataDir(env = process.env) {
+  const xdgDataHome = env.XDG_DATA_HOME ?? (env.LOCALAPPDATA ? env.LOCALAPPDATA : undefined);
+  if (env.MASON4AGENTS_DATA_HOME && env.MASON4AGENTS_DATA_HOME.length > 0) {
+    const p = env.MASON4AGENTS_DATA_HOME;
+    if (!p.startsWith(".") && (p.startsWith("/") || /^[A-Za-z]:[/\\]/.test(p))) {
+      return join2(p, "mason4agents");
+    }
+  }
+  if (xdgDataHome && xdgDataHome.length > 0) {
+    if (!xdgDataHome.startsWith(".") && (xdgDataHome.startsWith("/") || /^[A-Za-z]:[/\\]/.test(xdgDataHome))) {
+      return join2(xdgDataHome, "mason4agents");
+    }
+  }
+  const home = env.HOME ?? env.USERPROFILE;
+  if (!home) {
+    throw new Error("HOME or USERPROFILE is required to resolve mason4agents data directory");
+  }
+  return join2(home, ".local", "share", "mason4agents");
+}
+function ensureMasonBinOnPath(env = process.env) {
+  const dataDir = masonDataDir(env);
+  const binDir = join2(dataDir, "bin");
+  mkdirSync(binDir, { recursive: true });
+  const current = env.PATH;
+  if (current === undefined) {
+    env.PATH = binDir;
+    return { dataDir, binDir, changed: true, path: binDir };
+  }
+  const parts = current === "" ? [""] : current.split(delimiter);
+  const alreadyFirst = parts[0] === binDir;
+  const nextParts = alreadyFirst ? parts : [binDir, ...parts.filter((part) => part !== binDir)];
+  const next = nextParts.join(delimiter);
+  if (!alreadyFirst) {
+    env.PATH = next;
+  }
+  return { dataDir, binDir, changed: !alreadyFirst, path: env.PATH ?? next };
+}
+
+// src/pi/extension.ts
+async function activate(ctx, bridge = createCliBridge()) {
+  const pathInfo = ensureMasonBinOnPath();
+  const apiCtx = ctx;
+  registerCommand(ctx, "mason", "Open mason4agents package manager", async (args, commandCtx) => {
+    try {
+      const input = typeof args === "string" ? args.trim() : "";
+      const shownInUi = canShowCustomUi(commandCtx);
+      if (input.length === 0) {
+        const panel = await openMasonPanel(commandCtx, bridge);
+        if (!shownInUi) {
+          publishMessage(apiCtx, "mason4agents", panel.render());
+        }
+        return;
+      }
+      const model = await executeMasonCommand(input, bridge);
+      if (shownInUi) {
+        await showDisplayPanel(commandCtx, model);
+      } else {
+        publishMessage(apiCtx, "mason4agents", renderDisplayText(model));
+      }
+    } catch (err) {
+      reportCommandError(commandCtx, apiCtx, "mason", err);
+    }
+  });
+  registerCommand(ctx, "mason-doctor", "Run mason4agents doctor", async (_args, commandCtx) => {
+    try {
+      const model = await executeMasonCommand("doctor", bridge);
+      if (canShowCustomUi(commandCtx)) {
+        await showDisplayPanel(commandCtx, model);
+      } else {
+        publishMessage(apiCtx, "mason4agents-doctor", renderDisplayText(model));
+      }
+    } catch (err) {
+      reportCommandError(commandCtx, apiCtx, "mason-doctor", err);
+    }
+  });
+  const tools = registerPiTools(ctx, bridge);
+  registerSessionStart(ctx, () => ensureMasonBinOnPath());
+  return { name: "mason4agents", binDir: pathInfo.binDir, tools };
+}
+var extension_default = activate;
+function registerCommand(ctx, name, description, handler) {
+  const anyCtx = ctx;
+  const options = { description, handler };
+  if (typeof anyCtx.registerCommand === "function") {
+    anyCtx.registerCommand(name, options);
+  } else if (typeof anyCtx.commands?.registerCommand === "function") {
+    anyCtx.commands.registerCommand(name, options);
+  } else if (typeof anyCtx.commands?.register === "function") {
+    anyCtx.commands.register(name, options);
+  } else if (typeof anyCtx.command?.register === "function") {
+    anyCtx.command.register(name, options);
+  }
+}
+function canShowCustomUi(ctx) {
+  const anyCtx = ctx;
+  return anyCtx.hasUI !== false && typeof anyCtx.ui?.custom === "function";
+}
+async function showDisplayPanel(ctx, model) {
+  const anyCtx = ctx;
+  await anyCtx.ui?.custom?.((tui, _theme, _keybindings, done) => {
+    const state = { filter: "", filterDraft: "", editingFilter: false, scroll: 0 };
+    return {
+      render(width) {
+        return renderDisplayPanel(model, state, width);
+      },
+      handleInput(key) {
+        if (state.editingFilter) {
+          handleFilterInput(state, key);
+          requestTuiRender2(tui);
+          return;
+        }
+        if (isCloseKey2(key)) {
+          done(undefined);
+          return;
+        }
+        if (key === "/" && modelSupportsFiltering(model)) {
+          state.filterDraft = state.filter;
+          state.editingFilter = true;
+          requestTuiRender2(tui);
+          return;
+        }
+        if (isScrollDownKey2(key))
+          state.scroll += 1;
+        if (isScrollUpKey2(key))
+          state.scroll = Math.max(0, state.scroll - 1);
+        if (isPageDownKey2(key))
+          state.scroll += 10;
+        if (isPageUpKey2(key))
+          state.scroll = Math.max(0, state.scroll - 10);
+        requestTuiRender2(tui);
+      },
+      invalidate() {}
+    };
+  });
+}
+function publishMessage(ctx, customType, content) {
+  const anyCtx = ctx;
+  if (typeof anyCtx.sendMessage === "function") {
+    anyCtx.sendMessage({ customType, content, display: true }, { deliverAs: "nextTurn" });
+  }
+}
+function reportCommandError(commandCtx, apiCtx, command2, err) {
+  const msg = err instanceof Error ? err.message : String(err);
+  const anyCommandCtx = commandCtx;
+  if (typeof anyCommandCtx.ui?.notify === "function") {
+    anyCommandCtx.ui.notify(`${command2}: ${msg}`, "error");
+  } else {
+    publishMessage(apiCtx, `mason4agents-${command2}-error`, `${command2}: ${msg}`);
+  }
+}
+function renderDisplayPanel(model, state, width) {
+  const safeWidth = Math.max(1, Math.floor(width));
+  const lines = renderDisplay(model, { width: safeWidth, filter: state.filter, scroll: state.scroll });
+  if (state.editingFilter) {
+    lines.splice(1, 0, truncateToWidth3(`filter> ${state.filterDraft}`, safeWidth));
+  }
+  return lines.map((line) => truncateToWidth3(line, safeWidth));
+}
+function handleFilterInput(state, key) {
+  if (key === "\r" || key === `
+` || key === "enter" || key === "return") {
+    state.filter = state.filterDraft.trim();
+    state.scroll = 0;
+    state.editingFilter = false;
+    return;
+  }
+  if (key === "\x1B" || key === "escape" || key === "esc") {
+    state.editingFilter = false;
+    return;
+  }
+  if (key === "\b" || key === "\x7F" || key === "backspace") {
+    state.filterDraft = state.filterDraft.slice(0, -1);
+    return;
+  }
+  if (key.length === 1 && key >= " ")
+    state.filterDraft += key;
+}
+function truncateToWidth3(value, width) {
+  if (value.length <= width)
+    return value;
+  if (width <= 1)
+    return value.slice(0, width);
+  return `${value.slice(0, width - 1)}\u2026`;
+}
+function isCloseKey2(key) {
+  return key === "q" || key === "\x1B" || key === "escape" || key === "esc";
+}
+function isScrollDownKey2(key) {
+  return key === "down" || key === "j" || key === "\x1B[B";
+}
+function isScrollUpKey2(key) {
+  return key === "up" || key === "k" || key === "\x1B[A";
+}
+function isPageDownKey2(key) {
+  return key === "pagedown" || key === "\x1B[6~";
+}
+function isPageUpKey2(key) {
+  return key === "pageup" || key === "\x1B[5~";
+}
+function requestTuiRender2(tui) {
+  if (typeof tui !== "object" || tui === null)
+    return;
+  const candidate = tui;
+  if (typeof candidate.requestRender === "function") {
+    candidate.requestRender(true);
+  } else if (typeof candidate.invalidate === "function") {
+    candidate.invalidate();
+  }
+}
+function registerSessionStart(ctx, handler) {
+  const anyCtx = ctx;
+  if (typeof anyCtx.events?.on === "function") {
+    anyCtx.events.on("session_start", handler);
+  } else if (typeof anyCtx.on === "function") {
+    anyCtx.on("session_start", handler);
+  }
+}
+export {
+  extension_default as default,
+  activate
+};