@mandujs/core 0.18.20 → 0.18.22

package/src/openapi/generator.ts

@@ -12,6 +12,19 @@ import type {
   SchemaExamples,
 } from "../contract/schema";
 import path from "path";
+import {
+  getZodTypeName,
+  getZodInnerType,
+  getZodArrayElementType,
+  getZodEffectsSchema,
+  getZodObjectShape,
+  getZodChecks,
+  getZodEnumValues,
+  getZodUnionOptions,
+  getZodLiteralValue,
+  getZodDefaultValue,
+  isZodRequired,
+} from "../contract/zod-utils";
 
 // ============================================
 // OpenAPI Types
@@ -125,50 +138,54 @@ export interface OpenAPIDocument {
  * consider using zod-to-openapi or similar library.
  */
 export function zodToOpenAPISchema(zodSchema: z.ZodTypeAny): OpenAPISchema {
-  const def = zodSchema._def;
+  const typeName = getZodTypeName(zodSchema);
 
   // Handle ZodOptional
-  if (def.typeName === "ZodOptional") {
-    const innerSchema = zodToOpenAPISchema(def.innerType);
+  if (typeName === "ZodOptional") {
+    const inner = getZodInnerType(zodSchema);
+    const innerSchema = inner ? zodToOpenAPISchema(inner) : {};
     return { ...innerSchema, nullable: true };
   }
 
   // Handle ZodDefault
-  if (def.typeName === "ZodDefault") {
-    const innerSchema = zodToOpenAPISchema(def.innerType);
-    return { ...innerSchema, default: def.defaultValue() };
+  if (typeName === "ZodDefault") {
+    const inner = getZodInnerType(zodSchema);
+    const innerSchema = inner ? zodToOpenAPISchema(inner) : {};
+    return { ...innerSchema, default: getZodDefaultValue(zodSchema) };
   }
 
   // Handle ZodNullable
-  if (def.typeName === "ZodNullable") {
-    const innerSchema = zodToOpenAPISchema(def.innerType);
+  if (typeName === "ZodNullable") {
+    const inner = getZodInnerType(zodSchema);
+    const innerSchema = inner ? zodToOpenAPISchema(inner) : {};
     return { ...innerSchema, nullable: true };
   }
 
   // Handle ZodEffects (coerce, transform, etc.)
-  if (def.typeName === "ZodEffects") {
-    return zodToOpenAPISchema(def.schema);
+  if (typeName === "ZodEffects") {
+    const effectsSchema = getZodEffectsSchema(zodSchema);
+    return effectsSchema ? zodToOpenAPISchema(effectsSchema) : {};
   }
 
   // Handle ZodString
-  if (def.typeName === "ZodString") {
+  if (typeName === "ZodString") {
     const schema: OpenAPISchema = { type: "string" };
-    for (const check of def.checks || []) {
+    for (const check of getZodChecks(zodSchema)) {
       if (check.kind === "email") schema.format = "email";
       if (check.kind === "uuid") schema.format = "uuid";
       if (check.kind === "url") schema.format = "uri";
       if (check.kind === "datetime") schema.format = "date-time";
       if (check.kind === "min") schema.minLength = check.value;
       if (check.kind === "max") schema.maxLength = check.value;
-      if (check.kind === "regex") schema.pattern = check.regex.source;
+      if (check.kind === "regex") schema.pattern = check.regex?.source;
     }
     return schema;
   }
 
   // Handle ZodNumber
-  if (def.typeName === "ZodNumber") {
+  if (typeName === "ZodNumber") {
     const schema: OpenAPISchema = { type: "number" };
-    for (const check of def.checks || []) {
+    for (const check of getZodChecks(zodSchema)) {
       if (check.kind === "int") schema.type = "integer";
       if (check.kind === "min") schema.minimum = check.value;
       if (check.kind === "max") schema.maximum = check.value;
@@ -177,30 +194,30 @@ export function zodToOpenAPISchema(zodSchema: z.ZodTypeAny): OpenAPISchema {
   }
 
   // Handle ZodBoolean
-  if (def.typeName === "ZodBoolean") {
+  if (typeName === "ZodBoolean") {
     return { type: "boolean" };
   }
 
   // Handle ZodArray
-  if (def.typeName === "ZodArray") {
+  if (typeName === "ZodArray") {
+    const elementType = getZodArrayElementType(zodSchema);
     return {
       type: "array",
-      items: zodToOpenAPISchema(def.type),
+      items: elementType ? zodToOpenAPISchema(elementType) : {},
     };
   }
 
   // Handle ZodObject
-  if (def.typeName === "ZodObject") {
+  if (typeName === "ZodObject") {
     const properties: Record<string, OpenAPISchema> = {};
     const required: string[] = [];
 
-    const shape = def.shape();
+    const shape = getZodObjectShape(zodSchema) ?? {};
     for (const [key, value] of Object.entries(shape)) {
-      properties[key] = zodToOpenAPISchema(value as z.ZodTypeAny);
+      properties[key] = zodToOpenAPISchema(value);
 
       // Check if field is required
-      const fieldDef = (value as z.ZodTypeAny)._def;
-      if (fieldDef.typeName !== "ZodOptional" && fieldDef.typeName !== "ZodDefault") {
+      if (isZodRequired(value)) {
         required.push(key);
       }
     }
@@ -213,23 +230,24 @@ export function zodToOpenAPISchema(zodSchema: z.ZodTypeAny): OpenAPISchema {
   }
 
   // Handle ZodEnum
-  if (def.typeName === "ZodEnum") {
+  if (typeName === "ZodEnum") {
     return {
       type: "string",
-      enum: def.values,
+      enum: getZodEnumValues(zodSchema) as unknown[],
     };
   }
 
   // Handle ZodUnion
-  if (def.typeName === "ZodUnion") {
+  if (typeName === "ZodUnion") {
+    const options = getZodUnionOptions(zodSchema) ?? [];
     return {
-      oneOf: def.options.map((opt: z.ZodTypeAny) => zodToOpenAPISchema(opt)),
+      oneOf: options.map((opt) => zodToOpenAPISchema(opt)),
     };
   }
 
   // Handle ZodLiteral
-  if (def.typeName === "ZodLiteral") {
-    const value = def.value;
+  if (typeName === "ZodLiteral") {
+    const value = getZodLiteralValue(zodSchema);
     return {
       type: typeof value as string,
       enum: [value],
@@ -237,12 +255,12 @@ export function zodToOpenAPISchema(zodSchema: z.ZodTypeAny): OpenAPISchema {
   }
 
   // Handle ZodVoid/ZodUndefined (no content)
-  if (def.typeName === "ZodVoid" || def.typeName === "ZodUndefined") {
+  if (typeName === "ZodVoid" || typeName === "ZodUndefined") {
     return {};
   }
 
   // Handle ZodAny/ZodUnknown
-  if (def.typeName === "ZodAny" || def.typeName === "ZodUnknown") {
+  if (typeName === "ZodAny" || typeName === "ZodUnknown") {
     return {};
   }
 

package/src/plugins/index.ts

@@ -24,7 +24,7 @@ export type {
   GuardPresetPlugin,
   GuardRule,
   GuardRuleContext,
-  GuardViolation,
+  PluginGuardViolation,
   LayerDefinition,
   ImportInfo,
   ExportInfo,

package/src/plugins/registry.ts

@@ -25,15 +25,19 @@ import type {
 type PluginState = "pending" | "loaded" | "error" | "unloaded";
 
 /**
- * 등록된 플러그인 정보
+ * 등록된 플러그인 정보 (discriminated union by state)
+ *
+ * state에 따라 접근 가능한 필드가 타입 레벨에서 결정됨:
+ * - pending: plugin, config만 존재
+ * - loaded: plugin, config, loadedAt 존재
+ * - error: plugin, config, error 존재
+ * - unloaded: plugin만 존재
  */
-interface RegisteredPlugin<TConfig = unknown> {
-  plugin: Plugin<TConfig>;
-  state: PluginState;
-  config?: TConfig;
-  error?: Error;
-  loadedAt?: Date;
-}
+type RegisteredPlugin<TConfig = unknown> =
+  | { state: "pending"; plugin: Plugin<TConfig>; config?: TConfig }
+  | { state: "loaded"; plugin: Plugin<TConfig>; config?: TConfig; loadedAt: Date }
+  | { state: "error"; plugin: Plugin<TConfig>; config?: TConfig; error: Error }
+  | { state: "unloaded"; plugin: Plugin<TConfig> };
 
 /**
  * 소유자 정보 포함 리소스
@@ -89,7 +93,7 @@ export class PluginRegistry {
         const error = new Error(
           `Invalid config for plugin "${id}": ${result.error.message}`
         );
-        this.plugins.set(id, { plugin, state: "error", error });
+        this.plugins.set(id, { plugin: plugin as Plugin<unknown>, state: "error", config: validatedConfig, error });
         throw error;
       }
       validatedConfig = result.data;
@@ -97,7 +101,7 @@ export class PluginRegistry {
 
     // 등록
     this.plugins.set(id, {
-      plugin,
+      plugin: plugin as Plugin<unknown>,
       state: "pending",
       config: validatedConfig,
     });
@@ -112,16 +116,23 @@ export class PluginRegistry {
         await plugin.onLoad();
       }
 
-      const entry = this.plugins.get(id)!;
-      entry.state = "loaded";
-      entry.loadedAt = new Date();
+      this.plugins.set(id, {
+        state: "loaded",
+        plugin: plugin as Plugin<unknown>,
+        config: validatedConfig,
+        loadedAt: new Date(),
+      });
 
       this.logger.info(`Plugin loaded: ${id} (v${plugin.meta.version})`);
     } catch (error) {
-      const entry = this.plugins.get(id)!;
-      entry.state = "error";
-      entry.error = error instanceof Error ? error : new Error(String(error));
-      throw entry.error;
+      const pluginError = error instanceof Error ? error : new Error(String(error));
+      this.plugins.set(id, {
+        state: "error",
+        plugin: plugin as Plugin<unknown>,
+        config: validatedConfig,
+        error: pluginError,
+      });
+      throw pluginError;
     }
   }
 
@@ -142,7 +153,6 @@ export class PluginRegistry {
     // 등록된 리소스 정리
     this.removeOwnedResources(id);
 
-    entry.state = "unloaded";
     this.plugins.delete(id);
 
     this.logger.info(`Plugin unloaded: ${id}`);

package/src/plugins/types.ts

@@ -174,7 +174,7 @@ export interface GuardRule {
   name: string;
   description?: string;
   severity: "error" | "warn" | "off";
-  check: (context: GuardRuleContext) => GuardViolation[];
+  check: (context: GuardRuleContext) => PluginGuardViolation[];
 }
 
 /**
@@ -211,7 +211,7 @@ export interface ExportInfo {
 /**
  * Guard 위반
  */
-export interface GuardViolation {
+export interface PluginGuardViolation {
   ruleId: string;
   message: string;
   severity: "error" | "warn";

package/src/resource/__tests__/backward-compat.test.ts

@@ -277,7 +277,7 @@ describe("Backward Compatibility - Error Handling", () => {
       validateResourceDefinition({
         name: "",
         fields: {},
-      } as any);
+      } as unknown as Parameters<typeof validateResourceDefinition>[0]); // intentionally invalid
       expect(false).toBe(true); // Should not reach here
     } catch (error) {
       expect(error).toBeDefined();
@@ -292,7 +292,7 @@ describe("Backward Compatibility - Error Handling", () => {
       validateResourceDefinition({
         name: "test",
         fields: {},
-      } as any);
+      } as unknown as Parameters<typeof validateResourceDefinition>[0]); // intentionally invalid
       expect(false).toBe(true); // Should not reach here
     } catch (error) {
       expect(error).toBeDefined();

package/src/resource/__tests__/edge-cases.test.ts

@@ -10,6 +10,7 @@ import {
   validateResourceDefinition,
   FieldTypes,
   type ResourceDefinition,
+  type ResourceField,
 } from "../schema";
 
 describe("Edge Cases - Resource Names", () => {
@@ -30,7 +31,7 @@ describe("Edge Cases - Resource Names", () => {
       fields: {
         id: { type: "uuid", required: true },
       },
-    } as any;
+    } as unknown as ResourceDefinition; // intentionally invalid
 
     expect(() => validateResourceDefinition(definition)).toThrow(/Resource name is required/);
   });
@@ -41,7 +42,7 @@ describe("Edge Cases - Resource Names", () => {
       fields: {
         id: { type: "uuid", required: true },
       },
-    } as any;
+    } as unknown as ResourceDefinition; // intentionally invalid
 
     expect(() => validateResourceDefinition(definition)).toThrow(/Invalid resource name/);
   });
@@ -52,7 +53,7 @@ describe("Edge Cases - Resource Names", () => {
       fields: {
         id: { type: "uuid", required: true },
       },
-    } as any;
+    } as unknown as ResourceDefinition; // intentionally invalid
 
     expect(() => validateResourceDefinition(definition)).toThrow(/Invalid resource name/);
   });
@@ -63,7 +64,7 @@ describe("Edge Cases - Resource Names", () => {
       fields: {
         id: { type: "uuid", required: true },
       },
-    } as any;
+    } as unknown as ResourceDefinition; // intentionally invalid
 
     expect(() => validateResourceDefinition(definition)).toThrow(/Invalid resource name/);
   });
@@ -121,7 +122,7 @@ describe("Edge Cases - Field Names", () => {
       fields: {
         _privateField: { type: "string", required: true },
       },
-    } as any;
+    } as unknown as ResourceDefinition; // intentionally invalid
 
     // Field names must start with a letter (not underscore)
     expect(() => validateResourceDefinition(definition)).toThrow(/Invalid field name/);
@@ -133,7 +134,7 @@ describe("Edge Cases - Field Names", () => {
       fields: {
         "1field": { type: "string", required: true },
       },
-    } as any;
+    } as unknown as ResourceDefinition; // intentionally invalid
 
     expect(() => validateResourceDefinition(definition)).toThrow(/Invalid field name/);
   });
@@ -206,7 +207,7 @@ describe("Edge Cases - Field Types", () => {
       fields: {
         id: { type: "unsupported_type", required: true },
       },
-    } as any;
+    } as unknown as ResourceDefinition; // intentionally invalid
 
     expect(() => validateResourceDefinition(definition)).toThrow(/Invalid field type/);
   });
@@ -230,7 +231,7 @@ describe("Edge Cases - Field Types", () => {
       fields: {
         tags: { type: "array", required: true },
       },
-    } as any;
+    } as unknown as ResourceDefinition; // intentionally invalid
 
     expect(() => validateResourceDefinition(definition)).toThrow(/missing "items" property/);
   });
@@ -433,9 +434,9 @@ describe("Edge Cases - Resource Options", () => {
 
 describe("Edge Cases - Large Schemas", () => {
   test("should handle resource with many fields (50 fields)", () => {
-    const fields: Record<string, any> = {};
+    const fields: Record<string, ResourceField> = {};
     for (let i = 0; i < 50; i++) {
-      fields[`field${i}`] = { type: "string", required: i % 2 === 0 };
+      fields[`field${i}`] = { type: "string" as const, required: i % 2 === 0 };
     }
 
     const definition: ResourceDefinition = {
@@ -483,7 +484,7 @@ describe("Edge Cases - Boundary Conditions", () => {
     const definition = {
       name: "test",
       fields: {},
-    } as any;
+    } as unknown as ResourceDefinition; // intentionally invalid
 
     expect(() => validateResourceDefinition(definition)).toThrow(
       /must have at least one field/
@@ -494,7 +495,7 @@ describe("Edge Cases - Boundary Conditions", () => {
     const definition = {
       name: "test",
       fields: null,
-    } as any;
+    } as unknown as ResourceDefinition; // intentionally invalid
 
     expect(() => validateResourceDefinition(definition)).toThrow(
       /must have at least one field/
@@ -505,7 +506,7 @@ describe("Edge Cases - Boundary Conditions", () => {
     const definition = {
       name: "test",
       fields: undefined,
-    } as any;
+    } as unknown as ResourceDefinition; // intentionally invalid
 
     expect(() => validateResourceDefinition(definition)).toThrow(
       /must have at least one field/

package/src/resource/__tests__/fixtures.ts

@@ -166,7 +166,7 @@ export const invalidResourceFixtures = {
     fields: {
       id: { type: "uuid", required: true },
     },
-  } as any,
+  } as unknown as ResourceDefinition, // intentionally invalid: missing name
 
   invalidName: {
     name: "123-invalid",
@@ -190,7 +190,7 @@ export const invalidResourceFixtures = {
   invalidFieldType: {
     name: "valid",
     fields: {
-      field: { type: "invalid" as any, required: true },
+      field: { type: "invalid" as unknown as "string", required: true }, // intentionally invalid type
     },
   } as ResourceDefinition,
 

package/src/resource/__tests__/generator.test.ts

@@ -30,7 +30,7 @@ afterAll(async () => {
 /**
  * Create a test parsed resource (no file import needed)
  */
-function createTestParsedResource(resourceName: string, definition: any): ParsedResource {
+function createTestParsedResource(resourceName: string, definition: ParsedResource["definition"]): ParsedResource {
   return {
     definition,
     filePath: path.join(testDir, "spec", "resources", `${resourceName}.resource.ts`),

package/src/resource/__tests__/performance.test.ts

@@ -7,6 +7,8 @@
 import { describe, test, expect, beforeAll, afterAll } from "bun:test";
 import { generateResourceArtifacts } from "../generator";
 import type { ParsedResource } from "../parser";
+import type { ResourceField, ResourceDefinition } from "../schema";
+import { validateResourceDefinition } from "../schema";
 import path from "path";
 import fs from "fs/promises";
 import os from "os";
@@ -29,7 +31,7 @@ afterAll(async () => {
 /**
  * Create a test parsed resource
  */
-function createTestParsedResource(resourceName: string, definition: any): ParsedResource {
+function createTestParsedResource(resourceName: string, definition: ParsedResource["definition"]): ParsedResource {
   return {
     definition,
     filePath: path.join(testDir, "spec", "resources", `${resourceName}.resource.ts`),
@@ -70,10 +72,10 @@ describe("Performance - Resource Generation", () => {
   });
 
   test("should handle resource with 50 fields in < 1000ms", async () => {
-    const fields: Record<string, any> = {};
+    const fields: Record<string, ResourceField> = {};
     for (let i = 0; i < 50; i++) {
       fields[`field${i}`] = {
-        type: i % 5 === 0 ? "number" : "string",
+        type: i % 5 === 0 ? "number" as const : "string" as const,
         required: i % 2 === 0,
         default: i % 3 === 0 ? `value${i}` : undefined,
       };
@@ -169,7 +171,7 @@ describe("Performance - Schema Validation", () => {
   test("should validate complex schema (50 fields) in < 50ms", async () => {
     const { validateResourceDefinition } = await import("../schema");
 
-    const fields: Record<string, any> = {};
+    const fields: Record<string, ResourceField> = {};
     for (let i = 0; i < 50; i++) {
       fields[`field${i}`] = {
         type: (["string", "number", "boolean", "date", "email"] as const)[i % 5],
@@ -177,7 +179,7 @@ describe("Performance - Schema Validation", () => {
       };
     }
 
-    const definition = {
+    const definition: ResourceDefinition = {
       name: "complex",
       fields,
       options: {
@@ -280,7 +282,7 @@ describe("Performance - Comparison Benchmarks", () => {
     );
 
     // Large resource
-    const largeFields: Record<string, any> = {};
+    const largeFields: Record<string, ResourceField> = {};
     for (let i = 0; i < 30; i++) {
       largeFields[`field${i}`] = {
         type: (["string", "number", "boolean"] as const)[i % 3],

package/src/resource/schema.ts

@@ -40,7 +40,7 @@ export interface ResourceField {
   /** 배열 타입인 경우 요소 타입 */
   items?: FieldType;
   /** 커스텀 Zod 스키마 (고급 사용) */
-  schema?: z.ZodType<any>;
+  schema?: z.ZodTypeAny;
 }
 
 // ============================================

package/src/router/fs-routes.ts

@@ -21,7 +21,7 @@ import { loadManduConfig } from "../config";
 /**
  * 매니페스트 생성 결과
  */
-export interface GenerateResult {
+export interface FSGenerateResult {
   /** 생성된 매니페스트 */
   manifest: RoutesManifest;
 
@@ -51,49 +51,43 @@ export interface GenerateOptions {
  * FSRouteConfig를 RouteSpec으로 변환
  */
 export function fsRouteToRouteSpec(fsRoute: FSRouteConfig): RouteSpec {
-  const routeSpec: RouteSpec = {
+  const base = {
     id: fsRoute.id,
     pattern: fsRoute.pattern,
-    kind: fsRoute.kind,
     module: fsRoute.module,
   };
 
-  // 페이지 라우트의 경우
   if (fsRoute.kind === "page") {
-    routeSpec.componentModule = fsRoute.componentModule;
-
-    // Island (클라이언트 모듈)
-    if (fsRoute.clientModule) {
-      routeSpec.clientModule = fsRoute.clientModule;
-      routeSpec.hydration = fsRoute.hydration ?? {
-        strategy: "island",
-        priority: "visible",
-        preload: false,
-      };
-    }
-
-    // Layout 체인
-    if (fsRoute.layoutChain && fsRoute.layoutChain.length > 0) {
-      routeSpec.layoutChain = fsRoute.layoutChain;
-    }
-
-    // Loading UI
-    if (fsRoute.loadingModule) {
-      routeSpec.loadingModule = fsRoute.loadingModule;
-    }
-
-    // Error UI
-    if (fsRoute.errorModule) {
-      routeSpec.errorModule = fsRoute.errorModule;
-    }
+    const pageRoute: RouteSpec = {
+      ...base,
+      kind: "page" as const,
+      componentModule: fsRoute.componentModule ?? "",
+      ...(fsRoute.clientModule
+        ? {
+            clientModule: fsRoute.clientModule,
+            hydration: fsRoute.hydration ?? {
+              strategy: "island" as const,
+              priority: "visible" as const,
+              preload: false,
+            },
+          }
+        : {}),
+      ...(fsRoute.layoutChain && fsRoute.layoutChain.length > 0
+        ? { layoutChain: fsRoute.layoutChain }
+        : {}),
+      ...(fsRoute.loadingModule ? { loadingModule: fsRoute.loadingModule } : {}),
+      ...(fsRoute.errorModule ? { errorModule: fsRoute.errorModule } : {}),
+    };
+    return pageRoute;
   }
 
-  // API 라우트의 경우
-  if (fsRoute.kind === "api" && fsRoute.methods) {
-    routeSpec.methods = fsRoute.methods;
-  }
-
-  return routeSpec;
+  // API 라우트
+  const apiRoute: RouteSpec = {
+    ...base,
+    kind: "api" as const,
+    ...(fsRoute.methods ? { methods: fsRoute.methods } : {}),
+  };
+  return apiRoute;
 }
 
 /**
@@ -176,7 +170,7 @@ async function resolveScannerConfig(
 export async function generateManifest(
   rootDir: string,
   options: GenerateOptions = {}
-): Promise<GenerateResult> {
+): Promise<FSGenerateResult> {
   const scannerConfig = await resolveScannerConfig(rootDir, options.scanner);
 
   // FS Routes 스캔
@@ -215,7 +209,7 @@ export async function generateManifest(
 /**
  * 라우트 변경 콜백
  */
-export type RouteChangeCallback = (result: GenerateResult) => void | Promise<void>;
+export type RouteChangeCallback = (result: FSGenerateResult) => void | Promise<void>;
 
 /**
  * FS Routes 감시자 인터페이스
@@ -225,7 +219,7 @@ export interface FSRoutesWatcher {
   close(): void;
 
   /** 수동 재스캔 */
-  rescan(): Promise<GenerateResult>;
+  rescan(): Promise<FSGenerateResult>;
 }
 
 /**
@@ -281,7 +275,7 @@ export async function watchFSRoutes(
 
   let debounceTimer: ReturnType<typeof setTimeout> | null = null;
 
-  const triggerRescan = async (): Promise<GenerateResult> => {
+  const triggerRescan = async (): Promise<FSGenerateResult> => {
     const result = await generateManifest(rootDir, generateOptions);
     if (onChange) {
       await onChange(result);

package/src/router/fs-types.ts

@@ -6,7 +6,7 @@
  * @module router/fs-types
  */
 
-import type { RouteKind, HydrationConfig, HttpMethod } from "../spec/schema";
+import type { RouteKind, HydrationConfig, SpecHttpMethod } from "../spec/schema";
 
 // ═══════════════════════════════════════════════════════════════════════════
 // Segment Types
@@ -93,7 +93,7 @@ export interface FSRouteConfig {
   kind: RouteKind;
 
   /** HTTP 메서드 (API 라우트용) */
-  methods?: HttpMethod[];
+  methods?: SpecHttpMethod[];
 
   /** 페이지 컴포넌트 모듈 경로 */
   componentModule?: string;

package/src/router/index.ts

@@ -69,7 +69,7 @@ export {
 export { FSScanner, createFSScanner, scanRoutes } from "./fs-scanner";
 
 // Generator
-export type { GenerateResult, GenerateOptions, RouteChangeCallback, FSRoutesWatcher } from "./fs-routes";
+export type { FSGenerateResult, GenerateOptions, RouteChangeCallback, FSRoutesWatcher } from "./fs-routes";
 
 export {
   fsRouteToRouteSpec,