pi-lens 4.3.0 → 4.4.1

package/dist/chunk-JONGANYH.js

@@ -0,0 +1,202 @@
+import { createRequire as __pilensCreateRequire } from "node:module"; const require = __pilensCreateRequire(import.meta.url);
+import {
+  createAvailabilityChecker,
+  resolveAvailableOrInstall
+} from "./chunk-NFXP47RV.js";
+import {
+  ruffConfigArgs
+} from "./chunk-MGIWSROG.js";
+import "./chunk-IQZXOZ7S.js";
+import "./chunk-LNOMA3MP.js";
+import "./chunk-U52SAGRM.js";
+import "./chunk-KJCWXUUS.js";
+import "./chunk-QOZXJ4NA.js";
+import "./chunk-S6AMWKPC.js";
+import "./chunk-F5VLZHUW.js";
+import "./chunk-AXKPQ6ZI.js";
+import "./chunk-7BX5DWSA.js";
+import "./chunk-IUKPRZER.js";
+import "./chunk-Z3CCVDUB.js";
+import "./chunk-2BEMIWEW.js";
+import "./chunk-LD7WFTRX.js";
+import {
+  resolveToolCwd
+} from "./chunk-IUR76K6A.js";
+import "./chunk-T4QZ6FEH.js";
+import "./chunk-D6YF5HKX.js";
+import "./chunk-CMU4RMJB.js";
+import "./chunk-O7HZX7CA.js";
+import "./chunk-VYKKMYVT.js";
+import "./chunk-BNKLYOOO.js";
+import "./chunk-USHG4DLH.js";
+import "./chunk-H5EV3VMF.js";
+import {
+  safeSpawnAsync
+} from "./chunk-T54VJRAD.js";
+import "./chunk-BW5KFIQC.js";
+import "./chunk-QYF5S6P6.js";
+import {
+  isFileKind
+} from "./chunk-64LU2OVH.js";
+import "./chunk-N2IRDBZI.js";
+import "./chunk-Z6BB4JLQ.js";
+import "./chunk-2EECBNC5.js";
+import "./chunk-7ELY2CSM.js";
+import {
+  createSubsystemLogger
+} from "./chunk-34OCDWOS.js";
+import "./chunk-3PNFWVHT.js";
+import "./chunk-VSMJK3ZJ.js";
+import "./chunk-LJDODBBZ.js";
+import "./chunk-ABBOA7UD.js";
+import {
+  pathsEqual
+} from "./chunk-G3RLJYA2.js";
+import "./chunk-NXL4FFQQ.js";
+
+// dist/clients/ruff-client.js
+import * as fs from "node:fs";
+import * as path from "node:path";
+var ruffAvailability = createAvailabilityChecker("ruff", ".exe");
+var RuffClient = class {
+  ruffCommand = "ruff";
+  log;
+  constructor(verbose = false) {
+    this.log = verbose ? createSubsystemLogger("ruff") : () => {
+    };
+  }
+  /**
+   * Check if ruff CLI is available, auto-install if not.
+   *
+   * Re-entrancy safe: the shared availability seam deduplicates the complete
+   * probe/auto-install transaction per cwd and tool, so concurrent callers do
+   * not duplicate installation attempts.
+   */
+  async ensureAvailable() {
+    const resolved = await resolveAvailableOrInstall(ruffAvailability, "ruff", process.cwd());
+    if (!resolved)
+      return false;
+    this.ruffCommand = resolved;
+    return true;
+  }
+  /**
+   * Check if a file is a Python file
+   */
+  isPythonFile(filePath) {
+    return isFileKind(filePath, "python");
+  }
+  /**
+   * Async auto-fix variant for pipeline use (non-blocking spawn).
+   * `cwd` is the dispatch language root. It is the seam's starting point,
+   * not the answer: `resolveToolCwd` walks from the file to the nearest
+   * `pyproject.toml`/`ruff.toml`/`.ruff.toml` at or above it, capped inside
+   * `cwd` (and at `$HOME` when there is none), so a file in a nested package
+   * gets that package's config rather than the workspace-root one.
+   */
+  async fixFileAsync(filePath, cwd) {
+    if (!await this.ensureAvailable()) {
+      return {
+        success: false,
+        changed: false,
+        fixed: 0,
+        error: "Ruff not available"
+      };
+    }
+    const absolutePath = path.resolve(filePath);
+    if (!fs.existsSync(absolutePath)) {
+      return {
+        success: false,
+        changed: false,
+        fixed: 0,
+        error: "File not found"
+      };
+    }
+    try {
+      const before = await fs.promises.readFile(absolutePath, "utf-8");
+      const ruffCwd = resolveToolCwd("runner", "ruff", absolutePath, {
+        ...cwd !== void 0 && { cwd }
+      }).cwd;
+      const configArgs = ruffConfigArgs(ruffCwd);
+      const pre = await safeSpawnAsync(this.ruffCommand, [
+        "check",
+        "--output-format",
+        "json",
+        "--target-version",
+        "py310",
+        ...configArgs,
+        absolutePath
+      ], { timeout: 1e4, cwd: ruffCwd });
+      const beforeDiags = pre.stdout?.trim() ? this.parseOutput(pre.stdout, ruffCwd, absolutePath) : [];
+      const fixableCount = beforeDiags.filter((d) => d.fixable).length;
+      const fix = await safeSpawnAsync(this.ruffCommand, ["check", "--fix", ...configArgs, absolutePath], { timeout: 15e3, cwd: ruffCwd });
+      if (fix.error) {
+        return {
+          success: false,
+          changed: false,
+          fixed: 0,
+          error: fix.error.message
+        };
+      }
+      const after = await fs.promises.readFile(absolutePath, "utf-8");
+      const changed = before !== after;
+      if (changed) {
+        this.log(`Fixed ${fixableCount} issue(s) in ${path.basename(filePath)}`);
+      }
+      return { success: true, changed, fixed: fixableCount };
+    } catch (err) {
+      return { success: false, changed: false, fixed: 0, error: err.message };
+    }
+  }
+  // --- Internal ---
+  /**
+   * `cwd` is the directory ruff RAN in, and it is REQUIRED: a default would
+   * hide the wrong base at a call site that forgot it (#3284's D11).
+   *
+   * ruff's JSON `filename` is the `SourceFile`'s name verbatim — the JSON
+   * renderer reads `span.file().path(resolver)` (ruff 0.16.8
+   * `crates/ruff_db/src/diagnostic/render/json.rs:58,120`), which for a ruff
+   * (not `ty`) diagnostic is `file.name()` (`crates/ruff_db/src/diagnostic/
+   * mod.rs:1187-1193`), NOT the cwd-relative `relative_path` the text
+   * renderers use (`mod.rs:1195-1204`). That name is
+   * `SourceFileBuilder::new(path.to_string_lossy(), …)`
+   * (`crates/ruff_linter/src/linter.rs:1049`) over a path the resolver has
+   * already absolutized ("Normalize every path (e.g., convert from relative to
+   * absolute)", `crates/ruff_workspace/src/resolver.rs:484`). So ruff echoes
+   * the absolute path we hand it as argv: the BASE was already right here and
+   * the fold deletes a `path.resolve` with no base — which silently meant the
+   * EXTENSION's `process.cwd()`, not ruff's — rather than leaving it for a
+   * future relative invocation to re-enable.
+   */
+  parseOutput(output, cwd, filterFile) {
+    if (!output.trim())
+      return [];
+    try {
+      const items = JSON.parse(output);
+      const diagnostics = [];
+      for (const item of items) {
+        if (filterFile && !pathsEqual(path.resolve(cwd, item.filename), filterFile))
+          continue;
+        diagnostics.push({
+          line: item.location.row - 1,
+          // ruff is 1-indexed
+          column: item.location.column - 1,
+          endLine: item.end_location.row - 1,
+          endColumn: item.end_location.column - 1,
+          severity: item.code?.startsWith("E") ? "error" : "warning",
+          message: item.message,
+          rule: item.code || "unknown",
+          file: item.filename,
+          fixable: item.fix !== null
+        });
+      }
+      return diagnostics;
+    } catch (err) {
+      void err;
+      this.log("Failed to parse ruff JSON output");
+      return [];
+    }
+  }
+};
+export {
+  RuffClient
+};

package/dist/chunk-KJCWXUUS.js

@@ -0,0 +1,425 @@
+import { createRequire as __pilensCreateRequire } from "node:module"; const require = __pilensCreateRequire(import.meta.url);
+import {
+  getGlobalPiLensDir
+} from "./chunk-T54VJRAD.js";
+import {
+  SPECIAL_FILENAMES
+} from "./chunk-64LU2OVH.js";
+import {
+  getTurnId
+} from "./chunk-VSMJK3ZJ.js";
+import {
+  BoundedFifoMap
+} from "./chunk-ABBOA7UD.js";
+
+// dist/clients/custom-rule-locations.js
+import * as path from "node:path";
+function getUserRuleRoot() {
+  return path.join(getGlobalPiLensDir(), "rules");
+}
+var RULE_CORPUS_CYCLE_ENTRIES = 16;
+var ruleCorpusCycleFingerprints = new BoundedFifoMap(RULE_CORPUS_CYCLE_ENTRIES);
+var cycleSlot;
+function ruleCorpusFingerprintForCycle(family, root, compute, force = false) {
+  const cycle = getTurnId();
+  if (!force && cycleSlot !== void 0 && cycleSlot.cycle === cycle && cycleSlot.family === family && cycleSlot.root === root) {
+    return cycleSlot.fingerprint;
+  }
+  const key = `${cycle}\0${family}\0${root}`;
+  let fingerprint = force ? void 0 : ruleCorpusCycleFingerprints.get(key);
+  if (fingerprint === void 0) {
+    fingerprint = compute(root);
+    ruleCorpusCycleFingerprints.set(key, fingerprint);
+  }
+  cycleSlot = { cycle, family, root, fingerprint };
+  return fingerprint;
+}
+
+// dist/clients/language-registry.js
+var LANGUAGES = [
+  { id: "ada", extensions: [".adb", ".ads"] },
+  { id: "astro", extensions: [".astro"] },
+  { id: "c", kind: "cxx", extensions: [".c", ".h"], grammar: "c" },
+  {
+    id: "clojure",
+    kind: "clojure",
+    extensions: [".clj", ".cljc", ".cljs", ".edn"]
+  },
+  {
+    id: "cmake",
+    kind: "cmake",
+    extensions: [".cmake"],
+    filenames: ["CMakeLists.txt"]
+  },
+  { id: "cobol", extensions: [".cob", ".cbl"] },
+  {
+    id: "cpp",
+    kind: "cxx",
+    // The clang extension table (file-kinds.ts KIND_EXTENSIONS.cxx) minus the
+    // C header/source pair, which the `c` entry owns. `.cuh` deliberately
+    // diverges from clang's table: CUDA/HIP projects use it for C++ headers,
+    // so it must reach the same cpp grammar and clangd path as `.cu`/`.hip`.
+    extensions: [
+      ".c++",
+      ".c++m",
+      ".cc",
+      ".cl",
+      ".clcpp",
+      ".cp",
+      ".cpp",
+      ".cppm",
+      ".cu",
+      ".cuh",
+      ".cxx",
+      ".cxxm",
+      ".hh",
+      ".hip",
+      ".hpp",
+      ".hxx",
+      ".inl",
+      ".ipp",
+      ".ixx",
+      ".m",
+      ".mm",
+      ".tpp",
+      ".txx"
+    ],
+    grammar: "cpp",
+    // The module-interface (.c++m/.cppm/.cxxm/.ixx), Objective-C (.m/.mm),
+    // OpenCL (.cl/.clcpp) and .cp tail is classified cxx but has never been
+    // routed to the cpp grammar by extension; kind-keyed consumers still
+    // reach cpp through `kindFallback`.
+    grammarExtensions: [
+      ".c++",
+      ".cc",
+      ".cpp",
+      ".cu",
+      ".cuh",
+      ".cxx",
+      ".hh",
+      ".hip",
+      ".hpp",
+      ".hxx",
+      ".inl",
+      ".ipp",
+      ".tpp",
+      ".txx"
+    ],
+    kindFallback: true
+  },
+  { id: "csharp", kind: "csharp", extensions: [".cs"], grammar: "csharp" },
+  { id: "css", kind: "css", extensions: [".css"], grammar: "css" },
+  {
+    id: "cue",
+    kind: "cue",
+    extensions: [".cue"],
+    grammar: "cue",
+    // The cue grammar and its symbol queries ship, but no extension resolver
+    // has ever routed `.cue` to them; kind-keyed consumers reach it anyway.
+    grammarExtensions: []
+  },
+  { id: "dart", kind: "dart", extensions: [".dart"], grammar: "dart" },
+  {
+    id: "dockerfile",
+    kind: "docker",
+    extensions: [".dockerfile"],
+    filenames: ["Dockerfile"]
+  },
+  {
+    id: "elixir",
+    kind: "elixir",
+    extensions: [".ex", ".exs"],
+    grammar: "elixir"
+  },
+  { id: "erlang", extensions: [".erl", ".hrl"] },
+  { id: "fish", kind: "fish", extensions: [".fish"] },
+  { id: "fortran", extensions: [".f", ".f90", ".f95"] },
+  { id: "fsharp", kind: "fsharp", extensions: [".fs", ".fsi", ".fsx"] },
+  { id: "gleam", kind: "gleam", extensions: [".gleam"] },
+  { id: "go", kind: "go", extensions: [".go"], grammar: "go" },
+  // go.mod / go.sum: the LSP id is plain `go`, but they are not Go source and
+  // file-kinds.ts deliberately does not classify them.
+  { id: "go-mod", extensions: [".mod", ".sum"], lspId: "go" },
+  { id: "graphql", extensions: [".graphql", ".gql"] },
+  { id: "haskell", kind: "haskell", extensions: [".hs", ".lhs"] },
+  { id: "helm", kind: "helm-template", extensions: [".tpl"] },
+  {
+    id: "html",
+    kind: "html",
+    extensions: [".htm", ".html"],
+    grammar: "html",
+    grammarExtensions: []
+  },
+  { id: "java", kind: "java", extensions: [".java"], grammar: "java" },
+  {
+    id: "javascript",
+    kind: "jsts",
+    extensions: [".js", ".mjs", ".cjs"],
+    grammar: "javascript"
+  },
+  // `.jsx` is JSX-flavoured JavaScript: its own LSP id, but the plain
+  // javascript grammar (which parses JSX) rather than the tsx one.
+  {
+    id: "javascriptreact",
+    kind: "jsts",
+    extensions: [".jsx"],
+    grammar: "javascript"
+  },
+  {
+    id: "json",
+    kind: "json",
+    extensions: [".json", ".json5"],
+    grammar: "json",
+    grammarExtensions: []
+  },
+  { id: "jsonc", kind: "json", extensions: [".jsonc"] },
+  { id: "julia", extensions: [".jl"] },
+  {
+    id: "kotlin",
+    kind: "kotlin",
+    extensions: [".kt", ".kts"],
+    grammar: "kotlin"
+  },
+  { id: "less", kind: "css", extensions: [".less"] },
+  { id: "lua", kind: "lua", extensions: [".lua"], grammar: "lua" },
+  { id: "markdown", kind: "markdown", extensions: [".md", ".mdx"] },
+  { id: "nix", kind: "nix", extensions: [".nix"] },
+  {
+    id: "ocaml",
+    kind: "ocaml",
+    extensions: [".ml", ".mli"],
+    grammar: "ocaml"
+  },
+  { id: "pascal", extensions: [".pas", ".pp"] },
+  { id: "perl", extensions: [".pl", ".pm"] },
+  {
+    id: "php",
+    kind: "php",
+    extensions: [".php", ".phtml", ".php3", ".php4", ".php5"],
+    grammar: "php"
+  },
+  {
+    id: "powershell",
+    kind: "powershell",
+    extensions: [".ps1", ".psm1", ".psd1"]
+  },
+  { id: "prisma", kind: "prisma", extensions: [".prisma"] },
+  { id: "proto", extensions: [".proto"] },
+  {
+    id: "python",
+    kind: "python",
+    extensions: [".py", ".pyi"],
+    grammar: "python",
+    // `.pyi` stubs are not routed to the grammar by extension today.
+    grammarExtensions: [".py"]
+  },
+  { id: "r", extensions: [".r"] },
+  // Rusty Object Notation: served as `rust` by the LSP seam, not Rust source.
+  { id: "ron", extensions: [".ron"], lspId: "rust" },
+  {
+    id: "ruby",
+    kind: "ruby",
+    extensions: [".rb", ".rake", ".gemspec", ".ru"],
+    grammar: "ruby",
+    grammarExtensions: [".rb"]
+  },
+  { id: "rust", kind: "rust", extensions: [".rs"], grammar: "rust" },
+  { id: "sass", kind: "css", extensions: [".sass"] },
+  { id: "scala", extensions: [".scala", ".sc"] },
+  { id: "scss", kind: "css", extensions: [".scss"] },
+  {
+    id: "shell",
+    kind: "shell",
+    extensions: [".sh", ".bash", ".zsh"],
+    filenames: ["Makefile"],
+    // The LSP spec spells it `shellscript`; the tree-sitter grammar is `bash`.
+    lspId: "shellscript",
+    grammar: "bash",
+    grammarExtensions: [".sh", ".bash"]
+  },
+  { id: "sql", kind: "sql", extensions: [".sql"] },
+  { id: "svelte", kind: "jsts", extensions: [".svelte"] },
+  { id: "swift", kind: "swift", extensions: [".swift"], grammar: "swift" },
+  { id: "systemverilog", extensions: [".sv"] },
+  { id: "terraform", kind: "terraform", extensions: [".tf", ".tfvars"] },
+  {
+    id: "terragrunt",
+    kind: "terragrunt",
+    extensions: [],
+    filenames: ["terragrunt.hcl", "root.hcl"]
+  },
+  {
+    id: "toml",
+    kind: "toml",
+    extensions: [".toml"],
+    grammar: "toml",
+    grammarExtensions: []
+  },
+  {
+    id: "typescript",
+    kind: "jsts",
+    extensions: [".ts", ".mts", ".cts"],
+    grammar: "typescript"
+  },
+  // `.tsx` needs the tsx grammar (the typescript grammar ERRORs on JSX) and
+  // the LSP spec's `typescriptreact` id.
+  {
+    id: "typescriptreact",
+    kind: "jsts",
+    extensions: [".tsx"],
+    grammar: "tsx"
+  },
+  { id: "typst", extensions: [".typ", ".typc"] },
+  { id: "verilog", extensions: [".v"] },
+  { id: "vhdl", extensions: [".vhd", ".vhdl"] },
+  {
+    id: "vue",
+    kind: "jsts",
+    extensions: [".vue"],
+    grammar: "vue",
+    // The vue grammar ships as wasm but no extension resolver routes to it;
+    // the jsts fact providers deliberately skip .vue/.svelte (file-kinds.ts).
+    grammarExtensions: []
+  },
+  {
+    id: "yaml",
+    kind: "yaml",
+    extensions: [".yaml", ".yml"],
+    grammar: "yaml",
+    grammarExtensions: []
+  },
+  {
+    id: "zig",
+    kind: "zig",
+    extensions: [".zig", ".zon"],
+    grammar: "zig",
+    grammarExtensions: [".zig"]
+  }
+];
+function lspLanguageId(entry) {
+  return entry.lspId ?? entry.id;
+}
+function grammarExtensionsOf(entry) {
+  if (!entry.grammar)
+    return [];
+  return entry.grammarExtensions ?? entry.extensions;
+}
+var BY_EXTENSION = /* @__PURE__ */ new Map();
+var BY_FILENAME = /* @__PURE__ */ new Map();
+for (const entry of LANGUAGES) {
+  for (const extension of entry.extensions) {
+    BY_EXTENSION.set(extension.toLowerCase(), entry);
+  }
+  for (const filename of entry.filenames ?? []) {
+    BY_FILENAME.set(filename.toLowerCase(), entry);
+  }
+}
+var BY_ID = new Map(LANGUAGES.map((entry) => [entry.id, entry]));
+function extensionsForLanguage(id) {
+  return BY_ID.get(id)?.extensions ?? [];
+}
+var GRAMMAR_TO_EXTENSIONS = Object.freeze((() => {
+  const byGrammar = /* @__PURE__ */ new Map();
+  for (const entry of LANGUAGES) {
+    if (!entry.grammar)
+      continue;
+    const list = byGrammar.get(entry.grammar) ?? [];
+    list.push(...entry.extensions);
+    byGrammar.set(entry.grammar, list);
+  }
+  return Object.fromEntries([...byGrammar].map(([grammar, extensions]) => [
+    grammar,
+    Object.freeze([...new Set(extensions)])
+  ]));
+})());
+function extensionsForLanguageToken(token) {
+  return GRAMMAR_TO_EXTENSIONS[token] ?? extensionsForLanguage(token);
+}
+function basenameOf(filePath) {
+  const cut = Math.max(filePath.lastIndexOf("/"), filePath.lastIndexOf("\\"));
+  return cut === -1 ? filePath : filePath.slice(cut + 1);
+}
+function extensionOf(filePath) {
+  const base = basenameOf(filePath);
+  const dot = base.lastIndexOf(".");
+  return dot <= 0 ? "" : base.slice(dot).toLowerCase();
+}
+var BY_KIND = /* @__PURE__ */ new Map();
+{
+  const owners = /* @__PURE__ */ new Map();
+  for (const entry of LANGUAGES) {
+    if (!entry.kind)
+      continue;
+    const list = owners.get(entry.kind) ?? [];
+    list.push(entry);
+    owners.set(entry.kind, list);
+  }
+  for (const [kind, list] of owners) {
+    const resolved = list.length === 1 ? list[0] : list.find((entry) => entry.kindFallback);
+    if (resolved)
+      BY_KIND.set(kind, resolved);
+  }
+}
+function resolveLanguage(filePath) {
+  if (!filePath)
+    return void 0;
+  const base = basenameOf(filePath);
+  const byName = BY_FILENAME.get(base.toLowerCase());
+  if (byName)
+    return byName;
+  const byExtension = BY_EXTENSION.get(extensionOf(filePath));
+  if (byExtension)
+    return byExtension;
+  for (const { pattern, kind } of SPECIAL_FILENAMES) {
+    if (pattern.test(base))
+      return BY_KIND.get(kind);
+  }
+  return void 0;
+}
+var EXTENSION_TO_LSP_ID = Object.freeze(Object.fromEntries(LANGUAGES.flatMap((entry) => entry.extensions.map((extension) => [extension, lspLanguageId(entry)]))));
+var EXTENSION_TO_GRAMMAR = Object.freeze(Object.fromEntries(LANGUAGES.flatMap((entry) => grammarExtensionsOf(entry).map((extension) => [extension, entry.grammar]))));
+var KIND_TO_GRAMMAR = Object.freeze(Object.fromEntries([...BY_KIND.entries()].filter(([, entry]) => Boolean(entry.grammar)).map(([kind, entry]) => [kind, entry.grammar])));
+var SCAN_LANGUAGE_PRIORITY = [
+  ["typescript", "typescriptreact"],
+  ["javascript", "javascriptreact"],
+  ["python"],
+  ["rust"],
+  ["go"],
+  ["ruby"],
+  ["java"],
+  ["kotlin"],
+  ["swift"],
+  ["csharp"],
+  ["cpp"],
+  ["c"],
+  ["zig"],
+  ["haskell"],
+  ["elixir"],
+  ["gleam"],
+  ["terraform"],
+  ["nix"],
+  ["shell"],
+  ["php"],
+  ["lua"],
+  ["dart"],
+  ["vue"],
+  ["svelte"],
+  ["css", "scss", "less"],
+  ["html"],
+  ["json", "jsonc"],
+  ["yaml"],
+  ["toml"],
+  ["prisma"]
+];
+
+export {
+  getUserRuleRoot,
+  ruleCorpusFingerprintForCycle,
+  extensionsForLanguage,
+  extensionsForLanguageToken,
+  resolveLanguage,
+  EXTENSION_TO_LSP_ID,
+  EXTENSION_TO_GRAMMAR,
+  KIND_TO_GRAMMAR,
+  SCAN_LANGUAGE_PRIORITY
+};

package/dist/chunk-KJN4IOEJ.js

@@ -0,0 +1,17 @@
+import { createRequire as __pilensCreateRequire } from "node:module"; const require = __pilensCreateRequire(import.meta.url);
+import {
+  detectFileRole
+} from "./chunk-N2IRDBZI.js";
+
+// dist/clients/collateral-test-role.js
+function isTestRoleCollateral(filePath) {
+  try {
+    return detectFileRole(filePath) === "test";
+  } catch {
+    return false;
+  }
+}
+
+export {
+  isTestRoleCollateral
+};

package/dist/chunk-KMGPUKFD.js

@@ -0,0 +1,25 @@
+import { createRequire as __pilensCreateRequire } from "node:module"; const require = __pilensCreateRequire(import.meta.url);
+import {
+  getSourceFiles,
+  getSourceFilesAsync
+} from "./chunk-BNKLYOOO.js";
+import "./chunk-USHG4DLH.js";
+import "./chunk-H5EV3VMF.js";
+import "./chunk-T54VJRAD.js";
+import "./chunk-QYF5S6P6.js";
+import "./chunk-64LU2OVH.js";
+import "./chunk-N2IRDBZI.js";
+import "./chunk-Z6BB4JLQ.js";
+import "./chunk-2EECBNC5.js";
+import "./chunk-7ELY2CSM.js";
+import "./chunk-34OCDWOS.js";
+import "./chunk-3PNFWVHT.js";
+import "./chunk-VSMJK3ZJ.js";
+import "./chunk-LJDODBBZ.js";
+import "./chunk-ABBOA7UD.js";
+import "./chunk-G3RLJYA2.js";
+import "./chunk-NXL4FFQQ.js";
+export {
+  getSourceFiles,
+  getSourceFilesAsync
+};