@mandujs/core 0.54.12 → 0.54.14

package/src/filling/filling.ts

@@ -62,9 +62,17 @@ export interface MiddlewarePlugin {
  * `redirect(url)` helper for the common case; throwing a `Response` is
  * also accepted (Remix idiom).
  */
+export type LoaderResult<T = unknown> = T | Response;
+
 export type Loader<T = unknown> = (
   ctx: ManduContext
-) => T | Response | Promise<T | Response>;
+) => LoaderResult<T> | Promise<LoaderResult<T>>;
+
+/**
+ * Page-level SSR data reader. Prefer this name in public docs when the
+ * distinction from mutation actions or schema contracts matters.
+ */
+export type RouteDataLoader<T = unknown> = Loader<T>;
 
 /** Loader 실행 옵션 */
 export interface LoaderOptions<T = unknown> {
@@ -105,6 +113,19 @@ export class LoaderTimeoutError extends Error {
 /** Action handler type — named mutation handler */
 export type ActionHandler = (ctx: ManduContext) => Response | Promise<Response>;
 
+/**
+ * Named mutation/interaction handler. Alias of `ActionHandler`, exported so
+ * docs and generated examples can name the action responsibility directly.
+ */
+export type MutationAction = ActionHandler;
+
+/**
+ * Executable route pipeline: handlers, loader, actions, middleware, cache,
+ * render mode, and deploy intent. This is intentionally separate from the
+ * API schema contract.
+ */
+export type RouteFilling<TLoaderData = unknown> = ManduFilling<TLoaderData>;
+
 interface FillingConfig<TLoaderData = unknown> {
   handlers: Map<HttpMethod, Handler>;
   actions: Map<string, ActionHandler>;

package/src/filling/index.ts

@@ -7,7 +7,21 @@
 export { ManduContext, ValidationError, CookieManager } from "./context";
 export type { CookieOptions } from "./context";
 export { ManduFilling, ManduFillingFactory, LoaderTimeoutError } from "./filling";
-export type { Handler, Guard, ActionHandler, HttpMethod, Loader, LoaderOptions, LoaderCacheOptions, RenderMode, MiddlewarePlugin } from "./filling";
+export type {
+  Handler,
+  Guard,
+  ActionHandler,
+  MutationAction,
+  HttpMethod,
+  Loader,
+  RouteDataLoader,
+  LoaderResult,
+  LoaderOptions,
+  LoaderCacheOptions,
+  RenderMode,
+  MiddlewarePlugin,
+  RouteFilling,
+} from "./filling";
 export { createCookieSessionStorage, Session } from "./session";
 export type { SessionStorage, SessionData, CookieSessionOptions } from "./session";
 export { wrapBunWebSocket } from "./ws";

package/src/generator/generate.ts

@@ -99,25 +99,25 @@ export interface GeneratedMap {
   frameworkPaths: string[];
 }
 
-async function ensureDir(dirPath: string): Promise<void> {
-  try {
-    await fs.mkdir(dirPath, { recursive: true });
-  } catch  {
-    // ignore if exists
-  }
-}
-
-function touchGenerateStamp(rootDir: string): void {
-  const stampDir = path.join(rootDir, ".mandu");
-  if (!fsSync.existsSync(stampDir)) {
-    fsSync.mkdirSync(stampDir, { recursive: true });
-  }
-  fsSync.writeFileSync(path.join(stampDir, "generate.stamp"), Date.now().toString());
-}
-
-async function getExistingFiles(dir: string): Promise<string[]> {
-  try {
-    const files = await fs.readdir(dir);
+async function ensureDir(dirPath: string): Promise<void> {
+  try {
+    await fs.mkdir(dirPath, { recursive: true });
+  } catch  {
+    // ignore if exists
+  }
+}
+
+function touchGenerateStamp(rootDir: string): void {
+  const stampDir = path.join(rootDir, ".mandu");
+  if (!fsSync.existsSync(stampDir)) {
+    fsSync.mkdirSync(stampDir, { recursive: true });
+  }
+  fsSync.writeFileSync(path.join(stampDir, "generate.stamp"), Date.now().toString());
+}
+
+async function getExistingFiles(dir: string): Promise<string[]> {
+  try {
+    const files = await fs.readdir(dir);
     return files.filter((f) => f.endsWith(".route.ts") || f.endsWith(".route.tsx"));
   } catch {
     return [];
@@ -146,10 +146,10 @@ export async function generateRoutes(
     warnings: [],
   };
 
-  // Suppress watcher during generation to avoid false positives
-  const watcher = getWatcher();
-  watcher?.suppress();
-  touchGenerateStamp(rootDir);
+  // Suppress watcher during generation to avoid false positives
+  const watcher = getWatcher();
+  watcher?.suppress();
+  touchGenerateStamp(rootDir);
 
   const generatedPaths = resolveGeneratedPaths(rootDir);
   const serverRoutesDir = generatedPaths.serverRoutesDir;
@@ -363,10 +363,10 @@ export async function generateRoutes(
   const mapPath = path.join(mapDir, "generated.map.json");
   await Bun.write(mapPath, JSON.stringify(generatedMap, null, 2));
 
-  // Cross-process timestamp: watcher skips warnings if generate finished recently
-  touchGenerateStamp(rootDir);
-  // Resume watcher after the stamp is visible.
-  watcher?.resume();
-
-  return result;
-}
+  // Cross-process timestamp: watcher skips warnings if generate finished recently
+  touchGenerateStamp(rootDir);
+  // Resume watcher after the stamp is visible.
+  watcher?.resume();
+
+  return result;
+}

package/src/generator/index.ts

@@ -1,3 +1,3 @@
-export * from "./generate";
-export * from "./templates";
-export * from "./contract-glue";
+export * from "./generate";
+export * from "./templates";
+export * from "./contract-glue";

package/src/generator/templates.ts

@@ -1,4 +1,4 @@
-import { needsHydration, type RouteSpec } from "../spec/schema";
+import { needsHydration, type RouteSpec } from "../spec/schema";
 import { GENERATED_RELATIVE_PATHS } from "../paths";
 
 export function generateApiHandler(route: RouteSpec): string {
@@ -238,34 +238,34 @@ function computeSlotImportPath(slotModule: string, fromDir: string): string {
   return result;
 }
 
-export function generatePageComponent(route: RouteSpec): string {
-  // Island-First: clientModule이 있으면 Island render를 SSR에서 직접 사용
-  if (route.clientModule) {
-    return generatePageComponentWithIsland(route);
-  }
-
-  if (needsHydration(route)) {
-    throw new Error(
-      `[${route.id}] Route has hydration strategy "${route.hydration?.strategy}" but no clientModule. ` +
-      "Refusing to generate a placeholder page because it would disagree with runtime hydration state.",
-    );
-  }
-
-  // slotModule이 있으면 PageHandler 형식으로 생성 (filling 포함)
-  if (route.slotModule) {
-    return generatePageHandlerWithSlot(route);
-  }
-
-  if (route.kind === "page" && route.componentModule) {
-    return generatePageComponentFromModule(route);
-  }
-
-  const pageName = toPascalCase(route.id);
-
-  // Legacy fallback for malformed historical manifests that lack componentModule.
-  return `// Generated by Mandu - DO NOT EDIT DIRECTLY
-// Route ID: ${route.id}
-// Pattern: ${route.pattern}
+export function generatePageComponent(route: RouteSpec): string {
+  // Island-First: clientModule이 있으면 Island render를 SSR에서 직접 사용
+  if (route.clientModule) {
+    return generatePageComponentWithIsland(route);
+  }
+
+  if (needsHydration(route)) {
+    throw new Error(
+      `[${route.id}] Route has hydration strategy "${route.hydration?.strategy}" but no clientModule. ` +
+      "Refusing to generate a placeholder page because it would disagree with runtime hydration state.",
+    );
+  }
+
+  // slotModule이 있으면 PageHandler 형식으로 생성 (filling 포함)
+  if (route.slotModule) {
+    return generatePageHandlerWithSlot(route);
+  }
+
+  if (route.kind === "page" && route.componentModule) {
+    return generatePageComponentFromModule(route);
+  }
+
+  const pageName = toPascalCase(route.id);
+
+  // Legacy fallback for malformed historical manifests that lack componentModule.
+  return `// Generated by Mandu - DO NOT EDIT DIRECTLY
+// Route ID: ${route.id}
+// Pattern: ${route.pattern}
 
 import React from "react";
 
@@ -281,31 +281,31 @@ export default function ${pageName}Page({ params }: Props): React.ReactElement {
     React.createElement("p", null, "Pattern: ${route.pattern}")
   );
 }
-`;
-}
-
-export function generatePageComponentFromModule(route: RouteSpec): string {
-  const pageName = toPascalCase(route.id);
-  const pageImportPath = computeSlotImportPath(route.componentModule!, GENERATED_RELATIVE_PATHS.webRoutes);
-
-  return `// Generated by Mandu - DO NOT EDIT DIRECTLY
-// Route ID: ${route.id}
-// Pattern: ${route.pattern}
-// Page Module: ${route.componentModule}
-
-import React from "react";
-import pageModule from "${pageImportPath}";
-
-interface Props {
-  params: Record<string, string>;
-  loaderData?: unknown;
-}
-
-export default function ${pageName}Page(props: Props): React.ReactElement {
-  return React.createElement(pageModule as React.ComponentType<Props>, props);
-}
-`;
-}
+`;
+}
+
+export function generatePageComponentFromModule(route: RouteSpec): string {
+  const pageName = toPascalCase(route.id);
+  const pageImportPath = computeSlotImportPath(route.componentModule!, GENERATED_RELATIVE_PATHS.webRoutes);
+
+  return `// Generated by Mandu - DO NOT EDIT DIRECTLY
+// Route ID: ${route.id}
+// Pattern: ${route.pattern}
+// Page Module: ${route.componentModule}
+
+import React from "react";
+import pageModule from "${pageImportPath}";
+
+interface Props {
+  params: Record<string, string>;
+  loaderData?: unknown;
+}
+
+export default function ${pageName}Page(props: Props): React.ReactElement {
+  return React.createElement(pageModule as React.ComponentType<Props>, props);
+}
+`;
+}
 
 /**
  * Island-First Rendering: SSR이 island의 render 함수를 직접 사용
@@ -313,51 +313,51 @@ export default function ${pageName}Page(props: Props): React.ReactElement {
  * - SSR과 클라이언트가 동일한 렌더링 로직 사용 → 불일치 구조적 방지
  * - slotModule 유무에 따라 두 가지 변형 생성
  */
-export function generatePageComponentWithIsland(route: RouteSpec): string {
-  const pageName = toPascalCase(route.id);
-  const clientImportPath = computeSlotImportPath(route.clientModule!, GENERATED_RELATIVE_PATHS.webRoutes);
-  const pageImportPath = route.kind === "page" && route.componentModule
-    ? computeSlotImportPath(route.componentModule, GENERATED_RELATIVE_PATHS.webRoutes)
-    : null;
-  const pageModuleComment = route.kind === "page" && route.componentModule
-    ? `// Page Module: ${route.componentModule}\n`
-    : "";
-  const shouldImportPageModule = !!pageImportPath &&
-    normalizeRouteModulePath(route.componentModule) !== normalizeRouteModulePath(route.clientModule);
-  const pageImport = shouldImportPageModule ? `import pageModule from "${pageImportPath}";\n` : "";
-  const pageRenderTarget = shouldImportPageModule ? "pageModule" : "islandModule";
-  const renderHelper = generateClientBackedPageRenderHelper(pageRenderTarget, route.id);
-
-  // clientModule + slotModule → PageRegistration 형식
-  if (route.slotModule) {
-    const slotImportPath = computeSlotImportPath(route.slotModule!, GENERATED_RELATIVE_PATHS.webRoutes);
+export function generatePageComponentWithIsland(route: RouteSpec): string {
+  const pageName = toPascalCase(route.id);
+  const clientImportPath = computeSlotImportPath(route.clientModule!, GENERATED_RELATIVE_PATHS.webRoutes);
+  const pageImportPath = route.kind === "page" && route.componentModule
+    ? computeSlotImportPath(route.componentModule, GENERATED_RELATIVE_PATHS.webRoutes)
+    : null;
+  const pageModuleComment = route.kind === "page" && route.componentModule
+    ? `// Page Module: ${route.componentModule}\n`
+    : "";
+  const shouldImportPageModule = !!pageImportPath &&
+    normalizeRouteModulePath(route.componentModule) !== normalizeRouteModulePath(route.clientModule);
+  const pageImport = shouldImportPageModule ? `import pageModule from "${pageImportPath}";\n` : "";
+  const pageRenderTarget = shouldImportPageModule ? "pageModule" : "islandModule";
+  const renderHelper = generateClientBackedPageRenderHelper(pageRenderTarget, route.id);
+
+  // clientModule + slotModule → PageRegistration 형식
+  if (route.slotModule) {
+    const slotImportPath = computeSlotImportPath(route.slotModule!, GENERATED_RELATIVE_PATHS.webRoutes);
 
     return `// Generated by Mandu - DO NOT EDIT DIRECTLY
 // Island-First Rendering + Slot Module
 // Route ID: ${route.id}
-// Pattern: ${route.pattern}
-// Client Module: ${route.clientModule}
-// Slot Module: ${route.slotModule}
-${pageModuleComment}
-
-import React from "react";
-import filling from "${slotImportPath}";
-import islandModule from "${clientImportPath}";
-${pageImport}
-
-interface Props {
-  params: Record<string, string>;
-  loaderData?: unknown;
-}
-
-${renderHelper}
-
-function ${pageName}Page({ params, loaderData }: Props): React.ReactElement {
-  const serverData = (loaderData || {}) as Record<string, unknown>;
-  return renderClientBackedPage({ params, loaderData }, serverData);
-}
-
-// PageRegistration 형식으로 export (server.ts의 registerPageHandler용)
+// Pattern: ${route.pattern}
+// Client Module: ${route.clientModule}
+// Slot Module: ${route.slotModule}
+${pageModuleComment}
+
+import React from "react";
+import filling from "${slotImportPath}";
+import islandModule from "${clientImportPath}";
+${pageImport}
+
+interface Props {
+  params: Record<string, string>;
+  loaderData?: unknown;
+}
+
+${renderHelper}
+
+function ${pageName}Page({ params, loaderData }: Props): React.ReactElement {
+  const serverData = (loaderData || {}) as Record<string, unknown>;
+  return renderClientBackedPage({ params, loaderData }, serverData);
+}
+
+// PageRegistration 형식으로 export (server.ts의 registerPageHandler용)
 export default {
   component: ${pageName}Page,
   filling: filling,
@@ -368,124 +368,124 @@ export default {
   // clientModule만 (slotModule 없음) → default export 컴포넌트
   return `// Generated by Mandu - DO NOT EDIT DIRECTLY
 // Island-First Rendering: SSR이 island render 직접 사용
-// Route ID: ${route.id}
-// Pattern: ${route.pattern}
-// Client Module: ${route.clientModule}
-${pageModuleComment}
-
-import React from "react";
-import islandModule from "${clientImportPath}";
-${pageImport}
-
-interface Props {
-  params: Record<string, string>;
-  loaderData?: unknown;
-}
-
-${renderHelper}
-
-export default function ${pageName}Page({ params, loaderData }: Props): React.ReactElement {
-  const serverData = (loaderData || {}) as Record<string, unknown>;
-  return renderClientBackedPage({ params, loaderData }, serverData);
-}
-`;
-}
+// Route ID: ${route.id}
+// Pattern: ${route.pattern}
+// Client Module: ${route.clientModule}
+${pageModuleComment}
+
+import React from "react";
+import islandModule from "${clientImportPath}";
+${pageImport}
+
+interface Props {
+  params: Record<string, string>;
+  loaderData?: unknown;
+}
+
+${renderHelper}
+
+export default function ${pageName}Page({ params, loaderData }: Props): React.ReactElement {
+  const serverData = (loaderData || {}) as Record<string, unknown>;
+  return renderClientBackedPage({ params, loaderData }, serverData);
+}
+`;
+}
 
 /**
  * slotModule이 있는 Page Route용 Handler 생성
  * - component와 filling을 함께 export
  * - server.ts에서 filling.executeLoader() 호출 가능
  */
-export function generatePageHandlerWithSlot(route: RouteSpec): string {
-  const pageName = toPascalCase(route.id);
-  const slotImportPath = computeSlotImportPath(route.slotModule!, GENERATED_RELATIVE_PATHS.serverRoutes);
-  const pageImportPath = route.kind === "page" && route.componentModule
-    ? computeSlotImportPath(route.componentModule, GENERATED_RELATIVE_PATHS.serverRoutes)
-    : null;
-  const pageImport = pageImportPath ? `import pageModule from "${pageImportPath}";\n` : "";
-  const pageRender = pageImportPath
-    ? `  return React.createElement(pageModule as React.ComponentType<Props>, { params, loaderData });`
-    : `  return React.createElement("div", null,
-    React.createElement("h1", null, "${pageName} Page"),
-    React.createElement("p", null, "Route ID: ${route.id}"),
-    React.createElement("p", null, "Pattern: ${route.pattern}"),
-    loaderData ? React.createElement("pre", null, JSON.stringify(loaderData, null, 2)) : null
-  );`;
-
-  return `// Generated by Mandu - DO NOT EDIT DIRECTLY
-// Route ID: ${route.id}
-// Pattern: ${route.pattern}
-// Slot Module: ${route.slotModule}
-
-import React from "react";
-import filling from "${slotImportPath}";
-${pageImport}
-
-interface Props {
-  params: Record<string, string>;
-  loaderData?: unknown;
-}
-
-function ${pageName}Page({ params, loaderData }: Props): React.ReactElement {
-${pageRender}
-}
-
-// PageRegistration 형식으로 export (server.ts의 registerPageHandler용)
+export function generatePageHandlerWithSlot(route: RouteSpec): string {
+  const pageName = toPascalCase(route.id);
+  const slotImportPath = computeSlotImportPath(route.slotModule!, GENERATED_RELATIVE_PATHS.serverRoutes);
+  const pageImportPath = route.kind === "page" && route.componentModule
+    ? computeSlotImportPath(route.componentModule, GENERATED_RELATIVE_PATHS.serverRoutes)
+    : null;
+  const pageImport = pageImportPath ? `import pageModule from "${pageImportPath}";\n` : "";
+  const pageRender = pageImportPath
+    ? `  return React.createElement(pageModule as React.ComponentType<Props>, { params, loaderData });`
+    : `  return React.createElement("div", null,
+    React.createElement("h1", null, "${pageName} Page"),
+    React.createElement("p", null, "Route ID: ${route.id}"),
+    React.createElement("p", null, "Pattern: ${route.pattern}"),
+    loaderData ? React.createElement("pre", null, JSON.stringify(loaderData, null, 2)) : null
+  );`;
+
+  return `// Generated by Mandu - DO NOT EDIT DIRECTLY
+// Route ID: ${route.id}
+// Pattern: ${route.pattern}
+// Slot Module: ${route.slotModule}
+
+import React from "react";
+import filling from "${slotImportPath}";
+${pageImport}
+
+interface Props {
+  params: Record<string, string>;
+  loaderData?: unknown;
+}
+
+function ${pageName}Page({ params, loaderData }: Props): React.ReactElement {
+${pageRender}
+}
+
+// PageRegistration 형식으로 export (server.ts의 registerPageHandler용)
 export default {
   component: ${pageName}Page,
   filling: filling,
 };
-`;
-}
-
-function generateClientBackedPageRenderHelper(pageRenderTarget: string, routeId: string): string {
-  return `type ManduIslandModule = {
-  __mandu_island: true;
-  definition: {
-    setup: (serverData: Record<string, unknown>) => unknown;
-    render: (props: unknown) => React.ReactNode;
-  };
-};
-
-function isManduIslandModule(value: unknown): value is ManduIslandModule {
-  const candidate = value as Partial<ManduIslandModule> | null;
-  return !!(
-    candidate &&
-    typeof candidate === "object" &&
-    candidate.__mandu_island === true &&
-    typeof candidate.definition?.setup === "function" &&
-    typeof candidate.definition?.render === "function"
-  );
-}
-
-function renderClientBackedPage(props: Props, serverData: Record<string, unknown>): React.ReactElement {
-  if (isManduIslandModule(islandModule)) {
-    const setupResult = islandModule.definition.setup(serverData);
-    return islandModule.definition.render(setupResult) as React.ReactElement;
-  }
-
-  if (typeof ${pageRenderTarget} === "function") {
-    return React.createElement(${pageRenderTarget} as React.ComponentType<Props>, props);
-  }
-
-  if (typeof islandModule === "function") {
-    return React.createElement(islandModule as React.ComponentType<Record<string, unknown>>, serverData);
-  }
-
-  if (React.isValidElement(${pageRenderTarget})) {
-    return ${pageRenderTarget} as React.ReactElement;
-  }
-
-  if (React.isValidElement(islandModule)) {
-    return islandModule as React.ReactElement;
-  }
-
-  throw new Error("[Mandu] Route ${routeId} clientModule must export a Mandu island or React component.");
-}`;
-}
-
-/**
- * Convert string to PascalCase (handles kebab-case, snake_case)
+`;
+}
+
+function generateClientBackedPageRenderHelper(pageRenderTarget: string, routeId: string): string {
+  return `type ManduIslandModule = {
+  __mandu_island: true;
+  definition: {
+    setup: (serverData: Record<string, unknown>) => unknown;
+    render: (props: unknown) => React.ReactNode;
+  };
+};
+
+function isManduIslandModule(value: unknown): value is ManduIslandModule {
+  const candidate = value as Partial<ManduIslandModule> | null;
+  return !!(
+    candidate &&
+    typeof candidate === "object" &&
+    candidate.__mandu_island === true &&
+    typeof candidate.definition?.setup === "function" &&
+    typeof candidate.definition?.render === "function"
+  );
+}
+
+function renderClientBackedPage(props: Props, serverData: Record<string, unknown>): React.ReactElement {
+  if (isManduIslandModule(islandModule)) {
+    const setupResult = islandModule.definition.setup(serverData);
+    return islandModule.definition.render(setupResult) as React.ReactElement;
+  }
+
+  if (typeof ${pageRenderTarget} === "function") {
+    return React.createElement(${pageRenderTarget} as React.ComponentType<Props>, props);
+  }
+
+  if (typeof islandModule === "function") {
+    return React.createElement(islandModule as React.ComponentType<Record<string, unknown>>, serverData);
+  }
+
+  if (React.isValidElement(${pageRenderTarget})) {
+    return ${pageRenderTarget} as React.ReactElement;
+  }
+
+  if (React.isValidElement(islandModule)) {
+    return islandModule as React.ReactElement;
+  }
+
+  throw new Error("[Mandu] Route ${routeId} clientModule must export a Mandu island or React component.");
+}`;
+}
+
+/**
+ * Convert string to PascalCase (handles kebab-case, snake_case)
  * "todo-page" → "TodoPage"
  * "user_profile" → "UserProfile"
  */
@@ -496,10 +496,10 @@ function toPascalCase(str: string): string {
     .join("");
 }
 
-function pathDirname(filePath: string): string {
-  return filePath.replace(/\\/g, "/").split("/").slice(0, -1).join("/");
-}
-
-function normalizeRouteModulePath(filePath: string | undefined): string {
-  return (filePath ?? "").replace(/\\/g, "/").replace(/^\.\//, "");
-}
+function pathDirname(filePath: string): string {
+  return filePath.replace(/\\/g, "/").split("/").slice(0, -1).join("/");
+}
+
+function normalizeRouteModulePath(filePath: string | undefined): string {
+  return (filePath ?? "").replace(/\\/g, "/").replace(/^\.\//, "");
+}

package/src/guard/check.ts

@@ -30,21 +30,21 @@ export const GENERATED_IMPORT_DOCS_URL =
   "https://mandujs.com/docs/architect/generated-access";
 
 /**
- * Build the user-facing message for a detected direct generated-artifact
- * import. `specifier` is the literal import string that tripped the guard
- * (not the resolved path).
+ * Build the user-facing message for a detected direct generated-artifact
+ * import. `specifier` is the literal import string that tripped the guard
+ * (not the resolved path).
  *
  * This helper is the single source of truth for the message text — both
  * the static Guard pass (`checkInvalidGeneratedImport`) and the bundler
  * plugin (`blockGeneratedImports`) call through it so the two paths
  * cannot drift.
  */
-export function buildForbiddenGeneratedImportMessage(specifier: string): string {
-  return (
-    `Direct generated artifact imports are forbidden: ${specifier}. ` +
-    `Use the runtime registry: see ${GENERATED_IMPORT_DOCS_URL}`
-  );
-}
+export function buildForbiddenGeneratedImportMessage(specifier: string): string {
+  return (
+    `Direct generated artifact imports are forbidden: ${specifier}. ` +
+    `Use the runtime registry: see ${GENERATED_IMPORT_DOCS_URL}`
+  );
+}
 
 /**
  * Shared remediation hint. Points at `getGenerated()` from