diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 342eb34..86b0265 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -33,6 +33,10 @@ jobs:
           - shell: bash
             package: bash
             path: /bin/bash
+          # bash in POSIX mode, which is what /bin/sh is on a lot of machines.
+          - shell: bash --posix
+            package: bash
+            path: /bin/bash --posix
           - shell: ksh93
             package: ksh
             path: /bin/ksh93
@@ -42,6 +46,17 @@ jobs:
           - shell: zsh
             package: zsh
             path: /bin/zsh
+          # zsh emulating sh, which turns on word splitting and the POSIX
+          # builtins and is a different shell for everything here.
+          - shell: zsh --emulate sh
+            package: zsh
+            path: /bin/zsh --emulate sh
+          # Debian's policy-compliant shell: no more than POSIX, which is
+          # what makes it worth asking. It is the one that objected to $@
+          # with nothing behind it.
+          - shell: posh
+            package: posh
+            path: /bin/posh
           - shell: busybox ash
             package: busybox-static
             path: /usr/local/bin/ash
@@ -56,7 +71,8 @@ jobs:
         if: matrix.package == 'busybox-static'
         run: sudo ln -sf /bin/busybox /usr/local/bin/ash
       - run: make install-dev
-      - run: make test SHELLSPEC_FLAGS="--shell ${{ matrix.path }}"
+      # Quoted, because a shell here may come with options after it.
+      - run: make test SHELLSPEC_FLAGS='--shell "${{ matrix.path }}"'
 
   # BSD mktemp and BSD sleep, and a /bin/sh that is bash 3.2 in disguise.
   macos:
@@ -66,11 +82,11 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        shell: [/bin/sh, /bin/bash]
+        shell: [/bin/sh, /bin/bash, /bin/zsh]
     steps:
       - uses: actions/checkout@v7
       - run: make install-dev
-      - run: make test SHELLSPEC_FLAGS="--shell ${{ matrix.shell }}"
+      - run: make test SHELLSPEC_FLAGS='--shell "${{ matrix.shell }}"'
 
   # The benchmarks are a report, and a hosted runner is a noisy place to
   # take timings on, so the job only fails when a scenario was not faster in
diff --git a/Makefile b/Makefile
index 7b48b7b..74a44a3 100644
--- a/Makefile
+++ b/Makefile
@@ -16,15 +16,23 @@ SCRIPTS = parallel.sh examples/build.sh bench/bench.sh
 # nesting to keep and flattens the whole file to one column.
 SPECS = spec/parallel_spec.sh spec/spec_helper.sh
 
-.PHONY: check lint test bench install-dev
+.PHONY: check lint ascii test bench install-dev
 
 check: lint test
 
-lint:
+lint: ascii
 	shellcheck --shell=sh $(SCRIPTS) $(SPECS)
 	checkbashisms $(SCRIPTS)
 	shfmt -ln posix -d $(SCRIPTS)
 
+# Nothing here is anything but printable ASCII, comments included. A shell
+# reads a script through the locale, and yash in the C locale refuses one
+# carrying a byte sequence that locale cannot make a character of, which is
+# the locale a build container has when nobody set one. The box drawing bar
+# is written as its bytes in the one place it is needed.
+ascii:
+	! LC_ALL=C grep -n '[^[:print:][:blank:]]' $(SCRIPTS) $(SPECS)
+
 test:
 	@[ -x $(SHELLSPEC) ] || { echo "$(SHELLSPEC) is missing: make install-dev" >&2; exit 1; }
 	$(SHELLSPEC) $(SHELLSPEC_FLAGS)
diff --git a/README.md b/README.md
index 6e18f84..35768e3 100644
--- a/README.md
+++ b/README.md
@@ -24,12 +24,15 @@ After:
 set -e
 . ./parallel.sh
 
-chain "composer install --no-dev --no-interaction --prefer-dist --optimize-autoloader"
-chain "npm ci --audit false" "npm run build"
+chain "composer install" \
+	"composer install --no-dev --no-interaction --prefer-dist --optimize-autoloader"
+chain "npm build" "npm ci --audit false" "npm run build"
 
 run
 ```
 
+The first argument is what the chain is called; the rest are what it runs.
+
 Drawn out, with the times off a middling Laravel app. The second one
 finishes when its longest chain does rather than when its last command
 does:
@@ -81,7 +84,7 @@ composer install │ Generating optimized autoload files
        npm build │ ERR! Build failed in 4.21s
 
 [!] npm build exited 1
-[.] assets cancelled
+[.] composer install cancelled
 ```
 
 A line is printed once it is whole, so a command that writes a line in two
@@ -121,8 +124,32 @@ that code, it can be the last line of a build script:
 run
 ```
 
-Nothing else is public. `chain` and `run` are meant to be called once each,
-in that order.
+Nothing else is public. `chain` may be called as often as a build has chains
+to declare, and `run` once, after them.
+
+A chain that did not simply work ends on one of three lines, and both layouts
+use the same ones, so a build that greps for one finds it either way:
+
+- `[!] npm build exited 1` — the chain failed, and this is the code it failed
+  with.
+- `[.] npm build cancelled` — it was still running when another chain failed.
+- `[!] npm build killed` — it was taken away before it could report: the
+  signal nothing can catch, or the machine running out of memory. `run`
+  returns 137 for it, which is what a shell reports for a child SIGKILL took.
+
+Some smaller things worth knowing:
+
+- A chain reads its input from `/dev/null`, so nothing it runs can take what
+  the build script was going to read.
+- `chain` with no label at all writes to stderr and returns 2, which stops a
+  `set -e` build where it stands.
+- The library takes the `EXIT`, `INT` and `TERM` traps for itself, which is
+  how it takes the chains down with it and clears up after them. A build with
+  traps of its own should set them before sourcing, and expect them to be
+  replaced.
+- Every name it defines starts with an underscore, apart from `chain`, `run`
+  and the settings below. Nothing else in the calling script or in a chain's
+  commands is touched.
 
 ## POLL
 
@@ -143,6 +170,22 @@ depending on where it runs. The environment works everywhere too, so
 `POLL=0.5 ./build.sh` on a script that sources the library is the other way
 to do it.
 
+## GRACE
+
+A cancelled chain is asked to stop and then waited for, so that it is gone
+before the process group it leads is taken down and there is nobody left to
+announce the killing. `GRACE` is how many polls it gets before the signal
+nothing can ignore, a hundred of them by default, which at the default `POLL`
+is about ten seconds:
+
+```sh
+GRACE=300
+. ./parallel.sh
+```
+
+Without a bound, a build step that ignores `SIGTERM` would hold `run` open
+with no way out but Ctrl-C.
+
 ## STREAM
 
 Output is labelled and printed as it arrives. `STREAM=0` holds each chain's
@@ -163,9 +206,6 @@ Generating optimized autoload files
 added 214 packages
 building for production...
 [!] npm build exited 1
-
-... assets
-[.] assets cancelled
 ```
 
 `STREAM_SEP` is the bar between a label and its line. It defaults to `│`
@@ -249,15 +289,45 @@ Fractional `sleep` is not in POSIX, though both GNU coreutils and BSD accept
 it. Whole seconds are the fallback, not the default, so a build on a shell
 without fractional sleep finishes up to a second later than it might.
 
+The file itself is ASCII, comments included, and the box drawing bar is
+written as its bytes in the one place it is needed. A shell reads a script
+through the locale, and a strict one in the C locale refuses a file carrying
+a byte sequence that locale cannot make a character of, which is the locale a
+build container has when nobody has set one. `make lint` checks it.
+
 Under zsh, a script with `set -e` whose `run` fails leaves the temp
 directory behind: zsh skips `EXIT` traps when errexit is triggered by a
 function returning non-zero. Every other shell, and every other exit path
 under zsh, removes it.
 
-The library has no `local`, because POSIX sh has none. It keeps its own
-state in names starting with `_`, but its loops use `i`, `n`, `cmd`, `code`,
-`label`, `mark`, `seen`, `line` and `pending`, and sourcing it will clobber
-those in the calling script.
+The library has no `local`, because POSIX sh has none. Every name it uses
+starts with an underscore instead, including its loop counters, so a calling
+script and a chain's commands can use whatever they like as long as it does
+not start with one.
+
+A chain that something else kills is announced by bash as well as by the
+report: bash prints a line about the job to stderr when it reaps one that a
+signal ended, and there is no asking it not to. No other shell here says
+anything, and it only happens when a chain is taken from outside, which is
+worth a line either way.
+
+## Shells
+
+The suite runs under every shell below, on every push. The library is written
+for what they have in common, which is POSIX and not much more:
+
+| Where | Shells |
+| --- | --- |
+| Linux | dash, bash, bash `--posix`, ksh93, mksh, zsh, zsh `--emulate sh`, posh, busybox ash |
+| macOS | `/bin/sh` (bash 3.2), bash, zsh |
+| FreeBSD | `/bin/sh` |
+
+posh is Debian's policy-compliant shell, which is POSIX and deliberately
+nothing else; it is the one that objected to `"$@"` with no arguments behind
+it. bash in POSIX mode and zsh emulating sh are there because that is what
+`/bin/sh` is on a good many machines, and both differ from their own default
+mode in ways this library can feel. yash is not in the list: it is stricter
+still, and the library does run under it, but shellspec cannot drive it here.
 
 ## Prior art
 
diff --git a/parallel.sh b/parallel.sh
index 300cd00..7557536 100644
--- a/parallel.sh
+++ b/parallel.sh
@@ -1,6 +1,6 @@
 #!/bin/sh
 # shellcheck shell=sh
-# Run chains of commands in parallel. POSIX sh — no bashisms, no arrays.
+# Run chains of commands in parallel. POSIX sh: no bashisms, no arrays.
 #
 #   chain <label> <command> [command...]
 #   run
@@ -12,21 +12,50 @@
 #
 # With STREAM=0 the output is held instead, and printed in one block a chain
 # in declaration order.
+#
+# Every name this file defines starts with an underscore, apart from `chain`
+# and `run`. A calling script and the commands in a chain are free to use
+# anything else; anything starting with an underscore is this file's.
 
 POLL=${POLL:-0.1}           # seconds between checks
 POLL_WHOLE=${POLL_WHOLE:-1} # used instead if this sleep rejects fractions
 STREAM=${STREAM:-1}         # 0 to hold the output and print it grouped
 
+# How many polls a cancelled chain gets to leave on its own before it is
+# killed outright, which comes to about GRACE times POLL seconds: ten of them
+# by default. A chain that ignores SIGTERM would otherwise hold `run` open for
+# ever, and a build that hangs is worse than one that is rude.
+GRACE=${GRACE:-100}
+
 # The bar between a label and its line. A box drawing character reads as
 # three bytes of noise in a terminal that is not expecting UTF-8, and the
 # locale is what says whether it is, so the default follows the locale and
 # an ASCII pipe stands in everywhere else.
+#
+# The character is written as its bytes rather than as itself, because this
+# file has to be readable as text by whatever shell sources it: yash in the
+# C locale refuses to read a script with a byte sequence the locale cannot
+# make a character of, and a build container without a locale set is exactly
+# where that happens. Everything here is ASCII for that reason.
 case ${LC_ALL:-${LC_CTYPE:-${LANG:-}}} in
-*[Uu][Tt][Ff]8* | *[Uu][Tt][Ff]-8*) STREAM_SEP=${STREAM_SEP:-'│'} ;;
+*[Uu][Tt][Ff]8* | *[Uu][Tt][Ff]-8*) STREAM_SEP=${STREAM_SEP:-$(printf '\342\224\202')} ;;
 *) STREAM_SEP=${STREAM_SEP:-'|'} ;;
 esac
 
-_work=$(mktemp -d)
+# Somewhere to keep what has to travel between the chains and the script that
+# started them: a chain's log, and the status it ended on. What only this
+# shell ever looks at, a chain's label and its pid, is kept in a variable.
+#
+# An
+# explicit template because BSD mktemp wants one, and a check because
+# without the directory every path below is a bare filename and the library
+# would quietly write its bookkeeping into the working directory.
+_work=$(mktemp -d "${TMPDIR:-/tmp}/parallel.XXXXXX") || _work=''
+if [ -z "$_work" ] || [ ! -d "$_work" ]; then
+	printf 'parallel.sh: could not create a temporary directory\n' >&2
+	exit 1
+fi
+
 _count=0
 _failed=0
 _signal=0      # what to exit with if a signal arrives; 0 until one does
@@ -34,6 +63,14 @@ _fractional='' # whether sleep takes POLL; unknown until the first nap
 _groups=''     # whether a chain can have its own process group; unknown
 _monitor=''    # whether the calling shell had job control on already
 
+# POSIX sh has no arrays, so what a chain has one of is kept in a name with
+# the chain's number on the end of it, written and read through `eval`:
+# _label_1, _pid_1, _prefix_1, _seen_1. These are where one comes back out.
+_label=''
+_pid=''
+_prefix=''
+_seen=''
+
 _cleanup() { rm -rf "$_work" || :; }
 
 # Every exit goes through _finish, which is what makes the status the same
@@ -66,12 +103,15 @@ _finish() {
 # error worth reporting, so this cannot fail and cannot abandon the trap
 # that called it.
 _stop_chains() {
-	i=1
-	while [ "$i" -le "$_count" ]; do
-		if [ ! -f "$_work/$i.code" ] && [ -f "$_work/$i.pid" ]; then
-			_kill_chain "$(cat "$_work/$i.pid")" now
+	_i=1
+	while [ "$_i" -le "$_count" ]; do
+		# No pid where the script gave up between counting a chain and
+		# starting it, and nothing to kill in that case either.
+		eval "_pid=\${_pid_$_i:-}"
+		if [ ! -f "$_work/$_i.code" ] && [ -n "$_pid" ]; then
+			_kill_chain "$_pid" now
 		fi
-		i=$((i + 1))
+		_i=$((_i + 1))
 	done
 }
 
@@ -90,24 +130,46 @@ _stop_chains() {
 # is anything in it worth killing.
 #
 # `now` skips that wait, and the exit trap uses it. Nothing that trap kills
-# will be printed, so it has nothing to keep quiet for, and a chain that has
-# made itself deaf to the signal must not be able to hold the trap — and the
-# script — open while it waits for a shell that is not going to go.
+# will be printed, so it has nothing to keep quiet for, and the script is
+# already leaving, so there is nothing left to wait for it to be quiet for
+# either.
 #
 # Neither kill can fail: cancelling races the chain finishing on its own,
 # and this is called from the exit trap, which a failure would abandon.
 _kill_chain() {
 	kill "$1" 2>/dev/null || :
+	case $2 in
+	quietly) _await_exit "$1" ;;
+	esac
 	case $_groups in
-	yes)
-		case $2 in
-		quietly) wait "$1" 2>/dev/null || : ;;
-		esac
-		kill -- "-$1" 2>/dev/null || :
-		;;
+	yes) kill -- "-$1" 2>/dev/null || : ;;
 	esac
 }
 
+# Wait for a chain's shell to go, but not for ever. A chain that ignores
+# SIGTERM, whether it is a build step with a shutdown handler of its own or
+# one that has simply gone deaf, would otherwise hold `run` open with no way
+# out but Ctrl-C, so it gets GRACE polls and then the signal no process can
+# ignore.
+#
+# The kill is inside the loop, where the process was alive a moment ago,
+# rather than after it, where the chain may have gone and been reaped and
+# its pid handed to somebody else. `wait` afterwards reaps ours, and is the
+# reason `kill -0` keeps answering for a chain that is finished but not yet
+# collected.
+_await_exit() {
+	_left=$GRACE
+	while kill -0 "$1" 2>/dev/null; do
+		if [ "$_left" -le 0 ]; then
+			kill -9 "$1" 2>/dev/null || :
+			break
+		fi
+		_nap
+		_left=$((_left - 1))
+	done
+	wait "$1" 2>/dev/null || :
+}
+
 # Whether this shell will put a background job in a process group of its own,
 # which is what makes it possible to cancel a chain's children along with the
 # chain. Job control is POSIX, but a non-interactive shell is allowed to
@@ -119,7 +181,7 @@ _kill_chain() {
 # chains, and not in a subshell: a subshell is a different place to ask from
 # and gives different answers. mksh says the group is there and then will not
 # kill it, and FreeBSD's sh answered for a subshell what was not true of the
-# script — which is a probe reporting on itself rather than on the chains.
+# script, which is a probe reporting on itself rather than on the chains.
 #
 # A job that was given its own group leads that group, so a group with its
 # pid for an id exists. A job that was not is in the shell's group, and no
@@ -156,9 +218,14 @@ trap '_signal=130; _finish 130' INT
 trap '_signal=143; _finish 143' TERM
 
 chain() {
+	if [ "$#" -eq 0 ]; then
+		printf 'parallel.sh: chain needs a label\n' >&2
+		return 2
+	fi
+
 	_count=$((_count + 1))
-	n=$_count
-	printf '%s' "$1" >"$_work/$n.label"
+	_n=$_count
+	eval "_label_$_n=\$1"
 	shift
 
 	# Job control decides which process group a job starts in, and decides it
@@ -175,6 +242,14 @@ chain() {
 	# chain's, so it is this shell's stdout that has to point elsewhere while
 	# the chain starts. The chain's own output goes to its log either way, and
 	# a fork that fails still has stderr to say so on.
+	#
+	# stdin comes from /dev/null, and is the one thing here that is not about
+	# a shell being awkward. A background job in a shell without job control
+	# gets /dev/null anyway, and one in a shell with job control keeps the
+	# script's stdin and will read it: what that came to was a chain eating
+	# the input of the script that started it, on every shell with job
+	# control and on none of the ones without. Nothing a chain runs has any
+	# business reading the build's stdin, and now none of them can.
 	{
 		(
 			trap - INT TERM # don't inherit the parent's handlers
@@ -189,34 +264,34 @@ chain() {
 			# would be wrong about.
 			case $_groups in yes) set +m ;; esac
 
-			code=0
-			# Always leave a status behind, even if a command calls
-			# exit. Write, then rename, so the reader never sees a
-			# half-written file.
-			# shellcheck disable=SC2154 # ec is assigned in the same trap
-			trap 'ec=$?; [ "$code" -ne 0 ] || code=$ec
-				printf "%s" "$code" >"$_work/$n.code.part"
-				mv "$_work/$n.code.part" "$_work/$n.code"' EXIT
-
-			for cmd in "$@"; do
-				eval "$cmd" || {
-					code=$?
-					break
-				}
+			# Always leave a status behind, even for a command that calls
+			# exit itself: whatever ends this shell, the trap sees the
+			# status it ended on. Write, then rename, so a reader never
+			# sees a half-written file.
+			trap '_ec=$?
+				printf "%s" "$_ec" >"$_work/$_n.code.part"
+				mv "$_work/$_n.code.part" "$_work/$_n.code"' EXIT
+
+			# ${1+"$@"} rather than "$@", because a chain may have
+			# been given a label and nothing to do: posh in a
+			# script that set -u calls $@ with no arguments behind
+			# it an unset parameter, and stops there.
+			for _cmd in ${1+"$@"}; do
+				eval "$_cmd" || exit $?
 			done
-		) >"$_work/$n.log" 2>&1 &
+		) >"$_work/$_n.log" 2>&1 </dev/null &
 	} >/dev/null
 
-	printf '%s' "$!" >"$_work/$n.pid"
+	eval "_pid_$_n=\$!"
 
 	if [ "$_groups" = yes ] && [ "$_monitor" = no ]; then set +m; fi
 }
 
 run() {
-	_streaming && _prefixes
+	if _streaming; then _prefixes; fi
 	_await
 	_cancel
-	_streaming && _flush
+	if _streaming; then _emit_all last; fi
 	_report
 	return "$_failed"
 }
@@ -245,87 +320,110 @@ _nap() {
 # Wait for everything, or return early as soon as one chain fails
 _await() {
 	while :; do
-		_streaming && _pump
-		pending=0
-		i=1
-		while [ "$i" -le "$_count" ]; do
-			if [ -f "$_work/$i.code" ]; then
-				_failed=$(cat "$_work/$i.code")
+		if _streaming; then _emit_all now; fi
+		_pending=0
+		_i=1
+		while [ "$_i" -le "$_count" ]; do
+			_note_if_killed "$_i"
+			if [ -f "$_work/$_i.code" ]; then
+				_failed=$(cat "$_work/$_i.code")
 				# `return 0`, not a bare `return`: a bare one hands back
 				# the status of the test above, which aborts `run` in a
 				# script that set -e.
 				[ "$_failed" -eq 0 ] || return 0
 			else
-				pending=$((pending + 1))
+				_pending=$((_pending + 1))
 			fi
-			i=$((i + 1))
+			_i=$((_i + 1))
 		done
-		[ "$pending" -eq 0 ] && return 0
+		if [ "$_pending" -eq 0 ]; then return 0; fi
 		_nap
 	done
 }
 
+# A chain that is gone without having left a status behind was killed from
+# outside: the signal no process can catch, or the machine running out of
+# memory. Nothing is going to write that status now, so the wait above would
+# be for ever; the run has to end, and it has to end as a failure, because a
+# chain that was killed did not do the work it was given.
+#
+# Asked only of a chain that has not reported, and the report is looked for
+# again afterwards: a chain that finished in between wrote its status just
+# after we found the process gone, and that status is the true one. `kill -0`
+# is the whole of the test, because a chain of ours that has ended goes on
+# answering it until it is reaped, and `_cancel` is what reaps.
+_note_if_killed() {
+	if [ -f "$_work/$1.code" ]; then return 0; fi
+	eval "_pid=\$_pid_$1"
+	if kill -0 "$_pid" 2>/dev/null; then return 0; fi
+	if [ -f "$_work/$1.code" ]; then return 0; fi
+
+	: >"$_work/$1.killed"
+	# 137 is what a shell reports for a child that SIGKILL took, and the
+	# report says `killed` rather than this number, which the chain never
+	# chose. It is here because `run` has to return something.
+	printf '%s' 137 >"$_work/$1.code.part"
+	mv "$_work/$1.code.part" "$_work/$1.code"
+}
+
+# Stop whatever is still running, and leave every chain with either a status
+# or a cancellation, which is what lets the report read one or the other
+# without having to allow for neither.
 _cancel() {
-	i=1
-	while [ "$i" -le "$_count" ]; do
-		if [ ! -f "$_work/$i.code" ]; then
-			: >"$_work/$i.cancelled"
-			_kill_chain "$(cat "$_work/$i.pid")" quietly
+	_i=1
+	while [ "$_i" -le "$_count" ]; do
+		if [ ! -f "$_work/$_i.code" ]; then
+			: >"$_work/$_i.cancelled"
+			eval "_pid=\$_pid_$_i"
+			_kill_chain "$_pid" quietly
 		fi
-		i=$((i + 1))
+		_i=$((_i + 1))
 	done
 	wait 2>/dev/null || : # a killed job must not abort a script that set -e
 }
 
 # Whether output is streamed as it arrives rather than held and grouped.
 _streaming() {
-	case ${STREAM:-1} in
+	case $STREAM in
 	'' | 0 | no | off | false) return 1 ;;
 	*) return 0 ;;
 	esac
 }
 
 # The label a streamed line carries, one per chain, right aligned to the
-# longest of them so that the bars line up under each other. Labels are
-# known by the time `run` is called, which is the first moment a width can
-# be worked out, and they are kept in variables because the pump wants them
-# on every poll.
+# longest of them so that the bars line up under each other. Every label is
+# known by the time `run` is called, which is the first moment a width can be
+# worked out at all.
 _prefixes() {
 	_pad=0
-	i=1
-	while [ "$i" -le "$_count" ]; do
-		label=$(cat "$_work/$i.label")
-		[ "${#label}" -gt "$_pad" ] && _pad=${#label}
-		i=$((i + 1))
+	_i=1
+	while [ "$_i" -le "$_count" ]; do
+		eval "_label=\$_label_$_i"
+		if [ "${#_label}" -gt "$_pad" ]; then _pad=${#_label}; fi
+		_i=$((_i + 1))
 	done
 
-	i=1
-	while [ "$i" -le "$_count" ]; do
-		label=$(cat "$_work/$i.label")
-		while [ "${#label}" -lt "$_pad" ]; do label=" $label"; done
-		eval "_label_$i=\$label"
-		i=$((i + 1))
-	done
-}
-
-# What every chain has written since the last look round. The poll is the
-# only thing printing, so two chains that write at the same moment come out
-# as whole lines one after the other rather than mixed into each other.
-_pump() {
-	i=1
-	while [ "$i" -le "$_count" ]; do
-		_emit "$i" now
-		i=$((i + 1))
+	_i=1
+	while [ "$_i" -le "$_count" ]; do
+		eval "_label=\$_label_$_i"
+		_prefix=$(printf "%${_pad}s" "$_label")
+		eval "_prefix_$_i=\$_prefix"
+		_i=$((_i + 1))
 	done
 }
 
-# The rest of it, once the chains are done: what the last poll did not get
-# to, and the final line of a chain that ended without a newline.
-_flush() {
-	i=1
-	while [ "$i" -le "$_count" ]; do
-		_emit "$i" last
-		i=$((i + 1))
+# What every chain has written since the last look round, or, with `last`,
+# the rest of it, once the chains are done. The poll is the only thing
+# printing, so two chains that write at the same moment come out as whole
+# lines one after the other rather than mixed into each other.
+#
+# Its own counter, because the wait loop calls this from inside a loop of
+# its own and POSIX sh has no local variables.
+_emit_all() {
+	_e=1
+	while [ "$_e" -le "$_count" ]; do
+		_emit "$_e" "$1"
+		_e=$((_e + 1))
 	done
 }
 
@@ -334,30 +432,34 @@ _flush() {
 # that has no newline yet is left where it is, so a line written in two goes
 # out in one piece instead of as two labelled halves. `read` fails on that
 # partial line without counting it, which is what leaves it to be read again
-# next time round — until `last`, when there is no next time and what is
+# next time round, until `last`, when there is no next time and what is
 # there is all there will be.
 #
 # The loop reads a file rather than a pipe on purpose: a pipe would put it
-# in a subshell in most shells, and the count it keeps would go with it.
+# in a subshell in most shells, and the count it keeps would go with it. The
+# chunk is the one file here that is written more than once, so it is the one
+# redirection that has to say it means to overwrite: a calling script that
+# set -C would otherwise lose every line after the first poll.
 _emit() {
-	n=$1
-	eval "seen=\${_seen_$n:-0} label=\$_label_$n"
-	tail -n "+$((seen + 1))" "$_work/$n.log" \
-		>"$_work/$n.chunk" 2>/dev/null || return 0
-
-	line=''
-	while IFS= read -r line; do
-		printf '%s %s %s\n' "$label" "$STREAM_SEP" "$line"
-		seen=$((seen + 1))
-		line=''
-	done <"$_work/$n.chunk"
-
-	if [ -n "$line" ] && [ "$2" = last ]; then
-		printf '%s %s %s\n' "$label" "$STREAM_SEP" "$line"
-		seen=$((seen + 1))
+	_n=$1
+	eval "_seen=\${_seen_$_n:-0}"
+	eval "_prefix=\$_prefix_$_n"
+	tail -n "+$((_seen + 1))" "$_work/$_n.log" \
+		>|"$_work/$_n.chunk" 2>/dev/null || return 0
+
+	_line=''
+	while IFS= read -r _line; do
+		printf '%s %s %s\n' "$_prefix" "$STREAM_SEP" "$_line"
+		_seen=$((_seen + 1))
+		_line=''
+	done <"$_work/$_n.chunk"
+
+	if [ -n "$_line" ] && [ "$2" = last ]; then
+		printf '%s %s %s\n' "$_prefix" "$STREAM_SEP" "$_line"
+		_seen=$((_seen + 1))
 	fi
 
-	eval "_seen_$n=\$seen"
+	eval "_seen_$_n=\$_seen"
 }
 
 _report() {
@@ -365,41 +467,59 @@ _report() {
 	# run says nothing at the end about a chain that finished, and chains
 	# are cancelled by a failure and by nothing else, so a run that failed
 	# is exactly a run with something left to say.
-	_streaming && [ "$_failed" -ne 0 ] && printf '\n'
-	i=1
-	while [ "$i" -le "$_count" ]; do
-		label=$(cat "$_work/$i.label")
-		code=""
-		[ -f "$_work/$i.code" ] && code=$(cat "$_work/$i.code")
-
-		if [ -f "$_work/$i.cancelled" ]; then
-			mark="..."
-			code=""
-		elif [ "$code" = 0 ]; then
-			mark="---"
-		else
-			mark="[!]"
-		fi
+	if _streaming && [ "$_failed" -ne 0 ]; then printf '\n'; fi
 
+	_i=1
+	while [ "$_i" -le "$_count" ]; do
 		if _streaming; then
 			# Only what the output did not already say. A chain that
 			# finished said so line by line as it went, and a heading with
 			# nothing under it is a heading for nothing; what is left is
 			# the chain that failed and the chains that went down with it.
-			# The lines are the ones the grouped report ends a chain on, so
-			# a build that greps for one finds it either way.
-			if [ -f "$_work/$i.cancelled" ]; then
-				printf '[.] %s cancelled\n' "$label"
-			elif [ -n "$code" ] && [ "$code" -ne 0 ]; then
-				printf '[!] %s exited %s\n' "$label" "$code"
-			fi
+			_outcome "$_i"
 		else
-			printf '\n%s %s\n' "$mark" "$label"
-			cat "$_work/$i.log"
-			[ -n "$code" ] && [ "$code" -ne 0 ] &&
-				printf '[!] %s exited %s\n' "$label" "$code"
-			[ -f "$_work/$i.cancelled" ] && printf '[.] %s cancelled\n' "$label"
+			_group "$_i"
 		fi
-		i=$((i + 1))
+		_i=$((_i + 1))
 	done
 }
+
+# How a chain ended, or nothing at all if it simply worked. Both reports end
+# a chain on this line, so a build that greps for one finds it either way.
+_outcome() {
+	eval "_label=\$_label_$1"
+	if [ -f "$_work/$1.cancelled" ]; then
+		printf '[.] %s cancelled\n' "$_label"
+	elif [ -f "$_work/$1.killed" ]; then
+		printf '[!] %s killed\n' "$_label"
+	else
+		_code=$(cat "$_work/$1.code")
+		case $_code in
+		0) ;;
+		*) printf '[!] %s exited %s\n' "$_label" "$_code" ;;
+		esac
+	fi
+}
+
+# One chain's whole output under a heading of its own, which is what STREAM=0
+# asks for.
+_group() {
+	if [ -f "$_work/$1.cancelled" ]; then
+		_mark='...'
+	elif [ "$(cat "$_work/$1.code")" = 0 ]; then
+		_mark='---'
+	else
+		_mark='[!]'
+	fi
+
+	eval "_label=\$_label_$1"
+	printf '\n%s %s\n' "$_mark" "$_label"
+	cat "$_work/$1.log"
+	# A chain whose last line never got a newline would otherwise have the
+	# line below glued onto the end of it.
+	case $(tail -c 1 "$_work/$1.log" 2>/dev/null) in
+	'') ;;
+	*) printf '\n' ;;
+	esac
+	_outcome "$1"
+}
diff --git a/spec/parallel_spec.sh b/spec/parallel_spec.sh
index ad3382c..18ac77c 100644
--- a/spec/parallel_spec.sh
+++ b/spec/parallel_spec.sh
@@ -48,6 +48,96 @@ Describe 'parallel.sh'
 			The line 1 of output should equal "only | the one output"
 			The output should not include "--- only"
 		End
+
+		# The label and the bar are the only thing added to a line. What a
+		# command wrote is what comes out, whatever it happens to look like:
+		# a printf format, an option, a backslash, the spaces at either end.
+		It 'prints what a chain wrote and nothing else'
+			Data
+				#|set -eu
+				#|STREAM_SEP='|'
+				#|. "$LIB"
+				#|chain "odd" "printf '%s\n' '100% sure' '-n' 'a\\backslash' '  indented' 'two  spaces'"
+				#|run
+			End
+
+			When call driver
+			The status should equal 0
+			The line 1 of output should equal "odd | 100% sure"
+			The line 2 of output should equal "odd | -n"
+			The line 3 of output should equal "odd | a\\backslash"
+			The line 4 of output should equal "odd |   indented"
+			The line 5 of output should equal "odd | two  spaces"
+		End
+	End
+
+	# What a build declares, and the answers to declaring nothing much at all.
+	Describe 'declaring chains'
+		It 'has nothing to say when no chain was declared'
+			Data
+				#|set -eu
+				#|. "$LIB"
+				#|run
+				#|printf 'run returned %s\n' "$?"
+			End
+
+			When call driver
+			The status should equal 0
+			The output should equal "run returned 0"
+		End
+
+		It 'runs a chain that was given nothing to do'
+			Data
+				#|set -eu
+				#|. "$LIB"
+				#|chain "idle"
+				#|run
+				#|printf 'run returned %s\n' "$?"
+			End
+
+			When call driver
+			The status should equal 0
+			The output should equal "run returned 0"
+		End
+
+		# A chain needs a label, because the label is how its output is
+		# named. Saying so beats the shell's own complaint about $1.
+		It 'refuses a chain with no label'
+			Data
+				#|set -eu
+				#|. "$LIB"
+				#|chain || printf 'chain returned %s\n' "$?"
+				#|run
+			End
+
+			When call driver
+			The status should equal 0
+			The output should equal "chain returned 2"
+			The stderr should include "chain needs a label"
+		End
+
+		It 'keeps a dozen chains apart'
+			Data
+				#|set -eu
+				#|STREAM_SEP='|'
+				#|. "$LIB"
+				#|i=1
+				#|while [ "$i" -le 12 ]; do
+				#|	chain "chain-$i" "printf 'from %s\n' $i"
+				#|	i=$((i + 1))
+				#|done
+				#|run >"$WORK/out"
+				#|cat "$WORK/out"
+				#|printf 'lines %s\n' "$(grep -c 'from ' "$WORK/out")"
+			End
+
+			When call driver
+			The status should equal 0
+			The output should include " chain-1 | from 1"
+			The output should include "chain-12 | from 12"
+			# One line a chain, and every one of them accounted for.
+			The output should include "lines 12"
+		End
 	End
 
 	Describe 'ordering within a chain'
@@ -172,6 +262,222 @@ Describe 'parallel.sh'
 			The output should include "[.] slow cancelled"
 			The value "$(process_state "$WORK/childpid")" should equal "stopped"
 		End
+
+		# Cancelling asks a chain to go and then waits for it, so that the
+		# chain is gone before the group it leads is taken and there is
+		# nobody left to announce the killing. A chain that never answers
+		# would hold that wait, and the build, open for ever. It gets GRACE
+		# polls and then the signal nothing can ignore.
+		#
+		# GRACE is five here only so the example does not sit through the
+		# default; what is being tested is that the wait ends at all.
+		It 'gives up on a chain that will not answer the signal'
+			Data
+				#|set -eu
+				#|GRACE=5
+				#|. "$LIB"
+				#|chain "deaf" \
+				#|	"trap '' TERM; touch '$WORK/deaf-started'" \
+				#|	"until [ -f '$WORK/done' ] || [ ! -d '$WORK' ]; do sleep 1; done"
+				#|chain "quick" \
+				#|	"until [ -f '$WORK/deaf-started' ]; do sleep 1; done" \
+				#|	"exit 8"
+				#|run
+			End
+
+			When call driver
+			The status should equal 8
+			The output should include "[.] deaf cancelled"
+			# The driver reached its own end rather than being killed by
+			# the harness, which is the whole of the claim.
+			The stderr should not include "did not finish within"
+		End
+	End
+
+	# A chain is a process, and a process can be taken away: the signal no
+	# process can catch, the machine running out of memory. It leaves no
+	# status behind when it goes, and nothing is ever going to write one, so
+	# waiting for one is waiting for ever.
+	Describe 'a chain that is killed from outside'
+		It 'reports it rather than waiting for a status that will never come'
+			Data
+				#|set -eu
+				#|. "$LIB"
+				#|chain "victim" \
+				#|	"until [ -f '$WORK/done' ] || [ ! -d '$WORK' ]; do sleep 1; done"
+				#|printf '%s\n' "$!" >"$WORK/chainpid"
+				#|( sleep 1; kill -9 "$(cat "$WORK/chainpid")" ) &
+				#|run
+			End
+
+			When call driver
+			# 137 is what a shell reports for a child SIGKILL took, and is
+			# here because `run` has to return something. What the report
+			# says is that the chain was killed, which is what happened.
+			The status should equal 137
+			The output should include "[!] victim killed"
+			The stderr should not include "did not finish within"
+		End
+	End
+
+	# A build script is entitled to its own shell options and its own
+	# variables, and the library is a guest in that shell.
+	Describe 'the script that sourced it'
+		It "leaves the caller's own variables alone"
+			Data
+				#|set -eu
+				#|. "$LIB"
+				#|i=alpha n=beta cmd=gamma code=delta label=epsilon
+				#|mark=zeta seen=eta line=theta pending=iota pad=kappa ec=lambda
+				#|chain "guest" "printf 'ran\n'"
+				#|run >/dev/null
+				#|printf '%s\n' "$i $n $cmd $code $label $mark $seen $line $pending $pad $ec"
+			End
+
+			When call driver
+			The status should equal 0
+			The line 1 of output should equal \
+				"alpha beta gamma delta epsilon zeta eta theta iota kappa lambda"
+		End
+
+		# noclobber turns every plain > into a refusal to overwrite, and the
+		# library rewrites one file on every poll. Without saying that it
+		# means to, a build that set -C would lose every line after the
+		# first one and get a complaint a poll instead.
+		It 'streams under a caller that set -C'
+			Data
+				#|set -euC
+				#|STREAM_SEP='|'
+				#|. "$LIB"
+				#|chain "first" "printf 'the first line\n'"
+				#|chain "second" \
+				#|	"until grep -q 'the first line' '$WORK/out' 2>/dev/null ||
+				#|		[ ! -d '$WORK' ]; do sleep 1; done" \
+				#|	"printf 'the second line\n'"
+				#|run >"$WORK/out"
+				#|cat "$WORK/out"
+			End
+
+			When call driver
+			The status should equal 0
+			# The second chain only writes once it has seen the first
+			# chain's line already printed, so both lines here means at
+			# least two polls wrote a chunk, and the second one worked.
+			The output should include " first | the first line"
+			The output should include "second | the second line"
+			The stderr should equal ""
+		End
+
+		It 'groups under a caller that set -C'
+			Data
+				#|set -euC
+				#|STREAM=0
+				#|. "$LIB"
+				#|chain "slow" \
+				#|	"touch '$WORK/slow-started'" \
+				#|	"until [ -f '$WORK/done' ] || [ ! -d '$WORK' ]; do sleep 1; done"
+				#|chain "broken" \
+				#|	"until [ -f '$WORK/slow-started' ]; do sleep 1; done" \
+				#|	"exit 2"
+				#|run
+			End
+
+			When call driver
+			The status should equal 2
+			The output should include "[.] slow cancelled"
+			The output should include "[!] broken exited 2"
+			The stderr should equal ""
+		End
+
+		# Nothing a chain runs has any business reading the build's input,
+		# and a shell with job control would otherwise hand it over: the
+		# chain would eat what the script was going to read.
+		It "leaves the build's stdin to the build"
+			Data
+				#|set -eu
+				#|printf 'first line\nsecond line\n' >"$WORK/input"
+				#|exec <"$WORK/input"
+				#|. "$LIB"
+				#|chain "greedy" "cat >'$WORK/eaten'"
+				#|run >/dev/null
+				#|printf 'the script read: '
+				#|head -n 1
+			End
+
+			When call driver
+			The status should equal 0
+			The output should equal "the script read: first line"
+			The value "$(cat "$WORK/eaten")" should equal ""
+		End
+	End
+
+	# A command in a chain runs in the chain's own shell, so the names that
+	# shell is using are names the command can take away. Everything the
+	# library keeps there starts with an underscore for that reason: a build
+	# step counting with `i`, or keeping a status in `code`, would otherwise
+	# move the file the chain reports itself through and leave `run` waiting
+	# on a chain that had already finished.
+	Describe 'a chain command that uses ordinary variable names'
+		It 'runs and reports like any other'
+			Data
+				#|set -eu
+				#|STREAM_SEP='|'
+				#|. "$LIB"
+				#|chain "common" \
+				#|	"i=3 n=99 code=7 cmd=x label=y work=z; printf 'one\n'" \
+				#|	"printf 'two\n'"
+				#|run
+				#|printf 'run returned %s\n' "$?"
+			End
+
+			When call driver
+			The status should equal 0
+			The output should include "common | one"
+			The output should include "common | two"
+			The output should include "run returned 0"
+			The stderr should not include "did not finish within"
+		End
+	End
+
+	# The bar between a label and its line is a box drawing character where
+	# the locale says the terminal can show one, and an ASCII pipe where it
+	# does not. The library reads the locale rather than assuming it, and it
+	# is written in ASCII itself so that a shell reading it in the C locale
+	# has nothing to choke on.
+	Describe 'the locale'
+		It 'uses an ASCII bar where the locale is not UTF-8'
+			Data
+				#|set -eu
+				#|LC_ALL=C
+				#|export LC_ALL
+				#|. "$LIB"
+				#|chain "one" "printf 'a line\n'"
+				#|run
+			End
+
+			When call driver
+			The status should equal 0
+			The line 1 of output should equal "one | a line"
+		End
+
+		It 'uses a box drawing bar where the locale is UTF-8'
+			Data
+				#|set -eu
+				#|LC_ALL=C.UTF-8
+				#|export LC_ALL
+				#|. "$LIB"
+				#|chain "one" "printf 'a line\n'"
+				#|run
+			End
+
+			When call driver
+			The status should equal 0
+			The line 1 of output should equal "one $(printf '\342\224\202') a line"
+			# A shell without that locale installed says so, and the bar is
+			# chosen from the name rather than from the locale itself, so
+			# the complaint changes nothing here.
+			The stderr should not include "did not finish within"
+		End
 	End
 
 	# STREAM=0 holds each chain's output and prints it in one block instead,
@@ -221,6 +527,24 @@ Describe 'parallel.sh'
 			The line 7 of output should equal "[!] broken exited 2"
 		End
 
+		# A chain whose last line never got a newline would otherwise have
+		# the line below it printed onto the end of it.
+		It 'keeps the closing line off the end of an unfinished one'
+			Data
+				#|set -eu
+				#|STREAM=0
+				#|. "$LIB"
+				#|chain "abrupt" "printf 'no newline here'; exit 5"
+				#|run
+			End
+
+			When call driver
+			The status should equal 5
+			The line 2 of output should equal "[!] abrupt"
+			The line 3 of output should equal "no newline here"
+			The line 4 of output should equal "[!] abrupt exited 5"
+		End
+
 		It "collects a command's stdout and stderr into its own group"
 			Data
 				#|set -eu
@@ -307,6 +631,54 @@ Describe 'parallel.sh'
 	End
 
 	Describe 'cleanup'
+		# Everything the library keeps is under one directory, so there is
+		# nowhere for its bookkeeping to go if it cannot have one. Without
+		# saying so it would write `1.log` and `1.code` into whatever
+		# directory the build happened to be run from.
+		It 'stops rather than scatter its files when it can have no temp directory'
+			Skip if "this shell brings its own mktemp, so a fake cannot stand in for it" mktemp_is_builtin
+
+			Data
+				#|set -eu
+				#|mkdir -p "$WORK/bin"
+				#|printf '#!/bin/sh\nexit 1\n' >"$WORK/bin/mktemp"
+				#|chmod +x "$WORK/bin/mktemp"
+				#|PATH="$WORK/bin:$PATH"
+				#|export PATH
+				#|cd "$WORK"
+				#|. "$LIB"
+				#|printf 'kept going\n'
+			End
+
+			When call driver
+			The status should equal 1
+			The output should not include "kept going"
+			The stderr should include "could not create a temporary directory"
+			The file "$WORK/1.log" should not be exist
+		End
+
+		# TMPDIR is wherever the machine says, and on a laptop that is a
+		# path with a space in it often enough.
+		It 'works where the temp directory has a space in its path'
+			Data
+				#|set -eu
+				#|STREAM_SEP='|'
+				#|mkdir -p "$WORK/a spaced dir"
+				#|TMPDIR="$WORK/a spaced dir"
+				#|export TMPDIR
+				#|. "$LIB"
+				#|printf '%s\n' "$_work" >"$WORK/workdir"
+				#|chain "one" "printf 'a line\n'"
+				#|run
+			End
+
+			When call driver
+			The status should equal 0
+			The line 1 of output should equal "one | a line"
+			The value "$(reported_workdir)" should include "a spaced dir"
+			The directory "$(reported_workdir)" should not be exist
+		End
+
 		It 'removes its temp directory on a normal exit'
 			Data
 				#|set -eu
@@ -341,9 +713,9 @@ Describe 'parallel.sh'
 
 		# A signal is the one way out that the cancel path never sees, so
 		# unless the library stops the chains itself an interrupted build
-		# leaves whatever it started still running. That is its own bug —
-		# the point of Ctrl-C is that the compiler stops too — and it is
-		# also what stalls CI: a macOS runner does not finish a step while
+		# leaves whatever it started still running. That is its own bug,
+		# since the point of Ctrl-C is that the compiler stops too, and it
+		# is also what stalls CI: a macOS runner does not finish a step while
 		# a process the step started is alive, so a chain nobody killed
 		# holds the job open until it times out, minutes after the suite
 		# has passed.
@@ -482,6 +854,29 @@ Describe 'parallel.sh'
 			The output should include "[!] broken exited 3"
 		End
 
+		# The poll is the only thing printing, so two chains that write at
+		# the same moment come out as whole lines one after the other
+		# rather than as halves of each other.
+		It 'keeps the lines whole when two chains write at once'
+			Data
+				#|set -eu
+				#|STREAM_SEP='|'
+				#|. "$LIB"
+				#|chain "aaa" \
+				#|	"i=0; while [ \$i -lt 300 ]; do printf 'AAAAAAAAAA\n'; i=\$((i + 1)); done"
+				#|chain "bbb" \
+				#|	"i=0; while [ \$i -lt 300 ]; do printf 'BBBBBBBBBB\n'; i=\$((i + 1)); done"
+				#|run >"$WORK/out"
+				#|printf 'lines %s, malformed %s\n' \
+				#|	"$(grep -c . "$WORK/out")" \
+				#|	"$(grep -cv '^\(aaa\|bbb\) | [AB]\{10\}$' "$WORK/out" || true)"
+			End
+
+			When call driver
+			The status should equal 0
+			The output should equal "lines 600, malformed 0"
+		End
+
 		It "labels what a command writes to stderr as well"
 			Data
 				#|set -eu
diff --git a/spec/spec_helper.sh b/spec/spec_helper.sh
index ae782cd..3e47aaa 100644
--- a/spec/spec_helper.sh
+++ b/spec/spec_helper.sh
@@ -44,8 +44,13 @@ teardown_workdir() {
 # shellspec's own pipes, and it waits on them for as long as a stray holds
 # them open. Closing an fd that was never open is not an error in any of the
 # shells this suite runs under.
+#
+# The shell is left unquoted because it may come with options: `--shell "bash
+# --posix"` is a different shell from bash for everything the library cares
+# about, and splitting the words is how it gets to be one.
 start_driver() {
-	"$SHELLSPEC_SHELL" "$WORK/driver.sh" 3>&- 4>&- 5>&- 6>&- 7>&- 8>&- 9>&-
+	# shellcheck disable=SC2086 # the shell under test may carry options
+	$SHELLSPEC_SHELL "$WORK/driver.sh" 3>&- 4>&- 5>&- 6>&- 7>&- 8>&- 9>&-
 }
 
 # The same driver, but for the background, and `exec` is the whole point of
@@ -57,7 +62,8 @@ start_driver() {
 # example. Replacing the subshell with the driver keeps the pid the same one
 # the watchdog was given.
 spawn_driver() {
-	exec "$SHELLSPEC_SHELL" "$WORK/driver.sh" 3>&- 4>&- 5>&- 6>&- 7>&- 8>&- 9>&-
+	# shellcheck disable=SC2086 # the shell under test may carry options
+	exec $SHELLSPEC_SHELL "$WORK/driver.sh" 3>&- 4>&- 5>&- 6>&- 7>&- 8>&- 9>&-
 }
 
 detach() {
@@ -214,12 +220,13 @@ process_state() {
 # anyway, and zsh refuses it outright without a terminal.
 #
 # The library is asked rather than a copy of its probe run here: a copy can
-# answer differently from the real one — the FreeBSD runner had them
-# disagree — and then an example is skipped that should have run, or run
-# that should have been skipped, and the failure reads as a broken kill.
+# answer differently from the real one, as the FreeBSD runner had them do,
+# and then an example is skipped that should have run, or run that should
+# have been skipped, and the failure reads as a broken kill.
 no_process_groups() {
-	# shellcheck disable=SC2016 # the probe is the other shell's to expand
-	[ "$("$SHELLSPEC_SHELL" -c '. "$LIB"; _probe_groups; printf %s "$_groups"' \
+	# shellcheck disable=SC2016,SC2086 # the probe is the other shell's to
+	# expand, and that shell may carry options
+	[ "$($SHELLSPEC_SHELL -c '. "$LIB"; _probe_groups; printf %s "$_groups"' \
 		2>/dev/null)" != yes ]
 }
 
@@ -227,19 +234,31 @@ lines_in() {
 	wc -l <"$1" | tr -d ' '
 }
 
-# True when this shell runs `sleep` from PATH, which is what lets a spec put
-# a fake one in front of it. ksh93 has sleep as a builtin, and busybox ash
-# runs its own applet, so on those two a fake is simply not reachable.
-sleep_is_builtin() {
+# Whether this shell provides a command itself rather than running the one on
+# PATH, which is what says whether a spec can put a fake in front of it.
+# ksh93 has `sleep` built in and busybox resolves its own applets whatever
+# PATH says, so on those a fake is simply not reachable and the examples that
+# need one have nothing to test.
+#
+# The probe runs the command for real when the fake was not reached, so it
+# runs with TMPDIR pointing into the probe directory and everything it may
+# have made goes with it.
+provides_own() {
 	_probe=$(mktemp -d "${TMPDIR:-/tmp}/parallel-probe.XXXXXX")
-	printf '#!/bin/sh\nexit 42\n' >"$_probe/sleep"
-	chmod +x "$_probe/sleep"
+	printf '#!/bin/sh\nexit 42\n' >"$_probe/$1"
+	chmod +x "$_probe/$1"
 	(
 		PATH="$_probe:$PATH"
-		export PATH
-		sleep 0
-	)
+		TMPDIR="$_probe"
+		export PATH TMPDIR
+		shift
+		"$@"
+	) >/dev/null 2>&1
 	_probe_status=$?
 	rm -rf "$_probe"
 	[ "$_probe_status" -ne 42 ]
 }
+
+sleep_is_builtin() { provides_own sleep sleep 0; }
+
+mktemp_is_builtin() { provides_own mktemp mktemp -d; }