* fix(quality): preserve cursor iteration and option validation
Keep prefetched rows on ManagedCursor so partial loops and explicit fetches share one position, and stop existing iterators after close or retirement. Preserve chunked reads and native SQLite result lifetime on reexecution and errors.
Catch OptionError before ValueError so legacy auto-tag requests receive the actual validation error. Remove the overwritten ViewerJS title option.
Regression tests failed before the fixes for lost rows, reads after close/retirement, and misleading option errors. Focused Python checks pass; cursor checks also pass on Python 3.13 and 3.14. Refs #321.
* fix(quality): make the test doubles legal raises and hashes
The fake queue no longer raises an attribute that starts as None. The
oversized kind records hashes instead of raising from __hash__, which
also catches a hash that production code swallows. Hostile.__bool__
raises the TypeError a truth test may raise.
* fix(quality): drop the extra saveCoverage argument
* refactor(quality): remove assignments that are overwritten before use
* refactor(quality): remove the remaining overwritten test assignments
* refactor(quality): drop imports repeated inside functions
* refactor(quality): give duplicate identity keys one shape
* refactor(quality): name the unused job event loop variable
* refactor(quality): release model gates in finally, not except BaseException
* refactor(quality): end the job runners with an explicit return
* refactor(quality): use the precise unittest asserts
* refactor(quality): import unittest.mock one way in the tests
* fix(quality): say why each empty except is safe, log the broad ones
* refactor(quality): stop binding values the tests never read
* refactor(quality): remove the unused preview aliases and tag page query
* refactor(quality): remove re-exports nothing imports
* refactor(quality): parenthesize deliberate string joins in lists
* refactor(quality): remove unused JavaScript variables and imports
* refactor(quality): use the precise assert in the model status test
* test(database): require identical WAL/NORMAL settings on managed connections (#242)
Concurrent writers failed with 'database is locked' on Windows runners
despite the 30 s busy timeout: every WAL commit flushed to disk while it
held the write lock, so polling waiters starved. These tests pin the
shared per-connection settings, including synchronous=NORMAL in WAL mode.
* fix(database): stop WAL commits from holding the write lock across a flush (#242)
Every managed connection now goes through configure_connection: WAL,
foreign keys, the 30 s busy timeout and, when WAL is active,
synchronous=NORMAL. Under FULL each commit flushed to disk while it held
SQLite's only write lock; on slow Windows disks a burst of writers (a
scan beside ComfyUI saves, or the concurrency tests) starved a polling
waiter past the busy timeout and it failed with 'database is locked'.
With a 60 ms emulated flush on Linux, 8 threads x 50 save+use calls went
from 49.6 s with a 32.1 s worst call (and 'database is locked' in the
unit test) to 0.7 s with a 0.4 s worst call. NORMAL in WAL mode keeps the
database consistent after an application crash; only an OS crash or
power loss can drop the most recent commits. In-memory or non-WAL
databases keep SQLite's FULL default.
* test(history): hold the first concurrent writer open past the bounded wait (#242)
The concurrent replay tests expected every peer to succeed, but each peer
only waits 250 ms for BEGIN IMMEDIATE by design. On a slow Windows runner
three queued commits exceeded that and a peer raised 'database is
locked'. Holding the first writer's transaction open for 500 ms makes the
same failure deterministic on any host (20/20 locally).
* test(history): let concurrent replay peers queue like ordinary writers (#242)
History writes deliberately give up after a bounded 250 ms wait so they
never stall ComfyUI; the existing bounded-timeout test still proves that.
The concurrent replay tests assert that every peer succeeds, which is a
serialization and first-capture property, so they now raise the budget
to the shared 30 s busy timeout while the first writer is held open.
The budget is one named constant, EXECUTION_BUSY_TIMEOUT_MS, shared by
the transaction helper and the background writer.
Before: 20/20 'database is locked' with the held writer. After: 0/20.
* test(history): wait on restore handoff events, not a 5 s clock (#242)
The retired-owner projection tests park a history read at a barrier
while the test performs a full multipart restore, then release it. The
barrier gave up after 5 s and raised inside the route handler, so on a
slow Windows runner (a 694 s suite run) aiohttp answered with its
text/plain 500 and the test reported 'history route missing'.
Every wait already ends on an event; the ceiling now only stops a broken
test from hanging (60 s). With restore slowed by 5.5 s locally, all 8
subtests failed with text/plain before and pass after.
* docs(testing): add the concurrent SQLite test rule to the Windows preflight (#242)
Vito