A catch that explicitly names AbortException (or a subtype) is a deliberate
swallow, e.g. Presenter::run() ending the lifecycle. Only broad catches
(\Throwable, \Exception) that swallow it incidentally are reported now.

New ValidRegularExpressionRule (the first custom rule in the project)
checks constant patterns passed to Strings::match/matchAll/split/replace
and reports compilation errors via RegexpException under identifier
nette.strings.regexpPattern. Enabled by default.

Adds TypeAssert::assertErrors() for testing rules (assertNoErrors now
delegates to it).

Extensions called getArgs() unconditionally on the entry node. For a first-class callable such as json_encode(...) or $form[x]->m(...), PHPStan getArgs() asserts !isFirstClassCallable(), so any covered function/method/static method used in first-class-callable syntax crashed the whole analysis with an internal error. Bail out (return null) when the call node is a first-class callable, before touching getArgs(). Mirrors the standard guard in core PHPStan extensions.

Shared helper that centralizes the translation of Nette's boolean
parameters into a PREG flag mask, the RegexArrayShapeMatcher calls
(matchShape/matchAllShape, instance) and stateless argument resolution
(resolveFlag/findArg, static). The Strings regex extensions added in the
following commits build on it.

Without vendor/ it knows nothing of the classes of the libraries, so a call of a deprecated method passes unnoticed.

A type test could see *ERROR* in place of a perfectly declared type, and
whether it did depended on which other tests happened to run beside it.
In nette/http, TypesTest failed under php-cgi on Windows only when run in
parallel with a test that touched FileUpload: getImageSize() declared as
?array{int, int} came out as *ERROR*. Alone, with -j 1, under the CLI or
with opcache disabled it passed.

The cause lies in how PHPStan finds the source of a class. For a class
outside the analysed paths, its AutoloadSourceLocator calls the autoloader
under FileReadTrapStreamWrapper, a stream wrapper that intercepts the
include, records the path and returns empty content, so the file is never
executed. Opcache defeats the trap: a script it already has in the cache
is served without the file being opened, the wrapper never sees the read
and the file really runs. Its class gets defined natively in the middle of
the analysis, and any trait or parent it needs is in turn loaded under the
trap, which fails (here "Trait Nette\SmartObject not found"), so the
reflection breaks and the type becomes *ERROR*.

Why it looked random: the CLI usually has opcache off (opcache.enable_cli),
while php-cgi has it on by the php.ini. On Windows the opcache memory is
shared by the php-cgi processes that run at the same time, so a script is
already cached in the test that analyses it exactly when a parallel test
has loaded it first. Calling opcache_compile_file() on the file before
assertTypes() reproduces it deterministically in a single process.

Opcache can be switched off at runtime (only off, never on), and once off
the scripts are compiled from the files again, so the trap works. It is
done in createContainer(), the common entry of every assertion, before
anything is analysed.

Its @param callable is intentionally strict, but the method escalates the
validity check to a ReflectionException at runtime, so a value that cannot
be statically proven callable (e.g. a [class-string, method] tuple) is valid
by design. New IgnoreErrorExtension matched narrowly to that single method.

StringsReturnTypeExtension now uses phpstan's RegexArrayShapeMatcher to
infer the precise shape (capture groups, named/optional groups, offsets)
for constant patterns, translating Nette's boolean parameters into a PREG
flag mask. Non-constant patterns and the lazy matchAll() Generator fall
back to the previous generic shape; split() is unchanged.

RemoveFailingReturnTypeExtension: DynamicReturnTypeExtensionRegistry is
injected directly, the provider layer was removed from PHPStan.

Tests: PHPStan reverted decimal-int-string inference for regex groups
back to numeric-string.

StringsRegexHelper: matchAllShape() passes wasMatched=maybe; matchAll()
may return an empty list, and PHPStan now infers non-empty-list for yes.

Also resolves nested access - chained ($container['a']['b']) and Nette's dash
notation ($container['a-b']) - via createComponent<Name>() factories.

Since nette/schema 1.4 an Expect::array() without a shape is an ArrayType,
not a plain Type, so the extension asks Expect::array() for the class the
same way the Expect::type() one does; up to 1.3 the answer stays Type.

New StringsMatchTypeSpecifyingExtension narrows the subject of a
successful Strings::match()/matchAll() call inside a truthy context,
e.g. `if (Strings::match($s, '#\d+#'))` makes $s a non-empty-string.
Delegates to RegexArrayShapeMatcher::matchSubjectExpr().

Claude-Session: https://claude.ai/code/session_01YAusXLYHRUMofgyF5LHxqN

PHPStan core ignores @property/@property-read tags on interfaces: the
allowsDynamicProperties() gate skips annotation-based properties there,
so e.g. $asset->url on Nette\Assets\Asset reports property.notFound and
a custom PropertiesClassReflectionExtension is never consulted.

InterfacePropertyTagTypeExtension (ExpressionTypeResolverExtension) gives
such reads the annotated type (narrowed expression types and native
properties win), InterfacePropertyTagIgnoreExtension suppresses the false
property.notFound. Writes are intentionally left unsupported.

Claude-Session: https://claude.ai/code/session_01YAusXLYHRUMofgyF5LHxqN

Narrows return types based on a configurable table-to-entity-class
mapping (nette.database.mapping.tables), which is not yet part of the
nette/database distribution. Kept as the topmost commit so the whole
feature can be excluded or rebased independently.

Includes:
- TableRowTypeResolver shared resolver
- Explorer::table() -> Selection<EntityRow>
- ActiveRow::related() -> GroupedSelection<EntityRow>
- ActiveRow::ref() -> ?EntityRow
- Selection::insert() -> mapped EntityRow