@mandujs/core 0.18.20 → 0.18.22

package/src/devtools/index.ts

@@ -16,11 +16,11 @@ export type {
 
   // Error
   ErrorType,
-  Severity,
+  DevToolsSeverity,
   NormalizedError,
 
   // Island
-  HydrationStrategy,
+  DevToolsHydrationStrategy,
   IslandStatus,
   IslandSnapshot,
 
@@ -29,7 +29,7 @@ export type {
   NetworkBodyPolicy,
 
   // Guard
-  GuardViolation,
+  DevToolsGuardViolation,
 
   // AI Context
   CodeContextInfo,
@@ -170,7 +170,7 @@ export {
   createIslandHydrateEndEvent,
   createNetworkRequestEvent,
   createNetworkResponseEvent,
-  createGuardViolationEvent,
+  createDevToolsGuardViolationEvent,
   createHmrUpdateEvent,
   createHmrErrorEvent,
 
@@ -199,12 +199,12 @@ export {
 // ============================================================================
 
 import { getOrCreateHook } from './hook';
-import type { NormalizedError, GuardViolation } from './types';
+import type { NormalizedError, DevToolsGuardViolation } from './types';
 import {
   createErrorEvent,
   createHmrUpdateEvent,
   createHmrErrorEvent,
-  createGuardViolationEvent,
+  createDevToolsGuardViolationEvent,
 } from './protocol';
 
 /**
@@ -261,10 +261,10 @@ export function notifyHmrError(message: string, stack?: string): void {
  * Guard 위반 리포트 (간편 API)
  */
 export function reportGuardViolation(
-  violation: Omit<GuardViolation, 'id' | 'timestamp'>
+  violation: Omit<DevToolsGuardViolation, 'id' | 'timestamp'>
 ): void {
   const hook = getOrCreateHook();
-  hook.emit(createGuardViolationEvent(violation));
+  hook.emit(createDevToolsGuardViolationEvent(violation));
 }
 
 // ============================================================================

package/src/devtools/init.ts

@@ -30,7 +30,7 @@ export interface KitchenInstance {
   /** DevTools 언마운트 및 정리 */
   destroy: () => void;
   /** 상태 관리자 접근 */
-  getState: () => any;
+  getState: () => Record<string, unknown>;
   /** 에러 리포트 */
   reportError: (error: Error | string) => void;
   /** DevTools 열기 */
@@ -213,7 +213,7 @@ function createInstance(): KitchenInstance {
 function createNoopInstance(): KitchenInstance {
   return {
     destroy: () => {},
-    getState: () => ({} as any),
+    getState: () => ({}),
     reportError: () => {},
     open: () => {},
     close: () => {},

package/src/devtools/protocol.ts

@@ -8,7 +8,7 @@ import type {
   NormalizedError,
   IslandSnapshot,
   NetworkRequest,
-  GuardViolation,
+  DevToolsGuardViolation,
 } from './types';
 
 // ============================================================================
@@ -33,7 +33,7 @@ export type KitchenEvents =
   | KitchenEvent<'network:error', { id: string; error: string }>
 
   // Guard events
-  | KitchenEvent<'guard:violation', GuardViolation>
+  | KitchenEvent<'guard:violation', DevToolsGuardViolation>
   | KitchenEvent<'guard:clear', { ruleId?: string }>
 
   // HMR events
@@ -144,8 +144,8 @@ export function createNetworkResponseEvent(
   };
 }
 
-export function createGuardViolationEvent(
-  violation: Omit<GuardViolation, 'id' | 'timestamp'>
+export function createDevToolsGuardViolationEvent(
+  violation: Omit<DevToolsGuardViolation, 'id' | 'timestamp'>
 ): KitchenEvents {
   return {
     type: 'guard:violation',

package/src/devtools/server/source-context.ts

@@ -235,8 +235,14 @@ export interface SourcemapParseResult {
 /**
  * 간단한 Sourcemap 파서 (Base64 VLQ 디코딩)
  */
+interface RawSourcemap {
+  mappings: string;
+  sources: string[];
+  names?: string[];
+}
+
 export class SourcemapParser {
-  private sourcemap: any;
+  private sourcemap: RawSourcemap;
 
   constructor(sourcemapContent: string) {
     try {
@@ -405,7 +411,7 @@ export function createViteMiddleware(projectRoot: string) {
   const provider = new SourceContextProvider({ projectRoot });
   const handler = provider.createHandler();
 
-  return async (req: any, res: any, next: () => void) => {
+  return async (req: { url?: string }, res: { setHeader: (key: string, value: string) => void; statusCode: number; end: (data: string) => void }, next: () => void) => {
     // __mandu_source__ 엔드포인트만 처리
     if (!req.url?.startsWith('/api/__mandu_source__')) {
       return next();
@@ -435,7 +441,7 @@ export function manduSourceContextPlugin(options?: Partial<SourceContextProvider
   return {
     name: 'mandu-source-context',
 
-    configureServer(server: any) {
+    configureServer(server: { config: { root?: string }; middlewares: { use: (middleware: ReturnType<typeof createViteMiddleware>) => void } }) {
       const projectRoot = options?.projectRoot ?? server.config.root ?? process.cwd();
 
       server.middlewares.use(createViteMiddleware(projectRoot));

package/src/devtools/types.ts

@@ -18,12 +18,12 @@ export interface KitchenEvent<T extends string = string, D = unknown> {
 // ============================================================================
 
 export type ErrorType = 'runtime' | 'unhandled' | 'react' | 'network' | 'hmr' | 'guard';
-export type Severity = 'critical' | 'error' | 'warning' | 'info';
+export type DevToolsSeverity = 'critical' | 'error' | 'warning' | 'info';
 
 export interface NormalizedError {
   id: string;
   type: ErrorType;
-  severity: Severity;
+  severity: DevToolsSeverity;
   message: string;
   stack?: string;
   source?: string;
@@ -39,13 +39,13 @@ export interface NormalizedError {
 // Island Types
 // ============================================================================
 
-export type HydrationStrategy = 'load' | 'idle' | 'visible' | 'media' | 'never';
+export type DevToolsHydrationStrategy = 'load' | 'idle' | 'visible' | 'media' | 'never';
 export type IslandStatus = 'ssr' | 'pending' | 'hydrating' | 'hydrated' | 'error';
 
 export interface IslandSnapshot {
   id: string;
   name: string;
-  strategy: HydrationStrategy;
+  strategy: DevToolsHydrationStrategy;
   status: IslandStatus;
   ssrRenderTime?: number;
   hydrateStartTime?: number;
@@ -89,7 +89,7 @@ export interface NetworkBodyPolicy {
 // Guard Types
 // ============================================================================
 
-export interface GuardViolation {
+export interface DevToolsGuardViolation {
   id: string;
   ruleId: string;
   ruleName: string;

package/src/devtools/worker/redaction-worker.ts

@@ -185,12 +185,14 @@ function handleMessage(request: WorkerRequest): WorkerResponse {
         };
       }
 
-      default:
+      default: {
+        const unknownType: string = request.type;
         return {
           id: request.id,
           success: false,
-          error: `Unknown request type: ${(request as any).type}`,
+          error: `Unknown request type: ${unknownType}`,
         };
+      }
     }
   } catch (error) {
     return {
@@ -202,10 +204,15 @@ function handleMessage(request: WorkerRequest): WorkerResponse {
 }
 
 // Worker 컨텍스트에서만 실행
-if (typeof self !== 'undefined' && typeof (self as any).postMessage === 'function') {
-  self.onmessage = (event: MessageEvent<WorkerRequest>) => {
+interface WorkerSelf {
+  postMessage: (message: WorkerResponse) => void;
+  onmessage: ((event: MessageEvent<WorkerRequest>) => void) | null;
+}
+const workerSelf = typeof self !== 'undefined' ? (self as unknown as WorkerSelf) : undefined;
+if (workerSelf && typeof workerSelf.postMessage === 'function') {
+  workerSelf.onmessage = (event: MessageEvent<WorkerRequest>) => {
     const response = handleMessage(event.data);
-    (self as any).postMessage(response);
+    workerSelf.postMessage(response);
   };
 }
 

package/src/error/index.ts

@@ -38,4 +38,4 @@ export {
 
 // Result helpers
 export type { Result } from "./result";
-export { ok, err, statusFromError, errorToResponse } from "./result";
+export { ok, err, isOk, isErr, statusFromError, errorToResponse } from "./result";

package/src/error/result.ts

@@ -12,6 +12,20 @@ export type Result<T> =
 export const ok = <T>(value: T): Result<T> => ({ ok: true, value });
 export const err = (error: ManduError): Result<never> => ({ ok: false, error });
 
+/**
+ * Result가 성공인지 검사하는 type guard
+ */
+export function isOk<T>(result: Result<T>): result is { ok: true; value: T } {
+  return result.ok === true;
+}
+
+/**
+ * Result가 실패인지 검사하는 type guard
+ */
+export function isErr<T>(result: Result<T>): result is { ok: false; error: ManduError } {
+  return result.ok === false;
+}
+
 /**
  * ManduError -> HTTP status 매핑
  */

package/src/filling/deps.ts

@@ -163,7 +163,7 @@ export function createMockDeps(overrides: Partial<FillingDeps> = {}): FillingDep
 
   return {
     db: {
-      query: async () => [] as any,
+      query: async () => [] as never,
       transaction: async (fn) => fn(),
     },
     cache: {
@@ -171,7 +171,10 @@ export function createMockDeps(overrides: Partial<FillingDeps> = {}): FillingDep
       set: asyncNoop,
       delete: asyncNoop,
     },
-    fetch: async () => new Response(),
+    fetch: Object.assign(
+      async (): Promise<Response> => new Response(),
+      { preconnect: (_url: string) => {} }
+    ) as typeof fetch,
     logger: {
       debug: noop,
       info: noop,

package/src/filling/filling.ts

@@ -361,7 +361,7 @@ export class ManduFilling<TLoaderData = unknown> {
       if (error instanceof ValidationError) {
         return ctx.json({ errorType: "LOGIC_ERROR", code: ErrorCode.SLOT_VALIDATION_ERROR, message: "Validation failed", summary: "입력 검증 실패 - 요청 데이터 확인 필요", fix: { file: routeContext ? `spec/slots/${routeContext.routeId}.slot.ts` : "spec/slots/", suggestion: "요청 데이터가 스키마와 일치하는지 확인하세요" }, route: routeContext, errors: error.errors, timestamp: new Date().toISOString() }, 400);
       }
-      const classifier = new ErrorClassifier(null, routeContext);
+      const classifier = new ErrorClassifier(null, routeContext ? { id: routeContext.routeId, pattern: routeContext.pattern } : undefined);
       const manduError = classifier.classify(error);
       console.error(`[Mandu] ${manduError.errorType}:`, manduError.message);
       const response = formatErrorResponse(manduError, { isDev: process.env.NODE_ENV !== "production" });

package/src/generator/templates.ts

@@ -304,7 +304,7 @@ interface Props {
 }
 
 function ${pageName}Page({ params, loaderData }: Props): React.ReactElement {
-  const serverData = (loaderData || {}) as any;
+  const serverData = (loaderData || {}) as Record<string, unknown>;
   const setupResult = islandModule.definition.setup(serverData);
   return islandModule.definition.render(setupResult) as React.ReactElement;
 }
@@ -333,7 +333,7 @@ interface Props {
 }
 
 export default function ${pageName}Page({ params, loaderData }: Props): React.ReactElement {
-  const serverData = (loaderData || {}) as any;
+  const serverData = (loaderData || {}) as Record<string, unknown>;
   const setupResult = islandModule.definition.setup(serverData);
   return islandModule.definition.render(setupResult) as React.ReactElement;
 }

package/src/guard/contract-guard.test.ts

@@ -78,6 +78,7 @@ describe("Contract Guard", () => {
             pattern: "/",
             kind: "page",
             module: "generated/routes/home.ts",
+            componentModule: "generated/routes/home.tsx",
             slotModule: "spec/slots/home.slot.ts",
             // No contractModule - but that's fine for pages
           },

package/src/guard/file-type.test.ts

@@ -1,4 +1,4 @@
-import { describe, it, expect } from "vitest";
+import { describe, it, expect } from "bun:test";
 import { validateFileAnalysis } from "./validator";
 import { fsdPreset } from "./presets/fsd";
 import type { FileAnalysis, GuardConfig } from "./types";

package/src/guard/index.ts

@@ -272,7 +272,7 @@ export {
   type SlotMetadata,
   type CustomRule,
   type ConstraintViolation,
-  type SlotValidationResult,
+  type SemanticSlotValidationResult,
 } from "./semantic-slots";
 
 // ═══════════════════════════════════════════════════════════════════════════

package/src/guard/negotiation.ts

@@ -988,16 +988,44 @@ export interface ${toPascalCase(name)}Dto {
 export interface ${toPascalCase(name)}ResponseDto {
   // TODO: Define response DTO fields
 }
+`;
+
+    case "controller":
+      return `/**
+ * ${purpose}
+ *
+ * Controller - 요청/응답 처리
+ */
+
+export class ${toPascalCase(name)}Controller {
+  // TODO: Implement controller methods
+}
+`;
+
+    case "hook":
+      return `/**
+ * ${purpose}
+ *
+ * Custom Hook
+ */
+
+export function use${toPascalCase(name)}() {
+  // TODO: Implement hook logic
+}
 `;
 
     case "util":
-    default:
       return `/**
  * ${purpose}
  */
 
 // TODO: Implement utility functions
 `;
+
+    default: {
+      const _exhaustive: never = template;
+      throw new Error(`Unhandled file template: ${_exhaustive}`);
+    }
   }
 }
 

package/src/guard/presets/index.ts

@@ -11,6 +11,9 @@ import { hexagonalPreset, HEXAGONAL_HIERARCHY } from "./hexagonal";
 import { atomicPreset, ATOMIC_HIERARCHY } from "./atomic";
 import { cqrsPreset, CQRS_HIERARCHY } from "./cqrs";
 
+// Re-export types
+export type { GuardPreset, PresetDefinition } from "../types";
+
 // Re-export
 export { fsdPreset, FSD_HIERARCHY } from "./fsd";
 export { cleanPreset, CLEAN_HIERARCHY } from "./clean";

package/src/guard/semantic-slots.ts

@@ -144,7 +144,7 @@ export interface ConstraintViolation {
 /**
  * 슬롯 검증 결과
  */
-export interface SlotValidationResult {
+export interface SemanticSlotValidationResult {
   /** 유효 여부 */
   valid: boolean;
 
@@ -461,7 +461,7 @@ export async function validateSlotConstraints(
   filePath: string,
   constraints: SlotConstraints,
   rootDir?: string
-): Promise<SlotValidationResult> {
+): Promise<SemanticSlotValidationResult> {
   const violations: ConstraintViolation[] = [];
   const suggestions: string[] = [];
 
@@ -727,9 +727,9 @@ export async function validateSlots(
   totalSlots: number;
   validSlots: number;
   invalidSlots: number;
-  results: SlotValidationResult[];
+  results: SemanticSlotValidationResult[];
 }> {
-  const results: SlotValidationResult[] = [];
+  const results: SemanticSlotValidationResult[] = [];
 
   for (const filePath of slotFiles) {
     // 파일에서 메타데이터 추출 시도

package/src/index.ts

@@ -23,12 +23,21 @@ export * from "./intent";
 export * from "./devtools";
 export * from "./paths";
 export * from "./resource";
+export * from "./types";
+
+// ── Resolve export * ambiguities (TS2308) ──
+// When the same name is exported from multiple submodules via `export *`,
+// TypeScript considers them ambiguous. Explicit re-exports resolve this.
+export { formatViolation } from "./guard";
+export { type HttpMethod } from "./filling";
+export { type GuardViolation } from "./guard";
+export { type Severity } from "./guard";
 
 // Consolidated Mandu namespace
 import { ManduFilling, ManduContext, ManduFillingFactory, createSSEConnection } from "./filling";
 import { createContract, defineHandler, defineRoute, createClient, contractFetch, createClientContract, querySchema, bodySchema, apiError } from "./contract";
 import { defineContract, generateAllFromContract, generateOpenAPISpec } from "./contract/define";
-import { island, isIsland, type IslandComponent, type HydrationStrategy } from "./island";
+import { island, isIsland, type IslandComponent, type IslandHydrationStrategy } from "./island";
 import { intent, isIntent, getIntentDocs, generateOpenAPIFromIntent } from "./intent";
 import { initializeHook, reportError, ManduDevTools, getStateManager } from "./devtools";
 import type { ContractDefinition, ContractInstance, ContractSchema } from "./contract";

package/src/intent/index.ts

@@ -25,6 +25,8 @@
 import { z, type ZodType } from 'zod';
 import { ManduFillingFactory, type ManduFilling } from '../filling/filling';
 import type { ManduContext } from '../filling/context';
+import { getZodTypeName, getZodObjectShape, getZodArrayElementType } from '../contract/zod-utils';
+import type { ZodTypeAny } from 'zod';
 
 // ============================================================================
 // Types
@@ -51,7 +53,7 @@ export interface IntentDefinition<TInput = unknown, TOutput = unknown> {
   guard?: (ctx: ManduContext) => Response | void | Promise<Response | void>;
 }
 
-export type IntentMap = Record<string, IntentDefinition<any, any>>;
+export type IntentMap = Record<string, IntentDefinition<unknown, unknown>>;
 
 export interface IntentMeta {
   __intent: true;
@@ -86,7 +88,7 @@ export function intent(intents: IntentMap): ManduFilling & IntentMeta {
   const docs: IntentDocumentation[] = [];
 
   // 메서드별로 핸들러 그룹화
-  const methodHandlers: Record<HttpMethod, IntentDefinition<any, any>[]> = {
+  const methodHandlers: Record<HttpMethod, IntentDefinition<unknown, unknown>[]> = {
     GET: [],
     POST: [],
     PUT: [],
@@ -115,12 +117,13 @@ export function intent(intents: IntentMap): ManduFilling & IntentMeta {
   }
 
   // 각 메서드에 대해 핸들러 등록
-  const registerMethod = (method: HttpMethod, handlers: IntentDefinition<any, any>[]) => {
+  const registerMethod = (method: HttpMethod, handlers: IntentDefinition<unknown, unknown>[]) => {
     if (handlers.length === 0) return;
 
     const methodLower = method.toLowerCase() as Lowercase<HttpMethod>;
+    const fillingWithMethods = filling as ManduFilling & Record<Lowercase<HttpMethod>, (handler: (ctx: ManduContext) => Response | Promise<Response>) => ManduFilling>;
 
-    (filling as any)[methodLower](async (ctx: ManduContext) => {
+    fillingWithMethods[methodLower](async (ctx: ManduContext) => {
       // 경로 매칭 (path가 있는 경우)
       for (const def of handlers) {
         if (def.path && !matchPath(ctx.url, def.path)) {
@@ -135,11 +138,15 @@ export function intent(intents: IntentMap): ManduFilling & IntentMeta {
           }
         }
 
-        // Input 검증
+        // Input 검증 (ctx.body() throws ValidationError on schema mismatch)
         if (def.input && ['POST', 'PUT', 'PATCH'].includes(method)) {
-          const bodyResult = await ctx.body(def.input);
-          if (!bodyResult.success) {
-            return ctx.error('Validation failed', bodyResult.error);
+          try {
+            await ctx.body(def.input);
+          } catch (validationError) {
+            return ctx.error(
+              'Validation failed',
+              validationError instanceof Error ? validationError : new Error(String(validationError))
+            );
           }
         }
 
@@ -247,26 +254,30 @@ export function generateOpenAPIFromIntent(
  */
 function zodToJsonSchema(schema: ZodType<unknown>): Record<string, unknown> {
   // 실제 구현은 zod-to-json-schema 라이브러리 사용 권장
-  const def = (schema as any)._def;
+  const typeName = getZodTypeName(schema as ZodTypeAny);
 
-  if (def.typeName === 'ZodString') {
+  if (typeName === 'ZodString') {
     return { type: 'string' };
   }
-  if (def.typeName === 'ZodNumber') {
+  if (typeName === 'ZodNumber') {
     return { type: 'number' };
   }
-  if (def.typeName === 'ZodBoolean') {
+  if (typeName === 'ZodBoolean') {
     return { type: 'boolean' };
   }
-  if (def.typeName === 'ZodObject') {
+  if (typeName === 'ZodObject') {
     const properties: Record<string, unknown> = {};
-    for (const [key, value] of Object.entries(def.shape())) {
-      properties[key] = zodToJsonSchema(value as ZodType<unknown>);
+    const shape = getZodObjectShape(schema as ZodTypeAny);
+    if (shape) {
+      for (const [key, value] of Object.entries(shape)) {
+        properties[key] = zodToJsonSchema(value as ZodType<unknown>);
+      }
     }
     return { type: 'object', properties };
   }
-  if (def.typeName === 'ZodArray') {
-    return { type: 'array', items: zodToJsonSchema(def.type) };
+  if (typeName === 'ZodArray') {
+    const elementType = getZodArrayElementType(schema as ZodTypeAny);
+    return { type: 'array', items: elementType ? zodToJsonSchema(elementType as ZodType<unknown>) : {} };
   }
 
   return { type: 'unknown' };

package/src/island/index.ts

@@ -20,7 +20,7 @@ import { z } from 'zod';
 // ============================================================================
 
 /** 하이드레이션 타이밍 */
-export type HydrationStrategy =
+export type IslandHydrationStrategy =
   | 'load'      // 페이지 로드 즉시
   | 'idle'      // requestIdleCallback
   | 'visible'   // IntersectionObserver
@@ -30,7 +30,7 @@ export type HydrationStrategy =
 /** Island 옵션 */
 export interface IslandOptions<P = unknown> {
   /** 하이드레이션 전략 */
-  hydrate: HydrationStrategy;
+  hydrate: IslandHydrationStrategy;
   /** 미디어 쿼리 (hydrate: 'media' 일 때) */
   media?: string;
   /** SSR 폴백 컴포넌트 */
@@ -44,7 +44,7 @@ export interface IslandOptions<P = unknown> {
 /** Island 컴포넌트 메타데이터 */
 export interface IslandMeta {
   __island: true;
-  __hydrate: HydrationStrategy;
+  __hydrate: IslandHydrationStrategy;
   __media?: string;
   __fallback?: ReactNode;
   __name: string;
@@ -95,7 +95,7 @@ export function getAllIslands(): Map<string, IslandComponent<any>> {
  * });
  */
 export function island<P extends Record<string, unknown>>(
-  strategy: HydrationStrategy,
+  strategy: IslandHydrationStrategy,
   Component: ComponentType<P>
 ): IslandComponent<P>;
 
@@ -105,7 +105,7 @@ export function island<P extends Record<string, unknown>>(
 ): IslandComponent<P>;
 
 export function island<P extends Record<string, unknown>>(
-  strategyOrOptions: HydrationStrategy | IslandOptions<P>,
+  strategyOrOptions: IslandHydrationStrategy | IslandOptions<P>,
   Component: ComponentType<P>
 ): IslandComponent<P> {
   const options: IslandOptions<P> = typeof strategyOrOptions === 'string'
@@ -133,10 +133,10 @@ export function island<P extends Record<string, unknown>>(
 // isIsland() - Island 컴포넌트 체크
 // ============================================================================
 
-export function isIsland(component: unknown): component is IslandComponent<unknown> {
+export function isIsland(component: unknown): component is IslandComponent<any> {
   return (
     typeof component === 'function' &&
-    (component as IslandComponent<unknown>).__island === true
+    (component as IslandComponent<any>).__island === true
   );
 }
 
@@ -194,7 +194,7 @@ export function deserializeIslandProps(json: string): Record<string, unknown> {
 export interface IslandPlaceholderProps {
   name: string;
   props: Record<string, unknown>;
-  hydrate: HydrationStrategy;
+  hydrate: IslandHydrationStrategy;
   media?: string;
   fallback?: ReactNode;
 }