issue-flow 0.11.0 → 0.12.0

package/dist/{chunk-HC2MT7BX.js → chunk-BYZDPR7N.js}

@@ -1,332 +1,7 @@
 #!/usr/bin/env node
-
-// src/policy/schemas.ts
-import { z } from "zod";
-var policyDiscoveryConfigSchema = z.object({
-  issueTemplates: z.boolean().default(true),
-  pullRequestTemplate: z.boolean().default(true),
-  docs: z.boolean().default(true),
-  codeowners: z.boolean().default(true),
-  labels: z.boolean().default(true),
-  issueTypes: z.boolean().default(true)
-});
-var policyIssuesDeclarationSchema = z.object({
-  titleConvention: z.string().min(1).optional(),
-  /**
-   * Whether Issue Flow may create a label the repository does not have.
-   *
-   * `.optional()` rather than `.default(false)`: the resolved declarations must
-   * stay "only what was written", or the group would always look declared and
-   * `sources` would report a provenance nobody asked for. The effective default
-   * — false — lives at the call site.
-   *
-   * That default is a deliberate change of behaviour: creating taxonomy without
-   * asking is the defect this exists to stop. A repository that wants the old
-   * behaviour opts back into it.
-   */
-  allowLabelCreation: z.boolean().optional()
-});
-var policyPullRequestsDeclarationSchema = z.object({
-  baseBranch: z.string().min(1).optional(),
-  titleConvention: z.string().min(1).optional()
-});
-var policyGitDeclarationSchema = z.object({
-  branchConvention: z.string().min(1).optional(),
-  commitConvention: z.string().min(1).optional()
-});
-var policyConfigSchema = z.object({
-  enabled: z.boolean().default(true),
-  /**
-   * Token budget for the `__REPO_POLICY__` projection. Sections above it are
-   * replaced whole by a pointer rather than truncated — see
-   * `policy/placeholders.ts`.
-   */
-  contextBudget: z.number().int().positive().default(1500),
-  discovery: policyDiscoveryConfigSchema.prefault({}),
-  issues: policyIssuesDeclarationSchema.prefault({}),
-  pullRequests: policyPullRequestsDeclarationSchema.prefault({}),
-  git: policyGitDeclarationSchema.prefault({})
-});
-var policyConfigInputSchema = z.object({
-  enabled: z.boolean().optional(),
-  contextBudget: z.number().int().positive().optional(),
-  // Spelled out rather than `policyDiscoveryConfigSchema.partial()`: in zod 4
-  // a `.default()` survives `.partial()`, so every toggle would come back
-  // materialized and the input layer would stop meaning "what the user wrote".
-  discovery: z.object({
-    issueTemplates: z.boolean().optional(),
-    pullRequestTemplate: z.boolean().optional(),
-    docs: z.boolean().optional(),
-    codeowners: z.boolean().optional(),
-    labels: z.boolean().optional(),
-    issueTypes: z.boolean().optional()
-  }).optional(),
-  issues: z.object({ titleConvention: z.string().nullish(), allowLabelCreation: z.boolean().optional() }).optional(),
-  pullRequests: z.object({ baseBranch: z.string().nullish(), titleConvention: z.string().nullish() }).optional(),
-  git: z.object({ branchConvention: z.string().nullish(), commitConvention: z.string().nullish() }).optional()
-});
-
-// src/schemas.ts
-import { z as z2 } from "zod";
-var claudeUsageSchema = z2.object({
-  inputTokens: z2.number().optional(),
-  outputTokens: z2.number().optional(),
-  cacheReadTokens: z2.number().optional(),
-  cacheCreationTokens: z2.number().optional(),
-  costUsd: z2.number().optional()
-});
-var userStoryStatusSchema = z2.enum(["backlog", "in_progress", "in_review", "done"]);
-var storyStageSchema = z2.enum([
-  "pending",
-  "executing",
-  "awaiting_review",
-  "in_review",
-  "in_correction",
-  "done",
-  "failed"
-]);
-var userStorySchema = z2.object({
-  id: z2.string(),
-  title: z2.string(),
-  description: z2.string(),
-  acceptanceCriteria: z2.array(z2.string()),
-  priority: z2.number().int().positive(),
-  passes: z2.boolean(),
-  notes: z2.string(),
-  ...claudeUsageSchema.shape,
-  durationSeconds: z2.number().optional(),
-  status: userStoryStatusSchema.optional(),
-  dependencies: z2.array(z2.string()).optional(),
-  stage: storyStageSchema.optional(),
-  stageSince: z2.string().optional(),
-  stageDetail: z2.string().optional()
-});
-var pipelineStateSchema = z2.object({
-  analyzeCompleted: z2.boolean().optional(),
-  prdCompleted: z2.boolean(),
-  jsonCompleted: z2.boolean(),
-  executionCompleted: z2.boolean(),
-  reviewCompleted: z2.boolean(),
-  prCreated: z2.boolean(),
-  prReviewCompleted: z2.boolean().optional()
-});
-var pullRequestRefSchema = z2.object({
-  number: z2.number().int().positive(),
-  url: z2.string(),
-  headBranch: z2.string(),
-  createdAt: z2.string()
-});
-var prReviewRecommendationSchema = z2.enum([
-  "APPROVE",
-  "APPROVE_WITH_SUGGESTIONS",
-  "REQUEST_CHANGES"
-]);
-var prReviewStateSchema = z2.object({
-  enabled: z2.boolean().default(false),
-  pullRequestNumber: z2.number().int().positive().optional(),
-  rounds: z2.number().int().min(0).default(0),
-  lastRecommendation: prReviewRecommendationSchema.optional(),
-  lastReviewedAt: z2.string().optional()
-});
-var lastErrorSchema = z2.object({
-  category: z2.string(),
-  message: z2.string(),
-  at: z2.string()
-});
-var issueMetadataSchema = z2.object({
-  schemaVersion: z2.literal(1),
-  id: z2.string().min(1),
-  number: z2.number().int().positive().nullable(),
-  source: z2.enum(["github", "local"]),
-  title: z2.string(),
-  labels: z2.array(z2.string()),
-  state: z2.enum(["open", "closed"]),
-  createdAt: z2.string(),
-  updatedAt: z2.string(),
-  contentHash: z2.string(),
-  remote: z2.object({
-    provider: z2.enum(["github", "local"]),
-    ref: z2.string(),
-    syncedAt: z2.string(),
-    syncedContentHash: z2.string()
-  }).optional()
-});
-var taskPlanSchema = z2.object({
-  project: z2.string(),
-  issueNumber: z2.union([z2.number().int().positive(), z2.string().min(1)]),
-  issueUrl: z2.string().optional().default(""),
-  branchName: z2.string(),
-  noBranch: z2.boolean().optional().default(false),
-  description: z2.string(),
-  issueStatus: z2.enum(["pending", "in_progress", "completed"]),
-  completedAt: z2.string().nullable(),
-  lastAttemptAt: z2.string().nullable(),
-  lastError: lastErrorSchema.nullable(),
-  correctionCycle: z2.number().int().min(0),
-  maxCorrectionCycles: z2.number().int().min(0),
-  /**
-   * Findings from the most recent failed review, verbatim. Non-null means the
-   * issue has a pending correction even if every userStories[].passes is
-   * already true — the execute phase must address these before the field is
-   * cleared back to null. See core/engine.ts's early-return guards.
-   */
-  lastReviewFindings: z2.string().nullable().optional().default(null),
-  pipeline: pipelineStateSchema,
-  pullRequest: pullRequestRefSchema.optional(),
-  prReview: prReviewStateSchema.optional(),
-  userStories: z2.array(userStorySchema)
-});
-var headlessResultSchema = z2.object({
-  success: z2.boolean(),
-  result: z2.string(),
-  cost: claudeUsageSchema.nullable(),
-  error: z2.string().nullable()
-});
-var sessionLogEntrySchema = z2.object({
-  at: z2.string(),
-  level: z2.enum(["info", "warn", "error"]),
-  message: z2.string()
-});
-var sessionUsageShape = {
-  inputTokens: z2.number().nullable().default(null),
-  outputTokens: z2.number().nullable().default(null),
-  cacheReadTokens: z2.number().nullable().default(null),
-  cacheCreationTokens: z2.number().nullable().default(null),
-  costUsd: z2.number().nullable().default(null)
-};
-var sessionPhaseSchema = z2.object({
-  name: z2.string(),
-  status: z2.enum(["pending", "running", "completed", "failed"]),
-  startedAt: z2.string().nullable(),
-  endedAt: z2.string().nullable(),
-  durationSeconds: z2.number().nullable(),
-  error: z2.string().nullable(),
-  ...sessionUsageShape
-});
-var sessionStorySchema = z2.object({
-  id: z2.string(),
-  title: z2.string(),
-  priority: z2.number(),
-  passes: z2.boolean(),
-  completedAt: z2.string().nullable(),
-  // Also introduced with the metrics, hence the same tolerant default.
-  durationSeconds: z2.number().nullable().default(null),
-  // Snapshot fields are always present on output and defaulted on input, so a
-  // session.json written before they existed still parses. This is the mirror
-  // image of userStorySchema, where the same two fields are plainly optional.
-  status: userStoryStatusSchema.default("backlog"),
-  dependencies: z2.array(z2.string()).default([]),
-  // Published for the panel's story detail view. Same tolerant default as the
-  // fields above: absent (older session.json) and empty resolve to the same
-  // value, so the client never has to tell them apart.
-  description: z2.string().default(""),
-  acceptanceCriteria: z2.array(z2.string()).default([]),
-  // Additive like the rest of this schema: a session.json written before
-  // `stage` existed parses into 'pending'/null, the same values a fresh
-  // snapshot starts a story at.
-  stage: storyStageSchema.default("pending"),
-  stageSince: z2.string().nullable().default(null),
-  stageDetail: z2.string().nullable().default(null),
-  ...sessionUsageShape
-});
-var sessionSnapshotSchema = z2.object({
-  schemaVersion: z2.literal(1),
-  sessionId: z2.string().nullable(),
-  readOnly: z2.literal(true),
-  capabilities: z2.array(z2.string()),
-  issue: z2.object({
-    number: z2.number().nullable(),
-    url: z2.string().nullable(),
-    // Additive: a session.json written before the Issue section was enriched
-    // parses into the same "not reported" values createInitialSnapshot() uses.
-    title: z2.string().nullable().default(null),
-    description: z2.string().nullable().default(null),
-    labels: z2.array(z2.string()).default([]),
-    state: z2.string().nullable().default(null)
-  }),
-  status: z2.enum(["idle", "running", "completed", "failed"]),
-  startedAt: z2.string().nullable(),
-  updatedAt: z2.string().nullable(),
-  endedAt: z2.string().nullable(),
-  elapsedSeconds: z2.number().nullable(),
-  estimatedRemainingSeconds: z2.number().nullable(),
-  progress: z2.object({
-    percent: z2.number(),
-    phasesCompleted: z2.number(),
-    phasesTotal: z2.number(),
-    storiesCompleted: z2.number(),
-    storiesTotal: z2.number()
-  }),
-  currentPhase: z2.string().nullable(),
-  currentActivity: z2.object({
-    story: z2.string().nullable(),
-    tool: z2.string().nullable(),
-    detail: z2.string().nullable(),
-    since: z2.string()
-  }).nullable(),
-  phases: z2.array(sessionPhaseSchema),
-  stories: z2.array(sessionStorySchema),
-  // The whole aggregate is additive: a snapshot from before it existed parses
-  // into the same "nothing reported" object the reducer starts from.
-  metrics: z2.object({
-    totalInputTokens: z2.number().nullable().default(null),
-    totalOutputTokens: z2.number().nullable().default(null),
-    totalCacheReadTokens: z2.number().nullable().default(null),
-    totalCacheCreationTokens: z2.number().nullable().default(null),
-    totalCostUsd: z2.number().nullable().default(null)
-  }).default({
-    totalInputTokens: null,
-    totalOutputTokens: null,
-    totalCacheReadTokens: null,
-    totalCacheCreationTokens: null,
-    totalCostUsd: null
-  }),
-  execution: z2.object({
-    iteration: z2.number(),
-    retries: z2.number(),
-    correctionCycle: z2.number(),
-    maxCorrectionCycles: z2.number().nullable()
-  }),
-  git: z2.object({
-    branch: z2.string().nullable(),
-    baseBranch: z2.string().nullable(),
-    commits: z2.array(z2.object({ hash: z2.string(), subject: z2.string() }))
-  }),
-  // Additive like the metrics aggregate: a session.json written before the
-  // repository section existed parses into the same all-null object
-  // createInitialSnapshot() starts from.
-  repository: z2.object({
-    name: z2.string().nullable().default(null),
-    remoteUrl: z2.string().nullable().default(null),
-    branch: z2.string().nullable().default(null),
-    headCommit: z2.string().nullable().default(null),
-    root: z2.string().nullable().default(null)
-  }).default({ name: null, remoteUrl: null, branch: null, headCommit: null, root: null }),
-  pullRequests: z2.array(z2.object({ number: z2.number(), url: z2.string(), title: z2.string() })),
-  logs: z2.array(sessionLogEntrySchema),
-  errors: z2.array(sessionLogEntrySchema),
-  warnings: z2.array(sessionLogEntrySchema),
-  lastError: z2.object({ message: z2.string(), at: z2.string() }).nullable(),
-  nextSteps: z2.array(z2.string()),
-  environment: z2.object({ node: z2.string(), platform: z2.string() }).nullable()
-});
-var webConfigSchema = z2.object({
-  enabled: z2.boolean().default(false),
-  port: z2.number().int().min(1).max(65535).default(3737),
-  host: z2.string().min(1).default("0.0.0.0"),
-  refreshSeconds: z2.number().positive().default(5),
-  logLimit: z2.number().int().positive().default(200),
-  includeLogs: z2.boolean().default(true)
-});
-var issuesConfigSchema = z2.object({
-  defaultGenerateTarget: z2.enum(["github", "local", "both"]).default("github"),
-  preferredProvider: z2.enum(["github", "local"]).default("github"),
-  conflictPolicy: z2.enum(["ask", "prefer-local", "prefer-github"]).default("ask"),
-  requireConfirmation: z2.boolean().default(true)
-});
-var prReviewConfigSchema = z2.object({
-  publisher: z2.enum(["local"]).default("local")
-});
+import {
+  isoNow
+} from "./chunk-CD5ULRVC.js";
 
 // src/core/session-state.ts
 import { mkdir, rename, writeFile } from "fs/promises";
@@ -917,230 +592,6 @@ function getSessionPublisher() {
   return _publisher;
 }
 
-// src/core/state-manager.ts
-import { readFile } from "fs/promises";
-import { ZodError } from "zod";
-
-// src/utils/fs.ts
-import { copyFile, mkdtemp, rename as rename2, unlink, writeFile as writeFile2 } from "fs/promises";
-import { tmpdir } from "os";
-import { basename, join } from "path";
-async function writeFileAtomic(path, content) {
-  const tmpDir = await mkdtemp(join(tmpdir(), "issue-flow-"));
-  const tmpFile = join(tmpDir, basename(path));
-  await writeFile2(tmpFile, content, "utf-8");
-  try {
-    await rename2(tmpFile, path);
-  } catch (err) {
-    if (err.code === "EXDEV") {
-      await copyFile(tmpFile, path);
-      await unlink(tmpFile);
-    } else {
-      throw err;
-    }
-  }
-}
-
-// src/core/metrics.ts
-var USAGE_FIELDS = [
-  "inputTokens",
-  "outputTokens",
-  "cacheReadTokens",
-  "cacheCreationTokens",
-  "costUsd"
-];
-function num(value) {
-  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
-}
-function isRecord(value) {
-  return typeof value === "object" && value !== null;
-}
-function parseUsage(payload) {
-  if (!isRecord(payload)) return null;
-  const usageRaw = isRecord(payload.usage) ? payload.usage : void 0;
-  const usage = {};
-  const inputTokens = usageRaw ? num(usageRaw.input_tokens) : void 0;
-  const outputTokens = usageRaw ? num(usageRaw.output_tokens) : void 0;
-  const cacheReadTokens = usageRaw ? num(usageRaw.cache_read_input_tokens) : void 0;
-  const cacheCreationTokens = usageRaw ? num(usageRaw.cache_creation_input_tokens) : void 0;
-  const costUsd = num(payload.total_cost_usd);
-  const legacyInput = num(payload.num_input_tokens);
-  const legacyOutput = num(payload.num_output_tokens);
-  const legacyCost = num(payload.cost_usd);
-  const resolvedInput = inputTokens ?? legacyInput;
-  const resolvedOutput = outputTokens ?? legacyOutput;
-  const resolvedCost = costUsd ?? legacyCost;
-  if (resolvedInput !== void 0) usage.inputTokens = resolvedInput;
-  if (resolvedOutput !== void 0) usage.outputTokens = resolvedOutput;
-  if (cacheReadTokens !== void 0) usage.cacheReadTokens = cacheReadTokens;
-  if (cacheCreationTokens !== void 0) usage.cacheCreationTokens = cacheCreationTokens;
-  if (resolvedCost !== void 0) usage.costUsd = resolvedCost;
-  return Object.keys(usage).length > 0 ? usage : null;
-}
-function sumUsage(a, b) {
-  const result = {};
-  for (const field of USAGE_FIELDS) {
-    const left = a?.[field];
-    const right = b?.[field];
-    if (left === void 0 && right === void 0) continue;
-    result[field] = (left ?? 0) + (right ?? 0);
-  }
-  return result;
-}
-function divideUsage(usage, parts) {
-  const result = {};
-  if (!usage) return result;
-  const divisor = Number.isFinite(parts) && parts > 1 ? parts : 1;
-  for (const field of USAGE_FIELDS) {
-    const value = usage[field];
-    if (value === void 0) continue;
-    result[field] = field === "costUsd" ? value / divisor : Math.round(value / divisor);
-  }
-  return result;
-}
-function compactTokens(value) {
-  const abs = Math.abs(value);
-  if (abs >= 1e6) return `${(value / 1e6).toFixed(1)}M`;
-  if (abs >= 1e3) return `${(value / 1e3).toFixed(1)}k`;
-  return String(Math.round(value));
-}
-function formatTokens(usage) {
-  if (!usage) return "";
-  const segments = [];
-  const io = [];
-  if (usage.inputTokens !== void 0) io.push(`${compactTokens(usage.inputTokens)} in`);
-  if (usage.outputTokens !== void 0) io.push(`${compactTokens(usage.outputTokens)} out`);
-  if (io.length > 0) segments.push(io.join(" / "));
-  const cache = usage.cacheReadTokens !== void 0 || usage.cacheCreationTokens !== void 0 ? (usage.cacheReadTokens ?? 0) + (usage.cacheCreationTokens ?? 0) : void 0;
-  if (cache !== void 0) segments.push(`${compactTokens(cache)} cache`);
-  if (usage.costUsd !== void 0) segments.push(`~$${usage.costUsd.toFixed(4)}`);
-  return segments.join(" \xB7 ");
-}
-function hasUsageData(usage) {
-  if (!usage) return false;
-  return USAGE_FIELDS.some((field) => usage[field] !== void 0);
-}
-
-// src/core/state-manager.ts
-function isoNow() {
-  return (/* @__PURE__ */ new Date()).toISOString().replace(/\.\d{3}Z$/, "Z");
-}
-async function loadTaskPlan(path) {
-  const content = await readFile(path, "utf-8");
-  const raw = JSON.parse(content);
-  try {
-    return taskPlanSchema.parse(raw);
-  } catch (err) {
-    if (err instanceof ZodError) {
-      const issues = err.issues.map((i) => `  - ${i.path.join(".")}: ${i.message}`).join("\n");
-      throw new Error(`Invalid tasks.json at ${path}:
-${issues}`);
-    }
-    throw err;
-  }
-}
-async function saveTaskPlan(path, plan) {
-  await writeFileAtomic(path, `${JSON.stringify(plan, null, 2)}
-`);
-}
-function initializeState(plan) {
-  const defaultPipeline = {
-    prdCompleted: false,
-    jsonCompleted: false,
-    executionCompleted: false,
-    reviewCompleted: false,
-    prCreated: false
-  };
-  return {
-    ...plan,
-    issueStatus: plan.issueStatus ?? "pending",
-    completedAt: plan.completedAt ?? null,
-    lastAttemptAt: plan.lastAttemptAt ?? null,
-    lastError: plan.lastError ?? null,
-    correctionCycle: plan.correctionCycle ?? 0,
-    maxCorrectionCycles: plan.maxCorrectionCycles ?? 3,
-    lastReviewFindings: plan.lastReviewFindings ?? null,
-    pipeline: plan.pipeline ? { ...defaultPipeline, ...plan.pipeline } : defaultPipeline
-  };
-}
-function hasPendingCorrection(plan) {
-  return Boolean(plan.lastReviewFindings);
-}
-function allStoriesPass(plan) {
-  if (plan.userStories.length === 0) {
-    return false;
-  }
-  return plan.userStories.every((story) => story.passes === true);
-}
-function selectActiveStory(stories) {
-  return [...stories].filter((story) => !story.passes).sort((a, b) => a.priority - b.priority)[0];
-}
-function applyStoryMetrics(plan, storyIds, share, durationSeconds) {
-  if (storyIds.length === 0) return plan;
-  const targets = new Set(storyIds);
-  return {
-    ...plan,
-    userStories: plan.userStories.map((story) => {
-      if (!targets.has(story.id)) return story;
-      const updated = { ...story, ...sumUsage(story, share) };
-      if (story.durationSeconds !== void 0 || durationSeconds !== void 0) {
-        updated.durationSeconds = (story.durationSeconds ?? 0) + (durationSeconds ?? 0);
-      }
-      return updated;
-    })
-  };
-}
-function markIssueInProgress(plan, timestamp) {
-  const ts = timestamp ?? isoNow();
-  return {
-    ...plan,
-    issueStatus: "in_progress",
-    completedAt: null,
-    lastAttemptAt: ts
-  };
-}
-function markIssueCompleted(plan) {
-  const ts = isoNow();
-  return {
-    ...plan,
-    issueStatus: "completed",
-    completedAt: ts,
-    lastAttemptAt: ts,
-    lastError: null,
-    pipeline: plan.pipeline ? { ...plan.pipeline, executionCompleted: true } : plan.pipeline
-  };
-}
-function setLastError(plan, category, message) {
-  const ts = isoNow();
-  const error = {
-    category,
-    message,
-    at: ts
-  };
-  return {
-    ...plan,
-    lastAttemptAt: ts,
-    lastError: error
-  };
-}
-function clearLastError(plan, attemptStartedAt) {
-  const ts = isoNow();
-  if (plan.lastError && plan.lastError.at > attemptStartedAt) {
-    return {
-      ...plan,
-      lastAttemptAt: ts
-    };
-  }
-  return {
-    ...plan,
-    lastAttemptAt: ts,
-    lastError: null
-  };
-}
-function trimErrorMessage(message) {
-  return message.split("\n").filter((line) => line.trim().length > 0).slice(0, 8).join("\n");
-}
-
 // src/core/verbose.ts
 var _verbose = false;
 function setVerbose(enabled) {
@@ -1177,6 +628,13 @@ function setGlobalTimeout(ms) {
 function getGlobalTimeout() {
   return _globalTimeout;
 }
+var _inactivityTimeout;
+function setInactivityTimeout(ms) {
+  _inactivityTimeout = ms;
+}
+function getInactivityTimeout() {
+  return _inactivityTimeout;
+}
 
 // src/ui/logger.ts
 import chalk from "chalk";
@@ -1325,38 +783,11 @@ var ElapsedTimer = class {
 };
 
 export {
-  policyConfigSchema,
-  policyConfigInputSchema,
-  pullRequestRefSchema,
-  issueMetadataSchema,
-  taskPlanSchema,
-  sessionSnapshotSchema,
-  webConfigSchema,
-  issuesConfigSchema,
-  prReviewConfigSchema,
   NullPublisher,
+  MemoryPublisher,
   FilePublisher,
   setSessionPublisher,
   getSessionPublisher,
-  writeFileAtomic,
-  parseUsage,
-  sumUsage,
-  divideUsage,
-  formatTokens,
-  hasUsageData,
-  isoNow,
-  loadTaskPlan,
-  saveTaskPlan,
-  initializeState,
-  hasPendingCorrection,
-  allStoriesPass,
-  selectActiveStory,
-  applyStoryMetrics,
-  markIssueInProgress,
-  markIssueCompleted,
-  setLastError,
-  clearLastError,
-  trimErrorMessage,
   setVerbose,
   isVerbose,
   setOutputCallback,
@@ -1367,6 +798,8 @@ export {
   getStoryStageCallback,
   setGlobalTimeout,
   getGlobalTimeout,
+  setInactivityTimeout,
+  getInactivityTimeout,
   useUnicode,
   useColor,
   getIcons,
@@ -1380,4 +813,4 @@ export {
   formatDuration,
   ElapsedTimer
 };
-//# sourceMappingURL=chunk-HC2MT7BX.js.map
+//# sourceMappingURL=chunk-BYZDPR7N.js.map