@macroforge/mcp-server 0.1.74 → 0.1.75

package/docs/builtin-macros/clone.md

@@ -1,18 +1,16 @@
 # Clone
 
-The `Clone` macro generates a `clone()` method for deep copying objects.
-This is analogous to Rust's `Clone` trait, providing a way to create
-independent copies of values.
+The `Clone` macro generates a `clone()` method for deep copying objects. This is analogous to Rust's
+`Clone` trait, providing a way to create independent copies of values.
 
 ## Generated Output
 
-| Type | Generated Code | Description |
-|------|----------------|-------------|
-| Class | `classNameClone(value)` + `static clone(value)` | Standalone function + static wrapper method |
-| Enum | `enumNameClone(value: EnumName): EnumName` | Standalone function (enums are primitives, returns value as-is) |
-| Interface | `interfaceNameClone(value: InterfaceName): InterfaceName` | Standalone function creating a new object literal |
-| Type Alias | `typeNameClone(value: TypeName): TypeName` | Standalone function with spread copy for objects |
-
+| Type       | Generated Code                                            | Description                                                     |
+| ---------- | --------------------------------------------------------- | --------------------------------------------------------------- |
+| Class      | `classNameClone(value)` + `static clone(value)`           | Standalone function + static wrapper method                     |
+| Enum       | `enumNameClone(value: EnumName): EnumName`                | Standalone function (enums are primitives, returns value as-is) |
+| Interface  | `interfaceNameClone(value: InterfaceName): InterfaceName` | Standalone function creating a new object literal               |
+| Type Alias | `typeNameClone(value: TypeName): TypeName`                | Standalone function with spread copy for objects                |
 
 ## Cloning Strategy
 
@@ -22,8 +20,8 @@ The generated clone performs a **shallow copy** of all fields:
 - **Objects**: Reference is copied (not deep cloned)
 - **Arrays**: Reference is copied (not deep cloned)
 
-For deep cloning of nested objects, those objects should also derive `Clone`
-and the caller should clone them explicitly.
+For deep cloning of nested objects, those objects should also derive `Clone` and the caller should
+clone them explicitly.
 
 ## Example
 
@@ -55,8 +53,8 @@ export function pointClone(value: Point): Point {
 
 ## Implementation Notes
 
-- **Classes**: Uses `Object.create(Object.getPrototypeOf(value))` to preserve
-  the prototype chain, ensuring `instanceof` checks work correctly
+- **Classes**: Uses `Object.create(Object.getPrototypeOf(value))` to preserve the prototype chain,
+  ensuring `instanceof` checks work correctly
 - **Enums**: Simply returns the value (enums are primitives in TypeScript)
-- **Interfaces/Type Aliases**: Creates new object literals with spread operator
-  for union/tuple types, or field-by-field copy for object types
+- **Interfaces/Type Aliases**: Creates new object literals with spread operator for union/tuple
+  types, or field-by-field copy for object types

package/docs/builtin-macros/debug.md

@@ -1,21 +1,20 @@
 # Debug
 
-The `Debug` macro generates a human-readable `toString()` method for
-TypeScript classes, interfaces, enums, and type aliases.
+The `Debug` macro generates a human-readable `toString()` method for TypeScript classes, interfaces,
+enums, and type aliases.
 
 ## Generated Output
 
-**Classes**: Generates a standalone function `classNameToString(value)` and a static wrapper
-method `static toString(value)` returning a string like `"ClassName { field1: value1, field2: value2 }"`.
+**Classes**: Generates a standalone function `classNameToString(value)` and a static wrapper method
+`static toString(value)` returning a string like `"ClassName { field1: value1, field2: value2 }"`.
 
-**Enums**: Generates a standalone function `enumNameToString(value)` that performs
-reverse lookup on numeric enums.
+**Enums**: Generates a standalone function `enumNameToString(value)` that performs reverse lookup on
+numeric enums.
 
 **Interfaces**: Generates a standalone function `interfaceNameToString(value)`.
 
-**Type Aliases**: Generates a standalone function using JSON.stringify for
-complex types, or field enumeration for object types.
-
+**Type Aliases**: Generates a standalone function using JSON.stringify for complex types, or field
+enumeration for object types.
 
 ## Field-Level Options
 

package/docs/builtin-macros/default.md

@@ -1,35 +1,34 @@
 # Default
 
-The `Default` macro generates a static `defaultValue()` factory method that creates
-instances with default values. This is analogous to Rust's `Default` trait, providing
-a standard way to create "zero" or "empty" instances of types.
+The `Default` macro generates a static `defaultValue()` factory method that creates instances with
+default values. This is analogous to Rust's `Default` trait, providing a standard way to create
+"zero" or "empty" instances of types.
 
 ## Generated Output
 
-| Type | Generated Code | Description |
-|------|----------------|-------------|
-| Class | `static defaultValue(): ClassName` | Static factory method |
-| Enum | `defaultValueEnumName(): EnumName` | Standalone function returning marked variant |
-| Interface | `defaultValueInterfaceName(): InterfaceName` | Standalone function returning object literal |
-| Type Alias | `defaultValueTypeName(): TypeName` | Standalone function with type-appropriate default |
-
+| Type       | Generated Code                               | Description                                       |
+| ---------- | -------------------------------------------- | ------------------------------------------------- |
+| Class      | `static defaultValue(): ClassName`           | Static factory method                             |
+| Enum       | `defaultValueEnumName(): EnumName`           | Standalone function returning marked variant      |
+| Interface  | `defaultValueInterfaceName(): InterfaceName` | Standalone function returning object literal      |
+| Type Alias | `defaultValueTypeName(): TypeName`           | Standalone function with type-appropriate default |
 
 ## Default Values by Type
 
 The macro uses Rust-like default semantics:
 
-| Type | Default Value |
-|------|---------------|
-| `string` | `""` (empty string) |
-| `number` | `0` |
-| `boolean` | `false` |
-| `bigint` | `0n` |
-| `T[]` | `[]` (empty array) |
-| `Array<T>` | `[]` (empty array) |
-| `Map<K,V>` | `new Map()` |
-| `Set<T>` | `new Set()` |
-| `Date` | `new Date()` (current time) |
-| `T \| null` | `null` |
+| Type         | Default Value                           |
+| ------------ | --------------------------------------- |
+| `string`     | `""` (empty string)                     |
+| `number`     | `0`                                     |
+| `boolean`    | `false`                                 |
+| `bigint`     | `0n`                                    |
+| `T[]`        | `[]` (empty array)                      |
+| `Array<T>`   | `[]` (empty array)                      |
+| `Map<K,V>`   | `new Map()`                             |
+| `Set<T>`     | `new Set()`                             |
+| `Date`       | `new Date()` (current time)             |
+| `T \| null`  | `null`                                  |
 | `CustomType` | `CustomType.defaultValue()` (recursive) |
 
 ## Field-Level Options
@@ -52,7 +51,7 @@ class UserSettings {
     /** @default(10) */
     pageSize: number;
 
-    notifications: boolean;  // Uses type default: false
+    notifications: boolean; // Uses type default: false
 }
 ```
 

package/docs/builtin-macros/deserialize/cycleforward-reference-support.md

@@ -7,5 +7,6 @@ Uses deferred patching to handle references:
 3. After all objects are created, `ctx.applyPatches()` resolves all pending references
 
 References only apply to object-shaped, serializable values. The generator avoids probing for
-`__ref` on primitive-like fields (including literal unions and `T | null` where `T` is primitive-like),
-and it parses `Date` / `Date | null` from ISO strings without treating them as references.
+`__ref` on primitive-like fields (including literal unions and `T | null` where `T` is
+primitive-like), and it parses `Date` / `Date | null` from ISO strings without treating them as
+references.

package/docs/builtin-macros/deserialize/example.md

@@ -214,4 +214,5 @@ if (Result.isOk(result)) {
 ## Required Imports
 
 The generated code automatically imports:
-- `DeserializeContext`, `DeserializeError`, `PendingRef` from `macroforge/serde`
+
+- `DeserializeContext`, `DeserializeError`, `PendingRef` from `macroforge/serde`

package/docs/builtin-macros/deserialize/overview.md

@@ -1,21 +1,21 @@
 # Deserialize
 
-The `Deserialize` macro generates JSON deserialization methods with **cycle and
-forward-reference support**, plus comprehensive runtime validation. This enables
-safe parsing of complex JSON structures including circular references.
+The `Deserialize` macro generates JSON deserialization methods with **cycle and forward-reference
+support**, plus comprehensive runtime validation. This enables safe parsing of complex JSON
+structures including circular references.
 
 ## Generated Output
 
-| Type | Generated Code | Description |
-|------|----------------|-------------|
-| Class | `classNameDeserialize(input)` + `static deserialize(input)` | Standalone function + static factory method |
-| Enum | `enumNameDeserialize(input)`, `enumNameDeserializeWithContext(data)`, `enumNameIs(value)` | Standalone functions |
-| Interface | `interfaceNameDeserialize(input)`, etc. | Standalone functions |
-| Type Alias | `typeNameDeserialize(input)`, etc. | Standalone functions |
+| Type       | Generated Code                                                                            | Description                                 |
+| ---------- | ----------------------------------------------------------------------------------------- | ------------------------------------------- |
+| Class      | `classNameDeserialize(input)` + `static deserialize(input)`                               | Standalone function + static factory method |
+| Enum       | `enumNameDeserialize(input)`, `enumNameDeserializeWithContext(data)`, `enumNameIs(value)` | Standalone functions                        |
+| Interface  | `interfaceNameDeserialize(input)`, etc.                                                   | Standalone functions                        |
+| Type Alias | `typeNameDeserialize(input)`, etc.                                                        | Standalone functions                        |
 
 ## Return Type
 
 All public deserialization methods return `Result<T, Array<{ field: string; message: string }>>`:
 
 - `Result.ok(value)` - Successfully deserialized value
-- `Result.err(errors)` - Array of validation errors with field names and messages
+- `Result.err(errors)` - Array of validation errors with field names and messages

package/docs/builtin-macros/deserialize/union-type-deserialization.md

@@ -3,25 +3,31 @@
 Union types are deserialized based on their member types:
 
 ### Literal Unions
-For unions of literal values (`"A" | "B" | 123`), the value is validated against
-the allowed literals directly.
+
+For unions of literal values (`"A" | "B" | 123`), the value is validated against the allowed
+literals directly.
 
 ### Primitive Unions
-For unions containing primitive types (`string | number`), the deserializer uses
-`typeof` checks to validate the value type. No `__type` discriminator is needed.
+
+For unions containing primitive types (`string | number`), the deserializer uses `typeof` checks to
+validate the value type. No `__type` discriminator is needed.
 
 ### Class/Interface Unions
-For unions of serializable types (`User | Admin`), the deserializer requires a
-`__type` field in the JSON to dispatch to the correct type's `deserializeWithContext` method.
+
+For unions of serializable types (`User | Admin`), the deserializer requires a `__type` field in the
+JSON to dispatch to the correct type's `deserializeWithContext` method.
 
 ### Generic Type Parameters
-For generic unions like `type Result<T> = T | Error`, the generic type parameter `T`
-is passed through as-is since its concrete type is only known at the call site.
+
+For generic unions like `type Result<T> = T | Error`, the generic type parameter `T` is passed
+through as-is since its concrete type is only known at the call site.
 
 ### Mixed Unions
+
 Mixed unions (e.g., `string | Date | User`) check in order:
+
 1. Literal values
 2. Primitives (via `typeof`)
 3. Date (via `instanceof` or ISO string parsing)
 4. Serializable types (via `__type` dispatch)
-5. Generic type parameters (pass-through)
+5. Generic type parameters (pass-through)

package/docs/builtin-macros/deserialize/validation.md

@@ -3,19 +3,23 @@
 The macro supports 30+ validators via `@serde(validate(...))`:
 
 ### String Validators
+
 - `email`, `url`, `uuid` - Format validation
 - `minLength(n)`, `maxLength(n)`, `length(n)` - Length constraints
 - `pattern("regex")` - Regular expression matching
 - `nonEmpty`, `trimmed`, `lowercase`, `uppercase` - String properties
 
 ### Number Validators
+
 - `gt(n)`, `gte(n)`, `lt(n)`, `lte(n)`, `between(min, max)` - Range checks
 - `int`, `positive`, `nonNegative`, `finite` - Number properties
 
 ### Array Validators
+
 - `minItems(n)`, `maxItems(n)`, `itemsCount(n)` - Collection size
 
 ### Date Validators
+
 - `validDate`, `afterDate("ISO")`, `beforeDate("ISO")` - Date validation
 
 ## Field-Level Options
@@ -31,4 +35,4 @@ The `@serde` decorator supports:
 ## Container-Level Options
 
 - `denyUnknownFields` - Error on unrecognized JSON properties
-- `renameAll = "camelCase"` - Apply naming convention to all fields
+- `renameAll = "camelCase"` - Apply naming convention to all fields

package/docs/builtin-macros/deserialize.md

@@ -1,17 +1,17 @@
 # Deserialize
 
-The `Deserialize` macro generates JSON deserialization methods with **cycle and
-forward-reference support**, plus comprehensive runtime validation. This enables
-safe parsing of complex JSON structures including circular references.
+The `Deserialize` macro generates JSON deserialization methods with **cycle and forward-reference
+support**, plus comprehensive runtime validation. This enables safe parsing of complex JSON
+structures including circular references.
 
 ## Generated Output
 
-| Type | Generated Code | Description |
-|------|----------------|-------------|
-| Class | `classNameDeserialize(input)` + `static deserialize(input)` | Standalone function + static factory method |
-| Enum | `enumNameDeserialize(input)`, `enumNameDeserializeWithContext(data)`, `enumNameIs(value)` | Standalone functions |
-| Interface | `interfaceNameDeserialize(input)`, etc. | Standalone functions |
-| Type Alias | `typeNameDeserialize(input)`, etc. | Standalone functions |
+| Type       | Generated Code                                                                            | Description                                 |
+| ---------- | ----------------------------------------------------------------------------------------- | ------------------------------------------- |
+| Class      | `classNameDeserialize(input)` + `static deserialize(input)`                               | Standalone function + static factory method |
+| Enum       | `enumNameDeserialize(input)`, `enumNameDeserializeWithContext(data)`, `enumNameIs(value)` | Standalone functions                        |
+| Interface  | `interfaceNameDeserialize(input)`, etc.                                                   | Standalone functions                        |
+| Type Alias | `typeNameDeserialize(input)`, etc.                                                        | Standalone functions                        |
 
 ## Return Type
 
@@ -29,27 +29,32 @@ Uses deferred patching to handle references:
 3. After all objects are created, `ctx.applyPatches()` resolves all pending references
 
 References only apply to object-shaped, serializable values. The generator avoids probing for
-`__ref` on primitive-like fields (including literal unions and `T | null` where `T` is primitive-like),
-and it parses `Date` / `Date | null` from ISO strings without treating them as references.
+`__ref` on primitive-like fields (including literal unions and `T | null` where `T` is
+primitive-like), and it parses `Date` / `Date | null` from ISO strings without treating them as
+references.
 
 ## Validation
 
 The macro supports 30+ validators via `@serde(validate(...))`:
 
 ### String Validators
+
 - `email`, `url`, `uuid` - Format validation
 - `minLength(n)`, `maxLength(n)`, `length(n)` - Length constraints
 - `pattern("regex")` - Regular expression matching
 - `nonEmpty`, `trimmed`, `lowercase`, `uppercase` - String properties
 
 ### Number Validators
+
 - `gt(n)`, `gte(n)`, `lt(n)`, `lte(n)`, `between(min, max)` - Range checks
 - `int`, `positive`, `nonNegative`, `finite` - Number properties
 
 ### Array Validators
+
 - `minItems(n)`, `maxItems(n)`, `itemsCount(n)` - Collection size
 
 ### Date Validators
+
 - `validDate`, `afterDate("ISO")`, `beforeDate("ISO")` - Date validation
 
 ## Field-Level Options
@@ -72,23 +77,29 @@ The `@serde` decorator supports:
 Union types are deserialized based on their member types:
 
 ### Literal Unions
-For unions of literal values (`"A" | "B" | 123`), the value is validated against
-the allowed literals directly.
+
+For unions of literal values (`"A" | "B" | 123`), the value is validated against the allowed
+literals directly.
 
 ### Primitive Unions
-For unions containing primitive types (`string | number`), the deserializer uses
-`typeof` checks to validate the value type. No `__type` discriminator is needed.
+
+For unions containing primitive types (`string | number`), the deserializer uses `typeof` checks to
+validate the value type. No `__type` discriminator is needed.
 
 ### Class/Interface Unions
-For unions of serializable types (`User | Admin`), the deserializer requires a
-`__type` field in the JSON to dispatch to the correct type's `deserializeWithContext` method.
+
+For unions of serializable types (`User | Admin`), the deserializer requires a `__type` field in the
+JSON to dispatch to the correct type's `deserializeWithContext` method.
 
 ### Generic Type Parameters
-For generic unions like `type Result<T> = T | Error`, the generic type parameter `T`
-is passed through as-is since its concrete type is only known at the call site.
+
+For generic unions like `type Result<T> = T | Error`, the generic type parameter `T` is passed
+through as-is since its concrete type is only known at the call site.
 
 ### Mixed Unions
+
 Mixed unions (e.g., `string | Date | User`) check in order:
+
 1. Literal values
 2. Primitives (via `typeof`)
 3. Date (via `instanceof` or ISO string parsing)
@@ -311,4 +322,5 @@ if (Result.isOk(result)) {
 ## Required Imports
 
 The generated code automatically imports:
+
 - `DeserializeContext`, `DeserializeError`, `PendingRef` from `macroforge/serde`

package/docs/builtin-macros/hash.md

@@ -1,18 +1,17 @@
 # Hash
 
-The `Hash` macro generates a `hashCode()` method for computing numeric hash codes.
-This is analogous to Rust's `Hash` trait and Java's `hashCode()` method, enabling
-objects to be used as keys in hash-based collections.
+The `Hash` macro generates a `hashCode()` method for computing numeric hash codes. This is analogous
+to Rust's `Hash` trait and Java's `hashCode()` method, enabling objects to be used as keys in
+hash-based collections.
 
 ## Generated Output
 
-| Type | Generated Code | Description |
-|------|----------------|-------------|
-| Class | `classNameHashCode(value)` + `static hashCode(value)` | Standalone function + static wrapper method |
-| Enum | `enumNameHashCode(value: EnumName): number` | Standalone function hashing by enum value |
-| Interface | `interfaceNameHashCode(value: InterfaceName): number` | Standalone function computing hash |
-| Type Alias | `typeNameHashCode(value: TypeName): number` | Standalone function computing hash |
-
+| Type       | Generated Code                                        | Description                                 |
+| ---------- | ----------------------------------------------------- | ------------------------------------------- |
+| Class      | `classNameHashCode(value)` + `static hashCode(value)` | Standalone function + static wrapper method |
+| Enum       | `enumNameHashCode(value: EnumName): number`           | Standalone function hashing by enum value   |
+| Interface  | `interfaceNameHashCode(value: InterfaceName): number` | Standalone function computing hash          |
+| Type Alias | `typeNameHashCode(value: TypeName): number`           | Standalone function computing hash          |
 
 ## Hash Algorithm
 
@@ -28,17 +27,17 @@ This algorithm is consistent with Java's `Objects.hash()` implementation.
 
 ## Type-Specific Hashing
 
-| Type | Hash Strategy |
-|------|---------------|
-| `number` | Integer: direct value; Float: string hash of decimal |
-| `bigint` | String hash of decimal representation |
-| `string` | Character-by-character polynomial hash |
-| `boolean` | 1231 for true, 1237 for false (Java convention) |
-| `Date` | `getTime()` timestamp |
-| Arrays | Element-by-element hash combination |
-| `Map` | Entry-by-entry key+value hash |
-| `Set` | Element-by-element hash |
-| Objects | Calls `hashCode()` if available, else JSON string hash |
+| Type      | Hash Strategy                                          |
+| --------- | ------------------------------------------------------ |
+| `number`  | Integer: direct value; Float: string hash of decimal   |
+| `bigint`  | String hash of decimal representation                  |
+| `string`  | Character-by-character polynomial hash                 |
+| `boolean` | 1231 for true, 1237 for false (Java convention)        |
+| `Date`    | `getTime()` timestamp                                  |
+| Arrays    | Element-by-element hash combination                    |
+| `Map`     | Entry-by-entry key+value hash                          |
+| `Set`     | Element-by-element hash                                |
+| Objects   | Calls `hashCode()` if available, else JSON string hash |
 
 ## Field-Level Options
 
@@ -77,18 +76,14 @@ class User {
 
 export function userHashCode(value: User): number {
     let hash = 17;
-    hash =
-        (hash * 31 +
-            (Number.isInteger(value.id)
-                ? value.id | 0
-                : value.id
-                      .toString()
-                      .split('')
-                      .reduce((h, c) => (h * 31 + c.charCodeAt(0)) | 0, 0))) |
+    hash = (hash * 31 +
+        (Number.isInteger(value.id) ? value.id | 0 : value.id
+            .toString()
+            .split('')
+            .reduce((h, c) => (h * 31 + c.charCodeAt(0)) | 0, 0))) |
         0;
-    hash =
-        (hash * 31 +
-            (value.name ?? '').split('').reduce((h, c) => (h * 31 + c.charCodeAt(0)) | 0, 0)) |
+    hash = (hash * 31 +
+        (value.name ?? '').split('').reduce((h, c) => (h * 31 + c.charCodeAt(0)) | 0, 0)) |
         0;
     return hash;
 }
@@ -101,6 +96,5 @@ export function userEquals(a: User, b: User): boolean {
 
 ## Hash Contract
 
-Objects that are equal (`PartialEq`) should produce the same hash code.
-When using `@hash(skip)`, ensure the same fields are skipped in both
-`Hash` and `PartialEq` to maintain this contract.
+Objects that are equal (`PartialEq`) should produce the same hash code. When using `@hash(skip)`,
+ensure the same fields are skipped in both `Hash` and `PartialEq` to maintain this contract.

package/docs/builtin-macros/ord.md

@@ -1,23 +1,21 @@
 # Ord
 
-The `Ord` macro generates a `compareTo()` method for **total ordering** comparison.
-This is analogous to Rust's `Ord` trait, enabling objects to be sorted and
-compared with a guaranteed ordering relationship.
+The `Ord` macro generates a `compareTo()` method for **total ordering** comparison. This is
+analogous to Rust's `Ord` trait, enabling objects to be sorted and compared with a guaranteed
+ordering relationship.
 
 ## Generated Output
 
-| Type | Generated Code | Description |
-|------|----------------|-------------|
-| Class | `classNameCompare(a, b)` + `static compareTo(a, b)` | Standalone function + static wrapper method |
-| Enum | `enumNameCompare(a: EnumName, b: EnumName): number` | Standalone function comparing enum values |
-| Interface | `interfaceNameCompare(a: InterfaceName, b: InterfaceName): number` | Standalone function comparing fields |
-| Type Alias | `typeNameCompare(a: TypeName, b: TypeName): number` | Standalone function with type-appropriate comparison |
-
+| Type       | Generated Code                                                     | Description                                          |
+| ---------- | ------------------------------------------------------------------ | ---------------------------------------------------- |
+| Class      | `classNameCompare(a, b)` + `static compareTo(a, b)`                | Standalone function + static wrapper method          |
+| Enum       | `enumNameCompare(a: EnumName, b: EnumName): number`                | Standalone function comparing enum values            |
+| Interface  | `interfaceNameCompare(a: InterfaceName, b: InterfaceName): number` | Standalone function comparing fields                 |
+| Type Alias | `typeNameCompare(a: TypeName, b: TypeName): number`                | Standalone function with type-appropriate comparison |
 
 ## Return Values
 
-Unlike `PartialOrd`, `Ord` provides **total ordering** - every pair of values
-can be compared:
+Unlike `PartialOrd`, `Ord` provides **total ordering** - every pair of values can be compared:
 
 - **-1**: `a` is less than `b`
 - **0**: `a` is equal to `b`
@@ -36,14 +34,14 @@ Fields are compared **lexicographically** in declaration order:
 
 ## Type-Specific Comparisons
 
-| Type | Comparison Method |
-|------|-------------------|
-| `number`/`bigint` | Direct `<` and `>` comparison |
-| `string` | `localeCompare()` (clamped to -1, 0, 1) |
-| `boolean` | false &lt; true |
-| Arrays | Lexicographic element-by-element |
-| `Date` | `getTime()` timestamp comparison |
-| Objects | Calls `compareTo()` if available, else 0 |
+| Type              | Comparison Method                        |
+| ----------------- | ---------------------------------------- |
+| `number`/`bigint` | Direct `<` and `>` comparison            |
+| `string`          | `localeCompare()` (clamped to -1, 0, 1)  |
+| `boolean`         | false &lt; true                          |
+| Arrays            | Lexicographic element-by-element         |
+| `Date`            | `getTime()` timestamp comparison         |
+| Objects           | Calls `compareTo()` if available, else 0 |
 
 ## Field-Level Options
 

package/docs/builtin-macros/partial-eq.md

@@ -1,17 +1,17 @@
 # PartialEq
 
-The `PartialEq` macro generates an `equals()` method for field-by-field
-structural equality comparison. This is analogous to Rust's `PartialEq` trait,
-enabling value-based equality semantics instead of reference equality.
+The `PartialEq` macro generates an `equals()` method for field-by-field structural equality
+comparison. This is analogous to Rust's `PartialEq` trait, enabling value-based equality semantics
+instead of reference equality.
 
 ## Generated Output
 
-| Type | Generated Code | Description |
-|------|----------------|-------------|
-| Class | `classNameEquals(a, b)` + `static equals(a, b)` | Standalone function + static wrapper method |
-| Enum | `enumNameEquals(a: EnumName, b: EnumName): boolean` | Standalone function using strict equality |
-| Interface | `interfaceNameEquals(a: InterfaceName, b: InterfaceName): boolean` | Standalone function comparing fields |
-| Type Alias | `typeNameEquals(a: TypeName, b: TypeName): boolean` | Standalone function with type-appropriate comparison |
+| Type       | Generated Code                                                     | Description                                          |
+| ---------- | ------------------------------------------------------------------ | ---------------------------------------------------- |
+| Class      | `classNameEquals(a, b)` + `static equals(a, b)`                    | Standalone function + static wrapper method          |
+| Enum       | `enumNameEquals(a: EnumName, b: EnumName): boolean`                | Standalone function using strict equality            |
+| Interface  | `interfaceNameEquals(a: InterfaceName, b: InterfaceName): boolean` | Standalone function comparing fields                 |
+| Type Alias | `typeNameEquals(a: TypeName, b: TypeName): boolean`                | Standalone function with type-appropriate comparison |
 
 ## Comparison Strategy
 
@@ -22,14 +22,14 @@ The generated equality check:
 
 ## Type-Specific Comparisons
 
-| Type | Comparison Method |
-|------|-------------------|
-| Primitives | Strict equality (`===`) |
-| Arrays | Length + element-by-element (recursive) |
-| `Date` | `getTime()` comparison |
-| `Map` | Size + entry-by-entry comparison |
-| `Set` | Size + membership check |
-| Objects | Calls `equals()` if available, else `===` |
+| Type       | Comparison Method                         |
+| ---------- | ----------------------------------------- |
+| Primitives | Strict equality (`===`)                   |
+| Arrays     | Length + element-by-element (recursive)   |
+| `Date`     | `getTime()` comparison                    |
+| `Map`      | Size + entry-by-entry comparison          |
+| `Set`      | Size + membership check                   |
+| Objects    | Calls `equals()` if available, else `===` |
 
 ## Field-Level Options
 
@@ -73,18 +73,14 @@ export function userEquals(a: User, b: User): boolean {
 
 export function userHashCode(value: User): number {
     let hash = 17;
-    hash =
-        (hash * 31 +
-            (Number.isInteger(value.id)
-                ? value.id | 0
-                : value.id
-                      .toString()
-                      .split('')
-                      .reduce((h, c) => (h * 31 + c.charCodeAt(0)) | 0, 0))) |
+    hash = (hash * 31 +
+        (Number.isInteger(value.id) ? value.id | 0 : value.id
+            .toString()
+            .split('')
+            .reduce((h, c) => (h * 31 + c.charCodeAt(0)) | 0, 0))) |
         0;
-    hash =
-        (hash * 31 +
-            (value.name ?? '').split('').reduce((h, c) => (h * 31 + c.charCodeAt(0)) | 0, 0)) |
+    hash = (hash * 31 +
+        (value.name ?? '').split('').reduce((h, c) => (h * 31 + c.charCodeAt(0)) | 0, 0)) |
         0;
     return hash;
 }
@@ -134,18 +130,14 @@ export function userEquals(a: User, b: User): boolean {
 
 export function userHashCode(value: User): number {
     let hash = 17;
-    hash =
-        (hash * 31 +
-            (Number.isInteger(value.id)
-                ? value.id | 0
-                : value.id
-                      .toString()
-                      .split('')
-                      .reduce((h, c) => (h * 31 + c.charCodeAt(0)) | 0, 0))) |
+    hash = (hash * 31 +
+        (Number.isInteger(value.id) ? value.id | 0 : value.id
+            .toString()
+            .split('')
+            .reduce((h, c) => (h * 31 + c.charCodeAt(0)) | 0, 0))) |
         0;
-    hash =
-        (hash * 31 +
-            (value.name ?? '').split('').reduce((h, c) => (h * 31 + c.charCodeAt(0)) | 0, 0)) |
+    hash = (hash * 31 +
+        (value.name ?? '').split('').reduce((h, c) => (h * 31 + c.charCodeAt(0)) | 0, 0)) |
         0;
     return hash;
 }

package/docs/builtin-macros/partial-ord.md

@@ -1,17 +1,17 @@
 # PartialOrd
 
-The `PartialOrd` macro generates a `compareTo()` method for **partial ordering**
-comparison. This is analogous to Rust's `PartialOrd` trait, enabling comparison
-between values where some pairs may be incomparable.
+The `PartialOrd` macro generates a `compareTo()` method for **partial ordering** comparison. This is
+analogous to Rust's `PartialOrd` trait, enabling comparison between values where some pairs may be
+incomparable.
 
 ## Generated Output
 
-| Type | Generated Code | Description |
-|------|----------------|-------------|
-| Class | `classNamePartialCompare(a, b)` + `static compareTo(a, b)` | Standalone function + static wrapper method |
-| Enum | `enumNamePartialCompare(a: EnumName, b: EnumName): Option<number>` | Standalone function returning Option |
-| Interface | `interfaceNamePartialCompare(a: InterfaceName, b: InterfaceName): Option<number>` | Standalone function with Option |
-| Type Alias | `typeNamePartialCompare(a: TypeName, b: TypeName): Option<number>` | Standalone function with Option |
+| Type       | Generated Code                                                                    | Description                                 |
+| ---------- | --------------------------------------------------------------------------------- | ------------------------------------------- |
+| Class      | `classNamePartialCompare(a, b)` + `static compareTo(a, b)`                        | Standalone function + static wrapper method |
+| Enum       | `enumNamePartialCompare(a: EnumName, b: EnumName): Option<number>`                | Standalone function returning Option        |
+| Interface  | `interfaceNamePartialCompare(a: InterfaceName, b: InterfaceName): Option<number>` | Standalone function with Option             |
+| Type Alias | `typeNamePartialCompare(a: TypeName, b: TypeName): Option<number>`                | Standalone function with Option             |
 
 ## Return Values
 
@@ -43,15 +43,15 @@ Fields are compared **lexicographically** in declaration order:
 
 ## Type-Specific Comparisons
 
-| Type | Comparison Method |
-|------|-------------------|
-| `number`/`bigint` | Direct comparison, returns some() |
-| `string` | `localeCompare()` wrapped in some() |
-| `boolean` | false &lt; true, wrapped in some() |
-| null/undefined | Returns none() for mismatched nullability |
-| Arrays | Lexicographic, propagates none() on incomparable elements |
-| `Date` | Timestamp comparison, none() if invalid |
-| Objects | Unwraps nested Option from compareTo() |
+| Type              | Comparison Method                                         |
+| ----------------- | --------------------------------------------------------- |
+| `number`/`bigint` | Direct comparison, returns some()                         |
+| `string`          | `localeCompare()` wrapped in some()                       |
+| `boolean`         | false &lt; true, wrapped in some()                        |
+| null/undefined    | Returns none() for mismatched nullability                 |
+| Arrays            | Lexicographic, propagates none() on incomparable elements |
+| `Date`            | Timestamp comparison, none() if invalid                   |
+| Objects           | Unwraps nested Option from compareTo()                    |
 
 ## Field-Level Options
 

package/docs/builtin-macros/serialize.md

@@ -1,17 +1,17 @@
 # Serialize
 
-The `Serialize` macro generates JSON serialization methods with **cycle detection**
-and object identity tracking. This enables serialization of complex object graphs
-including circular references.
+The `Serialize` macro generates JSON serialization methods with **cycle detection** and object
+identity tracking. This enables serialization of complex object graphs including circular
+references.
 
 ## Generated Methods
 
-| Type | Generated Code | Description |
-|------|----------------|-------------|
-| Class | `classNameSerialize(value)` + `static serialize(value)` | Standalone function + static wrapper method |
-| Enum | `enumNameSerialize(value)`, `enumNameSerializeWithContext` | Standalone functions |
-| Interface | `interfaceNameSerialize(value)`, etc. | Standalone functions |
-| Type Alias | `typeNameSerialize(value)`, etc. | Standalone functions |
+| Type       | Generated Code                                             | Description                                 |
+| ---------- | ---------------------------------------------------------- | ------------------------------------------- |
+| Class      | `classNameSerialize(value)` + `static serialize(value)`    | Standalone function + static wrapper method |
+| Enum       | `enumNameSerialize(value)`, `enumNameSerializeWithContext` | Standalone functions                        |
+| Interface  | `interfaceNameSerialize(value)`, etc.                      | Standalone functions                        |
+| Type Alias | `typeNameSerialize(value)`, etc.                           | Standalone functions                        |
 
 ## Cycle Detection Protocol
 
@@ -22,29 +22,30 @@ The generated code handles circular references using `__id` and `__ref` markers:
     "__type": "User",
     "__id": 1,
     "name": "Alice",
-    "friend": { "__ref": 2 }  // Reference to object with __id: 2
+    "friend": { "__ref": 2 } // Reference to object with __id: 2
 }
 ```
 
 When an object is serialized:
+
 1. Check if it's already been serialized (has an `__id`)
 2. If so, return `{ "__ref": existingId }` instead
 3. Otherwise, register the object and serialize its fields
 
 ## Type-Specific Serialization
 
-| Type | Serialization Strategy |
-|------|------------------------|
-| Primitives | Direct value |
-| `Date` | `toISOString()` |
-| Arrays | For primitive-like element types, pass through; for `Date`/`Date | null`, map to ISO strings; otherwise map and call `SerializeWithContext(ctx)` when available |
-| `Map<K,V>` | For primitive-like values, `Object.fromEntries(map.entries())`; for `Date`/`Date | null`, convert to ISO strings; otherwise call `SerializeWithContext(ctx)` per value when available |
-| `Set<T>` | Convert to array; element handling matches `Array<T>` |
-| Nullable | Include `null` explicitly; for primitive-like and `Date` unions the generator avoids runtime `SerializeWithContext` checks |
-| Objects | Call `SerializeWithContext(ctx)` if available (to support user-defined implementations) |
-
-Note: the generator specializes some code paths based on the declared TypeScript type to
-avoid runtime feature detection on primitives and literal unions.
+| Type       | Serialization Strategy                                                                                                     |
+| ---------- | -------------------------------------------------------------------------------------------------------------------------- |
+| Primitives | Direct value                                                                                                               |
+| `Date`     | `toISOString()`                                                                                                            |
+| Arrays     | For primitive-like element types, pass through; for `Date`/`Date                                                           |
+| `Map<K,V>` | For primitive-like values, `Object.fromEntries(map.entries())`; for `Date`/`Date                                           |
+| `Set<T>`   | Convert to array; element handling matches `Array<T>`                                                                      |
+| Nullable   | Include `null` explicitly; for primitive-like and `Date` unions the generator avoids runtime `SerializeWithContext` checks |
+| Objects    | Call `SerializeWithContext(ctx)` if available (to support user-defined implementations)                                    |
+
+Note: the generator specializes some code paths based on the declared TypeScript type to avoid
+runtime feature detection on primitives and literal unions.
 
 ## Field-Level Options
 

package/docs/sections.json

@@ -1,127 +1,127 @@
 [
-  {
-    "id": "debug",
-    "title": "Debug",
-    "category": "builtin-macros",
-    "category_title": "Built-in Macros",
-    "path": "builtin-macros/debug.md",
-    "use_cases": "toString, debugging, logging, output, print"
-  },
-  {
-    "id": "clone",
-    "title": "Clone",
-    "category": "builtin-macros",
-    "category_title": "Built-in Macros",
-    "path": "builtin-macros/clone.md",
-    "use_cases": "copy, clone, duplicate, shallow copy, immutable"
-  },
-  {
-    "id": "default",
-    "title": "Default",
-    "category": "builtin-macros",
-    "category_title": "Built-in Macros",
-    "path": "builtin-macros/default.md",
-    "use_cases": "default values, factory, initialization, constructor"
-  },
-  {
-    "id": "hash",
-    "title": "Hash",
-    "category": "builtin-macros",
-    "category_title": "Built-in Macros",
-    "path": "builtin-macros/hash.md",
-    "use_cases": "hashCode, hashing, hash map, equality, hash function"
-  },
-  {
-    "id": "ord",
-    "title": "Ord",
-    "category": "builtin-macros",
-    "category_title": "Built-in Macros",
-    "path": "builtin-macros/ord.md",
-    "use_cases": "compareTo, ordering, sorting, comparison, total order"
-  },
-  {
-    "id": "partial-eq",
-    "title": "PartialEq",
-    "category": "builtin-macros",
-    "category_title": "Built-in Macros",
-    "path": "builtin-macros/partial-eq.md",
-    "use_cases": "equals, equality, comparison, value equality"
-  },
-  {
-    "id": "partial-ord",
-    "title": "PartialOrd",
-    "category": "builtin-macros",
-    "category_title": "Built-in Macros",
-    "path": "builtin-macros/partial-ord.md",
-    "use_cases": "compareTo, partial ordering, sorting, nullable comparison"
-  },
-  {
-    "id": "serialize",
-    "title": "Serialize",
-    "category": "builtin-macros",
-    "category_title": "Built-in Macros",
-    "path": "builtin-macros/serialize.md",
-    "use_cases": "toJSON, serialization, json, api, data transfer"
-  },
-  {
-    "id": "deserialize/overview",
-    "title": "Deserialize: Overview",
-    "category": "builtin-macros",
-    "category_title": "Built-in Macros",
-    "path": "builtin-macros/deserialize/overview.md",
-    "use_cases": "fromJSON, deserialization, deserialize, classnamedeserialize(input), enumnamedeserialize(input)",
-    "parent_id": "deserialize"
-  },
-  {
-    "id": "deserialize/cycleforward-reference-support",
-    "title": "Deserialize: Cycle/Forward-Reference Support",
-    "category": "builtin-macros",
-    "category_title": "Built-in Macros",
-    "path": "builtin-macros/deserialize/cycleforward-reference-support.md",
-    "use_cases": "fromJSON, deserialization, pendingref, ctx.applypatches(), __ref",
-    "parent_id": "deserialize"
-  },
-  {
-    "id": "deserialize/validation",
-    "title": "Deserialize: Validation",
-    "category": "builtin-macros",
-    "category_title": "Built-in Macros",
-    "path": "builtin-macros/deserialize/validation.md",
-    "use_cases": "fromJSON, deserialization, @serde(validate(...)), email, url, uuid",
-    "parent_id": "deserialize"
-  },
-  {
-    "id": "deserialize/union-type-deserialization",
-    "title": "Deserialize: Union Type Deserialization",
-    "category": "builtin-macros",
-    "category_title": "Built-in Macros",
-    "path": "builtin-macros/deserialize/union-type-deserialization.md",
-    "use_cases": "fromJSON, deserialization, typeof, __type",
-    "parent_id": "deserialize"
-  },
-  {
-    "id": "deserialize/example",
-    "title": "Deserialize: Example",
-    "category": "builtin-macros",
-    "category_title": "Built-in Macros",
-    "path": "builtin-macros/deserialize/example.md",
-    "use_cases": "fromJSON, deserialization",
-    "parent_id": "deserialize"
-  },
-  {
-    "id": "deserialize",
-    "title": "Deserialize",
-    "category": "builtin-macros",
-    "category_title": "Built-in Macros",
-    "path": "builtin-macros/deserialize.md",
-    "use_cases": "fromJSON, deserialization, parsing, validation, json",
-    "is_chunked": true,
-    "chunk_ids": [
-      "deserialize/overview",
-      "deserialize/cycleforward-reference-support",
-      "deserialize/validation",
-      "deserialize/union-type-deserialization",
-      "deserialize/example"
-    ]
-  }
-]
+    {
+        "id": "debug",
+        "title": "Debug",
+        "category": "builtin-macros",
+        "category_title": "Built-in Macros",
+        "path": "builtin-macros/debug.md",
+        "use_cases": "toString, debugging, logging, output, print"
+    },
+    {
+        "id": "clone",
+        "title": "Clone",
+        "category": "builtin-macros",
+        "category_title": "Built-in Macros",
+        "path": "builtin-macros/clone.md",
+        "use_cases": "copy, clone, duplicate, shallow copy, immutable"
+    },
+    {
+        "id": "default",
+        "title": "Default",
+        "category": "builtin-macros",
+        "category_title": "Built-in Macros",
+        "path": "builtin-macros/default.md",
+        "use_cases": "default values, factory, initialization, constructor"
+    },
+    {
+        "id": "hash",
+        "title": "Hash",
+        "category": "builtin-macros",
+        "category_title": "Built-in Macros",
+        "path": "builtin-macros/hash.md",
+        "use_cases": "hashCode, hashing, hash map, equality, hash function"
+    },
+    {
+        "id": "ord",
+        "title": "Ord",
+        "category": "builtin-macros",
+        "category_title": "Built-in Macros",
+        "path": "builtin-macros/ord.md",
+        "use_cases": "compareTo, ordering, sorting, comparison, total order"
+    },
+    {
+        "id": "partial-eq",
+        "title": "PartialEq",
+        "category": "builtin-macros",
+        "category_title": "Built-in Macros",
+        "path": "builtin-macros/partial-eq.md",
+        "use_cases": "equals, equality, comparison, value equality"
+    },
+    {
+        "id": "partial-ord",
+        "title": "PartialOrd",
+        "category": "builtin-macros",
+        "category_title": "Built-in Macros",
+        "path": "builtin-macros/partial-ord.md",
+        "use_cases": "compareTo, partial ordering, sorting, nullable comparison"
+    },
+    {
+        "id": "serialize",
+        "title": "Serialize",
+        "category": "builtin-macros",
+        "category_title": "Built-in Macros",
+        "path": "builtin-macros/serialize.md",
+        "use_cases": "toJSON, serialization, json, api, data transfer"
+    },
+    {
+        "id": "deserialize/overview",
+        "title": "Deserialize: Overview",
+        "category": "builtin-macros",
+        "category_title": "Built-in Macros",
+        "path": "builtin-macros/deserialize/overview.md",
+        "use_cases": "fromJSON, deserialization, deserialize, classnamedeserialize(input), enumnamedeserialize(input)",
+        "parent_id": "deserialize"
+    },
+    {
+        "id": "deserialize/cycleforward-reference-support",
+        "title": "Deserialize: Cycle/Forward-Reference Support",
+        "category": "builtin-macros",
+        "category_title": "Built-in Macros",
+        "path": "builtin-macros/deserialize/cycleforward-reference-support.md",
+        "use_cases": "fromJSON, deserialization, pendingref, ctx.applypatches(), __ref",
+        "parent_id": "deserialize"
+    },
+    {
+        "id": "deserialize/validation",
+        "title": "Deserialize: Validation",
+        "category": "builtin-macros",
+        "category_title": "Built-in Macros",
+        "path": "builtin-macros/deserialize/validation.md",
+        "use_cases": "fromJSON, deserialization, @serde(validate(...)), email, url, uuid",
+        "parent_id": "deserialize"
+    },
+    {
+        "id": "deserialize/union-type-deserialization",
+        "title": "Deserialize: Union Type Deserialization",
+        "category": "builtin-macros",
+        "category_title": "Built-in Macros",
+        "path": "builtin-macros/deserialize/union-type-deserialization.md",
+        "use_cases": "fromJSON, deserialization, typeof, __type",
+        "parent_id": "deserialize"
+    },
+    {
+        "id": "deserialize/example",
+        "title": "Deserialize: Example",
+        "category": "builtin-macros",
+        "category_title": "Built-in Macros",
+        "path": "builtin-macros/deserialize/example.md",
+        "use_cases": "fromJSON, deserialization",
+        "parent_id": "deserialize"
+    },
+    {
+        "id": "deserialize",
+        "title": "Deserialize",
+        "category": "builtin-macros",
+        "category_title": "Built-in Macros",
+        "path": "builtin-macros/deserialize.md",
+        "use_cases": "fromJSON, deserialization, parsing, validation, json",
+        "is_chunked": true,
+        "chunk_ids": [
+            "deserialize/overview",
+            "deserialize/cycleforward-reference-support",
+            "deserialize/validation",
+            "deserialize/union-type-deserialization",
+            "deserialize/example"
+        ]
+    }
+]

package/package.json

@@ -25,7 +25,7 @@
   "main": "dist/index.js",
   "name": "@macroforge/mcp-server",
   "peerDependencies": {
-    "macroforge": "^0.1.74"
+    "macroforge": "^0.1.75"
   },
   "peerDependenciesMeta": {
     "macroforge": {
@@ -46,5 +46,5 @@
     "test": "node --test tests/**/*.test.js"
   },
   "type": "module",
-  "version": "0.1.74"
+  "version": "0.1.75"
 }