@squiz/render-runtime-lib 1.64.0 → 1.65.0

package/lib/index.js

@@ -81,10 +81,10 @@ var import_cors = __toESM(require("cors"));
 var import_compression = __toESM(require("compression"));
 var import_crypto = require("crypto");
 var import_helmet = __toESM(require("helmet"));
-var import_dx_common_lib5 = require("@squiz/dx-common-lib");
+var import_dx_common_lib6 = require("@squiz/dx-common-lib");
 
 // src/webserver/routes/routes.ts
-var import_runtime5 = require("@tsoa/runtime");
+var import_runtime6 = require("@tsoa/runtime");
 
 // src/webserver/controllers/CoreController.ts
 var import_tsoa = require("tsoa");
@@ -340,17 +340,157 @@ DefinitionController = __decorateClass([
   __decorateParam(3, (0, import_inversify2.inject)("ComponentRootUrlResolver"))
 ], DefinitionController);
 
-// src/webserver/controllers/RenderController.ts
+// src/webserver/controllers/DevelopmentController.ts
 var import_tsoa3 = require("tsoa");
 var import_inversify_binding_decorators3 = require("inversify-binding-decorators");
 var import_inversify3 = require("inversify");
+var import_dx_common_lib3 = require("@squiz/dx-common-lib");
+var DevelopmentController = class extends import_tsoa3.Controller {
+  constructor(config, manifestService, componentRunnerService) {
+    super();
+    this.config = config;
+    this.manifestService = manifestService;
+    this.componentRunnerService = componentRunnerService;
+  }
+  async getComponents() {
+    if (!this.config.enableDevMode) {
+      throw new import_dx_common_lib3.ResourceNotFoundError("Route does not exist.");
+    }
+    const components = await this.manifestService.listAllComponentManifests();
+    return components.map((component) => component.getModel());
+  }
+  async Manifest(namespace, componentName, version) {
+    if (!this.config.enableDevMode) {
+      throw new import_dx_common_lib3.ResourceNotFoundError("Route does not exist.");
+    }
+    const manifest = await this.manifestService.loadManifest(namespace, componentName, version);
+    return manifest.getModel();
+  }
+  async getContentSchema(namespace, componentName, version) {
+    if (!this.config.enableDevMode) {
+      throw new import_dx_common_lib3.ResourceNotFoundError("Route does not exist.");
+    }
+    const componentManifest = await this.manifestService.loadManifest(namespace, componentName, version);
+    const inputSchemas = componentManifest.getInputSchemas();
+    const schemaResult = [];
+    inputSchemas.forEach((inputSchema) => {
+      if (inputSchema.schema && Object.keys(inputSchema.schema).length) {
+        schemaResult.push(inputSchema);
+      }
+    });
+    return schemaResult;
+  }
+  /* Commenting this out for POC, would like to do something like the following: */
+  /* TODO: FEAAS-627 Temporary Preview:
+    - Bit crude and should be improved but the method is:
+    - A preview is created by post of the temp data (env, header, content etc) to the server and stored in the map bellow
+    - Post request returns the id for the map
+    - Front end opens the get route in the browser using the id thats returned
+  
+    type TemporaryPreviewInput = {
+      componentSet: RuntimeComponentSet;
+      headers: Headers;
+      // content: ContentItemWebModelForCreate
+    };
+  
+    temporaryPreviewResultMap: Map<string, { componentResult: FunctionReturnTypes; headers: Headers }> = new Map();
+  
+    @Post('/temp-preview/:namespace/:componentName/:version/:functionName')
+    public async TemporaryPreview(
+      @Request() req: ExpressRequest,
+      @Path() namespace: string,
+      @Path() componentName: string,
+      @Path() version: string,
+      @Path() functionName: string,
+      @Body() requestBody?: TemporaryPreviewInput,
+    ) {
+      const res = (<any>req).res as ExpressResponse;
+      // const contentItem: ContentItem = new ContentItem(requestBody); //FIXME: do something like this
+      const rootUrl = parseEnvVarForVar('COMPONENT_RENDER_SERVICE_URL').replace(/\/+$/, '');
+      const componentManifest = await this.manifestService.loadManifest(namespace, componentName, version);
+      // const renderedOutput = await this.doFunctionRender(renderInput);
+  
+      // Form the input from the request body content
+      // const input = await this.getContentFromContentService(request);
+      // this.assertInputIsValid(input, componentFunction);
+      // const resolvedInput = await resolveFormattedTextNodes(
+      //   input,
+      //   componentFunction.input,
+      //   formattedTextToHtmlStringResolvers,
+      //   { withJoin: '' },
+      // );
+      // this.assertRenderInputIsValid(resolvedInput, componentFunction);
+  
+      const result = await this.componentRunnerService.executeComponentFunction({
+        dxpApiKey: undefined,
+        requestId: 'MOCK_ME',
+        args: [],
+        functionEntryFilePath: await componentManifest.getComponentFunctionEntryFilePath(
+          componentManifest.getComponentFunctionByName(functionName),
+        ),
+        environment: requestBody.componentSet.environment,
+        componentFullName: componentName,
+        componentFunction: componentManifest.getComponentFunctionByName(functionName),
+        componentRootUrl: rootUrl,
+        manifest: componentManifest.getModel(),
+        runtimeSet: requestBody.componentSet,
+        manifestPath: await componentManifest.getManifestPath(),
+        previewKey: undefined,
+        queryParameters: undefined,
+      });
+  
+      //Set the render and headers into temporary memory
+      this.temporaryPreviewResultMap.set(req.id, { componentResult: result, headers: requestBody.headers });
+      res.send(req.id);
+    }
+  
+    @Get('/temp-preview/:id')
+    public async getTemporaryPreviewRender(@Request() req: ExpressRequest, @Path() id: string) {
+      const res = (<any>req).res as ExpressResponse;
+      const temporaryPreview = this.temporaryPreviewResultMap.get(id);
+      if (temporaryPreview === undefined) {
+        throw new BadRequestError(`Temporary Preview with id ${id}, does not exist`);
+      }
+      setHeadersOnExpressResponse(temporaryPreview.headers, res);
+      res.send(temporaryPreview.componentResult);
+    }
+  */
+};
+__decorateClass([
+  (0, import_tsoa3.Get)("/all")
+], DevelopmentController.prototype, "getComponents", 1);
+__decorateClass([
+  (0, import_tsoa3.Get)("/manifest/:namespace/:componentName/:version"),
+  __decorateParam(0, (0, import_tsoa3.Path)()),
+  __decorateParam(1, (0, import_tsoa3.Path)()),
+  __decorateParam(2, (0, import_tsoa3.Path)())
+], DevelopmentController.prototype, "Manifest", 1);
+__decorateClass([
+  (0, import_tsoa3.Get)("/schemas/:namespace/:componentName/:version"),
+  __decorateParam(0, (0, import_tsoa3.Path)()),
+  __decorateParam(1, (0, import_tsoa3.Path)()),
+  __decorateParam(2, (0, import_tsoa3.Path)())
+], DevelopmentController.prototype, "getContentSchema", 1);
+DevelopmentController = __decorateClass([
+  (0, import_inversify_binding_decorators3.provide)(DevelopmentController),
+  (0, import_tsoa3.Route)("/dev"),
+  (0, import_tsoa3.Hidden)(),
+  __decorateParam(0, (0, import_inversify3.inject)("Config")),
+  __decorateParam(1, (0, import_inversify3.inject)("ManifestService")),
+  __decorateParam(2, (0, import_inversify3.inject)("ComponentRunnerService"))
+], DevelopmentController);
+
+// src/webserver/controllers/RenderController.ts
+var import_tsoa4 = require("tsoa");
+var import_inversify_binding_decorators4 = require("inversify-binding-decorators");
+var import_inversify4 = require("inversify");
 var import_query_string = require("query-string");
 var import_component_lib = require("@squiz/component-lib");
-var import_dx_common_lib3 = require("@squiz/dx-common-lib");
+var import_dx_common_lib4 = require("@squiz/dx-common-lib");
 var import_api = require("@opentelemetry/api");
 var UPPERCASE_REGEX = /[A-Z]/;
 var meter = import_api.metrics.getMeter("render-runtime");
-var RenderController = class extends import_tsoa3.Controller {
+var RenderController = class extends import_tsoa4.Controller {
   constructor(componentSetService, manifestService, componentFunctionService, componentRunnerService, renderInputService, contentItemService, componentPreviewService) {
     super();
     this.componentSetService = componentSetService;
@@ -375,7 +515,7 @@ var RenderController = class extends import_tsoa3.Controller {
   }
   async getGivenFunctionRendering(expressRequest, namespace, componentName, version, functionName, componentSet, previewKey, contentItemId) {
     const response = expressRequest.res;
-    (0, import_dx_common_lib3.assertIsDefined)(response);
+    (0, import_dx_common_lib4.assertIsDefined)(response);
     const { path: path7, query } = expressRequest;
     if (UPPERCASE_REGEX.test(path7) || componentSet && UPPERCASE_REGEX.test(componentSet)) {
       const url = (0, import_query_string.stringifyUrl)({
@@ -479,50 +619,50 @@ var RenderController = class extends import_tsoa3.Controller {
     if (typeof cacheControl !== "string") {
       cacheControl = void 0;
     }
-    response.setHeader("cache-control", (0, import_dx_common_lib3.parseAndSanitiseCacheControlHeader)(cacheControl));
+    response.setHeader("cache-control", (0, import_dx_common_lib4.parseAndSanitiseCacheControlHeader)(cacheControl));
   }
 };
 __decorateClass([
-  (0, import_tsoa3.Get)("/:namespace/:componentName/:version"),
-  __decorateParam(0, (0, import_tsoa3.Request)()),
-  __decorateParam(1, (0, import_tsoa3.Path)()),
-  __decorateParam(2, (0, import_tsoa3.Path)()),
-  __decorateParam(3, (0, import_tsoa3.Path)()),
-  __decorateParam(4, (0, import_tsoa3.Query)("_componentSet")),
-  __decorateParam(5, (0, import_tsoa3.Query)("_previewKey")),
-  __decorateParam(6, (0, import_tsoa3.Query)("_contentItemId"))
+  (0, import_tsoa4.Get)("/:namespace/:componentName/:version"),
+  __decorateParam(0, (0, import_tsoa4.Request)()),
+  __decorateParam(1, (0, import_tsoa4.Path)()),
+  __decorateParam(2, (0, import_tsoa4.Path)()),
+  __decorateParam(3, (0, import_tsoa4.Path)()),
+  __decorateParam(4, (0, import_tsoa4.Query)("_componentSet")),
+  __decorateParam(5, (0, import_tsoa4.Query)("_previewKey")),
+  __decorateParam(6, (0, import_tsoa4.Query)("_contentItemId"))
 ], RenderController.prototype, "getDefaultFunctionRendering", 1);
 __decorateClass([
-  (0, import_tsoa3.Get)("/:namespace/:componentName/:version/:functionName"),
-  __decorateParam(0, (0, import_tsoa3.Request)()),
-  __decorateParam(1, (0, import_tsoa3.Path)()),
-  __decorateParam(2, (0, import_tsoa3.Path)()),
-  __decorateParam(3, (0, import_tsoa3.Path)()),
-  __decorateParam(4, (0, import_tsoa3.Path)()),
-  __decorateParam(5, (0, import_tsoa3.Query)("_componentSet")),
-  __decorateParam(6, (0, import_tsoa3.Query)("_previewKey")),
-  __decorateParam(7, (0, import_tsoa3.Query)("_contentItemId"))
+  (0, import_tsoa4.Get)("/:namespace/:componentName/:version/:functionName"),
+  __decorateParam(0, (0, import_tsoa4.Request)()),
+  __decorateParam(1, (0, import_tsoa4.Path)()),
+  __decorateParam(2, (0, import_tsoa4.Path)()),
+  __decorateParam(3, (0, import_tsoa4.Path)()),
+  __decorateParam(4, (0, import_tsoa4.Path)()),
+  __decorateParam(5, (0, import_tsoa4.Query)("_componentSet")),
+  __decorateParam(6, (0, import_tsoa4.Query)("_previewKey")),
+  __decorateParam(7, (0, import_tsoa4.Query)("_contentItemId"))
 ], RenderController.prototype, "getGivenFunctionRendering", 1);
 RenderController = __decorateClass([
-  (0, import_inversify_binding_decorators3.provide)(RenderController),
-  (0, import_tsoa3.Route)("/r"),
-  __decorateParam(0, (0, import_inversify3.inject)("ComponentSetService")),
-  __decorateParam(1, (0, import_inversify3.inject)("ManifestService")),
-  __decorateParam(2, (0, import_inversify3.inject)("ComponentFunctionService")),
-  __decorateParam(3, (0, import_inversify3.inject)("ComponentRunnerService")),
-  __decorateParam(4, (0, import_inversify3.inject)("RenderInputService")),
-  __decorateParam(5, (0, import_inversify3.inject)("ContentItemService")),
-  __decorateParam(6, (0, import_inversify3.inject)("ComponentPreviewService"))
+  (0, import_inversify_binding_decorators4.provide)(RenderController),
+  (0, import_tsoa4.Route)("/r"),
+  __decorateParam(0, (0, import_inversify4.inject)("ComponentSetService")),
+  __decorateParam(1, (0, import_inversify4.inject)("ManifestService")),
+  __decorateParam(2, (0, import_inversify4.inject)("ComponentFunctionService")),
+  __decorateParam(3, (0, import_inversify4.inject)("ComponentRunnerService")),
+  __decorateParam(4, (0, import_inversify4.inject)("RenderInputService")),
+  __decorateParam(5, (0, import_inversify4.inject)("ContentItemService")),
+  __decorateParam(6, (0, import_inversify4.inject)("ComponentPreviewService"))
 ], RenderController);
 
 // src/webserver/controllers/StaticController.ts
-var import_tsoa4 = require("tsoa");
-var import_inversify_binding_decorators4 = require("inversify-binding-decorators");
-var import_dx_common_lib4 = require("@squiz/dx-common-lib");
+var import_tsoa5 = require("tsoa");
+var import_inversify_binding_decorators5 = require("inversify-binding-decorators");
+var import_dx_common_lib5 = require("@squiz/dx-common-lib");
 var import_path = __toESM(require("path"));
-var import_inversify4 = require("inversify");
+var import_inversify5 = require("inversify");
 var import_assert = __toESM(require("assert"));
-var StaticController = class extends import_tsoa4.Controller {
+var StaticController = class extends import_tsoa5.Controller {
   constructor(manifestService, componentSetService, componentFunctionService) {
     super();
     this.manifestService = manifestService;
@@ -531,7 +671,7 @@ var StaticController = class extends import_tsoa4.Controller {
   }
   async getPreview(namespace, componentName, version, staticFile, req, _componentSet, _previewKey) {
     if (_componentSet !== void 0 && _previewKey !== void 0) {
-      throw new import_dx_common_lib4.BadRequestError("You can not have both _componentSet and _previewKey");
+      throw new import_dx_common_lib5.BadRequestError("You can not have both _componentSet and _previewKey");
     }
     const manifest = await this.manifestService.loadManifest(namespace, componentName, version);
     const manifestModel = manifest.getModel();
@@ -560,7 +700,7 @@ var StaticController = class extends import_tsoa4.Controller {
           if (req.next) {
             if (e?.code == "ENOENT") {
               req.next(
-                new import_dx_common_lib4.ResourceNotFoundError(
+                new import_dx_common_lib5.ResourceNotFoundError(
                   `could not find ${e?.path.substr(
                     e?.path.indexOf(componentStaticFileRoot) + componentStaticFileRoot.length
                   )}`
@@ -579,20 +719,20 @@ var StaticController = class extends import_tsoa4.Controller {
         });
       });
     } else {
-      throw new import_dx_common_lib4.ResourceNotFoundError(`${componentName} ${version} doesn't expose any static resources`);
+      throw new import_dx_common_lib5.ResourceNotFoundError(`${componentName} ${version} doesn't expose any static resources`);
     }
   }
   setResponseHeaders(headers, response) {
     setHeadersOnExpressResponse(headers, response);
     let cacheControl = response.getHeader("cache-control");
     if (typeof cacheControl != "string") {
-      cacheControl = import_dx_common_lib4.DEFAULT_CACHE_CONTROL_HEADER;
+      cacheControl = import_dx_common_lib5.DEFAULT_CACHE_CONTROL_HEADER;
     }
-    let cacheControlObj = (0, import_dx_common_lib4.parseCacheControl)(cacheControl);
-    cacheControlObj = (0, import_dx_common_lib4.applyDefaultRulesToCacheControlObject)(cacheControlObj);
+    let cacheControlObj = (0, import_dx_common_lib5.parseCacheControl)(cacheControl);
+    cacheControlObj = (0, import_dx_common_lib5.applyDefaultRulesToCacheControlObject)(cacheControlObj);
     cacheControlObj.immutable = true;
     cacheControlObj["max-age"] = 604800;
-    response.setHeader("cache-control", (0, import_dx_common_lib4.cacheControlToString)(cacheControlObj));
+    response.setHeader("cache-control", (0, import_dx_common_lib5.cacheControlToString)(cacheControlObj));
   }
   async getHeadersForInputType(_componentSet, _previewKey, manifest) {
     if (_componentSet) {
@@ -605,13 +745,13 @@ var StaticController = class extends import_tsoa4.Controller {
       const headers = functionPreview?.headers ? functionPreview.headers : {};
       return headers;
     }
-    throw new import_dx_common_lib4.BadRequestError(`neither componentSet or previewKey set`);
+    throw new import_dx_common_lib5.BadRequestError(`neither componentSet or previewKey set`);
   }
   async getValidatedSet(_componentSet, manifest) {
     const set = await this.componentSetService.getComponentSet(_componentSet);
     const isCompVersionInSet = this.componentSetService.componentVersionInSet(manifest, set.webPath);
     if (!isCompVersionInSet) {
-      throw new import_dx_common_lib4.ResourceNotFoundError(`${manifest.getName()} ${manifest.getVersion()} not in set ${set.webPath}`);
+      throw new import_dx_common_lib5.ResourceNotFoundError(`${manifest.getName()} ${manifest.getVersion()} not in set ${set.webPath}`);
     }
     return set;
   }
@@ -630,33 +770,34 @@ var StaticController = class extends import_tsoa4.Controller {
   }
 };
 __decorateClass([
-  (0, import_tsoa4.Get)("/:namespace/:componentName/:version/:staticFile*"),
-  __decorateParam(0, (0, import_tsoa4.Path)()),
-  __decorateParam(1, (0, import_tsoa4.Path)()),
-  __decorateParam(2, (0, import_tsoa4.Path)()),
-  __decorateParam(3, (0, import_tsoa4.Path)()),
-  __decorateParam(4, (0, import_tsoa4.Request)()),
-  __decorateParam(5, (0, import_tsoa4.Query)()),
-  __decorateParam(6, (0, import_tsoa4.Query)())
+  (0, import_tsoa5.Get)("/:namespace/:componentName/:version/:staticFile*"),
+  __decorateParam(0, (0, import_tsoa5.Path)()),
+  __decorateParam(1, (0, import_tsoa5.Path)()),
+  __decorateParam(2, (0, import_tsoa5.Path)()),
+  __decorateParam(3, (0, import_tsoa5.Path)()),
+  __decorateParam(4, (0, import_tsoa5.Request)()),
+  __decorateParam(5, (0, import_tsoa5.Query)()),
+  __decorateParam(6, (0, import_tsoa5.Query)())
 ], StaticController.prototype, "getPreview", 1);
 StaticController = __decorateClass([
-  (0, import_inversify_binding_decorators4.provide)(StaticController),
-  (0, import_tsoa4.Route)("/s"),
-  __decorateParam(0, (0, import_inversify4.inject)("ManifestService")),
-  __decorateParam(1, (0, import_inversify4.inject)("ComponentSetService")),
-  __decorateParam(2, (0, import_inversify4.inject)("ComponentFunctionService"))
+  (0, import_inversify_binding_decorators5.provide)(StaticController),
+  (0, import_tsoa5.Route)("/s"),
+  __decorateParam(0, (0, import_inversify5.inject)("ManifestService")),
+  __decorateParam(1, (0, import_inversify5.inject)("ComponentSetService")),
+  __decorateParam(2, (0, import_inversify5.inject)("ComponentFunctionService"))
 ], StaticController);
 
 // src/ioc.ts
-var import_inversify5 = require("inversify");
-var import_inversify_binding_decorators5 = require("inversify-binding-decorators");
-var import_tsoa5 = require("tsoa");
-(0, import_inversify5.decorate)((0, import_inversify5.injectable)(), import_tsoa5.Controller);
+var import_inversify6 = require("inversify");
+var import_inversify_binding_decorators6 = require("inversify-binding-decorators");
+var import_tsoa6 = require("tsoa");
+(0, import_inversify6.decorate)((0, import_inversify6.injectable)(), import_tsoa6.Controller);
 var iocContainer;
-var initIocContainer = (services) => {
-  const container = new import_inversify5.Container();
-  container.load((0, import_inversify_binding_decorators5.buildProviderModule)());
-  container.bind("sandbox").toConstantValue(services.sandbox);
+var initIocContainer = (services, config) => {
+  const container = new import_inversify6.Container();
+  container.load((0, import_inversify_binding_decorators6.buildProviderModule)());
+  container.bind("Config").toConstantValue(config);
+  container.bind("Sandbox").toConstantValue(services.sandbox);
   container.bind("Logger").toConstantValue(services.logger);
   container.bind("ComponentFunctionService").toConstantValue(services.componentFunctionService);
   container.bind("ComponentRunnerService").toConstantValue(services.componentRunnerService);
@@ -1106,15 +1247,25 @@ var models = {
       "queryParameters": { "dataType": "nestedObjectLiteral", "nestedProperties": {}, "additionalProperties": { "ref": "QueryParameterValueType" } }
     },
     "additionalProperties": { "dataType": "any" }
+  },
+  // WARNING: This file was auto-generated with tsoa. Please do not modify it. Re-run tsoa to re-generate this file: https://github.com/lukeautry/tsoa
+  "ComponentManifest": {
+    "dataType": "refAlias",
+    "type": { "ref": "MANIFEST_MODELS.v1.ComponentManifest", "validators": {} }
+  },
+  // WARNING: This file was auto-generated with tsoa. Please do not modify it. Re-run tsoa to re-generate this file: https://github.com/lukeautry/tsoa
+  "ComponentSchema": {
+    "dataType": "refAlias",
+    "type": { "dataType": "nestedObjectLiteral", "nestedProperties": { "schema": { "dataType": "object", "required": true }, "name": { "dataType": "string", "required": true } }, "validators": {} }
   }
   // WARNING: This file was auto-generated with tsoa. Please do not modify it. Re-run tsoa to re-generate this file: https://github.com/lukeautry/tsoa
 };
-var validationService = new import_runtime5.ValidationService(models);
+var validationService = new import_runtime6.ValidationService(models);
 function RegisterRoutes(app) {
   app.get(
     "/schemas/:version.json",
-    ...(0, import_runtime5.fetchMiddlewares)(CoreController),
-    ...(0, import_runtime5.fetchMiddlewares)(CoreController.prototype.getSchemaVersion),
+    ...(0, import_runtime6.fetchMiddlewares)(CoreController),
+    ...(0, import_runtime6.fetchMiddlewares)(CoreController.prototype.getSchemaVersion),
     async function CoreController_getSchemaVersion(request, response, next) {
       const args = {
         version: { "in": "path", "name": "version", "required": true, "dataType": "string" }
@@ -1136,8 +1287,8 @@ function RegisterRoutes(app) {
   );
   app.get(
     "/health",
-    ...(0, import_runtime5.fetchMiddlewares)(CoreController),
-    ...(0, import_runtime5.fetchMiddlewares)(CoreController.prototype.getHealthInfo),
+    ...(0, import_runtime6.fetchMiddlewares)(CoreController),
+    ...(0, import_runtime6.fetchMiddlewares)(CoreController.prototype.getHealthInfo),
     async function CoreController_getHealthInfo(request, response, next) {
       const args = {};
       let validatedArgs = [];
@@ -1157,8 +1308,8 @@ function RegisterRoutes(app) {
   );
   app.get(
     "/",
-    ...(0, import_runtime5.fetchMiddlewares)(CoreController),
-    ...(0, import_runtime5.fetchMiddlewares)(CoreController.prototype.getComponents),
+    ...(0, import_runtime6.fetchMiddlewares)(CoreController),
+    ...(0, import_runtime6.fetchMiddlewares)(CoreController.prototype.getComponents),
     async function CoreController_getComponents(request, response, next) {
       const args = {
         req: { "in": "request", "name": "req", "required": true, "dataType": "object" }
@@ -1180,8 +1331,8 @@ function RegisterRoutes(app) {
   );
   app.get(
     "/d/:namespace/:componentName/:version/manifest.json",
-    ...(0, import_runtime5.fetchMiddlewares)(DefinitionController),
-    ...(0, import_runtime5.fetchMiddlewares)(DefinitionController.prototype.getComponentVersionManifest),
+    ...(0, import_runtime6.fetchMiddlewares)(DefinitionController),
+    ...(0, import_runtime6.fetchMiddlewares)(DefinitionController.prototype.getComponentVersionManifest),
     async function DefinitionController_getComponentVersionManifest(request, response, next) {
       const args = {
         namespace: { "in": "path", "name": "namespace", "required": true, "dataType": "string" },
@@ -1208,8 +1359,8 @@ function RegisterRoutes(app) {
   );
   app.get(
     "/d/:namespace/:componentName/:version",
-    ...(0, import_runtime5.fetchMiddlewares)(DefinitionController),
-    ...(0, import_runtime5.fetchMiddlewares)(DefinitionController.prototype.getDefaultFunctionDefinition),
+    ...(0, import_runtime6.fetchMiddlewares)(DefinitionController),
+    ...(0, import_runtime6.fetchMiddlewares)(DefinitionController.prototype.getDefaultFunctionDefinition),
     async function DefinitionController_getDefaultFunctionDefinition(request, response, next) {
       const args = {
         namespace: { "in": "path", "name": "namespace", "required": true, "dataType": "string" },
@@ -1236,8 +1387,8 @@ function RegisterRoutes(app) {
   );
   app.get(
     "/d/:namespace/:componentName/:version/:functionName",
-    ...(0, import_runtime5.fetchMiddlewares)(DefinitionController),
-    ...(0, import_runtime5.fetchMiddlewares)(DefinitionController.prototype.getGivenFunctionDefinition),
+    ...(0, import_runtime6.fetchMiddlewares)(DefinitionController),
+    ...(0, import_runtime6.fetchMiddlewares)(DefinitionController.prototype.getGivenFunctionDefinition),
     async function DefinitionController_getGivenFunctionDefinition(request, response, next) {
       const args = {
         namespace: { "in": "path", "name": "namespace", "required": true, "dataType": "string" },
@@ -1263,10 +1414,81 @@ function RegisterRoutes(app) {
       }
     }
   );
+  app.get(
+    "/dev/all",
+    ...(0, import_runtime6.fetchMiddlewares)(DevelopmentController),
+    ...(0, import_runtime6.fetchMiddlewares)(DevelopmentController.prototype.getComponents),
+    async function DevelopmentController_getComponents(request, response, next) {
+      const args = {};
+      let validatedArgs = [];
+      try {
+        validatedArgs = getValidatedArgs(args, request, response);
+        const container = typeof iocContainer === "function" ? iocContainer(request) : iocContainer;
+        const controller = await container.get(DevelopmentController);
+        if (typeof controller["setStatus"] === "function") {
+          controller.setStatus(void 0);
+        }
+        const promise = controller.getComponents.apply(controller, validatedArgs);
+        promiseHandler(controller, promise, response, void 0, next);
+      } catch (err) {
+        return next(err);
+      }
+    }
+  );
+  app.get(
+    "/dev/manifest/:namespace/:componentName/:version",
+    ...(0, import_runtime6.fetchMiddlewares)(DevelopmentController),
+    ...(0, import_runtime6.fetchMiddlewares)(DevelopmentController.prototype.Manifest),
+    async function DevelopmentController_Manifest(request, response, next) {
+      const args = {
+        namespace: { "in": "path", "name": "namespace", "required": true, "dataType": "string" },
+        componentName: { "in": "path", "name": "componentName", "required": true, "dataType": "string" },
+        version: { "in": "path", "name": "version", "required": true, "dataType": "string" }
+      };
+      let validatedArgs = [];
+      try {
+        validatedArgs = getValidatedArgs(args, request, response);
+        const container = typeof iocContainer === "function" ? iocContainer(request) : iocContainer;
+        const controller = await container.get(DevelopmentController);
+        if (typeof controller["setStatus"] === "function") {
+          controller.setStatus(void 0);
+        }
+        const promise = controller.Manifest.apply(controller, validatedArgs);
+        promiseHandler(controller, promise, response, void 0, next);
+      } catch (err) {
+        return next(err);
+      }
+    }
+  );
+  app.get(
+    "/dev/schemas/:namespace/:componentName/:version",
+    ...(0, import_runtime6.fetchMiddlewares)(DevelopmentController),
+    ...(0, import_runtime6.fetchMiddlewares)(DevelopmentController.prototype.getContentSchema),
+    async function DevelopmentController_getContentSchema(request, response, next) {
+      const args = {
+        namespace: { "in": "path", "name": "namespace", "required": true, "dataType": "string" },
+        componentName: { "in": "path", "name": "componentName", "required": true, "dataType": "string" },
+        version: { "in": "path", "name": "version", "required": true, "dataType": "string" }
+      };
+      let validatedArgs = [];
+      try {
+        validatedArgs = getValidatedArgs(args, request, response);
+        const container = typeof iocContainer === "function" ? iocContainer(request) : iocContainer;
+        const controller = await container.get(DevelopmentController);
+        if (typeof controller["setStatus"] === "function") {
+          controller.setStatus(void 0);
+        }
+        const promise = controller.getContentSchema.apply(controller, validatedArgs);
+        promiseHandler(controller, promise, response, void 0, next);
+      } catch (err) {
+        return next(err);
+      }
+    }
+  );
   app.get(
     "/r/:namespace/:componentName/:version",
-    ...(0, import_runtime5.fetchMiddlewares)(RenderController),
-    ...(0, import_runtime5.fetchMiddlewares)(RenderController.prototype.getDefaultFunctionRendering),
+    ...(0, import_runtime6.fetchMiddlewares)(RenderController),
+    ...(0, import_runtime6.fetchMiddlewares)(RenderController.prototype.getDefaultFunctionRendering),
     async function RenderController_getDefaultFunctionRendering(request, response, next) {
       const args = {
         expressRequest: { "in": "request", "name": "expressRequest", "required": true, "dataType": "object" },
@@ -1294,8 +1516,8 @@ function RegisterRoutes(app) {
   );
   app.get(
     "/r/:namespace/:componentName/:version/:functionName",
-    ...(0, import_runtime5.fetchMiddlewares)(RenderController),
-    ...(0, import_runtime5.fetchMiddlewares)(RenderController.prototype.getGivenFunctionRendering),
+    ...(0, import_runtime6.fetchMiddlewares)(RenderController),
+    ...(0, import_runtime6.fetchMiddlewares)(RenderController.prototype.getGivenFunctionRendering),
     async function RenderController_getGivenFunctionRendering(request, response, next) {
       const args = {
         expressRequest: { "in": "request", "name": "expressRequest", "required": true, "dataType": "object" },
@@ -1324,8 +1546,8 @@ function RegisterRoutes(app) {
   );
   app.get(
     "/s/:namespace/:componentName/:version/:staticFile*",
-    ...(0, import_runtime5.fetchMiddlewares)(StaticController),
-    ...(0, import_runtime5.fetchMiddlewares)(StaticController.prototype.getPreview),
+    ...(0, import_runtime6.fetchMiddlewares)(StaticController),
+    ...(0, import_runtime6.fetchMiddlewares)(StaticController.prototype.getPreview),
     async function StaticController_getPreview(request, response, next) {
       const args = {
         namespace: { "in": "path", "name": "namespace", "required": true, "dataType": "string" },
@@ -1419,7 +1641,7 @@ function RegisterRoutes(app) {
       }
     });
     if (Object.keys(fieldErrors).length > 0) {
-      throw new import_runtime5.ValidateError(fieldErrors, "");
+      throw new import_runtime6.ValidateError(fieldErrors, "");
     }
     return values;
   }
@@ -1428,8 +1650,8 @@ function RegisterRoutes(app) {
 // src/webserver/app.ts
 var import_path2 = __toESM(require("path"));
 var import_swagger_ui_express = __toESM(require("swagger-ui-express"));
-function setupApp(services) {
-  initIocContainer(services);
+function setupApp(services, config = {}) {
+  initIocContainer(services, config);
   const app = (0, import_express.default)();
   app.request.services = services;
   app.options("*", (0, import_cors.default)({ credentials: true }));
@@ -1466,6 +1688,11 @@ function setupApp(services) {
     next();
   });
   app.use((req, res, next) => {
+    req.accepts("json");
+    if (["POST", "PUT", "PATCH"].includes(req.method) && req.header("content-type") !== "application/json") {
+      next(new import_dx_common_lib6.BadRequestError("content-type must be application/json"));
+      return;
+    }
     const id = (0, import_crypto.randomUUID)();
     req.log = services.logger.child({ req_id: id, area: "application", path: req.path });
     req.id = id;
@@ -1484,7 +1711,7 @@ function setupApp(services) {
     })
   );
   RegisterRoutes(app);
-  app.use(import_dx_common_lib5.errorMiddleware);
+  app.use(import_dx_common_lib6.errorMiddleware);
   return app;
 }
 
@@ -1495,7 +1722,7 @@ var import_component_lib3 = require("@squiz/component-lib");
 var import_path3 = __toESM(require("path"));
 var import_api2 = require("@opentelemetry/api");
 var import_component_lib2 = require("@squiz/component-lib");
-var import_dx_common_lib6 = require("@squiz/dx-common-lib");
+var import_dx_common_lib7 = require("@squiz/dx-common-lib");
 
 // src/component-runner/ExecuteComponentTask.ts
 var isJobTask = (task) => {
@@ -1565,29 +1792,7 @@ var ComponentRunnerServiceWithWorkers = class {
           });
           return result;
         } catch (e) {
-          if (e instanceof import_dx_common_lib6.TimeoutError) {
-            const message = `function ${task.componentFunction.name} of component ${task.componentFullName} ${task.manifest.version} ` + WORKER_TIMEOUT_ERROR_MESSAGE;
-            await this.componentLogger.error(message, task.requestId).catch((err) => this.logger.error(err));
-            throw new import_component_lib2.ComponentError(
-              task.requestId,
-              new Error(message),
-              task.componentFunction.name,
-              task.componentFullName,
-              task.manifest.version,
-              task.runtimeSet.webPath
-            );
-          } else {
-            const componentError = new import_component_lib2.ComponentError(
-              task.requestId,
-              e,
-              task.componentFunction.name,
-              task.componentFullName,
-              task.manifest.version,
-              task.runtimeSet.webPath
-            );
-            await this.componentLogger.error(componentError.message, task.requestId).catch((err) => this.logger.error(err));
-            throw componentError;
-          }
+          return await this.handleComponentExecutionError(e, task);
         } finally {
           await this.componentLogger.flush().catch((err) => this.logger.error(err));
           span.end();
@@ -1600,7 +1805,7 @@ var ComponentRunnerServiceWithWorkers = class {
       const result = await this.sandbox.execute(task);
       return result;
     } catch (e) {
-      if (e instanceof import_dx_common_lib6.TimeoutError) {
+      if (e instanceof import_dx_common_lib7.TimeoutError) {
         const message = `function ${task.jobFunction.name} of job ${task.jobFullName} ${task.manifest.version} ` + WORKER_TIMEOUT_ERROR_MESSAGE;
         await this.componentLogger.error(message, task.requestId).catch((err) => this.logger.error(err));
         throw new import_component_lib2.JobError(task.requestId, e, task.jobFunction.name, task.jobFullName, task.manifest.version);
@@ -1625,6 +1830,24 @@ var ComponentRunnerServiceWithWorkers = class {
   async healthCheck() {
     return this.sandbox.health();
   }
+  async handleComponentExecutionError(e, task) {
+    const componentError = new import_component_lib2.ComponentError(
+      task.requestId,
+      e,
+      task.componentFunction.name,
+      task.componentFullName,
+      task.manifest.version,
+      task.runtimeSet.webPath
+    );
+    if (e instanceof import_dx_common_lib7.TimeoutError) {
+      componentError.message = this.constructTimeoutErrorMessage(e, task);
+    }
+    await this.componentLogger.error(componentError.message, task.requestId).catch((err) => this.logger.error(err));
+    throw componentError;
+  }
+  constructTimeoutErrorMessage(e, task) {
+    return `function ${task.componentFunction.name} of component ${task.componentFullName} ${task.manifest.version} ` + WORKER_TIMEOUT_ERROR_MESSAGE;
+  }
 };
 
 // src/PreviewComponentService.ts
@@ -1693,7 +1916,7 @@ function cssIncludeTagHtml(file) {
 }
 
 // src/PreviewComponentService.ts
-var import_dx_common_lib7 = require("@squiz/dx-common-lib");
+var import_dx_common_lib8 = require("@squiz/dx-common-lib");
 var PREVIEW_COMPONENT_SET = "unknown";
 var ComponentPreviewService = class {
   async dressRenderedOutputForPreview(componentManifest, functionDefinition, previewKey, componentOutput) {
@@ -1713,7 +1936,7 @@ var ComponentPreviewService = class {
   async embedComponentIntoWrapper(componentDirectory, wrapper, functionDefinition, componentOutput) {
     const wrapperFilePath = import_path4.default.resolve(componentDirectory, wrapper.path);
     if (await (0, import_fs_extra.pathExists)(wrapperFilePath) === false) {
-      throw new import_dx_common_lib7.BadRequestError(`Preview wrapper file "${wrapper.path}" does not exist`);
+      throw new import_dx_common_lib8.BadRequestError(`Preview wrapper file "${wrapper.path}" does not exist`);
     }
     const wrapperContent = await import_promises.default.readFile(wrapperFilePath, {
       encoding: "utf-8"
@@ -1729,17 +1952,17 @@ var ComponentPreviewService = class {
       case "json":
         return componentOutput;
       default:
-        return (0, import_dx_common_lib7.never)(type);
+        return (0, import_dx_common_lib8.never)(type);
     }
   }
 };
 
 // src/test/helpers/stack.ts
-var import_dx_common_lib9 = require("@squiz/dx-common-lib");
+var import_dx_common_lib10 = require("@squiz/dx-common-lib");
 
 // src/RenderInputService.ts
 var import_strict = __toESM(require("assert/strict"));
-var import_dx_common_lib8 = require("@squiz/dx-common-lib");
+var import_dx_common_lib9 = require("@squiz/dx-common-lib");
 var import_formatted_text_lib = require("@squiz/formatted-text-lib");
 var import_dx_json_schema_lib2 = require("@squiz/dx-json-schema-lib");
 var import_api3 = require("@opentelemetry/api");
@@ -1786,7 +2009,7 @@ var RenderInputService = class {
             case "preview":
               return this.getPreviewRenderInput(request, manifest);
             default:
-              return (0, import_dx_common_lib8.never)(renderType);
+              return (0, import_dx_common_lib9.never)(renderType);
           }
         } finally {
           span.end();
@@ -1797,10 +2020,10 @@ var RenderInputService = class {
   getRenderType(request) {
     if (request.previewKey) {
       if (request.contentItemId) {
-        throw new import_dx_common_lib8.BadRequestError("You cannot provide a previewKey and a ContentId as input");
+        throw new import_dx_common_lib9.BadRequestError("You cannot provide a previewKey and a ContentId as input");
       }
       if (request.componentSet) {
-        throw new import_dx_common_lib8.BadRequestError("You cannot provide a previewKey and a componentSet as input");
+        throw new import_dx_common_lib9.BadRequestError("You cannot provide a previewKey and a componentSet as input");
       }
       return "preview";
     }
@@ -1810,7 +2033,7 @@ var RenderInputService = class {
       }
       return "set-without-content-item";
     }
-    throw new import_dx_common_lib8.BadRequestError("invalid input, you must provide either a previewKey or a component set");
+    throw new import_dx_common_lib9.BadRequestError("invalid input, you must provide either a previewKey or a component set");
   }
   async getContentItemAndSetInput(request, manifest) {
     await this.assertComponentVersionInSet(request, manifest);
@@ -1932,13 +2155,13 @@ var RenderInputService = class {
     const queryParameters = {};
     for (const parameter of Object.keys(componentFunction.queryParameters)) {
       if (componentFunction.queryParameters[parameter].required && request.expressRequest.query[parameter] === void 0) {
-        throw new import_dx_common_lib8.BadRequestError(`Required query parameter '${parameter}' is missing`);
+        throw new import_dx_common_lib9.BadRequestError(`Required query parameter '${parameter}' is missing`);
       }
       if (request.expressRequest.query[parameter] === void 0) {
         continue;
       }
       if (typeof request.expressRequest.query[parameter] !== "string") {
-        throw new import_dx_common_lib8.BadRequestError(`Value for query parameter '${parameter}' must be a string`);
+        throw new import_dx_common_lib9.BadRequestError(`Value for query parameter '${parameter}' must be a string`);
       }
       queryParameters[parameter] = request.expressRequest.query[parameter];
     }
@@ -1957,7 +2180,7 @@ var RenderInputService = class {
       this.componentFunctionService.assertInputValidForComponentFunction(input, componentFunction);
     } catch (e) {
       if (e instanceof Error) {
-        const error = new import_dx_common_lib8.BadRequestError(e.message);
+        const error = new import_dx_common_lib9.BadRequestError(e.message);
         error.stack = e.stack;
         throw error;
       }
@@ -1969,7 +2192,7 @@ var RenderInputService = class {
       this.componentFunctionService.assertRenderInputValidForComponentFunction(input, componentFunction);
     } catch (e) {
       if (e instanceof Error) {
-        const error = new import_dx_common_lib8.BadRequestError(e.message);
+        const error = new import_dx_common_lib9.BadRequestError(e.message);
         error.stack = e.stack;
         throw error;
       }
@@ -1981,7 +2204,7 @@ var RenderInputService = class {
     const set = await this.componentSetService.getComponentSet(request.componentSet);
     const isCompVersionInSet = await this.componentSetService.componentVersionInSet(manifest, set.webPath);
     if (!isCompVersionInSet) {
-      throw new import_dx_common_lib8.ResourceNotFoundError(`${request.componentName} ${request.version} not in set ${set.webPath}`);
+      throw new import_dx_common_lib9.ResourceNotFoundError(`${request.componentName} ${request.version} not in set ${set.webPath}`);
     }
   }
   async getInputForPreview(request, manifest) {
@@ -2010,14 +2233,14 @@ var RenderInputService = class {
   }
   async getContentFromContentService(request) {
     if (!this.contentItemService) {
-      throw new import_dx_common_lib8.InternalServerError("Content Item service is not configured");
+      throw new import_dx_common_lib9.InternalServerError("Content Item service is not configured");
     }
     if (!request.contentItemId) {
-      throw new import_dx_common_lib8.InternalServerError("Content Item id must be defined");
+      throw new import_dx_common_lib9.InternalServerError("Content Item id must be defined");
     }
     const contentInput = await this.contentItemService.getContentItem(request.contentItemId, this.getDxpApiKey());
     if (!contentInput) {
-      throw new import_dx_common_lib8.ResourceNotFoundError(`Cannot find content item with ID '${request.contentItemId}'`);
+      throw new import_dx_common_lib9.ResourceNotFoundError(`Cannot find content item with ID '${request.contentItemId}'`);
     }
     return contentInput;
   }
@@ -2057,10 +2280,10 @@ function getTestComponentFolder() {
   const rootDir = (0, import_child_process.execSync)("git rev-parse --show-toplevel", { encoding: "utf-8" }).replace(/\n$/, "");
   return import_path5.default.resolve(rootDir, "test-components");
 }
-function setupTestApp(services = {}) {
+function setupTestApp(services = {}, config = {}) {
   const dataMount = getTestComponentFolder();
   const componentRootUrlResolver = () => "http://localhost:3000";
-  const apiKeyService = new import_dx_common_lib9.DevelopmentApiKeyService();
+  const apiKeyService = new import_dx_common_lib10.DevelopmentApiKeyService();
   const sandbox = services.sandbox || createTestSandbox();
   const componentRunnerService = new ComponentRunnerServiceWithWorkers(sandbox, testLogger, testComponentLogger);
   const componentFunctionService = new import_component_lib3.ComponentFunctionService();
@@ -2075,20 +2298,23 @@ function setupTestApp(services = {}) {
     contentItemService,
     componentRootUrlResolver
   );
-  const app = setupApp({
-    componentFunctionService,
-    componentSetService,
-    manifestService,
-    componentRunnerService,
-    contentItemService,
-    renderInputService,
-    logger: testLogger,
-    apiKeyService,
-    componentPreviewService: new ComponentPreviewService(),
-    sandbox,
-    componentRootUrlResolver,
-    ...services
-  });
+  const app = setupApp(
+    {
+      componentFunctionService,
+      componentSetService,
+      manifestService,
+      componentRunnerService,
+      contentItemService,
+      renderInputService,
+      logger: testLogger,
+      apiKeyService,
+      componentPreviewService: new ComponentPreviewService(),
+      sandbox,
+      componentRootUrlResolver,
+      ...services
+    },
+    config
+  );
   return { server: import_http.default.createServer(app), app };
 }
 function getTestWebServer(services = {}) {
@@ -2104,8 +2330,8 @@ function getTestWebServer(services = {}) {
   return agent;
 }
 var TestServer = class {
-  constructor(services = {}) {
-    const { server, app } = setupTestApp(services);
+  constructor(services = {}, config = {}) {
+    const { server, app } = setupTestApp(services, config);
     this.server = server;
     this.server.on("close", async () => {
       for (const service of Object.values(app.request.services)) {
@@ -3313,6 +3539,116 @@ function definitionRouteTests(request, _rootUrl = "http://localhost:3000") {
   });
 }
 
+// src/webserver/controllers/test/development-route-tests.ts
+function developmentRouteTests(request, devModeEnabled) {
+  describe(`development routes`, () => {
+    if (devModeEnabled) {
+      describe("all route (dev mode enabled)", () => {
+        it("should return an array of all component manifests", async () => {
+          const response = await request().get("/dev/all");
+          expect(response.statusCode).toEqual(200);
+          expect(response.type).toEqual("application/json");
+          expect(response.body).toEqual(
+            expect.arrayContaining([
+              expect.objectContaining({
+                $schema: "http://localhost:3000/schemas/v1.json#",
+                name: "test-preview-component",
+                version: "1.0.1",
+                mainFunction: "main",
+                displayName: "some-display-name",
+                namespace: "unit-test-components",
+                description: "some-description",
+                functions: expect.any(Array),
+                staticFiles: expect.any(Object),
+                previews: expect.any(Object)
+              })
+            ])
+          );
+        });
+      });
+      describe("manifest route (dev mode enabled)", () => {
+        it("should return the manifest of the requested component", async () => {
+          const response = await request().get("/dev/manifest/unit-test-components/test-preview-component/1.0.1");
+          expect(response.statusCode).toEqual(200);
+          expect(response.type).toEqual("application/json");
+          expect(response.body).toEqual(
+            expect.objectContaining({
+              $schema: "http://localhost:3000/schemas/v1.json#",
+              name: "test-preview-component",
+              version: "1.0.1",
+              mainFunction: "main",
+              displayName: "some-display-name",
+              namespace: "unit-test-components",
+              description: "some-description",
+              functions: expect.any(Array),
+              staticFiles: expect.any(Object),
+              previews: expect.any(Object)
+            })
+          );
+        });
+      });
+      describe("schemas route (dev mode enabled)", () => {
+        it("should return the schemas of the requested component", async () => {
+          const response = await request().get("/dev/schemas/unit-test-components/test-preview-component/1.0.1");
+          expect(response.statusCode).toEqual(200);
+          expect(response.type).toEqual("application/json");
+          expect(response.body).toEqual([
+            {
+              name: "main",
+              schema: {
+                type: "object",
+                properties: {
+                  something: {
+                    type: "string"
+                  }
+                },
+                required: []
+              }
+            },
+            {
+              name: "promise-func",
+              schema: {
+                type: "object",
+                properties: {
+                  something: {
+                    type: "string"
+                  }
+                },
+                required: ["something"]
+              }
+            }
+          ]);
+        });
+      });
+    } else {
+      describe("all route (dev mode disabled)", () => {
+        it("all return a 404 error", async () => {
+          const response = await request().get("/dev/all");
+          expect(response.statusCode).toEqual(404);
+          expect(response.type).toEqual("application/json");
+          expect(response.body).toEqual({ message: "Route does not exist." });
+        });
+      });
+      describe("manifest route (dev mode disabled)", () => {
+        it("should return a 404 error", async () => {
+          const response = await request().get("/dev/manifest/unit-test-components/test-preview-component/1.0.1");
+          expect(response.statusCode).toEqual(404);
+          expect(response.type).toEqual("application/json");
+          expect(response.body).toEqual({ message: "Route does not exist." });
+        });
+      });
+      describe("schemas route (dev mode disabled)", () => {
+        it("should return a 404 error", async () => {
+          const response = await request().get("/dev/schemas/unit-test-components/test-preview-component/1.0.1");
+          expect(response.statusCode).toEqual(404);
+          expect(response.type).toEqual("application/json");
+          expect(response.body).toEqual({ message: "Route does not exist." });
+        });
+      });
+    }
+  });
+}
+
 // src/webserver/controllers/test/static-route-tests.ts
 function staticRouteTests(request) {
   describe("GET /s/set/unit-test-components/test-static-files/1.0.0/", () => {
@@ -3431,6 +3767,9 @@ function staticRouteTests(request) {
 
 // src/webserver/controllers/test/render-route-tests.ts
 var import_os2 = __toESM(require("os"));
+function wrapMessageInHtmlComment(message) {
+  return `<!-- ${message} -->`;
+}
 function renderRouteTests(request, rootUrl) {
   describe("GET /r/unit-test-components/test-component/1.0.10/?_componentSet=set", () => {
     it("should render the test component with html endpoint", async () => {
@@ -3500,12 +3839,12 @@ function renderRouteTests(request, rootUrl) {
         "/r/unit-test-components/test-component/1.0.4/render-json-invalid?_componentSet=set"
       );
       expect(response.statusCode).toEqual(500);
-      expect(response.headers["content-type"]).toContain("application/json");
-      expect(response.body).toMatchInlineSnapshot(`
-        {
-          "message": "failed validation: Expected \`3\` (string) in \`#/my-array/0/a-number\` to be of type \`number\`",
-        }
-      `);
+      expect(response.headers["content-type"]).toContain("text/html; charset=utf-8");
+      expect(response.text).toEqual(
+        wrapMessageInHtmlComment(
+          "failed validation: Expected `3` (string) in `#/my-array/0/a-number` to be of type `number`"
+        )
+      );
     }, 2e4);
     it("should validate a complex json against a schema", async () => {
       const response = await request().get(
@@ -3528,13 +3867,13 @@ function renderRouteTests(request, rootUrl) {
         "/r/unit-test-components/test-component/1.0.4/render-json-nested-object-invalid?_componentSet=set"
       );
       expect(response.statusCode).toEqual(500);
-      expect(response.headers["content-type"]).toContain("application/json");
-      expect(response.body).toMatchInlineSnapshot(`
-        {
-          "message": "failed validation: Expected \`false\` (string) in \`#/my-object/a-boolean\` to be of type \`boolean\`,
-        Expected given value \`N\` in #/my-object/a-nested-object/an-enum\` to be one of \`[Y, E, S]\`",
-        }
-      `);
+      expect(response.headers["content-type"]).toContain("text/html; charset=utf-8");
+      expect(response.text).toEqual(
+        wrapMessageInHtmlComment(
+          `failed validation: Expected \`false\` (string) in \`#/my-object/a-boolean\` to be of type \`boolean\`,
+Expected given value \`N\` in #/my-object/a-nested-object/an-enum\` to be one of \`[Y, E, S]\``
+        )
+      );
     }, 2e4);
   });
   describe("GET /r/unit-test-components/test-component/1.0.7?_componentSet=set", () => {
@@ -3636,26 +3975,24 @@ function renderRouteTests(request, rootUrl) {
     it("should throw an error if trying to use modules in the js", async () => {
       const response = await request().get("/r/unit-test-components/test-component/1.0.8/module-js?_componentSet=set");
       expect(response.statusCode).toEqual(500);
-      expect(response.headers["content-type"]).toContain("application/json");
-      expect(response.body).toEqual({ message: "ESM style modules are not supported." });
+      expect(response.headers["content-type"]).toContain("text/html; charset=utf-8");
+      expect(response.text).toEqual(wrapMessageInHtmlComment("ESM style modules are not supported."));
     });
     it("should throw an error if the component uploaded does not export a function", async () => {
       const response = await request().get(
         "/r/unit-test-components/test-component/1.0.8/no-module-export?_componentSet=set"
       );
       expect(response.statusCode).toEqual(500);
-      expect(response.headers["content-type"]).toContain("application/json");
-      expect(response.body).toEqual({ message: "script is not a function" });
+      expect(response.headers["content-type"]).toContain("text/html; charset=utf-8");
+      expect(response.text).toEqual(wrapMessageInHtmlComment("script is not a function"));
     });
     it("should throw an error if the component is not async and throws and error object", async () => {
       const response = await request().get(
         "/r/unit-test-components/test-component/1.0.8/no-promise-throws-error?_componentSet=set"
       );
       expect(response.statusCode).toEqual(500);
-      expect(response.headers["content-type"]).toContain("application/json");
-      expect(response.body).toEqual({
-        message: "throw error"
-      });
+      expect(response.headers["content-type"]).toContain("text/html; charset=utf-8");
+      expect(response.text).toEqual(wrapMessageInHtmlComment("throw error"));
     });
     it("throw an error if the component is not async and throws an arbitrary value", async () => {
       const response = await request().get(
@@ -3663,10 +4000,10 @@ function renderRouteTests(request, rootUrl) {
       );
       expect(response.statusCode).toEqual(500);
       expect(response.headers["cache-control"]).toEqual("no-cache, no-store, max-age=0");
-      expect(response.headers["content-type"]).toContain("application/json");
-      expect(response.body).toEqual({
-        message: "An error occurred with no additional information available"
-      });
+      expect(response.headers["content-type"]).toContain("text/html; charset=utf-8");
+      expect(response.text).toEqual(
+        wrapMessageInHtmlComment("An error occurred with no additional information available")
+      );
     });
     it("throw an error if the component is not async and throws undefined", async () => {
       const response = await request().get(
@@ -3674,10 +4011,10 @@ function renderRouteTests(request, rootUrl) {
       );
       expect(response.statusCode).toEqual(500);
       expect(response.headers["cache-control"]).toEqual("no-cache, no-store, max-age=0");
-      expect(response.headers["content-type"]).toContain("application/json");
-      expect(response.body).toEqual({
-        message: "An error occurred with no additional information available"
-      });
+      expect(response.headers["content-type"]).toContain("text/html; charset=utf-8");
+      expect(response.text).toEqual(
+        wrapMessageInHtmlComment("An error occurred with no additional information available")
+      );
     });
     it("should throw an error if the component is async/returns a promise but rejects", async () => {
       const response = await request().get(
@@ -3685,10 +4022,10 @@ function renderRouteTests(request, rootUrl) {
       );
       expect(response.statusCode).toEqual(500);
       expect(response.headers["cache-control"]).toEqual("no-cache, no-store, max-age=0");
-      expect(response.headers["content-type"]).toContain("application/json");
-      expect(response.body).toEqual({
-        message: "An error occurred with no additional information available"
-      });
+      expect(response.headers["content-type"]).toContain("text/html; charset=utf-8");
+      expect(response.text).toEqual(
+        wrapMessageInHtmlComment("An error occurred with no additional information available")
+      );
     });
     it("should throw an error if the component is async/returns a promise and throws and error object", async () => {
       const response = await request().get(
@@ -3696,10 +4033,8 @@ function renderRouteTests(request, rootUrl) {
       );
       expect(response.statusCode).toEqual(500);
       expect(response.headers["cache-control"]).toEqual("no-cache, no-store, max-age=0");
-      expect(response.headers["content-type"]).toContain("application/json");
-      expect(response.body).toEqual({
-        message: "throws error"
-      });
+      expect(response.headers["content-type"]).toContain("text/html; charset=utf-8");
+      expect(response.text).toEqual(wrapMessageInHtmlComment("throws error"));
     });
     it("throw an error if the component is async/returns a promise and throws an arbitrary value", async () => {
       const response = await request().get(
@@ -3707,10 +4042,10 @@ function renderRouteTests(request, rootUrl) {
       );
       expect(response.statusCode).toEqual(500);
       expect(response.headers["cache-control"]).toEqual("no-cache, no-store, max-age=0");
-      expect(response.headers["content-type"]).toContain("application/json");
-      expect(response.body).toEqual({
-        message: "An error occurred with no additional information available"
-      });
+      expect(response.headers["content-type"]).toContain("text/html; charset=utf-8");
+      expect(response.text).toEqual(
+        wrapMessageInHtmlComment("An error occurred with no additional information available")
+      );
     });
     it("throw an error if the component is async/returns a promise and throws undefined", async () => {
       const response = await request().get(
@@ -3718,20 +4053,18 @@ function renderRouteTests(request, rootUrl) {
       );
       expect(response.statusCode).toEqual(500);
       expect(response.headers["cache-control"]).toEqual("no-cache, no-store, max-age=0");
-      expect(response.headers["content-type"]).toContain("application/json");
-      expect(response.body).toEqual({
-        message: "An error occurred with no additional information available"
-      });
+      expect(response.headers["content-type"]).toContain("text/html; charset=utf-8");
+      expect(response.text).toEqual(
+        wrapMessageInHtmlComment("An error occurred with no additional information available")
+      );
     });
     it("throw an error if the component has a syntax error", async () => {
       const response = await request().get(
         "/r/unit-test-components/test-component/1.0.8/syntax-error?_componentSet=set"
       );
       expect(response.statusCode).toEqual(500);
-      expect(response.headers["content-type"]).toContain("application/json");
-      expect(response.body).toEqual({
-        message: "Unexpected token '}'"
-      });
+      expect(response.headers["content-type"]).toContain("text/html; charset=utf-8");
+      expect(response.text).toEqual(wrapMessageInHtmlComment("Unexpected token '}'"));
     });
   });
   describe("GET /r/unit-test-components/test-static-files/1.0.0?_componentSet=set", () => {
@@ -3869,6 +4202,9 @@ function renderRouteTests(request, rootUrl) {
 }
 
 // src/webserver/controllers/test/render-route-sandbox-tests.ts
+function wrapMessageInHtmlComment2(message) {
+  return `<!-- ${message} -->`;
+}
 function renderRouteSandboxTests(request) {
   describe("GET /r/unit-test-components/test-malicious-code/...", () => {
     it("should timeout infinite running code", async () => {
@@ -3876,40 +4212,47 @@ function renderRouteSandboxTests(request) {
         "/r/unit-test-components/test-malicious-code/1.0.0/?_componentSet=set&something=hello"
       );
       expect(response.statusCode).toEqual(500);
-      expect(response.headers["content-type"]).toContain("application/json");
-      expect(response.body).toEqual({
-        message: "function while-true of component unit-test-components/test-malicious-code 1.0.0 could not complete with in the allotted time"
-      });
+      expect(response.headers["content-type"]).toContain("text/html; charset=utf-8");
+      expect(response.text).toEqual(
+        wrapMessageInHtmlComment2(
+          "function while-true of component unit-test-components/test-malicious-code 1.0.0 could not complete with in the allotted time"
+        )
+      );
     }, 3e4);
     it("should timeout non terminating code", async () => {
       const response = await request().get(
         "/r/unit-test-components/test-malicious-code/1.3.0/executing-after-return?_componentSet=set"
       );
       expect(response.statusCode).toEqual(500);
-      expect(response.headers["content-type"]).toContain("application/json");
-      expect(response.body).toEqual({
-        message: "function executing-after-return of component unit-test-components/test-malicious-code 1.3.0 could not complete with in the allotted time"
-      });
+      expect(response.headers["content-type"]).toContain("text/html; charset=utf-8");
+      expect(response.text).toEqual(
+        wrapMessageInHtmlComment2(
+          "function executing-after-return of component unit-test-components/test-malicious-code 1.3.0 could not complete with in the allotted time"
+        )
+      );
     }, 3e4);
     it.skip("should not allow starting your own services", async () => {
       const response = await request().get(
         "/r/unit-test-components/test-malicious-code/1.3.0/reverse-shell?_componentSet=set"
       );
+      expect(response.text).toEqual(
+        wrapMessageInHtmlComment2(
+          "function executing-after-return of component unit-test-components/test-malicious-code 1.3.0 could not complete with in the allotted time"
+        )
+      );
       expect(response.statusCode).toEqual(500);
-      expect(response.headers["content-type"]).toContain("application/json");
-      expect(response.body).toEqual({
-        message: "function executing-after-return of component unit-test-components/test-malicious-code 1.3.0 could not complete with in the allotted time"
-      });
+      expect(response.headers["content-type"]).toContain("text/html; charset=utf-8");
     }, 1e4);
     it.skip("should deny access to fs", async () => {
       const response = await request().get(
         "/r/unit-test-components/test-malicious-code/1.1.0/?_componentSet=set&something=hello"
       );
       expect(response.statusCode).toEqual(500);
-      expect(response.headers["content-type"]).toContain("application/json");
+      expect(response.headers["content-type"]).toContain("text/html; charset=utf-8");
       expect(response.body).toEqual({
         message: "Cannot find module 'fs'"
       });
+      expect(response.text).toEqual(wrapMessageInHtmlComment2(`"Cannot find module 'fs'`));
     });
     it("should allow access to a subset of node provided modules", async () => {
       const response = await request().get(
@@ -3993,100 +4336,92 @@ function renderRouteSandboxTests(request) {
         "/r/unit-test-components/test-malicious-code/1.2.0/process-exit?_componentSet=set"
       );
       expect(response.statusCode).toEqual(500);
-      expect(response.headers["content-type"]).toContain("application/json");
-      expect(response.body).toEqual({
-        message: "process.exit is not a function"
-      });
+      expect(response.headers["content-type"]).toContain("text/html; charset=utf-8");
+      expect(response.text).toEqual(wrapMessageInHtmlComment2("process.exit is not a function"));
     });
     it("should not allow process.binding calls", async () => {
       const response = await request().get(
         "/r/unit-test-components/test-malicious-code/1.2.0/process-binding?_componentSet=set"
       );
       expect(response.statusCode).toEqual(500);
-      expect(response.headers["content-type"]).toContain("application/json");
-      expect(response.body).toEqual({
-        message: "Cannot read properties of undefined (reading 'process')"
-      });
+      expect(response.headers["content-type"]).toContain("text/html; charset=utf-8");
+      expect(response.text).toEqual(
+        wrapMessageInHtmlComment2("Cannot read properties of undefined (reading 'process')")
+      );
     });
     it("should not allow process.kill calls", async () => {
       const response = await request().get(
         "/r/unit-test-components/test-malicious-code/1.2.0/process-kill?_componentSet=set"
       );
       expect(response.statusCode).toEqual(500);
-      expect(response.headers["content-type"]).toContain("application/json");
-      expect(response.body).toEqual({
-        message: "process.kill is not a function"
-      });
+      expect(response.headers["content-type"]).toContain("text/html; charset=utf-8");
+      expect(response.text).toEqual(wrapMessageInHtmlComment2("process.kill is not a function"));
     });
     it("should not allow process.abort calls", async () => {
       const response = await request().get(
         "/r/unit-test-components/test-malicious-code/1.2.0/process-abort?_componentSet=set"
       );
       expect(response.statusCode).toEqual(500);
-      expect(response.headers["content-type"]).toContain("application/json");
-      expect(response.body).toEqual({
-        message: "process.abort is not a function"
-      });
+      expect(response.headers["content-type"]).toContain("text/html; charset=utf-8");
+      expect(response.text).toEqual(wrapMessageInHtmlComment2("process.abort is not a function"));
     });
     it.skip("should not allow access to parentPort", async () => {
       const response = await request().get(
         "/r/unit-test-components/test-malicious-code/1.3.0/accessing-parent-port?_componentSet=set"
       );
       expect(response.statusCode).toEqual(500);
-      expect(response.headers["content-type"]).toContain("application/json");
-      expect(response.body).toEqual({
-        message: "Cannot find module 'worker_threads'"
-      });
+      expect(response.headers["content-type"]).toContain("text/html; charset=utf-8");
+      expect(response.text).toEqual(wrapMessageInHtmlComment2("Cannot find module 'worker_threads'"));
     });
     it("should not allow escaping the sandbox through the constructor", async () => {
       const response = await request().get(
         "/r/unit-test-components/test-malicious-code/1.2.0/constructor-escape?_componentSet=set"
       );
       expect(response.statusCode).toEqual(500);
-      expect(response.headers["content-type"]).toContain("application/json");
-      expect(response.body).toEqual({
-        message: "Cannot read properties of undefined (reading 'constructor')"
-      });
+      expect(response.headers["content-type"]).toContain("text/html; charset=utf-8");
+      expect(response.text).toEqual(
+        wrapMessageInHtmlComment2("Cannot read properties of undefined (reading 'constructor')")
+      );
     });
     it("should not allow escaping the sandbox through the constructor and calling exit", async () => {
       const response = await request().get(
         "/r/unit-test-components/test-malicious-code/1.2.0/constructor-escape?_componentSet=set"
       );
       expect(response.statusCode).toEqual(500);
-      expect(response.headers["content-type"]).toContain("application/json");
-      expect(response.body).toEqual({
-        message: "Cannot read properties of undefined (reading 'constructor')"
-      });
+      expect(response.headers["content-type"]).toContain("text/html; charset=utf-8");
+      expect(response.text).toEqual(
+        wrapMessageInHtmlComment2("Cannot read properties of undefined (reading 'constructor')")
+      );
     });
     it("should not allow escaping the sandbox through the constructor and loading restricted modules", async () => {
       const response = await request().get(
         "/r/unit-test-components/test-malicious-code/1.2.0/constructor-fs?_componentSet=set"
       );
+      expect(response.text).toEqual(
+        wrapMessageInHtmlComment2("Cannot read properties of undefined (reading 'constructor')")
+      );
       expect(response.statusCode).toEqual(500);
-      expect(response.headers["content-type"]).toContain("application/json");
-      expect(response.body).toEqual({
-        message: "Cannot read properties of undefined (reading 'constructor')"
-      });
+      expect(response.headers["content-type"]).toContain("text/html; charset=utf-8");
     });
     it("should not allow circumvention of module restrictions", async () => {
       const response = await request().get(
         "/r/unit-test-components/test-malicious-code/1.2.0/circumventing-module-restriction?_componentSet=set"
       );
       expect(response.statusCode).toEqual(500);
-      expect(response.headers["content-type"]).toContain("application/json");
-      expect(response.body).toEqual({
-        message: "Cannot read properties of undefined (reading 'constructor')"
-      });
+      expect(response.headers["content-type"]).toContain("text/html; charset=utf-8");
+      expect(response.text).toEqual(
+        wrapMessageInHtmlComment2("Cannot read properties of undefined (reading 'constructor')")
+      );
     });
     it("should not allow circumvention of module restrictions with mainmodule", async () => {
       const response = await request().get(
         "/r/unit-test-components/test-malicious-code/1.2.0/circumventing-module-restriction-mainmodule?_componentSet=set"
       );
       expect(response.statusCode).toEqual(500);
-      expect(response.headers["content-type"]).toContain("application/json");
-      expect(response.body).toEqual({
-        message: "Cannot read properties of undefined (reading 'require')"
-      });
+      expect(response.headers["content-type"]).toContain("text/html; charset=utf-8");
+      expect(response.text).toEqual(
+        wrapMessageInHtmlComment2("Cannot read properties of undefined (reading 'require')")
+      );
     });
   });
 }
@@ -4195,7 +4530,8 @@ var routeTests = {
   static: staticRouteTests,
   render: renderRouteTests,
   renderSandbox: renderRouteSandboxTests,
-  preview: previewRouteTests
+  preview: previewRouteTests,
+  development: developmentRouteTests
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {