A plugin could register routes outside its prefix but not WAC-exempt
them, so fixed protocol roots (/xrpc, /_matrix, /api) 401'd until the
operator hand-passed appPaths, and pinned documents inside pod
namespaces (/:user/did.json) couldn't be expressed at all.

reservePath(path, opts?):
- literal paths behave like an entry prefix — the plugin owns the
  subtree, every method
- parameterized paths (:name = one segment) compile to exact-shape
  matchers, read-only by default (GET/HEAD/OPTIONS, opts.methods to
  widen) — they live inside WAC-governed namespaces, where a subtree
  or write exemption would be a WAC bypass; without the method gate a
  PUT to the reserved shape would skip WAC and reach the LDP wildcard
  as an unauthenticated pod write
- claims are cross-plugin: a second claimant fails the boot naming
  both plugins, replacing the loud-failure-or-silent-loser lottery
  witnessed with webfinger vs remotestorage

The shared-document case (both plugins own parts of one JRD) is a
different primitive — split to #606.

Five tests incl. the write-stays-guarded gate. Full suite 1040/1040.

'//' (or '/ ') passed the pre-check but normalized to '', and an empty
string in appPaths startsWith-matches every URL — one bad reservePath
call disabled WAC wholesale. Validation now runs on the normalized key.
Regression test boots a '//' claimant and asserts the loud refusal.
1041/1041.

Two WAC-exemption soundness gaps:

- collisions were keyed on the raw string, so '/:user/did.json' and
  '/:acct/did.json' — same compiled matcher, same exempted URLs —
  didn't collide. Now keyed on the shape (param names canonicalized),
  so same-shape claims fail the boot like literal ones.
- compilePathPattern treated any segment STARTING with ':' as a param,
  so '/:user.json' compiled to '/[^/]+' and exempted every '/*.json' —
  far broader than the ':name'-per-segment contract. Only a segment
  that is entirely ':name' is a param now; '/:user.json' is literal.

Both extracted to isParamPath/reservationKey/PARAM_SEGMENT. Two tests:
same-shape different-param collides; '/:user.json' exempts only itself
while a real sibling stays WAC-guarded. 1043/1043.

reservationKey mapped param segments to the literal string ':', which
could false-collide with a literal ':' segment (a valid, if exotic,
'/:/x' reservation) and wrongly reject it as already-claimed. Each
segment is now tagged param-vs-literal with a '\x00' frame (never in a
real path), so only genuinely identical shapes collide. Test: a literal
':' segment and a param shape coexist without a false collision.
1044/1044.

- compilePathPattern param segments were [^/]+, which swallowed the
  query delimiter: a query containing '/' (e.g. /alice/did.json?r=/a/b)
  then failed to match a shape the path satisfies — matching depended
  on query contents. Now [^/?]+, so the trailing (?:\?.*)? handles all
  queries. Test pins a slash-bearing query.
- WAC-skip check now tests m.methods before m.re: the read-only default
  set skips the regex entirely on write traffic. Pure perf, same result.
1045/1045.

reservePath allowed a plugin to re-claim its own path but pushed a
fresh regex into the WAC hook each time; repeated calls (shared helper,
re-activation paths) accumulated duplicate per-request checks. A
same-plugin re-claim now returns early before any push. The main
fixture double-reserves its did.json shape to pin the no-op. 1045/1045.

Literal reservations went into the all-methods appPaths lane, so a
plugin claiming /xrpc also WAC-exempted every method under it — and the
LDP write wildcards (PUT/POST/... '/*') sit beneath, so PUT /xrpc/x with
no plugin handler fell through as an unauthenticated storage write. Same
trap core installs 405 blocks for under /.well-known/*.

Both lanes are now read-only by default and method-gated: literals match
their subtree via compileSubtreePattern, params match exactly, and
{ methods } widens either. A write under a read-only reservation is
WAC-guarded; a shim that needs writes opts in explicitly.

The residual (a widened method at an unhandled path, and the pre-existing
entry-prefix exposure, both reaching the LDP wildcard) is broader than
this seam — filed as #611. Two tests: write-stays-guarded, widen-to-serve.
1047/1047.

The prose already said read-only-by-default, but the doc example's inline
comment and the loader-header comment still said literals exempt 'all
methods' — the misleading-into-insecurity case (an author assuming writes
are exempt without registering handlers). Example now widens /xrpc
explicitly with { methods }; both comments corrected. Docs only.

A query in the reserved string was escaped into the matcher, tying the
exemption to that exact query; a fragment never reaches request.url.
Both silently produce a reservation that matches nothing real. Rejected
at validation now, with a test. 1048/1048.

A non-array { methods } (e.g. 'GET') now fails with a targeted error
instead of an opaque TypeError from .map deep in activate; a null/garbage
opts is treated as omitted (read-only default). Two tests. 1050/1050.