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

package/distribution/index.mjs

@@ -0,0 +1,1642 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// source/objects/Server/index.ts
+import fs2 from "fs";
+import path2 from "path";
+import express from "express";
+import compression from "compression";
+import open from "open";
+import {
+  ServerStyleSheet
+} from "styled-components";
+import {
+  time,
+  uuid
+} from "@plurid/plurid-functions";
+import {
+  routing
+} from "@plurid/plurid-engine";
+import {
+  serverComputeMetastate
+} from "@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
+};
+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"
+};
+
+// source/data/constants/stiller/index.ts
+var defaultStillerOptions = {
+  waitUntil: "networkidle0",
+  timeout: 3e4,
+  ignore: []
+};
+
+// source/utilities/template/index.ts
+import {
+  minify
+} from "html-minifier-terser";
+var cleanTemplate = (template2) => {
+  return minify(
+    template2,
+    {
+      collapseWhitespace: true,
+      conservativeCollapse: true,
+      collapseInlineTagWhitespace: false
+    }
+  );
+};
+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;
+    }
+    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;
+  }
+};
+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;
+};
+
+// 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;
+            }
+
+            .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;
+            }
+
+            .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);
+};
+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
+import React2 from "react";
+import {
+  renderToString
+} from "react-dom/server";
+import {
+  StyleSheetManager
+} from "styled-components";
+import {
+  HelmetProvider
+} from "react-helmet-async";
+import {
+  PluridProvider,
+  PluridRouterStatic
+} from "@plurid/plurid-react";
+
+// source/utilities/wrapping/index.tsx
+import React from "react";
+var wrapping = (WrappedComponent, WrappeeComponent, properties) => {
+  return class extends React.Component {
+    constructor(props) {
+      super(props);
+    }
+    render() {
+      return /* @__PURE__ */ React.createElement(
+        WrappedComponent,
+        {
+          ...properties
+        },
+        /* @__PURE__ */ React.createElement(WrappeeComponent, null)
+      );
+    }
+  };
+};
+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__ */ React2.createElement(
+      PluridProvider,
+      {
+        metastate: pluridMetastate
+      },
+      /* @__PURE__ */ React2.createElement(
+        PluridRouterStatic,
+        {
+          path: pathname,
+          directPlane: matchedPlane?.value,
+          routes,
+          planes,
+          exterior,
+          shell,
+          gateway,
+          gatewayEndpoint,
+          gatewayQuery,
+          hostname,
+          routerProperties
+        }
+      )
+    );
+    let Wrap = wrapping_default(
+      HelmetProvider,
+      RoutedApplication,
+      {
+        context: helmet
+      }
+    );
+    for (const service of services) {
+      const preserveProperties = preserveResult?.providers?.[service.name];
+      Wrap = wrapping_default(
+        service.Provider,
+        Wrap,
+        {
+          ...service.properties,
+          ...preserveProperties
+        }
+      );
+    }
+    const content = renderToString(
+      /* @__PURE__ */ React2.createElement(
+        StyleSheetManager,
+        {
+          sheet: stylesheet.instance
+        },
+        /* @__PURE__ */ React2.createElement(Wrap, null)
+      )
+    );
+    return content;
+  }
+};
+var ContentGenerator_default = PluridContentGenerator;
+
+// source/objects/StillsManager/index.ts
+import path from "path";
+import {
+  existsSync,
+  promises as fs
+} from "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;
+    }
+    return still.html;
+  }
+  async findStills() {
+    const {
+      buildDirectory,
+      stillsDirectory
+    } = this.options;
+    const stillsLocation = `${buildDirectory}/${stillsDirectory}`;
+    const stillsPath = path.join(process.cwd(), stillsLocation);
+    if (!existsSync(stillsPath)) {
+      return;
+    }
+    try {
+      const stillsMetadata = path.join(stillsPath, "metadata.json");
+      const stillsMetadataFile = await fs.readFile(stillsMetadata, "utf-8");
+      const stillsMetadataJSON = JSON.parse(stillsMetadataFile);
+      if (!Array.isArray(stillsMetadataJSON)) {
+        return;
+      }
+      for (const still of stillsMetadataJSON) {
+        const stillFilePath = path.join(stillsPath, still.name);
+        const stillFileData = await fs.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,
+      url: elementqlEndpoint
+    };
+  }
+  return {
+    name: planeMatch.data.component.name,
+    url: planeMatch.data.component.url || elementqlEndpoint
+  };
+};
+
+// source/objects/Server/index.ts
+var {
+  IsoMatcher: PluridIsoMatcher
+} = 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 = express();
+    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();
+    }
+  }
+  handleProcessSignal = () => {
+    this.stop();
+    process.exit(0);
+  };
+  signalHandlersAttached = false;
+  attachSignalHandlers() {
+    if (this.signalHandlersAttached) {
+      return;
+    }
+    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(
+        `
+	[${time.stamp()}] ${this.options.serverName} Started on Port ${port}: ${serverlink}
+`
+      );
+    }
+    this.server = this.serverApplication.listen(port);
+    this.open(serverlink);
+    return this.server;
+  }
+  stop() {
+    this.detachSignalHandlers();
+    if (this.server) {
+      if (this.debugAllows("info")) {
+        console.info(
+          `
+	[${time.stamp()}] ${this.options.serverName} Stopped on Port ${this.port}
+`
+        );
+      }
+      this.server.close();
+    } else {
+      if (this.debugAllows("info")) {
+        console.info(
+          `
+	[${time.stamp()}] ${this.options.serverName} Could not be Stopped on Port ${this.port}
+`
+        );
+      }
+    }
+  }
+  handle() {
+    return {
+      post: (path4, ...handlers) => {
+        this.serverApplication.post(path4, ...handlers);
+        return this.serverApplication;
+      },
+      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,
+        express.json(),
+        // body parsing is built into Express 5
+        async (request, response, next) => {
+          this.handlePTTPRequest(
+            request,
+            response
+          );
+        }
+      );
+    }
+  }
+  async handleGetRequest(request, response, next) {
+    const requestID = request.requestID || uuid.generate();
+    try {
+      if (this.debugAllows("info")) {
+        console.info(
+          `[${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(
+            `[${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(
+            `[${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(
+            `[${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(
+            `[${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(
+              `[${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(
+              `[${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(
+            `[${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(
+          `[${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(
+          `[${time.stamp()} :: ${requestID}] (500 Server Error) Could not handle GET ${request.path}${requestTime}`,
+          error
+        );
+      }
+      response.status(500).send(SERVER_ERROR_TEMPLATE);
+      return;
+    }
+  }
+  async handlePTTPRequest(request, response) {
+    const requestID = request.requestID || uuid.generate();
+    try {
+      if (this.debugAllows("info")) {
+        console.info(
+          `[${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(
+            `[${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(
+              `[${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(
+            `[${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(
+            `[${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(
+            `[${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(
+          `[${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(
+          `[${time.stamp()} :: ${requestID}] (500 Server Error) Could not handle POST ${request.path}${requestTime}`,
+          error
+        );
+      }
+      response.status(500).send(SERVER_ERROR_TEMPLATE);
+      return;
+    }
+  }
+  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, 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;
+      }
+    }
+    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: true,
+              preserveResult,
+              preserveAfterServe
+            };
+          }
+        }
+      } catch (error) {
+        if (preserveOnError) {
+          const onErrorResponse = await preserveOnError(
+            error,
+            transmission
+          );
+          if (onErrorResponse) {
+            if (onErrorResponse.responded) {
+              return {
+                preserveResponded: true,
+                preserveResult,
+                preserveAfterServe
+              };
+            }
+            if (!onErrorResponse.depreserve) {
+              return {
+                preserveResponded: false,
+                preserveResult,
+                preserveAfterServe
+              };
+            }
+          }
+        }
+      }
+    }
+    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);
+    }
+  }
+  async handleGateway(path4, request, preserveResult) {
+    const {
+      gatewayEndpoint
+    } = this.options;
+    if (path4 !== gatewayEndpoint) {
+      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 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 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
+          );
+        }
+      }
+      return {
+        content: "",
+        styles: ""
+      };
+    } finally {
+      stylesheet.seal();
+    }
+    return {
+      content,
+      styles
+    };
+  }
+  computeRequestTime(request) {
+    const requestTime = request.requestTime;
+    if (!requestTime) {
+      return "";
+    }
+    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 = path2.join(this.options.buildDirectory, "./client");
+    this.serverApplication.disable("x-powered-by");
+    this.serverApplication.use(
+      (request, _, next) => {
+        const requestID = uuid.generate();
+        request.requestID = requestID;
+        const requestTime = Date.now();
+        request.requestTime = requestTime;
+        next();
+      }
+    );
+    if (this.options.compression) {
+      this.serverApplication.use(
+        compression()
+        // @types/compression targets Express 4's handler type
+      );
+      this.serverApplication.get(
+        "/vendor.js",
+        (request, response, next) => {
+          response.setHeader(
+            "Content-Type",
+            "application/javascript"
+          );
+          const vendorBrotliExists = fs2.existsSync(
+            path2.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();
+            return;
+          }
+          next();
+        }
+      );
+    }
+    this.serverApplication.use(
+      express.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(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;
+    }
+  }
+};
+var Server_default = PluridServer;
+
+// source/objects/LiveServer/index.ts
+import http from "http";
+import express2 from "express";
+var LiveServer = class {
+  options;
+  expressServer;
+  httpServer;
+  sockets = [];
+  constructor(options) {
+    this.options = this.resolveOptions(options);
+    this.expressServer = express2();
+    this.setupExpressServer();
+    this.httpServer = http.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);
+      });
+    });
+    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
+import path3 from "path";
+import {
+  promises as fs3
+} from "fs";
+import {
+  fork
+} from "child_process";
+import detectPort from "detect-port";
+import {
+  uuid as uuid2
+} from "@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);
+    const stilltime = Date.now() - start;
+    console.info(`	Stilled '${route}' in ${(stilltime / 1e3).toFixed(2)} seconds.`);
+    return {
+      route,
+      html,
+      stilltime
+    };
+  } 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;
+    }
+    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)."
+      );
+    }
+    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();
+    }
+  }
+};
+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 = path3.join(process.cwd(), this.options.server);
+    const buildPath = path3.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 }
+      );
+    }
+    const pluridServer = serverModule?.default ?? serverModule;
+    const serverInformation = Server_default.analysis(pluridServer);
+    const stillerOptions = serverInformation.options.stiller;
+    const serverPort = await detectPort(9900) + "";
+    const child = 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 = path3.join(buildPath, "./stills");
+      await fs3.mkdir(
+        stillsPath,
+        {
+          recursive: true
+        }
+      );
+      const metadataFile = [];
+      for (const still of stills) {
+        if (!still) {
+          continue;
+        }
+        const stillName = uuid2.generate() + ".json";
+        const metadataItem = {
+          route: still.route,
+          name: stillName
+        };
+        metadataFile.push(metadataItem);
+        const stillJSON = JSON.stringify(still, null, 4);
+        const stillFile = path3.join(stillsPath, stillName);
+        await fs3.writeFile(stillFile, stillJSON);
+      }
+      const metadataFilePath = path3.join(stillsPath, "metadata.json");
+      const metadataJSON = JSON.stringify(metadataFile, null, 4);
+      await fs3.writeFile(metadataFilePath, metadataJSON);
+    } finally {
+      child.kill("SIGTERM");
+    }
+  }
+};
+var StillsGenerator_default = StillsGenerator;
+
+// source/index.ts
+var index_default = Server_default;
+export {
+  LiveServer_default as PluridLiveServer,
+  StillsGenerator_default as PluridStillsGenerator,
+  index_default as default
+};
+//# sourceMappingURL=index.mjs.map