@platformatic/next 3.38.1 → 3.40.0

package/config.d.ts

@@ -55,6 +55,10 @@ export interface PlatformaticNextJsConfig {
     customLevels?: {
       [k: string]: unknown;
     };
+    openTelemetryExporter?: {
+      protocol: "grpc" | "http";
+      url: string;
+    };
     [k: string]: unknown;
   };
   server?: {
@@ -186,6 +190,10 @@ export interface PlatformaticNextJsConfig {
       customLevels?: {
         [k: string]: unknown;
       };
+      openTelemetryExporter?: {
+        protocol: "grpc" | "http";
+        url: string;
+      };
       [k: string]: unknown;
     };
     server?: {
@@ -324,6 +332,12 @@ export interface PlatformaticNextJsConfig {
            */
           socket?: string;
         };
+    management?:
+      | boolean
+      | {
+          enabled?: boolean;
+          operations?: string[];
+        };
     metrics?:
       | boolean
       | {
@@ -648,6 +662,32 @@ export interface PlatformaticNextJsConfig {
     standalone?: boolean;
     trailingSlash?: boolean;
     useExperimentalAdapter?: boolean;
+    https?: {
+      enabled?: boolean | string;
+      key?: string;
+      cert?: string;
+      ca?: string;
+    };
+    imageOptimizer?: {
+      enabled: boolean;
+      fallback: string;
+      storage?:
+        | {
+            type: "memory";
+          }
+        | {
+            type: "filesystem";
+            path?: string;
+          }
+        | {
+            type: "redis" | "valkey";
+            url: string;
+            prefix?: string;
+            db?: number | string;
+          };
+      timeout?: number | string;
+      maxAttempts?: number | string;
+    };
   };
   cache?: {
     enabled?: boolean | string;

package/index.js

@@ -2,6 +2,7 @@ import { transform as basicTransform, resolve, validationOptions } from '@platfo
 import { kMetadata, loadConfiguration as utilsLoadConfiguration } from '@platformatic/foundation'
 import { resolve as resolvePath } from 'node:path'
 import { getCacheHandlerPath, NextCapability } from './lib/capability.js'
+import { NextImageOptimizerCapability } from './lib/image-optimizer.js'
 import { schema } from './lib/schema.js'
 
 /* c8 ignore next 9 */
@@ -103,10 +104,12 @@ export async function loadConfiguration (configOrRoot, sourceOrConfig, context)
 
 export async function create (configOrRoot, sourceOrConfig, context) {
   const config = await loadConfiguration(configOrRoot, sourceOrConfig, context)
-  return new NextCapability(config[kMetadata].root, config, context)
+
+  const Capability = config.next?.imageOptimizer?.enabled ? NextImageOptimizerCapability : NextCapability
+  return new Capability(config[kMetadata].root, config, context)
 }
 
-export * as cachingValkey from './lib/caching/valkey-isr.js'
 export * from './lib/capability.js'
 export * as errors from './lib/errors.js'
+export * from './lib/image-optimizer.js'
 export { packageJson, schema, schemaComponents, version } from './lib/schema.js'

package/lib/caching/valkey-common.js

@@ -1,12 +1,17 @@
 import { buildPinoFormatters, buildPinoTimestamp } from '@platformatic/foundation'
-import { Redis } from 'iovalkey'
-import { pack, unpack } from 'msgpackr'
 import { existsSync, readFileSync } from 'node:fs'
+import { createRequire } from 'node:module'
 import { hostname } from 'node:os'
 import { resolve } from 'node:path'
 import { fileURLToPath } from 'node:url'
 import { pino } from 'pino'
 
+// commonjs require is superior because it allows lazy loading
+const require = createRequire(import.meta.url)
+
+let Redis
+let msgpackr
+
 globalThis.platformatic ??= {}
 globalThis.platformatic.valkeyClients = new Map()
 
@@ -30,6 +35,18 @@ export function keyFor (prefix, subprefix, section, key) {
   return result
 }
 
+export function ensureRedis () {
+  if (!Redis) {
+    Redis = require('iovalkey').Redis
+  }
+}
+
+export function ensureMsgpackr () {
+  if (!msgpackr) {
+    msgpackr = require('msgpackr')
+  }
+}
+
 export function getConnection (url) {
   let client = globalThis.platformatic.valkeyClients.get(url)
 
@@ -93,9 +110,9 @@ export function getPlatformaticMeta () {
 }
 
 export function serialize (data) {
-  return pack(data).toString('base64url')
+  return msgpackr.pack(data).toString('base64url')
 }
 
 export function deserialize (data) {
-  return unpack(Buffer.from(data, 'base64url'))
+  return msgpackr.unpack(Buffer.from(data, 'base64url'))
 }

package/lib/caching/valkey-components.js

@@ -3,6 +3,8 @@ import { ReadableStream } from 'node:stream/web'
 import {
   createPlatformaticLogger,
   deserialize,
+  ensureMsgpackr,
+  ensureRedis,
   getConnection,
   getPlatformaticMeta,
   getPlatformaticSubprefix,
@@ -37,6 +39,9 @@ export class CacheHandler {
   #cacheMissMetric
 
   constructor () {
+    ensureRedis()
+    ensureMsgpackr()
+
     this.#config ??= globalThis.platformatic.config.cache
     this.#logger ??= createPlatformaticLogger()
     this.#store ??= getConnection(this.#config.url)

package/lib/caching/valkey-isr.js

@@ -2,6 +2,8 @@ import { ensureLoggableError } from '@platformatic/foundation'
 import {
   createPlatformaticLogger,
   deserialize,
+  ensureMsgpackr,
+  ensureRedis,
   getConnection,
   getPlatformaticMeta,
   getPlatformaticSubprefix,
@@ -33,6 +35,9 @@ export class CacheHandler {
   constructor (options) {
     options ??= {}
 
+    ensureRedis()
+    ensureMsgpackr()
+
     this.#standalone = options.standalone
     this.#config = options.config
     this.#logger = options.logger

package/lib/capability.js

@@ -20,7 +20,7 @@ import { parse, satisfies } from 'semver'
 import * as errors from './errors.js'
 import { version } from './schema.js'
 
-const supportedVersions = ['^14.0.0', '^15.0.0', '^16.0.0']
+export const supportedVersions = ['^14.0.0', '^15.0.0', '^16.0.0']
 
 export function getCacheHandlerPath (name) {
   return fileURLToPath(new URL(`./caching/${name}.js`, import.meta.url)).replaceAll(sep, '/')
@@ -239,21 +239,71 @@ export class NextCapability extends BaseCapability {
       this.#ensurePipeableStreamsInFork()
 
       if (this.#nextVersion.major === 14 && this.#nextVersion.minor < 2) {
-        await nextDev({
+        const devOptions = {
           '--hostname': serverOptions.host,
           '--port': serverOptions.port,
           _: [this.root]
-        })
+        }
+
+        const httpsOptions = this.config.next?.https ?? {}
+
+        if (httpsOptions.enabled) {
+          devOptions['--experimental-https-key'] = true
+
+          if (httpsOptions.key) {
+            devOptions['--experimental-https-key'] = resolvePath(this.root, httpsOptions.key)
+          }
+
+          if (httpsOptions.cert) {
+            devOptions['--experimental-https-cert'] = resolvePath(this.root, httpsOptions.cert)
+          }
+
+          if (httpsOptions.ca) {
+            devOptions['--experimental-https-ca'] = resolvePath(this.root, httpsOptions.ca)
+          }
+        }
+
+        await nextDev(devOptions)
       } else {
+        const nextConfig = this.config.next ?? {}
+        const httpsOptions = nextConfig.https ?? {}
+
+        if (httpsOptions.enabled) {
+          serverOptions.experimentalHttps = true
+
+          if (httpsOptions.key) {
+            serverOptions.experimentalHttpsKey = resolvePath(this.root, httpsOptions.key)
+          }
+
+          if (httpsOptions.cert) {
+            serverOptions.experimentalHttpsCert = resolvePath(this.root, httpsOptions.cert)
+          }
+
+          if (httpsOptions.ca) {
+            serverOptions.experimentalHttpsCa = resolvePath(this.root, httpsOptions.ca)
+          }
+        }
+
         await nextDev(serverOptions, 'default', this.root)
       }
 
       this.#child = await childPromise
-      this.#child.stdout.setEncoding('utf8')
-      this.#child.stderr.setEncoding('utf8')
 
-      this.#child.stdout.pipe(process.stdout, { end: false })
-      this.#child.stderr.pipe(process.stderr, { end: false })
+      // Paolo: I couldn't really reproduce this, but in some environments our child_process patch
+      // might not work and thus the stdio streams are not pipeable.
+      // Rathen than throwing an error in that case, we log a warning and continue without redirecting the output,
+      // as the worst thing is that the user will lose our formatted output.
+      //
+      // This should be fixable once https://github.com/nodejs/node/pull/61836 lands and it is broadly available.
+      if (typeof this.#child.stdout?.pipe === 'function' && typeof this.#child.stderr?.pipe === 'function') {
+        this.#child.stdout.setEncoding('utf8')
+        this.#child.stderr.setEncoding('utf8')
+
+        this.#child.stdout.pipe(process.stdout, { end: false })
+        this.#child.stderr.pipe(process.stderr, { end: false })
+      } else {
+        this.logger.warn('Unable to redirect Next.js development server output to the main process')
+      }
     } finally {
       await this.childManager.eject()
     }
@@ -493,7 +543,8 @@ export class NextCapability extends BaseCapability {
 
     try {
       serverModule = createRequire(serverEntrypoint)('next/dist/server/lib/start-server.js')
-    } catch (e) { // Fallback to bundled capability
+    } catch (e) {
+      // Fallback to bundled capability
       serverModule = createRequire(import.meta.file)('next/dist/server/lib/start-server.js')
     }
 

package/lib/image-optimizer.js

@@ -0,0 +1,283 @@
+import {
+  BaseCapability,
+  errors as basicErrors,
+  createServerListener,
+  getServerUrl,
+  importFile,
+  resolvePackageViaCJS
+} from '@platformatic/basic'
+import { cleanBasePath } from '@platformatic/basic/lib/utils.js'
+import { ensureLoggableError } from '@platformatic/foundation/lib/errors.js'
+import { createQueue } from '@platformatic/image-optimizer'
+import { FileStorage, MemoryStorage, RedisStorage } from '@platformatic/job-queue'
+import inject from 'light-my-request'
+import { readFile } from 'node:fs/promises'
+import { createServer } from 'node:http'
+import { dirname, resolve as resolvePath } from 'node:path'
+import { satisfies } from 'semver'
+import { supportedVersions } from './capability.js'
+import { version } from './schema.js'
+
+export class NextImageOptimizerCapability extends BaseCapability {
+  #basePath
+  #fallbackDomain
+  #next
+  #nextConfig
+  #validateParams
+  #app
+  #server
+  #dispatcher
+  #queue
+  #fetchTimeout
+
+  constructor (root, config, context) {
+    super('next-image', version, root, config, context)
+  }
+
+  async init () {
+    await super.init()
+
+    // This is needed to avoid Next.js to throw an error when the lockfile is not correct
+    // and the user is using npm but has pnpm in its $PATH.
+    //
+    // See: https://github.com/platformatic/composer-next-node-fastify/pull/3
+    //
+    // PS by Paolo: Sob.
+    process.env.NEXT_IGNORE_INCORRECT_LOCKFILE = 'true'
+
+    this.#next = resolvePath(dirname(await resolvePackageViaCJS(this.root, 'next')), '../..')
+    const nextPackage = JSON.parse(await readFile(resolvePath(this.#next, 'package.json'), 'utf-8'))
+
+    /* c8 ignore next 3 */
+    if (!this.isProduction && !supportedVersions.some(v => satisfies(nextPackage.version, v))) {
+      throw new basicErrors.UnsupportedVersion('next', nextPackage.version, supportedVersions)
+    }
+
+    const imageOptimizerConfig = this.config.next?.imageOptimizer ?? {}
+
+    this.#fetchTimeout = imageOptimizerConfig?.timeout ?? 30000
+    this.#fallbackDomain = this.config.next?.imageOptimizer?.fallback
+
+    // If it's not a full URL, it's a local service
+    if (!this.#fallbackDomain.startsWith('http://') && !this.#fallbackDomain.startsWith('https://')) {
+      this.#fallbackDomain = `http://${this.#fallbackDomain}.plt.local`
+    }
+
+    if (this.#fallbackDomain.endsWith('/')) {
+      this.#fallbackDomain = this.#fallbackDomain.slice(0, -1)
+    }
+
+    this.#queue = await this.#createQueue(imageOptimizerConfig)
+  }
+
+  async start ({ listen }) {
+    // Make this idempotent
+    if (this.url) {
+      return this.url
+    }
+
+    const config = this.config
+    this.#basePath = config.application?.basePath ? cleanBasePath(config.application?.basePath) : ''
+    await super._start({ listen })
+
+    if (this.#app && listen) {
+      const serverOptions = this.serverConfig
+      const listenOptions = { host: serverOptions?.hostname || '127.0.0.1', port: serverOptions?.port || 0 }
+
+      if (typeof serverOptions?.backlog === 'number') {
+        createServerListener(false, false, { backlog: serverOptions.backlog })
+        listenOptions.backlog = serverOptions.backlog
+      }
+
+      this.#server = await new Promise((resolve, reject) => {
+        return this.#app
+          .listen(listenOptions, function () {
+            resolve(this)
+          })
+          .on('error', reject)
+      })
+
+      this.url = getServerUrl(this.#server)
+
+      return this.url
+    }
+
+    const { ImageOptimizerCache } = await importFile(resolvePath(this.#next, './dist/server/image-optimizer.js'))
+    this.#validateParams = ImageOptimizerCache.validateParams.bind(ImageOptimizerCache)
+
+    try {
+      const { default: loadConfigAPI } = await importFile(resolvePath(this.#next, './dist/server/config.js'))
+      this.#nextConfig = await loadConfigAPI.default('production', this.root)
+    } catch (error) {
+      this.logger.error({ err: ensureLoggableError(error) }, 'Error loading Next.js configuration.')
+      throw new Error('Failed to load Next.js configuration.', { cause: error })
+    }
+
+    this.#app = createServer(this.#handleRequest.bind(this))
+    this.#dispatcher = this.#app.listeners('request')[0]
+    await this.#queue.start()
+  }
+
+  async stop () {
+    await super.stop()
+    await this.#queue?.stop()
+
+    globalThis.platformatic.events.emit('plt:next:close')
+
+    if (!this.#app || !this.#server?.listening) {
+      return
+    }
+    const { promise, resolve, reject } = Promise.withResolvers()
+
+    this.#server.close(error => {
+      if (error) {
+        return reject(error)
+      }
+
+      resolve()
+    })
+
+    return promise
+  }
+
+  /* c8 ignore next 5 */
+  async getWatchConfig () {
+    return {
+      enabled: false,
+      path: this.root
+    }
+  }
+
+  getMeta () {
+    const gateway = { prefix: this.basePath ?? this.#basePath, wantsAbsoluteUrls: true, needsRootTrailingSlash: false }
+
+    if (this.url) {
+      gateway.tcp = true
+      gateway.url = this.url
+    }
+
+    return { gateway }
+  }
+
+  async inject (injectParams, onInject) {
+    this.logger.trace({ injectParams }, 'injecting via light-my-request')
+    const res = inject(this.#dispatcher ?? this.#app, injectParams, onInject)
+
+    /* c8 ignore next 3 */
+    if (onInject) {
+      return
+    }
+
+    // Since inject might be called from the main thread directly via ITC, let's clean it up
+    const { statusCode, headers, body, payload, rawPayload } = res
+
+    return { statusCode, headers, body, payload, rawPayload }
+  }
+
+  async #createQueue (imageOptimizerConfig) {
+    const queueOptions = {
+      visibilityTimeout: imageOptimizerConfig.timeout,
+      maxRetries: imageOptimizerConfig.maxAttempts,
+      logger: this.logger
+    }
+
+    if (imageOptimizerConfig.storage.type === 'memory') {
+      queueOptions.storage = new MemoryStorage()
+    } else if (imageOptimizerConfig.storage.type === 'filesystem') {
+      queueOptions.storage = new FileStorage({
+        basePath: imageOptimizerConfig.storage.path ?? resolvePath(this.root, '.next/cache/image-optimizer')
+      })
+    } else {
+      const redisStorageOptions = {
+        url: this.#buildRedisStorageUrl(imageOptimizerConfig.storage.url, imageOptimizerConfig.storage.db)
+      }
+
+      if (typeof imageOptimizerConfig.storage.prefix === 'string') {
+        redisStorageOptions.keyPrefix = imageOptimizerConfig.storage.prefix
+      }
+
+      queueOptions.storage = new RedisStorage(redisStorageOptions)
+    }
+
+    return createQueue(queueOptions)
+  }
+
+  #buildRedisStorageUrl (url, db) {
+    if (typeof db === 'undefined') {
+      return url
+    }
+
+    const parsedUrl = new URL(url)
+    parsedUrl.pathname = `/${db}`
+    return parsedUrl.toString()
+  }
+
+  async #handleRequest (request, response) {
+    const { pathname, searchParams } = new URL(request.url, 'http://localhost')
+    const imagePath = `${this.#basePath}/_next/image`
+
+    if (request.method !== 'GET' || pathname !== imagePath) {
+      response.statusCode = 404
+      response.end('Not Found')
+      return
+    }
+
+    const query = {}
+
+    for (const [key, value] of searchParams.entries()) {
+      if (typeof query[key] === 'undefined') {
+        query[key] = value
+      } else if (Array.isArray(query[key])) {
+        query[key].push(value)
+      } else {
+        query[key] = [query[key], value]
+      }
+    }
+
+    try {
+      // Extract and validate the parameters
+      const params = this.#validateParams(request, query, this.#nextConfig, false)
+
+      if (params.errorMessage) {
+        const error = new Error('Invalid optimization parameters.')
+        error.reason = params.errorMessage
+        throw error
+      }
+
+      let url
+      if (params.isAbsolute) {
+        url = params.href
+      } else {
+        url = `${this.#fallbackDomain}${params.href.startsWith('/') ? '' : '/'}${params.href}`
+      }
+
+      const result = await this.#queue.fetchAndOptimize(
+        url,
+        params.width,
+        params.quality,
+        this.#nextConfig.images.dangerouslyAllowSVG,
+        { timeout: this.#fetchTimeout }
+      )
+      const buffer = Buffer.from(result.buffer, 'base64')
+
+      response.statusCode = 200
+      response.setHeader('Content-Type', result.contentType)
+      response.setHeader('Cache-Control', result.cacheControl)
+      response.end(buffer)
+    } catch (error) {
+      response.statusCode = 502
+      response.setHeader('Content-Type', 'application/json; charset=utf-8')
+      response.end(
+        JSON.stringify({
+          error: 'Bad Gateway',
+          message: 'An error occurred while optimizing the image.',
+          statusCode: 502,
+          cause: {
+            ...ensureLoggableError(error.originalError ? JSON.parse(error.originalError) : error),
+            stack: undefined
+          }
+        })
+      )
+    }
+  }
+}

package/lib/schema.js

@@ -63,7 +63,7 @@ const next = {
   type: 'object',
   properties: {
     standalone: {
-      type: 'boolean',
+      type: 'boolean'
     },
     trailingSlash: {
       type: 'boolean',
@@ -72,6 +72,132 @@ const next = {
     useExperimentalAdapter: {
       type: 'boolean',
       default: false
+    },
+    https: {
+      type: 'object',
+      properties: {
+        enabled: {
+          anyOf: [
+            {
+              type: 'boolean'
+            },
+            {
+              type: 'string'
+            }
+          ]
+        },
+        key: {
+          type: 'string'
+        },
+        cert: {
+          type: 'string'
+        },
+        ca: {
+          type: 'string'
+        }
+      },
+      additionalProperties: false
+    },
+    imageOptimizer: {
+      type: 'object',
+      properties: {
+        enabled: {
+          type: 'boolean',
+          default: false
+        },
+        fallback: {
+          type: 'string'
+        },
+        storage: {
+          oneOf: [
+            {
+              type: 'object',
+              properties: {
+                type: {
+                  const: 'memory'
+                }
+              },
+              required: ['type'],
+              additionalProperties: false
+            },
+            {
+              type: 'object',
+              properties: {
+                type: {
+                  const: 'filesystem'
+                },
+                path: {
+                  type: 'string',
+                  resolvePath: true
+                }
+              },
+              required: ['type'],
+              additionalProperties: false
+            },
+            {
+              type: 'object',
+              properties: {
+                type: {
+                  type: 'string',
+                  enum: ['redis', 'valkey']
+                },
+                url: {
+                  type: 'string'
+                },
+                prefix: {
+                  type: 'string'
+                },
+                db: {
+                  anyOf: [
+                    {
+                      type: 'number',
+                      minimum: 0,
+                      default: 0
+                    },
+                    {
+                      type: 'string',
+                      pattern: '^[0-9]+$'
+                    }
+                  ]
+                }
+              },
+              required: ['type', 'url'],
+              additionalProperties: false
+            }
+          ],
+          default: {
+            type: 'memory'
+          }
+        },
+        timeout: {
+          default: 30000,
+          anyOf: [
+            {
+              type: 'number',
+              minimum: 0
+            },
+            {
+              type: 'string',
+              pattern: '^[0-9]+$'
+            }
+          ]
+        },
+        maxAttempts: {
+          default: 3,
+          anyOf: [
+            {
+              type: 'number',
+              minimum: 1
+            },
+            {
+              type: 'string',
+              pattern: '^[1-9][0-9]*$'
+            }
+          ]
+        }
+      },
+      required: ['enabled', 'fallback'],
+      additionalProperties: false
     }
   },
   default: {},

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@platformatic/next",
-  "version": "3.38.1",
+  "version": "3.40.0",
   "description": "Platformatic Next.js Capability",
   "main": "index.js",
   "type": "module",
@@ -19,12 +19,14 @@
     "@babel/parser": "^7.25.3",
     "@babel/traverse": "^7.25.3",
     "@babel/types": "^7.25.2",
+    "@platformatic/image-optimizer": "^0.2.0",
     "amaro": "^0.3.0",
     "iovalkey": "^0.3.0",
+    "light-my-request": "^6.0.0",
     "msgpackr": "^1.11.2",
     "semver": "^7.6.3",
-    "@platformatic/basic": "3.38.1",
-    "@platformatic/foundation": "3.38.1"
+    "@platformatic/basic": "3.40.0",
+    "@platformatic/foundation": "3.40.0"
   },
   "devDependencies": {
     "@fastify/reply-from": "^12.0.0",
@@ -34,14 +36,14 @@
     "cleaner-spec-reporter": "^0.5.0",
     "eslint": "9",
     "execa": "^9.5.1",
-    "fastify": "^5.7.0",
+    "fastify": "^5.7.3",
     "json-schema-to-typescript": "^15.0.1",
     "neostandard": "^0.12.0",
-    "next": "^16.0.0",
+    "next": "^16.1.0",
     "typescript": "^5.5.4",
     "ws": "^8.18.0",
-    "@platformatic/service": "3.38.1",
-    "@platformatic/gateway": "3.38.1"
+    "@platformatic/gateway": "3.40.0",
+    "@platformatic/service": "3.40.0"
   },
   "engines": {
     "node": ">=22.19.0"

package/schema.json

@@ -1,5 +1,5 @@
 {
-  "$id": "https://schemas.platformatic.dev/@platformatic/next/3.38.1.json",
+  "$id": "https://schemas.platformatic.dev/@platformatic/next/3.40.0.json",
   "$schema": "http://json-schema.org/draft-07/schema#",
   "title": "Platformatic Next.js Config",
   "type": "object",
@@ -152,6 +152,26 @@
         "customLevels": {
           "type": "object",
           "additionalProperties": true
+        },
+        "openTelemetryExporter": {
+          "type": "object",
+          "properties": {
+            "protocol": {
+              "type": "string",
+              "enum": [
+                "grpc",
+                "http"
+              ]
+            },
+            "url": {
+              "type": "string"
+            }
+          },
+          "required": [
+            "protocol",
+            "url"
+          ],
+          "additionalProperties": false
         }
       },
       "default": {},
@@ -716,6 +736,29 @@
                     "additionalProperties": false
                   }
                 ]
+              },
+              "management": {
+                "anyOf": [
+                  {
+                    "type": "boolean"
+                  },
+                  {
+                    "type": "object",
+                    "properties": {
+                      "enabled": {
+                        "type": "boolean",
+                        "default": true
+                      },
+                      "operations": {
+                        "type": "array",
+                        "items": {
+                          "type": "string"
+                        }
+                      }
+                    },
+                    "additionalProperties": false
+                  }
+                ]
               }
             }
           }
@@ -935,6 +978,26 @@
             "customLevels": {
               "type": "object",
               "additionalProperties": true
+            },
+            "openTelemetryExporter": {
+              "type": "object",
+              "properties": {
+                "protocol": {
+                  "type": "string",
+                  "enum": [
+                    "grpc",
+                    "http"
+                  ]
+                },
+                "url": {
+                  "type": "string"
+                }
+              },
+              "required": [
+                "protocol",
+                "url"
+              ],
+              "additionalProperties": false
             }
           },
           "default": {},
@@ -1435,6 +1498,29 @@
           ],
           "default": true
         },
+        "management": {
+          "anyOf": [
+            {
+              "type": "boolean"
+            },
+            {
+              "type": "object",
+              "properties": {
+                "enabled": {
+                  "type": "boolean",
+                  "default": true
+                },
+                "operations": {
+                  "type": "array",
+                  "items": {
+                    "type": "string"
+                  }
+                }
+              },
+              "additionalProperties": false
+            }
+          ]
+        },
         "metrics": {
           "anyOf": [
             {
@@ -2372,6 +2458,145 @@
         "useExperimentalAdapter": {
           "type": "boolean",
           "default": false
+        },
+        "https": {
+          "type": "object",
+          "properties": {
+            "enabled": {
+              "anyOf": [
+                {
+                  "type": "boolean"
+                },
+                {
+                  "type": "string"
+                }
+              ]
+            },
+            "key": {
+              "type": "string"
+            },
+            "cert": {
+              "type": "string"
+            },
+            "ca": {
+              "type": "string"
+            }
+          },
+          "additionalProperties": false
+        },
+        "imageOptimizer": {
+          "type": "object",
+          "properties": {
+            "enabled": {
+              "type": "boolean",
+              "default": false
+            },
+            "fallback": {
+              "type": "string"
+            },
+            "storage": {
+              "oneOf": [
+                {
+                  "type": "object",
+                  "properties": {
+                    "type": {
+                      "const": "memory"
+                    }
+                  },
+                  "required": [
+                    "type"
+                  ],
+                  "additionalProperties": false
+                },
+                {
+                  "type": "object",
+                  "properties": {
+                    "type": {
+                      "const": "filesystem"
+                    },
+                    "path": {
+                      "type": "string",
+                      "resolvePath": true
+                    }
+                  },
+                  "required": [
+                    "type"
+                  ],
+                  "additionalProperties": false
+                },
+                {
+                  "type": "object",
+                  "properties": {
+                    "type": {
+                      "type": "string",
+                      "enum": [
+                        "redis",
+                        "valkey"
+                      ]
+                    },
+                    "url": {
+                      "type": "string"
+                    },
+                    "prefix": {
+                      "type": "string"
+                    },
+                    "db": {
+                      "anyOf": [
+                        {
+                          "type": "number",
+                          "minimum": 0,
+                          "default": 0
+                        },
+                        {
+                          "type": "string",
+                          "pattern": "^[0-9]+$"
+                        }
+                      ]
+                    }
+                  },
+                  "required": [
+                    "type",
+                    "url"
+                  ],
+                  "additionalProperties": false
+                }
+              ],
+              "default": {
+                "type": "memory"
+              }
+            },
+            "timeout": {
+              "default": 30000,
+              "anyOf": [
+                {
+                  "type": "number",
+                  "minimum": 0
+                },
+                {
+                  "type": "string",
+                  "pattern": "^[0-9]+$"
+                }
+              ]
+            },
+            "maxAttempts": {
+              "default": 3,
+              "anyOf": [
+                {
+                  "type": "number",
+                  "minimum": 1
+                },
+                {
+                  "type": "string",
+                  "pattern": "^[1-9][0-9]*$"
+                }
+              ]
+            }
+          },
+          "required": [
+            "enabled",
+            "fallback"
+          ],
+          "additionalProperties": false
         }
       },
       "default": {},