@platformatic/next 3.53.0 → 3.54.0

package/config.d.ts

@@ -517,7 +517,7 @@ export interface PlatformaticNextJsConfig {
       /**
        * Enable the OpenTelemetry diagnostic logger. Diagnostic messages are forwarded to the Platformatic global logger using the current logger level.
        */
-      diagLogger?: boolean;
+      diagLogger?: boolean | string;
     };
     verticalScaler?: {
       enabled?: boolean;

package/index.js

@@ -1,21 +1,8 @@
-import { transform as basicTransform, resolve, validationOptions } from '@platformatic/basic'
-import { kMetadata, loadConfiguration as utilsLoadConfiguration } from '@platformatic/foundation'
+import { kMetadata } from '@platformatic/foundation'
 import { resolve as resolvePath } from 'node:path'
 import { getCacheHandlerPath, NextCapability } from './lib/capability.js'
+import { loadConfiguration } from './lib/config.js'
 import { NextImageOptimizerCapability } from './lib/image-optimizer.js'
-import { schema } from './lib/schema.js'
-
-/* c8 ignore next 9 */
-export async function transform (config, schema, options) {
-  config = await basicTransform(config, schema, options)
-  config.watch = { enabled: false }
-
-  if (config.cache?.adapter === 'redis') {
-    config.cache.adapter = 'valkey'
-  }
-
-  return config
-}
 
 export function getAdapterPath () {
   return resolvePath(import.meta.dirname, 'lib', 'adapter.js')
@@ -99,18 +86,6 @@ export async function enhanceNextConfig (nextConfig, ...args) {
   return nextConfig
 }
 
-export async function loadConfiguration (configOrRoot, sourceOrConfig, context) {
-  const { root, source } = await resolve(configOrRoot, sourceOrConfig, 'application')
-
-  return utilsLoadConfiguration(source, context?.schema ?? schema, {
-    validationOptions,
-    transform,
-    replaceEnv: true,
-    root,
-    ...context
-  })
-}
-
 export async function create (configOrRoot, sourceOrConfig, context) {
   const config = await loadConfiguration(configOrRoot, sourceOrConfig, context)
 
@@ -119,6 +94,8 @@ export async function create (configOrRoot, sourceOrConfig, context) {
 }
 
 export * from './lib/capability.js'
+export * from './lib/commands/index.js'
+export * from './lib/config.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/capability.js

@@ -11,14 +11,12 @@ import {
 } from '@platformatic/basic'
 import { ChildProcess } from 'node:child_process'
 import { once } from 'node:events'
-import { existsSync } from 'node:fs'
-import { glob, readFile, writeFile } from 'node:fs/promises'
-import { createRequire } from 'node:module'
+import { readFile, writeFile } from 'node:fs/promises'
 import { dirname, resolve as resolvePath, sep } from 'node:path'
 import { fileURLToPath } from 'node:url'
 import { parse, satisfies } from 'semver'
-import * as errors from './errors.js'
 import { version } from './schema.js'
+import { parseStandaloneNextConfig, requireStandaloneStartServer, resolveStandaloneEntrypoint } from './standalone.js'
 
 export const supportedVersions = ['^14.0.0', '^15.0.0', '^16.0.0']
 
@@ -53,7 +51,7 @@ export class NextCapability extends BaseCapability {
     process.env.NEXT_IGNORE_INCORRECT_LOCKFILE = 'true'
 
     if (!building && this.isProduction && this.config.next?.standalone) {
-      this.#standaloneEntrypoint = await this.#resolveStandaloneEntrypoint()
+      this.#standaloneEntrypoint = await resolveStandaloneEntrypoint(this.root)
       this.#next = resolvePath(dirname(await resolvePackageViaCJS(this.#standaloneEntrypoint, 'next')), '../..')
     } else {
       this.#next = resolvePath(dirname(await resolvePackageViaCJS(this.root, 'next')), '../..')
@@ -382,14 +380,7 @@ export class NextCapability extends BaseCapability {
 
     // Parse the server.js to extract the nextConfig.
     // For now we use simple regex parsing, if it breaks, we can switch to proper AST parsing.
-    let nextConfig
-    try {
-      const serverJsContent = await readFile(this.#standaloneEntrypoint, 'utf-8')
-      const nextConfigMatch = serverJsContent.match(/(?:const|let)\s*nextConfig\s*=\s*(\{.+)/)
-      nextConfig = JSON.parse(nextConfigMatch[1])
-    } catch (e) {
-      throw new errors.CannotParseStandaloneServer({ cause: e })
-    }
+    const nextConfig = await parseStandaloneNextConfig(this.#standaloneEntrypoint)
 
     // Fix cache handlers path
     if (nextConfig.env?.PLT_NEXT_MODIFICATIONS) {
@@ -430,7 +421,7 @@ export class NextCapability extends BaseCapability {
 
       // This is needed by Next.js standalone server to pick up the correct configuration
       process.env.__NEXT_PRIVATE_STANDALONE_CONFIG = JSON.stringify(nextConfig)
-      const { startServer } = this.#requireStandaloneEntrypoint(this.#standaloneEntrypoint)
+      const { startServer } = requireStandaloneStartServer(this.#standaloneEntrypoint)
 
       await startServer({
         dir: dirname(this.#standaloneEntrypoint),
@@ -529,45 +520,4 @@ export class NextCapability extends BaseCapability {
 
     return distDir
   }
-
-  async #resolveStandaloneEntrypoint () {
-    // If built in standalone mode, the generated standalone directory is not on the root of the project but somewhere
-    // inside .next/standalone due to turbopack limitations in determining the root of the project.
-    // In that case we search a server.js next to a .next folder inside the .next /standalone folder.
-    const serverEntrypoints = await Array.fromAsync(
-      glob(['**/server.js'], { cwd: this.root, ignore: ['node_modules', '**/node_modules/**'] })
-    )
-
-    let serverEntrypoint
-    for (const entrypoint of serverEntrypoints) {
-      if (existsSync(resolvePath(this.root, dirname(entrypoint), '.next'))) {
-        const candidate = resolvePath(this.root, entrypoint)
-        const contents = await readFile(candidate, 'utf-8')
-
-        if (contents.includes('process.env.__NEXT_PRIVATE_STANDALONE_CONFIG =')) {
-          serverEntrypoint = candidate
-          break
-        }
-      }
-    }
-
-    if (!serverEntrypoint) {
-      throw new errors.StandaloneServerNotFound()
-    }
-
-    return serverEntrypoint
-  }
-
-  #requireStandaloneEntrypoint (serverEntrypoint) {
-    let serverModule
-
-    try {
-      serverModule = createRequire(serverEntrypoint)('next/dist/server/lib/start-server.js')
-    } catch (e) {
-      // Fallback to bundled capability
-      serverModule = createRequire(import.meta.file)('next/dist/server/lib/start-server.js')
-    }
-
-    return serverModule.default ?? serverModule
-  }
 }

package/lib/commands/index.js

@@ -0,0 +1,26 @@
+import { packCommand, helpFooter as packHelpFooter } from './pack.js'
+
+export function createCommands (id) {
+  return {
+    commands: {
+      [`${id}:pack`]: packCommand
+    },
+    help: {
+      [`${id}:pack`]: {
+        usage: `${id}:pack`,
+        description: 'Create a self-contained standalone bundle for a Next.js application',
+        footer: packHelpFooter,
+        options: [
+          {
+            usage: '-o, --output <path>',
+            description: 'Output directory for the packed bundle'
+          },
+          {
+            usage: '--no-build',
+            description: 'Fail if the standalone build output is missing instead of building it first'
+          }
+        ]
+      }
+    }
+  }
+}

package/lib/commands/pack.js

@@ -0,0 +1,121 @@
+import { ensureLoggableError, findRuntimeConfigurationFile, kMetadata, logFatalError } from '@platformatic/foundation'
+import { dirname } from 'node:path'
+import {
+  copyStandaloneFiles,
+  ensurePortableNodeModules,
+  materializeRuntimeDependencies,
+  prepareBundleDirectory,
+  resolveOutputDirectory,
+  writeBundleConfiguration,
+  writeBundleMetadata
+} from '../pack.js'
+import { NextCapability } from '../capability.js'
+import { loadConfiguration } from '../config.js'
+import { resolveStandaloneEntrypoint } from '../standalone.js'
+
+export async function packCommand (logger, configFile, args, context) {
+  const {
+    values: { output, 'no-build': noBuild },
+    positionals
+  } = context.parseArgs(
+    args,
+    {
+      output: {
+        type: 'string',
+        short: 'o'
+      },
+      'no-build': {
+        type: 'boolean'
+      }
+    },
+    false
+  )
+
+  if (positionals.length > 0) {
+    return logFatalError(logger, `Unexpected positional arguments: ${positionals.join(' ')}`)
+  }
+
+  let config
+  try {
+    config = await loadConfiguration(configFile)
+  } catch (error) {
+    return logFatalError(
+      logger,
+      { err: ensureLoggableError(error) },
+      `Cannot load the Next.js application configuration: ${error.message}`
+    )
+  }
+
+  if (config.next?.standalone !== true) {
+    return logFatalError(logger, 'The Next.js pack command requires next.standalone to be set to true.')
+  }
+
+  const applicationRoot = config[kMetadata].root
+  const applicationId = context.application?.id ?? 'main'
+  const invocationCwd = context.cwd ?? process.cwd()
+  const bundleRoot = resolveOutputDirectory(output, `.platformatic/${applicationId}-bundle`, invocationCwd)
+
+  let standaloneEntrypoint
+  try {
+    standaloneEntrypoint = await resolveStandaloneEntrypoint(applicationRoot)
+  } catch (error) {
+    if (noBuild) {
+      return logFatalError(logger, 'Cannot find a Next standalone build. Run the build first or omit --no-build.')
+    }
+
+    const capability = new NextCapability(applicationRoot, config, {
+      applicationId,
+      isProduction: true
+    })
+
+    try {
+      logger.info(`Building application ${applicationId} before packing ...`)
+      await capability.build()
+      standaloneEntrypoint = await resolveStandaloneEntrypoint(applicationRoot)
+    } catch (buildError) {
+      return logFatalError(
+        logger,
+        { err: ensureLoggableError(buildError) },
+        `Cannot build the Next.js application for packing: ${buildError.message}`
+      )
+    }
+  }
+
+  const standaloneRoot = dirname(standaloneEntrypoint)
+
+  try {
+    const runtimeConfig = await findRuntimeConfigurationFile(logger, invocationCwd, null, false, false, false)
+
+    await prepareBundleDirectory(bundleRoot)
+    await copyStandaloneFiles({ applicationRoot, standaloneRoot, bundleRoot })
+    await writeBundleConfiguration(config, bundleRoot)
+    const packages = await materializeRuntimeDependencies({ bundleRoot, logger })
+    await writeBundleMetadata({
+      applicationId,
+      applicationConfig: configFile,
+      runtimeConfig,
+      bundleRoot,
+      packages
+    })
+    await ensurePortableNodeModules(bundleRoot)
+  } catch (error) {
+    return logFatalError(
+      logger,
+      { err: ensureLoggableError(error) },
+      `Cannot pack the Next.js application: ${error.message}`
+    )
+  }
+
+  logger.done(`Packed application ${applicationId} into ${bundleRoot}.`)
+}
+
+export const helpFooter = `
+This command only supports Next.js applications configured with:
+
+- Next.js standalone output enabled in next.config.js
+- next.standalone = true in the Platformatic application config
+
+The packed output is intended to be started with:
+
+- ./node_modules/.bin/wattpm start
+`

package/lib/config.js

@@ -0,0 +1,26 @@
+import { transform as basicTransform, resolve, validationOptions } from '@platformatic/basic'
+import { loadConfiguration as utilsLoadConfiguration } from '@platformatic/foundation'
+import { schema } from './schema.js'
+
+export async function transform (config, schema, options) {
+  config = await basicTransform(config, schema, options)
+  config.watch = { enabled: false }
+
+  if (config.cache?.adapter === 'redis') {
+    config.cache.adapter = 'valkey'
+  }
+
+  return config
+}
+
+export async function loadConfiguration (configOrRoot, sourceOrConfig, context) {
+  const { root, source } = await resolve(configOrRoot, sourceOrConfig, 'application')
+
+  return utilsLoadConfiguration(source, context?.schema ?? schema, {
+    validationOptions,
+    transform,
+    replaceEnv: true,
+    root,
+    ...context
+  })
+}

package/lib/pack.js

@@ -0,0 +1,467 @@
+import { saveConfigurationFile } from '@platformatic/foundation'
+import { spawn } from 'node:child_process'
+import { existsSync } from 'node:fs'
+import {
+  chmod,
+  cp,
+  lstat,
+  mkdir,
+  mkdtemp,
+  readFile,
+  readdir,
+  readlink,
+  realpath,
+  rm,
+  symlink,
+  writeFile
+} from 'node:fs/promises'
+import { createRequire } from 'node:module'
+import { tmpdir } from 'node:os'
+import { dirname, isAbsolute, relative, resolve as resolvePath } from 'node:path'
+import { version as platformaticVersion } from './schema.js'
+
+const runtimePackages = ['wattpm', '@platformatic/next']
+
+export function resolveOutputDirectory (output, fallback, cwd) {
+  const target = output ?? fallback
+  return isAbsolute(target) ? target : resolvePath(cwd, target)
+}
+
+export async function prepareBundleDirectory (directory) {
+  await rm(directory, { recursive: true, force: true })
+  await mkdir(directory, { recursive: true })
+}
+
+export async function copyStandaloneFiles ({ applicationRoot, standaloneRoot, bundleRoot }) {
+  await cp(standaloneRoot, bundleRoot, {
+    recursive: true,
+    dereference: true,
+    preserveTimestamps: true
+  })
+
+  try {
+    await cp(resolvePath(applicationRoot, '.next', 'static'), resolvePath(bundleRoot, '.next', 'static'), {
+      recursive: true,
+      force: true,
+      errorOnExist: false,
+      preserveTimestamps: true
+    })
+  } catch (error) {
+    if (error.code !== 'ENOENT') {
+      throw error
+    }
+  }
+
+  try {
+    await cp(resolvePath(applicationRoot, 'public'), resolvePath(bundleRoot, 'public'), {
+      recursive: true,
+      force: true,
+      errorOnExist: false,
+      preserveTimestamps: true
+    })
+  } catch (error) {
+    if (error.code !== 'ENOENT') {
+      throw error
+    }
+  }
+}
+
+export async function writeBundleConfiguration (config, bundleRoot) {
+  const bundleConfig = JSON.parse(JSON.stringify(config))
+  bundleConfig.next ??= {}
+  bundleConfig.next.standalone = true
+  await saveConfigurationFile(resolvePath(bundleRoot, 'watt.json'), bundleConfig)
+}
+
+export async function materializeRuntimeDependencies ({ bundleRoot, logger }) {
+  const bundleNodeModules = resolvePath(bundleRoot, 'node_modules')
+  const stagingRoot = await mkdtemp(resolvePath(tmpdir(), 'platformatic-next-pack-'))
+
+  try {
+    await mkdir(bundleNodeModules, { recursive: true })
+
+    const workspacePackages = await collectWorkspacePackages(runtimePackages)
+    const tarballDirectory = resolvePath(stagingRoot, 'tarballs')
+    const dependencies = {}
+    const packages = new Map()
+
+    await mkdir(tarballDirectory, { recursive: true })
+
+    for (const name of runtimePackages) {
+      const pkg = workspacePackages.get(name) ?? (await loadInstalledPackage(name, import.meta.url))
+      packages.set(pkg.name, pkg)
+    }
+
+    for (const pkg of workspacePackages.values()) {
+      const tarball = await packWorkspacePackage(pkg, tarballDirectory)
+      dependencies[pkg.name] = `file:${relative(stagingRoot, tarball)}`
+    }
+
+    for (const pkg of packages.values()) {
+      dependencies[pkg.name] ??= pkg.version
+    }
+
+    await writeFile(
+      resolvePath(stagingRoot, 'package.json'),
+      JSON.stringify({ name: 'platformatic-next-pack', private: true, dependencies }, null, 2),
+      'utf-8'
+    )
+
+    await runCommand('npm', ['install', '--omit=dev', '--ignore-scripts', '--no-fund', '--no-audit'], { cwd: stagingRoot })
+    await mergeDirectory(resolvePath(stagingRoot, 'node_modules'), bundleNodeModules)
+    await cleanupBrokenSymlinks(resolvePath(bundleNodeModules, '.bin'))
+    await writePackageBins(packages, bundleNodeModules)
+
+    logger?.debug?.({ packages: [...packages.keys()] }, 'Materialized runtime packages for packed bundle.')
+
+    return packages
+  } finally {
+    await rm(stagingRoot, { recursive: true, force: true })
+  }
+}
+
+async function collectWorkspacePackages (rootNames) {
+  const packages = new Map()
+  const queue = [...rootNames]
+
+  while (queue.length) {
+    const name = queue.shift()
+    if (packages.has(name)) {
+      continue
+    }
+
+    const root = resolveWorkspacePackageRoot(name)
+    if (!root) {
+      continue
+    }
+
+    const pkg = await loadPackageFromRoot(root, name)
+    packages.set(pkg.name, pkg)
+
+    for (const dependencyName of listWorkspaceDependencies(pkg.packageJson)) {
+      queue.push(dependencyName)
+    }
+  }
+
+  return packages
+}
+
+function listWorkspaceDependencies (packageJson) {
+  return Object.keys({
+    ...(packageJson.dependencies ?? {}),
+    ...(packageJson.optionalDependencies ?? {})
+  }).filter(name => !!resolveWorkspacePackageRoot(name))
+}
+
+async function loadInstalledPackage (name, from) {
+  const root = await realpath(await resolvePackageRoot(name, from))
+  return loadPackageFromRoot(root, name)
+}
+
+async function loadPackageFromRoot (root, fallbackName) {
+  const packageJson = JSON.parse(await readFile(resolvePath(root, 'package.json'), 'utf-8'))
+  return {
+    name: packageJson.name ?? fallbackName,
+    version: packageJson.version,
+    root,
+    packageJson
+  }
+}
+
+async function resolvePackageRoot (name, from) {
+  const require = createRequire(from)
+
+  try {
+    const packageJsonPath = require.resolve(`${name}/package.json`)
+    return dirname(packageJsonPath)
+  } catch (error) {
+    const packageJsonPath = resolvePackageJsonFromSearchPaths(require, name)
+    if (packageJsonPath) {
+      return dirname(packageJsonPath)
+    }
+
+    try {
+      const resolvedEntry = require.resolve(name)
+      return await findPackageRoot(dirname(resolvedEntry))
+    } catch (resolveError) {
+      const workspacePackage = resolveWorkspacePackageRoot(name)
+      if (workspacePackage) {
+        return workspacePackage
+      }
+
+      throw resolveError
+    }
+  }
+}
+
+function resolvePackageJsonFromSearchPaths (require, name) {
+  const searchPaths = require.resolve.paths(name) ?? []
+  const packageSegments = name.split('/')
+
+  for (const searchPath of searchPaths) {
+    const candidate = resolvePath(searchPath, ...packageSegments, 'package.json')
+    if (existsSync(candidate)) {
+      return candidate
+    }
+  }
+
+  return null
+}
+
+async function findPackageRoot (directory) {
+  let current = directory
+
+  while (true) {
+    const candidate = resolvePath(current, 'package.json')
+    if (existsSync(candidate)) {
+      return current
+    }
+
+    const parent = resolvePath(current, '..')
+    if (parent === current) {
+      throw new Error(`Cannot determine package root for ${directory}.`)
+    }
+
+    current = parent
+  }
+}
+
+function resolveWorkspacePackageRoot (name) {
+  if (name !== 'wattpm' && !name.startsWith('@platformatic/')) {
+    return null
+  }
+
+  const packageDirectory = name === 'wattpm' ? 'wattpm' : name.replace('@platformatic/', '')
+  const candidate = resolvePath(import.meta.dirname, '..', '..', packageDirectory)
+
+  if (existsSync(resolvePath(candidate, 'package.json'))) {
+    return candidate
+  }
+
+  return null
+}
+
+async function packWorkspacePackage (pkg, tarballDirectory) {
+  const { stdout } = await runCommand('pnpm', ['pack', '--pack-destination', tarballDirectory], { cwd: pkg.root })
+  const tarball = stdout
+    .split('\n')
+    .map(line => line.trim())
+    .filter(line => line.endsWith('.tgz'))
+    .at(-1)
+
+  if (!tarball) {
+    throw new Error(`Cannot determine the tarball path for ${pkg.name}.`)
+  }
+
+  return tarball
+}
+
+async function runCommand (command, args, options) {
+  return await new Promise((resolve, reject) => {
+    const child = spawn(command, args, {
+      cwd: options.cwd,
+      env: process.env,
+      stdio: ['ignore', 'pipe', 'pipe']
+    })
+
+    let stdout = ''
+    let stderr = ''
+
+    child.stdout.on('data', chunk => {
+      stdout += chunk.toString()
+    })
+
+    child.stderr.on('data', chunk => {
+      stderr += chunk.toString()
+    })
+
+    child.on('error', reject)
+    child.on('close', code => {
+      if (code === 0) {
+        resolve({ stdout, stderr })
+      } else {
+        reject(new Error(`Command failed: ${command} ${args.join(' ')}\n${stderr || stdout}`))
+      }
+    })
+  })
+}
+
+async function mergeDirectory (source, destination) {
+  await mkdir(destination, { recursive: true })
+  const entries = await readdir(source, { withFileTypes: true })
+
+  for (const entry of entries) {
+    const sourcePath = resolvePath(source, entry.name)
+    const destinationPath = resolvePath(destination, entry.name)
+    const stats = await lstat(sourcePath)
+
+    if (stats.isSymbolicLink()) {
+      await copySymlink(sourcePath, destinationPath)
+      continue
+    }
+
+    if (entry.isDirectory()) {
+      if (!existsSync(destinationPath)) {
+        await cp(sourcePath, destinationPath, {
+          recursive: true,
+          dereference: false,
+          preserveTimestamps: true
+        })
+      } else {
+        await mergeDirectory(sourcePath, destinationPath)
+      }
+      continue
+    }
+
+    if (!existsSync(destinationPath)) {
+      await cp(sourcePath, destinationPath, { dereference: false, preserveTimestamps: true })
+    }
+  }
+}
+
+async function copySymlink (source, destination) {
+  if (existsSync(destination)) {
+    return
+  }
+
+  await mkdir(dirname(destination), { recursive: true })
+  await symlink(await readlink(source), destination)
+}
+
+async function cleanupBrokenSymlinks (directory) {
+  if (!existsSync(directory)) {
+    return
+  }
+
+  const entries = await readdir(directory, { withFileTypes: true })
+
+  for (const entry of entries) {
+    const path = resolvePath(directory, entry.name)
+    const stats = await lstat(path)
+
+    if (!stats.isSymbolicLink()) {
+      continue
+    }
+
+    try {
+      await realpath(path)
+    } catch (error) {
+      if (error.code === 'ENOENT') {
+        await rm(path, { force: true })
+        continue
+      }
+
+      throw error
+    }
+  }
+}
+
+async function writePackageBins (packages, bundleNodeModules) {
+  const binDirectory = resolvePath(bundleNodeModules, '.bin')
+  await mkdir(binDirectory, { recursive: true })
+
+  for (const pkg of packages.values()) {
+    const bin = normalizeBinField(pkg.packageJson.bin, pkg.name)
+    for (const [name, target] of Object.entries(bin)) {
+      await writeNodeShim(resolvePath(binDirectory, name), pkg.name, target)
+    }
+  }
+}
+
+function normalizeBinField (bin, pkgName) {
+  if (!bin) {
+    return {}
+  }
+
+  if (typeof bin === 'string') {
+    return { [pkgName]: bin }
+  }
+
+  return bin
+}
+
+async function writeNodeShim (destination, packageName, target) {
+  const normalizedTarget = target.replaceAll('\\', '/')
+  const unixScript = `#!/usr/bin/env node\nimport '../${packageName}/${normalizedTarget}'\n`
+
+  await rm(destination, { force: true })
+  await rm(`${destination}.cmd`, { force: true })
+  await writeFile(destination, unixScript, 'utf-8')
+  await chmod(destination, 0o755)
+  await writeFile(
+    `${destination}.cmd`,
+    `@ECHO off\r\nnode "%~dp0\\..\\${packageName.replaceAll('/', '\\')}\\${normalizedTarget.replaceAll('/', '\\')}" %*\r\n`,
+    'utf-8'
+  )
+}
+
+export async function writeBundleMetadata ({
+  applicationId,
+  applicationConfig,
+  runtimeConfig,
+  bundleRoot,
+  packages
+}) {
+  const metadataRoot = resolvePath(bundleRoot, '.platformatic')
+  await mkdir(metadataRoot, { recursive: true })
+
+  await writeFile(
+    resolvePath(metadataRoot, 'manifest.json'),
+    JSON.stringify(
+      {
+        bundleVersion: 1,
+        applicationId,
+        packedAt: new Date().toISOString(),
+        source: {
+          applicationConfig,
+          runtimeConfig: runtimeConfig ?? null
+        },
+        platformaticVersion,
+        packages: Object.fromEntries(
+          [...packages.values()].map(pkg => [pkg.name, { version: pkg.version, root: pkg.root }])
+        )
+      },
+      null,
+      2
+    ) + '\n',
+    'utf-8'
+  )
+
+  await writeFile(
+    resolvePath(metadataRoot, 'NOTICE'),
+    'This directory was generated by the Next standalone pack command.\n',
+    'utf-8'
+  )
+}
+
+export async function ensurePortableNodeModules (bundleRoot) {
+  const nodeModules = resolvePath(bundleRoot, 'node_modules')
+  await assertNoExternalSymlinks(nodeModules, bundleRoot)
+}
+
+async function assertNoExternalSymlinks (directory, bundleRoot) {
+  const entries = await readdir(directory, { withFileTypes: true })
+
+  for (const entry of entries) {
+    const path = resolvePath(directory, entry.name)
+    const stats = await lstat(path)
+
+    if (stats.isSymbolicLink()) {
+      let target
+      try {
+        target = await realpath(path)
+      } catch (error) {
+        if (error.code === 'ENOENT') {
+          continue
+        }
+        throw error
+      }
+
+      if (!target.startsWith(bundleRoot)) {
+        throw new Error(`Packed bundle contains a symlink outside the bundle: ${relative(bundleRoot, path)} -> ${target}`)
+      }
+    } else if (entry.isDirectory()) {
+      await assertNoExternalSymlinks(path, bundleRoot)
+    }
+  }
+}

package/lib/standalone.js

@@ -0,0 +1,51 @@
+import { existsSync } from 'node:fs'
+import { glob, readFile } from 'node:fs/promises'
+import { createRequire } from 'node:module'
+import { dirname, resolve as resolvePath } from 'node:path'
+import * as errors from './errors.js'
+
+export async function resolveStandaloneEntrypoint (root) {
+  const serverEntrypoints = await Array.fromAsync(
+    glob(['server.js', '.next/standalone/**/server.js', '**/server.js'], {
+      cwd: root,
+      exclude: ['node_modules', '**/node_modules/**']
+    })
+  )
+
+  for (const entrypoint of serverEntrypoints) {
+    if (entrypoint !== 'server.js' && !existsSync(resolvePath(root, dirname(entrypoint), '.next'))) {
+      continue
+    }
+
+    const candidate = resolvePath(root, entrypoint)
+    const contents = await readFile(candidate, 'utf-8')
+
+    if (contents.includes('process.env.__NEXT_PRIVATE_STANDALONE_CONFIG =')) {
+      return candidate
+    }
+  }
+
+  throw new errors.StandaloneServerNotFound()
+}
+
+export async function parseStandaloneNextConfig (serverEntrypoint) {
+  try {
+    const serverJsContent = await readFile(serverEntrypoint, 'utf-8')
+    const nextConfigMatch = serverJsContent.match(/(?:const|let)\s*nextConfig\s*=\s*(\{.+)/)
+    return JSON.parse(nextConfigMatch[1])
+  } catch (e) {
+    throw new errors.CannotParseStandaloneServer({ cause: e })
+  }
+}
+
+export function requireStandaloneStartServer (serverEntrypoint) {
+  let serverModule
+
+  try {
+    serverModule = createRequire(serverEntrypoint)('next/dist/server/lib/start-server.js')
+  } catch (e) {
+    serverModule = createRequire(import.meta.url)('next/dist/server/lib/start-server.js')
+  }
+
+  return serverModule.default ?? serverModule
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@platformatic/next",
-  "version": "3.53.0",
+  "version": "3.54.0",
   "description": "Platformatic Next.js Capability",
   "main": "index.js",
   "type": "module",
@@ -25,8 +25,8 @@
     "light-my-request": "^6.0.0",
     "msgpackr": "^1.11.2",
     "semver": "^7.6.3",
-    "@platformatic/basic": "3.53.0",
-    "@platformatic/foundation": "3.53.0"
+    "@platformatic/foundation": "3.54.0",
+    "@platformatic/basic": "3.54.0"
   },
   "devDependencies": {
     "@fastify/reply-from": "^12.0.0",
@@ -43,8 +43,8 @@
     "next": "^16.1.0",
     "typescript": "^5.5.4",
     "ws": "^8.18.0",
-    "@platformatic/gateway": "3.53.0",
-    "@platformatic/service": "3.53.0"
+    "@platformatic/gateway": "3.54.0",
+    "@platformatic/service": "3.54.0"
   },
   "engines": {
     "node": ">=22.19.0"

package/schema.json

@@ -1,5 +1,5 @@
 {
-  "$id": "https://schemas.platformatic.dev/@platformatic/next/3.53.0.json",
+  "$id": "https://schemas.platformatic.dev/@platformatic/next/3.54.0.json",
   "$schema": "http://json-schema.org/draft-07/schema#",
   "title": "Platformatic Next.js Config",
   "type": "object",
@@ -1918,7 +1918,14 @@
               ]
             },
             "diagLogger": {
-              "type": "boolean",
+              "anyOf": [
+                {
+                  "type": "boolean"
+                },
+                {
+                  "type": "string"
+                }
+              ],
               "description": "Enable the OpenTelemetry diagnostic logger. Diagnostic messages are forwarded to the Platformatic global logger using the current logger level."
             }
           },