@probelabs/visor 0.1.127 → 0.1.129

package/dist/sdk/{github-frontend-5PCKKHVC.mjs → github-frontend-3N2NLO66.mjs}

@@ -1,26 +1,30 @@
+import {
+  extractTextFromJson,
+  init_json_text_extractor
+} from "./chunk-H5BOW5CR.mjs";
 import {
   generateShortHumanId,
   init_human_id
-} from "./chunk-EXFGO4FX.mjs";
+} from "./chunk-KFKHU6CM.mjs";
 import {
   failure_condition_evaluator_exports,
   init_failure_condition_evaluator
-} from "./chunk-MPS4HVQI.mjs";
-import "./chunk-ZYAUYXSW.mjs";
-import "./chunk-S2RUE2RG.mjs";
-import "./chunk-CNX7V5JK.mjs";
-import "./chunk-BOVFH3LI.mjs";
-import "./chunk-IHZOSIF4.mjs";
+} from "./chunk-N7HO6KKC.mjs";
+import "./chunk-J5RGJQ53.mjs";
+import "./chunk-XR7XXGL7.mjs";
+import "./chunk-25IC7KXZ.mjs";
+import "./chunk-VF6XIUE4.mjs";
+import "./chunk-2KB35MB7.mjs";
 import {
   init_logger,
   logger
-} from "./chunk-3NMLT3YS.mjs";
-import "./chunk-YSN4G6CI.mjs";
+} from "./chunk-PO7X5XI7.mjs";
+import "./chunk-HEX3RL32.mjs";
 import {
   __esm,
   __export,
   __toCommonJS
-} from "./chunk-WMJKH4XE.mjs";
+} from "./chunk-J7LXIPZS.mjs";
 
 // src/footer.ts
 function generateFooter(options = {}) {
@@ -804,621 +808,549 @@ ${content}
 });
 
 // src/frontends/github-frontend.ts
-init_logger();
+var GitHubFrontend;
+var init_github_frontend = __esm({
+  "src/frontends/github-frontend.ts"() {
+    init_logger();
+    init_json_text_extractor();
+    GitHubFrontend = class {
+      name = "github";
+      subs = [];
+      checkRunIds = /* @__PURE__ */ new Map();
+      revision = 0;
+      cachedCommentId;
+      // legacy single-thread id (kept for compatibility)
+      // Group → (checkId → SectionState)
+      stepStatusByGroup = /* @__PURE__ */ new Map();
+      // Debounce/coalescing state
+      debounceMs = 400;
+      maxWaitMs = 2e3;
+      _timer = null;
+      _lastFlush = 0;
+      _pendingIds = /* @__PURE__ */ new Set();
+      // Mutex for serializing comment updates per group
+      updateLocks = /* @__PURE__ */ new Map();
+      minUpdateDelayMs = 1e3;
+      // Minimum delay between updates (public for testing)
+      // Cache of created GitHub comment IDs per group to handle API eventual consistency
+      createdCommentGithubIds = /* @__PURE__ */ new Map();
+      start(ctx) {
+        const log = ctx.logger;
+        const bus = ctx.eventBus;
+        const octokit = ctx.octokit;
+        const repo = ctx.run.repo;
+        const pr = ctx.run.pr;
+        const headSha = ctx.run.headSha;
+        const canPostComments = !!(octokit && repo && pr);
+        const canPostChecks = !!(octokit && repo && pr && headSha);
+        const svc = canPostChecks ? new (init_github_check_service(), __toCommonJS(github_check_service_exports)).GitHubCheckService(octokit) : null;
+        const CommentManager2 = (init_github_comments(), __toCommonJS(github_comments_exports)).CommentManager;
+        const comments = canPostComments ? new CommentManager2(octokit) : null;
+        const threadKey = repo && pr && headSha ? `${repo.owner}/${repo.name}#${pr}@${(headSha || "").substring(0, 7)}` : ctx.run.runId;
+        this.cachedCommentId = `visor-thread-${threadKey}`;
+        this.subs.push(
+          bus.on("CheckScheduled", async (env) => {
+            const ev = env && env.payload || env;
+            try {
+              if (!canPostChecks || !svc) return;
+              if (this.checkRunIds.has(ev.checkId)) return;
+              const group = this.getGroupForCheck(ctx, ev.checkId);
+              this.upsertSectionState(group, ev.checkId, {
+                status: "queued",
+                lastUpdated: (/* @__PURE__ */ new Date()).toISOString()
+              });
+              const res = await svc.createCheckRun(
+                {
+                  owner: repo.owner,
+                  repo: repo.name,
+                  head_sha: headSha,
+                  name: `Visor: ${ev.checkId}`,
+                  external_id: `visor:${ctx.run.runId}:${ev.checkId}`,
+                  engine_mode: "state-machine"
+                },
+                { title: `${ev.checkId}`, summary: "Queued" }
+              );
+              this.checkRunIds.set(ev.checkId, res.id);
+            } catch (e) {
+              log.warn(
+                `[github-frontend] createCheckRun failed for ${ev.checkId}: ${e instanceof Error ? e.message : e}`
+              );
+            }
+          })
+        );
+        this.subs.push(
+          bus.on("CheckCompleted", async (env) => {
+            const ev = env && env.payload || env;
+            try {
+              if (canPostChecks && svc && this.checkRunIds.has(ev.checkId)) {
+                const id = this.checkRunIds.get(ev.checkId);
+                const issues = Array.isArray(ev.result?.issues) ? ev.result.issues : [];
+                const failureResults = await this.evaluateFailureResults(ctx, ev.checkId, ev.result);
+                await svc.completeCheckRun(
+                  repo.owner,
+                  repo.name,
+                  id,
+                  ev.checkId,
+                  failureResults,
+                  issues,
+                  void 0,
+                  void 0,
+                  pr,
+                  headSha
+                );
+              }
+              if (canPostComments && comments) {
+                const count = Array.isArray(ev.result?.issues) ? ev.result.issues.length : 0;
+                const failureResults = await this.evaluateFailureResults(ctx, ev.checkId, ev.result);
+                const failed = Array.isArray(failureResults) ? failureResults.some((r) => r && r.failed) : false;
+                const group = this.getGroupForCheck(ctx, ev.checkId);
+                const rawContent = ev?.result?.content;
+                const extractedContent = extractTextFromJson(rawContent);
+                this.upsertSectionState(group, ev.checkId, {
+                  status: "completed",
+                  conclusion: failed ? "failure" : "success",
+                  issues: count,
+                  lastUpdated: (/* @__PURE__ */ new Date()).toISOString(),
+                  content: extractedContent
+                });
+                await this.updateGroupedComment(ctx, comments, group, ev.checkId);
+              }
+            } catch (e) {
+              log.warn(
+                `[github-frontend] handle CheckCompleted failed: ${e instanceof Error ? e.message : e}`
+              );
+            }
+          })
+        );
+        this.subs.push(
+          bus.on("CheckErrored", async (env) => {
+            const ev = env && env.payload || env;
+            try {
+              if (canPostChecks && svc && this.checkRunIds.has(ev.checkId)) {
+                const id = this.checkRunIds.get(ev.checkId);
+                await svc.completeCheckRun(
+                  repo.owner,
+                  repo.name,
+                  id,
+                  ev.checkId,
+                  [],
+                  [],
+                  ev.error?.message || "Execution error",
+                  void 0,
+                  pr,
+                  headSha
+                );
+              }
+              if (canPostComments && comments) {
+                const group = this.getGroupForCheck(ctx, ev.checkId);
+                this.upsertSectionState(group, ev.checkId, {
+                  status: "errored",
+                  conclusion: "failure",
+                  issues: 0,
+                  lastUpdated: (/* @__PURE__ */ new Date()).toISOString(),
+                  error: ev.error?.message || "Execution error"
+                });
+                await this.updateGroupedComment(ctx, comments, group, ev.checkId);
+              }
+            } catch (e) {
+              log.warn(
+                `[github-frontend] handle CheckErrored failed: ${e instanceof Error ? e.message : e}`
+              );
+            }
+          })
+        );
+        this.subs.push(
+          bus.on("StateTransition", async (env) => {
+            const ev = env && env.payload || env;
+            try {
+              if (ev.to === "Completed" || ev.to === "Error") {
+                if (canPostComments && comments) {
+                  for (const group of this.stepStatusByGroup.keys()) {
+                    await this.updateGroupedComment(ctx, comments, group);
+                  }
+                }
+              }
+            } catch (e) {
+              log.warn(
+                `[github-frontend] handle StateTransition failed: ${e instanceof Error ? e.message : e}`
+              );
+            }
+          })
+        );
+      }
+      stop() {
+        for (const s of this.subs) s.unsubscribe();
+        this.subs = [];
+      }
+      async buildFullBody(ctx, group) {
+        const header = this.renderThreadHeader(ctx, group);
+        const sections = this.renderSections(ctx, group);
+        return `${header}
 
-// src/utils/json-text-extractor.ts
-function extractTextFieldFromMalformedJson(content) {
-  const fieldPatterns = [
-    /^\s*\{\s*"text"\s*:\s*"/i,
-    /^\s*\{\s*"response"\s*:\s*"/i,
-    /^\s*\{\s*"message"\s*:\s*"/i
-  ];
-  for (const pattern of fieldPatterns) {
-    const match = pattern.exec(content);
-    if (match) {
-      const valueStart = match[0].length;
-      const remaining = content.substring(valueStart);
-      let value = "";
-      let i = 0;
-      while (i < remaining.length) {
-        const char = remaining[i];
-        if (char === "\\" && i + 1 < remaining.length) {
-          const nextChar = remaining[i + 1];
-          if (nextChar === "n") {
-            value += "\n";
-          } else if (nextChar === "r") {
-            value += "\r";
-          } else if (nextChar === "t") {
-            value += "	";
-          } else if (nextChar === '"') {
-            value += '"';
-          } else if (nextChar === "\\") {
-            value += "\\";
-          } else {
-            value += char + nextChar;
-          }
-          i += 2;
-        } else if (char === '"') {
-          break;
-        } else {
-          value += char;
-          i++;
-        }
+${sections}
+
+<!-- visor:thread-end key="${this.threadKeyFor(ctx)}" -->`;
       }
-      if (value.trim().length > 0) {
-        return value.trim();
+      threadKeyFor(ctx) {
+        const r = ctx.run;
+        return r.repo && r.pr && r.headSha ? `${r.repo.owner}/${r.repo.name}#${r.pr}@${(r.headSha || "").substring(0, 7)}` : r.runId;
       }
-    }
-  }
-  return void 0;
-}
-function extractTextFromJson(content) {
-  if (content === void 0 || content === null) return void 0;
-  let parsed = content;
-  if (typeof content === "string") {
-    const trimmed = content.trim();
-    if (!trimmed.startsWith("{") && !trimmed.startsWith("[")) {
-      return trimmed.length > 0 ? trimmed : void 0;
-    }
-    try {
-      parsed = JSON.parse(trimmed);
-    } catch {
-      const extracted = extractTextFieldFromMalformedJson(trimmed);
-      if (extracted) {
-        return extracted;
+      renderThreadHeader(ctx, group) {
+        const header = {
+          key: this.threadKeyFor(ctx),
+          runId: ctx.run.runId,
+          workflowId: ctx.run.workflowId,
+          revision: this.revision,
+          group,
+          generatedAt: (/* @__PURE__ */ new Date()).toISOString()
+        };
+        return `<!-- visor:thread=${JSON.stringify(header)} -->`;
       }
-      return trimmed.length > 0 ? trimmed : void 0;
-    }
-  }
-  if (parsed && typeof parsed === "object") {
-    const txt = parsed.text || parsed.response || parsed.message;
-    if (typeof txt === "string" && txt.trim()) {
-      return txt.trim();
-    }
-  }
-  if (typeof content === "string") {
-    const trimmed = content.trim();
-    return trimmed.length > 0 ? trimmed : void 0;
-  }
-  return void 0;
-}
-
-// src/frontends/github-frontend.ts
-var GitHubFrontend = class {
-  name = "github";
-  subs = [];
-  checkRunIds = /* @__PURE__ */ new Map();
-  revision = 0;
-  cachedCommentId;
-  // legacy single-thread id (kept for compatibility)
-  // Group → (checkId → SectionState)
-  stepStatusByGroup = /* @__PURE__ */ new Map();
-  // Debounce/coalescing state
-  debounceMs = 400;
-  maxWaitMs = 2e3;
-  _timer = null;
-  _lastFlush = 0;
-  _pendingIds = /* @__PURE__ */ new Set();
-  // Mutex for serializing comment updates per group
-  updateLocks = /* @__PURE__ */ new Map();
-  minUpdateDelayMs = 1e3;
-  // Minimum delay between updates (public for testing)
-  // Cache of created GitHub comment IDs per group to handle API eventual consistency
-  createdCommentGithubIds = /* @__PURE__ */ new Map();
-  start(ctx) {
-    const log = ctx.logger;
-    const bus = ctx.eventBus;
-    const octokit = ctx.octokit;
-    const repo = ctx.run.repo;
-    const pr = ctx.run.pr;
-    const headSha = ctx.run.headSha;
-    const canPostComments = !!(octokit && repo && pr);
-    const canPostChecks = !!(octokit && repo && pr && headSha);
-    const svc = canPostChecks ? new (init_github_check_service(), __toCommonJS(github_check_service_exports)).GitHubCheckService(octokit) : null;
-    const CommentManager2 = (init_github_comments(), __toCommonJS(github_comments_exports)).CommentManager;
-    const comments = canPostComments ? new CommentManager2(octokit) : null;
-    const threadKey = repo && pr && headSha ? `${repo.owner}/${repo.name}#${pr}@${(headSha || "").substring(0, 7)}` : ctx.run.runId;
-    this.cachedCommentId = `visor-thread-${threadKey}`;
-    this.subs.push(
-      bus.on("CheckScheduled", async (env) => {
-        const ev = env && env.payload || env;
-        try {
-          if (!canPostChecks || !svc) return;
-          if (this.checkRunIds.has(ev.checkId)) return;
-          const group = this.getGroupForCheck(ctx, ev.checkId);
-          this.upsertSectionState(group, ev.checkId, {
-            status: "queued",
-            lastUpdated: (/* @__PURE__ */ new Date()).toISOString()
-          });
-          const res = await svc.createCheckRun(
-            {
-              owner: repo.owner,
-              repo: repo.name,
-              head_sha: headSha,
-              name: `Visor: ${ev.checkId}`,
-              external_id: `visor:${ctx.run.runId}:${ev.checkId}`,
-              engine_mode: "state-machine"
-            },
-            { title: `${ev.checkId}`, summary: "Queued" }
-          );
-          this.checkRunIds.set(ev.checkId, res.id);
-        } catch (e) {
-          log.warn(
-            `[github-frontend] createCheckRun failed for ${ev.checkId}: ${e instanceof Error ? e.message : e}`
-          );
+      renderSections(ctx, group) {
+        const lines = [];
+        const groupMap = this.stepStatusByGroup.get(group) || /* @__PURE__ */ new Map();
+        for (const [checkId, st] of groupMap.entries()) {
+          const start = `<!-- visor:section=${JSON.stringify({ id: checkId, revision: this.revision })} -->`;
+          const end = `<!-- visor:section-end id="${checkId}" -->`;
+          const body = st.content && st.content.toString().trim().length > 0 ? st.content.toString().trim() : "";
+          lines.push(`${start}
+${body}
+${end}`);
         }
-      })
-    );
-    this.subs.push(
-      bus.on("CheckCompleted", async (env) => {
-        const ev = env && env.payload || env;
+        return lines.join("\\n\\n");
+      }
+      /**
+       * Acquires a mutex lock for the given group and executes the update.
+       * This ensures only one comment update happens at a time per group,
+       * preventing race conditions where updates overwrite each other.
+       *
+       * Uses a proper queue-based mutex: each new caller chains onto the previous
+       * lock, ensuring strict serialization even when multiple callers wait
+       * simultaneously.
+       */
+      async updateGroupedComment(ctx, comments, group, changedIds) {
+        const existingLock = this.updateLocks.get(group);
+        let resolveLock;
+        const ourLock = new Promise((resolve) => {
+          resolveLock = resolve;
+        });
+        this.updateLocks.set(group, ourLock);
         try {
-          if (canPostChecks && svc && this.checkRunIds.has(ev.checkId)) {
-            const id = this.checkRunIds.get(ev.checkId);
-            const issues = Array.isArray(ev.result?.issues) ? ev.result.issues : [];
-            const failureResults = await this.evaluateFailureResults(ctx, ev.checkId, ev.result);
-            await svc.completeCheckRun(
-              repo.owner,
-              repo.name,
-              id,
-              ev.checkId,
-              failureResults,
-              issues,
-              void 0,
-              void 0,
-              pr,
-              headSha
-            );
+          if (existingLock) {
+            try {
+              await existingLock;
+            } catch (error) {
+              logger.warn(
+                `[github-frontend] Previous update for group ${group} failed: ${error instanceof Error ? error.message : error}`
+              );
+            }
           }
-          if (canPostComments && comments) {
-            const count = Array.isArray(ev.result?.issues) ? ev.result.issues.length : 0;
-            const failureResults = await this.evaluateFailureResults(ctx, ev.checkId, ev.result);
-            const failed = Array.isArray(failureResults) ? failureResults.some((r) => r && r.failed) : false;
-            const group = this.getGroupForCheck(ctx, ev.checkId);
-            const rawContent = ev?.result?.content;
-            const extractedContent = extractTextFromJson(rawContent);
-            this.upsertSectionState(group, ev.checkId, {
-              status: "completed",
-              conclusion: failed ? "failure" : "success",
-              issues: count,
-              lastUpdated: (/* @__PURE__ */ new Date()).toISOString(),
-              content: extractedContent
-            });
-            await this.updateGroupedComment(ctx, comments, group, ev.checkId);
+          await this.performGroupedCommentUpdate(ctx, comments, group, changedIds);
+        } finally {
+          if (this.updateLocks.get(group) === ourLock) {
+            this.updateLocks.delete(group);
           }
-        } catch (e) {
-          log.warn(
-            `[github-frontend] handle CheckCompleted failed: ${e instanceof Error ? e.message : e}`
-          );
+          resolveLock();
         }
-      })
-    );
-    this.subs.push(
-      bus.on("CheckErrored", async (env) => {
-        const ev = env && env.payload || env;
+      }
+      /**
+       * Performs the actual comment update with delay enforcement.
+       */
+      async performGroupedCommentUpdate(ctx, comments, group, changedIds) {
         try {
-          if (canPostChecks && svc && this.checkRunIds.has(ev.checkId)) {
-            const id = this.checkRunIds.get(ev.checkId);
-            await svc.completeCheckRun(
-              repo.owner,
-              repo.name,
-              id,
-              ev.checkId,
-              [],
-              [],
-              ev.error?.message || "Execution error",
-              void 0,
-              pr,
-              headSha
+          if (!ctx.run.repo || !ctx.run.pr) return;
+          const config = ctx.config;
+          const prCommentEnabled = config?.output?.pr_comment?.enabled !== false;
+          if (!prCommentEnabled) {
+            logger.debug(
+              `[github-frontend] PR comments disabled in config, skipping comment for group: ${group}`
             );
+            return;
           }
-          if (canPostComments && comments) {
-            const group = this.getGroupForCheck(ctx, ev.checkId);
-            this.upsertSectionState(group, ev.checkId, {
-              status: "errored",
-              conclusion: "failure",
-              issues: 0,
-              lastUpdated: (/* @__PURE__ */ new Date()).toISOString(),
-              error: ev.error?.message || "Execution error"
-            });
-            await this.updateGroupedComment(ctx, comments, group, ev.checkId);
+          const timeSinceLastFlush = Date.now() - this._lastFlush;
+          if (this._lastFlush > 0 && timeSinceLastFlush < this.minUpdateDelayMs) {
+            const delay = this.minUpdateDelayMs - timeSinceLastFlush;
+            logger.debug(
+              `[github-frontend] Waiting ${delay}ms before next update to prevent rate limiting`
+            );
+            await this.sleep(delay);
           }
+          this.revision++;
+          const commentId = this.commentIdForGroup(ctx, group);
+          const mergedBody = await this.mergeIntoExistingBody(ctx, comments, group, changedIds);
+          const cachedGithubId = this.createdCommentGithubIds.get(commentId);
+          const result = await comments.updateOrCreateComment(
+            ctx.run.repo.owner,
+            ctx.run.repo.name,
+            ctx.run.pr,
+            mergedBody,
+            {
+              commentId,
+              triggeredBy: this.deriveTriggeredBy(ctx),
+              commitSha: ctx.run.headSha,
+              // Pass the cached GitHub comment ID if available
+              cachedGithubCommentId: cachedGithubId
+            }
+          );
+          if (result && result.id) {
+            this.createdCommentGithubIds.set(commentId, result.id);
+          }
+          this._lastFlush = Date.now();
         } catch (e) {
-          log.warn(
-            `[github-frontend] handle CheckErrored failed: ${e instanceof Error ? e.message : e}`
+          logger.debug(
+            `[github-frontend] updateGroupedComment failed: ${e instanceof Error ? e.message : e}`
           );
         }
-      })
-    );
-    this.subs.push(
-      bus.on("StateTransition", async (env) => {
-        const ev = env && env.payload || env;
-        try {
-          if (ev.to === "Completed" || ev.to === "Error") {
-            if (canPostComments && comments) {
-              for (const group of this.stepStatusByGroup.keys()) {
-                await this.updateGroupedComment(ctx, comments, group);
-              }
+      }
+      deriveTriggeredBy(ctx) {
+        const ev = ctx.run.event || "";
+        const actor = ctx.run.actor;
+        const commentEvents = /* @__PURE__ */ new Set([
+          "issue_comment",
+          "issue_comment_created",
+          "pr_comment",
+          "comment",
+          "pull_request_review_comment"
+        ]);
+        if (commentEvents.has(ev) && actor) return actor;
+        if (ev) return ev;
+        return actor || "unknown";
+      }
+      async mergeIntoExistingBody(ctx, comments, group, changedIds) {
+        const repo = ctx.run.repo;
+        const pr = ctx.run.pr;
+        const existing = await comments.findVisorComment(
+          repo.owner,
+          repo.name,
+          pr,
+          this.commentIdForGroup(ctx, group)
+        );
+        if (!existing || !existing.body) return this.buildFullBody(ctx, group);
+        const body = String(existing.body);
+        const doc = this.parseSections(body);
+        doc.header = {
+          ...doc.header || {},
+          key: this.threadKeyFor(ctx),
+          revision: this.revision,
+          group
+        };
+        if (changedIds) {
+          const ids = Array.isArray(changedIds) ? changedIds : [changedIds];
+          const fresh = this.renderSections(ctx, group);
+          for (const id of ids) {
+            const block = this.extractSectionById(fresh, id);
+            if (block) doc.sections.set(id, block);
+          }
+        } else {
+          const fresh = this.renderSections(ctx, group);
+          const map = this.stepStatusByGroup.get(group) || /* @__PURE__ */ new Map();
+          for (const [checkId] of map.entries()) {
+            if (!doc.sections.has(checkId)) {
+              const block = this.extractSectionById(fresh, checkId);
+              if (block) doc.sections.set(checkId, block);
             }
           }
-        } catch (e) {
-          log.warn(
-            `[github-frontend] handle StateTransition failed: ${e instanceof Error ? e.message : e}`
-          );
         }
-      })
-    );
-  }
-  stop() {
-    for (const s of this.subs) s.unsubscribe();
-    this.subs = [];
-  }
-  async buildFullBody(ctx, group) {
-    const header = this.renderThreadHeader(ctx, group);
-    const sections = this.renderSections(ctx, group);
-    return `${header}
-
-${sections}
-
-<!-- visor:thread-end key="${this.threadKeyFor(ctx)}" -->`;
-  }
-  threadKeyFor(ctx) {
-    const r = ctx.run;
-    return r.repo && r.pr && r.headSha ? `${r.repo.owner}/${r.repo.name}#${r.pr}@${(r.headSha || "").substring(0, 7)}` : r.runId;
-  }
-  renderThreadHeader(ctx, group) {
-    const header = {
-      key: this.threadKeyFor(ctx),
-      runId: ctx.run.runId,
-      workflowId: ctx.run.workflowId,
-      revision: this.revision,
-      group,
-      generatedAt: (/* @__PURE__ */ new Date()).toISOString()
-    };
-    return `<!-- visor:thread=${JSON.stringify(header)} -->`;
-  }
-  renderSections(ctx, group) {
-    const lines = [];
-    const groupMap = this.stepStatusByGroup.get(group) || /* @__PURE__ */ new Map();
-    for (const [checkId, st] of groupMap.entries()) {
-      const start = `<!-- visor:section=${JSON.stringify({ id: checkId, revision: this.revision })} -->`;
-      const end = `<!-- visor:section-end id="${checkId}" -->`;
-      const body = st.content && st.content.toString().trim().length > 0 ? st.content.toString().trim() : "";
-      lines.push(`${start}
-${body}
-${end}`);
-    }
-    return lines.join("\\n\\n");
-  }
-  /**
-   * Acquires a mutex lock for the given group and executes the update.
-   * This ensures only one comment update happens at a time per group,
-   * preventing race conditions where updates overwrite each other.
-   *
-   * Uses a proper queue-based mutex: each new caller chains onto the previous
-   * lock, ensuring strict serialization even when multiple callers wait
-   * simultaneously.
-   */
-  async updateGroupedComment(ctx, comments, group, changedIds) {
-    const existingLock = this.updateLocks.get(group);
-    let resolveLock;
-    const ourLock = new Promise((resolve) => {
-      resolveLock = resolve;
-    });
-    this.updateLocks.set(group, ourLock);
-    try {
-      if (existingLock) {
+        return this.serializeSections(doc);
+      }
+      parseSections(body) {
+        const sections = /* @__PURE__ */ new Map();
+        const headerRe = /<!--\s*visor:thread=(\{[\s\S]*?\})\s*-->/m;
+        const startRe = /<!--\s*visor:section=(\{[\s\S]*?\})\s*-->/g;
+        const endRe = /<!--\s*visor:section-end\s+id=\"([^\"]+)\"\s*-->/g;
+        const safePick = (obj, allowed) => {
+          if (!obj || typeof obj !== "object" || Array.isArray(obj)) return void 0;
+          const out = /* @__PURE__ */ Object.create(null);
+          for (const [k, t] of Object.entries(allowed)) {
+            if (Object.prototype.hasOwnProperty.call(obj, k)) {
+              const v = obj[k];
+              if (t === "string" && typeof v === "string") out[k] = v;
+              else if (t === "number" && typeof v === "number" && Number.isFinite(v)) out[k] = v;
+            }
+          }
+          return out;
+        };
+        const safeParse = (text) => {
+          try {
+            return JSON.parse(text);
+          } catch {
+            return void 0;
+          }
+        };
+        let header;
         try {
-          await existingLock;
-        } catch (error) {
-          logger.warn(
-            `[github-frontend] Previous update for group ${group} failed: ${error instanceof Error ? error.message : error}`
-          );
+          const h = headerRe.exec(body);
+          if (h) {
+            const parsed = safeParse(h[1]);
+            const picked = safePick(parsed, {
+              key: "string",
+              runId: "string",
+              workflowId: "string",
+              revision: "number",
+              group: "string",
+              generatedAt: "string"
+            });
+            header = picked;
+          }
+        } catch {
         }
+        let cursor = 0;
+        while (true) {
+          const s = startRe.exec(body);
+          if (!s) break;
+          const metaRaw = safeParse(s[1]);
+          const meta = safePick(metaRaw, { id: "string", revision: "number" }) || { id: "" };
+          const startIdx = startRe.lastIndex;
+          endRe.lastIndex = startIdx;
+          const e = endRe.exec(body);
+          if (!e) break;
+          const id = typeof meta.id === "string" && meta.id ? String(meta.id) : String(e[1]);
+          const content = body.substring(startIdx, e.index).trim();
+          const block = `<!-- visor:section=${JSON.stringify(meta)} -->
+${content}
+<!-- visor:section-end id="${id}" -->`;
+          sections.set(id, block);
+          cursor = endRe.lastIndex;
+          startRe.lastIndex = cursor;
+        }
+        return { header, sections };
       }
-      await this.performGroupedCommentUpdate(ctx, comments, group, changedIds);
-    } finally {
-      if (this.updateLocks.get(group) === ourLock) {
-        this.updateLocks.delete(group);
+      serializeSections(doc) {
+        const header = `<!-- visor:thread=${JSON.stringify({ ...doc.header || {}, generatedAt: (/* @__PURE__ */ new Date()).toISOString() })} -->`;
+        const blocks = Array.from(doc.sections.values()).join("\n\n");
+        const key = doc.header && doc.header.key || "";
+        return `${header}
+
+${blocks}
+
+<!-- visor:thread-end key="${key}" -->`;
       }
-      resolveLock();
-    }
-  }
-  /**
-   * Performs the actual comment update with delay enforcement.
-   */
-  async performGroupedCommentUpdate(ctx, comments, group, changedIds) {
-    try {
-      if (!ctx.run.repo || !ctx.run.pr) return;
-      const config = ctx.config;
-      const prCommentEnabled = config?.output?.pr_comment?.enabled !== false;
-      if (!prCommentEnabled) {
-        logger.debug(
-          `[github-frontend] PR comments disabled in config, skipping comment for group: ${group}`
+      extractSectionById(rendered, id) {
+        const rx = new RegExp(
+          `<!--\\s*visor:section=(\\{[\\s\\S]*?\\})\\s*-->[\\s\\S]*?<!--\\s*visor:section-end\\s+id=\\"${this.escapeRegExp(id)}\\"\\s*-->`,
+          "m"
         );
-        return;
+        const m = rx.exec(rendered);
+        return m ? m[0] : void 0;
       }
-      const timeSinceLastFlush = Date.now() - this._lastFlush;
-      if (this._lastFlush > 0 && timeSinceLastFlush < this.minUpdateDelayMs) {
-        const delay = this.minUpdateDelayMs - timeSinceLastFlush;
-        logger.debug(
-          `[github-frontend] Waiting ${delay}ms before next update to prevent rate limiting`
-        );
-        await this.sleep(delay);
+      escapeRegExp(s) {
+        return s.replace(/[.*+?^${}()|[\\]\\]/g, "\\$&");
       }
-      this.revision++;
-      const commentId = this.commentIdForGroup(ctx, group);
-      const mergedBody = await this.mergeIntoExistingBody(ctx, comments, group, changedIds);
-      const cachedGithubId = this.createdCommentGithubIds.get(commentId);
-      const result = await comments.updateOrCreateComment(
-        ctx.run.repo.owner,
-        ctx.run.repo.name,
-        ctx.run.pr,
-        mergedBody,
-        {
-          commentId,
-          triggeredBy: this.deriveTriggeredBy(ctx),
-          commitSha: ctx.run.headSha,
-          // Pass the cached GitHub comment ID if available
-          cachedGithubCommentId: cachedGithubId
+      getGroupForCheck(ctx, checkId) {
+        try {
+          const cfg = ctx.config || {};
+          const g = cfg?.checks?.[checkId]?.group || cfg?.steps?.[checkId]?.group;
+          if (typeof g === "string" && g.trim().length > 0) return g;
+        } catch {
         }
-      );
-      if (result && result.id) {
-        this.createdCommentGithubIds.set(commentId, result.id);
-      }
-      this._lastFlush = Date.now();
-    } catch (e) {
-      logger.debug(
-        `[github-frontend] updateGroupedComment failed: ${e instanceof Error ? e.message : e}`
-      );
-    }
-  }
-  deriveTriggeredBy(ctx) {
-    const ev = ctx.run.event || "";
-    const actor = ctx.run.actor;
-    const commentEvents = /* @__PURE__ */ new Set([
-      "issue_comment",
-      "issue_comment_created",
-      "pr_comment",
-      "comment",
-      "pull_request_review_comment"
-    ]);
-    if (commentEvents.has(ev) && actor) return actor;
-    if (ev) return ev;
-    return actor || "unknown";
-  }
-  async mergeIntoExistingBody(ctx, comments, group, changedIds) {
-    const repo = ctx.run.repo;
-    const pr = ctx.run.pr;
-    const existing = await comments.findVisorComment(
-      repo.owner,
-      repo.name,
-      pr,
-      this.commentIdForGroup(ctx, group)
-    );
-    if (!existing || !existing.body) return this.buildFullBody(ctx, group);
-    const body = String(existing.body);
-    const doc = this.parseSections(body);
-    doc.header = {
-      ...doc.header || {},
-      key: this.threadKeyFor(ctx),
-      revision: this.revision,
-      group
-    };
-    if (changedIds) {
-      const ids = Array.isArray(changedIds) ? changedIds : [changedIds];
-      const fresh = this.renderSections(ctx, group);
-      for (const id of ids) {
-        const block = this.extractSectionById(fresh, id);
-        if (block) doc.sections.set(id, block);
+        return "review";
       }
-    } else {
-      const fresh = this.renderSections(ctx, group);
-      const map = this.stepStatusByGroup.get(group) || /* @__PURE__ */ new Map();
-      for (const [checkId] of map.entries()) {
-        if (!doc.sections.has(checkId)) {
-          const block = this.extractSectionById(fresh, checkId);
-          if (block) doc.sections.set(checkId, block);
+      upsertSectionState(group, checkId, patch) {
+        let groupMap = this.stepStatusByGroup.get(group);
+        if (!groupMap) {
+          groupMap = /* @__PURE__ */ new Map();
+          this.stepStatusByGroup.set(group, groupMap);
         }
+        const prev = groupMap.get(checkId) || { status: "queued", lastUpdated: (/* @__PURE__ */ new Date()).toISOString() };
+        groupMap.set(checkId, { ...prev, ...patch });
       }
-    }
-    return this.serializeSections(doc);
-  }
-  parseSections(body) {
-    const sections = /* @__PURE__ */ new Map();
-    const headerRe = /<!--\s*visor:thread=(\{[\s\S]*?\})\s*-->/m;
-    const startRe = /<!--\s*visor:section=(\{[\s\S]*?\})\s*-->/g;
-    const endRe = /<!--\s*visor:section-end\s+id=\"([^\"]+)\"\s*-->/g;
-    const safePick = (obj, allowed) => {
-      if (!obj || typeof obj !== "object" || Array.isArray(obj)) return void 0;
-      const out = /* @__PURE__ */ Object.create(null);
-      for (const [k, t] of Object.entries(allowed)) {
-        if (Object.prototype.hasOwnProperty.call(obj, k)) {
-          const v = obj[k];
-          if (t === "string" && typeof v === "string") out[k] = v;
-          else if (t === "number" && typeof v === "number" && Number.isFinite(v)) out[k] = v;
+      commentIdForGroup(ctx, group) {
+        if (group === "dynamic") {
+          return `visor-thread-dynamic-${ctx.run.runId}`;
         }
+        const r = ctx.run;
+        const base = r.repo && r.pr ? `${r.repo.owner}/${r.repo.name}#${r.pr}` : r.runId;
+        return `visor-thread-${group}-${base}`;
       }
-      return out;
-    };
-    const safeParse = (text) => {
-      try {
-        return JSON.parse(text);
-      } catch {
-        return void 0;
+      /**
+       * Compute failure condition results for a completed check so Check Runs map to the
+       * correct GitHub conclusion. This mirrors the engine's evaluation for fail_if.
+       */
+      async evaluateFailureResults(ctx, checkId, result) {
+        try {
+          const config = ctx.config || {};
+          const checks = config && config.checks || {};
+          const checkCfg = checks[checkId] || {};
+          const checkSchema = typeof checkCfg.schema === "string" ? checkCfg.schema : "code-review";
+          const checkGroup = checkCfg.group || "default";
+          const { FailureConditionEvaluator } = (init_failure_condition_evaluator(), __toCommonJS(failure_condition_evaluator_exports));
+          const evaluator = new FailureConditionEvaluator();
+          const reviewSummary = { issues: Array.isArray(result?.issues) ? result.issues : [] };
+          const failures = [];
+          if (config.fail_if) {
+            const failed = await evaluator.evaluateSimpleCondition(
+              checkId,
+              checkSchema,
+              checkGroup,
+              reviewSummary,
+              config.fail_if
+            );
+            failures.push({
+              conditionName: "global_fail_if",
+              failed,
+              expression: config.fail_if,
+              severity: "error",
+              haltExecution: false
+            });
+          }
+          if (checkCfg.fail_if) {
+            const failed = await evaluator.evaluateSimpleCondition(
+              checkId,
+              checkSchema,
+              checkGroup,
+              reviewSummary,
+              checkCfg.fail_if
+            );
+            failures.push({
+              conditionName: `${checkId}_fail_if`,
+              failed,
+              expression: checkCfg.fail_if,
+              severity: "error",
+              haltExecution: false
+            });
+          }
+          return failures;
+        } catch {
+          return [];
+        }
       }
-    };
-    let header;
-    try {
-      const h = headerRe.exec(body);
-      if (h) {
-        const parsed = safeParse(h[1]);
-        const picked = safePick(parsed, {
-          key: "string",
-          runId: "string",
-          workflowId: "string",
-          revision: "number",
-          group: "string",
-          generatedAt: "string"
-        });
-        header = picked;
+      // Debounce helpers
+      scheduleUpdate(ctx, comments, group, id) {
+        if (id) this._pendingIds.add(id);
+        const now = Date.now();
+        const since = now - this._lastFlush;
+        const remaining = this.maxWaitMs - since;
+        if (this._timer) clearTimeout(this._timer);
+        const wait = Math.max(0, Math.min(this.debounceMs, remaining));
+        this._timer = setTimeout(async () => {
+          const ids = Array.from(this._pendingIds);
+          this._pendingIds.clear();
+          this._timer = null;
+          await this.updateGroupedComment(ctx, comments, group, ids.length > 0 ? ids : void 0);
+          this._lastFlush = Date.now();
+        }, wait);
       }
-    } catch {
-    }
-    let cursor = 0;
-    while (true) {
-      const s = startRe.exec(body);
-      if (!s) break;
-      const metaRaw = safeParse(s[1]);
-      const meta = safePick(metaRaw, { id: "string", revision: "number" }) || { id: "" };
-      const startIdx = startRe.lastIndex;
-      endRe.lastIndex = startIdx;
-      const e = endRe.exec(body);
-      if (!e) break;
-      const id = typeof meta.id === "string" && meta.id ? String(meta.id) : String(e[1]);
-      const content = body.substring(startIdx, e.index).trim();
-      const block = `<!-- visor:section=${JSON.stringify(meta)} -->
-${content}
-<!-- visor:section-end id="${id}" -->`;
-      sections.set(id, block);
-      cursor = endRe.lastIndex;
-      startRe.lastIndex = cursor;
-    }
-    return { header, sections };
-  }
-  serializeSections(doc) {
-    const header = `<!-- visor:thread=${JSON.stringify({ ...doc.header || {}, generatedAt: (/* @__PURE__ */ new Date()).toISOString() })} -->`;
-    const blocks = Array.from(doc.sections.values()).join("\n\n");
-    const key = doc.header && doc.header.key || "";
-    return `${header}
-
-${blocks}
-
-<!-- visor:thread-end key="${key}" -->`;
-  }
-  extractSectionById(rendered, id) {
-    const rx = new RegExp(
-      `<!--\\s*visor:section=(\\{[\\s\\S]*?\\})\\s*-->[\\s\\S]*?<!--\\s*visor:section-end\\s+id=\\"${this.escapeRegExp(id)}\\"\\s*-->`,
-      "m"
-    );
-    const m = rx.exec(rendered);
-    return m ? m[0] : void 0;
-  }
-  escapeRegExp(s) {
-    return s.replace(/[.*+?^${}()|[\\]\\]/g, "\\$&");
-  }
-  getGroupForCheck(ctx, checkId) {
-    try {
-      const cfg = ctx.config || {};
-      const g = cfg?.checks?.[checkId]?.group || cfg?.steps?.[checkId]?.group;
-      if (typeof g === "string" && g.trim().length > 0) return g;
-    } catch {
-    }
-    return "review";
-  }
-  upsertSectionState(group, checkId, patch) {
-    let groupMap = this.stepStatusByGroup.get(group);
-    if (!groupMap) {
-      groupMap = /* @__PURE__ */ new Map();
-      this.stepStatusByGroup.set(group, groupMap);
-    }
-    const prev = groupMap.get(checkId) || { status: "queued", lastUpdated: (/* @__PURE__ */ new Date()).toISOString() };
-    groupMap.set(checkId, { ...prev, ...patch });
-  }
-  commentIdForGroup(ctx, group) {
-    if (group === "dynamic") {
-      return `visor-thread-dynamic-${ctx.run.runId}`;
-    }
-    const r = ctx.run;
-    const base = r.repo && r.pr ? `${r.repo.owner}/${r.repo.name}#${r.pr}` : r.runId;
-    return `visor-thread-${group}-${base}`;
-  }
-  /**
-   * Compute failure condition results for a completed check so Check Runs map to the
-   * correct GitHub conclusion. This mirrors the engine's evaluation for fail_if.
-   */
-  async evaluateFailureResults(ctx, checkId, result) {
-    try {
-      const config = ctx.config || {};
-      const checks = config && config.checks || {};
-      const checkCfg = checks[checkId] || {};
-      const checkSchema = typeof checkCfg.schema === "string" ? checkCfg.schema : "code-review";
-      const checkGroup = checkCfg.group || "default";
-      const { FailureConditionEvaluator } = (init_failure_condition_evaluator(), __toCommonJS(failure_condition_evaluator_exports));
-      const evaluator = new FailureConditionEvaluator();
-      const reviewSummary = { issues: Array.isArray(result?.issues) ? result.issues : [] };
-      const failures = [];
-      if (config.fail_if) {
-        const failed = await evaluator.evaluateSimpleCondition(
-          checkId,
-          checkSchema,
-          checkGroup,
-          reviewSummary,
-          config.fail_if
-        );
-        failures.push({
-          conditionName: "global_fail_if",
-          failed,
-          expression: config.fail_if,
-          severity: "error",
-          haltExecution: false
-        });
+      async flushNow(ctx, comments, group) {
+        if (this._timer) {
+          clearTimeout(this._timer);
+          this._timer = null;
+        }
+        const ids = Array.from(this._pendingIds);
+        this._pendingIds.clear();
+        await this.updateGroupedComment(ctx, comments, group, ids.length > 0 ? ids : void 0);
+        this._lastFlush = Date.now();
       }
-      if (checkCfg.fail_if) {
-        const failed = await evaluator.evaluateSimpleCondition(
-          checkId,
-          checkSchema,
-          checkGroup,
-          reviewSummary,
-          checkCfg.fail_if
-        );
-        failures.push({
-          conditionName: `${checkId}_fail_if`,
-          failed,
-          expression: checkCfg.fail_if,
-          severity: "error",
-          haltExecution: false
-        });
+      /**
+       * Sleep utility for enforcing delays
+       */
+      sleep(ms) {
+        return new Promise((resolve) => setTimeout(resolve, ms));
       }
-      return failures;
-    } catch {
-      return [];
-    }
-  }
-  // Debounce helpers
-  scheduleUpdate(ctx, comments, group, id) {
-    if (id) this._pendingIds.add(id);
-    const now = Date.now();
-    const since = now - this._lastFlush;
-    const remaining = this.maxWaitMs - since;
-    if (this._timer) clearTimeout(this._timer);
-    const wait = Math.max(0, Math.min(this.debounceMs, remaining));
-    this._timer = setTimeout(async () => {
-      const ids = Array.from(this._pendingIds);
-      this._pendingIds.clear();
-      this._timer = null;
-      await this.updateGroupedComment(ctx, comments, group, ids.length > 0 ? ids : void 0);
-      this._lastFlush = Date.now();
-    }, wait);
-  }
-  async flushNow(ctx, comments, group) {
-    if (this._timer) {
-      clearTimeout(this._timer);
-      this._timer = null;
-    }
-    const ids = Array.from(this._pendingIds);
-    this._pendingIds.clear();
-    await this.updateGroupedComment(ctx, comments, group, ids.length > 0 ? ids : void 0);
-    this._lastFlush = Date.now();
-  }
-  /**
-   * Sleep utility for enforcing delays
-   */
-  sleep(ms) {
-    return new Promise((resolve) => setTimeout(resolve, ms));
+    };
   }
-};
+});
+init_github_frontend();
 export {
   GitHubFrontend
 };
-//# sourceMappingURL=github-frontend-5PCKKHVC.mjs.map
+//# sourceMappingURL=github-frontend-3N2NLO66.mjs.map