issue-flow 0.11.0 → 0.12.0

package/dist/chunk-42PJFMAR.js

@@ -0,0 +1,605 @@
+#!/usr/bin/env node
+import {
+  RETRY_CONFIG_KEYS,
+  getGlobalRoot,
+  getProjectRoot,
+  globalConfigSchema,
+  resilienceConfigSchema,
+  resolveIssuePaths,
+  run
+} from "./chunk-DIDUVL6O.js";
+import {
+  printWarning
+} from "./chunk-BYZDPR7N.js";
+import {
+  issuesConfigSchema,
+  policyConfigInputSchema,
+  policyConfigSchema,
+  prReviewConfigSchema,
+  webConfigSchema
+} from "./chunk-CD5ULRVC.js";
+
+// src/config.ts
+import { readFile } from "fs/promises";
+import { platform } from "os";
+import { join } from "path";
+var DEFAULTS = {
+  retryLimit: 10,
+  retryForever: false,
+  backoffBaseSeconds: 30,
+  backoffMaxSeconds: 900
+};
+function createConfig(options) {
+  return {
+    issueNumber: options.issueNumber,
+    maxIterations: options.maxIterations,
+    retryLimit: options.retryLimit ?? DEFAULTS.retryLimit,
+    retryForever: options.retryForever ?? DEFAULTS.retryForever,
+    backoffBaseSeconds: options.backoffBaseSeconds ?? DEFAULTS.backoffBaseSeconds,
+    backoffMaxSeconds: options.backoffMaxSeconds ?? DEFAULTS.backoffMaxSeconds,
+    // Left absent (rather than defaulted to an empty string) so the execute
+    // prompt keeps its historical commit format unless a queue asks otherwise.
+    ...options.commitScope === void 0 ? {} : { commitScope: options.commitScope }
+  };
+}
+async function resolvePaths(config, scriptDir) {
+  const projectRoot = await getProjectRoot();
+  if (config.issueNumber) {
+    const issuePaths = await resolveIssuePaths(config.issueNumber, { projectRoot });
+    return {
+      prdFile: issuePaths.tasksFile,
+      progressFile: issuePaths.progressFile,
+      archiveDir: issuePaths.archiveDir,
+      lastBranchFile: issuePaths.lastBranchFile,
+      projectRoot
+    };
+  }
+  const base = scriptDir ?? projectRoot;
+  return {
+    prdFile: join(base, "prd.json"),
+    progressFile: join(base, "progress.txt"),
+    archiveDir: join(base, "archive"),
+    lastBranchFile: join(base, ".last-branch"),
+    projectRoot
+  };
+}
+function getInstallHint(pkg) {
+  const os = platform();
+  if (os === "darwin") {
+    return `brew install ${pkg}`;
+  }
+  if (os === "linux") {
+    return `apt install ${pkg}  (or your distro's package manager)`;
+  }
+  if (os === "win32") {
+    return `winget install ${pkg}  (or choco install ${pkg})`;
+  }
+  return `install ${pkg} using your system package manager`;
+}
+async function validateDependencies() {
+  const errors = [];
+  const gitResult = await run("git", ["--version"]);
+  if (gitResult.exitCode !== 0) {
+    errors.push(`  - git  (install with: ${getInstallHint("git")})`);
+  }
+  const claudeResult = await run("claude", ["--version"]);
+  if (claudeResult.exitCode !== 0) {
+    errors.push("  - claude  (install with: npm install -g @anthropic-ai/claude-code)");
+  }
+  return errors;
+}
+var PROJECT_CONFIG_FILENAME = ".issue-flow.json";
+var WEB_CONFIG_FILENAME = PROJECT_CONFIG_FILENAME;
+async function readProjectConfigFile(projectRoot, warn) {
+  let root = projectRoot;
+  if (root === void 0) {
+    try {
+      root = await getProjectRoot();
+    } catch {
+      return null;
+    }
+  }
+  const filePath = join(root, PROJECT_CONFIG_FILENAME);
+  let raw;
+  try {
+    raw = await readFile(filePath, "utf-8");
+  } catch {
+    return null;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    warn(`Ignoring ${PROJECT_CONFIG_FILENAME}: invalid JSON.`);
+    return null;
+  }
+  if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+    warn(`Ignoring ${PROJECT_CONFIG_FILENAME}: expected a JSON object.`);
+    return null;
+  }
+  return parsed;
+}
+var GLOBAL_CONFIG_FILENAME = "config.json";
+async function loadGlobalConfig(options = {}) {
+  const warn = options.warn ?? printWarning;
+  let root;
+  try {
+    root = options.globalRoot ?? getGlobalRoot({ env: options.env ?? process.env });
+  } catch (err) {
+    warn(`Ignoring ${GLOBAL_CONFIG_FILENAME}: ${err.message}`);
+    return {};
+  }
+  const filePath = join(root, GLOBAL_CONFIG_FILENAME);
+  let raw;
+  try {
+    raw = await readFile(filePath, "utf-8");
+  } catch (err) {
+    if (err.code !== "ENOENT") {
+      warn(`Ignoring ${GLOBAL_CONFIG_FILENAME}: ${err.message}`);
+    }
+    return {};
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    warn(`Ignoring ${GLOBAL_CONFIG_FILENAME}: invalid JSON.`);
+    return {};
+  }
+  if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+    warn(`Ignoring ${GLOBAL_CONFIG_FILENAME}: expected a JSON object.`);
+    return {};
+  }
+  const config = {};
+  for (const [key, value] of Object.entries(parsed)) {
+    const result = globalConfigSchema.safeParse({ [key]: value });
+    if (!result.success) {
+      warn(
+        `Ignoring "${key}" key of ${GLOBAL_CONFIG_FILENAME}: ${result.error.issues[0]?.message ?? "invalid value"}.`
+      );
+      continue;
+    }
+    Object.assign(config, result.data);
+  }
+  return config;
+}
+function mergeConfigLayers(layers) {
+  const merged = {};
+  for (const layer of [
+    layers.defaults,
+    layers.discovered,
+    layers.global,
+    layers.project,
+    layers.env,
+    layers.cli
+  ]) {
+    for (const [key, value] of Object.entries(layer ?? {})) {
+      if (value !== void 0) {
+        merged[key] = value;
+      }
+    }
+  }
+  return merged;
+}
+var webCliOverrides = {};
+function setWebCliOverrides(overrides) {
+  webCliOverrides = overrides;
+}
+var FALSY_ENV_VALUES = /* @__PURE__ */ new Set(["", "0", "false", "no", "off"]);
+function parseBooleanEnv(value) {
+  return !FALSY_ENV_VALUES.has(value.trim().toLowerCase());
+}
+function readNumberEnv(env, name, warn) {
+  const raw = env[name];
+  if (raw === void 0) {
+    return void 0;
+  }
+  const parsed = Number(raw);
+  if (!Number.isFinite(parsed)) {
+    warn(`Ignoring ${name}="${raw}": not a number.`);
+    return void 0;
+  }
+  return parsed;
+}
+function readWebConfigEnv(env, warn) {
+  const layer = {};
+  if (env.ISSUE_FLOW_WEB !== void 0) {
+    layer.enabled = parseBooleanEnv(env.ISSUE_FLOW_WEB);
+  }
+  const port = readNumberEnv(env, "ISSUE_FLOW_WEB_PORT", warn);
+  if (port !== void 0) {
+    layer.port = port;
+  }
+  if (env.ISSUE_FLOW_WEB_HOST !== void 0) {
+    layer.host = env.ISSUE_FLOW_WEB_HOST;
+  }
+  const refresh = readNumberEnv(env, "ISSUE_FLOW_WEB_REFRESH", warn);
+  if (refresh !== void 0) {
+    layer.refreshSeconds = refresh;
+  }
+  const logLimit = readNumberEnv(env, "ISSUE_FLOW_WEB_LOG_LIMIT", warn);
+  if (logLimit !== void 0) {
+    layer.logLimit = logLimit;
+  }
+  return layer;
+}
+async function readWebConfigFile(projectRoot, warn) {
+  const file = await readProjectConfigFile(projectRoot, warn);
+  const web = file?.web;
+  if (web === void 0) {
+    return {};
+  }
+  const result = webConfigSchema.partial().safeParse(web);
+  if (!result.success) {
+    warn(
+      `Ignoring "web" key of ${PROJECT_CONFIG_FILENAME}: ${result.error.issues[0]?.message ?? "invalid value"}.`
+    );
+    return {};
+  }
+  return result.data;
+}
+async function loadWebConfig(options = {}) {
+  const warn = options.warn ?? printWarning;
+  const cli = options.cli ?? webCliOverrides;
+  const env = options.env ?? process.env;
+  const fileLayer = await readWebConfigFile(options.projectRoot, warn);
+  const envLayer = readWebConfigEnv(env, warn);
+  const merged = { ...fileLayer, ...envLayer, ...cli };
+  const result = webConfigSchema.safeParse(merged);
+  if (result.success) {
+    return result.data;
+  }
+  warn(
+    `Invalid web monitoring configuration (${result.error.issues[0]?.message ?? "invalid value"}); using defaults.`
+  );
+  return webConfigSchema.parse({});
+}
+var issuesCliOverrides = {};
+function setIssuesCliOverrides(overrides) {
+  issuesCliOverrides = overrides;
+}
+async function readIssuesConfigFile(projectRoot, warn) {
+  const file = await readProjectConfigFile(projectRoot, warn);
+  const issues = file?.issues;
+  if (issues === void 0) {
+    return {};
+  }
+  const result = issuesConfigSchema.partial().safeParse(issues);
+  if (!result.success) {
+    warn(
+      `Ignoring "issues" key of ${PROJECT_CONFIG_FILENAME}: ${result.error.issues[0]?.message ?? "invalid value"}.`
+    );
+    return {};
+  }
+  return result.data;
+}
+async function loadIssuesConfig(options = {}) {
+  const warn = options.warn ?? printWarning;
+  const cli = options.cli ?? issuesCliOverrides;
+  const fileLayer = await readIssuesConfigFile(options.projectRoot, warn);
+  const merged = { ...fileLayer, ...cli };
+  const result = issuesConfigSchema.safeParse(merged);
+  if (result.success) {
+    return result.data;
+  }
+  warn(
+    `Invalid Issue provider configuration (${result.error.issues[0]?.message ?? "invalid value"}); using defaults.`
+  );
+  return issuesConfigSchema.parse({});
+}
+function readPrReviewConfigEnv(env) {
+  const publisher = env.ISSUE_FLOW_PR_REVIEW_PUBLISHER;
+  return publisher === void 0 ? {} : { publisher };
+}
+async function readPrReviewConfigFile(projectRoot, warn) {
+  const file = await readProjectConfigFile(projectRoot, warn);
+  const prReview = file?.prReview;
+  if (prReview === void 0) {
+    return {};
+  }
+  const result = prReviewConfigSchema.partial().safeParse(prReview);
+  if (!result.success) {
+    warn(
+      `Ignoring "prReview" key of ${PROJECT_CONFIG_FILENAME}: ${result.error.issues[0]?.message ?? "invalid value"}.`
+    );
+    return {};
+  }
+  return result.data;
+}
+async function loadPrReviewConfig(options = {}) {
+  const warn = options.warn ?? printWarning;
+  const env = options.env ?? process.env;
+  const fileLayer = await readPrReviewConfigFile(options.projectRoot, warn);
+  const envLayer = readPrReviewConfigEnv(env);
+  const merged = { ...fileLayer, ...envLayer, ...options.cli ?? {} };
+  const result = prReviewConfigSchema.safeParse(merged);
+  if (result.success) {
+    return result.data;
+  }
+  warn(
+    `Invalid PR review configuration (${result.error.issues[0]?.message ?? "invalid value"}); using defaults.`
+  );
+  return prReviewConfigSchema.parse({});
+}
+var policyCliOverrides = {};
+function setPolicyCliOverrides(overrides) {
+  policyCliOverrides = overrides;
+}
+function dropNullish(layer) {
+  const result = {};
+  for (const [key, value] of Object.entries(layer ?? {})) {
+    if (value !== void 0 && value !== null) {
+      result[key] = value;
+    }
+  }
+  return result;
+}
+function readPolicyConfigEnv(env, warn) {
+  const layer = {};
+  if (env.ISSUE_FLOW_POLICY !== void 0) {
+    layer.enabled = parseBooleanEnv(env.ISSUE_FLOW_POLICY);
+  }
+  const budget = readNumberEnv(env, "ISSUE_FLOW_POLICY_CONTEXT_BUDGET", warn);
+  if (budget !== void 0) {
+    layer.contextBudget = budget;
+  }
+  const issues = {};
+  if (env.ISSUE_FLOW_POLICY_ISSUE_TITLE_CONVENTION !== void 0) {
+    issues.titleConvention = env.ISSUE_FLOW_POLICY_ISSUE_TITLE_CONVENTION;
+  }
+  if (Object.keys(issues).length > 0) layer.issues = issues;
+  const pullRequests = {};
+  if (env.ISSUE_FLOW_POLICY_BASE_BRANCH !== void 0) {
+    pullRequests.baseBranch = env.ISSUE_FLOW_POLICY_BASE_BRANCH;
+  }
+  if (env.ISSUE_FLOW_POLICY_PR_TITLE_CONVENTION !== void 0) {
+    pullRequests.titleConvention = env.ISSUE_FLOW_POLICY_PR_TITLE_CONVENTION;
+  }
+  if (Object.keys(pullRequests).length > 0) layer.pullRequests = pullRequests;
+  const git = {};
+  if (env.ISSUE_FLOW_POLICY_BRANCH_CONVENTION !== void 0) {
+    git.branchConvention = env.ISSUE_FLOW_POLICY_BRANCH_CONVENTION;
+  }
+  if (env.ISSUE_FLOW_POLICY_COMMIT_CONVENTION !== void 0) {
+    git.commitConvention = env.ISSUE_FLOW_POLICY_COMMIT_CONVENTION;
+  }
+  if (Object.keys(git).length > 0) layer.git = git;
+  const invalid = Object.entries(layer).find(
+    ([, value]) => typeof value === "object" && value !== null && Object.values(value).includes("")
+  );
+  if (invalid !== void 0) {
+    warn(`Ignoring empty ISSUE_FLOW_POLICY_* value in "${invalid[0]}".`);
+  }
+  return layer;
+}
+async function readPolicyConfigFile(projectRoot, warn) {
+  const file = await readProjectConfigFile(projectRoot, warn);
+  const policy = file?.policy;
+  if (policy === void 0) {
+    return {};
+  }
+  const result = policyConfigInputSchema.safeParse(policy);
+  if (!result.success) {
+    warn(
+      `Ignoring "policy" key of ${PROJECT_CONFIG_FILENAME}: ${result.error.issues[0]?.message ?? "invalid value"}.`
+    );
+    return {};
+  }
+  return result.data;
+}
+async function loadPolicyConfig(options = {}) {
+  const warn = options.warn ?? printWarning;
+  const cli = options.cli ?? policyCliOverrides;
+  const env = options.env ?? process.env;
+  const fileLayer = await readPolicyConfigFile(options.projectRoot, warn);
+  const envLayer = readPolicyConfigEnv(env, warn);
+  const merged = {
+    ...mergeConfigLayers({
+      project: dropNullish({ enabled: fileLayer.enabled, contextBudget: fileLayer.contextBudget }),
+      env: dropNullish({ enabled: envLayer.enabled, contextBudget: envLayer.contextBudget }),
+      cli: dropNullish({ enabled: cli.enabled, contextBudget: cli.contextBudget })
+    }),
+    discovery: mergeConfigLayers({
+      project: dropNullish(fileLayer.discovery),
+      env: dropNullish(envLayer.discovery),
+      cli: dropNullish(cli.discovery)
+    }),
+    issues: mergeConfigLayers({
+      project: dropNullish(fileLayer.issues),
+      env: dropNullish(envLayer.issues),
+      cli: dropNullish(cli.issues)
+    }),
+    pullRequests: mergeConfigLayers({
+      project: dropNullish(fileLayer.pullRequests),
+      env: dropNullish(envLayer.pullRequests),
+      cli: dropNullish(cli.pullRequests)
+    }),
+    git: mergeConfigLayers({
+      project: dropNullish(fileLayer.git),
+      env: dropNullish(envLayer.git),
+      cli: dropNullish(cli.git)
+    })
+  };
+  const result = policyConfigSchema.safeParse(merged);
+  if (result.success) {
+    return result.data;
+  }
+  warn(
+    `Invalid repository policy configuration (${result.error.issues[0]?.message ?? "invalid value"}); using defaults.`
+  );
+  return policyConfigSchema.parse({});
+}
+var resilienceCliOverrides = {};
+function setResilienceCliOverrides(overrides) {
+  resilienceCliOverrides = overrides;
+}
+function mergeResilienceSection(layers) {
+  const merged = mergeConfigLayers({
+    global: layers[0],
+    project: layers[1],
+    env: layers[2],
+    cli: layers[3]
+  });
+  return Object.keys(merged).length > 0 ? merged : void 0;
+}
+function mergeResilienceRetry(layers) {
+  const merged = {};
+  for (const key of RETRY_CONFIG_KEYS) {
+    const entry = mergeResilienceSection(layers.map((layer) => layer?.[key]));
+    if (entry !== void 0) {
+      merged[key] = entry;
+    }
+  }
+  return Object.keys(merged).length > 0 ? merged : void 0;
+}
+function parseResilienceLayer(value, origin, warn) {
+  const result = resilienceConfigSchema.safeParse(value);
+  if (!result.success) {
+    warn(
+      `Ignoring "resilience" key of ${origin}: ${result.error.issues[0]?.message ?? "invalid value"}.`
+    );
+    return {};
+  }
+  return result.data;
+}
+async function readResilienceConfigFile(projectRoot, warn) {
+  const file = await readProjectConfigFile(projectRoot, warn);
+  const resilience = file?.resilience;
+  if (resilience === void 0) {
+    return {};
+  }
+  return parseResilienceLayer(resilience, PROJECT_CONFIG_FILENAME, warn);
+}
+function readResilienceConfigEnv(env, warn) {
+  const layer = {};
+  if (env.ISSUE_FLOW_RESILIENCE_PROFILE !== void 0) {
+    layer.profile = env.ISSUE_FLOW_RESILIENCE_PROFILE;
+  }
+  if (env.ISSUE_FLOW_RESILIENCE_FAILOVER_ON_AUTH !== void 0) {
+    layer.failoverOnAuth = parseBooleanEnv(env.ISSUE_FLOW_RESILIENCE_FAILOVER_ON_AUTH);
+  }
+  const retry = env.ISSUE_FLOW_RESILIENCE_RETRY;
+  if (retry !== void 0) {
+    try {
+      layer.retry = JSON.parse(retry);
+    } catch {
+      warn("Ignoring ISSUE_FLOW_RESILIENCE_RETRY: invalid JSON.");
+    }
+  }
+  const providers = {};
+  if (env.ISSUE_FLOW_RESILIENCE_FAILOVER !== void 0) {
+    providers.failover = parseBooleanEnv(env.ISSUE_FLOW_RESILIENCE_FAILOVER);
+  }
+  if (env.ISSUE_FLOW_RESILIENCE_PROVIDER_CHAIN !== void 0) {
+    providers.chain = env.ISSUE_FLOW_RESILIENCE_PROVIDER_CHAIN.split(",").map((name) => name.trim()).filter((name) => name !== "");
+  }
+  const cooldown = readNumberEnv(env, "ISSUE_FLOW_RESILIENCE_PROVIDER_COOLDOWN_MS", warn);
+  if (cooldown !== void 0) {
+    providers.cooldownMs = cooldown;
+  }
+  if (Object.keys(providers).length > 0) layer.providers = providers;
+  const queue = {};
+  if (env.ISSUE_FLOW_RESILIENCE_ON_ISSUE_FAILURE !== void 0) {
+    queue.onIssueFailure = env.ISSUE_FLOW_RESILIENCE_ON_ISSUE_FAILURE;
+  }
+  const maxIssueAttempts = readNumberEnv(env, "ISSUE_FLOW_RESILIENCE_MAX_ISSUE_ATTEMPTS", warn);
+  if (maxIssueAttempts !== void 0) {
+    queue.maxIssueAttempts = maxIssueAttempts;
+  }
+  if (Object.keys(queue).length > 0) layer.queue = queue;
+  const inactivity = readNumberEnv(env, "ISSUE_FLOW_RESILIENCE_INACTIVITY_TIMEOUT_MS", warn);
+  if (inactivity !== void 0) {
+    layer.watchdog = { inactivityTimeoutMs: inactivity };
+  }
+  const journal = {};
+  if (env.ISSUE_FLOW_RESILIENCE_JOURNAL !== void 0) {
+    journal.enabled = parseBooleanEnv(env.ISSUE_FLOW_RESILIENCE_JOURNAL);
+  }
+  const journalBytes = readNumberEnv(env, "ISSUE_FLOW_RESILIENCE_JOURNAL_MAX_BYTES", warn);
+  if (journalBytes !== void 0) {
+    journal.maxFileBytes = journalBytes;
+  }
+  if (Object.keys(journal).length > 0) layer.journal = journal;
+  if (env.ISSUE_FLOW_RESILIENCE_AUTO_DECOMPOSE !== void 0) {
+    layer.decompose = { auto: parseBooleanEnv(env.ISSUE_FLOW_RESILIENCE_AUTO_DECOMPOSE) };
+  }
+  if (Object.keys(layer).length === 0) {
+    return {};
+  }
+  return parseResilienceLayer(layer, "the ISSUE_FLOW_RESILIENCE_* environment", warn);
+}
+async function loadResilienceConfig(options = {}) {
+  const warn = options.warn ?? printWarning;
+  const env = options.env ?? process.env;
+  const cli = options.cli ?? resilienceCliOverrides;
+  const globalLayer = options.global ?? (await loadGlobalConfig({
+    env,
+    ...options.globalRoot === void 0 ? {} : { globalRoot: options.globalRoot },
+    warn
+  })).resilience ?? {};
+  const projectLayer = await readResilienceConfigFile(options.projectRoot, warn);
+  const envLayer = readResilienceConfigEnv(env, warn);
+  const layers = [globalLayer, projectLayer, envLayer, cli];
+  const scalars = mergeConfigLayers({
+    global: { profile: globalLayer.profile, failoverOnAuth: globalLayer.failoverOnAuth },
+    project: { profile: projectLayer.profile, failoverOnAuth: projectLayer.failoverOnAuth },
+    env: { profile: envLayer.profile, failoverOnAuth: envLayer.failoverOnAuth },
+    cli: { profile: cli.profile, failoverOnAuth: cli.failoverOnAuth }
+  });
+  const retry = mergeResilienceRetry(layers.map((layer) => layer.retry));
+  const providers = mergeResilienceSection(layers.map((layer) => layer.providers));
+  const queue = mergeResilienceSection(layers.map((layer) => layer.queue));
+  const watchdog = mergeResilienceSection(layers.map((layer) => layer.watchdog));
+  const journal = mergeResilienceSection(layers.map((layer) => layer.journal));
+  const decompose = mergeResilienceSection(layers.map((layer) => layer.decompose));
+  return {
+    ...scalars,
+    ...retry === void 0 ? {} : { retry },
+    ...providers === void 0 ? {} : { providers },
+    ...queue === void 0 ? {} : { queue },
+    ...watchdog === void 0 ? {} : { watchdog },
+    ...journal === void 0 ? {} : { journal },
+    ...decompose === void 0 ? {} : { decompose }
+  };
+}
+var activeResilienceConfig = {};
+function getActiveResilienceConfig() {
+  return activeResilienceConfig;
+}
+function setActiveResilienceConfig(config) {
+  activeResilienceConfig = config;
+}
+async function initResilienceConfig(options = {}) {
+  try {
+    activeResilienceConfig = await loadResilienceConfig(options);
+  } catch {
+    activeResilienceConfig = {};
+  }
+  return activeResilienceConfig;
+}
+
+export {
+  DEFAULTS,
+  createConfig,
+  resolvePaths,
+  getInstallHint,
+  validateDependencies,
+  PROJECT_CONFIG_FILENAME,
+  WEB_CONFIG_FILENAME,
+  GLOBAL_CONFIG_FILENAME,
+  loadGlobalConfig,
+  mergeConfigLayers,
+  setWebCliOverrides,
+  loadWebConfig,
+  setIssuesCliOverrides,
+  loadIssuesConfig,
+  loadPrReviewConfig,
+  setPolicyCliOverrides,
+  loadPolicyConfig,
+  setResilienceCliOverrides,
+  loadResilienceConfig,
+  getActiveResilienceConfig,
+  setActiveResilienceConfig,
+  initResilienceConfig
+};
+//# sourceMappingURL=chunk-42PJFMAR.js.map