Architecture

Capxul is a TypeScript monorepo with ten packages and seven applications. The Core SDK is the consumer boundary, React projects it into hooks, Convex owns durable product state, and applications compose those packages for a particular runtime.

The repository's architecture canon owns the current dependency map. The nearest package or application CONTEXT.md owns implementation detail.

Package layers

applications
  -> sdk-react
      -> sdk
          -> config + errors + types + wire + observability

backend -> config + observability + types + wire
contracts -> generated contract artifact

An import edge does not transfer ownership. For example, MCP projects SDK operations into agent tools, but the SDK still owns the method contract and the backend still owns durable authorization and state.

Consumer boundary

package.json#publishConfig.exports is the installable npm boundary. Workspace exports can be broader for repository development, so documentation must not teach a workspace-only subpath as a consumer API.

The SDK exposes domain method bundles returning Promise<CapxulResult<T>>. Effect programs, Convex transports, provider clients, custody details, and raw chain units remain behind package boundaries. React hooks delegate to the Core SDK client instead of defining a second product model.

Documentation ownership

code + tests + manifests
  -> package or app CONTEXT.md
  -> cross-package canon or ADR
  -> public Diataxis projection

When a changed fact crosses one of those boundaries, update every affected owner in the same PR. The repository documentation map and update map route the change.

The documentation workflow turns that ownership model into the required same-PR development loop.

Proof boundary

A type, registered tool, hermetic adapter, integration branch, packed artifact, and live provider run prove different things. Use the capability status vocabulary and stop each claim at the strongest evidence actually run.