@akanjs/devkit 3.0.0-beta.2 → 3.0.0-beta.20

package/applicationBuildRunner.test.ts

@@ -1,5 +1,7 @@
 import { describe, expect, test } from "bun:test";
 import { rm } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
 import { AKAN_BACKEND_MINIFY, AKAN_OPTIONAL_BACKEND_EXTERNALS } from "./applicationBuildRunner";
 
 describe("ApplicationBuildRunner", () => {
@@ -16,8 +18,8 @@ describe("ApplicationBuildRunner", () => {
   });
 
   test("a bundler that mangles identifiers loses the class name a Logger reads", async () => {
-    const dir = `${process.env.TMPDIR ?? "/tmp"}/akan-minify-${Bun.randomUUIDv7()}`;
-    const entry = `${dir}/entry.ts`;
+    const dir = path.join(os.tmpdir(), `akan-minify-${Bun.randomUUIDv7()}`);
+    const entry = path.join(dir, "entry.ts");
     await Bun.write(
       entry,
       `const serve = () => class Service { readonly name = this.constructor.name; };
@@ -26,7 +28,7 @@ console.info(new SampleService().name);
 `,
     );
     const build = async (minify: Bun.BuildConfig["minify"]) => {
-      const result = await Bun.build({ entrypoints: [entry], target: "bun", minify, outdir: `${dir}/out` });
+      const result = await Bun.build({ entrypoints: [entry], target: "bun", minify, outdir: path.join(dir, "out") });
       expect(result.success).toBe(true);
       const proc = Bun.spawn([process.execPath, result.outputs[0].path], { stdout: "pipe" });
       return (await new Response(proc.stdout).text()).trim();

package/applicationBuildRunner.ts

@@ -60,9 +60,8 @@ const SSR_RENDER_EXTERNALS = [
   "react-server-dom-webpack/client.browser",
 ] as const;
 
-// Identifier mangling renames every class, and `this.constructor.name` is what names a service's logger, an
-// `Exception`, a guard, and every frame of a stack trace — for ~2% of boot on server bytes nothing downloads.
-// `minify.keepNames` typechecks and does nothing as of Bun 1.4.2.
+// Mangling renames classes, and `this.constructor.name` names loggers, exceptions and guards; `minify.keepNames`
+// is a no-op as of Bun 1.4.2.
 export const AKAN_BACKEND_MINIFY = { whitespace: true, syntax: true, identifiers: false } as const;
 
 export const AKAN_OPTIONAL_BACKEND_EXTERNALS = [
@@ -77,6 +76,7 @@ export class ApplicationBuildRunner {
   #app: App;
   #fast: boolean;
   #reporter?: BuildProgressReporter;
+  #spinner?: boolean;
   #startedAt = Date.now();
   #phases: BuildPhaseResult[] = [];
 
@@ -88,18 +88,15 @@ export class ApplicationBuildRunner {
 
   async build({ spinner = false }: BuildOptions = {}): Promise<BuildResult> {
     // serial build is needed because of Bun.build is unstable for parallel build
-    const phaseOptions = { spinner };
+    this.#spinner = spinner;
     const { web, assets } = await this.#app.getConfig();
-    await this.#runPhase("prepare", "Preparing output directory", () => this.#app.prepareCommand("build"), undefined, {
-      spinner,
-    });
-    if (!this.#fast) await this.#runPhase("typecheck", "Typechecking", () => this.typecheck(), undefined, phaseOptions);
+    await this.#runPhase("prepare", "Preparing output directory", () => this.#app.prepareCommand("build"));
+    if (!this.#fast) await this.#runPhase("typecheck", "Typechecking", () => this.typecheck());
     await this.#runPhase(
       "backend",
       "Compiling backend",
       () => this.#buildBackend(),
       (result) => `${result.entrypoints} entrypoints, ${result.outputs} outputs`,
-      phaseOptions,
     );
     await this.#runPhase(
       "ssr",
@@ -111,14 +108,12 @@ export class ApplicationBuildRunner {
           : web.ssr
             ? "skipped"
             : "disabled by akan.config.ts web.ssr",
-      phaseOptions,
     );
     await this.#runPhase(
       "csr",
       "Building CSR assets",
-      async () => (web.csr ? await this.#buildCsr() : null),
+      async () => (web.csr ? await new CsrArtifactBuilder(this.#app, "build").build() : null),
       (result) => result?.outputDir ?? (web.csr ? "skipped" : "disabled by akan.config.ts web.csr"),
-      phaseOptions,
     );
     await this.#runPhase(
       "assets",
@@ -128,7 +123,6 @@ export class ApplicationBuildRunner {
         result
           ? `${result.removed.length} font file(s) dropped, ${ApplicationBuildRunner.formatBytes(result.freedBytes)} freed; ${result.kept.length} kept`
           : "disabled by akan.config.ts assets.pruneFonts",
-      phaseOptions,
     );
     await this.#runPhase(
       "compress",
@@ -138,11 +132,8 @@ export class ApplicationBuildRunner {
         result.files > 0
           ? `${result.files} files, ${ApplicationBuildRunner.formatBytes(result.inputBytes)} -> gzip ${ApplicationBuildRunner.formatBytes(result.outputBytes)} / br ${ApplicationBuildRunner.formatBytes(result.brotliBytes)}`
           : "no files",
-      phaseOptions,
     );
-    await this.#runPhase("metadata", "Writing production metadata", () => this.#buildAppMeta(), undefined, {
-      spinner,
-    });
+    await this.#runPhase("metadata", "Writing production metadata", () => this.#buildAppMeta());
     return {
       phases: this.#phases,
       durationMs: Date.now() - this.#startedAt,
@@ -154,7 +145,7 @@ export class ApplicationBuildRunner {
   async typecheck(options: TypecheckOptions = {}) {
     const { clean = false, incremental = true } = options;
     await this.#app.getPageKeys({ refresh: true });
-    const { typecheckDir, tsconfigPath } = await this.#writeTypecheckTsconfig({ incremental });
+    const { typecheckDir, tsconfigPath } = await this.#writeTypecheckTsconfig(incremental);
     if (clean) await rm(path.join(typecheckDir, "tsconfig.tsbuildinfo"), { force: true });
     await this.#checkProjectInChildProcess(tsconfigPath);
   }
@@ -164,19 +155,17 @@ export class ApplicationBuildRunner {
     label: string,
     task: () => Promise<T>,
     summarize?: (result: T) => string | undefined,
-    options: BuildPhaseRunOptions = {},
   ) {
     this.#reporter?.phaseStart?.({ id, label });
     const phaseStartedAt = Date.now();
-    const spinner = options.spinner
+    const spinner = this.#spinner
       ? new Spinner(label, { prefix: `${BUILD_PHASE_EMOJIS[id]} ${id}` }).start()
       : undefined;
     try {
       const result = await task();
       const phase = { id, label, durationMs: Date.now() - phaseStartedAt, summary: summarize?.(result) };
       this.#phases.push(phase);
-      const summary = phase.summary ? `: ${phase.summary}` : "";
-      spinner?.succeed(`${label}${summary}`);
+      spinner?.succeed(`${label}${phase.summary ? `: ${phase.summary}` : ""}`);
       this.#reporter?.phaseDone?.(phase);
       return result;
     } catch (error) {
@@ -191,66 +180,79 @@ export class ApplicationBuildRunner {
     await Promise.all([
       this.#app.dist.writeJson("package.json", akanConfig.getProductionPackageJson()),
       this.#app.dist.writeFile(`${this.#app.dist.cwdPath}/Dockerfile`, akanConfig.dockerfile),
+      this.#app.dist.writeJson("akan.build.json", {
+        buildId: await this.#resolveBuildId(),
+        akanVersion: akanConfig.akanVersion,
+        builtAt: new Date().toISOString(),
+      }),
     ]);
   }
 
+  //* Read back at runtime as `buildId` on the ops channel; a deployment's own AKAN_BUILD_ID still wins over it there.
+  async #resolveBuildId() {
+    const fromEnv = process.env.AKAN_BUILD_ID?.trim();
+    if (fromEnv) return fromEnv;
+    const root = this.#app.workspace.workspaceRoot;
+    const sha = Bun.spawnSync(["git", "rev-parse", "--short=12", "HEAD"], { cwd: root, stderr: "ignore" });
+    if (sha.exitCode !== 0) return null;
+    const dirty = Bun.spawnSync(["git", "status", "--porcelain", "--untracked-files=no"], {
+      cwd: root,
+      stderr: "ignore",
+    });
+    const suffix = dirty.exitCode === 0 && dirty.stdout.toString().trim() ? "-dirty" : "";
+    return `${sha.stdout.toString().trim()}${suffix}`;
+  }
+
   async #buildBackend() {
-    const akanConfig = await this.#app.getConfig();
-    const backendExternals = [
-      ...new Set([...akanConfig.externalLibs, ...SSR_RENDER_EXTERNALS, ...AKAN_OPTIONAL_BACKEND_EXTERNALS]),
-    ];
-    const { web } = akanConfig;
+    const { externalLibs, web } = await this.#app.getConfig();
     const backendEntryPoints = [`${this.#app.cwdPath}/main.ts`, `${this.#app.cwdPath}/server.ts`];
     for (const entrypoint of backendEntryPoints) {
       if (!(await Bun.file(entrypoint).exists())) throw new Error(`Backend entrypoint not found: ${entrypoint}`);
     }
-    const backendResult = await this.#buildOrThrow("backend", {
-      entrypoints: backendEntryPoints,
+    const sharedConfig = {
       outdir: this.#app.dist.cwdPath,
       target: "bun",
       minify: AKAN_BACKEND_MINIFY,
       naming: { entry: "[name].[ext]", chunk: "chunk-[hash].[ext]" },
+      // `akan build` must embed production react-server-dom regardless of the shell's NODE_ENV.
       define: { "process.env.NODE_ENV": JSON.stringify("production") },
-      plugins: backendExternals.length > 0 ? [this.#createExternalSpecifiersPlugin(backendExternals)] : [],
-    });
+    } satisfies Omit<Bun.BuildConfig, "entrypoints">;
+    const backendConfig = { ...sharedConfig, plugins: [this.#createExternalSpecifiersPlugin(externalLibs)] };
+    //* Built apart so main.js keeps its own module copies; splitting moves lazy vendor `import()`s out of the boot parse.
+    const [mainResult, serverResult] = [
+      await this.#buildOrThrow("backend", { ...backendConfig, entrypoints: [backendEntryPoints[0]] }),
+      await this.#buildOrThrow("backend", { ...backendConfig, entrypoints: [backendEntryPoints[1]], splitting: true }),
+    ];
     // Nothing spawns the RSC worker without SSR, so an api-only image does not carry it.
     const rscWorkerResult = web.ssr
       ? await this.#buildOrThrow("rsc-worker", {
+          ...backendConfig,
           entrypoints: [this.#resolveRscWorkerBuildEntry()],
-          outdir: this.#app.dist.cwdPath,
-          target: "bun",
-          minify: AKAN_BACKEND_MINIFY,
-          naming: { entry: "[name].[ext]", chunk: "chunk-[hash].[ext]" },
           conditions: ["react-server"],
-          // `akan build` must embed production react-server-dom regardless of the shell's NODE_ENV.
-          define: { "process.env.NODE_ENV": JSON.stringify("production") },
-          plugins: backendExternals.length > 0 ? [this.#createExternalSpecifiersPlugin(backendExternals)] : [],
         })
       : null;
     const consoleRuntimeResult = await this.#buildOrThrow("console-runtime", {
+      ...sharedConfig,
       entrypoints: [this.#resolveConsoleRuntimeBuildEntry()],
-      outdir: this.#app.dist.cwdPath,
-      target: "bun",
-      minify: AKAN_BACKEND_MINIFY,
       naming: { entry: "console-runtime.[ext]", chunk: "chunk-[hash].[ext]" },
-      define: { "process.env.NODE_ENV": JSON.stringify("production") },
     });
     await this.#writeConsoleShim();
+    const results = [mainResult, serverResult, rscWorkerResult, consoleRuntimeResult];
     return {
       entrypoints: backendEntryPoints.length + (rscWorkerResult ? 2 : 1),
-      outputs:
-        backendResult.outputs.length + (rscWorkerResult?.outputs.length ?? 0) + consoleRuntimeResult.outputs.length + 1,
+      outputs: results.reduce((sum, result) => sum + (result?.outputs.length ?? 0), 1),
     };
   }
 
   async #writeConsoleShim() {
     await Bun.write(
       path.join(this.#app.dist.cwdPath, "console.js"),
-      `import { cnst, db, dict, option, server, sig, srv } from "./server.js";
-import { assertAkanConsoleAllowed, startAkanConsole } from "./console-runtime.js";
+      `process.env.AKAN_COMMAND_TYPE = "console";
+const { cnst, db, dict, option, server, sig, srv } = await import("./server.js");
+const { assertAkanConsoleAllowed, startAkanConsole } = await import("./console-runtime.js");
 
 const run = async () => {
-  assertAkanConsoleAllowed(server.env);
+  assertAkanConsoleAllowed();
   await server.start({ listen: false, web: false });
   try {
     await startAkanConsole(server, { globals: { cnst, db, dict, option, sig, srv } });
@@ -283,10 +285,6 @@ void run().catch((error) => {
     }
   }
 
-  async #buildCsr() {
-    return await new CsrArtifactBuilder(this.#app, "build").build();
-  }
-
   async #buildSsr() {
     const pageKeys = await this.#app.getPageKeys();
     if (pageKeys.length === 0) {
@@ -298,7 +296,7 @@ void run().catch((error) => {
     return { base, allRoutes };
   }
 
-  async #writeTypecheckTsconfig({ incremental = true }: TypecheckOptions = {}) {
+  async #writeTypecheckTsconfig(incremental: boolean) {
     const typecheckDir = path.join(this.#app.cwdPath, ".akan", "typecheck");
     await mkdir(typecheckDir, { recursive: true });
     //* TypeScript's `include` globs do not cross a symlink, so synced lib pages need their real path.
@@ -367,11 +365,10 @@ void run().catch((error) => {
     return result;
   }
 
-  #createExternalSpecifiersPlugin(specifiers: readonly string[]): BunPlugin {
-    const uniqueSpecifiers = [...new Set(specifiers)];
-    const escaped = uniqueSpecifiers.map((specifier) => specifier.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"));
+  #createExternalSpecifiersPlugin(externalLibs: readonly string[]): BunPlugin {
+    const specifiers = new Set([...externalLibs, ...SSR_RENDER_EXTERNALS, ...AKAN_OPTIONAL_BACKEND_EXTERNALS]);
+    const escaped = [...specifiers].map((specifier) => specifier.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"));
     const filter = new RegExp(`^(${escaped.join("|")})(?:/.*)?$`);
-
     return {
       name: "akan-backend-externalize-specifiers",
       setup(build) {
@@ -380,9 +377,5 @@ void run().catch((error) => {
     };
   }
 
-  static formatBytes(bytes: number): string {
-    if (bytes < 1024) return `${bytes}B`;
-    if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)}KB`;
-    return `${(bytes / 1024 / 1024).toFixed(1)}MB`;
-  }
+  static formatBytes = FontPruner.formatBytes;
 }

package/applicationReleasePackager.ts

@@ -63,13 +63,7 @@ export class ApplicationReleasePackager {
     await rm(`${buildRoot}/frontend/.next`, { recursive: true, force: true });
 
     const releaseRoot = this.#app.workspace.workspaceRoot;
-    // Pass a path relative to cwd so tar never sees a Windows drive letter (e.g. "C:\...")
-    // which GNU tar would interpret as a remote "host:file" spec.
-    const releaseArchivePath = path
-      .relative(releaseRoot, `${releaseRoot}/releases/builds/${this.#app.name}-release.tar.gz`)
-      .split(path.sep)
-      .join("/");
-    await this.#app.workspace.spawn("tar", ["-zcf", releaseArchivePath, "-C", buildRoot, "./"], { cwd: releaseRoot });
+    await this.#tar(releaseRoot, `${releaseRoot}/releases/builds/${this.#app.name}-release.tar.gz`, buildRoot);
     await this.#writeCsrZipIfPresent();
     return { platformVersion };
   }
@@ -112,26 +106,19 @@ export class ApplicationReleasePackager {
     await this.#writeSourceTsconfig(sourceRoot, libDeps);
     await Bun.write(`${sourceRoot}/README.md`, readme);
     const sourceCwd = this.#app.workspace.cwdPath;
-    // Pass a path relative to cwd so tar never sees a Windows drive letter (e.g. "C:\...")
-    // which GNU tar would interpret as a remote "host:file" spec.
-    const sourceArchivePath = path
-      .relative(sourceCwd, `${sourceCwd}/releases/sources/${this.#app.name}-source.tar.gz`)
-      .split(path.sep)
-      .join("/");
-    await this.#app.workspace.spawn("tar", ["-zcf", sourceArchivePath, "-C", sourceRoot, "./"], { cwd: sourceCwd });
+    await this.#tar(sourceCwd, `${sourceCwd}/releases/sources/${this.#app.name}-source.tar.gz`, sourceRoot);
+  }
+
+  async #tar(cwd: string, archivePath: string, sourceDir: string) {
+    // Relative to cwd so tar never sees a Windows drive letter ("C:\..."), which GNU tar reads as a remote "host:file".
+    const relativeArchivePath = path.relative(cwd, archivePath).split(path.sep).join("/");
+    await this.#app.workspace.spawn("tar", ["-zcf", relativeArchivePath, "-C", sourceDir, "./"], { cwd });
   }
 
   async #resetSourceRoot(sourceRoot: string): Promise<void> {
-    if (await FileSys.dirExists(sourceRoot)) {
-      const maxRetry = 3;
-      for (let i = 0; i < maxRetry; i++) {
-        try {
-          await rm(sourceRoot, { recursive: true, force: true });
-        } catch {
-          //
-        }
-      }
-    }
+    if (await FileSys.dirExists(sourceRoot))
+      for (let attempt = 0; attempt < 3; attempt++)
+        await rm(sourceRoot, { recursive: true, force: true }).catch(() => undefined);
     await mkdir(sourceRoot, { recursive: true });
   }
 
@@ -147,6 +134,17 @@ export class ApplicationReleasePackager {
     await Bun.write(`${sourceRoot}/tsconfig.json`, JSON.stringify(tsconfig, null, 2));
   }
 
+  static #envSetup = `  cat <<EOF >> .env
+  # ENV For Server => debug | debug.local | develop | develop.local | main | main.local
+  SERVER_ENV=debug.local
+  # Run Mode For Server => federation | batch | all
+  SERVER_MODE=federation
+  # ENV For Client => debug | debug.local | develop | develop.local | main | main.local
+  AKAN_PUBLIC_CLIENT_ENV=debug.local
+  ANALYZE=false
+  EOF
+`;
+
   #confidentialReadme(): string {
     return `# ${this.#app.name}
   본 프로젝트의 소스코드 및 관련자료는 모두 비밀정보로 관리됩니다.
@@ -157,16 +155,7 @@ export class ApplicationReleasePackager {
   bun install -g bun
   bun i
 
-  cat <<EOF >> .env
-  # ENV For Server => debug | debug.local | develop | develop.local | main | main.local
-  SERVER_ENV=debug.local
-  # Run Mode For Server => federation | batch | all
-  SERVER_MODE=federation
-  # ENV For Client => debug | debug.local | develop | develop.local | main | main.local
-  AKAN_PUBLIC_CLIENT_ENV=debug.local
-  ANALYZE=false
-  EOF
-
+${ApplicationReleasePackager.#envSetup}
   akn start-backend ${this.#app.name}
   # or akn start-frontend ${this.#app.name}, etc
   \`\`\`
@@ -185,16 +174,7 @@ export class ApplicationReleasePackager {
   ## Get Started
   Run the code below.
   \`\`\`
-  cat <<EOF >> .env
-  # ENV For Server => debug | debug.local | develop | develop.local | main | main.local
-  SERVER_ENV=debug.local
-  # Run Mode For Server => federation | batch | all
-  SERVER_MODE=federation
-  # ENV For Client => debug | debug.local | develop | develop.local | main | main.local
-  AKAN_PUBLIC_CLIENT_ENV=debug.local
-  ANALYZE=false
-  EOF
-
+${ApplicationReleasePackager.#envSetup}
   akan start ${this.#app.name}
   \`\`\`
 

package/applicationTestPreload.ts

@@ -8,7 +8,7 @@ export interface SignalTestPreloadTarget {
 
 export async function resolveSignalTestPreloadPath(target: SignalTestPreloadTarget) {
   const candidates: string[] = [];
-  const addResolvedPackageCandidate = (basePath: string) => {
+  for (const basePath of [target.cwdPath, process.cwd(), path.dirname(Bun.main), import.meta.dir]) {
     try {
       candidates.push(
         path.join(path.dirname(Bun.resolveSync("akanjs/package.json", basePath)), SIGNAL_TEST_PRELOAD_PATH),
@@ -16,13 +16,7 @@ export async function resolveSignalTestPreloadPath(target: SignalTestPreloadTarg
     } catch {
       // Source workspaces and published installs can resolve Akan packages from different roots.
     }
-  };
-
-  addResolvedPackageCandidate(target.cwdPath);
-  addResolvedPackageCandidate(process.cwd());
-  addResolvedPackageCandidate(path.dirname(Bun.main));
-  addResolvedPackageCandidate(import.meta.dir);
-
+  }
   candidates.push(
     path.join(target.cwdPath, "../../node_modules/akanjs", SIGNAL_TEST_PRELOAD_PATH),
     path.join(target.cwdPath, "../../pkgs/akanjs", SIGNAL_TEST_PRELOAD_PATH),
@@ -33,10 +27,7 @@ export async function resolveSignalTestPreloadPath(target: SignalTestPreloadTarg
   );
 
   const uniqueCandidates = [...new Set(candidates)];
-  for (const candidate of uniqueCandidates) {
-    if (await Bun.file(candidate).exists()) return candidate;
-  }
-
+  for (const candidate of uniqueCandidates) if (await Bun.file(candidate).exists()) return candidate;
   throw new Error(
     `Failed to locate ${SIGNAL_TEST_PRELOAD_PATH} from ${target.cwdPath}.\nProbed paths:\n${uniqueCandidates
       .map((candidate) => `  - ${candidate}`)

package/artifact/implicitRootLayout.test.ts

@@ -1,25 +1,9 @@
-import { afterEach, describe, expect, test } from "bun:test";
-import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
-import os from "node:os";
+import { describe, expect, test } from "bun:test";
 import path from "node:path";
+import { tempDirs, writeText as write } from "../testHelpers";
 import { resolveSsrPageEntries } from "./implicitRootLayout";
 
-const tempRoots: string[] = [];
-
-const makeTempRoot = async () => {
-  const root = await mkdtemp(path.join(os.tmpdir(), "akan-implicit-root-layout-"));
-  tempRoots.push(root);
-  return root;
-};
-
-const write = async (filePath: string, content: string) => {
-  await mkdir(path.dirname(filePath), { recursive: true });
-  await writeFile(filePath, content);
-};
-
-afterEach(async () => {
-  await Promise.all(tempRoots.splice(0).map((root) => rm(root, { recursive: true, force: true })));
-});
+const makeTempRoot = tempDirs("akan-implicit-root-layout-");
 
 describe("resolveSsrPageEntries", () => {
   test("inherits root layout static exports for grouped root boundaries", async () => {
@@ -31,11 +15,11 @@ describe("resolveSsrPageEntries", () => {
     await write(path.join(appRoot, "env", "env.client.ts"), "export const env = {};\n");
     await write(
       rootLayoutPath,
-      'export const theme = "dark";\nexport const fonts = [{ name: "pretendard" }];\nexport const metadata = { title: "Root" };\n',
+      'export const theme = "dark";\nexport const fonts = [{ name: "pretendard" }];\nexport const head = null;\n',
     );
     await write(
       groupedLayoutPath,
-      'export function generateMetadata() { return { title: "Home" }; }\nexport default function Layout({ children }) { return children; }\n',
+      "export function generateHead() { return null; }\nexport default function Layout({ children }) { return children; }\n",
     );
 
     const entries = await resolveSsrPageEntries({
@@ -54,15 +38,10 @@ describe("resolveSsrPageEntries", () => {
     expect(generatedSource).toContain('import * as inheritedModule from "../../../page/_layout.tsx";');
     expect(generatedSource).toContain("const inheritedLayout = resolveRouteModule(inheritedModule as never");
     expect(generatedSource).not.toContain("<System.Provider");
-    expect(generatedSource).toContain("export async function generateMetadata(props: PageProps)");
-    expect(generatedSource).toContain("if (userLayout.generateMetadata) return userLayout.generateMetadata(props);");
-    expect(generatedSource).toContain("if (userLayout.metadata !== undefined) return userLayout.metadata;");
-    expect(generatedSource).toContain(
-      "if (inheritedLayout.generateMetadata) return inheritedLayout.generateMetadata(props);",
-    );
-    expect(generatedSource).toContain("return inheritedLayout.metadata;");
-    expect(generatedSource).not.toContain("Object.keys(userLayout.metadata)");
-    expect(generatedSource).not.toContain("Object.keys(inheritedLayout.metadata)");
+    expect(generatedSource).toContain("export async function generateHead(props: PageProps)");
+    expect(generatedSource).toContain("if (userLayout.generateHead) return userLayout.generateHead(props);");
+    expect(generatedSource).toContain("return inheritedLayout.head;");
+    expect(generatedSource).not.toContain("generateMetadata");
     expect(generatedSource).toContain("export const NotFound = userLayout.NotFound ?? inheritedLayout.NotFound;");
     expect(generatedSource).toContain("export const Error = userLayout.Error ?? inheritedLayout.Error;");
     expect(generatedSource).toContain("export const pageConfig = userLayout.pageConfig ?? inheritedLayout.pageConfig;");