uneventful 0.0.9 → 0.0.11

package/dist/{call-or-wait-DpJBh_pS.mjs → jobutils-Dvu-e99o.mjs}

@@ -1,4 +1,4 @@
-import { b as batch, d as defer, i as isFunction, G as GeneratorBase, c as apply } from './utils-P0JEpWXG.mjs';
+import { e as batch, d as defer, i as isFunction, G as GeneratorBase, c as apply } from './utils-cyEhnyp7.mjs';
 
 function resolve(request, val) {
   request("next", val);
@@ -44,12 +44,13 @@ function markHandled(res) {
   return res.err;
 }
 function getResult(res) {
-  if (isValue(res))
-    return res.val;
-  res.op;
-  fulfillPromise(noop, (e) => {
-    throw e;
-  }, res);
+  if (!isValue(res)) {
+    res.op;
+    fulfillPromise(noop, (e) => {
+      throw e;
+    }, res);
+  }
+  return res.val;
 }
 function fulfillPromise(resolve2, reject2, res) {
   if (isError(res))
@@ -66,31 +67,25 @@ function propagateResult(job, res) {
 class CancelError extends Error {
 }
 
-var current = makeCtx();
-function swapCtx(future) {
-  const now = current;
-  current = future;
-  return now;
-}
-var freelist = [];
-function makeCtx(job, cell) {
-  if (freelist && freelist.length) {
-    const s = freelist.pop();
-    s.job = job;
-    s.cell = cell;
-    return s;
-  }
-  return { job, cell };
-}
-function freeCtx(s) {
-  s.job = s.cell = null;
-  freelist.push(s);
+var currentJob, currentCell;
+const cells = [], jobs = [];
+function pushCtx(job, cell) {
+  jobs.push(currentJob);
+  cells.push(currentCell);
+  currentJob = job;
+  currentCell = cell;
+}
+function popCtx() {
+  currentJob = jobs.pop();
+  currentCell = cells.pop();
+}
+function cellJob() {
+  return currentJob ||= currentCell?.getJob();
 }
 
 const catchers = /* @__PURE__ */ new WeakMap(), defaultCatch = (e) => {
   Promise.reject(e);
 };
-const nullCtx = makeCtx();
 const owners = /* @__PURE__ */ new WeakMap();
 const pulls = /* @__PURE__ */ batch((pulls2) => {
   for (const conn of pulls2) {
@@ -127,8 +122,7 @@ function qlen(c) {
   return c ? c.v : 0;
 }
 function pop(c) {
-  if (qlen(c))
-    return unlink(c, c.p);
+  return qlen(c) ? unlink(c, c.p) : void 0;
 }
 class Node {
   constructor() {
@@ -185,22 +179,23 @@ function unlinker(chain2, node) {
 }
 
 function getJob() {
-  const job = current.job || current.cell?.getJob();
+  const job = currentJob || cellJob();
   if (job)
     return job;
   throw new Error("No job is currently active");
 }
 function recalcJob(job) {
   return (cb) => {
-    current.job.must(job.release(cb));
+    currentJob.must(job.release(cb));
   };
 }
 function runChain(res, cbs) {
-  while (qlen(cbs))
+  let cb;
+  while (cb = pop(cbs))
     try {
-      pop(cbs)(res);
+      cb(res);
     } catch (e) {
-      detached.asyncThrow(e);
+      _detached.asyncThrow(e);
     }
   cbs && recycle(cbs);
   return void 0;
@@ -212,14 +207,15 @@ class _Job {
       const res = this._done ||= CancelResult, cbs = this._cbs;
       if (!cbs && !isUnhandled(res))
         return;
-      const ct = inProcess.size, old = swapCtx(nullCtx);
+      const ct = inProcess.size;
+      pushCtx();
       if (!ct)
         inProcess.add(null);
       if (cbs && cbs.u)
         cbs.u = runChain(res, cbs.u);
       inProcess.add(this);
       if (ct) {
-        swapCtx(old);
+        popCtx();
         return;
       }
       inProcess.delete(null);
@@ -230,7 +226,7 @@ class _Job {
         if (isUnhandled(item._done))
           item.throw(markHandled(item._done));
       }
-      swapCtx(old);
+      popCtx();
     };
     this._done = void 0;
     // Chain whose .u stores a second chain for `release()` callbacks
@@ -268,7 +264,7 @@ class _Job {
     });
   }
   result() {
-    return this._done || current.cell?.recalcWhen(this, recalcJob) || void 0;
+    return this._done || currentCell?.recalcWhen(this, recalcJob) || void 0;
   }
   get [Symbol.toStringTag]() {
     return "Job";
@@ -289,14 +285,14 @@ class _Job {
   _end(res) {
     if (this._done)
       throw new Error("Job already ended");
-    if (this !== detached)
+    if (this !== _detached)
       this._done = res;
     this.end();
     return this;
   }
   throw(err) {
     if (this._done) {
-      (owners.get(this) || detached).asyncThrow(err);
+      (owners.get(this) || _detached).asyncThrow(err);
       return this;
     }
     return this._end(ErrorResult(err));
@@ -380,21 +376,21 @@ class _Job {
     return this.start((job) => void src(sink, job, inlet));
   }
   run(fn, ...args) {
-    const old = swapCtx(makeCtx(this));
+    pushCtx(this);
     try {
       return fn(...args);
     } finally {
-      freeCtx(swapCtx(old));
+      popCtx();
     }
   }
   bind(fn) {
     const job = this;
     return function() {
-      const old = swapCtx(makeCtx(job));
+      pushCtx(job);
       try {
         return apply(fn, this, arguments);
       } finally {
-        freeCtx(swapCtx(old));
+        popCtx();
       }
     };
   }
@@ -404,7 +400,7 @@ class _Job {
     return this;
   }
   release(cleanup) {
-    if (this === detached)
+    if (this === _detached)
       return noop;
     let cbs = this._chain();
     if (!this._done || cbs.u)
@@ -415,7 +411,7 @@ class _Job {
     try {
       (catchers.get(this) || this.throw).call(this, err);
     } catch (e) {
-      if (this === detached)
+      if (this === _detached)
         catchers.set(this, defaultCatch);
       else
         catchers.delete(this);
@@ -433,7 +429,7 @@ class _Job {
     return this;
   }
   _chain() {
-    if (this === detached)
+    if (this === _detached)
       this.end();
     if (this._done && isEmpty(this._cbs))
       defer(this.end);
@@ -454,14 +450,23 @@ function nativePromise(job) {
   return promises.get(job);
 }
 const makeJob = _Job.create;
-const detached = makeJob();
-detached.end = () => {
+const _detached = makeJob();
+const detached = _detached;
+_detached.end = () => {
   throw new Error("Can't do that with the detached job");
 };
-detached.asyncCatch(defaultCatch);
+_detached.asyncCatch(defaultCatch);
+let root;
+newRoot();
+function newRoot() {
+  root?.end();
+  const job = root = makeJob().asyncCatch((e) => _detached.asyncThrow(e));
+  job.release(() => root === job && (root = null));
+  return root;
+}
 function runGen(g, job) {
-  let it = g[Symbol.iterator](), running = true, ctx = makeCtx(job), ct = 0;
-  let done = ctx.job.release(() => {
+  let it = g[Symbol.iterator](), running = true, j = job, ct = 0;
+  let done = job.release(() => {
     job = void 0;
     ++ct;
     step("return", void 0);
@@ -476,7 +481,7 @@ function runGen(g, job) {
     if (running) {
       return defer(step.bind(null, method, arg));
     }
-    const old = swapCtx(ctx);
+    pushCtx(j);
     try {
       running = true;
       try {
@@ -510,107 +515,18 @@ function runGen(g, job) {
         }
       } catch (e) {
         it = job = void 0;
-        ctx.job.throw(e);
+        j.throw(e);
       }
       it = void 0;
       done?.();
       done = void 0;
     } finally {
-      swapCtx(old);
+      popCtx();
       running = false;
     }
   }
 }
 
-function backpressure(inlet = defaultInlet) {
-  const job = getJob();
-  return (cb) => {
-    if (!job.result() && inlet.isOpen()) {
-      if (cb)
-        inlet.onReady(cb, job);
-      return inlet.isReady();
-    }
-    return false;
-  };
-}
-const IsStream = "uneventful/is-stream";
-function connect(src, sink, inlet) {
-  return getJob().connect(src, sink, inlet);
-}
-function throttle(job = current.job) {
-  return new _Throttle(job);
-}
-class _Throttle {
-  /** @internal */
-  constructor(_job) {
-    this._job = _job;
-    /** @internal */
-    this._callbacks = void 0;
-    this._isReady = true;
-    this._isPulling = false;
-  }
-  isOpen() {
-    return !this._job?.result();
-  }
-  /** Is the connection ready to receive data? */
-  isReady() {
-    return this.isOpen() && this._isReady;
-  }
-  onReady(cb, job) {
-    if (!this.isOpen())
-      return this;
-    const _callbacks = this._callbacks ||= /* @__PURE__ */ new Map();
-    const unlink = job.release(() => _callbacks.delete(cb));
-    if (this.isReady() && this && !_callbacks.size) {
-      pulls.add(this);
-    }
-    _callbacks.set(cb, unlink);
-    return this;
-  }
-  pause() {
-    this._isReady = false;
-    return this;
-  }
-  doPull() {
-    if (this._isPulling)
-      return;
-    const { _callbacks } = this;
-    if (!_callbacks?.size)
-      return;
-    this._isPulling = true;
-    try {
-      for (let [cb, unlink] of _callbacks) {
-        if (!this.isReady())
-          break;
-        unlink();
-        _callbacks.delete(cb);
-        cb();
-      }
-    } finally {
-      this._isPulling = false;
-    }
-  }
-  resume() {
-    if (this.isOpen()) {
-      this._isReady = true;
-      this.doPull();
-    }
-  }
-}
-const defaultInlet = throttle();
-function pipe() {
-  var v = arguments[0];
-  for (var i = 1; i < arguments.length; i++)
-    v = arguments[i](v);
-  return v;
-}
-function compose(...fns) {
-  return (val) => pipe(val, ...fns);
-}
-function into(...args) {
-  return (src) => src(...args);
-}
-
 function must(cleanup) {
   getJob().must(cleanup);
 }
@@ -618,7 +534,7 @@ function start(init, fn) {
   return getJob().start(init, fn);
 }
 function isJobActive() {
-  return !!current.job;
+  return !!currentJob;
 }
 const timers = /* @__PURE__ */ new WeakMap();
 function timeout(ms = 0, job = getJob()) {
@@ -664,14 +580,14 @@ function restarting(task2) {
   inner.asyncCatch((e) => outer.asyncThrow(e));
   return function() {
     inner.restart().must(outer.release(end));
-    const old = swapCtx(makeCtx(inner));
+    pushCtx(inner);
     try {
       return apply(task2, this, arguments);
     } catch (e) {
       inner.restart();
       throw e;
     } finally {
-      freeCtx(swapCtx(old));
+      popCtx();
     }
   };
 }
@@ -683,23 +599,4 @@ function task(fn, _ctx, desc) {
   };
 }
 
-function callOrWait(source, method, handler, noArgs) {
-  if (source && isFunction(source[method]))
-    return source[method]();
-  if (isFunction(source))
-    return (source.length === 0 ? noArgs(source) : false) || start((job) => {
-      connect(source, (v) => handler(job, v)).do((r) => {
-        if (isValue(r))
-          job.throw(new Error("Stream ended"));
-        else if (isError(r))
-          job.throw(markHandled(r));
-      });
-    });
-  mustBeSourceOrSignal();
-}
-function mustBeSourceOrSignal() {
-  throw new TypeError("not a source or signal");
-}
-
-export { nativePromise as A, makeJob as B, CancelResult as C, pipe as D, ErrorResult as E, compose as F, into as G, isJobActive as H, IsStream as I, timeout as J, abortSignal as K, task as L, swapCtx as M, nullCtx as N, makeCtx as O, freeCtx as P, ValueResult as V, rejecter as a, resolve as b, backpressure as c, detached as d, isUnhandled as e, markHandled as f, getJob as g, isError as h, isCancel as i, connect as j, fulfillPromise as k, callOrWait as l, must as m, noop as n, restarting as o, current as p, mustBeSourceOrSignal as q, resolver as r, start as s, throttle as t, isValue as u, reject as v, isHandled as w, getResult as x, propagateResult as y, CancelError as z };
-//# sourceMappingURL=call-or-wait-DpJBh_pS.mjs.map
+export { timeout as A, abortSignal as B, CancelResult as C, task as D, ErrorResult as E, pushCtx as F, popCtx as G, currentJob as H, pulls as I, ValueResult as V, rejecter as a, resolve as b, root as c, isUnhandled as d, markHandled as e, isError as f, getJob as g, fulfillPromise as h, isCancel as i, restarting as j, currentCell as k, isValue as l, must as m, noop as n, reject as o, isHandled as p, getResult as q, resolver as r, start as s, propagateResult as t, CancelError as u, nativePromise as v, makeJob as w, detached as x, newRoot as y, isJobActive as z };

package/dist/mod.d.ts

@@ -6,6 +6,7 @@ export { a as Each, E as EachResult, N as NextMethod, U as UntilMethod, e as eac
  * Invoke a no-argument function as a microtask, using queueMicrotask or Promise.resolve().then()
  *
  * @category Scheduling
+ * @function
  */
 declare let defer: (cb: () => any) => void;
 
@@ -37,21 +38,30 @@ declare function nativePromise<T>(job: Job<T>): Promise<T>;
  * Return a new {@link Job}.  If *either* a parent parameter or stop function
  * are given, the new job is linked to the parent.
  *
+ * @remarks You should generally use `start()`, `parent.start()` or
+ * `root.start()` instead of this, unless you're creating a special kind of job
+ * that needs a custom stop function.
+ *
  * @param parent The parent job to which the new job should be attached.
- * Defaults to the currently-active job if none given (assuming a stop
- * parameter is provided).
+ * Defaults to the currently-active job if none given (assuming a stop parameter
+ * is provided).
  *
  * @param stop The function to call to destroy the nested job.  Defaults to the
  * {@link Job.end} method of the new job if none is given (assuming a parent
  * parameter is provided).
  *
- * @returns A new job.  The job is linked/nested if any arguments are given,
- * or a detached (parentless) job otherwise.
+ * @returns A new job.  The job is a child job if any arguments are given, or
+ * a detached (parentless) job otherwise.
  *
  * @category Jobs
+ * @function
  */
 declare const makeJob: <T>(parent?: Job, stop?: CleanupFn) => Job<T>;
 /**
+ * @deprecated Use {@link root} instead.  (Including uses of
+ * `.asyncCatch()` to set the default async error handling policy.)
+ *
+ * ---
  * A special {@link Job} with no parents, that can be used to create standalone
  * jobs.  detached.start() returns a new detached job, detached.run() can be
  * used to run code that expects to create a child job, and detached.bind() can
@@ -80,6 +90,56 @@ declare const makeJob: <T>(parent?: Job, stop?: CleanupFn) => Job<T>;
  * @category Jobs
  */
 declare const detached: Job<unknown>;
+/**
+ * The "main" job of the program or bundle, which all other jobs should be a
+ * child of.  This provides a single point of configuration and cleanup, as one
+ * can e.g.:
+ *
+ * - Use {@link Job.asyncCatch `root.asyncCatch()`} to define the default async
+ *   error handling policy
+ * - Use {@link Job.end `root.end()`} to clean up all resources for the entire
+ *   program
+ * - Use {@link Job.start `root.start()`} to create top-level, standalone, or
+ *   "daemon"/service tasks, or to create tasks whose lifetime is managed by an
+ *   external framework.
+ *
+ * By default, there is only ever one root job, run once, in a given process or
+ * page.  But for testing you can use {@link newRoot} to end the existing root
+ * and start a new one.
+ *
+ * @remarks
+ * Uneventful does not include any code to end the root job itself, as the
+ * decision of when and whether to do that varies heavily by context (e.g.
+ * server vs. browser, app vs. plugin, etc.), and often doesn't need to happen
+ * at all.  (Because exiting the process or leaving the web page is often
+ * sufficient.)
+ *
+ * More commonly, you will only end the root job when running tests (to get a
+ * clean environment for the next test), or when your entire bundle is itself an
+ * unloadable plugin (e.g. in Obsidian).
+ *
+ * Note, too, that when the root job ends, root is reset to `null` so that any
+ * subsequent attempt to use the root job will throw an exception.  (Unless of
+ * course a new root job has been created with {@link newRoot}.)
+ *
+ * @category Jobs
+ */
+declare let root: Job<unknown>;
+/**
+ * Create a new root job (usually for testing purposes). If there is an existing
+ * root job, it is ended first.  The new root is configured to convert async
+ * errors into unhandled promise rejections by default, so if you need to change
+ * that you can use its {@link Job.asyncCatch `.asyncCatch()`} method.
+ *
+ * @returns The new root job.
+ *
+ * @remarks If your project customizes the root job in some way(s), you will
+ * probably want a function to do that, so you can use it both in tests and at
+ * runtime.  (e.g. `myInit(newJob())` in tests, and `myInit(root)` at runtime.)
+ *
+ * @category Jobs
+ */
+declare function newRoot(): Job<unknown>;
 
 /**
  * Convert a (possible) promise to something you can `yield *to()` in a job
@@ -653,4 +713,4 @@ declare function task<T, A extends any[], C, D extends {
     value?: (this: C, ...args: A) => StartObj<T>;
 }>(clsOrProto: any, name: string | symbol, desc: D): D;
 
-export { AnyFunction, Backpressure, CleanupFn, DisposeFn, type Emitter, Job, type MockSource, OptionalCleanup, Sink, Source, StartFn, StartObj, Stream, Transformer, Yielding, abortSignal, concat, concatAll, concatMap, defer, detached, emitter, empty, filter, fromAsyncIterable, fromDomEvent, fromIterable, fromPromise, fromSubscribe, fromValue, getJob, interval, isJobActive, lazy, makeJob, map, merge, mergeAll, mergeMap, mockSource, must, nativePromise, never, restarting, share, skip, skipUntil, skipWhile, slack, sleep, start, switchAll, switchMap, take, takeUntil, takeWhile, task, timeout, to };
+export { AnyFunction, Backpressure, CleanupFn, DisposeFn, type Emitter, Job, type MockSource, OptionalCleanup, Sink, Source, StartFn, StartObj, Stream, Transformer, Yielding, abortSignal, concat, concatAll, concatMap, defer, detached, emitter, empty, filter, fromAsyncIterable, fromDomEvent, fromIterable, fromPromise, fromSubscribe, fromValue, getJob, interval, isJobActive, lazy, makeJob, map, merge, mergeAll, mergeMap, mockSource, must, nativePromise, never, newRoot, restarting, root, share, skip, skipUntil, skipWhile, slack, sleep, start, switchAll, switchMap, take, takeUntil, takeWhile, task, timeout, to };

package/dist/mod.mjs

@@ -1,6 +1,8 @@
-import { d as defer, i as isFunction } from './utils-P0JEpWXG.mjs';
-import { r as resolver, a as rejecter, b as resolve, I as IsStream, c as backpressure, m as must, s as start, g as getJob, n as noop, t as throttle, d as detached, i as isCancel, e as isUnhandled, f as markHandled, h as isError, j as connect, k as fulfillPromise, l as callOrWait, o as restarting, p as current, q as mustBeSourceOrSignal, u as isValue } from './call-or-wait-DpJBh_pS.mjs';
-export { z as CancelError, C as CancelResult, E as ErrorResult, V as ValueResult, K as abortSignal, F as compose, x as getResult, G as into, w as isHandled, H as isJobActive, B as makeJob, A as nativePromise, D as pipe, y as propagateResult, v as reject, L as task, J as timeout } from './call-or-wait-DpJBh_pS.mjs';
+import { d as defer, i as isFunction } from './utils-cyEhnyp7.mjs';
+import { r as resolver, a as rejecter, b as resolve, m as must, s as start, g as getJob, n as noop, c as root, i as isCancel, d as isUnhandled, e as markHandled, f as isError, h as fulfillPromise, j as restarting, k as currentCell, l as isValue } from './jobutils-Dvu-e99o.mjs';
+export { u as CancelError, C as CancelResult, E as ErrorResult, V as ValueResult, B as abortSignal, x as detached, q as getResult, p as isHandled, z as isJobActive, w as makeJob, v as nativePromise, y as newRoot, t as propagateResult, o as reject, D as task, A as timeout } from './jobutils-Dvu-e99o.mjs';
+import { I as IsStream, b as backpressure, t as throttle, c as connect, a as callOrWait, m as mustBeSourceOrSignal } from './call-or-wait-EzXJX5Dq.mjs';
+export { d as compose, i as into, p as pipe } from './call-or-wait-EzXJX5Dq.mjs';
 
 function* to(p) {
   return yield (res) => Promise.resolve(p).then(resolver(res), rejecter(res));
@@ -189,7 +191,7 @@ function share(source) {
         defer(produce);
     });
     if (links.size === 1) {
-      uplink = detached.connect(source, (v) => {
+      uplink = root.connect(source, (v) => {
         for (const [s, c] of links)
           try {
             s(v);
@@ -274,10 +276,10 @@ function forEach(src, sink, inlet) {
   return (src2) => forEach(src2, sink, inlet);
 }
 function recalcWhen(fnOrKey, fn) {
-  current.cell?.recalcWhen(fnOrKey, fn);
+  currentCell?.recalcWhen(fnOrKey, fn);
 }
 function isObserved() {
-  return current.cell?.isObserved();
+  return currentCell?.isObserved();
 }
 
 function concat(sources) {
@@ -369,7 +371,7 @@ function slack(size, dropped = noop) {
     conn.connect(src, (v) => {
       buffer.push(v);
       if (!draining && ready())
-        return drain();
+        return void drain();
       while (buffer.length > max) {
         dropped(size < 0 ? buffer.pop() : buffer.shift());
       }
@@ -399,6 +401,7 @@ function slack(size, dropped = noop) {
       } finally {
         draining = false;
       }
+      return false;
     }
     return IsStream;
   };
@@ -438,5 +441,4 @@ function takeWhile(condition) {
   };
 }
 
-export { IsStream, backpressure, concat, concatAll, concatMap, connect, defer, detached, each, emitter, empty, filter, forEach, fromAsyncIterable, fromDomEvent, fromIterable, fromPromise, fromSubscribe, fromValue, fulfillPromise, getJob, interval, isCancel, isError, isObserved, isUnhandled, isValue, lazy, map, markHandled, merge, mergeAll, mergeMap, mockSource, must, never, next, noop, recalcWhen, rejecter, resolve, resolver, restarting, share, skip, skipUntil, skipWhile, slack, sleep, start, switchAll, switchMap, take, takeUntil, takeWhile, throttle, to };
-//# sourceMappingURL=mod.mjs.map
+export { IsStream, backpressure, concat, concatAll, concatMap, connect, defer, each, emitter, empty, filter, forEach, fromAsyncIterable, fromDomEvent, fromIterable, fromPromise, fromSubscribe, fromValue, fulfillPromise, getJob, interval, isCancel, isError, isObserved, isUnhandled, isValue, lazy, map, markHandled, merge, mergeAll, mergeMap, mockSource, must, never, next, noop, recalcWhen, rejecter, resolve, resolver, restarting, root, share, skip, skipUntil, skipWhile, slack, sleep, start, switchAll, switchMap, take, takeUntil, takeWhile, throttle, to };

package/dist/shared.d.ts

@@ -0,0 +1,109 @@
+import { Y as Yielding } from './types-N2ua11te.js';
+
+/**
+ * Tools for sharing tasks, values, services, etc., especially across job
+ * boundaries.
+ *
+ * @module uneventful/shared
+ */
+
+/**
+ * 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 {@link root}
+ * job does, after which the cached result will be cleared.
+ *
+ * @param factory 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 {@link 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 {@link fork} before
+ * returning it.)
+ *
+ * @remarks Note that if you want your code to be testable with {@link 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 {@link 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.)
+ */
+declare function service<T>(factory: () => T): () => T;
+/**
+ * Proxy an object so it "expires" (becomes inaccessible) with the calling job.
+ *
+ * Any attempts to use the returned object after the job ends or restarts (other
+ * than to check its `typeof`) will result in a TypeError.
+ *
+ * Note: your runtime environment must support `Proxy.revocable()`.
+ */
+declare function expiring<T extends object>(obj: T): T;
+/**
+ * Wrap a generator, generator function, or generator method to run in parallel
+ * and have a result that can be waited on in parallel as well.
+ *
+ * Normally, when you `yield *` to a generator in a job function, you're
+ * *pausing* the current function until that generator is finished.  And
+ * normally, this is what you *want*, because you're not trying to do things in
+ * parallel.  But if you *do* want to do things in parallel, you need `fork`.
+ *
+ * Generators also can't normally be *waited on* in parallel either: if multiple
+ * jobs try to wait on an unfinished generator, the most likely result is an
+ * error or data corruption. (Because the extra `yield *` operations will make
+ * the generator think it's received data it was waiting for, causing all kinds
+ * of havoc.)
+ *
+ * So if you want a generator to either *run* in parallel or be *waited on* in
+ * parallel (or both), you need to `fork` it: either on the consuming side by
+ * wrapping a generator with `fork()`, or on the producing side by wrapping a
+ * generator function (or decorating a generator method).
+ *
+ * When called with a generator, `fork` returns a wrapped generator; when called
+ * with a function, it returns a wrapped version of the function that will fork
+ * its results.  And when used as a decorator (`@fork`, compatible with both
+ * TC39 and legacy decorator protocols), it wraps a method to fork its result as
+ * well.
+ *
+ * It is safe to call `fork()` more than once on the same generator, or to
+ * `fork()` an already-forked generator: the result will always be the same as
+ * the original fork.
+ *
+ * @remarks Note that while you can *also* make a generator run or be waitable
+ * in parallel using e.g. `start()`, the critical difference is in when resource
+ * cleanup happens. If you `start()` the generator (or wrap the generator
+ * function with `task`), its resources will be cleaned up when the generator
+ * function exits.
+ *
+ * With `yield*`, however (with or without `fork`), the resources are cleaned up
+ * when the original *calling* job ends.  And this is what you want when the
+ * generator's return value is some kind of resource using other active
+ * resources (such as event listeners rules, etc.) that need to *remain* active
+ * for the caller.
+ *
+ * (If you're familiar with the Effection framework, you may recognize this as
+ * the difference between "actions" and "resources": in Uneventful we use
+ * `start()` or `task()` for generators that return the result of an action, and
+ * `fork` for generators that return a resource that will be owned by the
+ * calling job.)
+ */
+declare function fork<T>(gen: Yielding<T>): Yielding<T>;
+declare function fork<T, F extends (...args: any[]) => Yielding<T>>(genFunc: F): F;
+/** @hidden TC39 decorator */
+declare function fork<T, F extends (...args: any[]) => Yielding<T>>(genFunc: F, ctx: {
+    kind: "method";
+}): F;
+/** @hidden legacy decorator */
+declare function fork<T, F extends (...args: any[]) => Yielding<T>, D extends {
+    value?: F;
+}>(clsOrProto: any, name: string | symbol, desc: D): D;
+
+export { expiring, fork, service };