Research Contribution
The Stateful Computing Papers · In-Progress
Re-Exploring Stateful Computing — A Paper Series
A paper series that formalizes the thesis behind all of the tooling work in this document — across languages, databases, browsers, and network protocols.
Core thesis: Software has a state problem. This paper names the structural problem and formalizes a model that addresses it at the foundations of software itself.
Each project in this document is an implementation of that model at a different layer of the stack: The Language/Runtime Layer · The DOM/UI Layer · Networking Boundaries · The Application/Database Boundary · The Application Layer
The Language/Runtime Layer
The Observer Protocol & The
"use live"
Runtime Directive2019 — present
A set of runtime and language extensions to JavaScript that brings the Live Contract model
to the JavaScript
runtime — each operating at different levels of abstraction. The first — the Observer
Protocol — standardizes how mutations are exposed
and observed
across native JavaScript values — plain objects and arrays:
Observer.observe(obj, handler). The second — the
"use live"
directive — builds on that to enable a program-level opt-in to reactivity in JavaScript where ordinary
imperative
JavaScript constructs run as self-enforcing contracts — enabling Imperative Reactive
Programming (IRP) in JavaScript.
- The Observer Protocol uses an "internal traps" model on native JavaScript objects and arrays that makes mutations at the object-level observable — enabling reactivity over program-level mutations
- The
"use live"program-level opt-in to reactivity is backed by a purpose-built JavaScript compiler that feeds arbitrary JavaScript source through a transform pipeline into a reactive execution engine —parsing → static analysis → internal representation + dependency graph → reactive runtime - The combination eliminates the secondary stack and manual update plumbing traditionally required for reactive programming in JavaScript: Signals, Proxies, other observable wrappers
The DOM/UI Layer
The RealDOM API & Object-Oriented HTML (OOHTML)
2019 — present
A set of runtime and language extensions that brings the Live Contract model to
the DOM — each operating at different levels of abstraction. The first — RealDOM — polyfills
the DOM with a mutation observer engine that
enables lower-level integration with the DOM than the native
MutationObserver
API does; builds on that to extend the Live Contract
model to relevant DOM APIs:
querySelector(selector, { live: true }). The second — OOHTML — polyfills the
DOM
with a declarative data-binding model, new scoping behaviours, and a reactive component
model over arbitrary HTML
— making it possible to directly author user interfaces in HTML.
- RealDOM is a ground-up mutation-observer engine designed to address the limitations of
the
native
MutationObserverAPI — including observability across Shadow Roots - OOHTML utilizes the RealDOM API, the Observer Protocol, the DOM's event system, interfaces, and timing semantics to make HTML programmable for applications
- Both follow a polyfill architecture that exploits the DOM's own extension points as against introducing a parallel object model or compile step
Networking Boundaries
PortPlus & FetchPlus
2022 — present
A set of extensions to the web's networking protocols and primitives that makes Live
Contracts native
to the web's communication model. The first — PortPlus — unifies the browser's
MessageChannel, BroadcastChannel, and WebSocket
primitives
under a consistent MessagePort interface that adds live mode to the messaging
protocol: postMessage(msg, { live: true }).
The second — FetchPlus — adds the Live Contracts model to the standard HTTP
request/response model: fetch(url, { live: true }), without requiring new
server infrastructure or replacing existing transport mechanisms.
- PortPlus addresses the structural gaps across the browser's messaging primitives at their roots and extends the resulting unified model with live state projection — giving both ends of a channel the concept of a shared state and stable object identity across the wire
- FetchPlus introduces a
LiveResponseprimitive to HTTP that extends the request/response model with interactive request processing and live state projection, giving both the client and the server the concept of a shared state and stable object identity across the wire - Live state projection across system boundaries eliminates the secondary infrastructure and manual update plumbing traditionally required in realtime systems: Web Sockets, subscription servers, event pipelines, state management libraries
The Application/Database Boundary
LinkedQL
2023 — present
A universal database interface for applications and agents that treats queries as contracts
and makes them self-enforcing — bringing an object-relational syntax, live queries and sync,
and
automatic version-safety to the application-database boundary.
Where the traditional approach requires a choreography of tools and secondary infrastructure
alongside the database — ORMs, API
servers, realtime infrastructure, and sync engines — LinkedQL composes those behaviours
natively through a small set of additions to SQL. LinkedQL is backed by:
- a special-purpose SQL compiler that simultaneously understands the PostgreSQL and MySQL dialects
- a live query engine that returns real-time results over arbitrary SQL
queries:
db.query(sql, { live: true })— across mainstream databases: PostgreSQL, MySQL/MariaDB - a semantic versioning engine that enforces version safety between application logic and the database
- the Edge Protocol — a purpose-built protocol for directly querying the database from across runtime boundaries; e.g. from browser and edge runtimes
- FlashQL — a ground-up embeddable SQL engine built for agent memory and offline-first workloads
The Application Layer
Webflo & node-live-response
2020 — present
Purpose-built application runtimes designed as native Live Contracts environments — each
targeting a different scope. The first — Webflo — is the full-stack framework with Live
Contracts as first-class
computing model across the entire stack — from the language/runtime layer to the DOM/UI
layer,
across networking boundaries and the
application/database boundary. The second —
node-live-response — is a pluggable module for the Node.js
runtime that brings LiveResponse to vanilla Node.js and Express backends.
Realtime
applications naturally emerge from the runtime rather than constructed.
- Webflo covers the full spectrum of application types — backend, frontend, and fullstack applications, Progressive Web Apps (PWAs), realtime, multiplayer and offline-first experiences, AI agent workflows
- Webflo is a convergence of multiple shifts in framework architecture — in routing and static file serving, server and client-side rendering, state and session management, authentication and redirects, life-cycle management, hot module replacement, and others — making it a new foundation for modern applications
- node-live-response lets the ordinary Node.js and Express backend operate a LiveResponse model without standing up a parallel realtime infrastructure