hover the atom · observe · collapse ψ
ψThe Continuum Framework
Your app exists in every runtime.
Until you run it.
Write the domain once. It lives in superposition across every context: server, edge, browser, agents. Running it is the observation that collapses it into one. Stone.js orchestrates the collapse.
ψThe principle
Architecture, borrowed from quantum mechanics.
The Continuum is built on the uncertainty principle and wave-function collapse, applied to software. Not a metaphor for show: each law maps to a mechanism we ship.
SUPERPOSITION
All contexts, latent
From the system's point of view, the outer context is in superposition: every platform, request and input source exists in potential, as long as none has been integrated, selected, collapsed.
OBSERVATION
Runtime is the measurement
At runtime, in the integration dimension, the intention is collapsed, normalised and stabilised into a usable internal context. That decoherence is where raw reality meets your logic.
ENTANGLEMENT
Backend ⟷ frontend, correlated
One schema validates the API and the form. One rule guards the route and shapes the UI. Measure one side: the other is already correct.
CONTEXTUAL UNCERTAINTY
Defer the where. Own the what.
A domain cannot, at the same time, know its execution context exactly and evolve independently of it. Know it too well and you are coupled; ignore it and you fail the intent. Stone.js keeps the where uncertain while you build the what, at full speed.
ψSuperposition, in code
Stack adapters. Collapse at runtime.
There is no build-time choice to regret. Install as many adapters as you want: they superpose in your code, visibly. Work locally on Node, ship the same class to a Lambda. The contextual collapse happens at runtime, in the integration dimension. Toggle contexts:
state: |API⟩ · service · collapse deferred to runtime
import { NodeHttp } from '@stone-js/node-http-adapter' import { AwsLambdaHttp } from '@stone-js/aws-lambda-http-adapter' @NodeHttp() @AwsLambdaHttp() @Routing() @StoneApp() export class Application {}
ψTwo paradigms, one state
Decorators or define*. Superposed, until you choose.
Both paradigms are first-class and 1:1: same domain, same power. Pick one in the docs and every example follows you, classes only or functions only.
|declarative⟩ · classes
@EventHandler('/tasks') export class TasksController { constructor ({ tasks }) { this.tasks = tasks } @Get('/') list () { return this.tasks.list() } }
|imperative⟩ · functions
export const Routes = defineRoutes([ [({ tasks }) => () => tasks.list(), { path: '/tasks', method: 'GET' }], ]) // same domain, same power
ψThe geological record
Each era buried the last one's frameworks.
A cross-section of thirty years of execution contexts. Frameworks welded to their era went down with it: collapsed states, fossilised in place. The vein that crosses every stratum is a domain that never collapsed. It stayed in superposition.
the same domain crosses every stratum · that is the continuum
ψThe ecosystem
A keystone kernel. Everything else plugs in.
The core knows nothing of HTTP, CLI or the browser. Adapters and extensions graft onto it through blueprints, never the other way around. Browse the marketplace:
@stone-js/validation
One schema, validated on the backend and the frontend form.
extension@stone-js/auth
Stateless JWT/OAuth on jose: edge-native, no session.
extension@stone-js/realtime
One Broadcaster API, backend and frontend: channels and presence.
extension@stone-js/event-bus
Emit domain events to local and cloud targets; route them anywhere.
adapter@stone-js/fetch-adapter
One Web-standard adapter for Cloudflare, Deno, Bun, Vercel, Netlify.
extension@stone-js/mcp-dev
Serve the framework + your app to a coding agent: `stone mcp`.
extension@stone-js/queue
Dispatch work now or later, process with a worker, retry with backoff.
extension@stone-js/openapi
A public contract derived from the schemas you already write.
ψShip faster
Start from a template. Learn from the recipes.
Scaffold a real, running app in one command, then follow the blog recipes that build on the very same starters.
Starters
All starters →Continuum Showcase
The full Continuum tour: one domain running across every context.
realtimeRealtime chat
Channels, presence and broadcast over WebSockets, ready to run.
multi-tenantMulti-tenant (subdomain routing)
Capture the tenant from the subdomain and scope every request to it.
agentsAgent superpowers (MCP dev)
Give your coding agent Stone.js superpowers: `stone mcp` serves the framework + your app.
From the blog
All posts →Give your coding agent Stone.js superpowers
One command, `stone mcp`, serves your coding agent the framework’s knowledge and a live, read-only view of your own app: its routes, commands and config, plus any tools you add.
Stateless auth at the edge
Verify a token at the boundary instead of holding a session, and the same auth guard runs on Node, serverless, the edge and agents, with nothing to store.
One domain, three runtimes
One codebase, unchanged, running on Node, AWS Lambda and the edge. Not three apps: three runtimes. The thing a single-target framework cannot do.
Introducing Stone.js
An application is an act, not an object. Write the domain once; the context applies to it at run time. This is the Continuum, and this is Stone.js.
ψAgent-native
Your domain, observable by machines.
Agents are the next execution context, and Stone.js treats them as first-class: the agent that builds your app, and the agent that calls it. No other framework is built this way.
@stone-js/mcp-dev
One command, stone mcp, serves your coding agent the framework's map and a live, read-only view of your app: concepts, modules, routes, config, plus Agent Skills. Consulted in real time, no package scanning, no guessing.
@stone-js/mcp coming
Expose your running domain to AI agents as MCP tools, the same domain your REST API serves, without touching a handler. The MCP equivalent of your REST API.
“The LLM masters the context.
You master the domain.
Together, you ship.”
ψBefore the framework
“An application is not an object.
It is an act.”
The Continuum Architecture manifesto
Read the manifesto →Learn the core once. Command every context.
One base of knowledge. Every dimension open: this era's, and the next.