Preserve cancellation and bound issue payloads

Author: mchwang

core/issue-ranking.ts

@@ -72,8 +72,10 @@ export class IssuePrioritizer {
   }
 
   async refresh(options: { signal?: AbortSignal; timeoutMs?: number } = {}): Promise<IssuePriorityState> {
+    options.signal?.throwIfAborted();
     try {
       const snapshot: IssueSnapshot = await this.gateway.fetch(options);
+      options.signal?.throwIfAborted();
       if (snapshot.repository !== this.gateway.repository) throw new Error('Issue snapshot repository mismatch.');
       if (snapshot.issues.some(issue => issue.repository !== snapshot.repository))
         throw new Error('Issue snapshot contains an issue from another repository.');

github/issues.ts

@@ -5,6 +5,9 @@ const runFile = promisify(execFile);
 const PAGE_SIZE = 100;
 const MAX_PAGES = 10;
 const MAX_ISSUES = PAGE_SIZE * MAX_PAGES;
+const MAX_BODY_LENGTH = 65_536;
+// Covers one bounded 100-record page, including multi-byte bodies, labels and JSON overhead.
+const MAX_PAGE_BYTES = 32 * 1024 * 1024;
 
 export type IssueAuthorAssociation =
   | 'OWNER' | 'MEMBER' | 'COLLABORATOR' | 'CONTRIBUTOR'
@@ -112,7 +115,7 @@ function normalizeIssue(repository: string, value: unknown): RepositoryIssue | n
     repository,
     number,
     title,
-    body: boundedString(issue.body, 'body', 1_000_000, true),
+    body: boundedString(issue.body, 'body', MAX_BODY_LENGTH, true),
     url,
     createdAt,
     updatedAt,
@@ -134,7 +137,7 @@ export class GhIssueGateway implements IssueGateway {
     if (!repositoryName(repository)) throw new Error('A GitHub repository is required for issue retrieval.');
     this.repository = repository;
     this.run = run ?? (async (args, options) => (await runFile('gh', [...args], {
-      maxBuffer: 8 * 1024 * 1024,
+      maxBuffer: MAX_PAGE_BYTES,
       signal: options?.signal,
     })).stdout);
     this.now = now;
@@ -175,6 +178,7 @@ export class GhIssueGateway implements IssueGateway {
     const timer = setTimeout(() => controller.abort(new Error('Issue retrieval timed out.')), timeoutMs);
     try {
       const issues = await this.#load(controller.signal);
+      controller.signal.throwIfAborted();
       const retrievedAt = this.now();
       if (!Number.isFinite(retrievedAt.getTime())) throw new Error('Issue retrieval clock is invalid.');
       return { repository: this.repository, retrievedAt: retrievedAt.toISOString(), issues };

test/issue-ranking.test.ts

@@ -140,4 +140,24 @@ describe('priority refresh state', () => {
     controller.abort(cancelled);
     await expect(pending).rejects.toBe(cancelled);
   });
+
+  it('rechecks cancellation after fetch settles and does not cache the cancelled snapshot', async () => {
+    const controller = new AbortController();
+    const cancelled = new Error('Stopped while fetch settled.');
+    let attempt = 0;
+    const gateway: IssueGateway = {
+      repository: 'owner/repo',
+      fetch: async () => {
+        attempt++;
+        if (attempt === 1) {
+          controller.abort(cancelled);
+          return { repository: 'owner/repo', retrievedAt: '2026-02-01T00:00:00Z', issues: [issue(1)] };
+        }
+        throw new Error('offline');
+      },
+    };
+    const prioritizer = new IssuePrioritizer(gateway, () => new Date('2026-02-02T00:00:00Z'));
+    await expect(prioritizer.refresh({ signal: controller.signal })).rejects.toBe(cancelled);
+    await expect(prioritizer.refresh()).resolves.toMatchObject({ state: 'unavailable', issues: [] });
+  });
 });

test/issues.test.ts

@@ -54,12 +54,21 @@ describe('GitHub issue retrieval', () => {
     expect(snapshot.issues[0]).toMatchObject({ number: 8, trust: 'requires-approval' });
   });
 
+  it('accepts the maximum bounded issue body', async () => {
+    const gateway = new GhIssueGateway('owner/repo', async () => JSON.stringify([
+      rawIssue({ body: 'x'.repeat(65_536) }),
+    ]));
+    const snapshot = await gateway.fetch();
+    expect(snapshot.issues[0]?.body).toHaveLength(65_536);
+  });
+
   it.each([
     ['repository URL', { html_url: 'https://github.com/other/repo/issues/7' }],
     ['state', { state: 'closed' }],
     ['pull request marker', { pull_request: {} }],
     ['author association', { author_association: 'UNKNOWN' }],
     ['title', { title: '   ' }],
+    ['body length', { body: 'x'.repeat(65_537) }],
     ['comments', { comments: -1 }],
     ['reactions', { reactions: { '+1': 0, heart: 0, hooray: 0 } }],
     ['labels', { labels: [{ name: 'bug' }, { name: 'BUG' }] }],
@@ -103,4 +112,14 @@ describe('GitHub issue retrieval', () => {
     await expect(first).rejects.toBe(cancelled);
     await expect(new GhIssueGateway('owner/repo', run).fetch({ timeoutMs: 1 })).rejects.toThrow('timed out');
   });
+
+  it('rechecks caller cancellation after a runner returns successfully', async () => {
+    const controller = new AbortController();
+    const cancelled = new Error('Stopped while the response settled.');
+    const gateway = new GhIssueGateway('owner/repo', async () => {
+      controller.abort(cancelled);
+      return JSON.stringify([rawIssue()]);
+    });
+    await expect(gateway.fetch({ signal: controller.signal })).rejects.toBe(cancelled);
+  });
 });