The web app, the API, the billing worker, and the mobile SDK all compute the same number differently. Until they do not match. Traverse writes business logic once and runs it everywhere.
Every environment needs its own version. They drift. Support tickets follow.
Pricing logic in the storefront, the API, the billing worker, and the webhook handler. Each one a slightly different version. Reconciliation becomes a quarterly event.
Feature flag checks on the frontend and the backend, maintained separately. They get out of sync. A feature gates correctly on mobile but not in the API.
Permission logic reimplemented for every new client SDK. JavaScript, Python, iOS. Each implementation introduces its own edge cases.
Your AI feature needs eligibility rules. Those rules live in the backend. Now you need to expose them, or rewrite them, or both.
Write the logic once as a governed capability. The runtime handles placement.
Compile to WASM. The same binary runs in the browser, the API, and the worker. The result is always the same.
Capability contracts declare who can call what and under what conditions. Entitlement rules are enforced at the contract level, not scattered in application code.
Contract versions pin behavior. Old clients get old behavior. New clients get new behavior. Nothing silently changes mid-cycle.
Deploy the same eligibility check to edge for low-latency pricing. No rewrite. Same contract, different placement target.
Compute plan prices across web, mobile, and backend. Same capability, same result in every environment.
Check which features a user can access based on their plan tier. Governed by contract. No scattered if-statements.
Determine whether a user qualifies to upgrade. Preconditions declared in the contract, not buried in application logic.
Permission logic for multiple tenants, each with different rules. One capability per rule, versioned independently.
Clone the repo, inspect the example bundle, run the browser demo. No account required.