Verify each finding against the current code and only fix it if needed.

Inline comments:
In `@express-zod-api/src/documentation-helpers.ts`:
- Around line 129-133: depictIntersection reads maxCombinations from the
depiction context but depictResponse and depictRequest build ctx without that
field, causing intersections to run unbounded; update the context construction
in depictResponse and depictRequest to include maxCombinations (propagate the
value from the function arguments/config/options into the ctx passed to
depictIntersection and flattenIO) so that flattenIO receives the intended
maxCombinations limit.

In `@express-zod-api/src/documentation.ts`:
- Around line 89-94: The JSDoc for the public constructor option maxCombinations
is missing an `@example`; update the comment block for the maxCombinations
property in documentation.ts to include an `@example` directive showing typical
usage (e.g., setting maxCombinations: 20 or Infinity) while keeping the existing
`@desc` and `@default` lines so the property has `@desc`, `@default`, and `@example` as
required by the public API documentation guidelines.

In `@express-zod-api/src/endpoint.ts`:
- Around line 94-98: Remove the R.once memoization wrapper from the private
methods that generate examples so they can be re-run with different limits:
specifically un-wrap the definitions of `#ensureOutputExamples` and the analogous
`#ensureInputExamples` (the ones currently defined as R.once((limit?: number) => {
... })). Leave the existing guard checks (e.g., the globalRegistry lookup and
isSchema check inside `#ensureOutputExamples`) intact so redundant work is still
avoided, but allow the function body to execute on each call with the provided
limit parameter instead of being permanently memoized.

Verify each finding against the current code and only fix it if needed.

Inline comments:
In `@express-zod-api/src/diagnostics.ts`:
- Around line 49-52: The diagnostics code mutates the shared combinations.limit
(setting it to 0) and fails to restore it, causing later consumers to see the
wrong limit; update the sections that set combinations.limit (the block
iterating responseVariants + endpoint.getResponses(...) and the similar block in
`#checkPathParams`) to save the original value (e.g., const prevLimit =
combinations.limit) before changing it and restore it in a finally or after the
loop (combinations.limit = prevLimit) so the global state is not left modified
after diagnostics complete.

In `@express-zod-api/src/integration.ts`:
- Line 95: The code sets combinations.limit = 0 and leaves module state mutated;
fix by saving the original value (e.g., const prev = combinations.limit) before
setting it to 0, perform the generation, and restore combinations.limit = prev
in a finally block so the original limit is always reinstated; apply this change
in the same constructor/generation block where combinations.limit is modified to
avoid shared-state side effects.

In `@express-zod-api/tests/common-helpers.spec.ts`:
- Around line 294-298: The test mutates the global combinations.limit and only
resets it if the assertions pass; change the test to always restore
combinations.limit (e.g., capture const prev = combinations.limit then run the
assertions inside a try/finally and in finally set combinations.limit = prev) so
the global state is restored even on failure; refer to the combinations function
and its combinations.limit property when making the change.

---

Nitpick comments:
In `@express-zod-api/src/documentation.ts`:
- Around line 170-176: The constructor of the Documentation class mutates the
module-level combinations by setting combinations.limit, which creates global
state leakage; instead remove that side-effect and scope the limit to this
instance by creating a local combinations object or passing the limit through a
parameter/context when generating docs (e.g., instantiate a localCombinations
from combinations() or call combinations({limit: maxCombinations}) if
supported), update any uses in Documentation methods to reference the
instance-local combination object rather than the module-level combinations
symbol, and ensure no other code relies on the module-level combinations.limit
being modified.