calkit-python 0.49.3__tar.gz → 0.49.4__tar.gz

{calkit_python-0.49.3 → calkit_python-0.49.4}/.calkit/stage-runs.json

@@ -38,18 +38,18 @@
     }
   },
   "find-calkit-papers": {
-    "start_time": "2026-10-22T02:33:03.151000",
-    "end_time": "2026-10-22T02:33:13.966000",
+    "start_time": "2026-10-24T01:16:02.141000",
+    "end_time": "2026-10-24T01:16:07.971000",
     "environment": "dev",
-    "git_rev": "2965496b66b48944fab7b03e19371886ae05a2a8",
+    "git_rev": "daae45c7f8364137254446ee39f0045ae1fb4191",
     "git_dirty": false,
-    "dvc_lock_hash": "sha256:45a249777a79aebf205a0c061fcf007b33d05a671bc57c29fcb1f21938446425",
-    "calkit_version": "0.49.3.dev39+g2965496b",
-    "calkit_git_rev": "2965496b66b48944fab7b03e19371886ae05a2a8",
+    "dvc_lock_hash": "sha256:ed1acb0f5f05f00a02b693c42cccf1e8bb1b500f497ab480c1f7370fb1770308",
+    "calkit_version": "0.49.4.dev43+gdaae45c7",
+    "calkit_git_rev": "daae45c7f8364137254446ee39f0045ae1fb4191",
     "system": {
-      "machine_id": "6b80cb66c24c4cf8ba62e40236d3cfda",
+      "machine_id": "2d791d5cce6240faa3c626058b1ffc7d",
       "os": "Linux",
-      "os_version": "7.0.0-1017-azure",
+      "os_version": "6.17.0-1022-azure",
       "machine": "x86_64",
       "processor": "x86_64",
       "cpu_count": 4,
@@ -57,18 +57,18 @@
     }
   },
   "find-calkit-projects": {
-    "start_time": "2026-10-22T02:32:01.006000",
-    "end_time": "2026-10-22T02:33:03.151000",
+    "start_time": "2026-10-24T01:15:00.963000",
+    "end_time": "2026-10-24T01:16:02.141000",
     "environment": "dev",
-    "git_rev": "2965496b66b48944fab7b03e19371886ae05a2a8",
+    "git_rev": "daae45c7f8364137254446ee39f0045ae1fb4191",
     "git_dirty": false,
-    "dvc_lock_hash": "sha256:ca096611f632a62330e433a0e4dbf11de8df6e2385c391205eadc02242945377",
-    "calkit_version": "0.49.3.dev39+g2965496b",
-    "calkit_git_rev": "2965496b66b48944fab7b03e19371886ae05a2a8",
+    "dvc_lock_hash": "sha256:301672e6a490f398eb70c7aee98495445266cdec96aba0cf263685b8e675c4c0",
+    "calkit_version": "0.49.4.dev43+gdaae45c7",
+    "calkit_git_rev": "daae45c7f8364137254446ee39f0045ae1fb4191",
     "system": {
-      "machine_id": "6b80cb66c24c4cf8ba62e40236d3cfda",
+      "machine_id": "2d791d5cce6240faa3c626058b1ffc7d",
       "os": "Linux",
-      "os_version": "7.0.0-1017-azure",
+      "os_version": "6.17.0-1022-azure",
       "machine": "x86_64",
       "processor": "x86_64",
       "cpu_count": 4,
@@ -132,17 +132,17 @@
     }
   },
   "one-pager/pdf": {
-    "start_time": "2026-10-22T02:33:15.906000",
-    "end_time": "2026-10-22T02:33:21.333000",
-    "git_rev": "2965496b66b48944fab7b03e19371886ae05a2a8",
+    "start_time": "2026-10-24T01:16:09.299000",
+    "end_time": "2026-10-24T01:16:13.252000",
+    "git_rev": "daae45c7f8364137254446ee39f0045ae1fb4191",
     "git_dirty": false,
-    "dvc_lock_hash": "sha256:1baf82191bd18d3f450c21417bd1550de1b0a9c195473f47667e3906e66f2fd4",
-    "calkit_version": "0.49.3.dev39+g2965496b",
-    "calkit_git_rev": "2965496b66b48944fab7b03e19371886ae05a2a8",
+    "dvc_lock_hash": "sha256:fc7b6c75e7f03baafcb74de4df99747695ea56f21c2f4ddec1129ec68c3959a0",
+    "calkit_version": "0.49.4.dev43+gdaae45c7",
+    "calkit_git_rev": "daae45c7f8364137254446ee39f0045ae1fb4191",
     "system": {
-      "machine_id": "6b80cb66c24c4cf8ba62e40236d3cfda",
+      "machine_id": "2d791d5cce6240faa3c626058b1ffc7d",
       "os": "Linux",
-      "os_version": "7.0.0-1017-azure",
+      "os_version": "6.17.0-1022-azure",
       "machine": "x86_64",
       "processor": "x86_64",
       "cpu_count": 4,
@@ -150,18 +150,18 @@
     }
   },
   "traction": {
-    "start_time": "2026-10-22T02:33:13.966000",
-    "end_time": "2026-10-22T02:33:15.906000",
+    "start_time": "2026-10-24T01:16:07.971000",
+    "end_time": "2026-10-24T01:16:09.299000",
     "environment": "dev",
-    "git_rev": "2965496b66b48944fab7b03e19371886ae05a2a8",
+    "git_rev": "daae45c7f8364137254446ee39f0045ae1fb4191",
     "git_dirty": false,
-    "dvc_lock_hash": "sha256:ee16ee8873750d7ab3bddccb4a2b0833217ef1b6641bf95ab8de9f867a794c6b",
-    "calkit_version": "0.49.3.dev39+g2965496b",
-    "calkit_git_rev": "2965496b66b48944fab7b03e19371886ae05a2a8",
+    "dvc_lock_hash": "sha256:3ac5e2633cbc17d07d9d1ae8740a42744dcb865f66dc2022eec0752994a82e5d",
+    "calkit_version": "0.49.4.dev43+gdaae45c7",
+    "calkit_git_rev": "daae45c7f8364137254446ee39f0045ae1fb4191",
     "system": {
-      "machine_id": "6b80cb66c24c4cf8ba62e40236d3cfda",
+      "machine_id": "2d791d5cce6240faa3c626058b1ffc7d",
       "os": "Linux",
-      "os_version": "7.0.0-1017-azure",
+      "os_version": "6.17.0-1022-azure",
       "machine": "x86_64",
       "processor": "x86_64",
       "cpu_count": 4,

{calkit_python-0.49.3 → calkit_python-0.49.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: calkit-python
-Version: 0.49.3
+Version: 0.49.4
 Summary: Reproducibility simplified.
 Project-URL: Homepage, https://calkit.org
 Project-URL: Issues, https://github.com/calkit/calkit/issues

{calkit_python-0.49.3 → calkit_python-0.49.4}/browser-ext/public/manifest.json

@@ -25,11 +25,12 @@
     "service_worker": "background.js",
     "type": "module"
   },
-  "permissions": ["storage", "tabs", "scripting", "activeTab"],
+  "permissions": ["storage", "tabs", "scripting", "activeTab", "cookies"],
   "host_permissions": [
     "https://api.calkit.io/*",
     "https://api.staging.calkit.io/*",
     "http://api.localhost/*",
+    "https://www.overleaf.com/*",
     "https://storage.googleapis.com/*",
     "https://s3.amazonaws.com/*",
     "https://*.s3.amazonaws.com/*"

{calkit_python-0.49.3 → calkit_python-0.49.4}/browser-ext/src/background/index.ts

@@ -38,6 +38,11 @@ function projectPath(owner: string, project: string): string {
   )}`;
 }
 
+// The session Overleaf's web app signs in with, which lets the hub sync for
+// users without Overleaf Premium, whose Git integration needs a token
+const OVERLEAF_URL = "https://www.overleaf.com";
+const OVERLEAF_SESSION_COOKIE = "overleaf_session2";
+
 const MAX_PREVIEW_BYTES = 2_000_000;
 const MAX_VIEWER_BYTES = 25_000_000;
 
@@ -251,6 +256,21 @@ async function handle(message: Request): Promise<unknown> {
         method: "PUT",
         body: { token: message.token },
       });
+    case "overleaf.connectSession": {
+      // Read here, since Overleaf keeps the cookie from page scripts, and
+      // only when the user asks, so it's never held otherwise
+      const cookie = await chrome.cookies.get({
+        url: OVERLEAF_URL,
+        name: OVERLEAF_SESSION_COOKIE,
+      });
+      if (!cookie) {
+        throw new Error("Sign in to Overleaf first");
+      }
+      return request<{ message: string }>("/user/overleaf-session", {
+        method: "PUT",
+        body: { session: cookie.value },
+      });
+    }
     case "overleaf.import":
       return request<{ path: string; title: string }>(
         `${projectPath(message.owner, message.project)}/publications/overleaf`,

{calkit_python-0.49.3 → calkit_python-0.49.4}/browser-ext/src/content/overleaf.ts

@@ -35,6 +35,19 @@ const OVERLEAF_TOKEN_RE = /\bolp_[A-Za-z0-9]{20,}\b/;
 let panel: Panel | null = null;
 let currentProjectId: string | null = null;
 let hubWebUrl = "https://calkit.io";
+// The last status found for this page, so opening the panel shows it at
+// once instead of waiting for the hub to check Overleaf all over again
+let lastCheck: {
+  overleafProjectId: string;
+  hubWebUrl: string;
+  link: OverleafLinkPublic;
+  status: OverleafSyncStatus;
+  // What the last sync did, kept through the check that follows it
+  notice?: string;
+} | null = null;
+// Bumped by each load, each sync, and each sign-in change, so a check
+// that finishes after any of them doesn't draw over it
+let loadGeneration = 0;
 let tokenWatcher: MutationObserver | null = null;
 
 /**
@@ -50,12 +63,51 @@ function isOverleafTokenProblem(e: unknown): boolean {
   );
 }
 
-/** Ask for an Overleaf Git token, and save it to the hub. */
+/**
+ * Ask for an Overleaf Git token, and save it to the hub, or, without
+ * Overleaf Premium, connect the browser's Overleaf login instead.
+ */
 function renderTokenForm(
   container: HTMLElement,
-  rejected: boolean,
+  problem: string,
   reload: () => void,
 ): void {
+  const rejected = problem.includes("rejected");
+  const sessionRejected = rejected && problem.includes("session");
+  const connectMessage = el("div", { class: "small" });
+  const connect = el("button", {
+    class: sessionRejected ? "action" : "action secondary",
+    text: "Connect with Overleaf login",
+  });
+  connect.addEventListener("click", async () => {
+    connect.disabled = true;
+    clear(connectMessage).append(loading("Connecting"));
+    try {
+      await send({ type: "overleaf.connectSession" });
+      reload();
+    } catch (e) {
+      connect.disabled = false;
+      clear(connectMessage).append(
+        errorMessage(e instanceof Error ? e.message : String(e)),
+      );
+    }
+  });
+  const connectSection = el("div", { style: { marginTop: "12px" } }, [
+    el("div", {
+      class: "small",
+      text: sessionRejected
+        ? "Overleaf no longer accepts the Overleaf login Calkit saved. " +
+          "Connect it again to keep syncing."
+        : "No Overleaf Premium? Calkit can sync using your Overleaf " +
+          "login instead of a token.",
+    }),
+    el("div", { class: "actions" }, [connect]),
+    connectMessage,
+  ]);
+  if (sessionRejected) {
+    container.append(connectSection);
+    return;
+  }
   const input = textInput({ placeholder: "olp_..." });
   input.type = "password";
   const message = el("div", { class: "small" });
@@ -107,9 +159,27 @@ function renderTokenForm(
       }),
     ]),
     message,
+    connectSection,
   );
 }
 
+/**
+ * Show a failure, offering to connect Overleaf when that's what's missing,
+ * so a first link or import works without Premium too.
+ */
+function renderOverleafFailure(e: unknown, reload: () => void): HTMLElement {
+  if (isOverleafTokenProblem(e)) {
+    const container = el("div");
+    renderTokenForm(
+      container,
+      e instanceof Error ? e.message : String(e),
+      reload,
+    );
+    return container;
+  }
+  return renderFailure(e, { onSignedIn: reload });
+}
+
 /**
  * Offer to save an Overleaf Git token to Calkit as soon as Overleaf shows
  * one, which it only does once, right after it's generated.
@@ -309,6 +379,7 @@ function renderStatus(
   });
   const message = el("div", { class: "small" });
   syncButton.addEventListener("click", async () => {
+    loadGeneration++;
     syncButton.disabled = true;
     clear(message).append(loading("Syncing"));
     try {
@@ -318,16 +389,25 @@ function renderStatus(
         project: link.project_name,
         path: status.path,
       });
-      clear(message).append(
-        el("span", {
-          class: "dim",
-          text:
-            `Synced. ${result.commits_from_overleaf} change` +
-            `${
-              result.commits_from_overleaf === 1 ? "" : "s"
-            } came from Overleaf.`,
-        }),
-      );
+      // Shown as in sync straight away, since that's what a sync leaves,
+      // while the hub confirms it
+      lastSyncNeeded = false;
+      lastCheck = {
+        overleafProjectId: link.overleaf_project_id,
+        hubWebUrl,
+        link,
+        status: {
+          ...status,
+          in_sync: true,
+          files_to_push: [],
+          files_to_delete: [],
+          commits_from_overleaf: 0,
+        },
+        notice:
+          `Synced. ${result.commits_from_overleaf} change` +
+          `${result.commits_from_overleaf === 1 ? "" : "s"} came from ` +
+          "Overleaf.",
+      };
       reload();
     } catch (e) {
       syncButton.disabled = false;
@@ -396,9 +476,7 @@ async function renderPicker(
         ]),
       );
     } catch (e) {
-      clear(message).append(
-        errorMessage(e instanceof Error ? e.message : String(e)),
-      );
+      clear(message).append(renderOverleafFailure(e, reload));
     }
   };
   const runSearch = async () => {
@@ -616,7 +694,7 @@ async function renderAttachForm(
       reload();
     } catch (e) {
       attach.disabled = false;
-      clear(message).append(renderFailure(e, { onSignedIn: reload }));
+      clear(message).append(renderOverleafFailure(e, reload));
     }
   });
   container.append(
@@ -682,9 +760,7 @@ function renderImportForm(
       reload();
     } catch (e) {
       importButton.disabled = false;
-      clear(message).append(
-        errorMessage(e instanceof Error ? e.message : String(e)),
-      );
+      clear(message).append(renderOverleafFailure(e, reload));
     }
   });
   return [
@@ -702,6 +778,8 @@ async function load(overleafProjectId: string): Promise<void> {
     return;
   }
   const body = panel.body;
+  const generation = ++loadGeneration;
+  const current = () => generation === loadGeneration;
   clear(body).append(loading());
   const reload = () => void load(overleafProjectId);
   try {
@@ -718,7 +796,31 @@ async function load(overleafProjectId: string): Promise<void> {
         }),
       ],
     );
-    clear(body).append(pickers, loading("Looking for the linked project"));
+    const cached =
+      lastCheck?.overleafProjectId === overleafProjectId &&
+      lastCheck.hubWebUrl === hubWebUrl
+        ? lastCheck
+        : null;
+    const content = el("div");
+    clear(body).append(pickers, content);
+    const showNotice = () => {
+      if (cached?.notice) {
+        content.append(
+          el("div", {
+            class: "dim small",
+            style: { marginTop: "6px" },
+            text: cached.notice,
+          }),
+        );
+      }
+    };
+    if (cached) {
+      renderStatus(content, cached.link, cached.status, reload);
+      showNotice();
+      content.append(loading("Checking for changes"));
+    } else {
+      content.append(loading("Looking for the linked project"));
+    }
     // The index answers at once when this Overleaf project has been seen
     // before; otherwise the hub reads through the user's projects, active
     // one first, and remembers what it finds
@@ -727,6 +829,9 @@ async function load(overleafProjectId: string): Promise<void> {
       overleafProjectId,
       activeProject: settings.activeProject ?? undefined,
     });
+    if (!current()) {
+      return;
+    }
     const links = lookup.links;
     if (!links.length) {
       clear(body).append(pickers);
@@ -752,15 +857,14 @@ async function load(overleafProjectId: string): Promise<void> {
       await renderPicker(chooser, overleafProjectId, reload);
       return;
     }
-    clear(body).append(pickers);
-    const content = el("div");
-    body.append(content);
     // A folder in more than one project is rare, so the first link is the
     // one shown, with the rest offered as alternatives underneath
     const link = links[0];
-    clear(content).append(
-      loading(`Checking ${link.project_owner_name}/${link.project_name}`),
-    );
+    if (!cached) {
+      clear(content).append(
+        loading(`Checking ${link.project_owner_name}/${link.project_name}`),
+      );
+    }
     const statuses = await send({
       type: "overleaf.status",
       owner: link.project_owner_name,
@@ -768,6 +872,9 @@ async function load(overleafProjectId: string): Promise<void> {
       overleafProjectId,
       path: link.path,
     });
+    if (!current()) {
+      return;
+    }
     if (!statuses.length) {
       clear(content).append(
         el("div", {
@@ -781,7 +888,9 @@ async function load(overleafProjectId: string): Promise<void> {
     }
     lastTokenProblem = false;
     lastSyncNeeded = !statuses[0].in_sync;
+    lastCheck = { overleafProjectId, hubWebUrl, link, status: statuses[0] };
     renderStatus(content, link, statuses[0], reload);
+    showNotice();
     if (links.length > 1) {
       content.append(
         el("div", {
@@ -792,6 +901,9 @@ async function load(overleafProjectId: string): Promise<void> {
       );
     }
   } catch (e) {
+    if (!current()) {
+      return;
+    }
     clear(body);
     if (e instanceof RequestFailed && e.notSignedIn) {
       // With a hub picker alongside, since credentials are per hub and a
@@ -820,15 +932,20 @@ async function load(overleafProjectId: string): Promise<void> {
       );
       return;
     }
+    // The picker stays, since the problem may be with this hub, e.g., an
+    // Overleaf token only another hub has, and switching is the way out
+    const hubPicker = el("div", { style: { marginBottom: "8px" } }, [
+      await renderHubPicker(reload),
+    ]);
     if (isOverleafTokenProblem(e)) {
-      renderTokenForm(
-        body,
-        e instanceof Error && e.message.includes("rejected"),
-        reload,
-      );
+      body.append(hubPicker);
+      renderTokenForm(body, e instanceof Error ? e.message : String(e), reload);
       return;
     }
-    body.append(errorMessage(e instanceof Error ? e.message : String(e)));
+    body.append(
+      hubPicker,
+      errorMessage(e instanceof Error ? e.message : String(e)),
+    );
   }
 }
 
@@ -942,6 +1059,12 @@ function sync(): void {
  * shows: an amber button when a sync would do something.
  */
 async function checkSyncStatus(overleafProjectId: string): Promise<void> {
+  // An answer from a hub or sign-in that has since changed describes
+  // something else, so it's dropped rather than cached
+  const generation = loadGeneration;
+  const hub = await getHubWebUrl();
+  const current = async () =>
+    generation === loadGeneration && (await getHubWebUrl()) === hub;
   try {
     const settings = await send({ type: "settings.get" });
     const lookup = await send({
@@ -960,8 +1083,14 @@ async function checkSyncStatus(overleafProjectId: string): Promise<void> {
       overleafProjectId,
       path: link.path,
     });
+    if (!(await current())) {
+      return;
+    }
     lastTokenProblem = false;
     lastSyncNeeded = Boolean(statuses.length) && !statuses[0].in_sync;
+    lastCheck = statuses.length
+      ? { overleafProjectId, hubWebUrl: hub, link, status: statuses[0] }
+      : null;
     // Nothing to say if the panel was opened in the meantime, or if the
     // page moved on to another project
     if (panel || currentProjectId !== overleafProjectId) {
@@ -972,6 +1101,9 @@ async function checkSyncStatus(overleafProjectId: string): Promise<void> {
       lastSyncNeeded ? "attention" : "idle",
     );
   } catch (e) {
+    if (!(await current())) {
+      return;
+    }
     // A token problem is worth a nudge, since nothing works until it's
     // fixed; anything else the panel explains when opened
     lastTokenProblem = isOverleafTokenProblem(e);
@@ -1028,8 +1160,10 @@ runContentScript({
     }
     const overleafProjectId = currentProjectId;
     // What the last session found says nothing about this one
+    loadGeneration++;
     lastSyncNeeded = false;
     lastTokenProblem = false;
+    lastCheck = null;
     if (panel) {
       void load(overleafProjectId);
     } else {

{calkit_python-0.49.3 → calkit_python-0.49.4}/browser-ext/src/core/messages.ts

@@ -118,6 +118,7 @@ export type Request =
     }
   | { type: "overleaf.sync"; owner: string; project: string; path: string }
   | { type: "overleaf.setToken"; token: string }
+  | { type: "overleaf.connectSession" }
   | {
       type: "overleaf.import";
       owner: string;
@@ -183,6 +184,7 @@ export interface ResponseMap {
   "overleaf.status": OverleafSyncStatus[];
   "overleaf.sync": OverleafSyncResponse;
   "overleaf.setToken": { message: string };
+  "overleaf.connectSession": { message: string };
   "overleaf.import": { path: string; title: string };
   "references.list": References[];
   "references.search": ReferenceSearchMatch[];

{calkit_python-0.49.3 → calkit_python-0.49.4}/browser-ext/src/core/pickers.ts

@@ -92,6 +92,9 @@ export async function renderProjectPicker(options: {
     class: "stack",
     style: { display: "none", marginTop: "4px" },
   });
+  // Focusable, so clicking a row's text doesn't count as leaving the list
+  results.tabIndex = -1;
+  results.style.outline = "none";
   const message = el("div", { class: "small" });
   const container = el("div", {}, [
     el("label", { text: "Active project" }),
@@ -99,6 +102,20 @@ export async function renderProjectPicker(options: {
     results,
     message,
   ]);
+  // Leaving the list without picking keeps the active project as it was
+  const close = () => {
+    clearTimeout(timer);
+    results.style.display = "none";
+    input.value = options.activeProject ?? "";
+  };
+  const cancelRow = () =>
+    el("div", { class: "actions" }, [
+      el("button", {
+        class: "action secondary",
+        text: "Cancel",
+        onClick: close,
+      }),
+    ]);
   const choose = async (spec: string) => {
     input.value = spec;
     results.style.display = "none";
@@ -128,6 +145,7 @@ export async function renderProjectPicker(options: {
       if (!projects.data.length) {
         results.append(
           el("div", { class: "dim small", text: "No matching projects" }),
+          cancelRow(),
         );
         return;
       }
@@ -148,8 +166,12 @@ export async function renderProjectPicker(options: {
           ]),
         );
       }
+      results.append(cancelRow());
     } catch (e) {
-      clear(results).append(renderFailure(e, { onSignedIn: options.onChange }));
+      clear(results).append(
+        renderFailure(e, { onSignedIn: options.onChange }),
+        cancelRow(),
+      );
     }
   };
   let timer: ReturnType<typeof setTimeout> | undefined;
@@ -162,6 +184,22 @@ export async function renderProjectPicker(options: {
       void search();
     }
   });
+  input.addEventListener("keydown", (e) => {
+    if (e.key === "Escape") {
+      close();
+      input.blur();
+    }
+  });
+  // Clicking anywhere outside the picker closes it too
+  container.addEventListener("focusout", (e) => {
+    const next = e.relatedTarget;
+    if (
+      results.style.display !== "none" &&
+      !(next instanceof Node && container.contains(next))
+    ) {
+      close();
+    }
+  });
   return container;
 }
 

{calkit_python-0.49.3 → calkit_python-0.49.4}/calkit/cli/__init__.py

@@ -19,6 +19,16 @@ def run() -> None:
     # otherwise print the *current* CLI's help instead of re-execing
     # under the requested version.
     _maybe_exec_with_version()
+    if sys.platform == "win32":
+        import io
+
+        from calkit.core import is_mintty
+
+        # mintty shows UTF-8, so emoji needn't be replaced, and output is
+        # line buffered as it would be to a terminal
+        for stream in (sys.stdout, sys.stderr):
+            if isinstance(stream, io.TextIOWrapper) and is_mintty(stream):
+                stream.reconfigure(encoding="utf-8", line_buffering=True)
     from .main import app
 
     # Completion lists commands, so needs them all

{calkit_python-0.49.3 → calkit_python-0.49.4}/calkit/cli/core.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 import os
 import re
 import subprocess
+import sys
 from enum import Enum
 from typing import Any, NoReturn
 
@@ -152,8 +153,24 @@ def echo_json(obj: Any) -> None:
     typer.echo(json.dumps(obj, default=str))
 
 
+def _echo_above_spinner(text: str, err: bool) -> bool:
+    """Print through a spinner's stand-in for the stream, if there is one.
+
+    Click writes to a Windows console's handle directly, which would put the
+    text on the spinner's line rather than above it.
+    """
+    file_proxy = sys.modules.get("rich.file_proxy")
+    stream = sys.stderr if err else sys.stdout
+    if file_proxy is None or not isinstance(stream, file_proxy.FileProxy):
+        return False
+    print(text, file=stream, flush=True)
+    return True
+
+
 def raise_error(txt: str) -> NoReturn:
-    typer.echo(typer.style("Error: " + str(txt), fg="red"), err=True)
+    text = typer.style("Error: " + str(txt), fg="red")
+    if not _echo_above_spinner(text, err=True):
+        typer.echo(text, err=True)
     raise typer.Exit(1)
 
 
@@ -164,7 +181,6 @@ def warn(txt: str, prefix: str = "Warning: ", err: bool = False):
     # defined.
     from calkit.core import encode_safe
 
-    typer.echo(
-        typer.style(prefix + encode_safe(str(txt), err=err), fg="yellow"),
-        err=err,
-    )
+    text = typer.style(prefix + encode_safe(str(txt), err=err), fg="yellow")
+    if not _echo_above_spinner(text, err=err):
+        typer.echo(text, err=err)