Merge remote-tracking branch 'origin/master' into bot/docs-audit

Author: rain

.github/workflows/discord-posts.yml

@@ -29,17 +29,40 @@ jobs:
           script: |
             const { owner, repo } = context.repo;
             const sha = context.sha;
-            const prs = await github.paginate(github.rest.repos.listPullRequestsAssociatedWithCommit, {
-              owner,
-              repo,
-              commit_sha: sha,
-            });
+
+            async function findAssociatedPRs() {
+              // It seems that when we do this too promptly after a PR merge then the data isn't there, so we have a retry loop.
+              for (let attempt = 1; attempt <= 3; attempt++) {
+                core.info('Looking for associated PRs..');
+                const prs = await github.paginate(github.rest.repos.listPullRequestsAssociatedWithCommit, {
+                  owner,
+                  repo,
+                  commit_sha: sha,
+                });
+
+                if (prs.length > 0) {
+                  return prs;
+                }
+
+                core.info('No associated PRs found. Will check again.');
+                await new Promise((resolve) => setTimeout(resolve, 30000));
+              }
+
+              return [];
+            }
+
+            const prs = await findAssociatedPRs();
+            core.info(`Associated PR info found:`);
+            core.info(JSON.stringify(prs, null, 2));
 
             if (prs.length === 0) {
+              core.info('No associated PRs found. Treating this push as a direct/non-PR push.');
               core.setOutput('is_pr_merge', 'false');
+              core.info('Output is_pr_merge=false');
               return;
             }
             if (prs.length > 1) {
+              core.info('Multiple associated PRs found. Failing because downstream notification expects exactly one PR.');
               core.setFailed(`Expected exactly one PR associated with ${sha}, found ${prs.length}.`);
               return;
             }

.github/workflows/llm-benchmark-periodic.yml

@@ -114,7 +114,7 @@ jobs:
           ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
           LLM_VENDOR: openrouter
           LLM_BENCHMARK_API_KEY: ${{ secrets.LLM_BENCHMARK_API_KEY }}
-          LLM_BENCHMARK_UPLOAD_URL: ${{ secrets.LLM_BENCHMARK_UPLOAD_URL }}
+          LLM_BENCHMARK_UPLOAD_URL: ${{ inputs.LLM_BENCHMARK_UPLOAD_URL }}
           DOTNET_MULTILEVEL_LOOKUP: "0"
           DOTNET_CLI_HOME: ${{ runner.temp }}/dotnet-home
           DOTNET_SKIP_FIRST_TIME_EXPERIENCE: "1"

Cargo.lock

@@ -294,6 +294,72 @@ class ConnectionManagerImpl {
     return this.#buildManagedConnection(managed, builder);
   }
 
+  /**
+   * Tears down the current connection and builds a fresh one from `builder`,
+   * preserving the entry's ref count and listener set.
+   *
+   * `retain()` deliberately ignores the builder once a connection is live —
+   * the right behaviour for ref-counting, but it blocks "reconnect with a
+   * fresh token" flows (e.g. swapping an anonymous session for a signed-in one
+   * after an auth change). `rebuild()` is the supported escape hatch: pass a
+   * builder carrying the new token and the pool swaps the live connection
+   * under the same subscribers, so framework hooks (`useTable`, `useReducer`,
+   * …) re-bind to the new connection automatically.
+   *
+   * The old connection's callbacks are detached before it is closed, so its
+   * disconnect event never leaks into pool state, and any pending auto-reconnect
+   * is cancelled (the caller is driving the reconnect explicitly). Returns the
+   * newly-built connection, or `null` if the key has no retained entry.
+   *
+   * @param key - Unique identifier for the connection (use getKey to generate)
+   * @param builder - Fresh connection builder; its handlers are rewired into the pool
+   */
+  rebuild<T extends DbConnectionImpl<any>>(
+    key: string,
+    builder: DbConnectionBuilder<T>
+  ): T | null {
+    const managed = this.#connections.get(key);
+    if (!managed || managed.refCount <= 0) {
+      return null;
+    }
+
+    // The caller is taking over the connection lifecycle explicitly; cancel a
+    // deferred release or a pending auto-reconnect so neither races the fresh
+    // connection, and reset the backoff so the next unexpected drop starts over.
+    if (managed.pendingRelease) {
+      clearTimeout(managed.pendingRelease);
+      managed.pendingRelease = null;
+    }
+    if (managed.reconnectTimer) {
+      clearTimeout(managed.reconnectTimer);
+      managed.reconnectTimer = null;
+    }
+    managed.reconnectAttempt = 0;
+
+    const connection = managed.connection;
+    if (connection) {
+      this.#detachCallbacks(managed, connection);
+      connection.disconnect();
+    }
+    managed.connection = undefined;
+
+    try {
+      return this.#buildManagedConnection(managed, builder) as T;
+    } catch (error) {
+      // The old connection is already torn down, so a failed rebuild would
+      // otherwise leave the pool reporting a stale "live" connection. Surface
+      // the failure into pool state (matching the onConnectError shape) so
+      // subscribers see a disconnected/errored connection, then re-throw so
+      // the caller can handle it.
+      this.#updateState(managed, {
+        isActive: false,
+        connectionError:
+          error instanceof Error ? error : new Error(String(error)),
+      });
+      throw error;
+    }
+  }
+
   release(key: string): void {
     const managed = this.#connections.get(key);
     if (!managed) {