@craft-ng/core

Appearance

@craft-ng/coreType-safe Angular, by construction.

Fine-grained reactivity. Declare. Yield. Derive. Compile — no surprises.

Start the tutorial
Guide
Examples
ng-craft logo

Fine-grained reactivity

A signal read inside a binding invalidates only that text, property, class or style. Sibling bindings and the component template stay untouched.

One API for every kind of state

state, query, mutation, queryParams and asyncProcess share the same shape — a name, a config, insertions. Learn one and you know all five.

Highly composable

State composes with insertions, components with directives, and both through .pipe(...) — storage persistence, optimistic updates, forms, permissions. Library behaviour and yours are the same kind of function.

Services are functions, not classes

A service is a factory with a name and a scope: clear inputs, clear outputs. Yield it where you need it — no @Injectable, no constructor.

Selectorless, tagless components

Children are referenced lexically, not by a string selector — rename one and the compiler follows. And nothing extra reaches the DOM: no host element wraps your markup, so the tree you write is the tree that renders.

Forget a provider and it won't compile

Dependencies are tracked in the type system. A missing service, a misspelled route input or an unhandled exception stops the build, not the user.

Exceptions as values

A declared failure is returned, not thrown — it travels through types instead of the stack. The compiler knows every code a route can produce, and tells you when one is unhandled or handled for nothing.

Forms derived from state

The field tree, the validity and the error types are consequences of your state and your mutation, so they cannot drift apart from them.

Tests that mirror the real graph

The test register is derived from actual dependencies. Keep the app real and mock only the browser boundaries — "I forgot to mock that" becomes a compile error.

Assert what a template renders, at compile time

Type-level tests prove an element only appears under a condition, that a binding is the one you think, that a list item renders its label — no TestBed, no DOM, no fixture.

Templates are functions, not a dialect

Markup is typed hyperscript: each, ifBlock, matchBlock and defer instead of @for, @if, @switch and @defer. No template compiler, no parse errors — your editor refactors a template exactly like it refactors code.

Built for observability

Declarative code is instrumentable code: one provider adds structured logs, correlation ids, per-service timing or a snapshot of the live dependency graph — across the whole app, without touching a single call site. Fast to debug, easy to trace and monitor.

Architecture as a graph

The static Craft graph makes architecture enforceable: keep this feature from depending on that one, keep file kinds in their lanes, or allow an endpoint to be called only once. Ordinary Vitest assertions — see the shape of the system, then teach it its boundaries.

Packages ​

The toolkit is split into focused packages. They are currently published on the beta channel. Coding agents should start from llms.txt and the coding agents guide.

PackagePurpose
@craft-ng/coreReactive primitives, services, forms, routing and testing utilities
@craft-ng/componentSelectorless functional components and typed hyperscript templates
@craft-ng/dev-toolsCodemods, generators, CLI commands and ESLint rules
@craft-ng/mcpMCP server, Agent Skills and llms.txt helpers for coding agents
Romain Geffrault, creator of @craft-ng

I built @craft-ng around one priority: robustness. Applications that stay solid over time, composed from the smallest possible pieces — so the people who use them inherit a reliability they never have to think about.

The project is open to every suggestion and improvement that can take that robustness further.

Romain Geffraultcreator of @craft-ng