@ebrindley/build 0.0.0-stage → 1.42.1-rc28

package/dist/chunk-75EMT7BF.js

@@ -0,0 +1,616 @@
+import {
+  isPathAllowed,
+  normalizePath
+} from "./chunk-XZOXEIN4.js";
+import {
+  filterWorktreeRunSentinelPaths,
+  filterWorktreeRunSentinelStatusOutput
+} from "./chunk-2NMNFUQA.js";
+import {
+  shouldExcludePath
+} from "./chunk-5UBIFVRD.js";
+import {
+  RUN_BRANCH_LIST_PATTERNS
+} from "./chunk-F55YABKV.js";
+import {
+  readTrackedToolOutputRoots
+} from "./chunk-5EQN56OZ.js";
+import {
+  classifyRepoPath
+} from "./chunk-RBBTBCHX.js";
+import {
+  parseNameStatusZ,
+  parsePorcelainLinePath
+} from "./chunk-5KQETTNS.js";
+import {
+  GitExecError,
+  execGit
+} from "./chunk-MHLEZQQI.js";
+import {
+  mainCheckoutFromGitDirs
+} from "./chunk-JNMWYMC6.js";
+
+// src/automation/flywheel-git-isolation.ts
+import { execFileSync } from "child_process";
+import * as path from "path";
+import { execa } from "execa";
+var GIT_COMMAND_TIMEOUT_MS = Math.max(
+  3e4,
+  Number.parseInt(process.env.BUILD_GIT_COMMAND_TIMEOUT_MS ?? "", 10) || 12e4
+);
+function getRepoRoot() {
+  try {
+    const [gitDir, gitCommonDir, topLevel] = execFileSync(
+      "git",
+      ["rev-parse", "--path-format=absolute", "--git-dir", "--git-common-dir", "--show-toplevel"],
+      {
+        cwd: process.cwd(),
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "ignore"]
+      }
+    ).split("\n").map((line) => line.trim());
+    const mainCheckout = mainCheckoutFromGitDirs(gitDir, gitCommonDir);
+    if (mainCheckout) return mainCheckout;
+    if (!topLevel) throw new Error("git rev-parse returned no work-tree top level");
+    return topLevel;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(
+      `[flywheel-git-isolation] Failed to resolve git repo root from ${process.cwd()}: ${message}`
+    );
+  }
+}
+function isMissingWorktreeCwdError(error) {
+  const errnoError = error;
+  const combined = [errnoError.message, errnoError.shortMessage, errnoError.stderr].filter((value) => typeof value === "string" && value.length > 0).join("\n");
+  return /\bcwd\b/i.test(combined) && (typeof errnoError.code === "string" && errnoError.code === "ENOENT" || /\bENOENT\b/i.test(combined) || /no such file or directory/i.test(combined) || /\binvalid\b/i.test(combined));
+}
+async function createStageCheckpoint(stageId, cwd) {
+  if (!cwd || !path.isAbsolute(cwd)) {
+    throw new Error(`createStageCheckpoint requires absolute cwd, got: ${cwd}`);
+  }
+  const startCommit = await getCurrentCommit(cwd);
+  const untrackedFiles = await getUntrackedFiles(cwd);
+  return {
+    stageId,
+    startCommit,
+    untrackedFiles,
+    diff: void 0,
+    // Populated after stage execution
+    endCommit: void 0
+    // Populated if committed
+  };
+}
+async function rollbackToCheckpoint(checkpoint, cwd) {
+  if (!cwd || !path.isAbsolute(cwd)) {
+    throw new Error(`rollbackToCheckpoint requires absolute cwd, got: ${cwd}`);
+  }
+  await execa("git", ["reset", "--hard", checkpoint.startCommit], {
+    cwd,
+    stdio: "pipe",
+    timeout: GIT_COMMAND_TIMEOUT_MS
+  });
+  const currentUntracked = await getUntrackedFiles(cwd);
+  const filesToRemove = currentUntracked.filter((f) => !checkpoint.untrackedFiles.includes(f));
+  if (filesToRemove.length > 0) {
+    await execa("git", ["clean", "-fd", "--", ...filesToRemove], {
+      cwd,
+      stdio: "pipe",
+      timeout: GIT_COMMAND_TIMEOUT_MS
+    });
+  }
+}
+var WorktreeReuseDirtyError = class extends Error {
+  constructor(message, worktreePath, report) {
+    super(message);
+    this.worktreePath = worktreePath;
+    this.report = report;
+    this.name = "WorktreeReuseDirtyError";
+  }
+  worktreePath;
+  report;
+};
+var WorktreeReuseUnavailableError = class extends Error {
+  constructor(message, worktreePath, cause) {
+    super(message);
+    this.worktreePath = worktreePath;
+    this.cause = cause;
+    this.name = "WorktreeReuseUnavailableError";
+  }
+  worktreePath;
+  cause;
+};
+function isNotAGitRepositoryError(error) {
+  if (!error || typeof error !== "object") return false;
+  const messageSource = error.stderr ?? error.message ?? "";
+  const message = typeof messageSource === "string" ? messageSource : String(messageSource);
+  return /not a git repository/i.test(message);
+}
+async function inspectWorktreeCleanliness(worktreePath) {
+  if (!worktreePath || !path.isAbsolute(worktreePath)) {
+    throw new Error(
+      `inspectWorktreeCleanliness requires absolute worktree path, got: ${worktreePath}`
+    );
+  }
+  let statusOut;
+  try {
+    const result = await execa("git", ["status", "--porcelain"], {
+      cwd: worktreePath,
+      stdio: "pipe",
+      timeout: GIT_COMMAND_TIMEOUT_MS
+    });
+    statusOut = result.stdout;
+  } catch (error) {
+    if (isNotAGitRepositoryError(error)) {
+      throw new WorktreeReuseUnavailableError(
+        `Worktree ${worktreePath} is not a git repository; cannot inspect cleanliness for reuse`,
+        worktreePath,
+        error
+      );
+    }
+    throw error;
+  }
+  const trackedRoots = await readTrackedToolOutputRoots(worktreePath);
+  const dirtyFiles = filterWorktreeRunSentinelStatusOutput(statusOut).split("\n").filter((line) => line.trim().length > 0).map(parsePorcelainLinePath).filter((filePath) => !shouldExcludePath2(filePath, trackedRoots));
+  let addedLines = 0;
+  let removedLines = 0;
+  if (dirtyFiles.length > 0) {
+    try {
+      const { stdout: numstatOut } = await execa("git", ["diff", "--numstat", "HEAD"], {
+        cwd: worktreePath,
+        stdio: "pipe",
+        timeout: GIT_COMMAND_TIMEOUT_MS
+      });
+      for (const line of numstatOut.split("\n")) {
+        if (!line.trim()) continue;
+        const parts = line.split("	");
+        if (parts.length < 3) continue;
+        const filePath = parts[2] ?? "";
+        if (shouldExcludePath2(filePath, trackedRoots)) continue;
+        const added = Number.parseInt(parts[0] ?? "", 10);
+        const removed = Number.parseInt(parts[1] ?? "", 10);
+        if (Number.isFinite(added)) addedLines += added;
+        if (Number.isFinite(removed)) removedLines += removed;
+      }
+    } catch {
+    }
+  }
+  return {
+    isClean: dirtyFiles.length === 0,
+    dirtyFiles,
+    addedLines,
+    removedLines
+  };
+}
+async function assertWorktreeCleanForReuse(worktreePath, options = {}) {
+  const report = await inspectWorktreeCleanliness(worktreePath);
+  if (report.isClean) {
+    return report;
+  }
+  if (!options.reset) {
+    throw new WorktreeReuseDirtyError(
+      `Refusing to reuse worktree ${worktreePath}: ${report.dirtyFiles.length} uncommitted file(s) (+${report.addedLines}/-${report.removedLines}) from prior attempt`,
+      worktreePath,
+      report
+    );
+  }
+  await execa("git", ["reset", "--hard", "HEAD"], {
+    cwd: worktreePath,
+    stdio: "pipe",
+    timeout: GIT_COMMAND_TIMEOUT_MS
+  });
+  await execa("git", ["clean", "-fd"], {
+    cwd: worktreePath,
+    stdio: "pipe",
+    timeout: GIT_COMMAND_TIMEOUT_MS
+  });
+  const after = await inspectWorktreeCleanliness(worktreePath);
+  if (!after.isClean) {
+    throw new WorktreeReuseDirtyError(
+      `Worktree ${worktreePath} remains dirty after reset (${after.dirtyFiles.length} file(s))`,
+      worktreePath,
+      after
+    );
+  }
+  return after;
+}
+async function getCurrentCommit(cwd) {
+  if (!cwd || !path.isAbsolute(cwd)) {
+    throw new Error(`getCurrentCommit requires absolute cwd, got: ${cwd}`);
+  }
+  const { stdout } = await execa("git", ["rev-parse", "HEAD"], {
+    cwd,
+    stdio: "pipe",
+    timeout: GIT_COMMAND_TIMEOUT_MS
+  });
+  return stdout.trim();
+}
+async function getUntrackedFiles(cwd) {
+  if (!cwd || !path.isAbsolute(cwd)) {
+    throw new Error(`getUntrackedFiles requires absolute cwd, got: ${cwd}`);
+  }
+  const { stdout } = await execa("git", ["ls-files", "-z", "--others", "--exclude-standard"], {
+    cwd,
+    stdio: "pipe",
+    timeout: GIT_COMMAND_TIMEOUT_MS
+  });
+  return stdout.split("\0").filter((entry) => entry.length > 0);
+}
+function normalizeExplicitRepoFilePath(filePath) {
+  const normalized = normalizePath(filePath);
+  if (normalized.length === 0 || normalized === "." || normalized === ".." || normalized.startsWith("../") || normalized.includes("/../") || normalized.endsWith("/") || path.posix.isAbsolute(normalized) || // Windows drive / UNC after normalizePath slash conversion
+  /^[a-zA-Z]:\//.test(normalized) || normalized.startsWith("//")) {
+    return void 0;
+  }
+  return normalized;
+}
+async function getIgnoredExplicitFiles(cwd, paths = []) {
+  const candidates = [
+    ...new Set(
+      paths.map((entry) => normalizeExplicitRepoFilePath(entry)).filter((entry) => Boolean(entry))
+    )
+  ];
+  if (candidates.length === 0) return [];
+  const { stdout } = await execa(
+    "git",
+    ["ls-files", "-z", "--others", "--ignored", "--exclude-standard", "--", ...candidates],
+    {
+      cwd,
+      stdio: "pipe",
+      timeout: GIT_COMMAND_TIMEOUT_MS
+    }
+  );
+  return stdout.split("\0").filter((entry) => entry.length > 0);
+}
+async function getChangedFilesSince(fromCommit, cwd, options = {}) {
+  if (!cwd || !path.isAbsolute(cwd)) {
+    throw new Error(`getChangedFilesSince requires absolute cwd, got: ${cwd}`);
+  }
+  const changedFiles = /* @__PURE__ */ new Set();
+  const parseNameStatus = (output) => {
+    for (const entry of parseNameStatusZ(output)) changedFiles.add(entry.path);
+  };
+  const { stdout: cachedDiffOutput } = await execa(
+    "git",
+    ["diff", "--name-status", "-z", "-M", fromCommit, "--cached"],
+    { cwd, stdio: "pipe", timeout: GIT_COMMAND_TIMEOUT_MS }
+  );
+  parseNameStatus(cachedDiffOutput);
+  const { stdout: workingDiffOutput } = await execa(
+    "git",
+    ["diff", "--name-status", "-z", "-M", fromCommit],
+    {
+      cwd,
+      stdio: "pipe",
+      timeout: GIT_COMMAND_TIMEOUT_MS
+    }
+  );
+  parseNameStatus(workingDiffOutput);
+  const { stdout: untrackedOutput } = await execa(
+    "git",
+    ["ls-files", "-z", "--others", "--exclude-standard"],
+    {
+      cwd,
+      stdio: "pipe",
+      timeout: GIT_COMMAND_TIMEOUT_MS
+    }
+  );
+  for (const file of untrackedOutput.split("\0").filter((entry) => entry.length > 0)) {
+    const generatedArtifact = classifyRepoPath(file) === "generated-artifact";
+    if (generatedArtifact && !isPathAllowed(file, options.includeIgnoredPaths ?? [])) {
+      continue;
+    }
+    changedFiles.add(file);
+    options.untracked?.add(file);
+  }
+  for (const file of await getIgnoredExplicitFiles(cwd, options.includeIgnoredPaths)) {
+    changedFiles.add(file);
+    options.untracked?.add(file);
+  }
+  return filterWorktreeRunSentinelPaths([...changedFiles]);
+}
+function shouldExcludePath2(filePath, trackedRoots) {
+  return shouldExcludePath(normalizePath(filePath), trackedRoots);
+}
+async function getCleanChangedFiles(fromCommit, cwd) {
+  const allChanges = await getChangedFilesSince(fromCommit, cwd);
+  const trackedRoots = await readTrackedToolOutputRoots(cwd, fromCommit);
+  const changes = [];
+  const excludedSymlinks = [];
+  const excludedPatterns = [];
+  const fs = await import("fs/promises");
+  for (const filePath of allChanges) {
+    if (shouldExcludePath2(filePath, trackedRoots)) {
+      excludedPatterns.push(filePath);
+      continue;
+    }
+    try {
+      const fullPath = path.join(cwd, filePath);
+      const stats = await fs.lstat(fullPath);
+      if (stats.isSymbolicLink()) {
+        excludedSymlinks.push(filePath);
+        continue;
+      }
+    } catch {
+    }
+    changes.push(filePath);
+  }
+  return {
+    changes,
+    excludedSymlinks,
+    excludedPatterns,
+    isClean: excludedSymlinks.length === 0 && excludedPatterns.length === 0
+  };
+}
+async function getDiff(fromCommit, toCommit = "HEAD") {
+  const { stdout } = await execa("git", ["diff", fromCommit, toCommit], {
+    cwd: getRepoRoot(),
+    stdio: "pipe",
+    timeout: GIT_COMMAND_TIMEOUT_MS
+  });
+  return stdout;
+}
+async function isGitRepository() {
+  try {
+    await execa("git", ["rev-parse", "--git-dir"], {
+      cwd: getRepoRoot(),
+      stdio: "pipe",
+      timeout: GIT_COMMAND_TIMEOUT_MS
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function listFlywheelBranches(options) {
+  const { stdout } = await execa("git", ["branch", "--list", ...RUN_BRANCH_LIST_PATTERNS], {
+    cwd: options?.cwd ?? getRepoRoot(),
+    stdio: "pipe",
+    timeout: GIT_COMMAND_TIMEOUT_MS
+  });
+  const branches = [];
+  const lines = stdout.split("\n").filter((line) => line.trim().length > 0);
+  for (const line of lines) {
+    const name = line.replace(/^[*+]?\s*/, "").trim();
+    if (!name) continue;
+    let timestamp;
+    let ageDays;
+    const timestampMatch = name.match(/(\d{4}-\d{2}-\d{2}T\d{2}-\d{2}-\d{2})/);
+    if (timestampMatch?.[1]) {
+      const isoString = timestampMatch[1].replace(/-(\d{2})-(\d{2})$/, ":$1:$2");
+      timestamp = new Date(isoString);
+      if (!Number.isNaN(timestamp.getTime())) {
+        ageDays = Math.floor((Date.now() - timestamp.getTime()) / (1e3 * 60 * 60 * 24));
+      }
+    }
+    branches.push({
+      name,
+      timestamp,
+      ageDays
+    });
+  }
+  return branches;
+}
+async function commitWithAllowlist(worktreePath, allowlist, strictMode, commitMessage, stageId, mode, denylist = [], denylistMode = "strict", allowDenylist = [], options) {
+  const { computeCommitFiles, stageAndCommit } = await import("./commit-utils-3STAY7C7.js");
+  const { isSystemWritePath, normalizePath: normalizePath2 } = await import("./allowlist-utils-MZZKKXRD.js");
+  const { decideStageChangeScope } = await import("./flywheel-scope-decision-ALJUUNGG.js");
+  const effectiveMode = mode ?? (strictMode ? "strict" : "off");
+  const normalizedAllowlist = [...new Set(allowlist.map((file) => normalizePath2(file)))];
+  const normalizedDenylist = [...new Set(denylist.map((file) => normalizePath2(file)))];
+  const normalizedAllowDenylist = [...new Set(allowDenylist.map((file) => normalizePath2(file)))];
+  const {
+    eligibleFiles: rawEligibleFiles,
+    allStatusEntries,
+    skippedPaths
+  } = await computeCommitFiles({
+    worktreePath,
+    forceIncludeFiles: options?.skipForceInclude ? void 0 : normalizedAllowlist,
+    includeAllUntrackedPaths: true
+  });
+  if (skippedPaths.length > 0) {
+    return {
+      committed: false,
+      commitSha: null,
+      eligibleFiles: rawEligibleFiles,
+      filesToCommit: [],
+      error: `Stage '${stageId}' has ${skippedPaths.length} eligible path(s) that could not be staged: ${skippedPaths.join(", ")}`,
+      mode: effectiveMode
+    };
+  }
+  const systemStatusFiles = allStatusEntries.flatMap(
+    (entry) => [entry.originalPath, entry.path].filter(
+      (file) => typeof file === "string" && isSystemWritePath(file)
+    )
+  );
+  const eligibleFiles = [
+    ...new Set([...rawEligibleFiles, ...systemStatusFiles].map((file) => normalizePath2(file)))
+  ];
+  if (eligibleFiles.length === 0) {
+    return {
+      committed: false,
+      commitSha: null,
+      eligibleFiles: [],
+      filesToCommit: [],
+      reason: "no-changes",
+      mode: effectiveMode
+    };
+  }
+  const mutationOrigin = options?.mutationOrigin ?? "provider";
+  const decision = decideStageChangeScope({
+    changedPaths: eligibleFiles,
+    explicitScope: normalizedAllowlist,
+    allowlistMode: effectiveMode,
+    denylistPolicy: {
+      denylist: normalizedDenylist,
+      mode: denylistMode,
+      allow: normalizedAllowDenylist
+    },
+    mutationOrigin
+  });
+  const violations = decision.allowlistViolations;
+  const denylistViolations = decision.denylistViolations;
+  const systemFiles = mutationOrigin === "coordinator" ? eligibleFiles.filter((file) => isSystemWritePath(file)) : [];
+  if (decision.disposition === "block") {
+    return {
+      committed: false,
+      commitSha: null,
+      eligibleFiles,
+      filesToCommit: [],
+      error: `Stage '${stageId}' modified ${denylistViolations.length} denylisted file(s): ${decision.reason}`,
+      denylistViolations,
+      violations: violations.length > 0 ? violations : void 0,
+      mode: effectiveMode
+    };
+  }
+  if (decision.disposition === "rollback") {
+    const emptyScope = normalizedAllowlist.length === 0;
+    return {
+      committed: false,
+      commitSha: null,
+      eligibleFiles,
+      filesToCommit: [],
+      error: emptyScope ? `Strict mode: stage '${stageId}' changed ${violations.length} files but no allowlist defined` : `Stage '${stageId}' modified ${violations.length} non-allowlisted file(s)`,
+      violations,
+      denylistViolations: denylistViolations.length > 0 ? denylistViolations : void 0,
+      mode: effectiveMode
+    };
+  }
+  const filesToCommit = decision.permittedPaths;
+  if (filesToCommit.length === 0) {
+    return {
+      committed: false,
+      commitSha: null,
+      eligibleFiles,
+      filesToCommit: [],
+      reason: "scope-filtered",
+      violations: violations.length > 0 ? violations : void 0,
+      denylistViolations: denylistViolations.length > 0 ? denylistViolations : void 0,
+      mode: effectiveMode
+    };
+  }
+  const result = await stageAndCommit({
+    worktreePath,
+    filesToStage: filesToCommit,
+    commitMessage,
+    forceAdd: true
+  });
+  return {
+    committed: result.committed,
+    commitSha: result.commitSha ?? null,
+    eligibleFiles,
+    filesToCommit,
+    reason: result.reason,
+    violations: violations.length > 0 ? violations : void 0,
+    denylistViolations: denylistViolations.length > 0 ? denylistViolations : void 0,
+    mode: effectiveMode,
+    systemFiles: systemFiles.length > 0 ? systemFiles : void 0
+  };
+}
+var ConflictError = class extends Error {
+  constructor(message, conflictedFiles) {
+    super(message);
+    this.conflictedFiles = conflictedFiles;
+    this.name = "ConflictError";
+  }
+  conflictedFiles;
+};
+async function tryCherryPickCleanup(args, cwd) {
+  try {
+    return (await execGit(args, { cwd, timeoutMs: GIT_COMMAND_TIMEOUT_MS })).exitCode === 0;
+  } catch (error) {
+    if (error instanceof GitExecError) return false;
+    throw error;
+  }
+}
+async function abortCherryPickOrReset(worktreePath) {
+  if (await tryCherryPickCleanup(["cherry-pick", "--abort"], worktreePath)) {
+    return { abortFailed: false };
+  }
+  return { abortFailed: !await tryCherryPickCleanup(["reset", "--hard", "HEAD"], worktreePath) };
+}
+async function cherryPickCommit(worktreePath, commitSha) {
+  try {
+    const cherryPickResult = await execGit(["cherry-pick", commitSha], {
+      cwd: worktreePath,
+      timeoutMs: GIT_COMMAND_TIMEOUT_MS
+    });
+    if (cherryPickResult.exitCode === 0) {
+      return;
+    }
+    const { parseGitStatus } = await import("./parse-git-status-7PIYFPS2.js");
+    let statusOutput;
+    try {
+      const statusResult = await execGit(["status", "--porcelain"], {
+        cwd: worktreePath,
+        timeoutMs: GIT_COMMAND_TIMEOUT_MS
+      });
+      if (statusResult.exitCode !== 0) throw new Error(statusResult.stderr);
+      statusOutput = filterWorktreeRunSentinelStatusOutput(statusResult.stdout);
+    } catch (error) {
+      if (cherryPickResult.exitCode === 0 && isMissingWorktreeCwdError(error)) {
+        return;
+      }
+      throw error;
+    }
+    const statusEntries = parseGitStatus(statusOutput);
+    const conflictedFiles = statusEntries.filter((entry) => {
+      const idx = entry.indexStatus;
+      const wt = entry.worktreeStatus;
+      return idx === "U" || wt === "U" || // Unmerged
+      idx === "A" && wt === "A" || // Both added
+      idx === "D" && wt === "D";
+    }).map((entry) => entry.path);
+    if (conflictedFiles.length > 0) {
+      const { abortFailed } = await abortCherryPickOrReset(worktreePath);
+      const message = `Cherry-pick conflict: ${conflictedFiles.length} file(s) conflicted${abortFailed ? " (WARNING: cherry-pick cleanup failed; worktree may be poisoned)" : ""}`;
+      throw new ConflictError(message, conflictedFiles);
+    }
+    if (cherryPickResult.exitCode !== 0) {
+      const output = `${cherryPickResult.stdout ?? ""}
+${cherryPickResult.stderr ?? ""}`;
+      const isEmptyPick = output.includes("cherry-pick is now empty") || output.includes("The previous cherry-pick is now empty") || output.includes("nothing to commit") || output.includes("previous cherry-pick is now empty");
+      if (isEmptyPick) {
+        if (!await tryCherryPickCleanup(["cherry-pick", "--skip"], worktreePath)) {
+          await tryCherryPickCleanup(["cherry-pick", "--abort"], worktreePath);
+        }
+        return;
+      }
+      await tryCherryPickCleanup(["cherry-pick", "--abort"], worktreePath);
+      throw new Error(`Cherry-pick failed (non-conflict): ${output.trim() || "unknown error"}`);
+    }
+  } catch (error) {
+    if (error instanceof ConflictError) {
+      throw error;
+    }
+    try {
+      await execGit(["cherry-pick", "--abort"], {
+        cwd: worktreePath,
+        timeoutMs: GIT_COMMAND_TIMEOUT_MS
+      });
+    } catch {
+    }
+    throw new Error(
+      `Cherry-pick failed: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+
+export {
+  isMissingWorktreeCwdError,
+  createStageCheckpoint,
+  rollbackToCheckpoint,
+  WorktreeReuseDirtyError,
+  WorktreeReuseUnavailableError,
+  inspectWorktreeCleanliness,
+  assertWorktreeCleanForReuse,
+  getChangedFilesSince,
+  getCleanChangedFiles,
+  getDiff,
+  isGitRepository,
+  listFlywheelBranches,
+  commitWithAllowlist,
+  ConflictError,
+  cherryPickCommit
+};
+//# sourceMappingURL=chunk-75EMT7BF.js.map