typespec-rust-emitter 0.6.0 → 0.8.0

package/example/output-rust/src/generated/server.rs

@@ -2,9 +2,11 @@
 
 use super::types::*;
 use async_trait::async_trait;
-use axum::{http::StatusCode, Json};
 use axum::extract::Path;
 use axum::Extension;
+use axum::http::StatusCode;
+use axum::response::IntoResponse;
+use axum::Json;
 use eyre::Result;
 
 #[async_trait]
@@ -51,7 +53,7 @@ pub trait Server: Send + Sync {
 }
 pub enum GroupsListResponse {
     Ok(Json<Vec<GroupStatistics>>),
-    Unauthorized,
+    Unauthorized(Json<ApiError>),
 }
 
 impl IntoResponse for GroupsListResponse {
@@ -59,15 +61,15 @@ impl IntoResponse for GroupsListResponse {
         match self {
 
             GroupsListResponse::Ok(body) => (StatusCode::OK, body).into_response(),
-            GroupsListResponse::Unauthorized => StatusCode::UNAUTHORIZED.into_response(),
+            GroupsListResponse::Unauthorized(body) => (StatusCode::UNAUTHORIZED, body).into_response(),
         }
     }
 }
 
 pub enum GroupsCreateResponse {
     Created(Json<Group>),
-    BadRequest,
-    Unauthorized,
+    BadRequest(Json<ValidationError>),
+    Unauthorized(Json<ApiError>),
 }
 
 impl IntoResponse for GroupsCreateResponse {
@@ -75,16 +77,16 @@ impl IntoResponse for GroupsCreateResponse {
         match self {
 
             GroupsCreateResponse::Created(body) => (StatusCode::CREATED, body).into_response(),
-            GroupsCreateResponse::BadRequest => StatusCode::BAD_REQUEST.into_response(),
-            GroupsCreateResponse::Unauthorized => StatusCode::UNAUTHORIZED.into_response(),
+            GroupsCreateResponse::BadRequest(body) => (StatusCode::BAD_REQUEST, body).into_response(),
+            GroupsCreateResponse::Unauthorized(body) => (StatusCode::UNAUTHORIZED, body).into_response(),
         }
     }
 }
 
 pub enum GroupsGetByIdResponse {
     Ok(Json<GroupStatistics>),
-    Unauthorized,
-    NotFound,
+    Unauthorized(Json<ApiError>),
+    NotFound(Json<NotFoundError>),
 }
 
 impl IntoResponse for GroupsGetByIdResponse {
@@ -92,17 +94,17 @@ impl IntoResponse for GroupsGetByIdResponse {
         match self {
 
             GroupsGetByIdResponse::Ok(body) => (StatusCode::OK, body).into_response(),
-            GroupsGetByIdResponse::Unauthorized => StatusCode::UNAUTHORIZED.into_response(),
-            GroupsGetByIdResponse::NotFound => StatusCode::NOT_FOUND.into_response(),
+            GroupsGetByIdResponse::Unauthorized(body) => (StatusCode::UNAUTHORIZED, body).into_response(),
+            GroupsGetByIdResponse::NotFound(body) => (StatusCode::NOT_FOUND, body).into_response(),
         }
     }
 }
 
 pub enum GroupsUpdateResponse {
     Ok(Json<Group>),
-    BadRequest,
-    Unauthorized,
-    NotFound,
+    BadRequest(Json<ValidationError>),
+    Unauthorized(Json<ApiError>),
+    NotFound(Json<NotFoundError>),
 }
 
 impl IntoResponse for GroupsUpdateResponse {
@@ -110,17 +112,17 @@ impl IntoResponse for GroupsUpdateResponse {
         match self {
 
             GroupsUpdateResponse::Ok(body) => (StatusCode::OK, body).into_response(),
-            GroupsUpdateResponse::BadRequest => StatusCode::BAD_REQUEST.into_response(),
-            GroupsUpdateResponse::Unauthorized => StatusCode::UNAUTHORIZED.into_response(),
-            GroupsUpdateResponse::NotFound => StatusCode::NOT_FOUND.into_response(),
+            GroupsUpdateResponse::BadRequest(body) => (StatusCode::BAD_REQUEST, body).into_response(),
+            GroupsUpdateResponse::Unauthorized(body) => (StatusCode::UNAUTHORIZED, body).into_response(),
+            GroupsUpdateResponse::NotFound(body) => (StatusCode::NOT_FOUND, body).into_response(),
         }
     }
 }
 
 pub enum GroupsDeleteResponse {
     NoContent,
-    Unauthorized,
-    NotFound,
+    Unauthorized(Json<ApiError>),
+    NotFound(Json<NotFoundError>),
 }
 
 impl IntoResponse for GroupsDeleteResponse {
@@ -128,16 +130,16 @@ impl IntoResponse for GroupsDeleteResponse {
         match self {
 
             GroupsDeleteResponse::NoContent => StatusCode::NO_CONTENT.into_response(),
-            GroupsDeleteResponse::Unauthorized => StatusCode::UNAUTHORIZED.into_response(),
-            GroupsDeleteResponse::NotFound => StatusCode::NOT_FOUND.into_response(),
+            GroupsDeleteResponse::Unauthorized(body) => (StatusCode::UNAUTHORIZED, body).into_response(),
+            GroupsDeleteResponse::NotFound(body) => (StatusCode::NOT_FOUND, body).into_response(),
         }
     }
 }
 
 pub enum SubjectsListResponse {
     Ok(Json<Vec<SubjectStatistics>>),
-    Unauthorized,
-    NotFound,
+    Unauthorized(Json<ApiError>),
+    NotFound(Json<NotFoundError>),
 }
 
 impl IntoResponse for SubjectsListResponse {
@@ -145,17 +147,17 @@ impl IntoResponse for SubjectsListResponse {
         match self {
 
             SubjectsListResponse::Ok(body) => (StatusCode::OK, body).into_response(),
-            SubjectsListResponse::Unauthorized => StatusCode::UNAUTHORIZED.into_response(),
-            SubjectsListResponse::NotFound => StatusCode::NOT_FOUND.into_response(),
+            SubjectsListResponse::Unauthorized(body) => (StatusCode::UNAUTHORIZED, body).into_response(),
+            SubjectsListResponse::NotFound(body) => (StatusCode::NOT_FOUND, body).into_response(),
         }
     }
 }
 
 pub enum SubjectsCreateResponse {
     Created(Json<Subject>),
-    BadRequest,
-    Unauthorized,
-    NotFound,
+    BadRequest(Json<ValidationError>),
+    Unauthorized(Json<ApiError>),
+    NotFound(Json<NotFoundError>),
 }
 
 impl IntoResponse for SubjectsCreateResponse {
@@ -163,17 +165,17 @@ impl IntoResponse for SubjectsCreateResponse {
         match self {
 
             SubjectsCreateResponse::Created(body) => (StatusCode::CREATED, body).into_response(),
-            SubjectsCreateResponse::BadRequest => StatusCode::BAD_REQUEST.into_response(),
-            SubjectsCreateResponse::Unauthorized => StatusCode::UNAUTHORIZED.into_response(),
-            SubjectsCreateResponse::NotFound => StatusCode::NOT_FOUND.into_response(),
+            SubjectsCreateResponse::BadRequest(body) => (StatusCode::BAD_REQUEST, body).into_response(),
+            SubjectsCreateResponse::Unauthorized(body) => (StatusCode::UNAUTHORIZED, body).into_response(),
+            SubjectsCreateResponse::NotFound(body) => (StatusCode::NOT_FOUND, body).into_response(),
         }
     }
 }
 
 pub enum SubjectsGetByIdResponse {
     Ok(Json<SubjectStatistics>),
-    Unauthorized,
-    NotFound,
+    Unauthorized(Json<ApiError>),
+    NotFound(Json<NotFoundError>),
 }
 
 impl IntoResponse for SubjectsGetByIdResponse {
@@ -181,17 +183,17 @@ impl IntoResponse for SubjectsGetByIdResponse {
         match self {
 
             SubjectsGetByIdResponse::Ok(body) => (StatusCode::OK, body).into_response(),
-            SubjectsGetByIdResponse::Unauthorized => StatusCode::UNAUTHORIZED.into_response(),
-            SubjectsGetByIdResponse::NotFound => StatusCode::NOT_FOUND.into_response(),
+            SubjectsGetByIdResponse::Unauthorized(body) => (StatusCode::UNAUTHORIZED, body).into_response(),
+            SubjectsGetByIdResponse::NotFound(body) => (StatusCode::NOT_FOUND, body).into_response(),
         }
     }
 }
 
 pub enum SubjectsUpdateResponse {
     Ok(Json<Subject>),
-    BadRequest,
-    Unauthorized,
-    NotFound,
+    BadRequest(Json<ValidationError>),
+    Unauthorized(Json<ApiError>),
+    NotFound(Json<NotFoundError>),
 }
 
 impl IntoResponse for SubjectsUpdateResponse {
@@ -199,17 +201,17 @@ impl IntoResponse for SubjectsUpdateResponse {
         match self {
 
             SubjectsUpdateResponse::Ok(body) => (StatusCode::OK, body).into_response(),
-            SubjectsUpdateResponse::BadRequest => StatusCode::BAD_REQUEST.into_response(),
-            SubjectsUpdateResponse::Unauthorized => StatusCode::UNAUTHORIZED.into_response(),
-            SubjectsUpdateResponse::NotFound => StatusCode::NOT_FOUND.into_response(),
+            SubjectsUpdateResponse::BadRequest(body) => (StatusCode::BAD_REQUEST, body).into_response(),
+            SubjectsUpdateResponse::Unauthorized(body) => (StatusCode::UNAUTHORIZED, body).into_response(),
+            SubjectsUpdateResponse::NotFound(body) => (StatusCode::NOT_FOUND, body).into_response(),
         }
     }
 }
 
 pub enum SubjectsDeleteResponse {
     NoContent,
-    Unauthorized,
-    NotFound,
+    Unauthorized(Json<ApiError>),
+    NotFound(Json<NotFoundError>),
 }
 
 impl IntoResponse for SubjectsDeleteResponse {
@@ -217,17 +219,17 @@ impl IntoResponse for SubjectsDeleteResponse {
         match self {
 
             SubjectsDeleteResponse::NoContent => StatusCode::NO_CONTENT.into_response(),
-            SubjectsDeleteResponse::Unauthorized => StatusCode::UNAUTHORIZED.into_response(),
-            SubjectsDeleteResponse::NotFound => StatusCode::NOT_FOUND.into_response(),
+            SubjectsDeleteResponse::Unauthorized(body) => (StatusCode::UNAUTHORIZED, body).into_response(),
+            SubjectsDeleteResponse::NotFound(body) => (StatusCode::NOT_FOUND, body).into_response(),
         }
     }
 }
 
 pub enum SessionsStartResponse {
     Created(Json<SessionOpenedResponse>),
-    Unauthorized,
-    NotFound,
-    Conflict,
+    Unauthorized(Json<ApiError>),
+    NotFound(Json<NotFoundError>),
+    Conflict(Json<ConflictError>),
 }
 
 impl IntoResponse for SessionsStartResponse {
@@ -235,18 +237,18 @@ impl IntoResponse for SessionsStartResponse {
         match self {
 
             SessionsStartResponse::Created(body) => (StatusCode::CREATED, body).into_response(),
-            SessionsStartResponse::Unauthorized => StatusCode::UNAUTHORIZED.into_response(),
-            SessionsStartResponse::NotFound => StatusCode::NOT_FOUND.into_response(),
-            SessionsStartResponse::Conflict => StatusCode::CONFLICT.into_response(),
+            SessionsStartResponse::Unauthorized(body) => (StatusCode::UNAUTHORIZED, body).into_response(),
+            SessionsStartResponse::NotFound(body) => (StatusCode::NOT_FOUND, body).into_response(),
+            SessionsStartResponse::Conflict(body) => (StatusCode::CONFLICT, body).into_response(),
         }
     }
 }
 
 pub enum SessionsPauseResponse {
     Ok(Json<SessionClosedResponse>),
-    Unauthorized,
-    NotFound,
-    Conflict,
+    Unauthorized(Json<ApiError>),
+    NotFound(Json<NotFoundError>),
+    Conflict(Json<ConflictError>),
 }
 
 impl IntoResponse for SessionsPauseResponse {
@@ -254,18 +256,18 @@ impl IntoResponse for SessionsPauseResponse {
         match self {
 
             SessionsPauseResponse::Ok(body) => (StatusCode::OK, body).into_response(),
-            SessionsPauseResponse::Unauthorized => StatusCode::UNAUTHORIZED.into_response(),
-            SessionsPauseResponse::NotFound => StatusCode::NOT_FOUND.into_response(),
-            SessionsPauseResponse::Conflict => StatusCode::CONFLICT.into_response(),
+            SessionsPauseResponse::Unauthorized(body) => (StatusCode::UNAUTHORIZED, body).into_response(),
+            SessionsPauseResponse::NotFound(body) => (StatusCode::NOT_FOUND, body).into_response(),
+            SessionsPauseResponse::Conflict(body) => (StatusCode::CONFLICT, body).into_response(),
         }
     }
 }
 
 pub enum SessionsResumeResponse {
     Ok(Json<SessionOpenedResponse>),
-    Unauthorized,
-    NotFound,
-    Conflict,
+    Unauthorized(Json<ApiError>),
+    NotFound(Json<NotFoundError>),
+    Conflict(Json<ConflictError>),
 }
 
 impl IntoResponse for SessionsResumeResponse {
@@ -273,18 +275,18 @@ impl IntoResponse for SessionsResumeResponse {
         match self {
 
             SessionsResumeResponse::Ok(body) => (StatusCode::OK, body).into_response(),
-            SessionsResumeResponse::Unauthorized => StatusCode::UNAUTHORIZED.into_response(),
-            SessionsResumeResponse::NotFound => StatusCode::NOT_FOUND.into_response(),
-            SessionsResumeResponse::Conflict => StatusCode::CONFLICT.into_response(),
+            SessionsResumeResponse::Unauthorized(body) => (StatusCode::UNAUTHORIZED, body).into_response(),
+            SessionsResumeResponse::NotFound(body) => (StatusCode::NOT_FOUND, body).into_response(),
+            SessionsResumeResponse::Conflict(body) => (StatusCode::CONFLICT, body).into_response(),
         }
     }
 }
 
 pub enum SessionsStopResponse {
     Ok(Json<SessionClosedResponse>),
-    Unauthorized,
-    NotFound,
-    Conflict,
+    Unauthorized(Json<ApiError>),
+    NotFound(Json<NotFoundError>),
+    Conflict(Json<ConflictError>),
 }
 
 impl IntoResponse for SessionsStopResponse {
@@ -292,14 +294,13 @@ impl IntoResponse for SessionsStopResponse {
         match self {
 
             SessionsStopResponse::Ok(body) => (StatusCode::OK, body).into_response(),
-            SessionsStopResponse::Unauthorized => StatusCode::UNAUTHORIZED.into_response(),
-            SessionsStopResponse::NotFound => StatusCode::NOT_FOUND.into_response(),
-            SessionsStopResponse::Conflict => StatusCode::CONFLICT.into_response(),
+            SessionsStopResponse::Unauthorized(body) => (StatusCode::UNAUTHORIZED, body).into_response(),
+            SessionsStopResponse::NotFound(body) => (StatusCode::NOT_FOUND, body).into_response(),
+            SessionsStopResponse::Conflict(body) => (StatusCode::CONFLICT, body).into_response(),
         }
     }
 }
 
-use axum::response::IntoResponse;
 use axum::routing::{delete, get, patch, post};
 use axum::Router;
 

package/example/output-rust/src/generated/types.rs

@@ -1,5 +1,9 @@
 #![allow(unused)]
 
+use axum::http::StatusCode;
+use axum::response::IntoResponse;
+use axum::Json;
+
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize, thiserror::Error)]
 #[error("{code}: {message}")]
 pub struct ApiError {
@@ -9,6 +13,12 @@ pub struct ApiError {
   pub message: String,
 }
 
+impl IntoResponse for ApiError {
+    fn into_response(self) -> axum::response::Response {
+        (StatusCode::INTERNAL_SERVER_ERROR, Json(self)).into_response()
+    }
+}
+
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize, thiserror::Error)]
 #[error("{code}: {message}")]
 pub struct NotFoundError {
@@ -17,6 +27,12 @@ pub struct NotFoundError {
   pub message: String,
 }
 
+impl IntoResponse for NotFoundError {
+    fn into_response(self) -> axum::response::Response {
+        (StatusCode::NOT_FOUND, Json(self)).into_response()
+    }
+}
+
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize, thiserror::Error)]
 #[error("{code}: {message}")]
 pub struct ValidationError {
@@ -25,6 +41,12 @@ pub struct ValidationError {
   pub message: String,
 }
 
+impl IntoResponse for ValidationError {
+    fn into_response(self) -> axum::response::Response {
+        (StatusCode::BAD_REQUEST, Json(self)).into_response()
+    }
+}
+
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize, thiserror::Error)]
 #[error("{code}: {message}")]
 pub struct ConflictError {
@@ -33,6 +55,12 @@ pub struct ConflictError {
   pub message: String,
 }
 
+impl IntoResponse for ConflictError {
+    fn into_response(self) -> axum::response::Response {
+        (StatusCode::CONFLICT, Json(self)).into_response()
+    }
+}
+
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct DurationStats {
   #[serde(rename = "durationTotal")]

package/example/package-lock.json

@@ -17,7 +17,7 @@
       }
     },
     "..": {
-      "version": "0.6.0",
+      "version": "0.8.0",
       "license": "MIT",
       "devDependencies": {
         "@types/node": "latest",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "typespec-rust-emitter",
-  "version": "0.6.0",
+  "version": "0.8.0",
   "description": "TypeSpec emitter that generates idiomatic Rust types and structs",
   "keywords": [
     "typespec",

package/src/emitter.ts

@@ -417,8 +417,21 @@ function getBodyFromResponse(
 ): { type: string | undefined; description: string | undefined } {
   if (variant.type.kind === "Model") {
     const model = variant.type as Model;
-    for (const [propName, prop] of model.properties) {
-      if (propName === "body") {
+    for (const [_propName, prop] of model.properties) {
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      const decorators = (prop as any).decorators;
+      let isBody = false;
+      if (decorators) {
+        for (const key of Object.keys(decorators)) {
+          const decorator = decorators[key];
+          const name = getDecoratorName(decorator);
+          if (name === "body" || name === "bodyRoot") {
+            isBody = true;
+            break;
+          }
+        }
+      }
+      if (isBody) {
         const { type: rustType } = getRustTypeForProperty(
           prop.type,
           program,
@@ -545,6 +558,13 @@ function getHttpStatusCode(statusCode: number): string {
   return statusCodes[statusCode] || `StatusCode::from_u16(${statusCode})`;
 }
 
+function getHttpStatusCodeForError(errorName: string): string {
+  if (errorName.endsWith("NotFoundError")) return "NOT_FOUND";
+  if (errorName.endsWith("ValidationError")) return "BAD_REQUEST";
+  if (errorName.endsWith("ConflictError")) return "CONFLICT";
+  return "INTERNAL_SERVER_ERROR";
+}
+
 function generateServerTrait(
   program: Program,
   namespaceGroups: { namespace: Namespace; operations: Operation[] }[],
@@ -554,9 +574,11 @@ function generateServerTrait(
 
   parts.push(`use super::types::*;
 use async_trait::async_trait;
-use axum::{http::StatusCode, Json};
 use axum::extract::Path;
 use axum::Extension;
+use axum::http::StatusCode;
+use axum::response::IntoResponse;
+use axum::Json;
 use eyre::Result;
 
 #[async_trait]
@@ -812,8 +834,7 @@ where
   const routerBody = buildRouterBody(publicRoutes, protectedRoutes);
 
   const parts: string[] = [];
-  parts.push(`use axum::response::IntoResponse;
-use axum::routing::{${methodImports}};
+  parts.push(`use axum::routing::{${methodImports}};
 use axum::Router;
 
 `);
@@ -1232,6 +1253,16 @@ ${fields.join("\n")}
     parts.push("(());");
   }
 
+  if (isError && allProps.size > 0) {
+    const statusCode = getHttpStatusCodeForError(name);
+    parts.push(`
+impl IntoResponse for ${name} {
+    fn into_response(self) -> axum::response::Response {
+        (StatusCode::${statusCode}, Json(self)).into_response()
+    }
+}`);
+  }
+
   return parts.join("\n");
 }
 
@@ -1508,7 +1539,13 @@ export async function $onEmit(
 
   const namespaceGroups = getAllOperations(context.program);
 
-  const outputContent = "#![allow(unused)]\n\n" + content.join("\n") + "\n";
+  const outputContent =
+    "#![allow(unused)]\n\n" +
+    "use axum::http::StatusCode;\n" +
+    "use axum::response::IntoResponse;\n" +
+    "use axum::Json;\n\n" +
+    content.join("\n") +
+    "\n";
 
   await emitFile(context.program, {
     path: resolvePath(context.emitterOutputDir, "types.rs"),

package/src/testing/index.ts

@@ -1,8 +1,12 @@
 import { resolvePath } from "@typespec/compiler";
-import { createTestLibrary, TypeSpecTestLibrary } from "@typespec/compiler/testing";
+import {
+  createTestLibrary,
+  TypeSpecTestLibrary,
+} from "@typespec/compiler/testing";
 import { fileURLToPath } from "url";
 
-export const TypespecEmitterTestLibrary: TypeSpecTestLibrary = createTestLibrary({
-  name: "typespec-emitter",
-  packageRoot: resolvePath(fileURLToPath(import.meta.url), "../../../../"),
-});
+export const TypespecEmitterTestLibrary: TypeSpecTestLibrary =
+  createTestLibrary({
+    name: "typespec-emitter",
+    packageRoot: resolvePath(fileURLToPath(import.meta.url), "../../../../"),
+  });

package/DEV.md

@@ -1,81 +0,0 @@
-# TypeSpec Rust Emitter - LLM Context
-
-## Purpose
-
-TypeSpec emitter that generates idiomatic Rust code (structs, enums, server traits) from TypeSpec specifications.
-
-## Key Paths
-
-| Path                                 | Purpose                                                 |
-| ------------------------------------ | ------------------------------------------------------- |
-| `src/emitter.ts`                     | Main emitter logic (1464 lines) - TypeSpec→Rust codegen |
-| `src/lib.tsp`                        | Decorator declarations (`@rustDerive`, `@rustDerives`)  |
-| `test/hello.test.ts`                 | Unit tests using `emit()` helper                        |
-| `example/lib/learning/`              | Demo TypeSpec models & operations                       |
-| `example/output-rust/src/generated/` | Generated Rust output                                   |
-| `oas3-gen/crates/oas3-gen/`          | Reference template for codegen patterns                 |
-
-## Commands (Run After Every Change)
-
-```bash
-just build      # npm run build - Compile TypeScript
-just test       # npm test - Run unit tests
-just compile    # tsp compile example → generates Rust code
-just check-rust # cargo check - Verify Rust compiles
-```
-
-## Type Mappings
-
-| TypeSpec               | Rust                    |
-| ---------------------- | ----------------------- |
-| `string`               | `String`                |
-| `int32/64`             | `i32/i64`               |
-| `T \| null`            | `Option<T>`             |
-| `T[]`                  | `Vec<T>`                |
-| `Record<T>`            | `HashMap<String, T>`    |
-| `@format("uuid")`      | `uuid::Uuid`            |
-| `@format("date-time")` | `chrono::DateTime<Utc>` |
-
-## Architecture
-
-1. `navigateProgram()` walks TypeSpec AST
-2. Collects models, enums, operations
-3. Processes decorators
-4. Generates Rust code via string templates
-5. Emits to `example/output-rust/src/generated/`
-
-## Server Trait Generation
-
-- Generates `Server<Claims>` trait with async methods per operation
-- Handler functions: `pub async fn {op}_handler<S, Claims>(...)`
-- All handlers use `<S, Claims>` generics (even public routes)
-- Protected routes (`@useAuth`) receive `claims: Claims` parameter
-- Router splits public/protected routes, merges at end
-
-## Test Pattern
-
-```typescript
-import { emit } from "./test-host.js";
-const results = await emit(`model User { name: string; }`);
-const output = results["types.rs"];
-strictEqual(output.includes("pub struct User"), true);
-```
-
-## Recent Fix (2026-03-27)
-
-All handler functions now use `<S, Claims>` generics uniformly. Public routes include `Claims: Send + Sync + Clone + 'static` bound even without using Claims, because Server trait requires it.
-
-## Rules
-
-1. Always run full cycle: `build → test → compile → check-rust`
-2. TypeScript strict mode enabled - no implicit any
-3. Match existing code patterns in `src/emitter.ts`
-4. Add tests for new features
-5. Generated Rust must compile
-
-## Todo
-
-- [ ] More server trait test coverage
-- [ ] Integration tests with Rust compilation
-- [ ] Expand scalar format mappings
-- [ ] Full working Rust server example