Philosophy

Infrastructure tools check that YAML, HCL or SDK calls are well-formed. chant also checks whether what you declared makes sense in context.

The deterministic core and the lifecycle built on it

Two Ideas

Lexicons are collections of types and semantic lint rules for an operational area. A lexicon knows what resources exist in its domain and checks that your declarations are both well-formed and consistent with each other.

Synthesis takes TypeScript declarations in and produces validated artifacts out. You write TypeScript objects, chant resolves dependencies, and serializes to the target format.

A Compiler at the Core

chant is a compiler: TypeScript in, spec-native output out. The approach was always available. Other tools built the deployment lifecycle into the compiler instead. chant keeps the compiler deterministic and builds those steps as separate layers you choose.

TypeScript as Data

Most IaC tools that use general-purpose languages — CDK, Pulumi, Terraform’s CDK — work by executing your code. Your program runs, makes API calls, and the tool captures the result.

The build runs only synthesis. It imports your .ts files, reads the resource objects they export, and emits output. It never calls a cloud API, reads or writes state, or deploys. The build turns your TypeScript into an artifact, deterministically and with no side effects. Deploying the artifact is a separate step.

Synthesis does run your code, but only a constrained slice of it. The evaluability lint rules (EVL) reject anything that would make a resource depend on more than literals, constants, and cross-resource references. That rules out function calls in props and control flow around resources. With those rules satisfied, running the file is equivalent to reading static data. Because synthesis is side-effect-free and deterministic for conforming source:

• Evaluation is deterministic for code that passes the evaluability rules. Same source, same output. No API calls during synthesis.
• Analysis is a single pass over the imported modules. Type-checking and linting are separate commands.
• Output is auditable. Every value traces to a literal, a const binding, or a cross-resource reference.
• IDEs work fully. Types drive the API surface, so autocompletion, inline errors, and go-to-definition work with no extra setup.

Static evaluation also suits agentic workflows. Agents deploy, monitor and remediate. chant produces the deterministic, auditable artifact they work from.

Spec-True, Not Cloud-Abstract

Each lexicon is faithful to its target spec. The AWS lexicon generates from the CloudFormation resource specification. The GitLab lexicon maps to .gitlab-ci.yml schema. Chant gives you each spec’s real API surface, typed and linted, with no abstraction layer across specs.

The output is standard CloudFormation, standard GitLab CI, or whatever standard format the lexicon targets. If you stop using chant, the artifacts keep working.

Where the Build Path Ends

chant build produces artifacts — it doesn’t deploy them, call cloud APIs, or manage state. Deployment, drift, and reconciliation are separate steps (Lifecycle Models), so the build path stays small to audit, with no provider SDKs, state backend, or network at build time. See Owning less.

The steps after the build run as chant’s own Ops, or you hand the artifact to agents, CI pipelines, or platform tooling.

Anything with a schema is a potential lexicon target. chant adds types and lint rules to your existing cloud tooling. You can import existing templates, give them types, and lint them alongside everything else.

The Lifecycle on Top

Each lifecycle layer adds steps after chant build without changing the build pipeline.

The lifecycle spans declarative deployment workflows (Op — phased convergent workflows declared in *.op.ts files, run via chant run), continuous observation (WatchOp — periodic snapshot+diff on the Op’s own schedule), the observational lifecycle model (chant lifecycle — non-authoritative snapshots; see Drift Detection), a release model (Components — releasable units composed from a bounded capability set and run by a generated Op), and agentic skills for import and drift detection. All of them act on the same deterministic build output.

The lifecycle is opt-in per environment. Use none of it and chant is a compiler whose output you deploy yourself. Use all of it and chant also deploys, observes, and reconciles, with the same build underneath.