@ebrindley/build 0.0.0-stage → 1.42.1-rc28

package/dist/chunk-C7AGUJ5K.js

@@ -0,0 +1,267 @@
+import {
+  classifyProviderResultFailure,
+  runWithProviderFailover
+} from "./chunk-VLMDM56Q.js";
+import {
+  runProvider
+} from "./chunk-VCGSWN5M.js";
+import {
+  iterateUnquotedJsonBraces
+} from "./chunk-TGCVL74Y.js";
+import {
+  extractAcceptanceCriteria
+} from "./chunk-XON4ZCYX.js";
+import {
+  filterPatchDiffBySecretPaths
+} from "./chunk-AEQWV746.js";
+import {
+  debugLog
+} from "./chunk-7VRJHTGZ.js";
+
+// src/core/validation/semantic-evaluator.ts
+async function runSemanticPrompt(options) {
+  const executionIntent = options.executionIntent ?? "analysis";
+  const run = (target) => runProvider({
+    provider: target.provider,
+    profile: options.profile ?? "default",
+    prompt: options.prompt,
+    workingDir: options.workingDir,
+    model: target.model,
+    timeoutMs: options.timeoutMs,
+    deadlineMs: options.deadlineMs,
+    abortSignal: options.abortSignal,
+    executionIntent,
+    workspaceMode: options.workspaceMode ?? "passthrough",
+    allowedTools: options.allowedTools,
+    tools: options.tools,
+    disallowedTools: options.disallowedTools
+  });
+  const primary = { provider: options.provider, model: options.model };
+  const failover = options.failover;
+  if (!failover) {
+    return await run(primary);
+  }
+  const { value, ran } = await runWithProviderFailover({
+    first: primary,
+    fallbacks: failover.fallbacks,
+    callSite: failover.callSite,
+    attempt: run,
+    failureOf: (result) => (result.exitCode ?? 0) === 0 ? void 0 : classifyProviderResultFailure(result),
+    onSwitch: failover.onSwitch
+  });
+  failover.onRan?.(ran);
+  return value;
+}
+
+// src/core/validation/acceptance-criteria-checker.ts
+var DEFAULT_MIN_CONFIDENCE = 0.7;
+var DEFAULT_TIMEOUT_MS = 3e4;
+async function checkCriterionWithProvider(criterion, gitDiff, options) {
+  const prompt = `You are evaluating whether a specific acceptance criterion is satisfied by code changes.
+
+**Acceptance Criterion:**
+${criterion}
+
+**Git Diff (changes made):**
+\`\`\`diff
+${gitDiff}
+\`\`\`
+
+Analyze whether the changes in the git diff satisfy this acceptance criterion.
+
+Respond with ONLY a JSON object in this exact format:
+{
+  "satisfied": <true|false>,
+  "confidence": <0.0-1.0>,
+  "evidence": "<brief quote from diff showing why satisfied or not satisfied>"
+}
+
+  Be concise. The evidence should be 1-2 lines maximum.`;
+  const providerResult = await runSemanticPrompt({
+    provider: options.provider,
+    prompt,
+    workingDir: options.workingDir,
+    profile: options.profile,
+    model: options.model,
+    timeoutMs: options.timeoutMs,
+    deadlineMs: options.deadlineMs,
+    abortSignal: options.abortSignal,
+    workspaceMode: options.workspaceMode,
+    allowedTools: options.allowedTools,
+    tools: options.tools,
+    disallowedTools: options.disallowedTools,
+    failover: options.failover,
+    executionIntent: "analysis"
+  });
+  const responseText = (providerResult.stdout ?? "").trim();
+  if (!responseText) {
+    throw new Error("Acceptance criteria provider returned empty output");
+  }
+  let jsonMatch = null;
+  const firstBrace = responseText.indexOf("{");
+  if (firstBrace !== -1) {
+    let depth = 0;
+    let end = -1;
+    for (const { index: i, brace: ch } of iterateUnquotedJsonBraces(responseText, firstBrace)) {
+      if (ch === "{") depth++;
+      else if (ch === "}") {
+        depth--;
+        if (depth === 0) {
+          end = i + 1;
+          break;
+        }
+      }
+    }
+    if (end !== -1) {
+      jsonMatch = [responseText.slice(firstBrace, end)];
+    }
+  }
+  if (!jsonMatch) {
+    throw new Error(`Failed to parse JSON from response: ${responseText}`);
+  }
+  const result = JSON.parse(jsonMatch[0]);
+  const rawConfidence = typeof result.confidence === "number" && Number.isFinite(result.confidence) ? result.confidence : 0;
+  const confidence = Math.max(
+    0,
+    Math.min(1, rawConfidence > 1 ? rawConfidence / 100 : rawConfidence)
+  );
+  const satisfied = (result.satisfied ?? false) && confidence >= options.minConfidence;
+  return {
+    criterion,
+    satisfied,
+    confidence,
+    evidence: result.evidence ?? "No evidence provided"
+  };
+}
+async function checkAcceptanceCriteria(taskSpec, rawGitDiff, options = {}) {
+  const gitDiff = filterPatchDiffBySecretPaths(rawGitDiff ?? "");
+  debugLog("[ACChecker] Extracting acceptance criteria from task spec...");
+  const criteria = extractAcceptanceCriteria(taskSpec);
+  if (criteria.length === 0) {
+    debugLog("[ACChecker] No acceptance criteria found in task spec");
+    return [];
+  }
+  if (!options.provider || !options.workingDir) {
+    throw new Error(
+      "checkAcceptanceCriteria requires provider and workingDir when acceptance criteria exist"
+    );
+  }
+  const config = {
+    provider: options.provider,
+    workingDir: options.workingDir,
+    profile: options.profile ?? "default",
+    model: options.model ?? "",
+    minConfidence: options.minConfidence ?? DEFAULT_MIN_CONFIDENCE,
+    timeoutMs: options.timeoutMs ?? DEFAULT_TIMEOUT_MS,
+    workspaceMode: options.workspaceMode ?? "passthrough",
+    deadlineMs: options.deadlineMs,
+    abortSignal: options.abortSignal,
+    allowedTools: options.allowedTools,
+    tools: options.tools,
+    disallowedTools: options.disallowedTools,
+    failover: options.failover
+  };
+  debugLog(`[ACChecker] Found ${criteria.length} acceptance criteria to check`);
+  if (!gitDiff || gitDiff.trim().length === 0) {
+    if ((rawGitDiff ?? "").trim().length > 0) {
+      debugLog("[ACChecker] Diff contained only excluded files - evaluation unavailable");
+      throw new Error(
+        "Semantic evaluation unavailable: every changed file is excluded from model prompts"
+      );
+    }
+    debugLog("[ACChecker] Empty git diff - marking all criteria as unsatisfied");
+    return criteria.map((criterion) => ({
+      criterion,
+      satisfied: false,
+      confidence: 1,
+      evidence: "No changes made (empty git diff)"
+    }));
+  }
+  const results = [];
+  for (let i = 0; i < criteria.length; i++) {
+    const criterion = criteria[i];
+    if (!criterion) continue;
+    const remainingMs = config.deadlineMs != null ? Math.max(0, config.deadlineMs - Date.now()) : void 0;
+    if (config.abortSignal?.aborted) {
+      for (let j = i; j < criteria.length; j++) {
+        const skipped = criteria[j];
+        if (!skipped) continue;
+        results.push({
+          criterion: skipped,
+          satisfied: false,
+          confidence: 0,
+          evidence: "Skipped: evaluation aborted",
+          evaluated: false
+        });
+      }
+      break;
+    }
+    if (remainingMs === 0) {
+      for (let j = i; j < criteria.length; j++) {
+        const skipped = criteria[j];
+        if (!skipped) continue;
+        results.push({
+          criterion: skipped,
+          satisfied: false,
+          confidence: 0,
+          evidence: "Skipped: shared evaluation deadline exhausted",
+          evaluated: false
+        });
+      }
+      break;
+    }
+    const callTimeoutMs = remainingMs != null ? Math.min(config.timeoutMs, remainingMs) : config.timeoutMs;
+    debugLog(`[ACChecker] Checking criterion ${i + 1}/${criteria.length}: "${criterion}"`);
+    try {
+      let evaluatedBy;
+      const failover = config.failover && {
+        ...config.failover,
+        onRan: (target) => {
+          evaluatedBy = target;
+          config.failover?.onRan?.(target);
+        }
+      };
+      const result = await checkCriterionWithProvider(criterion, gitDiff, {
+        ...config,
+        timeoutMs: callTimeoutMs,
+        failover
+      });
+      results.push(evaluatedBy ? { ...result, evaluatedBy } : result);
+      debugLog(
+        `[ACChecker] Result: ${result.satisfied ? "satisfied" : "not satisfied"} (confidence: ${result.confidence.toFixed(2)})`
+      );
+    } catch (error) {
+      debugLog(
+        `[ACChecker] Error checking criterion: ${error instanceof Error ? error.message : String(error)}`
+      );
+      results.push({
+        criterion,
+        satisfied: false,
+        confidence: 0,
+        evidence: `Error checking criterion: ${error instanceof Error ? error.message : String(error)}`,
+        evaluated: false
+      });
+    }
+  }
+  return results;
+}
+function calculateSatisfactionScore(results) {
+  if (results.length === 0) return 0;
+  let totalWeight = 0;
+  let satisfiedWeight = 0;
+  for (const result of results) {
+    const weight = result.evaluated === false ? 1 : result.confidence;
+    totalWeight += weight;
+    if (result.satisfied) {
+      satisfiedWeight += weight;
+    }
+  }
+  return totalWeight > 0 ? satisfiedWeight / totalWeight : 0;
+}
+
+export {
+  runSemanticPrompt,
+  checkAcceptanceCriteria,
+  calculateSatisfactionScore
+};
+//# sourceMappingURL=chunk-C7AGUJ5K.js.map

package/dist/chunk-CBSWKQCX.js

@@ -0,0 +1,342 @@
+import {
+  tailUtf8
+} from "./chunk-K7FAFORM.js";
+import {
+  NON_BLOCKING_QUALITY_GATE_SKIP_MARKERS
+} from "./chunk-QOFLUS24.js";
+import {
+  atomicWriteJson
+} from "./chunk-RFDVSI4N.js";
+import {
+  failureMatchesBase,
+  normalizeFailureText,
+  readFailingTestNames
+} from "./chunk-AHU3FKPA.js";
+
+// src/orchestrator/autoloop-trajectory.ts
+import * as path from "path";
+
+// src/orchestrator/autoloop-gate-baseline.ts
+var MAX_EVIDENCE_OUTPUT_CHARS = 2e4;
+var MAX_RECORDED_OUTPUT_CHARS = 1500;
+function commandEvidence(entry, workingDir) {
+  const command = entry.command ?? "";
+  const raw = [entry.stdout, entry.stderr].filter((part) => part && part.length > 0).join("\n");
+  const names = command ? readFailingTestNames(command, raw) : void 0;
+  return {
+    command,
+    ...entry.exitCode !== void 0 ? { exitCode: entry.exitCode } : {},
+    timedOut: entry.timedOut === true,
+    unavailable: entry.unavailable === true,
+    outputTail: normalizeFailureText(raw.slice(-MAX_EVIDENCE_OUTPUT_CHARS), [workingDir]),
+    ...raw.length > MAX_EVIDENCE_OUTPUT_CHARS ? { truncated: true } : {},
+    ...names?.complete && names.names.length > 0 ? { failingTests: names.names } : {}
+  };
+}
+function gateEvidenceOf(result, workingDir) {
+  if (result.unavailable === true) {
+    return { status: "unavailable", reason: result.message, commands: [] };
+  }
+  if (result.skipped === true) {
+    return { status: "skipped", reason: result.message, commands: [] };
+  }
+  if (result.success) return { status: "passed", commands: [] };
+  const entries = result.failedCommands?.filter((entry) => entry.passed !== true) ?? [
+    {
+      command: result.command,
+      stdout: result.stdout,
+      stderr: result.stderr
+    }
+  ];
+  return {
+    status: "failed",
+    commands: entries.map((entry) => commandEvidence(entry, workingDir))
+  };
+}
+function failsIdenticallyOnBaseline(current, baseline) {
+  if (current.status !== "failed" || baseline?.status !== "failed") return false;
+  if (current.commands.length === 0) return false;
+  return current.commands.every((now) => {
+    if (now.timedOut || now.unavailable) return false;
+    const before = baseline.commands.find((entry) => entry.command === now.command);
+    if (!before || before.timedOut || before.unavailable) return false;
+    const named = (now.failingTests?.length ?? 0) > 0 || (before.failingTests?.length ?? 0) > 0;
+    if (!named && (now.truncated || before.truncated)) return false;
+    return failureMatchesBase(
+      {
+        command: now.command,
+        exitCode: now.exitCode,
+        outputTail: now.outputTail,
+        failingTests: now.failingTests
+      },
+      {
+        command: before.command,
+        exitCode: before.exitCode,
+        outputTail: before.outputTail,
+        failingTests: before.failingTests
+      }
+    );
+  });
+}
+function describeMissingGateBaseline(baseline, gate) {
+  if (!baseline) return "no baseline was captured";
+  if (baseline.status !== "captured") {
+    const what = baseline.status === "skipped" ? "was skipped" : "run failed";
+    return `the baseline ${what}: ${baseline.reason}`;
+  }
+  const before = baseline.gateEvidence?.[gate];
+  if (!before) return `the baseline did not run the ${gate} gate`;
+  if (before.status === "unavailable" || before.status === "skipped") {
+    return `the baseline ${before.status === "unavailable" ? "could not run" : "skipped"} the ${gate} gate${before.reason ? `: ${before.reason}` : ""}`;
+  }
+  if (before.status === "passed") return void 0;
+  return "the failure could not be matched to the baseline failure";
+}
+function recordQualityBaseline(baseline) {
+  if (!baseline) return void 0;
+  if (baseline.status !== "captured") return { status: baseline.status, reason: baseline.reason };
+  const gates = {};
+  for (const [gate, evidence] of Object.entries(baseline.gateEvidence ?? {})) {
+    gates[gate] = {
+      status: evidence.status,
+      ...evidence.reason ? { reason: evidence.reason.slice(0, 500) } : {},
+      commands: evidence.commands.map((entry) => ({
+        command: entry.command,
+        ...entry.exitCode !== void 0 ? { exitCode: entry.exitCode } : {},
+        outputTail: entry.outputTail.slice(-MAX_RECORDED_OUTPUT_CHARS)
+      }))
+    };
+  }
+  return { status: "captured", gates };
+}
+
+// src/orchestrator/autoloop-trajectory.ts
+var MAX_CHANGED_FILES = 200;
+var MAX_PROVIDER_OUTPUT_BYTES = 4e3;
+var MAX_OUTPUT_TAIL_BYTES = 1500;
+var MAX_INSIGHTS = 10;
+var MAX_INSIGHT_LEN = 500;
+var MAX_GATES_PER_ITERATION = 50;
+function safeTaskIdComponent(input) {
+  return input.replace(/[^a-zA-Z0-9_.-]/g, "_");
+}
+function clampStringList(values, maxItems, maxLen) {
+  if (!values || values.length === 0) return void 0;
+  return values.slice(0, maxItems).map((entry) => entry.length > maxLen ? entry.slice(0, maxLen) : entry);
+}
+function cleanChangedFilePath(input) {
+  const trimmed = input.trim();
+  if (!trimmed) return null;
+  const porcelainMatch = trimmed.match(/^(?:[ MADRCU?!]{1,2})\s+(.+)$/);
+  const candidate = porcelainMatch?.[1] ?? trimmed;
+  const renamedPath = candidate.includes(" -> ") ? candidate.split(" -> ").at(-1) : candidate;
+  const pathOnly = renamedPath?.trim();
+  return pathOnly && pathOnly.length > 0 ? pathOnly : null;
+}
+function cleanChangedFiles(files) {
+  if (!files || files.length === 0) return [];
+  const seen = /* @__PURE__ */ new Set();
+  const cleaned = [];
+  for (const file of files) {
+    const clean = cleanChangedFilePath(file);
+    if (!clean || seen.has(clean)) continue;
+    seen.add(clean);
+    cleaned.push(clean);
+  }
+  return cleaned;
+}
+function buildGate(gate) {
+  return {
+    gateId: gate.gateId,
+    passed: gate.passed,
+    score: gate.score,
+    details: gate.details.length > 500 ? gate.details.slice(0, 500) : gate.details,
+    durationMs: Number(gate.duration),
+    outputTail: tailUtf8(gate.outputTail, MAX_OUTPUT_TAIL_BYTES),
+    ...gate.command ? { command: gate.command } : {},
+    ...gate.exitCode !== void 0 ? { exitCode: gate.exitCode } : {},
+    isRegression: gate.isRegression,
+    ...gate.baselineUnavailableReason ? { baselineUnavailableReason: gate.baselineUnavailableReason } : {},
+    ...gate.skipped === true ? { skipped: true } : {},
+    ...gate.unavailable === true ? { unavailable: true } : {}
+  };
+}
+function isBlockingGateFailure(gate) {
+  if (gate.passed || gate.unavailable === true) return false;
+  if (gate.skipped !== true) return true;
+  const details = gate.details.toLowerCase();
+  return !NON_BLOCKING_QUALITY_GATE_SKIP_MARKERS.some((marker) => details.includes(marker));
+}
+function buildCustomGate(gate) {
+  return {
+    id: gate.id,
+    command: gate.command,
+    passed: gate.passed,
+    durationMs: Number(gate.durationMs),
+    exitCode: gate.exitCode,
+    outputTail: tailUtf8(gate.outputTail, MAX_OUTPUT_TAIL_BYTES),
+    isRegression: gate.isRegression,
+    ...gate.skipped === true ? { skipped: true } : {},
+    ...gate.unavailable === true ? { unavailable: true } : {},
+    ...gate.misconfigured === true ? { misconfigured: true } : {}
+  };
+}
+function isBlockingCustomGateFailure(gate) {
+  if (gate.passed) return false;
+  if (gate.skipped === true) return false;
+  return gate.isRegression !== false;
+}
+function resolveGateAggregatePassed(gates, failedCount) {
+  if (!gates) return void 0;
+  if ((failedCount ?? 0) > 0) return false;
+  return gates.some((gate) => gate.passed && gate.skipped !== true && gate.unavailable !== true) ? true : void 0;
+}
+function buildSemantic(validation) {
+  if (!validation) return void 0;
+  return {
+    enabled: validation.enabled,
+    passed: validation.passed,
+    skipped: validation.skipped,
+    satisfactionScore: validation.satisfactionScore
+  };
+}
+function buildReportedTokens(inputTokens, outputTokens) {
+  const input = inputTokens ?? 0;
+  const output = outputTokens ?? 0;
+  const total = input + output;
+  return total > 0 ? { input, output, total } : void 0;
+}
+function buildDirectAutoloopTrajectory(input) {
+  const iterations = input.iterations.map(
+    ({
+      result,
+      variantInvocations,
+      changedFiles,
+      providerOutputText,
+      completeness,
+      wasNoOp,
+      duplicateChangeSet,
+      cost,
+      inputTokens,
+      outputTokens
+    }) => {
+      const files = cleanChangedFiles(changedFiles);
+      const gates = result.qualityGates?.slice(0, MAX_GATES_PER_ITERATION).map(buildGate);
+      const failedGateCount = gates ? gates.filter(isBlockingGateFailure).length : void 0;
+      const unavailableGateCount = gates?.filter(
+        (gate) => !gate.passed && gate.unavailable === true
+      ).length;
+      const customGates = result.customGateResults?.slice(0, MAX_GATES_PER_ITERATION).map(buildCustomGate);
+      const failedCustomGateCount = customGates ? customGates.filter(isBlockingCustomGateFailure).length : void 0;
+      const tokens = buildReportedTokens(inputTokens, outputTokens);
+      return {
+        ...variantInvocations?.length ? { variantInvocations: structuredClone(variantInvocations) } : {},
+        iteration: Number(result._iteration),
+        success: result.success,
+        durationMs: Number(result.duration),
+        progressScore: Number(result.progress.score),
+        progressTrend: result.progress.trend,
+        progressConfidence: result.progress.confidence,
+        completeness,
+        changedFiles: files.slice(0, MAX_CHANGED_FILES),
+        changedFileCount: files.length,
+        cost,
+        tokens,
+        wasNoOp,
+        iterationChange: result.iterationFingerprint === void 0 ? "unknown" : result.iterationFingerprint === "" ? "no_op" : "changed",
+        duplicateChangeSet,
+        qualityGates: gates,
+        qualityGatesPassed: resolveGateAggregatePassed(gates, failedGateCount),
+        qualityGatesFailedCount: failedGateCount,
+        ...unavailableGateCount ? { qualityGatesUnavailableCount: unavailableGateCount } : {},
+        customGateResults: customGates,
+        customGatesPassed: resolveGateAggregatePassed(customGates, failedCustomGateCount),
+        customGatesFailedCount: failedCustomGateCount,
+        semanticValidation: buildSemantic(result.semanticValidation),
+        completionEvidence: result.completionEvidence,
+        completionSummaryStatus: result.completionSummary?.status,
+        completionSignalDetected: result.completionSummary?.completionSignalDetected,
+        completionVerificationDisposition: result.completionSummary?.verificationDisposition,
+        ...result.progress.verificationUnavailable === true ? {
+          verificationUnavailable: true,
+          verificationUnavailableReason: result.progress.verificationUnavailableReason
+        } : {},
+        pivotReason: result.pivotReason,
+        usedProvider: result.usedProvider,
+        warningCodes: clampStringList(result.warningCodes, 20, 200),
+        insights: clampStringList(result.progress.insights, MAX_INSIGHTS, MAX_INSIGHT_LEN),
+        error: result.error?.message,
+        failureRecovery: result.failureRecovery,
+        earlyFinalization: result.earlyFinalization,
+        providerOutputExcerpt: tailUtf8(providerOutputText, MAX_PROVIDER_OUTPUT_BYTES)
+      };
+    }
+  );
+  const completionEvidence = iterations.slice().reverse().find((iteration) => iteration.completionEvidence !== void 0)?.completionEvidence;
+  return {
+    schemaVersion: 1,
+    ...input.variantRequest ? { variantRequest: structuredClone(input.variantRequest) } : {},
+    runId: input.runId,
+    taskId: input.taskId,
+    startedAt: input.startedAt,
+    completedAt: input.completedAt,
+    durationMs: input.durationMs,
+    provider: input.provider ?? void 0,
+    model: input.model,
+    cost: input.cost ?? void 0,
+    tokens: buildReportedTokens(input.inputTokens, input.outputTokens),
+    inPlace: input.inPlace,
+    status: input.status,
+    terminationReason: input.terminationReason,
+    terminationDetail: input.terminationDetail ?? void 0,
+    terminationDetailCode: input.terminationDetailCode ?? void 0,
+    totalIterations: input.totalIterations,
+    finalProgressScore: input.finalProgressScore ?? void 0,
+    success: input.success,
+    qualityGatePolicy: input.qualityGatePolicy ?? "not_configured",
+    ...input.qualityBaseline ? { qualityBaseline: recordQualityBaseline(input.qualityBaseline) } : {},
+    completionEvidence,
+    sessionId: input.sessionId ?? void 0,
+    worktree: input.worktree ?? void 0,
+    branch: input.branch ?? void 0,
+    iterations
+  };
+}
+function getDirectAutoloopTrajectoryPath(input) {
+  return path.join(
+    input.projectRoot,
+    ".build-project",
+    "autoloop",
+    "runs",
+    `${safeTaskIdComponent(input.taskId)}.trajectory.json`
+  );
+}
+async function persistDirectAutoloopTrajectory(input) {
+  const taskId = input.trajectory.taskId;
+  if (!taskId || taskId.trim().length === 0) {
+    return { path: null };
+  }
+  const filePath = getDirectAutoloopTrajectoryPath({
+    projectRoot: input.projectRoot,
+    taskId
+  });
+  try {
+    await atomicWriteJson(filePath, input.trajectory);
+    return { path: filePath };
+  } catch (err) {
+    console.warn(
+      `[autoloop-trajectory] Persist failed: ${err instanceof Error ? err.message : String(err)}`
+    );
+    return { path: null };
+  }
+}
+
+export {
+  gateEvidenceOf,
+  failsIdenticallyOnBaseline,
+  describeMissingGateBaseline,
+  buildDirectAutoloopTrajectory,
+  getDirectAutoloopTrajectoryPath,
+  persistDirectAutoloopTrajectory
+};
+//# sourceMappingURL=chunk-CBSWKQCX.js.map

package/dist/chunk-CE5OZBYY.js

@@ -0,0 +1,21 @@
+// src/core/estimation/runtime-estimate.ts
+var RUNTIME_ESTIMATOR_VERSION = 1;
+function provenanceForTier(tier) {
+  switch (tier) {
+    case "exact":
+    case "provider-model-strategy":
+    case "provider-model":
+      return "telemetry";
+    case "provider":
+    case "global":
+      return "blended";
+    case "cold-start":
+      return "heuristic";
+  }
+}
+
+export {
+  RUNTIME_ESTIMATOR_VERSION,
+  provenanceForTier
+};
+//# sourceMappingURL=chunk-CE5OZBYY.js.map