A function returning whatever result you want to share: a value, a function, an object, etc. It will be called at most once per root job lifetime, in a job that is an immediate child of the root job.
(Note: if your factory is a native generator function, it is automatically wrapped with fork() so that its job will not end when the generator ends, and the result can be waited on by multiple callers. If your factory is not a native generator function but still returns a generator to produce an async result, you should wrap that generator with fork before returning it.)
Note that if you want your code to be testable with newRoot, you should avoid storing the result of calling the service accessor anywhere it can outlive the root job, since you will otherwise end up with a stale reference to the previous service instance and fail to initialize the new instance.
Your services can detect this scenario, however, by having the factory wrap its return value with expiring(), which will make any access to a saved service value throw a TypeError after the root job ends. (Note that such a thing should not be necessary in your production builds, however, since at runtime you will normally only ever have one root job.)
Wrap a factory function to create a singleton service accessor
The returned function, when called, will run the factory in a new job and cache the result. The job the factory ran in will end when the root job does, after which the cached result will be cleared.