hpcflow-new2 0.2.0a189__py3-none-any.whl → 0.2.0a199__py3-none-any.whl

hpcflow/sdk/core/parameters.py

@@ -3,48 +3,77 @@ Parameters represent information passed around within a workflow.
 """
 
 from __future__ import annotations
+from collections.abc import Sequence
 import copy
 from dataclasses import dataclass, field
 from datetime import timedelta
 import enum
 from pathlib import Path
 import re
-from typing import Any, Dict, List, Optional, Sequence, Tuple, Union
+from typing import TypeVar, cast, TYPE_CHECKING
+from typing_extensions import override, TypeIs
 
 import numpy as np
-import valida
-
-from hpcflow.sdk import app
-from hpcflow.sdk.core.element import ElementFilter
+from scipy.stats.qmc import LatinHypercube
+from valida import Schema as ValidaSchema  # type: ignore
+
+from hpcflow.sdk.typing import hydrate
+from hpcflow.sdk.core.enums import (
+    InputSourceType,
+    ParallelMode,
+    ParameterPropagationMode,
+    TaskSourceType,
+)
 from hpcflow.sdk.core.errors import (
     MalformedParameterPathError,
     UnknownResourceSpecItemError,
     WorkflowParameterMissingError,
 )
 from hpcflow.sdk.core.json_like import ChildObjectSpec, JSONLike
-from hpcflow.sdk.core.parallel import ParallelMode
-from hpcflow.sdk.core.rule import Rule
 from hpcflow.sdk.core.utils import (
     check_valid_py_identifier,
     get_enum_by_name_or_val,
     linspace_rect,
     process_string_nodes,
     split_param_label,
+    timedelta_format,
 )
-from hpcflow.sdk.submission.shells import get_shell
-from hpcflow.sdk.submission.submission import timedelta_format
 
+if TYPE_CHECKING:
+    from collections.abc import Iterable, Iterator, Mapping
+    from typing import Any, ClassVar, Literal
+    from typing_extensions import Self, TypeAlias
+    from h5py import Group  # type: ignore
+    from numpy.typing import NDArray
+    from ..app import BaseApp
+    from ..typing import ParamSource
+    from .actions import ActionScope
+    from .element import ElementFilter
+    from .object_list import ResourceList
+    from .rule import Rule
+    from .task import ElementSet, TaskSchema, TaskTemplate, WorkflowTask
+    from .types import (
+        Address,
+        Numeric,
+        LabelInfo,
+        LabellingDescriptor,
+        ResourcePersistingWorkflow,
+        RuleArgs,
+        SchemaInputKwargs,
+    )
+    from .workflow import Workflow, WorkflowTemplate
+    from .validation import Schema
+
+
+T = TypeVar("T")
 
-Address = List[Union[int, float, str]]
-Numeric = Union[int, float, np.number]
 
+def _process_demo_data_strings(app: BaseApp, value: T) -> T:
+    demo_pattern = re.compile(r"\<\<demo_data_file:(.*)\>\>")
 
-def _process_demo_data_strings(app, value):
-    def string_processor(str_in):
-        demo_pattern = r"\<\<demo_data_file:(.*)\>\>"
-        str_out = re.sub(
-            pattern=demo_pattern,
-            repl=lambda x: str(app.get_demo_data_file_path(x.group(1))),
+    def string_processor(str_in: str) -> str:
+        str_out = demo_pattern.sub(
+            repl=lambda x: str(app.get_demo_data_file_path(x[1])),
             string=str_in,
         )
         return str_out
@@ -52,6 +81,8 @@ def _process_demo_data_strings(app, value):
     return process_string_nodes(value, string_processor)
 
 
+@dataclass
+@hydrate
 class ParameterValue:
     """
     The value handler for a parameter.
@@ -59,58 +90,60 @@ class ParameterValue:
     Intended to be subclassed.
     """
 
-    _typ = None
-    _sub_parameters = {}
+    _typ: ClassVar[str | None] = None
+    _sub_parameters: ClassVar[dict[str, str]] = {}
 
-    def to_dict(self):
+    def to_dict(self) -> dict[str, Any]:
         """
         Serialise this parameter value as a dictionary.
         """
         if hasattr(self, "__dict__"):
-            return dict(self.__dict__)
+            return self._postprocess_to_dict(dict(self.__dict__))
         elif hasattr(self, "__slots__"):
-            return {k: getattr(self, k) for k in self.__slots__}
+            return self._postprocess_to_dict(
+                {k: getattr(self, k) for k in self.__slots__}
+            )
+        else:
+            raise NotImplementedError
+
+    def _postprocess_to_dict(self, d: dict[str, Any]) -> dict[str, Any]:
+        """Postprocess the results of :meth:`to_dict`."""
+        return d
 
-    def prepare_JSON_dump(self) -> Dict:
+    def prepare_JSON_dump(self) -> dict[str, Any]:
         """
         Prepare this parameter value for serialisation as JSON.
         """
         raise NotImplementedError
 
-    def dump_to_HDF5_group(self, group):
+    def dump_to_HDF5_group(self, group: Group):
         """
         Write this parameter value to an HDF5 group.
         """
         raise NotImplementedError
 
     @classmethod
-    def save_from_HDF5_group(cls, group, param_id: int, workflow):
+    def dump_element_group_to_HDF5_group(cls, objs: list[ParameterValue], group: Group):
+        """
+        Write a list (from an element group) of parameter values to an HDF5 group.
+        """
+        raise NotImplementedError
+
+    @classmethod
+    def save_from_HDF5_group(cls, group: Group, param_id: int, workflow: Workflow):
         """
         Extract a parameter value from an HDF5 group.
         """
         raise NotImplementedError
 
     @classmethod
-    def save_from_JSON(cls, data, param_id: int, workflow):
+    def save_from_JSON(cls, data, param_id: int | list[int], workflow: Workflow):
         """
         Extract a parameter value from JSON data.
         """
         raise NotImplementedError
 
 
-class ParameterPropagationMode(enum.Enum):
-    """
-    How a parameter is propagated.
-    """
-
-    #: Parameter is propagated implicitly.
-    IMPLICIT = 0
-    #: Parameter is propagated explicitly.
-    EXPLICIT = 1
-    #: Parameter is never propagated.
-    NEVER = 2
-
-
 @dataclass
 class ParameterPath(JSONLike):
     """
@@ -119,14 +152,13 @@ class ParameterPath(JSONLike):
 
     # TODO: unused?
     #: The path to the parameter.
-    path: Sequence[Union[str, int, float]]
+    path: Sequence[str | int | float]
     #: The task in which to look up the parameter.
-    task: Optional[
-        Union[app.TaskTemplate, app.TaskSchema]
-    ] = None  # default is "current" task
+    task: TaskTemplate | TaskSchema | None = None  # default is "current" task
 
 
 @dataclass
+@hydrate
 class Parameter(JSONLike):
     """
     A general parameter to a workflow task.
@@ -150,15 +182,15 @@ class Parameter(JSONLike):
         Validation schema.
     """
 
-    _validation_schema = "parameters_spec_schema.yaml"
-    _child_objects = (
+    _validation_schema: ClassVar[str] = "parameters_spec_schema.yaml"
+    _child_objects: ClassVar[tuple[ChildObjectSpec, ...]] = (
         ChildObjectSpec(
             name="typ",
             json_like_name="type",
         ),
         ChildObjectSpec(
             name="_validation",
-            class_obj=valida.Schema,
+            class_obj=ValidaSchema,
         ),
     )
 
@@ -168,10 +200,10 @@ class Parameter(JSONLike):
     #: Whether this parameter represents a file.
     is_file: bool = False
     #: Any parameters packed within this one.
-    sub_parameters: List[app.SubParameter] = field(default_factory=lambda: [])
-    _value_class: Any = None
-    _hash_value: Optional[str] = field(default=None, repr=False)
-    _validation: Optional[valida.Schema] = None
+    sub_parameters: list[SubParameter] = field(default_factory=list)
+    _value_class: type[ParameterValue] | None = None
+    _hash_value: str | None = field(default=None, repr=False)
+    _validation: Schema | None = None
 
     def __repr__(self) -> str:
         is_file_str = ""
@@ -192,31 +224,42 @@ class Parameter(JSONLike):
             f")"
         )
 
-    def __post_init__(self):
+    def __post_init__(self) -> None:
         self.typ = check_valid_py_identifier(self.typ)
         self._set_value_class()
 
-    def _set_value_class(self):
+    def _set_value_class(self) -> None:
         # custom parameter classes must inherit from `ParameterValue` not the app
         # subclass:
         if self._value_class is None:
-            for i in ParameterValue.__subclasses__():
-                if i._typ == self.typ:
-                    self._value_class = i
+            self._value_class = next(
+                (
+                    pv_class
+                    for pv_class in ParameterValue.__subclasses__()
+                    if pv_class._typ == self.typ
+                ),
+                None,
+            )
 
-    def __lt__(self, other):
+    def __eq__(self, other: Any) -> bool:
+        return isinstance(other, self.__class__) and self.typ == other.typ
+
+    def __lt__(self, other: Parameter):
         return self.typ < other.typ
 
-    def __deepcopy__(self, memo):
+    def __deepcopy__(self, memo: dict[int, Any]):
         kwargs = self.to_dict()
         _validation = kwargs.pop("_validation")
         obj = self.__class__(**copy.deepcopy(kwargs, memo))
         obj._validation = _validation
         return obj
 
-    def to_dict(self):
-        dct = super().to_dict()
+    @override
+    def _postprocess_to_dict(self, d: dict[str, Any]) -> dict[str, Any]:
+        dct = super()._postprocess_to_dict(d)
         del dct["_value_class"]
+        if dct.get("name", None) is None:
+            dct.pop("name", None)
         dct.pop("_task_schema", None)  # TODO: how do we have a _task_schema ref?
         return dct
 
@@ -227,6 +270,25 @@ class Parameter(JSONLike):
         """
         return self.typ.lower().replace("_", "-")
 
+    def _instantiate_value(self, source: ParamSource, val: dict) -> Any:
+        """
+        Convert the serialized form of this parameter to its "real" form,
+        if that is valid to do at all.
+        """
+        if self._value_class is None:
+            return val
+        if (method_name := source.get("value_class_method")) is not None:
+            method = getattr(self._value_class, method_name)
+        else:
+            method = self._value_class
+        return method(**val)
+
+    def _force_value_class(self) -> type[ParameterValue] | None:
+        if (param_cls := self._value_class) is None:
+            self._set_value_class()
+            param_cls = self._value_class
+        return param_cls
+
 
 @dataclass
 class SubParameter:
@@ -237,10 +299,11 @@ class SubParameter:
     #: How to find this within the containing paraneter.
     address: Address
     #: The containing main parameter.
-    parameter: app.Parameter
+    parameter: Parameter
 
 
 @dataclass
+@hydrate
 class SchemaParameter(JSONLike):
     """
     A parameter bound in a schema.
@@ -251,9 +314,7 @@ class SchemaParameter(JSONLike):
         The parameter.
     """
 
-    _app_attr = "app"
-
-    _child_objects = (
+    _child_objects: ClassVar[tuple[ChildObjectSpec, ...]] = (
         ChildObjectSpec(
             name="parameter",
             class_name="Parameter",
@@ -262,22 +323,15 @@ class SchemaParameter(JSONLike):
         ),
     )
 
-    def __post_init__(self):
+    def __post_init__(self) -> None:
         self._validate()
 
-    def _validate(self):
+    def _validate(self) -> None:
         if isinstance(self.parameter, str):
-            self.parameter = self.app.Parameter(self.parameter)
-
-    @property
-    def name(self):
-        """
-        The name of the parameter.
-        """
-        return self.parameter.name
+            self.parameter: Parameter = self._app.Parameter(typ=self.parameter)
 
     @property
-    def typ(self):
+    def typ(self) -> str:
         """
         The type code of the parameter.
         """
@@ -294,6 +348,7 @@ class NullDefault(enum.Enum):
     NULL = 0
 
 
+@hydrate
 class SchemaInput(SchemaParameter):
     """A Parameter as used within a particular schema, for which a default value may be
     applied.
@@ -330,11 +385,18 @@ class SchemaInput(SchemaParameter):
         Determines the name of the element group from which this input should be sourced.
         This is a default value that will be applied to all `labels` if a "group" key
         does not exist.
+    allow_failed_dependencies
+        This controls whether failure to retrieve inputs (i.e. an
+        `UnsetParameterDataError` is raised for one of the input sources) should be
+        allowed. By default, the unset value, which is equivalent to `False`, means no
+        failures are allowed. If set to `True`, any number of failures are allowed. If an
+        integer is specified, that number of failures are permitted. Finally, if a float
+        is specified, that proportion of failures are allowed.
     """
 
-    _task_schema = None  # assigned by parent TaskSchema
+    _task_schema: TaskSchema | None = None  # assigned by parent TaskSchema
 
-    _child_objects = (
+    _child_objects: ClassVar[tuple[ChildObjectSpec, ...]] = (
         ChildObjectSpec(
             name="parameter",
             class_name="Parameter",
@@ -345,12 +407,13 @@ class SchemaInput(SchemaParameter):
 
     def __init__(
         self,
-        parameter: app.Parameter,
+        parameter: Parameter | str,
         multiple: bool = False,
-        labels: Optional[Dict] = None,
-        default_value: Optional[Union[app.InputValue, NullDefault]] = NullDefault.NULL,
+        labels: dict[str, LabelInfo] | None = None,
+        default_value: InputValue | Any | NullDefault = NullDefault.NULL,
         propagation_mode: ParameterPropagationMode = ParameterPropagationMode.IMPLICIT,
-        group: Optional[str] = None,
+        group: str | None = None,
+        allow_failed_dependencies: int | float | bool | None = False,
     ):
         # TODO: can we define elements groups on local inputs as well, or should these be
         # just for elements from other tasks?
@@ -360,24 +423,32 @@ class SchemaInput(SchemaParameter):
 
         if isinstance(parameter, str):
             try:
-                parameter = self.app.parameters.get(parameter)
+                #: The parameter (i.e. type) of this schema input.
+                self.parameter = self._app.parameters.get(parameter)
             except ValueError:
-                parameter = self.app.Parameter(parameter)
+                self.parameter = self._app.Parameter(parameter)
+        else:
+            self.parameter = parameter
 
-        #: The parameter (i.e. type) of this schema input.
-        self.parameter = parameter
-        #: Whether to expect more than of these parameters defined in the workflow.
+        if allow_failed_dependencies is None:
+            allow_failed_dependencies = 0.0
+        elif isinstance(allow_failed_dependencies, bool):
+            allow_failed_dependencies = float(allow_failed_dependencies)
+
+        #: Whether to expect multiple labels for this parameter.
         self.multiple = multiple
+        self.allow_failed_dependencies = allow_failed_dependencies
+
         #: Dict whose keys represent the string labels that distinguish multiple
         #: parameters if `multiple` is `True`.
-        self.labels = labels
-
-        if self.labels is None:
+        self.labels: dict[str, LabelInfo]
+        if labels is None:
             if self.multiple:
                 self.labels = {"*": {}}
             else:
                 self.labels = {"": {}}
         else:
+            self.labels = labels
             if not self.multiple:
                 # check single-item:
                 if len(self.labels) > 1:
@@ -387,7 +458,7 @@ class SchemaInput(SchemaParameter):
                         f"`labels` is: {self.labels!r}."
                     )
 
-        labels_defaults = {}
+        labels_defaults: LabelInfo = {}
         if propagation_mode is not None:
             labels_defaults["propagation_mode"] = propagation_mode
         if group is not None:
@@ -397,14 +468,15 @@ class SchemaInput(SchemaParameter):
         for k, v in self.labels.items():
             labels_defaults_i = copy.deepcopy(labels_defaults)
             if default_value is not NullDefault.NULL:
-                if not isinstance(default_value, InputValue):
-                    default_value = app.InputValue(
+                if isinstance(default_value, InputValue):
+                    labels_defaults_i["default_value"] = default_value
+                else:
+                    labels_defaults_i["default_value"] = self._app.InputValue(
                         parameter=self.parameter,
                         value=default_value,
                         label=k,
                     )
-                labels_defaults_i["default_value"] = default_value
-            label_i = {**labels_defaults_i, **v}
+            label_i: LabelInfo = {**labels_defaults_i, **v}
             if "propagation_mode" in label_i:
                 label_i["propagation_mode"] = get_enum_by_name_or_val(
                     ParameterPropagationMode, label_i["propagation_mode"]
@@ -420,8 +492,8 @@ class SchemaInput(SchemaParameter):
         default_str = ""
         group_str = ""
         labels_str = ""
-        if not self.multiple:
-            label = next(iter(self.labels.keys()))  # the single key
+        if not self.multiple and self.labels:
+            label = next(iter(self.labels))  # the single key
 
             default_str = ""
             if "default_value" in self.labels[label]:
@@ -429,8 +501,7 @@ class SchemaInput(SchemaParameter):
                     f", default_value={self.labels[label]['default_value'].value!r}"
                 )
 
-            group = self.labels[label].get("group")
-            if group is not None:
+            if (group := self.labels[label].get("group")) is not None:
                 group_str = f", group={group!r}"
 
         else:
@@ -444,20 +515,20 @@ class SchemaInput(SchemaParameter):
             f")"
         )
 
-    def to_dict(self):
-        dct = super().to_dict()
+    @override
+    def _postprocess_to_dict(self, d: dict[str, Any]) -> dict[str, Any]:
+        dct = super()._postprocess_to_dict(d)
+        v: dict[str, ParameterPropagationMode]
         for k, v in dct["labels"].items():
-            prop_mode = v.get("parameter_propagation_mode")
-            if prop_mode:
+            if (prop_mode := v.get("parameter_propagation_mode")) is not None:
                 dct["labels"][k]["parameter_propagation_mode"] = prop_mode.name
         return dct
 
-    def to_json_like(self, dct=None, shared_data=None, exclude=None, path=None):
-        out, shared = super().to_json_like(dct, shared_data, exclude, path)
-        for k, v in out["labels"].items():
+    def _postprocess_to_json(self, json_like):
+        for v in json_like["labels"].values():
             if "default_value" in v:
-                out["labels"][k]["default_value_is_input_value"] = True
-        return out, shared
+                v["default_value_is_input_value"] = True
+        return json_like
 
     @classmethod
     def from_json_like(cls, json_like, shared_data=None):
@@ -473,81 +544,86 @@ class SchemaInput(SchemaParameter):
                     }
                 json_like["labels"][k][
                     "default_value"
-                ] = cls.app.InputValue.from_json_like(
+                ] = cls._app.InputValue.from_json_like(
                     json_like=inp_val_kwargs,
                     shared_data=shared_data,
                 )
 
-        obj = super().from_json_like(json_like, shared_data)
-        return obj
+        return super().from_json_like(json_like, shared_data)
 
-    def __deepcopy__(self, memo):
-        kwargs = {
-            "parameter": self.parameter,
+    def __deepcopy__(self, memo: dict[int, Any]):
+        kwargs: SchemaInputKwargs = {
+            "parameter": copy.deepcopy(self.parameter, memo),
             "multiple": self.multiple,
-            "labels": self.labels,
+            "labels": copy.deepcopy(self.labels, memo),
+            "allow_failed_dependencies": self.allow_failed_dependencies,
         }
-        obj = self.__class__(**copy.deepcopy(kwargs, memo))
+        obj = self.__class__(**kwargs)
         obj._task_schema = self._task_schema
         return obj
 
     @property
-    def default_value(self):
+    def default_value(self) -> InputValue | Literal[NullDefault.NULL] | None:
         """
         The default value of the input.
         """
-        if not self.multiple:
-            if "default_value" in self.single_labelled_data:
-                return self.single_labelled_data["default_value"]
+        if single_data := self.single_labelled_data:
+            if "default_value" in single_data:
+                return single_data["default_value"]
             else:
                 return NullDefault.NULL
+        return None
 
     @property
-    def task_schema(self):
+    def task_schema(self) -> TaskSchema:
         """
         The schema containing this input.
         """
+        assert self._task_schema is not None
         return self._task_schema
 
     @property
-    def all_labelled_types(self):
+    def all_labelled_types(self) -> list[str]:
         """
         The types of the input labels.
         """
-        return list(f"{self.typ}{f'[{i}]' if i else ''}" for i in self.labels)
+        return [(f"{self.typ}[{i}]" if i else self.typ) for i in self.labels]
 
     @property
-    def single_label(self):
+    def single_label(self) -> str | None:
         """
         The label of this input, assuming it is not mulitple.
         """
         if not self.multiple:
             return next(iter(self.labels))
+        return None
 
     @property
-    def single_labelled_type(self):
+    def single_labelled_type(self) -> str | None:
         """
         The type code of this input, assuming it is not mulitple.
         """
         if not self.multiple:
             return next(iter(self.labelled_info()))["labelled_type"]
+        return None
 
     @property
-    def single_labelled_data(self):
+    def single_labelled_data(self) -> LabelInfo | None:
         """
         The value of this input, assuming it is not mulitple.
         """
-        if not self.multiple:
-            return self.labels[self.single_label]
+        if (label := self.single_label) is not None:
+            return self.labels[label]
+        return None
 
-    def labelled_info(self):
+    def labelled_info(self) -> Iterator[LabellingDescriptor]:
         """
         Get descriptors for all the labels associated with this input.
         """
         for k, v in self.labels.items():
-            label = f"[{k}]" if k else ""
-            dct = {
-                "labelled_type": self.parameter.typ + label,
+            label = f"{self.parameter.typ}[{k}]" if k else self.parameter.typ
+            dct: LabellingDescriptor = {
+                "labelled_type": label,
                 "propagation_mode": v["propagation_mode"],
                 "group": v.get("group"),
             }
@@ -555,18 +631,28 @@ class SchemaInput(SchemaParameter):
                 dct["default_value"] = v["default_value"]
             yield dct
 
-    def _validate(self):
+    @property
+    def _simple_labelled_info(self) -> Iterator[tuple[str, ParameterPropagationMode]]:
+        """
+        Cut-down version of :py:meth:`labelled_info` that has lower overheads.
+        """
+        for k, v in self.labels.items():
+            label = f"{self.parameter.typ}[{k}]" if k else self.parameter.typ
+            yield label, v["propagation_mode"]
+
+    def _validate(self) -> None:
         super()._validate()
         for k, v in self.labels.items():
             if "default_value" in v:
                 if not isinstance(v["default_value"], InputValue):
-                    def_val = self.app.InputValue(
+                    def_val = self._app.InputValue(
                         parameter=self.parameter,
                         value=v["default_value"],
                         label=k,
                     )
-                    self.labels[k]["default_value"] = def_val
-                def_val = self.labels[k]["default_value"]
+                    v["default_value"] = def_val
+                else:
+                    def_val = v["default_value"]
                 if def_val.parameter != self.parameter or def_val.label != k:
                     raise ValueError(
                         f"{self.__class__.__name__} `default_value` for label {k!r} must "
@@ -576,24 +662,36 @@ class SchemaInput(SchemaParameter):
                     )
 
     @property
-    def input_or_output(self):
+    def input_or_output(self) -> str:
         """
         Whether this is an input or output. Always ``input``.
         """
         return "input"
 
 
-@dataclass
+@dataclass(init=False)
+@hydrate
 class SchemaOutput(SchemaParameter):
     """A Parameter as outputted from particular task."""
 
     #: The basic parameter this supplies.
     parameter: Parameter
     #: How this output propagates.
-    propagation_mode: ParameterPropagationMode = ParameterPropagationMode.IMPLICIT
+    propagation_mode: ParameterPropagationMode
+
+    def __init__(
+        self,
+        parameter: Parameter | str,
+        propagation_mode: ParameterPropagationMode = ParameterPropagationMode.IMPLICIT,
+    ):
+        if isinstance(parameter, str):
+            self.parameter: Parameter = self._app.Parameter(typ=parameter)
+        else:
+            self.parameter = parameter
+        self.propagation_mode = propagation_mode
 
     @property
-    def input_or_output(self):
+    def input_or_output(self) -> str:
         """
         Whether this is an input or output. Always ``output``.
         """
@@ -624,7 +722,52 @@ class BuiltinSchemaParameter:
     pass
 
 
-class ValueSequence(JSONLike):
+class _BaseSequence(JSONLike):
+    """
+    A base class for shared methods of `ValueSequence` and `MultiPathSequence`.
+    """
+
+    def __eq__(self, other: Any) -> bool:
+        if not isinstance(other, self.__class__):
+            return False
+        return self.to_dict() == other.to_dict()
+
+    @classmethod
+    def from_json_like(cls, json_like, shared_data=None):
+        if "path" in json_like:  # note: singular
+            # only applicable to ValueSequence, although not well-defined/useful anyway,
+            # I think.
+            if "::" in json_like["path"]:
+                path, cls_method = json_like["path"].split("::")
+                json_like["path"] = path
+                json_like["value_class_method"] = cls_method
+
+        val_key = next((item for item in json_like if "values" in item), "")
+        if "::" in val_key:
+            # class method (e.g. `from_range`, `from_file` etc):
+            _, method = val_key.split("::")
+            _values_method_args = json_like.pop(val_key)
+
+            if "paths" in json_like:  # note: plural
+                # only applicable to `MultiPathSequence`, where it is useful to know
+                # how many paths we are generating sequences for:
+                _values_method_args["paths"] = json_like["paths"]
+
+            _values_method = f"_values_{method}"
+            _values_method_args = _process_demo_data_strings(
+                cls._app, _values_method_args
+            )
+            json_like["values"] = getattr(cls, _values_method)(**_values_method_args)
+
+        obj = super().from_json_like(json_like, shared_data)
+        if "::" in val_key:
+            obj._values_method = method
+            obj._values_method_args = _values_method_args
+
+        return obj
+
+
+class ValueSequence(_BaseSequence):
     """
     A sequence of values.
 
@@ -645,39 +788,43 @@ class ValueSequence(JSONLike):
     def __init__(
         self,
         path: str,
-        values: List[Any],
-        nesting_order: Optional[int] = 0,
-        label: Optional[str] = None,
-        value_class_method: Optional[str] = None,
+        values: Sequence[Any] | None,
+        nesting_order: int | float | None = None,
+        label: str | int | None = None,
+        value_class_method: str | None = None,
     ):
-        label = str(label) if label is not None else ""
-        path, label = self._validate_parameter_path(path, label)
-
+        path_, label_ = self._validate_parameter_path(path, label)
         #: The path to this sequence.
-        self.path = path
+        self.path = path_
         #: The label of this sequence.
-        self.label = label
+        self.label = label_
         #: The nesting order for this sequence.
-        self.nesting_order = nesting_order
+        self.nesting_order = None if nesting_order is None else float(nesting_order)
         #: Name of a method used to generate sequence values.
         self.value_class_method = value_class_method
 
         if values is not None:
-            self._values = [_process_demo_data_strings(self.app, i) for i in values]
+            self._values: list[Any] | None = [
+                _process_demo_data_strings(self._app, i) for i in values
+            ]
+        else:
+            self._values = None
 
-        self._values_group_idx = None
-        self._values_are_objs = None  # assigned initially on `make_persistent`
+        self._values_group_idx: list[int] | None = None
+        self._values_are_objs: list[
+            bool
+        ] | None = None  # assigned initially on `make_persistent`
 
-        self._workflow = None
-        self._element_set = None  # assigned by parent ElementSet
+        self._workflow: Workflow | None = None  # assigned in `make_persistent`
+        self._element_set: ElementSet | None = None  # assigned by parent `ElementSet`
 
         # assigned if this is an "inputs" sequence in `WorkflowTask._add_element_set`:
-        self._parameter = None
+        self._parameter: Parameter | None = None
 
-        self._path_split = None  # assigned by property `path_split`
+        self._path_split: list[str] | None = None  # assigned by property `path_split`
 
-        self._values_method = None
-        self._values_method_args = None
+        self._values_method: str | None = None
+        self._values_method_args: dict | None = None
 
     def __repr__(self):
         label_str = ""
@@ -698,14 +845,7 @@ class ValueSequence(JSONLike):
             f")"
         )
 
-    def __eq__(self, other) -> bool:
-        if not isinstance(other, self.__class__):
-            return False
-        if self.to_dict() == other.to_dict():
-            return True
-        return False
-
-    def __deepcopy__(self, memo):
+    def __deepcopy__(self, memo: dict[int, Any]):
         kwargs = self.to_dict()
         kwargs["values"] = kwargs.pop("_values")
 
@@ -728,95 +868,73 @@ class ValueSequence(JSONLike):
 
         return obj
 
-    @classmethod
-    def from_json_like(cls, json_like, shared_data=None):
-        if "::" in json_like["path"]:
-            path, cls_method = json_like["path"].split("::")
-            json_like["path"] = path
-            json_like["value_class_method"] = cls_method
-
-        val_key = None
-        for i in json_like:
-            if "values" in i:
-                val_key = i
-        if "::" in val_key:
-            # class method (e.g. `from_range`, `from_file` etc):
-            _, method = val_key.split("::")
-            _values_method_args = json_like.pop(val_key)
-            _values_method = f"_values_{method}"
-            _values_method_args = _process_demo_data_strings(cls.app, _values_method_args)
-            json_like["values"] = getattr(cls, _values_method)(**_values_method_args)
-
-        obj = super().from_json_like(json_like, shared_data)
-        if "::" in val_key:
-            obj._values_method = method
-            obj._values_method_args = _values_method_args
-
-        return obj
-
     @property
-    def parameter(self):
+    def parameter(self) -> Parameter | None:
         """
         The parameter this sequence supplies.
         """
         return self._parameter
 
     @property
-    def path_split(self):
+    def path_split(self) -> Sequence[str]:
         """
-        The components of ths path.
+        The components of this path.
         """
         if self._path_split is None:
             self._path_split = self.path.split(".")
         return self._path_split
 
     @property
-    def path_type(self):
+    def path_type(self) -> str:
         """
         The type of path this is.
         """
         return self.path_split[0]
 
     @property
-    def input_type(self):
+    def input_type(self) -> str | None:
         """
         The type of input sequence this is, if it is one.
         """
         if self.path_type == "inputs":
             return self.path_split[1].replace(self._label_fmt, "")
+        return None
 
     @property
-    def input_path(self):
+    def input_path(self) -> str | None:
         """
         The path of the input sequence this is, if it is one.
         """
         if self.path_type == "inputs":
             return ".".join(self.path_split[2:])
+        return None
 
     @property
-    def resource_scope(self):
+    def resource_scope(self) -> str | None:
         """
         The scope of the resources this is, if it is one.
         """
         if self.path_type == "resources":
             return self.path_split[1]
+        return None
 
     @property
-    def is_sub_value(self):
+    def is_sub_value(self) -> bool:
         """True if the values are for a sub part of the parameter."""
-        return True if self.input_path else False
+        return bool(self.input_path)
 
     @property
-    def _label_fmt(self):
+    def _label_fmt(self) -> str:
         return f"[{self.label}]" if self.label else ""
 
     @property
-    def labelled_type(self):
+    def labelled_type(self) -> str | None:
         """
         The labelled type of input sequence this is, if it is one.
         """
         if self.input_type:
             return f"{self.input_type}{self._label_fmt}"
+        return None
 
     @classmethod
     def _json_like_constructor(cls, json_like):
@@ -836,7 +954,9 @@ class ValueSequence(JSONLike):
         obj._values_method_args = _values_method_args
         return obj
 
-    def _validate_parameter_path(self, path, label):
+    def _validate_parameter_path(
+        self, path: str, label: str | int | None
+    ) -> tuple[str, str | int | None]:
         """Parse the supplied path and perform basic checks on it.
 
         This method also adds the specified `SchemaInput` label to the path and checks for
@@ -852,25 +972,24 @@ class ValueSequence(JSONLike):
             )
         path_l = path.lower()
         path_split = path_l.split(".")
-        allowed_path_start = ("inputs", "resources", "environments", "env_preset")
-        if not path_split[0] in allowed_path_start:
+        ALLOWED_PATH_START = ("inputs", "resources", "environments", "env_preset")
+        if not path_split[0] in ALLOWED_PATH_START:
             raise MalformedParameterPathError(
                 f"`path` must start with one of: "
-                f'{", ".join(f"{i!r}" for i in allowed_path_start)}, but given path '
+                f'{", ".join(f"{pfx!r}" for pfx in ALLOWED_PATH_START)}, but given path '
                 f"is: {path!r}."
             )
 
         _, label_from_path = split_param_label(path_l)
 
         if path_split[0] == "inputs":
-            if label_arg:
-                if not label_from_path:
+            if label_arg is not None and label_arg != "":
+                if label_from_path is None:
                     # add label to path without lower casing any parts:
                     path_split_orig = path.split(".")
                     path_split_orig[1] += f"[{label_arg}]"
                     path = ".".join(path_split_orig)
-                    label = label_arg
-                elif label_arg != label_from_path:
+                elif str(label_arg) != label_from_path:
                     raise ValueError(
                         f"{self.__class__.__name__} `label` argument is specified as "
                         f"{label_arg!r}, but a distinct label is implied by the sequence "
@@ -887,7 +1006,7 @@ class ValueSequence(JSONLike):
                     f"`resource` sequences."
                 )
             try:
-                self.app.ActionScope.from_json_like(path_split[1])
+                self._app.ActionScope.from_json_like(path_split[1])
             except Exception as err:
                 raise MalformedParameterPathError(
                     f"Cannot parse a resource action scope from the second component of the "
@@ -895,42 +1014,42 @@ class ValueSequence(JSONLike):
                 ) from None
 
             if len(path_split) > 2:
-                path_split_2 = path_split[2]
-                allowed = ResourceSpec.ALLOWED_PARAMETERS
-                if path_split_2 not in allowed:
-                    allowed_keys_str = ", ".join(f'"{i}"' for i in allowed)
+                if path_split[2] not in ResourceSpec.ALLOWED_PARAMETERS:
                     raise UnknownResourceSpecItemError(
-                        f"Resource item name {path_split_2!r} is unknown. Allowed "
-                        f"resource item names are: {allowed_keys_str}."
+                        f"Resource item name {path_split[2]!r} is unknown. Allowed "
+                        f"resource item names are: {ResourceSpec._allowed_params_quoted()}."
                     )
+            label = ""
 
         elif path_split[0] == "environments":
             # rewrite as a resources path:
             path = f"resources.any.{path}"
-
-        # note: `env_preset` paths also need to be transformed into `resources` paths, but
-        # we cannot do that until the sequence is part of a task, since the available
-        # environment presets are defined in the task schema.
+            label = str(label) if label is not None else ""
+        else:
+            pass
+            # note: `env_preset` paths also need to be transformed into `resources`
+            # paths, but we cannot do that until the sequence is part of a task, since
+            # the available environment presets are defined in the task schema.
 
         return path, label
 
-    def to_dict(self):
-        out = super().to_dict()
+    @override
+    def _postprocess_to_dict(self, d: dict[str, Any]) -> dict[str, Any]:
+        out = super()._postprocess_to_dict(d)
         del out["_parameter"]
         del out["_path_split"]
-        if "_workflow" in out:
-            del out["_workflow"]
+        out.pop("_workflow", None)
         return out
 
     @property
-    def normalised_path(self):
+    def normalised_path(self) -> str:
         """
         The path to this sequence.
         """
         return self.path
 
     @property
-    def normalised_inputs_path(self):
+    def normalised_inputs_path(self) -> str | None:
         """
         The normalised path without the "inputs" prefix, if the sequence is an
         inputs sequence, else return None.
@@ -941,63 +1060,68 @@ class ValueSequence(JSONLike):
                 return f"{self.labelled_type}.{self.input_path}"
             else:
                 return self.labelled_type
+        return None
 
     def make_persistent(
-        self, workflow: app.Workflow, source: Dict
-    ) -> Tuple[str, List[int], bool]:
+        self, workflow: Workflow, source: ParamSource
+    ) -> tuple[str, list[int], bool]:
         """Save value to a persistent workflow."""
 
         if self._values_group_idx is not None:
-            is_new = False
-            data_ref = self._values_group_idx
-            if not all(workflow.check_parameters_exist(data_ref)):
+            if not workflow.check_parameters_exist(self._values_group_idx):
                 raise RuntimeError(
                     f"{self.__class__.__name__} has a parameter group index "
-                    f"({data_ref}), but does not exist in the workflow."
+                    f"({self._values_group_idx}), but does not exist in the workflow."
                 )
             # TODO: log if already persistent.
+            return self.normalised_path, self._values_group_idx, False
 
-        else:
-            data_ref = []
-            source = copy.deepcopy(source)
+        data_ref: list[int] = []
+        source = copy.deepcopy(source)
+        if self.value_class_method:
             source["value_class_method"] = self.value_class_method
-            are_objs = []
-            for idx, i in enumerate(self._values):
-                # record if ParameterValue sub-classes are passed for values, which allows
-                # us to re-init the objects on access to `.value`:
-                are_objs.append(isinstance(i, ParameterValue))
-                source = copy.deepcopy(source)
-                source["sequence_idx"] = idx
-                pg_idx_i = workflow._add_parameter_data(i, source=source)
-                data_ref.append(pg_idx_i)
-
-            is_new = True
-            self._values_group_idx = data_ref
-            self._workflow = workflow
-            self._values = None
-            self._values_are_objs = are_objs
+        are_objs: list[bool] = []
+        assert self._values is not None
+        for idx, item in enumerate(self._values):
+            # record if ParameterValue sub-classes are passed for values, which allows
+            # us to re-init the objects on access to `.value`:
+            are_objs.append(isinstance(item, ParameterValue))
+            source = copy.deepcopy(source)
+            source["sequence_idx"] = idx
+            pg_idx_i = workflow._add_parameter_data(item, source=source)
+            data_ref.append(pg_idx_i)
 
-        return (self.normalised_path, data_ref, is_new)
+        self._values_group_idx = data_ref
+        self._workflow = workflow
+        self._values = None
+        self._values_are_objs = are_objs
+        return self.normalised_path, data_ref, True
 
     @property
-    def workflow(self):
+    def workflow(self) -> Workflow | None:
         """
         The workflow containing this sequence.
         """
         if self._workflow:
+            # (assigned in `make_persistent`)
             return self._workflow
         elif self._element_set:
-            return self._element_set.task_template.workflow_template.workflow
+            # (assigned by parent `ElementSet`)
+            if tmpl := self._element_set.task_template.workflow_template:
+                return tmpl.workflow
+        return None
 
     @property
-    def values(self):
+    def values(self) -> Sequence[Any] | None:
         """
         The values in this sequence.
         """
         if self._values_group_idx is not None:
-            vals = []
+            vals: list[Any] = []
             for idx, pg_idx_i in enumerate(self._values_group_idx):
-                param_i = self.workflow.get_parameter(pg_idx_i)
+                if not (w := self.workflow):
+                    continue
+                param_i = w.get_parameter(pg_idx_i)
                 if param_i.data is not None:
                     val_i = param_i.data
                 else:
@@ -1007,16 +1131,11 @@ class ValueSequence(JSONLike):
                 # yet been committed to disk:
                 if (
                     self.parameter
-                    and self.parameter._value_class
+                    and self._values_are_objs
                     and self._values_are_objs[idx]
-                    and not isinstance(val_i, self.parameter._value_class)
+                    and isinstance(val_i, dict)
                 ):
-                    method_name = param_i.source.get("value_class_method")
-                    if method_name:
-                        method = getattr(self.parameter._value_class, method_name)
-                    else:
-                        method = self.parameter._value_class
-                    val_i = method(**val_i)
+                    val_i = self.parameter._instantiate_value(param_i.source, val_i)
 
                 vals.append(val_i)
             return vals
@@ -1024,52 +1143,72 @@ class ValueSequence(JSONLike):
             return self._values
 
     @classmethod
-    def _values_from_linear_space(cls, start, stop, num, **kwargs):
+    def _values_from_linear_space(
+        cls, start: float, stop: float, num: int, **kwargs
+    ) -> list[float]:
         return np.linspace(start, stop, num=num, **kwargs).tolist()
 
     @classmethod
-    def _values_from_geometric_space(cls, start, stop, num, **kwargs):
+    def _values_from_geometric_space(
+        cls, start: float, stop: float, num: int, **kwargs
+    ) -> list[float]:
         return np.geomspace(start, stop, num=num, **kwargs).tolist()
 
     @classmethod
-    def _values_from_log_space(cls, start, stop, num, base=10.0, **kwargs):
+    def _values_from_log_space(
+        cls, start: float, stop: float, num: int, base: float = 10.0, **kwargs
+    ) -> list[float]:
         return np.logspace(start, stop, num=num, base=base, **kwargs).tolist()
 
     @classmethod
-    def _values_from_range(cls, start, stop, step, **kwargs):
+    def _values_from_range(
+        cls, start: int | float, stop: int | float, step: int | float, **kwargs
+    ) -> list[float]:
         return np.arange(start, stop, step, **kwargs).tolist()
 
     @classmethod
-    def _values_from_file(cls, file_path):
+    def _values_from_file(cls, file_path: str | Path) -> list[str]:
         with Path(file_path).open("rt") as fh:
-            vals = [i.strip() for i in fh.readlines()]
-        return vals
+            return [line.strip() for line in fh.readlines()]
 
     @classmethod
-    def _values_from_rectangle(cls, start, stop, num, coord=None, include=None, **kwargs):
+    def _values_from_rectangle(
+        cls,
+        start: Sequence[float],
+        stop: Sequence[float],
+        num: Sequence[int],
+        coord: int | tuple[int, int] | None = None,
+        include: Sequence[str] | None = None,
+        **kwargs,
+    ) -> list[float]:
         vals = linspace_rect(start=start, stop=stop, num=num, include=include, **kwargs)
         if coord is not None:
-            vals = vals[coord].tolist()
+            return vals[coord].tolist()
         else:
-            vals = (vals.T).tolist()
-        return vals
+            return (vals.T).tolist()
 
     @classmethod
-    def _values_from_random_uniform(cls, num, low=0.0, high=1.0, seed=None):
+    def _values_from_random_uniform(
+        cls,
+        num: int,
+        low: float = 0.0,
+        high: float = 1.0,
+        seed: int | list[int] | None = None,
+    ) -> list[float]:
         rng = np.random.default_rng(seed)
         return rng.uniform(low=low, high=high, size=num).tolist()
 
     @classmethod
     def from_linear_space(
         cls,
-        path,
-        start,
-        stop,
-        num,
-        nesting_order=0,
-        label=None,
+        path: str,
+        start: float,
+        stop: float,
+        num: int,
+        nesting_order: float = 0,
+        label: str | int | None = None,
         **kwargs,
-    ):
+    ) -> Self:
         """
         Build a sequence from a NumPy linear space.
         """
@@ -1084,15 +1223,15 @@ class ValueSequence(JSONLike):
     @classmethod
     def from_geometric_space(
         cls,
-        path,
-        start,
-        stop,
-        num,
-        nesting_order=0,
+        path: str,
+        start: float,
+        stop: float,
+        num: int,
+        nesting_order: float = 0,
         endpoint=True,
-        label=None,
+        label: str | int | None = None,
         **kwargs,
-    ):
+    ) -> Self:
         """
         Build a sequence from a NumPy geometric space.
         """
@@ -1106,16 +1245,16 @@ class ValueSequence(JSONLike):
     @classmethod
     def from_log_space(
         cls,
-        path,
-        start,
-        stop,
-        num,
-        nesting_order=0,
+        path: str,
+        start: float,
+        stop: float,
+        num: int,
+        nesting_order: float = 0,
         base=10.0,
         endpoint=True,
-        label=None,
+        label: str | int | None = None,
         **kwargs,
-    ):
+    ) -> Self:
         """
         Build a sequence from a NumPy logarithmic space.
         """
@@ -1136,14 +1275,14 @@ class ValueSequence(JSONLike):
     @classmethod
     def from_range(
         cls,
-        path,
-        start,
-        stop,
-        nesting_order=0,
-        step=1,
-        label=None,
+        path: str,
+        start: float,
+        stop: float,
+        nesting_order: float = 0,
+        step: int | float = 1,
+        label: str | int | None = None,
         **kwargs,
-    ):
+    ) -> Self:
         """
         Build a sequence from a range.
         """
@@ -1173,12 +1312,12 @@ class ValueSequence(JSONLike):
     @classmethod
     def from_file(
         cls,
-        path,
-        file_path,
-        nesting_order=0,
-        label=None,
+        path: str,
+        file_path: str | Path,
+        nesting_order: float = 0,
+        label: str | int | None = None,
         **kwargs,
-    ):
+    ) -> Self:
         """
         Build a sequence from a simple file.
         """
@@ -1198,16 +1337,16 @@ class ValueSequence(JSONLike):
     @classmethod
     def from_rectangle(
         cls,
-        path,
-        start,
-        stop,
-        num,
-        coord: Optional[int] = None,
-        include: Optional[list[str]] = None,
-        nesting_order=0,
-        label=None,
+        path: str,
+        start: Sequence[float],
+        stop: Sequence[float],
+        num: Sequence[int],
+        coord: int | None = None,
+        include: list[str] | None = None,
+        nesting_order: float = 0,
+        label: str | int | None = None,
         **kwargs,
-    ):
+    ) -> Self:
         """
         Build a sequence to cover a rectangle.
 
@@ -1238,14 +1377,14 @@ class ValueSequence(JSONLike):
     def from_random_uniform(
         cls,
         path,
-        num,
-        low=0.0,
-        high=1.0,
-        seed=None,
-        nesting_order=0,
-        label=None,
+        num: int,
+        low: float = 0.0,
+        high: float = 1.0,
+        seed: int | list[int] | None = None,
+        nesting_order: float = 0,
+        label: str | int | None = None,
         **kwargs,
-    ):
+    ) -> Self:
         """
         Build a sequence from a uniform random number generator.
         """
@@ -1257,13 +1396,264 @@ class ValueSequence(JSONLike):
         return obj
 
 
+class MultiPathSequence(_BaseSequence):
+    """
+    A sequence of values to be distributed across one or more paths.
+
+    Notes
+    -----
+    This is useful when we would like to generate values for multiple input paths that
+    have some interdependency, or when they must be generate together in one go.
+
+    Parameters
+    ----------
+    paths:
+        The paths to this multi-path sequence.
+    values:
+        The values in this multi-path sequence.
+    nesting_order: int
+        A nesting order for this multi-path sequence. Can be used to compose sequences
+        together.
+    label: str
+        A label for this multi-path sequence.
+    value_class_method: str
+        Name of a method used to generate multi-path sequence values. Not normally used
+        directly.
+    """
+
+    # TODO: add a `path_axis` argument with doc string like:
+    # path_axis:
+    #    The axis (as in a Numpy axis) along `values` to which the different paths
+    #    correspond.
+
+    def __init__(
+        self,
+        paths: Sequence[str],
+        values: NDArray | Sequence[Sequence] | None,
+        nesting_order: int | float | None = None,
+        label: str | int | None = None,
+        value_class_method: str | None = None,
+    ):
+        self.paths = list(paths)
+        self.nesting_order = nesting_order
+        self.label = label
+        self.value_class_method = value_class_method
+
+        self._sequences: list[ValueSequence] | None = None
+        self._values: NDArray | Sequence[Sequence] | None = None
+
+        if values is not None:
+            if (len_paths := len(paths)) != (len_vals := len(values)):
+                raise ValueError(
+                    f"The number of values ({len_vals}) must be equal to the number of "
+                    f"paths provided ({len_paths})."
+                )
+            self._values = values
+            self._sequences = [
+                self._app.ValueSequence(
+                    path=path,
+                    values=values[idx],
+                    label=label,
+                    nesting_order=nesting_order,
+                    value_class_method=value_class_method,
+                )
+                for idx, path in enumerate(paths)
+            ]
+
+        # assigned by `_move_to_sequence_list` (invoked by first init of parent
+        # `ElementSet`), corresponds to the sequence indices with the element set's
+        # sequence list:
+        self._sequence_indices: Sequence[int] | None = None
+
+        self._element_set: ElementSet | None = None  # assigned by parent `ElementSet`
+
+        self._values_method: str | None = None
+        self._values_method_args: dict | None = None
+
+    def __repr__(self):
+
+        label_str = f"label={self.label!r}, " if self.label else ""
+        val_cls_str = (
+            f"value_class_method={self.value_class_method!r}, "
+            if self.value_class_method
+            else ""
+        )
+        return (
+            f"{self.__class__.__name__}("
+            f"paths={self.paths!r}, "
+            f"{label_str}"
+            f"nesting_order={self.nesting_order}, "
+            f"{val_cls_str}"
+            f"values={self.values}"
+            f")"
+        )
+
+    def __deepcopy__(self, memo: dict[int, Any]):
+        kwargs = self.to_dict()
+        kwargs["values"] = kwargs.pop("_values")
+
+        _sequences = kwargs.pop("_sequences", None)
+        _sequence_indices = kwargs.pop("_sequence_indices", None)
+        _values_method = kwargs.pop("_values_method", None)
+        _values_method_args = kwargs.pop("_values_method_args", None)
+
+        obj = self.__class__(**copy.deepcopy(kwargs, memo))
+
+        obj._sequences = _sequences
+        obj._sequence_indices = _sequence_indices
+        obj._values_method = _values_method
+        obj._values_method_args = _values_method_args
+
+        obj._element_set = self._element_set
+
+        return obj
+
+    @override
+    def _postprocess_to_dict(self, d: dict[str, Any]) -> dict[str, Any]:
+        dct = super()._postprocess_to_dict(d)
+        del dct["_sequences"]
+        return dct
+
+    @classmethod
+    def _json_like_constructor(cls, json_like):
+        """Invoked by `JSONLike.from_json_like` instead of `__init__`."""
+
+        # pop the keys we don't accept in `__init__`, and then assign after `__init__`:
+        _sequence_indices = json_like.pop("_sequence_indices", None)
+
+        _values_method = json_like.pop("_values_method", None)
+        _values_method_args = json_like.pop("_values_method_args", None)
+        if "_values" in json_like:
+            json_like["values"] = json_like.pop("_values")
+
+        obj = cls(**json_like)
+        obj._sequence_indices = _sequence_indices
+        obj._values_method = _values_method
+        obj._values_method_args = _values_method_args
+        return obj
+
+    @property
+    def sequence_indices(self) -> Sequence[int] | None:
+        """
+        The range indices (start and stop) to the parent element set's sequences list that
+        correspond to the `ValueSequence`s generated by this multi-path sequence, if this
+        object is bound to a parent element set.
+        """
+        return self._sequence_indices
+
+    @property
+    def sequences(self) -> Sequence[ValueSequence]:
+        """
+        The child value sequences, one for each path.
+        """
+        if self._sequence_indices:
+            # they are stored in the parent `ElementSet`
+            assert self._element_set
+            return self._element_set.sequences[slice(*self._sequence_indices)]
+        else:
+            # not yet bound to a parent `ElementSet`
+            assert self._sequences
+            return self._sequences
+
+    @property
+    def values(self) -> list[Sequence[Any]]:
+        values = []
+        for seq_i in self.sequences:
+            assert seq_i.values
+            values.append(seq_i.values)
+        return values
+
+    def _move_to_sequence_list(self, sequences: list[ValueSequence]) -> None:
+        """
+        Move the individual value sequences to an external list of value sequences (i.e.,
+        the parent `ElementSet`'s), and update the `sequence_indices` attribute so we can
+        retrieve the sequences from that list at will.
+        """
+        len_ours = len(self.sequences)
+        len_ext = len(sequences)
+        sequences.extend(self.sequences)
+
+        # child sequences are now stored externally, and values retrieved via those:
+        self._sequences = None
+        self._values = None
+        self._sequence_indices = [len_ext, len_ext + len_ours]
+
+    @classmethod
+    def _values_from_latin_hypercube(
+        cls,
+        paths: Sequence[str],
+        num_samples: int,
+        *,
+        scramble: bool = True,
+        strength: int = 1,
+        optimization: Literal["random-cd", "lloyd"] | None = None,
+        rng=None,
+    ) -> NDArray:
+
+        num_paths = len(paths)
+        kwargs = dict(
+            d=num_paths,
+            scramble=scramble,
+            strength=strength,
+            optimization=optimization,
+            rng=rng,
+        )
+        try:
+            sampler = LatinHypercube(**kwargs)
+        except TypeError:
+            # `rng` was previously (<1.15.0) `seed`:
+            kwargs["seed"] = kwargs.pop("rng")
+            sampler = LatinHypercube(**kwargs)
+        return sampler.random(n=num_samples).T
+
+    @classmethod
+    def from_latin_hypercube(
+        cls,
+        paths: Sequence[str],
+        num_samples: int,
+        *,
+        scramble: bool = True,
+        strength: int = 1,
+        optimization: Literal["random-cd", "lloyd"] | None = None,
+        rng=None,
+        nesting_order: int | float | None = None,
+        label: str | int | None = None,
+    ) -> Self:
+        """
+        Generate values from SciPy's latin hypercube sampler: :class:`scipy.stats.qmc.LatinHypercube`.
+        """
+        kwargs = {
+            "paths": paths,
+            "num_samples": num_samples,
+            "scramble": scramble,
+            "strength": strength,
+            "optimization": optimization,
+            "rng": rng,
+        }
+        values = cls._values_from_latin_hypercube(**kwargs)
+        assert values is not None
+        obj = cls(
+            paths=paths,
+            values=values,
+            nesting_order=nesting_order,
+            label=label,
+        )
+        obj._values_method = "from_latin_hypercube"
+        obj._values_method_args = kwargs
+        return obj
+
+
 @dataclass
 class AbstractInputValue(JSONLike):
     """Class to represent all sequence-able inputs to a task."""
 
-    _workflow = None
+    _workflow: Workflow | None = None
+    _element_set: ElementSet | None = None
+    _schema_input: SchemaInput | None = None
+    _value: Any | None = None
+    _value_group_idx: int | list[int] | None = None
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         try:
             value_str = f", value={self.value}"
         except WorkflowParameterMissingError:
@@ -1276,25 +1666,26 @@ class AbstractInputValue(JSONLike):
             f")"
         )
 
-    def to_dict(self):
-        out = super().to_dict()
-        if "_workflow" in out:
-            del out["_workflow"]
-        if "_schema_input" in out:
-            del out["_schema_input"]
+    @override
+    def _postprocess_to_dict(self, d: dict[str, Any]) -> dict[str, Any]:
+        out = super()._postprocess_to_dict(d)
+        out.pop("_workflow", None)
+        out.pop("_schema_input", None)
         return out
 
     def make_persistent(
-        self, workflow: app.Workflow, source: Dict
-    ) -> Tuple[str, List[int], bool]:
+        self, workflow: Workflow, source: ParamSource
+    ) -> tuple[str, list[int | list[int]], bool]:
         """Save value to a persistent workflow.
 
         Returns
         -------
-        String is the data path for this task input and single item integer list
-        contains the index of the parameter data Zarr group where the data is
-        stored.
-
+        str
+            Normalised path for this task input.
+        list[int | list[int]]
+            The index of the parameter data Zarr group where the data is stored.
+        bool
+            Whether this is newly persistent.
         """
 
         if self._value_group_idx is not None:
@@ -1315,30 +1706,34 @@ class AbstractInputValue(JSONLike):
         return (self.normalised_path, [data_ref], is_new)
 
     @property
-    def workflow(self):
+    def normalised_path(self) -> str:
+        """
+        The normalised path, if known.
+        """
+        raise NotImplementedError
+
+    @property
+    def workflow(self) -> Workflow | None:
         """
         The workflow containing this input value.
         """
         if self._workflow:
             return self._workflow
-        elif self._element_set:
-            return self._element_set.task_template.workflow_template.workflow
-        elif self._schema_input:
-            return self._schema_input.task_schema.task_template.workflow_template.workflow
+        if self._element_set:
+            if w_tmpl := self._element_set.task_template.workflow_template:
+                return w_tmpl.workflow
+        if self._schema_input:
+            if t_tmpl := self._schema_input.task_schema.task_template:
+                if w_tmpl := t_tmpl.workflow_template:
+                    return w_tmpl.workflow
+        return None
 
     @property
-    def value(self):
+    def value(self) -> Any:
         """
         The value itself.
         """
-        if self._value_group_idx is not None:
-            val = self.workflow.get_parameter_data(self._value_group_idx)
-            if self._value_is_obj and self.parameter._value_class:
-                val = self.parameter._value_class(**val)
-        else:
-            val = self._value
-
-        return val
+        return self._value
 
 
 @dataclass
@@ -1348,13 +1743,16 @@ class ValuePerturbation(AbstractInputValue):
     """
 
     #: The name of this perturbation.
-    name: str
+    name: str = ""
     #: The path to the value(s) to perturb.
-    path: Optional[Sequence[Union[str, int, float]]] = None
+    path: Sequence[str | int | float] | None = None
     #: The multiplicative factor to apply.
-    multiplicative_factor: Optional[Numeric] = 1
+    multiplicative_factor: Numeric | None = 1
     #: The additive factor to apply.
-    additive_factor: Optional[Numeric] = 0
+    additive_factor: Numeric | None = 0
+
+    def __post_init__(self):
+        assert self.name
 
     @classmethod
     def from_spec(cls, spec):
@@ -1364,6 +1762,7 @@ class ValuePerturbation(AbstractInputValue):
         return cls(**spec)
 
 
+@hydrate
 class InputValue(AbstractInputValue):
     """
     An input value to a task.
@@ -1386,7 +1785,7 @@ class InputValue(AbstractInputValue):
 
     """
 
-    _child_objects = (
+    _child_objects: ClassVar[tuple[ChildObjectSpec, ...]] = (
         ChildObjectSpec(
             name="parameter",
             class_name="Parameter",
@@ -1397,45 +1796,40 @@ class InputValue(AbstractInputValue):
 
     def __init__(
         self,
-        parameter: Union[app.Parameter, str],
-        value: Optional[Any] = None,
-        label: Optional[str] = None,
-        value_class_method: Optional[str] = None,
-        path: Optional[str] = None,
-        __check_obj: Optional[bool] = True,
+        parameter: Parameter | SchemaInput | str,
+        value: Any | None = None,
+        label: str | int | None = None,
+        value_class_method: str | None = None,
+        path: str | None = None,
+        _check_obj: bool = True,
     ):
+        super().__init__()
         if isinstance(parameter, str):
             try:
-                parameter = self.app.parameters.get(parameter)
+                #: Parameter whose value is to be specified.
+                self.parameter = self._app.parameters.get(parameter)
             except ValueError:
-                parameter = self.app.Parameter(parameter)
+                self.parameter = self._app.Parameter(parameter)
         elif isinstance(parameter, SchemaInput):
-            parameter = parameter.parameter
+            self.parameter = parameter.parameter
+        else:
+            self.parameter = parameter
 
-        #: Parameter whose value is to be specified.
-        self.parameter = parameter
         #: Identifier to be used where the associated `SchemaInput` accepts multiple
         #: parameters of the specified type.
         self.label = str(label) if label is not None else ""
         #: Dot-delimited path within the parameter's nested data structure for which
         #: `value` should be set.
-        self.path = (path.strip(".") if path else None) or None
+        self.path = (path.strip(".") or None) if path else None
         #: A class method that can be invoked with the `value` attribute as keyword
         #: arguments.
         self.value_class_method = value_class_method
-        self._value = _process_demo_data_strings(self.app, value)
-
-        self._value_group_idx = None  # assigned by method make_persistent
-        self._element_set = None  # assigned by parent ElementSet (if belonging)
-
-        # assigned by parent SchemaInput (if this object is a default value of a
-        # SchemaInput):
-        self._schema_input = None
+        self._value = _process_demo_data_strings(self._app, value)
 
         # record if a ParameterValue sub-class is passed for value, which allows us
         # to re-init the object on `.value`:
         self._value_is_obj = isinstance(value, ParameterValue)
-        if __check_obj:
+        if _check_obj:
             self._check_dict_value_if_object()
 
     def _check_dict_value_if_object(self):
@@ -1459,13 +1853,13 @@ class InputValue(AbstractInputValue):
                 f"dict."
             )
 
-    def __deepcopy__(self, memo):
+    def __deepcopy__(self, memo: dict[int, Any]) -> Self:
         kwargs = self.to_dict()
         _value = kwargs.pop("_value")
         kwargs.pop("_schema_input", None)
         _value_group_idx = kwargs.pop("_value_group_idx")
         _value_is_obj = kwargs.pop("_value_is_obj")
-        obj = self.__class__(**copy.deepcopy(kwargs, memo), _InputValue__check_obj=False)
+        obj = self.__class__(**copy.deepcopy(kwargs, memo), _check_obj=False)
         obj._value = _value
         obj._value_group_idx = _value_group_idx
         obj._value_is_obj = _value_is_obj
@@ -1473,7 +1867,7 @@ class InputValue(AbstractInputValue):
         obj._schema_input = self._schema_input
         return obj
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         val_grp_idx = ""
         if self._value_group_idx is not None:
             val_grp_idx = f", value_group_idx={self._value_group_idx}"
@@ -1500,12 +1894,10 @@ class InputValue(AbstractInputValue):
             f")"
         )
 
-    def __eq__(self, other) -> bool:
+    def __eq__(self, other: Any) -> bool:
         if not isinstance(other, self.__class__):
             return False
-        if self.to_dict() == other.to_dict():
-            return True
-        return False
+        return self.to_dict() == other.to_dict()
 
     @classmethod
     def _json_like_constructor(cls, json_like):
@@ -1516,14 +1908,14 @@ class InputValue(AbstractInputValue):
         if "_value" in json_like:
             json_like["value"] = json_like.pop("_value")
 
-        obj = cls(**json_like, _InputValue__check_obj=False)
+        obj = cls(**json_like, _check_obj=False)
         obj._value_group_idx = _value_group_idx
         obj._value_is_obj = _value_is_obj
         obj._check_dict_value_if_object()
         return obj
 
     @property
-    def labelled_type(self):
+    def labelled_type(self) -> str:
         """
         The labelled type of this input value.
         """
@@ -1531,22 +1923,25 @@ class InputValue(AbstractInputValue):
         return f"{self.parameter.typ}{label}"
 
     @property
-    def normalised_inputs_path(self):
+    def normalised_inputs_path(self) -> str:
         """
         The normalised input path without the ``inputs.`` prefix.
         """
         return f"{self.labelled_type}{f'.{self.path}' if self.path else ''}"
 
     @property
-    def normalised_path(self):
+    def normalised_path(self) -> str:
         """
         The full normalised input path.
         """
         return f"inputs.{self.normalised_inputs_path}"
 
-    def make_persistent(self, workflow: Any, source: Dict) -> Tuple[str, List[int], bool]:
+    def make_persistent(
+        self, workflow: Workflow, source: ParamSource
+    ) -> tuple[str, list[int | list[int]], bool]:
         source = copy.deepcopy(source)
-        source["value_class_method"] = self.value_class_method
+        if self.value_class_method is not None:
+            source["value_class_method"] = self.value_class_method
         return super().make_persistent(workflow, source)
 
     @classmethod
@@ -1558,25 +1953,37 @@ class InputValue(AbstractInputValue):
             json_like["label"] = label
 
         if "::" in json_like["parameter"]:
+            # double-colon syntax indicates a `ParameterValue`-subclass class method
+            # of the specified name should be used to construct the values:
             param, cls_method = json_like["parameter"].split("::")
             json_like["parameter"] = param
             json_like["value_class_method"] = cls_method
 
         if "path" not in json_like:
-            param_spec = json_like["parameter"].split(".")
-            json_like["parameter"] = param_spec[0]
-            json_like["path"] = ".".join(param_spec[1:])
-
-        obj = super().from_json_like(json_like, shared_data)
+            # in the case this value corresponds to some sub-part of the parameter's
+            # nested data structure:
+            param, *path = json_like["parameter"].split(".")
+            json_like["parameter"] = param
+            json_like["path"] = ".".join(path)
 
-        return obj
+        return super().from_json_like(json_like, shared_data)
 
     @property
-    def is_sub_value(self):
+    def is_sub_value(self) -> bool:
         """True if the value is for a sub part of the parameter (i.e. if `path` is set).
         Sub-values are not added to the base parameter data, but are interpreted as
         single-value sequences."""
-        return True if self.path else False
+        return bool(self.path)
+
+    @property
+    def value(self) -> Any:
+        if self._value_group_idx is not None and self.workflow:
+            val = self.workflow.get_parameter_data(cast("int", self._value_group_idx))
+            if self._value_is_obj and self.parameter._value_class:
+                return self.parameter._value_class(**val)
+            return val
+        else:
+            return self._value
 
 
 class ResourceSpec(JSONLike):
@@ -1611,6 +2018,12 @@ class ResourceSpec(JSONLike):
         Whether to use array jobs.
     max_array_items: int
         If using array jobs, up to how many items should be in the job array.
+    write_app_logs: bool
+        Whether an app log file should be written.
+    combine_jobscript_std: bool
+        Whether jobscript standard output and error streams should be combined.
+    combine_scripts: bool
+        Whether Python scripts should be combined.
     time_limit: str
         How long to run for.
     scheduler_args: dict[str, Any]
@@ -1621,6 +2034,13 @@ class ResourceSpec(JSONLike):
         Which OS to use.
     environments: dict
         Which execution environments to use.
+    resources_id: int
+        An arbitrary integer that can be used to force multiple jobscripts.
+    skip_downstream_on_failure: bool
+        Whether to skip downstream dependents on failure.
+    allow_failed_dependencies: int | float | bool | None
+        The failure tolerance with respect to dependencies, specified as a number or
+        proportion.
     SGE_parallel_env: str
         Which SGE parallel environment to request.
     SLURM_partition: str
@@ -1636,7 +2056,7 @@ class ResourceSpec(JSONLike):
     """
 
     #: The names of parameters that may be used when making an instance of this class.
-    ALLOWED_PARAMETERS = {
+    ALLOWED_PARAMETERS: ClassVar[set[str]] = {
         "scratch",
         "parallel_mode",
         "num_cores",
@@ -1647,11 +2067,16 @@ class ResourceSpec(JSONLike):
         "shell",
         "use_job_array",
         "max_array_items",
+        "write_app_logs",
+        "combine_jobscript_std",
+        "combine_scripts",
         "time_limit",
         "scheduler_args",
         "shell_args",
         "os_name",
         "environments",
+        "resources_id",
+        "skip_downstream_on_failure",
         "SGE_parallel_env",
         "SLURM_partition",
         "SLURM_num_tasks",
@@ -1660,51 +2085,76 @@ class ResourceSpec(JSONLike):
         "SLURM_num_cpus_per_task",
     }
 
-    _resource_list = None
+    _resource_list: ResourceList | None = None
 
-    _child_objects = (
+    _child_objects: ClassVar[tuple[ChildObjectSpec, ...]] = (
         ChildObjectSpec(
             name="scope",
             class_name="ActionScope",
         ),
     )
 
+    @staticmethod
+    def __quoted(values: Iterable):
+        return ", ".join(f'"{item}"' for item in values)
+
+    @classmethod
+    def _allowed_params_quoted(cls) -> str:
+        """
+        The string version of the list of allowed parameters.
+        """
+        return cls.__quoted(cls.ALLOWED_PARAMETERS)
+
+    @staticmethod
+    def __parse_thing(
+        typ: type[ActionScope], val: ActionScope | str | None
+    ) -> ActionScope | None:
+        if isinstance(val, typ):
+            return val
+        elif val is None:
+            return typ.any()
+        else:
+            return typ.from_json_like(cast("str", val))
+
     def __init__(
         self,
-        scope: app.ActionScope = None,
-        scratch: Optional[str] = None,
-        parallel_mode: Optional[Union[str, ParallelMode]] = None,
-        num_cores: Optional[int] = None,
-        num_cores_per_node: Optional[int] = None,
-        num_threads: Optional[int] = None,
-        num_nodes: Optional[int] = None,
-        scheduler: Optional[str] = None,
-        shell: Optional[str] = None,
-        use_job_array: Optional[bool] = None,
-        max_array_items: Optional[int] = None,
-        time_limit: Optional[Union[str, timedelta]] = None,
-        scheduler_args: Optional[Dict] = None,
-        shell_args: Optional[Dict] = None,
-        os_name: Optional[str] = None,
-        environments: Optional[Dict] = None,
-        SGE_parallel_env: Optional[str] = None,
-        SLURM_partition: Optional[str] = None,
-        SLURM_num_tasks: Optional[str] = None,
-        SLURM_num_tasks_per_node: Optional[str] = None,
-        SLURM_num_nodes: Optional[str] = None,
-        SLURM_num_cpus_per_task: Optional[str] = None,
+        scope: ActionScope | str | None = None,
+        scratch: str | None = None,
+        parallel_mode: str | ParallelMode | None = None,
+        num_cores: int | None = None,
+        num_cores_per_node: int | None = None,
+        num_threads: int | None = None,
+        num_nodes: int | None = None,
+        scheduler: str | None = None,
+        shell: str | None = None,
+        use_job_array: bool | None = None,
+        max_array_items: int | None = None,
+        write_app_logs: bool | None = None,
+        combine_jobscript_std: bool | None = None,
+        combine_scripts: bool | None = None,
+        time_limit: str | timedelta | None = None,
+        scheduler_args: dict[str, Any] | None = None,
+        shell_args: dict[str, Any] | None = None,
+        os_name: str | None = None,
+        environments: Mapping[str, Mapping[str, Any]] | None = None,
+        resources_id: int | None = None,
+        skip_downstream_on_failure: bool | None = None,
+        SGE_parallel_env: str | None = None,
+        SLURM_partition: str | None = None,
+        SLURM_num_tasks: str | None = None,
+        SLURM_num_tasks_per_node: str | None = None,
+        SLURM_num_nodes: str | None = None,
+        SLURM_num_cpus_per_task: str | None = None,
     ):
         #: Which scope does this apply to.
-        self.scope = scope or self.app.ActionScope.any()
-        if not isinstance(self.scope, self.app.ActionScope):
-            self.scope = self.app.ActionScope.from_json_like(self.scope)
+        self.scope = self.__parse_thing(self._app.ActionScope, scope)
 
         if isinstance(time_limit, timedelta):
             time_limit = timedelta_format(time_limit)
 
         # assigned by `make_persistent`
-        self._workflow = None
-        self._value_group_idx = None
+        self._workflow: Workflow | None = None
+        self._value_group_idx: int | list[int] | None = None
 
         # user-specified resource parameters:
         self._scratch = scratch
@@ -1717,8 +2167,13 @@ class ResourceSpec(JSONLike):
         self._shell = self._process_string(shell)
         self._os_name = self._process_string(os_name)
         self._environments = environments
+        self._resources_id = resources_id
+        self._skip_downstream_on_failure = skip_downstream_on_failure
         self._use_job_array = use_job_array
         self._max_array_items = max_array_items
+        self._write_app_logs = write_app_logs
+        self._combine_jobscript_std = combine_jobscript_std
+        self._combine_scripts = combine_scripts
         self._time_limit = time_limit
         self._scheduler_args = scheduler_args
         self._shell_args = shell_args
@@ -1733,7 +2188,7 @@ class ResourceSpec(JSONLike):
         self._SLURM_num_nodes = SLURM_num_nodes
         self._SLURM_num_cpus_per_task = SLURM_num_cpus_per_task
 
-    def __deepcopy__(self, memo):
+    def __deepcopy__(self, memo: dict[int, Any]) -> Self:
         kwargs = copy.deepcopy(self.to_dict(), memo)
         _value_group_idx = kwargs.pop("value_group_idx", None)
         obj = self.__class__(**kwargs)
@@ -1743,65 +2198,60 @@ class ResourceSpec(JSONLike):
 
     def __repr__(self):
         param_strs = ""
-        for i in self.ALLOWED_PARAMETERS:
-            i_str = ""
+        for param in self.ALLOWED_PARAMETERS:
             try:
-                i_val = getattr(self, i)
+                i_val = getattr(self, param)
             except WorkflowParameterMissingError:
-                pass
-            else:
-                if i_val is not None:
-                    i_str = f", {i}={i_val!r}"
-
-            param_strs += i_str
+                continue
+            if i_val is not None:
+                param_strs += f", {param}={i_val!r}"
 
         return f"{self.__class__.__name__}(scope={self.scope}{param_strs})"
 
-    def __eq__(self, other) -> bool:
+    def __eq__(self, other: Any) -> bool:
         if not isinstance(other, self.__class__):
             return False
-        if self.to_dict() == other.to_dict():
-            return True
-        return False
+        return self.to_dict() == other.to_dict()
 
     @classmethod
-    def _json_like_constructor(cls, json_like):
+    def _json_like_constructor(cls, json_like) -> Self:
         """Invoked by `JSONLike.from_json_like` instead of `__init__`."""
 
         _value_group_idx = json_like.pop("value_group_idx", None)
         try:
             obj = cls(**json_like)
         except TypeError:
-            given_keys = set(k for k in json_like.keys() if k != "scope")
-            bad_keys = given_keys - cls.ALLOWED_PARAMETERS
-            bad_keys_str = ", ".join(f'"{i}"' for i in bad_keys)
-            allowed_keys_str = ", ".join(f'"{i}"' for i in cls.ALLOWED_PARAMETERS)
+            given_keys = set(k for k in json_like if k != "scope")
+            bad_keys = cls.__quoted(given_keys - cls.ALLOWED_PARAMETERS)
+            good_keys = cls._allowed_params_quoted()
             raise UnknownResourceSpecItemError(
-                f"The following resource item names are unknown: {bad_keys_str}. Allowed "
-                f"resource item names are: {allowed_keys_str}."
+                f"The following resource item names are unknown: {bad_keys}. "
+                f"Allowed resource item names are: {good_keys}."
             )
         obj._value_group_idx = _value_group_idx
 
         return obj
 
     @property
-    def normalised_resources_path(self):
+    def normalised_resources_path(self) -> str:
         """
         Standard name of this resource spec.
         """
-        return self.scope.to_string()
+        scope = self.scope
+        assert scope is not None
+        return scope.to_string()
 
     @property
-    def normalised_path(self):
+    def normalised_path(self) -> str:
         """
         Full name of this resource spec.
         """
         return f"resources.{self.normalised_resources_path}"
 
-    def to_dict(self):
-        out = super().to_dict()
-        if "_workflow" in out:
-            del out["_workflow"]
+    @override
+    def _postprocess_to_dict(self, d: dict[str, Any]) -> dict[str, Any]:
+        out = super()._postprocess_to_dict(d)
+        out.pop("_workflow", None)
 
         if self._value_group_idx is not None:
             # only store pointer to persistent data:
@@ -1819,9 +2269,13 @@ class ResourceSpec(JSONLike):
         out = {k: v for k, v in out.items() if v is not None}
         return out
 
+    @classmethod
+    def __is_Workflow(cls, value) -> TypeIs[Workflow]:
+        return isinstance(value, cls._app.Workflow)
+
     def make_persistent(
-        self, workflow: app.Workflow, source: Dict
-    ) -> Tuple[str, List[int], bool]:
+        self, workflow: ResourcePersistingWorkflow, source: ParamSource
+    ) -> tuple[str, list[int | list[int]], bool]:
         """Save to a persistent workflow.
 
         Returns
@@ -1830,6 +2284,9 @@ class ResourceSpec(JSONLike):
         contains the indices of the parameter data Zarr groups where the data is
         stored.
 
+        Note
+        ----
+        May modify the internal state of this object.
         """
 
         if self._value_group_idx is not None:
@@ -1845,7 +2302,8 @@ class ResourceSpec(JSONLike):
             data_ref = workflow._add_parameter_data(self._get_members(), source=source)
             is_new = True
             self._value_group_idx = data_ref
-            self._workflow = workflow
+            if self.__is_Workflow(workflow):
+                self._workflow = workflow
 
             self._num_cores = None
             self._scratch = None
@@ -1853,11 +2311,16 @@ class ResourceSpec(JSONLike):
             self._shell = None
             self._use_job_array = None
             self._max_array_items = None
+            self._write_app_logs = None
+            self._combine_jobscript_std = None
+            self._combine_scripts = None
             self._time_limit = None
             self._scheduler_args = None
             self._shell_args = None
             self._os_name = None
             self._environments = None
+            self._resources_id = None
+            self._skip_downstream_on_failure = None
 
         return (self.normalised_path, [data_ref], is_new)
 
@@ -1868,18 +2331,18 @@ class ResourceSpec(JSONLike):
             kwargs[name] = getattr(self, name)
         return self.__class__(**kwargs)
 
-    def _get_value(self, value_name=None):
-        if self._value_group_idx is not None:
-            val = self.workflow.get_parameter_data(self._value_group_idx)
+    def _get_value(self, value_name: str | None = None):
+        if self._value_group_idx is not None and self.workflow:
+            val = self.workflow.get_parameter_data(cast("int", self._value_group_idx))
         else:
             val = self._get_members()
-        if value_name:
-            val = val.get(value_name)
+        if value_name is not None and val is not None:
+            return val.get(value_name)
 
         return val
 
     @staticmethod
-    def _process_string(value: Union[str, None]):
+    def _process_string(value: str | None):
         return value.lower().strip() if value else value
 
     def _setter_persistent_check(self):
@@ -1889,7 +2352,7 @@ class ResourceSpec(JSONLike):
             )
 
     @property
-    def scratch(self):
+    def scratch(self) -> str | None:
         """
         Which scratch space to use.
 
@@ -1900,164 +2363,182 @@ class ResourceSpec(JSONLike):
         return self._get_value("scratch")
 
     @property
-    def parallel_mode(self):
+    def parallel_mode(self) -> ParallelMode | None:
         """
         Which parallel mode to use.
         """
         return self._get_value("parallel_mode")
 
     @property
-    def num_cores(self):
+    def num_cores(self) -> int | None:
         """
         How many cores to request.
         """
         return self._get_value("num_cores")
 
     @property
-    def num_cores_per_node(self):
+    def num_cores_per_node(self) -> int | None:
         """
         How many cores per compute node to request.
         """
         return self._get_value("num_cores_per_node")
 
     @property
-    def num_nodes(self):
+    def num_nodes(self) -> int | None:
         """
         How many compute nodes to request.
         """
         return self._get_value("num_nodes")
 
     @property
-    def num_threads(self):
+    def num_threads(self) -> int | None:
         """
         How many threads to request.
         """
         return self._get_value("num_threads")
 
     @property
-    def scheduler(self):
+    def scheduler(self) -> str | None:
         """
         Which scheduler to use.
         """
         return self._get_value("scheduler")
 
     @scheduler.setter
-    def scheduler(self, value):
+    def scheduler(self, value: str | None):
         self._setter_persistent_check()
-        value = self._process_string(value)
-        self._scheduler = value
+        self._scheduler = self._process_string(value)
 
     @property
-    def shell(self):
+    def shell(self) -> str | None:
         """
         Which system shell to use.
         """
         return self._get_value("shell")
 
     @shell.setter
-    def shell(self, value):
+    def shell(self, value: str | None):
         self._setter_persistent_check()
-        value = self._process_string(value)
-        self._shell = value
+        self._shell = self._process_string(value)
 
     @property
-    def use_job_array(self):
+    def use_job_array(self) -> bool:
         """
         Whether to use array jobs.
         """
         return self._get_value("use_job_array")
 
     @property
-    def max_array_items(self):
+    def max_array_items(self) -> int | None:
         """
         If using array jobs, up to how many items should be in the job array.
         """
         return self._get_value("max_array_items")
 
     @property
-    def time_limit(self):
+    def write_app_logs(self) -> bool:
+        return self._get_value("write_app_logs")
+
+    @property
+    def combine_jobscript_std(self) -> bool:
+        return self._get_value("combine_jobscript_std")
+
+    @property
+    def combine_scripts(self) -> bool:
+        return self._get_value("combine_scripts")
+
+    @property
+    def time_limit(self) -> str | None:
         """
         How long to run for.
         """
         return self._get_value("time_limit")
 
     @property
-    def scheduler_args(self):
+    def scheduler_args(self) -> Mapping:  # TODO: TypedDict
         """
         Additional arguments to pass to the scheduler.
         """
         return self._get_value("scheduler_args")
 
     @property
-    def shell_args(self):
+    def shell_args(self) -> Mapping | None:  # TODO: TypedDict
         """
         Additional arguments to pass to the shell.
         """
         return self._get_value("shell_args")
 
     @property
-    def os_name(self):
+    def os_name(self) -> str:
         """
         Which OS to use.
         """
         return self._get_value("os_name")
 
+    @os_name.setter
+    def os_name(self, value: str):
+        self._setter_persistent_check()
+        self._os_name = self._process_string(value)
+
     @property
-    def environments(self):
+    def environments(self) -> Mapping | None:  # TODO: TypedDict
         """
         Which execution environments to use.
         """
         return self._get_value("environments")
 
     @property
-    def SGE_parallel_env(self):
+    def resources_id(self) -> int:
+        return self._get_value("resources_id")
+
+    @property
+    def skip_downstream_on_failure(self) -> bool:
+        return self._get_value("skip_downstream_on_failure")
+
+    @property
+    def SGE_parallel_env(self) -> str | None:
         """
         Which SGE parallel environment to request.
         """
         return self._get_value("SGE_parallel_env")
 
     @property
-    def SLURM_partition(self):
+    def SLURM_partition(self) -> str | None:
         """
         Which SLURM partition to request.
         """
         return self._get_value("SLURM_partition")
 
     @property
-    def SLURM_num_tasks(self):
+    def SLURM_num_tasks(self) -> int | None:
         """
         How many SLURM tasks to request.
         """
         return self._get_value("SLURM_num_tasks")
 
     @property
-    def SLURM_num_tasks_per_node(self):
+    def SLURM_num_tasks_per_node(self) -> int | None:
         """
         How many SLURM tasks per compute node to request.
         """
         return self._get_value("SLURM_num_tasks_per_node")
 
     @property
-    def SLURM_num_nodes(self):
+    def SLURM_num_nodes(self) -> int | None:
         """
         How many compute nodes to request.
         """
         return self._get_value("SLURM_num_nodes")
 
     @property
-    def SLURM_num_cpus_per_task(self):
+    def SLURM_num_cpus_per_task(self) -> int | None:
         """
         How many CPU cores to ask for per SLURM task.
         """
         return self._get_value("SLURM_num_cpus_per_task")
 
-    @os_name.setter
-    def os_name(self, value):
-        self._setter_persistent_check()
-        self._os_name = self._process_string(value)
-
     @property
-    def workflow(self):
+    def workflow(self) -> Workflow | None:
         """
         The workflow owning this resource spec.
         """
@@ -2066,7 +2547,8 @@ class ResourceSpec(JSONLike):
 
         elif self.element_set:
             # element-set-level resources
-            return self.element_set.task_template.workflow_template.workflow
+            wt = self.element_set.task_template.workflow_template
+            return wt.workflow if wt else None
 
         elif self.workflow_template:
             # template-level resources
@@ -2079,47 +2561,29 @@ class ResourceSpec(JSONLike):
                 f"creating the workflow object."
             )
 
+        return None
+
     @property
-    def element_set(self):
+    def element_set(self) -> ElementSet | None:
         """
         The element set that will use this resource spec.
         """
+        if not self._resource_list:
+            return None
         return self._resource_list.element_set
 
     @property
-    def workflow_template(self):
+    def workflow_template(self) -> WorkflowTemplate | None:
         """
         The workflow template that will use this resource spec.
         """
+        if not self._resource_list:
+            return None
         return self._resource_list.workflow_template
 
 
-class InputSourceType(enum.Enum):
-    """
-    The types if input sources.
-    """
-
-    #: Input source is an import.
-    IMPORT = 0
-    #: Input source is local.
-    LOCAL = 1
-    #: Input source is a default.
-    DEFAULT = 2
-    #: Input source is a task.
-    TASK = 3
-
-
-class TaskSourceType(enum.Enum):
-    """
-    The types of task-based input sources.
-    """
-
-    #: Input source is a task input.
-    INPUT = 0
-    #: Input source is a task output.
-    OUTPUT = 1
-    #: Input source is unspecified.
-    ANY = 2
+#: How to specify a selection rule.
+Where: TypeAlias = "RuleArgs | Rule | Sequence[RuleArgs | Rule] | ElementFilter"
 
 
 class InputSource(JSONLike):
@@ -2144,7 +2608,7 @@ class InputSource(JSONLike):
         Filtering rules.
     """
 
-    _child_objects = (
+    _child_objects: ClassVar[tuple[ChildObjectSpec, ...]] = (
         ChildObjectSpec(
             name="source_type",
             json_like_name="type",
@@ -2153,55 +2617,61 @@ class InputSource(JSONLike):
         ),
     )
 
+    @classmethod
+    def __is_ElementFilter(cls, value) -> TypeIs[ElementFilter]:
+        return isinstance(value, cls._app.ElementFilter)
+
+    @classmethod
+    def __is_Rule(cls, value) -> TypeIs[Rule]:
+        return isinstance(value, cls._app.Rule)
+
     def __init__(
         self,
-        source_type,
-        import_ref=None,
-        task_ref=None,
-        task_source_type=None,
-        element_iters=None,
-        path=None,
-        where: Optional[
-            Union[dict, app.Rule, List[dict], List[app.Rule], app.ElementFilter]
-        ] = None,
+        source_type: InputSourceType | str,
+        import_ref: int | None = None,
+        task_ref: int | None = None,
+        task_source_type: TaskSourceType | str | None = None,
+        element_iters: list[int] | None = None,
+        path: str | None = None,
+        where: Where | None = None,
     ):
-        if where is not None and not isinstance(where, ElementFilter):
-            rules = where
-            if not isinstance(rules, list):
-                rules = [rules]
-            for idx, i in enumerate(rules):
-                if not isinstance(i, Rule):
-                    rules[idx] = app.Rule(**i)
-            where = app.ElementFilter(rules=rules)
+        if where is None or self.__is_ElementFilter(where):
+            #: Filtering rules.
+            self.where: ElementFilter | None = where
+        else:
+            self.where = self._app.ElementFilter(
+                rules=[
+                    rule if self.__is_Rule(rule) else self._app.Rule(**rule)
+                    for rule in (where if isinstance(where, Sequence) else [where])
+                ]
+            )
 
         #: Type of the input source.
-        self.source_type = self._validate_source_type(source_type)
+        self.source_type = get_enum_by_name_or_val(InputSourceType, source_type)
         #: Where the input comes from when the type is `IMPORT`.
         self.import_ref = import_ref
         #: Which task is this an input for? Used when the type is `TASK`.
         self.task_ref = task_ref
         #: Type of task source.
-        self.task_source_type = self._validate_task_source_type(task_source_type)
+        self.task_source_type = get_enum_by_name_or_val(TaskSourceType, task_source_type)
         #: Which element iterations does this apply to?
         self.element_iters = element_iters
-        #: Filtering rules.
-        self.where = where
         #: Path to where this input goes.
         self.path = path
 
         if self.source_type is InputSourceType.TASK:
             if self.task_ref is None:
-                raise ValueError(f"Must specify `task_ref` if `source_type` is TASK.")
+                raise ValueError("Must specify `task_ref` if `source_type` is TASK.")
             if self.task_source_type is None:
                 self.task_source_type = TaskSourceType.OUTPUT
 
         if self.source_type is InputSourceType.IMPORT and self.import_ref is None:
-            raise ValueError(f"Must specify `import_ref` if `source_type` is IMPORT.")
+            raise ValueError("Must specify `import_ref` if `source_type` is IMPORT.")
 
-    def __eq__(self, other):
+    def __eq__(self, other: Any):
         if not isinstance(other, self.__class__):
             return False
-        elif (
+        return (
             self.source_type == other.source_type
             and self.import_ref == other.import_ref
             and self.task_ref == other.task_ref
@@ -2209,23 +2679,22 @@ class InputSource(JSONLike):
             and self.element_iters == other.element_iters
             and self.where == other.where
             and self.path == other.path
-        ):
-            return True
-        else:
-            return False
+        )
 
     def __repr__(self) -> str:
+        assert self.source_type
         cls_method_name = self.source_type.name.lower()
 
-        args_lst = []
+        args_lst: list[str] = []
 
         if self.source_type is InputSourceType.IMPORT:
             cls_method_name += "_"
             args_lst.append(f"import_ref={self.import_ref}")
 
         elif self.source_type is InputSourceType.TASK:
-            args_lst += (
-                f"task_ref={self.task_ref}",
+            assert self.task_source_type
+            args_lst.append(f"task_ref={self.task_ref}")
+            args_lst.append(
                 f"task_source_type={self.task_source_type.name.lower()!r}",
             )
 
@@ -2240,15 +2709,16 @@ class InputSource(JSONLike):
 
         return out
 
-    def get_task(self, workflow):
+    def get_task(self, workflow: Workflow) -> WorkflowTask | None:
         """If source_type is task, then return the referenced task from the given
         workflow."""
         if self.source_type is InputSourceType.TASK:
-            for task in workflow.tasks:
-                if task.insert_ID == self.task_ref:
-                    return task
+            return next(
+                (task for task in workflow.tasks if task.insert_ID == self.task_ref), None
+            )
+        return None
 
-    def is_in(self, other_input_sources: List[app.InputSource]) -> Union[None, int]:
+    def is_in(self, other_input_sources: Sequence[InputSource]) -> int | None:
         """Check if this input source is in a list of other input sources, without
         considering the `element_iters` and `where` attributes."""
 
@@ -2263,51 +2733,38 @@ class InputSource(JSONLike):
                 return idx
         return None
 
-    def to_string(self):
+    def to_string(self) -> str:
         """
         Render this input source as a string.
         """
         out = [self.source_type.name.lower()]
         if self.source_type is InputSourceType.TASK:
-            out += [str(self.task_ref), self.task_source_type.name.lower()]
+            assert self.task_source_type
+            out.append(str(self.task_ref))
+            out.append(self.task_source_type.name.lower())
             if self.element_iters is not None:
-                out += ["[" + ",".join(f"{i}" for i in self.element_iters) + "]"]
+                out.append(f'[{",".join(map(str, self.element_iters))}]')
         elif self.source_type is InputSourceType.IMPORT:
-            out += [str(self.import_ref)]
+            out.append(str(self.import_ref))
         return ".".join(out)
 
-    @staticmethod
-    def _validate_source_type(src_type):
-        if src_type is None:
-            return None
-        if isinstance(src_type, InputSourceType):
-            return src_type
-        try:
-            src_type = getattr(InputSourceType, src_type.upper())
-        except AttributeError:
-            raise ValueError(
-                f"InputSource `source_type` specified as {src_type!r}, but "
-                f"must be one of: {[i.name for i in InputSourceType]!r}."
-            )
-        return src_type
-
     @classmethod
-    def _validate_task_source_type(cls, task_src_type):
+    def _validate_task_source_type(cls, task_src_type) -> None | TaskSourceType:
         if task_src_type is None:
             return None
         if isinstance(task_src_type, TaskSourceType):
             return task_src_type
         try:
-            task_source_type = getattr(cls.app.TaskSourceType, task_src_type.upper())
+            task_source_type = getattr(cls._app.TaskSourceType, task_src_type.upper())
         except AttributeError:
             raise ValueError(
                 f"InputSource `task_source_type` specified as {task_src_type!r}, but "
-                f"must be one of: {[i.name for i in TaskSourceType]!r}."
+                f"must be one of: {TaskSourceType.names!r}."
             )
         return task_source_type
 
     @classmethod
-    def from_string(cls, str_defn):
+    def from_string(cls, str_defn: str) -> Self:
         """Parse a dot-delimited string definition of an InputSource.
 
         Parameter
@@ -2322,44 +2779,49 @@ class InputSource(JSONLike):
             local
             default
             import.[import_ref]
-
         """
         return cls(**cls._parse_from_string(str_defn))
 
-    @classmethod
-    def _parse_from_string(cls, str_defn):
+    @staticmethod
+    def _parse_from_string(str_defn: str) -> dict[str, Any]:
+        """Parse a dot-delimited string definition of an InputSource.
+
+        Examples
+        --------
+            task.[task_ref].input
+            task.[task_ref].output
+            local
+            default
+            import.[import_ref]
+        """
         parts = str_defn.split(".")
-        source_type = cls._validate_source_type(parts[0])
-        task_ref = None
-        task_source_type = None
-        import_ref = None
+        source_type = get_enum_by_name_or_val(InputSourceType, parts[0])
+        task_ref: int | None = None
+        task_source_type: TaskSourceType | None = None
+        import_ref: int | None = None
         if (
             (
-                source_type
-                in (cls.app.InputSourceType.LOCAL, cls.app.InputSourceType.DEFAULT)
+                source_type in (InputSourceType.LOCAL, InputSourceType.DEFAULT)
                 and len(parts) > 1
             )
-            or (source_type is cls.app.InputSourceType.TASK and len(parts) > 3)
-            or (source_type is cls.app.InputSourceType.IMPORT and len(parts) > 2)
+            or (source_type is InputSourceType.TASK and len(parts) > 3)
+            or (source_type is InputSourceType.IMPORT and len(parts) > 2)
         ):
             raise ValueError(f"InputSource string not understood: {str_defn!r}.")
 
-        if source_type is cls.app.InputSourceType.TASK:
+        if source_type is InputSourceType.TASK:
             # TODO: does this include element_iters?
-            task_ref = parts[1]
             try:
-                task_ref = int(task_ref)
+                task_ref = int(parts[1])
             except ValueError:
                 pass
             try:
-                task_source_type_str = parts[2]
+                task_source_type = get_enum_by_name_or_val(TaskSourceType, parts[2])
             except IndexError:
-                task_source_type_str = cls.app.TaskSourceType.OUTPUT
-            task_source_type = cls._validate_task_source_type(task_source_type_str)
-        elif source_type is cls.app.InputSourceType.IMPORT:
-            import_ref = parts[1]
+                task_source_type = TaskSourceType.OUTPUT
+        elif source_type is InputSourceType.IMPORT:
             try:
-                import_ref = int(import_ref)
+                import_ref = int(parts[1])
             except ValueError:
                 pass
 
@@ -2377,9 +2839,14 @@ class InputSource(JSONLike):
         return super().from_json_like(json_like, shared_data)
 
     @classmethod
-    def import_(cls, import_ref, element_iters=None, where=None):
+    def import_(
+        cls,
+        import_ref: int,
+        element_iters: list[int] | None = None,
+        where: Where | None = None,
+    ) -> Self:
         """
-        Make an instnace of an input source that is an import.
+        Make an instance of an input source that is an import.
 
         Parameters
         ----------
@@ -2391,30 +2858,36 @@ class InputSource(JSONLike):
             Filtering rule.
         """
         return cls(
-            source_type=cls.app.InputSourceType.IMPORT,
+            source_type=InputSourceType.IMPORT,
             import_ref=import_ref,
             element_iters=element_iters,
             where=where,
         )
 
     @classmethod
-    def local(cls):
+    def local(cls) -> Self:
         """
-        Make an instnace of an input source that is local.
+        Make an instance of an input source that is local.
         """
-        return cls(source_type=cls.app.InputSourceType.LOCAL)
+        return cls(source_type=InputSourceType.LOCAL)
 
     @classmethod
-    def default(cls):
+    def default(cls) -> Self:
         """
-        Make an instnace of an input source that is default.
+        Make an instance of an input source that is default.
         """
-        return cls(source_type=cls.app.InputSourceType.DEFAULT)
+        return cls(source_type=InputSourceType.DEFAULT)
 
     @classmethod
-    def task(cls, task_ref, task_source_type=None, element_iters=None, where=None):
+    def task(
+        cls,
+        task_ref: int,
+        task_source_type: TaskSourceType | str | None = None,
+        element_iters: list[int] | None = None,
+        where: Where | None = None,
+    ) -> Self:
         """
-        Make an instnace of an input source that is a task.
+        Make an instance of an input source that is a task.
 
         Parameters
         ----------
@@ -2427,12 +2900,12 @@ class InputSource(JSONLike):
         where:
             Filtering rule.
         """
-        if not task_source_type:
-            task_source_type = cls.app.TaskSourceType.OUTPUT
         return cls(
-            source_type=cls.app.InputSourceType.TASK,
+            source_type=InputSourceType.TASK,
             task_ref=task_ref,
-            task_source_type=cls._validate_task_source_type(task_source_type),
+            task_source_type=get_enum_by_name_or_val(
+                TaskSourceType, task_source_type or TaskSourceType.OUTPUT
+            ),
             where=where,
             element_iters=element_iters,
         )