@scalar/cli 2.1.0 → 2.5.1

package/chunks/action-LA6KVAXQ.js

@@ -0,0 +1,374 @@
+import { createRequire as $$cR } from "node:module"; const require = $$cR(import.meta.url);
+import {
+  getFileOrUrl,
+  isAsyncApiContent
+} from "./chunk-24WAOKGG.js";
+import {
+  err,
+  ok
+} from "./chunk-P7H7GY5A.js";
+import {
+  require_dist
+} from "./chunk-K74E42RV.js";
+import "./chunk-CISTON3A.js";
+import "./chunk-Q7DOQHZN.js";
+import "./chunk-4ORL4MST.js";
+import {
+  output
+} from "./chunk-T5HJUAWB.js";
+import "./chunk-GSGZHE26.js";
+import "./chunk-IKT5F47M.js";
+import {
+  __toESM
+} from "./chunk-3MZYUBJ6.js";
+
+// src/domains/document/lint/action.ts
+import as from "ansis";
+
+// ../../packages/api-document-lint/dist/constants.js
+var DEFAULT_RULESET = `extends: spectral:oas
+rules: {}`;
+var ASYNCAPI_RULESET = `extends: spectral:asyncapi
+rules: {}`;
+
+// ../../packages/api-document-lint/dist/default-ruleset.js
+function isAsyncApiContent2(content) {
+  const head = content.slice(0, 500);
+  if (head.includes('"asyncapi"')) {
+    return true;
+  }
+  return head.split("\n").some((line) => /^asyncapi\s*:/.test(line.trimStart()));
+}
+function defaultRulesetFor(content) {
+  return isAsyncApiContent2(content) ? ASYNCAPI_RULESET : DEFAULT_RULESET;
+}
+
+// ../../packages/api-document-lint/dist/run-spectral.js
+import spectralCore from "@stoplight/spectral-core";
+import { bundleAndLoadRuleset } from "@stoplight/spectral-ruleset-bundler/with-loader";
+import "@stoplight/spectral-rulesets";
+var { Spectral } = spectralCore;
+async function runSpectral(input) {
+  const rulesetSource = input.ruleset && input.ruleset.trim().length > 0 ? input.ruleset : defaultRulesetFor(input.document);
+  const ruleset = await loadRuleset(rulesetSource);
+  if (!ruleset.ok) {
+    return ruleset;
+  }
+  const spectral = new Spectral();
+  spectral.setRuleset(ruleset.data);
+  const diagnostics = await spectral.run(input.document).catch((error) => error instanceof Error ? error : new Error(String(error)));
+  if (diagnostics instanceof Error) {
+    return err(`Spectral failed to lint the document \u2014 ${diagnostics.message}`);
+  }
+  return ok(diagnostics);
+}
+async function loadRuleset(source) {
+  const ruleset = await bundleAndLoadRuleset("/.spectral.yaml", {
+    fs: {
+      promises: {
+        // @ts-expect-error The loader only ever reads our single virtual file.
+        async readFile() {
+          return source;
+        }
+      }
+    },
+    format: "esm"
+  }).catch((error) => error instanceof Error ? error : new Error(String(error)));
+  if (ruleset instanceof Error) {
+    return err(`Failed to load ruleset \u2014 ${ruleset.message}`);
+  }
+  return ok(ruleset);
+}
+
+// ../../packages/api-document-lint/dist/run-vacuum.js
+import { execFile } from "node:child_process";
+import { mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join as join2 } from "node:path";
+import { promisify } from "node:util";
+
+// ../../packages/api-document-lint/dist/normalize-diagnostics.js
+var EMPTY_RANGE = {
+  start: { line: 0, character: 0 },
+  end: { line: 0, character: 0 }
+};
+function normalizeDiagnostics(raw) {
+  if (!Array.isArray(raw)) {
+    return [];
+  }
+  return raw.filter(isObject).map((item) => {
+    const source = item.source;
+    return {
+      code: isCode(item.code) ? item.code : "",
+      message: typeof item.message === "string" ? item.message : "",
+      severity: normalizeSeverity(item.severity),
+      path: Array.isArray(item.path) ? item.path.filter(isSegment) : [],
+      range: normalizeRange(item.range),
+      ...typeof source === "string" ? { source } : {}
+    };
+  });
+}
+function isObject(value) {
+  return typeof value === "object" && value !== null;
+}
+function isCode(value) {
+  return typeof value === "string" || typeof value === "number";
+}
+function isSegment(value) {
+  return typeof value === "string" || typeof value === "number";
+}
+function normalizeRange(range) {
+  if (!isObject(range)) {
+    return EMPTY_RANGE;
+  }
+  return {
+    start: normalizePosition(range.start),
+    end: normalizePosition(range.end)
+  };
+}
+function normalizePosition(position) {
+  if (!isObject(position)) {
+    return { line: 0, character: 0 };
+  }
+  return {
+    line: toCoordinate(position.line),
+    character: toCoordinate(position.character)
+  };
+}
+function toCoordinate(value) {
+  return typeof value === "number" && Number.isInteger(value) && value >= 0 ? value : 0;
+}
+function normalizeSeverity(severity) {
+  return severity === 1 || severity === 2 || severity === 3 ? severity : 0;
+}
+
+// ../../packages/api-document-lint/dist/resolve-binary.js
+import { statSync } from "node:fs";
+import { createRequire } from "node:module";
+import { dirname, join } from "node:path";
+var binaryName = process.platform === "win32" ? "vacuum.exe" : "vacuum";
+function resolveVacuumBinary(override) {
+  const explicit = override ?? process.env.VACUUM_BINARY;
+  if (explicit) {
+    return isFile(explicit) ? ok(explicit) : err(`vacuum binary not found at ${explicit}`);
+  }
+  const packaged = resolvePackagedBinary();
+  if (packaged) {
+    return ok(packaged);
+  }
+  return ok("vacuum");
+}
+function resolvePackagedBinary() {
+  try {
+    const require2 = createRequire(import.meta.url);
+    const packageJsonPath = require2.resolve("@quobix/vacuum/package.json");
+    const candidate = join(dirname(packageJsonPath), "bin", binaryName);
+    return isFile(candidate) ? candidate : null;
+  } catch {
+    return null;
+  }
+}
+function isFile(path) {
+  try {
+    return statSync(path, { throwIfNoEntry: false })?.isFile() ?? false;
+  } catch {
+    return false;
+  }
+}
+
+// ../../packages/api-document-lint/dist/run-vacuum.js
+var execFileAsync = promisify(execFile);
+var MAX_BUFFER = 64 * 1024 * 1024;
+var TIMEOUT_MS = 6e4;
+async function runVacuum(input, options = {}) {
+  if (input.document.trim().length === 0) {
+    return ok([]);
+  }
+  const binary = resolveVacuumBinary(options.binaryPath);
+  if (!binary.ok) {
+    return binary;
+  }
+  const directory = await mkdtemp(join2(tmpdir(), "scalar-lint-")).catch(() => null);
+  if (directory === null) {
+    return err("vacuum lint failed \u2014 could not create a temporary directory");
+  }
+  const documentPath = join2(directory, "document.yaml");
+  const reportPath = join2(directory, "report.json");
+  try {
+    const wroteDocument = await writeFile(documentPath, input.document, "utf8").then(() => true).catch(() => false);
+    if (!wroteDocument) {
+      return err("vacuum lint failed \u2014 could not write the document to a temporary file");
+    }
+    const args = [
+      "spectral-report",
+      "--no-style",
+      "--no-update-check",
+      "--skip-check",
+      // Match Spectral's working-directory base for document strings.
+      "--base",
+      process.cwd()
+    ];
+    if (input.ruleset && input.ruleset.trim().length > 0) {
+      const rulesetPath = join2(directory, "ruleset.yaml");
+      const wroteRuleset = await writeFile(rulesetPath, input.ruleset, "utf8").then(() => true).catch(() => false);
+      if (!wroteRuleset) {
+        return err("vacuum lint failed \u2014 could not write the ruleset to a temporary file");
+      }
+      args.push("--ruleset", rulesetPath);
+    }
+    args.push(documentPath, reportPath);
+    const failure = await execFileAsync(binary.data, args, {
+      maxBuffer: MAX_BUFFER,
+      timeout: TIMEOUT_MS
+    }).then(() => null).catch((error) => error);
+    const report = await readFile(reportPath, "utf8").catch(() => null);
+    if (report === null) {
+      if (failure === null) {
+        return err("vacuum ran but its report could not be read");
+      }
+      return err(`vacuum failed to lint the document \u2014 ${describeFailure(failure)}`);
+    }
+    const parsed = parseReport(report);
+    if (!parsed.ok) {
+      return parsed;
+    }
+    return ok(normalizeDiagnostics(parsed.data));
+  } finally {
+    await rm(directory, { recursive: true, force: true }).catch(() => void 0);
+  }
+}
+function describeFailure(failure) {
+  if (failure && typeof failure === "object") {
+    const stderr = failure.stderr;
+    if (typeof stderr === "string" && stderr.trim().length > 0) {
+      return stderr.trim();
+    }
+    if (failure instanceof Error) {
+      return failure.message;
+    }
+  }
+  return "no report was written";
+}
+function parseReport(report) {
+  try {
+    const parsed = JSON.parse(report);
+    if (!Array.isArray(parsed)) {
+      return err("vacuum produced a report in an unexpected shape");
+    }
+    return ok(parsed);
+  } catch {
+    return err("vacuum produced an unreadable report");
+  }
+}
+
+// ../../packages/api-document-lint/dist/select-engine.js
+var import_yaml = __toESM(require_dist(), 1);
+function selectEngine(ruleset) {
+  if (!ruleset || ruleset.trim().length === 0) {
+    return "vacuum";
+  }
+  const parsed = parseRuleset(ruleset);
+  if (parsed === null) {
+    return "spectral";
+  }
+  if (hasCustomFunctions(parsed) || hasRuleCustomizations(parsed) || extendsUninspectableRuleset(parsed) || overridesRequireSpectral(parsed)) {
+    return "spectral";
+  }
+  return "vacuum";
+}
+function overridesRequireSpectral(ruleset) {
+  const overrides = ruleset.overrides;
+  if (!Array.isArray(overrides)) {
+    return false;
+  }
+  return overrides.some((entry) => isRecord(entry) && (hasCustomFunctions(entry) || hasRuleCustomizations(entry) || extendsUninspectableRuleset(entry)));
+}
+function hasRuleCustomizations(ruleset) {
+  return ruleset.rules !== void 0 && (!isRecord(ruleset.rules) || Object.keys(ruleset.rules).length > 0);
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function parseRuleset(ruleset) {
+  try {
+    const value = (0, import_yaml.parse)(ruleset);
+    if (value && typeof value === "object" && !Array.isArray(value)) {
+      return value;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function hasCustomFunctions(ruleset) {
+  const functions = ruleset.functions;
+  if (Array.isArray(functions) && functions.length > 0) {
+    return true;
+  }
+  return typeof ruleset.functionsDir === "string" && ruleset.functionsDir.length > 0;
+}
+function extendsUninspectableRuleset(ruleset) {
+  const extended = ruleset.extends;
+  if (extended === void 0) {
+    return false;
+  }
+  const entries = Array.isArray(extended) ? extended : [extended];
+  return entries.some((entry) => !isBuiltInRuleset(entry));
+}
+function isBuiltInRuleset(entry) {
+  const source = Array.isArray(entry) ? entry[0] : entry;
+  return source === "spectral:oas" || source === "spectral:asyncapi";
+}
+
+// ../../packages/api-document-lint/dist/lint.js
+async function lint(input, options = {}) {
+  const ruleset = input.ruleset && input.ruleset.trim().length > 0 ? input.ruleset : defaultRulesetFor(input.document);
+  const resolved = { document: input.document, ruleset };
+  const engine = selectEngine(ruleset);
+  const diagnostics = engine === "vacuum" ? await runVacuum(resolved, options) : await runSpectral(resolved);
+  if (!diagnostics.ok) {
+    return diagnostics;
+  }
+  return ok({ diagnostics: diagnostics.data, engine });
+}
+
+// src/domains/document/lint/helpers.ts
+var severityToLabel = (severity) => {
+  return {
+    0: "Error",
+    1: "Warning",
+    2: "Information",
+    3: "Hint"
+  }[severity];
+};
+
+// src/domains/document/lint/action.ts
+async function lintAction(inputArgument, { rule: ruleArgument }) {
+  if (!inputArgument) {
+    return output.error().title("Invalid argument").message("Please provide a file path").exit("error");
+  }
+  const specification = await getFileOrUrl(inputArgument);
+  const ruleset = ruleArgument ? await getFileOrUrl(ruleArgument) : isAsyncApiContent(specification) ? ASYNCAPI_RULESET : DEFAULT_RULESET;
+  const result = await lint({ document: specification, ruleset });
+  if (!result.ok) {
+    return output.error().title("Failed to lint the document").message(result.error).exit("error");
+  }
+  const diagnostics = result.data.diagnostics;
+  const hasErrors = diagnostics.some((diagnostic) => diagnostic.severity === 0);
+  if (!hasErrors) {
+    output.info().message(as.green("\u2714 No issues found!")).print();
+  } else {
+    output.warn().line(as.red("\u2716 Issues found:")).print();
+  }
+  for (const diagnostic of diagnostics) {
+    output.info().line(`${as.yellow("Rule:")} ${as.bold(String(diagnostic.code))}`).line(`${as.yellow("Message:")} ${diagnostic.message}`).line(`${as.yellow("Severity:")} ${severityToLabel(diagnostic.severity)}`).line(
+      `${as.yellow("Location:")} ${diagnostic.range.start.line}:${diagnostic.range.start.character} - ${diagnostic.range.end.line}:${diagnostic.range.end.character}`
+    ).line(as.gray("---")).print();
+  }
+  if (hasErrors) {
+    output.error().exit("error");
+  }
+}
+export {
+  lintAction
+};

package/chunks/{action-PVDDRIM6.js → action-M7RQKBSB.js}

@@ -1,19 +1,26 @@
 import { createRequire as $$cR } from "node:module"; const require = $$cR(import.meta.url);
 import {
-  loadOpenApiFile,
-  printSpecificationBanner
-} from "./chunk-23I5PKZZ.js";
+  getFileOrUrl,
+  isAsyncApiDocument,
+  isDocument,
+  loadOpenApiDocument,
+  printSpecificationBanner,
+  safeNormalize
+} from "./chunk-24WAOKGG.js";
 import {
   watchFile
-} from "./chunk-5BISXQX4.js";
-import "./chunk-OAXFCOJV.js";
-import "./chunk-4DGQIAJX.js";
-import "./chunk-ISGLWBXZ.js";
-import "./chunk-H2WRMLYY.js";
-import "./chunk-IX7LJ3AD.js";
+} from "./chunk-M37TP6U2.js";
+import "./chunk-4ZDQXWBT.js";
+import "./chunk-VNYE4R7N.js";
+import "./chunk-OQKDBLOZ.js";
+import "./chunk-CISTON3A.js";
+import "./chunk-Q7DOQHZN.js";
+import "./chunk-4ORL4MST.js";
 import {
   output
-} from "./chunk-X4QLDBB5.js";
+} from "./chunk-T5HJUAWB.js";
+import "./chunk-GSGZHE26.js";
+import "./chunk-IKT5F47M.js";
 import "./chunk-3MZYUBJ6.js";
 
 // src/domains/document/serve/action.ts
@@ -21,25 +28,47 @@ import { serve } from "@hono/node-server";
 import as from "ansis";
 import { Hono } from "hono";
 import { stream } from "hono/streaming";
+
+// src/domains/document/serve/load-document.ts
+import { validate } from "@scalar/asyncapi-validator";
+var loadServeDocument = async (input) => {
+  const content = await getFileOrUrl(input);
+  const document = safeNormalize(content);
+  if (!isDocument(document) || !isAsyncApiDocument(document)) {
+    return loadOpenApiDocument(content);
+  }
+  const result = validate(document);
+  if (!result.valid) {
+    output.warn().title("File does not match the AsyncAPI specification.").print();
+    for (const error of result.errors ?? []) {
+      output.warn().title(error.message ?? "Invalid AsyncAPI document").print();
+    }
+  }
+  return {
+    valid: result.valid,
+    version: result.version,
+    specification: document,
+    schema: void 0
+  };
+};
+
+// src/domains/document/serve/action.ts
 async function serveAction(inputArgument, { watch, once, port }) {
   if (!inputArgument) {
     return output.error().title("Invalid argument").message("Please provide a file path").exit("error");
   }
-  const result = await loadOpenApiFile(inputArgument);
-  if (!result.valid) {
+  const result = await loadServeDocument(inputArgument);
+  if (result.specification === void 0) {
     return;
   }
   let { specification } = result;
-  printSpecificationBanner({
-    version: result.version,
-    schema: result.schema
-  });
-  if (specification?.paths === void 0 || Object.keys(specification?.paths).length === 0) {
+  printServeBanner(result);
+  if (!isAsyncApiDocument(specification) && Object.keys(specification.paths ?? {}).length === 0) {
     output.warn().title("Could not find any paths in the OpenAPI file.").print();
   }
   const app = new Hono();
   app.get("/", (c) => {
-    return c.html(getHtmlDocument(specification ?? {}, watch));
+    return c.html(getHtmlDocument(specification, watch));
   });
   app.use("/__watcher", async (c, next) => {
     c.header("Content-Type", "text/event-stream");
@@ -51,14 +80,14 @@ async function serveAction(inputArgument, { watch, once, port }) {
     return stream(c, async (s) => {
       if (watch) {
         const subscription = await watchFile(inputArgument, async () => {
-          const newResult = await loadOpenApiFile(inputArgument);
-          const specificationHasChanged = newResult?.specification && JSON.stringify(specification) !== JSON.stringify(newResult.specification);
-          if (specificationHasChanged && newResult.valid) {
-            output.info().title(as.grey("OpenAPI file modified")).print();
-            printSpecificationBanner({
-              version: newResult.version,
-              schema: newResult.schema
-            });
+          const newResult = await loadServeDocument(inputArgument);
+          if (newResult.specification && JSON.stringify(specification) !== JSON.stringify(newResult.specification)) {
+            output.info().title(
+              as.grey(
+                `${isAsyncApiDocument(newResult.specification) ? "AsyncAPI" : "OpenAPI"} file modified`
+              )
+            ).print();
+            printServeBanner(newResult);
             specification = newResult.specification;
             s.write("data: file modified\n\n");
           }
@@ -124,6 +153,16 @@ var getHtmlDocument = (specification, watch = false) => {
       </body>
     </html>`;
 };
+var printServeBanner = (result) => {
+  if (isAsyncApiDocument(result.specification)) {
+    output.info().title(`AsyncAPI${result.version ? ` v${result.version}` : ""}`).print();
+    return;
+  }
+  printSpecificationBanner({
+    version: result.version,
+    schema: result.valid ? result.schema : void 0
+  });
+};
 export {
   getHtmlDocument,
   serveAction

package/chunks/{action-F4Y6Q2VB.js → action-MSLBC2SO.js}

@@ -1,39 +1,39 @@
 import { createRequire as $$cR } from "node:module"; const require = $$cR(import.meta.url);
 import {
   apiService
-} from "./chunk-SXYALPYK.js";
+} from "./chunk-AO3F5XWR.js";
 import {
   BaseCollections
-} from "./chunk-2BSG2QHO.js";
+} from "./chunk-F467BYYR.js";
 import {
   getDatabaseClient
-} from "./chunk-SHSHFGA7.js";
-import "./chunk-UPUTMFD4.js";
-import "./chunk-B6QZJWCQ.js";
-import "./chunk-5BPPGTUU.js";
-import "./chunk-P646T2WH.js";
-import "./chunk-4QS7SJTG.js";
-import "./chunk-VTYTPSXO.js";
+} from "./chunk-Z2KMGFE6.js";
+import "./chunk-HCPN3KNF.js";
+import "./chunk-B2MHTD3R.js";
+import "./chunk-3L6DLIXJ.js";
+import "./chunk-P7H7GY5A.js";
+import "./chunk-HPL3ZZ2P.js";
 import {
   getAuthData
-} from "./chunk-5BISXQX4.js";
-import "./chunk-OAXFCOJV.js";
-import "./chunk-TLFMATXR.js";
+} from "./chunk-M37TP6U2.js";
+import "./chunk-4ZDQXWBT.js";
 import {
   teamSchema
-} from "./chunk-4DGQIAJX.js";
-import {
-  namespaceSchema
-} from "./chunk-ISGLWBXZ.js";
-import {
-  external_exports
-} from "./chunk-H2WRMLYY.js";
+} from "./chunk-VNYE4R7N.js";
+import "./chunk-OQKDBLOZ.js";
 import "./chunk-K74E42RV.js";
-import "./chunk-IX7LJ3AD.js";
+import "./chunk-CISTON3A.js";
+import "./chunk-Q7DOQHZN.js";
+import "./chunk-4ORL4MST.js";
 import {
   output,
   printTable
-} from "./chunk-X4QLDBB5.js";
+} from "./chunk-T5HJUAWB.js";
+import "./chunk-GSGZHE26.js";
+import {
+  external_exports,
+  namespaceSchema
+} from "./chunk-IKT5F47M.js";
 import "./chunk-3MZYUBJ6.js";
 
 // src/domains/registry/list/action.ts

package/chunks/{action-BNEGJBUH.js → action-NVSZT2ZD.js}

@@ -2,18 +2,17 @@ import { createRequire as $$cR } from "node:module"; const require = $$cR(import
 import {
   readAndParseConfig,
   renderConfigError
-} from "./chunk-P2VH7DOC.js";
-import "./chunk-47Y4L5IT.js";
-import "./chunk-5BPPGTUU.js";
-import "./chunk-4QS7SJTG.js";
-import "./chunk-VTYTPSXO.js";
-import "./chunk-TLFMATXR.js";
-import "./chunk-ISGLWBXZ.js";
-import "./chunk-H2WRMLYY.js";
+} from "./chunk-7AGLC7WV.js";
+import "./chunk-PBXZN65A.js";
+import "./chunk-OQKDBLOZ.js";
 import "./chunk-K74E42RV.js";
+import "./chunk-CISTON3A.js";
+import "./chunk-Q7DOQHZN.js";
 import {
   output
-} from "./chunk-X4QLDBB5.js";
+} from "./chunk-T5HJUAWB.js";
+import "./chunk-GSGZHE26.js";
+import "./chunk-IKT5F47M.js";
 import "./chunk-3MZYUBJ6.js";
 
 // src/domains/project/check-config/action.ts

package/chunks/{action-ANU5HGC4.js → action-OGQSTRMX.js}

@@ -1,22 +1,25 @@
 import { createRequire as $$cR } from "node:module"; const require = $$cR(import.meta.url);
 import {
   apiService
-} from "./chunk-SXYALPYK.js";
-import "./chunk-UPUTMFD4.js";
-import "./chunk-B6QZJWCQ.js";
-import "./chunk-P646T2WH.js";
-import "./chunk-4QS7SJTG.js";
-import "./chunk-VTYTPSXO.js";
-import "./chunk-5BISXQX4.js";
-import "./chunk-OAXFCOJV.js";
-import "./chunk-TLFMATXR.js";
-import "./chunk-4DGQIAJX.js";
-import "./chunk-ISGLWBXZ.js";
-import "./chunk-H2WRMLYY.js";
-import "./chunk-IX7LJ3AD.js";
+} from "./chunk-AO3F5XWR.js";
+import "./chunk-HCPN3KNF.js";
+import "./chunk-B2MHTD3R.js";
+import "./chunk-3L6DLIXJ.js";
+import "./chunk-P7H7GY5A.js";
+import "./chunk-HPL3ZZ2P.js";
+import "./chunk-M37TP6U2.js";
+import "./chunk-4ZDQXWBT.js";
+import "./chunk-VNYE4R7N.js";
+import "./chunk-OQKDBLOZ.js";
+import "./chunk-K74E42RV.js";
+import "./chunk-CISTON3A.js";
+import "./chunk-Q7DOQHZN.js";
+import "./chunk-4ORL4MST.js";
 import {
   output
-} from "./chunk-X4QLDBB5.js";
+} from "./chunk-T5HJUAWB.js";
+import "./chunk-GSGZHE26.js";
+import "./chunk-IKT5F47M.js";
 import "./chunk-3MZYUBJ6.js";
 
 // src/domains/registry/delete/action.ts

package/chunks/{action-CLSD7O2R.js → action-PAGJ5PWC.js}

@@ -1,23 +1,23 @@
 import { createRequire as $$cR } from "node:module"; const require = $$cR(import.meta.url);
 import {
   getUserTeams
-} from "./chunk-ASMHW5AY.js";
+} from "./chunk-6ZMT63IV.js";
 import {
   getDatabaseClient
-} from "./chunk-SHSHFGA7.js";
-import "./chunk-B6QZJWCQ.js";
+} from "./chunk-Z2KMGFE6.js";
+import "./chunk-B2MHTD3R.js";
 import {
   getAuthData,
   refreshToken
-} from "./chunk-5BISXQX4.js";
-import "./chunk-OAXFCOJV.js";
-import "./chunk-4DGQIAJX.js";
-import "./chunk-ISGLWBXZ.js";
-import "./chunk-H2WRMLYY.js";
-import "./chunk-IX7LJ3AD.js";
+} from "./chunk-M37TP6U2.js";
+import "./chunk-4ZDQXWBT.js";
+import "./chunk-VNYE4R7N.js";
+import "./chunk-OQKDBLOZ.js";
+import "./chunk-4ORL4MST.js";
 import {
   output
-} from "./chunk-X4QLDBB5.js";
+} from "./chunk-T5HJUAWB.js";
+import "./chunk-IKT5F47M.js";
 import "./chunk-3MZYUBJ6.js";
 
 // src/domains/team/set/action.ts