nept-frameworks 0.1.0

package/dist/index.js

@@ -0,0 +1,849 @@
+// src/lib/dockerfile-generator.ts
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+
+// src/framework-defaults.ts
+var supported = {
+  next: {
+    displayName: "Next.js",
+    language: "TypeScript",
+    stackType: "fullstack",
+    defaultPort: 3000,
+    defaultRuntime: "node",
+    defaultVersion: "24.18.0-trixie-slim",
+    status: "supported",
+    deployment: {
+      kind: "js-artifact",
+      selfContained: true,
+      copies: [
+        ["/app/public", "./public"],
+        ["/app/.next/standalone", "./"],
+        ["/app/.next/static", "./.next/static"]
+      ],
+      entrypoint: "server.js"
+    }
+  },
+  nuxt: {
+    displayName: "Nuxt",
+    language: "TypeScript",
+    stackType: "fullstack",
+    defaultPort: 3000,
+    defaultRuntime: "node",
+    defaultVersion: "24.18.0-trixie-slim",
+    status: "supported",
+    deployment: {
+      kind: "js-artifact",
+      selfContained: true,
+      copies: [["/app/.output", "./.output"]],
+      entrypoint: ".output/server/index.mjs"
+    }
+  },
+  astro: {
+    displayName: "Astro",
+    language: "TypeScript",
+    stackType: "fullstack",
+    defaultPort: 3000,
+    defaultRuntime: "node",
+    defaultVersion: "24.18.0-trixie-slim",
+    status: "supported",
+    deployment: {
+      kind: "js-artifact",
+      selfContained: false,
+      copies: [["/app/dist", "./dist"]],
+      entrypoint: "dist/server/entry.mjs"
+    }
+  },
+  sveltekit: {
+    displayName: "SvelteKit",
+    language: "TypeScript",
+    stackType: "fullstack",
+    defaultPort: 3000,
+    defaultRuntime: "node",
+    defaultVersion: "24.18.0-trixie-slim",
+    status: "supported",
+    deployment: {
+      kind: "js-artifact",
+      selfContained: false,
+      copies: [["/app/build", "./build"]],
+      entrypoint: "build/index.js"
+    }
+  },
+  remix: {
+    displayName: "Remix",
+    language: "TypeScript",
+    stackType: "fullstack",
+    defaultPort: 3000,
+    defaultRuntime: "node",
+    defaultVersion: "24.18.0-trixie-slim",
+    status: "supported",
+    deployment: {
+      kind: "js-artifact",
+      selfContained: false,
+      copies: [["/app/build", "./build"]],
+      entrypoint: "node_modules/@remix-run/serve/dist/cli.js",
+      entrypointArgument: "build/server/index.js"
+    }
+  },
+  qwik: {
+    displayName: "Qwik",
+    language: "TypeScript",
+    stackType: "fullstack",
+    defaultPort: 3000,
+    defaultRuntime: "node",
+    defaultVersion: "24.18.0-trixie-slim",
+    status: "supported",
+    deployment: {
+      kind: "js-artifact",
+      selfContained: false,
+      copies: [
+        ["/app/dist", "./dist"],
+        ["/app/server", "./server"]
+      ],
+      entrypoint: "server/entry.node-server.js"
+    }
+  }
+};
+var planned = (displayName, language, stackType, defaultPort, defaultRuntime, defaultVersion) => ({
+  displayName,
+  language,
+  stackType,
+  defaultPort,
+  defaultRuntime,
+  defaultVersion,
+  status: "planned"
+});
+var excluded = (displayName, language, defaultPort) => ({
+  displayName,
+  language,
+  stackType: "static",
+  defaultPort,
+  defaultRuntime: "nginx",
+  defaultVersion: "1.29.8-alpine",
+  status: "excluded"
+});
+var FRAMEWORK_DEFAULTS = {
+  ...supported,
+  express: {
+    ...planned("Express", "JavaScript", "backend", 3000, "node", "24.18.0-trixie-slim"),
+    status: "supported",
+    deployment: { kind: "js-source", build: false, entrypoint: "server.js" }
+  },
+  nest: {
+    ...planned("NestJS", "TypeScript", "backend", 3000, "node", "24.18.0-trixie-slim"),
+    status: "supported",
+    deployment: { kind: "js-source", build: true, entrypoint: "dist/main.js" }
+  },
+  fastify: {
+    ...planned("Fastify", "JavaScript", "backend", 3000, "node", "24.18.0-trixie-slim"),
+    status: "supported",
+    deployment: { kind: "js-source", build: false, entrypoint: "server.js" }
+  },
+  koa: {
+    ...planned("Koa", "JavaScript", "backend", 3000, "node", "24.18.0-trixie-slim"),
+    status: "supported",
+    deployment: { kind: "js-source", build: false, entrypoint: "server.js" }
+  },
+  deno: {
+    ...planned("Deno", "TypeScript", "backend", 8000, "deno", "2.9.2"),
+    status: "supported",
+    deployment: { kind: "deno-source", entrypoint: "main.ts" }
+  },
+  bun: {
+    ...planned("Bun", "TypeScript", "backend", 3000, "bun", "1.3.14-slim"),
+    status: "supported",
+    deployment: { kind: "bun-source", entrypoint: "server.ts" }
+  },
+  django: {
+    ...planned("Django", "Python", "backend", 8000, "python", "3.14.6-slim-trixie"),
+    status: "supported",
+    deployment: { kind: "python", command: ["gunicorn", "config.wsgi:application", "--bind", "0.0.0.0:8000"] }
+  },
+  flask: {
+    ...planned("Flask", "Python", "backend", 8000, "python", "3.14.6-slim-trixie"),
+    status: "supported",
+    deployment: { kind: "python", command: ["gunicorn", "app:app", "--bind", "0.0.0.0:8000"] }
+  },
+  fastapi: {
+    ...planned("FastAPI", "Python", "backend", 8000, "python", "3.14.6-slim-trixie"),
+    status: "supported",
+    deployment: { kind: "python", command: ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "8000"] }
+  },
+  python: {
+    ...planned("Python", "Python", "backend", 8000, "python", "3.14.6-slim-trixie"),
+    status: "supported",
+    deployment: { kind: "python", command: ["gunicorn", "app:app", "--bind", "0.0.0.0:8000"] }
+  },
+  go: {
+    ...planned("Go", "Go", "backend", 8080, "go", "1.26.5-trixie"),
+    status: "supported",
+    deployment: { kind: "go" }
+  },
+  gin: {
+    ...planned("Gin", "Go", "backend", 8080, "go", "1.26.5-trixie"),
+    status: "supported",
+    deployment: { kind: "go" }
+  },
+  echo: {
+    ...planned("Echo", "Go", "backend", 1323, "go", "1.26.5-trixie"),
+    status: "supported",
+    deployment: { kind: "go" }
+  },
+  rust: {
+    ...planned("Rust", "Rust", "backend", 8080, "rust", "1.97.0-slim-trixie"),
+    status: "supported",
+    deployment: { kind: "rust" }
+  },
+  actix: {
+    ...planned("Actix Web", "Rust", "backend", 8080, "rust", "1.97.0-slim-trixie"),
+    status: "supported",
+    deployment: { kind: "rust" }
+  },
+  rocket: {
+    ...planned("Rocket", "Rust", "backend", 8000, "rust", "1.97.0-slim-trixie"),
+    status: "supported",
+    deployment: { kind: "rust" }
+  },
+  java: {
+    ...planned("Java", "Java", "backend", 8080, "java", "25.0.3_9-jre-noble"),
+    status: "supported",
+    deployment: { kind: "java", mode: "class" }
+  },
+  springBoot: {
+    ...planned("Spring Boot", "Java", "backend", 8080, "java", "25.0.3_9-jre-noble"),
+    status: "supported",
+    deployment: { kind: "java", mode: "jar" }
+  },
+  quarkus: {
+    ...planned("Quarkus", "Java", "backend", 8080, "java", "25.0.3_9-jre-noble"),
+    status: "supported",
+    deployment: { kind: "java", mode: "quarkus" }
+  },
+  ruby: {
+    ...planned("Ruby", "Ruby", "backend", 4567, "ruby", "4.0.5-slim-trixie"),
+    status: "supported",
+    deployment: { kind: "ruby", command: ["ruby", "app.rb"] }
+  },
+  rails: {
+    ...planned("Ruby on Rails", "Ruby", "backend", 3000, "ruby", "4.0.5-slim-trixie"),
+    status: "supported",
+    deployment: { kind: "ruby", command: ["bundle", "exec", "rails", "server", "-b", "0.0.0.0", "-p", "3000"] }
+  },
+  php: {
+    ...planned("PHP", "PHP", "backend", 8080, "php", "8.5.8-apache-trixie"),
+    status: "supported",
+    deployment: { kind: "php" }
+  },
+  laravel: {
+    ...planned("Laravel", "PHP", "backend", 8080, "php", "8.5.8-apache-trixie"),
+    status: "supported",
+    deployment: { kind: "php" }
+  },
+  symfony: {
+    ...planned("Symfony", "PHP", "backend", 8080, "php", "8.5.8-apache-trixie"),
+    status: "supported",
+    deployment: { kind: "php" }
+  },
+  csharp: {
+    ...planned("C#", "C#", "backend", 8080, "dotnet", "10.0-noble"),
+    status: "supported",
+    deployment: { kind: "dotnet", aspnet: false, dll: "App.dll" }
+  },
+  aspnet: {
+    ...planned("ASP.NET Core", "C#", "backend", 8080, "dotnet", "10.0-noble"),
+    status: "supported",
+    deployment: { kind: "dotnet", aspnet: true, dll: "App.dll" }
+  },
+  other: {
+    ...planned("Other", "Other", "backend", 8080, "custom", "required"),
+    status: "supported",
+    deployment: { kind: "custom" }
+  },
+  html: excluded("HTML/CSS/JS", "HTML", 80),
+  react: excluded("React", "JavaScript", 80),
+  vue: excluded("Vue", "JavaScript", 80),
+  angular: excluded("Angular", "TypeScript", 80),
+  svelte: excluded("Svelte", "JavaScript", 80),
+  vite: excluded("Vite", "JavaScript", 80),
+  gatsby: excluded("Gatsby", "JavaScript", 80),
+  solid: excluded("Solid", "JavaScript", 80)
+};
+function getJavaScriptDeployment(framework) {
+  const deployment = FRAMEWORK_DEFAULTS[framework].deployment;
+  if (deployment?.kind !== "js-artifact") {
+    throw new Error(`${framework} is not an artifact framework`);
+  }
+  return deployment;
+}
+function defaultVersionFor(runtime) {
+  if (runtime === "bun")
+    return "1.3.14-slim";
+  if (runtime === "deno")
+    return "2.9.2";
+  return "24.18.0-trixie-slim";
+}
+
+// src/lib/dockerfile-generator.ts
+var packageManagers = {
+  bun: {
+    lockfile: "bun.lock",
+    install: "bun install --frozen-lockfile",
+    production: "bun install --frozen-lockfile --production",
+    build: "bun run build",
+    cache: "/root/.bun/install/cache"
+  },
+  npm: {
+    lockfile: "package-lock.json",
+    install: "npm ci --no-audit --no-fund",
+    production: "npm prune --omit=dev",
+    build: "npm run build",
+    cache: "/root/.npm"
+  },
+  pnpm: {
+    lockfile: "pnpm-lock.yaml",
+    install: "corepack enable && pnpm install --frozen-lockfile",
+    production: "pnpm prune --prod",
+    build: "pnpm run build",
+    cache: "/root/.local/share/pnpm/store"
+  },
+  yarn: {
+    lockfile: "yarn.lock",
+    install: "corepack enable && yarn install --immutable",
+    production: "yarn workspaces focus --production",
+    build: "yarn run build",
+    cache: "/root/.yarn/berry/cache"
+  }
+};
+var DOCKERIGNORE = `node_modules
+.next
+.nuxt
+.output
+dist
+build
+.svelte-kit
+.astro
+.git
+.env*
+!.env.example
+coverage
+*.log
+`;
+var NEXT_DOCKERIGNORE = DOCKERIGNORE;
+function detectPackageManager(projectDir = ".") {
+  const matches = Object.entries(packageManagers).filter(([, value]) => existsSync(join(projectDir, value.lockfile)));
+  if (matches.length !== 1) {
+    throw new Error(matches.length === 0 ? `No supported lockfile found in ${projectDir}` : `Multiple lockfiles found in ${projectDir}: ${matches.map(([, value]) => value.lockfile).join(", ")}`);
+  }
+  return matches[0][0];
+}
+function inferPackageManager(installCommand) {
+  if (!installCommand)
+    return detectPackageManager();
+  const command = installCommand.trim();
+  if (/^(?:corepack enable && )?pnpm\b/.test(command))
+    return "pnpm";
+  if (/^(?:corepack enable && )?yarn\b/.test(command))
+    return "yarn";
+  if (/^npm\b/.test(command))
+    return "npm";
+  if (/^bun\b/.test(command))
+    return "bun";
+  return detectPackageManager();
+}
+function inferRuntime(framework, command) {
+  if (framework === "bun")
+    return "bun";
+  if (framework === "deno")
+    return "deno";
+  if (command && /^(?:\[\s*"bun"|bun\b)/.test(command.trim()))
+    return "bun";
+  return FRAMEWORK_DEFAULTS[framework].defaultRuntime;
+}
+function isJavaScriptFramework(framework) {
+  const kind = FRAMEWORK_DEFAULTS[framework].deployment?.kind;
+  return kind === "js-artifact" || kind === "js-source";
+}
+function applyParams(dockerfile, params, defaultOutput) {
+  let result = dockerfile;
+  if (params.outputDir && defaultOutput) {
+    if (/[\r\n]/.test(params.outputDir) || params.outputDir.includes("..")) {
+      throw new Error(`Invalid output directory: ${params.outputDir}`);
+    }
+    const output = `/app/${params.outputDir.replace(/^\.\//, "").replace(/\/$/, "")}`;
+    result = result.replaceAll(defaultOutput, output);
+  }
+  const buildInstructions = [
+    params.installCMD && `RUN ${singleLine(params.installCMD, "install command")}`,
+    ...(params.buildCMD ?? []).map((command) => `RUN ${singleLine(command, "build command")}`)
+  ].filter(Boolean).join(`
+`);
+  if (buildInstructions)
+    result = insertBeforeRuntime(result, buildInstructions);
+  const environment = Object.entries(params.envVars).map(([key, value]) => {
+    if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(key)) {
+      throw new Error(`Invalid environment variable name: ${key}`);
+    }
+    return `ENV ${key}=${JSON.stringify(value)}`;
+  }).join(`
+`);
+  if (environment)
+    result = insertBeforeFinalUser(result, environment);
+  if (params.runCMD) {
+    result = insertBeforeFinalCommand(result, `RUN ${singleLine(params.runCMD, "run command")}`);
+  }
+  if (params.cmd) {
+    result = result.replace(/CMD [^\n]+(?=\n?$)/, `CMD ${singleLine(params.cmd, "CMD")}`);
+  }
+  return result;
+}
+function insertBeforeRuntime(dockerfile, instructions) {
+  const firstStage = dockerfile.indexOf(`
+FROM `);
+  const runtime = dockerfile.lastIndexOf(`
+FROM `);
+  if (runtime !== -1 && runtime !== firstStage) {
+    return `${dockerfile.slice(0, runtime)}
+${instructions}
+${dockerfile.slice(runtime)}`;
+  }
+  return insertBeforeFinalUser(dockerfile, instructions);
+}
+function insertBeforeFinalUser(dockerfile, instructions) {
+  const user = dockerfile.lastIndexOf(`
+USER `);
+  if (user !== -1) {
+    return `${dockerfile.slice(0, user)}
+${instructions}${dockerfile.slice(user)}`;
+  }
+  return insertBeforeFinalCommand(dockerfile, instructions);
+}
+function insertBeforeFinalCommand(dockerfile, instructions) {
+  const command = dockerfile.lastIndexOf(`
+CMD `);
+  if (command === -1)
+    return `${dockerfile.trimEnd()}
+${instructions}
+`;
+  return `${dockerfile.slice(0, command)}
+${instructions}${dockerfile.slice(command)}`;
+}
+function singleLine(value, label) {
+  if (!value.trim() || /[\r\n]/.test(value))
+    throw new Error(`Invalid ${label}`);
+  return value.trim();
+}
+function generateDockerfile(params) {
+  const framework = Object.keys(FRAMEWORK_DEFAULTS).find((candidate) => candidate.toLowerCase() === params.framework.toLowerCase());
+  if (!framework)
+    throw new Error(`Unsupported framework: ${params.framework}`);
+  const runtime = inferRuntime(framework, params.cmd);
+  const packageManager = inferPackageManager(params.installCMD);
+  const version = params.version || FRAMEWORK_DEFAULTS[framework].defaultVersion;
+  const bunVersion = runtime === "bun" || framework === "bun" ? version : defaultVersionFor("bun");
+  const composerVersion = "2.10.2";
+  const denoVersion = framework === "deno" ? version : defaultVersionFor("deno");
+  const dotnetVersion = framework === "csharp" || framework === "aspnet" ? version : FRAMEWORK_DEFAULTS.csharp.defaultVersion;
+  const goVersion = ["go", "gin", "echo"].includes(framework) ? version : FRAMEWORK_DEFAULTS.go.defaultVersion;
+  const javaVersion = ["java", "springBoot", "quarkus"].includes(framework) ? version : FRAMEWORK_DEFAULTS.java.defaultVersion;
+  const mavenVersion = "3.9.16-eclipse-temurin-25-noble";
+  const nodeVersion = isJavaScriptFramework(framework) && runtime === "node" ? version : defaultVersionFor("node");
+  const phpVersion = ["php", "laravel", "symfony"].includes(framework) ? version : FRAMEWORK_DEFAULTS.php.defaultVersion;
+  const pythonVersion = ["django", "flask", "fastapi", "python"].includes(framework) ? version : FRAMEWORK_DEFAULTS.python.defaultVersion;
+  const rubyVersion = ["ruby", "rails"].includes(framework) ? version : FRAMEWORK_DEFAULTS.ruby.defaultVersion;
+  const rustVersion = ["rust", "actix", "rocket"].includes(framework) ? version : FRAMEWORK_DEFAULTS.rust.defaultVersion;
+  const finish = (dockerfile, outputDir) => applyParams(dockerfile, params, outputDir);
+  validateImageTag(bunVersion);
+  validateImageTag(composerVersion);
+  validateImageTag(denoVersion);
+  validateImageTag(dotnetVersion);
+  validateImageTag(goVersion);
+  validateImageTag(javaVersion);
+  validateImageTag(mavenVersion);
+  validateImageTag(nodeVersion);
+  validateImageTag(phpVersion);
+  validateImageTag(pythonVersion);
+  validateImageTag(rubyVersion);
+  validateImageTag(rustVersion);
+  const deployment = FRAMEWORK_DEFAULTS[framework].deployment;
+  if (!deployment)
+    throw new Error(`Unsupported framework: ${framework}`);
+  if (deployment.kind === "deno-source") {
+    return finish(generateDenoDockerfile(deployment.entrypoint, denoVersion));
+  }
+  if (deployment.kind === "bun-source") {
+    return finish(generateBunSourceDockerfile(deployment.entrypoint, bunVersion));
+  }
+  if (deployment.kind === "python") {
+    return finish(generatePythonDockerfile(pythonVersion, FRAMEWORK_DEFAULTS[framework].defaultPort, deployment.command));
+  }
+  if (deployment.kind === "go") {
+    return finish(generateGoDockerfile(FRAMEWORK_DEFAULTS[framework].defaultPort, goVersion));
+  }
+  if (deployment.kind === "rust") {
+    return finish(generateRustDockerfile(FRAMEWORK_DEFAULTS[framework].defaultPort, rustVersion));
+  }
+  if (deployment.kind === "java") {
+    return finish(generateJavaDockerfile(deployment.mode, FRAMEWORK_DEFAULTS[framework].defaultPort, javaVersion, mavenVersion));
+  }
+  if (deployment.kind === "ruby") {
+    return finish(generateRubyDockerfile(rubyVersion, FRAMEWORK_DEFAULTS[framework].defaultPort, deployment.command));
+  }
+  if (deployment.kind === "php") {
+    return finish(generatePhpDockerfile(phpVersion, composerVersion));
+  }
+  if (deployment.kind === "dotnet") {
+    return finish(generateDotnetDockerfile(deployment.aspnet, deployment.dll, dotnetVersion));
+  }
+  if (deployment.kind === "custom") {
+    return generateParamDockerfile(params);
+  }
+  if (deployment.kind === "js-source") {
+    return finish(generateJavaScriptSourceDockerfile({
+      build: deployment.build,
+      bunVersion,
+      entrypoint: deployment.entrypoint,
+      nodeVersion,
+      packageManager,
+      runtime
+    }));
+  }
+  const manager = packageManager;
+  const commands = packageManagers[manager];
+  const target = getJavaScriptDeployment(framework);
+  if (!commands)
+    throw new Error(`Unsupported package manager: ${manager}`);
+  if (!target)
+    throw new Error(`Unsupported framework: ${framework}`);
+  if (runtime !== "bun" && runtime !== "node") {
+    throw new Error(`Unsupported runtime: ${runtime}`);
+  }
+  const buildImage = manager === "bun" ? `oven/bun:${bunVersion}` : `node:${nodeVersion}`;
+  const runtimeImage = runtime === "bun" ? `oven/bun:${bunVersion}` : `node:${nodeVersion}`;
+  const user = runtime === "bun" ? "bun" : "node";
+  const buildEnvironment = framework === "nuxt" ? `ENV NITRO_PRESET=${runtime === "bun" ? "bun" : "node-server"}
+` : "";
+  const prepareBuild = framework === "next" ? "mkdir -p public && " : "";
+  const buildCache = framework === "next" ? "--mount=type=cache,target=/app/.next/cache " : "";
+  const productionDependencies = target.selfContained ? "" : `
+FROM dependencies AS production-dependencies
+RUN ${commands.production}
+`;
+  const prepareRuntime = framework === "next" ? `RUN mkdir .next && chown ${user}:${user} .next
+` : "";
+  const copyDependencies = target.selfContained ? "" : `COPY --from=production-dependencies --chown=${user}:${user} /app/node_modules ./node_modules
+COPY --from=production-dependencies --chown=${user}:${user} /app/package.json ./package.json
+`;
+  const copies = target.copies.map(([source, destination]) => `COPY --from=build --chown=${user}:${user} ${source} ${destination}`).join(`
+`);
+  const command = [runtime, target.entrypoint, target.entrypointArgument].filter(Boolean).map((part) => JSON.stringify(part)).join(", ");
+  return finish(`# syntax=docker/dockerfile:1
+
+ARG BUILD_IMAGE=${buildImage}
+ARG RUNTIME_IMAGE=${runtimeImage}
+
+FROM \${BUILD_IMAGE} AS dependencies
+WORKDIR /app
+COPY package.json ${commands.lockfile} ./
+RUN --mount=type=cache,target=${commands.cache} ${commands.install}
+${productionDependencies}
+FROM dependencies AS build
+WORKDIR /app
+COPY . .
+ENV NEXT_TELEMETRY_DISABLED=1
+${buildEnvironment}RUN ${buildCache}${prepareBuild}${commands.build}
+
+FROM \${RUNTIME_IMAGE} AS runtime
+WORKDIR /app
+ENV NODE_ENV=production \\
+    NEXT_TELEMETRY_DISABLED=1 \\
+    HOST=0.0.0.0 \\
+    HOSTNAME=0.0.0.0 \\
+    PORT=3000
+${prepareRuntime}${copyDependencies}${copies}
+USER ${user}
+EXPOSE 3000
+CMD [${command}]
+`, (target.copies.find(([, destination]) => destination === "./") ?? target.copies[0])?.[0]);
+}
+function generateJavaScriptSourceDockerfile({
+  build,
+  bunVersion,
+  entrypoint,
+  nodeVersion,
+  packageManager,
+  runtime
+}) {
+  if (runtime !== "bun" && runtime !== "node") {
+    throw new Error(`Unsupported runtime for JavaScript server: ${runtime}`);
+  }
+  const commands = packageManagers[packageManager];
+  const buildImage = packageManager === "bun" ? `oven/bun:${bunVersion}` : `node:${nodeVersion}`;
+  const runtimeImage = runtime === "bun" ? `oven/bun:${bunVersion}` : `node:${nodeVersion}`;
+  const user = runtime;
+  const buildStage = build ? `
+FROM dependencies AS build
+COPY . .
+RUN ${commands.build}
+` : "";
+  const sourceCopy = build ? `COPY --from=build --chown=${user}:${user} /app/dist ./dist
+COPY --from=build --chown=${user}:${user} /app/public ./public` : `COPY --chown=${user}:${user} . .`;
+  return `# syntax=docker/dockerfile:1
+
+FROM ${buildImage} AS dependencies
+WORKDIR /app
+COPY package.json ${commands.lockfile} ./
+RUN --mount=type=cache,target=${commands.cache} ${commands.install}
+
+FROM dependencies AS production-dependencies
+RUN ${commands.production}
+${buildStage}
+FROM ${runtimeImage} AS runtime
+WORKDIR /app
+ENV NODE_ENV=production HOST=0.0.0.0 PORT=3000
+COPY --from=production-dependencies --chown=${user}:${user} /app/node_modules ./node_modules
+COPY --from=production-dependencies --chown=${user}:${user} /app/package.json ./package.json
+${sourceCopy}
+USER ${user}
+EXPOSE 3000
+CMD [${JSON.stringify(runtime)}, ${JSON.stringify(entrypoint)}]
+`;
+}
+function generateDenoDockerfile(entrypoint, version) {
+  return `# syntax=docker/dockerfile:1
+
+FROM denoland/deno:${version} AS dependencies
+WORKDIR /app
+COPY deno.json ./
+COPY ${entrypoint} ./
+RUN deno cache ${entrypoint}
+
+FROM denoland/deno:${version} AS runtime
+WORKDIR /app
+ENV HOST=0.0.0.0 PORT=8000
+COPY --from=dependencies --chown=deno:deno /deno-dir /deno-dir
+COPY --chown=deno:deno . .
+USER deno
+EXPOSE 8000
+CMD ["run", "--allow-net", "--allow-read", "--allow-env", "${entrypoint}"]
+`;
+}
+function generateBunSourceDockerfile(entrypoint, bunVersion) {
+  return `# syntax=docker/dockerfile:1
+
+FROM oven/bun:${bunVersion} AS dependencies
+WORKDIR /app
+COPY package.json bun.lock ./
+RUN --mount=type=cache,target=/root/.bun/install/cache bun install --frozen-lockfile --production
+
+FROM oven/bun:${bunVersion} AS runtime
+WORKDIR /app
+ENV NODE_ENV=production HOST=0.0.0.0 PORT=3000
+COPY --from=dependencies --chown=bun:bun /app/node_modules ./node_modules
+COPY --chown=bun:bun . .
+USER bun
+EXPOSE 3000
+CMD ["bun", "${entrypoint}"]
+`;
+}
+function generatePythonDockerfile(version, port, command) {
+  return `# syntax=docker/dockerfile:1
+
+FROM python:${version} AS dependencies
+WORKDIR /app
+COPY requirements.txt ./
+RUN --mount=type=cache,target=/root/.cache/pip pip install --prefix=/install -r requirements.txt
+
+FROM python:${version} AS runtime
+WORKDIR /app
+ENV PYTHONDONTWRITEBYTECODE=1 PYTHONUNBUFFERED=1 PORT=${port}
+RUN useradd --create-home --uid 10001 app
+COPY --from=dependencies /install /usr/local
+COPY --chown=app:app . .
+USER app
+EXPOSE ${port}
+CMD [${command.map((part) => JSON.stringify(part)).join(", ")}]
+`;
+}
+function generateGoDockerfile(port, version) {
+  return `# syntax=docker/dockerfile:1
+
+FROM golang:${version} AS build
+WORKDIR /app
+COPY go.mod go.sum* ./
+RUN --mount=type=cache,target=/go/pkg/mod go mod download
+COPY . .
+RUN --mount=type=cache,target=/go/pkg/mod --mount=type=cache,target=/root/.cache/go-build CGO_ENABLED=0 go build -trimpath -ldflags="-s -w" -o /out/app .
+
+FROM debian:13.5-slim AS runtime
+WORKDIR /app
+ENV PORT=${port}
+COPY --from=build --chown=10001:10001 /out/app /app/app
+USER 10001:10001
+EXPOSE ${port}
+CMD ["/app/app"]
+`;
+}
+function generateRustDockerfile(port, version) {
+  return `# syntax=docker/dockerfile:1
+
+FROM rust:${version} AS build
+WORKDIR /app
+COPY Cargo.toml Cargo.lock ./
+COPY src ./src
+RUN --mount=type=cache,target=/usr/local/cargo/registry --mount=type=cache,target=/app/target cargo build --locked --release && cp target/release/app /tmp/app
+
+FROM debian:13.5-slim AS runtime
+WORKDIR /app
+ENV PORT=${port} ROCKET_ADDRESS=0.0.0.0 ROCKET_PORT=${port}
+COPY --from=build --chown=10001:10001 /tmp/app /app/app
+USER 10001:10001
+EXPOSE ${port}
+CMD ["/app/app"]
+`;
+}
+function generateJavaDockerfile(mode, port, version, mavenVersion) {
+  const jdkVersion = version.replace("-jre-", "-jdk-");
+  if (mode === "class") {
+    return `# syntax=docker/dockerfile:1
+
+FROM eclipse-temurin:${jdkVersion} AS build
+WORKDIR /app
+COPY Main.java ./
+RUN javac Main.java
+
+FROM eclipse-temurin:${version} AS runtime
+WORKDIR /app
+ENV PORT=${port}
+COPY --from=build --chown=10001:10001 /app/Main.class ./
+USER 10001:10001
+EXPOSE ${port}
+CMD ["java", "Main"]
+`;
+  }
+  const copy = mode === "jar" ? "COPY --from=build --chown=10001:10001 /app/target/app.jar /app/app.jar" : "COPY --from=build --chown=10001:10001 /app/target/quarkus-app /app/quarkus-app";
+  const command = mode === "jar" ? '["java", "-jar", "/app/app.jar"]' : '["java", "-jar", "/app/quarkus-app/quarkus-run.jar"]';
+  return `# syntax=docker/dockerfile:1
+
+FROM maven:${mavenVersion} AS build
+WORKDIR /app
+COPY pom.xml ./
+RUN --mount=type=cache,target=/root/.m2 mvn --batch-mode dependency:go-offline
+COPY src ./src
+RUN --mount=type=cache,target=/root/.m2 mvn --batch-mode package -DskipTests
+
+FROM eclipse-temurin:${version} AS runtime
+WORKDIR /app
+ENV PORT=${port}
+${copy}
+USER 10001:10001
+EXPOSE ${port}
+CMD ${command}
+`;
+}
+function generateRubyDockerfile(version, port, command) {
+  return `# syntax=docker/dockerfile:1
+
+FROM ruby:${version} AS dependencies
+WORKDIR /app
+RUN apt-get update && apt-get install -y --no-install-recommends build-essential && rm -rf /var/lib/apt/lists/*
+COPY Gemfile ./
+RUN --mount=type=cache,target=/usr/local/bundle/cache bundle config set without development:test && bundle lock && bundle install
+
+FROM ruby:${version} AS runtime
+WORKDIR /app
+ENV RAILS_ENV=production RACK_ENV=production PORT=${port}
+RUN useradd --create-home --uid 10001 app
+COPY --from=dependencies /usr/local/bundle /usr/local/bundle
+COPY --chown=app:app . .
+COPY --from=dependencies --chown=app:app /app/Gemfile.lock ./Gemfile.lock
+RUN mkdir -p tmp/pids log storage && chown -R app:app tmp log storage
+USER app
+EXPOSE ${port}
+CMD [${command.map((part) => JSON.stringify(part)).join(", ")}]
+`;
+}
+function generatePhpDockerfile(version, composerVersion) {
+  return `# syntax=docker/dockerfile:1
+
+FROM composer:${composerVersion} AS dependencies
+WORKDIR /app
+COPY composer.json ./
+RUN --mount=type=cache,target=/tmp/cache COMPOSER_CACHE_DIR=/tmp/cache composer install --no-dev --no-interaction --classmap-authoritative
+COPY . .
+RUN composer dump-autoload --no-dev --classmap-authoritative
+
+FROM php:${version} AS runtime
+WORKDIR /app
+ENV APACHE_DOCUMENT_ROOT=/app/public
+RUN a2enmod rewrite     && sed -ri 's!Listen 80!Listen 8080!; s!AllowOverride None!AllowOverride All!g' /etc/apache2/ports.conf /etc/apache2/apache2.conf     && rm -rf /var/www/html && ln -s /app/public /var/www/html     && mkdir -p /var/run/apache2 /var/lock/apache2 /var/log/apache2     && chown -R www-data:www-data /var/run/apache2 /var/lock/apache2 /var/log/apache2 /app
+COPY --from=dependencies --chown=www-data:www-data /app /app
+RUN mkdir -p storage/framework/cache storage/framework/sessions storage/framework/views bootstrap/cache     && chown -R www-data:www-data storage bootstrap/cache
+USER www-data
+EXPOSE 8080
+CMD ["apache2-foreground"]
+`;
+}
+function generateDotnetDockerfile(aspnet, dll, version) {
+  const runtime = aspnet ? "aspnet" : "runtime";
+  return `# syntax=docker/dockerfile:1
+
+FROM mcr.microsoft.com/dotnet/sdk:${version} AS build
+WORKDIR /src
+COPY *.csproj ./
+RUN --mount=type=cache,target=/root/.nuget/packages dotnet restore
+COPY . .
+RUN --mount=type=cache,target=/root/.nuget/packages dotnet publish -c Release -o /out --no-restore
+
+FROM mcr.microsoft.com/dotnet/${runtime}:${version} AS runtime
+WORKDIR /app
+ENV ASPNETCORE_HTTP_PORTS=8080 PORT=8080
+COPY --from=build --chown=app:app /out ./
+USER app
+EXPOSE 8080
+CMD ["dotnet", "${dll}"]
+`;
+}
+function generateParamDockerfile(params) {
+  const image = params.version.includes(":") ? params.version : `node:${params.version}`;
+  validateImage(image);
+  const workdir = params.outputDir ? `/app/${params.outputDir.replace(/^\.\//, "").replace(/\/$/, "")}` : "/app";
+  return applyParams(`# syntax=docker/dockerfile:1
+
+FROM ${image}
+WORKDIR /app
+COPY --chown=node:node . .
+WORKDIR ${workdir}
+USER node
+CMD ["node", "server.js"]
+`, { ...params, outputDir: null });
+}
+function validateImage(value) {
+  if (!/^[a-zA-Z0-9][a-zA-Z0-9_./:-]*$/.test(value)) {
+    throw new Error(`Invalid container image: ${value}`);
+  }
+}
+function validateImageTag(value) {
+  if (!/^[a-zA-Z0-9][a-zA-Z0-9_.-]*$/.test(value)) {
+    throw new Error(`Invalid container image tag: ${value}`);
+  }
+}
+
+// src/lib/next-js/next-dockerfile-generator.ts
+function generateNextDockerfile(options) {
+  return generateDockerfile({ ...options, framework: "next" });
+}
+
+// src/index.ts
+var detectPackageManager2 = detectPackageManager;
+var DOCKERIGNORE2 = DOCKERIGNORE;
+var FRAMEWORK_DEFAULTS2 = FRAMEWORK_DEFAULTS;
+var generateDockerfile2 = generateDockerfile;
+var generateNextDockerfile2 = generateNextDockerfile;
+var NEXT_DOCKERIGNORE2 = NEXT_DOCKERIGNORE;
+export {
+  generateNextDockerfile2 as generateNextDockerfile,
+  generateDockerfile2 as generateDockerfile,
+  detectPackageManager2 as detectPackageManager,
+  NEXT_DOCKERIGNORE2 as NEXT_DOCKERIGNORE,
+  FRAMEWORK_DEFAULTS2 as FRAMEWORK_DEFAULTS,
+  DOCKERIGNORE2 as DOCKERIGNORE
+};