About

Specified before it is written

ursprung is a full-stack TypeScript application framework written from scratch, targeting Cloudflare Workers, with AI agents as its first-class users. It does not exist yet — what exists is the architecture, being decided in the open.

Where it stands

The package published to npm exposes its own name and version and nothing else. Every decision that is hard to reverse is being written down first — one file per decision, with the reasoning that would not be obvious from the code — and the vocabulary those decisions are argued in is fixed before either is built.

the package

Two exports, both read from its own manifest. It is published so that the name is taken and the release path is proven, not because there is anything to install.

the language

A glossary of the terms the project argues in, used verbatim in issues, commits and code. It is the first thing that was written and the thing most often corrected.

the log

What was decided, what the research changed, and what is still open — including the decisions that were reversed a day after they were made.

What it does itself

Three pieces that a framework usually delegates are written here instead. Not because the alternatives are bad, but because a borrowed one cannot be explained all the way down — and being explainable all the way down is the point of the name.

the bundler

One unified module graph, from which the server output and the client output are both derived. Every first-party module declares in its filename which side it may run on, and the build audits what it emitted rather than trusting its own traversal.

the JSX runtime

JSX evaluates to inert data that names an element or a component. Nothing retains it and two of them are never compared, so there is no virtual DOM to diff — a change flows to the one position it was wired to.

type stripping

Erasable TypeScript syntax is deleted and the JavaScript underneath is otherwise preserved. Application code may use no construct that would need replacement code generated for it.

Agents are the users

Treating AI agents as the primary audience licenses decisions a human developer would reasonably refuse: an enumerated set of intrinsic elements instead of a permissive passthrough, a side declared in every filename instead of inferred, an unknown name as an error instead of a guess. Each of those trades a little writing comfort for a diagnostic that says exactly what went wrong — which is the trade an agent wants, because it cannot squint at a page and notice something looks off.

The same reasoning runs through the repository itself. The design record is checked in next to the code, the terms are fixed so that two sessions arguing a week apart argue about the same thing, and nothing important lives only in someone's head.

Where the design lives

• The glossary — the project's ubiquitous language, every term the rest of the record leans on.
• The dev log — one timestamped entry for each major development, newest first.
• The blog — the readable version of the architecture being decided, at length.
• The decision records — one file per decision that is hard to reverse, with the reasoning kept.
• The repository — the source, and the notes the work is actually done in.