bindery-cli 0.41.0__tar.gz → 0.42.0__tar.gz

{bindery_cli-0.41.0 → bindery_cli-0.42.0}/.github/workflows/publish.yml

@@ -73,8 +73,13 @@ jobs:
 
       # The tag message IS the release's patchnotes entry (verbatim, per the
       # tagging procedure), so the release body is extracted from the tag
-      # object rather than paraphrased here. Without it the release page
-      # renders blank beside the zip.
+      # object rather than paraphrased here. The checkout is depth-1 and
+      # leaves a LIGHTWEIGHT local tag on the commit (whose %(contents) is
+      # the commit message, not the release entry), so the real annotated
+      # tag object is force-fetched from the origin before reading it.
+      - name: Fetch the tag object
+        run: git fetch --no-tags --force origin "refs/tags/${GITHUB_REF_NAME}:refs/tags/${GITHUB_REF_NAME}"
+
       - name: Extract the release body from the tag message
         run: git tag -l --format='%(contents)' "${GITHUB_REF_NAME}" > release-body.md
 

{bindery_cli-0.41.0 → bindery_cli-0.42.0}/CLAUDE.md

@@ -82,7 +82,7 @@ Born from the 2026 library audit (see the user memory `calibre-library-epubcheck
 
 ## Layout
 
-- `src/bindery/transforms.py`: pure `str -> (str, int)` text transforms (including `strip_broken_tags`). Since v0.32.0: `strip_attrs_in_start_tags` anchors attribute edits on the quote-aware start-tag matcher, `_outside_protected` forwards arguments (context-carrying transforms can be decorated), `fix_id_colons` matches only the bare `id` attribute and only internal fragments (`fix_ncx_src_fragments` carries renames into the NCX), `fix_ncx_playorder` is anchored to `<navPoint>` start tags, and the css selector boundary covers namespaced and functional selector forms. Since v0.37.0: `fix_ncx_playorder` strips quotes before its already-correct comparison (regex groups carry quote characters; comparing quoted values against bare numbers counted phantom fixes on every sequential NCX and rewrote single-quoted correct attributes to double quotes).
+- `src/bindery/transforms.py`: pure `str -> (str, int)` text transforms (including `strip_broken_tags`). Since v0.32.0: `strip_attrs_in_start_tags` anchors attribute edits on the quote-aware start-tag matcher, `_outside_protected` forwards arguments (context-carrying transforms can be decorated), `fix_id_colons` matches only the bare `id` attribute and only internal fragments (`fix_ncx_src_fragments` carries renames into the NCX), `fix_ncx_playorder` is anchored to `<navPoint>` start tags, and the css selector boundary covers namespaced and functional selector forms. HAZARD (the 0.41.0 spin): the quote-aware tag-prefix alternation (double-quoted | single-quoted | [^>]) OVERLAPS ([^>] matches quotes too), so a plain `*` re-partitions exponentially on failing candidates; every such greedy loop must carry the possessive `*+` (re 3.11+, the plugin's minimum Calibre). Since v0.42.0 the census is complete and pinned by tests/test_matcher_hardening.py: every greedy loop of this family is possessive (the three 0.41.1 rewrites plus _START_TAG_RE, _COVER_META_RE, _GUIDE_REF_RE, prune_dangling_edges' spine|item|itemref matcher, _ITEM_TAG_RE, _SPINE_ITEM_RE -- possessive is byte-identical on success because the loop is always followed by a literal `>` the [^>] branch cannot consume), and the five LAZY siblings (_VOID_RE, the transforms <img> matcher, and epub's link/a/img matchers) use the disjoint catch-all `[^>"']` instead: mutually exclusive branches cannot re-partition, and an unterminated quote inside a tag now fails to match rather than pairing across markup. NEW tag matchers: quote-aware possessive for greedy loops, the disjoint catch-all for lazy ones, and the tempered-quote idiom (["'])((?:(?!\1).)*)\1 for attribute values. Since v0.37.0: `fix_ncx_playorder` strips quotes before its already-correct comparison (regex groups carry quote characters; comparing quoted values against bare numbers counted phantom fixes on every sequential NCX and rewrote single-quoted correct attributes to double quotes).
 - `src/bindery/pagination.py`: the opt-in lossy page-number strip (runhead detection, page-layer decision, block-centric removal/merge, safety nets).
 - `src/bindery/watermark.py`: the opt-in lossy watermark strip (anchored and anchorless signature removal).
 - `src/bindery/reserialize.py`: structural repair via `html5lib`.

{bindery_cli-0.41.0 → bindery_cli-0.42.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: bindery-cli
-Version: 0.41.0
+Version: 0.42.0
 Summary: Audit EPUB body text and repair broken EPUBs with deterministic, epubcheck-gated fixes; atomic in-place replacement in a Calibre library.
 Project-URL: Homepage, https://github.com/VirInvictus/bindery-cli
 Project-URL: Repository, https://github.com/VirInvictus/bindery-cli

{bindery_cli-0.41.0 → bindery_cli-0.42.0}/patchnotes.md

@@ -1,4 +1,49 @@
 # bindery-cli Patch Notes
+## v0.42.0 (2026-09-16)
+
+### The matcher audit executed: every quote-aware tag matcher hardened
+The follow-up box the 0.41.1 hotfix opened is closed with a full per-matcher census, and the audit found the box's own enumeration incomplete. Six GREEDY patterns of the exponential overlap class were unhardened -- `_START_TAG_RE` (the quote-aware start-tag matcher anchoring `--strip-epub3-attrs` and `--strip-bad-attrs`, running under `repair --all` on every content doc; not even named in the box), `_COVER_META_RE`, `_GUIDE_REF_RE`, `prune_dangling_edges`' spine|item|itemref matcher, `_ITEM_TAG_RE`, and `_SPINE_ITEM_RE`. All six are possessive-bounded now: byte-identical on every successful match (the loop is always followed by a literal `>` that the `[^>]` branch cannot consume, so backtracking only ever happened on failure) and linear on failure. Five LAZY patterns of the quadratic class (`_VOID_RE`, the transforms `<img>` matcher, and epub's link/anchor/img matchers) took the disjoint catch-all `[^>"']` instead of a blind possessive swap: mutually exclusive branches cannot re-partition, so any quantifier is linear, and an unterminated quote inside a tag now fails to match instead of pairing with a distant quote and matching across markup. Every well-formed shape is byte-identical. The epub `_IMG_TAG_RE` is renamed `_PRUNE_IMG_TAG_RE` (it collided with the transforms matcher of the same name). Everything else in the package audited safe by construction: tempered-quote value matchers, two-branch quote alternations, `[^>]*` single-class prefixes (linear, not quote-aware -- accepted, documented), lazy paired-delimiter spans, and the analyzer tokenizers.
+
+Pinned by `tests/test_matcher_hardening.py` (15 tests): alarm-guarded spin shapes per greedy site (OPF flavor, the truncated-OPF prune shape), unterminated-quote skips, and well-formed byte-identity. `CLAUDE.md`'s hazard note now carries the census and the rule for new matchers. The full suite is 491 tests.
+
+## v0.41.1 (2026-09-15)
+
+### The 0.41.0 CPU-spin regression: possessive bounds on the quote-aware tag matchers
+
+- **The regression.** `repair --all` spun CPU indefinitely on real
+  books (found on a Hackett Aristotle *Physics* whose 843k-character
+  back-matter document is full of apostrophes and span candidates
+  whose closer never comes). 0.40.0 repaired the same book in seconds.
+  Brandon bisected it to 0.41.0 and root-caused it to the wheel diff:
+  the 0.41.0 quote-aware rewrite of `unwrap_block_in_inline`'s start
+  tag replaced the linear prefix with an overlapping alternation
+  (double-quoted | single-quoted | any-non-bracket), and because the
+  non-bracket branch also matches quote characters, every failing
+  candidate let the engine re-partition the prefix across the branches
+  exponentially. The flag-bisect had looked interaction-shaped because
+  earlier transforms move where the failing candidates sit; the regex
+  was input-sensitive, not the flags broken.
+- **The fix: possessive quantifiers.** The repeated group is now
+  possessive (`*+`, Python 3.11's `re`, the same floor as the plugin's
+  minimum Calibre): the engine commits to its first-alternative
+  consumption, which is the nearest-paired-quote path ending at the
+  first unquoted `>` (the correct tag end), and never re-partitions.
+  Failure becomes linear; successful matches are unchanged. Applied to
+  all three patterns the 0.41.0 commit rewrote:
+  `unwrap_block_in_inline` (the spinner), `unwrap_illegal_tags`, and
+  `downgrade_epub3_tags`. The pre-existing quote-aware matchers
+  (`_VOID_RE`, the OPF tag matchers) were tested against the same
+  shape and do not spin; their audit is a recorded follow-up box.
+- **Verified on the fixture.** The transform went from still-spinning
+  at 15 seconds to 0.01 seconds; the recorded reproduction
+  (`repair --all --force`) completes in 7.7 seconds (epubcheck's own
+  time) with output identical to the 0.40.0 shape
+  (cover_meta_repointed:1, pagelist_class_added:1, ncx_uid_synced).
+  Two regression tests pin it: the spin shape itself (a span followed
+  by a 40k-character apostrophe run with no `>`: the old pattern
+  provably cannot finish it) and the quote-aware function the rewrite
+  was for (a `>` inside an attribute value).
+
 ## v0.41.0 (2026-09-15)
 
 ### The final-audit blitz: robust analyzers, the stub-docs strip, and a privacy untrack

bindery_cli-0.42.0/project.done

@@ -0,0 +1,64 @@
+# bindery-cli: project.done
+
+Completed: 2026-09-15 (THE FINAL BLITZ, repo agent lane)
+Range: 2b9f24e (analyzer trio) through f47fc8f (ci tag-fetch fix), on main,
+pushed; CI green throughout; v0.41.0 tagged and published to PyPI.
+
+POSTSCRIPT 2026-09-15 (same day, Brandon's regression report): v0.41.1
+hotfixed the one real defect the blitz shipped, the catastrophic-backtracking
+CPU spin in `repair --all`'s rewritten quote-aware span matcher (the Physics
+fixture; Brandon bisected and root-caused it). Fix: possessive quantifiers
+on all three rewritten tag-prefix patterns; verified on his fixture against
+the 0.40.0 output shape; the follow-up matcher-audit box is in the roadmap.
+
+## What shipped
+
+- The analyzer-robustness trio: spineless-EPUB verdicts, per-book try
+  coverage, the corrupt-container CORRUPT verdict, the DRM false-EMPTY fix.
+- The phase3 aggregate-summary fix (applied/equal states only,
+  rejected_projection line, Ghost Brigades regression test).
+- Six features: `bindery doctor`, `repair --json FILE`, `--strip-stub-docs`
+  (the lossy lane's live fixture, Brandon-approved), plugin log rotation,
+  `--backup-keep N` ring, the fast_sweep count-scale pin.
+- The robustness LOW batch (quote-aware matchers, raw-name resolution,
+  atomic backups, rglob filter, mojibake-uid guard, daemon tempdir sweep,
+  apply-failure accounting, relative_to guard).
+- The privacy untrack of testing_facility/top500candidates/REPORT.md
+  (forward-only; Brandon's ruling).
+- The GitHub batch: release bodies via body_path + three backfills, the
+  description rewrite, [project.urls], topics swap, wiki off, the
+  redundant suite run removed, concurrency blocks, checkout alignment,
+  the release action SHA-pinned; plus a v*.*.* tag ruleset (admin bypass)
+  and the pypi environment restricted to tag pushes (Brandon's rulings).
+- Docs truth batches: one canonical repair inventory in spec.md, the audit
+  exit-code contract, the epubcheck install paragraph, the flag-list move,
+  the mimetype-fix counts, the degrades-safely correction, the
+  comment/docstring truth pass, the em-dash sweep and the "honest" tic.
+- Dead code removed on a recorded go: validate's `_daemon` alias, cli's
+  `done_count`, audit's `sys.path.insert`.
+- Hygiene: REPORT-12-Sept.md retired per the BINDERY_REPORT precedent; the
+  derived litter deleted (test_facility/__pycache__, FastSweepExtract.class,
+  venv/ + .venv_ci/).
+- Tests: 445 -> 474, all green; ruff 0.16.2 clean.
+
+## Reopen conditions (recorded future work)
+
+1. top500candidates/REPORT.md history strip: declined (forward-only only).
+   If ever wanted: filter-repo the file out, re-tag every affected release
+   verbatim, disable publish.yml around the push (force-push class).
+2. Stranger-facing XML hardening (dependency ask pending): a stdlib
+   per-entry size cap in load_book plus defusedxml-style entity-expansion
+   gating. Trigger: a real 3.12/3.13 stranger audience. Roadmap boxed.
+3. MobileRead listing for the Bindery Repair plugin: Brandon's manual
+   posting step; roadmap boxed with the material listed.
+4. README screenshot regeneration against a synthetic library: pending
+   Brandon's call; the current PNG still shows real library rows.
+5. Boxed M feature set: --encode-url-spaces entry renames (280-book
+   PKG-010 class), the cover advisory analyzer, the audit-refresh
+   deep-dive, the NCX<->nav drift detector.
+6. Boxed internal refactors: RepairFlags dataclass for the triplicated
+   kwarg signature; shared roman/arabic number helpers for pagination.py
+   and audit.py.
+7. Cross-repo note under decision #117: cquarry, CalibreQuarry, and
+   vir-tui should mirror the tag ruleset + pypi environment policy this
+   repo adopted.

{bindery_cli-0.41.0 → bindery_cli-0.42.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "bindery-cli"
-version = "0.41.0"
+version = "0.42.0"
 description = "Audit EPUB body text and repair broken EPUBs with deterministic, epubcheck-gated fixes; atomic in-place replacement in a Calibre library."
 readme = "README.md"
 classifiers = [

{bindery_cli-0.41.0 → bindery_cli-0.42.0}/roadmap.md

@@ -1642,7 +1642,7 @@ four interpreter families.
       (the oldest series whose embedded interpreter CI covers; the hollow
       (2, 0, 0) is gone) and the README plugin section documents platforms
       (Linux-tested) and the verification story.
-- [ ] **Analyzer robustness on untrusted input:** spine_integrity
+- [x] **Analyzer robustness on untrusted input:** *(SHIPPED in v0.41.0 -- the analyzer-robustness trio; verified 2026-09-16 by the post-blitz audit run: per-book verdicts over truncated/renamed-zip/zero-byte fixtures with no run abort.)* ** spine_integrity
       IndexErrors on a spineless EPUB (nums[0] with an empty list) and
       the call sites sit OUTSIDE the per-book try - one malformed book
       aborts a whole run; load_book raises NameError (encrypted_names
@@ -1671,7 +1671,7 @@ four interpreter families.
       --encode-url-spaces entry renames (the reference-rewrite half
       shipped v0.28.0; the remainder is renaming archive entries whose
       filenames carry raw spaces; PKG-010, 280 books); plugin log rotation.
-- [ ] **GitHub presentation (workspace batch):** description rewrite
+- [x] **GitHub presentation (workspace batch):** *(EXECUTED and verified at the ticked box below (line ~1745) during the blitz; ticked 2026-09-16 to stop it reading as open work.)* ** description rewrite
       (leads with deterministic epubcheck-gated repair); 7 topics swapped
       (add epub3/calibre-plugin/python-cli/ebook-audit); codex page still
       says calibredb; wiki off.
@@ -1690,7 +1690,7 @@ four interpreter families.
       real 3.12/3.13 (258 tests per leg, verified locally under
       3.12.14/3.13.15). Suite 445, ruff 0.16.2 clean.
 
-- [ ] **Candidate (lossy lane): strip duplicate stub spine docs.** Opened
+- [x] **Candidate (lossy lane): strip duplicate stub spine docs.** *(SHIPPED as --strip-stub-docs (the ticked box at ~1796); verified 2026-09-16: the no_worse gate correctly refuses a fabricated regression-stub.)* ** Opened
       2026-09-13 from the phase-1 Redwall-fleet successor run: The River
       Has Roots (bookmate platform conversion) carries 14 of 37 spine
       docs that are identical stubs (the same short boilerplate body
@@ -1708,7 +1708,7 @@ four interpreter families.
       (kept in ~/Downloads pending Brandon's import-or-re-source call);
       the 2026-09-13 phase-1 JSON has the analyzer verdicts.
 
-- [ ] **`run phase3`'s aggregate before/after summary mixes a rejected
+- [x] **`run phase3`'s aggregate before/after summary mixes a rejected
       candidate's projected after-state into the totals** (observed
       2026-09-13, OMW batch): Ghost Brigades measured 0f/47e -> 1f/24e
       REGRESSION and was correctly rejected, untouched; the only applied
@@ -1849,3 +1849,51 @@ four interpreter families.
       stdlib-only rule and adds a vendored plugin dep): trigger is a
       real 3.12/3.13 stranger audience, not a hypothetical.
 - [x] **vir-tui floor >=2.5.0 + lock refresh** (2026-09-14, no release cut: upstream 2.4.0/2.5.0 are additive terminal-safety and session-awareness releases; only the vir-tui resolution moved in the lock, the cquarry lag rule is untouched). *(Mention the floor bump in the next release's patchnotes.)*
+
+- [x] **REGRESSION (0.41.0) FIXED in v0.41.1: the repair --all CPU
+      spin on the Physics fixture was catastrophic backtracking in the
+      rewritten `unwrap_block_in_inline` regex** (SHIPPED 2026-09-15,
+      176906f): the quote-aware alternation's branches overlap ([^>]
+      also matches quotes), so failing candidates re-partitioned the
+      prefix exponentially. All three patterns the 0.41.0 commit
+      rewrote (`unwrap_block_in_inline`, `unwrap_illegal_tags`,
+      `downgrade_epub3_tags`) are now possessive-bounded (`*+`, re
+      3.11+ = the plugin's minimum Calibre floor): the committed
+      first-alternative path is the correct tag end, failure is
+      linear, successful matches are unchanged. Verified on Brandon's
+      fixture: the transform went from still-spinning at 15s to
+      0.01s; the recorded repro (`repair --all --force`) completes in
+      7.7s with output identical to the 0.40.0 shape. Regression
+      tests: the spin shape (the old pattern provably cannot finish
+      it) and the quote-aware function. Root-cause note preserved from
+      the report: the flag-bisect looked interaction-shaped because
+      earlier transforms move where failing candidates sit; the regex
+      was input-sensitive, not the flags broken. Unpin 0.40.0 once
+      0.41.1 is installed.
+- [x] **Audit the remaining quote-aware tag matchers for the same
+      overlap ambiguity** *(EXECUTED 2026-09-16, v0.42.0 -- the full
+      per-matcher census, one ruling each: the audit found the box's own
+      enumeration incomplete. Six GREEDY exponential-class sites were
+      unhardened, possessive-bounded now (success is byte-identical:
+      the loop is always followed by a literal `>` that `[^>]` cannot
+      consume): transforms.py `_START_TAG_RE` -- the true gap, not even
+      named in the box, running under repair --all on every content doc;
+      `_COVER_META_RE`; `_GUIDE_REF_RE`; prune_dangling_edges'
+      spine|item|itemref matcher; `_ITEM_TAG_RE`; `_SPINE_ITEM_RE`.
+      Five LAZY quadratic-class sites took the disjoint catch-all
+      `[^>"']` instead of a blind possessive swap (a lazy `*?` ->
+      `*+` is NOT byte-identical with the trailing `\s*(/?)>`
+      continuation, which peels whitespace and the self-close slash):
+      `_VOID_RE`, the transforms `<img>` matcher, and epub's
+      link/a/img matchers -- mutually exclusive branches make any
+      quantifier linear and fix the far-match wart: an unterminated
+      quote inside a tag now fails to match instead of pairing across
+      markup. The epub `_IMG_TAG_RE` renamed `_PRUNE_IMG_TAG_RE` (name
+      collision with the transforms one). Everything else audited safe
+      by construction: tempered-quote value matchers, two-branch
+      quote alternations, `[^>]*` single-class prefixes (linear,
+      not quote-aware -- accepted), lazy paired-delimiter spans, and
+      the analyzer tokenizers. Pinned by tests/test_matcher_hardening.py:
+      15 tests (spin shapes alarm-guarded per greedy site, unterminated-
+      quote skips, well-formed byte-identity, prune spin over the
+      truncated-OPF shape). Never a third grammar copy.)*

{bindery_cli-0.41.0 → bindery_cli-0.42.0}/src/bindery/__init__.py

@@ -11,7 +11,7 @@ Calibre plugin built from this core.
 Single source of truth for the version. pyproject.toml must match VERSION below.
 """
 
-VERSION = "0.41.0"
+VERSION = "0.42.0"
 __version__ = VERSION
 
 from .epub import RepairReport, repair_epub  # noqa: E402

{bindery_cli-0.41.0 → bindery_cli-0.42.0}/src/bindery/epub.py

@@ -316,14 +316,14 @@ _EDGE_ATTR_RES = (
     re.compile(r"""\s+fallback\s*=\s*(?:"[^"]*"|'[^']*')""", re.IGNORECASE),
 )
 _COVER_META_RE = re.compile(
-    r"""<meta\b(?=(?:[^>]*\bname=)["']cover["'])(?:(?:"[^"]*"|'[^']*'|[^>])*)>""",
+    r"""<meta\b(?=(?:[^>]*\bname=)["']cover["'])(?:(?:"[^"]*"|'[^']*'|[^>])*+)>""",
     re.IGNORECASE,
 )
 _COVER_CONTENT_RE = re.compile(
     r"""\s+content\s*=\s*(["'])((?:(?!\1).)+)\1""", re.IGNORECASE
 )
 _GUIDE_REF_RE = re.compile(
-    r"""<reference\b(?:(?:"[^"]*"|'[^']*'|[^>])*)>""", re.IGNORECASE
+    r"""<reference\b(?:(?:"[^"]*"|'[^']*'|[^>])*+)>""", re.IGNORECASE
 )
 
 
@@ -421,7 +421,7 @@ def prune_dangling_edges(opf_text: str, pruned_ids: set[str]) -> tuple[str, int]
         return tag
 
     out = re.sub(
-        r"""<(?:spine|item|itemref)\b(?:(?:"[^"]*"|'[^']*'|[^>])*)>""",
+        r"""<(?:spine|item|itemref)\b(?:(?:"[^"]*"|'[^']*'|[^>])*+)>""",
         strip_attrs,
         opf_text,
         flags=re.IGNORECASE,
@@ -588,9 +588,12 @@ def downgrade_epub3_tags(
             return f"</{new}>"
 
         # quote-aware attrs group (same shape as the manifest matchers): a
-        # `>` inside an attribute value must not end the tag early
+        # `>` inside an attribute value must not end the tag early. The
+        # branches overlap ([^>] also matches quotes), so the possessive
+        # `*+` bounds the re-partitioning that spun CPU on failing
+        # candidates in 0.41.0 (see transforms.unwrap_block_in_inline).
         text = re.sub(
-            rf"""<{tag}\b((?:"[^"]*"|'[^']*'|[^>])*)>""",
+            rf"""<{tag}\b((?:"[^"]*"|'[^']*'|[^>])*+)>""",
             repl_open,
             text,
             flags=re.IGNORECASE,
@@ -656,21 +659,21 @@ _DROP_HREF_ATTR_RE = re.compile(r"""\s+href\s*=\s*(?:"[^"]*"|'[^']*')""", re.IGN
 # shape as transforms._VOID_RE, so a '>' inside an attribute value cannot end
 # the tag early.
 _LINK_TAG_RE = re.compile(
-    r"""<link(?=[\s/>])((?:"[^"]*"|'[^']*'|[^>])*?)\s*(/?)>""",
+    r"""<link(?=[\s/>])((?:"[^"]*"|'[^']*'|[^>"'])*?)\s*(/?)>""",
     re.IGNORECASE | re.DOTALL,
 )
 _ANCHOR_TAG_RE = re.compile(
-    r"""<a(?=[\s/>])((?:"[^"]*"|'[^']*'|[^>])*?)\s*(/?)>""", re.IGNORECASE | re.DOTALL
+    r"""<a(?=[\s/>])((?:"[^"]*"|'[^']*'|[^>"'])*?)\s*(/?)>""", re.IGNORECASE | re.DOTALL
 )
-_IMG_TAG_RE = re.compile(
-    r"""<img(?=[\s/>])((?:"[^"]*"|'[^']*'|[^>])*?)\s*(/?)>""",
+_PRUNE_IMG_TAG_RE = re.compile(
+    r"""<img(?=[\s/>])((?:"[^"]*"|'[^']*'|[^>"'])*?)\s*(/?)>""",
     re.IGNORECASE | re.DOTALL,
 )
-_ITEM_TAG_RE = re.compile(r"""<item\b(?:(?:"[^"]*"|'[^']*'|[^>])*)>""", re.IGNORECASE)
+_ITEM_TAG_RE = re.compile(r"""<item\b(?:(?:"[^"]*"|'[^']*'|[^>])*+)>""", re.IGNORECASE)
 # `<itemref` must not be swallowed by the `<item\b` matcher above (\b has no
 # boundary before the 'r'), and its own idref carries the spine order.
 _SPINE_ITEM_RE = re.compile(
-    r"""<itemref\b(?:(?:"[^"]*"|'[^']*'|[^>])*)>""", re.IGNORECASE
+    r"""<itemref\b(?:(?:"[^"]*"|'[^']*'|[^>])*+)>""", re.IGNORECASE
 )
 # `\b` is what keeps `<item\b` from matching `<itemref`: "itemref" has a word
 # character right after "item", so there is no boundary there.
@@ -996,7 +999,7 @@ def prune_missing_images(
             counts[key] = counts.get(key, 0) + 1
             return alt if key == "missing_imgs_unwrapped" else ""
 
-        return _IMG_TAG_RE.sub(repl, part), counts
+        return _PRUNE_IMG_TAG_RE.sub(repl, part), counts
 
     total: dict[str, int] = {}
     if "<!" in text:

{bindery_cli-0.41.0 → bindery_cli-0.42.0}/src/bindery/transforms.py

@@ -32,14 +32,14 @@ XML_PREDEFINED = {"amp", "lt", "gt", "quot", "apos"}
 # quote-aware so a `>` inside an attribute value does not end the tag early. Group 3
 # captures an existing trailing slash so already-self-closed tags are left untouched.
 _VOID_RE = re.compile(
-    rf"""<({VOID})(?=[\s/>])((?:"[^"]*"|'[^']*'|[^>])*?)\s*(/?)>""",
+    rf"""<({VOID})(?=[\s/>])((?:"[^"]*"|'[^']*'|[^>"'])*?)\s*(/?)>""",
     re.IGNORECASE | re.DOTALL,
 )
 _VOID_END_RE = re.compile(rf"""</(?:{VOID})\s*>""", re.IGNORECASE)
 _NAMED_ENTITY_RE = re.compile(r"&([a-zA-Z][a-zA-Z0-9]*);")
 _BARE_AMP_RE = re.compile(r"&(?![a-zA-Z][a-zA-Z0-9]*;|#[0-9]+;|#[xX][0-9a-fA-F]+;)")
 # A start tag (quote-aware) and an attribute within it, for invalid-attribute stripping.
-_START_TAG_RE = re.compile(r"""<[a-zA-Z][\w:.-]*(?:"[^"]*"|'[^']*'|[^>])*>""")
+_START_TAG_RE = re.compile(r"""<[a-zA-Z][\w:.-]*(?:"[^"]*"|'[^']*'|[^>])*+>""")
 # The unquoted-value branch stops at whitespace or the end of the tag, and the `/?>`
 # lookahead is what keeps it off the tag's own self-closing slash: a plain `[^\s>]+`
 # swallowed it, so dropping the attribute in `<img 31=x/>` left `<img>` and turned a
@@ -235,7 +235,7 @@ def escape_unknown_entities(s: str) -> tuple[str, int]:
 # An <img> start tag, quote-aware like _VOID_RE; group 1 is the attribute block and
 # group 2 an existing self-closing slash, so the tag is rebuilt without reordering.
 _IMG_TAG_RE = re.compile(
-    r"""<img(?=[\s/>])((?:"[^"]*"|'[^']*'|[^>])*?)\s*(/?)>""",
+    r"""<img(?=[\s/>])((?:"[^"]*"|'[^']*'|[^>"'])*?)\s*(/?)>""",
     re.IGNORECASE | re.DOTALL,
 )
 # Whitespace before `alt` keeps data-alt/xml:alt-style names from matching; a quoted
@@ -374,8 +374,19 @@ def unwrap_block_in_inline(s: str) -> tuple[str, int]:
         return m.group(1)
 
     s, n = re.subn(
-        r"""<span(?:(?:"[^"]*"|'[^']*'|[^>])*)>\s*"""
-        r"""(<(div|p|blockquote)(?:(?:"[^"]*"|'[^']*'|[^>])*)>.*?</\2>)\s*</span>""",
+        # The quote-aware branches OVERLAP ([^>] also matches quote
+        # characters), so a plain `*` lets the engine re-partition the start
+        # tag exponentially across them on every failing candidate: on a
+        # 843k-char doc full of <span>s whose closer never comes, 0.41.0
+        # spun CPU indefinitely (the Physics-fixture regression,
+        # roadmap 2026-09-15). The possessive `*+` commits to the
+        # first-alternative consumption (ending at the first unquoted `>`,
+        # which is the correct tag end) and never re-partitions: linear on
+        # failure, same matches on success. `re` has had possessive
+        # quantifiers since 3.11, the same floor as the plugin's minimum
+        # Calibre.
+        r"""<span(?:(?:"[^"]*"|'[^']*'|[^>])*+)>\s*"""
+        r"""(<(div|p|blockquote)(?:(?:"[^"]*"|'[^']*'|[^>])*+)>.*?</\2>)\s*</span>""",
         repl,
         s,
         flags=re.IGNORECASE | re.DOTALL,
@@ -503,9 +514,15 @@ def unwrap_illegal_tags(
             continue
         # quote-aware start-tag match (same shape as _VOID_RE): a `>` inside
         # an attribute value would otherwise end the match early and mangle
-        # the tag into a malformed edit the gate then rejects
+        # the tag into a malformed edit the gate then rejects. The branches
+        # overlap ([^>] also matches quotes), so the possessive `*+` bounds
+        # the re-partitioning that spun CPU on failing candidates in 0.41.0
+        # (see unwrap_block_in_inline).
         s, n1 = re.subn(
-            rf"""<{tag}\b(?:(?:"[^"]*"|'[^']*'|[^>])*)>""", "", s, flags=re.IGNORECASE
+            rf"""<{tag}\b(?:(?:"[^"]*"|'[^']*'|[^>])*+)>""",
+            "",
+            s,
+            flags=re.IGNORECASE,
         )
         s, n2 = re.subn(rf"</{tag}\s*>", "", s, flags=re.IGNORECASE)
         count += n1 + n2

bindery_cli-0.42.0/tests/test_matcher_hardening.py

@@ -0,0 +1,165 @@
+"""Regression net for the 2026-09-16 per-matcher hardening (the roadmap's
+matcher-audit follow-up box, executed).
+
+The 0.41.1 hotfix made three rewritten patterns possessive; the audit that
+followed found six more greedy patterns of the same exponential class
+(the quote-aware loop whose branches overlap) and five lazy patterns of
+the quadratic class. The greedy loops are now possessive `*+` (byte-
+identical on success: the loop is always followed by a literal `>` that
+the `[^>]` branch cannot consume, so backtracking only ever happened on
+failure). The lazy loops got a disjoint branch 3 (`[^>"']`: the catch-all
+no longer eats quote characters), which makes re-partitioning impossible
+and stops an unterminated quote inside a tag from pairing with a distant
+quote and matching across markup.
+
+A1 behavioral pins (success cases unchanged) and A2 pins (unterminated-
+quote tags are now skipped rather than mis-paired) live beside the spin
+guards here. The spin guard is the same shape as the 0.41.0 test: a
+failing candidate over an apostrophe-rich run must finish, not hang."""
+
+import signal
+import time
+import unittest
+
+from bindery import epub, transforms
+from bindery.transforms import _START_TAG_RE
+
+
+def _apostrophe_run(times: int = 2000) -> str:
+    return "don't can't won't it's kind of prose, isn't it " * times
+
+
+class GreedyStartTagSpin(unittest.TestCase):
+    """_START_TAG_RE runs under repair --all on every content doc: the same
+    input class as the Physics fixture (an apostrophe-rich run with no `>`
+    after the tag opener) must fail linearly."""
+
+    def test_spin_shape_fails_fast(self):
+        doc = "<p class='broken " + _apostrophe_run() + "and still no closer in sight"
+        signal.alarm(20)
+        try:
+            t0 = time.perf_counter()
+            m = _START_TAG_RE.search(doc)
+            elapsed = time.perf_counter() - t0
+        finally:
+            signal.alarm(0)
+        self.assertIsNone(m)
+        self.assertLess(elapsed, 5.0)
+
+    def test_success_shape_is_unchanged(self):
+        text = "<p class='x' data-y=\"a>b\">body</p>"
+        m = _START_TAG_RE.search(text)
+        self.assertEqual(m.group(0), "<p class='x' data-y=\"a>b\">")
+        # the `>` inside the quoted attribute stays attribute content
+        self.assertNotIn("body", m.group(0))
+
+
+class OpfTagMatchersSpin(unittest.TestCase):
+    """The OPF matchers iterate manifest/spine/guide tags: a truncated OPF
+    that ends inside an apostrophe-rich attribute run must fail linearly."""
+
+    SPIN_PREFIX = "<item id='id1' href='text/part1.xhtml' media-type='application/xhtml+xml' extra='"
+
+    def _assert_fast_no_match(self, regex, text):
+        signal.alarm(20)
+        try:
+            t0 = time.perf_counter()
+            m = regex.search(text)
+            elapsed = time.perf_counter() - t0
+        finally:
+            signal.alarm(0)
+        self.assertIsNone(m)
+        self.assertLess(elapsed, 5.0)
+
+    def test_item_tag_spin_shape(self):
+        self._assert_fast_no_match(
+            epub._ITEM_TAG_RE, self.SPIN_PREFIX + _apostrophe_run(500)
+        )
+
+    def test_itemref_tag_spin_shape(self):
+        text = "<itemref idref='id1' extra='" + _apostrophe_run(500)
+        self._assert_fast_no_match(epub._SPINE_ITEM_RE, text)
+
+    def test_cover_meta_spin_shape(self):
+        text = '<meta name="cover" content="' + _apostrophe_run(500)
+        self._assert_fast_no_match(epub._COVER_META_RE, text)
+
+    def test_guide_reference_spin_shape(self):
+        text = "<reference type='text' title='" + _apostrophe_run(500)
+        self._assert_fast_no_match(epub._GUIDE_REF_RE, text)
+
+    def test_success_shapes_unchanged(self):
+        opf = (
+            '<package><item id="id1" href="a.xhtml" media-type="application/xhtml+xml"/>'
+            "<itemref idref='id1'/>"
+            '<meta name="cover" content="cover-image"/>'
+            "<reference type='text' title='t' href='a.xhtml'/></package>"
+        )
+        item = epub._ITEM_TAG_RE.search(opf)
+        self.assertEqual(
+            item.group(0),
+            '<item id="id1" href="a.xhtml" media-type="application/xhtml+xml"/>',
+        )
+        self.assertIsNotNone(epub._SPINE_ITEM_RE.search(opf))
+        self.assertIsNotNone(epub._COVER_META_RE.search(opf))
+        self.assertIsNotNone(epub._GUIDE_REF_RE.search(opf))
+
+    def test_prune_dangling_edges_spin_shape(self):
+        # prune_dangling_edges' inline spine|item|itemref matcher over a
+        # truncated OPF: linear failure, no hang.
+        opf = '<package><spine toc="ncx"><itemref idref=\'broken ' + _apostrophe_run(
+            500
+        )
+        signal.alarm(20)
+        try:
+            t0 = time.perf_counter()
+            epub.prune_dangling_edges(opf, {"gone"})
+            elapsed = time.perf_counter() - t0
+        finally:
+            signal.alarm(0)
+        self.assertLess(elapsed, 5.0)
+
+
+class LazyMatcherDisjointBranch(unittest.TestCase):
+    """The lazy matchers (_VOID_RE, the img/link/a tag matchers) now use a
+    disjoint branch 3 ([^>"']): an unterminated quote inside a tag can no
+    longer pair with a distant quote, so the mis-pairing match is gone.
+    Every well-formed shape is byte-identical."""
+
+    def test_void_unterminated_quote_skipped(self):
+        # OLD: this matched, pairing the quote with a distant one and
+        # mis-styling markup after the tag. NEW: no match, text untouched.
+        text = '<br x="a> and more prose follows here'
+        self.assertIsNone(transforms._VOID_RE.search(text))
+
+    def test_void_wellformed_shapes_still_match(self):
+        for tag in ("<br/>", "<br />", '<br class="x"/>', "<hr class='x' />"):
+            self.assertIsNotNone(transforms._VOID_RE.search(tag), tag)
+
+    def test_img_unterminated_quote_skipped(self):
+        text = '<img src="a> more prose'
+        self.assertIsNone(transforms._IMG_TAG_RE.search(text))
+
+    def test_img_wellformed_rebuild_identical(self):
+        tag = '<img src="pic.png" alt="a photo" />'
+        out, count = transforms.add_img_alt("<html><body>" + tag + "</body></html>")
+        self.assertEqual(count, 0)  # alt already present; tag untouched
+        self.assertIn(tag, out)
+
+    def test_prune_img_unterminated_quote_skipped(self):
+        text = '<img src="a> more prose'
+        self.assertIsNone(epub._PRUNE_IMG_TAG_RE.search(text))
+
+    def test_link_and_anchor_unterminated_quote_skipped(self):
+        self.assertIsNone(epub._LINK_TAG_RE.search('<link href="a> prose'))
+        self.assertIsNone(epub._ANCHOR_TAG_RE.search("<a href='a> prose"))
+
+    def test_link_and_anchor_wellformed_match(self):
+        self.assertIsNotNone(
+            epub._LINK_TAG_RE.search('<link href="a.css" rel="stylesheet"/>')
+        )
+        self.assertIsNotNone(epub._ANCHOR_TAG_RE.search('<a href="b.xhtml">text</a>'))
+
+
+if __name__ == "__main__":
+    unittest.main()

{bindery_cli-0.41.0 → bindery_cli-0.42.0}/tests/test_transforms.py

@@ -389,6 +389,38 @@ class TestProtectedSpans(unittest.TestCase):
         out, n = unwrap_illegal_tags("<p>a<w>x</w>b<st>c</st></p>")
         self.assertEqual((out, n), ("<p>axbc</p>", 4))
 
+    def test_span_wrapping_block_with_gt_in_attribute_unwraps(self):
+        # the reason the start-tag match is quote-aware at all: the `>` of
+        # "a>b" is attribute content, and the span still wraps a block
+        text = '<p><span title="a>b"><div class="k">x</div></span>tail</p>'
+        out, n = unwrap_block_in_inline(text)
+        self.assertEqual((out, n), ('<p><div class="k">x</div>tail</p>', 1))
+
+    def test_failing_span_candidate_cannot_backtrack_explode(self):
+        # REGRESSION (0.41.0, the Physics fixture): the quote-aware prefix
+        # branches overlap ([^>] also matches quote characters), so in a
+        # long apostrophe-rich run with no `>` after a <span, the engine
+        # re-partitioned the prefix exponentially on the failing match and
+        # spun CPU indefinitely (an 843k-char back-matter document never
+        # finished). The possessive `*+` commits to the first partition and
+        # makes failure linear. This shape is the guard: the old pattern
+        # cannot finish this function call at all.
+        import signal
+        import time
+
+        run = "don't can't won't it's a>kind of prose, isn't it " * 2000
+        doc = "<p><span class='broken " + run + "and no closer.</p>"
+        signal.alarm(20)  # belt: fail the test, never hang the suite
+        try:
+            t0 = time.perf_counter()
+            out, n = unwrap_block_in_inline(doc)
+            elapsed = time.perf_counter() - t0
+        finally:
+            signal.alarm(0)
+        self.assertEqual(n, 0)
+        self.assertEqual(out, doc)  # nothing matched: byte-for-byte
+        self.assertLess(elapsed, 5.0)
+
     def test_illegal_tag_with_gt_in_attribute_value_is_removed_whole(self):
         # a bare [^>]* matcher ended the start tag at the `>` inside the
         # attribute value, mangled the edit, and the gate rejected the run

{bindery_cli-0.41.0 → bindery_cli-0.42.0}/uv.lock

@@ -8,7 +8,7 @@ resolution-markers = [
 
 [[package]]
 name = "bindery-cli"
-version = "0.41.0"
+version = "0.41.1"
 source = { editable = "." }
 dependencies = [
     { name = "cquarry", marker = "python_full_version >= '3.14'" },