Merge branch 'develop'

* develop: (21 commits)
  specify next release
  fix namespace
  use promoted properties
  fix documentation
  replace innmind/time-continuum and innmind/time-warp by innmind/time
  add missing test case
  fix warnings
  add NoDiscard attributes
  add extensive CI
  tag dependencies
  use innmind/io to require files
  remove warnings
  add Config::useFileWatch()
  add Config::useServerStatus()
  add Config::useServerControl()
  use the filesystem abstraction to check if a file/directory exists
  make Remote::sql() return an Attempt
  update dependencies
  add todo for Filesystem::contains() to integrate correctly with other abstractions
  require php 8.4
  ...

Author: Baptouuuu

.gitattributes

@@ -1,4 +1,3 @@
 /.gitattributes export-ignore
 /.gitignore export-ignore
-/phpunit.xml.dist export-ignore
 /tests export-ignore

.github/workflows/ci.yml

@@ -12,5 +12,3 @@ jobs:
     uses: innmind/github-workflows/.github/workflows/psalm-matrix.yml@main
   cs:
     uses: innmind/github-workflows/.github/workflows/cs.yml@main
-    with:
-      php-version: '8.2'

.github/workflows/extensive.yml

@@ -0,0 +1,12 @@
+name: Extensive CI
+
+on:
+  push:
+    tags:
+      - '*'
+    paths:
+      - '.github/workflows/extensive.yml'
+
+jobs:
+  blackbox:
+    uses: innmind/github-workflows/.github/workflows/extensive.yml@main

CHANGELOG.md

@@ -1,5 +1,22 @@
 # Changelog
 
+## 7.0.0 - 2026-02-07
+
+### Added
+
+- `Innmind\OperatingSystem\Config::useServerControl()`
+- `Innmind\OperatingSystem\Config::useServerStatus()`
+- `Innmind\OperatingSystem\Config::useFileWatch()`
+
+### Changed
+
+- Requires PHP `8.4`
+- `Innmind\OperatingSystem\Remote::sql()` now returns an `Innmind\Immutable\Attempt`
+- `Innmind\OperatingSystem\Filesystem::mount()` now longer automatically create the directory
+- `Innmind\OperatingSystem\CurrentProcess\Signals::listen()` now returns an `Innmind\Immutable\Attempt`
+- `Innmind\OperatingSystem\CurrentProcess\Signals::remove()` now returns an `Innmind\Immutable\Attempt`
+- Requires `innmind/time:~1.0`
+
 ## 6.2.0 - 2025-08-10
 
 ### Added

README.md

@@ -31,7 +31,7 @@ $os = Factory::build();
 
 ### Want to access the system clock ?
 
-`$os->clock()` will return an instance of [`Innmind\TimeContinuum\Clock`](https://github.com/innmind/timecontinuum#usage).
+`$os->clock()` will return an instance of [`Innmind\Time\Clock`](https://github.com/innmind/time#usage).
 
 ### Want to access the filesystem ?
 
@@ -153,7 +153,7 @@ $os->process()->id()->unwrap();
 ### Want to pause the current process ?
 
 ```php
-use Innmind\TimeContinuum\Period;
+use Innmind\Time\Period;
 
 $os->process()->halt(Period::minute(1));
 ```
@@ -165,5 +165,5 @@ use Innmind\Signals\Signal;
 
 $os->process()->signals()->listen(Signal::terminate, function() {
     // handle the signal here
-});
+})->unwrap();
 ```

blackbox.php

@@ -10,6 +10,10 @@
 };
 
 Application::new($argv)
+    ->when(
+        \getenv('BLACKBOX_SET_SIZE') !== false,
+        static fn(Application $app) => $app->scenariiPerProof((int) \getenv('BLACKBOX_SET_SIZE')),
+    )
     ->when(
         \getenv('ENABLE_COVERAGE') !== false,
         static fn(Application $app) => $app

composer.json

@@ -15,18 +15,17 @@
         "issues": "http://github.com/Innmind/OperatingSystem/issues"
     },
     "require": {
-        "php": "~8.2",
-        "innmind/time-continuum": "^4.1.1",
-        "innmind/server-status": "~5.0",
-        "innmind/server-control": "~6.0",
-        "innmind/filesystem": "~8.1",
-        "innmind/http-transport": "~8.0",
-        "innmind/time-warp": "~4.0",
-        "innmind/signals": "~4.0",
-        "innmind/file-watch": "~5.0",
-        "formal/access-layer": "~4.0",
-        "innmind/io": "~3.2",
-        "innmind/immutable": "~5.15"
+        "php": "~8.4",
+        "innmind/time": "~1.0",
+        "innmind/server-status": "~6.0",
+        "innmind/server-control": "~7.0",
+        "innmind/filesystem": "~9.0",
+        "innmind/http-transport": "~9.0",
+        "innmind/signals": "~5.0",
+        "innmind/file-watch": "~6.0",
+        "formal/access-layer": "~5.0",
+        "innmind/io": "~4.0",
+        "innmind/immutable": "~6.0"
     },
     "autoload": {
         "psr-4": {
@@ -39,9 +38,7 @@
         }
     },
     "require-dev": {
-        "innmind/url": "~4.0",
-        "innmind/ip": "~3.0",
-        "innmind/static-analysis": "^1.2.1",
+        "innmind/static-analysis": "~1.3",
         "innmind/black-box": "~6.2",
         "innmind/coding-standard": "~2.0"
     }

documentation/upgrade/v6-to-v7.md

@@ -0,0 +1,102 @@
+# V6 to V7
+
+### Mounting a folder that doesn't exist
+
+=== "Before"
+    ```php
+    $adapter = $os
+        ->filesystem()
+        ->mount(Path::of('/some/folder/'))
+        ->unwrap();
+    ```
+
+=== "After"
+    ```php hl_lines="1 6"
+    use Innmind\Filesystem\Recover;
+
+    $adapter = $os
+        ->filesystem()
+        ->mount(Path::of('/some/folder/'))
+        ->recover(Recover::mount(...))
+        ->unwrap();
+    ```
+
+### Accessing a SQL connection
+
+=== "Before"
+    ```php
+    $connection = $os
+        ->remote()
+        ->sql(Url::of('mysql://127.0.0.1:3306/database'));
+    ```
+
+=== "After"
+    ```php hl_lines="4"
+    $connection = $os
+        ->remote()
+        ->sql(Url::of('mysql://127.0.0.1:3306/database'))
+        ->unwrap();
+    ```
+
+### Handling process signals
+
+=== "Before"
+    ```php
+    $os
+        ->process()
+        ->signals()
+        ->listen($signal, $listener);
+    $os
+        ->process()
+        ->signals()
+        ->remove($listener);
+    ```
+
+=== "After"
+    ```php hl_lines="5 10"
+    $os
+        ->process()
+        ->signals()
+        ->listen($signal, $listener)
+        ->unwrap();
+    $os
+        ->process()
+        ->signals()
+        ->remove($listener)
+        ->unwrap();
+    ```
+
+### HTTP client config
+
+=== "Before"
+    ```php
+    use Innmind\HttpTransport\Curl;
+    use Innmind\TimeContinuum\Period;
+
+    $os = $os->map(
+        static fn($config) => $config->useHttpTransport(
+            Curl::of($config->clock(), $config->io())
+                ->disableSSLVerification()
+                ->maxConcurrency(10)
+                ->heartbeat(
+                    Period::second(1),
+                    static fn() => 'heartbeat',
+                ),
+        ),
+    );
+    ```
+
+=== "After"
+    ```php
+    use Innmind\HttpTransport\Config;
+
+    $os = $os->map(
+        static fn($config) => $config->mapHttpTransport(
+            static fn($transport) => $transport->map(
+                static fn(Config $config) => $config
+                    ->limitConcurrencyTo(10)
+                    ->disableSSLVerification(),
+            ),
+        ),
+    );
+    ```

documentation/use_cases/filesystem.md

@@ -119,6 +119,25 @@ $os
 
 See [processes](processes.md) section on how to execute commands on your operating system.
 
+### Automatically create the mounted folder
+
+By default when mounting a folder if it doesn't exist it will fail. But you can instruct to automatically create the folder in such case.
+
+```php
+use Innmind\Filesystem\{
+    Adapter,
+    Recover,
+};
+use Innmind\Url\Path;
+
+$adapter = $os
+    ->filesystem()
+    ->mount(Path::of('/some/folder/'))
+    ->recover(Recover::mount(...))
+    ->unwrap();
+$adapter instanceof Adapter; // true
+```
+
 ### Mounting the `tmp` folder
 
 Sometimes you want to use the `tmp` folder to write down files such as cache that can be safely lost in case of a system reboot. You can easily mount this folder as any other folder like so:

documentation/use_cases/http.md

@@ -19,10 +19,8 @@ $response = $http(Request::of(
     ProtocolVersion::v20,
 ))
     ->map(static fn($success) => $success->response())
-    ->match(
-        static fn($response) => $response,
-        static fn($error) => throw new \RuntimeException($error::class),
-    );
+    ->attempt(static fn($error) => throw new \RuntimeException($error::class))
+    ->unwrap();
 $response instanceof Response; // true
 ```
 
@@ -37,20 +35,20 @@ One of the first things taught when working with distributed systems is that the
 
 ```php
 use Innmind\OperatingSystem\Config\Resilient;
-use Innmind\HttpTransport\ExponentialBackoff;
+use Innmind\HttpTransport\Transport;
 
 $os = $os->map(Resilient::new());
 $http = $os->remote()->http();
-$http instanceof ExponentialBackoff; // true
+$http instanceof Transport; // true
 ```
 
 Another strategy you can add on top of that is the [circuit breaker pattern](https://en.wikipedia.org/wiki/Circuit_breaker_design_pattern) that will stop sending request to a server known to have failed.
 
 ```php
-use Innmind\HttpTransport\CircuitBreaker;
-use Innmind\TimeContinuum\Period;
+use Innmind\HttpTransport\Transport;
+use Innmind\Time\Period;
 
-$http = CircuitBreaker::of(
+$http = Transport::circuitBreaker(
     $http,
     $os->clock(),
     Period::minute(1),