@kirigami/php-prepros 1.1.0 → 1.6.0

package/src/libraries/yaml.class.php

@@ -1,29 +1,29 @@
 <?php
 
 /**
- * YAML — Parseur YAML léger, entièrement statique.
+ * YAML — lightweight, fully static YAML parser.
  *
- * Utilisation :
- *   $data = YAML::parse($yamlString);          // mappings → stdClass (défaut)
- *   $data = YAML::parse($yamlString, true);    // mappings → array associatif
- *   $data = YAML::parseFile('/chemin/vers/config.yaml');
+ * Usage:
+ *   $data = YAML::parse($yamlString);          // mappings → stdClass (default)
+ *   $data = YAML::parse($yamlString, true);    // mappings → associative array
+ *   $data = YAML::parseFile('/path/to/config.yaml');
  *
- * Supporte :
- *  - Scalaires typés (string, int, float, bool, null)
- *  - Guillemets simples et doubles (avec séquences d'échappement)
- *  - Blocs multi-lignes (| littéral et > replié, avec chomping -, +)
- *  - Plain scalars multi-lignes (continuation sans indicateur)
- *  - Mappings et séquences imbriqués
- *  - Collections inline [a, b] et {k: v}
- *  - Commentaires (#)
- *  - Documents multiples séparés par ---
+ * Supports:
+ *  - Typed scalars (string, int, float, bool, null)
+ *  - Single and double quotes (with escape sequences)
+ *  - Multi-line blocks (| literal and > folded, with chomping -, +)
+ *  - Multi-line plain scalars (continuation with no indicator)
+ *  - Nested mappings and sequences
+ *  - Inline collections [a, b] and {k: v}
+ *  - Comments (#)
+ *  - Multiple documents separated by ---
  */
 class YAML
 {
     private function __construct() {}
 
     // -------------------------------------------------------------------------
-    // Points d'entrée publics
+    // Public entry points
     // -------------------------------------------------------------------------
 
     public static function parse(string $yaml, bool $assoc = false): mixed
@@ -49,60 +49,60 @@ class YAML
     public static function parseFile(string $path, bool $assoc = false): mixed
     {
         if (!is_readable($path)) {
-            throw new \RuntimeException("Impossible de lire le fichier : $path");
+            throw new \RuntimeException("Cannot read file: $path");
         }
         return self::parse(file_get_contents($path), $assoc);
     }
 
     /**
-     * Charge un fichier YAML ou JSON, puis parcourt récursivement le résultat
-     * et remplace toute valeur string qui correspond à un chemin relatif vers
-     * un fichier YAML/JSON existant par le contenu désérialisé de ce fichier.
+     * Loads a YAML or JSON file, then walks the result recursively and replaces
+     * any string value that matches a relative path to an existing YAML/JSON
+     * file with that file's deserialized content.
      *
-     * Chaque fichier inclus est lui-même résolu relativement à son propre
-     * répertoire, et ainsi de suite (récursif).
+     * Each included file is itself resolved relative to its own directory, and
+     * so on (recursive).
      *
-     * Si la chaîne ne se termine pas par .yml/.yaml/.json, ou si le fichier
-     * résolu n'existe pas, la valeur est conservée telle quelle.
+     * If the string doesn't end in .yml/.yaml/.json, or the resolved file
+     * doesn't exist, the value is kept as-is.
      *
-     * Les références circulaires (ex. A → B → A) lèvent une RuntimeException.
+     * Circular references (e.g. A → B → A) throw a RuntimeException.
      *
-     * Utilisation :
-     *   $data = YAML::loadFile('/chemin/vers/config.yaml');
-     *   $data = YAML::loadFile('/chemin/vers/config.yaml', true); // arrays assoc
+     * Usage:
+     *   $data = YAML::loadFile('/path/to/config.yaml');
+     *   $data = YAML::loadFile('/path/to/config.yaml', true); // assoc arrays
      *
-     * @param string   $path   Chemin vers le fichier racine (YAML ou JSON).
-     * @param bool     $assoc  true → mappings en array, false → stdClass.
+     * @param string   $path   Path to the root file (YAML or JSON).
+     * @param bool     $assoc  true → mappings as arrays, false → stdClass.
      * @return mixed
      */
     public static function loadFile(string $path, bool $assoc = false): mixed
     {
         $absolute = realpath($path);
         if ($absolute === false || !is_readable($absolute)) {
-            throw new \RuntimeException("Impossible de lire le fichier : $path");
+            throw new \RuntimeException("Cannot read file: $path");
         }
 
         return self::loadFileRecursive($absolute, $assoc, []);
     }
 
     // -------------------------------------------------------------------------
-    // Méthodes privées pour loadFile
+    // Private methods for loadFile
     // -------------------------------------------------------------------------
 
     /**
-     * Charge et résout un fichier, en propageant la liste des ancêtres pour
-     * détecter les cycles.
+     * Loads and resolves a file, propagating the list of ancestors to detect
+     * cycles.
      *
-     * @param string   $absolute Chemin absolu canonique du fichier à charger.
+     * @param string   $absolute Canonical absolute path of the file to load.
      * @param bool     $assoc
-     * @param string[] $ancestors Chemins absolus des fichiers en cours de traitement.
+     * @param string[] $ancestors Absolute paths of the files currently being processed.
      * @return mixed
      */
     private static function loadFileRecursive(string $absolute, bool $assoc, array $ancestors): mixed
     {
         if (in_array($absolute, $ancestors, true)) {
             throw new \RuntimeException(
-                "Référence circulaire détectée : " . implode(' → ', $ancestors) . " → $absolute"
+                "Circular reference detected: " . implode(' → ', $ancestors) . " → $absolute"
             );
         }
 
@@ -113,7 +113,7 @@ class YAML
         if ($ext === 'json') {
             $data = json_decode($raw, $assoc, 512, JSON_THROW_ON_ERROR);
         } else {
-            // .yml, .yaml ou autre extension traitée comme YAML
+            // .yml, .yaml or any other extension treated as YAML
             $data = self::parse($raw, $assoc);
         }
 
@@ -121,11 +121,11 @@ class YAML
     }
 
     /**
-     * Parcourt récursivement une valeur PHP (objet stdClass, array, string,
-     * scalaire) et résout les références vers des fichiers externes.
+     * Recursively walks a PHP value (stdClass object, array, string, scalar)
+     * and resolves references to external files.
      *
      * @param mixed    $node
-     * @param string   $dir      Répertoire du fichier qui contient ce nœud.
+     * @param string   $dir      Directory of the file that contains this node.
      * @param bool     $assoc
      * @param string[] $ancestors
      * @return mixed
@@ -150,14 +150,14 @@ class YAML
             return $node;
         }
 
-        // int, float, bool, null → retourné tel quel
+        // int, float, bool, null → returned as-is
         return $node;
     }
 
     /**
-     * Si la chaîne pointe vers un fichier YAML/JSON existant (chemin relatif
-     * au répertoire $dir), charge ce fichier récursivement. Sinon retourne la
-     * chaîne d'origine.
+     * If the string points to an existing YAML/JSON file (path relative to the
+     * $dir directory), loads that file recursively. Otherwise returns the
+     * original string.
      *
      * @param string   $str
      * @param string   $dir
@@ -169,24 +169,24 @@ class YAML
     {
         $trimmed = trim($str);
 
-        // Filtre rapide sur l'extension
+        // Quick filter on the extension
         if (!preg_match('/\.(ya?ml|json)$/i', $trimmed)) {
             return $str;
         }
 
-        // Résolution du chemin relatif au répertoire du fichier parent
+        // Resolve the path relative to the parent file's directory
         $candidate = $dir . DIRECTORY_SEPARATOR . $trimmed;
         $absolute  = realpath($candidate);
 
         if ($absolute === false || !is_readable($absolute)) {
-            return $str; // Fichier introuvable → string ordinaire
+            return $str; // File not found → plain string
         }
 
         return self::loadFileRecursive($absolute, $assoc, $ancestors);
     }
 
     // -------------------------------------------------------------------------
-    // Parsing récursif
+    // Recursive parsing
     // -------------------------------------------------------------------------
 
     private static function parseBlock(array $lines, int &$pos, int $indent, bool $assoc = false): mixed
@@ -231,13 +231,13 @@ class YAML
             $pos++;
 
             if ($rest === null) {
-                // Valeur sur les lignes suivantes : sous-bloc ou plain scalar multi-ligne
+                // Value on the following lines: sub-block or multi-line plain scalar
                 self::skipEmptyAndComments($lines, $pos);
                 if ($pos < count($lines)) {
                     $nextIndent = self::getIndent($lines[$pos]);
                     if ($nextIndent > $indent) {
                         $nextTrimmed = ltrim($lines[$pos]);
-                        // Plain scalar si ce n'est ni un mapping ni une séquence
+                        // Plain scalar if it's neither a mapping nor a sequence
                         if (!self::isMapping($nextTrimmed) && !str_starts_with($nextTrimmed, '- ')) {
                             $result[$key] = self::parseScalar(
                                 self::collectPlainScalar($lines, $pos, $indent, '')
@@ -258,7 +258,7 @@ class YAML
             } elseif ($rest !== '' && ($rest[0] === '[' || $rest[0] === '{')) {
                 $result[$key] = self::parseInlineCollection($rest, $assoc);
             } else {
-                // Scalaire inline, peut être suivi de lignes de continuation
+                // Inline scalar, may be followed by continuation lines
                 $result[$key] = self::parseScalar(
                     self::collectPlainScalar($lines, $pos, $indent, $rest)
                 );
@@ -299,10 +299,10 @@ class YAML
                     $result[] = null;
                 }
             } elseif (self::isMapping($itemContent)) {
-                // Mapping inline dans la séquence :
-                // On reconstruit un tableau de lignes virtuel en préfixant la première clé
-                // avec fakeIndent, puis on délègue entièrement à parseMapping pour bénéficier
-                // de toute sa logique (|, >, plain scalars, sous-blocs…).
+                // Inline mapping inside the sequence:
+                // Rebuild a virtual array of lines by prefixing the first key
+                // with fakeIndent, then delegate entirely to parseMapping to get
+                // all of its logic (|, >, plain scalars, sub-blocks…).
                 $fakeIndent   = $lineIndent + 2;
                 $fakePrefix   = str_repeat(' ', $fakeIndent);
                 $virtualLines = array_merge(
@@ -324,12 +324,12 @@ class YAML
     }
 
     // -------------------------------------------------------------------------
-    // Plain scalar multi-ligne
+    // Multi-line plain scalar
     // -------------------------------------------------------------------------
 
     /**
-     * Collecte un scalaire qui peut continuer sur des lignes plus indentées que $parentIndent.
-     * Les lignes de continuation sont jointes par un espace (repli implicite).
+     * Collects a scalar that may continue on lines more indented than $parentIndent.
+     * Continuation lines are joined with a space (implicit folding).
      */
     private static function collectPlainScalar(array $lines, int &$pos, int $parentIndent, string $first): string
     {
@@ -339,18 +339,18 @@ class YAML
             $raw     = $lines[$pos];
             $trimmed = trim($raw);
 
-            // Ligne vide : fin du scalaire
+            // Blank line: end of the scalar
             if ($trimmed === '') break;
 
             $lineIndent = self::getIndent($raw);
 
-            // Retour à l'indentation parente ou moins : fin
+            // Back to the parent indentation or less: end
             if ($lineIndent <= $parentIndent) break;
 
-            // Commentaire seul sur la ligne : fin
+            // Comment alone on the line: end
             if (str_starts_with($trimmed, '#')) break;
 
-            // C'est un mapping ou une séquence : fin
+            // It's a mapping or a sequence: end
             if (self::isMapping($trimmed) || str_starts_with($trimmed, '- ')) break;
 
             $parts[] = $trimmed;
@@ -361,7 +361,7 @@ class YAML
     }
 
     // -------------------------------------------------------------------------
-    // Blocs multi-lignes
+    // Multi-line blocks
     // -------------------------------------------------------------------------
 
     private static function parseLiteralBlock(array $lines, int &$pos, int $parentIndent, string $indicator): string
@@ -435,7 +435,7 @@ class YAML
     }
 
     // -------------------------------------------------------------------------
-    // Collections inline  [a, b]  {k: v}
+    // Inline collections  [a, b]  {k: v}
     // -------------------------------------------------------------------------
 
     private static function parseInlineCollection(string $raw, bool $assoc = false): mixed
@@ -500,7 +500,7 @@ class YAML
     }
 
     // -------------------------------------------------------------------------
-    // Scalaires
+    // Scalars
     // -------------------------------------------------------------------------
 
     private static function parseScalar(string $value): mixed
@@ -534,7 +534,7 @@ class YAML
     }
 
     // -------------------------------------------------------------------------
-    // Utilitaires
+    // Helpers
     // -------------------------------------------------------------------------
 
     private static function getIndent(string $line): int

package/src/phpjs/fstat.js

@@ -0,0 +1,9 @@
+import path from "path";
+import getFileStats from "../utils/getfilestats.js";
+
+const __root = process.cwd();
+
+export default async function fstat(php, msg) {
+	const file = path.join(__root, msg.path);
+	return getFileStats(file);
+}

package/src/prepros.js

@@ -8,6 +8,7 @@ import { walkFile } from '@kirigami/struct-walker';
 import { getPHPRuntime, getPHPRuntimeWithNetwork } from "@kirigami/php-wasm";
 
 
+const __modules = new Map;
 const __project = process.cwd();
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const __configpath = path.join(__project, 'kirigami.yaml');
@@ -20,39 +21,59 @@ const config = await walkFile(__configpath);
 if(!config) throw `Invalid config file: ${__configpath}`;
 
 
-
 const getPHPInstance = async () => {
     if(!__php) {
         if(config?.kirigami?.root === undefined) throw `Missing prepros:root property in config file: ${__configpath}`;
         __root = path.join(__project, config.kirigami.root);
         if (!fs.existsSync(__root)) throw `Invalid prepros:root path: ${__root}`;
 
+        if(!config.image) config.image = {};
+        if(!config.image.format) config.image.format = 'webp';
+        if(!config.image.source) config.image.source = 'assets/images/';
+        if(!config.image.dest) config.image.dest = 'images/';
+
         const preprosConfig = config.prepros || {};
+        preprosConfig.image = config.image;
         preprosConfig.timezone = Intl.DateTimeFormat().resolvedOptions().timeZone;
         preprosConfig.root = joinWith('/project/', config?.kirigami?.root);
         preprosConfig.data = config.kirigami || {};
+        preprosConfig.jsonld = config.jsonld ?? null;
+        // The build task list — read by PREPROS::injectHead() to auto-wire each
+        // page's <head> with a <link>/<script> per sass/esbuild task output.
+        preprosConfig.tasks = config.tasks || [];
 
         __php = await (preprosConfig.network ? getPHPRuntimeWithNetwork() : getPHPRuntime());
         __php.setSpawnHandler((command, args, options) => spawn(command, args, options));
         __php.preprosConfig = preprosConfig;
+        __php.setIniValues({
+            log_errors:      1,
+            html_errors:     0,
+            display_errors:  1,
+            error_reporting: 32767,
+            error_log:       'php://stderr',
+            memory_limit:    '2G',
+        });
+
+        await mountPath(__dirname, '/prepros', __php);
+        await mountPath(joinWith(__project, config?.kirigami?.root), joinWith('/project', config?.kirigami?.root), __php);
 
         const __cache = path.join(__project, '.cache.db');
         const __cookie = path.join(__project, '.cookie.txt');
-        mountPath(__php, __dirname, '/prepros');
-        mountPath(__php, joinWith(__project, config?.kirigami?.root), joinWith('/project', config?.kirigami?.root));
+        if (fs.existsSync(__cache)) await mountPath(__cache, '/project/.cache.db', __php);
+        if (fs.existsSync(__cookie)) await mountPath(__cookie, '/project/.cookie.txt', __php);
 
-        if (fs.existsSync(__cache)) mountPath(__php, __cache, '/project/.cache.db');
-        if (fs.existsSync(__cookie)) mountPath(__php, __cookie, '/project/.cookie.txt');
-
-        __php.onMessage(async (data) => {
+        __php.onMessage(async data => {
             const msg = JSON.parse(data);
             if(!msg.command) return { success: false, error: "Invalid command."};
             const file = path.join(__dirname, 'phpjs', `${msg.command}.js`);
             if(!fs.existsSync(file)) return { success: false, error: "Invalid command."};
-
             try {
-                const cmdModule = await import(pathToFileURL(file).href);
-                const results = await cmdModule.default(__php, msg);
+                if(!__modules.has(msg.command)) {
+                    const cmdModule = await import(pathToFileURL(file).href);
+                    __modules.set(msg.command, cmdModule);
+                }
+                const mod = __modules.get(msg.command);
+                const results = await mod.default(__php, msg);
                 return JSON.stringify({
                     success: true,
                     results: results
@@ -63,35 +84,36 @@ const getPHPInstance = async () => {
                     error: typeof e == 'string' ? e : e.message
                 }
             }
-
-
-            // console.log(msg);
-            // console.log(__dirname);
-
         });
     }
     return __php;
 }
 
 
-const mountPath = (php, localPath, virtualDir) => {
+const mountPath = async (localPath, virtualDir, php) => {
+    php = php || await getPHPInstance();
+    if(!path.isAbsolute(localPath)) localPath = path.join(__project, localPath);
+    virtualDir = virtualDir || path.posix.join('/project', localPath.replace(__project + path.sep, ''));
     const includeExtensions = new Set(['.php', '.json', '.yaml', '.yml', '.md', '.db', '.txt', ...(config?.prepros?.mountext || [])]);
     const stat = fs.statSync(localPath);
     if (stat.isDirectory()) {
         php.mkdirTree(virtualDir);
         for (const entry of fs.readdirSync(localPath, { withFileTypes: true })) {
-            mountPath(php, path.join(localPath, entry.name), virtualDir + '/' + entry.name);
-        }
-    } else {
-        const ext = path.extname(localPath).toLowerCase();
-        if (includeExtensions.has(ext)) {
-            const buf = fs.readFileSync(localPath);
-            const parentDir = virtualDir.substring(0, virtualDir.lastIndexOf('/'));
-            if (parentDir) {
-                php.mkdirTree(parentDir);
+            const target = path.join(localPath, entry.name);
+            if(!fs.statSync(target).isDirectory()) {
+                const ext = path.extname(target).toLowerCase();
+                if (includeExtensions.has(ext)) {
+                    await mountPath(target, virtualDir + '/' + entry.name, php);
+                }
+            } else {
+                await mountPath(target, virtualDir + '/' + entry.name, php);
             }
-            php.writeFile(virtualDir, isBinary(buf) ? buf : buf.toString('utf8'));
         }
+    } else {
+        const buf = fs.readFileSync(localPath);
+        const parentDir = virtualDir.substring(0, virtualDir.lastIndexOf('/'));
+        if (parentDir) php.mkdirTree(parentDir);
+        php.writeFile(virtualDir, isBinary(buf) ? buf : buf.toString('utf8'));
     }
 }
 
@@ -129,7 +151,6 @@ const run = async (args = [], script = null, mountfiles = []) => {
             const buffer = php.readFileAsBuffer(resultPath);
             retobj = JSON.parse(Buffer.from(buffer).toString('utf8'));
             retobj.debug = stdout;
-
             if(retobj.files) await Promise.all(retobj.files.map(async (file, i) => {
                 const fbuffer = php.readFileAsBuffer(file);
                 const dest = file.replace(/^\/project\//i, '');
@@ -139,23 +160,60 @@ const run = async (args = [], script = null, mountfiles = []) => {
                 retobj.files[i] = dest;
             }));
         } else {
-            retobj = { success: true, files: [], debug: stdout };
+            // No result file: PHP exited before STD::succeed()/error() — a
+            // parse error, an OOM, a die(), a hard crash. Pull whatever
+            // explanation we can out of the streams instead of a silent pass.
+            const crash = extractPhpError(stderr) || extractPhpError(stdout);
+            retobj = {
+                success: false,
+                files: [],
+                error: crash || 'PHP produced no result (exited early — check the debug output).',
+                debug: stdout,
+                stderr,
+            };
         }
     } catch (e) {
-        retobj = { success: false, error: 'Response parsing error.' + e, debug: stdout, stderr };
+        retobj = { success: false, error: 'Response parsing error: ' + (e?.message || e), debug: stdout, stderr };
     } finally {
         if (await php.fileExists(resultPath)) {
             await php.unlink(resultPath);
         }
     }
+
+    // A fatal that still managed to write a (stale/partial) result file, or
+    // warnings printed to stderr. Only a genuine fatal marker overrides a
+    // result the PHP side reported as a success; plain warnings are attached
+    // as `warnings` so a stray notice doesn't sink an otherwise-clean build.
     if (stderr) {
-        retobj = { success: false, error: stderr, debug: stdout };
+        const fatal = extractPhpError(stderr);
+        if (fatal && (!retobj || retobj.success !== false)) {
+            retobj = { success: false, files: [], error: fatal, debug: stdout, stderr };
+        } else if (retobj && retobj.success && !fatal) {
+            retobj.warnings = stderr.trim();
+        } else if (retobj && retobj.success === false && !retobj.stderr) {
+            retobj.stderr = stderr.trim();
+        }
+    }
+
+    // Never hand back a failure without a usable message.
+    if (retobj && retobj.success === false && !retobj.error) {
+        retobj.error = retobj.message || retobj.stderr || 'Unknown error.';
     }
 
     return retobj;
 }
 
 
+// Pulls the first meaningful PHP error line out of a stdout/stderr blob
+// (fatals, parse errors, uncaught throwables). Returns null when the text
+// holds nothing that looks like a hard error.
+const extractPhpError = (text) => {
+    if (!text) return null;
+    const m = text.match(/^.*\b(?:PHP\s+)?(?:Fatal error|Parse error|Uncaught\s+\w+|Recoverable fatal error)\b.*$/mi);
+    return m ? m[0].trim() : null;
+}
+
+
 const runenv = async (script, paths = [], ...args) => {
     if(!script) throw "Missing PHP file.";
     const file = path.resolve(script);
@@ -166,30 +224,51 @@ const runenv = async (script, paths = [], ...args) => {
 }
 
 
-const render = async (file = '.') => {
-    const php = await getPHPInstance();
-    const target = path.resolve(__project, config?.kirigami?.root, file);
+// Run a batch of image jobs (resize / palette) through /prepros/imagebatch.php,
+// i.e. the IMG class (GD + Imagick). Used by @kirigami/kirigami's `sass` task so
+// that img-asset() / colors() and the PHP IMG::asset() / <img asset> tag share
+// one engine. `jobs` is the list documented in imagebatch.php; the result is a
+// PreprosResult plus a `colors` map ({ "<src>:<count>": ["#rrggbb", …] }).
+const processImages = async (jobs = []) => {
+    if (!Array.isArray(jobs) || !jobs.length) return { success: true, files: [], colors: {} };
+    const result = await run(['imagebatch', JSON.stringify(jobs)], '/prepros/imagebatch.php');
+    if (!result.colors) result.colors = {};
+    if (!result.files) result.files = [];
+    return result;
+}
+
+
+const render = async (file = '.', phpIncludes = []) => {
+    const target = path.resolve(config?.kirigami?.root, file);
     const fsvm = path.join('/project', config?.kirigami?.root, file).replace(/\\/g, '/');
-    mountPath(php, target, fsvm);
-    if(config?.prepros?.before) {
-        const include = path.resolve(__project, config?.kirigami?.root, config?.prepros?.before);
-        const dest = path.join('/project', config?.kirigami?.root, config?.prepros?.before).replace(/\\/g, '/');
-        mountPath(php, include, dest);
-    }
-    if(config?.prepros?.after) {
-        const include = path.resolve(__project, config?.kirigami?.root, config?.prepros?.after);
-        const dest = path.join('/project', config?.kirigami?.root, config?.prepros?.after).replace(/\\/g, '/');
-        mountPath(php, include, dest);
+    await mountPath(target);
+    if(config?.prepros?.before) await mountPath(path.resolve(config?.kirigami?.root, config?.prepros?.before));
+    if(config?.prepros?.after) await mountPath(path.resolve(config?.kirigami?.root, config?.prepros?.after));
+
+    // Extra PHP files contributed by plugins (the kiri 'prepros:php' hook):
+    // mounted outside /project and include_once'd once, before any page
+    // renders, so they can PREPROS::registerTag()/registerHook() from PHP.
+    if (Array.isArray(phpIncludes) && phpIncludes.length) {
+        const php = await getPHPInstance();
+        const mounted = [];
+        for (let i = 0; i < phpIncludes.length; i++) {
+            const abs = path.resolve(phpIncludes[i]);
+            if (!fs.existsSync(abs)) continue;
+            const virt = `/plugins/${i}_${path.basename(abs)}`;
+            await mountPath(abs, virt, php);
+            mounted.push(virt);
+        }
+        php.preprosConfig.phpIncludes = mounted;
     }
+
     return run([fsvm]);
 }
 
 
-const sitemap = async (dir) => {
-    const php = await getPHPInstance();
-    mountPath(php, __root, '/project/' + config?.kirigami?.root);
+const sitemap = async () => {
+    await mountPath(config?.kirigami?.root);
     return run(['sitemap']);
 }
 
 
-export { runenv, render, sitemap };
+export { runenv, render, sitemap, mountPath, processImages };

package/src/prepros.php

@@ -24,8 +24,15 @@ try {
         throw new Exception("Invalid target.");
     }
 
-} catch(Exception $e) {
-    STD::error(['message' => $e->getMessage()]);
+} catch(Throwable $e) {
+    // Catch Error/TypeError too, not just Exception, so a fatal in a template
+    // (a bad call, a null arg, …) still comes back as a structured result with
+    // a real message and the page that blew up — never a bare "Error: undefined".
+    STD::error([
+        'error' => $e->getMessage(),
+        'page'  => PREPROS::$file ?: ($argv[1] ?? null),
+        'where' => $e->getFile() . ':' . $e->getLine(),
+    ]);
 }
 
 

package/src/runenv.php

@@ -10,8 +10,11 @@ try {
 
     require_once($argv[1]);
 
-} catch(Exception $e) {
-    STD::error($e->getMessage());
+} catch(Throwable $e) {
+    STD::error([
+        'error' => $e->getMessage(),
+        'where' => $e->getFile() . ':' . $e->getLine(),
+    ]);
 }
 
 STD::succeed(['files' => PREPROS::getExportedFiles()]);