@nooh-ts/compiler 0.1.1 → 0.2.1

package/dist/index.mjs

@@ -86,18 +86,29 @@ const isPathInside = (file, root) => {
 const generateAppModule = (plan, model) => {
 	const moduleId = `${plan.outputRoot}/app.ts`;
 	const typesModuleId = `${plan.outputRoot}/types.ts`;
+	const errorModuleId = `${plan.outputRoot}/error.ts`;
 	const root = model.groups.find((group) => group.id === "root");
 	if (!root) throw new Error("Nooh compilation requires a root route group.");
 	return {
 		code: [
 			...[
 				`import { Hono } from "hono";`,
+				`import config from ${JSON.stringify(relativeModuleSpecifier(moduleId, model.config.source))};`,
 				`import type { App } from ${JSON.stringify(relativeModuleSpecifier(moduleId, typesModuleId))};`,
+				`import { defaultErrorHandler } from ${JSON.stringify(relativeModuleSpecifier(moduleId, errorModuleId))};`,
 				`import root from ${JSON.stringify(relativeModuleSpecifier(moduleId, groupModuleId(plan, root.id)))};`
 			],
 			"",
 			"const app = new Hono<App>();",
 			"",
+			"if (config.onError !== undefined) {",
+			"  app.onError(",
+			"    config.onError as Parameters<typeof app.onError>[0],",
+			"  );",
+			"} else {",
+			"  app.onError(defaultErrorHandler);",
+			"}",
+			"",
 			"app.route(\"/\", root);",
 			"",
 			"export type AppType = typeof app;",
@@ -110,6 +121,175 @@ const generateAppModule = (plan, model) => {
 	};
 };
 //#endregion
+//#region src/generate/dependency.ts
+const generateDependencyModule = (plan) => {
+	const moduleId = `${plan.outputRoot}/router/di.ts`;
+	return {
+		code: [
+			"import type {",
+			"  DependencyResolutionContext,",
+			"} from \"@nooh-ts/nooh\";",
+			"",
+			"const requestContexts =",
+			"  new WeakMap<object, DependencyResolutionContext>();",
+			"",
+			"export const createDependencyResolutionContext = (): DependencyResolutionContext => ({",
+			"  cache: new Map<object, unknown>(),",
+			"  resolving: new Set<object>(),",
+			"  stack: [],",
+			"});",
+			"",
+			"export const getDependencyResolutionContext = (",
+			"  request: object,",
+			"): DependencyResolutionContext => {",
+			"  const existing = requestContexts.get(request);",
+			"",
+			"  if (existing) {",
+			"    return existing;",
+			"  }",
+			"",
+			"  const created = createDependencyResolutionContext();",
+			"",
+			"  requestContexts.set(request, created);",
+			"",
+			"  return created;",
+			"};",
+			""
+		].join("\n"),
+		id: moduleId,
+		kind: "di"
+	};
+};
+//#endregion
+//#region src/generate/error.ts
+const generateErrorModule = (plan) => {
+	const moduleId = `${plan.outputRoot}/error.ts`;
+	const typesModuleId = `${plan.outputRoot}/types.ts`;
+	return {
+		code: [
+			`import { HTTPException } from "hono/http-exception";`,
+			`import type { ErrorHandler } from "hono";`,
+			`import type { App } from ${JSON.stringify(relativeModuleSpecifier(moduleId, typesModuleId))};`,
+			`import type { NoohStandardSchema } from "@nooh-ts/nooh";`,
+			"",
+			"const isRecord = (",
+			"  value: unknown,",
+			"): value is Record<PropertyKey, unknown> =>",
+			"  typeof value === \"object\" && value !== null;",
+			"",
+			"export class ResponseValidationError extends Error {",
+			"  readonly route: string;",
+			"  readonly issues: readonly unknown[];",
+			"",
+			"  constructor(",
+			"    route: string,",
+			"    issues: readonly unknown[],",
+			"  ) {",
+			"    super(`Response validation failed for ${route}.`);",
+			"    this.name = \"ResponseValidationError\";",
+			"    this.route = route;",
+			"    this.issues = issues;",
+			"  }",
+			"}",
+			"",
+			"const extractResponseValue = async (",
+			"  response: Response,",
+			"  route: string,",
+			"): Promise<unknown> => {",
+			"  if (",
+			"    response.status === 204 ||",
+			"    response.status === 205 ||",
+			"    response.status === 304 ||",
+			"    response.body === null",
+			"  ) {",
+			"    return undefined;",
+			"  }",
+			"",
+			"  const contentType =",
+			"    response.headers.get(\"content-type\")?.split(\";\", 1)[0]?.trim().toLowerCase() ??",
+			"    \"\";",
+			"",
+			"  let clone: Response;",
+			"",
+			"  try {",
+			"    clone = response.clone();",
+			"  } catch {",
+			"    throw new ResponseValidationError(route, [",
+			"      {",
+			"        message: \"The response body could not be cloned for validation.\",",
+			"      },",
+			"    ]);",
+			"  }",
+			"",
+			"  if (",
+			"    contentType === \"application/json\" ||",
+			"    contentType.endsWith(\"+json\")",
+			"  ) {",
+			"    try {",
+			"      return await clone.json();",
+			"    } catch {",
+			"      throw new ResponseValidationError(route, [",
+			"        {",
+			"          message: \"The response body is not valid JSON.\",",
+			"        },",
+			"      ]);",
+			"    }",
+			"  }",
+			"",
+			"  if (contentType.startsWith(\"text/\")) {",
+			"    return clone.text();",
+			"  }",
+			"",
+			"  throw new ResponseValidationError(route, [",
+			"    {",
+			"      message:",
+			"        `Response validation only supports JSON and text responses. ` +",
+			"        `Received \"${contentType || \"unknown\"}\".`,",
+			"    },",
+			"  ]);",
+			"};",
+			"",
+			"export const validateResponse = async (",
+			"  response: Response,",
+			"  schema: NoohStandardSchema,",
+			"  route: string,",
+			"): Promise<Response> => {",
+			"  const value = await extractResponseValue(response, route);",
+			"",
+			"  const validate = schema[\"~standard\"]",
+			"    .validate as (value: unknown) =>",
+			"    | unknown",
+			"    | Promise<unknown>;",
+			"",
+			"  const result = await validate(value);",
+			"",
+			"  if (",
+			"    isRecord(result) &&",
+			"    \"issues\" in result &&",
+			"    Array.isArray(result.issues)",
+			"  ) {",
+			"    throw new ResponseValidationError(route, result.issues);",
+			"  }",
+			"",
+			"  return response;",
+			"};",
+			"",
+			"export const defaultErrorHandler: ErrorHandler<App> = (error, c) => {",
+			"  if (error instanceof HTTPException) {",
+			"    return error.getResponse();",
+			"  }",
+			"",
+			"  console.error(error);",
+			"",
+			"  return c.json({ error: \"Internal Server Error\" }, 500);",
+			"};",
+			""
+		].join("\n"),
+		id: moduleId,
+		kind: "error"
+	};
+};
+//#endregion
 //#region src/generate/group.ts
 const getGroupRoutes = (model, group) => {
 	const ids = new Set(group.routes);
@@ -162,10 +342,32 @@ const generateGroupModule = (plan, model, group) => {
 		"",
 		"use(\"*\", ...(groupConfig.middleware ?? []));"
 	] : [];
-	const registrations = routes.map((route, index) => {
-		return `  ${`register${capitalize(route.method)}`}(${JSON.stringify(ensureLeadingSlash(route.localPath))}, ...endpoint${index});`;
+	const routeRegistrations = routes.map((route, index) => {
+		const register = `register${capitalize(route.method)}`;
+		const path = JSON.stringify(ensureLeadingSlash(route.localPath));
+		const endpointApp = `endpointApp${index}`;
+		const endpointRegister = `registerEndpoint${index}`;
+		return [
+			`  if (endpoint${index}.onError === undefined) {`,
+			`    ${register}(${path}, ...endpoint${index});`,
+			"  } else {",
+			`    const ${endpointApp} = new Hono<App>();`,
+			`    ${endpointApp}.onError(`,
+			`      endpoint${index}.onError as Parameters<typeof ${endpointApp}.onError>[0],`,
+			"    );",
+			`    const ${endpointRegister} = ${endpointApp}.${route.method} as unknown as RouteRegister;`,
+			`    ${endpointRegister}(${path}, ...endpoint${index});`,
+			`    route.route(${path}, ${endpointApp});`,
+			"  }"
+		].join("\n");
 	});
 	const childRegistrations = children.map((child, index) => `  route.route(${JSON.stringify(getChildPath(group, child))}, child${index});`);
+	const groupErrorHandler = group.configSource ? [
+		"",
+		"if (groupConfig.onError !== undefined) {",
+		"  route.onError(groupConfig.onError);",
+		"}"
+	] : [];
 	return {
 		code: [
 			...imports,
@@ -176,7 +378,8 @@ const generateGroupModule = (plan, model, group) => {
 			"",
 			...registerDeclarations,
 			...useDeclaration.length > 0 ? ["", ...useDeclaration] : [],
-			...registrations.length > 0 ? ["", ...registrations] : [],
+			...groupErrorHandler,
+			...routeRegistrations.length > 0 ? ["", ...routeRegistrations] : [],
 			...childRegistrations.length > 0 ? ["", ...childRegistrations] : [],
 			"",
 			"export default route;",
@@ -204,14 +407,6 @@ const generateMiddlewareModule = (plan) => {
 };
 //#endregion
 //#region src/generate/router.ts
-const VALIDATION_TARGETS = [
-	"json",
-	"form",
-	"query",
-	"param",
-	"header",
-	"cookie"
-];
 const METHOD_FUNCTION_NAMES = {
 	all: "all",
 	delete: "del",
@@ -223,96 +418,316 @@ const METHOD_FUNCTION_NAMES = {
 	put: "put"
 };
 const getRoutesForRouter = (model, routerPath) => model.routes.filter((route) => route.routerPath === routerPath).sort((a, b) => a.method.localeCompare(b.method));
-const renderMethod = (route) => {
-	const { method } = route;
-	const functionName = METHOD_FUNCTION_NAMES[method];
-	return [
-		`type Path = ${JSON.stringify(ensureLeadingSlash(route.localPath))};`,
+const getRouteDependencyModel = (model, routeId) => model.routeDependencies.find((route) => route.routeId === routeId);
+const getDependencyNames = (model, route) => {
+	const dependencyModel = getRouteDependencyModel(model, route.id);
+	if (!dependencyModel) return [];
+	return dependencyModel.roots.map((dependencyId) => {
+		const node = model.dependencies.nodes.get(dependencyId);
+		if (!node) throw new Error([
+			"Nooh internal error:",
+			`dependency "${dependencyId}"`,
+			`for route "${route.id}" is missing`,
+			"from the dependency graph."
+		].join(" "));
+		return node.declaration.name;
+	});
+};
+const renderMethod = (model, route, mode) => {
+	const functionName = METHOD_FUNCTION_NAMES[route.method];
+	const prefix = functionName.charAt(0).toUpperCase() + functionName.slice(1);
+	const path = JSON.stringify(ensureLeadingSlash(route.localPath));
+	const routeLabel = JSON.stringify(`${route.method.toUpperCase()} ${ensureLeadingSlash(route.localPath)}`);
+	const dependencyNames = getDependencyNames(model, route);
+	const common = [
+		`type ${prefix}Path = ${path};`,
 		"",
-		"type RouteMiddleware = MiddlewareHandler<App, Path>;",
+		`type ${prefix}RouteMiddleware = MiddlewareHandler<App, ${prefix}Path>;`,
 		"",
-		"type ValidationTarget = Parameters<typeof sValidator>[0];",
-		"type StandardSchema = Parameters<typeof sValidator>[1];",
+		`type ${prefix}RouteHandler = Handler<App, ${prefix}Path, any, any>;`,
 		"",
-		"type ValidationOptions = Partial<",
-		"  Record<ValidationTarget, StandardSchema>",
+		`type ${prefix}ValidationSchemaMap = Record<`,
+		"  NoohRequestValidationTarget,",
+		"  NoohStandardSchema",
 		">;",
 		"",
-		"type HandlerInput<T> = T extends Handler<",
-		"  any,",
-		"  any,",
-		"  infer I,",
-		"  any",
-		"> ? I : never;",
+		`type ${prefix}ValidationOptions = Partial<${prefix}ValidationSchemaMap> & {`,
+		"  readonly response?: NoohStandardSchema;",
+		"};",
 		"",
-		"type ValidationHandler<",
-		"  Target extends ValidationTarget,",
-		"  Schema extends StandardSchema,",
-		"> = ReturnType<",
-		"  typeof sValidator<Schema, Target, App, Path>",
-		">;",
+		`type ${prefix}ValidationEntry<`,
+		"  Target extends NoohRequestValidationTarget,",
+		"  Schema extends NoohStandardSchema",
+		"> = undefined extends NoohStandardSchemaInput<Schema>",
+		"  ? {",
+		"      readonly in: {",
+		"        readonly [Key in Target]?: NoohStandardSchemaInput<Schema>;",
+		"      };",
+		"      readonly out: {",
+		"        readonly [Key in Target]: NoohStandardSchemaOutput<Schema>;",
+		"      };",
+		"    }",
+		"  : {",
+		"      readonly in: {",
+		"        readonly [Key in Target]: NoohStandardSchemaInput<Schema>;",
+		"      };",
+		"      readonly out: {",
+		"        readonly [Key in Target]: NoohStandardSchemaOutput<Schema>;",
+		"      };",
+		"    };",
 		"",
-		"type ValidationInput<V extends ValidationOptions> =",
-		...VALIDATION_TARGETS.map((target) => `  & (${JSON.stringify(target)} extends keyof V ? HandlerInput<ValidationHandler<${JSON.stringify(target)}, NonNullable<V[${JSON.stringify(target)}]>>> : {})`),
-		";",
+		`type ${prefix}ValidationInput<V extends ${prefix}ValidationOptions> =`,
+		"  keyof V extends never",
+		"    ? {}",
+		"    : UnionToIntersection<{",
+		"        [Target in keyof V & NoohRequestValidationTarget]:",
+		"          V[Target] extends NoohStandardSchema",
+		"            ? ",
+		`              ${prefix}ValidationEntry<Target, V[Target]>`,
+		"            : never",
+		"      }[keyof V &",
+		"        NoohRequestValidationTarget]>;",
 		"",
-		"type RouteHandler = Handler<App, Path, any, any>;",
+		`type ${prefix}ResponseSchema<V extends ${prefix}ValidationOptions> =`,
+		"  V extends {",
+		"    readonly response: infer Schema extends NoohStandardSchema;",
+		"  }",
+		"    ? Schema",
+		"    : never;",
+		"",
+		`type ${prefix}NoohHandlerReturn<V extends ${prefix}ValidationOptions> =`,
+		"  V extends {",
+		"    readonly response: infer Schema extends NoohStandardSchema;",
+		"  }",
+		"    ? Response &",
+		"        TypedResponse<",
+		"          NoohStandardSchemaInput<Schema>,",
+		"          any,",
+		"          any",
+		"        >",
+		"      | Promise<",
+		"          Response &",
+		"            TypedResponse<",
+		"              NoohStandardSchemaInput<Schema>,",
+		"              any,",
+		"              any",
+		"            >",
+		"        >",
+		`    : ReturnType<${prefix}RouteHandler>;`,
 		"",
-		"type EndpointOptions<",
-		"  M extends readonly RouteMiddleware[],",
-		"  V extends ValidationOptions,",
-		"  H extends Handler<App, Path, ValidationInput<V>>,",
+		`type ${prefix}RouteContext<V extends ${prefix}ValidationOptions> =`,
+		"  Context<",
+		"    App,",
+		`    ${prefix}Path,`,
+		`    ${prefix}ValidationInput<V>`,
+		"  >;",
+		"",
+		`type ${prefix}RouteNext = Parameters<${prefix}RouteHandler>[1];`,
+		"",
+		`type ${prefix}RouteErrorHandler = NoohErrorHandler<App, ${prefix}Path>;`,
+		"",
+		`type ${prefix}HandlerInput<`,
+		"  D extends readonly RouteDependency[],",
+		`  V extends ${prefix}ValidationOptions,`,
+		"  E extends ErrorDefinitions",
+		"> = {",
+		`  readonly c: ${prefix}RouteContext<V>;`,
+		`  readonly next: ${prefix}RouteNext;`,
+		"} & DependencyContext<D> & (",
+		"  keyof E extends never",
+		"    ? {}",
+		"    : { readonly errors: ErrorContext<E> }",
+		");",
+		"",
+		`type ${prefix}NoohHandler<`,
+		"  D extends readonly RouteDependency[],",
+		`  V extends ${prefix}ValidationOptions,`,
+		"  E extends ErrorDefinitions",
+		"> = (",
+		`  input: ${prefix}HandlerInput<D, V, E>`,
+		`) => ${prefix}NoohHandlerReturn<V>;`,
+		"",
+		`type ${prefix}RouteHandlers = readonly ${prefix}RouteHandler[] & {`,
+		`  readonly onError?: ${prefix}RouteErrorHandler;`,
+		"};",
+		"",
+		`type ${prefix}EndpointOptions<`,
+		"  D extends readonly RouteDependency[] = readonly RouteDependency[],",
+		`  V extends ${prefix}ValidationOptions = ${prefix}ValidationOptions,`,
+		`  M extends readonly ${prefix}RouteMiddleware[] = readonly ${prefix}RouteMiddleware[],`,
+		"  E extends ErrorDefinitions = {}",
 		"> = {",
 		"  readonly middleware?: M;",
 		"  readonly validation?: V;",
-		"  readonly handler: H;",
+		"  readonly deps?: D & ValidateDependencies<D, ReservedDependencyName>;",
+		"  readonly errors?: E;",
+		`  readonly onError?: ${prefix}RouteErrorHandler;`,
+		`  readonly handler: ${prefix}NoohHandler<D, V, E>;`,
 		"};",
 		"",
-		`export function ${functionName}<H extends Handler<App, Path>>(`,
-		"  handler: H,",
-		"): readonly RouteHandler[];",
+		`export function ${functionName}(`,
+		`  handler: ${prefix}RouteHandler`,
+		`): ${prefix}RouteHandlers;`,
 		"",
 		`export function ${functionName}<`,
-		"  M extends readonly RouteMiddleware[],",
-		"  V extends ValidationOptions,",
-		"  H extends Handler<App, Path, ValidationInput<V>>,",
+		"  const D extends readonly RouteDependency[] = [],",
+		`  const V extends ${prefix}ValidationOptions = {},`,
+		`  const M extends readonly ${prefix}RouteMiddleware[] = [],`,
+		"  const E extends ErrorDefinitions = {}",
 		">(",
-		"  options: EndpointOptions<M, V, H>,",
-		"): readonly RouteHandler[];",
+		`  options: ${prefix}EndpointOptions<D, V, M, E>`,
+		`): ${prefix}RouteHandlers;`,
 		"",
-		`export function ${functionName}<`,
-		"  M extends readonly RouteMiddleware[],",
-		"  V extends ValidationOptions,",
-		"  H extends Handler<App, Path, ValidationInput<V>>,",
-		">(",
+		`export function ${functionName}(`,
 		"  input:",
-		"    | H",
-		"    | EndpointOptions<M, V, H>,",
-		"): readonly RouteHandler[] {",
+		`    | ${prefix}RouteHandler`,
+		`    | ${prefix}EndpointOptions`,
+		`): ${prefix}RouteHandlers {`
+	];
+	if (mode === "introspection") return [
+		...common,
+		"",
+		"  if (typeof input === \"function\") {",
+		"    return defineRouteMetadata(",
+		"      [input],",
+		"      [],",
+		`    ) as unknown as ${prefix}RouteHandlers;`,
+		"  }",
+		"",
+		"  return defineRouteMetadata(",
+		`    [input.handler as unknown as ${prefix}RouteHandler],`,
+		"    input.deps ?? [],",
+		`  ) as unknown as ${prefix}RouteHandlers;`,
+		"}",
+		""
+	].join("\n");
+	const dependencyResolution = dependencyNames.flatMap((_, index) => [`    const resolvedDependency${index} = dependencies[${index}]!.resolve(dependencyContext);`]);
+	const dependencyProperties = dependencyNames.map((name, index) => `      ${JSON.stringify(name)}: resolvedDependency${index},`);
+	return [
+		...common,
+		"",
 		"  if (typeof input === \"function\") {",
-		"    return [input as RouteHandler];",
+		`    return defineRouteHandlers<${prefix}Path>([input]);`,
 		"  }",
 		"",
-		"  return [",
-		"    ...(input.middleware ?? []) as readonly RouteHandler[],",
-		...VALIDATION_TARGETS.map((target) => `    ...(input.validation?.${target} !== undefined ? [sValidator(${JSON.stringify(target)}, input.validation.${target}) as RouteHandler] : []),`),
-		"    input.handler as RouteHandler,",
-		"  ];",
+		"  const dependencies = input.deps ?? [];",
+		"",
+		"  const errors =",
+		"    input.errors === undefined",
+		"      ? undefined",
+		"      : createErrorContext(input.errors);",
+		"",
+		`  const handler: ${prefix}RouteHandler = async (c, next) => {`,
+		...dependencyNames.length > 0 ? [
+			"    const dependencyContext =",
+			"      getDependencyResolutionContext(c);",
+			"",
+			...dependencyResolution,
+			""
+		] : [],
+		"    const response = await input.handler({",
+		"      c: c as unknown as",
+		`        ${prefix}RouteContext<${prefix}ValidationOptions>,`,
+		"      next,",
+		...dependencyNames.length > 0 ? dependencyProperties : [],
+		"      ...(errors !== undefined ? { errors } : {})",
+		"    });",
+		"",
+		"    if (input.validation?.response !== undefined) {",
+		"      return validateResponse(",
+		"        response as Response,",
+		"        input.validation.response,",
+		`        ${routeLabel}`,
+		"      );",
+		"    }",
+		"",
+		"    return response;",
+		"  };",
+		"",
+		"  const handlers = [",
+		`    ...((input.middleware ?? []) as readonly ${prefix}RouteHandler[]),`,
+		...[
+			"json",
+			"form",
+			"query",
+			"param",
+			"header",
+			"cookie"
+		].map((target) => `    ...(input.validation?.${target} !== undefined ? [validatorEngine(${JSON.stringify(target)}, input.validation.${target}) as ${prefix}RouteHandler] : []),`),
+		"    handler,",
+		"  ] as const;",
+		"",
+		`  return defineRouteHandlers<${prefix}Path>(handlers, input.onError);`,
 		"}",
 		""
 	].join("\n");
 };
-const generateRouterModule = (plan, model, routerPath) => {
+const COMMON_TYPES = [
+	"type RouteDependency = AnyDependencyReference;",
+	"",
+	"type ErrorDefinitions = Record<string, ErrorConstructor>;",
+	"",
+	"type UnionToIntersection<Union> =",
+	"  (Union extends unknown",
+	"    ? (value: Union) => void",
+	"    : never) extends",
+	"  (value: infer Intersection) => void",
+	"    ? Intersection",
+	"    : never;",
+	"",
+	"type ReservedDependencyName =",
+	"  | \"c\"",
+	"  | \"next\"",
+	"  | \"error\"",
+	"  | \"errors\"",
+	"  | \"onError\"",
+	"  | \"response\"",
+	"  | NoohValidationTarget;"
+];
+const generateRouterModule = (plan, model, routerPath, mode = "runtime") => {
 	const routes = getRoutesForRouter(model, routerPath);
 	const moduleId = `${plan.outputRoot}/${routerPath}.ts`;
 	const typesModuleId = `${plan.outputRoot}/types.ts`;
+	const dependencyModuleId = `${plan.outputRoot}/router/di.ts`;
+	const errorModuleId = `${plan.outputRoot}/error.ts`;
+	const configModuleId = model.config.source;
+	const usesDependencies = mode === "runtime" && routes.some((route) => {
+		return !!getRouteDependencyModel(model, route.id)?.roots.length;
+	});
+	const imports = [
+		"import type {",
+		"  Context,",
+		"  Handler,",
+		"  MiddlewareHandler,",
+		"  TypedResponse",
+		"} from \"hono\";",
+		"import type {",
+		"  AnyDependencyReference,",
+		"  DependencyContext,",
+		"  ErrorContext,",
+		"  ErrorConstructor,",
+		"  NoohErrorHandler,",
+		"  NoohRequestValidationTarget,",
+		"  NoohStandardSchema,",
+		"  NoohStandardSchemaInput,",
+		"  NoohStandardSchemaOutput,",
+		"  NoohValidationTarget,",
+		"  ValidateDependencies",
+		"} from \"@nooh-ts/nooh\";",
+		`import type { App } from ${JSON.stringify(relativeModuleSpecifier(moduleId, typesModuleId))};`
+	];
+	if (mode === "runtime") imports.unshift(`import { sValidator } from "@hono/standard-validator";`, `import config from ${JSON.stringify(relativeModuleSpecifier(moduleId, configModuleId))};`, `import { validateResponse } from ${JSON.stringify(relativeModuleSpecifier(moduleId, errorModuleId))};`);
+	if (usesDependencies) imports.push("import {", "  getDependencyResolutionContext", "} from " + JSON.stringify(relativeModuleSpecifier(moduleId, dependencyModuleId)) + ";");
+	const prelude = ["", ...COMMON_TYPES];
+	if (mode === "runtime") prelude.push("", "const validatorEngine = (", "  config.validator?.engine ?? sValidator", ") as unknown as (", "  target: NoohRequestValidationTarget,", "  schema: NoohStandardSchema", ") => unknown;");
+	if (mode === "runtime") prelude.push("", "const createErrorContext = <", "  const E extends ErrorDefinitions", ">(", "  definitions: E | undefined", "): ErrorContext<E> => {", "  const errors: Record<string, unknown> = {};", "", "  if (definitions === undefined) {", "    return errors as ErrorContext<E>;", "  }", "", "  for (const [name, Constructor] of Object.entries(definitions)) {", "    errors[name] = (...args: unknown[]) =>", "      Reflect.construct(Constructor, args);", "  }", "", "  return errors as ErrorContext<E>;", "};", "", "const defineRouteHandlers = <", "  const P extends string,", "  const T extends readonly Handler<App, P, any, any>[]", ">(", "  handlers: T,", "  onError?: NoohErrorHandler<App, P>", "): T & { readonly onError?: NoohErrorHandler<App, P> } => {", "  if (onError !== undefined) {", "    Object.defineProperty(handlers, \"onError\", {", "      configurable: false,", "      enumerable: false,", "      value: onError,", "      writable: false", "    });", "  }", "", "  return handlers as T & {", "    readonly onError?: NoohErrorHandler<App, P>", "  };", "};");
+	if (mode === "introspection") prelude.push("", "const NOOH_ROUTE_METADATA = Symbol.for(\"nooh.route\");", "", "type NoohRouteMetadata = {", "  readonly kind: \"route\";", "  readonly dependencies: readonly RouteDependency[]", "};", "", "const defineRouteMetadata = <", "  T extends readonly unknown[]", ">(", "  handlers: T,", "  dependencies: readonly RouteDependency[]", "): T => {", "  const metadata: NoohRouteMetadata = {", "    kind: \"route\",", "    dependencies", "};", "", "  Object.defineProperty(", "    handlers,", "    NOOH_ROUTE_METADATA,", "    {", "      value: metadata,", "      enumerable: false", "    }", "  );", "", "  return handlers;", "};");
 	return {
 		code: [
-			`import { sValidator } from "@hono/standard-validator";`,
-			`import type { Handler, MiddlewareHandler } from "hono";`,
-			`import type { App } from ${JSON.stringify(relativeModuleSpecifier(moduleId, typesModuleId))};`,
+			...imports,
+			...prelude,
 			"",
-			...routes.map(renderMethod)
+			...routes.map((route) => renderMethod(model, route, mode))
 		].join("\n"),
 		id: moduleId,
 		kind: "router"
@@ -341,19 +756,405 @@ const generateTypesModule = (plan, config) => {
 };
 //#endregion
 //#region src/generate/index.ts
+const getRouterPaths = (model) => [...new Set(model.routes.map((route) => route.routerPath))].sort();
 const generate = (plan, model) => {
 	const modules = [];
 	modules.push(generateTypesModule(plan, model.config));
+	modules.push(generateDependencyModule(plan));
+	modules.push(generateErrorModule(plan));
 	modules.push(generateMiddlewareModule(plan));
-	const routerPaths = [...new Set(model.routes.map((route) => route.routerPath))].sort();
-	for (const routerPath of routerPaths) modules.push(generateRouterModule(plan, model, routerPath));
+	for (const routerPath of getRouterPaths(model)) modules.push(generateRouterModule(plan, model, routerPath));
 	for (const group of model.groups) modules.push(generateGroupModule(plan, model, group));
 	modules.push(generateAppModule(plan, model));
 	modules.sort((a, b) => a.id.localeCompare(b.id));
 	return { modules };
 };
+const generateRouteIntrospection = (plan, model) => {
+	const modules = [];
+	for (const routerPath of getRouterPaths(model)) modules.push(generateRouterModule(plan, model, routerPath, "introspection"));
+	modules.sort((a, b) => a.id.localeCompare(b.id));
+	return { modules };
+};
+//#endregion
+//#region src/pipeline/dependencies.ts
+const isRecord$2 = (value) => typeof value === "object" && value !== null;
+const isDependencyReference = (value) => isRecord$2(value) && value.__nooh_dependency === true && typeof value.name === "string" && Array.isArray(value.dependencies) && (value.scope === "value" || value.scope === "singleton" || value.scope === "request" || value.scope === "transient");
+const isDependencyContainer = (value) => {
+	if (!isRecord$2(value) || Array.isArray(value)) return false;
+	if (!Object.isFrozen(value)) return false;
+	const entries = Object.entries(value);
+	return entries.length > 0 && entries.every(([, entry]) => isDependencyReference(entry));
+};
+const emptyGraph = () => ({
+	nodes: /* @__PURE__ */ new Map(),
+	order: [],
+	references: /* @__PURE__ */ new Map()
+});
+const canDependOn = (parent, child) => {
+	if (parent === "singleton") return child === "singleton" || child === "value";
+	if (parent === "request") return child === "singleton" || child === "request" || child === "transient" || child === "value";
+	if (parent === "transient") return true;
+	return child === "value";
+};
+const createScopeDiagnostic = (declaration, dependency) => {
+	if (canDependOn(declaration.scope, dependency.scope)) return null;
+	return {
+		code: "NOOH020",
+		file: declaration.source,
+		message: [`Dependency "${declaration.name}" with scope "${declaration.scope}"`, `cannot depend on "${dependency.name}" with scope "${dependency.scope}".`].join(" "),
+		severity: "error"
+	};
+};
+const createMissingDependencyDiagnostic = (declaration, dependencyId) => ({
+	code: "NOOH021",
+	file: declaration.source,
+	message: [`Dependency "${declaration.name}" references`, `unknown dependency "${dependencyId}".`].join(" "),
+	severity: "error"
+});
+const createDuplicateDependencyDiagnostic = (declaration) => ({
+	code: "NOOH022",
+	file: declaration.source,
+	message: `Duplicate dependency provider "${declaration.id}".`,
+	severity: "error"
+});
+const createCycleDiagnostic = (cycle) => {
+	const [first] = cycle;
+	return {
+		code: "NOOH023",
+		...first?.declaration.source !== void 0 && { file: first.declaration.source },
+		message: `Circular dependency detected: ${cycle.map((node) => node.declaration.name).join(" -> ")}`,
+		severity: "error"
+	};
+};
+const topologicalOrder = (nodes, diagnostics) => {
+	const state = /* @__PURE__ */ new Map();
+	const stack = [];
+	const order = [];
+	const visit = (id) => {
+		const current = state.get(id);
+		if (current === "visited") return;
+		if (current === "visiting") {
+			const cycleStart = stack.indexOf(id);
+			const cycle = (cycleStart === -1 ? [...stack, id] : [...stack.slice(cycleStart), id]).map((cycleId) => nodes.get(cycleId)).filter((n) => n !== void 0);
+			diagnostics.push(createCycleDiagnostic(cycle));
+			return;
+		}
+		const node = nodes.get(id);
+		if (!node) return;
+		state.set(id, "visiting");
+		stack.push(id);
+		for (const dependencyId of node.declaration.dependencies) visit(dependencyId);
+		stack.pop();
+		state.set(id, "visited");
+		order.push(id);
+	};
+	const ids = [...nodes.keys()].sort();
+	for (const id of ids) visit(id);
+	return order;
+};
+const createDependencyGraph = (declarations, references = /* @__PURE__ */ new Map()) => {
+	if (declarations.length === 0) return {
+		diagnostics: [],
+		graph: {
+			...emptyGraph(),
+			references
+		}
+	};
+	const diagnostics = [];
+	const nodes = /* @__PURE__ */ new Map();
+	for (const declaration of declarations) {
+		if (nodes.has(declaration.id)) {
+			diagnostics.push(createDuplicateDependencyDiagnostic(declaration));
+			continue;
+		}
+		nodes.set(declaration.id, { declaration });
+	}
+	for (const declaration of declarations) {
+		if (!nodes.get(declaration.id)) continue;
+		for (const dependencyId of declaration.dependencies) {
+			const dependencyNode = nodes.get(dependencyId);
+			if (!dependencyNode) {
+				diagnostics.push(createMissingDependencyDiagnostic(declaration, dependencyId));
+				continue;
+			}
+			const scopeDiagnostic = createScopeDiagnostic(declaration, dependencyNode.declaration);
+			if (scopeDiagnostic) diagnostics.push(scopeDiagnostic);
+		}
+	}
+	const order = topologicalOrder(nodes, diagnostics);
+	const unique = /* @__PURE__ */ new Map();
+	for (const diagnostic of diagnostics) {
+		const key = [
+			diagnostic.code,
+			diagnostic.file ?? "",
+			diagnostic.message
+		].join("\0");
+		unique.set(key, diagnostic);
+	}
+	return {
+		diagnostics: [...unique.values()],
+		graph: {
+			nodes,
+			order,
+			references
+		}
+	};
+};
+const loadModule = async (loader, path) => {
+	if (loader.loadModule) return loader.loadModule(path);
+	return { default: await loader.loadDefault(path) };
+};
+const collectReferences = (source, module) => {
+	const diagnostics = [];
+	const references = [];
+	const seenObjects = /* @__PURE__ */ new Set();
+	const addReference = (id, value) => {
+		if (seenObjects.has(value)) {
+			diagnostics.push({
+				code: "NOOH027",
+				file: source,
+				message: [
+					`Dependency reference "${value.name}"`,
+					"is exported more than once.",
+					`Duplicate provider: "${id}".`
+				].join(" "),
+				severity: "error"
+			});
+			return;
+		}
+		seenObjects.add(value);
+		references.push({
+			id,
+			name: value.name,
+			reference: value,
+			scope: value.scope,
+			source
+		});
+	};
+	for (const [exportName, exported] of Object.entries(module)) {
+		if (exportName === "__esModule") continue;
+		if (isDependencyReference(exported)) {
+			addReference(`${source}#${exportName}`, exported);
+			continue;
+		}
+		if (isDependencyContainer(exported)) for (const [name, reference] of Object.entries(exported)) {
+			if (!isDependencyReference(reference)) continue;
+			addReference(`${source}#${exportName}.${name}`, reference);
+		}
+	}
+	return {
+		diagnostics,
+		references
+	};
+};
+const loadDependencyGraph = async (sources, loader) => {
+	if (sources.length === 0) return {
+		diagnostics: [],
+		graph: emptyGraph()
+	};
+	const diagnostics = [];
+	const loaded = [];
+	for (const source of sources) {
+		let module;
+		try {
+			module = await loadModule(loader, source.path);
+		} catch (error) {
+			diagnostics.push({
+				code: "NOOH024",
+				file: source.path,
+				message: error instanceof Error ? ["Failed to load dependency module:", error.message].join(" ") : "Failed to load dependency module.",
+				severity: "error"
+			});
+			continue;
+		}
+		const result = collectReferences(source.path, module);
+		diagnostics.push(...result.diagnostics);
+		loaded.push(...result.references);
+	}
+	const references = /* @__PURE__ */ new Map();
+	for (const entry of loaded) references.set(entry.reference, entry.id);
+	const declarations = [];
+	for (const entry of loaded) {
+		const dependencies = [];
+		for (const dependency of entry.reference.dependencies) {
+			if (!isDependencyReference(dependency)) {
+				diagnostics.push({
+					code: "NOOH026",
+					file: entry.source,
+					message: [`Dependency "${entry.name}" contains`, "an invalid dependency reference."].join(" "),
+					severity: "error"
+				});
+				continue;
+			}
+			const dependencyId = references.get(dependency);
+			if (!dependencyId) {
+				diagnostics.push({
+					code: "NOOH021",
+					file: entry.source,
+					message: [`Dependency "${entry.name}" references`, `an unknown dependency "${dependency.name}".`].join(" "),
+					severity: "error"
+				});
+				continue;
+			}
+			dependencies.push(dependencyId);
+		}
+		declarations.push({
+			dependencies,
+			id: entry.id,
+			name: entry.name,
+			scope: entry.scope,
+			source: entry.source
+		});
+	}
+	const result = createDependencyGraph(declarations, references);
+	return {
+		diagnostics: [...diagnostics, ...result.diagnostics],
+		graph: result.graph
+	};
+};
+const dependencyClosure = (graph, roots) => {
+	const visited = /* @__PURE__ */ new Set();
+	const result = [];
+	const visit = (id) => {
+		if (visited.has(id)) return;
+		visited.add(id);
+		const node = graph.nodes.get(id);
+		if (!node) return;
+		for (const dependencyId of node.declaration.dependencies) visit(dependencyId);
+		result.push(id);
+	};
+	for (const root of roots) visit(root);
+	return result;
+};
+//#endregion
+//#region src/introspect.ts
+const NOOH_ROUTE_METADATA = Symbol.for("nooh.route");
+const isRecord$1 = (value) => typeof value === "object" && value !== null;
+const isRouteMetadata = (value) => {
+	if (!isRecord$1(value)) return false;
+	return value.kind === "route" && Array.isArray(value.dependencies);
+};
+const readRouteMetadata = (value) => {
+	if (!isRecord$1(value)) return null;
+	const metadata = value[NOOH_ROUTE_METADATA];
+	return isRouteMetadata(metadata) ? metadata : null;
+};
+const introspectRoute = async (route, loader) => {
+	let exported;
+	try {
+		exported = await loader.loadDefault(route.source);
+	} catch (error) {
+		return { diagnostics: [{
+			code: "NOOH031",
+			file: route.source,
+			message: error instanceof Error ? `Failed to introspect route: ${error.message}` : "Failed to introspect route.",
+			severity: "error"
+		}] };
+	}
+	const metadata = readRouteMetadata(exported);
+	if (!metadata) return { diagnostics: [{
+		code: "NOOH032",
+		file: route.source,
+		message: [
+			"The route did not expose Nooh route metadata.",
+			"",
+			"Make sure the route is evaluated against",
+			"the generated Nooh introspection router."
+		].join("\n"),
+		severity: "error"
+	}] };
+	return {
+		diagnostics: [],
+		metadata
+	};
+};
+const unknownDependencyDiagnostic = (route, dependency) => ({
+	code: "NOOH034",
+	file: route.source,
+	message: isRecord$1(dependency) && typeof dependency.name === "string" ? [`Route "${route.id}" references unknown dependency`, `"${dependency.name}".`].join(" ") : `Route "${route.id}" contains an invalid dependency reference.`,
+	severity: "error"
+});
+const duplicateRouteDependencyNameDiagnostic = (route, name) => ({
+	code: "NOOH035",
+	file: route.source,
+	message: [`Route "${route.id}" injects multiple dependencies`, `with the same name "${name}".`].join(" "),
+	severity: "error"
+});
+const introspectCompilation = async (input) => {
+	if (!input.compilation.plan) return {
+		diagnostics: [{
+			code: "NOOH033",
+			message: "Cannot introspect a compilation without a compilation plan.",
+			severity: "error"
+		}],
+		introspection: null
+	};
+	const graph = input.compilation.model.dependencies;
+	const diagnostics = [];
+	const routeDependencies = /* @__PURE__ */ new Map();
+	for (const route of input.compilation.model.routes) {
+		const result = await introspectRoute(route, input.loader);
+		diagnostics.push(...result.diagnostics);
+		if (!result.metadata) continue;
+		const roots = [];
+		const names = /* @__PURE__ */ new Set();
+		for (const dependency of result.metadata.dependencies) {
+			if (typeof dependency !== "object" || dependency === null) {
+				diagnostics.push(unknownDependencyDiagnostic(route, dependency));
+				continue;
+			}
+			const id = graph.references.get(dependency);
+			if (!id) {
+				diagnostics.push(unknownDependencyDiagnostic(route, dependency));
+				continue;
+			}
+			const node = graph.nodes.get(id);
+			if (!node) {
+				diagnostics.push({
+					code: "NOOH034",
+					file: route.source,
+					message: [`Route "${route.id}" references dependency`, `"${id}" that is missing from the dependency graph.`].join(" "),
+					severity: "error"
+				});
+				continue;
+			}
+			const { name } = node.declaration;
+			if (names.has(name)) {
+				diagnostics.push(duplicateRouteDependencyNameDiagnostic(route, name));
+				continue;
+			}
+			names.add(name);
+			roots.push(id);
+		}
+		const closure = dependencyClosure(graph, roots);
+		routeDependencies.set(route.id, {
+			closure,
+			roots
+		});
+	}
+	if (diagnostics.some((diagnostic) => diagnostic.severity === "error")) return {
+		diagnostics,
+		introspection: null
+	};
+	return {
+		diagnostics,
+		introspection: {
+			dependencies: graph,
+			routeDependencies: [...routeDependencies.entries()].map(([routeId, value]) => ({
+				closure: value.closure,
+				roots: value.roots,
+				routeId
+			})).sort((a, b) => a.routeId.localeCompare(b.routeId))
+		}
+	};
+};
 //#endregion
 //#region src/pipeline/analyze.ts
+const emptyDependencyGraph$1 = () => ({
+	nodes: /* @__PURE__ */ new Map(),
+	order: [],
+	references: /* @__PURE__ */ new Map()
+});
 const segmentToHono = (segment) => {
 	switch (segment.kind) {
 		case "static": return segment.value;
@@ -453,7 +1254,7 @@ const buildGroups = (parsed, routeModels, diagnostics) => {
 		};
 	});
 };
-const analyze = (parsed, config) => {
+const analyze = (parsed, config, dependencies = emptyDependencyGraph$1()) => {
 	const diagnostics = [...parsed.diagnostics];
 	const routeModels = [];
 	const seen = /* @__PURE__ */ new Map();
@@ -493,16 +1294,20 @@ const analyze = (parsed, config) => {
 		diagnostics,
 		model: {
 			config,
+			dependencies,
 			groups: buildGroups(parsed, routeModels, diagnostics),
+			routeDependencies: [],
 			routes: routeModels
 		}
 	};
 };
 //#endregion
 //#region src/pipeline/config.ts
+const DEFAULT_DEPENDENCIES_ROOT = "src/deps";
 const DEFAULT_ROUTES_ROOT = "src/routes";
 const isRecord = (value) => typeof value === "object" && value !== null;
 const isString = (value) => typeof value === "string";
+const isFunction = (value) => typeof value === "function";
 const loadConfig = async (input) => {
 	let defaultExport;
 	try {
@@ -528,14 +1333,41 @@ const loadConfig = async (input) => {
 		message: "The Nooh config \"routes\" option must be a string.",
 		severity: "error"
 	}] };
+	const dependenciesValue = defaultExport.dependencies;
+	if (dependenciesValue !== void 0 && !isString(dependenciesValue)) return { diagnostics: [{
+		code: "NOOH013",
+		file: input.config,
+		message: "The Nooh config \"dependencies\" option must be a string.",
+		severity: "error"
+	}] };
+	const validatorValue = defaultExport.validator;
+	if (validatorValue !== void 0 && !isRecord(validatorValue)) return { diagnostics: [{
+		code: "NOOH014",
+		file: input.config,
+		message: "The Nooh config \"validator\" option must be an object.",
+		severity: "error"
+	}] };
+	if (isRecord(validatorValue) && validatorValue.engine !== void 0 && !isFunction(validatorValue.engine)) return { diagnostics: [{
+		code: "NOOH015",
+		file: input.config,
+		message: "The Nooh config \"validator.engine\" option must be a function.",
+		severity: "error"
+	}] };
 	const root = normalizePath(input.root ?? "");
 	const source = toProjectPath(input.config, root);
+	const routes = routesValue ?? DEFAULT_ROUTES_ROOT;
+	const dependencies = dependenciesValue ?? DEFAULT_DEPENDENCIES_ROOT;
+	const routesRoot = toProjectPath(routes, root);
 	return {
 		config: {
+			dependenciesRoot: toProjectPath(dependencies, root),
 			root,
-			routesRoot: toProjectPath(routesValue ?? DEFAULT_ROUTES_ROOT, root),
+			routesRoot,
 			source,
-			value: { routes: routesValue }
+			value: {
+				dependencies: dependenciesValue,
+				routes: routesValue
+			}
 		},
 		diagnostics: []
 	};
@@ -549,6 +1381,14 @@ const isGroupFile = (filePath) => {
 	const filename = basename(filePath);
 	return filename === "$.ts" || filename === "$.tsx";
 };
+const discoverDependency = (config, file) => {
+	const source = toProjectPath(file.path, config.root);
+	if (!isPathInside(source, config.dependenciesRoot)) return null;
+	return {
+		content: file.content,
+		path: source
+	};
+};
 const discoverGroup = (config, file) => {
 	const source = toProjectPath(file.path, config.root);
 	if (!isPathInside(source, config.routesRoot)) return null;
@@ -574,8 +1414,14 @@ const discoverEndpoint = (config, file) => {
 const discover = (snapshot, config) => {
 	const endpoints = [];
 	const groups = [];
+	const dependencies = [];
 	for (const file of snapshot.files) {
 		if (!isTypeScriptFile(file)) continue;
+		const dependency = discoverDependency(config, file);
+		if (dependency) {
+			dependencies.push(dependency);
+			continue;
+		}
 		const group = discoverGroup(config, file);
 		if (group) {
 			groups.push(group);
@@ -584,10 +1430,12 @@ const discover = (snapshot, config) => {
 		const endpoint = discoverEndpoint(config, file);
 		if (endpoint) endpoints.push(endpoint);
 	}
+	dependencies.sort((a, b) => a.path.localeCompare(b.path));
 	endpoints.sort((a, b) => a.source.localeCompare(b.source));
 	groups.sort((a, b) => a.source.localeCompare(b.source));
 	return {
 		config,
+		dependencies,
 		endpoints,
 		groups
 	};
@@ -716,13 +1564,24 @@ const DEFAULT_OUTPUT_ROOT = ".nooh";
 const modulePath = (outputRoot, value) => normalizePath(`${outputRoot}/${value}.ts`);
 const plan = (model, outputRoot = DEFAULT_OUTPUT_ROOT) => {
 	const normalizedOutputRoot = normalizePath(outputRoot);
-	const modules = [{
-		id: modulePath(normalizedOutputRoot, "types"),
-		kind: "types"
-	}, {
-		id: modulePath(normalizedOutputRoot, "router/middleware"),
-		kind: "middleware"
-	}];
+	const modules = [
+		{
+			id: modulePath(normalizedOutputRoot, "types"),
+			kind: "types"
+		},
+		{
+			id: modulePath(normalizedOutputRoot, "router/di"),
+			kind: "di"
+		},
+		{
+			id: modulePath(normalizedOutputRoot, "router/middleware"),
+			kind: "middleware"
+		},
+		{
+			id: modulePath(normalizedOutputRoot, "error"),
+			kind: "error"
+		}
+	];
 	const routerPaths = [...new Set(model.routes.map((route) => route.routerPath))].sort();
 	for (const routerPath of routerPaths) {
 		const route = model.routes.find((candidate) => candidate.routerPath === routerPath);
@@ -747,12 +1606,18 @@ const plan = (model, outputRoot = DEFAULT_OUTPUT_ROOT) => {
 	});
 	modules.sort((a, b) => a.id.localeCompare(b.id));
 	return {
+		dependencies: model.dependencies,
 		modules,
 		outputRoot: normalizedOutputRoot
 	};
 };
 //#endregion
 //#region src/compiler.ts
+const emptyDependencyGraph = {
+	nodes: /* @__PURE__ */ new Map(),
+	order: [],
+	references: /* @__PURE__ */ new Map()
+};
 const createCompiler = () => ({
 	analyze,
 	compile: async (input) => {
@@ -761,12 +1626,15 @@ const createCompiler = () => ({
 			diagnostics: configResult.diagnostics,
 			model: {
 				config: {
+					dependenciesRoot: "",
 					root: input.root ? input.root.replaceAll("\\", "/") : "",
 					routesRoot: "",
 					source: input.config,
 					value: {}
 				},
+				dependencies: emptyDependencyGraph,
 				groups: [],
+				routeDependencies: [],
 				routes: []
 			},
 			output: null,
@@ -774,8 +1642,13 @@ const createCompiler = () => ({
 		};
 		const discovered = discover(input.sources, configResult.config);
 		const parsed = parse(discovered);
-		const analyzed = analyze(parsed, configResult.config);
-		const diagnostics = [...configResult.diagnostics, ...analyzed.diagnostics];
+		const dependencyResult = await loadDependencyGraph(discovered.dependencies, input.loader);
+		const analyzed = analyze(parsed, configResult.config, dependencyResult.graph);
+		const diagnostics = [
+			...configResult.diagnostics,
+			...dependencyResult.diagnostics,
+			...analyzed.diagnostics
+		];
 		if (diagnostics.some((diagnostic) => diagnostic.severity === "error")) return {
 			diagnostics,
 			model: analyzed.model,
@@ -783,7 +1656,7 @@ const createCompiler = () => ({
 			plan: null
 		};
 		const compilationPlan = plan(analyzed.model, input.options?.outputRoot);
-		const output = generate(compilationPlan, analyzed.model);
+		const output = generateRouteIntrospection(compilationPlan, analyzed.model);
 		return {
 			diagnostics,
 			model: analyzed.model,
@@ -793,10 +1666,12 @@ const createCompiler = () => ({
 	},
 	discover,
 	generate,
+	generateRouteIntrospection,
 	loadConfig,
 	parse,
 	plan
 });
+const introspect = (input) => introspectCompilation(input);
 //#endregion
 //#region src/compile.ts
 const compile = (input) => createCompiler().compile(input);
@@ -830,6 +1705,26 @@ const diff = (previous, next) => {
 	};
 };
 //#endregion
+//#region src/finalize.ts
+const finalizeCompilation = (compilation, introspection) => {
+	if (!(compilation.plan && compilation.output)) return compilation;
+	const model = {
+		...compilation.model,
+		dependencies: introspection.dependencies,
+		routeDependencies: introspection.routeDependencies
+	};
+	const plan = {
+		...compilation.plan,
+		dependencies: introspection.dependencies,
+		routeDependencies: introspection.routeDependencies
+	};
+	return {
+		...compilation,
+		model,
+		plan
+	};
+};
+//#endregion
 //#region src/recompile.ts
 const recompile = (input) => {
 	const compiler = createCompiler();
@@ -843,6 +1738,6 @@ const recompile = (input) => {
 	});
 };
 //#endregion
-export { analyze, compile, createCompiler, diff, discover, generate, loadConfig, parse, plan, recompile };
+export { NOOH_ROUTE_METADATA, analyze, compile, createCompiler, createDependencyGraph, dependencyClosure, diff, discover, finalizeCompilation, generate, generateRouteIntrospection, introspect, introspectCompilation, introspectRoute, loadConfig, loadDependencyGraph, parse, plan, readRouteMetadata, recompile };
 
 //# sourceMappingURL=index.mjs.map