@platformatic/runtime 3.32.0-alpha.0 → 3.32.0

package/config.d.ts

@@ -42,7 +42,6 @@ export type PlatformaticRuntimeConfig = {
           maxHeapTotal?: number | string;
           maxYoungGeneration?: number | string;
           codeRangeSize?: number | string;
-          noHeapCheck?: boolean | string;
         };
         dependencies?: string[];
         arguments?: string[];
@@ -79,6 +78,18 @@ export type PlatformaticRuntimeConfig = {
           )[];
           [k: string]: unknown;
         };
+        compileCache?:
+          | boolean
+          | {
+              /**
+               * Enable Node.js module compile cache for faster startup
+               */
+              enabled?: boolean;
+              /**
+               * Directory to store compile cache. Defaults to .plt/compile-cache in app root
+               */
+              directory?: string;
+            };
       };
     };
   };
@@ -109,7 +120,7 @@ export type PlatformaticRuntimeConfig = {
       };
   workersRestartDelay?: number | string;
   logger?: {
-    level: (
+    level?: (
       | ("fatal" | "error" | "warn" | "info" | "debug" | "trace" | "silent")
       | {
           [k: string]: unknown;
@@ -213,7 +224,6 @@ export type PlatformaticRuntimeConfig = {
     maxHeapTotal?: number | string;
     maxYoungGeneration?: number | string;
     codeRangeSize?: number | string;
-    noHeapCheck?: boolean | string;
   };
   undici?: {
     agentOptions?: {
@@ -265,6 +275,18 @@ export type PlatformaticRuntimeConfig = {
         maxSize?: number;
         maxEntrySize?: number;
         maxCount?: number;
+        /**
+         * Whitelist of origins to cache. Supports exact strings and regex patterns (e.g., "/https:\\/\\/.*\\.example\\.com/").
+         */
+        origins?: string[];
+        /**
+         * Default cache duration in seconds for responses without explicit expiration headers.
+         */
+        cacheByDefault?: number;
+        /**
+         * Cache type. "shared" caches may be shared between users, "private" caches are user-specific.
+         */
+        type?: "shared" | "private";
         [k: string]: unknown;
       };
   watch?: boolean | string;
@@ -503,4 +525,16 @@ export type PlatformaticRuntimeConfig = {
       [k: string]: string | [string, ...string[]];
     };
   };
+  compileCache?:
+    | boolean
+    | {
+        /**
+         * Enable Node.js module compile cache for faster startup
+         */
+        enabled?: boolean;
+        /**
+         * Directory to store compile cache. Defaults to .plt/compile-cache in app root
+         */
+        directory?: string;
+      };
 };

package/lib/runtime.js

@@ -10,6 +10,7 @@ import {
   parseMemorySize
 } from '@platformatic/foundation'
 import { ITC } from '@platformatic/itc'
+import { client as metricsClient, collectProcessMetrics } from '@platformatic/metrics'
 import fastify from 'fastify'
 import { EventEmitter, once } from 'node:events'
 import { existsSync } from 'node:fs'
@@ -68,9 +69,26 @@ import {
 
 const kWorkerFile = join(import.meta.dirname, 'worker/main.js')
 const kInspectorOptions = Symbol('plt.runtime.worker.inspectorOptions')
+const kHeapCheckCounter = Symbol('plt.runtime.worker.heapCheckCounter')
+const kLastHeapStats = Symbol('plt.runtime.worker.lastHeapStats')
 
 const MAX_LISTENERS_COUNT = 100
 
+function parseOrigins (origins) {
+  if (!origins) return undefined
+
+  return origins.map(origin => {
+    // Check if the origin is a regex pattern (starts and ends with /)
+    if (origin.startsWith('/') && origin.lastIndexOf('/') > 0) {
+      const lastSlash = origin.lastIndexOf('/')
+      const pattern = origin.slice(1, lastSlash)
+      const flags = origin.slice(lastSlash + 1)
+      return new RegExp(pattern, flags)
+    }
+    return origin
+  })
+}
+
 const MAX_CONCURRENCY = 5
 const MAX_BOOTSTRAP_ATTEMPTS = 5
 const IMMEDIATE_RESTART_MAX_THRESHOLD = 10
@@ -119,6 +137,8 @@ export class Runtime extends EventEmitter {
 
   #channelCreationHook
 
+  #processMetricsRegistry
+
   constructor (config, context) {
     super()
     this.setMaxListeners(MAX_LISTENERS_COUNT)
@@ -197,6 +217,14 @@ export class Runtime extends EventEmitter {
       this.#metricsLabelName = 'applicationId'
     }
 
+    // Initialize process-level metrics registry in the main thread if metrics or management API is enabled
+    // These metrics are the same across all workers and only need to be collected once
+    // We need this for management API as it can request metrics even without explicit metrics config
+    if (config.metrics || config.managementApi) {
+      this.#processMetricsRegistry = new metricsClient.Registry()
+      collectProcessMetrics(this.#processMetricsRegistry)
+    }
+
     // Create the logger
     const [logger, destination, context] = await createLogger(config)
     this.logger = logger
@@ -346,6 +374,12 @@ export class Runtime extends EventEmitter {
       await this.#prometheusServer.close()
     }
 
+    // Clean up process metrics registry
+    if (this.#processMetricsRegistry) {
+      this.#processMetricsRegistry.clear()
+      this.#processMetricsRegistry = null
+    }
+
     if (this.#sharedHttpCache?.close) {
       await this.#sharedHttpCache.close()
     }
@@ -1059,6 +1093,12 @@ export class Runtime extends EventEmitter {
   async getMetrics (format = 'json') {
     let metrics = null
 
+    // Get process-level metrics once from main thread registry (if available)
+    let processMetricsJson = null
+    if (this.#processMetricsRegistry) {
+      processMetricsJson = await this.#processMetricsRegistry.getMetricsAsJSON()
+    }
+
     for (const worker of this.#workers.values()) {
       try {
         // The application might be temporarily unavailable
@@ -1066,6 +1106,7 @@ export class Runtime extends EventEmitter {
           continue
         }
 
+        // Get thread-specific metrics from worker
         const applicationMetrics = await executeWithTimeout(
           sendViaITC(worker, 'getMetrics', format),
           this.#config.metrics?.timeout ?? 10000
@@ -1076,9 +1117,30 @@ export class Runtime extends EventEmitter {
             metrics = format === 'json' ? [] : ''
           }
 
+          // Build worker labels including custom labels from metrics config
+          const workerLabels = {
+            ...this.#config.metrics?.labels,
+            [this.#metricsLabelName]: worker[kApplicationId]
+          }
+          const workerId = worker[kWorkerId]
+          if (workerId >= 0) {
+            workerLabels.workerId = workerId
+          }
+
           if (format === 'json') {
-            metrics.push(...applicationMetrics)
+            // Duplicate process metrics with worker labels and add to output
+            if (processMetricsJson) {
+              this.#applyLabelsToMetrics(processMetricsJson, workerLabels, metrics)
+            }
+            // Add worker's thread-specific metrics
+            for (let i = 0; i < applicationMetrics.length; i++) {
+              metrics.push(applicationMetrics[i])
+            }
           } else {
+            // Text format: format process metrics with worker labels
+            if (processMetricsJson) {
+              metrics += this.#formatProcessMetricsText(processMetricsJson, workerLabels)
+            }
             metrics += applicationMetrics
           }
         }
@@ -1099,6 +1161,65 @@ export class Runtime extends EventEmitter {
     return { metrics }
   }
 
+  // Apply labels to process metrics and push to output array (for JSON format)
+  #applyLabelsToMetrics (processMetrics, labels, outputArray) {
+    for (let i = 0; i < processMetrics.length; i++) {
+      const metric = processMetrics[i]
+      const newValues = []
+      const values = metric.values
+      for (let j = 0; j < values.length; j++) {
+        const v = values[j]
+        newValues.push({
+          value: v.value,
+          labels: { ...labels, ...v.labels },
+          metricName: v.metricName
+        })
+      }
+      outputArray.push({
+        name: metric.name,
+        help: metric.help,
+        type: metric.type,
+        aggregator: metric.aggregator,
+        values: newValues
+      })
+    }
+  }
+
+  // Format process metrics as Prometheus text format with labels
+  #formatProcessMetricsText (processMetricsJson, labels) {
+    let output = ''
+
+    for (let i = 0; i < processMetricsJson.length; i++) {
+      const metric = processMetricsJson[i]
+      const name = metric.name
+      const help = metric.help
+      const type = metric.type
+
+      // Add HELP and TYPE lines
+      output += `# HELP ${name} ${help}\n`
+      output += `# TYPE ${name} ${type}\n`
+
+      const values = metric.values
+      for (let j = 0; j < values.length; j++) {
+        const v = values[j]
+        const combinedLabels = { ...labels, ...v.labels }
+        const labelParts = []
+
+        for (const [key, val] of Object.entries(combinedLabels)) {
+          // Escape label values for Prometheus format
+          const escapedVal = String(val).replace(/\\/g, '\\\\').replace(/"/g, '\\"').replace(/\n/g, '\\n')
+          labelParts.push(`${key}="${escapedVal}"`)
+        }
+
+        const labelStr = labelParts.length > 0 ? `{${labelParts.join(',')}}` : ''
+        const metricName = v.metricName || name
+        output += `${metricName}${labelStr} ${v.value}\n`
+      }
+    }
+
+    return output
+  }
+
   async getFormattedMetrics () {
     try {
       const { metrics } = await this.getMetrics()
@@ -1349,11 +1470,20 @@ export class Runtime extends EventEmitter {
       elu = worker.performance.eventLoopUtilization(elu, previousELU)
     }
 
-    if (!features.node.worker.getHeapStatistics || options.noHeapCheck) {
+    if (!features.node.worker.getHeapStatistics) {
       return { elu: elu.utilization, currentELU }
     }
 
-    const { used_heap_size: heapUsed, total_heap_size: heapTotal } = await worker.getHeapStatistics()
+    // Only check heap statistics every 60 health checks (once per minute)
+    const counter = (worker[kHeapCheckCounter] ?? 0) + 1
+    worker[kHeapCheckCounter] = counter >= 60 ? 0 : counter
+
+    if (counter >= 60 || !worker[kLastHeapStats]) {
+      const { used_heap_size: heapUsed, total_heap_size: heapTotal } = await worker.getHeapStatistics()
+      worker[kLastHeapStats] = { heapUsed, heapTotal }
+    }
+
+    const { heapUsed, heapTotal } = worker[kLastHeapStats]
     return { elu: elu.utilization, heapUsed, heapTotal, currentELU }
   }
 
@@ -1396,7 +1526,10 @@ export class Runtime extends EventEmitter {
       interceptors.push(
         undiciInterceptors.cache({
           store: this.#sharedHttpCache,
-          methods: config.httpCache.methods ?? ['GET', 'HEAD']
+          methods: config.httpCache.methods ?? ['GET', 'HEAD'],
+          origins: parseOrigins(config.httpCache.origins),
+          cacheByDefault: config.httpCache.cacheByDefault,
+          type: config.httpCache.type
         })
       )
     }
@@ -1564,7 +1697,8 @@ export class Runtime extends EventEmitter {
         codeRangeSizeMb
       },
       stdout: true,
-      stderr: true
+      stderr: true,
+      name: workerId
     })
 
     this.#handleWorkerStandardStreams(worker, applicationId, index)
@@ -1753,8 +1887,7 @@ export class Runtime extends EventEmitter {
         let health = null
         try {
           health = await this.getWorkerHealth(worker, {
-            previousELU: worker[kLastHealthCheckELU],
-            noHeapCheck: worker[kConfig]?.health?.noHeapCheck
+            previousELU: worker[kLastHealthCheckELU]
           })
         } catch (err) {
           this.logger.error({ err }, `Failed to get health for ${errorLabel}.`)
@@ -1798,7 +1931,7 @@ export class Runtime extends EventEmitter {
 
     const healthConfig = worker[kConfig].health
 
-    let { maxELU, maxHeapUsed, maxHeapTotal, maxUnhealthyChecks, interval, noHeapCheck } = worker[kConfig].health
+    let { maxELU, maxHeapUsed, maxHeapTotal, maxUnhealthyChecks, interval } = worker[kConfig].health
 
     if (typeof maxHeapTotal === 'string') {
       maxHeapTotal = parseMemorySize(maxHeapTotal)
@@ -1829,8 +1962,8 @@ export class Runtime extends EventEmitter {
 
       if (lastHealthMetrics) {
         const health = lastHealthMetrics.currentHealth
-        const memoryUsage = noHeapCheck ? 0 : health.heapUsed / maxHeapTotal
-        const unhealthy = health.elu > maxELU || (!noHeapCheck && memoryUsage > maxHeapUsed)
+        const memoryUsage = health.heapUsed / maxHeapTotal
+        const unhealthy = health.elu > maxELU || memoryUsage > maxHeapUsed
 
         this.emit('application:worker:health', {
           id: worker[kId],
@@ -1848,7 +1981,7 @@ export class Runtime extends EventEmitter {
           )
         }
 
-        if (!noHeapCheck && memoryUsage > maxHeapUsed) {
+        if (memoryUsage > maxHeapUsed) {
           this.logger.error(
             `The ${errorLabel} is using ${(memoryUsage * 100).toFixed(2)} % of the memory, ` +
               `above the maximum allowed usage of ${(maxHeapUsed * 100).toFixed(2)} %.`

package/lib/worker/interceptors.js

@@ -178,7 +178,23 @@ function createThreadInterceptor (runtimeConfig) {
   return threadDispatcher
 }
 
+function parseOrigins (origins) {
+  if (!origins) return undefined
+
+  return origins.map(origin => {
+    // Check if the origin is a regex pattern (starts and ends with /)
+    if (origin.startsWith('/') && origin.lastIndexOf('/') > 0) {
+      const lastSlash = origin.lastIndexOf('/')
+      const pattern = origin.slice(1, lastSlash)
+      const flags = origin.slice(lastSlash + 1)
+      return new RegExp(pattern, flags)
+    }
+    return origin
+  })
+}
+
 function createHttpCacheInterceptor (runtimeConfig) {
+  const httpCache = runtimeConfig.httpCache
   const cacheInterceptor = httpCacheInterceptor({
     store: new RemoteCacheStore({
       onRequest: opts => {
@@ -192,7 +208,10 @@ function createHttpCacheInterceptor (runtimeConfig) {
       },
       logger: globalThis.platformatic.logger
     }),
-    methods: runtimeConfig.httpCache.methods ?? ['GET', 'HEAD'],
+    methods: httpCache.methods ?? ['GET', 'HEAD'],
+    origins: parseOrigins(httpCache.origins),
+    cacheByDefault: httpCache.cacheByDefault,
+    type: httpCache.type,
     logger: globalThis.platformatic.logger
   })
   return cacheInterceptor

package/lib/worker/main.js

@@ -9,11 +9,11 @@ import { EventEmitter } from 'node:events'
 import { ServerResponse } from 'node:http'
 import inspector from 'node:inspector'
 import { hostname } from 'node:os'
-import { resolve } from 'node:path'
+import { join, resolve } from 'node:path'
 import { pathToFileURL } from 'node:url'
 import { threadId, workerData } from 'node:worker_threads'
 import pino from 'pino'
-import { fetch } from 'undici'
+import { install as installUndiciGlobals } from 'undici'
 import { Controller } from './controller.js'
 import { setDispatcher } from './interceptors.js'
 import { setupITC } from './itc.js'
@@ -85,8 +85,59 @@ async function performPreloading (...sources) {
   }
 }
 
+// Enable compile cache if configured (Node.js 22.1.0+)
+async function setupCompileCache (runtimeConfig, applicationConfig, logger) {
+  // Normalize boolean shorthand: true -> { enabled: true }
+  const normalizeConfig = cfg => {
+    if (cfg === true) return { enabled: true }
+    if (cfg === false) return { enabled: false }
+    return cfg
+  }
+
+  // Merge runtime and app-level config (app overrides runtime)
+  const runtimeCache = normalizeConfig(runtimeConfig.compileCache)
+  const appCache = normalizeConfig(applicationConfig.compileCache)
+  const config = { ...runtimeCache, ...appCache }
+
+  if (!config.enabled) {
+    return
+  }
+
+  // Check if API is available (Node.js 22.1.0+)
+  let moduleApi
+  try {
+    moduleApi = await import('node:module')
+    if (typeof moduleApi.enableCompileCache !== 'function') {
+      return
+    }
+  } catch {
+    return
+  }
+
+  // Determine cache directory - use applicationConfig.path for the app root
+  const cacheDir = config.directory ?? join(applicationConfig.path, '.plt', 'compile-cache')
+
+  try {
+    const result = moduleApi.enableCompileCache(cacheDir)
+
+    const { compileCacheStatus } = moduleApi.constants ?? {}
+
+    if (result.status === compileCacheStatus?.ENABLED) {
+      logger.debug({ directory: result.directory }, 'Module compile cache enabled')
+    } else if (result.status === compileCacheStatus?.ALREADY_ENABLED) {
+      logger.debug({ directory: result.directory }, 'Module compile cache already enabled')
+    } else if (result.status === compileCacheStatus?.FAILED) {
+      logger.warn({ message: result.message }, 'Failed to enable module compile cache')
+    } else if (result.status === compileCacheStatus?.DISABLED) {
+      logger.debug('Module compile cache disabled via NODE_DISABLE_COMPILE_CACHE')
+    }
+  } catch (err) {
+    logger.warn({ err }, 'Error enabling module compile cache')
+  }
+}
+
 async function main () {
-  globalThis.fetch = fetch
+  installUndiciGlobals(globalThis)
   globalThis[kId] = threadId
   globalThis.platformatic = Object.assign(globalThis.platformatic ?? {}, {
     logger: createLogger(),
@@ -94,10 +145,12 @@ async function main () {
   })
 
   const runtimeConfig = workerData.config
+  const applicationConfig = workerData.applicationConfig
 
-  await performPreloading(runtimeConfig, workerData.applicationConfig)
+  // Enable compile cache early before loading user modules
+  await setupCompileCache(runtimeConfig, applicationConfig, globalThis.platformatic.logger)
 
-  const applicationConfig = workerData.applicationConfig
+  await performPreloading(runtimeConfig, applicationConfig)
 
   // Load env file and mixin env vars from application config
   let envfile

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@platformatic/runtime",
-  "version": "3.32.0-alpha.0",
+  "version": "3.32.0",
   "description": "",
   "main": "index.js",
   "type": "module",
@@ -35,14 +35,14 @@
     "typescript": "^5.5.4",
     "undici-oidc-interceptor": "^0.5.0",
     "why-is-node-running": "^2.2.2",
-    "@platformatic/composer": "3.32.0-alpha.0",
-    "@platformatic/db": "3.32.0-alpha.0",
-    "@platformatic/node": "3.32.0-alpha.0",
-    "@platformatic/service": "3.32.0-alpha.0",
-    "@platformatic/gateway": "3.32.0-alpha.0",
-    "@platformatic/sql-graphql": "3.32.0-alpha.0",
-    "@platformatic/wattpm-pprof-capture": "3.32.0-alpha.0",
-    "@platformatic/sql-mapper": "3.32.0-alpha.0"
+    "@platformatic/composer": "3.32.0",
+    "@platformatic/db": "3.32.0",
+    "@platformatic/gateway": "3.32.0",
+    "@platformatic/node": "3.32.0",
+    "@platformatic/sql-graphql": "3.32.0",
+    "@platformatic/service": "3.32.0",
+    "@platformatic/sql-mapper": "3.32.0",
+    "@platformatic/wattpm-pprof-capture": "3.32.0"
   },
   "dependencies": {
     "@fastify/accepts": "^5.0.0",
@@ -71,12 +71,12 @@
     "undici": "^7.0.0",
     "undici-thread-interceptor": "^1.0.0",
     "ws": "^8.16.0",
-    "@platformatic/basic": "3.32.0-alpha.0",
-    "@platformatic/foundation": "3.32.0-alpha.0",
-    "@platformatic/generators": "3.32.0-alpha.0",
-    "@platformatic/itc": "3.32.0-alpha.0",
-    "@platformatic/metrics": "3.32.0-alpha.0",
-    "@platformatic/telemetry": "3.32.0-alpha.0"
+    "@platformatic/basic": "3.32.0",
+    "@platformatic/foundation": "3.32.0",
+    "@platformatic/generators": "3.32.0",
+    "@platformatic/itc": "3.32.0",
+    "@platformatic/metrics": "3.32.0",
+    "@platformatic/telemetry": "3.32.0"
   },
   "engines": {
     "node": ">=22.19.0"

package/schema.json

@@ -1,5 +1,5 @@
 {
-  "$id": "https://schemas.platformatic.dev/@platformatic/runtime/3.32.0-alpha.0.json",
+  "$id": "https://schemas.platformatic.dev/@platformatic/runtime/3.32.0.json",
   "$schema": "http://json-schema.org/draft-07/schema#",
   "title": "Platformatic Runtime Config",
   "type": "object",
@@ -208,16 +208,6 @@
                         "type": "string"
                       }
                     ]
-                  },
-                  "noHeapCheck": {
-                    "anyOf": [
-                      {
-                        "type": "boolean"
-                      },
-                      {
-                        "type": "string"
-                      }
-                    ]
                   }
                 },
                 "additionalProperties": false
@@ -342,6 +332,28 @@
                     }
                   }
                 }
+              },
+              "compileCache": {
+                "anyOf": [
+                  {
+                    "type": "boolean"
+                  },
+                  {
+                    "type": "object",
+                    "properties": {
+                      "enabled": {
+                        "type": "boolean",
+                        "default": true,
+                        "description": "Enable Node.js module compile cache for faster startup"
+                      },
+                      "directory": {
+                        "type": "string",
+                        "description": "Directory to store compile cache. Defaults to .plt/compile-cache in app root"
+                      }
+                    },
+                    "additionalProperties": false
+                  }
+                ]
               }
             }
           }
@@ -532,16 +544,6 @@
                     "type": "string"
                   }
                 ]
-              },
-              "noHeapCheck": {
-                "anyOf": [
-                  {
-                    "type": "boolean"
-                  },
-                  {
-                    "type": "string"
-                  }
-                ]
               }
             },
             "additionalProperties": false
@@ -666,6 +668,28 @@
                 }
               }
             }
+          },
+          "compileCache": {
+            "anyOf": [
+              {
+                "type": "boolean"
+              },
+              {
+                "type": "object",
+                "properties": {
+                  "enabled": {
+                    "type": "boolean",
+                    "default": true,
+                    "description": "Enable Node.js module compile cache for faster startup"
+                  },
+                  "directory": {
+                    "type": "string",
+                    "description": "Directory to store compile cache. Defaults to .plt/compile-cache in app root"
+                  }
+                },
+                "additionalProperties": false
+              }
+            ]
           }
         }
       }
@@ -854,16 +878,6 @@
                     "type": "string"
                   }
                 ]
-              },
-              "noHeapCheck": {
-                "anyOf": [
-                  {
-                    "type": "boolean"
-                  },
-                  {
-                    "type": "string"
-                  }
-                ]
               }
             },
             "additionalProperties": false
@@ -988,6 +1002,28 @@
                 }
               }
             }
+          },
+          "compileCache": {
+            "anyOf": [
+              {
+                "type": "boolean"
+              },
+              {
+                "type": "object",
+                "properties": {
+                  "enabled": {
+                    "type": "boolean",
+                    "default": true,
+                    "description": "Enable Node.js module compile cache for faster startup"
+                  },
+                  "directory": {
+                    "type": "string",
+                    "description": "Directory to store compile cache. Defaults to .plt/compile-cache in app root"
+                  }
+                },
+                "additionalProperties": false
+              }
+            ]
           }
         }
       }
@@ -1176,16 +1212,6 @@
                     "type": "string"
                   }
                 ]
-              },
-              "noHeapCheck": {
-                "anyOf": [
-                  {
-                    "type": "boolean"
-                  },
-                  {
-                    "type": "string"
-                  }
-                ]
               }
             },
             "additionalProperties": false
@@ -1310,6 +1336,28 @@
                 }
               }
             }
+          },
+          "compileCache": {
+            "anyOf": [
+              {
+                "type": "boolean"
+              },
+              {
+                "type": "object",
+                "properties": {
+                  "enabled": {
+                    "type": "boolean",
+                    "default": true,
+                    "description": "Enable Node.js module compile cache for faster startup"
+                  },
+                  "directory": {
+                    "type": "string",
+                    "description": "Directory to store compile cache. Defaults to .plt/compile-cache in app root"
+                  }
+                },
+                "additionalProperties": false
+              }
+            ]
           }
         }
       }
@@ -1389,7 +1437,6 @@
       "properties": {
         "level": {
           "type": "string",
-          "default": "info",
           "oneOf": [
             {
               "enum": [
@@ -1536,9 +1583,6 @@
           "default": true
         }
       },
-      "required": [
-        "level"
-      ],
       "default": {},
       "additionalProperties": true
     },
@@ -1834,17 +1878,6 @@
             }
           ],
           "default": 268435456
-        },
-        "noHeapCheck": {
-          "anyOf": [
-            {
-              "type": "boolean"
-            },
-            {
-              "type": "string"
-            }
-          ],
-          "default": false
         }
       },
       "additionalProperties": false
@@ -1976,6 +2009,26 @@
             },
             "maxCount": {
               "type": "integer"
+            },
+            "origins": {
+              "type": "array",
+              "items": {
+                "type": "string"
+              },
+              "description": "Whitelist of origins to cache. Supports exact strings and regex patterns (e.g., \"/https:\\\\/\\\\/.*\\\\.example\\\\.com/\")."
+            },
+            "cacheByDefault": {
+              "type": "integer",
+              "description": "Default cache duration in seconds for responses without explicit expiration headers."
+            },
+            "type": {
+              "type": "string",
+              "enum": [
+                "shared",
+                "private"
+              ],
+              "default": "shared",
+              "description": "Cache type. \"shared\" caches may be shared between users, \"private\" caches are user-specific."
             }
           }
         }
@@ -2621,6 +2674,28 @@
         "deny"
       ],
       "additionalProperties": false
+    },
+    "compileCache": {
+      "anyOf": [
+        {
+          "type": "boolean"
+        },
+        {
+          "type": "object",
+          "properties": {
+            "enabled": {
+              "type": "boolean",
+              "default": true,
+              "description": "Enable Node.js module compile cache for faster startup"
+            },
+            "directory": {
+              "type": "string",
+              "description": "Directory to store compile cache. Defaults to .plt/compile-cache in app root"
+            }
+          },
+          "additionalProperties": false
+        }
+      ]
     }
   },
   "anyOf": [