diff --git a/CHANGELOG.md b/CHANGELOG.md
index 6ffd834d..c80e4722 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2,6 +2,39 @@
 
 ## 0.8.0
 
+### Breaking: native scalar storage is now the default
+
+`use native_types` has been removed. Inferred `int`, `float`, and `bool`
+locals now use `php::Int`, `php::Float`, and `php::Bool` by default. Their
+storage type is fixed and the compiler never promotes one of these locals to
+`php::Var` merely because a later operation needs dynamic PHP semantics.
+
+Two explicit escape hatches remain:
+
+- `use varint_types` is a file-level mode that stores inferred integer values
+  in `php::Var`, preserving PHP's overflow-to-float, non-integral division,
+  and other Zend integer arithmetic behavior. It does not box `float` or
+  `bool` locals.
+- `std::any($value)` erases the static type of that individual expression, so
+  a variable initialized from it uses `php::Var` and may participate in PHP
+  reference or dynamic-value operations.
+
+For example, `$i = 100` is now permanently an integer local. Reusing `$i` as a
+`foreach` key is rejected because PHP keys have type `int|string`; write
+`$i = std::any(100)` or select `use varint_types` if this reuse is intentional.
+Projects must remove `use native_types` and add the new compatibility mode only
+to files that genuinely depend on Zend integer widening semantics.
+
+Fixed-storage locals can no longer be converted to PHP references. This rule
+applies to native scalars, strings, arrays, objects, streams, high-precision
+values, and `std` containers. Zend references are untyped, so allowing one to
+alias fixed C++ storage could corrupt the variable's type. Use `std::any()`
+before reference operations and explicitly convert the result back afterward.
+
+TypePHP is always strict. Project sources no longer need
+`declare(strict_types=1)`; the directive remains accepted as a redundant PHP
+compatibility declaration, while `strict_types=0` is rejected.
+
 ### Breaking: compile-time API namespace cleanup
 
 TypePHP compile-time APIs now occupy only two global class symbols:
@@ -45,6 +78,32 @@ should review the change log and run their full test suite before upgrading.
 
 ## 0.8.0（中文）
 
+### 破坏性变更：默认使用原生标量存储
+
+`use native_types` 已移除。推断出的 `int`、`float`、`bool` 局部变量现在默认分别
+使用 `php::Int`、`php::Float`、`php::Bool`。这些变量的存储类型一旦确定便不会因为
+后续操作需要 PHP 动态语义而被编译器自动提升为 `php::Var`。
+
+只保留两个显式出口：
+
+- `use varint_types` 是文件级模式，使推断出的整数使用 `php::Var`，保留 PHP 的
+  整数溢出转浮点、整数除法产生非整数结果等 Zend 算术语义；它不会装箱 `float`
+  或 `bool`。
+- `std::any($value)` 只擦除该表达式的静态类型。以它初始化的变量使用 `php::Var`，
+  可参与引用或其他动态值操作。
+
+例如 `$i = 100` 现在固定为整数局部变量。由于 PHP 的 foreach key 类型为
+`int|string`，之后复用 `$i` 作为 key 会在编译期报错；确需复用时，应写成
+`$i = std::any(100)` 或在文件中声明 `use varint_types`。升级项目必须删除
+`use native_types`，并且只为真正依赖 Zend 整数扩展语义的文件添加新兼容模式。
+
+固定存储的局部变量不再允许转换为 PHP 引用，包括原生标量、字符串、数组、对象、
+stream、高精度值和 `std` 容器。Zend 引用没有类型约束，若允许其指向固定 C++ 存储，
+可能破坏变量类型。需要引用操作时先使用 `std::any()`，操作完成后再显式转换回目标类型。
+
+TypePHP 始终使用严格类型，项目源码不再需要 `declare(strict_types=1)`。该声明仍作为
+冗余的 PHP 兼容语法被接受，而 `strict_types=0` 会被拒绝。
+
 ### 破坏性变更：整理编译期 API 命名空间
 
 TypePHP 编译期 API 现在只占用两个全局类符号：
diff --git a/README-CN.md b/README-CN.md
index 0f4595b2..9885e614 100644
--- a/README-CN.md
+++ b/README-CN.md
@@ -109,8 +109,11 @@ AST，待全部项目符号就绪后再在 convert 阶段解析。这一两阶
 - **原生进程入口。** 二进制模式直接启动原生可执行文件，不需要 PHP CLI 或独立的
   解释器进程。可执行文件仍会嵌入或链接 PHPX、`libphp` 及项目配置的原生库，部署包
   中必须提供这些运行时依赖。
-- **渐进式类型，真正带来收益。** 只在性能关键处添加 `use native_types`、`std::`
-  容器和类型声明，其余保持普通 PHP。
+- **默认使用强标量类型。** 推断出的 `int`、`float`、`bool` 局部变量直接使用
+  C++ 原生存储。单个动态值使用 `std::any()`；只有文件确实依赖 PHP 整数扩展语义时，
+  才使用 `use varint_types`。
+- **始终严格调用。** TypePHP 不启用 PHP 的弱标量类型转换，无需声明
+  `declare(strict_types=1)`。
 - **Zend 生态互通。** 扩展模式以标准 PHP 扩展形式加载，项目可以调用受支持的
   内置函数，并显式声明依赖的其他 Zend 扩展。
 
@@ -299,7 +302,9 @@ TypePHP 会在适合 AOT 编译的范围内保持 PHP 语法和运行行为，
 
 - 全局作用域只允许声明，可执行语句必须位于函数或方法内；
 - 二进制模式对 `main()` 使用严格签名；
-- `use native_types` 会让标量声明使用固定原生存储，之后不能改为不兼容类型；
+- 推断出的 `int`、`float`、`bool` 默认使用固定原生存储，之后不能改为不兼容类型；
+- `use varint_types` 使推断出的整数存入 `php::Var`，保留 PHP 的整数溢出和除法语义；
+  `std::any()` 则只擦除单个表达式的静态类型；
 - 静态可确定的调用和属性会直接编译，受支持的动态操作则通过 PHPX/Zend runtime
   fallback 执行；
 - `.stub.php` 用于声明 C++ 或外部库 API，函数体必须为空，stub 文件禁止声明
@@ -367,7 +372,6 @@ function main(): void
 
 ```php
 <?php
-use native_types;
 
 function fib(int $n): int
 {
@@ -391,15 +395,14 @@ bin/tpc.php fib.php -O3 -o fib
 ./fib 30
 ```
 
-使用 `use native_types` 后，`int` 变量变为 C++ `int64_t`，算术运算直接编译为
-CPU 指令，而不是 ZendVM 调用。
+默认情况下，推断和声明的 `int` 变量都会变为 C++ `int64_t`，算术运算直接编译为
+CPU 指令，而不是 ZendVM 调用。仅当本文件需要 PHP 的整数溢出转浮点、整数除法产生
+非整数结果等语义时，才添加 `use varint_types`。
 
 ### 2. 高精度数值
 
 ```php
 <?php
-declare(strict_types=1);
-use native_types;
 
 function main(): void
 {
@@ -425,7 +428,6 @@ function main(): void
 
 ```php
 <?php
-use native_types;
 
 function main(): void
 {
diff --git a/README.md b/README.md
index 54b611ed..03f0acc0 100644
--- a/README.md
+++ b/README.md
@@ -127,9 +127,11 @@ This two-phase design keeps multi-file and self-hosted builds deterministic.
   executable and does not require the PHP CLI or a separate interpreter
   process. The executable still embeds/links PHPX, `libphp`, and any configured
   native libraries, which must be available in the deployment package.
-- **Gradual typing that actually pays off.** Add `use native_types`, `std::`
-  containers, and type declarations only where performance matters; the rest
-  stays ordinary PHP.
+- **Strong scalar types by default.** Inferred `int`, `float`, and `bool`
+  locals use native C++ storage. Use `std::any()` for an individual dynamic
+  value, or `use varint_types` when a file requires PHP integer widening.
+- **Always-strict calls.** TypePHP never enables PHP's weak scalar coercion;
+  `declare(strict_types=1)` is unnecessary.
 - **Zend ecosystem interop.** Extension mode loads as a standard PHP extension,
   and projects can call supported internal functions and require other Zend
   extensions explicitly.
@@ -331,8 +333,10 @@ ahead-of-time compilation, but it also makes several deliberate restrictions:
 - global scope is declaration-only; executable statements must be inside a
   function or method;
 - binary mode has a strict `main()` signature;
-- `use native_types` opts scalar declarations into fixed native storage, so a
-  value cannot later change to an incompatible type;
+- inferred `int`, `float`, and `bool` values use fixed native storage by
+  default and cannot later change to an incompatible type;
+- `use varint_types` stores inferred integers in `php::Var` for PHP-compatible
+  overflow and division behavior; `std::any()` erases one expression's type;
 - statically-known calls and properties are compiled directly, while supported
   dynamic operations use PHPX/Zend runtime fallbacks;
 - `.stub.php` files declare C++ or imported-library APIs and must contain empty
@@ -405,7 +409,6 @@ inherited final method is a compile-time error.
 
 ```php
 <?php
-use native_types;
 
 function fib(int $n): int
 {
@@ -429,15 +432,15 @@ bin/tpc.php fib.php -O3 -o fib
 ./fib 30
 ```
 
-With `use native_types`, `int` variables become C++ `int64_t` and arithmetic
-compiles to plain CPU instructions instead of ZendVM calls.
+By default, inferred and declared `int` variables become C++ `int64_t`, and
+arithmetic compiles to plain CPU instructions instead of ZendVM calls. Add
+`use varint_types` only when a file requires PHP's overflow-to-float and
+non-integral integer-division behavior.
 
 ### 2. High-precision numerics
 
 ```php
 <?php
-declare(strict_types=1);
-use native_types;
 
 function main(): void
 {
@@ -464,7 +467,6 @@ See [High-precision types](docs/en/HIGH_PRECISION_TYPES.md) and
 
 ```php
 <?php
-use native_types;
 
 function main(): void
 {
diff --git a/benchmark/bridge/benchmark.php b/benchmark/bridge/benchmark.php
index 591fab19..39bda0c3 100644
--- a/benchmark/bridge/benchmark.php
+++ b/benchmark/bridge/benchmark.php
@@ -1,6 +1,5 @@
 <?php
 
-declare(strict_types=1);
 
 const BRIDGE_ITERATIONS = 10_000_000;
 const BRIDGE_CONTAINER_ITERATIONS = 1_000_000;
diff --git a/benchmark/bridge/run.php b/benchmark/bridge/run.php
index fd3bfd69..b0950037 100644
--- a/benchmark/bridge/run.php
+++ b/benchmark/bridge/run.php
@@ -1,6 +1,5 @@
 <?php
 
-declare(strict_types=1);
 
 $root = dirname(__DIR__, 2);
 $source = __DIR__ . '/benchmark.php';
diff --git a/benchmark/dynamic-call/benchmark.php b/benchmark/dynamic-call/benchmark.php
index a425190b..31206e15 100644
--- a/benchmark/dynamic-call/benchmark.php
+++ b/benchmark/dynamic-call/benchmark.php
@@ -1,6 +1,5 @@
 <?php
 
-declare(strict_types=1);
 
 const DYNAMIC_CALL_ITERATIONS = 1_000_000;
 const DYNAMIC_CALL_ROUNDS = 5;
diff --git a/benchmark/dynamic-call/run.php b/benchmark/dynamic-call/run.php
index ef6ce762..51c1eaf6 100644
--- a/benchmark/dynamic-call/run.php
+++ b/benchmark/dynamic-call/run.php
@@ -1,6 +1,5 @@
 <?php
 
-declare(strict_types=1);
 
 $root = dirname(__DIR__, 2);
 $source = __DIR__ . '/benchmark.php';
diff --git a/benchmark/micro_bench.php b/benchmark/micro_bench.php
index 50697227..6aa83357 100644
--- a/benchmark/micro_bench.php
+++ b/benchmark/micro_bench.php
@@ -1,5 +1,4 @@
 <?php
-declare(strict_types=1);
 
 function hallo() {
 }
diff --git a/benchmark/property-access/benchmark.php b/benchmark/property-access/benchmark.php
index 588fc903..ff54c75f 100644
--- a/benchmark/property-access/benchmark.php
+++ b/benchmark/property-access/benchmark.php
@@ -1,6 +1,5 @@
 <?php
 
-declare(strict_types=1);
 
 final class DynamicPropertyEntity
 {
diff --git a/benchmark/property-access/run.php b/benchmark/property-access/run.php
index 71fb41fa..5285867b 100644
--- a/benchmark/property-access/run.php
+++ b/benchmark/property-access/run.php
@@ -1,6 +1,5 @@
 <?php
 
-declare(strict_types=1);
 
 $root = dirname(__DIR__, 2);
 $source = __DIR__ . '/benchmark.php';
diff --git a/benchmark/static-cache/benchmark.php b/benchmark/static-cache/benchmark.php
index fa3966b7..d42b2444 100644
--- a/benchmark/static-cache/benchmark.php
+++ b/benchmark/static-cache/benchmark.php
@@ -1,6 +1,5 @@
 <?php
 
-declare(strict_types=1);
 
 const STATIC_CACHE_ITERATIONS = 1_000_000;
 const STATIC_CACHE_WARMUPS = 2;
diff --git a/benchmark/static-cache/run.php b/benchmark/static-cache/run.php
index 73942375..89581187 100644
--- a/benchmark/static-cache/run.php
+++ b/benchmark/static-cache/run.php
@@ -1,6 +1,5 @@
 <?php
 
-declare(strict_types=1);
 
 $root = dirname(__DIR__, 2);
 $source = __DIR__ . '/benchmark.php';
diff --git a/bin/analyze-test-coverage.php b/bin/analyze-test-coverage.php
index 1d55ac62..66f42fe7 100755
--- a/bin/analyze-test-coverage.php
+++ b/bin/analyze-test-coverage.php
@@ -7,7 +7,6 @@
  * @contact  service@swoole.com
  */
 
-declare(strict_types=1);
 
 use TypePhp\Testing\TestCoverageAnalyzer;
 
diff --git a/bin/clean-phpt-artifacts.php b/bin/clean-phpt-artifacts.php
index f04ffb4c..6efb6c75 100755
--- a/bin/clean-phpt-artifacts.php
+++ b/bin/clean-phpt-artifacts.php
@@ -1,7 +1,6 @@
 #!/usr/bin/env php
 <?php
 
-declare(strict_types=1);
 
 const DEFAULT_TEST_DIR = 'tests';
 
diff --git a/bin/run-integration-tests.php b/bin/run-integration-tests.php
index 21fbc2ea..9892005b 100755
--- a/bin/run-integration-tests.php
+++ b/bin/run-integration-tests.php
@@ -1,7 +1,6 @@
 #!/usr/bin/env php
 <?php
 
-declare(strict_types=1);
 
 namespace TypePhp\IntegrationTest;
 
diff --git a/docs/en/HIGH_PRECISION_TYPES.md b/docs/en/HIGH_PRECISION_TYPES.md
index b529768d..f5d5fe0f 100644
--- a/docs/en/HIGH_PRECISION_TYPES.md
+++ b/docs/en/HIGH_PRECISION_TYPES.md
@@ -48,14 +48,11 @@ The AOT compiler provides three high-precision types, built on mature C/C++ math
 
 Prerequisites for using high-precision types:
 
-1. Declare `declare(strict_types=1)` at the top of the file
-2. Import the native type declaration `use native_types`
-3. The system must have the corresponding C++ libraries installed (`libgmp-dev`, `libmpdec-dev`, `libmpfr-dev`)
+- The system must have the corresponding C++ libraries installed (`libgmp-dev`, `libmpdec-dev`, `libmpfr-dev`).
+- TypePHP always uses strict typing; no `declare(strict_types=1)` directive is required.
 
 ```php
 <?php
-declare(strict_types=1);
-use native_types;
 
 function main(): void {
     // Your high-precision computation code
@@ -74,7 +71,9 @@ php bin/tpc.php my_program.php -o my_program
 ./my_program
 ```
 
-> **Tip**: Like all native_types, the Big* types can only be used in AOT compile mode and cannot run in the normal PHP interpreter. The AOT compiler performs compile-time evaluation of functions such as `std::bigInt()` and directly generates C++ code.
+> **Tip**: Big* types can only be used in AOT compile mode and cannot run in
+> the normal PHP interpreter. The compiler recognizes functions such as
+> `std::bigInt()` and directly generates C++ code.
 
 ---
 
@@ -133,11 +132,9 @@ $g = std::bigFloat("3.14159265358979323846");             // from string (exact)
 
 ### 4.2 Type Annotation
 
-Under `use native_types`, Big* type variables automatically get native C++ storage types:
+Big* constructors always produce their dedicated boxed C++ storage type:
 
 ```php
-use native_types;
-
 // The compiler automatically infers the type as php::BigInt / php::Decimal / php::BigFloat
 $a = std::bigInt(100);         // → C++: php::Variant(new BigInt(100))
 $b = std::decimal("100.50");   // → C++: php::Variant(new Decimal("100.50"))
@@ -586,9 +583,11 @@ This restriction also applies to comparison operations. Before comparing, both s
 
 Big* types are a proprietary feature of the AOT compiler, relying on compile-time code generation and C++ underlying libraries. The source code cannot be directly interpreted and executed by the `php` command.
 
-### 12.8 Enabling `use native_types`
+### 12.8 No file-level opt-in required
 
-Forgetting to add `use native_types` causes Big* variables to be treated as Var (generic type), losing most of the performance advantages of native types.
+Big* constructors determine their result type directly. No file-level native
+type declaration is required. `use varint_types` affects only inferred ordinary
+integers and does not change BigInt, Decimal, or BigFloat storage.
 
 ---
 
@@ -598,8 +597,6 @@ Forgetting to add `use native_types` causes Big* variables to be treated as Var
 
 ```php
 <?php
-declare(strict_types=1);
-use native_types;
 
 /**
  * Compute the factorial of n, supporting arbitrarily large results
@@ -625,8 +622,6 @@ function main(): void {
 
 ```php
 <?php
-declare(strict_types=1);
-use native_types;
 
 function main(): void {
     // use Decimal to represent amounts exactly
@@ -661,8 +656,6 @@ total: 64.7676
 
 ```php
 <?php
-declare(strict_types=1);
-use native_types;
 
 function main(): void {
     // use BigFloat for high-precision math computation
@@ -690,8 +683,6 @@ function main(): void {
 
 ```php
 <?php
-declare(strict_types=1);
-use native_types;
 
 function main(): void {
     // BigInt — large integer operations
diff --git a/docs/en/INCOMPATIBLE_PHP_FEATURES.md b/docs/en/INCOMPATIBLE_PHP_FEATURES.md
index c0996085..818a5b99 100644
--- a/docs/en/INCOMPATIBLE_PHP_FEATURES.md
+++ b/docs/en/INCOMPATIBLE_PHP_FEATURES.md
@@ -77,7 +77,7 @@ incompatible with or more restrictive than standard PHP.
 
 - `declare(ticks=...)` is not supported.
 - `declare(encoding=...)` accepts only `UTF-8`.
-- `declare(strict_types=...)` accepts only `strict_types=1`.
+- TypePHP always uses strict typing. `declare(strict_types=1)` is accepted but redundant; `strict_types=0` is rejected.
 - No other `declare` directives are supported.
 
 ## Calls and references
@@ -103,6 +103,15 @@ incompatible with or more restrictive than standard PHP.
   used explicitly.
 - `std::ref()` / `toRef()` only accept variables, array elements, or object
   properties.
+- A local with fixed storage (`Int`, `Float`, `Bool`, `Str`, `Array`, `Object`,
+  `Stream`, high-precision values, or a `std` container) cannot be made into a
+  PHP reference. Zend references are untyped and could replace such storage
+  with an incompatible value. Objects, streams, typed objects, and `std`
+  containers already use handle/reference-like value semantics, so adding a
+  PHP reference to the local variable is unnecessary as well. Initialize the
+  value with `std::any()` when PHP reference semantics are required, then
+  convert it back explicitly with a keyword such as `toArray()` or
+  `toString()`.
 - A call that uses argument unpacking followed by named arguments falls back to
   dynamic dispatch and cannot use the native call path.
 
diff --git a/docs/en/NATIVE_TYPES.md b/docs/en/NATIVE_TYPES.md
index 82231bda..269fd1c0 100644
--- a/docs/en/NATIVE_TYPES.md
+++ b/docs/en/NATIVE_TYPES.md
@@ -4,6 +4,15 @@
 
 **The AOT compiler supports 6 native/high-precision types**:
 
+Since TypePHP 0.8, inferred `int`, `float`, and `bool` locals use native
+`php::Int`, `php::Float`, and `php::Bool` storage by default. The old
+`use native_types` directive has been removed. Native locals are never
+silently promoted to `php::Var` later.
+
+Use `use varint_types` only for a file that needs Zend PHP integer widening
+semantics. It boxes inferred integers, but not floats or booleans. Use
+`std::any($value)` when only one value must be dynamic or reference-capable.
+
 ### Basic Native Types
 1. ✅ `std::int` - Native integer type (zend_long, 8 bytes)
 2. ✅ `std::float` - Native floating-point type (double, 8 bytes)
@@ -24,7 +33,6 @@ Pay particular attention to `unset($obj->prop)` and assigning `null` on fixed-va
 
 ```php
 <?php
-use native_types;
 
 class User {
     public int $id = 0;
@@ -263,8 +271,6 @@ BigInt, Decimal, and BigFloat all inherit from `php::Box` and are stored inside
 ### Declaration and Construction
 
 ```php
-use native_types;
-
 // Construct a BigInt from an integer literal
 $a = std::bigInt(100);
 $b = std::bigInt("123456789012345678901234567890");  // Very long integer string
@@ -496,11 +502,15 @@ Both sides are Int
 
 ### Rule 1: Var Dominates
 
-When at least one side of the operands is of type `Var` (not declared with `use native_types`), both sides are treated as `Var`, using ZendVM's `add_function` / `div_function` and other operation functions, fully following PHP's native type conversion (type juggling) semantics.
+When at least one operand is `Var`, both sides use the PHPX/Zend arithmetic
+path and follow PHP type-juggling semantics. A `Var` comes from an expression
+such as `std::any(...)`, a dynamic runtime value, or an inferred integer in a
+file that declares `use varint_types`.
 
 ```php
+use varint_types;
 $a = 10;        // Var, stores int(10)
-$b = 2.5;       // Var, stores float(2.5)
+$b = 2.5;       // php::Float (varint_types affects only inferred integers)
 $c = $a + $b;   // Both sides are Var → ZendVM operation → float(12.5)
 ```
 
@@ -508,10 +518,11 @@ C++ code generation: `int64_t` and `double` values are implicitly converted to `
 
 ### Rule 2: Float Takes Precedence over Int
 
-When both sides are native types (declared via `use native_types` or `std::int()`/`std::float()`), if either side is Float, both sides are converted to Float for the operation. Only when both sides are Int is integer arithmetic used.
+When both sides are native types (the default, or explicitly constructed with
+`std::int()` / `std::float()` inside a varint file), Float takes precedence.
+Only two Int operands use integer arithmetic.
 
 ```php
-use native_types;
 $a = 10;        // php::Int
 $b = 2.5;       // php::Float
 $c = $a + $b;   // Float + Float → double addition
@@ -521,7 +532,10 @@ $e = 3;         // php::Int
 $f = $d + $e;   // Int + Int → int64_t addition
 ```
 
-> **Note**: native-type variables **do not change their own type** during operations. For example, `Int += Float` executes `int64_t += double` in C++, and the result is truncated to int64_t, which differs from PHP behavior (in PHP the variable becomes float). This is intentional semantics of `use native_types`.
+> **Note**: native variables **do not change storage type** during operations.
+> For example, `Int += Float` remains Int. This fixed-type behavior is now the
+> default; choose `use varint_types` or `std::any()` when dynamic integer
+> widening is required.
 
 ### Rule 3: Safe Promotion of High-Precision Types
 
@@ -560,15 +574,15 @@ When the operands include `BigInt`, `Decimal`, or `BigFloat`, only explicit and
 Compound assignment operators such as `+=`, `-=`, `*=`, `/=`, `%=` follow the same type promotion rules, but the RHS is converted to the type of the LHS variable. If the LHS is Var, the RHS keeps its original type (Var's `operator+=` takes over); if the LHS is a native type, the RHS is explicitly converted to that type.
 
 ```php
-$a = 10;        // Var
+use varint_types;
+$a = 10;        // Var because this file selected varint_types
 $a += 2.5;      // Var::operator+=(float) → ZendVM → $a becomes float(12.5)
 
-use native_types;
-$b = 10;        // php::Int
+$b = std::int(10); // Explicit php::Int inside a varint_types file
 $b += 2.5;      // int64_t += double → C++ implicit truncation → $b = 12 (Int)
 ```
 
 ---
 
-**Last updated**: May 26, 2026
-**Applicable version**: PHP AOT Compiler v1.x
+**Last updated**: September 6, 2026
+**Applicable version**: TypePHP 0.8+
diff --git a/docs/en/PHP_INCOMPATIBILITY_CLASSIFICATION.md b/docs/en/PHP_INCOMPATIBILITY_CLASSIFICATION.md
index 0f6145a2..62aba3b0 100644
--- a/docs/en/PHP_INCOMPATIBILITY_CLASSIFICATION.md
+++ b/docs/en/PHP_INCOMPATIBILITY_CLASSIFICATION.md
@@ -66,7 +66,7 @@ These items should be documented with the exact boundary.
 | Binary mode requires global `main()` | Intentional Rule | This defines the binary entry ABI. |
 | `main()` only accepts no parameters or `(int $argc, array $argv)` | Intentional Rule | Keeps the entry ABI explicit and stable. |
 | `main()` must return `void` | Intentional Rule | An integer exit-code convention could be added later, but current TypePHP rules reject return values. |
-| `declare(strict_types=...)` only supports `strict_types=1` | Intentional Rule | Supporting mixed strict/weak typing is possible, but TypePHP keeps strict behavior predictable. |
+| TypePHP is always strict; `strict_types=0` is rejected | Intentional Rule | Per-file weak typing conflicts with TypePHP's fixed storage and static type guarantees. `strict_types=1` remains accepted as a redundant compatibility directive. |
 | Default parameter before required parameter | Intentional Rule | PHP allows this legacy pattern but ignores the default. TypePHP rejects it to avoid misleading declarations. |
 | Child class overriding parent private property | Intentional Rule / Pending if dynamicized | PHP stores private properties by declaring class. TypePHP native/fixed layouts make this expensive. Rejecting it keeps property layout predictable. |
 | `__construct()` return value | Intentional Rule | PHP constructors should not return values. TypePHP rejects this explicitly. |
diff --git a/docs/en/STD_CONTAINERS.md b/docs/en/STD_CONTAINERS.md
index 146ff9f5..8438918a 100644
--- a/docs/en/STD_CONTAINERS.md
+++ b/docs/en/STD_CONTAINERS.md
@@ -511,8 +511,6 @@ sec: 67.638107061386108
 ### std::array
 Test code:
 ```php
-use native_types;
-
 function main(int $argc, array $argv): void
 {
     $u = (int)$argv[2];
diff --git a/docs/en/UNIVERSAL_METHODS.md b/docs/en/UNIVERSAL_METHODS.md
index f75290cb..ebb74210 100644
--- a/docs/en/UNIVERSAL_METHODS.md
+++ b/docs/en/UNIVERSAL_METHODS.md
@@ -917,8 +917,6 @@ Format: `{type_prefix}_{snake_case_method_name}`
 
 ```php
 <?php
-declare(strict_types=1);
-use native_types;
 
 /**
  * Extension method: determine whether an Int is prime
@@ -974,8 +972,6 @@ function main(): void {
 
 ```php
 <?php
-declare(strict_types=1);
-use native_types;
 
 function main(): void {
     $raw = "  <h1>Hello World!</h1>  \n";
@@ -998,8 +994,6 @@ function main(): void {
 
 ```php
 <?php
-declare(strict_types=1);
-use native_types;
 
 function main(): void {
     $data = [5, 2, 8, 1, 9, 3, 7];
@@ -1034,8 +1028,6 @@ function main(): void {
 
 ```php
 <?php
-declare(strict_types=1);
-use native_types;
 
 function main(): void {
     // Factorial of a large integer (using compound assignment for brevity)
@@ -1072,8 +1064,6 @@ function main(): void {
 
 ```php
 <?php
-declare(strict_types=1);
-use native_types;
 
 function main(): void {
     // Write to the file
diff --git a/docs/zh-cn/HIGH_PRECISION_TYPES.md b/docs/zh-cn/HIGH_PRECISION_TYPES.md
index 3fde670c..516ba5df 100644
--- a/docs/zh-cn/HIGH_PRECISION_TYPES.md
+++ b/docs/zh-cn/HIGH_PRECISION_TYPES.md
@@ -48,14 +48,11 @@ AOT 编译器提供了三种高精度类型，底层基于成熟的 C/C++ 数学
 
 使用高精度类型的前提条件：
 
-1. 文件头部声明 `declare(strict_types=1)`
-2. 导入原生类型声明 `use native_types`
-3. 系统已安装对应的 C++ 库（`libgmp-dev`、`libmpdec-dev`、`libmpfr-dev`）
+- 系统已安装对应的 C++ 库（`libgmp-dev`、`libmpdec-dev`、`libmpfr-dev`）。
+- TypePHP 始终使用严格类型，无需声明 `declare(strict_types=1)`。
 
 ```php
 <?php
-declare(strict_types=1);
-use native_types;
 
 function main(): void {
     // 你的高精度计算代码
@@ -74,7 +71,8 @@ php bin/tpc.php my_program.php -o my_program
 ./my_program
 ```
 
-> **提示**：和所有 native_types 一样，Big* 类型只能在 AOT 编译模式下使用，不能在普通 PHP 解释器中运行。AOT 编译器会对 `std::bigInt()` 等函数进行编译期求值，直接生成 C++ 代码。
+> **提示**：Big* 类型只能在 AOT 编译模式下使用，不能在普通 PHP 解释器中运行。
+> 编译器会识别 `std::bigInt()` 等函数并直接生成 C++ 代码。
 
 ---
 
@@ -133,11 +131,9 @@ $g = std::bigFloat("3.14159265358979323846");             // 从字符串（精
 
 ### 4.2 类型标注
 
-在 `use native_types` 下，Big* 类型变量自动获得原生 C++ 存储类型：
+Big* 构造函数始终产生对应的专用 C++ 装箱存储类型：
 
 ```php
-use native_types;
-
 // 编译器自动推断类型为 php::BigInt / php::Decimal / php::BigFloat
 $a = std::bigInt(100);         // → C++: php::Variant(new BigInt(100))
 $b = std::decimal("100.50");   // → C++: php::Variant(new Decimal("100.50"))
@@ -586,9 +582,10 @@ $c = $a + std::bigFloat($b->toString());  // ✅
 
 Big* 类型是 AOT 编译器的专有特性，依赖编译期代码生成和 C++ 底层库。源码不能被 `php` 命令直接解释执行。
 
-### 12.8 启用 `use native_types`
+### 12.8 无需文件级开关
 
-忘记添加 `use native_types` 会导致 Big* 变量被当作 Var（通用类型），失去原生类型的大部分性能优势。
+Big* 构造函数会直接确定结果类型，不需要文件级原生类型声明。`use varint_types`
+只影响推断出的普通整数，不改变 BigInt、Decimal 或 BigFloat 的存储。
 
 ---
 
@@ -598,8 +595,6 @@ Big* 类型是 AOT 编译器的专有特性，依赖编译期代码生成和 C++
 
 ```php
 <?php
-declare(strict_types=1);
-use native_types;
 
 /**
  * 计算 n 的阶乘，支持任意大的结果
@@ -625,8 +620,6 @@ function main(): void {
 
 ```php
 <?php
-declare(strict_types=1);
-use native_types;
 
 function main(): void {
     // 使用 Decimal 精确表示金额
@@ -661,8 +654,6 @@ function main(): void {
 
 ```php
 <?php
-declare(strict_types=1);
-use native_types;
 
 function main(): void {
     // 使用 BigFloat 进行高精度数学运算
@@ -690,8 +681,6 @@ function main(): void {
 
 ```php
 <?php
-declare(strict_types=1);
-use native_types;
 
 function main(): void {
     // BigInt — 大整数运算
diff --git a/docs/zh-cn/INCOMPATIBLE_PHP_FEATURES.md b/docs/zh-cn/INCOMPATIBLE_PHP_FEATURES.md
index 42986a04..a41e0db8 100644
--- a/docs/zh-cn/INCOMPATIBLE_PHP_FEATURES.md
+++ b/docs/zh-cn/INCOMPATIBLE_PHP_FEATURES.md
@@ -36,7 +36,7 @@
 
 - 不支持 `declare(ticks=...)`。
 - `declare(encoding=...)` 只允许 `UTF-8`。
-- `declare(strict_types=...)` 只允许 `strict_types=1`。
+- TypePHP 始终使用严格类型。`declare(strict_types=1)` 可兼容接受但没有作用；`strict_types=0` 会被拒绝。
 - 不支持其他 `declare` 指令。
 
 ## 调用与引用
@@ -48,6 +48,12 @@
 - 引用赋值不支持从复杂静态属性表达式建立引用。
 - 动态调用、闭包调用等编译期无法确定参数签名的调用，不能自动转换引用参数；需要显式使用 `std::ref()` 或等价关键词方法 `toRef()`。
 - `std::ref()` / `toRef()` 只接受变量、数组元素或对象属性。
+- 采用固定存储的局部变量（`Int`、`Float`、`Bool`、`Str`、`Array`、`Object`、
+  `Stream`、高精度值或 `std` 容器）不能转换为 PHP 引用。Zend 引用没有类型约束，
+  可能把固定存储替换成不兼容的值。对象、stream、typed object 与 `std` 容器本身
+  已采用句柄或引用式值语义，再对局部变量建立 PHP 引用也没有意义。确需 PHP 引用
+  语义时，应使用 `std::any()` 初始化，完成引用操作后再通过 `toArray()`、
+  `toString()` 等关键词显式转换回来。
 - 带 unpack 且尾部追加 named arguments 的调用会退化为动态调用，不能使用 native call。
 
 ## 对象模型
diff --git a/docs/zh-cn/NATIVE_TYPES.md b/docs/zh-cn/NATIVE_TYPES.md
index 0252734b..b8f29e4f 100644
--- a/docs/zh-cn/NATIVE_TYPES.md
+++ b/docs/zh-cn/NATIVE_TYPES.md
@@ -4,6 +4,14 @@
 
 **AOT 编译器支持 6 种原生/高精度类型**:
 
+从 TypePHP 0.8 起，推断出的 `int`、`float`、`bool` 局部变量默认分别使用
+`php::Int`、`php::Float`、`php::Bool` 原生存储。原有 `use native_types` 已移除，
+编译器也绝不会在后续流程中把原生局部变量静默提升为 `php::Var`。
+
+只有文件确实需要 Zend PHP 的整数扩展语义时才使用 `use varint_types`；它只装箱
+推断出的整数，不影响 float 和 bool。只有单个值需要动态或引用语义时，使用
+`std::any($value)`。
+
 ### 基础原生类型
 1. ✅ `std::int` - 原生整数类型 (zend_long, 8 字节)
 2. ✅ `std::float` - 原生浮点类型 (double, 8 字节)
@@ -24,7 +32,6 @@ AOT 编译器要求对象属性在整个生命周期内始终保持声明时的
 
 ```php
 <?php
-use native_types;
 
 class User {
     public int $id = 0;
@@ -263,8 +270,6 @@ BigInt、Decimal、BigFloat 均继承自 `php::Box`，存储于 `php::Variant` 
 ### 声明与构造
 
 ```php
-use native_types;
-
 // 从整数字面量构造 BigInt
 $a = std::bigInt(100);
 $b = std::bigInt("123456789012345678901234567890");  // 超长整数字符串
@@ -496,11 +501,14 @@ BigFloat / Decimal / BigInt 参与
 
 ### 规则一：Var 主导
 
-当运算数中至少有一边是 `Var` 类型（非 `use native_types` 声明），两边均作为 `Var` 处理，使用 ZendVM 的 `add_function` / `div_function` 等运算函数，完全遵循 PHP 原生类型转换（type juggling）语义。
+当至少一个运算数为 `Var` 时，两边都进入 PHPX/Zend 算术路径，遵循 PHP 的类型
+转换语义。`Var` 可以来自 `std::any(...)`、动态运行时值，或声明了
+`use varint_types` 的文件中推断出的整数。
 
 ```php
+use varint_types;
 $a = 10;        // Var，存 int(10)
-$b = 2.5;       // Var，存 float(2.5)
+$b = 2.5;       // php::Float（varint_types 只影响推断整数）
 $c = $a + $b;   // 两边为 Var → ZendVM 运算 → float(12.5)
 ```
 
@@ -508,10 +516,10 @@ C++ 代码生成：`int64_t` 和 `double` 值通过 `php::Variant` 的模板构
 
 ### 规则二：Float 优先于 Int
 
-当两边均为原生类型（通过 `use native_types` 或 `std::int()`/`std::float()` 声明），如果任一边是 Float，则两边均转为 Float 运算。仅当两边都是 Int 才使用整数运算。
+当两边均为原生类型（默认行为，或在 varint 文件中显式使用 `std::int()` /
+`std::float()`）时，Float 优先。仅当两边都是 Int 才使用整数运算。
 
 ```php
-use native_types;
 $a = 10;        // php::Int
 $b = 2.5;       // php::Float
 $c = $a + $b;   // Float + Float → double 加法
@@ -521,7 +529,9 @@ $e = 3;         // php::Int
 $f = $d + $e;   // Int + Int → int64_t 加法
 ```
 
-> **注意**：原生类型变量在运算中**不会改变自身类型**。如 `Int += Float` 在 C++ 中执行 `int64_t += double`，结果截断为 int64_t，与 PHP 行为不同（PHP 中变量会变为 float）。这是 `use native_types` 有意为之的语义。
+> **注意**：原生变量在运算中**不会改变存储类型**。例如 `Int += Float` 的结果仍是
+> Int。这种固定类型行为现在是默认规则；需要动态整数扩展时应显式选择
+> `use varint_types` 或 `std::any()`。
 
 ### 规则三：高精度类型的安全提升
 
@@ -560,15 +570,15 @@ $f = $d + $e;   // Int + Int → int64_t 加法
 `+=`、`-=`、`*=`、`/=`、`%=` 等复合赋值运算符遵循相同的类型提升规则，但 RHS 会被转换为 LHS 变量的类型。若 LHS 为 Var，RHS 保持原类型（Var 的 `operator+=` 接管）；若 LHS 为原生类型，RHS 显式转换为该类型。
 
 ```php
-$a = 10;        // Var
+use varint_types;
+$a = 10;        // 该文件启用 varint_types，因此为 Var
 $a += 2.5;      // Var::operator+=(float) → ZendVM → $a 变为 float(12.5)
 
-use native_types;
-$b = 10;        // php::Int
+$b = std::int(10); // varint_types 文件中显式声明 php::Int
 $b += 2.5;      // int64_t += double → C++ 隐式截断 → $b = 12 (Int)
 ```
 
 ---
 
-**最后更新**: 2026 年 5 月 26 日  
-**适用版本**: PHP AOT Compiler v1.x
+**最后更新**: 2026 年 9 月 6 日
+**适用版本**: TypePHP 0.8+
diff --git a/docs/zh-cn/STD_CONTAINERS.md b/docs/zh-cn/STD_CONTAINERS.md
index 50fd3592..75303383 100644
--- a/docs/zh-cn/STD_CONTAINERS.md
+++ b/docs/zh-cn/STD_CONTAINERS.md
@@ -510,8 +510,6 @@ sec: 67.638107061386108
 ### std::array
 测试代码：
 ```php
-use native_types;
-
 function main(int $argc, array $argv): void
 {
     $u = (int)$argv[2];
diff --git a/docs/zh-cn/UNIVERSAL_METHODS.md b/docs/zh-cn/UNIVERSAL_METHODS.md
index 34ce4814..cc368c01 100644
--- a/docs/zh-cn/UNIVERSAL_METHODS.md
+++ b/docs/zh-cn/UNIVERSAL_METHODS.md
@@ -917,8 +917,6 @@ echo $x->contains("test");
 
 ```php
 <?php
-declare(strict_types=1);
-use native_types;
 
 /**
  * 扩展方法：判断 Int 是否为素数
@@ -974,8 +972,6 @@ function main(): void {
 
 ```php
 <?php
-declare(strict_types=1);
-use native_types;
 
 function main(): void {
     $raw = "  <h1>Hello World!</h1>  \n";
@@ -998,8 +994,6 @@ function main(): void {
 
 ```php
 <?php
-declare(strict_types=1);
-use native_types;
 
 function main(): void {
     $data = [5, 2, 8, 1, 9, 3, 7];
@@ -1034,8 +1028,6 @@ function main(): void {
 
 ```php
 <?php
-declare(strict_types=1);
-use native_types;
 
 function main(): void {
     // 大整数阶乘（使用复合赋值，更简洁）
@@ -1072,8 +1064,6 @@ function main(): void {
 
 ```php
 <?php
-declare(strict_types=1);
-use native_types;
 
 function main(): void {
     // 写入文件
diff --git a/examples/debug/prop.php b/examples/debug/prop.php
index ffc20ba1..456d7823 100644
--- a/examples/debug/prop.php
+++ b/examples/debug/prop.php
@@ -1,5 +1,4 @@
 <?php
-declare(strict_types=1);
 class Data {
     public int $value = 0;
     public bool $bv = true;
diff --git a/examples/high-precision.php b/examples/high-precision.php
index 34841d9b..70951bab 100644
--- a/examples/high-precision.php
+++ b/examples/high-precision.php
@@ -1,5 +1,4 @@
 <?php
-declare(strict_types=1);
 function main(): void
 {
     $integer = std::bigInt("123456789012345678901234567890");
diff --git a/examples/lib-demo/php-src/logic.php b/examples/lib-demo/php-src/logic.php
index cf0822e4..cf391479 100644
--- a/examples/lib-demo/php-src/logic.php
+++ b/examples/lib-demo/php-src/logic.php
@@ -1,6 +1,5 @@
 <?php
 
-declare(strict_types=1);
 
 function demo_add(int $a, int $b): int
 {
diff --git a/examples/minecraft-demo/main.php b/examples/minecraft-demo/main.php
index 0c595e20..486ce638 100644
--- a/examples/minecraft-demo/main.php
+++ b/examples/minecraft-demo/main.php
@@ -1,6 +1,5 @@
 <?php
 
-declare(strict_types=1);
 
 const BLOCK_GRASS = 1;
 const BLOCK_SAND = 2;
diff --git a/examples/minecraft-godot/php-src/world.php b/examples/minecraft-godot/php-src/world.php
index 00c51eee..9bace567 100644
--- a/examples/minecraft-godot/php-src/world.php
+++ b/examples/minecraft-godot/php-src/world.php
@@ -1,6 +1,5 @@
 <?php
 
-declare(strict_types=1);
 
 const DEMO_BLOCK_GRASS = 1;
 const DEMO_BLOCK_SAND = 2;
diff --git a/examples/ocean-demo/main.php b/examples/ocean-demo/main.php
index 65b712e1..14a9312f 100644
--- a/examples/ocean-demo/main.php
+++ b/examples/ocean-demo/main.php
@@ -1,6 +1,5 @@
 <?php
 
-declare(strict_types=1);
 
 const KEY_W = 0x57;
 const KEY_A = 0x41;
diff --git a/examples/ocean-godot/php-src/ocean.php b/examples/ocean-godot/php-src/ocean.php
index 00ab5e1e..0e28bf14 100644
--- a/examples/ocean-godot/php-src/ocean.php
+++ b/examples/ocean-godot/php-src/ocean.php
@@ -1,6 +1,5 @@
 <?php
 
-declare(strict_types=1);
 
 const OCEAN_WEATHER_SUNNY = 0;
 const OCEAN_WEATHER_CLOUDY = 1;
diff --git a/examples/onepiece-doudizhu-win32/php-src/doudizhu/Ai.php b/examples/onepiece-doudizhu-win32/php-src/doudizhu/Ai.php
index 3ec67268..d8589740 100644
--- a/examples/onepiece-doudizhu-win32/php-src/doudizhu/Ai.php
+++ b/examples/onepiece-doudizhu-win32/php-src/doudizhu/Ai.php
@@ -1,6 +1,5 @@
 <?php
 
-declare(strict_types=1);
 
 namespace Yangweijie\Ui2\Games\OnePieceDoudizhu;
 
diff --git a/examples/onepiece-doudizhu-win32/php-src/doudizhu/Card.php b/examples/onepiece-doudizhu-win32/php-src/doudizhu/Card.php
index 9c706724..66d248db 100644
--- a/examples/onepiece-doudizhu-win32/php-src/doudizhu/Card.php
+++ b/examples/onepiece-doudizhu-win32/php-src/doudizhu/Card.php
@@ -1,6 +1,5 @@
 <?php
 
-declare(strict_types=1);
 
 namespace Yangweijie\Ui2\Games\OnePieceDoudizhu;
 
diff --git a/examples/onepiece-doudizhu-win32/php-src/doudizhu/Character.php b/examples/onepiece-doudizhu-win32/php-src/doudizhu/Character.php
index 37c09eb0..d23509fe 100644
--- a/examples/onepiece-doudizhu-win32/php-src/doudizhu/Character.php
+++ b/examples/onepiece-doudizhu-win32/php-src/doudizhu/Character.php
@@ -1,6 +1,5 @@
 <?php
 
-declare(strict_types=1);
 
 namespace Yangweijie\Ui2\Games\OnePieceDoudizhu;
 
diff --git a/examples/onepiece-doudizhu-win32/php-src/doudizhu/Combo.php b/examples/onepiece-doudizhu-win32/php-src/doudizhu/Combo.php
index 2a8ef633..2a19762b 100644
--- a/examples/onepiece-doudizhu-win32/php-src/doudizhu/Combo.php
+++ b/examples/onepiece-doudizhu-win32/php-src/doudizhu/Combo.php
@@ -1,6 +1,5 @@
 <?php
 
-declare(strict_types=1);
 
 namespace Yangweijie\Ui2\Games\OnePieceDoudizhu;
 
diff --git a/examples/onepiece-doudizhu-win32/php-src/doudizhu/Deck.php b/examples/onepiece-doudizhu-win32/php-src/doudizhu/Deck.php
index d941a24b..a15f9165 100644
--- a/examples/onepiece-doudizhu-win32/php-src/doudizhu/Deck.php
+++ b/examples/onepiece-doudizhu-win32/php-src/doudizhu/Deck.php
@@ -1,6 +1,5 @@
 <?php
 
-declare(strict_types=1);
 
 namespace Yangweijie\Ui2\Games\OnePieceDoudizhu;
 
diff --git a/examples/onepiece-doudizhu-win32/php-src/doudizhu/Faction.php b/examples/onepiece-doudizhu-win32/php-src/doudizhu/Faction.php
index 81ab4763..320080de 100644
--- a/examples/onepiece-doudizhu-win32/php-src/doudizhu/Faction.php
+++ b/examples/onepiece-doudizhu-win32/php-src/doudizhu/Faction.php
@@ -1,6 +1,5 @@
 <?php
 
-declare(strict_types=1);
 
 namespace Yangweijie\Ui2\Games\OnePieceDoudizhu;
 
diff --git a/examples/onepiece-doudizhu-win32/php-src/doudizhu/Game.php b/examples/onepiece-doudizhu-win32/php-src/doudizhu/Game.php
index 6686fbc2..4bd80fc9 100644
--- a/examples/onepiece-doudizhu-win32/php-src/doudizhu/Game.php
+++ b/examples/onepiece-doudizhu-win32/php-src/doudizhu/Game.php
@@ -1,6 +1,5 @@
 <?php
 
-declare(strict_types=1);
 
 namespace Yangweijie\Ui2\Games\OnePieceDoudizhu;
 
diff --git a/examples/onepiece-doudizhu-win32/php-src/doudizhu/GameController.php b/examples/onepiece-doudizhu-win32/php-src/doudizhu/GameController.php
index 464ed182..5eb4fd53 100644
--- a/examples/onepiece-doudizhu-win32/php-src/doudizhu/GameController.php
+++ b/examples/onepiece-doudizhu-win32/php-src/doudizhu/GameController.php
@@ -1,6 +1,5 @@
 <?php
 
-declare(strict_types=1);
 
 namespace Yangweijie\Ui2\Games\OnePieceDoudizhu;
 
diff --git a/examples/onepiece-doudizhu-win32/php-src/doudizhu/MoveGenerator.php b/examples/onepiece-doudizhu-win32/php-src/doudizhu/MoveGenerator.php
index c5358f41..88927012 100644
--- a/examples/onepiece-doudizhu-win32/php-src/doudizhu/MoveGenerator.php
+++ b/examples/onepiece-doudizhu-win32/php-src/doudizhu/MoveGenerator.php
@@ -1,6 +1,5 @@
 <?php
 
-declare(strict_types=1);
 
 namespace Yangweijie\Ui2\Games\OnePieceDoudizhu;
 
diff --git a/examples/onepiece-doudizhu-win32/php-src/doudizhu/PlayerState.php b/examples/onepiece-doudizhu-win32/php-src/doudizhu/PlayerState.php
index dbb84614..4d3e82f9 100644
--- a/examples/onepiece-doudizhu-win32/php-src/doudizhu/PlayerState.php
+++ b/examples/onepiece-doudizhu-win32/php-src/doudizhu/PlayerState.php
@@ -1,6 +1,5 @@
 <?php
 
-declare(strict_types=1);
 
 namespace Yangweijie\Ui2\Games\OnePieceDoudizhu;
 
diff --git a/examples/onepiece-doudizhu-win32/php-src/doudizhu/Render.php b/examples/onepiece-doudizhu-win32/php-src/doudizhu/Render.php
index a5624ead..637cf67c 100644
--- a/examples/onepiece-doudizhu-win32/php-src/doudizhu/Render.php
+++ b/examples/onepiece-doudizhu-win32/php-src/doudizhu/Render.php
@@ -1,6 +1,5 @@
 <?php
 
-declare(strict_types=1);
 
 namespace Yangweijie\Ui2\Games\OnePieceDoudizhu;
 
diff --git a/examples/onepiece-doudizhu-win32/php-src/doudizhu/Skill.php b/examples/onepiece-doudizhu-win32/php-src/doudizhu/Skill.php
index bf77b33c..fa21bdad 100644
--- a/examples/onepiece-doudizhu-win32/php-src/doudizhu/Skill.php
+++ b/examples/onepiece-doudizhu-win32/php-src/doudizhu/Skill.php
@@ -1,6 +1,5 @@
 <?php
 
-declare(strict_types=1);
 
 namespace Yangweijie\Ui2\Games\OnePieceDoudizhu;
 
diff --git a/examples/onepiece-doudizhu-win32/php-src/doudizhu/Sound.php b/examples/onepiece-doudizhu-win32/php-src/doudizhu/Sound.php
index 1505cea9..68b6e110 100644
--- a/examples/onepiece-doudizhu-win32/php-src/doudizhu/Sound.php
+++ b/examples/onepiece-doudizhu-win32/php-src/doudizhu/Sound.php
@@ -1,6 +1,5 @@
 <?php
 
-declare(strict_types=1);
 
 namespace Yangweijie\Ui2\Games\OnePieceDoudizhu;
 
diff --git a/examples/void.php b/examples/void.php
index 9384b8dd..88ce9ca4 100644
--- a/examples/void.php
+++ b/examples/void.php
@@ -1,5 +1,4 @@
 <?php
-declare(strict_types=1);
 function main() {
 	$v = usleep(111);
 var_dump($v);
diff --git a/examples/wasm-hello/src/WasiDemo.php b/examples/wasm-hello/src/WasiDemo.php
index d94f1c5d..e7339856 100644
--- a/examples/wasm-hello/src/WasiDemo.php
+++ b/examples/wasm-hello/src/WasiDemo.php
@@ -1,5 +1,4 @@
 <?php
-declare(strict_types=1);
 
 
 final class WasiDemo
diff --git a/examples/wasm-hello/src/main.php b/examples/wasm-hello/src/main.php
index 041729b0..0e4acad7 100644
--- a/examples/wasm-hello/src/main.php
+++ b/examples/wasm-hello/src/main.php
@@ -1,6 +1,5 @@
 <?php
 
-declare(strict_types=1);
 
 #[WasmExport(name: 'get-demo-report')]
 function getDemoReport(string $argumentsJson, string $greeting, string $stdin): string
diff --git a/phpunit/code/bigfloat-unsupported-mod.php b/phpunit/code/bigfloat-unsupported-mod.php
index b303abe9..6b25ae13 100644
--- a/phpunit/code/bigfloat-unsupported-mod.php
+++ b/phpunit/code/bigfloat-unsupported-mod.php
@@ -1,5 +1,4 @@
 <?php
-declare(strict_types=1);
 function main()
 {
     $a = std::bigFloat("3.14");
diff --git a/phpunit/code/bigfloat-unsupported-shift.php b/phpunit/code/bigfloat-unsupported-shift.php
index 14104493..5b4087e7 100644
--- a/phpunit/code/bigfloat-unsupported-shift.php
+++ b/phpunit/code/bigfloat-unsupported-shift.php
@@ -1,5 +1,4 @@
 <?php
-declare(strict_types=1);
 function main()
 {
     $a = std::bigFloat("10.0");
diff --git a/phpunit/code/bigint-post-inc.php b/phpunit/code/bigint-post-inc.php
index 11b36c8d..f14db20b 100644
--- a/phpunit/code/bigint-post-inc.php
+++ b/phpunit/code/bigint-post-inc.php
@@ -1,5 +1,4 @@
 <?php
-declare(strict_types=1);
 function main()
 {
     $a = std::bigInt(100);
diff --git a/phpunit/code/bigint-pre-inc.php b/phpunit/code/bigint-pre-inc.php
index 46bbf83d..91b5d1dc 100644
--- a/phpunit/code/bigint-pre-inc.php
+++ b/phpunit/code/bigint-pre-inc.php
@@ -1,5 +1,4 @@
 <?php
-declare(strict_types=1);
 function main()
 {
     $a = std::bigInt(100);
diff --git a/phpunit/code/closure/use-reference-capture.php b/phpunit/code/closure/use-reference-capture.php
index 899330f5..64b5c260 100644
--- a/phpunit/code/closure/use-reference-capture.php
+++ b/phpunit/code/closure/use-reference-capture.php
@@ -1,7 +1,7 @@
 <?php
 function main(): void
 {
-    $arr = [1, 2];
+    $arr = std::any([1, 2]);
     $copy = function () use ($arr) {
         $arr[] = 3;
         return $arr;
@@ -14,7 +14,7 @@ function main(): void
     };
     $ref();
 
-    $value = 'old';
+    $value = std::any('old');
     $returnCapturedRef = function () use (&$value) {
         return $value;
     };
diff --git a/phpunit/code/constant-overflow-native-add.php b/phpunit/code/constant-overflow-native-add.php
index f9a954ed..1325736c 100644
--- a/phpunit/code/constant-overflow-native-add.php
+++ b/phpunit/code/constant-overflow-native-add.php
@@ -1,5 +1,4 @@
 <?php
-declare(strict_types=1);
 
 function main(): void
 {
diff --git a/phpunit/code/constant-overflow-native-div-subtree.php b/phpunit/code/constant-overflow-native-div-subtree.php
index 8d8d9f4d..5b797c95 100644
--- a/phpunit/code/constant-overflow-native-div-subtree.php
+++ b/phpunit/code/constant-overflow-native-div-subtree.php
@@ -1,5 +1,4 @@
 <?php
-declare(strict_types=1);
 
 function main(): void
 {
diff --git a/phpunit/code/constant-overflow-native-div.php b/phpunit/code/constant-overflow-native-div.php
index a3350501..b5b2548d 100644
--- a/phpunit/code/constant-overflow-native-div.php
+++ b/phpunit/code/constant-overflow-native-div.php
@@ -1,5 +1,4 @@
 <?php
-declare(strict_types=1);
 
 function main(): void
 {
diff --git a/phpunit/code/constant-overflow-native-mod.php b/phpunit/code/constant-overflow-native-mod.php
index 8357481e..f499eabe 100644
--- a/phpunit/code/constant-overflow-native-mod.php
+++ b/phpunit/code/constant-overflow-native-mod.php
@@ -1,5 +1,4 @@
 <?php
-declare(strict_types=1);
 
 function main(): void
 {
diff --git a/phpunit/code/constant-overflow-native-mul.php b/phpunit/code/constant-overflow-native-mul.php
index 242e5dfc..19ad0dc3 100644
--- a/phpunit/code/constant-overflow-native-mul.php
+++ b/phpunit/code/constant-overflow-native-mul.php
@@ -1,5 +1,4 @@
 <?php
-declare(strict_types=1);
 
 function main(): void
 {
diff --git a/phpunit/code/constant-overflow-native-neg.php b/phpunit/code/constant-overflow-native-neg.php
index c67e2b6b..8bbe01ff 100644
--- a/phpunit/code/constant-overflow-native-neg.php
+++ b/phpunit/code/constant-overflow-native-neg.php
@@ -1,5 +1,4 @@
 <?php
-declare(strict_types=1);
 
 function main(): void
 {
diff --git a/phpunit/code/constant-overflow-native-nested-add.php b/phpunit/code/constant-overflow-native-nested-add.php
index 284bdfc8..c0b3e75e 100644
--- a/phpunit/code/constant-overflow-native-nested-add.php
+++ b/phpunit/code/constant-overflow-native-nested-add.php
@@ -1,5 +1,4 @@
 <?php
-declare(strict_types=1);
 
 function main(): void
 {
diff --git a/phpunit/code/constant-overflow-native-nested-div.php b/phpunit/code/constant-overflow-native-nested-div.php
index 49695522..96ca5039 100644
--- a/phpunit/code/constant-overflow-native-nested-div.php
+++ b/phpunit/code/constant-overflow-native-nested-div.php
@@ -1,5 +1,4 @@
 <?php
-declare(strict_types=1);
 
 function main(): void
 {
diff --git a/phpunit/code/constant-overflow-native-nested-mod.php b/phpunit/code/constant-overflow-native-nested-mod.php
index cf97c890..4ac8541c 100644
--- a/phpunit/code/constant-overflow-native-nested-mod.php
+++ b/phpunit/code/constant-overflow-native-nested-mod.php
@@ -1,5 +1,4 @@
 <?php
-declare(strict_types=1);
 
 function main(): void
 {
diff --git a/phpunit/code/constant-overflow-native-nested-zero.php b/phpunit/code/constant-overflow-native-nested-zero.php
index 7639b3fc..9618a274 100644
--- a/phpunit/code/constant-overflow-native-nested-zero.php
+++ b/phpunit/code/constant-overflow-native-nested-zero.php
@@ -1,5 +1,4 @@
 <?php
-declare(strict_types=1);
 
 function main(): void
 {
diff --git a/phpunit/code/constant-overflow-native-nonconstant.php b/phpunit/code/constant-overflow-native-nonconstant.php
index c75da045..e65a79e9 100644
--- a/phpunit/code/constant-overflow-native-nonconstant.php
+++ b/phpunit/code/constant-overflow-native-nonconstant.php
@@ -1,5 +1,4 @@
 <?php
-declare(strict_types=1);
 
 function addToMaximum(int $value): int
 {
diff --git a/phpunit/code/constant-overflow-native-ok.php b/phpunit/code/constant-overflow-native-ok.php
index c811ee52..18170e54 100644
--- a/phpunit/code/constant-overflow-native-ok.php
+++ b/phpunit/code/constant-overflow-native-ok.php
@@ -1,5 +1,4 @@
 <?php
-declare(strict_types=1);
 
 function main(): void
 {
diff --git a/phpunit/code/constant-overflow-native-sub.php b/phpunit/code/constant-overflow-native-sub.php
index 47bc6a75..056ed992 100644
--- a/phpunit/code/constant-overflow-native-sub.php
+++ b/phpunit/code/constant-overflow-native-sub.php
@@ -1,5 +1,4 @@
 <?php
-declare(strict_types=1);
 
 function main(): void
 {
diff --git a/phpunit/code/constant-overflow-warning.php b/phpunit/code/constant-overflow-warning.php
index d293beae..7ce228aa 100644
--- a/phpunit/code/constant-overflow-warning.php
+++ b/phpunit/code/constant-overflow-warning.php
@@ -1,7 +1,6 @@
 <?php
 use varint_types;
 
-declare(strict_types=1);
 
 function main(): void
 {
diff --git a/phpunit/code/count-literal-fold-unsafe.php b/phpunit/code/count-literal-fold-unsafe.php
index d78a4906..fed64526 100644
--- a/phpunit/code/count-literal-fold-unsafe.php
+++ b/phpunit/code/count-literal-fold-unsafe.php
@@ -31,7 +31,7 @@ function main(): void
     $rest = [1, 2, 3, 4, 5];
     $i = 0;
     $plain = 1;
-    $ref = 1;
+    $ref = std::any(1);
     $object = new MagicHolder();
 
     echo count([bump(), bump()]), "\n";
diff --git a/phpunit/code/decimal-pre-dec.php b/phpunit/code/decimal-pre-dec.php
index 3c600d65..323b5282 100644
--- a/phpunit/code/decimal-pre-dec.php
+++ b/phpunit/code/decimal-pre-dec.php
@@ -1,5 +1,4 @@
 <?php
-declare(strict_types=1);
 function main()
 {
     $a = std::decimal("100");
diff --git a/phpunit/code/decimal-unsupported-bitand.php b/phpunit/code/decimal-unsupported-bitand.php
index 50387040..f2f48582 100644
--- a/phpunit/code/decimal-unsupported-bitand.php
+++ b/phpunit/code/decimal-unsupported-bitand.php
@@ -1,5 +1,4 @@
 <?php
-declare(strict_types=1);
 function main()
 {
     $a = std::decimal("3.14");
diff --git a/phpunit/code/decimal-unsupported-bitor.php b/phpunit/code/decimal-unsupported-bitor.php
index b58e3a65..4f8bceca 100644
--- a/phpunit/code/decimal-unsupported-bitor.php
+++ b/phpunit/code/decimal-unsupported-bitor.php
@@ -1,5 +1,4 @@
 <?php
-declare(strict_types=1);
 function main()
 {
     $a = std::decimal("100");
diff --git a/phpunit/code/fixed-reference-argument.php b/phpunit/code/fixed-reference-argument.php
new file mode 100644
index 00000000..7ec2bb4e
--- /dev/null
+++ b/phpunit/code/fixed-reference-argument.php
@@ -0,0 +1,9 @@
+<?php
+
+function fixedReferenceArgumentTarget(string &$value): void {}
+
+function fixedReferenceArgument(): void
+{
+    $value = 'fixed';
+    fixedReferenceArgumentTarget($value);
+}
diff --git a/phpunit/code/fixed-reference-array.php b/phpunit/code/fixed-reference-array.php
new file mode 100644
index 00000000..67a3b724
--- /dev/null
+++ b/phpunit/code/fixed-reference-array.php
@@ -0,0 +1,8 @@
+<?php
+
+function fixedReferenceArray(): void
+{
+    $value = [];
+    $closure = static function () use (&$value): void {};
+    $closure();
+}
diff --git a/phpunit/code/fixed-reference-assignment.php b/phpunit/code/fixed-reference-assignment.php
new file mode 100644
index 00000000..c15d0deb
--- /dev/null
+++ b/phpunit/code/fixed-reference-assignment.php
@@ -0,0 +1,7 @@
+<?php
+
+function fixedReferenceAssignment(): void
+{
+    $value = [];
+    $reference =& $value;
+}
diff --git a/phpunit/code/fixed-reference-explicit-any.php b/phpunit/code/fixed-reference-explicit-any.php
new file mode 100644
index 00000000..d15211b2
--- /dev/null
+++ b/phpunit/code/fixed-reference-explicit-any.php
@@ -0,0 +1,11 @@
+<?php
+
+function fixedReferenceExplicitAny(): void
+{
+    $value = std::any('fixed');
+    $closure = static function () use (&$value): void {
+        $value = [];
+    };
+    $closure();
+    $array = $value->toArray();
+}
diff --git a/phpunit/code/fixed-reference-generic-object.php b/phpunit/code/fixed-reference-generic-object.php
new file mode 100644
index 00000000..dfc3769d
--- /dev/null
+++ b/phpunit/code/fixed-reference-generic-object.php
@@ -0,0 +1,13 @@
+<?php
+
+function fixedReferenceGenericObjectValue(): object
+{
+    return new stdClass();
+}
+
+function fixedReferenceGenericObject(): void
+{
+    $value = fixedReferenceGenericObjectValue();
+    $closure = static function () use (&$value): void {};
+    $closure();
+}
diff --git a/phpunit/code/fixed-reference-object.php b/phpunit/code/fixed-reference-object.php
new file mode 100644
index 00000000..985e5441
--- /dev/null
+++ b/phpunit/code/fixed-reference-object.php
@@ -0,0 +1,10 @@
+<?php
+
+final class FixedReferenceObjectValue {}
+
+function fixedReferenceObject(): void
+{
+    $value = new FixedReferenceObjectValue();
+    $closure = static function () use (&$value): void {};
+    $closure();
+}
diff --git a/phpunit/code/fixed-reference-return.php b/phpunit/code/fixed-reference-return.php
new file mode 100644
index 00000000..c53e3421
--- /dev/null
+++ b/phpunit/code/fixed-reference-return.php
@@ -0,0 +1,7 @@
+<?php
+
+function &fixedReferenceReturn(): mixed
+{
+    $value = 'fixed';
+    return $value;
+}
diff --git a/phpunit/code/fixed-reference-static.php b/phpunit/code/fixed-reference-static.php
new file mode 100644
index 00000000..bf0f20e8
--- /dev/null
+++ b/phpunit/code/fixed-reference-static.php
@@ -0,0 +1,8 @@
+<?php
+
+function fixedReferenceStatic(): void
+{
+    static $value = 'fixed';
+    $closure = static function () use (&$value): void {};
+    $closure();
+}
diff --git a/phpunit/code/fixed-reference-std-container.php b/phpunit/code/fixed-reference-std-container.php
new file mode 100644
index 00000000..6f24df53
--- /dev/null
+++ b/phpunit/code/fixed-reference-std-container.php
@@ -0,0 +1,8 @@
+<?php
+
+function fixedReferenceStdContainer(): void
+{
+    $value = std::vector(Type::Int);
+    $closure = static function () use (&$value): void {};
+    $closure();
+}
diff --git a/phpunit/code/fixed-reference-stream.php b/phpunit/code/fixed-reference-stream.php
new file mode 100644
index 00000000..2fe5018f
--- /dev/null
+++ b/phpunit/code/fixed-reference-stream.php
@@ -0,0 +1,8 @@
+<?php
+
+function fixedReferenceStream(): void
+{
+    $value = fopen(__FILE__, 'r');
+    $closure = static function () use (&$value): void {};
+    $closure();
+}
diff --git a/phpunit/code/fixed-reference-string.php b/phpunit/code/fixed-reference-string.php
new file mode 100644
index 00000000..d66dbeae
--- /dev/null
+++ b/phpunit/code/fixed-reference-string.php
@@ -0,0 +1,8 @@
+<?php
+
+function fixedReferenceString(): void
+{
+    $value = 'fixed';
+    $closure = static function () use (&$value): void {};
+    $closure();
+}
diff --git a/phpunit/code/fixed-reference-to-ref.php b/phpunit/code/fixed-reference-to-ref.php
new file mode 100644
index 00000000..f3eb7f73
--- /dev/null
+++ b/phpunit/code/fixed-reference-to-ref.php
@@ -0,0 +1,9 @@
+<?php
+
+function fixedReferenceToRefTarget(mixed &$value): void {}
+
+function fixedReferenceToRef(): void
+{
+    $value = [];
+    fixedReferenceToRefTarget($value->toRef());
+}
diff --git a/phpunit/code/override_byref_return_added.php b/phpunit/code/override_byref_return_added.php
index dc0c5883..1cd5b659 100644
--- a/phpunit/code/override_byref_return_added.php
+++ b/phpunit/code/override_byref_return_added.php
@@ -11,7 +11,8 @@ class B extends A
 {
     public function &f(): array
     {
-        static $a = [];
+        static $a;
+        $a ??= [];
         return $a;
     }
 }
diff --git a/phpunit/code/override_byref_return_dropped.php b/phpunit/code/override_byref_return_dropped.php
index b2acb90e..00b6c020 100644
--- a/phpunit/code/override_byref_return_dropped.php
+++ b/phpunit/code/override_byref_return_dropped.php
@@ -3,7 +3,8 @@ class A
 {
     public function &f(): array
     {
-        static $a = [];
+        static $a;
+        $a ??= [];
         return $a;
     }
 }
diff --git a/phpunit/code/preprocessor/namespace_ending_comment_unbracketed.php b/phpunit/code/preprocessor/namespace_ending_comment_unbracketed.php
index 7ad8b333..13a3233c 100644
--- a/phpunit/code/preprocessor/namespace_ending_comment_unbracketed.php
+++ b/phpunit/code/preprocessor/namespace_ending_comment_unbracketed.php
@@ -1,6 +1,5 @@
 <?php
 
-declare(strict_types=1);
 
 namespace NamespaceEndingComment;
 
diff --git a/phpunit/code/re-assign-obj-to-str.php b/phpunit/code/re-assign-obj-to-str.php
index 25a71a7b..a787907d 100644
--- a/phpunit/code/re-assign-obj-to-str.php
+++ b/phpunit/code/re-assign-obj-to-str.php
@@ -1,5 +1,4 @@
 <?php
-declare(strict_types=1);
 function main()
 {
     $x = "hello";
diff --git a/phpunit/code/shift-boundary-native-neg-left.php b/phpunit/code/shift-boundary-native-neg-left.php
index 13f897d8..d5b44456 100644
--- a/phpunit/code/shift-boundary-native-neg-left.php
+++ b/phpunit/code/shift-boundary-native-neg-left.php
@@ -1,5 +1,4 @@
 <?php
-declare(strict_types=1);
 
 function main(): void
 {
diff --git a/phpunit/code/shift-boundary-native-neg-right.php b/phpunit/code/shift-boundary-native-neg-right.php
index 46562f44..6cadf8d2 100644
--- a/phpunit/code/shift-boundary-native-neg-right.php
+++ b/phpunit/code/shift-boundary-native-neg-right.php
@@ -1,5 +1,4 @@
 <?php
-declare(strict_types=1);
 
 function main(): void
 {
diff --git a/phpunit/code/shift-boundary-native-negative.php b/phpunit/code/shift-boundary-native-negative.php
index 873a47a2..007d024d 100644
--- a/phpunit/code/shift-boundary-native-negative.php
+++ b/phpunit/code/shift-boundary-native-negative.php
@@ -1,5 +1,4 @@
 <?php
-declare(strict_types=1);
 
 function main(): void
 {
diff --git a/phpunit/code/shift-boundary-native-nested-neg-right.php b/phpunit/code/shift-boundary-native-nested-neg-right.php
index 9f86e5c2..7a171b89 100644
--- a/phpunit/code/shift-boundary-native-nested-neg-right.php
+++ b/phpunit/code/shift-boundary-native-nested-neg-right.php
@@ -1,5 +1,4 @@
 <?php
-declare(strict_types=1);
 
 function main(): void
 {
diff --git a/phpunit/code/shift-boundary-native-nested-overflow.php b/phpunit/code/shift-boundary-native-nested-overflow.php
index 239c84f9..75220585 100644
--- a/phpunit/code/shift-boundary-native-nested-overflow.php
+++ b/phpunit/code/shift-boundary-native-nested-overflow.php
@@ -1,5 +1,4 @@
 <?php
-declare(strict_types=1);
 
 function main(): void
 {
diff --git a/phpunit/code/shift-boundary-native-ok.php b/phpunit/code/shift-boundary-native-ok.php
index a3638f79..45eac84e 100644
--- a/phpunit/code/shift-boundary-native-ok.php
+++ b/phpunit/code/shift-boundary-native-ok.php
@@ -1,5 +1,4 @@
 <?php
-declare(strict_types=1);
 
 function main(): void
 {
diff --git a/phpunit/code/shift-boundary-native-overflow.php b/phpunit/code/shift-boundary-native-overflow.php
index 698d08cb..f4a6e853 100644
--- a/phpunit/code/shift-boundary-native-overflow.php
+++ b/phpunit/code/shift-boundary-native-overflow.php
@@ -1,5 +1,4 @@
 <?php
-declare(strict_types=1);
 
 function main(): void
 {
diff --git a/phpunit/code/shift-boundary-native-sign-bit.php b/phpunit/code/shift-boundary-native-sign-bit.php
index ea80b5b5..fead2755 100644
--- a/phpunit/code/shift-boundary-native-sign-bit.php
+++ b/phpunit/code/shift-boundary-native-sign-bit.php
@@ -1,5 +1,4 @@
 <?php
-declare(strict_types=1);
 
 function main(): void
 {
diff --git a/phpunit/code/shift-boundary-native-wrapped-overflow.php b/phpunit/code/shift-boundary-native-wrapped-overflow.php
index 844e6f5e..e61344cd 100644
--- a/phpunit/code/shift-boundary-native-wrapped-overflow.php
+++ b/phpunit/code/shift-boundary-native-wrapped-overflow.php
@@ -1,5 +1,4 @@
 <?php
-declare(strict_types=1);
 
 function main(): void
 {
diff --git a/phpunit/code/shift-boundary-warning.php b/phpunit/code/shift-boundary-warning.php
index b9df192a..d68eaf78 100644
--- a/phpunit/code/shift-boundary-warning.php
+++ b/phpunit/code/shift-boundary-warning.php
@@ -1,7 +1,6 @@
 <?php
 use varint_types;
 
-declare(strict_types=1);
 
 function main(): void
 {
diff --git a/phpunit/code/trait-aliased-constructor-parent-call.php b/phpunit/code/trait-aliased-constructor-parent-call.php
index 42cd4a40..e7cf1e77 100644
--- a/phpunit/code/trait-aliased-constructor-parent-call.php
+++ b/phpunit/code/trait-aliased-constructor-parent-call.php
@@ -1,6 +1,5 @@
 <?php
 
-declare(strict_types=1);
 
 class Base
 {
diff --git a/phpunit/code/trait_constructor_conflict.php b/phpunit/code/trait_constructor_conflict.php
index 695eee02..3477268a 100644
--- a/phpunit/code/trait_constructor_conflict.php
+++ b/phpunit/code/trait_constructor_conflict.php
@@ -1,6 +1,5 @@
 <?php
 
-declare(strict_types=1);
 
 trait TraitA
 {
diff --git a/phpunit/code/trait_constructor_private.php b/phpunit/code/trait_constructor_private.php
index 2dc1db14..b847fc12 100644
--- a/phpunit/code/trait_constructor_private.php
+++ b/phpunit/code/trait_constructor_private.php
@@ -1,6 +1,5 @@
 <?php
 
-declare(strict_types=1);
 
 trait TestTrait
 {
diff --git a/phpunit/code/trait_constructor_protected.php b/phpunit/code/trait_constructor_protected.php
index be585075..d74221d8 100644
--- a/phpunit/code/trait_constructor_protected.php
+++ b/phpunit/code/trait_constructor_protected.php
@@ -1,6 +1,5 @@
 <?php
 
-declare(strict_types=1);
 
 trait TestTrait
 {
diff --git a/phpunit/src/AssignTest.php b/phpunit/src/AssignTest.php
index d08be448..525d78dc 100644
--- a/phpunit/src/AssignTest.php
+++ b/phpunit/src/AssignTest.php
@@ -171,7 +171,7 @@ class AssignTest extends \BaseTest
 
     public function testStrictTypesZeroNotAllowed()
     {
-        $this->exec("declare(strict_types=0) is not allowed, only strict_types=1 is supported", 'declare-strict-types-zero.php');
+        $this->exec("TypePHP always uses strict types; declare(strict_types=0) is not allowed", 'declare-strict-types-zero.php');
     }
 
     /** @dataProvider nativeScalarArrayDimWriteProvider */
diff --git a/phpunit/src/ExitCodeTest.php b/phpunit/src/ExitCodeTest.php
index cd54fec1..7d5dfbfd 100644
--- a/phpunit/src/ExitCodeTest.php
+++ b/phpunit/src/ExitCodeTest.php
@@ -35,7 +35,6 @@ class ExitCodeTest extends TestCase
         $exitCode = $this->buildAndRun(<<<'PHP'
 <?php
 
-declare(strict_types=1);
 
 function main(): void
 {
@@ -51,7 +50,6 @@ PHP);
         $exitCode = $this->buildAndRun(<<<'PHP'
 <?php
 
-declare(strict_types=1);
 
 function main(): void
 {
@@ -67,7 +65,6 @@ PHP);
         $exitCode = $this->buildAndRun(<<<'PHP'
 <?php
 
-declare(strict_types=1);
 
 function main(): void
 {
@@ -83,7 +80,6 @@ PHP);
         $exitCode = $this->buildAndRun(<<<'PHP'
 <?php
 
-declare(strict_types=1);
 
 function main(): void
 {
diff --git a/phpunit/src/FixedReferenceStorageTest.php b/phpunit/src/FixedReferenceStorageTest.php
new file mode 100644
index 00000000..e32188d9
--- /dev/null
+++ b/phpunit/src/FixedReferenceStorageTest.php
@@ -0,0 +1,88 @@
+<?php
+
+use TypePhp\CompilerTest;
+use TypePhp\Exception\TestError;
+
+final class FixedReferenceStorageTest extends BaseTest
+{
+    /** @dataProvider fixedStorageProvider */
+    public function testFixedStorageCannotBeCapturedByReference(string $fixture, string $type): void
+    {
+        $this->expectException(TestError::class);
+        $this->expectExceptionMessage('of fixed type ' . $type . '; initialize it with std::any()');
+
+        $this->compileFixture($fixture);
+    }
+
+    public static function fixedStorageProvider(): iterable
+    {
+        yield 'string' => ['fixed-reference-string.php', 'php::Str'];
+        yield 'array' => ['fixed-reference-array.php', 'php::Array'];
+        yield 'object' => ['fixed-reference-generic-object.php', 'php::Object'];
+        yield 'typed object' => ['fixed-reference-object.php', 'php::Object'];
+        yield 'stream' => ['fixed-reference-stream.php', 'php::Stream'];
+        yield 'std container' => ['fixed-reference-std-container.php', 'php::StdVector'];
+    }
+
+    public function testFixedStorageCannotBePassedToKnownReferenceParameter(): void
+    {
+        $this->expectException(TestError::class);
+        $this->expectExceptionMessage('variable $value of fixed type php::Str');
+
+        $this->compileFixture('fixed-reference-argument.php');
+    }
+
+    public function testFixedStorageCannotBeUsedAsReferenceAssignmentSource(): void
+    {
+        $this->expectException(TestError::class);
+        $this->expectExceptionMessage('variable $value of fixed type php::Array');
+
+        $this->compileFixture('fixed-reference-assignment.php');
+    }
+
+    public function testFixedStorageCannotBeReturnedByReference(): void
+    {
+        $this->expectException(TestError::class);
+        $this->expectExceptionMessage('variable $value of fixed type php::Str');
+
+        $this->compileFixture('fixed-reference-return.php');
+    }
+
+    public function testFixedStaticStorageCannotBeCapturedByReference(): void
+    {
+        $this->expectException(TestError::class);
+        $this->expectExceptionMessage('variable $value of fixed type php::Str');
+
+        $this->compileFixture('fixed-reference-static.php');
+    }
+
+    public function testFixedStorageCannotUseToRefKeyword(): void
+    {
+        $this->expectException(TestError::class);
+        $this->expectExceptionMessage('variable $value of fixed type php::Array');
+
+        $this->compileFixture('fixed-reference-to-ref.php');
+    }
+
+    public function testExplicitAnyCanUseReferenceStorage(): void
+    {
+        $code = $this->compileFixture('fixed-reference-explicit-any.php');
+
+        self::assertStringContainsString('php::Var value', $code);
+        self::assertStringContainsString('value.toReference()', $code);
+    }
+
+    private function compileFixture(string $fixture): string
+    {
+        global $translator;
+        $compiler = CompilerTest::create(TYPEPHP_ROOT_PATH);
+        $translator = $compiler;
+        $source = TYPEPHP_ROOT_PATH . '/phpunit/code/' . $fixture;
+        $compiler->addFiles([$source]);
+        $compiler->prepareFile($source);
+        $generated = $compiler->convertFile($source);
+        $code = file_get_contents($generated);
+        self::assertIsString($code);
+        return $code;
+    }
+}
diff --git a/phpunit/src/NativeSlotZeroDivisorTest.php b/phpunit/src/NativeSlotZeroDivisorTest.php
index a4a7adee..2dd5a5a2 100644
--- a/phpunit/src/NativeSlotZeroDivisorTest.php
+++ b/phpunit/src/NativeSlotZeroDivisorTest.php
@@ -3,7 +3,7 @@
 /**
  * std::int()/std::float() opt into native C++ arithmetic, so a proven zero
  * divisor cannot be silently rerouted to PHP semantics; it keeps the
- * compile-time rejection that native_types mode uses.
+ * compile-time rejection used by native scalar storage.
  */
 class NativeSlotZeroDivisorTest extends BaseTest
 {
diff --git a/phpunit/src/NegativeCompatibilityTest.php b/phpunit/src/NegativeCompatibilityTest.php
index 0c4f5f00..6c93e789 100644
--- a/phpunit/src/NegativeCompatibilityTest.php
+++ b/phpunit/src/NegativeCompatibilityTest.php
@@ -405,7 +405,7 @@ PHP,
 
         yield 'disabled strict types declare' => [
             'convert',
-            'declare(strict_types=0) is not allowed, only strict_types=1 is supported',
+            'TypePHP always uses strict types; declare(strict_types=0) is not allowed',
             <<<'PHP'
 <?php
 declare(strict_types=0); // @diagnostic
diff --git a/phpunit/src/Testing/TestCoverageAnalyzerTest.php b/phpunit/src/Testing/TestCoverageAnalyzerTest.php
index e65604f7..7d5293a8 100644
--- a/phpunit/src/Testing/TestCoverageAnalyzerTest.php
+++ b/phpunit/src/Testing/TestCoverageAnalyzerTest.php
@@ -6,7 +6,6 @@
  * @contact  service@swoole.com
  */
 
-declare(strict_types=1);
 
 namespace TypePhp\Tests\Testing;
 
diff --git a/phpunit/src/VarIntTypesTest.php b/phpunit/src/VarIntTypesTest.php
index c321f1a9..3059f69b 100644
--- a/phpunit/src/VarIntTypesTest.php
+++ b/phpunit/src/VarIntTypesTest.php
@@ -75,7 +75,7 @@ final class VarIntTypesTest extends BaseTest
     {
         $this->expectException(TestError::class);
         $this->expectExceptionMessage(
-            'Cannot create a reference to native variable of type php::Bool; initialize it with std::any()',
+            'Cannot create a reference to variable $changed of fixed type php::Bool; initialize it with std::any()',
         );
 
         $this->compileSource(
diff --git a/src/CompilerBase.php b/src/CompilerBase.php
index 13830967..1527879c 100644
--- a/src/CompilerBase.php
+++ b/src/CompilerBase.php
@@ -2391,21 +2391,7 @@ class CompilerBase implements PropertyAccessContext
                 if (!$this->hasVar($name)) {
                     $this->errorUndefinedVariable($v->expr);
                 }
-                if ($this->hasLocalVar($name) && $this->getVarType($name) !== Type::VAR && $this->getVarType($name) !== Type::REF) {
-                    $isParameter = false;
-                    foreach ($this->functionDef->argInfoList as $argInfo) {
-                        if ($argInfo->name === $name) {
-                            $isParameter = true;
-                            break;
-                        }
-                    }
-                    if ($isParameter) {
-                        $this->fatalError($v, 'A function returning by reference cannot return a native typed parameter');
-                    }
-                    // The declaration is emitted after parsing the body, so a local can
-                    // be promoted to Variant before C++ is generated.
-                    $this->context->localVars[$name] = Type::VAR;
-                }
+                $this->assertVariableReferenceStorage($v->expr, $v, $name);
                 return 'return ' . $name . '.toReference();';
             }
             if ($this->isPropertyFetch($v->expr)) {
@@ -4398,6 +4384,7 @@ class CompilerBase implements PropertyAccessContext
         if ($op === self::OP_REFVAL) {
             $this->assertNativeArrayAccessReferenceForbidden($node);
             $this->assertNativeObjectReferenceForbidden($node, $node);
+            $this->assertVariableReferenceStorage($node, $node);
         }
         if ($node instanceof Expr\ArrayDimFetch
             && $this->isNativeObjectClass($this->detectClassOfExpr($node->var))
diff --git a/src/Generator/CallArgumentGenerator.php b/src/Generator/CallArgumentGenerator.php
index 16476ae4..bfd14f6e 100644
--- a/src/Generator/CallArgumentGenerator.php
+++ b/src/Generator/CallArgumentGenerator.php
@@ -847,10 +847,7 @@ trait CallArgumentGenerator
         } elseif ($this->getVarType($name) === Type::REF) {
             return '&' . $name;
         } else {
-            // A local variable of native type is converted to a plain variable
-            if ($this->hasLocalVar($name) and $this->isNativeType($this->getVarType($name))) {
-                $this->context->localVars[$name] = Type::VAR;
-            }
+            $this->assertVariableReferenceStorage($arg->value, $arg, $name);
             // For a by-reference parameter, use a temporary variable as the reference
             // and replace the actual argument with it
             $tmpVar = $this->genTmpVarName();
diff --git a/src/Generator/ParameterCountCheckGenerator.php b/src/Generator/ParameterCountCheckGenerator.php
index ea1c926c..7305cb17 100644
--- a/src/Generator/ParameterCountCheckGenerator.php
+++ b/src/Generator/ParameterCountCheckGenerator.php
@@ -1,5 +1,4 @@
 <?php
-declare(strict_types=1);
 
 namespace TypePhp\Generator;
 
diff --git a/src/Parser/AssignOpTrait.php b/src/Parser/AssignOpTrait.php
index a8a0673d..ef6f9fbd 100644
--- a/src/Parser/AssignOpTrait.php
+++ b/src/Parser/AssignOpTrait.php
@@ -298,6 +298,16 @@ trait AssignOpTrait
                         . $this->parseAssignToList($item->value, $itemExpr)
                         . PHP_EOL;
                 } else {
+                    // Destructuring is an indirect write form. It must not
+                    // inherit the direct-assignment initialization exception
+                    // for readonly properties.
+                    $writeTarget = $item->value;
+                    while ($writeTarget instanceof Expr\ArrayDimFetch) {
+                        $writeTarget = $writeTarget->var;
+                    }
+                    if ($writeTarget instanceof Expr\PropertyFetch) {
+                        $this->preparePropertyWriteTarget($writeTarget, false);
+                    }
                     // Route every destructuring target through the normal
                     // assignment pipeline. Existing native locals remain
                     // native and receive the usual scalar conversion, while
@@ -1527,7 +1537,7 @@ trait AssignOpTrait
         $rightExpr = '';
 
         if ($this->isVarExpr($expr->expr)) {
-            $rightExpr = $tmpVar . ' = ' . $this->parseIdentifier($expr->expr) . '.toReference()';
+            $rightExpr = $tmpVar . ' = ' . $this->convertToRef($expr->expr);
         } elseif ($expr->expr instanceof Expr\FuncCall && $this->isNameExpr($expr->expr->name)) {
             $name = $this->parseIdentifier($expr->expr->name);
             $function = $this->findNativeFunction($name);
diff --git a/src/Parser/BinaryOpTrait.php b/src/Parser/BinaryOpTrait.php
index 89a6aca0..ab735c59 100644
--- a/src/Parser/BinaryOpTrait.php
+++ b/src/Parser/BinaryOpTrait.php
@@ -734,8 +734,8 @@ trait BinaryOpTrait
                 || $this->usesNativeScalarStorage($type)
             ) {
                 // Calls and nested binary operands are materialized to preserve
-                // PHP's left-to-right evaluation order. In native-types mode
-                // their scalar result has a fixed C++ representation, so
+                // PHP's left-to-right evaluation order. A statically native
+                // scalar result has a fixed C++ representation, so
                 // boxing it in a Variant would add dynamic arithmetic and zval
                 // lifetime work to otherwise native expressions.
                 return $type;
@@ -781,8 +781,8 @@ trait BinaryOpTrait
         // around a side effect is materialized for evaluation order, but its
         // lowered C++ form can still be dynamic — `-strlen($s)` on an
         // unqualified namespaced call lowers to `-(php::call(...))`, a
-        // Variant. Outside native-types mode the temporary must stay dynamic,
-        // matching the call and binary-op policy above.
+        // Variant. When its type is not statically fixed the temporary must
+        // stay dynamic, matching the call and binary-op policy above.
         return Type::VAR;
     }
 
diff --git a/src/Parser/ForeachTrait.php b/src/Parser/ForeachTrait.php
index a52d2ecc..be2a22f1 100644
--- a/src/Parser/ForeachTrait.php
+++ b/src/Parser/ForeachTrait.php
@@ -265,9 +265,4 @@ trait ForeachTrait
         return $code;
     }
 
-    /**
-     * For backward compatibility, native types are not used by default; integers and floats are treated as php variables.
-     * Native int/float/bool types do not support automatic conversion. For example, an int computation that exceeds its maximum value is promoted to float, and a division that does not divide evenly becomes float.
-     * In some cases high-performance computation may need native types; use `$a = std::int(0)` to explicitly opt into native types.
-     */
 }
diff --git a/src/Parser/TypeConversionTrait.php b/src/Parser/TypeConversionTrait.php
index f61d2d0d..ce597f77 100644
--- a/src/Parser/TypeConversionTrait.php
+++ b/src/Parser/TypeConversionTrait.php
@@ -290,14 +290,43 @@ trait TypeConversionTrait
             return $this->emitStaticPropertyFetchRef($expr, $expr);
         }
         $var = $this->parseIdentifier($expr);
-        if ($this->isVarExpr($expr) and $this->isNativeTypeVar($var)) {
-            $this->fatalError(
-                $expr,
-                'Cannot create a reference to native variable of type ' . $this->getVarType($var)
-                    . '; initialize it with std::any() when reference semantics are required',
-            );
-        }
+        $this->assertVariableReferenceStorage($expr, $expr, $var);
         return $var . '.toReference()';
     }
 
+    /**
+     * PHP references are untyped zval aliases. Exposing fixed C++ storage as
+     * one would let dynamic code replace the value with an incompatible type.
+     * Only php::Var (or an existing php::Ref) has storage that can safely
+     * participate in Zend reference semantics.
+     */
+    protected function assertVariableReferenceStorage(
+        NodeAbstract $expr,
+        NodeAbstract $errorNode,
+        ?string $name = null,
+    ): void {
+        if (!$this->isVarExpr($expr)) {
+            return;
+        }
+
+        $name ??= $this->parseIdentifier($expr);
+        if (!$this->hasVar($name)) {
+            return;
+        }
+
+        $type = $this->hasStaticVar($name)
+            ? $this->context->staticVars[$name]
+            : $this->getVarType($name);
+        if ($type === Type::VAR || $type === Type::REF) {
+            return;
+        }
+
+        $this->fatalError(
+            $errorNode,
+            'Cannot create a reference to variable $' . $this->unescapeVarName($name)
+                . ' of fixed type ' . $type
+                . '; initialize it with std::any() when reference semantics are required',
+        );
+    }
+
 }
diff --git a/src/Testing/TestCoverageAnalyzer.php b/src/Testing/TestCoverageAnalyzer.php
index fb896d63..27240b94 100644
--- a/src/Testing/TestCoverageAnalyzer.php
+++ b/src/Testing/TestCoverageAnalyzer.php
@@ -6,7 +6,6 @@
  * @contact  service@swoole.com
  */
 
-declare(strict_types=1);
 
 namespace TypePhp\Testing;
 
diff --git a/src/Translator.php b/src/Translator.php
index 53df8acc..e05e63e4 100644
--- a/src/Translator.php
+++ b/src/Translator.php
@@ -3260,7 +3260,7 @@ CODE;
                 }
             } elseif ($key === 'strict_types') {
                 if (!($declare->value instanceof Node\Scalar\Int_) or $declare->value->value !== 1) {
-                    $this->fatalError($v, 'declare(strict_types=0) is not allowed, only strict_types=1 is supported');
+                    $this->fatalError($v, 'TypePHP always uses strict types; declare(strict_types=0) is not allowed');
                 }
             } else {
                 $this->fatalError($v, 'declare(' . $key . '=' . $value . ') is not supported');
diff --git a/src/TypeSystem/NativeTypeCompatibilityTrait.php b/src/TypeSystem/NativeTypeCompatibilityTrait.php
index 2ad17387..06f5b95e 100644
--- a/src/TypeSystem/NativeTypeCompatibilityTrait.php
+++ b/src/TypeSystem/NativeTypeCompatibilityTrait.php
@@ -265,7 +265,7 @@ trait NativeTypeCompatibilityTrait
 
         if (($type === Type::VAR || $type === Type::REF) && $this->isStrictScalarType($argInfo->type)) {
             // A native scalar ABI value has already lost its zval type. Preserve
-            // the dynamic value until strict_types validation has completed.
+            // the dynamic value until TypePHP's strict validation has completed.
             // The PHPX helper evaluates the expression exactly once and returns
             // the final native ABI type without an immediately-invoked closure.
             $this->checkVarAssignExpr($arg, $argInfo->type, $type);
diff --git a/src/gen_stub.php b/src/gen_stub.php
index 4b16bb10..ed2cda44 100755
--- a/src/gen_stub.php
+++ b/src/gen_stub.php
@@ -1,5 +1,4 @@
 <?php
-declare(strict_types=1);
 
 /*
  * This file is derived from build/gen_stub.php in php-src and is not
diff --git a/tests/compiler/array/array-multisort.phpt b/tests/compiler/array/array-multisort.phpt
index 55533dd6..eab61e05 100644
--- a/tests/compiler/array/array-multisort.phpt
+++ b/tests/compiler/array/array-multisort.phpt
@@ -3,8 +3,8 @@ array_multisort() function - normal arguments
 --FILE--
 <?php
 function main() {
-    $ar1 = array("row1" => 2, "row2" => 1, "row3" => 1);
-    $ar2 = array("row1" => 2, "row2" => "aa", "row3" => "1");
+    $ar1 = std::any(array("row1" => 2, "row2" => 1, "row3" => 1));
+    $ar2 = std::any(array("row1" => 2, "row2" => "aa", "row3" => "1"));
 
     echo "\n-- Testing array_multisort() function with all normal arguments --\n";
     var_dump(array_multisort($ar1, SORT_ASC, SORT_REGULAR, $ar2, SORT_DESC, SORT_STRING) );
@@ -29,4 +29,4 @@ array(3) {
   string(1) "1"
   ["row1"]=>
   int(2)
-}
\ No newline at end of file
+}
diff --git a/tests/compiler/array/array-push-empty-unpack.phpt b/tests/compiler/array/array-push-empty-unpack.phpt
index 670c2441..a2106a7f 100644
--- a/tests/compiler/array/array-push-empty-unpack.phpt
+++ b/tests/compiler/array/array-push-empty-unpack.phpt
@@ -6,7 +6,7 @@ array_push retains its required array argument when an unpacked list is empty
 function main(): void
 {
     // Keep the required by-reference argument before an empty unpack.
-    $values = [];
+    $values = std::any([]);
     array_push($values, ...[]);
     var_dump($values);
 
diff --git a/tests/compiler/array/complex_array_operations.phpt b/tests/compiler/array/complex_array_operations.phpt
index f6958186..2185dde7 100644
--- a/tests/compiler/array/complex_array_operations.phpt
+++ b/tests/compiler/array/complex_array_operations.phpt
@@ -114,7 +114,7 @@ function main() {
     var_dump($assoc['first']); // 110
 
     // Test with array references
-    $original = ['value' => 50];
+    $original = std::any(['value' => 50]);
     $xref =& $original;
     $xref['value'] += 25;
     var_dump($original['value']); // 75
diff --git a/tests/compiler/array/compound-offset-evaluated-once.phpt b/tests/compiler/array/compound-offset-evaluated-once.phpt
index d2039286..1d3e0a99 100644
--- a/tests/compiler/array/compound-offset-evaluated-once.phpt
+++ b/tests/compiler/array/compound-offset-evaluated-once.phpt
@@ -2,7 +2,6 @@
 Array compound assignment evaluates a side-effecting offset once
 --FILE--
 <?php
-declare(strict_types=1);
 
 function nextCompoundOffset(int &$index): int
 {
@@ -41,7 +40,7 @@ function main(): void
 
     var_dump($nestedIndex, $nestedValues[0][1], $nestedValues[1][0], $nestedResult);
 
-    $callIndex = 0;
+    $callIndex = std::any(0);
     $callValues = [[10, 20], [30, 40]];
     $callResult = ($callValues[nextCompoundOffset($callIndex)][nextCompoundOffset($callIndex)] *= 2);
 
@@ -53,7 +52,7 @@ function main(): void
 
     var_dump($rhsIndex, $rhsValues[0], $rhsValues[1], $rhsResult);
 
-    $offsetPart = 'a';
+    $offsetPart = std::any('a');
     $interpolatedValues = ['a0' => 10, 'b0' => 20];
     $interpolatedResult = ($interpolatedValues["{$offsetPart}0"] += changeCompoundOffsetPart($offsetPart));
 
diff --git a/tests/compiler/array/compound-overflow.phpt b/tests/compiler/array/compound-overflow.phpt
index 70c41575..57e3e7a6 100644
--- a/tests/compiler/array/compound-overflow.phpt
+++ b/tests/compiler/array/compound-overflow.phpt
@@ -2,7 +2,6 @@
 Array element compound arithmetic promotes overflowing integers to float
 --FILE--
 <?php
-declare(strict_types=1);
 
 function main(): void
 {
diff --git a/tests/compiler/array/count-literal-fold.phpt b/tests/compiler/array/count-literal-fold.phpt
index 6f370bf5..8ca4298b 100644
--- a/tests/compiler/array/count-literal-fold.phpt
+++ b/tests/compiler/array/count-literal-fold.phpt
@@ -60,7 +60,7 @@ function main()
     var_dump(count(["{$object->property}"]));
 
     // A by-reference item binds the source variable instead of reading it.
-    $ref = 1;
+    $ref = std::any(1);
     var_dump(count([&$ref]));
 
     // A defined class constant is still evaluated, not discarded.
diff --git a/tests/compiler/array/multi-return-forward-args.phpt b/tests/compiler/array/multi-return-forward-args.phpt
index b62d2645..7ed8080b 100644
--- a/tests/compiler/array/multi-return-forward-args.phpt
+++ b/tests/compiler/array/multi-return-forward-args.phpt
@@ -26,7 +26,7 @@ function multi_return_forward_defaults(
 function main(): void
 {
     $object = (object) ['name' => 'direct'];
-    $directReference = 'before';
+    $directReference = std::any('before');
     [$value, $text, $items, $directObject, $count, $returnedReference, $rest]
         = multi_return_forward_args('value', 'text', [1], $object, 2, $directReference, 'x');
     var_dump(
@@ -40,7 +40,7 @@ function main(): void
         $rest,
     );
 
-    $arrayReference = 'before';
+    $arrayReference = std::any('before');
     $array = multi_return_forward_args('array', 'adapter', [3], $object, 4, $arrayReference, 'y', 'z');
     var_dump($arrayReference, $array[0], $array[1], $array[2], $array[3]->name, $array[4], $array[5], $array[6]);
 
diff --git a/tests/compiler/array/multi-return-move-production.phpt b/tests/compiler/array/multi-return-move-production.phpt
index 09190ffb..c129e5c5 100644
--- a/tests/compiler/array/multi-return-move-production.phpt
+++ b/tests/compiler/array/multi-return-move-production.phpt
@@ -48,7 +48,7 @@ function main(): void
     $first[] = 'changed';
     var_dump($first, $second, $tail);
 
-    $source = 'reference';
+    $source = std::any('reference');
     [$referenceFirst, $referenceSecond] = multi_return_reference_value($source);
     $referenceFirst = 'changed';
     var_dump($source, $referenceFirst, $referenceSecond);
diff --git a/tests/compiler/array_method/method.phpt b/tests/compiler/array_method/method.phpt
index a39b38a6..b3bb1917 100644
--- a/tests/compiler/array_method/method.phpt
+++ b/tests/compiler/array_method/method.phpt
@@ -140,35 +140,35 @@ function main()
     Assert::true($array->isEmpty());
 
     $fruits1 = array("lemon", "orange", "banana", "apple");
-    $fruits2 = array("lemon", "orange", "banana", "apple");
+    $fruits2 = std::any(array("lemon", "orange", "banana", "apple"));
     sort($fruits2);
     Assert::eq($fruits1->sort(), $fruits2);
     Assert::eq($fruits1, $fruits2);
 
-    $stack = array("orange", "banana", "apple", "raspberry");
+    $stack = std::any(array("orange", "banana", "apple", "raspberry"));
     Assert::eq($stack->pop(), 'raspberry');
     Assert::eq(array_pop($stack), 'apple');
 
-    $array = array("red","green");
-    $array->push("blue");
-    Assert::eq($array, ["red","green", "blue"]);
-    array_push($array, "yellow");
-    Assert::eq($array, ["red","green", "blue", "yellow"]);
+    $mutableArray = std::any(array("red","green"));
+    $mutableArray->push("blue");
+    Assert::eq($mutableArray, ["red","green", "blue"]);
+    array_push($mutableArray, "yellow");
+    Assert::eq($mutableArray, ["red","green", "blue", "yellow"]);
 
-    $stack = array("orange", "banana", "apple", "raspberry");
+    $stack = std::any(array("orange", "banana", "apple", "raspberry"));
     Assert::eq($stack->shift(), 'orange');
     Assert::eq(array_shift($stack), 'banana');
 
-    $queue = ["orange", "banana"];
+    $queue = std::any(["orange", "banana"]);
     $queue->unshift("orange");
     Assert::eq($queue, ["orange", "orange", "banana"]);
     array_unshift($queue, "orange");
     Assert::eq($queue, ["orange", "orange", "orange", "banana"]);
 
     $array1 = array("red", "green", "blue", "yellow");
-    $array2 = array("red", "green", "blue", "yellow");
-    Assert::eq($array1->splice(2), array_splice($array2, 2));
-    Assert::eq($array1, $array2);
+    $spliceArray = std::any(array("red", "green", "blue", "yellow"));
+    Assert::eq($array1->splice(2), array_splice($spliceArray, 2));
+    Assert::eq($array1, $spliceArray);
 
     $find = array("Hello","world");
     $replace = array("B");
diff --git a/tests/compiler/attribute/immutable.phpt b/tests/compiler/attribute/immutable.phpt
index c0476655..e20f564d 100644
--- a/tests/compiler/attribute/immutable.phpt
+++ b/tests/compiler/attribute/immutable.phpt
@@ -118,7 +118,8 @@ function main(): void
     echo $user->traitName(), PHP_EOL;
     echo sumImmutable([2, 3]), PHP_EOL;
     echo cloneImmutable($user), PHP_EOL;
-    echo inspectImmutableReference($user), PHP_EOL;
+    $referenceUser = std::any($user);
+    echo inspectImmutableReference($referenceUser), PHP_EOL;
     echo deliberatelyEscapeImmutableCheck($user), PHP_EOL;
     echo (new ImmutableHookedValue())->read(), PHP_EOL;
     echo closureImmutableParameter($user), PHP_EOL;
diff --git a/tests/compiler/basic/clone-with-references.phpt b/tests/compiler/basic/clone-with-references.phpt
index ca54d127..62ef4417 100644
--- a/tests/compiler/basic/clone-with-references.phpt
+++ b/tests/compiler/basic/clone-with-references.phpt
@@ -12,7 +12,7 @@ if (PHP_VERSION_ID < 80500) {
 function main(): void
 {
     $source = new stdClass();
-    $value = 'reference';
+    $value = std::any('reference');
     $updates = ['value' => &$value];
 
     try {
diff --git a/tests/compiler/basic/json-exception-boundary.phpt b/tests/compiler/basic/json-exception-boundary.phpt
index 9e56b43b..93902ee8 100644
--- a/tests/compiler/basic/json-exception-boundary.phpt
+++ b/tests/compiler/basic/json-exception-boundary.phpt
@@ -12,7 +12,7 @@ function main(): void
         echo "decode-caught\n";
     }
 
-    $recursive = [];
+    $recursive = std::any([]);
     $recursive['self'] = &$recursive;
     try {
         json_encode($recursive, JSON_THROW_ON_ERROR);
diff --git a/tests/compiler/basic/std_builtin.phpt b/tests/compiler/basic/std_builtin.phpt
index a07a1483..9dcc33cf 100644
--- a/tests/compiler/basic/std_builtin.phpt
+++ b/tests/compiler/basic/std_builtin.phpt
@@ -2,7 +2,6 @@
 std::bigInt() and std::decimal() builtin functions
 --FILE--
 <?php
-declare(strict_types=1);
 function main(): void {
     // std::bigInt from big literal (auto-detected BigInt → no-op pass-through)
     $a = std::bigInt(12345678901234567890);
diff --git a/tests/compiler/bigint/arithmetic.phpt b/tests/compiler/bigint/arithmetic.phpt
index e23ac4e6..0cb568fd 100644
--- a/tests/compiler/bigint/arithmetic.phpt
+++ b/tests/compiler/bigint/arithmetic.phpt
@@ -2,7 +2,6 @@
 BigInt arithmetic operations
 --FILE--
 <?php
-declare(strict_types=1);
 function main(): void {
     $a = 12345678901234567890;
     $b = 98765432109876543210;
diff --git a/tests/compiler/bigint/assign_op.phpt b/tests/compiler/bigint/assign_op.phpt
index c37f12b1..4184cfc3 100644
--- a/tests/compiler/bigint/assign_op.phpt
+++ b/tests/compiler/bigint/assign_op.phpt
@@ -2,7 +2,6 @@
 BigInt compound assignment operators (+=, -=, *=, /=, %=)
 --FILE--
 <?php
-declare(strict_types=1);
 function main(): void {
     // BigInt +=
     $a = std::bigInt(100);
diff --git a/tests/compiler/bigint/bigint_types.phpt b/tests/compiler/bigint/bigint_types.phpt
index 2d5e6cfd..7f511e5c 100644
--- a/tests/compiler/bigint/bigint_types.phpt
+++ b/tests/compiler/bigint/bigint_types.phpt
@@ -2,7 +2,6 @@
 use bigint_types — integer literals auto-converted to BigInt
 --FILE--
 <?php
-declare(strict_types=1);
 use bigint_types;
 
 function main(): void {
diff --git a/tests/compiler/bigint/bitwise.phpt b/tests/compiler/bigint/bitwise.phpt
index db9d51a9..9ac9ce87 100644
--- a/tests/compiler/bigint/bitwise.phpt
+++ b/tests/compiler/bigint/bitwise.phpt
@@ -2,7 +2,6 @@
 BigInt bitwise operations (&, |, ^, ~, &=, |=, ^=, testBit, popCount)
 --FILE--
 <?php
-declare(strict_types=1);
 function main(): void {
     $a = std::bigInt("240");  // 0xF0
     $b = std::bigInt("15");   // 0x0F
diff --git a/tests/compiler/bigint/bitwise_shift.phpt b/tests/compiler/bigint/bitwise_shift.phpt
index 1549b345..45f07e15 100644
--- a/tests/compiler/bigint/bitwise_shift.phpt
+++ b/tests/compiler/bigint/bitwise_shift.phpt
@@ -2,7 +2,6 @@
 BigInt bitwise shift operations (<<, >>, <<=, >>=, bitShiftLeft, bitShiftRight)
 --FILE--
 <?php
-declare(strict_types=1);
 function main(): void {
     $a = std::bigInt("16");  // 0b10000
 
diff --git a/tests/compiler/bigint/both_types.phpt b/tests/compiler/bigint/both_types.phpt
index c2e38102..fd12c6ab 100644
--- a/tests/compiler/bigint/both_types.phpt
+++ b/tests/compiler/bigint/both_types.phpt
@@ -2,7 +2,6 @@
 use bigint_types + use decimal_types together
 --FILE--
 <?php
-declare(strict_types=1);
 use bigint_types;
 use decimal_types;
 
diff --git a/tests/compiler/bigint/compare.phpt b/tests/compiler/bigint/compare.phpt
index c1c19f8a..72c0abc0 100644
--- a/tests/compiler/bigint/compare.phpt
+++ b/tests/compiler/bigint/compare.phpt
@@ -2,7 +2,6 @@
 BigInt comparison
 --FILE--
 <?php
-declare(strict_types=1);
 function main(): void {
     $a = 12345678901234567890;
     $b = 98765432109876543210;
diff --git a/tests/compiler/bigint/divmod.phpt b/tests/compiler/bigint/divmod.phpt
index 793b3654..8968f88d 100644
--- a/tests/compiler/bigint/divmod.phpt
+++ b/tests/compiler/bigint/divmod.phpt
@@ -2,7 +2,6 @@
 BigInt: divmod
 --FILE--
 <?php
-declare(strict_types=1);
 function main(): void {
     $a = std::bigInt(10);
     $b = std::bigInt(3);
diff --git a/tests/compiler/bigint/gcd.phpt b/tests/compiler/bigint/gcd.phpt
index a3d7b9fb..bb5d9369 100644
--- a/tests/compiler/bigint/gcd.phpt
+++ b/tests/compiler/bigint/gcd.phpt
@@ -2,7 +2,6 @@
 BigInt: gcd
 --FILE--
 <?php
-declare(strict_types=1);
 function main(): void {
     $a = std::bigInt(12);
     $b = std::bigInt(8);
diff --git a/tests/compiler/bigint/literal.phpt b/tests/compiler/bigint/literal.phpt
index a43c7561..d16b9bd4 100644
--- a/tests/compiler/bigint/literal.phpt
+++ b/tests/compiler/bigint/literal.phpt
@@ -2,7 +2,6 @@
 BigInt literal parsing and output
 --FILE--
 <?php
-declare(strict_types=1);
 function main(): void {
     $a = 12345678901234567890;
     echo $a->toString();
diff --git a/tests/compiler/bigint/math_func_opt.phpt b/tests/compiler/bigint/math_func_opt.phpt
index 6663433e..5b7ddedd 100644
--- a/tests/compiler/bigint/math_func_opt.phpt
+++ b/tests/compiler/bigint/math_func_opt.phpt
@@ -2,7 +2,6 @@
 Big* types: math function optimization (abs/pow/sqrt/floor/ceil/round)
 --FILE--
 <?php
-declare(strict_types=1);
 function main(): void {
     // BigInt
     $a = std::bigInt("100");
diff --git a/tests/compiler/bigint/mixed.phpt b/tests/compiler/bigint/mixed.phpt
index 6f9f51c3..290f938e 100644
--- a/tests/compiler/bigint/mixed.phpt
+++ b/tests/compiler/bigint/mixed.phpt
@@ -2,7 +2,6 @@
 BigInt mixed operations with Int
 --FILE--
 <?php
-declare(strict_types=1);
 function main(): void {
     $a = 12345678901234567890;
     // BigInt + Int
diff --git a/tests/compiler/bigint/operator.phpt b/tests/compiler/bigint/operator.phpt
index 24cb96cf..a70239b4 100644
--- a/tests/compiler/bigint/operator.phpt
+++ b/tests/compiler/bigint/operator.phpt
@@ -2,7 +2,6 @@
 BigInt binary operators (+, -, *, /, %) and unary minus
 --FILE--
 <?php
-declare(strict_types=1);
 function main(): void {
     $a = std::bigInt(100);
 
diff --git a/tests/compiler/bigint/pow-right-bigint.phpt b/tests/compiler/bigint/pow-right-bigint.phpt
index 2a20bad4..4ecd9521 100644
--- a/tests/compiler/bigint/pow-right-bigint.phpt
+++ b/tests/compiler/bigint/pow-right-bigint.phpt
@@ -2,7 +2,6 @@
 BigInt exponentiation dispatches when BigInt is the right operand
 --FILE--
 <?php
-declare(strict_types=1);
 function main(): void {
     $exponent = std::bigInt("10");
     echo (2 ** $exponent)->toString(), "\n";
diff --git a/tests/compiler/bigint/powmod.phpt b/tests/compiler/bigint/powmod.phpt
index 4ea681b6..84fd1898 100644
--- a/tests/compiler/bigint/powmod.phpt
+++ b/tests/compiler/bigint/powmod.phpt
@@ -2,7 +2,6 @@
 BigInt: powmod
 --FILE--
 <?php
-declare(strict_types=1);
 function main(): void {
     // 2^10 mod 1000 = 1024 mod 1000 = 24
     $a = std::bigInt(2);
diff --git a/tests/compiler/bigint/sqrt.phpt b/tests/compiler/bigint/sqrt.phpt
index 6f79edd4..3cd8f25d 100644
--- a/tests/compiler/bigint/sqrt.phpt
+++ b/tests/compiler/bigint/sqrt.phpt
@@ -2,7 +2,6 @@
 BigInt: sqrt
 --FILE--
 <?php
-declare(strict_types=1);
 function main(): void {
     $a = std::bigInt(0);
     echo $a->sqrt()->toString(); echo "\n";
diff --git a/tests/compiler/bigint/toInt_toFloat.phpt b/tests/compiler/bigint/toInt_toFloat.phpt
index 4827ed68..58e10ec8 100644
--- a/tests/compiler/bigint/toInt_toFloat.phpt
+++ b/tests/compiler/bigint/toInt_toFloat.phpt
@@ -2,7 +2,6 @@
 BigInt: toInt / toFloat
 --FILE--
 <?php
-declare(strict_types=1);
 function main(): void {
     $a = std::bigInt(42);
     var_dump($a->toInt());
diff --git a/tests/compiler/bigint/toString_cast.phpt b/tests/compiler/bigint/toString_cast.phpt
index a835c398..b646c83a 100644
--- a/tests/compiler/bigint/toString_cast.phpt
+++ b/tests/compiler/bigint/toString_cast.phpt
@@ -2,7 +2,6 @@
 Big* types: (string) cast, strval() and echo → toString()
 --FILE--
 <?php
-declare(strict_types=1);
 function main(): void {
     // BigInt
     $a = std::bigInt("12345678901234567890");
diff --git a/tests/compiler/bignumber/big_number_operators.phpt b/tests/compiler/bignumber/big_number_operators.phpt
index ef6c33ae..dd37797f 100644
--- a/tests/compiler/bignumber/big_number_operators.phpt
+++ b/tests/compiler/bignumber/big_number_operators.phpt
@@ -2,7 +2,6 @@
 BigInt and Decimal operator overloading (+, -, *, /, %, **, <, >, <=, >=, ==, !=, <=>)
 --FILE--
 <?php
-declare(strict_types=1);
 function main(): void {
     // === BigInt arithmetic operators ===
     $a = std::bigInt(100);
diff --git a/tests/compiler/bignumber/bigfloat-high-precision.phpt b/tests/compiler/bignumber/bigfloat-high-precision.phpt
index d9005c97..62b0ecd4 100644
--- a/tests/compiler/bignumber/bigfloat-high-precision.phpt
+++ b/tests/compiler/bignumber/bigfloat-high-precision.phpt
@@ -2,7 +2,6 @@
 BigFloat arithmetic retains precision beyond IEEE double
 --FILE--
 <?php
-declare(strict_types=1);
 function main(): void {
     $large = std::bigFloat("1000000000000000000000000000000");
     $one = std::bigFloat("1");
diff --git a/tests/compiler/bignumber/bigfloat_operators.phpt b/tests/compiler/bignumber/bigfloat_operators.phpt
index e6e42f81..79a96cd5 100644
--- a/tests/compiler/bignumber/bigfloat_operators.phpt
+++ b/tests/compiler/bignumber/bigfloat_operators.phpt
@@ -2,7 +2,6 @@
 BigFloat operator overloading (+, -, *, /) and comparisons (<, >, <=, >=, ==, !=, <=>)
 --FILE--
 <?php
-declare(strict_types=1);
 function main(): void {
     // === BigFloat arithmetic operators ===
     $a = std::bigFloat(100.5);
diff --git a/tests/compiler/bignumber/conversions-and-boundaries.phpt b/tests/compiler/bignumber/conversions-and-boundaries.phpt
index a0826d0b..ab23f2c6 100644
--- a/tests/compiler/bignumber/conversions-and-boundaries.phpt
+++ b/tests/compiler/bignumber/conversions-and-boundaries.phpt
@@ -2,7 +2,6 @@
 Big numeric casts, conversion functions, and runtime boundaries
 --FILE--
 <?php
-declare(strict_types=1);
 function main(): void {
     $bigint = std::bigInt("42");
     var_dump((int) $bigint, (float) $bigint, (bool) $bigint);
diff --git a/tests/compiler/bignumber/logical-and-unary-operators.phpt b/tests/compiler/bignumber/logical-and-unary-operators.phpt
index 519ae600..ffa0795f 100644
--- a/tests/compiler/bignumber/logical-and-unary-operators.phpt
+++ b/tests/compiler/bignumber/logical-and-unary-operators.phpt
@@ -2,7 +2,6 @@
 Big numeric unary plus and boolean contexts use numeric truth values
 --FILE--
 <?php
-declare(strict_types=1);
 function main(): void {
     $bi0 = std::bigInt(0);
     $bi1 = std::bigInt(1);
diff --git a/tests/compiler/bignumber/operator-error-boundaries.phpt b/tests/compiler/bignumber/operator-error-boundaries.phpt
index 6c147458..7140d110 100644
--- a/tests/compiler/bignumber/operator-error-boundaries.phpt
+++ b/tests/compiler/bignumber/operator-error-boundaries.phpt
@@ -2,7 +2,6 @@
 Big numeric operator error boundaries use PHP-compatible exception types
 --FILE--
 <?php
-declare(strict_types=1);
 function main(): void {
     try {
         $unused = std::bigInt(1) / 0;
diff --git a/tests/compiler/bignumber/reverse-and-compound-operators.phpt b/tests/compiler/bignumber/reverse-and-compound-operators.phpt
index ae7d990f..900dbcb3 100644
--- a/tests/compiler/bignumber/reverse-and-compound-operators.phpt
+++ b/tests/compiler/bignumber/reverse-and-compound-operators.phpt
@@ -2,7 +2,6 @@
 Big numeric reverse non-commutative and BigFloat compound operators
 --FILE--
 <?php
-declare(strict_types=1);
 function main(): void {
     $bi = std::bigInt(4);
     echo (10 - $bi)->toString(), "\n";
diff --git a/tests/compiler/callable/misc.phpt b/tests/compiler/callable/misc.phpt
index 4aaa361f..0f04678e 100644
--- a/tests/compiler/callable/misc.phpt
+++ b/tests/compiler/callable/misc.phpt
@@ -48,7 +48,7 @@ function main() {
     var_dump($squared);
 
     // Test callable with usort
-    $unsorted = [5, 2, 8, 1, 9];
+    $unsorted = std::any([5, 2, 8, 1, 9]);
     usort($unsorted, fn($a, $b) => $a <=> $b);
     var_dump($unsorted);
 }
diff --git a/tests/compiler/class/abstract-method-byref-defined-var.phpt b/tests/compiler/class/abstract-method-byref-defined-var.phpt
index c753ffda..d6dfc332 100644
--- a/tests/compiler/class/abstract-method-byref-defined-var.phpt
+++ b/tests/compiler/class/abstract-method-byref-defined-var.phpt
@@ -9,7 +9,7 @@ namespace {
 
         public function run()
         {
-            $v = 0;
+            $v = std::any(0);
             $this->abc($v);
             var_dump($v);
         }
diff --git a/tests/compiler/class/abstract-method-byref-multi-param.phpt b/tests/compiler/class/abstract-method-byref-multi-param.phpt
index 9023cc2d..c513bf11 100644
--- a/tests/compiler/class/abstract-method-byref-multi-param.phpt
+++ b/tests/compiler/class/abstract-method-byref-multi-param.phpt
@@ -9,7 +9,7 @@ namespace {
 
         public function run()
         {
-            $x = 5;
+            $x = std::any(5);
             // $x 已定义；$y 未定义，按引用传参后由实现类赋值
             $this->abc($x, $y);
             var_dump($x, $y);
diff --git a/tests/compiler/class/get-called-class.phpt b/tests/compiler/class/get-called-class.phpt
index 0665b9b3..9388df39 100644
--- a/tests/compiler/class/get-called-class.phpt
+++ b/tests/compiler/class/get-called-class.phpt
@@ -2,7 +2,6 @@
 static::class uses the runtime called scope
 --FILE--
 <?php
-declare(strict_types=1);
 
 class CalledClassParent
 {
diff --git a/tests/compiler/class/interface-return-covariance.phpt b/tests/compiler/class/interface-return-covariance.phpt
index 792c3c76..a9291bb1 100644
--- a/tests/compiler/class/interface-return-covariance.phpt
+++ b/tests/compiler/class/interface-return-covariance.phpt
@@ -3,7 +3,6 @@ Interface return type covariance with nullable interface and anonymous class
 --FILE--
 <?php
 
-declare(strict_types=1);
 
 interface TestInterface1
 {
diff --git a/tests/compiler/closure/by-reference-parameters.phpt b/tests/compiler/closure/by-reference-parameters.phpt
index 2f20b058..c517233b 100644
--- a/tests/compiler/closure/by-reference-parameters.phpt
+++ b/tests/compiler/closure/by-reference-parameters.phpt
@@ -8,7 +8,7 @@ function main(): void
     $fixed = static function (&$value): void {
         $value .= '!';
     };
-    $text = 'fixed';
+    $text = std::any('fixed');
     $fixed(std::ref($text));
     var_dump($text);
 
@@ -19,7 +19,7 @@ function main(): void
     $optional();
 
     $arrow = static fn (&$value): int => ++$value;
-    $number = 40;
+    $number = std::any(40);
     var_dump($arrow(std::ref($number)), $number);
 
     $typed = static function (int &$value): void {
diff --git a/tests/compiler/closure/closure-002.phpt b/tests/compiler/closure/closure-002.phpt
index a934cf0b..6612f8bd 100644
--- a/tests/compiler/closure/closure-002.phpt
+++ b/tests/compiler/closure/closure-002.phpt
@@ -5,7 +5,7 @@ closure 001
 function main()
 {
     $a = 100;
-    $b = [1, 2, 3];
+    $b = std::any([1, 2, 3]);
     $fn = function ($x) use ($a, &$b) {
         var_dump($a);
         var_dump($b);
@@ -35,4 +35,3 @@ array(3) {
   [2]=>
   int(6)
 }
-
diff --git a/tests/compiler/closure/closure-use-ref-composed.phpt b/tests/compiler/closure/closure-use-ref-composed.phpt
index ba7bd4dd..24776e0c 100644
--- a/tests/compiler/closure/closure-use-ref-composed.phpt
+++ b/tests/compiler/closure/closure-use-ref-composed.phpt
@@ -4,8 +4,8 @@ closure use by reference should work with nested control flow
 <?php
 
 function main() {
-    $log = [];
-    $counter = 0;
+    $log = std::any([]);
+    $counter = std::any(0);
 
     $push = function (string $label, int $value) use (&$log, &$counter): int {
         $log[] = $label . ':' . $counter;
diff --git a/tests/compiler/closure/closure-use-reference-callback.phpt b/tests/compiler/closure/closure-use-reference-callback.phpt
index 56f5f54f..7b1d048c 100644
--- a/tests/compiler/closure/closure-use-reference-callback.phpt
+++ b/tests/compiler/closure/closure-use-reference-callback.phpt
@@ -16,7 +16,7 @@ function apply_items(array $items, callable $cb): string
 
 function main(): void
 {
-    $errors = [];
+    $errors = std::any([]);
     array_map(function ($value) use (&$errors) {
         if ($value % 2 === 0) {
             $errors[] = "even:$value";
@@ -25,7 +25,7 @@ function main(): void
     }, [1, 2, 3, 4]);
     var_dump($errors);
 
-    $generated = [];
+    $generated = std::any([]);
     $code = apply_items([1, 2, 3], function ($value) use (&$generated) {
         $generated[] = $value * 10;
         return "[$value]";
@@ -33,7 +33,7 @@ function main(): void
     var_dump($code);
     var_dump($generated);
 
-    $declaredStrings = [];
+    $declaredStrings = std::any([]);
     $emit = function (string $name) use (&$declaredStrings): string {
         if (isset($declaredStrings[$name])) {
             return $declaredStrings[$name];
diff --git a/tests/compiler/closure/closure-use-reference-capture.phpt b/tests/compiler/closure/closure-use-reference-capture.phpt
index ef78af8d..09803a30 100644
--- a/tests/compiler/closure/closure-use-reference-capture.phpt
+++ b/tests/compiler/closure/closure-use-reference-capture.phpt
@@ -4,7 +4,7 @@ Closure use value and reference capture
 <?php
 function main(): void
 {
-    $arr = [1, 2];
+    $arr = std::any([1, 2]);
 
     $copy = function () use ($arr) {
         $arr[] = 3;
@@ -22,7 +22,7 @@ function main(): void
     var_dump($arr);
     var_dump($refResult);
 
-    $value = 'old';
+    $value = std::any('old');
     $returnCapturedRef = function () use (&$value) {
         return $value;
     };
@@ -30,7 +30,7 @@ function main(): void
     $value = 'new';
     var_dump($returnCapturedRef());
 
-    $count = 0;
+    $count = std::any(0);
     $inc = function () use (&$count) {
         $count++;
         return $count;
diff --git a/tests/compiler/closure/closure-variadic-unpack-use-ref.phpt b/tests/compiler/closure/closure-variadic-unpack-use-ref.phpt
index 6d4675d2..d8401720 100644
--- a/tests/compiler/closure/closure-variadic-unpack-use-ref.phpt
+++ b/tests/compiler/closure/closure-variadic-unpack-use-ref.phpt
@@ -4,7 +4,7 @@ closure variadic parameter should work with unpacked positional arguments
 <?php
 
 function main() {
-    $log = [];
+    $log = std::any([]);
     $fn = function ($a, $b = 20, ...$rest) use (&$log) {
         $log[] = $a + $b + array_sum($rest);
         var_dump($a, $b, $rest);
diff --git a/tests/compiler/closure/static-closure-use-ref-internal-callback.phpt b/tests/compiler/closure/static-closure-use-ref-internal-callback.phpt
index 53ed291a..253b8321 100644
--- a/tests/compiler/closure/static-closure-use-ref-internal-callback.phpt
+++ b/tests/compiler/closure/static-closure-use-ref-internal-callback.phpt
@@ -4,7 +4,7 @@ static closure use by reference through internal callback
 <?php
 function main(): void
 {
-    $seen = [];
+    $seen = std::any([]);
     $values = [1, 2, 3];
 
     $result = array_map(
diff --git a/tests/compiler/closure/static-closure-use-ref-typed-callback.phpt b/tests/compiler/closure/static-closure-use-ref-typed-callback.phpt
index 09cbd468..f79f907e 100644
--- a/tests/compiler/closure/static-closure-use-ref-typed-callback.phpt
+++ b/tests/compiler/closure/static-closure-use-ref-typed-callback.phpt
@@ -13,7 +13,7 @@ function apply_items(iterable $items, Closure $callback): array
 
 function main(): void
 {
-    $seen = [];
+    $seen = std::any([]);
     $prefix = 'v';
 
     $result = apply_items(
diff --git a/tests/compiler/closure/static-closure-use.phpt b/tests/compiler/closure/static-closure-use.phpt
index e1ee8067..4e85f48c 100644
--- a/tests/compiler/closure/static-closure-use.phpt
+++ b/tests/compiler/closure/static-closure-use.phpt
@@ -6,7 +6,7 @@ static closure captures values and references through use
 function main(): void
 {
     $base = 10;
-    $log = [];
+    $log = std::any([]);
 
     $copy = static function (int $value) use ($base): int {
         return $base + $value;
diff --git a/tests/compiler/closure/strict-builtin-fallback.phpt b/tests/compiler/closure/strict-builtin-fallback.phpt
index 33d631a5..d67e51d7 100644
--- a/tests/compiler/closure/strict-builtin-fallback.phpt
+++ b/tests/compiler/closure/strict-builtin-fallback.phpt
@@ -2,7 +2,6 @@
 Closure calls preserve strict builtin argument validation on dynamic fallback
 --FILE--
 <?php
-declare(strict_types=1);
 
 function mixedInt(): mixed
 {
diff --git a/tests/compiler/coalesce/array-access-assign.phpt b/tests/compiler/coalesce/array-access-assign.phpt
index 1196fb0d..3753c8cb 100644
--- a/tests/compiler/coalesce/array-access-assign.phpt
+++ b/tests/compiler/coalesce/array-access-assign.phpt
@@ -2,7 +2,6 @@
 ArrayAccess ??= preserves offsetExists, offsetGet, offsetSet and lazy evaluation semantics
 --FILE--
 <?php
-declare(strict_types=1);
 
 final class CoalesceBag implements ArrayAccess
 {
@@ -136,8 +135,8 @@ function main(): void
 
     echo "-- receiver and key once --\n";
     $sideEffect = new CoalesceBag();
-    $receiverCalls = 0;
-    $keyCalls = 0;
+    $receiverCalls = std::any(0);
+    $keyCalls = std::any(0);
     var_dump(coalesceReceiver($sideEffect, $receiverCalls)[coalesceKey($keyCalls)]
         ??= coalesceRhs('side', 55));
     var_dump($receiverCalls, $keyCalls, $sideEffect->data);
diff --git a/tests/compiler/coalesce/assign-coalesce-compound-rhs-side-effect.phpt b/tests/compiler/coalesce/assign-coalesce-compound-rhs-side-effect.phpt
index cce33885..16a7e74a 100644
--- a/tests/compiler/coalesce/assign-coalesce-compound-rhs-side-effect.phpt
+++ b/tests/compiler/coalesce/assign-coalesce-compound-rhs-side-effect.phpt
@@ -2,7 +2,6 @@
 ??= does not evaluate a compound side-effecting RHS when the target is set
 --FILE--
 <?php
-declare(strict_types=1);
 
 function sideEffect(): int
 {
diff --git a/tests/compiler/coalesce/assign-coalesce-instanceof-rhs.phpt b/tests/compiler/coalesce/assign-coalesce-instanceof-rhs.phpt
index 12007b76..56370198 100644
--- a/tests/compiler/coalesce/assign-coalesce-instanceof-rhs.phpt
+++ b/tests/compiler/coalesce/assign-coalesce-instanceof-rhs.phpt
@@ -19,14 +19,14 @@ function ensure_option(array &$options, object $platform): void
 
 function main(): void
 {
-    $options = [];
+    $options = std::any([]);
     ensure_option($options, new CoalescePlatform());
     var_dump($options);
 
     ensure_option($options, new CoalescePlatform());
     var_dump($options);
 
-    $options = [];
+    $options = std::any([]);
     ensure_option($options, new stdClass());
     var_dump($options);
 }
diff --git a/tests/compiler/coalesce/unset-ref-coalesce.phpt b/tests/compiler/coalesce/unset-ref-coalesce.phpt
index 40c7ab9f..c1d747c4 100644
--- a/tests/compiler/coalesce/unset-ref-coalesce.phpt
+++ b/tests/compiler/coalesce/unset-ref-coalesce.phpt
@@ -6,7 +6,7 @@ Null coalescing (??) on unset reference variable
 function main()
 {
     // Test 1: unset reference variable then ?? with int
-    $a = 1;
+    $a = std::any(1);
     $b = &$a;
     $b = 2;
     var_dump($a, $b);
@@ -16,7 +16,7 @@ function main()
     var_dump($b ?? 123);
 
     // Test 2: unset reference variable then ?? with string
-    $c = 'hello';
+    $c = std::any('hello');
     $d = &$c;
     $d = 'world';
     var_dump($c, $d);
@@ -26,18 +26,18 @@ function main()
     var_dump($d ?? 'default');
 
     // Test 3: ?? on reference without unset (should return value)
-    $e = 42;
+    $e = std::any(42);
     $f = &$e;
     var_dump($f ?? 999);
 
     // Test 4: chained ?? with unset reference
-    $g = 'first';
+    $g = std::any('first');
     $h = &$g;
     unset($h);
     var_dump($h ?? null ?? 'fallback');
 
     // Test 5: ??= on unset reference (assign coalesce)
-    $i = 10;
+    $i = std::any(10);
     $j = &$i;
     $j = 20;
     unset($j);
@@ -46,7 +46,7 @@ function main()
     var_dump($i);
 
     // Test 6: reference reassignment after unset
-    $k = 100;
+    $k = std::any(100);
     $l = &$k;
     unset($l);
     var_dump($l ?? 200);
@@ -60,13 +60,13 @@ function main()
     var_dump($m ?? 777);
 
     // Test 8: isset after unset of reference
-    $n = 'test';
+    $n = std::any('test');
     $o = &$n;
     unset($o);
     var_dump(isset($o));
 
     // Test 9: elvis (?:) on unset reference
-    $p = 5;
+    $p = std::any(5);
     $q = &$p;
     $q = 6;
     unset($q);
diff --git a/tests/compiler/const/class-const-override-variants.phpt b/tests/compiler/const/class-const-override-variants.phpt
index 32a085e4..f2b3175b 100644
--- a/tests/compiler/const/class-const-override-variants.phpt
+++ b/tests/compiler/const/class-const-override-variants.phpt
@@ -3,7 +3,6 @@ class const override variants (self::class, parent::class, references, multi-lev
 --FILE--
 <?php
 
-declare(strict_types=1);
 
 class Base
 {
diff --git a/tests/compiler/const/class-const-override.phpt b/tests/compiler/const/class-const-override.phpt
index 5d9e4c97..fe389140 100644
--- a/tests/compiler/const/class-const-override.phpt
+++ b/tests/compiler/const/class-const-override.phpt
@@ -3,7 +3,6 @@ class const override referencing another constant
 --FILE--
 <?php
 
-declare(strict_types=1);
 
 abstract class ParentClass
 {
diff --git a/tests/compiler/control_flow/branch-prediction.phpt b/tests/compiler/control_flow/branch-prediction.phpt
index 2f6e6727..7d12c524 100644
--- a/tests/compiler/control_flow/branch-prediction.phpt
+++ b/tests/compiler/control_flow/branch-prediction.phpt
@@ -11,7 +11,7 @@ function predicted_condition(int &$calls, bool $result): bool
 
 function main(): void
 {
-    $calls = 0;
+    $calls = std::any(0);
 
     if (std::expected(predicted_condition($calls, true))) {
         echo "expected\n";
diff --git a/tests/compiler/control_flow/expression-side-effects-composed.phpt b/tests/compiler/control_flow/expression-side-effects-composed.phpt
index 6073613a..bd92092b 100644
--- a/tests/compiler/control_flow/expression-side-effects-composed.phpt
+++ b/tests/compiler/control_flow/expression-side-effects-composed.phpt
@@ -10,7 +10,7 @@ function side_effect(string $label, &$counter, $value) {
 }
 
 function main() {
-    $n = 0;
+    $n = std::any(0);
 
     $ternary = side_effect('ternary-cond', $n, true)
         ? side_effect('ternary-if', $n, 'yes')
diff --git a/tests/compiler/decimal/arithmetic.phpt b/tests/compiler/decimal/arithmetic.phpt
index 2a063be7..042d73bf 100644
--- a/tests/compiler/decimal/arithmetic.phpt
+++ b/tests/compiler/decimal/arithmetic.phpt
@@ -2,7 +2,6 @@
 Decimal arithmetic operations
 --FILE--
 <?php
-declare(strict_types=1);
 function main(): void {
     $a = std::decimal("100.50");
     $b = std::decimal("50.25");
diff --git a/tests/compiler/decimal/assign_op.phpt b/tests/compiler/decimal/assign_op.phpt
index 5fb3be0e..fba93560 100644
--- a/tests/compiler/decimal/assign_op.phpt
+++ b/tests/compiler/decimal/assign_op.phpt
@@ -2,7 +2,6 @@
 Decimal compound assignment operators (+=, -=, *=, /=, %=)
 --FILE--
 <?php
-declare(strict_types=1);
 function main(): void {
     // Decimal +=
     $a = std::decimal("100.50");
diff --git a/tests/compiler/decimal/ceil.phpt b/tests/compiler/decimal/ceil.phpt
index ef616ae6..2af80165 100644
--- a/tests/compiler/decimal/ceil.phpt
+++ b/tests/compiler/decimal/ceil.phpt
@@ -2,7 +2,6 @@
 Decimal: ceil
 --FILE--
 <?php
-declare(strict_types=1);
 function main(): void {
     $a = std::decimal("3.2");
     var_dump($a->ceil()->toString());
diff --git a/tests/compiler/decimal/compare.phpt b/tests/compiler/decimal/compare.phpt
index d92bfc20..f03514e4 100644
--- a/tests/compiler/decimal/compare.phpt
+++ b/tests/compiler/decimal/compare.phpt
@@ -2,7 +2,6 @@
 Decimal comparison and conversions
 --FILE--
 <?php
-declare(strict_types=1);
 function main(): void {
     $a = std::decimal("123.456");
     $b = std::decimal("789.012");
diff --git a/tests/compiler/decimal/decimal_types.phpt b/tests/compiler/decimal/decimal_types.phpt
index c6a61552..bcfd881d 100644
--- a/tests/compiler/decimal/decimal_types.phpt
+++ b/tests/compiler/decimal/decimal_types.phpt
@@ -2,7 +2,6 @@
 use decimal_types — float literals auto-converted to Decimal
 --FILE--
 <?php
-declare(strict_types=1);
 use decimal_types;
 
 function main(): void {
diff --git a/tests/compiler/decimal/divmod.phpt b/tests/compiler/decimal/divmod.phpt
index 85a988ab..e847d9bf 100644
--- a/tests/compiler/decimal/divmod.phpt
+++ b/tests/compiler/decimal/divmod.phpt
@@ -2,7 +2,6 @@
 Decimal: divmod
 --FILE--
 <?php
-declare(strict_types=1);
 function main(): void {
     $a = std::decimal("10");
     $b = std::decimal("3");
diff --git a/tests/compiler/decimal/floor.phpt b/tests/compiler/decimal/floor.phpt
index 2fbba2f3..45258db7 100644
--- a/tests/compiler/decimal/floor.phpt
+++ b/tests/compiler/decimal/floor.phpt
@@ -2,7 +2,6 @@
 Decimal: floor
 --FILE--
 <?php
-declare(strict_types=1);
 function main(): void {
     $a = std::decimal("3.7");
     var_dump($a->floor()->toString());
diff --git a/tests/compiler/decimal/operator.phpt b/tests/compiler/decimal/operator.phpt
index 364a190e..c3981409 100644
--- a/tests/compiler/decimal/operator.phpt
+++ b/tests/compiler/decimal/operator.phpt
@@ -2,7 +2,6 @@
 Decimal operator overloading (+, -, *, /, %) and comparisons
 --FILE--
 <?php
-declare(strict_types=1);
 function main(): void {
     $dec = std::decimal("100.25");
 
diff --git a/tests/compiler/decimal/pow.phpt b/tests/compiler/decimal/pow.phpt
index d9dbc3ac..8069d355 100644
--- a/tests/compiler/decimal/pow.phpt
+++ b/tests/compiler/decimal/pow.phpt
@@ -2,7 +2,6 @@
 Decimal: pow
 --FILE--
 <?php
-declare(strict_types=1);
 function main(): void {
     $a = std::decimal("2");
     var_dump($a->pow(std::decimal("3"))->toString());
diff --git a/tests/compiler/decimal/powmod.phpt b/tests/compiler/decimal/powmod.phpt
index 8316b9c1..4fbb145c 100644
--- a/tests/compiler/decimal/powmod.phpt
+++ b/tests/compiler/decimal/powmod.phpt
@@ -2,7 +2,6 @@
 Decimal: powmod
 --FILE--
 <?php
-declare(strict_types=1);
 function main(): void {
     // 2^10 mod 1000 = 24
     $a = std::decimal("2");
diff --git a/tests/compiler/decimal/precision-and-exception-boundaries.phpt b/tests/compiler/decimal/precision-and-exception-boundaries.phpt
index c7064775..7fc256d9 100644
--- a/tests/compiler/decimal/precision-and-exception-boundaries.phpt
+++ b/tests/compiler/decimal/precision-and-exception-boundaries.phpt
@@ -2,7 +2,6 @@
 Decimal keeps 50 digits and translates native arithmetic errors
 --FILE--
 <?php
-declare(strict_types=1);
 function main(): void {
     $large = std::decimal("1234567890123456789012345678901234567890123456789");
     echo ($large + 1)->toString(), "\n";
diff --git a/tests/compiler/decimal/round.phpt b/tests/compiler/decimal/round.phpt
index 902b0618..09b1dcf9 100644
--- a/tests/compiler/decimal/round.phpt
+++ b/tests/compiler/decimal/round.phpt
@@ -2,7 +2,6 @@
 Decimal: round
 --FILE--
 <?php
-declare(strict_types=1);
 function main(): void {
     // round without precision (default 0, round to integer)
     $a = std::decimal("3.4");
diff --git a/tests/compiler/decimal/sqrt.phpt b/tests/compiler/decimal/sqrt.phpt
index 75a85550..6d73741e 100644
--- a/tests/compiler/decimal/sqrt.phpt
+++ b/tests/compiler/decimal/sqrt.phpt
@@ -2,7 +2,6 @@
 Decimal: sqrt
 --FILE--
 <?php
-declare(strict_types=1);
 function main(): void {
     $a = std::decimal("0");
     var_dump($a->sqrt()->toString());
diff --git a/tests/compiler/decimal/toFloat.phpt b/tests/compiler/decimal/toFloat.phpt
index 54462bd4..7af3ffae 100644
--- a/tests/compiler/decimal/toFloat.phpt
+++ b/tests/compiler/decimal/toFloat.phpt
@@ -2,7 +2,6 @@
 Decimal: toFloat
 --FILE--
 <?php
-declare(strict_types=1);
 function main(): void {
     $a = std::decimal("3.14");
     var_dump($a->toFloat());
diff --git a/tests/compiler/decimal/unary_minus.phpt b/tests/compiler/decimal/unary_minus.phpt
index a5ab7151..603b37f1 100644
--- a/tests/compiler/decimal/unary_minus.phpt
+++ b/tests/compiler/decimal/unary_minus.phpt
@@ -2,7 +2,6 @@
 Decimal unary minus operator
 --FILE--
 <?php
-declare(strict_types=1);
 function main(): void {
     $a = std::decimal("123.456");
 
diff --git a/tests/compiler/declare/strict_types.phpt b/tests/compiler/declare/strict_types.phpt
index 120d14cc..c1061a0f 100644
--- a/tests/compiler/declare/strict_types.phpt
+++ b/tests/compiler/declare/strict_types.phpt
@@ -1,8 +1,7 @@
 --TEST--
-declare: strict types 1
+dynamic calls remain strict without a declare directive
 --FILE--
 <?php
-declare(strict_types=1);
 function main() {
     $callable = 'strlen';
     try {
diff --git a/tests/compiler/dynamic_call/assignment-expression-receiver.phpt b/tests/compiler/dynamic_call/assignment-expression-receiver.phpt
index e8be849a..4920fa16 100644
--- a/tests/compiler/dynamic_call/assignment-expression-receiver.phpt
+++ b/tests/compiler/dynamic_call/assignment-expression-receiver.phpt
@@ -58,7 +58,7 @@ function makeAssignmentReceiver(int &$calls, string $value): AssignmentReceiver
 
 function main(): void
 {
-    $original = new AssignmentReceiver('base');
+    $original = std::any(new AssignmentReceiver('base'));
 
     echo ($assigned = $original)->id(), "\n";
     var_dump($assigned === $original);
@@ -67,7 +67,7 @@ function main(): void
     // control for the no-argument path fixed by this regression.
     echo ($withArgument = $original)->append('-arg'), "\n";
 
-    $calls = 0;
+    $calls = std::any(0);
     echo ($created = makeAssignmentReceiver($calls, 'factory'))->id(), "\n";
     var_dump($calls);
     echo $created->id(), "\n";
diff --git a/tests/compiler/dynamic_call/call-cache-arguments.phpt b/tests/compiler/dynamic_call/call-cache-arguments.phpt
index 9db6dcb9..49f5a512 100644
--- a/tests/compiler/dynamic_call/call-cache-arguments.phpt
+++ b/tests/compiler/dynamic_call/call-cache-arguments.phpt
@@ -38,7 +38,7 @@ function main(): void
     var_dump($sum(...$arguments));
 
     $increment = 'cached_increment';
-    $value = 10;
+    $value = std::any(10);
     var_dump($increment(std::ref($value)));
     var_dump($value);
 
diff --git a/tests/compiler/dynamic_call/call-magic-direct-safe.phpt b/tests/compiler/dynamic_call/call-magic-direct-safe.phpt
index 6af2f38b..300a85aa 100644
--- a/tests/compiler/dynamic_call/call-magic-direct-safe.phpt
+++ b/tests/compiler/dynamic_call/call-magic-direct-safe.phpt
@@ -51,7 +51,7 @@ function main(): void
 
     // Zend constructs __call()'s argument array by value. A source reference
     // must not leak into that array, including on the direct compiled path.
-    $source = 'original';
+    $source = std::any('original');
     $reference = &$source;
     $mutating = new MutatingMagic();
     var_dump($mutating->missing($reference));
diff --git a/tests/compiler/dynamic_call/call-parent-return-override-no-native-types.phpt b/tests/compiler/dynamic_call/call-parent-return-override-no-native-types.phpt
index 423d0014..292e83b5 100644
--- a/tests/compiler/dynamic_call/call-parent-return-override-no-native-types.phpt
+++ b/tests/compiler/dynamic_call/call-parent-return-override-no-native-types.phpt
@@ -1,5 +1,5 @@
 --TEST--
-call overridden method through parent parameter type without native_types
+call overridden method through parent parameter type with default scalar types
 --FILE--
 <?php
 class Base
diff --git a/tests/compiler/dynamic_call/new-named-args.phpt b/tests/compiler/dynamic_call/new-named-args.phpt
index d0967cac..065d7e72 100644
--- a/tests/compiler/dynamic_call/new-named-args.phpt
+++ b/tests/compiler/dynamic_call/new-named-args.phpt
@@ -2,7 +2,6 @@
 Dynamic instantiation with named arguments and dynamic method call
 --FILE--
 <?php
-declare(strict_types=1);
 
 class HelloController {
     public string $prefix;
diff --git a/tests/compiler/dynamic_call/vargs.phpt b/tests/compiler/dynamic_call/vargs.phpt
index 9b82d729..b86a1b95 100644
--- a/tests/compiler/dynamic_call/vargs.phpt
+++ b/tests/compiler/dynamic_call/vargs.phpt
@@ -4,7 +4,7 @@ named args
 <?php
 function main()
 {
-    $array = [1, 3, 5];
+    $array = std::any([1, 3, 5]);
     $push = [12, 33, 99];
     array_push($array, ...$push);
     var_dump($array);
@@ -24,4 +24,4 @@ array(6) {
   int(33)
   [5]=>
   int(99)
-}
\ No newline at end of file
+}
diff --git a/tests/compiler/float_edge/decimal-literal-classification.phpt b/tests/compiler/float_edge/decimal-literal-classification.phpt
index 41ecb2e5..93751666 100644
--- a/tests/compiler/float_edge/decimal-literal-classification.phpt
+++ b/tests/compiler/float_edge/decimal-literal-classification.phpt
@@ -2,7 +2,6 @@
 Auto-Decimal literal classification: significant digits, hex, float mixing
 --FILE--
 <?php
-declare(strict_types=1);
 
 function main(): void
 {
diff --git a/tests/compiler/functions/args-count.phpt b/tests/compiler/functions/args-count.phpt
index 52009450..a4d2dc04 100644
--- a/tests/compiler/functions/args-count.phpt
+++ b/tests/compiler/functions/args-count.phpt
@@ -2,7 +2,6 @@
 Zend wrappers validate required, optional, variadic and excessive arguments
 --FILE--
 <?php
-declare(strict_types=1);
 function noArgs() {
     echo "noArgs\n";
 }
diff --git a/tests/compiler/functions/array-push-unpack-side-effects.phpt b/tests/compiler/functions/array-push-unpack-side-effects.phpt
index 7ca6065e..95107c78 100644
--- a/tests/compiler/functions/array-push-unpack-side-effects.phpt
+++ b/tests/compiler/functions/array-push-unpack-side-effects.phpt
@@ -11,7 +11,7 @@ function make_push_values(): array
 
 function main(): void
 {
-    $items = [1];
+    $items = std::any([1]);
     $count = array_push($items, ...make_push_values());
 
     var_dump($count);
diff --git a/tests/compiler/functions/deep-recursion.phpt b/tests/compiler/functions/deep-recursion.phpt
index 0605b763..bdc1e6c4 100644
--- a/tests/compiler/functions/deep-recursion.phpt
+++ b/tests/compiler/functions/deep-recursion.phpt
@@ -77,7 +77,7 @@ function main() {
     var_dump(factorial(5));
     var_dump(factorial(10));
 
-    $memo = [];
+    $memo = std::any([]);
     var_dump(fib(10, $memo));
     var_dump(fib(15, $memo));
 
diff --git a/tests/compiler/functions/print.phpt b/tests/compiler/functions/print.phpt
index ec512144..0e099a43 100644
--- a/tests/compiler/functions/print.phpt
+++ b/tests/compiler/functions/print.phpt
@@ -2,7 +2,6 @@
 any
 --FILE--
 <?php
-declare(strict_types=1);
 
 interface I { function o(): string; }
 
diff --git a/tests/compiler/functions/wrapper-argument-move.phpt b/tests/compiler/functions/wrapper-argument-move.phpt
index 6224abce..49ca405b 100644
--- a/tests/compiler/functions/wrapper-argument-move.phpt
+++ b/tests/compiler/functions/wrapper-argument-move.phpt
@@ -18,7 +18,7 @@ function wrapper_argument_move(
 
 function main(): void
 {
-    $reference = 'before';
+    $reference = std::any('before');
     $object = (object) ['name' => 'object'];
     $result = wrapper_argument_move('mixed', 'text', [10], $object, 5, $reference, 'x', 'y');
     var_dump($reference, $result);
diff --git a/tests/compiler/generator/closure-generator.phpt b/tests/compiler/generator/closure-generator.phpt
index d4cb94a8..f4c92e1a 100644
--- a/tests/compiler/generator/closure-generator.phpt
+++ b/tests/compiler/generator/closure-generator.phpt
@@ -17,7 +17,7 @@ class GeneratorClosureBox
 
 function main(): void
 {
-    $state = 1;
+    $state = std::any(1);
     $factory = function (int $add) use (&$state): iterable {
         ++$state;
         $sent = yield 'closure' => $state + $add;
diff --git a/tests/compiler/include_require/001.phpt b/tests/compiler/include_require/001.phpt
index d30c8c2d..e6445b75 100644
--- a/tests/compiler/include_require/001.phpt
+++ b/tests/compiler/include_require/001.phpt
@@ -5,7 +5,6 @@ PHPRC=tests/compiler/include_require/no-leak.ini
 PHP_INI_SCAN_DIR={PWD}/empty-ini-dir
 --FILE--
 <?php
-declare(strict_types=1);
 function Hello(string $value) {}
 
 function includePath(string $name): string
diff --git a/tests/compiler/include_require/Hello.php b/tests/compiler/include_require/Hello.php
index 96b684de..9122c801 100644
--- a/tests/compiler/include_require/Hello.php
+++ b/tests/compiler/include_require/Hello.php
@@ -1,3 +1,2 @@
 <?php
-declare(strict_types=1);
 Hello();
diff --git a/tests/compiler/keyword_extension/001.phpt b/tests/compiler/keyword_extension/001.phpt
index 62431587..db76152b 100644
--- a/tests/compiler/keyword_extension/001.phpt
+++ b/tests/compiler/keyword_extension/001.phpt
@@ -2,7 +2,6 @@
 Keyword MethodsFor method with snake_case name
 --FILE--
 <?php
-declare(strict_types=1);
 #[MethodsFor('*')]
 final class KeywordExtensions
 {
diff --git a/tests/compiler/keyword_extension/camel.phpt b/tests/compiler/keyword_extension/camel.phpt
index e5a5f378..a5e6c911 100644
--- a/tests/compiler/keyword_extension/camel.phpt
+++ b/tests/compiler/keyword_extension/camel.phpt
@@ -2,7 +2,6 @@
 Keyword MethodsFor method with lowerCamelCase name
 --FILE--
 <?php
-declare(strict_types=1);
 
 #[MethodsFor('*')]
 final class KeywordExtensions
diff --git a/tests/compiler/keyword_method/to-any-to-ref.phpt b/tests/compiler/keyword_method/to-any-to-ref.phpt
index c9f617ce..38d97c33 100644
--- a/tests/compiler/keyword_method/to-any-to-ref.phpt
+++ b/tests/compiler/keyword_method/to-any-to-ref.phpt
@@ -24,7 +24,7 @@ function main(): void
     $b = 4;
     var_dump($a->toAny() / $b->toAny());
 
-    $name = 'php ';
+    $name = std::any('php ');
     append_text($name->toRef(), 'keyword');
     var_dump($name);
 
@@ -38,11 +38,11 @@ function main(): void
     var_dump($obj->prop);
 
     $fn = 'set_value';
-    $dynamic = 'old';
+    $dynamic = std::any('old');
     $fn($dynamic->toRef(), 'dynamic');
     var_dump($dynamic);
 
-    $named = 'old';
+    $named = std::any('old');
     $fn = 'set_named';
     $fn(label: 'named', value: $named->toRef());
     var_dump($named);
diff --git a/tests/compiler/loop/foreach-array-edge-cases.phpt b/tests/compiler/loop/foreach-array-edge-cases.phpt
index 5344ff41..feec4e7e 100644
--- a/tests/compiler/loop/foreach-array-edge-cases.phpt
+++ b/tests/compiler/loop/foreach-array-edge-cases.phpt
@@ -38,7 +38,7 @@ function main(): void
         echo "unreachable\n";
     }
 
-    $inner = 1;
+    $inner = std::any(1);
     $references = [&$inner];
     foreach ($references as $value) {
         $value = 9;
diff --git a/tests/compiler/loop/foreach-direct-array-targets.phpt b/tests/compiler/loop/foreach-direct-array-targets.phpt
index d7382292..77f974c5 100644
--- a/tests/compiler/loop/foreach-direct-array-targets.phpt
+++ b/tests/compiler/loop/foreach-direct-array-targets.phpt
@@ -35,7 +35,7 @@ function main(): void
     var_dump(valuesOnly([10, 20]));
     var_dump(sameTarget([7 => 'last-value']));
 
-    $source = 10;
+    $source = std::any(10);
     $values = [&$source];
     foreach ($values as $value) {
         $value = 99;
diff --git a/tests/compiler/magic_methods/indirect-update.phpt b/tests/compiler/magic_methods/indirect-update.phpt
index 5c96bab9..eab7ce2c 100644
--- a/tests/compiler/magic_methods/indirect-update.phpt
+++ b/tests/compiler/magic_methods/indirect-update.phpt
@@ -2,7 +2,6 @@
 Magic Methods - indirect property update uses __get by reference
 --FILE--
 <?php
-declare(strict_types=1);
 
 class MagicUpdateTest
 {
diff --git a/tests/compiler/magic_methods/named-property-cache.phpt b/tests/compiler/magic_methods/named-property-cache.phpt
index b7e14042..3654dbe2 100644
--- a/tests/compiler/magic_methods/named-property-cache.phpt
+++ b/tests/compiler/magic_methods/named-property-cache.phpt
@@ -2,7 +2,6 @@
 Named magic property cache preserves polymorphism, dynamic names, and receiver evaluation
 --FILE--
 <?php
-declare(strict_types=1);
 
 class FirstMagicProperty
 {
@@ -161,7 +160,7 @@ function main(): void
     var_dump(readNamedProperty($throwing), $throwing->getCalls);
 
     // A parenthesized receiver is cacheable, but is still evaluated once.
-    $calls = 0;
+    $calls = std::any(0);
     namedPropertyReceiver($first, $calls)->value = 50;
     var_dump($calls, namedPropertyReceiver($first, $calls)->value, $calls);
 }
diff --git a/tests/compiler/magic_methods/read-skips-isset.phpt b/tests/compiler/magic_methods/read-skips-isset.phpt
index 7dba37ee..1d6a2472 100644
--- a/tests/compiler/magic_methods/read-skips-isset.phpt
+++ b/tests/compiler/magic_methods/read-skips-isset.phpt
@@ -2,7 +2,6 @@
 Magic Methods - a plain property read invokes __get, never __isset
 --FILE--
 <?php
-declare(strict_types=1);
 
 class MagicReadTest
 {
diff --git a/tests/compiler/namespace/namespace-ending-comment.phpt b/tests/compiler/namespace/namespace-ending-comment.phpt
index e937a711..350907a0 100644
--- a/tests/compiler/namespace/namespace-ending-comment.phpt
+++ b/tests/compiler/namespace/namespace-ending-comment.phpt
@@ -3,7 +3,6 @@ A namespace block ending with a comment must not be treated as stray code
 --FILE--
 <?php
 
-declare(strict_types=1);
 
 namespace Test {
     /* named namespace trailing block comment */
diff --git a/tests/compiler/native-class/any-property-reference.phpt b/tests/compiler/native-class/any-property-reference.phpt
index 3d4b0ccf..7c4c79aa 100644
--- a/tests/compiler/native-class/any-property-reference.phpt
+++ b/tests/compiler/native-class/any-property-reference.phpt
@@ -38,7 +38,7 @@ function main(): void
     replaceAny($object->child->value, 'direct argument');
     var_dump($childReference);
 
-    $source = 'assigned reference';
+    $source = std::any('assigned reference');
     $object->value =& $source;
     $source = 'source changed';
     var_dump($object->value);
diff --git a/tests/compiler/nullsafe/nullsafe-chain-typed-return.phpt b/tests/compiler/nullsafe/nullsafe-chain-typed-return.phpt
index 6c990e8a..2896884b 100644
--- a/tests/compiler/nullsafe/nullsafe-chain-typed-return.phpt
+++ b/tests/compiler/nullsafe/nullsafe-chain-typed-return.phpt
@@ -2,7 +2,6 @@
 Nullsafe chain preserves typed method returns and member names
 --FILE--
 <?php
-declare(strict_types=1);
 
 final class NullsafeTypedReturnLeaf
 {
diff --git a/tests/compiler/object_property/default-mixed-array.phpt b/tests/compiler/object_property/default-mixed-array.phpt
index dbb4e883..7b62e2ae 100644
--- a/tests/compiler/object_property/default-mixed-array.phpt
+++ b/tests/compiler/object_property/default-mixed-array.phpt
@@ -3,7 +3,6 @@ property default value is array with mixed declared type
 --FILE--
 <?php
 
-declare(strict_types=1);
 
 class Test
 {
diff --git a/tests/compiler/object_property/dynamic-property-string-name.phpt b/tests/compiler/object_property/dynamic-property-string-name.phpt
index c9df8c18..e8045f48 100644
--- a/tests/compiler/object_property/dynamic-property-string-name.phpt
+++ b/tests/compiler/object_property/dynamic-property-string-name.phpt
@@ -31,7 +31,7 @@ function writeName(DynamicNameBag $bag, mixed $name, mixed $value): void
 function main(): void
 {
     $bag = new DynamicNameBag();
-    $name = 'answer';
+    $name = std::any('answer');
     writeName($bag, $name, 42);
     var_dump(readName($bag, $name));
 
diff --git a/tests/compiler/object_property/dynamic-property-write-fast-path.phpt b/tests/compiler/object_property/dynamic-property-write-fast-path.phpt
index ad08be30..d59fc4c9 100644
--- a/tests/compiler/object_property/dynamic-property-write-fast-path.phpt
+++ b/tests/compiler/object_property/dynamic-property-write-fast-path.phpt
@@ -2,7 +2,6 @@
 Dynamic property statement writes preserve scope, evaluation and reference value semantics
 --FILE--
 <?php
-declare(strict_types=1);
 
 final class DynamicWriter
 {
@@ -42,11 +41,11 @@ function main(): void
     $writer->write($name, 17);
     var_dump($writer->value());
 
-    $calls = 0;
+    $calls = std::any(0);
     $writer->writeComputed($name, $calls);
     var_dump($writer->value(), $calls);
 
-    $source = 42;
+    $source = std::any(42);
     $writer->writeFromReference($name, $source);
     $source = 43;
     var_dump($writer->value(), $source);
diff --git a/tests/compiler/object_property/int-property-compound-assignment.phpt b/tests/compiler/object_property/int-property-compound-assignment.phpt
index aba96679..815e4d4b 100644
--- a/tests/compiler/object_property/int-property-compound-assignment.phpt
+++ b/tests/compiler/object_property/int-property-compound-assignment.phpt
@@ -2,7 +2,6 @@
 Typed int property compound assignments use PHP arithmetic and checked writes
 --FILE--
 <?php
-declare(strict_types=1);
 use varint_types;
 
 class IntCompoundBox
diff --git a/tests/compiler/object_property/native-int-property-assign.phpt b/tests/compiler/object_property/native-int-property-assign.phpt
index 009fe342..2a783318 100644
--- a/tests/compiler/object_property/native-int-property-assign.phpt
+++ b/tests/compiler/object_property/native-int-property-assign.phpt
@@ -2,7 +2,6 @@
 Native int property assignment follows strict property type rules
 --FILE--
 <?php
-declare(strict_types=1);
 class GridSize
 {
     public int $size = 0;
diff --git a/tests/compiler/object_property/native-types-int-property-compound-assignment.phpt b/tests/compiler/object_property/native-types-int-property-compound-assignment.phpt
index f08a58ae..3f1374ee 100644
--- a/tests/compiler/object_property/native-types-int-property-compound-assignment.phpt
+++ b/tests/compiler/object_property/native-types-int-property-compound-assignment.phpt
@@ -1,5 +1,5 @@
 --TEST--
-Native-types int property compound assignments use C++ integer semantics
+Default int property compound assignments use C++ integer semantics
 --FILE--
 <?php
 class NativeTypesIntCompoundBox
@@ -22,8 +22,8 @@ function nativeTypesIntCompoundOperand(int $value, int &$calls): int
 function main(): void
 {
     $box = new NativeTypesIntCompoundBox();
-    $receiverCalls = 0;
-    $operandCalls = 0;
+    $receiverCalls = std::any(0);
+    $operandCalls = std::any(0);
 
     $box->value = 7;
     $result = nativeTypesIntCompoundReceiver($box, $receiverCalls)->value
diff --git a/tests/compiler/object_property/property-array-write-composed-expr.phpt b/tests/compiler/object_property/property-array-write-composed-expr.phpt
index 3f12b0b0..43faf2b1 100644
--- a/tests/compiler/object_property/property-array-write-composed-expr.phpt
+++ b/tests/compiler/object_property/property-array-write-composed-expr.phpt
@@ -25,7 +25,7 @@ function next_value(&$counter) {
 
 function main() {
     $box = new PropertyArrayWriteComposedBox();
-    $counter = 0;
+    $counter = std::any(0);
 
     $a = ($box->node->items[] = next_value($counter));
     $b = true ? ($box->node->items['k'] = next_value($counter)) : 99;
diff --git a/tests/compiler/object_property/property-known-string-names.phpt b/tests/compiler/object_property/property-known-string-names.phpt
index 339ddb4f..81f8b1a1 100644
--- a/tests/compiler/object_property/property-known-string-names.phpt
+++ b/tests/compiler/object_property/property-known-string-names.phpt
@@ -42,10 +42,10 @@ function main(): void
     var_dump($object->values());
 
     $reflection = new ReflectionClass(KnownStringProperties::class);
-    $names = array_map(
+    $names = std::any(array_map(
         static fn (ReflectionProperty $property): string => $property->getName(),
         $reflection->getProperties(),
-    );
+    ));
     sort($names);
     var_dump($names);
 }
diff --git a/tests/compiler/operator/array-statement-write-optimized.phpt b/tests/compiler/operator/array-statement-write-optimized.phpt
index ce8177b6..5a3fbd8b 100644
--- a/tests/compiler/operator/array-statement-write-optimized.phpt
+++ b/tests/compiler/operator/array-statement-write-optimized.phpt
@@ -2,7 +2,6 @@
 Known array statement writes preserve references, keys and expression results
 --FILE--
 <?php
-declare(strict_types=1);
 
 function main(): void
 {
diff --git a/tests/compiler/operator/compound-assign.phpt b/tests/compiler/operator/compound-assign.phpt
index a500e8f8..d528b249 100644
--- a/tests/compiler/operator/compound-assign.phpt
+++ b/tests/compiler/operator/compound-assign.phpt
@@ -30,7 +30,7 @@ function main() {
     var_dump($c);
 
     // Reference assignment
-    $y = 2;
+    $y = std::any(2);
     $z = &$y;
     $y = 5;
     var_dump($z);
diff --git a/tests/compiler/operator/constant-int-arithmetic-overflow.phpt b/tests/compiler/operator/constant-int-arithmetic-overflow.phpt
index efee3517..13962eda 100644
--- a/tests/compiler/operator/constant-int-arithmetic-overflow.phpt
+++ b/tests/compiler/operator/constant-int-arithmetic-overflow.phpt
@@ -2,7 +2,6 @@
 Constant integer arithmetic overflow promotes to float like PHP
 --FILE--
 <?php
-declare(strict_types=1);
 use varint_types;
 
 function overflowInferred()
diff --git a/tests/compiler/operator/constant-shift-boundaries.phpt b/tests/compiler/operator/constant-shift-boundaries.phpt
index 6b389326..aaa05a4f 100644
--- a/tests/compiler/operator/constant-shift-boundaries.phpt
+++ b/tests/compiler/operator/constant-shift-boundaries.phpt
@@ -2,7 +2,6 @@
 Constant bit shift boundaries follow PHP semantics
 --FILE--
 <?php
-declare(strict_types=1);
 
 function main(): void
 {
diff --git a/tests/compiler/operator/eval-order-side-effects.phpt b/tests/compiler/operator/eval-order-side-effects.phpt
index 4c885941..2e4cb2d9 100644
--- a/tests/compiler/operator/eval-order-side-effects.phpt
+++ b/tests/compiler/operator/eval-order-side-effects.phpt
@@ -2,7 +2,6 @@
 Call arguments and concat operands follow Zend's operand read order around side effects
 --FILE--
 <?php
-declare(strict_types=1);
 
 function pair(int $a, int $b): string
 {
diff --git a/tests/compiler/operator/literal-division-by-zero-runtime.phpt b/tests/compiler/operator/literal-division-by-zero-runtime.phpt
index 1f07b29e..18ee6fd3 100644
--- a/tests/compiler/operator/literal-division-by-zero-runtime.phpt
+++ b/tests/compiler/operator/literal-division-by-zero-runtime.phpt
@@ -2,7 +2,6 @@
 Literal zero divisors compile and raise catchable DivisionByZeroError at runtime
 --FILE--
 <?php
-declare(strict_types=1);
 
 function main(): void
 {
diff --git a/tests/compiler/operator/runtime-int-division.phpt b/tests/compiler/operator/runtime-int-division.phpt
index 06c9e972..77ee2bbd 100644
--- a/tests/compiler/operator/runtime-int-division.phpt
+++ b/tests/compiler/operator/runtime-int-division.phpt
@@ -2,7 +2,6 @@
 Runtime int division preserves PHP exact, fractional, overflow and zero-divisor semantics
 --FILE--
 <?php
-declare(strict_types=1);
 use varint_types;
 
 function divide(int $left, int $right): mixed
diff --git a/tests/compiler/operator/runtime-int-overflow-return.phpt b/tests/compiler/operator/runtime-int-overflow-return.phpt
index 0d439f81..0b83ba15 100644
--- a/tests/compiler/operator/runtime-int-overflow-return.phpt
+++ b/tests/compiler/operator/runtime-int-overflow-return.phpt
@@ -2,7 +2,6 @@
 Runtime integer overflow is checked at an int return boundary
 --FILE--
 <?php
-declare(strict_types=1);
 use varint_types;
 
 final class OverflowProperties
diff --git a/tests/compiler/operator/string-concat-assign-in-place.phpt b/tests/compiler/operator/string-concat-assign-in-place.phpt
index 2816bb0d..b85c620d 100644
--- a/tests/compiler/operator/string-concat-assign-in-place.phpt
+++ b/tests/compiler/operator/string-concat-assign-in-place.phpt
@@ -2,7 +2,6 @@
 String concat assignment preserves PHP value, COW and expression semantics
 --FILE--
 <?php
-declare(strict_types=1);
 
 final class ConcatAssignStringable
 {
diff --git a/tests/compiler/operator/ternary-ref-captured.phpt b/tests/compiler/operator/ternary-ref-captured.phpt
index 7fa2704c..d068a6af 100644
--- a/tests/compiler/operator/ternary-ref-captured.phpt
+++ b/tests/compiler/operator/ternary-ref-captured.phpt
@@ -9,8 +9,8 @@ function &ternary_ref_value(mixed &$value): mixed
 
 function main(): void
 {
-    $first = 1;
-    $second = 2;
+    $first = std::any(1);
+    $second = std::any(2);
     $values = [1];
 
     $result = count($values) > 0
diff --git a/tests/compiler/operator/ternary-typed-arg.phpt b/tests/compiler/operator/ternary-typed-arg.phpt
index efc0d508..3ceed3b4 100644
--- a/tests/compiler/operator/ternary-typed-arg.phpt
+++ b/tests/compiler/operator/ternary-typed-arg.phpt
@@ -2,7 +2,6 @@
 Ternary with captured statements keeps its static type for typed arguments
 --FILE--
 <?php
-declare(strict_types=1);
 
 class TernaryBoolArg
 {
diff --git a/tests/compiler/operator/traditional-syntax-regression.phpt b/tests/compiler/operator/traditional-syntax-regression.phpt
index 8a146cdc..285cbfa3 100644
--- a/tests/compiler/operator/traditional-syntax-regression.phpt
+++ b/tests/compiler/operator/traditional-syntax-regression.phpt
@@ -21,7 +21,7 @@ function main(): void
     $highOr = false || true;
     var_dump($lowAnd, $highAnd, $lowOr, $highOr);
 
-    $events = [];
+    $events = std::any([]);
     $andResult = traditional_record($events, 'and-left', false)
         and traditional_record($events, 'and-right', true);
     $orResult = traditional_record($events, 'or-left', true)
diff --git a/tests/compiler/operator/typed-int-float-division.phpt b/tests/compiler/operator/typed-int-float-division.phpt
index 6e94b62f..4a745713 100644
--- a/tests/compiler/operator/typed-int-float-division.phpt
+++ b/tests/compiler/operator/typed-int-float-division.phpt
@@ -2,7 +2,6 @@
 Typed int and float division follows PHP semantics (fractional result, DivisionByZeroError)
 --FILE--
 <?php
-declare(strict_types=1);
 use varint_types;
 
 function divInts(int $a, int $b): float
diff --git a/tests/compiler/operator/typed-int-mod-shift.phpt b/tests/compiler/operator/typed-int-mod-shift.phpt
index 5ad23fa6..44577ef8 100644
--- a/tests/compiler/operator/typed-int-mod-shift.phpt
+++ b/tests/compiler/operator/typed-int-mod-shift.phpt
@@ -2,7 +2,6 @@
 Typed int modulo and shifts follow PHP semantics (errors, boundaries)
 --FILE--
 <?php
-declare(strict_types=1);
 
 function modInts(int $a, int $b): int
 {
diff --git a/tests/compiler/operator/unary-minus-parens.phpt b/tests/compiler/operator/unary-minus-parens.phpt
index 8464b182..435f5a7f 100644
--- a/tests/compiler/operator/unary-minus-parens.phpt
+++ b/tests/compiler/operator/unary-minus-parens.phpt
@@ -2,7 +2,6 @@
 Unary minus applies to the whole operand expression
 --FILE--
 <?php
-declare(strict_types=1);
 
 function pick(int $a, int $b, int $c): int
 {
diff --git a/tests/compiler/optimizations/final-int-property-add-chain.phpt b/tests/compiler/optimizations/final-int-property-add-chain.phpt
index 2371507e..908b2ede 100644
--- a/tests/compiler/optimizations/final-int-property-add-chain.phpt
+++ b/tests/compiler/optimizations/final-int-property-add-chain.phpt
@@ -2,7 +2,6 @@
 Final int property addition uses a detached value accumulator
 --FILE--
 <?php
-declare(strict_types=1);
 
 final class AddChain
 {
diff --git a/tests/compiler/optimizations/narrow-ref-prevent.phpt b/tests/compiler/optimizations/narrow-ref-prevent.phpt
index f7a0b483..9ce0d3ab 100644
--- a/tests/compiler/optimizations/narrow-ref-prevent.phpt
+++ b/tests/compiler/optimizations/narrow-ref-prevent.phpt
@@ -3,7 +3,7 @@ SSA narrowing: reference assignment prevents narrowing
 --FILE--
 <?php
 function main(): void {
-    $a = 100;
+    $a = std::any(100);
     $b = &$a;
     $a = 200;
     echo $b, PHP_EOL;
diff --git a/tests/compiler/optimizations/typed-read-fast-path.phpt b/tests/compiler/optimizations/typed-read-fast-path.phpt
index 0789d3ec..12679958 100644
--- a/tests/compiler/optimizations/typed-read-fast-path.phpt
+++ b/tests/compiler/optimizations/typed-read-fast-path.phpt
@@ -21,7 +21,7 @@ function inspectSelections(array $values, string $text, bool $flag): void
 
 function main(): void
 {
-    $referenced = 3;
+    $referenced = std::any(3);
     $values = [
         'value' => 1,
         '12' => 'numeric key',
diff --git a/tests/compiler/place-holder/globals-null-arithmetic.phpt b/tests/compiler/place-holder/globals-null-arithmetic.phpt
index de2ae550..a1b0db89 100644
--- a/tests/compiler/place-holder/globals-null-arithmetic.phpt
+++ b/tests/compiler/place-holder/globals-null-arithmetic.phpt
@@ -2,7 +2,6 @@
 NULL globals in arithmetic should treat NULL as 0
 --FILE--
 <?php
-declare(strict_types=1);
 
 // Test 1: NULL global += float
 function test_global_add() {
diff --git a/tests/compiler/python/conversion-errors.phpt b/tests/compiler/python/conversion-errors.phpt
index 38f86048..35f0ebf8 100644
--- a/tests/compiler/python/conversion-errors.phpt
+++ b/tests/compiler/python/conversion-errors.phpt
@@ -17,7 +17,7 @@ function main(): void
         echo "invalid utf8\n";
     }
 
-    $recursive = [];
+    $recursive = std::any([]);
     $recursive['self'] = &$recursive;
     try {
         python\repr($recursive);
diff --git a/tests/compiler/ref/002.phpt b/tests/compiler/ref/002.phpt
index 94da74bb..b0e364d8 100644
--- a/tests/compiler/ref/002.phpt
+++ b/tests/compiler/ref/002.phpt
@@ -4,7 +4,7 @@ ref 002
 <?php
 function main()
 {
-    $a = [1, 2, 3];
+    $a = std::any([1, 2, 3]);
     $b = &$a;
     $b[] = 5;
     var_dump($a);
@@ -20,4 +20,4 @@ array(4) {
   int(3)
   [3]=>
   int(5)
-}
\ No newline at end of file
+}
diff --git a/tests/compiler/ref/003.phpt b/tests/compiler/ref/003.phpt
index c0bb7903..4eafa96e 100644
--- a/tests/compiler/ref/003.phpt
+++ b/tests/compiler/ref/003.phpt
@@ -4,7 +4,7 @@ ref 003
 <?php
 function main()
 {
-    $a = [1, 2, 3];
+    $a = std::any([1, 2, 3]);
     $c = $d = $e = &$a;
 
     $e[] = 5;
@@ -40,4 +40,4 @@ array(4) {
   int(3)
   [3]=>
   int(5)
-}
\ No newline at end of file
+}
diff --git a/tests/compiler/ref/004.phpt b/tests/compiler/ref/004.phpt
index 37f6896c..413416de 100644
--- a/tests/compiler/ref/004.phpt
+++ b/tests/compiler/ref/004.phpt
@@ -5,7 +5,7 @@ ref 004
 function main()
 {
     $a = [1, 2, 3];
-    $b = [4, 5];
+    $b = std::any([4, 5]);
     $a[] = &$b;
     var_dump($a);
 
@@ -36,4 +36,4 @@ array(3) {
   int(5)
   [2]=>
   int(10)
-}
\ No newline at end of file
+}
diff --git a/tests/compiler/ref/007.phpt b/tests/compiler/ref/007.phpt
index bc8f182c..0191e482 100644
--- a/tests/compiler/ref/007.phpt
+++ b/tests/compiler/ref/007.phpt
@@ -9,7 +9,7 @@ class WorkerA
     }
 
     public function baz(string $name) {
-        $value = '';
+        $value = std::any('');
         $this->foo($name, $value);
         return $value;
     }
@@ -18,7 +18,7 @@ class WorkerA
 class WorkerB extends WorkerA
 {
     public function bar(string $name) {
-        $value = '';
+        $value = std::any('');
         $this->foo($name, $value);
         return $value;
     }
@@ -35,4 +35,4 @@ function main()
 ?>
 --EXPECT--
 string(9) "hello php"
-string(12) "hello swoole"
\ No newline at end of file
+string(12) "hello swoole"
diff --git a/tests/compiler/ref/008.phpt b/tests/compiler/ref/008.phpt
index 4135787c..48de904e 100644
--- a/tests/compiler/ref/008.phpt
+++ b/tests/compiler/ref/008.phpt
@@ -5,7 +5,7 @@ class const 001
 class WorkerA
 {
     public function foo(): array {
-        $list = [377, 64, 688, 2];
+        $list = std::any([377, 64, 688, 2]);
         $ref = &$list;
         $this->sort($ref);
         return $list;
@@ -32,4 +32,4 @@ array(4) {
   int(377)
   [3]=>
   int(688)
-}
\ No newline at end of file
+}
diff --git a/tests/compiler/ref/009.phpt b/tests/compiler/ref/009.phpt
index 2b2ff674..c376688d 100644
--- a/tests/compiler/ref/009.phpt
+++ b/tests/compiler/ref/009.phpt
@@ -19,7 +19,7 @@ class WorkerA
 class WorkerB extends WorkerA
 {
     public function foo(): array {
-        $list = [377, 64, 688, 2];
+        $list = std::any([377, 64, 688, 2]);
         $ref = &$list;
         $this->sort($ref);
         return $list;
@@ -42,4 +42,4 @@ array(4) {
   int(377)
   [3]=>
   int(688)
-}
\ No newline at end of file
+}
diff --git a/tests/compiler/ref/array-ref-assign-002.phpt b/tests/compiler/ref/array-ref-assign-002.phpt
index ac441ca0..5d8ca7b3 100644
--- a/tests/compiler/ref/array-ref-assign-002.phpt
+++ b/tests/compiler/ref/array-ref-assign-002.phpt
@@ -10,8 +10,8 @@ class RefSource
 
 function main()
 {
-    $x = 10;
-    $y = 20;
+    $x = std::any(10);
+    $y = std::any(20);
     $arr = [1, 2, 3];
     $arr[0] = &$x;   // 覆盖已有元素为引用
     $arr[5] = &$y;   // 新建元素为引用
@@ -25,7 +25,7 @@ function main()
     var_dump($x, $y); // 111, 222
 
     // 嵌套：引用赋值到多维数组元素
-    $z = 7;
+    $z = std::any(7);
     $m = [[1], [2]];
     $m[0][0] = &$z;
     $z = 77;
diff --git a/tests/compiler/ref/array-ref-assign-003.phpt b/tests/compiler/ref/array-ref-assign-003.phpt
index 6e9f8ca4..0e42078f 100644
--- a/tests/compiler/ref/array-ref-assign-003.phpt
+++ b/tests/compiler/ref/array-ref-assign-003.phpt
@@ -14,13 +14,13 @@ function writeReferencedContainer(mixed &$container, mixed $value): void
 
 function main()
 {
-    $referenced = 10;
+    $referenced = std::any(10);
     $array = [&$referenced];
     writeElement($array, 0, 123);
     var_dump($referenced, $array[0]);
 
-    $referencedAgain = 20;
-    $arrayByReference = [&$referencedAgain];
+    $referencedAgain = std::any(20);
+    $arrayByReference = std::any([&$referencedAgain]);
     writeReferencedContainer($arrayByReference, 234);
     var_dump($referencedAgain, $arrayByReference[0]);
 
diff --git a/tests/compiler/ref/array-value-write-dereferences-source.phpt b/tests/compiler/ref/array-value-write-dereferences-source.phpt
index aa7669b2..229b3eef 100644
--- a/tests/compiler/ref/array-value-write-dereferences-source.phpt
+++ b/tests/compiler/ref/array-value-write-dereferences-source.phpt
@@ -5,7 +5,7 @@ ordinary array writes copy referenced sources while explicit references stay lin
 
 function main()
 {
-    $source = 1;
+    $source = std::any(1);
     $reference =& $source;
 
     $appended = [];
@@ -21,9 +21,9 @@ function main()
     $reference = 2;
     var_dump($appended, $keyed, $literal, $mixedLiteral, $explicitReference);
 
-    $target = 10;
+    $target = std::any(10);
     $targetArray = [&$target];
-    $other = 20;
+    $other = std::any(20);
     $otherReference =& $other;
     $targetArray[0] = $otherReference;
     $otherReference = 30;
diff --git a/tests/compiler/ref/basic.phpt b/tests/compiler/ref/basic.phpt
index 32457804..05c5f20f 100644
--- a/tests/compiler/ref/basic.phpt
+++ b/tests/compiler/ref/basic.phpt
@@ -6,7 +6,7 @@ function main()
 {
     require __DIR__ . '/../../../src/Assert.php';
 
-    $a = [1, 2, 3];
+    $a = std::any([1, 2, 3]);
     $b = &$a;
     $b[] = 5;
 
@@ -17,7 +17,7 @@ function main()
     Assert::eq(count($b), 5);
     Assert::eq(count($c), 5);
 
-    $array = [1, 2, 3];
+    $array = std::any([1, 2, 3]);
 
     $ref = &$array;
     $ref[1] = 2026;
diff --git a/tests/compiler/ref/dynamic-return-reference-argument.phpt b/tests/compiler/ref/dynamic-return-reference-argument.phpt
index aede4d2a..d69ead11 100644
--- a/tests/compiler/ref/dynamic-return-reference-argument.phpt
+++ b/tests/compiler/ref/dynamic-return-reference-argument.phpt
@@ -27,7 +27,8 @@ function &test1()
 
 function &test2()
 {
-    static $value = 0;
+    static $value;
+    $value ??= 0;
     ++$value;
     return $value;
 }
@@ -40,7 +41,8 @@ function value_order(string $label): string
 
 function &ref_order(string $label)
 {
-    static $value = 42;
+    static $value;
+    $value ??= 42;
     echo "$label\n";
     return $value;
 }
diff --git a/tests/compiler/ref/dynamic-return-reference-chain.phpt b/tests/compiler/ref/dynamic-return-reference-chain.phpt
index 60015aae..fabcb257 100644
--- a/tests/compiler/ref/dynamic-return-reference-chain.phpt
+++ b/tests/compiler/ref/dynamic-return-reference-chain.phpt
@@ -4,7 +4,8 @@ Reference-returning functions can forward dynamic and chained calls
 <?php
 function &dynamic_source(): mixed
 {
-    static $value = 1;
+    static $value;
+    $value ??= 1;
     return $value;
 }
 
diff --git a/tests/compiler/ref/fixed-storage-explicit-any.phpt b/tests/compiler/ref/fixed-storage-explicit-any.phpt
new file mode 100644
index 00000000..79c207c0
--- /dev/null
+++ b/tests/compiler/ref/fixed-storage-explicit-any.phpt
@@ -0,0 +1,29 @@
+--TEST--
+std::any explicitly enables reference mutation before conversion to fixed types
+--FILE--
+<?php
+function main(): void
+{
+    $stringValue = std::any('start');
+    $replaceWithArray = static function () use (&$stringValue): void {
+        $stringValue = ['value' => 42];
+    };
+    $replaceWithArray();
+    $arrayValue = $stringValue->toArray();
+    var_dump($arrayValue);
+
+    $arraySource = std::any(['old']);
+    $replaceWithString = static function () use (&$arraySource): void {
+        $arraySource = 'done';
+    };
+    $replaceWithString();
+    $finalString = $arraySource->toString();
+    var_dump($finalString);
+}
+?>
+--EXPECT--
+array(1) {
+  ["value"]=>
+  int(42)
+}
+string(4) "done"
diff --git a/tests/compiler/ref/function-return-reference.phpt b/tests/compiler/ref/function-return-reference.phpt
index 3836d2fa..d792d999 100644
--- a/tests/compiler/ref/function-return-reference.phpt
+++ b/tests/compiler/ref/function-return-reference.phpt
@@ -15,7 +15,7 @@ function value_copy()
 function main()
 {
     global $value;
-    $value = 1;
+    $value = std::any(1);
     $alias =& value_ref();
     $alias = 42;
     var_dump(value_ref());
@@ -45,7 +45,7 @@ function main()
 
 function &local_ref()
 {
-    $value = 1;
+    $value = std::any(1);
     return $value;
 }
 ?>
diff --git a/tests/compiler/ref/nested-reference-return.phpt b/tests/compiler/ref/nested-reference-return.phpt
index f9985fd2..edcb44a8 100644
--- a/tests/compiler/ref/nested-reference-return.phpt
+++ b/tests/compiler/ref/nested-reference-return.phpt
@@ -25,10 +25,10 @@ function &object_property_ref(NestedReferenceBox $box): mixed
 
 function main(): void
 {
-    $values = [
+    $values = std::any([
         'item' => 'before',
         'outer' => ['inner' => 'nested-before'],
-    ];
+    ]);
 
     $item =& array_element_ref($values);
     $item = 'after';
diff --git a/tests/compiler/ref/property-reference-rebind.phpt b/tests/compiler/ref/property-reference-rebind.phpt
index 4308f434..27934301 100644
--- a/tests/compiler/ref/property-reference-rebind.phpt
+++ b/tests/compiler/ref/property-reference-rebind.phpt
@@ -2,7 +2,6 @@
 Object property reference assignment preserves aliases and typed-property sources
 --FILE--
 <?php
-declare(strict_types=1);
 
 final class PropertyReferenceHolder
 {
@@ -73,19 +72,19 @@ function trackThroughSplObjectStorage(object $target): PropertyReferenceDep
 function main(): void
 {
     $holder = new PropertyReferenceHolder();
-    $source = ['initial' => 1];
+    $source = std::any(['initial' => 1]);
     $holder->value = &$source;
     $source['source'] = 2;
     $holder->value['property'] = 3;
     var_dump($source);
 
     $dynamicHolder = new PropertyReferenceHolder();
-    $dynamicSource = [];
+    $dynamicSource = std::any([]);
     bindObjectProperty($dynamicHolder, $dynamicSource);
     $dynamicSource['dynamic'] = true;
     var_dump($dynamicHolder->value);
 
-    $wrong = 'invalid';
+    $wrong = std::any('invalid');
     try {
         bindObjectProperty($dynamicHolder, $wrong);
         echo "missing initial TypeError\n";
@@ -95,7 +94,7 @@ function main(): void
     $dynamicSource['preserved'] = true;
     var_dump($dynamicHolder->value);
 
-    $replacement = ['replacement' => true];
+    $replacement = std::any(['replacement' => true]);
     $holder->value = &$replacement;
     replaceReference($source, 'detached');
     var_dump($source);
@@ -107,14 +106,14 @@ function main(): void
     }
     var_dump($holder->value);
 
-    $privateSource = [];
+    $privateSource = std::any([]);
     $privateHolder = new PrivatePropertyReferenceHolder();
     $privateHolder->bind($privateSource);
     $privateSource['private'] = true;
     var_dump($privateHolder->value());
 
-    $events = [];
-    $orderedSource = [];
+    $events = std::any([]);
+    $orderedSource = std::any([]);
     $orderedHolder = new PropertyReferenceHolder();
     propertyReferenceTarget($events, $orderedHolder)->{propertyReferenceName($events)}
         = &propertyReferenceSource($events, $orderedSource);
diff --git a/tests/compiler/ref/ref-closure-param.phpt b/tests/compiler/ref/ref-closure-param.phpt
index 0e37e70f..b3668cd2 100644
--- a/tests/compiler/ref/ref-closure-param.phpt
+++ b/tests/compiler/ref/ref-closure-param.phpt
@@ -8,7 +8,7 @@ function main()
         $data .= " (_)";
     };
     $sweet = array('a' => 'apple', 'b' => 'banana');
-    $fruits = array('sweet' => $sweet, 'sour' => 'lemon');
+    $fruits = std::any(array('sweet' => $sweet, 'sour' => 'lemon'));
 
     array_walk_recursive($fruits, $testFn);
     var_dump($fruits);
diff --git a/tests/compiler/ref/ref-func-param.phpt b/tests/compiler/ref/ref-func-param.phpt
index a30aefa8..64cf7275 100644
--- a/tests/compiler/ref/ref-func-param.phpt
+++ b/tests/compiler/ref/ref-func-param.phpt
@@ -9,7 +9,7 @@ function test_fn(&$data)
 
 function main()
 {
-    $s = "foo";
+    $s = std::any("foo");
     test_fn($s);
     var_dump($s);
 }
diff --git a/tests/compiler/ref/ref-object.phpt b/tests/compiler/ref/ref-object.phpt
index a12b8fde..b576e36c 100644
--- a/tests/compiler/ref/ref-object.phpt
+++ b/tests/compiler/ref/ref-object.phpt
@@ -32,13 +32,13 @@ function test2(&$test)
 
 function main()
 {
-    $test = new Test();
+    $test = std::any(new Test());
     $testOrigin = $test;
     test1($test);
     var_dump($test !== $testOrigin);
     var_dump($testOrigin->value, $test->value);
 
-    $test = new Test();
+    $test = std::any(new Test());
     $testOrigin = $test;
     test2($test);
     var_dump($test !== $testOrigin);
diff --git a/tests/compiler/ref/ref.phpt b/tests/compiler/ref/ref.phpt
index 5b6714cd..bf0cd41c 100644
--- a/tests/compiler/ref/ref.phpt
+++ b/tests/compiler/ref/ref.phpt
@@ -4,7 +4,7 @@ object link operator
 <?php
 function main()
 {
-    $a = [1, 2, 3];
+    $a = std::any([1, 2, 3]);
     $b = &$a;
     $b[] = 5;
 
diff --git a/tests/compiler/ref/static-byref-call.phpt b/tests/compiler/ref/static-byref-call.phpt
index 63c337d9..c0587200 100644
--- a/tests/compiler/ref/static-byref-call.phpt
+++ b/tests/compiler/ref/static-byref-call.phpt
@@ -37,7 +37,7 @@ class RefChild extends RefTarget
 
 function main(): void
 {
-    $value = 'start';
+    $value = std::any('start');
     mutate_arg($value);
     $target = new RefTarget($value);
     $target->mutate($value);
diff --git a/tests/compiler/ref/std-any-ref.phpt b/tests/compiler/ref/std-any-ref.phpt
index f712e2fd..4361f0ee 100644
--- a/tests/compiler/ref/std-any-ref.phpt
+++ b/tests/compiler/ref/std-any-ref.phpt
@@ -17,7 +17,7 @@ function main(): void
         $value = 'changed';
     };
 
-    $value = 'variable';
+    $value = std::any('variable');
     $replace(StD::ReF($value));
     echo $value, "\n";
 
diff --git a/tests/compiler/ref/std-ref-static-method.phpt b/tests/compiler/ref/std-ref-static-method.phpt
index bf14a556..3c7a1f48 100644
--- a/tests/compiler/ref/std-ref-static-method.phpt
+++ b/tests/compiler/ref/std-ref-static-method.phpt
@@ -7,7 +7,7 @@ function reference_test(&$name) {
 }
 function main()
 {
-    $name = 'php ';
+    $name = std::any('php ');
     reference_test(std::ref($name));
     echo $name;
 }
diff --git a/tests/compiler/ref/std-ref-variable.phpt b/tests/compiler/ref/std-ref-variable.phpt
index 7a69792a..b48b2f05 100644
--- a/tests/compiler/ref/std-ref-variable.phpt
+++ b/tests/compiler/ref/std-ref-variable.phpt
@@ -6,7 +6,7 @@ function main()
 {
     eval('function reference_test(&$name) { $name .= "std::ref test"; }');
 
-    $name = 'php ';
+    $name = std::any('php ');
     reference_test(std::ref($name));
     echo $name;
 }
diff --git a/tests/compiler/ref/unset.phpt b/tests/compiler/ref/unset.phpt
index 6e27517f..3f8282b2 100644
--- a/tests/compiler/ref/unset.phpt
+++ b/tests/compiler/ref/unset.phpt
@@ -4,7 +4,7 @@ object link operator
 <?php
 function main()
 {
-    $a = 1;
+    $a = std::any(1);
     $b = &$a;
     $b = 2;
     var_dump($a, $b);
@@ -23,4 +23,4 @@ int(2)
 int(2)
 bool(false)
 int(1)
-int(2)
\ No newline at end of file
+int(2)
diff --git a/tests/compiler/self-class/003.phpt b/tests/compiler/self-class/003.phpt
index 40300468..fb55ab87 100644
--- a/tests/compiler/self-class/003.phpt
+++ b/tests/compiler/self-class/003.phpt
@@ -3,7 +3,6 @@ Class constants referenced through self, parent, explicit names and runtime stat
 --FILE--
 <?php
 
-declare(strict_types=1);
 
 namespace StubConstRef {
     class Base
diff --git a/tests/compiler/static/late-static-class-return.phpt b/tests/compiler/static/late-static-class-return.phpt
index 9d7c45a6..1527daed 100644
--- a/tests/compiler/static/late-static-class-return.phpt
+++ b/tests/compiler/static/late-static-class-return.phpt
@@ -2,7 +2,6 @@
 static::class resolves to the called class through string-typed methods
 --FILE--
 <?php
-declare(strict_types=1);
 
 trait LsbClassTrait
 {
diff --git a/tests/compiler/static/object-static-call-runtime-class.phpt b/tests/compiler/static/object-static-call-runtime-class.phpt
index c7d8f61a..b43500d8 100644
--- a/tests/compiler/static/object-static-call-runtime-class.phpt
+++ b/tests/compiler/static/object-static-call-runtime-class.phpt
@@ -63,7 +63,7 @@ function callOnClassString(string $class): array
 
 function callReferenceArgument(ObjectStaticCallBase $object): array
 {
-    $value = 1;
+    $value = std::any(1);
     $class = $object::increment($value);
     return [$class, $value];
 }
diff --git a/tests/compiler/static/static-call-dynamic-class-order.phpt b/tests/compiler/static/static-call-dynamic-class-order.phpt
index fdfb08f3..dadcaa10 100644
--- a/tests/compiler/static/static-call-dynamic-class-order.phpt
+++ b/tests/compiler/static/static-call-dynamic-class-order.phpt
@@ -40,7 +40,7 @@ function make_dynamic_class_argument(): string
 
 function main(): void
 {
-    $class = DynamicClassFirst::class;
+    $class = std::any(DynamicClassFirst::class);
     var_dump($class::render(replace_dynamic_class($class)));
     var_dump($class::render('next'));
     var_dump(choose_dynamic_class()::render(make_dynamic_class_argument()));
diff --git a/tests/compiler/static/static-prop-native-defaults.phpt b/tests/compiler/static/static-prop-native-defaults.phpt
index aed15347..81b36042 100644
--- a/tests/compiler/static/static-prop-native-defaults.phpt
+++ b/tests/compiler/static/static-prop-native-defaults.phpt
@@ -1,5 +1,5 @@
 --TEST--
-Static properties with native_types keep defaults and local slots
+Static properties with native scalar storage keep defaults and local slots
 --FILE--
 <?php
 class StaticNativeDefaults {
diff --git a/tests/compiler/stdlib/array-keys-dynamic-arguments.phpt b/tests/compiler/stdlib/array-keys-dynamic-arguments.phpt
index eb156c36..36276b6f 100644
--- a/tests/compiler/stdlib/array-keys-dynamic-arguments.phpt
+++ b/tests/compiler/stdlib/array-keys-dynamic-arguments.phpt
@@ -2,7 +2,6 @@
 array_keys optimized calls preserve dynamic arguments, strict types, and evaluation order
 --FILE--
 <?php
-declare(strict_types=1);
 
 final class ArrayKeysOptions
 {
@@ -61,7 +60,7 @@ function main()
     $options = new ArrayKeysOptions();
     var_dump(array_keys($values, '1', $options->strict));
 
-    $events = [];
+    $events = std::any([]);
     var_dump(array_keys(
         arrayKeysDynamicValues($events),
         arrayKeysDynamicFilter($events),
diff --git a/tests/compiler/stdlib/array-slice-reverse-preserve-keys.phpt b/tests/compiler/stdlib/array-slice-reverse-preserve-keys.phpt
index 2a536108..ece87b10 100644
--- a/tests/compiler/stdlib/array-slice-reverse-preserve-keys.phpt
+++ b/tests/compiler/stdlib/array-slice-reverse-preserve-keys.phpt
@@ -5,7 +5,7 @@ array_search keys with array_slice and array_reverse preserving keys
 
 function select_version_flags(array $flagsByVersions, int $minVersion, ?int $maxVersion): array
 {
-    ksort($flagsByVersions);
+    $flagsByVersions->keySort();
 
     $index = array_search($minVersion, array_keys($flagsByVersions));
     if ($index === false) {
diff --git a/tests/compiler/stdlib/docblock-param-regex.phpt b/tests/compiler/stdlib/docblock-param-regex.phpt
index 9b8e8fba..26aa2993 100644
--- a/tests/compiler/stdlib/docblock-param-regex.phpt
+++ b/tests/compiler/stdlib/docblock-param-regex.phpt
@@ -5,7 +5,6 @@ docblock param regex with recursive named groups
 
 function parse_doc_param_name(string $value): array
 {
-    $matches = [];
     preg_match('/^\s*(?<type>[\w\|\\\\]+(?<parens>\((?<inparens>(?:(?&parens)|[^(){}[\]<>]*+))++\)|\{(?&inparens)\}|\[(?&inparens)\]|<(?&inparens)>)*+(?::(?&type))?)\s*(\.\.\.)?\$(?<name>\w+).*$/', $value, $matches);
 
     return [
diff --git a/tests/compiler/stdlib/null_optional_arg.phpt b/tests/compiler/stdlib/null_optional_arg.phpt
index a007d2c0..ceea3866 100644
--- a/tests/compiler/stdlib/null_optional_arg.phpt
+++ b/tests/compiler/stdlib/null_optional_arg.phpt
@@ -2,7 +2,6 @@
 Nullable and non-nullable builtin parameters preserve strict null semantics
 --FILE--
 <?php
-declare(strict_types=1);
 
 function main()
 {
diff --git a/tests/compiler/stdlib/preprocessor-condition-stack.phpt b/tests/compiler/stdlib/preprocessor-condition-stack.phpt
index a7224dbf..cd44c11b 100644
--- a/tests/compiler/stdlib/preprocessor-condition-stack.phpt
+++ b/tests/compiler/stdlib/preprocessor-condition-stack.phpt
@@ -34,7 +34,7 @@ function handle_preprocessor_conditions(array &$conds, array $comments): ?string
 
 function main(): void
 {
-    $conds = [];
+    $conds = std::any([]);
     var_dump(handle_preprocessor_conditions($conds, ['#ifdef PHP_WIN32', '#if PHP_VERSION_ID >= 80400']));
     var_dump(handle_preprocessor_conditions($conds, ['#else']));
     var_dump(handle_preprocessor_conditions($conds, ['#endif', '#endif']));
diff --git a/tests/compiler/stdlib/repeatable-argv-parser.phpt b/tests/compiler/stdlib/repeatable-argv-parser.phpt
index 17a93c12..fbe81660 100644
--- a/tests/compiler/stdlib/repeatable-argv-parser.phpt
+++ b/tests/compiler/stdlib/repeatable-argv-parser.phpt
@@ -16,7 +16,7 @@ function is_long_flag_with_equals(string $arg, array $flags, array &$values): bo
 
 function parse_repeatable_argv(array $argv, array $flags): array
 {
-    $values = [];
+    $values = std::any([]);
     for ($i = 1; $i < count($argv); $i++) {
         if (in_array($argv[$i], $flags, true) && isset($argv[$i + 1]) && $argv[$i + 1] !== '' && $argv[$i + 1][0] !== '-') {
             $values[] = $argv[$i + 1];
diff --git a/tests/compiler/stdlib/strict-builtin-typed-arguments.phpt b/tests/compiler/stdlib/strict-builtin-typed-arguments.phpt
index f8e902f2..d80bbcdf 100644
--- a/tests/compiler/stdlib/strict-builtin-typed-arguments.phpt
+++ b/tests/compiler/stdlib/strict-builtin-typed-arguments.phpt
@@ -2,7 +2,6 @@
 Optimized builtins preserve strict typed parameter validation
 --FILE--
 <?php
-declare(strict_types=1);
 
 function mixedBool(): mixed
 {
@@ -82,7 +81,7 @@ function main()
     var_dump(function_exists(mixedString()));
     var_dump(round(...[1.25, 1]));
 
-    $events = [];
+    $events = std::any([]);
     var_dump(in_array(
         orderedNeedle($events),
         orderedHaystack($events),
diff --git a/tests/compiler/stdlib/strict-builtin-union-types.phpt b/tests/compiler/stdlib/strict-builtin-union-types.phpt
index 004eada1..9c647d84 100644
--- a/tests/compiler/stdlib/strict-builtin-union-types.phpt
+++ b/tests/compiler/stdlib/strict-builtin-union-types.phpt
@@ -2,7 +2,6 @@
 Optimized numeric builtins preserve strict union parameter validation
 --FILE--
 <?php
-declare(strict_types=1);
 
 function main(): void
 {
diff --git a/tests/compiler/strict_types/scalar-dynamic-boundaries.phpt b/tests/compiler/strict_types/scalar-dynamic-boundaries.phpt
index 9a1ce6bc..65d667d6 100644
--- a/tests/compiler/strict_types/scalar-dynamic-boundaries.phpt
+++ b/tests/compiler/strict_types/scalar-dynamic-boundaries.phpt
@@ -5,7 +5,6 @@ USE_ZEND_ALLOC=0
 --FILE--
 <?php
 
-declare(strict_types=1);
 
 function acceptsInt(int $value): int { return $value; }
 function acceptsFloat(float $value): float { return $value; }
diff --git a/tests/compiler/strict_types/strict_types.phpt b/tests/compiler/strict_types/strict_types.phpt
index ade63d3b..a7baf2fa 100644
--- a/tests/compiler/strict_types/strict_types.phpt
+++ b/tests/compiler/strict_types/strict_types.phpt
@@ -1,8 +1,7 @@
 --TEST--
-strict_types=1 with typed functions
+TypePHP applies strict types without a declare directive
 --FILE--
 <?php
-declare(strict_types=1);
 
 function add(int $a, int $b): int {
     return $a + $b;
diff --git a/tests/compiler/trait/trait-ctor-basic.phpt b/tests/compiler/trait/trait-ctor-basic.phpt
index 1cf76b71..9436b1e6 100644
--- a/tests/compiler/trait/trait-ctor-basic.phpt
+++ b/tests/compiler/trait/trait-ctor-basic.phpt
@@ -3,7 +3,6 @@ Trait __construct is used by the composing class
 --FILE--
 <?php
 
-declare(strict_types=1);
 
 trait TestTrait
 {
diff --git a/tests/compiler/trait/trait-ctor-override.phpt b/tests/compiler/trait/trait-ctor-override.phpt
index 5b40f487..610b17b7 100644
--- a/tests/compiler/trait/trait-ctor-override.phpt
+++ b/tests/compiler/trait/trait-ctor-override.phpt
@@ -3,7 +3,6 @@ Class __construct overrides the one provided by a trait
 --FILE--
 <?php
 
-declare(strict_types=1);
 
 trait TestTrait
 {
diff --git a/tests/compiler/trait/trait-ctor-protected-subclass.phpt b/tests/compiler/trait/trait-ctor-protected-subclass.phpt
index 319fd2f3..4d9b1a4d 100644
--- a/tests/compiler/trait/trait-ctor-protected-subclass.phpt
+++ b/tests/compiler/trait/trait-ctor-protected-subclass.phpt
@@ -3,7 +3,6 @@ Trait protected __construct is accessible from a subclass
 --FILE--
 <?php
 
-declare(strict_types=1);
 
 trait TestTrait
 {
diff --git a/tests/compiler/trait/trait-ctor-with-args.phpt b/tests/compiler/trait/trait-ctor-with-args.phpt
index 5177cb28..3bdda665 100644
--- a/tests/compiler/trait/trait-ctor-with-args.phpt
+++ b/tests/compiler/trait/trait-ctor-with-args.phpt
@@ -3,7 +3,6 @@ Trait __construct with arguments and $this property access
 --FILE--
 <?php
 
-declare(strict_types=1);
 
 trait TestTrait
 {
diff --git a/tests/compiler/trait/trait-parent-constructor.phpt b/tests/compiler/trait/trait-parent-constructor.phpt
index 941968a6..ac3b0cfc 100644
--- a/tests/compiler/trait/trait-parent-constructor.phpt
+++ b/tests/compiler/trait/trait-parent-constructor.phpt
@@ -3,7 +3,6 @@ Trait constructor calling parent::__construct of the composing class
 --FILE--
 <?php
 
-declare(strict_types=1);
 
 trait TestTrait
 {
diff --git a/tests/compiler/trait/trait-parent-method-reference.phpt b/tests/compiler/trait/trait-parent-method-reference.phpt
index 4e72026d..189d38b7 100644
--- a/tests/compiler/trait/trait-parent-method-reference.phpt
+++ b/tests/compiler/trait/trait-parent-method-reference.phpt
@@ -26,7 +26,7 @@ class ReferenceChild extends ReferenceParent
 
 function main(): void
 {
-    $value = 'initial';
+    $value = std::any('initial');
     $child = new ReferenceChild();
     $child->update($value);
     var_dump($value);
diff --git a/tests/compiler/type_decl/001.phpt b/tests/compiler/type_decl/001.phpt
index f7279222..a29068df 100644
--- a/tests/compiler/type_decl/001.phpt
+++ b/tests/compiler/type_decl/001.phpt
@@ -2,7 +2,6 @@
 Type Declarations - Strict and weak typing modes
 --FILE--
 <?php
-declare(strict_types=1);
 
 // Test callable type
 function apply_callable(callable $callback, int $value): int {
diff --git a/tests/compiler/type_decl/002.phpt b/tests/compiler/type_decl/002.phpt
index 9fb1631d..2b62707d 100644
--- a/tests/compiler/type_decl/002.phpt
+++ b/tests/compiler/type_decl/002.phpt
@@ -2,7 +2,6 @@
 Type Declarations - Strict and weak typing modes
 --FILE--
 <?php
-declare(strict_types=1);
 
 // Test scalar type declarations
 function add_integers(int $a, int $b): int {
diff --git a/tests/compiler/type_decl/003.phpt b/tests/compiler/type_decl/003.phpt
index 505b2808..6ff8bd52 100644
--- a/tests/compiler/type_decl/003.phpt
+++ b/tests/compiler/type_decl/003.phpt
@@ -2,7 +2,6 @@
 Type Declarations - Strict and weak typing modes
 --FILE--
 <?php
-declare(strict_types=1);
 
 // Test iterable type
 function sum_iterable(iterable $numbers): int {
diff --git a/tests/compiler/type_decl/scalar-alias-class-type-names.phpt b/tests/compiler/type_decl/scalar-alias-class-type-names.phpt
index 5a56115d..49a0a9b8 100644
--- a/tests/compiler/type_decl/scalar-alias-class-type-names.phpt
+++ b/tests/compiler/type_decl/scalar-alias-class-type-names.phpt
@@ -2,7 +2,6 @@
 integer, boolean and double remain class names in PHP type declarations
 --FILE--
 <?php
-declare(strict_types=1);
 
 class integer {}
 class boolean {}
diff --git a/tests/compiler/variadic/by-reference-basic.phpt b/tests/compiler/variadic/by-reference-basic.phpt
index d764fa14..7688cddf 100644
--- a/tests/compiler/variadic/by-reference-basic.phpt
+++ b/tests/compiler/variadic/by-reference-basic.phpt
@@ -41,18 +41,18 @@ function main(): void
 {
     var_dump(suffix('!'));
 
-    $first = 'first';
-    $second = 'second';
+    $first = std::any('first');
+    $second = std::any('second');
     var_dump(suffix('!', $first, $second));
     var_dump($first, $second);
 
-    $left = 'left';
-    $right = 'right';
+    $left = std::any('left');
+    $right = std::any('right');
     var_dump(suffix(suffix: '?', left: $left, right: $right));
     var_dump($left, $right);
 
-    $one = 1;
-    $two = 2;
+    $one = std::any(1);
+    $two = std::any(2);
     VariadicReferenceMutator::increment($one, $two);
     var_dump($one, $two);
 
diff --git a/tests/compiler/variadic/by-reference-closure-callback.phpt b/tests/compiler/variadic/by-reference-closure-callback.phpt
index 39b36795..b8c2f9ca 100644
--- a/tests/compiler/variadic/by-reference-closure-callback.phpt
+++ b/tests/compiler/variadic/by-reference-closure-callback.phpt
@@ -5,25 +5,28 @@ Reference Closure parameters work at Zend callback boundaries used by Symfony mb
 
 function convert_values(string $suffix, &...$vars): bool
 {
-    $ok = true;
-    array_walk_recursive($vars, static function (&$value, $key) use (&$ok, $suffix): void {
-        if (!is_string($value)) {
-            $ok = false;
-            return;
-        }
-        $value .= $suffix . ':' . $key;
-    });
+    $ok = std::any(true);
+    foreach ($vars as &$var) {
+        array_walk_recursive($var, static function (&$value, $key) use (&$ok, $suffix): void {
+            if (!is_string($value)) {
+                $ok = false;
+                return;
+            }
+            $value .= $suffix . ':' . $key;
+        });
+    }
+    unset($var);
     return $ok;
 }
 
 function main(): void
 {
-    $first = ['a' => 'one', 'nested' => ['b' => 'two']];
-    $second = 'three';
+    $first = std::any(['a' => 'one', 'nested' => ['b' => 'two']]);
+    $second = std::any('three');
     var_dump(convert_values('!', $first, $second));
     var_dump($first, $second);
 
-    $invalid = ['ok', 42];
+    $invalid = std::any(['ok', 42]);
     var_dump(convert_values('?', $invalid));
     var_dump($invalid);
 }
diff --git a/tests/compiler/variadic/by-reference-dynamic-explicit.phpt b/tests/compiler/variadic/by-reference-dynamic-explicit.phpt
index 3413de9a..0c177ff9 100644
--- a/tests/compiler/variadic/by-reference-dynamic-explicit.phpt
+++ b/tests/compiler/variadic/by-reference-dynamic-explicit.phpt
@@ -25,14 +25,14 @@ class DynamicReferenceMutator
 function main(): void
 {
     $function = 'dynamic_increment';
-    $number = 40;
+    $number = std::any(40);
     $function(std::ref($number));
     var_dump($number);
 
     $mutator = new DynamicReferenceMutator();
     $method = [$mutator, 'suffix'];
-    $first = 'one';
-    $second = 'two';
+    $first = std::any('one');
+    $second = std::any('two');
     $method('!', std::ref($first), std::ref($second));
     var_dump($first, $second);
 
diff --git a/tests/compiler/variadic/by-reference-inheritance.phpt b/tests/compiler/variadic/by-reference-inheritance.phpt
index cde662bc..e18f002b 100644
--- a/tests/compiler/variadic/by-reference-inheritance.phpt
+++ b/tests/compiler/variadic/by-reference-inheritance.phpt
@@ -2,7 +2,6 @@
 By-reference variadic signatures remain compatible across interfaces and inheritance
 --FILE--
 <?php
-declare(strict_types=1);
 
 interface IncrementContract
 {
@@ -28,8 +27,8 @@ final class Incrementer extends IncrementBase
 function main(): void
 {
     $incrementer = new Incrementer();
-    $first = 10;
-    $second = 20;
+    $first = std::any(10);
+    $second = std::any(20);
     $incrementer->increment($first, $second);
     var_dump($first, $second);
 }
diff --git a/tests/compiler/variadic/by-reference-types.phpt b/tests/compiler/variadic/by-reference-types.phpt
index a1e65e3c..87a994db 100644
--- a/tests/compiler/variadic/by-reference-types.phpt
+++ b/tests/compiler/variadic/by-reference-types.phpt
@@ -2,7 +2,6 @@
 Typed by-reference variadics validate, widen float arguments and write through unions and objects
 --FILE--
 <?php
-declare(strict_types=1);
 
 class Counter
 {
@@ -40,8 +39,8 @@ function require_ints(int &...$values): void
 
 function main(): void
 {
-    $integer = 2;
-    $float = 2.5;
+    $integer = std::any(2);
+    $float = std::any(2.5);
     scale($integer, $float);
     var_dump($integer, $float);
 
@@ -49,13 +48,13 @@ function main(): void
     scale(...$values);
     var_dump($values);
 
-    $number = 10;
-    $text = 'hello';
+    $number = std::any(10);
+    $text = std::any('hello');
     normalize($number, $text);
     var_dump($number, $text);
 
-    $first = new Counter(1);
-    $second = new Counter(5);
+    $first = std::any(new Counter(1));
+    $second = std::any(new Counter(5));
     bump_objects($first, $second);
     var_dump($first->value, $second->value);
 
diff --git a/tests/compiler/variadic/by-reference-unpack.phpt b/tests/compiler/variadic/by-reference-unpack.phpt
index d2775a1c..4a4eb4ff 100644
--- a/tests/compiler/variadic/by-reference-unpack.phpt
+++ b/tests/compiler/variadic/by-reference-unpack.phpt
@@ -28,7 +28,7 @@ function main(): void
     var_dump(increment_all(...$first, ...$second));
     var_dump($first, $second);
 
-    $external = 60;
+    $external = std::any(60);
     $references = [&$external];
     increment_all(...$references);
     var_dump($external, $references);
diff --git a/tests/std/array/array_column_scalar_index_strict_types.phpt b/tests/std/array/array_column_scalar_index_strict_types.phpt
index fbb4a641..6b81ef6f 100644
--- a/tests/std/array/array_column_scalar_index_strict_types.phpt
+++ b/tests/std/array/array_column_scalar_index_strict_types.phpt
@@ -4,7 +4,6 @@ Test array_column(): Index argument with various types in strict type mode
 <?php die("skip AOT does not enforce strict_types for internal function calls"); ?>
 --FILE--
 <?php
-declare(strict_types=1);
 
 function main() {
     echo "\n-- Testing array_column() column key parameter should be a string or an integer (testing bool) --\n";
diff --git a/tests/std/strings/gh18823_strict.phpt b/tests/std/strings/gh18823_strict.phpt
index 36d426fa..280f1e67 100644
--- a/tests/std/strings/gh18823_strict.phpt
+++ b/tests/std/strings/gh18823_strict.phpt
@@ -6,7 +6,6 @@ echo 'skip setlocale() is not available in AOT';
 ?>
 --FILE--
 <?php
-declare(strict_types=1);
 try {
     setlocale(LC_ALL, 0, "0");
 } catch (TypeError $e) {