async-lube 2.0.0 → 2.1.0

package/src/flow/nodes.js

@@ -73,22 +73,27 @@ function apply_value(c, name, value) {
 	set_status(c, record, "skipped")
 	delete c.results[name]
 	enter(c, targets, name)
-	if (c.run_status != "running") return
+	if (c.run_status != "running") {
+		return
+	}
 	if (record.status == "skipped") {
 		kill_transitions(c, name)
-		for (const dependent of record.node.dependents) try_start(c, dependent)
-		if (record.backlog.length > record.backlog_head || record.retrigger) defer(c, () => run_next(c, name))
+		for (const dependent of record.node.dependents) {
+			try_start(c, dependent)
+		}
+		if (record.backlog.length > record.backlog_head || record.retrigger) {
+			defer(c, () => run_next(c, name))
+		}
 	}
 	drain(c)
 	schedule(c)
 }
 /**
- * @param {RunContext} c
  * @param {NodeRecord} record
  * @returns {unknown[]}
  */
-export function args_of(c, record) {
-	return record.args ?? values_for(c, record)
+export function args_of(record) {
+	return /** @type {unknown[]} */(record.args)/**/
 }
 /**
  * @param {RunContext} c
@@ -97,12 +102,14 @@ export function args_of(c, record) {
  */
 export function clear_record(c, record) {
 	const { name, options } = record.node
-	if (options.release && record.status == "done" && !record.released) release_quietly(
-		record,
-		new CancelError(
-			`Flow node "${name}" was reset`
+	if (options.release && record.status == "done" && !record.released) {
+		release_quietly(
+			record,
+			new CancelError(
+				`Flow node "${name}" was reset`
+			)
 		)
-	)
+	}
 	stop_record(
 		c,
 		record,
@@ -112,12 +119,16 @@ export function clear_record(c, record) {
 			)
 			: void 0
 	)
-	if (record.status == "done") record.previous = record.result
+	if (record.status == "done") {
+		record.previous = record.result
+	}
 	delete c.errors[name]
 	if (record.node.each) {
 		const prefix = name + "."
 		for (const key of Object.keys(c.errors)) {
-			if (key.startsWith(prefix)) delete c.errors[key]
+			if (key.startsWith(prefix)) {
+				delete c.errors[key]
+			}
 		}
 	}
 	record.abandoned = false
@@ -150,7 +161,9 @@ export function clear_record(c, record) {
 function drop(c, name, error) {
 	c.errors[name] = error
 	settle(c, name, "skipped", void 0)
-	for (const dep of get_record(c, name).node.deps) release_unused(c, dep, error)
+	for (const dep of get_record(c, name).node.deps) {
+		release_unused(c, dep, error)
+	}
 }
 /**
  * @param {RunContext} c
@@ -185,7 +198,9 @@ export function fail(c, name, error) {
 		new CancelError("The flow failed"),
 		true
 	)
-	if (!c.cycle.settled) close_cycle(c, failure, void 0)
+	if (!c.cycle.settled) {
+		close_cycle(c, failure, void 0)
+	}
 }
 /**
  * @param {RunContext} c
@@ -220,9 +235,7 @@ export function forget_runs(record) {
  * @returns {NodeRecord}
  */
 export function get_record(c, name) {
-	const record = c.records.get(name)
-	if (!record) throw Error(`Unknown flow node "${name}"`)
-	return record
+	return /** @type {NodeRecord} */(c.records.get(name))/**/
 }
 /**
  * @param {RunContext} c
@@ -236,12 +249,14 @@ async function handle_error(c, name, error, from_items, index) {
 	const record = get_record(c, name)
 	const token = record.token
 	const { fallback, options } = record.node
-	if (index != null) c.errors[name + "." + index] = error
+	if (index != null) {
+		c.errors[name + "." + index] = error
+	}
 	if (options.catch && !from_items) {
 		try {
 			const value = await options.catch(
 				error,
-				...args_of(c, record),
+				...args_of(record),
 				make_context(
 					c,
 					record,
@@ -251,22 +266,32 @@ async function handle_error(c, name, error, from_items, index) {
 					record.runs.get("")
 				)
 			)
-			if (token != record.token) return
+			if (token != record.token) {
+				return
+			}
 			c.errors[name] = error
 			apply_value(c, name, value)
 		} catch (catch_error) {
-			if (token != record.token) return
-			if (record.abandoned) drop(c, name, catch_error)
-			else fail(c, name, catch_error)
+			if (token != record.token) {
+				return
+			}
+			if (record.abandoned) {
+				drop(c, name, catch_error)
+			} else {
+				fail(c, name, catch_error)
+			}
 		}
-	} else if (record.abandoned) drop(c, name, error)
-	else if (fallback.length) {
+	} else if (record.abandoned) {
+		drop(c, name, error)
+	} else if (fallback.length) {
 		c.errors[name] = error
 		apply_value(c, name, { [GOTO]: fallback })
 	} else if (options.optional && !from_items) {
 		c.errors[name] = error
 		settle(c, name, "failed", void 0)
-	} else fail(c, name, error)
+	} else {
+		fail(c, name, error)
+	}
 }
 /**
  * @param {NodeRecord} record
@@ -311,7 +336,9 @@ function launch(c, record, args) {
 			return false
 		}
 	} catch (error) {
-		if (c.run_status != "running" || record.status != "idle") return false
+		if (c.run_status != "running" || record.status != "idle") {
+			return false
+		}
 		record.args = args
 		if (kind == "input" || each) {
 			fail_input(c, record, error)
@@ -319,7 +346,9 @@ function launch(c, record, args) {
 		}
 		record.gate = { error }
 	}
-	if (c.run_status != "running" || record.status != "idle") return false
+	if (c.run_status != "running" || record.status != "idle") {
+		return false
+	}
 	record.args = args
 	if (kind == "input" && record.buffer) {
 		const { value } = record.buffer
@@ -337,22 +366,21 @@ function launch(c, record, args) {
 		set_status(c, record, "waiting")
 		if (options.timeout) {
 			const timeout = options.timeout
-			const token = record.token
 			const deadline = record.resume_deadline ?? Date.now() + timeout
 			record.deadline = deadline
 			record.resume_deadline = void 0
-			/**
-			 * @returns {void}
-			 */
+			/** @returns {void} */
 			function expire() {
-				if (record.status != "waiting" || token != record.token) return
 				const left = deadline - Date.now()
-				if (left > 0) record.timer = setTimeout(expire, clamp_delay(left))
-				else fail_input(
-					c,
-					record,
-					new TimeoutError(timeout)
-				)
+				if (left > 0) {
+					record.timer = setTimeout(expire, clamp_delay(left))
+				} else {
+					fail_input(
+						c,
+						record,
+						new TimeoutError(timeout)
+					)
+				}
 			}
 			record.timer = setTimeout(
 				expire,
@@ -362,7 +390,9 @@ function launch(c, record, args) {
 	} else if (c.running >= c.concurrency) {
 		set_status(c, record, "pending")
 		c.queue.push(name)
-	} else start(c, name)
+	} else {
+		start(c, name)
+	}
 	return true
 }
 /**
@@ -372,9 +402,11 @@ function launch(c, record, args) {
  */
 export function name_or_throw(c, target) {
 	const name = c.program.name_of(target)
-	if (name == null) throw Error(
-		`${describe(target)} is not added to the flow`
-	)
+	if (name == null) {
+		throw Error(
+			`${describe(target)} is not added to the flow`
+		)
+	}
 	return name
 }
 /**
@@ -384,18 +416,30 @@ export function name_or_throw(c, target) {
  */
 function needs(c, name) {
 	const record = get_record(c, name)
-	if (!record.activated || record.status != "idle" && !(record.retrigger && active_statuses.has(record.status))) return false
+	if (!record.activated || record.status != "idle" && !(record.retrigger && active_statuses.has(record.status))) {
+		return false
+	}
 	const { arrive, deps, options } = record.node
 	for (const dep of deps) {
 		const dep_record = get_record(c, dep)
-		if (dep_record.fatal) return false
-		if (dep_record.node.options.release && !settled_statuses.has(dep_record.status)) continue
+		if (dep_record.fatal) {
+			return false
+		}
+		if (dep_record.node.options.release && !settled_statuses.has(dep_record.status)) {
+			continue
+		}
 		if (arrive?.[dep] == "queue") {
-			if (!record.queued?.get(dep)?.length) return false
+			if (!record.queued?.get(dep)?.length) {
+				return false
+			}
 			continue
 		}
-		if (!settled_statuses.has(dep_record.status)) return false
-		if (dep_record.status == "skipped" && (options.join ?? "all") == "all") return false
+		if (!settled_statuses.has(dep_record.status)) {
+			return false
+		}
+		if (dep_record.status == "skipped" && (options.join ?? "all") == "all") {
+			return false
+		}
 	}
 	return !options.release || !record.node.dependents.length || record.node.dependents.some(
 		dependent => needs(c, dependent)
@@ -449,10 +493,13 @@ export function plan_retry(record) {
  */
 export function prepare_restart(c, record) {
 	record.fatal = false
-	if (record.args && !same_args(c, record)) forget_runs(record)
-	else {
+	if (record.args && !same_args(c, record)) {
+		forget_runs(record)
+	} else {
 		record.resume_items = record.items ?? record.resume_items
-		if (record.sub_runs.size) record.resume_subs = snapshot_subs(record)
+		if (record.sub_runs.size) {
+			record.resume_subs = snapshot_subs(record)
+		}
 	}
 	set_status(c, record, "idle")
 	record.sub_runs.clear()
@@ -463,7 +510,9 @@ export function prepare_restart(c, record) {
  * @returns {void}
  */
 function release(c, record) {
-	if (!record.slot) return
+	if (!record.slot) {
+		return
+	}
 	record.slot = false
 	c.running--
 }
@@ -473,9 +522,13 @@ function release(c, record) {
  * @returns {void}
  */
 function run_next(c, name) {
-	if (c.room_waiters.length) wake_room(c)
+	if (c.room_waiters.length) {
+		wake_room(c)
+	}
 	const record = get_record(c, name)
-	if (c.run_status != "running" || active_statuses.has(record.status)) return
+	if (c.run_status != "running" || active_statuses.has(record.status)) {
+		return
+	}
 	const { backlog, backlog_head } = record
 	const entry = backlog[backlog_head]
 	const retrigger = record.retrigger
@@ -486,21 +539,32 @@ function run_next(c, name) {
 			: void 0
 	/** @type {Iterable<string>} */
 	let touched = [ name ]
-	if (entry?.resume) clear_record(c, record)
-	else touched = reset(c, name, true, true)
-	if (plan) plan_resume(record, plan)
+	if (entry?.resume) {
+		clear_record(c, record)
+	} else {
+		touched = reset(c, name, true, true)
+	}
+	if (plan) {
+		plan_resume(record, plan)
+	}
 	if (entry) {
 		const head = backlog_head + 1
-		if (head > 1024 && head * 2 > backlog.length) record.backlog = backlog.slice(head)
-		else if (head < backlog.length) {
+		if (head > 1024 && head * 2 > backlog.length) {
+			record.backlog = backlog.slice(head)
+		} else if (head < backlog.length) {
 			record.backlog = backlog
 			record.backlog_head = head
 		}
 		record.retrigger = retrigger
-		if (entry.skipped) settle(c, name, "skipped", void 0)
-		else launch(c, record, entry.args)
+		if (entry.skipped) {
+			settle(c, name, "skipped", void 0)
+		} else {
+			launch(c, record, entry.args)
+		}
+	}
+	for (const touched_name of touched) {
+		try_start(c, touched_name)
 	}
-	for (const touched_name of touched) try_start(c, touched_name)
 }
 /**
  * @param {RunContext} c
@@ -509,14 +573,22 @@ function run_next(c, name) {
  */
 export function same_args(c, record) {
 	const { args, backlog, backlog_head } = record
-	if (!args) return false
+	if (!args) {
+		return false
+	}
 	const { arrive, deps, options } = record.node
 	const head = backlog[backlog_head]
-	if (options.overlap == "queue" && head?.resume) return head.args === args
+	if (options.overlap == "queue" && head?.resume) {
+		return head.args === args
+	}
 	for (const [ index, dep ] of deps.entries()) {
 		if (arrive?.[dep] == "queue") {
-			if (record.queued?.get(dep)?.[0] !== args[index]) return false
-		} else if (!settled_statuses.has(get_record(c, dep).status) || c.results[dep] !== args[index]) return false
+			if (record.queued?.get(dep)?.[0] !== args[index]) {
+				return false
+			}
+		} else if (!settled_statuses.has(get_record(c, dep).status) || c.results[dep] !== args[index]) {
+			return false
+		}
 	}
 	return true
 }
@@ -531,7 +603,9 @@ export function save_run(run_state) {
 		serial: run_state.serial,
 		waits: [ ...run_state.waits ]
 	}
-	if (run_state.delay != null) saved.delay = run_state.delay
+	if (run_state.delay != null) {
+		saved.delay = run_state.delay
+	}
 	return saved
 }
 /**
@@ -541,8 +615,12 @@ export function save_run(run_state) {
  * @returns {void}
  */
 export function set_status(c, record, status) {
-	if (active_statuses.has(record.status)) c.active_count--
-	if (active_statuses.has(status)) c.active_count++
+	if (active_statuses.has(record.status)) {
+		c.active_count--
+	}
+	if (active_statuses.has(status)) {
+		c.active_count++
+	}
 	record.status = status
 	c.version++
 }
@@ -555,22 +633,28 @@ export function set_status(c, record, status) {
  * @returns {void}
  */
 export function settle(c, name, status, value, cancelled) {
-	if (c.room_waiters.length) defer(c, wake_room.bind(void 0, c))
-	if (c.trace && status == "skipped" && !cancelled) emit(
-		c,
-		{
-			attempt: 0,
-			index: c.item_index,
-			node: name,
-			time: Date.now(),
-			type: "skip"
-		}
-	)
+	if (c.room_waiters.length) {
+		defer(c, wake_room.bind(void 0, c))
+	}
+	if (c.trace && status == "skipped" && !cancelled) {
+		emit(
+			c,
+			{
+				attempt: 0,
+				index: c.item_index,
+				node: name,
+				time: Date.now(),
+				type: "skip"
+			}
+		)
+	}
 	const record = get_record(c, name)
 	clearTimeout(record.timer)
 	record.controller = void 0
 	set_status(c, record, status)
-	if (record.node.kind == "input") record.buffer = void 0
+	if (record.node.kind == "input") {
+		record.buffer = void 0
+	}
 	if (status == "done") {
 		record.result = value
 		c.results[name] = value
@@ -589,35 +673,56 @@ export function settle(c, name, status, value, cancelled) {
 	let more = false
 	if (record.queued) {
 		for (const waiting of record.queued.values()) {
-			if (waiting.length > 1) more = true
+			if (waiting.length > 1) {
+				more = true
+			}
 		}
 		record.holding = status == "failed" && !more && !!record.args
 		if (!record.holding) {
-			for (const waiting of record.queued.values()) waiting.shift()
+			for (const waiting of record.queued.values()) {
+				waiting.shift()
+			}
 		}
 	}
-	if (status == "done") c.streams.get(name)?.send(value)
+	if (status == "done") {
+		c.streams.get(name)?.send(value)
+	}
 	if (status == "done" && !record.abandoned) {
 		for (const dependent of record.node.queuers) {
 			const target = get_record(c, dependent)
 			target.queued ??= new Map()
 			if (target.holding) {
 				target.holding = false
-				for (const waiting of target.queued.values()) waiting.shift()
+				for (const waiting of target.queued.values()) {
+					waiting.shift()
+				}
 			}
 			const waiting = target.queued.get(name) ?? []
 			waiting.push(value)
 			const in_use = active_statuses.has(target.status) || target.fatal ? 1 : 0
-			if (waiting.length - in_use > (target.node.options.limit ?? Infinity)) waiting.splice(in_use, 1)
+			if (waiting.length - in_use > (target.node.options.limit ?? Infinity)) {
+				waiting.splice(in_use, 1)
+			}
 			target.queued.set(name, waiting)
-			if (settled_statuses.has(target.status) && c.run_status == "running") defer(c, () => run_next(c, dependent))
+			if (settled_statuses.has(target.status) && c.run_status == "running") {
+				defer(c, () => run_next(c, dependent))
+			}
 		}
 	}
-	for (const dependent of record.node.dependents) try_start(c, dependent)
-	if (status == "done" && !record.abandoned) follow_edge(c, name, value)
-	else kill_transitions(c, name)
-	if (c.run_status != "running") return
-	if (has_next || more) defer(c, () => run_next(c, name))
+	for (const dependent of record.node.dependents) {
+		try_start(c, dependent)
+	}
+	if (status == "done" && !record.abandoned) {
+		follow_edge(c, name, value)
+	} else {
+		kill_transitions(c, name)
+	}
+	if (c.run_status != "running") {
+		return
+	}
+	if (has_next || more) {
+		defer(c, () => run_next(c, name))
+	}
 	drain(c)
 	schedule(c)
 }
@@ -647,8 +752,12 @@ export async function start(c, name) {
 		const outcome = record.node.each
 			? await run_each(c, record, token)
 			: await run_single(c, record, token)
-		if (token != record.token && outcome.kind == "done" && !is_sentinel(outcome.value)) discard(record, outcome.value)
-		if (token != record.token || outcome.kind == "stale") return
+		if (token != record.token && outcome.kind == "done" && !is_sentinel(outcome.value)) {
+			discard(record, outcome.value)
+		}
+		if (token != record.token || outcome.kind == "stale") {
+			return
+		}
 		release(c, record)
 		if (outcome.kind == "error") {
 			drain(c)
@@ -659,9 +768,13 @@ export async function start(c, name) {
 				!!outcome.items,
 				outcome.index
 			)
-		} else apply_value(c, name, outcome.value)
+		} else {
+			apply_value(c, name, outcome.value)
+		}
 	} catch (error) {
-		if (token != record.token || c.run_status != "running") return
+		if (token != record.token || c.run_status != "running") {
+			return
+		}
 		release(c, record)
 		fail(c, name, error)
 	}
@@ -687,7 +800,9 @@ export function stop_all(c, status, reason, keep) {
 			]
 			record.backlog_head = 0
 		} else if (!holds) {
-			if (record.backlog[record.backlog_head]?.resume) forget_runs(record)
+			if (record.backlog[record.backlog_head]?.resume) {
+				forget_runs(record)
+			}
 			record.backlog = []
 			record.backlog_head = 0
 		}
@@ -719,7 +834,9 @@ export function stop_record(c, record, reason) {
 		record.controller = void 0
 	} else if (record.status == "pending") {
 		const index = c.queue.indexOf(record.node.name)
-		if (index >= 0) c.queue.splice(index, 1)
+		if (index >= 0) {
+			c.queue.splice(index, 1)
+		}
 	}
 }
 /**
@@ -732,13 +849,19 @@ export function try_start(c, name) {
 		c,
 		() => {
 			const record = get_record(c, name)
-			if (!record.activated || c.run_status != "running") return
+			if (!record.activated || c.run_status != "running") {
+				return
+			}
 			const overlapping = record.retrigger && (active_statuses.has(record.status) || holds_backlog(record))
-			if (record.status != "idle" && !overlapping) return
+			if (record.status != "idle" && !overlapping) {
+				return
+			}
 			const { dependents, deps, options } = record.node
 			if (options.release && dependents.length && !dependents.some(
 				dependent => needs(c, dependent)
-			)) return
+			)) {
+				return
+			}
 			const join = options.join ?? "all"
 			let done = 0
 			let resources = 0
@@ -747,7 +870,9 @@ export function try_start(c, name) {
 			const { arrive } = record.node
 			for (const dep of deps) {
 				const dep_record = get_record(c, dep)
-				if (dep_record.fatal) return
+				if (dep_record.fatal) {
+					return
+				}
 				if (dep_record.status == "idle" && dep_record.node.options.release) {
 					resources++
 					continue
@@ -759,20 +884,32 @@ export function try_start(c, name) {
 					}
 					continue
 				}
-				if (dep_record.status == "done") done++
-				if (dep_record.status == "skipped") skipped++
-				if (settled_statuses.has(dep_record.status)) settled++
+				if (dep_record.status == "done") {
+					done++
+				}
+				if (dep_record.status == "skipped") {
+					skipped++
+				}
+				if (settled_statuses.has(dep_record.status)) {
+					settled++
+				}
 			}
 			if (resources && !(join == "race" && done)) {
-				if (settled + resources < deps.length) return
+				if (settled + resources < deps.length) {
+					return
+				}
 				if (join != "all" || !skipped) {
 					for (const dep of deps) {
 						const dep_record = get_record(c, dep)
-						if (dep_record.status == "idle" && dep_record.node.options.release) try_start(c, dep)
+						if (dep_record.status == "idle" && dep_record.node.options.release) {
+							try_start(c, dep)
+						}
 					}
 					return
 				}
-			} else if (join == "race" ? !done && settled < deps.length : settled < deps.length) return
+			} else if (join == "race" ? !done && settled < deps.length : settled < deps.length) {
+				return
+			}
 			const is_skipped = !!deps.length && (join == "all" ? skipped > 0 : !done)
 			if (overlapping) {
 				record.retrigger = false
@@ -780,10 +917,15 @@ export function try_start(c, name) {
 				const overlap = options.overlap ?? "restart"
 				if (overlap == "restart") {
 					const touched = reset(c, name, true, true)
-					if (is_skipped) settle(c, name, "skipped", void 0)
-					else launch(c, record, args)
+					if (is_skipped) {
+						settle(c, name, "skipped", void 0)
+					} else {
+						launch(c, record, args)
+					}
 					for (const touched_name of touched) {
-						if (touched_name != name) try_start(c, touched_name)
+						if (touched_name != name) {
+							try_start(c, touched_name)
+						}
 					}
 					return
 				}
@@ -797,7 +939,9 @@ export function try_start(c, name) {
 					const held = record.backlog[record.backlog_head]?.resume ? 1 : 0
 					if (record.backlog.length - record.backlog_head - held > limit) {
 						record.dropped++
-						if (held) record.backlog[record.backlog_head + 1] = /** @type {BacklogEntry} */(record.backlog[record.backlog_head])/**/
+						if (held) {
+							record.backlog[record.backlog_head + 1] = /** @type {BacklogEntry} */(record.backlog[record.backlog_head])/**/
+						}/**/
 						record.backlog_head++
 						if (record.backlog_head * 2 > record.backlog.length) {
 							record.backlog = record.backlog.slice(record.backlog_head)
@@ -805,7 +949,9 @@ export function try_start(c, name) {
 						}
 					}
 				}
-				if (!active_statuses.has(record.status)) run_next(c, name)
+				if (!active_statuses.has(record.status)) {
+					run_next(c, name)
+				}
 				return
 			}
 			if (record.backlog.length > record.backlog_head) {
@@ -816,7 +962,9 @@ export function try_start(c, name) {
 				settle(c, name, "skipped", void 0)
 				return
 			}
-			if (launch(c, record, values_for(c, record)) && join == "race" && c.run_status == "running") abandon(c, deps, name)
+			if (launch(c, record, values_for(c, record)) && join == "race" && c.run_status == "running") {
+				abandon(c, deps, name)
+			}
 		}
 	)
 }
@@ -827,7 +975,9 @@ export function try_start(c, name) {
  */
 function values_for(c, record) {
 	const { arrive, deps } = record.node
-	if (!arrive) return deps.map(dep => c.results[dep])
+	if (!arrive) {
+		return deps.map(dep => c.results[dep])
+	}
 	return deps.map(
 		dep => arrive[dep] == "queue"
 			? record.queued?.get(dep)?.[0]