@hcrosse/opencode-pr-tracker 0.4.2 → 0.4.4

package/README.md

@@ -52,7 +52,7 @@ Agents get three tools in the `pr` namespace: `pr.list`, `pr.attach` and `pr.det
 
 Each attached pull request shows its repository, number, status, and title. Open the sidebar with ctrl+x b if your terminal is narrow enough to hide it. Click a row to open its pull request. With more than two pull requests attached, click the **Pull requests** heading to collapse or expand the list.
 
-Stack members appear together in Stack order, joined by `┌─`, `├─` and `└─`. `├┄ 2 PRs not attached` marks Stack members between attached ones. Other pull requests use `•`.
+Stack members appear together in Stack order, including pull requests linked into a Stack after they were attached, joined by `┌─`, `├─` and `└─`. `├┄ 2 PRs not attached` marks Stack members between attached ones. Other pull requests use `•`.
 
 | Status          | Appearance             |
 | --------------- | ---------------------- |

package/dist/server.js

@@ -607,19 +607,38 @@ class AmbiguousPullRequestNumber extends Schema8.TaggedError()("AmbiguousPullReq
 function isMember(stack, attachment) {
   return stack.some((ref) => samePullRequest(ref, attachment.ref));
 }
-function attach(tracking, stack, now) {
+var differs = (before, after) => after.length !== before.length || after.some((attachment, index) => attachment !== before[index]);
+function groupOne(tracking, stack) {
   const members = Arr4.dedupeWith(stack, samePullRequest);
+  const insertAt = tracking.findIndex((attachment) => isMember(members, attachment));
+  if (insertAt === -1)
+    return tracking;
   const others = tracking.filter((attachment) => !isMember(members, attachment));
-  const requested = others.length + members.length;
+  const placed = members.flatMap((ref) => Option7.toArray(Arr4.findFirst(tracking, (attachment) => samePullRequest(attachment.ref, ref))));
+  return [...others.slice(0, insertAt), ...placed, ...others.slice(insertAt)];
+}
+function group(tracking, stacks) {
+  const grouped = new Set;
+  let next = tracking;
+  for (const stack of stacks) {
+    if (stack.some((ref) => grouped.has(ref.url)))
+      continue;
+    for (const ref of stack)
+      grouped.add(ref.url);
+    next = groupOne(next, stack);
+  }
+  return { changed: differs(tracking, next), tracking: next };
+}
+function attach(tracking, stack, now) {
+  const members = Arr4.dedupeWith(stack, samePullRequest);
+  const missing = members.filter((ref) => !tracking.some((attachment) => samePullRequest(attachment.ref, ref)));
+  const requested = tracking.length + missing.length;
   if (requested > maximumAttachments) {
     return Result5.fail(new AttachmentLimitReached({ limit: maximumAttachments, requested }));
   }
-  const position = tracking.findIndex((attachment) => isMember(members, attachment));
-  const insertAt = position === -1 ? others.length : position;
-  const placed = members.map((ref) => Option7.getOrElse(Arr4.findFirst(tracking, (attachment) => samePullRequest(attachment.ref, ref)), () => new Attachment({ attachedAt: now, ref })));
-  const next = [...others.slice(0, insertAt), ...placed, ...others.slice(insertAt)];
-  const changed = next.length !== tracking.length || next.some((attachment, index) => attachment !== tracking[index]);
-  return Result5.succeed({ changed, tracking: next });
+  const appended = [...tracking, ...missing.map((ref) => new Attachment({ attachedAt: now, ref }))];
+  const next = group(appended, [members]).tracking;
+  return Result5.succeed({ changed: differs(tracking, next), tracking: next });
 }
 function detach(tracking, ref) {
   const next = tracking.filter((attachment) => !samePullRequest(attachment.ref, ref));
@@ -685,14 +704,126 @@ function layer4(storage) {
 }
 
 // src/application/Monitor.ts
-import { Context as Context6, Effect as Effect10, Layer as Layer6, Option as Option14, PubSub, Ref as Ref2, Result as Result7, Stream } from "effect";
+import { Context as Context6, Effect as Effect10, Layer as Layer6, Option as Option15, PubSub, Ref as Ref2, Result as Result7, Stream } from "effect";
+
+// src/domain/StackLayout.ts
+import { Array as Arr6, Option as Option9, Schema as Schema11 } from "effect";
+var Membership = Schema11.Union([
+  Schema11.TaggedStruct("Standalone", {}),
+  Schema11.TaggedStruct("Stack", {
+    id: Schema11.String,
+    members: Schema11.NonEmptyArray(PullRequestRef)
+  })
+]);
+var stackOf = (entry) => Option9.filter(entry.membership, (membership) => membership._tag === "Stack");
+var urlsOf = (stack) => stack.members.map((member) => member.url);
+function reportsById(entries) {
+  const byId = new Map;
+  for (const [index, entry] of entries.entries()) {
+    for (const stack of Option9.toArray(stackOf(entry))) {
+      byId.set(stack.id, [...byId.get(stack.id) ?? [], { index, stack, url: entry.ref.url }]);
+    }
+  }
+  return byId;
+}
+function claims(byId) {
+  const claimed = new Map;
+  for (const [id, reports] of byId) {
+    for (const url of reports.flatMap((report) => urlsOf(report.stack))) {
+      claimed.set(url, new Set([...claimed.get(url) ?? [], id]));
+    }
+  }
+  return claimed;
+}
+function agrees(reports, entries, claimed) {
+  const members = Option9.match(Arr6.head(reports), {
+    onNone: () => [],
+    onSome: (report) => urlsOf(report.stack)
+  });
+  const listed = new Set(members);
+  const attachedMembers = entries.filter((entry) => listed.has(entry.ref.url));
+  return listed.size === members.length && reports.every((report) => urlsOf(report.stack).join(`
+`) === members.join(`
+`)) && members.every((url) => (claimed.get(url) ?? new Set).size === 1) && reports.every((report) => listed.has(report.url)) && attachedMembers.length === reports.length;
+}
+function placements(reports) {
+  const placed = reports.map((report) => ({
+    index: report.index,
+    position: urlsOf(report.stack).indexOf(report.url),
+    size: report.stack.members.length
+  }));
+  const adjacent = Arr6.zipWith(placed, placed.slice(1), (before, after) => after.index === before.index + 1 && after.position > before.position);
+  const ordered = placed.every((member) => member.position >= 0) && adjacent.every(Boolean);
+  return ordered ? Option9.some(placed) : Option9.none();
+}
+function agreedReports(entries) {
+  const byId = reportsById(entries);
+  const claimed = claims(byId);
+  return [...byId.values()].filter((reports) => agrees(reports, entries, claimed));
+}
+function agreedStacks(entries) {
+  return agreedReports(entries).flatMap((reports) => Option9.toArray(Option9.map(Arr6.head(reports), (report) => report.stack)));
+}
+function consistentStacks(entries) {
+  const places = new Map;
+  for (const reports of agreedReports(entries)) {
+    const placed = placements(reports);
+    for (const group of Option9.toArray(placed)) {
+      for (const [step, current] of group.entries()) {
+        places.set(current.index, {
+          attached: group.length,
+          current,
+          first: step === 0,
+          last: step === group.length - 1,
+          previous: Arr6.get(group, step - 1)
+        });
+      }
+    }
+  }
+  return places;
+}
+function marker(place) {
+  const { current } = place;
+  if (place.attached === 1 && current.size > 1)
+    return "middle";
+  if (place.first && current.position === 0)
+    return "first";
+  if (place.last && current.position === current.size - 1)
+    return "last";
+  return "middle";
+}
+function connector(place) {
+  if (!place.last)
+    return "continues";
+  return place.current.position < place.current.size - 1 ? "open" : "none";
+}
+function stackRows(entry, place) {
+  const skipped = Option9.match(place.previous, {
+    onNone: () => 0,
+    onSome: (before) => place.current.position - before.position - 1
+  });
+  const row = {
+    _tag: "PullRequest",
+    connector: connector(place),
+    entry,
+    marker: marker(place)
+  };
+  return skipped > 0 ? [{ _tag: "Gap", count: skipped }, row] : [row];
+}
+function layout(entries) {
+  const places = consistentStacks(entries);
+  return entries.flatMap((entry, index) => Option9.match(Option9.fromNullishOr(places.get(index)), {
+    onNone: () => [{ _tag: "PullRequest", connector: "none", entry, marker: "bullet" }],
+    onSome: (place) => stackRows(entry, place)
+  }));
+}
 
 // src/application/FetchQueue.ts
-import { Deferred, Effect as Effect6, Exit, Option as Option9 } from "effect";
+import { Deferred, Effect as Effect6, Exit, Option as Option10 } from "effect";
 
 class FetchQueue {
   running = false;
-  queued = Option9.none();
+  queued = Option10.none();
   fetchNow;
   scope;
   constructor(fetchNow, scope) {
@@ -711,33 +842,33 @@ class FetchQueue {
     });
   }
   join(refs) {
-    const next = Option9.getOrElse(this.queued, () => ({
+    const next = Option10.getOrElse(this.queued, () => ({
       done: Deferred.makeUnsafe(),
       refs: new Map
     }));
     for (const ref of refs)
       next.refs.set(ref.url, ref);
-    this.queued = Option9.some(next);
+    this.queued = Option10.some(next);
     return next.done;
   }
   drain(refs, done) {
     return this.fetchNow(refs).pipe(Effect6.andThen(Deferred.succeed(done, true)), Effect6.andThen(Effect6.suspend(() => this.next())), Effect6.onExit((exit) => Exit.isSuccess(exit) ? Effect6.void : Effect6.suspend(() => this.reset(done, exit.cause))));
   }
   next() {
-    return Option9.match(this.queued, {
+    return Option10.match(this.queued, {
       onNone: () => Effect6.sync(() => {
         this.running = false;
       }),
       onSome: (queued) => {
-        this.queued = Option9.none();
+        this.queued = Option10.none();
         return this.drain([...queued.refs.values()], queued.done);
       }
     });
   }
   reset(done, cause) {
-    const waiting = [done, ...Option9.toArray(Option9.map(this.queued, (queued) => queued.done))];
+    const waiting = [done, ...Option10.toArray(Option10.map(this.queued, (queued) => queued.done))];
     this.running = false;
-    this.queued = Option9.none();
+    this.queued = Option10.none();
     return Effect6.forEach(waiting, (deferred) => Deferred.failCause(deferred, cause), {
       discard: true
     });
@@ -745,28 +876,66 @@ class FetchQueue {
 }
 
 // src/application/Known.ts
-import { Duration as Duration3, Option as Option11 } from "effect";
+import { Duration as Duration3, Option as Option12 } from "effect";
 
 // src/domain/RefreshPolicy.ts
-import { Duration as Duration2, Option as Option10 } from "effect";
+import { Duration as Duration2, Option as Option11 } from "effect";
 var refreshInterval = Duration2.seconds(15);
 function nextRefresh(status) {
-  const merged = (status._tag === "Fresh" || status._tag === "Stale") && status.snapshot.state._tag === "Merged";
-  return merged ? Option10.none() : Option10.some(refreshInterval);
+  const merged = status._tag === "Fresh" && status.snapshot.state._tag === "Merged";
+  return merged ? Option11.none() : Option11.some(refreshInterval);
 }
 
 // src/application/Known.ts
-var unknown = { dueAt: Option11.some(0), membership: Option11.none(), status: pending };
+var unknown = { dueAt: Option12.some(0), membership: Option12.none(), status: pending };
 function afterRefresh(previous, result, now) {
   const status = result._tag === "Reported" ? succeeded(result.report.snapshot) : failed(previous.status, result.diagnostic, now);
   const membership = result._tag === "Reported" ? result.report.membership : previous.membership;
   return {
-    dueAt: Option11.map(nextRefresh(status), (delay) => now + Duration3.toMillis(delay)),
+    dueAt: Option12.map(nextRefresh(status), (delay) => now + Duration3.toMillis(delay)),
     membership,
     status
   };
 }
-var isDue = (known, now, ref) => Option11.match((known.get(ref.url) ?? unknown).dueAt, {
+var membersOf = (membership) => Option12.match(membership, {
+  onNone: () => [],
+  onSome: (known) => known._tag === "Stack" ? known.members : []
+});
+var keyOf2 = (membership) => Option12.match(membership, {
+  onNone: () => "",
+  onSome: (known) => known._tag === "Stack" ? [known.id, ...known.members.map((member) => member.url)].join(`
+`) : "standalone"
+});
+var sameMembership = (left, right) => keyOf2(left) === keyOf2(right);
+var outdated = (known, reported) => Option12.exists(known, (entry) => Option12.isNone(entry.dueAt) && !sameMembership(entry.membership, reported));
+function contradicted(current, results) {
+  const urls = new Set;
+  for (const [url, result] of results) {
+    if (result._tag !== "Reported")
+      continue;
+    const reported = result.report.membership;
+    const previous = (current.get(url) ?? unknown).membership;
+    if (sameMembership(previous, reported))
+      continue;
+    for (const member of [...membersOf(previous), ...membersOf(reported)]) {
+      const known = Option12.fromNullishOr(current.get(member.url));
+      if (!results.has(member.url) && outdated(known, reported))
+        urls.add(member.url);
+    }
+  }
+  return urls;
+}
+function recorded(current, results, now) {
+  const next = new Map(current);
+  for (const [url, result] of results)
+    next.set(url, afterRefresh(current.get(url) ?? unknown, result, now));
+  for (const url of contradicted(current, results)) {
+    const { membership, status } = current.get(url) ?? unknown;
+    next.set(url, { dueAt: Option12.some(now), membership, status });
+  }
+  return next;
+}
+var isDue = (known, now, ref) => Option12.match((known.get(ref.url) ?? unknown).dueAt, {
   onNone: () => false,
   onSome: (at) => at <= now
 });
@@ -779,10 +948,10 @@ import { Clock, Effect as Effect7 } from "effect";
 var currentMillis = Effect7.map(Clock.currentTimeMillis, Math.floor);
 
 // src/application/Tracker.ts
-import { Array as Arr6, Context as Context5, Effect as Effect9, Layer as Layer5, Option as Option13, Schema as Schema11 } from "effect";
+import { Array as Arr7, Context as Context5, Effect as Effect9, Layer as Layer5, Option as Option14, Schema as Schema12 } from "effect";
 
 // src/application/SessionLocks.ts
-import { Effect as Effect8, Option as Option12, Semaphore } from "effect";
+import { Effect as Effect8, Option as Option13, Semaphore } from "effect";
 
 class SessionLocks {
   locks = new Map;
@@ -803,8 +972,8 @@ class SessionLocks {
     return semaphore;
   }
   leave(sessionID) {
-    const current = Option12.fromUndefinedOr(this.locks.get(sessionID));
-    if (Option12.isNone(current))
+    const current = Option13.fromUndefinedOr(this.locks.get(sessionID));
+    if (Option13.isNone(current))
       return;
     const { semaphore, users } = current.value;
     if (users === 1)
@@ -815,11 +984,11 @@ class SessionLocks {
 }
 
 // src/application/Tracker.ts
-class PullRequestUnavailable extends Schema11.TaggedError()("PullRequestUnavailable", { diagnostic: Diagnostic, url: Schema11.String }) {
+class PullRequestUnavailable extends Schema12.TaggedError()("PullRequestUnavailable", { diagnostic: Diagnostic, url: Schema12.String }) {
 }
 
-class StackIncomplete extends Schema11.TaggedError()("StackIncomplete", {
-  url: Schema11.String
+class StackIncomplete extends Schema12.TaggedError()("StackIncomplete", {
+  url: Schema12.String
 }) {
 }
 
@@ -829,11 +998,11 @@ function discovered(ref, result) {
   if (result._tag === "Failed")
     return Effect9.fail(new PullRequestUnavailable({ diagnostic: result.diagnostic, url: ref.url }));
   const { report } = result;
-  return Option13.match(report.membership, {
+  return Option14.match(report.membership, {
     onNone: () => Effect9.fail(new StackIncomplete({ url: ref.url })),
     onSome: (membership) => Effect9.succeed({
       report,
-      stack: membership._tag === "Stack" ? membership.members : Arr6.of(ref)
+      stack: membership._tag === "Stack" ? membership.members : Arr7.of(ref)
     })
   });
 }
@@ -860,10 +1029,16 @@ var attachTo = Effect9.fn("Tracker.attach")(function* (services, sessionID, targ
 var detachFrom = Effect9.fn("Tracker.detach")(function* ({ repository }, sessionID, input) {
   const current = yield* repository.load(sessionID);
   const removal = input._tag === "Reference" ? detach(current, input.ref) : yield* Effect9.fromResult(detachNumber(current, input.number));
-  if (Option13.isSome(removal.removed))
+  if (Option14.isSome(removal.removed))
     yield* repository.save(sessionID, removal.tracking);
   return removal;
 });
+var regroupIn = Effect9.fn("Tracker.regroup")(function* ({ repository }, sessionID, stacks) {
+  const change = group(yield* repository.load(sessionID), stacks);
+  if (change.changed)
+    yield* repository.save(sessionID, change.tracking);
+  return change.tracking;
+});
 var layer5 = Layer5.effect(Tracker, Effect9.gen(function* () {
   const services = { github: yield* GitHub, repository: yield* TrackingRepository };
   const locks = new SessionLocks;
@@ -871,7 +1046,8 @@ var layer5 = Layer5.effect(Tracker, Effect9.gen(function* () {
     attach: (sessionID, input, directory) => locks.run(sessionID, attachTo(services, sessionID, { directory, input })),
     detach: (sessionID, input) => locks.run(sessionID, detachFrom(services, sessionID, input)),
     forget: (sessionID) => locks.run(sessionID, services.repository.remove(sessionID)),
-    list: (sessionID) => services.repository.load(sessionID)
+    list: (sessionID) => services.repository.load(sessionID),
+    regroup: (sessionID, stacks) => locks.run(sessionID, regroupIn(services, sessionID, stacks))
   });
 }));
 
@@ -887,16 +1063,11 @@ function entryOf(known, attachment) {
     status: current.status
   };
 }
-var urlsOf = (tracking) => tracking.map((attachment) => attachment.ref.url);
+var urlsOf2 = (tracking) => tracking.map((attachment) => attachment.ref.url);
 function remember(cache, results) {
   return Effect10.gen(function* () {
     const now = yield* currentMillis;
-    yield* Ref2.update(cache.known, (current) => {
-      const next = new Map(current);
-      for (const [url, result] of results)
-        next.set(url, afterRefresh(current.get(url) ?? unknown, result, now));
-      return next;
-    });
+    yield* Ref2.update(cache.known, (current) => recorded(current, results, now));
   });
 }
 function update(cache, refs) {
@@ -908,8 +1079,14 @@ function update(cache, refs) {
 }
 function viewOf(state, sessionID) {
   return Effect10.gen(function* () {
-    const tracking = yield* state.tracker.list(sessionID);
+    const stored = yield* state.tracker.list(sessionID);
     const current = yield* Ref2.get(state.known);
+    const entries = stored.map((attachment) => entryOf(current, attachment));
+    const stacks = agreedStacks(entries).map((stack) => stack.members);
+    if (!group(stored, stacks).changed)
+      return { entries, sessionID };
+    const regrouped = Effect10.orElseSucceed(state.tracker.regroup(sessionID, stacks), () => stored);
+    const tracking = yield* regrouped;
     return { entries: tracking.map((attachment) => entryOf(current, attachment)), sessionID };
   });
 }
@@ -931,7 +1108,7 @@ function poll(state) {
       return;
     yield* state.fetch(due);
     const dueUrls = new Set(due.map((ref) => ref.url));
-    const affected = sessions.filter((_, index) => urlsOf(trackings[index] ?? []).some((url) => dueUrls.has(url)));
+    const affected = sessions.filter((_, index) => urlsOf2(trackings[index] ?? []).some((url) => dueUrls.has(url)));
     yield* Effect10.forEach(affected, (sessionID) => publish(state, sessionID), {
       discard: true
     });
@@ -942,14 +1119,14 @@ function fetchAndShow(state, sessionID, select) {
     yield* use(state, sessionID);
     const tracking = yield* state.tracker.list(sessionID);
     const known = yield* Ref2.get(state.known);
-    yield* state.fetch(tracking.map((attachment) => attachment.ref).filter((ref) => select(Option14.fromNullishOr(known.get(ref.url)))));
+    yield* state.fetch(tracking.map((attachment) => attachment.ref).filter((ref) => select(Option15.fromNullishOr(known.get(ref.url)))));
     const view = yield* viewOf(state, sessionID);
     yield* PubSub.publish(state.published, view);
     return view;
   });
 }
-var refreshable = (known) => Option14.isSome(Option14.getOrElse(known, () => unknown).dueAt);
-var notYetKnown = (known) => Option14.isNone(known);
+var refreshable = (known) => Option15.isSome(Option15.getOrElse(known, () => unknown).dueAt);
+var notYetKnown = (known) => Option15.isNone(known);
 var layer6 = Layer6.effect(Monitor, Effect10.gen(function* () {
   const cache = {
     github: yield* GitHub,
@@ -978,114 +1155,6 @@ var layer6 = Layer6.effect(Monitor, Effect10.gen(function* () {
 // src/rpc.ts
 import { Rpc } from "@opencode/plugin/rpc";
 import { Schema as Schema13 } from "effect";
-
-// src/domain/StackLayout.ts
-import { Array as Arr7, Option as Option15, Schema as Schema12 } from "effect";
-var Membership = Schema12.Union([
-  Schema12.TaggedStruct("Standalone", {}),
-  Schema12.TaggedStruct("Stack", {
-    id: Schema12.String,
-    members: Schema12.NonEmptyArray(PullRequestRef)
-  })
-]);
-var stackOf = (entry) => Option15.filter(entry.membership, (membership) => membership._tag === "Stack");
-var urlsOf2 = (stack) => stack.members.map((member) => member.url);
-function reportsById(entries) {
-  const byId = new Map;
-  for (const [index, entry] of entries.entries()) {
-    for (const stack of Option15.toArray(stackOf(entry))) {
-      byId.set(stack.id, [...byId.get(stack.id) ?? [], { index, stack, url: entry.ref.url }]);
-    }
-  }
-  return byId;
-}
-function claims(byId) {
-  const claimed = new Map;
-  for (const [id, reports] of byId) {
-    for (const url of reports.flatMap((report) => urlsOf2(report.stack))) {
-      claimed.set(url, new Set([...claimed.get(url) ?? [], id]));
-    }
-  }
-  return claimed;
-}
-function agrees(reports, entries, claimed) {
-  const members = Option15.match(Arr7.head(reports), {
-    onNone: () => [],
-    onSome: (report) => urlsOf2(report.stack)
-  });
-  const listed = new Set(members);
-  const attachedMembers = entries.filter((entry) => listed.has(entry.ref.url));
-  return listed.size === members.length && reports.every((report) => urlsOf2(report.stack).join(`
-`) === members.join(`
-`)) && members.every((url) => (claimed.get(url) ?? new Set).size === 1) && attachedMembers.length === reports.length;
-}
-function placements(reports) {
-  const placed = reports.map((report) => ({
-    index: report.index,
-    position: urlsOf2(report.stack).indexOf(report.url),
-    size: report.stack.members.length
-  }));
-  const adjacent = Arr7.zipWith(placed, placed.slice(1), (before, after) => after.index === before.index + 1 && after.position > before.position);
-  const ordered = placed.every((member) => member.position >= 0) && adjacent.every(Boolean);
-  return ordered ? Option15.some(placed) : Option15.none();
-}
-function consistentStacks(entries) {
-  const byId = reportsById(entries);
-  const claimed = claims(byId);
-  const places = new Map;
-  for (const reports of byId.values()) {
-    const placed = agrees(reports, entries, claimed) ? placements(reports) : Option15.none();
-    for (const group of Option15.toArray(placed)) {
-      for (const [step, current] of group.entries()) {
-        places.set(current.index, {
-          attached: group.length,
-          current,
-          first: step === 0,
-          last: step === group.length - 1,
-          previous: Arr7.get(group, step - 1)
-        });
-      }
-    }
-  }
-  return places;
-}
-function marker(place) {
-  const { current } = place;
-  if (place.attached === 1 && current.size > 1)
-    return "middle";
-  if (place.first && current.position === 0)
-    return "first";
-  if (place.last && current.position === current.size - 1)
-    return "last";
-  return "middle";
-}
-function connector(place) {
-  if (!place.last)
-    return "continues";
-  return place.current.position < place.current.size - 1 ? "open" : "none";
-}
-function stackRows(entry, place) {
-  const skipped = Option15.match(place.previous, {
-    onNone: () => 0,
-    onSome: (before) => place.current.position - before.position - 1
-  });
-  const row = {
-    _tag: "PullRequest",
-    connector: connector(place),
-    entry,
-    marker: marker(place)
-  };
-  return skipped > 0 ? [{ _tag: "Gap", count: skipped }, row] : [row];
-}
-function layout(entries) {
-  const places = consistentStacks(entries);
-  return entries.flatMap((entry, index) => Option15.match(Option15.fromNullishOr(places.get(index)), {
-    onNone: () => [{ _tag: "PullRequest", connector: "none", entry, marker: "bullet" }],
-    onSome: (place) => stackRows(entry, place)
-  }));
-}
-
-// src/rpc.ts
 var Layout = Schema13.Literals(["default", "compact"]);
 var EntryView = Schema13.Struct({
   attachedAt: Schema13.Int,
@@ -1271,7 +1340,7 @@ function appearance(status) {
 // src/server/Tools.ts
 var options = { codemode: true, namespace: "pr", pinned: true };
 var PullRequestArgument = Schema14.Struct({
-  pull_request: Schema14.Union([Schema14.String, Schema14.Int]).annotate({
+  pull_request: Schema14.Union([Schema14.String, Schema14.Number]).annotate({
     description: "A pull request URL, such as github.com/owner/repository/pull/123, or a number in this repository"
   })
 });
@@ -1340,4 +1409,4 @@ export {
   server_default as default
 };
 
-//# debugId=7CB75665EE3FC22164756E2164756E21
+//# debugId=3A0BF0214CF1B17464756E2164756E21