@ebrindley/build 0.0.0-stage → 1.42.1-rc28

package/dist/chunk-HBTTGVR5.js

@@ -0,0 +1,353 @@
+import {
+  getCompetitionRunSnapshotV1,
+  resolveCliStateRoots
+} from "./chunk-AAAODV76.js";
+import {
+  getBacklogExecutionProvenancePath,
+  loadBacklogExecutionProvenance
+} from "./chunk-3WY5TU2O.js";
+
+// src/cli/utils/operational-readback.ts
+import * as fs from "fs";
+var OPERATIONAL_READBACK_SCHEMA_VERSION_V1 = "1.0.0";
+var OPERATIONAL_READBACK_MAX_LABEL_CHARS = 160;
+var DEFAULT_STALE_AFTER_MS = 5 * 60 * 1e3;
+var OperationalReadbackCompatibilityError = class extends Error {
+  constructor(requestedVersion) {
+    super(
+      `Incompatible operational readback schema version ${requestedVersion}; supported major version is 1`
+    );
+    this.requestedVersion = requestedVersion;
+    this.name = "OperationalReadbackCompatibilityError";
+  }
+  requestedVersion;
+};
+function resolveOperationalReadbackCompatibility(requestedVersion = OPERATIONAL_READBACK_SCHEMA_VERSION_V1) {
+  const match = /^(\d+)\.(\d+)\.(\d+)$/.exec(requestedVersion);
+  if (!match || match[1] !== "1") throw new OperationalReadbackCompatibilityError(requestedVersion);
+  return {
+    state: requestedVersion === OPERATIONAL_READBACK_SCHEMA_VERSION_V1 ? "exact" : "compatible_minor_difference",
+    requestedVersion,
+    providedVersion: OPERATIONAL_READBACK_SCHEMA_VERSION_V1
+  };
+}
+function truncateLabel(text) {
+  const normalized = text.replace(/\s+/g, " ").trim();
+  if (normalized.length <= OPERATIONAL_READBACK_MAX_LABEL_CHARS) return normalized;
+  return `${normalized.slice(0, OPERATIONAL_READBACK_MAX_LABEL_CHARS - 3)}...`;
+}
+function isTerminalStatus(status) {
+  return status === "succeeded" || status === "failed" || status === "cancelled";
+}
+function evidenceReference(kind, value) {
+  return typeof value === "string" && value.trim().length > 0 ? [{ kind, value: value.trim() }] : [];
+}
+function probeSource(filePath, readAt) {
+  const exists = fs.existsSync(filePath);
+  if (!exists) return { path: filePath, readAt, exists };
+  try {
+    return {
+      path: filePath,
+      readAt,
+      exists,
+      modifiedAt: fs.statSync(filePath).mtime.toISOString()
+    };
+  } catch {
+    return { path: filePath, readAt, exists };
+  }
+}
+function defaultIsProcessAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error.code !== "ESRCH";
+  }
+}
+function snapshotLabel(snapshot) {
+  const { completedVariants, totalVariants } = snapshot.progress;
+  const parts = [`${snapshot.kind} ${snapshot.status}`];
+  if (totalVariants > 0) parts.push(`${completedVariants}/${totalVariants} variants complete`);
+  if (snapshot.health.issues.length > 0) parts.push(snapshot.health.issues.join(", "));
+  return truncateLabel(parts.join(" | "));
+}
+function composeSnapshotReadbackBase(snapshot, compatibility) {
+  const issues = [
+    ...snapshot.health.issues,
+    ...compatibility.state === "compatible_minor_difference" && !snapshot.health.issues.includes("compatibility") ? ["compatibility"] : []
+  ];
+  return {
+    schemaVersion: OPERATIONAL_READBACK_SCHEMA_VERSION_V1,
+    compatibility,
+    id: snapshot.id,
+    status: snapshot.status,
+    terminal: isTerminalStatus(snapshot.status),
+    label: snapshotLabel(snapshot),
+    timestamps: { ...snapshot.timestamps },
+    health: {
+      state: snapshot.health.state === "healthy" && issues.length > 0 ? "degraded" : snapshot.health.state,
+      issues
+    },
+    freshness: { ...snapshot.freshness },
+    provenance: {
+      primarySource: snapshot.provenance.primarySource,
+      localOnly: true,
+      sources: snapshot.provenance.sources
+    },
+    evidence: [...snapshot.evidence]
+  };
+}
+function composeFusionReadback(snapshot, compatibility) {
+  return {
+    ...composeSnapshotReadbackBase(snapshot, compatibility),
+    kind: "fusion",
+    fusion: snapshot
+  };
+}
+function composeCompetitionReadback(snapshot, compatibility) {
+  return {
+    ...composeSnapshotReadbackBase(snapshot, compatibility),
+    kind: "competition",
+    competition: snapshot
+  };
+}
+function toFusionOperationalReadbackV1(snapshot, requestedReadbackVersion) {
+  return composeFusionReadback(
+    snapshot,
+    resolveOperationalReadbackCompatibility(requestedReadbackVersion)
+  );
+}
+function getCompetitionOperationalReadbackV1(runId, options = {}) {
+  const compatibility = resolveOperationalReadbackCompatibility(options.requestedReadbackVersion);
+  const snapshot = getCompetitionRunSnapshotV1(runId, options);
+  return snapshot === null ? null : composeCompetitionReadback(snapshot, compatibility);
+}
+function resolveTrackedStatus(provenance, processState, stale) {
+  switch (provenance.status) {
+    case "initialized":
+      return { status: "queued", partial: false };
+    case "executing":
+      if (processState === "gone" || stale) return { status: "unknown", partial: false };
+      return { status: "running", partial: false };
+    case "blocked":
+      return provenance.pendingBlockers.length > 0 ? { status: "blocked", partial: false } : { status: "unknown", partial: true };
+    case "pr-open":
+      return provenance.prNumber !== null ? { status: "running", partial: false } : { status: "unknown", partial: true };
+    case "archive-sync-pending":
+      return provenance.archiveSyncPrNumber !== null && provenance.prNumber !== null && Boolean(provenance.mergeCommit) ? { status: "running", partial: false } : { status: "unknown", partial: true };
+    case "delivered-local":
+      return provenance.lastCompletedStep === "execute" ? { status: "succeeded", partial: false } : { status: "unknown", partial: true };
+    case "merged":
+      return provenance.mergeCommit ? { status: "succeeded", partial: false } : { status: "unknown", partial: true };
+    case "archived":
+      return provenance.mergeCommit ? { status: "succeeded", partial: false } : { status: "unknown", partial: true };
+    case "failed":
+      return provenance.failedAtStep || provenance.errorMessage ? { status: "failed", partial: false } : { status: "unknown", partial: true };
+    default:
+      return { status: "unknown", partial: true };
+  }
+}
+function resolveFinalizationState(provenance) {
+  switch (provenance.status) {
+    case "initialized":
+      return "not-started";
+    case "executing":
+    case "blocked":
+    case "failed":
+      return "in-progress";
+    case "pr-open":
+      return "pr-open";
+    case "archive-sync-pending":
+      return "archive-sync-pending";
+    case "delivered-local":
+      return "delivered-local";
+    case "merged":
+      return "merged";
+    case "archived":
+      return "archived";
+    default:
+      return "unavailable";
+  }
+}
+function resolveProcessState(provenance, isProcessAlive) {
+  const pid = provenance.executingPid;
+  if (typeof pid !== "number" || !Number.isFinite(pid)) return "unobserved";
+  try {
+    return isProcessAlive(pid) ? "alive" : "gone";
+  } catch {
+    return "unobserved";
+  }
+}
+function trackedEvidence(provenance) {
+  return [
+    ...evidenceReference("branch", provenance.branch),
+    ...evidenceReference("branch", provenance.sourceBranch),
+    ...evidenceReference("commit", provenance.mergeCommit),
+    ...evidenceReference("artifact", provenance.planArtifact),
+    ...provenance.prNumber !== null ? evidenceReference("delivery", `pr#${provenance.prNumber}`) : [],
+    ...provenance.archiveSyncPrNumber !== null ? evidenceReference("delivery", `archive-sync-pr#${provenance.archiveSyncPrNumber}`) : []
+  ];
+}
+function trackedLabel(backlogItemId, provenanceStatus, provenance, issues) {
+  const parts = [`backlog-execute ${provenanceStatus}`, backlogItemId];
+  if (provenance) {
+    if (provenance.prNumber !== null) parts.push(`PR #${provenance.prNumber}`);
+    if (provenance.pendingBlockers.length > 0) {
+      parts.push(`${provenance.pendingBlockers.length} blocker(s)`);
+    }
+    if (provenance.failedAtStep) parts.push(`failed at ${provenance.failedAtStep}`);
+  }
+  if (issues.length > 0) parts.push(issues.join(", "));
+  return truncateLabel(parts.join(" | "));
+}
+function unavailableTrackedReadback(backlogItemId, compatibility, source, checkedAt) {
+  const issues = [
+    ...compatibility.state === "compatible_minor_difference" ? ["compatibility"] : [],
+    "corrupt"
+  ];
+  return {
+    schemaVersion: OPERATIONAL_READBACK_SCHEMA_VERSION_V1,
+    compatibility,
+    kind: "backlog-execute",
+    id: backlogItemId,
+    status: "unknown",
+    terminal: false,
+    label: trackedLabel(backlogItemId, "unavailable", null, issues),
+    timestamps: { lastActivityAt: source.modifiedAt },
+    health: { state: "unavailable", issues },
+    freshness: { state: "unknown", checkedAt, lastModifiedAt: source.modifiedAt },
+    provenance: {
+      primarySource: "backlog_execution_provenance",
+      localOnly: true,
+      sources: { executionProvenance: source }
+    },
+    evidence: [],
+    backlogExecute: {
+      backlogItem: { id: backlogItemId },
+      provenanceStatus: "unavailable",
+      workflow: { workflowId: null, sprintId: null, taskIds: [], planArtifact: null },
+      process: { executingPid: null, executingStartedAt: null, state: "unobserved" },
+      steps: { lastCompletedStep: null, failedAtStep: null, errorMessage: null },
+      blockers: [],
+      branch: {
+        name: null,
+        role: null,
+        action: null,
+        sourceBranch: null,
+        sourceBranchRole: null
+      },
+      pullRequest: { number: null, mergeCommit: null },
+      finalization: {
+        state: "unavailable",
+        mergeCommit: null,
+        archiveSyncPrNumber: null,
+        archiveSyncWarning: null
+      }
+    }
+  };
+}
+async function getBacklogExecuteOperationalReadbackV1(backlogItemId, options = {}) {
+  const compatibility = resolveOperationalReadbackCompatibility(options.requestedReadbackVersion);
+  const projectRoot = options.projectRoot ?? resolveCliStateRoots(options.cwd).repoRoot;
+  const now = options.now ?? /* @__PURE__ */ new Date();
+  const checkedAt = now.toISOString();
+  const filePath = getBacklogExecutionProvenancePath(projectRoot, backlogItemId);
+  const source = probeSource(filePath, checkedAt);
+  if (!source.exists) return null;
+  let provenance;
+  try {
+    provenance = await loadBacklogExecutionProvenance(projectRoot, backlogItemId, {
+      cleanupTerminalLocks: false
+    });
+  } catch (error) {
+    source.parseError = error instanceof Error ? error.message : String(error);
+    provenance = null;
+  }
+  if (!provenance) {
+    source.parseError ??= "Backlog execution provenance record is unreadable or invalid.";
+    return unavailableTrackedReadback(backlogItemId, compatibility, source, checkedAt);
+  }
+  const isProcessAlive = options.isProcessAlive ?? defaultIsProcessAlive;
+  const processState = resolveProcessState(provenance, isProcessAlive);
+  const lastActivityAt = provenance.updatedAt ?? source.modifiedAt ?? provenance.createdAt;
+  const ageMs = lastActivityAt ? now.getTime() - Date.parse(lastActivityAt) : Number.POSITIVE_INFINITY;
+  const stale = provenance.status === "executing" && processState !== "alive" && (!Number.isFinite(ageMs) || ageMs > (options.staleAfterMs ?? DEFAULT_STALE_AFTER_MS));
+  const resolution = resolveTrackedStatus(provenance, processState, stale);
+  const issues = [
+    ...compatibility.state === "compatible_minor_difference" ? ["compatibility"] : [],
+    ...resolution.partial ? ["partial"] : [],
+    ...stale ? ["stale"] : []
+  ];
+  const terminal = isTerminalStatus(resolution.status);
+  return {
+    schemaVersion: OPERATIONAL_READBACK_SCHEMA_VERSION_V1,
+    compatibility,
+    kind: "backlog-execute",
+    id: backlogItemId,
+    status: resolution.status,
+    terminal,
+    label: trackedLabel(backlogItemId, provenance.status, provenance, issues),
+    timestamps: {
+      createdAt: provenance.createdAt,
+      updatedAt: provenance.updatedAt,
+      lastActivityAt
+    },
+    health: { state: issues.length > 0 ? "degraded" : "healthy", issues },
+    freshness: {
+      state: stale ? "stale" : terminal ? "historical" : lastActivityAt ? "fresh" : "unknown",
+      checkedAt,
+      lastModifiedAt: source.modifiedAt
+    },
+    provenance: {
+      primarySource: "backlog_execution_provenance",
+      localOnly: true,
+      sources: { executionProvenance: source }
+    },
+    evidence: trackedEvidence(provenance),
+    backlogExecute: {
+      backlogItem: { id: provenance.backlogItemId },
+      provenanceStatus: provenance.status,
+      workflow: {
+        workflowId: provenance.workflowId,
+        sprintId: provenance.sprintId,
+        taskIds: [...provenance.taskIds],
+        planArtifact: provenance.planArtifact
+      },
+      process: {
+        executingPid: provenance.executingPid ?? null,
+        executingStartedAt: provenance.executingStartedAt ?? null,
+        state: processState
+      },
+      steps: {
+        lastCompletedStep: provenance.lastCompletedStep,
+        failedAtStep: provenance.failedAtStep,
+        errorMessage: provenance.errorMessage
+      },
+      blockers: provenance.pendingBlockers.map((blocker) => ({ ...blocker })),
+      branch: {
+        name: provenance.branch,
+        role: provenance.branchRole ?? null,
+        action: provenance.branchRoleAction ?? null,
+        sourceBranch: provenance.sourceBranch ?? null,
+        sourceBranchRole: provenance.sourceBranchRole ?? null
+      },
+      pullRequest: {
+        number: provenance.prNumber,
+        mergeCommit: provenance.mergeCommit
+      },
+      finalization: {
+        state: resolveFinalizationState(provenance),
+        mergeCommit: provenance.mergeCommit,
+        archiveSyncPrNumber: provenance.archiveSyncPrNumber,
+        archiveSyncWarning: provenance.archiveSyncWarning
+      }
+    }
+  };
+}
+
+export {
+  toFusionOperationalReadbackV1,
+  getCompetitionOperationalReadbackV1,
+  getBacklogExecuteOperationalReadbackV1
+};
+//# sourceMappingURL=chunk-HBTTGVR5.js.map

package/dist/chunk-HBZ322WZ.js

@@ -0,0 +1,35 @@
+// src/automation/review-inspection-attestation.ts
+var REVIEW_INSPECTION_RULE = '"inspection" is required: report "completed" only after you read the diff and opened the files it touches in the checkout; report "unavailable" with a "reason" when you could not read the diff or the checkout. Never report "completed" for a change you did not read.';
+var MAX_REASON_LENGTH = 200;
+function flattenUntrustedReviewerText(value) {
+  const flattened = value.replaceAll(/[\u0000-\u001f\u007f-\u009f\s]+/g, " ").trim();
+  return flattened.length > MAX_REASON_LENGTH ? `${flattened.slice(0, MAX_REASON_LENGTH - 3)}...` : flattened;
+}
+function readReviewInspectionAttestation(payload) {
+  const inspection = payload.inspection;
+  if (inspection === "completed") return { completed: true };
+  if (inspection === void 0 || inspection === null) {
+    return { completed: false, reason: "reviewer omitted the inspection attestation" };
+  }
+  if (inspection === "unavailable") {
+    const reason = typeof payload.reason === "string" ? flattenUntrustedReviewerText(payload.reason) : "";
+    return {
+      completed: false,
+      reason: `reviewer reported inspection unavailable: ${reason || "no reason given"}`
+    };
+  }
+  const preview = flattenUntrustedReviewerText(
+    JSON.stringify(inspection) ?? String(inspection)
+  ).slice(0, 80);
+  return {
+    completed: false,
+    reason: `reviewer reported an unrecognized inspection attestation: ${preview}`
+  };
+}
+
+export {
+  REVIEW_INSPECTION_RULE,
+  flattenUntrustedReviewerText,
+  readReviewInspectionAttestation
+};
+//# sourceMappingURL=chunk-HBZ322WZ.js.map

package/dist/chunk-HEP3ILP4.js

@@ -0,0 +1,34 @@
+import {
+  BUILD_TELEMETRY_SQLITE_BUSY_TIMEOUT_MS,
+  BUILD_TELEMETRY_SQLITE_CACHE_SIZE,
+  BUILD_TELEMETRY_SQLITE_MMAP_SIZE,
+  readEnv
+} from "./chunk-7VRJHTGZ.js";
+
+// src/telemetry/sqlite-timeout-config.ts
+function getSqliteBusyTimeoutMs() {
+  return readEnv(BUILD_TELEMETRY_SQLITE_BUSY_TIMEOUT_MS).value ?? 3e4;
+}
+function getSqliteCacheSize() {
+  return readEnv(BUILD_TELEMETRY_SQLITE_CACHE_SIZE).value ?? -2e4;
+}
+function getSqliteMmapSize() {
+  return readEnv(BUILD_TELEMETRY_SQLITE_MMAP_SIZE).value ?? 268435456;
+}
+function applySqlitePragmas(db, options) {
+  db.pragma("journal_mode = WAL");
+  db.pragma("synchronous = NORMAL");
+  db.pragma(`busy_timeout = ${getSqliteBusyTimeoutMs()}`);
+  db.pragma(`cache_size = ${getSqliteCacheSize()}`);
+  db.pragma("temp_store = MEMORY");
+  db.pragma(`mmap_size = ${getSqliteMmapSize()}`);
+  if (options?.foreignKeys === true) {
+    db.pragma("foreign_keys = ON");
+  }
+}
+
+export {
+  getSqliteBusyTimeoutMs,
+  applySqlitePragmas
+};
+//# sourceMappingURL=chunk-HEP3ILP4.js.map

package/dist/chunk-HGFXODKO.js

@@ -0,0 +1,106 @@
+import {
+  quotePosixShellArg
+} from "./chunk-N5DX4JAK.js";
+
+// src/utils/security.ts
+import { realpathSync } from "fs";
+import path from "path";
+function isValidPid(pid) {
+  if (typeof pid === "string") {
+    if (!/^\d+$/.test(pid)) {
+      return false;
+    }
+    const numPid = parseInt(pid, 10);
+    return numPid > 0 && numPid <= Number.MAX_SAFE_INTEGER;
+  }
+  if (typeof pid !== "number" || !Number.isInteger(pid)) {
+    return false;
+  }
+  return pid > 0 && pid <= Number.MAX_SAFE_INTEGER;
+}
+function isValidCommandName(command) {
+  if (!command || typeof command !== "string") {
+    return false;
+  }
+  const trimmed = command.trim();
+  if (!trimmed) return false;
+  const looksLikePath = trimmed.startsWith("~") || trimmed.startsWith("/") || trimmed.startsWith("./") || trimmed.startsWith(".\\") || trimmed.startsWith("../") || trimmed.startsWith("..\\") || trimmed.startsWith("\\\\") || /^[a-zA-Z]:[\\/]/.test(trimmed);
+  if (looksLikePath) {
+    if (trimmed.includes("../") || trimmed.includes("..\\")) return false;
+    const segments = trimmed.split(/[/\\]/);
+    if (segments.includes("..")) return false;
+    if (trimmed.length > 4096) return false;
+    if (trimmed.includes("\0") || /[\r\n]/.test(trimmed)) return false;
+    if (/[;&|`$<>(){}[\]!*?]/.test(trimmed)) return false;
+    return true;
+  }
+  const safeCommandPattern = /^[a-zA-Z0-9_][a-zA-Z0-9._-]*$/;
+  return safeCommandPattern.test(trimmed) && trimmed.length <= 50;
+}
+function isValidPath(pathValue, options = { allowAbsolute: true }) {
+  if (!pathValue || typeof pathValue !== "string") {
+    return false;
+  }
+  const trimmed = pathValue.trim();
+  if (!trimmed) {
+    return false;
+  }
+  if (trimmed.includes("../") || trimmed.includes("..\\")) {
+    return false;
+  }
+  const segments = trimmed.split(/[/\\]/);
+  if (segments.includes("..")) {
+    return false;
+  }
+  const unsafeChars = /[;&|`$<>(){}[\]!*?~\n\r'"]/;
+  if (unsafeChars.test(trimmed)) {
+    return false;
+  }
+  if (!options.allowAbsolute) {
+    if (trimmed.startsWith("/") || /^[a-zA-Z]:/.test(trimmed) || trimmed.startsWith("\\\\")) {
+      return false;
+    }
+  }
+  if (pathValue.length > 4096) {
+    return false;
+  }
+  if (options.baseDir) {
+    try {
+      const resolvedBaseDir = realpathSync(options.baseDir);
+      const candidate = path.isAbsolute(trimmed) ? path.resolve(trimmed) : path.resolve(resolvedBaseDir, trimmed);
+      const resolvedCandidate = realpathSync(candidate);
+      if (resolvedCandidate !== resolvedBaseDir && !resolvedCandidate.startsWith(`${resolvedBaseDir}${path.sep}`)) {
+        return false;
+      }
+    } catch {
+      return false;
+    }
+  }
+  return true;
+}
+function escapeShellArg(arg) {
+  if (!arg || typeof arg !== "string") {
+    return "''";
+  }
+  if (process.platform !== "win32") {
+    return quotePosixShellArg(arg);
+  }
+  return `"${arg.replace(/\^/g, "^^").replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/%/g, "^%").replace(/!/g, "^!").replace(/&/g, "^&").replace(/\|/g, "^|").replace(/</g, "^<").replace(/\(/g, "^(").replace(/\)/g, "^)").replace(/>/g, "^>")}"`;
+}
+var SecurityValidationError = class extends Error {
+  constructor(message, field) {
+    super(message);
+    this.field = field;
+    this.name = "SecurityValidationError";
+  }
+  field;
+};
+
+export {
+  isValidPid,
+  isValidCommandName,
+  isValidPath,
+  escapeShellArg,
+  SecurityValidationError
+};
+//# sourceMappingURL=chunk-HGFXODKO.js.map

package/dist/chunk-HHWDTB6S.js

@@ -0,0 +1,59 @@
+// src/core/judge/matrix-escalation-policy.ts
+var DEFAULT_MATRIX_ESCALATION_THRESHOLDS = {
+  closeCallMargin: 5,
+  borderlineMargin: 7,
+  confidenceThreshold: 0.75
+};
+function normalizeMatrixEscalationThresholds(patch, fallback = DEFAULT_MATRIX_ESCALATION_THRESHOLDS) {
+  const closeCallMargin = typeof patch?.closeCallMargin === "number" && Number.isFinite(patch.closeCallMargin) && patch.closeCallMargin >= 0 ? patch.closeCallMargin : fallback.closeCallMargin;
+  const rawBorderlineMargin = typeof patch?.borderlineMargin === "number" && Number.isFinite(patch.borderlineMargin) && patch.borderlineMargin >= 0 ? patch.borderlineMargin : fallback.borderlineMargin;
+  const confidenceThreshold = typeof patch?.confidenceThreshold === "number" && Number.isFinite(patch.confidenceThreshold) && patch.confidenceThreshold >= 0 && patch.confidenceThreshold <= 1 ? patch.confidenceThreshold : fallback.confidenceThreshold;
+  return {
+    closeCallMargin,
+    borderlineMargin: Math.max(closeCallMargin, rawBorderlineMargin),
+    confidenceThreshold
+  };
+}
+function readMatrixEscalationThresholdPatchFromEnv() {
+  const patch = {};
+  const closeCallMargin = readOptionalNumber("BUILD_MATRIX_CLOSE_CALL_MARGIN");
+  if (closeCallMargin !== void 0 && closeCallMargin >= 0) {
+    patch.closeCallMargin = closeCallMargin;
+  }
+  const borderlineMargin = readOptionalNumber("BUILD_MATRIX_BORDERLINE_MARGIN");
+  if (borderlineMargin !== void 0 && borderlineMargin >= 0) {
+    patch.borderlineMargin = borderlineMargin;
+  }
+  const confidenceThreshold = readOptionalNumber("BUILD_MATRIX_CONFIDENCE_THRESHOLD");
+  if (confidenceThreshold !== void 0 && confidenceThreshold >= 0 && confidenceThreshold <= 1) {
+    patch.confidenceThreshold = confidenceThreshold;
+  }
+  return patch;
+}
+function readOptionalNumber(name) {
+  const raw = process.env[name];
+  const trimmed = raw?.trim();
+  if (trimmed === void 0 || trimmed.length === 0) return void 0;
+  if (!/^[+-]?(?:\d+(?:\.\d+)?|\.\d+)$/.test(trimmed)) return void 0;
+  const parsed = Number(trimmed);
+  return Number.isFinite(parsed) ? parsed : void 0;
+}
+var MATRIX_REPLAY_ENV = [
+  ["closeCallMargin", "BUILD_MATRIX_CLOSE_CALL_MARGIN"],
+  ["borderlineMargin", "BUILD_MATRIX_BORDERLINE_MARGIN"],
+  ["confidenceThreshold", "BUILD_MATRIX_CONFIDENCE_THRESHOLD"]
+];
+function buildMatrixReplayEnv(matrix) {
+  if (!matrix) return "";
+  return MATRIX_REPLAY_ENV.filter(
+    ([field]) => matrix[field] !== DEFAULT_MATRIX_ESCALATION_THRESHOLDS[field]
+  ).map(([field, name]) => `${name}=${matrix[field]} `).join("");
+}
+
+export {
+  DEFAULT_MATRIX_ESCALATION_THRESHOLDS,
+  normalizeMatrixEscalationThresholds,
+  readMatrixEscalationThresholdPatchFromEnv,
+  buildMatrixReplayEnv
+};
+//# sourceMappingURL=chunk-HHWDTB6S.js.map