@plurid/plurid-react-server 0.0.0-14 → 0.0.0-16

package/distribution/index.js

@@ -1,1127 +1,1644 @@
 "use strict";
-
-Object.defineProperty(exports, "__esModule", {
-    value: true
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// source/index.ts
+var index_exports = {};
+__export(index_exports, {
+  PluridLiveServer: () => LiveServer_default,
+  PluridStillsGenerator: () => StillsGenerator_default,
+  default: () => index_default
 });
-
-var fs = require("fs");
-
-var path = require("path");
-
-var express = require("express");
-
-var compression = require("compression");
-
-var bodyParser = require("body-parser");
-
-var open = require("open");
-
-var styledComponents = require("styled-components");
-
-var pluridFunctions = require("@plurid/plurid-functions");
-
-var pluridEngine = require("@plurid/plurid-engine");
-
-var pluridReact = require("@plurid/plurid-react");
-
-var htmlMinifier = require("html-minifier");
-
-var React = require("react");
-
-var server = require("react-dom/server");
-
-var reactHelmetAsync = require("react-helmet-async");
-
-var http = require("http");
-
-var child_process = require("child_process");
-
-var detectPort = require("detect-port");
-
-function _interopDefaultLegacy(e) {
-    return e && typeof e === "object" && "default" in e ? e : {
-        default: e
-    };
-}
-
-var fs__default = _interopDefaultLegacy(fs);
-
-var path__default = _interopDefaultLegacy(path);
-
-var express__default = _interopDefaultLegacy(express);
-
-var compression__default = _interopDefaultLegacy(compression);
-
-var open__default = _interopDefaultLegacy(open);
-
-var React__default = _interopDefaultLegacy(React);
-
-var http__default = _interopDefaultLegacy(http);
-
-var detectPort__default = _interopDefaultLegacy(detectPort);
-
-function __awaiter(thisArg, _arguments, P, generator) {
-    function adopt(value) {
-        return value instanceof P ? value : new P((function(resolve) {
-            resolve(value);
-        }));
-    }
-    return new (P || (P = Promise))((function(resolve, reject) {
-        function fulfilled(value) {
-            try {
-                step(generator.next(value));
-            } catch (e) {
-                reject(e);
-            }
-        }
-        function rejected(value) {
-            try {
-                step(generator["throw"](value));
-            } catch (e) {
-                reject(e);
-            }
-        }
-        function step(result) {
-            result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
-        }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    }));
-}
-
-function __await(v) {
-    return this instanceof __await ? (this.v = v, this) : new __await(v);
-}
-
-function __asyncGenerator(thisArg, _arguments, generator) {
-    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
-    var g = generator.apply(thisArg, _arguments || []), i, q = [];
-    return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function() {
-        return this;
-    }, i;
-    function verb(n) {
-        if (g[n]) i[n] = function(v) {
-            return new Promise((function(a, b) {
-                q.push([ n, v, a, b ]) > 1 || resume(n, v);
-            }));
-        };
-    }
-    function resume(n, v) {
-        try {
-            step(g[n](v));
-        } catch (e) {
-            settle(q[0][3], e);
-        }
-    }
-    function step(r) {
-        r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r);
-    }
-    function fulfill(value) {
-        resume("next", value);
-    }
-    function reject(value) {
-        resume("throw", value);
-    }
-    function settle(f, v) {
-        if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]);
-    }
-}
-
-const DEFAULT_SERVER_PORT = process.env.PORT ? parseInt(process.env.PORT) : 8080;
-
-const DEFAULT_SERVER_OPTIONS_SERVER_NAME = "Plurid Server";
-
-const DEFAULT_SERVER_OPTIONS_HOSTNAME = "origin";
-
-const DEFAULT_SERVER_OPTIONS_QUIET = false;
-
-const DEFAULT_SERVER_OPTIONS_COMPRESSION = true;
-
-const DEFAULT_SERVER_OPTIONS_OPEN = false;
-
-const DEFAULT_SERVER_OPTIONS_BUILD_DIRECTORY = "build";
-
-const DEFAULT_SERVER_OPTIONS_ASSETS_DIRECTORY = "assets";
-
-const DEFAULT_SERVER_OPTIONS_STILLS_DIRECTORY = "stills";
-
-const DEFAULT_SERVER_OPTIONS_GATEWAY = "/gateway";
-
-const DEFAULT_SERVER_OPTIONS = {
-    SERVER_NAME: DEFAULT_SERVER_OPTIONS_SERVER_NAME,
-    HOSTNAME: DEFAULT_SERVER_OPTIONS_HOSTNAME,
-    QUIET: DEFAULT_SERVER_OPTIONS_QUIET,
-    COMPRESSION: DEFAULT_SERVER_OPTIONS_COMPRESSION,
-    OPEN: DEFAULT_SERVER_OPTIONS_OPEN,
-    BUILD_DIRECTORY: DEFAULT_SERVER_OPTIONS_BUILD_DIRECTORY,
-    ASSETS_DIRECTORY: DEFAULT_SERVER_OPTIONS_ASSETS_DIRECTORY,
-    STILLS_DIRECTORY: DEFAULT_SERVER_OPTIONS_STILLS_DIRECTORY,
-    GATEWAY: DEFAULT_SERVER_OPTIONS_GATEWAY
+module.exports = __toCommonJS(index_exports);
+
+// source/objects/Server/index.ts
+var import_fs2 = __toESM(require("fs"));
+var import_path2 = __toESM(require("path"));
+var import_express = __toESM(require("express"));
+var import_compression = __toESM(require("compression"));
+var import_open = __toESM(require("open"));
+var import_styled_components2 = require("styled-components");
+var import_plurid_functions = require("@plurid/plurid-functions");
+var import_plurid_engine = require("@plurid/plurid-engine");
+var import_plurid_react2 = require("@plurid/plurid-react");
+
+// source/data/constants/general/index.ts
+var DEFAULT_SERVER_PORT = process.env.PORT ? parseInt(process.env.PORT) : 8080;
+var DEFAULT_SERVER_OPTIONS_SERVER_NAME = "Plurid Server";
+var DEFAULT_SERVER_OPTIONS_HOSTNAME = "origin";
+var DEFAULT_SERVER_OPTIONS_QUIET = false;
+var DEFAULT_SERVER_OPTIONS_COMPRESSION = true;
+var DEFAULT_SERVER_OPTIONS_OPEN = false;
+var DEFAULT_SERVER_OPTIONS_BUILD_DIRECTORY = "build";
+var DEFAULT_SERVER_OPTIONS_ASSETS_DIRECTORY = "assets";
+var DEFAULT_SERVER_OPTIONS_STILLS_DIRECTORY = "stills";
+var DEFAULT_SERVER_OPTIONS_GATEWAY = "/gateway";
+var DEFAULT_SERVER_OPTIONS = {
+  SERVER_NAME: DEFAULT_SERVER_OPTIONS_SERVER_NAME,
+  HOSTNAME: DEFAULT_SERVER_OPTIONS_HOSTNAME,
+  QUIET: DEFAULT_SERVER_OPTIONS_QUIET,
+  COMPRESSION: DEFAULT_SERVER_OPTIONS_COMPRESSION,
+  OPEN: DEFAULT_SERVER_OPTIONS_OPEN,
+  BUILD_DIRECTORY: DEFAULT_SERVER_OPTIONS_BUILD_DIRECTORY,
+  ASSETS_DIRECTORY: DEFAULT_SERVER_OPTIONS_ASSETS_DIRECTORY,
+  STILLS_DIRECTORY: DEFAULT_SERVER_OPTIONS_STILLS_DIRECTORY,
+  GATEWAY: DEFAULT_SERVER_OPTIONS_GATEWAY
 };
-
-const DEFAULT_RENDERER_LANGUAGE = "en";
-
-const DEFAULT_RENDERER_ROOT = "root";
-
-const DEFAULT_RENDERER_PLURID_STATE = "{}";
-
-const DEFAULT_RENDERER_VENDOR_SCRIPT_SOURCE = "/vendor.js";
-
-const DEFAULT_RENDERER_MAIN_SCRIPT_SOURCE = "/index.js";
-
-const DEFAULT__PRELOADED_PLURID_METASTATE__ = "__PRELOADED_PLURID_METASTATE__";
-
-const CATCH_ALL_ROUTE = "*";
-
-const NOT_FOUND_ROUTE = process.env.PLURID_SERVER_NOT_FOUND_ROUTE || "/not-found";
-
-const PTTP_ROUTE = process.env.PLURID_SERVER_PTTP_ROUTE || "/pttp";
-
-const environment = {
-    production: process.env.ENV_MODE === "production",
-    development: process.env.ENV_MODE === "development"
+var DEFAULT_RENDERER_LANGUAGE = "en";
+var DEFAULT_RENDERER_ROOT = "root";
+var DEFAULT_RENDERER_PLURID_STATE = "{}";
+var DEFAULT_RENDERER_VENDOR_SCRIPT_SOURCE = "/vendor.js";
+var DEFAULT_RENDERER_MAIN_SCRIPT_SOURCE = "/index.js";
+var DEFAULT__PRELOADED_PLURID_METASTATE__ = "__PRELOADED_PLURID_METASTATE__";
+var CATCH_ALL_ROUTE = "*";
+var CATCH_ALL_ROUTE_PATTERN = /.*/;
+var NOT_FOUND_ROUTE = process.env.PLURID_SERVER_NOT_FOUND_ROUTE || "/not-found";
+var PTTP_ROUTE = process.env.PLURID_SERVER_PTTP_ROUTE || "/pttp";
+var environment = {
+  production: process.env.ENV_MODE === "production",
+  development: process.env.ENV_MODE === "development"
 };
 
-const defaultStillerOptions = {
-    waitUntil: "networkidle0",
-    timeout: 3e4,
-    ignore: []
+// source/data/constants/stiller/index.ts
+var defaultStillerOptions = {
+  waitUntil: "networkidle0",
+  timeout: 3e4,
+  ignore: []
 };
 
-const cleanTemplate = template => htmlMinifier.minify(template, {
-    collapseWhitespace: true,
-    conservativeCollapse: true,
-    collapseInlineTagWhitespace: false
-});
-
-const resolveBackgroundStyle = store => {
-    var _a;
-    const defaultBackground = {
-        gradientBackground: "hsl(220, 10%, 32%)",
-        gradientForeground: "hsl(220, 10%, 18%)"
-    };
-    try {
-        const storeJSON = JSON.parse(store);
-        const generalPluridTheme = (_a = storeJSON === null || storeJSON === void 0 ? void 0 : storeJSON.themes) === null || _a === void 0 ? void 0 : _a.general;
-        if (!generalPluridTheme) {
-            return defaultBackground;
-        }
-        const gradientBackground = generalPluridTheme.type === "dark" ? generalPluridTheme.backgroundColorTertiary : generalPluridTheme.backgroundColorPrimary;
-        const gradientForeground = generalPluridTheme.type === "dark" ? generalPluridTheme.backgroundColorPrimary : generalPluridTheme.backgroundColorTertiary;
-        return {
-            gradientBackground: gradientBackground,
-            gradientForeground: gradientForeground
-        };
-    } catch (error) {
-        return defaultBackground;
+// source/utilities/template/index.ts
+var import_html_minifier_terser = require("html-minifier-terser");
+var cleanTemplate = (template2) => {
+  return (0, import_html_minifier_terser.minify)(
+    template2,
+    {
+      collapseWhitespace: true,
+      conservativeCollapse: true,
+      collapseInlineTagWhitespace: false
     }
+  );
 };
-
-const recordToString = record => {
-    if (!record) {
-        return "";
-    }
-    let recordString = "";
-    for (const [key, value] of Object.entries(record)) {
-        recordString += `${key}="${value}"`;
+var resolveBackgroundStyle = (store) => {
+  const defaultBackground = {
+    gradientBackground: "hsl(220, 10%, 32%)",
+    gradientForeground: "hsl(220, 10%, 18%)"
+  };
+  try {
+    const storeJSON = JSON.parse(store);
+    const generalPluridTheme = storeJSON?.themes?.general;
+    if (!generalPluridTheme) {
+      return defaultBackground;
     }
-    return recordString;
+    const gradientBackground = generalPluridTheme.type === "dark" ? generalPluridTheme.backgroundColorTertiary : generalPluridTheme.backgroundColorPrimary;
+    const gradientForeground = generalPluridTheme.type === "dark" ? generalPluridTheme.backgroundColorPrimary : generalPluridTheme.backgroundColorTertiary;
+    return {
+      gradientBackground,
+      gradientForeground
+    };
+  } catch (error) {
+    return defaultBackground;
+  }
 };
-
-const assetsPathRewrite = content => content.replace(/="client\//g, '="/');
-
-const globalsInjector = globals => {
-    let globalsScript = "";
-    for (const [key, value] of Object.entries(globals)) {
-        const globalScript = `window.${key} = ${value};\n`;
-        globalsScript += globalScript;
-    }
-    return globalsScript;
+var escapeAttribute = (value) => {
+  return String(value).replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+};
+var recordToString = (record) => {
+  if (!record) {
+    return "";
+  }
+  return Object.entries(record).map(([key, value]) => `${key}="${escapeAttribute(value)}"`).join(" ");
+};
+var assetsPathRewrite = (content) => {
+  return content.replace(
+    /="client\//g,
+    '="/'
+  );
+};
+var safeStore = (store) => {
+  return store.replace(
+    /</g,
+    "\\u003c"
+  );
+};
+var globalsInjector = (globals) => {
+  let globalsScript = "";
+  for (const [key, value] of Object.entries(globals)) {
+    const globalScript = `window.${key} = ${value};
+`;
+    globalsScript += globalScript;
+  }
+  return globalsScript;
 };
 
-const NOT_FOUND_TEMPLATE = cleanTemplate(`\n<!DOCTYPE html>\n<html>\n    <head>\n        <title>[404] Not Found</title>\n        <style>\n            html, body {\n                margin: 0;\n                background: #242b33;\n                color: #ddd;\n                user-select: none;\n            }\n\n            .not-found {\n                position: absolute;\n                top: 50%;\n                left: 50%;\n                transform: translate(-50%, -50%);\n                font-family: 'Ubuntu', -apple-system, system-ui, BlinkMacSystemFont, 'Segoe UI', Roboto;\n            }\n        </style>\n    </head>\n\n    <body>\n        <div class="not-found">[404] Not Found</div>\n    </body>\n</html>\n`);
+// source/data/templates/index.ts
+var NOT_FOUND_TEMPLATE = cleanTemplate(`
+<!DOCTYPE html>
+<html>
+    <head>
+        <title>[404] Not Found</title>
+        <style>
+            html, body {
+                margin: 0;
+                background: #242b33;
+                color: #ddd;
+                user-select: none;
+            }
 
-const SERVER_ERROR_TEMPLATE = cleanTemplate(`\n<!DOCTYPE html>\n<html>\n    <head>\n        <title>[500] Server Error</title>\n        <style>\n            html, body {\n                margin: 0;\n                background: #242b33;\n                color: #ddd;\n                user-select: none;\n            }\n\n            .error {\n                position: absolute;\n                top: 50%;\n                left: 50%;\n                transform: translate(-50%, -50%);\n                font-family: 'Ubuntu', -apple-system, system-ui, BlinkMacSystemFont, 'Segoe UI', Roboto;\n            }\n        </style>\n    </head>\n\n    <body>\n        <div class="error">[500] Server Error</div>\n    </body>\n</html>\n`);
+            .not-found {
+                position: absolute;
+                top: 50%;
+                left: 50%;
+                transform: translate(-50%, -50%);
+                font-family: 'Ubuntu', -apple-system, system-ui, BlinkMacSystemFont, 'Segoe UI', Roboto;
+            }
+        </style>
+    </head>
+
+    <body>
+        <div class="not-found">[404] Not Found</div>
+    </body>
+</html>
+`);
+var SERVER_ERROR_TEMPLATE = cleanTemplate(`
+<!DOCTYPE html>
+<html>
+    <head>
+        <title>[500] Server Error</title>
+        <style>
+            html, body {
+                margin: 0;
+                background: #242b33;
+                color: #ddd;
+                user-select: none;
+            }
 
-const template = data => {
-    const {htmlLanguage: htmlLanguage, head: head, htmlAttributes: htmlAttributes, bodyAttributes: bodyAttributes, defaultStyle: defaultStyle, styles: styles, headScripts: headScripts, bodyScripts: bodyScripts, vendorScriptSource: vendorScriptSource, mainScriptSource: mainScriptSource, root: root, content: content, defaultPreloadedPluridMetastate: defaultPreloadedPluridMetastate, pluridMetastate: pluridMetastate, globals: globals, minify: minify} = data;
-    const injectedGlobals = globalsInjector(globals);
-    const templateString = `\n<!DOCTYPE html>\n<html lang="${htmlLanguage}" ${htmlAttributes}>\n    <head>\n        ${head}\n\n        ${defaultStyle && `<style>\n                ${defaultStyle}\n            </style>`}\n\n        ${styles}\n\n        ${headScripts.join("\n")}\n\n        <script src="${vendorScriptSource}"><\/script>\n        <script defer src="${mainScriptSource}"><\/script>\n    </head>\n    <body ${bodyAttributes}>\n        <div id="${root}">${content}</div>\n\n        <script>\n            ${injectedGlobals}\n            window.${defaultPreloadedPluridMetastate} = ${pluridMetastate};\n        <\/script>\n\n        ${bodyScripts.join("\n")}\n    </body>\n</html>\n    `;
-    if (!minify) {
-        return templateString;
-    }
-    return cleanTemplate(templateString);
+            .error {
+                position: absolute;
+                top: 50%;
+                left: 50%;
+                transform: translate(-50%, -50%);
+                font-family: 'Ubuntu', -apple-system, system-ui, BlinkMacSystemFont, 'Segoe UI', Roboto;
+            }
+        </style>
+    </head>
+
+    <body>
+        <div class="error">[500] Server Error</div>
+    </body>
+</html>
+`);
+
+// source/objects/Renderer/template/index.ts
+var template = async (data) => {
+  const {
+    htmlLanguage,
+    head,
+    htmlAttributes,
+    bodyAttributes,
+    defaultStyle,
+    styles,
+    headScripts,
+    bodyScripts,
+    vendorScriptSource,
+    mainScriptSource,
+    root,
+    content,
+    defaultPreloadedPluridMetastate,
+    pluridMetastate,
+    globals,
+    minify: minify2
+  } = data;
+  const injectedGlobals = globalsInjector(globals);
+  const templateString = `
+<!DOCTYPE html>
+<html lang="${htmlLanguage}" ${htmlAttributes}>
+    <head>
+        ${head}
+
+        ${defaultStyle && `<style>
+                ${defaultStyle}
+            </style>`}
+
+        ${styles}
+
+        ${headScripts.join("\n")}
+
+        <script src="${vendorScriptSource}"></script>
+        <script defer src="${mainScriptSource}"></script>
+    </head>
+    <body ${bodyAttributes}>
+        <div id="${root}">${content}</div>
+
+        <script>
+            ${injectedGlobals}
+            window.${defaultPreloadedPluridMetastate} = ${safeStore(pluridMetastate)};
+        </script>
+
+        ${bodyScripts.join("\n")}
+    </body>
+</html>
+    `;
+  if (!minify2) {
+    return templateString;
+  }
+  return cleanTemplate(templateString);
 };
-
-class PluridRenderer {
-    constructor(configuration) {
-        const {htmlLanguage: htmlLanguage, head: head, htmlAttributes: htmlAttributes, bodyAttributes: bodyAttributes, defaultStyle: defaultStyle, styles: styles, headScripts: headScripts, bodyScripts: bodyScripts, vendorScriptSource: vendorScriptSource, mainScriptSource: mainScriptSource, content: content, root: root, defaultPreloadedPluridMetastate: defaultPreloadedPluridMetastate, pluridMetastate: pluridMetastate, globals: globals, minify: minify} = configuration;
-        const {gradientBackground: gradientBackground, gradientForeground: gradientForeground} = resolveBackgroundStyle("");
-        const defaultStyleBasic = `\n            body {\n                background: radial-gradient(ellipse at center, ${gradientBackground} 0%, ${gradientForeground} 100%);\n                height: 100%;\n                margin: 0;\n            }\n        `;
-        this.htmlLanguage = htmlLanguage || DEFAULT_RENDERER_LANGUAGE;
-        this.head = head || "";
-        this.htmlAttributes = htmlAttributes;
-        this.bodyAttributes = bodyAttributes || "";
-        this.defaultStyle = defaultStyle !== null && defaultStyle !== void 0 ? defaultStyle : defaultStyleBasic;
-        this.styles = styles;
-        this.headScripts = headScripts;
-        this.bodyScripts = bodyScripts;
-        this.vendorScriptSource = vendorScriptSource || DEFAULT_RENDERER_VENDOR_SCRIPT_SOURCE;
-        this.mainScriptSource = mainScriptSource || DEFAULT_RENDERER_MAIN_SCRIPT_SOURCE;
-        this.root = root || DEFAULT_RENDERER_ROOT;
-        this.content = assetsPathRewrite(content) || "";
-        this.defaultPreloadedPluridMetastate = defaultPreloadedPluridMetastate || DEFAULT__PRELOADED_PLURID_METASTATE__;
-        this.pluridMetastate = pluridMetastate || DEFAULT_RENDERER_PLURID_STATE;
-        this.globals = globals !== null && globals !== void 0 ? globals : {};
-        this.minify = minify !== null && minify !== void 0 ? minify : true;
-    }
-    html() {
-        const data = {
-            htmlLanguage: this.htmlLanguage,
-            head: this.head,
-            htmlAttributes: this.htmlAttributes,
-            bodyAttributes: this.bodyAttributes,
-            defaultStyle: this.defaultStyle,
-            styles: this.styles,
-            headScripts: this.headScripts,
-            bodyScripts: this.bodyScripts,
-            vendorScriptSource: this.vendorScriptSource,
-            mainScriptSource: this.mainScriptSource,
-            root: this.root,
-            content: this.content,
-            defaultPreloadedPluridMetastate: this.defaultPreloadedPluridMetastate,
-            pluridMetastate: this.pluridMetastate,
-            globals: this.globals,
-            minify: this.minify
-        };
-        return template(data);
-    }
-}
-
-const wrapping = (WrappedComponent, WrappeeComponent, properties) => class extends React__default["default"].Component {
+var template_default = template;
+
+// source/objects/Renderer/index.ts
+var PluridRenderer = class {
+  htmlLanguage;
+  head;
+  htmlAttributes;
+  bodyAttributes;
+  defaultStyle;
+  styles;
+  headScripts;
+  bodyScripts;
+  vendorScriptSource;
+  mainScriptSource;
+  root;
+  content;
+  defaultPreloadedPluridMetastate;
+  pluridMetastate;
+  globals;
+  minify;
+  constructor(configuration) {
+    const {
+      htmlLanguage,
+      head,
+      htmlAttributes,
+      bodyAttributes,
+      defaultStyle,
+      styles,
+      headScripts,
+      bodyScripts,
+      vendorScriptSource,
+      mainScriptSource,
+      content,
+      root,
+      defaultPreloadedPluridMetastate,
+      pluridMetastate,
+      globals,
+      minify: minify2
+    } = configuration;
+    const {
+      gradientBackground,
+      gradientForeground
+      // The metastate carries `themes.general` (see `serverComputeMetastate`), so the SSR'd background
+      // gradient matches the active theme; `resolveBackgroundStyle` falls back to a default if it can't parse.
+    } = resolveBackgroundStyle(pluridMetastate || "");
+    const defaultStyleBasic = `
+            body {
+                background: radial-gradient(ellipse at center, ${gradientBackground} 0%, ${gradientForeground} 100%);
+                height: 100%;
+                margin: 0;
+            }
+        `;
+    this.htmlLanguage = htmlLanguage || DEFAULT_RENDERER_LANGUAGE;
+    this.head = head || "";
+    this.htmlAttributes = htmlAttributes;
+    this.bodyAttributes = bodyAttributes || "";
+    this.defaultStyle = defaultStyle ?? defaultStyleBasic;
+    this.styles = styles;
+    this.headScripts = headScripts;
+    this.bodyScripts = bodyScripts;
+    this.vendorScriptSource = vendorScriptSource || DEFAULT_RENDERER_VENDOR_SCRIPT_SOURCE;
+    this.mainScriptSource = mainScriptSource || DEFAULT_RENDERER_MAIN_SCRIPT_SOURCE;
+    this.root = root || DEFAULT_RENDERER_ROOT;
+    this.content = assetsPathRewrite(content) || "";
+    this.defaultPreloadedPluridMetastate = defaultPreloadedPluridMetastate || DEFAULT__PRELOADED_PLURID_METASTATE__;
+    this.pluridMetastate = pluridMetastate || DEFAULT_RENDERER_PLURID_STATE;
+    this.globals = globals ?? {};
+    this.minify = minify2 ?? true;
+  }
+  async html() {
+    const data = {
+      htmlLanguage: this.htmlLanguage,
+      head: this.head,
+      htmlAttributes: this.htmlAttributes,
+      bodyAttributes: this.bodyAttributes,
+      defaultStyle: this.defaultStyle,
+      styles: this.styles,
+      headScripts: this.headScripts,
+      bodyScripts: this.bodyScripts,
+      vendorScriptSource: this.vendorScriptSource,
+      mainScriptSource: this.mainScriptSource,
+      root: this.root,
+      content: this.content,
+      defaultPreloadedPluridMetastate: this.defaultPreloadedPluridMetastate,
+      pluridMetastate: this.pluridMetastate,
+      globals: this.globals,
+      minify: this.minify
+    };
+    return template_default(data);
+  }
+};
+var Renderer_default = PluridRenderer;
+
+// source/objects/ContentGenerator/index.tsx
+var import_react2 = __toESM(require("react"));
+var import_server = require("react-dom/server");
+var import_styled_components = require("styled-components");
+var import_react_helmet_async = require("react-helmet-async");
+var import_plurid_react = require("@plurid/plurid-react");
+
+// source/utilities/wrapping/index.tsx
+var import_react = __toESM(require("react"));
+var wrapping = (WrappedComponent, WrappeeComponent, properties) => {
+  return class extends import_react.default.Component {
     constructor(props) {
-        super(props);
+      super(props);
     }
     render() {
-        return React__default["default"].createElement(WrappedComponent, Object.assign({}, properties), React__default["default"].createElement(WrappeeComponent, null));
+      return /* @__PURE__ */ import_react.default.createElement(
+        WrappedComponent,
+        {
+          ...properties
+        },
+        /* @__PURE__ */ import_react.default.createElement(WrappeeComponent, null)
+      );
     }
+  };
 };
-
-class PluridContentGenerator {
-    constructor(data) {
-        this.data = data;
+var wrapping_default = wrapping;
+
+// source/objects/ContentGenerator/index.tsx
+var PluridContentGenerator = class {
+  data;
+  constructor(data) {
+    this.data = data;
+  }
+  async render() {
+    const {
+      pluridMetastate,
+      routes,
+      planes,
+      exterior,
+      shell,
+      routerProperties,
+      gateway,
+      gatewayEndpoint,
+      gatewayQuery,
+      helmet,
+      services,
+      stylesheet,
+      preserveResult,
+      matchedPlane,
+      pathname,
+      hostname
+    } = this.data;
+    const RoutedApplication = () => /* @__PURE__ */ import_react2.default.createElement(
+      import_plurid_react.PluridProvider,
+      {
+        metastate: pluridMetastate
+      },
+      /* @__PURE__ */ import_react2.default.createElement(
+        import_plurid_react.PluridRouterStatic,
+        {
+          path: pathname,
+          directPlane: matchedPlane?.value,
+          routes,
+          planes,
+          exterior,
+          shell,
+          gateway,
+          gatewayEndpoint,
+          gatewayQuery,
+          hostname,
+          routerProperties
+        }
+      )
+    );
+    let Wrap = wrapping_default(
+      import_react_helmet_async.HelmetProvider,
+      RoutedApplication,
+      {
+        context: helmet
+      }
+    );
+    for (const service of services) {
+      const preserveProperties = preserveResult?.providers?.[service.name];
+      Wrap = wrapping_default(
+        service.Provider,
+        Wrap,
+        {
+          ...service.properties,
+          ...preserveProperties
+        }
+      );
     }
-    render() {
-        var _a;
-        return __awaiter(this, void 0, void 0, (function*() {
-            const {pluridMetastate: pluridMetastate, routes: routes, planes: planes, exterior: exterior, shell: shell, gateway: gateway, gatewayEndpoint: gatewayEndpoint, gatewayQuery: gatewayQuery, helmet: helmet, services: services, stylesheet: stylesheet, preserveResult: preserveResult, matchedPlane: matchedPlane, pathname: pathname, hostname: hostname} = this.data;
-            const RoutedApplication = () => React__default["default"].createElement(pluridReact.PluridProvider, {
-                metastate: pluridMetastate
-            }, React__default["default"].createElement(pluridReact.PluridRouterStatic, {
-                path: pathname,
-                directPlane: matchedPlane === null || matchedPlane === void 0 ? void 0 : matchedPlane.value,
-                routes: routes,
-                planes: planes,
-                exterior: exterior,
-                shell: shell,
-                gateway: gateway,
-                gatewayEndpoint: gatewayEndpoint,
-                gatewayQuery: gatewayQuery,
-                hostname: hostname
-            }));
-            let Wrap = wrapping(reactHelmetAsync.HelmetProvider, RoutedApplication, {
-                context: helmet
-            });
-            for (const service of services) {
-                const preserveProperties = (_a = preserveResult === null || preserveResult === void 0 ? void 0 : preserveResult.providers) === null || _a === void 0 ? void 0 : _a[service.name];
-                Wrap = wrapping(service.Provider, Wrap, Object.assign(Object.assign({}, service.properties), preserveProperties));
-            }
-            const content = server.renderToString(React__default["default"].createElement(styledComponents.StyleSheetManager, {
-                sheet: stylesheet.instance
-            }, React__default["default"].createElement(Wrap, null)));
-            return content;
-        }));
+    const content = (0, import_server.renderToString)(
+      /* @__PURE__ */ import_react2.default.createElement(
+        import_styled_components.StyleSheetManager,
+        {
+          sheet: stylesheet.instance
+        },
+        /* @__PURE__ */ import_react2.default.createElement(Wrap, null)
+      )
+    );
+    return content;
+  }
+};
+var ContentGenerator_default = PluridContentGenerator;
+
+// source/objects/StillsManager/index.ts
+var import_path = __toESM(require("path"));
+var import_fs = require("fs");
+var StillsManager = class {
+  options;
+  stills = /* @__PURE__ */ new Map();
+  constructor(options) {
+    this.options = options;
+    this.findStills();
+  }
+  get(url) {
+    const still = this.stills.get(url);
+    if (!still) {
+      return;
     }
-}
-
-const resolveElementFromPlaneMatch = (planeMatch, elementqlEndpoint) => {
-    if (typeof planeMatch.data.component === "function") {
-        return;
+    return still.html;
+  }
+  async findStills() {
+    const {
+      buildDirectory,
+      stillsDirectory
+    } = this.options;
+    const stillsLocation = `${buildDirectory}/${stillsDirectory}`;
+    const stillsPath = import_path.default.join(process.cwd(), stillsLocation);
+    if (!(0, import_fs.existsSync)(stillsPath)) {
+      return;
     }
-    if (typeof planeMatch.data.component === "string") {
-        return {
-            name: planeMatch.data.component,
-            url: elementqlEndpoint
-        };
+    try {
+      const stillsMetadata = import_path.default.join(stillsPath, "metadata.json");
+      const stillsMetadataFile = await import_fs.promises.readFile(stillsMetadata, "utf-8");
+      const stillsMetadataJSON = JSON.parse(stillsMetadataFile);
+      if (!Array.isArray(stillsMetadataJSON)) {
+        return;
+      }
+      for (const still of stillsMetadataJSON) {
+        const stillFilePath = import_path.default.join(stillsPath, still.name);
+        const stillFileData = await import_fs.promises.readFile(stillFilePath, "utf-8");
+        const stillFileJSON = JSON.parse(stillFileData);
+        if (!stillFileJSON) {
+          continue;
+        }
+        this.stills.set(stillFileJSON.route, stillFileJSON);
+      }
+    } catch (error) {
+      if (this.options.debug !== "none" && !this.options.quiet) {
+        const errorText = "Plurid Server Error: Could not read stills.";
+        if (this.options.debug === "error") {
+          console.error(errorText, error);
+        } else {
+          console.log(errorText);
+        }
+      }
+      return;
     }
+  }
+};
+var StillsManager_default = StillsManager;
+
+// source/utilities/pttp/index.ts
+var resolveElementFromPlaneMatch = (planeMatch, elementqlEndpoint) => {
+  if (typeof planeMatch.data.component === "function") {
+    return;
+  }
+  if (typeof planeMatch.data.component === "string") {
     return {
-        name: planeMatch.data.component.name,
-        url: planeMatch.data.component.url || elementqlEndpoint
+      name: planeMatch.data.component,
+      url: elementqlEndpoint
     };
+  }
+  return {
+    name: planeMatch.data.component.name,
+    url: planeMatch.data.component.url || elementqlEndpoint
+  };
 };
 
-const {IsoMatcher: PluridIsoMatcher} = pluridEngine.routing;
-
-class PluridServer {
-    constructor(configuration) {
-        const {routes: routes, planes: planes, preserves: preserves, helmet: helmet, styles: styles, middleware: middleware, exterior: exterior, shell: shell, services: services, options: options, template: template, usePTTP: usePTTP, pttpHandler: pttpHandler, elementqlEndpoint: elementqlEndpoint} = configuration;
-        this.routes = routes;
-        this.planes = planes || [];
-        this.preserves = preserves;
-        this.helmet = helmet;
-        this.styles = styles || [];
-        this.middleware = middleware || [];
-        this.exterior = exterior;
-        this.shell = shell;
-        this.services = services || [];
-        this.options = this.handleOptions(options);
-        this.template = template;
-        this.usePTTP = usePTTP !== null && usePTTP !== void 0 ? usePTTP : false;
-        this.pttpHandler = pttpHandler;
-        this.elementqlEndpoint = elementqlEndpoint;
-        this.serverApplication = express__default["default"]();
-        this.port = DEFAULT_SERVER_PORT;
-        this.isoMatcher = new PluridIsoMatcher({
-            routes: this.routes,
-            routePlanes: this.planes
-        }, this.options.hostname);
-        this.configureServer();
-        this.handleEndpoints();
-        process.addListener("SIGINT", (() => {
-            this.stop();
-            process.exit(0);
-        }));
-    }
-    static analysis(pluridServer) {
-        return {
-            routes: pluridServer.routes,
-            options: pluridServer.options
-        };
+// source/objects/Server/index.ts
+var {
+  IsoMatcher: PluridIsoMatcher
+} = import_plurid_engine.routing;
+var PluridServer = class {
+  routes;
+  planes;
+  preserves;
+  helmet;
+  styles;
+  middleware;
+  exterior;
+  shell;
+  routerProperties;
+  services;
+  options;
+  template;
+  usePTTP;
+  pttpHandler;
+  elementqlEndpoint;
+  serverApplication;
+  server;
+  port;
+  stills;
+  isoMatcher;
+  constructor(configuration) {
+    const {
+      routes,
+      planes,
+      preserves,
+      helmet,
+      styles,
+      middleware,
+      exterior,
+      shell,
+      routerProperties,
+      services,
+      options,
+      template: template2,
+      usePTTP,
+      pttpHandler,
+      elementqlEndpoint
+    } = configuration;
+    this.routes = routes;
+    this.planes = planes || [];
+    this.preserves = preserves;
+    this.helmet = helmet;
+    this.styles = styles || [];
+    this.middleware = middleware || [];
+    this.exterior = exterior;
+    this.shell = shell;
+    this.routerProperties = routerProperties || {};
+    this.services = services || [];
+    this.options = this.handleOptions(options);
+    this.template = template2;
+    this.usePTTP = usePTTP ?? false;
+    this.pttpHandler = pttpHandler;
+    this.elementqlEndpoint = elementqlEndpoint;
+    this.serverApplication = (0, import_express.default)();
+    this.port = DEFAULT_SERVER_PORT;
+    this.stills = new StillsManager_default(this.options);
+    this.isoMatcher = new PluridIsoMatcher(
+      {
+        routes: this.routes,
+        routePlanes: this.planes
+      },
+      this.options.hostname
+    );
+    this.configureServer();
+    this.handleEndpoints();
+    if (this.options.attachSignalHandlers) {
+      this.attachSignalHandlers();
     }
-    start(port = this.port) {
-        this.port = port;
-        const serverlink = `http://localhost:${port}`;
-        if (this.debugAllows("info")) {
-            console.info(`\n\t[${pluridFunctions.time.stamp()}] ${this.options.serverName} Started on Port ${port}: ${serverlink}\n`);
-        }
-        this.server = this.serverApplication.listen(port);
-        this.open(serverlink);
-        return this.server;
+  }
+  handleProcessSignal = () => {
+    this.stop();
+    process.exit(0);
+  };
+  signalHandlersAttached = false;
+  attachSignalHandlers() {
+    if (this.signalHandlersAttached) {
+      return;
     }
-    stop() {
-        if (this.server) {
-            if (this.debugAllows("info")) {
-                console.info(`\n\t[${pluridFunctions.time.stamp()}] ${this.options.serverName} Stopped on Port ${this.port}\n`);
-            }
-            this.server.close();
-        } else {
-            if (this.debugAllows("info")) {
-                console.info(`\n\t[${pluridFunctions.time.stamp()}] ${this.options.serverName} Could not be Stopped on Port ${this.port}\n`);
-            }
-        }
+    process.on("SIGINT", this.handleProcessSignal);
+    process.on("SIGTERM", this.handleProcessSignal);
+    this.signalHandlersAttached = true;
+  }
+  detachSignalHandlers() {
+    process.removeListener("SIGINT", this.handleProcessSignal);
+    process.removeListener("SIGTERM", this.handleProcessSignal);
+    this.signalHandlersAttached = false;
+  }
+  static analysis(pluridServer) {
+    return {
+      routes: pluridServer.routes,
+      options: pluridServer.options
+    };
+  }
+  start(port = this.port) {
+    this.port = port;
+    const serverlink = `http://localhost:${port}`;
+    if (this.debugAllows("info")) {
+      console.info(
+        `
+	[${import_plurid_functions.time.stamp()}] ${this.options.serverName} Started on Port ${port}: ${serverlink}
+`
+      );
     }
-    handle() {
-        return {
-            post: (path, ...handlers) => {
-                this.serverApplication.post(path, ...handlers);
-                return this.serverApplication;
-            },
-            patch: (path, ...handlers) => {
-                this.serverApplication.patch(path, ...handlers);
-                return this.serverApplication;
-            },
-            put: (path, ...handlers) => {
-                this.serverApplication.put(path, ...handlers);
-                return this.serverApplication;
-            },
-            delete: (path, ...handlers) => {
-                this.serverApplication.delete(path, ...handlers);
-                return this.serverApplication;
-            }
-        };
+    this.server = this.serverApplication.listen(port);
+    this.open(serverlink);
+    return this.server;
+  }
+  stop() {
+    this.detachSignalHandlers();
+    if (this.server) {
+      if (this.debugAllows("info")) {
+        console.info(
+          `
+	[${import_plurid_functions.time.stamp()}] ${this.options.serverName} Stopped on Port ${this.port}
+`
+        );
+      }
+      this.server.close();
+    } else {
+      if (this.debugAllows("info")) {
+        console.info(
+          `
+	[${import_plurid_functions.time.stamp()}] ${this.options.serverName} Could not be Stopped on Port ${this.port}
+`
+        );
+      }
     }
-    instance() {
+  }
+  handle() {
+    return {
+      post: (path4, ...handlers) => {
+        this.serverApplication.post(path4, ...handlers);
         return this.serverApplication;
-    }
-    handleEndpoints() {
-        this.serverApplication.get(CATCH_ALL_ROUTE, ((request, response, next) => __awaiter(this, void 0, void 0, (function*() {
-            this.handleGetRequest(request, response, next);
-        }))));
-        if (this.usePTTP) {
-            this.serverApplication.post(PTTP_ROUTE, bodyParser.json(), ((request, response, next) => __awaiter(this, void 0, void 0, (function*() {
-                this.handlePTTPRequest(request, response);
-            }))));
+      },
+      patch: (path4, ...handlers) => {
+        this.serverApplication.patch(path4, ...handlers);
+        return this.serverApplication;
+      },
+      put: (path4, ...handlers) => {
+        this.serverApplication.put(path4, ...handlers);
+        return this.serverApplication;
+      },
+      delete: (path4, ...handlers) => {
+        this.serverApplication.delete(path4, ...handlers);
+        return this.serverApplication;
+      }
+    };
+  }
+  instance() {
+    return this.serverApplication;
+  }
+  handleEndpoints() {
+    this.serverApplication.get(
+      CATCH_ALL_ROUTE_PATTERN,
+      async (request, response, next) => {
+        this.handleGetRequest(
+          request,
+          response,
+          next
+        );
+      }
+    );
+    if (this.usePTTP) {
+      this.serverApplication.post(
+        PTTP_ROUTE,
+        import_express.default.json(),
+        // body parsing is built into Express 5
+        async (request, response, next) => {
+          this.handlePTTPRequest(
+            request,
+            response
+          );
         }
+      );
     }
-    handleGetRequest(request, response, next) {
-        return __awaiter(this, void 0, void 0, (function*() {
-            const requestID = request.requestID || pluridFunctions.uuid.generate();
-            try {
-                if (this.debugAllows("info")) {
-                    console.info(`[${pluridFunctions.time.stamp()} :: ${requestID}] (000 Start) Handling GET ${request.path}`);
-                }
-                const ignorable = this.ignoreGetRequest(request.path);
-                if (ignorable) {
-                    if (this.debugAllows("info")) {
-                        const requestTime = this.computeRequestTime(request);
-                        console.info(`[${pluridFunctions.time.stamp()} :: ${requestID}] (204 No Content) Ignored GET ${request.path}${requestTime}`);
-                    }
-                    next();
-                    return;
-                }
-                const {preserveResponded: preserveResponded, preserveResult: preserveResult, preserveAfterServe: preserveAfterServe} = yield this.resolvePreserve(request, response);
-                if (preserveResponded) {
-                    if (this.debugAllows("info")) {
-                        const requestTime = this.computeRequestTime(request);
-                        console.info(`[${pluridFunctions.time.stamp()} :: ${requestID}] (204 No Content) Preserve handled GET ${request.path}${requestTime}`);
-                    }
-                    return;
-                }
-                const {externalRedirect: externalRedirect, matchingPath: matchingPath} = this.resolveMatchingPath(preserveResult, request.originalUrl);
-                if (externalRedirect) {
-                    if (this.debugAllows("info")) {
-                        const requestTime = this.computeRequestTime(request);
-                        console.info(`[${pluridFunctions.time.stamp()} :: ${requestID}] (302 Redirect) Handled GET ${request.path} redirect to ${matchingPath}${requestTime}`);
-                    }
-                    response.status(302).redirect(matchingPath);
-                    this.resolvePreserveAfterServe(preserveAfterServe, request, response);
-                    return;
-                }
-                const isoMatch = this.isoMatcher.match(matchingPath, "route");
-                if (!isoMatch) {
-                    const isoMatchNotFound = this.isoMatcher.match(NOT_FOUND_ROUTE, "route");
-                    if (!isoMatchNotFound) {
-                        if (this.debugAllows("info")) {
-                            const requestTime = this.computeRequestTime(request);
-                            console.info(`[${pluridFunctions.time.stamp()} :: ${requestID}] (404 Not Found) Handled GET ${matchingPath}${requestTime}`);
-                        }
-                        response.status(404).send(NOT_FOUND_TEMPLATE);
-                        this.resolvePreserveAfterServe(preserveAfterServe, request, response);
-                        return;
-                    }
-                    const renderer = yield this.renderApplication(isoMatchNotFound, preserveResult);
-                    if (this.debugAllows("info")) {
-                        const requestTime = this.computeRequestTime(request);
-                        console.info(`[${pluridFunctions.time.stamp()} :: ${requestID}] (404 Not Found) Handled GET ${matchingPath}${requestTime}`);
-                    }
-                    response.status(404).send(renderer.html());
-                    this.resolvePreserveAfterServe(preserveAfterServe, request, response);
-                    response.status(404).end();
-                    return;
-                }
-                const renderer = yield this.renderApplication(isoMatch, preserveResult);
-                if (this.debugAllows("info")) {
-                    const requestTime = this.computeRequestTime(request);
-                    console.info(`[${pluridFunctions.time.stamp()} :: ${requestID}] (200 OK) Handled GET ${matchingPath}${requestTime}`);
-                }
-                response.send(renderer.html());
-                this.resolvePreserveAfterServe(preserveAfterServe, request, response);
-                return;
-            } catch (error) {
-                if (this.debugAllows("error")) {
-                    const requestTime = this.computeRequestTime(request);
-                    console.error(`[${pluridFunctions.time.stamp()} :: ${requestID}] (500 Server Error) Could not handle GET ${request.path}${requestTime}`, error);
-                }
-                response.status(500).send(SERVER_ERROR_TEMPLATE);
-                return;
-            }
-        }));
+  }
+  async handleGetRequest(request, response, next) {
+    const requestID = request.requestID || import_plurid_functions.uuid.generate();
+    try {
+      if (this.debugAllows("info")) {
+        console.info(
+          `[${import_plurid_functions.time.stamp()} :: ${requestID}] (000 Start) Handling GET ${request.path}`
+        );
+      }
+      const ignorable = this.ignoreGetRequest(
+        request.path
+      );
+      if (ignorable) {
+        if (this.debugAllows("info")) {
+          const requestTime = this.computeRequestTime(request);
+          console.info(
+            `[${import_plurid_functions.time.stamp()} :: ${requestID}] (204 No Content) Ignored GET ${request.path}${requestTime}`
+          );
+        }
+        next();
+        return;
+      }
+      const {
+        preserveResponded,
+        preserveResult,
+        preserveAfterServe
+      } = await this.resolvePreserve(
+        request,
+        response
+      );
+      if (preserveResponded) {
+        if (this.debugAllows("info")) {
+          const requestTime = this.computeRequestTime(request);
+          console.info(
+            `[${import_plurid_functions.time.stamp()} :: ${requestID}] (204 No Content) Preserve handled GET ${request.path}${requestTime}`
+          );
+        }
+        return;
+      }
+      const {
+        externalRedirect,
+        matchingPath
+      } = this.resolveMatchingPath(
+        preserveResult,
+        request.originalUrl
+      );
+      if (externalRedirect) {
+        if (this.debugAllows("info")) {
+          const requestTime = this.computeRequestTime(request);
+          console.info(
+            `[${import_plurid_functions.time.stamp()} :: ${requestID}] (302 Redirect) Handled GET ${request.path} redirect to ${matchingPath}${requestTime}`
+          );
+        }
+        response.status(302).redirect(matchingPath);
+        this.resolvePreserveAfterServe(
+          preserveAfterServe,
+          request,
+          response
+        );
+        return;
+      }
+      const still = this.stills.get(matchingPath);
+      if (still) {
+        if (this.debugAllows("info")) {
+          const requestTime = this.computeRequestTime(request);
+          console.info(
+            `[${import_plurid_functions.time.stamp()} :: ${requestID}] (200 OK) Still Handled GET ${matchingPath}${requestTime}`
+          );
+        }
+        response.send(still);
+        this.resolvePreserveAfterServe(
+          preserveAfterServe,
+          request,
+          response
+        );
+        return;
+      }
+      const isoMatch = this.isoMatcher.match(
+        matchingPath,
+        "route"
+      );
+      if (!isoMatch) {
+        const notFoundStill = this.stills.get(NOT_FOUND_ROUTE);
+        if (notFoundStill) {
+          if (this.debugAllows("info")) {
+            const requestTime = this.computeRequestTime(request);
+            console.info(
+              `[${import_plurid_functions.time.stamp()} :: ${requestID}] (404 Not Found) Handled GET ${matchingPath}${requestTime}`
+            );
+          }
+          response.status(404).send(notFoundStill);
+          this.resolvePreserveAfterServe(
+            preserveAfterServe,
+            request,
+            response
+          );
+          return;
+        }
+        const isoMatchNotFound = this.isoMatcher.match(
+          NOT_FOUND_ROUTE,
+          "route"
+        );
+        if (!isoMatchNotFound) {
+          if (this.debugAllows("info")) {
+            const requestTime = this.computeRequestTime(request);
+            console.info(
+              `[${import_plurid_functions.time.stamp()} :: ${requestID}] (404 Not Found) Handled GET ${matchingPath}${requestTime}`
+            );
+          }
+          response.status(404).send(NOT_FOUND_TEMPLATE);
+          this.resolvePreserveAfterServe(
+            preserveAfterServe,
+            request,
+            response
+          );
+          return;
+        }
+        const renderer2 = await this.renderApplication(
+          isoMatchNotFound,
+          preserveResult
+        );
+        if (this.debugAllows("info")) {
+          const requestTime = this.computeRequestTime(request);
+          console.info(
+            `[${import_plurid_functions.time.stamp()} :: ${requestID}] (404 Not Found) Handled GET ${matchingPath}${requestTime}`
+          );
+        }
+        response.status(404).send(await renderer2.html());
+        this.resolvePreserveAfterServe(
+          preserveAfterServe,
+          request,
+          response
+        );
+        response.status(404).end();
+        return;
+      }
+      const renderer = await this.renderApplication(
+        isoMatch,
+        preserveResult
+      );
+      if (this.debugAllows("info")) {
+        const requestTime = this.computeRequestTime(request);
+        console.info(
+          `[${import_plurid_functions.time.stamp()} :: ${requestID}] (200 OK) Handled GET ${matchingPath}${requestTime}`
+        );
+      }
+      response.send(await renderer.html());
+      this.resolvePreserveAfterServe(
+        preserveAfterServe,
+        request,
+        response
+      );
+      return;
+    } catch (error) {
+      if (this.debugAllows("error")) {
+        const requestTime = this.computeRequestTime(request);
+        console.error(
+          `[${import_plurid_functions.time.stamp()} :: ${requestID}] (500 Server Error) Could not handle GET ${request.path}${requestTime}`,
+          error
+        );
+      }
+      response.status(500).send(SERVER_ERROR_TEMPLATE);
+      return;
     }
-    handlePTTPRequest(request, response) {
-        return __awaiter(this, void 0, void 0, (function*() {
-            const requestID = request.requestID || pluridFunctions.uuid.generate();
-            try {
-                if (this.debugAllows("info")) {
-                    console.info(`[${pluridFunctions.time.stamp()} :: ${requestID}] (000 Start) Handling POST ${request.path}`);
-                }
-                response.setHeader("Access-Control-Allow-Origin", request.headers.origin || "");
-                response.setHeader("Access-Control-Allow-Credentials", "true");
-                const data = request.body;
-                if (!data && !data.path) {
-                    if (this.debugAllows("warn")) {
-                        const requestTime = this.computeRequestTime(request);
-                        console.info(`[${pluridFunctions.time.stamp()} :: ${requestID}] (400 Bad Request) Could not handle POST ${request.path}${requestTime}`);
-                    }
-                    response.status(400).end();
-                    return;
-                }
-                if (this.pttpHandler) {
-                    const pttpHandled = yield this.pttpHandler(data.path);
-                    if (pttpHandled) {
-                        if (this.debugAllows("info")) {
-                            const requestTime = this.computeRequestTime(request);
-                            console.info(`[${pluridFunctions.time.stamp()} :: ${requestID}] (200 OK) Handled POST ${request.path}${requestTime} in custom handler`);
-                        }
-                        return;
-                    }
-                }
-                const planeMatch = this.isoMatcher.match(data.path);
-                if (!planeMatch) {
-                    if (this.debugAllows("warn")) {
-                        const requestTime = this.computeRequestTime(request);
-                        console.info(`[${pluridFunctions.time.stamp()} :: ${requestID}] (400 Bad Request) Could not handle POST ${request.path}${requestTime}`);
-                    }
-                    response.status(400).end();
-                    return;
-                }
-                const elementMatch = resolveElementFromPlaneMatch(planeMatch, this.elementqlEndpoint);
-                if (!elementMatch) {
-                    if (this.debugAllows("warn")) {
-                        const requestTime = this.computeRequestTime(request);
-                        console.info(`[${pluridFunctions.time.stamp()} :: ${requestID}] (404 Not Found) Could not handle POST ${request.path}${requestTime}`);
-                    }
-                    response.status(404).end();
-                    return;
-                }
-                const elementURL = elementMatch.url;
-                if (!elementURL) {
-                    if (this.debugAllows("warn")) {
-                        const requestTime = this.computeRequestTime(request);
-                        console.info(`[${pluridFunctions.time.stamp()} :: ${requestID}] (400 Bad Request) Could not handle POST ${request.path}${requestTime}`);
-                    }
-                    response.status(400).end();
-                    return;
-                }
-                if (this.debugAllows("info")) {
-                    const requestTime = this.computeRequestTime(request);
-                    console.info(`[${pluridFunctions.time.stamp()} :: ${requestID}] (200 OK) Handled POST ${request.path}${requestTime}`);
-                }
-                const elementName = elementMatch.name;
-                const linksTo = [];
-                const element = {
-                    url: elementURL,
-                    name: elementName,
-                    json: {
-                        elements: [ {
-                            name: elementName
-                        } ]
-                    },
-                    linksTo: linksTo
-                };
-                response.json({
-                    element: element
-                });
-            } catch (error) {
-                if (this.debugAllows("error")) {
-                    const requestTime = this.computeRequestTime(request);
-                    console.error(`[${pluridFunctions.time.stamp()} :: ${requestID}] (500 Server Error) Could not handle POST ${request.path}${requestTime}`, error);
-                }
-                response.status(500).send(SERVER_ERROR_TEMPLATE);
-                return;
+  }
+  async handlePTTPRequest(request, response) {
+    const requestID = request.requestID || import_plurid_functions.uuid.generate();
+    try {
+      if (this.debugAllows("info")) {
+        console.info(
+          `[${import_plurid_functions.time.stamp()} :: ${requestID}] (000 Start) Handling POST ${request.path}`
+        );
+      }
+      response.setHeader("Access-Control-Allow-Origin", request.headers.origin || "");
+      response.setHeader("Access-Control-Allow-Credentials", "true");
+      const data = request.body;
+      if (!data || !data.path) {
+        if (this.debugAllows("warn")) {
+          const requestTime = this.computeRequestTime(request);
+          console.info(
+            `[${import_plurid_functions.time.stamp()} :: ${requestID}] (400 Bad Request) Could not handle POST ${request.path}${requestTime}`
+          );
+        }
+        response.status(400).end();
+        return;
+      }
+      if (this.pttpHandler) {
+        const pttpHandled = await this.pttpHandler(
+          data.path
+        );
+        if (pttpHandled) {
+          if (this.debugAllows("info")) {
+            const requestTime = this.computeRequestTime(request);
+            console.info(
+              `[${import_plurid_functions.time.stamp()} :: ${requestID}] (200 OK) Handled POST ${request.path}${requestTime} in custom handler`
+            );
+          }
+          return;
+        }
+      }
+      const planeMatch = this.isoMatcher.match(
+        data.path
+      );
+      if (!planeMatch) {
+        if (this.debugAllows("warn")) {
+          const requestTime = this.computeRequestTime(request);
+          console.info(
+            `[${import_plurid_functions.time.stamp()} :: ${requestID}] (400 Bad Request) Could not handle POST ${request.path}${requestTime}`
+          );
+        }
+        response.status(400).end();
+        return;
+      }
+      const elementMatch = resolveElementFromPlaneMatch(
+        planeMatch,
+        this.elementqlEndpoint
+      );
+      if (!elementMatch) {
+        if (this.debugAllows("warn")) {
+          const requestTime = this.computeRequestTime(request);
+          console.info(
+            `[${import_plurid_functions.time.stamp()} :: ${requestID}] (404 Not Found) Could not handle POST ${request.path}${requestTime}`
+          );
+        }
+        response.status(404).end();
+        return;
+      }
+      const elementURL = elementMatch.url;
+      if (!elementURL) {
+        if (this.debugAllows("warn")) {
+          const requestTime = this.computeRequestTime(request);
+          console.info(
+            `[${import_plurid_functions.time.stamp()} :: ${requestID}] (400 Bad Request) Could not handle POST ${request.path}${requestTime}`
+          );
+        }
+        response.status(400).end();
+        return;
+      }
+      if (this.debugAllows("info")) {
+        const requestTime = this.computeRequestTime(request);
+        console.info(
+          `[${import_plurid_functions.time.stamp()} :: ${requestID}] (200 OK) Handled POST ${request.path}${requestTime}`
+        );
+      }
+      const elementName = elementMatch.name;
+      const linksTo = [];
+      const element = {
+        url: elementURL,
+        name: elementName,
+        json: {
+          elements: [
+            {
+              name: elementName
             }
-        }));
+          ]
+        },
+        linksTo
+      };
+      response.json({
+        element
+      });
+    } catch (error) {
+      if (this.debugAllows("error")) {
+        const requestTime = this.computeRequestTime(request);
+        console.error(
+          `[${import_plurid_functions.time.stamp()} :: ${requestID}] (500 Server Error) Could not handle POST ${request.path}${requestTime}`,
+          error
+        );
+      }
+      response.status(500).send(SERVER_ERROR_TEMPLATE);
+      return;
     }
-    ignoreGetRequest(path) {
-        for (const ignore of this.options.ignore) {
-            const normalizedIgnore = ignore.endsWith("/") && ignore.length > 1 ? ignore.slice(0, ignore.length - 1) : ignore;
-            if (path === normalizedIgnore) {
-                return true;
-            }
-            if (normalizedIgnore.endsWith("/*")) {
-                const curatedIgnore = normalizedIgnore.replace("/*", "");
-                if (path.startsWith(curatedIgnore)) {
-                    return true;
-                }
-            }
+  }
+  ignoreGetRequest(path4) {
+    for (const ignore of this.options.ignore) {
+      const normalizedIgnore = ignore.endsWith("/") && ignore.length > 1 ? ignore.slice(0, ignore.length - 1) : ignore;
+      if (path4 === normalizedIgnore) {
+        return true;
+      }
+      if (normalizedIgnore.endsWith("/*")) {
+        const curatedIgnore = normalizedIgnore.replace("/*", "");
+        if (path4.startsWith(curatedIgnore)) {
+          return true;
         }
-        return false;
+      }
     }
-    resolveMatchingPath(preserveResult, path) {
-        const redirect = preserveResult ? preserveResult.redirect : "";
-        const externalRedirect = !!(redirect === null || redirect === void 0 ? void 0 : redirect.startsWith("http"));
-        const matchingPath = redirect || path;
-        return {
-            externalRedirect: externalRedirect,
-            matchingPath: matchingPath
-        };
+    return false;
+  }
+  resolveMatchingPath(preserveResult, path4) {
+    const redirect = preserveResult ? preserveResult.redirect : "";
+    const externalRedirect = !!redirect?.startsWith("http");
+    const matchingPath = redirect || path4;
+    return {
+      externalRedirect,
+      matchingPath
+    };
+  }
+  async resolvePreserve(request, response) {
+    const catchAll = this.preserves.find(
+      (preserve) => preserve.serve === CATCH_ALL_ROUTE
+    );
+    const notFound = this.preserves.find(
+      (preserve) => preserve.serve === NOT_FOUND_ROUTE
+    );
+    const isoMatch = this.isoMatcher.match(
+      request.originalUrl,
+      "route"
+    );
+    let preserveOnServe;
+    let preserveAfterServe;
+    let preserveOnError;
+    if (isoMatch || catchAll || notFound) {
+      const preserve = catchAll ? catchAll : notFound && !isoMatch ? notFound : this.preserves.find(
+        (preserve2) => preserve2.serve === isoMatch?.data.value
+      );
+      if (preserve) {
+        preserveOnServe = preserve.onServe;
+        preserveAfterServe = preserve.afterServe;
+        preserveOnError = preserve.onError;
+      }
     }
-    resolvePreserve(request, response) {
-        return __awaiter(this, void 0, void 0, (function*() {
-            const catchAll = this.preserves.find((preserve => preserve.serve === CATCH_ALL_ROUTE));
-            const notFound = this.preserves.find((preserve => preserve.serve === NOT_FOUND_ROUTE));
-            const isoMatch = this.isoMatcher.match(request.originalUrl, "route");
-            let preserveOnServe;
-            let preserveAfterServe;
-            let preserveOnError;
-            if (isoMatch || catchAll || notFound) {
-                const preserve = catchAll ? catchAll : notFound && !isoMatch ? notFound : this.preserves.find((preserve => preserve.serve === (isoMatch === null || isoMatch === void 0 ? void 0 : isoMatch.data.value)));
-                if (preserve) {
-                    preserveOnServe = preserve.onServe;
-                    preserveAfterServe = preserve.afterServe;
-                    preserveOnError = preserve.onError;
-                }
-            }
-            let preserveResult;
-            if (preserveOnServe) {
-                const transmission = {
-                    context: {
-                        route: request.originalUrl,
-                        match: isoMatch
-                    },
-                    request: request,
-                    response: response
-                };
-                try {
-                    preserveResult = yield preserveOnServe(transmission);
-                    if (preserveResult) {
-                        if (preserveResult.responded) {
-                            return {
-                                preserveResponded: true,
-                                preserveResult: preserveResult,
-                                preserveAfterServe: preserveAfterServe
-                            };
-                        }
-                    }
-                } catch (error) {
-                    if (preserveOnError) {
-                        const onErrorResponse = yield preserveOnError(error, transmission);
-                        if (onErrorResponse) {
-                            if (onErrorResponse.responded) {
-                                return {
-                                    preserveResponded: true,
-                                    preserveResult: preserveResult,
-                                    preserveAfterServe: preserveAfterServe
-                                };
-                            }
-                            if (!onErrorResponse.depreserve) {
-                                return {
-                                    preserveResponded: false,
-                                    preserveResult: preserveResult,
-                                    preserveAfterServe: preserveAfterServe
-                                };
-                            }
-                        }
-                    }
-                }
-            }
+    let preserveResult;
+    if (preserveOnServe) {
+      const transmission = {
+        context: {
+          route: request.originalUrl,
+          match: isoMatch
+        },
+        request,
+        response
+      };
+      try {
+        preserveResult = await preserveOnServe(transmission);
+        if (preserveResult) {
+          if (preserveResult.responded) {
             return {
-                preserveResponded: false,
-                preserveResult: preserveResult,
-                preserveAfterServe: preserveAfterServe
+              preserveResponded: true,
+              preserveResult,
+              preserveAfterServe
             };
-        }));
-    }
-    resolvePreserveAfterServe(preserveAfterServe, request, response) {
-        return __awaiter(this, void 0, void 0, (function*() {
-            if (preserveAfterServe) {
-                const isoMatch = this.isoMatcher.match(request.originalUrl, "route");
-                const transmission = {
-                    context: {
-                        route: request.originalUrl,
-                        match: isoMatch
-                    },
-                    request: request,
-                    response: response
-                };
-                yield preserveAfterServe(transmission);
+          }
+        }
+      } catch (error) {
+        if (preserveOnError) {
+          const onErrorResponse = await preserveOnError(
+            error,
+            transmission
+          );
+          if (onErrorResponse) {
+            if (onErrorResponse.responded) {
+              return {
+                preserveResponded: true,
+                preserveResult,
+                preserveAfterServe
+              };
             }
-        }));
-    }
-    handleGateway(path, request, preserveResult) {
-        return __awaiter(this, void 0, void 0, (function*() {
-            const {gatewayEndpoint: gatewayEndpoint} = this.options;
-            if (path !== gatewayEndpoint) {
-                return;
+            if (!onErrorResponse.depreserve) {
+              return {
+                preserveResponded: false,
+                preserveResult,
+                preserveAfterServe
+              };
             }
-            ({
-                path: {
-                    value: gatewayEndpoint
-                },
-                pathname: gatewayEndpoint,
-                parameters: {},
-                query: {
-                    __gatewayQuery: request.originalUrl
-                },
-                fragments: {
-                    texts: [],
-                    elements: []
-                },
-                route: gatewayEndpoint
-            });
-            return "";
-        }));
+          }
+        }
+      }
     }
-    renderApplication(isoMatch, preserveResult, matchedPlane) {
-        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s;
-        return __awaiter(this, void 0, void 0, (function*() {
-            const globals = preserveResult === null || preserveResult === void 0 ? void 0 : preserveResult.globals;
-            const mergedHtmlLanguage = ((_a = preserveResult === null || preserveResult === void 0 ? void 0 : preserveResult.template) === null || _a === void 0 ? void 0 : _a.htmlLanguage) || ((_b = this.template) === null || _b === void 0 ? void 0 : _b.htmlLanguage);
-            const pluridMetastate = yield pluridReact.serverComputeMetastate(isoMatch, this.routes, globals, this.options.hostname);
-            const {content: content, styles: styles} = yield this.getContentAndStyles(isoMatch, pluridMetastate, preserveResult, matchedPlane);
-            const stringedStyles = this.styles.reduce(((accumulator, style) => accumulator + style), "");
-            const preserveStyles = ((_d = (_c = preserveResult === null || preserveResult === void 0 ? void 0 : preserveResult.template) === null || _c === void 0 ? void 0 : _c.styles) === null || _d === void 0 ? void 0 : _d.join(" ")) || "";
-            const mergedStyles = styles + stringedStyles + preserveStyles;
-            const {helmet: helmet} = this.helmet;
-            const head = helmet ? `\n            ${helmet.meta.toString()}\n            ${helmet.title.toString()}\n            ${helmet.base.toString()}\n            ${helmet.link.toString()}\n            ${helmet.style.toString()}\n            ${helmet.noscript.toString()}\n            ${helmet.script.toString()}\n        ` : "";
-            const htmlAttributes = Object.assign(Object.assign({}, (_e = this.template) === null || _e === void 0 ? void 0 : _e.htmlAttributes), helmet === null || helmet === void 0 ? void 0 : helmet.htmlAttributes.toComponent());
-            const mergedHtmlAttributes = recordToString(htmlAttributes) + (((_f = preserveResult === null || preserveResult === void 0 ? void 0 : preserveResult.template) === null || _f === void 0 ? void 0 : _f.htmlAttributes) || "");
-            const bodyAttributes = (helmet === null || helmet === void 0 ? void 0 : helmet.bodyAttributes.toString()) || "";
-            const preserveBodyAttributes = ((_g = preserveResult === null || preserveResult === void 0 ? void 0 : preserveResult.template) === null || _g === void 0 ? void 0 : _g.bodyAttributes) || "";
-            const mergedBodyAttributes = bodyAttributes + preserveBodyAttributes;
-            const headScripts = ((_h = this.template) === null || _h === void 0 ? void 0 : _h.headScripts) || [];
-            const mergedHeadScripts = [ ...headScripts, ...((_j = preserveResult === null || preserveResult === void 0 ? void 0 : preserveResult.template) === null || _j === void 0 ? void 0 : _j.headScripts) || [] ];
-            const bodyScripts = ((_k = this.template) === null || _k === void 0 ? void 0 : _k.bodyScripts) || [];
-            const mergedBodyScripts = [ ...bodyScripts, ...((_l = preserveResult === null || preserveResult === void 0 ? void 0 : preserveResult.template) === null || _l === void 0 ? void 0 : _l.bodyScripts) || [] ];
-            const renderer = new PluridRenderer({
-                htmlLanguage: mergedHtmlLanguage,
-                head: head,
-                htmlAttributes: mergedHtmlAttributes,
-                bodyAttributes: mergedBodyAttributes,
-                defaultStyle: (_m = this.template) === null || _m === void 0 ? void 0 : _m.defaultStyle,
-                styles: mergedStyles,
-                headScripts: mergedHeadScripts,
-                bodyScripts: mergedBodyScripts,
-                vendorScriptSource: (_o = this.template) === null || _o === void 0 ? void 0 : _o.vendorScriptSource,
-                mainScriptSource: (_p = this.template) === null || _p === void 0 ? void 0 : _p.mainScriptSource,
-                root: (_q = this.template) === null || _q === void 0 ? void 0 : _q.root,
-                content: content,
-                defaultPreloadedPluridMetastate: (_r = this.template) === null || _r === void 0 ? void 0 : _r.defaultPreloadedPluridMetastate,
-                pluridMetastate: JSON.stringify(pluridMetastate),
-                globals: globals,
-                minify: (_s = this.template) === null || _s === void 0 ? void 0 : _s.minify
-            });
-            return renderer;
-        }));
+    return {
+      preserveResponded: false,
+      preserveResult,
+      preserveAfterServe
+    };
+  }
+  async resolvePreserveAfterServe(preserveAfterServe, request, response) {
+    if (preserveAfterServe) {
+      const isoMatch = this.isoMatcher.match(
+        request.originalUrl,
+        "route"
+      );
+      const transmission = {
+        context: {
+          route: request.originalUrl,
+          match: isoMatch
+        },
+        request,
+        response
+      };
+      await preserveAfterServe(transmission);
     }
-    getContentAndStyles(isoMatch, pluridMetastate, preserveResult, matchedPlane) {
-        return __awaiter(this, void 0, void 0, (function*() {
-            const stylesheet = new styledComponents.ServerStyleSheet;
-            let content = "";
-            let styles = "";
-            try {
-                const gateway = false;
-                const gatewayQuery = "";
-                const {gatewayEndpoint: gatewayEndpoint} = this.options;
-                const contentHandler = new PluridContentGenerator({
-                    services: this.services,
-                    stylesheet: stylesheet,
-                    exterior: this.exterior,
-                    shell: this.shell,
-                    helmet: this.helmet,
-                    routes: this.routes,
-                    planes: this.planes,
-                    pluridMetastate: pluridMetastate,
-                    gateway: gateway,
-                    gatewayEndpoint: gatewayEndpoint,
-                    gatewayQuery: gatewayQuery,
-                    preserveResult: preserveResult,
-                    pathname: isoMatch.match.value,
-                    hostname: this.options.hostname,
-                    matchedPlane: isoMatch.kind === "RoutePlane" ? {
-                        value: isoMatch.match.value
-                    } : undefined
-                });
-                content = yield contentHandler.render();
-                styles = stylesheet.getStyleTags();
-            } catch (error) {
-                if (this.options.debug !== "none" && !this.options.quiet) {
-                    const errorText = `${this.options.serverName} Error: Something went wrong in getContentAndStyles().`;
-                    if (this.debugAllows("error")) {
-                        console.error(errorText, error);
-                    }
-                }
-                return {
-                    content: "",
-                    styles: ""
-                };
-            } finally {
-                stylesheet.seal();
-            }
-            return {
-                content: content,
-                styles: styles
-            };
-        }));
+  }
+  async handleGateway(path4, request, preserveResult) {
+    const {
+      gatewayEndpoint
+    } = this.options;
+    if (path4 !== gatewayEndpoint) {
+      return;
     }
-    computeRequestTime(request) {
-        const requestTime = request.requestTime;
-        if (!requestTime) {
-            return "";
+    const gatewayRoute = {
+      path: {
+        value: gatewayEndpoint
+      },
+      pathname: gatewayEndpoint,
+      parameters: {},
+      query: {
+        __gatewayQuery: request.originalUrl
+      },
+      fragments: {
+        texts: [],
+        elements: []
+      },
+      route: gatewayEndpoint
+    };
+    return "";
+  }
+  async renderApplication(isoMatch, preserveResult, matchedPlane) {
+    const globals = preserveResult?.globals;
+    const mergedHtmlLanguage = preserveResult?.template?.htmlLanguage || this.template?.htmlLanguage;
+    const pluridMetastate = await (0, import_plurid_react2.serverComputeMetastate)(
+      isoMatch,
+      this.routes,
+      globals,
+      this.options.hostname
+    );
+    const {
+      content,
+      styles
+    } = await this.getContentAndStyles(
+      isoMatch,
+      pluridMetastate,
+      preserveResult,
+      matchedPlane
+    );
+    const stringedStyles = this.styles.reduce(
+      (accumulator, style) => accumulator + style,
+      ""
+    );
+    const preserveStyles = preserveResult?.template?.styles?.join(" ") || "";
+    const mergedStyles = styles + stringedStyles + preserveStyles;
+    const {
+      helmet
+    } = this.helmet;
+    const head = helmet ? `
+            ${helmet.meta.toString()}
+            ${helmet.title.toString()}
+            ${helmet.base.toString()}
+            ${helmet.link.toString()}
+            ${helmet.style.toString()}
+            ${helmet.noscript.toString()}
+            ${helmet.script.toString()}
+        ` : "";
+    const htmlAttributes = {
+      ...this.template?.htmlAttributes,
+      ...helmet?.htmlAttributes.toComponent()
+    };
+    const mergedHtmlAttributes = recordToString(htmlAttributes) + (preserveResult?.template?.htmlAttributes || "");
+    const bodyAttributes = helmet?.bodyAttributes.toString() || "";
+    const preserveBodyAttributes = preserveResult?.template?.bodyAttributes || "";
+    const mergedBodyAttributes = bodyAttributes + preserveBodyAttributes;
+    const headScripts = this.template?.headScripts || [];
+    const mergedHeadScripts = [
+      ...headScripts,
+      ...preserveResult?.template?.headScripts || []
+    ];
+    const bodyScripts = this.template?.bodyScripts || [];
+    const mergedBodyScripts = [
+      ...bodyScripts,
+      ...preserveResult?.template?.bodyScripts || []
+    ];
+    const renderer = new Renderer_default({
+      htmlLanguage: mergedHtmlLanguage,
+      head,
+      htmlAttributes: mergedHtmlAttributes,
+      bodyAttributes: mergedBodyAttributes,
+      defaultStyle: this.template?.defaultStyle,
+      styles: mergedStyles,
+      headScripts: mergedHeadScripts,
+      bodyScripts: mergedBodyScripts,
+      vendorScriptSource: this.template?.vendorScriptSource,
+      mainScriptSource: this.template?.mainScriptSource,
+      root: this.template?.root,
+      content,
+      defaultPreloadedPluridMetastate: this.template?.defaultPreloadedPluridMetastate,
+      pluridMetastate: JSON.stringify(pluridMetastate),
+      globals,
+      minify: this.template?.minify
+    });
+    return renderer;
+  }
+  async getContentAndStyles(isoMatch, pluridMetastate, preserveResult, matchedPlane) {
+    const stylesheet = new import_styled_components2.ServerStyleSheet();
+    let content = "";
+    let styles = "";
+    try {
+      const gateway = false;
+      const gatewayQuery = "";
+      const {
+        gatewayEndpoint
+      } = this.options;
+      const contentHandler = new ContentGenerator_default({
+        services: this.services,
+        stylesheet,
+        exterior: this.exterior,
+        shell: this.shell,
+        routerProperties: this.routerProperties,
+        helmet: this.helmet,
+        routes: this.routes,
+        planes: this.planes,
+        pluridMetastate,
+        gateway,
+        gatewayEndpoint,
+        gatewayQuery,
+        preserveResult,
+        pathname: isoMatch.match.value,
+        hostname: this.options.hostname,
+        matchedPlane: isoMatch.kind === "RoutePlane" ? {
+          value: isoMatch.match.value
+        } : void 0
+      });
+      content = await contentHandler.render();
+      styles = stylesheet.getStyleTags();
+    } catch (error) {
+      if (this.options.debug !== "none" && !this.options.quiet) {
+        const errorText = `${this.options.serverName} Error: Something went wrong in getContentAndStyles().`;
+        if (this.debugAllows("error")) {
+          console.error(
+            errorText,
+            error
+          );
         }
-        const now = Date.now();
-        const difference = now - requestTime;
-        return ` in ${difference} ms`;
+      }
+      return {
+        content: "",
+        styles: ""
+      };
+    } finally {
+      stylesheet.seal();
     }
-    handleOptions(partialOptions) {
-        var _a, _b;
-        const options = {
-            serverName: (partialOptions === null || partialOptions === void 0 ? void 0 : partialOptions.serverName) || DEFAULT_SERVER_OPTIONS.SERVER_NAME,
-            hostname: (partialOptions === null || partialOptions === void 0 ? void 0 : partialOptions.hostname) || DEFAULT_SERVER_OPTIONS.HOSTNAME,
-            quiet: (partialOptions === null || partialOptions === void 0 ? void 0 : partialOptions.quiet) || DEFAULT_SERVER_OPTIONS.QUIET,
-            debug: (partialOptions === null || partialOptions === void 0 ? void 0 : partialOptions.debug) ? partialOptions === null || partialOptions === void 0 ? void 0 : partialOptions.debug : environment.production ? "error" : "info",
-            compression: (_a = partialOptions === null || partialOptions === void 0 ? void 0 : partialOptions.compression) !== null && _a !== void 0 ? _a : DEFAULT_SERVER_OPTIONS.COMPRESSION,
-            open: (_b = partialOptions === null || partialOptions === void 0 ? void 0 : partialOptions.open) !== null && _b !== void 0 ? _b : DEFAULT_SERVER_OPTIONS.OPEN,
-            buildDirectory: (partialOptions === null || partialOptions === void 0 ? void 0 : partialOptions.buildDirectory) || DEFAULT_SERVER_OPTIONS.BUILD_DIRECTORY,
-            assetsDirectory: (partialOptions === null || partialOptions === void 0 ? void 0 : partialOptions.assetsDirectory) || DEFAULT_SERVER_OPTIONS.ASSETS_DIRECTORY,
-            gatewayEndpoint: (partialOptions === null || partialOptions === void 0 ? void 0 : partialOptions.gatewayEndpoint) || DEFAULT_SERVER_OPTIONS.GATEWAY,
-            staticCache: (partialOptions === null || partialOptions === void 0 ? void 0 : partialOptions.staticCache) || 0,
-            ignore: (partialOptions === null || partialOptions === void 0 ? void 0 : partialOptions.ignore) || [],
-            stillsDirectory: (partialOptions === null || partialOptions === void 0 ? void 0 : partialOptions.stillsDirectory) || DEFAULT_SERVER_OPTIONS.STILLS_DIRECTORY,
-            stiller: (partialOptions === null || partialOptions === void 0 ? void 0 : partialOptions.stiller) || defaultStillerOptions
-        };
-        return options;
+    return {
+      content,
+      styles
+    };
+  }
+  computeRequestTime(request) {
+    const requestTime = request.requestTime;
+    if (!requestTime) {
+      return "";
     }
-    configureServer() {
-        const clientPath = path__default["default"].join(this.options.buildDirectory, "./client");
-        this.serverApplication.disable("x-powered-by");
-        this.serverApplication.use(((request, _, next) => {
-            const requestID = pluridFunctions.uuid.generate();
-            request.requestID = requestID;
-            const requestTime = Date.now();
-            request.requestTime = requestTime;
+    const now = Date.now();
+    const difference = now - requestTime;
+    return ` in ${difference} ms`;
+  }
+  handleOptions(partialOptions) {
+    const options = {
+      serverName: partialOptions?.serverName || DEFAULT_SERVER_OPTIONS.SERVER_NAME,
+      hostname: partialOptions?.hostname || DEFAULT_SERVER_OPTIONS.HOSTNAME,
+      quiet: partialOptions?.quiet || DEFAULT_SERVER_OPTIONS.QUIET,
+      debug: partialOptions?.debug ? partialOptions?.debug : environment.production ? "error" : "info",
+      compression: partialOptions?.compression ?? DEFAULT_SERVER_OPTIONS.COMPRESSION,
+      open: partialOptions?.open ?? DEFAULT_SERVER_OPTIONS.OPEN,
+      buildDirectory: partialOptions?.buildDirectory || DEFAULT_SERVER_OPTIONS.BUILD_DIRECTORY,
+      assetsDirectory: partialOptions?.assetsDirectory || DEFAULT_SERVER_OPTIONS.ASSETS_DIRECTORY,
+      gatewayEndpoint: partialOptions?.gatewayEndpoint || DEFAULT_SERVER_OPTIONS.GATEWAY,
+      staticCache: partialOptions?.staticCache || 0,
+      ignore: partialOptions?.ignore || [],
+      stillsDirectory: partialOptions?.stillsDirectory || DEFAULT_SERVER_OPTIONS.STILLS_DIRECTORY,
+      stiller: partialOptions?.stiller || defaultStillerOptions,
+      attachSignalHandlers: partialOptions?.attachSignalHandlers ?? true
+    };
+    return options;
+  }
+  configureServer() {
+    const clientPath = import_path2.default.join(this.options.buildDirectory, "./client");
+    this.serverApplication.disable("x-powered-by");
+    this.serverApplication.use(
+      (request, _, next) => {
+        const requestID = import_plurid_functions.uuid.generate();
+        request.requestID = requestID;
+        const requestTime = Date.now();
+        request.requestTime = requestTime;
+        next();
+      }
+    );
+    if (this.options.compression) {
+      this.serverApplication.use(
+        (0, import_compression.default)()
+        // @types/compression targets Express 4's handler type
+      );
+      this.serverApplication.get(
+        "/vendor.js",
+        (request, response, next) => {
+          response.setHeader(
+            "Content-Type",
+            "application/javascript"
+          );
+          const vendorBrotliExists = import_fs2.default.existsSync(
+            import_path2.default.join(clientPath, "vendor.js.br")
+          );
+          const acceptEncoding = request.header("Accept-Encoding");
+          if (acceptEncoding?.includes("br") && vendorBrotliExists) {
+            request.url += ".br";
+            response.set("Content-Encoding", "br");
             next();
-        }));
-        if (this.options.compression) {
-            this.serverApplication.use(compression__default["default"]());
-            this.serverApplication.get("/vendor.js", ((request, response, next) => {
-                response.setHeader("Content-Type", "application/javascript");
-                const vendorBrotliExists = fs__default["default"].existsSync(path__default["default"].join(clientPath, "vendor.js.br"));
-                const acceptEncoding = request.header("Accept-Encoding");
-                if ((acceptEncoding === null || acceptEncoding === void 0 ? void 0 : acceptEncoding.includes("br")) && vendorBrotliExists) {
-                    request.url += ".br";
-                    response.set("Content-Encoding", "br");
-                    next();
-                    return;
-                }
-                next();
-            }));
+            return;
+          }
+          next();
         }
-        this.serverApplication.use(express__default["default"].static(clientPath, {
-            maxAge: this.options.staticCache
-        }));
-        this.loadMiddleware();
+      );
     }
-    loadMiddleware() {
-        for (const middleware of this.middleware) {
-            this.serverApplication.use(((req, res, next) => middleware(req, res, next)));
-        }
+    this.serverApplication.use(
+      import_express.default.static(clientPath, {
+        maxAge: this.options.staticCache
+      })
+    );
+    this.loadMiddleware();
+  }
+  loadMiddleware() {
+    for (const middleware of this.middleware) {
+      this.serverApplication.use(
+        (req, res, next) => middleware(req, res, next)
+      );
     }
-    open(serverlink) {
-        try {
-            const processDoNotOpen = process.env.PLURID_OPEN === "false" ? true : false;
-            if (processDoNotOpen) {
-                return;
-            }
-            if (this.options.open) {
-                open__default["default"](serverlink);
-            }
-        } catch (error) {
-            return;
-        }
+  }
+  open(serverlink) {
+    try {
+      const processDoNotOpen = process.env.PLURID_OPEN === "false" ? true : false;
+      if (processDoNotOpen) {
+        return;
+      }
+      if (this.options.open) {
+        (0, import_open.default)(serverlink);
+      }
+    } catch (error) {
+      return;
     }
-    debugAllows(level) {
-        if (this.options.quiet) {
-            return false;
-        }
-        if (this.options.debug === "none") {
-            return false;
-        }
-        switch (level) {
-          case "error":
-            return true;
-
-          case "warn":
-            if (this.options.debug === "error") {
-                return false;
-            }
-            return true;
-
-          case "info":
-            if (this.options.debug === "error" || this.options.debug === "warn") {
-                return false;
-            }
-            return true;
-
-          default:
-            return false;
-        }
+  }
+  debugAllows(level) {
+    if (this.options.quiet) {
+      return false;
     }
-}
-
-class LiveServer {
-    constructor(options) {
-        this.sockets = [];
-        this.resolveOptions = options => {
-            const defaultServerPath = "./source/server/index.ts";
-            const resolvedOptions = {
-                server: (options === null || options === void 0 ? void 0 : options.server) || defaultServerPath
-            };
-            return resolvedOptions;
-        };
-        this.options = this.resolveOptions(options);
-        this.expressServer = express__default["default"]();
-        this.setupExpressServer();
-        this.httpServer = http__default["default"].createServer(this.expressServer);
-        this.setupHttpServer();
+    if (this.options.debug === "none") {
+      return false;
     }
-    setupExpressServer() {}
-    setupHttpServer() {
-        this.httpServer.on("connection", (socket => {
-            this.sockets.push(socket);
-            socket.once("close", (() => {
-                this.sockets.splice(this.sockets.indexOf(socket), 1);
-            }));
-        }));
-        this.httpServer.on("error", (error => {
-            throw error;
-        }));
+    switch (level) {
+      case "error":
+        return true;
+      case "warn":
+        if (this.options.debug === "error") {
+          return false;
+        }
+        return true;
+      case "info":
+        if (this.options.debug === "error" || this.options.debug === "warn") {
+          return false;
+        }
+        return true;
+      default:
+        return false;
     }
-    start() {}
-}
-
-const replacePluridResolution = html => {
-    const normalResolution = "width: 1366px; height: 768px;";
-    const zeroResolution = "width: 0px; height: 0px;";
-    return html.replace(normalResolution, zeroResolution);
+  }
 };
-
-const isCurrentUserRoot = () => process.getuid() == 0;
-
-const render = (puppeteer, host, route, configuration) => __awaiter(void 0, void 0, void 0, (function*() {
-    const start = Date.now();
-    const browser = yield puppeteer.launch({
-        defaultViewport: {
-            width: 1366,
-            height: 768
-        },
-        headless: true,
-        args: isCurrentUserRoot() ? [ "--no-sandbox" ] : undefined
+var Server_default = PluridServer;
+
+// source/objects/LiveServer/index.ts
+var import_http = __toESM(require("http"));
+var import_express2 = __toESM(require("express"));
+var LiveServer = class {
+  options;
+  expressServer;
+  httpServer;
+  sockets = [];
+  constructor(options) {
+    this.options = this.resolveOptions(options);
+    this.expressServer = (0, import_express2.default)();
+    this.setupExpressServer();
+    this.httpServer = import_http.default.createServer(this.expressServer);
+    this.setupHttpServer();
+  }
+  resolveOptions = (options) => {
+    const defaultServerPath = "./source/server/index.ts";
+    const resolvedOptions = {
+      server: options?.server || defaultServerPath
+    };
+    return resolvedOptions;
+  };
+  setupExpressServer() {
+  }
+  setupHttpServer() {
+    this.httpServer.on("connection", (socket) => {
+      this.sockets.push(socket);
+      socket.once("close", () => {
+        this.sockets.splice(this.sockets.indexOf(socket), 1);
+      });
     });
-    const page = yield browser.newPage();
-    try {
-        const url = host + route;
-        yield page.goto(url, {
-            waitUntil: configuration.waitUntil,
-            timeout: configuration.timeout
-        });
-    } catch (err) {
-        throw new Error(`${route} timed out.`);
-    }
-    const pageContent = yield page.content();
+    this.httpServer.on("error", (error) => {
+      throw error;
+    });
+  }
+  start() {
+    throw new Error(
+      "PluridLiveServer is not implemented yet. Use `PluridServer` (production) or a bundler dev server (tsx/Vite) for live reload."
+    );
+  }
+};
+var LiveServer_default = LiveServer;
+
+// source/objects/StillsGenerator/index.ts
+var import_path3 = __toESM(require("path"));
+var import_fs3 = require("fs");
+var import_child_process = require("child_process");
+var import_detect_port = __toESM(require("detect-port"));
+var import_plurid_functions2 = require("@plurid/plurid-functions");
+
+// source/objects/Stiller/index.ts
+var replacePluridResolution = (html) => {
+  const normalResolution = "width: 1366px; height: 768px;";
+  const zeroResolution = "width: 0px; height: 0px;";
+  return html.replace(normalResolution, zeroResolution);
+};
+var isCurrentUserRoot = () => {
+  return typeof process.getuid === "function" && process.getuid() === 0;
+};
+var render = async (browser, host, route, configuration) => {
+  const start = Date.now();
+  const page = await browser.newPage();
+  try {
+    const url = host + route;
+    await page.goto(
+      url,
+      {
+        waitUntil: configuration.waitUntil,
+        timeout: configuration.timeout
+      }
+    );
+    const pageContent = await page.content();
     const html = replacePluridResolution(pageContent);
-    yield browser.close();
     const stilltime = Date.now() - start;
-    console.info(`\tStilled '${route}' in ${(stilltime / 1e3).toFixed(2)} seconds.`);
+    console.info(`	Stilled '${route}' in ${(stilltime / 1e3).toFixed(2)} seconds.`);
     return {
-        route: route,
-        html: html,
-        stilltime: stilltime
+      route,
+      html,
+      stilltime
     };
-}));
-
-class Stiller {
-    constructor(options) {
-        try {
-            this.puppeteer = require("puppeteer");
-        } catch (error) {
-            console.error("could not load puppeteer: check puppeteer is installed");
-        }
-        const {host: host, routes: routes, configuration: configuration} = options;
-        this.host = host;
-        this.routes = routes;
-        this.configuration = configuration;
+  } catch (error) {
+    const reason = error instanceof Error ? error.message : String(error);
+    throw new Error(`Could not still '${route}': ${reason}`, { cause: error });
+  } finally {
+    await page.close();
+  }
+};
+var Stiller = class {
+  puppeteer = null;
+  host;
+  routes;
+  configuration;
+  constructor(options) {
+    try {
+      this.puppeteer = require("puppeteer");
+    } catch (_error) {
+      this.puppeteer = null;
     }
-    still() {
-        return __asyncGenerator(this, arguments, (function* still_1() {
-            for (const route of this.routes) {
-                yield yield __await(yield __await(render(this.puppeteer, this.host, route, this.configuration)));
-            }
-        }));
+    const {
+      host,
+      routes,
+      configuration
+    } = options;
+    this.host = host;
+    this.routes = routes;
+    this.configuration = configuration;
+  }
+  async *still() {
+    if (!this.puppeteer) {
+      throw new Error(
+        "Plurid Stiller: the optional 'puppeteer' dependency is not installed. Install it to generate stills (npm install puppeteer)."
+      );
     }
-}
-
-class StillsGenerator {
-    constructor(options) {
-        this.options = this.resolveOptions(options);
+    const browser = await this.puppeteer.launch({
+      defaultViewport: {
+        width: 1366,
+        height: 768
+      },
+      headless: true,
+      args: isCurrentUserRoot() ? ["--no-sandbox"] : void 0
+    });
+    try {
+      for (const route of this.routes) {
+        yield await render(
+          browser,
+          this.host,
+          route,
+          this.configuration
+        );
+      }
+    } finally {
+      await browser.close();
     }
-    resolveOptions(options) {
-        var _a, _b;
-        const stillsGeneratorOptions = {
-            server: (_a = options === null || options === void 0 ? void 0 : options.server) !== null && _a !== void 0 ? _a : "./build/server.js",
-            build: (_b = options === null || options === void 0 ? void 0 : options.build) !== null && _b !== void 0 ? _b : "./build/"
-        };
-        return stillsGeneratorOptions;
+  }
+};
+var Stiller_default = Stiller;
+
+// source/objects/StillsGenerator/index.ts
+var StillsGenerator = class {
+  options;
+  constructor(options) {
+    this.options = this.resolveOptions(options);
+  }
+  resolveOptions(options) {
+    const stillsGeneratorOptions = {
+      server: options?.server ?? "./build/server.js",
+      build: options?.build ?? "./build/"
+    };
+    return stillsGeneratorOptions;
+  }
+  async initialize() {
+    const serverPath = import_path3.default.join(process.cwd(), this.options.server);
+    const buildPath = import_path3.default.join(process.cwd(), this.options.build);
+    let serverModule;
+    try {
+      serverModule = require(serverPath);
+    } catch (error) {
+      const reason = error instanceof Error ? error.message : String(error);
+      throw new Error(
+        `Plurid StillsGenerator: could not load the built server at '${serverPath}'. Build the server first so the generator can read its routes. (${reason})`,
+        { cause: error }
+      );
     }
-    initialize() {
-        return __awaiter(this, void 0, void 0, (function*() {
-            const serverPath = path__default["default"].join(process.cwd(), this.options.server);
-            const buildPath = path__default["default"].join(process.cwd(), this.options.build);
-            const pluridServer = require(serverPath);
-            const serverInformation = PluridServer.analysis(pluridServer);
-            const stillerOptions = serverInformation.options.stiller;
-            const serverPort = (yield detectPort__default["default"](9900)) + "";
-            const child = child_process.fork(serverPath, [], {
-                stdio: "pipe",
-                env: {
-                    PORT: serverPort,
-                    PLURID_OPEN: "false"
-                }
-            });
-            const stillRoutes = [];
-            for (const route of serverInformation.routes) {
-                if (route.value.includes("/:")) {
-                    continue;
-                }
-                if (stillerOptions.ignore.includes(route.value)) {
-                    continue;
-                }
-                stillRoutes.push(route);
-            }
-            const stillRoutesPaths = stillRoutes.map((stillRoute => stillRoute.value));
-            console.info("\n\tParsed the following still routes:");
-            for (const stillRoutePath of stillRoutesPaths) {
-                console.info(`\t  ${stillRoutePath}`);
-            }
-            yield new Promise((resolve => setTimeout(resolve, 1500)));
-            const startTime = Date.now();
-            const estimatedDuration = 3 * serverInformation.routes.length;
-            console.info(`\n\tStarting to generate stills... (this may take about ${estimatedDuration} seconds)\n`);
-            const stiller = new Stiller({
-                host: "http://localhost:" + serverPort,
-                routes: [ ...stillRoutesPaths ],
-                configuration: {
-                    waitUntil: stillerOptions.waitUntil,
-                    timeout: stillerOptions.timeout
-                }
-            });
-            const sequence = stiller.still();
-            const stills = [];
-            let next;
-            while (!(next = yield sequence.next()).done) {
-                stills.push(next.value);
-            }
-            const endTime = Date.now();
-            const duration = (endTime - startTime) / 1e3;
-            const plural = stills.length === 1 ? "" : "s";
-            console.info(`\n\tGenerated ${stills.length} still${plural} in ${duration.toFixed(2)} seconds.\n`);
-            const stillsPath = path__default["default"].join(buildPath, "./stills");
-            yield fs.promises.mkdir(stillsPath, {
-                recursive: true
-            });
-            const metadataFile = [];
-            for (const still of stills) {
-                if (!still) {
-                    continue;
-                }
-                const stillName = pluridFunctions.uuid.generate() + ".json";
-                const metadataItem = {
-                    route: still.route,
-                    name: stillName
-                };
-                metadataFile.push(metadataItem);
-                const stillJSON = JSON.stringify(still, null, 4);
-                const stillFile = path__default["default"].join(stillsPath, stillName);
-                yield fs.promises.writeFile(stillFile, stillJSON);
-            }
-            const metadataFilePath = path__default["default"].join(stillsPath, "metadata.json");
-            const metadataJSON = JSON.stringify(metadataFile, null, 4);
-            yield fs.promises.writeFile(metadataFilePath, metadataJSON);
-            child.kill(2);
-        }));
+    const pluridServer = serverModule?.default ?? serverModule;
+    const serverInformation = Server_default.analysis(pluridServer);
+    const stillerOptions = serverInformation.options.stiller;
+    const serverPort = await (0, import_detect_port.default)(9900) + "";
+    const child = (0, import_child_process.fork)(serverPath, [], {
+      stdio: "pipe",
+      env: {
+        PORT: serverPort,
+        PLURID_OPEN: "false"
+      }
+    });
+    try {
+      const stillRoutes = [];
+      for (const route of serverInformation.routes) {
+        if (route.value.includes("/:")) {
+          continue;
+        }
+        if (stillerOptions.ignore.includes(route.value)) {
+          continue;
+        }
+        stillRoutes.push(route);
+      }
+      const stillRoutesPaths = stillRoutes.map((stillRoute) => stillRoute.value);
+      console.info("\n	Parsed the following still routes:");
+      for (const stillRoutePath of stillRoutesPaths) {
+        console.info(`	  ${stillRoutePath}`);
+      }
+      await new Promise((resolve) => setTimeout(resolve, 1500));
+      const startTime = Date.now();
+      const estimatedDuration = 3 * serverInformation.routes.length;
+      console.info(`
+	Starting to generate stills... (this may take about ${estimatedDuration} seconds)
+`);
+      const stiller = new Stiller_default({
+        host: "http://localhost:" + serverPort,
+        routes: [
+          ...stillRoutesPaths
+        ],
+        configuration: {
+          waitUntil: stillerOptions.waitUntil,
+          timeout: stillerOptions.timeout
+        }
+      });
+      const sequence = stiller.still();
+      const stills = [];
+      let next;
+      while (!(next = await sequence.next()).done) {
+        stills.push(next.value);
+      }
+      const endTime = Date.now();
+      const duration = (endTime - startTime) / 1e3;
+      const plural = stills.length === 1 ? "" : "s";
+      console.info(`
+	Generated ${stills.length} still${plural} in ${duration.toFixed(2)} seconds.
+`);
+      const stillsPath = import_path3.default.join(buildPath, "./stills");
+      await import_fs3.promises.mkdir(
+        stillsPath,
+        {
+          recursive: true
+        }
+      );
+      const metadataFile = [];
+      for (const still of stills) {
+        if (!still) {
+          continue;
+        }
+        const stillName = import_plurid_functions2.uuid.generate() + ".json";
+        const metadataItem = {
+          route: still.route,
+          name: stillName
+        };
+        metadataFile.push(metadataItem);
+        const stillJSON = JSON.stringify(still, null, 4);
+        const stillFile = import_path3.default.join(stillsPath, stillName);
+        await import_fs3.promises.writeFile(stillFile, stillJSON);
+      }
+      const metadataFilePath = import_path3.default.join(stillsPath, "metadata.json");
+      const metadataJSON = JSON.stringify(metadataFile, null, 4);
+      await import_fs3.promises.writeFile(metadataFilePath, metadataJSON);
+    } finally {
+      child.kill("SIGTERM");
     }
-}
-
-exports.PluridLiveServer = LiveServer;
-
-exports.PluridStillsGenerator = StillsGenerator;
-
-exports["default"] = PluridServer;
+  }
+};
+var StillsGenerator_default = StillsGenerator;
+
+// source/index.ts
+var index_default = Server_default;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PluridLiveServer,
+  PluridStillsGenerator
+});
+//# sourceMappingURL=index.js.map