@quenty/nevermore-cli 4.43.0-canary.783.30683872723.0 → 4.43.1

package/src/utils/open-cloud/open-cloud-client.ts

@@ -342,8 +342,10 @@ export class OpenCloudClient {
 
   private async _fetchRawLogsAsync(taskPath: string): Promise<string> {
     const apiKey = await this._resolveApiKeyAsync();
+    // Arrival order, deliberately. Do not sort by createTime: every print in a
+    // single frame shares one value, so it cannot order them anyway, and the
+    // fractional digit count varies, so comparing the strings reorders them.
     const messages: string[] = [];
-    const structured: { message: string; createTime: string }[] = [];
     let pageToken: string | undefined;
     let pagesFetched = 0;
     let entriesFetched = 0;
@@ -381,14 +383,7 @@ export class OpenCloudClient {
 
       for (const entry of data.luauExecutionSessionTaskLogs ?? []) {
         if (entry.structuredMessages?.length) {
-          // Keep createTime alongside the text: the API does not guarantee
-          // chronological order, and readers downstream assume it.
-          for (const msg of entry.structuredMessages) {
-            structured.push({
-              message: msg.message,
-              createTime: msg.createTime,
-            });
-          }
+          messages.push(...entry.structuredMessages.map((msg) => msg.message));
         } else if (entry.messages?.length) {
           messages.push(...entry.messages);
         }
@@ -399,12 +394,6 @@ export class OpenCloudClient {
       pageToken = data.nextPageToken || undefined;
     } while (pageToken);
 
-    // Out-of-order messages silently destroy marker-delimited parsing: a
-    // trailing summary that arrives early ends the scan before any of the
-    // output it summarizes has been read.
-    structured.sort((a, b) => a.createTime.localeCompare(b.createTime));
-    messages.push(...structured.map((m) => m.message));
-
     const text = messages.join('\n');
 
     // Log volume is the prime suspect when engine output goes missing between
@@ -502,10 +491,14 @@ export class OpenCloudClient {
 
   /**
    * Resolve the newest saved or published version number of a place, via the
-   * Open Cloud Assets API (`asset:read` scope; `legacy-asset:manage` also
-   * grants it). The returned number is the same value the Asset Delivery API's
-   * `/version/{n}` route expects, so it can be written straight into a
-   * `basePlace.version` pin.
+   * Open Cloud Assets API (`asset:read` scope). The returned number is the same
+   * value the Asset Delivery API's `/version/{n}` route expects, so it can be
+   * written straight into a `basePlace.version` pin.
+   *
+   * This used to add that `legacy-asset:manage` grants `asset:read` too. They
+   * are separate boxes on the credentials page and nothing here ever verified
+   * the implication, so the claim is gone rather than restated — it had already
+   * been copied into the `nevermore login` instructions as fact once.
    *
    * `saved` is the newest version of any kind — Studio saves and publishes
    * share one increasing version sequence. `published` is the newest version

package/src/utils/testing/parsers/batch-log-parser.test.ts

@@ -99,6 +99,42 @@ describe('parseBatchTestLogs', () => {
     expect(result?.logs).toContain('PlayerBadgeHelper');
   });
 
+  it('closes a section whose END was delivered after the summary', () => {
+    const logs = [
+      '===BATCH_TEST_BEGIN egghunt2026===',
+      'Tests:  1014 passed, 1077 total',
+      '===BATCH_TEST_SUMMARY===',
+      '[{"slug":"egghunt2026","success":true,"durationMs":110467}]',
+      '===BATCH_TEST_END egghunt2026 PASS 110467===',
+    ].join('\n');
+
+    const result = parseBatchTestLogs(logs, SLUG_MAP).get('egghunt2026');
+
+    expect(result?.success).toBe(true);
+    expect(result?.error).toBeUndefined();
+    expect(result?.testCounts).toEqual({
+      passed: 1014,
+      failed: 0,
+      total: 1077,
+    });
+  });
+
+  it('keeps the summary payload out of the section it interrupts', () => {
+    const logs = [
+      '===BATCH_TEST_BEGIN egghunt2026===',
+      'Tests:  10 passed, 10 total',
+      '===BATCH_TEST_SUMMARY===',
+      '[{"slug":"egghunt2026","success":true},' +
+        '{"slug":"other","success":false,"error":"boom"}]',
+      '===BATCH_TEST_END egghunt2026 PASS 10===',
+    ].join('\n');
+
+    const result = parseBatchTestLogs(logs, SLUG_MAP).get('egghunt2026');
+
+    expect(result?.logs).not.toContain('boom');
+    expect(result?.success).toBe(true);
+  });
+
   it('counts tracebacks that jest reports as a clean pass', () => {
     const logs = buildLogs(
       [

package/src/utils/testing/parsers/batch-log-parser.ts

@@ -70,6 +70,8 @@ export function parseBatchTestLogs(
   let currentSlug: string | null = null;
   let currentLines: string[] = [];
   let summaryLineIndex = -1;
+  /** True between the summary marker and its JSON payload. */
+  let summaryPayloadPending = false;
   let beginMarkersSeen = 0;
   let endMarkersSeen = 0;
   let strayEndMarkers = 0;
@@ -130,8 +132,19 @@ export function parseBatchTestLogs(
     }
 
     if (trimmed === SUMMARY_MARKER) {
-      summaryLineIndex = i;
-      break;
+      // Keep scanning: the summary prints last but is not always delivered last,
+      // and a section's END can follow it.
+      if (summaryLineIndex < 0) {
+        summaryLineIndex = i;
+      }
+      summaryPayloadPending = true;
+      continue;
+    }
+
+    // The summary's JSON payload belongs to no section.
+    if (summaryPayloadPending && trimmed.trimStart().startsWith('[')) {
+      summaryPayloadPending = false;
+      continue;
     }
 
     // Accumulate unconditionally: output that precedes the first surviving
@@ -209,7 +222,7 @@ export function parseBatchTestLogs(
     OutputHelper.warn(
       summaryLineIndex >= lines.length - 2
         ? '[batch-log-parser] Summary sits at the end of the log — consistent with the head being dropped by a log size/retention limit.'
-        : '[batch-log-parser] Summary sits early in the log — consistent with out-of-order messages ending the scan prematurely.'
+        : '[batch-log-parser] Summary sits early in the log — consistent with messages delivered out of order.'
     );
   }
 

package/src/utils/watch/github-context.test.ts

@@ -1,4 +1,4 @@
-import { describe, it, expect, vi, afterEach } from 'vitest';
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
 import {
   describeMissingWatchToken,
   parseGithubRepository,
@@ -35,6 +35,15 @@ describe('tryResolveGithubDispatchContext token', () => {
     'git rev-parse': 'main',
   };
 
+  // Cleared so these exercise the git fallback rather than whatever the host
+  // happens to export. Actions sets both, and on a pull request GITHUB_REF_NAME
+  // is a merge ref — which resolution rightly refuses, so without this the
+  // whole describe passes locally and fails only in CI.
+  beforeEach(() => {
+    vi.stubEnv('GITHUB_REPOSITORY', '');
+    vi.stubEnv('GITHUB_REF_NAME', '');
+  });
+
   // Registering ships the token to the watch service, so it has to be one the
   // user handed over. Nearly every dev machine has a logged-in `gh`, so reading
   // it by default would turn a local watch into a silent credential send.

package/src/utils/watch/http-watch-registry.ts

@@ -239,9 +239,11 @@ function _describeFailure(
     case 422: {
       // 422 is the service's "your config cannot work" answer, and it covers
       // several unrelated causes now — a missing workflow, an Open Cloud key
-      // without universe.place:read, a "saved" watch with no key, a baseline in
-      // the wrong vocabulary. Its own message names which, so the only thing
-      // worth adding is a remedy that could not already be in it.
+      // that cannot read a base place, a "saved" watch with no key, a baseline
+      // in the wrong vocabulary. Its own message names which, so the only thing
+      // worth adding is a remedy that could not already be in it. The scope
+      // itself is deliberately not named here: this file would then be a second
+      // place to correct when it is wrong, and it already has been once.
       const workflows = [
         ...new Set(
           request.watches.flatMap((w) =>

package/src/utils/watch/stream-watch-loop.ts

@@ -96,42 +96,51 @@ export async function runStreamWatchLoopAsync(
     process.on('SIGINT', onSigint);
   }
 
-  const byWatchName = new Map(entries.map((e) => [e.watchName, e]));
+  /** Everything this loop knows about one watch, in one place. */
+  interface WatchState {
+    entry: StreamWatchEntry;
+    /**
+     * What the place has actually been built from here, as an Open Cloud place
+     * version. Seeded from the lock and advanced only by a rebuild that
+     * succeeded: the service moves its own baseline whether or not anyone was
+     * listening, so this is the only durable record of what exists.
+     */
+    built: number | undefined;
+    /**
+     * The last service-side token this watch was settled at. Purely an
+     * optimization — a reconnect that reports the same token needs no Open
+     * Cloud call — and deliberately not advanced when a rebuild fails, so the
+     * next `ready` retries it.
+     */
+    settledAt?: string;
+    /**
+     * Set once the service has told us it cannot read this source, from either
+     * direction: the `ready` snapshot on connect, or a `poll-failed` event as
+     * it happens.
+     *
+     * Both are needed. A connection opened before the service's first failed
+     * poll gets a clean snapshot, and the next one is an hour away — so without
+     * the live tail a private base place would look fine for an hour before the
+     * watch admitted it was doing nothing.
+     */
+    unreadable: boolean;
+  }
 
-  /**
-   * What each place has actually been built from here, as an Open Cloud place
-   * version. Seeded from the lock and advanced only by a rebuild that
-   * succeeded: the service moves its own baseline whether or not anyone was
-   * listening, so this map is the only durable record of what exists.
-   */
-  const built = new Map<string, number | undefined>(
-    entries.map((e) => [e.watchName, e.baseline])
+  // One record per watch rather than parallel maps under the same key: every
+  // field above is a fact about the same thing, and holding them apart only
+  // creates the possibility of disagreeing about which watches exist.
+  const watches = new Map<string, WatchState>(
+    entries.map((e) => [
+      e.watchName,
+      { entry: e, built: e.baseline, unreadable: false },
+    ])
   );
 
-  /**
-   * The last service-side token each watch was settled at. Purely an
-   * optimization — a reconnect that reports the same token needs no Open Cloud
-   * call — and deliberately not advanced when a rebuild fails, so the next
-   * `ready` retries it.
-   */
-  const settledAt = new Map<string, string>();
-
   let redeploys = 0;
   let failures = 0;
   let lastDropReason: string | undefined;
   let unobservable = false;
 
-  /**
-   * Watches the service has told us it cannot read, from either direction:
-   * the `ready` snapshot on connect, or a `poll-failed` event as it happens.
-   *
-   * Both are needed. A connection opened before the service's first failed
-   * poll gets a clean snapshot, and the next one is an hour away — so without
-   * the live tail a private base place would look fine for an hour before the
-   * watch admitted it was doing nothing.
-   */
-  const unreadable = new Set<string>();
-
   /**
    * Give up the stream once nothing on it can ever fire, so the caller can
    * poll instead — this machine's credentials reach places the service's
@@ -141,7 +150,8 @@ export async function runStreamWatchLoopAsync(
     // Counted against every entry this run owns, not against what the last
     // frame happened to mention: a watch the service has stopped reporting
     // altogether can no more produce a notification than one it cannot read.
-    if (unreadable.size < byWatchName.size) {
+    const all = [...watches.values()];
+    if (all.length === 0 || !all.every((w) => w.unreadable)) {
       return false;
     }
     unobservable = true;
@@ -149,6 +159,16 @@ export async function runStreamWatchLoopAsync(
     return true;
   };
 
+  /** Marks a watch unreadable, and says whether that was news worth printing. */
+  const markUnreadable = (name: string): boolean => {
+    const state = watches.get(name);
+    if (state == null || state.unreadable) {
+      return false;
+    }
+    state.unreadable = true;
+    return true;
+  };
+
   OutputHelper.info(
     `Watching ${entries.length} base place${
       entries.length === 1 ? '' : 's'
@@ -172,10 +192,11 @@ export async function runStreamWatchLoopAsync(
    * what the place is actually at, which is the same number the build records.
    */
   const settleAsync = async (
-    entry: StreamWatchEntry,
+    state: WatchState,
     token: string | null
   ): Promise<void> => {
-    if (token != null && settledAt.get(entry.watchName) === token) {
+    const entry = state.entry;
+    if (token != null && state.settledAt === token) {
       return;
     }
 
@@ -196,17 +217,17 @@ export async function runStreamWatchLoopAsync(
       return;
     }
 
-    const previous = built.get(entry.watchName);
+    const previous = state.built;
     const settle = () => {
       if (token != null) {
-        settledAt.set(entry.watchName, token);
+        state.settledAt = token;
       }
     };
 
     if (previous === undefined) {
       // Never built here and nothing locked: adopt what is there rather than
       // reading "unknown -> something" as a change.
-      built.set(entry.watchName, latest);
+      state.built = latest;
       settle();
       return;
     }
@@ -221,7 +242,7 @@ export async function runStreamWatchLoopAsync(
     try {
       await redeployAsync(entry, latest);
       redeploys++;
-      built.set(entry.watchName, latest);
+      state.built = latest;
       settle();
       OutputHelper.info(`${entry.label}: rebuilt from v${latest}.`);
     } catch (err) {
@@ -244,7 +265,7 @@ export async function runStreamWatchLoopAsync(
         // Every connection starts here, including reconnects. Nothing is
         // replayed while a client is away, so this is the whole catch-up.
         onReadyAsync: async (ready: WatchStreamReady) => {
-          const ours = ready.watches.filter((s) => byWatchName.has(s.name));
+          const ours = ready.watches.filter((s) => watches.has(s.name));
 
           // A source the service cannot read never fires, and the socket says
           // nothing about it — the failure is visible only here. Waiting
@@ -268,17 +289,16 @@ export async function runStreamWatchLoopAsync(
           // the same set means a partial snapshot falls back too, instead of
           // holding the socket for the ones that remain and silently never
           // rebuilding the rest.
-          const missing = [...byWatchName.keys()].filter(
+          const missing = [...watches.keys()].filter(
             (name) => !ready.watches.some((s) => s.name === name)
           );
           for (const name of missing) {
-            if (unreadable.has(name)) {
+            if (!markUnreadable(name)) {
               continue;
             }
-            unreadable.add(name);
             OutputHelper.warn(
               `The watch monitor no longer holds ${
-                byWatchName.get(name)!.label
+                watches.get(name)!.entry.label
               } — another checkout has probably re-registered it.`
             );
           }
@@ -287,13 +307,12 @@ export async function runStreamWatchLoopAsync(
           }
 
           for (const status of failedToRead) {
-            if (unreadable.has(status.name)) {
+            if (!markUnreadable(status.name)) {
               continue;
             }
-            unreadable.add(status.name);
             OutputHelper.warn(
               `The watch service cannot read ${
-                byWatchName.get(status.name)!.label
+                watches.get(status.name)!.entry.label
               }` + (status.sourceError ? `: ${status.sourceError}` : '.')
             );
           }
@@ -302,25 +321,23 @@ export async function runStreamWatchLoopAsync(
           }
 
           for (const status of ours) {
-            if (!unreadable.has(status.name)) {
-              await settleAsync(
-                byWatchName.get(status.name)!,
-                status.currentVersion
-              );
+            const state = watches.get(status.name)!;
+            if (!state.unreadable) {
+              await settleAsync(state, status.currentVersion);
             }
           }
         },
 
         onNotifyAsync: async (notify: WatchStreamNotify) => {
-          const entry = byWatchName.get(notify.watchName);
-          if (!entry) {
+          const state = watches.get(notify.watchName);
+          if (!state) {
             OutputHelper.verbose(
               `Ignoring a notification for "${notify.watchName}", which this ` +
                 'run does not watch.'
             );
             return;
           }
-          await settleAsync(entry, notify.version);
+          await settleAsync(state, notify.version);
         },
 
         onEvent: (message) => {
@@ -334,17 +351,14 @@ export async function runStreamWatchLoopAsync(
           // is polling something that could have been streamed, which still
           // works.
           const name = message.event.watchName;
-          if (
-            message.event.type !== 'poll-failed' ||
-            name == null ||
-            !byWatchName.has(name) ||
-            unreadable.has(name)
-          ) {
+          if (message.event.type !== 'poll-failed' || name == null) {
+            return;
+          }
+          if (!markUnreadable(name)) {
             return;
           }
-          unreadable.add(name);
           OutputHelper.warn(
-            `The watch service cannot read ${byWatchName.get(name)!.label}: ${
+            `The watch service cannot read ${watches.get(name)!.entry.label}: ${
               message.event.message
             }`
           );