from_thread.run() isn't cancelled on asyncio when the host scope was cancelled before the call (Trio raises Cancelled)

[sungbin1015]

I have a sync Starlette endpoint that does some blocking work and then reads the body with anyio.from_thread.run(request.body), so I was checking what happens if the request's scope gets cancelled while the thread is still busy. On asyncio, if the host scope is cancelled while the worker thread is in blocking code, a later from_thread.run() from that thread isn't cancelled at all. check_cancelled() in the same thread does raise, and on Trio the same from_thread.run() raises Cancelled right away. If the thread is already inside from_thread.run() when the deadline hits, asyncio cancels it fine, so it's only the "cancelled before the call" case.

import sys
import time

import anyio
from anyio import from_thread, to_thread


def worker():
    time.sleep(0.3)  # the deadline below expires while we're in blocking code
    try:
        from_thread.check_cancelled()
    except BaseException as exc:
        print("check_cancelled():", type(exc).__name__)

    start = time.monotonic()
    try:
        from_thread.run(anyio.sleep, 2)
        print(f"from_thread.run(): returned after {time.monotonic() - start:.1f}s")
    except BaseException as exc:
        print(f"from_thread.run(): {type(exc).__name__} after {time.monotonic() - start:.1f}s")


async def main():
    with anyio.move_on_after(0.1):
        await to_thread.run_sync(worker)


anyio.run(main, backend=sys.argv[1])

$ python repro.py asyncio
check_cancelled(): CancelledError
from_thread.run(): returned after 2.0s
$ python repro.py trio
check_cancelled(): Cancelled
from_thread.run(): Cancelled after 0.0s

With anyio.sleep_forever instead of sleep(2) the asyncio run never finishes. Same result on 4.15.1 and current master, Python 3.12 and 3.13, trio 0.34.0.

From a quick look, the scope has already stopped delivering by then (_cancel_handle is None, since the only task in it is parked in to_thread's shield), and the task from_thread.run() creates gets added to scope._tasks without anything restarting delivery. tg.start_soon() called from a shielded scope inside an already-cancelled task group does the same thing on asyncio.

Is from_thread.run() supposed to raise here like it does on Trio, or should I treat check_cancelled() as the only reliable signal once the host may have been cancelled?