diff --git a/.idea/nulib.iml b/.idea/nulib.iml
index 61abbb4..265b084 100644
--- a/.idea/nulib.iml
+++ b/.idea/nulib.iml
@@ -5,6 +5,7 @@
       <sourceFolder url="file://$MODULE_DIR$/php/src_base" isTestSource="false" packagePrefix="nulib\" />
       <sourceFolder url="file://$MODULE_DIR$/php/tests" isTestSource="true" packagePrefix="nulib\" />
       <sourceFolder url="file://$MODULE_DIR$/php/src_output" isTestSource="false" packagePrefix="nulib\output\" />
+      <sourceFolder url="file://$MODULE_DIR$/php/src_web" isTestSource="false" packagePrefix="nulib\web\" />
       <excludeFolder url="file://$MODULE_DIR$/vendor" />
     </content>
     <orderEntry type="inheritedJdk" />
diff --git a/bash/src/base.tools.sh b/bash/src/base.tools.sh
index b786213..4812774 100644
--- a/bash/src/base.tools.sh
+++ b/bash/src/base.tools.sh
@@ -2,6 +2,11 @@
 ##@cooked nocomments
 module: base.tools "Fonctions de base: outils divers"
 
+function: mkdirof 'Créer le répertoire correspondant au fichier $1'
+function mkdirof() {
+    mkdir -p "$(dirname -- "$1")"
+}
+
 function __la_cmd() {
     [ $# -gt 0 ] || set '*'
     local arg
diff --git a/composer.json b/composer.json
index ee7bce3..e820acb 100644
--- a/composer.json
+++ b/composer.json
@@ -17,7 +17,8 @@
 	"autoload": {
 		"psr-4": {
 			"nulib\\": "php/src_base",
-			"nulib\\output\\": "php/src_output"
+			"nulib\\output\\": "php/src_output",
+			"nulib\\web\\": "php/src_web"
 		}
 	},
 	"autoload-dev": {
diff --git a/php/src_output/IContent.php b/php/src_output/IContent.php
new file mode 100644
index 0000000..0b92311
--- /dev/null
+++ b/php/src_output/IContent.php
@@ -0,0 +1,10 @@
+<?php
+namespace nulib\output;
+
+/**
+ * Interface IContent: un objet capable de produire du contenu à afficher
+ */
+interface IContent {
+  /** retourner le contenu à afficher */
+  function getContent(): iterable;
+}
diff --git a/php/src_output/IMessenger.php b/php/src_output/IMessenger.php
new file mode 100644
index 0000000..5106c0c
--- /dev/null
+++ b/php/src_output/IMessenger.php
@@ -0,0 +1,96 @@
+<?php
+namespace nulib\output;
+
+/**
+ * Interface IMessenger: un objet pouvant afficher des messages de l'application
+ */
+interface IMessenger {
+  const DEBUG = -1, MINOR = 0, NORMAL = 1, MAJOR = 2, NONE = 3;
+  const MIN_LEVEL = self::DEBUG, MAX_LEVEL = self::MAJOR;
+
+  /** réinitialiser les paramètres de l'objet */
+  function resetParams(?array $params=null): void;
+
+  /**
+   * créer une copie de cet objet avec éventuellement des paramètres différents
+   */
+  function clone(?array $params=null): self;
+
+  /**
+   * commencer une section.
+   *
+   * flush tous les messages en cours. ne peut être imbriqué. on peut considérer
+   * que c'est une sorte de "reset" de l'objet
+   */
+  function section($content, ?callable $func=null, ?int $level=null): void;
+
+  /**
+   * commencer un chapitre.
+   *
+   * peut être imbriqué dans un autre chapitre. terminer automatiquement
+   * l'action en cours avec un résultat neutre
+   */
+  function title($content, ?callable $func=null, ?int $level=null): void;
+
+  /** ajouter une description au chapitre courant. */
+  function desc($content, ?int $level=null): void;
+
+  /**
+   * comencer une action dans le chapitre courant.
+   *
+   * peut être imbriqué dans une autre action.
+   */
+  function action($content, ?callable $func=null, ?int $level=null): void;
+
+  /**
+   * ajouter une étape à l'action courante.
+   *
+   * démarrer une action le cas échéant (et la terminer aussitôt)
+   */
+  function step($content, ?int $level=null): void;
+
+  /**
+   * terminer l'action courante avec le résultat "succès"
+   *
+   * démarrer une action le cas échéant (et la terminer aussitôt)
+   */
+  function asuccess($content=null): void;
+
+  /**
+   * terminer l'action courante avec le résultat "échec"
+   *
+   * démarrer une action le cas échéant (et la terminer aussitôt)
+   */
+  function afailure($content=null): void;
+
+  /**
+   * terminer l'action courante avec le résultat "neutre"
+   *
+   * démarrer une action le cas échéant (et la terminer aussitôt)
+   */
+  function adone($content=null): void;
+
+  /** afficher une donnée non structurée */
+  function print($content, ?int $level=null): void;
+
+  /** afficher un événément "information" */
+  function info($content, ?int $level=null): void;
+
+  /** afficher un événément "information importante" */
+  function note($content, ?int $level=null): void;
+
+  /** afficher un événément "avertissement" */
+  function warn($content, ?int $level=null): void;
+
+  /** afficher un événément "erreur" */
+  function error($content, ?int $level=null): void;
+
+  /**
+   * terminer le chapitre en cours. toutes les actions en cours sont terminées
+   * avec un résultat neutre.
+   *
+   * @param bool $all faut-il terminer *tous* les chapitres ainsi que la section
+   * en cours?
+   */
+  function end(bool $all=false): void;
+}
diff --git a/php/src_output/IPrintable.php b/php/src_output/IPrintable.php
new file mode 100644
index 0000000..0f09fd2
--- /dev/null
+++ b/php/src_output/IPrintable.php
@@ -0,0 +1,11 @@
+<?php
+namespace nulib\output;
+
+/**
+ * Interface IPrintable: un objet qui peut écrire du contenu sur la sortie
+ * standard
+ */
+interface IPrintable {
+  /** afficher le contenu */
+  function print(): void;
+}
diff --git a/php/src_output/TODO.md b/php/src_output/TODO.md
new file mode 100644
index 0000000..87c6b0e
--- /dev/null
+++ b/php/src_output/TODO.md
@@ -0,0 +1,8 @@
+# TOOD
+
+* [ ] possibilité de paramétrer le nom du fichier destination pour faire une
+  rotation des logs
+  * [ ] lors de la rotation, si l'ouverture du nouveau fichier échoue, continuer
+    à écrire dans l'ancien fichier
+
+-*- coding: utf-8 mode: markdown -*- vim:sw=4:sts=4:et:ai:si:sta:fenc=utf-8:noeol:binary
\ No newline at end of file
diff --git a/php/src_output/_messenger.php b/php/src_output/_messenger.php
new file mode 100644
index 0000000..0fe4033
--- /dev/null
+++ b/php/src_output/_messenger.php
@@ -0,0 +1,79 @@
+<?php
+namespace nulib\output;
+
+use nulib\str;
+use nulib\ValueException;
+
+/**
+ * Class _messenger: classe de base pour say, log et msg
+ */
+abstract class _messenger {
+  /** @var IMessenger */
+  protected static $say;
+
+  /** @var IMessenger */
+  protected static $log;
+
+  abstract static function get(): IMessenger;
+
+  /** obtenir une nouvelle instance, avec un nouveau paramétrage */
+  static function new(?array $params=null): IMessenger {
+    return static::get()->clone($params);
+  }
+
+  /** @var IMessenger */
+  protected static $msg;
+
+  /** @var IMessenger[] */
+  protected static $stack;
+
+  /** pousser une nouvelle instance avec un nouveau paramétrage sur la pile */
+  static function push(?array $params=null) {
+    self::$stack[] = static::get();
+    self::$msg = self::new($params);
+  }
+
+  /** dépiler la précédente instance */
+  static function pop(): IMessenger {
+    if (self::$stack) $msg = self::$msg = array_pop(self::$stack);
+    else $msg = self::$msg;
+    return $msg;
+  }
+
+  static final function __callStatic($name, $args) {
+    $name = str::us2camel($name);
+    call_user_func_array([static::get(), $name], $args);
+  }
+
+  #############################################################################
+
+  const DEBUG = IMessenger::DEBUG;
+  const MINOR = IMessenger::MINOR;
+  const NORMAL = IMessenger::NORMAL;
+  const MAJOR = IMessenger::MAJOR;
+  const NONE = IMessenger::NONE;
+
+  static function reset_params(?array $params=null): void { static::get()->resetParams($params); }
+  static function section($content, ?callable $func=null, ?int $level=null): void { static::get()->section($content, $func, $level); }
+  static function title($content, ?callable $func=null, ?int $level=null): void { static::get()->title($content, $func, $level); }
+  static function desc($content, ?int $level=null): void { static::get()->desc($content, $level); }
+  static function action($content, ?callable $func=null, ?int $level=null): void { static::get()->action($content, $func, $level); }
+  static function step($content, ?int $level=null): void { static::get()->step($content, $level); }
+  static function asuccess($content=null): void { static::get()->asuccess($content); }
+  static function afailure($content=null): void { static::get()->afailure($content); }
+  static function adone($content=null): void { static::get()->adone($content); }
+  static function print($content, ?int $level=null): void { static::get()->print($content, $level); }
+  static function info($content, ?int $level=null): void { static::get()->info($content, $level); }
+  static function note($content, ?int $level=null): void { static::get()->note($content, $level); }
+  static function warn($content, ?int $level=null): void { static::get()->warn($content, $level); }
+  static function error($content, ?int $level=null): void { static::get()->error($content, $level); }
+  static function end(bool $all=false): void { static::get()->end($all); }
+
+  static function debug($content): void { self::info($content, self::DEBUG);}
+  static function normal($content): void { self::info($content, self::NORMAL);}
+  static function minor($content): void { self::info($content, self::MINOR);}
+  static function important($content): void { self::info($content, self::MAJOR);}
+  static function attention($content): void { self::note($content, self::MAJOR);}
+  static function critwarn($content): void { self::warn($content, self::MAJOR);}
+  static function criterror($content): void { self::error($content, self::MAJOR);}
+}
diff --git a/php/src_output/log.php b/php/src_output/log.php
new file mode 100644
index 0000000..0542587
--- /dev/null
+++ b/php/src_output/log.php
@@ -0,0 +1,30 @@
+<?php
+namespace nulib\output;
+
+use nulib\ValueException;
+use nulib\output\std\ProxyMessenger;
+
+/**
+ * Class log: inscrire un message dans les logs uniquement
+ */
+class log extends _messenger {
+  static function set_messenger(IMessenger $log=null) {
+    self::$log = $log;
+  }
+
+  static function set_messenger_class(string $log_class=null, ?array $params=null) {
+    if (!is_subclass_of($log_class, IMessenger::class)) {
+      throw ValueException::invalid_class($log_class, IMessenger::class);
+    }
+    self::$log = new $log_class($params);
+  }
+
+  static function get(): IMessenger {
+    if (self::$msg === null) {
+      $msg = self::$log;
+      if ($msg === null) $msg = new ProxyMessenger();
+      self::$msg = $msg;
+    }
+    return self::$msg;
+  }
+}
diff --git a/php/src_output/msg.php b/php/src_output/msg.php
new file mode 100644
index 0000000..cf09a11
--- /dev/null
+++ b/php/src_output/msg.php
@@ -0,0 +1,41 @@
+<?php
+namespace nulib\output;
+
+use nulib\ValueException;
+use nulib\output\std\ProxyMessenger;
+
+/**
+ * Class msg: inscrire un message dans les logs ET l'afficher sur la console
+ */
+class msg extends _messenger {
+  static function set_messenger(IMessenger $say, ?IMessenger $log=null) {
+    self::$say = $say;
+    if ($log !== null) self::$log = $log;
+  }
+
+  static function set_messenger_class(string $say_class, ?string $log_class=null) {
+    if (!is_subclass_of($say_class, IMessenger::class)) {
+      throw ValueException::invalid_class($say_class, IMessenger::class);
+    }
+    self::$say = new $say_class();
+    if ($log_class !== null) {
+      if (!is_subclass_of($log_class, IMessenger::class)) {
+        throw ValueException::invalid_class($log_class, IMessenger::class);
+      }
+      self::$log = new $log_class();
+    }
+  }
+
+  static function get(): IMessenger {
+    if (self::$msg === null) {
+      $log = self::$log;
+      $say = self::$say;
+      if ($log !== null && $say !== null) $msg = new ProxyMessenger($log, $say);
+      elseif ($log !== null) $msg = $log;
+      elseif ($say !== null) $msg = $say;
+      else $msg = new ProxyMessenger();
+      self::$msg = $msg;
+    }
+    return self::$msg;
+  }
+}
diff --git a/php/src_output/say.php b/php/src_output/say.php
new file mode 100644
index 0000000..9a3e847
--- /dev/null
+++ b/php/src_output/say.php
@@ -0,0 +1,30 @@
+<?php
+namespace nulib\output;
+
+use nulib\ValueException;
+use nulib\output\std\ProxyMessenger;
+
+/**
+ * Class say: afficher un message sur la console uniquement
+ */
+class say extends _messenger {
+  static function set_messenger(IMessenger $say) {
+    self::$say = $say;
+  }
+
+  static function set_messenger_class(string $say_class, ?array $params=null) {
+    if (!is_subclass_of($say_class, IMessenger::class)) {
+      throw ValueException::invalid_class($say_class, IMessenger::class);
+    }
+    self::$say = new $say_class($params);
+  }
+
+  static function get(): IMessenger {
+    if (self::$msg === null) {
+      $msg = self::$say;
+      if ($msg === null) $msg = new ProxyMessenger();
+      self::$msg = $msg;
+    }
+    return self::$msg;
+  }
+}
diff --git a/php/src_output/std/ProxyMessenger.php b/php/src_output/std/ProxyMessenger.php
new file mode 100644
index 0000000..fd15c1b
--- /dev/null
+++ b/php/src_output/std/ProxyMessenger.php
@@ -0,0 +1,100 @@
+<?php
+namespace nulib\output\std;
+
+use nulib\output\IMessenger;
+
+/**
+ * Class ProxyMessenger: un proxy vers ou un plusieurs instances de IMessenger
+ */
+class ProxyMessenger implements IMessenger {
+  function __construct(?IMessenger ...$msgs) {
+    $this->msgs = [];
+    foreach ($msgs as $msg) {
+      if ($msg !== null) $this->msgs[] = $msg;
+    }
+  }
+
+  /** @var IMessenger[] */
+  protected $msgs;
+
+  function resetParams(?array $params=null): void { foreach ($this->msgs as $msg) { $msg->resetParams($params); } }
+  function clone(?array $params=null): self {
+    $clone = clone $this;
+    foreach ($clone->msgs as &$msg) {
+      $msg = $msg->clone($params);
+    }; unset($msg);
+    return $clone;
+  }
+  function section($content, ?callable $func=null, ?int $level=null): void {
+    $useFunc = false;
+    foreach ($this->msgs as $msg) {
+      $msg->section($content, null, $level);
+      if ($msg instanceof _IMessenger) $useFunc = true;
+    }
+    if ($useFunc && $func !== null) {
+      try {
+        $func($this);
+      } finally {
+        /** @var _IMessenger $msg */
+        foreach ($this->msgs as $msg) {
+          $msg->_endSection();
+        }
+      }
+    }
+  }
+  function title($content, ?callable $func=null, ?int $level=null): void {
+    $useFunc = false;
+    $untils = [];
+    foreach ($this->msgs as $msg) {
+      $msg->title($content, null, $level);
+      if ($msg instanceof _IMessenger) {
+        $useFunc = true;
+        $untils[] = $msg->_getTitleMark();
+      }
+    }
+    if ($useFunc && $func !== null) {
+      try {
+        $func($this);
+      } finally {
+        /** @var _IMessenger $msg */
+        $index = 0;
+        foreach ($this->msgs as $msg) {
+          $msg->_endTitle($untils[$index++]);
+        }
+      }
+    }
+  }
+  function desc($content, ?int $level=null): void { foreach ($this->msgs as $msg) { $msg->desc($content, $level); } }
+  function action($content, ?callable $func=null, ?int $level=null): void {
+    $useFunc = false;
+    $untils = [];
+    foreach ($this->msgs as $msg) {
+      $msg->action($content, null, $level);
+      if ($msg instanceof _IMessenger) {
+        $useFunc = true;
+        $untils[] = $msg->_getTitleMark();
+      }
+    }
+    if ($useFunc && $func !== null) {
+      try {
+        $func($this);
+      } finally {
+        /** @var _IMessenger $msg */
+        $index = 0;
+        foreach ($this->msgs as $msg) {
+          $msg->_endAction($untils[$index++]);
+        }
+      }
+    }
+  }
+  function step($content, ?int $level=null): void { foreach ($this->msgs as $msg) { $msg->step($content, $level); } }
+  function asuccess($content=null): void { foreach ($this->msgs as $msg) { $msg->asuccess($content); } }
+  function afailure($content=null): void { foreach ($this->msgs as $msg) { $msg->afailure($content); } }
+  function adone($content=null): void { foreach ($this->msgs as $msg) { $msg->adone($content); } }
+  function print($content, ?int $level=null): void { foreach ($this->msgs as $msg) { $msg->print($content, $level); } }
+  function info($content, ?int $level=null): void { foreach ($this->msgs as $msg) { $msg->info($content, $level); } }
+  function note($content, ?int $level=null): void { foreach ($this->msgs as $msg) { $msg->note($content, $level); } }
+  function warn($content, ?int $level=null): void { foreach ($this->msgs as $msg) { $msg->warn($content, $level); } }
+  function error($content, ?int $level=null): void { foreach ($this->msgs as $msg) { $msg->error($content, $level); } }
+  function end(bool $all=false): void { foreach ($this->msgs as $msg) { $msg->end($all); } }
+}
diff --git a/php/src_output/std/StdMessenger.php b/php/src_output/std/StdMessenger.php
new file mode 100644
index 0000000..b7ba5ca
--- /dev/null
+++ b/php/src_output/std/StdMessenger.php
@@ -0,0 +1,693 @@
+<?php
+namespace nulib\output\std;
+
+use Exception;
+use nulib\cl;
+use nulib\ExceptionShadow;
+use nulib\UserException;
+use nulib\output\IMessenger;
+use Throwable;
+
+class StdMessenger implements _IMessenger {
+  const INDENT = "  ";
+  const DATE_FORMAT = 'Y-m-d\TH:i:s.u';
+
+  const VALID_LEVELS = [self::DEBUG, self::MINOR, self::NORMAL, self::MAJOR, self::NONE];
+  const LEVEL_MAP = [
+    "debug" => self::DEBUG,
+    "minor" => self::MINOR, "verbose" => self::MINOR,
+    "normal" => self::NORMAL,
+    "major" => self::MAJOR, "quiet" => self::MAJOR,
+    "none" => self::NONE, "silent" => self::NONE,
+  ];
+
+  protected static function verifix_level($level, int $max_level=self::MAX_LEVEL): int {
+    if (!in_array($level, self::VALID_LEVELS, true)) {
+      $level = cl::get(self::LEVEL_MAP, $level, $level);
+    }
+    if (!in_array($level, self::VALID_LEVELS, true)) {
+      throw new Exception("$level: invalid level");
+    }
+    if ($level > $max_level) {
+      throw new Exception("$level: level not allowed here");
+    }
+    return $level;
+  }
+
+  const GENERIC_PREFIXES = [
+    self::MAJOR => [
+      "section" => [true, "SECTION!", "===", "<color @b>=", "=</color>", "==="],
+      "title" => [false, "TITLE!", null, "<color @b>T", "</color>", "==="],
+      "desc" => ["DESC!", "<color @b>></color>", ""],
+      "error" => ["CRIT.ERROR!", "<color @r>E!", "</color>"],
+      "warn" => ["CRIT.WARN!", "<color @y>W!", "</color>"],
+      "note" => ["ATTENTION!", "<color @g>N!", "</color>"],
+      "info" => ["IMPORTANT!", "<color @b>N!", "</color>"],
+      "step" => ["*", "<color @w>.</color>", ""],
+      "print" => [null, null, null],
+    ],
+    self::NORMAL => [
+      "section" => [true, "SECTION:", "---", "<color @b>-", "-</color>", "---"],
+      "title" => [false, "TITLE:", null, "<color @b>T</color><color b>", "</color>", "---"],
+      "desc" => ["DESC:", "<color @b>></color>", ""],
+      "error" => ["ERROR:", "<color @r>E</color><color r>", "</color>"],
+      "warn" => ["WARN:", "<color @y>W</color><color y>", "</color>"],
+      "note" => ["NOTE:", "<color @g>N</color>", ""],
+      "info" => ["INFO:", "<color @b>I</color>", ""],
+      "step" => ["*", "<color @w>.</color>", ""],
+      "print" => [null, null, null],
+    ],
+    self::MINOR => [
+      "section" => [true, "section", null, "<color @w>>>", "<<</color>", null],
+      "title" => [false, "title", null, "<color b>t", "</color>", null],
+      "desc" => ["desc", "<color b>></color>", ""],
+      "error" => ["error", "<color r>E</color><color -r>", "</color>"],
+      "warn" => ["warn", "<color y>W</color><color -y>", "</color>"],
+      "note" => ["note", "<color g>N</color>", ""],
+      "info" => ["info", "<color b>I</color><color w>", "</color>"],
+      "step" => ["*", "<color w>.</color>", ""],
+      "print" => [null, null, null],
+    ],
+    self::DEBUG => [
+      "section" => [true, "section", null, "<color @w>>>", "<<</color>", null],
+      "title" => [false, "title", null, "<color b>t", "</color>", null],
+      "desc" => ["desc", "<color b>></color>", ""],
+      "error" => ["debugE", "<color r>e</color><color -r>", "</color>"],
+      "warn" => ["debugW", "<color y>w</color><color -y>", "</color>"],
+      "note" => ["debugN", "<color b>i</color>", ""],
+      "info" => ["debug", "<color @w>D</color><color w>", "</color>"],
+      "step" => ["*", "<color w>.</color>", ""],
+      "print" => [null, null, null],
+    ],
+  ];
+
+  const RESULT_PREFIXES = [
+    "failure" => ["(FAILURE)", "<color r>✘</color>"],
+    "success" => ["(SUCCESS)", "<color @g>✔</color>"],
+    "done" => [null, null],
+  ];
+
+  function __construct(?array $params=null) {
+    $output = cl::get($params, "output");
+    $color = cl::get($params, "color");
+    $indent = cl::get($params, "indent", static::INDENT);
+
+    $defaultLevel = cl::get($params, "default_level");
+    if ($defaultLevel === null) $defaultLevel = self::NORMAL;
+    $defaultLevel = self::verifix_level($defaultLevel);
+
+    $debug = boolval(cl::get($params, "debug"));
+    $minLevel = cl::get($params, "min_level");
+    if ($minLevel === null && $debug) $minLevel = self::DEBUG;
+    if ($minLevel === null) $minLevel = cl::get($params, "verbosity"); # alias
+    if ($minLevel === null) $minLevel = self::NORMAL;
+    $minLevel = self::verifix_level($minLevel, self::NONE);
+
+    $addDate = boolval(cl::get($params, "add_date"));
+    $dateFormat = cl::get($params, "date_format", static::DATE_FORMAT);
+    $id = cl::get($params, "id");
+
+    $params = [
+      "color" => $color,
+      "indent" => $indent,
+    ];
+    if ($output !== null) {
+      $this->err = $this->out = new StdOutput($output, $params);
+    } else {
+      $this->out = new StdOutput(STDOUT, $params);
+      $this->err = new StdOutput(STDERR, $params);
+    }
+    $this->defaultLevel = $defaultLevel;
+    $this->minLevel = $minLevel;
+    $this->addDate = $addDate;
+    $this->dateFormat = $dateFormat;
+    $this->id = $id;
+    $this->inSection = false;
+    $this->titles = [];
+    $this->actions = [];
+  }
+
+  function resetParams(?array $params=null): void {
+    $output = cl::get($params, "output");
+    $color = cl::get($params, "color");
+    $indent = cl::get($params, "indent");
+
+    $defaultLevel = cl::get($params, "default_level");
+    if ($defaultLevel !== null) $defaultLevel = self::verifix_level($defaultLevel);
+
+    $debug = cl::get($params, "debug");
+    $minLevel = cl::get($params, "min_level");
+    if ($minLevel === null && $debug !== null) $minLevel = $debug? self::DEBUG: self::NORMAL;
+    if ($minLevel === null) $minLevel = cl::get($params, "verbosity"); # alias
+    if ($minLevel !== null) $minLevel = self::verifix_level($minLevel, self::NONE);
+
+    $addDate = cl::get($params, "add_date");
+    $dateFormat = cl::get($params, "date_format");
+    $id = cl::get($params, "id");
+
+    $params = [
+      "output" => $output,
+      "color" => $color,
+      "indent" => $indent,
+    ];
+    if ($output !== null) {
+      $this->out->resetParams($params);
+    } else {
+      $this->out->resetParams($params);
+      $this->err->resetParams($params);
+    }
+    if ($defaultLevel !== null) $this->defaultLevel = $defaultLevel;
+    if ($minLevel !== null) $this->minLevel = $minLevel;
+    if ($addDate !== null) $this->addDate = boolval($addDate);
+    if ($dateFormat !== null) $this->dateFormat = $dateFormat;
+    if ($id !== null) $this->id = $id;
+  }
+
+  function clone(?array $params=null): IMessenger {
+    $clone = clone $this;
+    if ($params !== null) $clone->resetParams($params);
+    #XXX faut-il marquer la section et les titres du clone à "print" => false?
+    # ou en faire des références au parent?
+    # dans tous les cas, on considère qu'il n'y a pas d'actions en cours, et on
+    # ne doit pas dépiler avec end() plus que l'état que l'on a eu lors du clone
+    return $clone;
+  }
+
+  /** @var StdOutput la sortie standard */
+  protected $out;
+
+  /** @var StdOutput la sortie d'erreur */
+  protected $err;
+
+  /** @var int level par défaut dans lequel les messages sont affichés */
+  protected $defaultLevel;
+
+  /** @var int level minimum que doivent avoir les messages pour être affichés */
+  protected $minLevel;
+
+  /** @var bool faut-il ajouter la date à chaque ligne? */
+  protected $addDate;
+
+  /** @var string format de la date */
+  protected $dateFormat;
+
+  /** @var ?string identifiant de ce messenger, à ajouter à chaque ligne */
+  protected $id;
+
+  protected function getLinePrefix(): ?string {
+    $linePrefix = null;
+    if ($this->addDate) {
+      $date = date_create()->format($this->dateFormat);
+      $linePrefix .= "$date ";
+    }
+    if ($this->id !== null) {
+      $linePrefix .= "$this->id ";
+    }
+    return $linePrefix;
+  }
+
+  protected function decrLevel(int $level, int $amount=-1): int {
+    $level += $amount;
+    if ($level < self::MIN_LEVEL) $level = self::MIN_LEVEL;
+    return $level;
+  }
+
+  protected function checkLevel(?int &$level): bool {
+    if ($level === null) $level = $this->defaultLevel;
+    elseif ($level < 0) $level = $this->decrLevel($this->defaultLevel, $level);
+    return $level >= $this->minLevel;
+  }
+
+  protected function getIndentLevel(bool $withActions=true): int {
+    $indentLevel = count($this->titles) - 1;
+    if ($indentLevel < 0) $indentLevel = 0;
+    if ($withActions) {
+      foreach ($this->actions as $action) {
+        if ($action["level"] < $this->minLevel) continue;
+        $indentLevel++;
+      }
+    }
+    return $indentLevel;
+  }
+
+  protected function _printTitle(?string $linePrefix, int $level,
+                                 string $type, $content,
+                                 int $indentLevel, StdOutput $out): void {
+    $prefixes = self::GENERIC_PREFIXES[$level][$type];
+    if ($prefixes[0]) $out->print();
+    if ($out->isColor()) {
+      $before = $prefixes[2];
+      $prefix = $prefixes[3];
+      $prefix2 = $prefix !== null? "$prefix ": null;
+      $suffix = $prefixes[4];
+      $suffix2 = $suffix !== null? " $suffix": null;
+      $after = $prefixes[5];
+
+      $lines = $out->getLines(false, $content);
+      $maxlen = 0;
+      foreach ($lines as &$content) {
+        $line = $out->filterColors($content);
+        $len = mb_strlen($line);
+        if ($len > $maxlen) $maxlen = $len;
+        $content = [$content, $len];
+      }; unset($content);
+      if ($before !== null) {
+        if ($linePrefix !== null) $out->write($linePrefix);
+        $out->iprint($indentLevel, $prefix, substr($before, 1), str_repeat($before[0], $maxlen), $suffix);
+      }
+      foreach ($lines as [$content, $len]) {
+        if ($linePrefix !== null) $out->write($linePrefix);
+        $padding = $len < $maxlen? str_repeat(" ", $maxlen - $len): null;
+        $out->iprint($indentLevel, $prefix2, $content, $padding, $suffix2);
+      }
+      if ($after !== null) {
+        if ($linePrefix !== null) $out->write($linePrefix);
+        $out->iprint($indentLevel, $prefix, substr($after, 1), str_repeat($after[0], $maxlen), $suffix);
+      }
+    } else {
+      $prefix = $prefixes[1];
+      if ($prefix !== null) $prefix .= " ";
+      $prefix2 = str_repeat(" ", mb_strlen($prefix));
+      $lines = $out->getLines(false, $content);
+      foreach ($lines as $content) {
+        if ($linePrefix !== null) $out->write($linePrefix);
+        $out->iprint($indentLevel, $prefix, $content);
+        $prefix = $prefix2;
+      }
+    }
+  }
+
+  protected function _printAction(?string $linePrefix, int $level,
+                                  bool $printContent, $content,
+                                  bool $printResult, ?bool $rsuccess, $rcontent,
+                                  int $indentLevel, StdOutput $out): void {
+    $color = $out->isColor();
+    if ($rsuccess === true) $type = "success";
+    elseif ($rsuccess === false) $type = "failure";
+    else $type = "done";
+    $rprefixes = self::RESULT_PREFIXES[$type];
+    if ($color) {
+      $rprefix = $rprefixes[1];
+      $rprefix2 = null;
+      if ($rprefix !== null) {
+        $rprefix .= " ";
+        $rprefix2 = $out->filterColors($out->filterContent($rprefix));
+        $rprefix2 = str_repeat(" ", mb_strlen($rprefix2));
+      }
+    } else {
+      $rprefix = $rprefixes[0];
+      if ($rprefix !== null) $rprefix .= " ";
+      $rprefix2 = str_repeat(" ", mb_strlen($rprefix));
+    }
+    if ($printContent && $printResult) {
+      if ($rcontent) {
+        cl::ensure_array($content);
+        $content[] = ": ";
+        $content[] = $rcontent;
+      }
+      $lines = $out->getLines(false, $content);
+      foreach ($lines as $content) {
+        if ($linePrefix !== null) $out->write($linePrefix);
+        $out->iprint($indentLevel, $rprefix, $content);
+        $rprefix = $rprefix2;
+      }
+    } elseif ($printContent) {
+      $prefixes = self::GENERIC_PREFIXES[$level]["step"];
+      if ($color) {
+        $prefix = $prefixes[1];
+        if ($prefix !== null) $prefix .= " ";
+        $prefix2 = $out->filterColors($out->filterContent($prefix));
+        $prefix2 = str_repeat(" ", mb_strlen($prefix2));
+        $suffix = $prefixes[2];
+      } else {
+        $prefix = $prefixes[0];
+        if ($prefix !== null) $prefix .= " ";
+        $prefix2 = str_repeat(" ", mb_strlen($prefix));
+        $suffix = null;
+      }
+      $lines = $out->getLines(false, $content, ":");
+      foreach ($lines as $content) {
+        if ($linePrefix !== null) $out->write($linePrefix);
+        $out->iprint($indentLevel, $prefix, $content, $suffix);
+        $prefix = $prefix2;
+      }
+    } elseif ($printResult) {
+      if (!$rcontent) {
+        if ($type === "success") $rcontent = $color? "succès": "";
+        elseif ($type === "failure") $rcontent = $color? "échec": "";
+        elseif ($type === "done") $rcontent = "fait";
+      }
+      $rprefix = " $rprefix";
+      $rprefix2 = " $rprefix2";
+      $lines = $out->getLines(false, $rcontent);
+      foreach ($lines as $rcontent) {
+        if ($linePrefix !== null) $out->write($linePrefix);
+        $out->iprint($indentLevel, $rprefix, $rcontent);
+        $rprefix = $rprefix2;
+      }
+    }
+  }
+
+  protected function _printGeneric(?string $linePrefix, int $level,
+                                   string $type, $content,
+                                   int $indentLevel, StdOutput $out): void {
+    $prefixes = self::GENERIC_PREFIXES[$level][$type];
+    if ($out->isColor()) {
+      $prefix = $prefixes[1];
+      $prefix2 = null;
+      if ($prefix !== null) {
+        $prefix .= " ";
+        $prefix2 = $out->filterColors($out->filterContent($prefix));
+        $prefix2 = str_repeat(" ", mb_strlen($prefix2));
+      }
+      $suffix = $prefixes[2];
+      $lines = $out->getLines(false, $content);
+      foreach ($lines as $content) {
+        if ($linePrefix !== null) $out->write($linePrefix);
+        $out->iprint($indentLevel, $prefix, $content, $suffix);
+        $prefix = $prefix2;
+      }
+    } else {
+      $prefix = $prefixes[0];
+      if ($prefix !== null) $prefix .= " ";
+      $prefix2 = str_repeat(" ", mb_strlen($prefix));
+      $lines = $out->getLines(false, $content);
+      foreach ($lines as $content) {
+        if ($linePrefix !== null) $out->write($linePrefix);
+        $out->iprint($indentLevel, $prefix, $content);
+        $prefix = $prefix2;
+      }
+    }
+  }
+
+  protected function _printGenericOrException(?int $level, string $type, $content, int $indentLevel, StdOutput $out): void {
+    $linePrefix = $this->getLinePrefix();
+    # si $content contient des exceptions, les afficher avec un level moindre
+    $exceptions = null;
+    if (is_array($content)) {
+      $valueContent = null;
+      foreach ($content as $value) {
+        if ($value instanceof Throwable || $value instanceof ExceptionShadow) {
+          $exceptions[] = $value;
+        } else {
+          $valueContent[] = $value;
+        }
+      }
+      $content = $valueContent;
+    } elseif ($content instanceof Throwable || $content instanceof ExceptionShadow) {
+      $exceptions[] = $content;
+      $content = null;
+    }
+
+    $printActions = true;
+    $showContent = $this->checkLevel($level);
+    if ($content !== null && $showContent) {
+      $this->printActions(); $printActions = false;
+      $this->_printGeneric($linePrefix, $level, $type, $content, $indentLevel, $out);
+    }
+    if ($exceptions !== null) {
+      $level1 = $this->decrLevel($level);
+      $showTraceback = $this->checkLevel($level1);
+      foreach ($exceptions as $exception) {
+        # tout d'abord userMessage
+        $userMessage = UserException::get_user_message($exception);
+        if ($userMessage !== null && $showContent) {
+          if ($printActions) { $this->printActions(); $printActions = false; }
+          $this->_printGeneric($linePrefix, $level, $type, $userMessage, $indentLevel, $out);
+        }
+        # puis summary et traceback
+        if ($showTraceback) {
+          if ($printActions) { $this->printActions(); $printActions = false; }
+          $summary = UserException::get_summary($exception);
+          $traceback = UserException::get_traceback($exception);
+          $this->_printGeneric($linePrefix, $level1, $type, $summary, $indentLevel, $out);
+          $this->_printGeneric($linePrefix, $level1, $type, $traceback, $indentLevel, $out);
+        }
+      }
+    }
+  }
+
+  /** @var bool est-on dans une section? */
+  protected $inSection;
+
+  /** @var array section qui est en attente d'affichage */
+  protected $section;
+
+  function section($content, ?callable $func=null, ?int $level=null): void {
+    $this->_endSection();
+    $this->inSection = true;
+    if (!$this->checkLevel($level)) return;
+    $this->section = [
+      "line_prefix" => $this->getLinePrefix(),
+      "level" => $level,
+      "content" => $content,
+      "print_content" => true,
+    ];
+    if ($func !== null) {
+      try {
+        $func($this);
+      } finally {
+        $this->_endSection();
+      }
+    }
+  }
+
+  protected function printSection() {
+    $section =& $this->section;
+    if ($section !== null && $section["print_content"]) {
+      $this->_printTitle(
+        $section["line_prefix"], $section["level"],
+        "section", $section["content"],
+        0, $this->err);
+      $section["print_content"] = false;
+    }
+  }
+
+  function _endSection(): void {
+    $this->inSection = false;
+    $this->section = null;
+  }
+
+  /** @var array */
+  protected $titles;
+
+  /** @var array */
+  protected $title;
+
+  function _getTitleMark(): int {
+    return count($this->titles);
+  }
+
+  function title($content, ?callable $func=null, ?int $level=null): void {
+    if (!$this->checkLevel($level)) return;
+    $until = $this->_getTitleMark();
+    $this->titles[] = [
+      "line_prefix" => $this->getLinePrefix(),
+      "level" => $level,
+      "content" => $content,
+      "print_content" => true,
+      "descs" => [],
+      "print_descs" => false,
+    ];
+    $this->title =& $this->titles[$until];
+    if ($func !== null) {
+      try {
+        $func($this);
+      } finally {
+        $this->_endTitle($until);
+      }
+    }
+  }
+
+  function desc($content, ?int $level=null): void {
+    if (!$this->checkLevel($level)) return;
+    $title =& $this->title;
+    $title["descs"][] = [
+      "line_prefix" => $this->getLinePrefix(),
+      "level" => $level,
+      "content" => $content,
+    ];
+    $title["print_descs"] = true;
+  }
+
+  protected function printTitles(): void {
+    $this->printSection();
+    $err = $this->err;
+    $indentLevel = 0;
+    foreach ($this->titles as &$title) {
+      if ($title["print_content"]) {
+        $this->_printTitle(
+          $title["line_prefix"], $title["level"],
+          "title", $title["content"],
+          $indentLevel, $err);
+        $title["print_content"] = false;
+      }
+      if ($title["print_descs"]) {
+        foreach ($title["descs"] as $desc) {
+          $this->_printGeneric(
+            $desc["line_prefix"], $desc["level"],
+            "desc", $desc["content"],
+            $indentLevel, $err);
+        }
+        $title["descs"] = [];
+        $title["print_descs"] = false;
+      }
+      $indentLevel++;
+    }; unset($title);
+  }
+
+  function _endTitle(?int $until=null): void {
+    if ($until === null) $until = $this->_getTitleMark() - 1;
+    while (count($this->titles) > $until) {
+      array_pop($this->titles);
+    }
+    if ($this->titles) {
+      $this->title =& $this->titles[count($this->titles) - 1];
+    } else {
+      $this->titles = [];
+      unset($this->title);
+    }
+  }
+
+  /** @var array */
+  protected $actions;
+  
+  /** @var array */
+  protected $action;
+
+  function _getActionMark(): int {
+    return count($this->actions);
+  }
+
+  function action($content, ?callable $func=null, ?int $level=null): void {
+    $this->checkLevel($level);
+    $until = $this->_getActionMark();
+    $this->actions[] = [
+      "line_prefix" => $this->getLinePrefix(),
+      "level" => $level,
+      "content" => $content,
+      "print_content" => true,
+      "result_success" => null,
+      "result_content" => null,
+    ];
+    $this->action =& $this->actions[$until];
+    if ($func !== null) {
+      try {
+        $result = $func($this);
+        if ($result !== null) {
+          if ($result === true) $this->asuccess();
+          elseif ($result === false) $this->afailure();
+          else $this->adone($result);
+        }
+      } finally {
+        $this->_endAction($until);
+      }
+    }
+  }
+  
+  function printActions(bool $endAction=false): void {
+    $this->printTitles();
+    $err = $this->err;
+    $indentLevel = $this->getIndentLevel(false);
+    $lastIndex = count($this->actions) - 1;
+    $index = 0;
+    foreach ($this->actions as &$action) {
+      $mergeResult = $index++ == $lastIndex && $endAction;
+      $linePrefix = $action["line_prefix"];
+      $level = $action["level"];
+      $content = $action["content"];
+      $printContent = $action["print_content"];
+      $rsuccess = $action["result_success"];
+      $rcontent = $action["result_content"];
+      if ($level < $this->minLevel) continue;
+      if ($mergeResult) {
+        $this->_printAction(
+          $linePrefix, $level,
+          $printContent, $content,
+          true, $rsuccess, $rcontent,
+          $indentLevel, $err);
+      } elseif ($printContent) {
+        $this->_printAction(
+          $linePrefix, $level,
+          $printContent, $content,
+          false, $rsuccess, $rcontent,
+          $indentLevel, $err);
+        $action["print_content"] = false;
+      }
+      $indentLevel++;
+    }; unset($action);
+    if ($endAction) $this->_endAction();
+  }
+
+  function step($content, ?int $level=null): void {
+    $this->_printGenericOrException($level, "step", $content, $this->getIndentLevel(), $this->err);
+  }
+
+  function asuccess($content=null): void {
+    if (!$this->actions) $this->action(null);
+    $this->action["result_success"] = true;
+    $this->action["result_content"] = $content;
+    $this->printActions(true);
+  }
+
+  function afailure($content=null): void {
+    if (!$this->actions) $this->action(null);
+    $this->action["result_success"] = false;
+    $this->action["result_content"] = $content;
+    $this->printActions(true);
+  }
+
+  function adone($content=null): void {
+    if (!$this->actions) $this->action(null);
+    $this->action["result_success"] = null;
+    $this->action["result_content"] = $content;
+    $this->printActions(true);
+  }
+
+  function _endAction(?int $until=null): void {
+    if ($until === null) $until = $this->_getActionMark() - 1;
+    while (count($this->actions) > $until) {
+      array_pop($this->actions);
+    }
+    if ($this->actions) {
+      $this->action =& $this->actions[count($this->actions) - 1];
+    } else {
+      $this->actions = [];
+      unset($this->action);
+    }
+  }
+
+  function print($content, ?int $level=null): void {
+    $this->_printGenericOrException($level, "print", $content, $this->getIndentLevel(), $this->out);
+  }
+
+  function info($content, ?int $level=null): void {
+    $this->_printGenericOrException($level, "info", $content, $this->getIndentLevel(), $this->err);
+  }
+
+  function note($content, ?int $level=null): void {
+    $this->_printGenericOrException($level, "note", $content, $this->getIndentLevel(), $this->err);
+  }
+
+  function warn($content, ?int $level=null): void {
+    $this->_printGenericOrException($level, "warn", $content, $this->getIndentLevel(), $this->err);
+  }
+
+  function error($content, ?int $level=null): void {
+    $this->_printGenericOrException($level, "error", $content, $this->getIndentLevel(), $this->err);
+  }
+
+  function end(bool $all=false): void {
+    if ($all) {
+      while ($this->actions) $this->adone();
+      while ($this->titles) $this->_endTitle();
+      $this->_endSection();
+    } elseif ($this->actions) {
+      $this->_endAction();
+    } elseif ($this->titles) {
+      $this->_endTitle();
+    } else {
+      $this->_endSection();
+    }
+  }
+}
diff --git a/php/src_output/std/StdOutput.php b/php/src_output/std/StdOutput.php
new file mode 100644
index 0000000..a95468b
--- /dev/null
+++ b/php/src_output/std/StdOutput.php
@@ -0,0 +1,272 @@
+<?php
+namespace nulib\output\std;
+
+use Exception;
+use nulib\cl;
+use nulib\output\IContent;
+use nulib\output\IPrintable;
+
+/**
+ * Class StdOutput: affichage sur STDOUT, STDERR ou dans un fichier quelconque
+ *
+ * si la destination est un fichier, aucune gestion d'erreur n'est faite, sauf
+ * lors de l'ouverture.
+ */
+class StdOutput {
+  const COLORS = [
+    "reset" => "0",
+    "bold" => "1",
+    "faint" => "2",
+    "underlined" => "4",
+    "reverse" => "7",
+    "normal" => "22",
+    "black" => "30",
+    "red" => "31",
+    "green" => "32",
+    "yellow" => "33",
+    "blue" => "34",
+    "magenta" => "35",
+    "cyan" => "36",
+    "white" => "37",
+    "default" => "39",
+    "black-bg" => "40",
+    "red-bg" => "41",
+    "green-bg" => "42",
+    "yellow-bg" => "43",
+    "blue-bg" => "44",
+    "magenta-bg" => "45",
+    "cyan-bg" => "46",
+    "white-bg" => "47",
+    "default-bg" => "49",
+  ];
+
+  const COLOR_MAP = [
+    "z" => "reset",
+    "o" => "black",
+    "r" => "red",
+    "g" => "green",
+    "y" => "yellow",
+    "b" => "blue",
+    "m" => "magenta",
+    "c" => "cyan",
+    "w" => "white",
+    "O" => "black_bg",
+    "R" => "red_bg",
+    "G" => "green_bg",
+    "Y" => "yellow_bg",
+    "B" => "blue_bg",
+    "M" => "magenta_bg",
+    "C" => "cyan_bg",
+    "W" => "white_bg",
+    "@" => "bold",
+    "-" => "faint",
+    "_" => "underlined",
+    "~" => "reverse",
+    "n" => "normal",
+  ];
+
+  /**
+   * @param resource|null $outf
+   * @throws Exception si la destination est un fichier et que son ouverture a
+   * échoué
+   */
+  function __construct($output=null, ?array $params=null) {
+    if ($output !== null) $params["output"] = $output;
+    elseif (!isset($params["output"])) $params["output"] = STDOUT;
+    if (!isset($params["filter_tags"])) $params["filter_tags"] = true;
+    if (!isset($params["indent"])) $params["indent"] = "  ";
+    $this->resetParams($params);
+  }
+
+  function resetParams(?array $params=null): void {
+    $output = cl::get($params, "output");
+    $maskErrors = null;
+    $color = cl::get($params, "color");
+    $filterTags = cl::get($params, "filter_tags");
+    $indent = cl::get($params, "indent");
+    $flush = cl::get($params, "flush");
+
+    if ($output !== null) {
+      if ($output === "php://stdout") {
+        $outf = STDOUT;
+      } elseif ($output === "php://stderr") {
+        $outf = STDERR;
+      } elseif (!is_resource($output)) {
+        # si $outf est un nom de fichier, vérifier que l'ouverture se fait sans
+        # erreur. à partir de là, plus aucune gestion d'erreur n'est faite, à
+        # part afficher les erreurs d'écriture la première fois qu'elles se
+        # produisent
+        $maskErrors = false;
+        $outf = @fopen($output, "ab");
+        if ($outf === false) {
+          $error = error_get_last();
+          if ($error !== null) $message = $error["message"];
+          else $message = "$output: open error";
+          throw new Exception($message);
+        }
+        if ($flush === null) $flush = true;
+      } else {
+        $outf = $output;
+      }
+      $this->outf = $outf;
+      $this->maskErrors = $maskErrors;
+      if ($color === null) $color = stream_isatty($outf);
+      if ($flush === null) $flush = false;
+    }
+    if ($color !== null) $this->color = boolval($color);
+    if ($filterTags !== null) $this->filterTags = boolval($filterTags);
+    if ($indent !== null) $this->indent = strval($indent);
+    if ($flush !== null) $this->flush = boolval($flush);
+  }
+
+  /** @var resource  */
+  protected $outf;
+
+  /** @var bool faut-il masquer les erreurs d'écriture? */
+  protected $maskErrors;
+
+  /** @var bool faut-il autoriser la sortie en couleur? */
+  protected $color;
+
+  function isColor(): bool {
+    return $this->color;
+  }
+
+  /** @var bool faut-il enlever les tags dans la sortie? */
+  protected $filterTags;
+
+  /** @var string indentation unitaire */
+  protected $indent;
+
+  /** @var bool faut-il flush le fichier après l'écriture de chaque ligne */
+  protected $flush;
+
+  function isatty(): bool {
+    return stream_isatty($this->outf);
+  }
+
+  private static function replace_colors(array $ms): string {
+    $colors = [];
+    foreach (preg_split('/\s+/', $ms[1]) as $color) {
+      while ($color && !cl::has(self::COLORS, $color)) {
+        $alias = substr($color, 0, 1);
+        $colors[] = self::COLOR_MAP[$alias];
+        $color = substr($color, 1);
+      }
+      if ($color) $colors[] = $color;
+    }
+    $text = "\x1B[";
+    $first = true;
+    foreach ($colors as $color) {
+      if (!$color) continue;
+      if ($first) $first = false;
+      else $text .= ";";
+      $text .= self::COLORS[$color];
+    }
+    $text .= "m";
+    return $text;
+  }
+  function filterContent(string $text): string {
+    # couleur au début
+    $text = preg_replace_callback('/<color([^>]*)>/', [self::class, "replace_colors"], $text);
+    # reset à la fin
+    $text = preg_replace('/<\/color>/', "\x1B[0m", $text);
+    # enlever les tags classiques
+    if ($this->filterTags) {
+      $text = preg_replace('/<[^>]*>/', "", $text);
+    }
+    return $text;
+  }
+  function filterColors(string $text): string {
+    return preg_replace('/\x1B\[.*?m/', "", $text);
+  }
+
+  static function flatten($values, ?array &$dest=null): array {
+    if ($dest === null) $dest = [];
+    if ($values === null) return $dest;
+    if (is_string($values)) {
+      $dest[] = $values;
+      return $dest;
+    } elseif (!is_array($values)) {
+      if ($values instanceof IContent) {
+        $values = $values->getContent();
+      } elseif ($values instanceof IPrintable) {
+        ob_start(null, 0, PHP_OUTPUT_HANDLER_STDFLAGS ^ PHP_OUTPUT_HANDLER_FLUSHABLE);
+        $values->print();
+        $dest[] = ob_get_clean();
+        return $dest;
+      } elseif (!is_iterable($values)) {
+        $dest[] = strval($values);
+        return $dest;
+      }
+    }
+    foreach ($values as $value) {
+      self::flatten($value, $dest);
+    }
+    return $dest;
+  }
+
+  function getIndent(int $indentLevel): string {
+    return str_repeat($this->indent, $indentLevel);
+  }
+
+  function getLines(bool $withNl, ...$values): array {
+    $values = self::flatten($values);
+    if (!$values) return [];
+    $text = implode("", $values);
+    if ($text === "") return [""];
+    $text = $this->filterContent($text);
+    if (!$this->color) $text = $this->filterColors($text);
+    $lines = explode("\n", $text);
+    $max = count($lines) - 1;
+    if ($withNl) {
+      for ($i = 0; $i < $max; $i++) {
+        $lines[$i] .= "\n";
+      }
+    }
+    if ($lines[$max] === "") unset($lines[$max]);
+    return $lines;
+  }
+
+  private function _fwrite($outf, string $data): void {
+    if ($this->maskErrors === null) {
+      # masquer les erreurs d'écriture en permanence
+      @fwrite($outf, $data);
+      return;
+    }
+    # masquer uniquement la première erreur, jusqu'à ce que l'erreur disparaisse
+    if ($this->maskErrors) $r = @fwrite($outf, $data);
+    else $r = fwrite($outf, $data);
+    $this->maskErrors = $r === false;
+  }
+
+  function writeLines($indent, array $lines, bool $addNl=false): void {
+    $outf = $this->outf;
+    foreach ($lines as $line) {
+      if ($indent !== null) $this->_fwrite($outf, $indent);
+      $this->_fwrite($outf, $line);
+      if ($addNl) $this->_fwrite($outf, "\n");
+    }
+    if ($this->flush) @fflush($outf);
+  }
+
+  function write(...$values): void {
+    $this->writeLines(null, $this->getLines(true, ...$values));
+  }
+
+  function print(...$values): void {
+    $values[] = "\n";
+    $this->writeLines(null, $this->getLines(true, ...$values));
+  }
+
+  function iwrite(int $indentLevel, ...$values): void {
+    $indent = $this->getIndent($indentLevel);
+    $this->writeLines($indent, $this->getLines(true, ...$values));
+  }
+
+  function iprint(int $indentLevel, ...$values): void {
+    $values[] = "\n";
+    $indent = $this->getIndent($indentLevel);
+    $this->writeLines($indent, $this->getLines(true, ...$values));
+  }
+}
diff --git a/php/src_output/std/_IMessenger.php b/php/src_output/std/_IMessenger.php
new file mode 100644
index 0000000..9b54b59
--- /dev/null
+++ b/php/src_output/std/_IMessenger.php
@@ -0,0 +1,19 @@
+<?php
+namespace nulib\output\std;
+
+use nulib\output\IMessenger;
+
+/**
+ * Interface _IMessenger: méthodes privées de IMessenger
+ */
+interface _IMessenger extends IMessenger {
+  function _endSection(): void;
+
+  function _getTitleMark(): int;
+
+  function _endTitle(?int $until=null): void;
+
+  function _getActionMark(): int;
+
+  function _endAction(?int $until=null): void;
+}
diff --git a/php/src_web/params/F.php b/php/src_web/params/F.php
new file mode 100644
index 0000000..468f37f
--- /dev/null
+++ b/php/src_web/params/F.php
@@ -0,0 +1,67 @@
+<?php
+namespace nulib\web\params;
+
+use nulib\str;
+
+/**
+ * Class F: gestion unifiée des paramètres POST + GET
+ */
+class F {
+  /** tester si le paramètre $name existe dans $_POST ou $_GET */
+  static final function has($name): bool {
+    if ($name === null || $name === false) return false;
+    elseif (array_key_exists($name, $_POST)) return true;
+    elseif (array_key_exists($name, $_GET)) return true;
+    else return false;
+  }
+
+  /** obtenir le paramètre $name en cherchant dans $_POST puis $_GET */
+  static final function get($name, $default=null, bool $trim=false) {
+    if ($name === null || $name === false) $value = $default;
+    elseif (array_key_exists($name, $_POST)) $value = $_POST[$name];
+    elseif (array_key_exists($name, $_GET)) $value = $_GET[$name];
+    else $value = $default;
+    if ($trim) $value = str::trim($value);
+    return $value;
+  }
+
+  /**
+   * modifier le paramètre.
+   *
+   * - s'il provenait de $_POST, modifier $_POST
+   * - s'il provenait de $_GET, modifier $_GET
+   * - sinon modifier $_POST
+   */
+  static final function set(string $name, ?string $value): void {
+    if (array_key_exists($name, $_POST)) $_POST[$name] = $value;
+    elseif (array_key_exists($name, $_GET)) $_GET[$name] = $value;
+    else $_POST[$name] = $value;
+  }
+
+  /** obtenir la liste des clés définies dans les paramètres */
+  protected static final function get_names(): array {
+    return array_keys(array_merge(
+      array_fill_keys(array_keys($_POST), true),
+      array_fill_keys(array_keys($_GET), true),
+    ));
+  }
+
+  /**
+   * retourner une liste des paramètres qui ont été passés, en les sélectionnant
+   * selon le contenu de $includes et $excludes. ensuite, fusionner le tableau
+   * $merge s'il est spécifié
+   *
+   * pour être sélectionné, un paramètre ne doit pas être dans $excludes, et si
+   * $includes n'est pas null, doit être dans $includes
+   */
+  static final function select(?array $includes=null, ?array $excludes=null, ?array $merges=null): array {
+    $params = [];
+    foreach (self::get_names() as $name) {
+      if ($excludes !== null && in_array($name, $excludes)) continue;
+      if ($includes !== null && !in_array($name, $includes)) continue;
+      $params[$name] = self::get($name);
+    }
+    if ($merges !== null) $params = array_merge($params, $merges);
+    return $params;
+  }
+}
diff --git a/php/src_web/params/G.php b/php/src_web/params/G.php
new file mode 100644
index 0000000..febdfd3
--- /dev/null
+++ b/php/src_web/params/G.php
@@ -0,0 +1,28 @@
+<?php
+namespace nulib\web\params;
+
+use nulib\cl;
+use nulib\str;
+
+/**
+ * Class G: gestion des paramètres $_GET
+ */
+class G {
+  /** tester si le paramètre $name existe */
+  static final function has($name): bool {
+    if ($name === null || $name === false) return false;
+    return array_key_exists($name, $_GET);
+  }
+
+  /** obtenir le paramètre $name */
+  static final function get($name, $default=null, bool $trim=false) {
+    $value = cl::get($_GET, $name, $default);
+    if ($trim) $value = str::trim($value);
+    return $value;
+  }
+
+  /** modifier le paramètre. */
+  static final function set(string $name, ?string $value): void {
+    $_GET[$name] = $value;
+  }
+}
diff --git a/php/src_web/params/P.php b/php/src_web/params/P.php
new file mode 100644
index 0000000..04faeec
--- /dev/null
+++ b/php/src_web/params/P.php
@@ -0,0 +1,33 @@
+<?php
+namespace nulib\web\params;
+
+use nulib\cl;
+use nulib\str;
+
+/**
+ * Class P: gestion des paramètres $_POST
+ */
+class P {
+  /** tester si le paramètre $name existe */
+  static final function has($name): bool {
+    if ($name === null || $name === false) return false;
+    return array_key_exists($name, $_POST);
+  }
+
+  /** obtenir le paramètre $name */
+  static final function get($name, $default=null, bool $trim=false) {
+    $value = cl::get($_POST, $name, $default);
+    if ($trim) $value = str::trim($value);
+    return $value;
+  }
+
+  /** modifier le paramètre. */
+  static final function set(string $name, ?string $value): void {
+    $_POST[$name] = $value;
+  }
+
+  /** obtenir le corps de la requête POST */
+  static final function raw(): string {
+    return file_get_contents("php://input");
+  }
+}
diff --git a/php/src_web/params/R.php b/php/src_web/params/R.php
new file mode 100644
index 0000000..9c1aae6
--- /dev/null
+++ b/php/src_web/params/R.php
@@ -0,0 +1,23 @@
+<?php
+namespace nulib\web\params;
+
+use nulib\cl;
+use nulib\str;
+
+/**
+ * Class R: gestion des paramètres $_REQUEST (GET + POST + COOKIES)
+ */
+class R {
+  /** tester si le paramètre $name existe */
+  static final function has($name): bool {
+    if ($name === null || $name === false) return false;
+    return array_key_exists($name, $_REQUEST);
+  }
+
+  /** obtenir le paramètre $name */
+  static final function get($name, $default=null, bool $trim=false) {
+    $value = cl::get($_REQUEST, $name, $default);
+    if ($trim) $value = str::trim($value);
+    return $value;
+  }
+}