@macroforge/mcp-server 0.1.65 → 0.1.72

package/docs/builtin-macros/partial-eq/overview.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 | `equals(other: unknown): boolean` | Instance method with instanceof check |
-| Enum | `equalsEnumName(a: EnumName, b: EnumName): boolean` | Standalone function using strict equality |
-| Interface | `equalsInterfaceName(a: InterfaceName, b: InterfaceName): boolean` | Standalone function comparing fields |
-| Type Alias | `equalsTypeName(a: TypeName, b: TypeName): boolean` | Standalone function with type-appropriate comparison |
+| Type       | Generated Code                                                     | Description                                          |
+| ---------- | ------------------------------------------------------------------ | ---------------------------------------------------- |
+| Class      | `equals(other: unknown): boolean`                                  | Instance method with instanceof check                |
+| Enum       | `equalsEnumName(a: EnumName, b: EnumName): boolean`                | Standalone function using strict equality            |
+| Interface  | `equalsInterfaceName(a: InterfaceName, b: InterfaceName): boolean` | Standalone function comparing fields                 |
+| Type Alias | `equalsTypeName(a: TypeName, b: TypeName): boolean`                | Standalone function with type-appropriate comparison |
 
 ## Comparison Strategy
 
@@ -23,17 +23,17 @@ 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
 
 The `@partialEq` decorator supports:
 
-- `skip` - Exclude the field from equality comparison
+- `skip` - Exclude the field from equality comparison

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

@@ -38,7 +38,10 @@ class User {
 @param value - The value to serialize
 @param ctx - The serialization context  */
 
-    static serializeWithContext(value: User, ctx: SerializeContext): Record<string, unknown> {
+    static serializeWithContext(
+        value: User,
+        ctx: SerializeContext
+    ): Record<string, unknown> {
         return userSerializeWithContext(value, ctx);
     }
 }
@@ -53,6 +56,7 @@ class User {
 } /** @internal Serializes with an existing context for nested/cyclic object graphs.
 @param value - The value to serialize
 @param ctx - The serialization context */
+
 export function userSerializeWithContext(
     value: User,
     ctx: SerializeContext
@@ -98,7 +102,10 @@ class User {
 @param value - The value to serialize
 @param ctx - The serialization context  */
 
-    static serializeWithContext(value: User, ctx: SerializeContext): Record<string, unknown> {
+    static serializeWithContext(
+        value: User,
+        ctx: SerializeContext
+    ): Record<string, unknown> {
         return userSerializeWithContext(value, ctx);
     }
 }
@@ -113,6 +120,7 @@ class User {
 } /** @internal Serializes with an existing context for nested/cyclic object graphs.
 @param value - The value to serialize
 @param ctx - The serialization context */
+
 export function userSerializeWithContext(
     value: User,
     ctx: SerializeContext
@@ -136,4 +144,4 @@ export function userSerializeWithContext(
 
 ## Required Import
 
-The generated code automatically imports `SerializeContext` from `macroforge/serde`.
+The generated code automatically imports `SerializeContext` from `macroforge/serde`.

package/docs/builtin-macros/serialize/overview.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,11 +22,12 @@ 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
+3. Otherwise, register the object and serialize its fields

package/docs/builtin-macros/serialize/type-specific-serialization.md

@@ -1,17 +1,17 @@
 ## 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) |
+| 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.
+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
 
@@ -19,4 +19,4 @@ The `@serde` decorator supports:
 
 - `skip` / `skipSerializing` - Exclude field from serialization
 - `rename = "jsonKey"` - Use different JSON property name
-- `flatten` - Merge nested object's fields into parent
+- `flatten` - Merge nested object's fields into parent

package/docs/concepts/architecture.md

@@ -1,6 +1,7 @@
 # Architecture
 
-Macroforge is built as a native Node.js module using Rust and NAPI-RS. It leverages SWC for fast TypeScript parsing and code generation.
+Macroforge is built as a native Node.js module using Rust and NAPI-RS. It leverages SWC for fast
+TypeScript parsing and code generation.
 
 ## Overview
 
@@ -26,41 +27,41 @@ TypeScript parsing & codegen
 
 The foundation layer provides:
 
-*   Fast TypeScript/JavaScript parsing
-*   AST representation
-*   Code generation (AST → source code)
+- Fast TypeScript/JavaScript parsing
+- AST representation
+- Code generation (AST → source code)
 
 ### macroforge\_ts\_syn
 
 A Rust crate that provides:
 
-*   TypeScript-specific AST types
-*   Parsing utilities for macro input
-*   Derive input structures (class fields, decorators, etc.)
+- TypeScript-specific AST types
+- Parsing utilities for macro input
+- Derive input structures (class fields, decorators, etc.)
 
 ### macroforge\_ts\_quote
 
 Template-based code generation similar to Rust's `quote!`:
 
-*   `ts_template!` - Generate TypeScript code from templates
-*   `body!` - Generate class body members
-*   Control flow: `{"{#for}"}`, `{"{#if}"}`, `{"{$let}"}`
+- `ts_template!` - Generate TypeScript code from templates
+- `body!` - Generate class body members
+- Control flow: `{"{#for}"}`, `{"{#if}"}`, `{"{$let}"}`
 
 ### macroforge\_ts\_macros
 
 The procedural macro attribute for defining derive macros:
 
-*   `#[ts_macro_derive(Name)]` attribute
-*   Automatic registration with the macro system
-*   Error handling and span tracking
+- `#[ts_macro_derive(Name)]` attribute
+- Automatic registration with the macro system
+- Error handling and span tracking
 
 ### NAPI-RS Bindings
 
 Bridges Rust and Node.js:
 
-*   Exposes `expandSync`, `transformSync`, etc.
-*   Provides the `NativePlugin` class for caching
-*   Handles data marshaling between Rust and JavaScript
+- Exposes `expandSync`, `transformSync`, etc.
+- Provides the `NativePlugin` class for caching
+- Handles data marshaling between Rust and JavaScript
 
 ## Data Flow
 
@@ -98,10 +99,10 @@ to JavaScript with source mapping
 
 ## Performance Characteristics
 
-*   **Thread-safe**: Each expansion runs in an isolated thread with a 32MB stack
-*   **Caching**: `NativePlugin` caches results by file version
-*   **Binary search**: Position mapping uses O(log n) lookups
-*   **Zero-copy**: SWC's arena allocator minimizes allocations
+- **Thread-safe**: Each expansion runs in an isolated thread with a 32MB stack
+- **Caching**: `NativePlugin` caches results by file version
+- **Binary search**: Position mapping uses O(log n) lookups
+- **Zero-copy**: SWC's arena allocator minimizes allocations
 
 ## Re-exported Crates
 
@@ -122,5 +123,5 @@ use macroforge_ts::swc_ecma_ast;
 
 ## Next Steps
 
-*   [Write custom macros](../../docs/custom-macros)
-*   [Explore the API reference](../../docs/api)
+- [Write custom macros](../../docs/custom-macros)
+- [Explore the API reference](../../docs/api)

package/docs/concepts/derive-system/built-in-vs-custom-macros.md

@@ -1,6 +1,7 @@
 ## Built-in vs Custom Macros
 
-Macroforge comes with built-in macros that work out of the box. You can also create custom macros in Rust and use them via the `import macro` statement.
+Macroforge comes with built-in macros that work out of the box. You can also create custom macros in
+Rust and use them via the `import macro` statement.
 
 | Type     | Import Required | Examples                                                                        |
 | -------- | --------------- | ------------------------------------------------------------------------------- |
@@ -9,5 +10,5 @@ Macroforge comes with built-in macros that work out of the box. You can also cre
 
 ## Next Steps
 
-*   [Explore built-in macros](../../docs/builtin-macros)
-*   [Create custom macros](../../docs/custom-macros)
+- [Explore built-in macros](../../docs/builtin-macros)
+- [Create custom macros](../../docs/custom-macros)

package/docs/concepts/derive-system/overview.md

@@ -1,10 +1,12 @@
 # The Derive System
 
-The derive system is inspired by Rust's derive macros. It allows you to automatically implement common patterns by annotating your classes with `@derive`.
+The derive system is inspired by Rust's derive macros. It allows you to automatically implement
+common patterns by annotating your classes with `@derive`.
 
 ## Syntax Reference
 
-Macroforge uses JSDoc comments for all macro annotations. This ensures compatibility with standard TypeScript tooling.
+Macroforge uses JSDoc comments for all macro annotations. This ensures compatibility with standard
+TypeScript tooling.
 
 ### The @derive Statement
 
@@ -23,10 +25,10 @@ class MyClass {
 
 Syntax rules:
 
-*   Must be inside a JSDoc comment (`/** */`)
-*   Must appear immediately before the class/interface declaration
-*   Multiple macros can be comma-separated: `@derive(A, B, C)`
-*   Multiple `@derive` statements can be stacked
+- Must be inside a JSDoc comment (`/** */`)
+- Must appear immediately before the class/interface declaration
+- Multiple macros can be comma-separated: `@derive(A, B, C)`
+- Multiple `@derive` statements can be stacked
 
 Source
 
@@ -52,10 +54,10 @@ TypeScript
 
 Syntax rules:
 
-*   Must be inside a JSDoc comment (`/** */`)
-*   Can appear anywhere in the file (typically at the top)
-*   Multiple macros can be imported: `import macro { A, B } from "pkg";`
-*   Multiple import statements can be used for different packages
+- Must be inside a JSDoc comment (`/** */`)
+- Can appear anywhere in the file (typically at the top)
+- Multiple macros can be imported: `import macro { A, B } from "pkg";`
+- Multiple import statements can be used for different packages
 
 TypeScript
 
@@ -72,7 +74,8 @@ class User {
 
 Built-in macros
 
-Built-in macros (Debug, Clone, Default, Hash, Ord, PartialEq, PartialOrd, Serialize, Deserialize) do not require an import statement.
+Built-in macros (Debug, Clone, Default, Hash, Ord, PartialEq, PartialOrd, Serialize, Deserialize) do
+not require an import statement.
 
 ### Field Attributes
 
@@ -167,11 +170,11 @@ export function userSerializeWithContext(
 
 Syntax rules:
 
-*   Must be inside a JSDoc comment immediately before the field
-*   Options use object literal syntax: `@attr({ key: value })`
-*   Boolean options: `@attr({ skip: true })`
-*   String options: `@attr({ rename: "newName" })`
-*   Multiple attributes can be on separate lines or combined
+- Must be inside a JSDoc comment immediately before the field
+- Options use object literal syntax: `@attr({ key: value })`
+- Boolean options: `@attr({ skip: true })`
+- String options: `@attr({ rename: "newName" })`
+- Multiple attributes can be on separate lines or combined
 
 Common field attributes by macro:
 
@@ -185,16 +188,16 @@ Common field attributes by macro:
 
 ## How It Works
 
-1.  **Declaration**: You write `@derive(MacroName)` before a class
-2.  **Discovery**: Macroforge finds all derive decorators in your code
-3.  **Expansion**: Each named macro receives the class AST and generates code
-4.  **Injection**: Generated methods/properties are added to the class
+1. **Declaration**: You write `@derive(MacroName)` before a class
+2. **Discovery**: Macroforge finds all derive decorators in your code
+3. **Expansion**: Each named macro receives the class AST and generates code
+4. **Injection**: Generated methods/properties are added to the class
 
 ## What Can Be Derived
 
 The derive system works on:
 
-*   **Classes**: The primary target for derive macros
-*   **Interfaces**: Macros generate companion namespace functions
-*   **Enums**: Macros generate namespace functions for enum values
-*   **Type aliases**: Both object types and union types are supported
+- **Classes**: The primary target for derive macros
+- **Interfaces**: Macros generate companion namespace functions
+- **Enums**: Macros generate namespace functions for enum values
+- **Type aliases**: Both object types and union types are supported

package/docs/concepts/derive-system.md

@@ -1,10 +1,12 @@
 # The Derive System
 
-The derive system is inspired by Rust's derive macros. It allows you to automatically implement common patterns by annotating your classes with `@derive`.
+The derive system is inspired by Rust's derive macros. It allows you to automatically implement
+common patterns by annotating your classes with `@derive`.
 
 ## Syntax Reference
 
-Macroforge uses JSDoc comments for all macro annotations. This ensures compatibility with standard TypeScript tooling.
+Macroforge uses JSDoc comments for all macro annotations. This ensures compatibility with standard
+TypeScript tooling.
 
 ### The @derive Statement
 
@@ -23,10 +25,10 @@ class MyClass {
 
 Syntax rules:
 
-*   Must be inside a JSDoc comment (`/** */`)
-*   Must appear immediately before the class/interface declaration
-*   Multiple macros can be comma-separated: `@derive(A, B, C)`
-*   Multiple `@derive` statements can be stacked
+- Must be inside a JSDoc comment (`/** */`)
+- Must appear immediately before the class/interface declaration
+- Multiple macros can be comma-separated: `@derive(A, B, C)`
+- Multiple `@derive` statements can be stacked
 
 Source
 
@@ -52,10 +54,10 @@ TypeScript
 
 Syntax rules:
 
-*   Must be inside a JSDoc comment (`/** */`)
-*   Can appear anywhere in the file (typically at the top)
-*   Multiple macros can be imported: `import macro { A, B } from "pkg";`
-*   Multiple import statements can be used for different packages
+- Must be inside a JSDoc comment (`/** */`)
+- Can appear anywhere in the file (typically at the top)
+- Multiple macros can be imported: `import macro { A, B } from "pkg";`
+- Multiple import statements can be used for different packages
 
 TypeScript
 
@@ -72,7 +74,8 @@ class User {
 
 Built-in macros
 
-Built-in macros (Debug, Clone, Default, Hash, Ord, PartialEq, PartialOrd, Serialize, Deserialize) do not require an import statement.
+Built-in macros (Debug, Clone, Default, Hash, Ord, PartialEq, PartialOrd, Serialize, Deserialize) do
+not require an import statement.
 
 ### Field Attributes
 
@@ -167,11 +170,11 @@ export function userSerializeWithContext(
 
 Syntax rules:
 
-*   Must be inside a JSDoc comment immediately before the field
-*   Options use object literal syntax: `@attr({ key: value })`
-*   Boolean options: `@attr({ skip: true })`
-*   String options: `@attr({ rename: "newName" })`
-*   Multiple attributes can be on separate lines or combined
+- Must be inside a JSDoc comment immediately before the field
+- Options use object literal syntax: `@attr({ key: value })`
+- Boolean options: `@attr({ skip: true })`
+- String options: `@attr({ rename: "newName" })`
+- Multiple attributes can be on separate lines or combined
 
 Common field attributes by macro:
 
@@ -185,23 +188,24 @@ Common field attributes by macro:
 
 ## How It Works
 
-1.  **Declaration**: You write `@derive(MacroName)` before a class
-2.  **Discovery**: Macroforge finds all derive decorators in your code
-3.  **Expansion**: Each named macro receives the class AST and generates code
-4.  **Injection**: Generated methods/properties are added to the class
+1. **Declaration**: You write `@derive(MacroName)` before a class
+2. **Discovery**: Macroforge finds all derive decorators in your code
+3. **Expansion**: Each named macro receives the class AST and generates code
+4. **Injection**: Generated methods/properties are added to the class
 
 ## What Can Be Derived
 
 The derive system works on:
 
-*   **Classes**: The primary target for derive macros
-*   **Interfaces**: Macros generate companion namespace functions
-*   **Enums**: Macros generate namespace functions for enum values
-*   **Type aliases**: Both object types and union types are supported
+- **Classes**: The primary target for derive macros
+- **Interfaces**: Macros generate companion namespace functions
+- **Enums**: Macros generate namespace functions for enum values
+- **Type aliases**: Both object types and union types are supported
 
 ## Built-in vs Custom Macros
 
-Macroforge comes with built-in macros that work out of the box. You can also create custom macros in Rust and use them via the `import macro` statement.
+Macroforge comes with built-in macros that work out of the box. You can also create custom macros in
+Rust and use them via the `import macro` statement.
 
 | Type     | Import Required | Examples                                                                        |
 | -------- | --------------- | ------------------------------------------------------------------------------- |
@@ -210,5 +214,5 @@ Macroforge comes with built-in macros that work out of the box. You can also cre
 
 ## Next Steps
 
-*   [Explore built-in macros](../../docs/builtin-macros)
-*   [Create custom macros](../../docs/custom-macros)
+- [Explore built-in macros](../../docs/builtin-macros)
+- [Create custom macros](../../docs/custom-macros)

package/docs/concepts/how-macros-work.md

@@ -1,15 +1,16 @@
 # How Macros Work
 
-Macroforge performs compile-time code generation by parsing your TypeScript, expanding macros, and outputting transformed code. This happens before your code runs, resulting in zero runtime overhead.
+Macroforge performs compile-time code generation by parsing your TypeScript, expanding macros, and
+outputting transformed code. This happens before your code runs, resulting in zero runtime overhead.
 
 ## Compile-Time Expansion
 
 Unlike runtime solutions that use reflection or proxies, Macroforge expands macros at compile time:
 
-1.  **Parse**: Your TypeScript code is parsed into an AST using SWC
-2.  **Find**: Macroforge finds `@derive` decorators and their associated items
-3.  **Expand**: Each macro generates new code based on the class structure
-4.  **Output**: The transformed TypeScript is written out, ready for normal compilation
+1. **Parse**: Your TypeScript code is parsed into an AST using SWC
+2. **Find**: Macroforge finds `@derive` decorators and their associated items
+3. **Expand**: Each macro generates new code based on the class structure
+4. **Output**: The transformed TypeScript is written out, ready for normal compilation
 
 Before (Your Code)
 
@@ -42,10 +43,10 @@ export function userToString(value: User): string {
 
 Because code generation happens at compile time, there's no:
 
-*   Runtime reflection or metadata
-*   Proxy objects or wrappers
-*   Additional dependencies in your bundle
-*   Performance cost at runtime
+- Runtime reflection or metadata
+- Proxy objects or wrappers
+- Additional dependencies in your bundle
+- Performance cost at runtime
 
 The generated code is plain TypeScript that compiles to efficient JavaScript.
 
@@ -53,13 +54,14 @@ The generated code is plain TypeScript that compiles to efficient JavaScript.
 
 Macroforge tracks the relationship between your source code and the expanded output. This means:
 
-*   Errors in generated code point back to your source
-*   Debugging works correctly
-*   IDE features like "go to definition" work as expected
+- Errors in generated code point back to your source
+- Debugging works correctly
+- IDE features like "go to definition" work as expected
 
 Error positioning
 
-The TypeScript plugin uses source mapping to show errors at the `@derive` decorator position, not in the generated code.
+The TypeScript plugin uses source mapping to show errors at the `@derive` decorator position, not in
+the generated code.
 
 ## Execution Flow
 
@@ -91,19 +93,19 @@ Macroforge integrates at two key points:
 
 The TypeScript plugin intercepts language server calls to provide:
 
-*   Diagnostics that reference your source, not expanded code
-*   Completions for generated methods
-*   Hover information showing what macros generate
+- Diagnostics that reference your source, not expanded code
+- Completions for generated methods
+- Hover information showing what macros generate
 
 ### Build (Vite Plugin)
 
 The Vite plugin runs macro expansion during the build process:
 
-*   Transforms files before they reach the TypeScript compiler
-*   Generates type declaration files (.d.ts)
-*   Produces metadata for debugging
+- Transforms files before they reach the TypeScript compiler
+- Generates type declaration files (.d.ts)
+- Produces metadata for debugging
 
 ## Next Steps
 
-*   [Learn about the derive system](../docs/concepts/derive-system)
-*   [Explore the architecture](../docs/concepts/architecture)
+- [Learn about the derive system](../docs/concepts/derive-system)
+- [Explore the architecture](../docs/concepts/architecture)

package/docs/custom-macros/custom-overview.md

@@ -1,15 +1,16 @@
 # Custom Macros
 
-Macroforge allows you to create custom derive macros in Rust. Your macros have full access to the class AST and can generate any TypeScript code.
+Macroforge allows you to create custom derive macros in Rust. Your macros have full access to the
+class AST and can generate any TypeScript code.
 
 ## Overview
 
 Custom macros are written in Rust and compiled to native Node.js addons. The process involves:
 
-1.  Creating a Rust crate with NAPI bindings
-2.  Defining macro functions with `#[ts_macro_derive]`
-3.  Using `macroforge_ts_quote` to generate TypeScript code
-4.  Building and publishing as an npm package
+1. Creating a Rust crate with NAPI bindings
+2. Defining macro functions with `#[ts_macro_derive]`
+3. Using `macroforge_ts_quote` to generate TypeScript code
+4. Building and publishing as an npm package
 
 ## Quick Example
 
@@ -78,6 +79,6 @@ The `import macro` comment tells Macroforge which package provides the macro.
 
 Follow these guides to create your own macros:
 
-*   [Set up a Rust macro crate](../docs/custom-macros/rust-setup)
-*   [Learn the #\[ts\_macro\_derive\] attribute](../docs/custom-macros/ts-macro-derive)
-*   [Learn the template syntax](../docs/custom-macros/ts-quote)
+- [Set up a Rust macro crate](../docs/custom-macros/rust-setup)
+- [Learn the #\[ts\_macro\_derive\] attribute](../docs/custom-macros/ts-macro-derive)
+- [Learn the template syntax](../docs/custom-macros/ts-quote)