"Things are only impossible until they're not." -- Jean-Luc Picard

Wesley is a domain-free GraphQL-to-IR transformation toolchain.

Wesley extracts the structure described by GraphQL SDL, lowers that structure into deterministic JSON IR, and provides hooks for you to give it semantics in your own extensions.

There is no graph. Only structure and what you make of it.

GraphQL SDL -> deterministic Wesley IR -> your domain via extensions

Wesley is deliberately domain-empty. It claims no ownership over runtime law, scheduler semantics, persistence models, replication behavior, storage engines, transport protocols, or substrate truth. Those concerns belong to extension modules, sibling repos, or consuming applications.

Wesley owns the GraphQL-to-IR transformation. Extensions own meaning.

Wesley is pre-1.0 software. APIs, CLI commands, generated artifacts, metadata schemas, and extension boundaries can still change between 0.x releases.

Use Wesley when you want deterministic build-time structure extraction and are comfortable pinning versions. Treat generated artifacts and extension contracts as release-scoped until the project declares a stable 1.0 surface.

Install the latest stable native CLI from crates.io:

cargo install wesley-cli --version 0.2.0
wesley --help

Pre-release builds of the next line (for example 0.3.0-alpha.1) are published to crates.io as opt-in previews once their signed tag lands; after one is published, pin its exact version to install it. Pre-releases are unstable and are not the recommended default.

From a source checkout:

cargo run --bin wesley -- --help
cargo xtask preflight

Lower GraphQL SDL into Wesley L1 IR:

cargo run --bin wesley -- schema lower \
  --schema test/fixtures/ir-parity/small-schema.graphql \
  --json

Generate target-neutral Rust or TypeScript projections:

cargo run --bin wesley -- emit rust \
  --schema test/fixtures/weslaw/contract-bundle-shape.graphql \
  --out generated/model.rs \
  --metadata-out generated/model.metadata.json

cargo run --bin wesley -- emit typescript \
  --schema test/fixtures/weslaw/contract-bundle-shape.graphql \
  --out generated/types.ts \
  --metadata-out generated/types.metadata.json

Run the local release-quality gate before opening a PR:

cargo xtask preflight

Validate a project manifest when a repo wants config-driven schema selection:

cargo run --bin wesley -- config validate --config wesley.config.json --json
cargo run --bin wesley -- config changed-schemas \
  --config wesley.config.json \
  --changed test/fixtures/examples/ecommerce.graphql \
  --json

The retained pnpm workspace supports docs, Holmes assurance tooling, and workspace checks. Use Node ^22.13.0 || ^24.0.0 || >=26.0.0 with pnpm 9.15.9 when working from this checkout.

For assurance status, use the Assurance Capability Matrix. Wesley emits deterministic evidence inputs and ships experimental assurance tooling around them; a capability is shipped only when the matrix lists an executable command or workflow.

Wesley owns domain-free compiler facts:

• GraphQL SDL parsing and normalization
• deterministic L1 IR and schema hashes
• schema diffs and root operation catalogs
• operation selection and directive-argument extraction
• Rust and TypeScript model and operation bindings
• TypeScript and Rust LE-binary codec projections
• weslaw/v1 authoring, hashing, diffing, rebinding, and coverage metadata
• deterministic evidence inputs and release checks around those generic compiler contracts

Wesley preserves directives as inspectable structure. It does not decide what those directives mean for a database, runtime, product, graph rewrite system, transport, scheduler, or application. Extension owners do that work.

The detailed ownership rule lives in Domain-Empty Core Boundary.

A single schema can be compiled by many extensions simultaneously. Each extension consumes Wesley IR independently and emits its own artifacts.

0.3.0-alpha.1 is the first pre-release of the 0.3.0 line, cut to unblock downstream consumers that need Wesley changes landed since 0.2.0. Notable changes since 0.2.0 include the extension generation provenance contract, hardened generation input-schema validation, pre-push and test Git-context isolation, and a release pipeline that now publishes pre-release tags as GitHub pre-releases (not latest). As a pre-release, APIs, CLI surface, and emitted artifacts remain unstable and may change before the stable 0.3.0; see the changelog for the complete list.

Wesley 0.2.0 is the domain-free project-manifest platform release. It adds the JSON/YAML wesley.project-manifest/v1 surface, native wesley config commands, manifest-driven schema selection for HOLMES CI, descriptor-only extension fixture modules, and a comprehensive docs/topics/ operator map. The release keeps the boundary explicit: Wesley extracts structure from GraphQL, and extensions assign meaning.

For complete history, read CHANGELOG.md.

• Docs entrance
• Topics
• Guide
• Architecture
• Wesley North Star
• SDL, Shape, And Law
• End To End
• Entrypoints
• CLI reference
• Project manifest
• Directive truth table
• Module authoring
• Technical teardown
• Release process
• Release policy
• Contributing
• Support
• Security

Wesley is not:

• a runtime
• a scheduler
• a database
• a replication engine
• a GraphQL server replacement
• a universal protocol
• a transport framework
• a venue for domain-specific product semantics

Keeping Wesley narrow is what lets extensions own rich semantics without turning the compiler into hidden platform ideology.

Use SUPPORT.md for questions, issue routing, security reporting, and release-support expectations.