High-performance DDEX XML builder and parser with native bindings for TypeScript/JavaScript and Python. Built on a single Rust core for consistent behavior across all platforms.

DDEX Suite brings together powerful tools for music industry data exchange, combining the robust ddex-parser library for reading and transforming DDEX messages with the ddex-builder library for deterministic XML generation, creating a complete round-trip solution for DDEX processing.

Working with DDEX XML shouldn't feel like archaeology. The suite transforms complex DDEX messages into clean, strongly-typed data structures that are as easy to work with as JSON.

• Single Rust Core: One implementation to rule them all - consistent behavior across JavaScript, Python, and Rust
• Dual Model Architecture: Choose between faithful graph representation or developer-friendly flattened view
• Production Ready: Built-in XXE protection, memory-bounded streaming, and comprehensive security hardening
• Deterministic Output: DB-C14N/1.0 canonicalization for byte-perfect reproducibility

I'm building DDEX Suite as a rigorous, end-to-end learning project to deepen my Rust skills while unifying my JavaScript and Python experience into a production-grade toolkit for music metadata. The intent is to ship a single Rust core that serves both a high-performance, security-hardened DDEX XML parser library (ddex-parser) and a byte-perfect, deterministic builder library (ddex-builder). This core is exposed through napi-rs for Node/TypeScript and PyO3 for Python, showcasing not just cross-language API design but also deep ecosystem integration, including a declarative DataFrame mapping DSL for Python users. The project is deliberately "industry-shaped," tackling the complementary challenges of transforming complex DDEX XML into clean models (parsing) and generating canonical, reproducible XML from those models. This is achieved through a dual graph+flattened data model for developer UX and an uncompromising approach to determinism, centered on a custom canonicalization specification, DB-C14N/1.0, and a stable, content-addressable ID generation engine.

Beyond the core implementation, this is a showcase of software craftsmanship and platform thinking. The suite provides consistent APIs, painless installation via prebuilt binaries, a hardened CI/CD pipeline, and robust supply-chain safety (SBOM, cargo-deny, and Sigstore artifact signing). Every feature reflects production wisdom—from the parser's XXE protection to the builder's versioned partner presets system with safety locks. Paired with my validator work (DDEX Workbench), DDEX Suite delivers a credible, end-to-end Parse → Modify → Build processing pipeline, complete with enterprise-grade features like preflight validation, a semantic diff engine, and a comprehensive CLI. It illustrates how to design interoperable components that are fast, safe, and easy to adopt in real-world systems.

Current Phase: Phase 4.3 - Perfect Fidelity Engine
Latest Release: Suite v0.2.5 🎉
Target Release: Suite v1.0.0 in Q4 2025

All packages published across npm, PyPI, and crates.io! ✅

✅ Phase 1-3: Complete - Core foundation, parser, and builder are fully implemented
✅ Phase 4.1: Integration Testing - Round-trip functionality validated with 94 tests passing
✅ crates.io Publishing - NEW! All Rust crates published to the official registry
✅ Phase 4.2: Documentation - Docusaurus site in React
🔄 Phase 4.3: Perfect Fidelity Engine - Round-trip, deterministic output

For detailed development progress and technical implementation details, see blueprint.md.

The suite provides two complementary views of the same data with full round-trip fidelity:

Preserves the exact DDEX structure with references and extensions - perfect for compliance and round-trip operations:

interface ERNMessage {
  messageHeader: MessageHeader;
  parties: Party[];               // All parties with IDs
  resources: Resource[];          // Audio, video, image resources
  releases: Release[];            // Release metadata with references
  deals: Deal[];                  // Commercial terms
  extensions?: Map<string, XmlFragment>;  // Preserved for round-trip
  toBuildRequest(): BuildRequest; // Convert to builder input
}

Denormalized and resolved for easy consumption - ideal for applications while maintaining round-trip capability:

interface ParsedRelease {
  releaseId: string;
  title: string;
  displayArtist: string;
  tracks: ParsedTrack[];          // Fully resolved with resources merged
  coverArt?: ParsedImage;
  _graph?: Release;               // Reference to original for full fidelity
  extensions?: Map<string, XmlFragment>; // Extensions preserved
}

New in v0.2.5: The Perfect Fidelity Engine ensures 100% round-trip preservation of DDEX XML with mathematical guarantees.

The DDEX Suite provides mathematically verifiable guarantees for XML processing:

∀ XML input X: canonicalize(build(parse(X))) = canonicalize(X)

Promise: Any valid DDEX XML file that goes through Parse → Build produces byte-identical output after canonicalization.

∀ data D, time T₁, T₂: build(D, T₁) = build(D, T₂)

Promise: Building the same data structure multiple times produces identical XML bytes, regardless of when or where it's executed.

∀ extensions E ⊆ X: E ⊆ build(parse(X))

Promise: All partner extensions (Spotify, Apple, YouTube, etc.) and custom namespaces are preserved with their original structure and attributes.

∀ business data B ⊆ X: B = extract_business_data(build(parse(X)))

Promise: All business-critical data (ISRCs, titles, artist names, deal terms) remains semantically identical after round-trip processing.

const fidelityOptions = {
  enable_perfect_fidelity: true,      // Master switch for all fidelity features
  preserve_comments: true,            // XML comments in original positions  
  preserve_processing_instructions: true, // Processing instructions
  preserve_extensions: true,          // Partner & custom extensions
  preserve_attribute_order: true,     // Original attribute ordering
  preserve_namespace_prefixes: true,  // Namespace prefix preservation
  canonicalization: 'DB-C14N',       // DDEX-specific canonicalization
  enable_verification: true,          // Automatic verification
  collect_statistics: true            // Performance monitoring
};

Every build operation can be verified automatically:

const builder = new DDEXBuilder().withPerfectFidelity();
const result = await builder.buildWithVerification(data);

console.log(`✅ Fidelity: ${result.verification.success ? 'PERFECT' : 'DEGRADED'}`);
console.log(`📐 Canonicalization: ${result.canonicalization_applied ? 'DB-C14N/1.0' : 'None'}`);
console.log(`🔍 Round-trip: ${result.verification.round_trip_success ? 'PASSED' : 'FAILED'}`);

• 🔒 Mathematical Guarantees: Verifiable round-trip fidelity with formal proofs
• 📐 DB-C14N/1.0 Canonicalization: DDEX-specific canonicalization for byte-perfect output
• 🔌 Extension Preservation: 100% preservation of Spotify, Apple, YouTube, Amazon extensions
• 💬 Comment & PI Preservation: XML comments and processing instructions in original positions
• 🏷️ Namespace Fidelity: Original namespace prefixes and declarations preserved
• ✅ Automatic Verification: Built-in round-trip verification with detailed reporting
• 📊 Fidelity Statistics: Comprehensive metrics and performance monitoring

• 🔄 Round-Trip Workflow: Parse → Modify → Build with 100% data preservation
• 🎭 Dual Model Architecture: Graph (faithful) and flattened (developer-friendly) views
• 🛡️ Enterprise Security: XXE protection, entity expansion limits, memory bounds
• ⚡ High Performance: Sub-millisecond processing for typical files
• 🌐 Multi-Platform: Native bindings for Node.js, Python, WASM, and Rust
• 🔗 Reference Linking: Automatic relationship resolution between entities
• 🆔 Stable Hash IDs: Content-based deterministic ID generation
• ✨ Multi-Version Support: ERN 3.8.2, 4.2, and 4.3 with automatic detection

• Partner Presets: Optimized configurations for YouTube (v1.1)
• Streaming: Handle massive catalogs with backpressure and progress callbacks
• Semantic Diff: Track changes between DDEX message versions
• Full Python Support: Complete PyPI release for parser

# JavaScript/TypeScript
npm install ddex-parser  # ✅ Latest: v0.2.5
npm install ddex-builder # ✅ Latest: v0.2.5

# Python
pip install ddex-parser  # ✅ Latest: v0.2.5
pip install ddex-builder # ✅ Latest: v0.2.5

# Rust ✅ NEW!
cargo add ddex-core      # ✅ Latest: v0.2.5
cargo add ddex-parser    # ✅ Latest: v0.2.5 
cargo add ddex-builder   # ✅ Latest: v0.2.5

import { DDEXParser } from 'ddex-parser';
import { DDEXBuilder } from 'ddex-builder';

// Parse DDEX message
const parser = new DDEXParser();
const result = await parser.parse(xmlContent);

// Modify the parsed data
result.flat.releases[0].title = "Updated Title";

// Build deterministic XML
const builder = new DDEXBuilder();
const xml = await builder.build(result.toBuildRequest());

// Perfect round-trip guarantee
const reparsed = await parser.parse(xml);
assert.deepEqual(reparsed.graph, result.graph); // ✅ Identical

from ddex_parser import DDEXParser
from ddex_builder import DDEXBuilder

# Parse DDEX message
parser = DDEXParser()
message = parser.parse(xml_content)

# Build DDEX from scratch
builder = DDEXBuilder()
xml = builder.build({
    'header': {
        'message_sender': {'party_name': [{'text': 'My Label'}]},
        'message_recipient': {'party_name': [{'text': 'YouTube'}]}
    },
    'version': '4.3',
    'releases': [{
        'release_id': '1234567890123',
        'title': [{'text': 'Amazing Album'}],
        'display_artist': 'Great Artist',
        'tracks': [
            {'position': 1, 'isrc': 'USXYZ2600001', 'title': 'Track 1', 'duration': 180}
        ]
    }]
})

use ddex_parser::DDEXParser;
use ddex_builder::DDEXBuilder;

// Parse DDEX message
let parser = DDEXParser::new();
let result = parser.parse(&xml_content)?;

// Modify the parsed data
let mut build_request = result.to_build_request();
build_request.releases[0].title = "Updated Title".to_string();

// Build deterministic XML
let builder = DDEXBuilder::new();
let xml = builder.build(&build_request)?;

// Perfect round-trip with Rust's type safety
let reparsed = parser.parse(&xml)?;
assert_eq!(reparsed.graph, result.graph); // ✅ Identical

Built as a monorepo with shared core components:

┌───────────────────────────────────────┐
│            DDEX Suite                 │
├─────────────────┬─────────────────────┤
│   DDEX Parser   │   DDEX Builder      │
│  Read & Parse   │  Generate & Build   │
├─────────────────┴─────────────────────┤
│           Shared Core                 │
│    Models │ Errors │ FFI │ Utils      │
├───────────────────────────────────────┤
│         Language Bindings             │
│   napi-rs │ PyO3 │ WASM │ CLI         │
└───────────────────────────────────────┘

• XXE (XML External Entity) protection
• Entity expansion limits (billion laughs protection)
• Deep nesting protection
• Size and timeout limits
• Memory-bounded streaming
• Supply chain security with cargo-deny and SBOM

• DB-C14N/1.0 Specification - DDEX-specific canonicalization standard
• Migration Guide - Upgrading to Perfect Fidelity Engine
• Performance Tuning Guide - Optimizing fidelity vs performance
• Perfect Fidelity Examples - Comprehensive usage examples

• Blueprint - Detailed architecture, roadmap, and technical implementation
• Parser API - Parser documentation
• Builder API - Builder documentation
• Round-Trip Guide - Parse → Modify → Build guide
• Error Handbook - Understanding and handling errors

• ddex-core - Core data models and utilities
• ddex-parser - Parser API reference
• ddex-builder - Builder API reference

• Fidelity Test Suite - 100+ test file validation results
• Contributing Guide - Development setup and guidelines
• API Changelog - Version history and breaking changes

This project is in active development. While external contributions aren't yet accepted, we welcome feedback and issue reports. Follow the project for updates!

MIT License - see LICENSE file for details.

DDEX Suite is designed to complement DDEX Workbench by providing structural parsing and deterministic generation while Workbench handles XSD validation and business rules.

Repository: https://github.com/daddykev/ddex-suite
Status: Phase 4.3 - Perfect Fidelity Engine
Parser: v0.2.5 on npm and PyPI
Builder: v0.2.5 on npm and PyPI
Suite Target: v1.0.0 in Q4 2025
Last Updated: September 11, 2025