Crate typewriter_engine 

typewriter-engine

Shared parser/emitter engine used by both proc-macro and CLI flows.

This crate provides the core functionality for the typewriter type synchronization SDK:

• Scanning: Discovers #[derive(TypeWriter)] items in Rust source files
• Parsing: Converts Rust AST (syn) into language-agnostic IR (Internal Representation)
• Rendering: Generates type definitions for target languages (TypeScript, Python, Go, etc.)
• Drift Detection: Compares expected generated output with actual on-disk files

Architecture

┌─────────────────┐     ┌─────────────┐     ┌─────────┐
│  Rust Source     │────▶│  Scanner    │────▶│  Parser │
│  (.rs files)     │     │  (scan.rs)  │     │(parser) │
└─────────────────┘     └─────────────┘     └────┬────┘
                                                  │
                                                  ▼
┌─────────────────┐     ┌─────────────┐     ┌─────────┐
│  Generated Files │◀────│  Writer     │◀────│   IR    │
│  (.ts, .py, ...) │     │  (emit.rs)  │     │  Types  │
└─────────────────┘     └─────────────┘     └─────────┘

Modules

• scan - Source file discovery and TypeWriter item detection
• parser - syn DeriveInput → IR type conversion
• emit - IR → target language type rendering and file writing
• drift - Drift detection between expected and actual generated files
• project - Project root and configuration discovery

Usage

CLI Usage

use typewriter_engine::{scan, emit, project};

// Discover project root and load config
let project_root = project::discover_project_root(&std::env::current_dir()?)?;
let config = project::load_config(&project_root)?;

// Scan for TypeWriter definitions
let specs = scan::scan_project(&project_root)?;

// Render to all target languages
let files = emit::render_specs_deduped(&specs, &project_root, &config, &[], false)?;

// Write generated files
emit::write_generated_files(&files)?;

Library Usage

use typewriter_engine::{TypeSpec, Language, TypeDef};
use typewriter_core::ir::{StructDef, TypeDef};

// Create a type spec manually
let spec = TypeSpec {
    type_def: TypeDef::Struct(StructDef { ... }),
    targets: vec![Language::TypeScript, Language::Python],
    source_path: PathBuf::from("src/models.rs"),
    zod_schema: None,
};

Modules

drift

Drift detection between expected generated output and on-disk files.

emit

Render and write generated output files for target languages.

parser

Parser: converts Rust AST (syn) into typewriter IR (TypeDef).

project

Project root and configuration discovery utilities.

scan

Source scanning for #[derive(TypeWriter)] items.

Structs

TypeSpec

Parsed TypeWriter definition discovered in a Rust source file.

TypewriterConfig

Top-level configuration from typewriter.toml.

Enums

Language

The target languages that typewriter can generate code for.

TypeDef

Top-level item — either a struct or an enum.

Functions

all_languages

Returns a vector of all supported languages.

parse_languages

Parse a comma-separated or list of language names (case-insensitive) into Language values.