diff --git a/package.json b/package.json
index 61957d5..ed53ae6 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
     "name": "uneventful",
-    "version": "0.0.3",
+    "version": "0.0.4",
     "description": "Declarative, event-driven reactivity: signals, streams, structured concurrency, and easy resource cleanup",
     "keywords": [
         "signals",
diff --git a/src/async.ts b/src/async.ts
index 1ef51c4..8aade97 100644
--- a/src/async.ts
+++ b/src/async.ts
@@ -2,7 +2,7 @@ import { Request, Yielding } from "./types.ts";
 import { rejecter, resolve, resolver } from "./results.ts"
 
 /**
- * Convert a promise to something you can `yield *to()` in a job
+ * Convert a (possible) promise to something you can `yield *to()` in a job
  *
  * Much like `await valueOrPromiseLike` in an async function, using `yield
  * *to(valueOrPromiseLike)` in a {@link Job}'s generator function will return
diff --git a/src/signals.ts b/src/signals.ts
index b70221a..76a217a 100644
--- a/src/signals.ts
+++ b/src/signals.ts
@@ -259,7 +259,7 @@ export function peek<F extends PlainFunction>(fn: F, ...args: Parameters<F>): Re
  * on every call to recalcWhen().
  *
  * If the source needs to reference some object, it's best to use the 2-argument
- * version (i.e. `changesWhen(someObj, factory)`, where `factory` is a function
+ * version (i.e. `recalcWhen(someObj, factory)`, where `factory` is a function
  * that takes `someObj` and returns a suitable {@link RecalcSource}.)
  *
  * @remarks
diff --git a/src/sinks.ts b/src/sinks.ts
index 18863c2..dd46720 100644
--- a/src/sinks.ts
+++ b/src/sinks.ts
@@ -163,18 +163,18 @@ function waitTruthy<T>(job: Job<T>, v: T) { v && job.return(v); }
  * processed with `yield *` within a {@link Job}).
  *
  * This differs from {@link until}() in that it waits for the *next* value
- * (truthy or not!), and it never resumes immediately for signals, but instead waits
- * for the signal to *change*.  (Also, it does not support zero-argument functions,
- * unless you wrap them with {@link cached}() first.)
+ * (truthy or not!), and it never resumes immediately for signals, but instead
+ * waits for the signal to *change*.  (Also, it does not support zero-argument
+ * functions, unless you wrap them with {@link cached}() first.)
  *
  * @param source The source to wait on, which can be:
  * - An object with an `"uneventful.next"` method returning a {@link Yielding}
  *   (in which case the result will be the the result of calling that method)
  * - A {@link Signal} or {@link Source} (in which case the job resumes on the
- *  next value it produces)
+ *   next value it produces)
  *
- * (Note: if the supplied source has a non-zero `.length`, it is assumed to be a
- * {@link Source}.)
+ * (Note: if the supplied source is a function with a non-zero `.length`, it is
+ * assumed to be a {@link Source}.)
  *
  * @returns a Yieldable that when processed with `yield *` in a job, will return
  * the triggered event, or signal value.  An error is thrown if event stream
diff --git a/src/types.ts b/src/types.ts
index 906234f..3e4681e 100644
--- a/src/types.ts
+++ b/src/types.ts
@@ -167,7 +167,7 @@ export interface Job<T=any> extends Yielding<T>, Promise<T> {
      * In order to ensure that all such "child" jobs, resources, and activities
      * are marked as canceled *before* any side effects (such as events,
      * callbacks or I/O operations) can occur, Uneventful prioritizes *all*
-     * release callbacks to run before *any* other callbacks of any kind.  since
+     * release callbacks to run before *any* other callbacks of any kind.  Since
      * release callbacks are used for child jobs, this means that the entire job
      * subtree is notified immediately of cancellation, before any other actions
      * are taken.  This ensures that no "stray" operations can continue, unaware