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

hpcflow/sdk/persistence/base.py

@@ -4,37 +4,75 @@ Base persistence models.
 Store* classes represent the element-metadata in the store, in a store-agnostic way.
 """
 from __future__ import annotations
-from abc import ABC
-
+from abc import ABC, abstractmethod
 import contextlib
 import copy
 from dataclasses import dataclass, field
-from datetime import datetime, timezone
 import enum
+from logging import Logger
 import os
 from pathlib import Path
-import re
 import shutil
 import socket
 import time
-from typing import Any, Dict, Iterable, List, Optional, Set, Tuple, TypeVar, Union
+from typing import Generic, TypeVar, cast, overload, TYPE_CHECKING
 
 from hpcflow.sdk.core.utils import (
     flatten,
     get_in_container,
     get_relative_path,
+    remap,
     reshape,
     set_in_container,
-    JSONLikeDirSnapShot,
+    normalise_timestamp,
+    parse_timestamp,
+    current_timestamp,
 )
 from hpcflow.sdk.log import TimeIt
+from hpcflow.sdk.typing import hydrate
 from hpcflow.sdk.persistence.pending import PendingChanges
+from hpcflow.sdk.persistence.types import (
+    AnySTask,
+    AnySElement,
+    AnySElementIter,
+    AnySEAR,
+    AnySParameter,
+)
 
-AnySTask = TypeVar("AnySTask", bound="StoreTask")
-AnySElement = TypeVar("AnySElement", bound="StoreElement")
-AnySElementIter = TypeVar("AnySElementIter", bound="StoreElementIter")
-AnySEAR = TypeVar("AnySEAR", bound="StoreEAR")
-AnySParameter = TypeVar("AnySParameter", bound="StoreParameter")
+if TYPE_CHECKING:
+    from collections.abc import Callable, Iterable, Iterator, Mapping, Sequence
+    from contextlib import AbstractContextManager
+    from datetime import datetime
+    from typing import Any, ClassVar, Final, Literal
+    from typing_extensions import Self, TypeIs
+    from fsspec import AbstractFileSystem  # type: ignore
+    from .pending import CommitResourceMap
+    from .store_resource import StoreResource
+    from .types import (
+        EncodedStoreParameter,
+        File,
+        FileDescriptor,
+        LoopDescriptor,
+        Metadata,
+        ParameterTypes,
+        PersistenceCache,
+        StoreCreationInfo,
+        TemplateMeta,
+        TypeLookup,
+    )
+    from .zarr import ZarrAttrsDict
+    from ..app import BaseApp
+    from ..typing import DataIndex, PathLike, ParamSource
+    from ..core.json_like import JSONed, JSONDocument
+    from ..core.parameters import ParameterValue
+    from ..core.workflow import Workflow
+    from ..submission.types import VersionInfo
+
+T = TypeVar("T")
+#: Type of the serialized form.
+SerFormT = TypeVar("SerFormT")
+#: Type of the encoding and decoding context.
+ContextT = TypeVar("ContextT")
 
 PRIMITIVES = (
     int,
@@ -50,14 +88,14 @@ TEMPLATE_COMP_TYPES = (
     "task_schemas",
 )
 
-PARAM_DATA_NOT_SET = 0
+PARAM_DATA_NOT_SET: Final[int] = 0
 
 
-def update_param_source_dict(source, update):
+def update_param_source_dict(source: ParamSource, update: ParamSource) -> ParamSource:
     """
     Combine two dicts into a new dict that is ordered on its keys.
     """
-    return dict(sorted({**source, **update}.items()))
+    return cast("ParamSource", dict(sorted({**source, **update}.items())))
 
 
 @dataclass
@@ -102,7 +140,7 @@ class PersistentStoreFeatures:
 
 
 @dataclass
-class StoreTask:
+class StoreTask(Generic[SerFormT]):
     """
     Represents a task in a persistent store.
 
@@ -120,6 +158,12 @@ class StoreTask:
         Description of the template for the task.
     """
 
+    # This would be in the docstring except it renders really wrongly!
+    # Type Parameters
+    # ---------------
+    # SerFormT
+    #     Type of the serialized form.
+
     #: The ID of the task.
     id_: int
     #: The index of the task within its workflow.
@@ -127,41 +171,38 @@ class StoreTask:
     #: Whether the task has changes not yet persisted.
     is_pending: bool
     #: The IDs of elements in the task.
-    element_IDs: List[int]
+    element_IDs: list[int]
     #: Description of the template for the task.
-    task_template: Optional[Dict] = None
+    task_template: Mapping[str, Any] | None = None
 
-    def encode(self) -> Tuple[int, Dict, Dict]:
+    @abstractmethod
+    def encode(self) -> tuple[int, SerFormT, dict[str, Any]]:
         """Prepare store task data for the persistent store."""
-        wk_task = {"id_": self.id_, "element_IDs": self.element_IDs}
-        task = {"id_": self.id_, **self.task_template}
-        return self.index, wk_task, task
 
     @classmethod
-    def decode(cls, task_dat: Dict) -> StoreTask:
+    @abstractmethod
+    def decode(cls, task_dat: SerFormT) -> Self:
         """Initialise a `StoreTask` from store task data
 
         Note: the `task_template` is only needed for encoding because it is retrieved as
         part of the `WorkflowTemplate` so we don't need to load it when decoding.
 
         """
-        return cls(is_pending=False, **task_dat)
 
     @TimeIt.decorator
-    def append_element_IDs(self: AnySTask, pend_IDs: List[int]) -> AnySTask:
+    def append_element_IDs(self, pend_IDs: list[int]) -> Self:
         """Return a copy, with additional element IDs."""
-        elem_IDs = self.element_IDs[:] + pend_IDs
         return self.__class__(
             id_=self.id_,
             index=self.index,
             is_pending=self.is_pending,
-            element_IDs=elem_IDs,
+            element_IDs=[*self.element_IDs, *pend_IDs],
             task_template=self.task_template,
         )
 
 
 @dataclass
-class StoreElement:
+class StoreElement(Generic[SerFormT, ContextT]):
     """
     Represents an element in a persistent store.
 
@@ -185,6 +226,14 @@ class StoreElement:
         IDs of element-iterations that belong to this element.
     """
 
+    # These would be in the docstring except they render really wrongly!
+    # Type Parameters
+    # ---------------
+    # SerFormT
+    #     Type of the serialized form.
+    # ContextT
+    #     Type of the encoding and decoding context.
+
     #: The ID of the element.
     id_: int
     #: Whether the element has changes not yet persisted.
@@ -194,26 +243,24 @@ class StoreElement:
     #: Index of the element set containing this element.
     es_idx: int
     #: Value sequence index map.
-    seq_idx: Dict[str, int]
+    seq_idx: dict[str, int]
     #: Data source index map.
-    src_idx: Dict[str, int]
+    src_idx: dict[str, int]
     #: ID of the task that contains this element.
     task_ID: int
     #: IDs of element-iterations that belong to this element.
-    iteration_IDs: List[int]
+    iteration_IDs: list[int]
 
-    def encode(self) -> Dict:
+    @abstractmethod
+    def encode(self, context: ContextT) -> SerFormT:
         """Prepare store element data for the persistent store."""
-        dct = self.__dict__
-        del dct["is_pending"]
-        return dct
 
     @classmethod
-    def decode(cls, elem_dat: Dict) -> StoreElement:
+    @abstractmethod
+    def decode(cls, elem_dat: SerFormT, context: ContextT) -> Self:
         """Initialise a `StoreElement` from store element data"""
-        return cls(is_pending=False, **elem_dat)
 
-    def to_dict(self, iters):
+    def to_dict(self, iters) -> dict[str, Any]:
         """Prepare data for the user-facing `Element` object."""
         return {
             "id_": self.id_,
@@ -228,9 +275,9 @@ class StoreElement:
         }
 
     @TimeIt.decorator
-    def append_iteration_IDs(self: AnySElement, pend_IDs: List[int]) -> AnySElement:
+    def append_iteration_IDs(self, pend_IDs: Iterable[int]) -> Self:
         """Return a copy, with additional iteration IDs."""
-        iter_IDs = self.iteration_IDs[:] + pend_IDs
+        iter_IDs = [*self.iteration_IDs, *pend_IDs]
         return self.__class__(
             id_=self.id_,
             is_pending=self.is_pending,
@@ -244,7 +291,7 @@ class StoreElement:
 
 
 @dataclass
-class StoreElementIter:
+class StoreElementIter(Generic[SerFormT, ContextT]):
     """
     Represents an element iteration in a persistent store.
 
@@ -269,6 +316,14 @@ class StoreElementIter:
         What loops are being handled here and where they're up to.
     """
 
+    # These would be in the docstring except they render really wrongly!
+    # Type Parameters
+    # ---------------
+    # SerFormT
+    #     Type of the serialized form.
+    # ContextT
+    #     Type of the encoding and decoding context.
+
     #: The ID of this element iteration.
     id_: int
     #: Whether the element iteration has changes not yet persisted.
@@ -278,34 +333,25 @@ class StoreElementIter:
     #: Whether EARs have been initialised for this element iteration.
     EARs_initialised: bool
     #: Maps task schema action indices to EARs by ID.
-    EAR_IDs: Dict[int, List[int]]
+    EAR_IDs: dict[int, list[int]] | None
     #: Overall data index for the element-iteration, which maps parameter names to
     #: parameter data indices.
-    data_idx: Dict[str, int]
+    data_idx: DataIndex
     #: List of parameters defined by the associated task schema.
-    schema_parameters: List[str]
+    schema_parameters: list[str]
     #: What loops are being handled here and where they're up to.
-    loop_idx: Dict[str, int] = field(default_factory=dict)
+    loop_idx: Mapping[str, int] = field(default_factory=dict)
 
-    def encode(self) -> Dict:
+    @abstractmethod
+    def encode(self, context: ContextT) -> SerFormT:
         """Prepare store element iteration data for the persistent store."""
-        dct = self.__dict__
-        del dct["is_pending"]
-        return dct
 
     @classmethod
-    def decode(cls, iter_dat: Dict) -> StoreElementIter:
+    @abstractmethod
+    def decode(cls, iter_dat: SerFormT, context: ContextT) -> Self:
         """Initialise a `StoreElementIter` from persistent store element iteration data"""
 
-        iter_dat = copy.deepcopy(iter_dat)  # to avoid mutating; can we avoid this?
-
-        # cast JSON string keys to integers:
-        for act_idx in list((iter_dat["EAR_IDs"] or {}).keys()):
-            iter_dat["EAR_IDs"][int(act_idx)] = iter_dat["EAR_IDs"].pop(act_idx)
-
-        return cls(is_pending=False, **iter_dat)
-
-    def to_dict(self, EARs):
+    def to_dict(self, EARs: dict[int, dict[str, Any]] | None) -> dict[str, Any]:
         """Prepare data for the user-facing `ElementIteration` object."""
         return {
             "id_": self.id_,
@@ -316,20 +362,16 @@ class StoreElementIter:
             "schema_parameters": self.schema_parameters,
             "EARs": EARs,
             "EARs_initialised": self.EARs_initialised,
-            "loop_idx": self.loop_idx,
+            "loop_idx": dict(self.loop_idx),
         }
 
     @TimeIt.decorator
-    def append_EAR_IDs(
-        self: AnySElementIter, pend_IDs: Dict[int, List[int]]
-    ) -> AnySElementIter:
+    def append_EAR_IDs(self, pend_IDs: Mapping[int, Sequence[int]]) -> Self:
         """Return a copy, with additional EAR IDs."""
 
         EAR_IDs = copy.deepcopy(self.EAR_IDs) or {}
         for act_idx, IDs_i in pend_IDs.items():
-            if act_idx not in EAR_IDs:
-                EAR_IDs[act_idx] = []
-            EAR_IDs[act_idx].extend(IDs_i)
+            EAR_IDs.setdefault(act_idx, []).extend(IDs_i)
 
         return self.__class__(
             id_=self.id_,
@@ -343,11 +385,9 @@ class StoreElementIter:
         )
 
     @TimeIt.decorator
-    def update_loop_idx(
-        self: AnySElementIter, loop_idx: Dict[str, int]
-    ) -> AnySElementIter:
+    def update_loop_idx(self, loop_idx: Mapping[str, int]) -> Self:
         """Return a copy, with the loop index updated."""
-        loop_idx_new = copy.deepcopy(self.loop_idx)
+        loop_idx_new = dict(self.loop_idx)
         loop_idx_new.update(loop_idx)
         return self.__class__(
             id_=self.id_,
@@ -361,7 +401,7 @@ class StoreElementIter:
         )
 
     @TimeIt.decorator
-    def set_EARs_initialised(self: AnySElementIter) -> AnySElementIter:
+    def set_EARs_initialised(self) -> Self:
         """Return a copy with `EARs_initialised` set to `True`."""
         return self.__class__(
             id_=self.id_,
@@ -376,7 +416,7 @@ class StoreElementIter:
 
 
 @dataclass
-class StoreEAR:
+class StoreEAR(Generic[SerFormT, ContextT]):
     """
     Represents an element action run in a persistent store.
 
@@ -416,6 +456,14 @@ class StoreEAR:
         Where this EAR was submitted to run, if known.
     """
 
+    # These would be in the docstring except they render really wrongly!
+    # Type Parameters
+    # ---------------
+    # SerFormT
+    #     Type of the serialized form.
+    # ContextT
+    #     Type of the encoding and decoding context.
+
     #: The ID of this element action run.
     id_: int
     #: Whether the element action run has changes not yet persisted.
@@ -425,74 +473,54 @@ class StoreEAR:
     #: The task schema action associated with this EAR.
     action_idx: int
     #: The indices of the commands in the EAR.
-    commands_idx: List[int]
+    commands_idx: list[int]
     #: Maps parameter names within this EAR to parameter data indices.
-    data_idx: Dict[str, int]
+    data_idx: DataIndex
     #: Which submission contained this EAR, if known.
-    submission_idx: Optional[int] = None
+    submission_idx: int | None = None
     #: Whether to skip this EAR.
-    skip: Optional[bool] = False
+    skip: bool = False
     #: Whether this EAR was successful, if known.
-    success: Optional[bool] = None
+    success: bool | None = None
     #: When this EAR started, if known.
-    start_time: Optional[datetime] = None
+    start_time: datetime | None = None
     #: When this EAR finished, if known.
-    end_time: Optional[datetime] = None
+    end_time: datetime | None = None
     #: Snapshot of files at EAR start, if recorded.
-    snapshot_start: Optional[Dict] = None
+    snapshot_start: dict[str, Any] | None = None
     #: Snapshot of files at EAR end, if recorded.
-    snapshot_end: Optional[Dict] = None
+    snapshot_end: dict[str, Any] | None = None
     #: The exit code of the underlying executable, if known.
-    exit_code: Optional[int] = None
+    exit_code: int | None = None
     #: Metadata concerning e.g. the state of the EAR.
-    metadata: Dict[str, Any] = None
+    metadata: Metadata | None = None
     #: Where this EAR was submitted to run, if known.
-    run_hostname: Optional[str] = None
+    run_hostname: str | None = None
 
     @staticmethod
-    def _encode_datetime(dt: Union[datetime, None], ts_fmt: str) -> str:
+    def _encode_datetime(dt: datetime | None, ts_fmt: str) -> str | None:
         return dt.strftime(ts_fmt) if dt else None
 
     @staticmethod
-    def _decode_datetime(dt_str: Union[str, None], ts_fmt: str) -> datetime:
-        return datetime.strptime(dt_str, ts_fmt) if dt_str else None
+    def _decode_datetime(dt_str: str | None, ts_fmt: str) -> datetime | None:
+        return parse_timestamp(dt_str, ts_fmt) if dt_str else None
 
-    def encode(self, ts_fmt: str) -> Dict:
+    @abstractmethod
+    def encode(self, ts_fmt: str, context: ContextT) -> SerFormT:
         """Prepare store EAR data for the persistent store."""
-        return {
-            "id_": self.id_,
-            "elem_iter_ID": self.elem_iter_ID,
-            "action_idx": self.action_idx,
-            "commands_idx": self.commands_idx,
-            "data_idx": self.data_idx,
-            "submission_idx": self.submission_idx,
-            "success": self.success,
-            "skip": self.skip,
-            "start_time": self._encode_datetime(self.start_time, ts_fmt),
-            "end_time": self._encode_datetime(self.end_time, ts_fmt),
-            "snapshot_start": self.snapshot_start,
-            "snapshot_end": self.snapshot_end,
-            "exit_code": self.exit_code,
-            "metadata": self.metadata,
-            "run_hostname": self.run_hostname,
-        }
 
     @classmethod
-    def decode(cls, EAR_dat: Dict, ts_fmt: str) -> StoreEAR:
+    @abstractmethod
+    def decode(cls, EAR_dat: SerFormT, ts_fmt: str, context: ContextT) -> Self:
         """Initialise a `StoreEAR` from persistent store EAR data"""
-        # don't want to mutate EAR_dat:
-        EAR_dat = copy.deepcopy(EAR_dat)
-        EAR_dat["start_time"] = cls._decode_datetime(EAR_dat["start_time"], ts_fmt)
-        EAR_dat["end_time"] = cls._decode_datetime(EAR_dat["end_time"], ts_fmt)
-        return cls(is_pending=False, **EAR_dat)
 
-    def to_dict(self) -> Dict:
+    def to_dict(self) -> dict[str, Any]:
         """Prepare data for the user-facing `ElementActionRun` object."""
 
-        def _process_datetime(dt: datetime) -> datetime:
+        def _process_datetime(dt: datetime | None) -> datetime | None:
             """We store datetime objects implicitly in UTC, so we need to first make
             that explicit, and then convert to the local time zone."""
-            return dt.replace(tzinfo=timezone.utc).astimezone() if dt else None
+            return normalise_timestamp(dt) if dt else None
 
         return {
             "id_": self.id_,
@@ -516,16 +544,16 @@ class StoreEAR:
     @TimeIt.decorator
     def update(
         self,
-        submission_idx: Optional[int] = None,
-        skip: Optional[bool] = None,
-        success: Optional[bool] = None,
-        start_time: Optional[datetime] = None,
-        end_time: Optional[datetime] = None,
-        snapshot_start: Optional[Dict] = None,
-        snapshot_end: Optional[Dict] = None,
-        exit_code: Optional[int] = None,
-        run_hostname: Optional[str] = None,
-    ) -> AnySEAR:
+        submission_idx: int | None = None,
+        skip: bool | None = None,
+        success: bool | None = None,
+        start_time: datetime | None = None,
+        end_time: datetime | None = None,
+        snapshot_start: dict[str, Any] | None = None,
+        snapshot_end: dict[str, Any] | None = None,
+        exit_code: int | None = None,
+        run_hostname: str | None = None,
+    ) -> Self:
         """Return a shallow copy, with specified data updated."""
 
         sub_idx = submission_idx if submission_idx is not None else self.submission_idx
@@ -559,6 +587,7 @@ class StoreEAR:
 
 
 @dataclass
+@hydrate
 class StoreParameter:
     """
     Represents a parameter in a persistent store.
@@ -586,47 +615,60 @@ class StoreParameter:
     #: Whether the parameter is set.
     is_set: bool
     #: Description of the value of the parameter.
-    data: Any
+    data: ParameterTypes
     #: Description of the file this parameter represents.
-    file: Dict
+    file: File | None
     #: Description of where this parameter originated.
-    source: Dict
+    source: ParamSource
 
-    _encoders = {}
-    _decoders = {}
+    _encoders: ClassVar[dict[type, Callable]] = {}
+    _decoders: ClassVar[dict[str, Callable]] = {}
+    _MAX_DEPTH: ClassVar[int] = 50
 
-    def encode(self, **kwargs) -> Dict:
+    def encode(self, **kwargs) -> dict[str, Any] | int:
         """Prepare store parameter data for the persistent store."""
         if self.is_set:
             if self.file:
                 return {"file": self.file}
             else:
-                return self._encode(obj=self.data, **kwargs)
+                return cast("dict", self._encode(obj=self.data, **kwargs))
         else:
             return PARAM_DATA_NOT_SET
 
+    @staticmethod
+    def __is_ParameterValue(value) -> TypeIs[ParameterValue]:
+        # avoid circular import of `ParameterValue` until needed...
+        from ..core.parameters import ParameterValue as PV
+
+        return isinstance(value, PV)
+
+    def _init_type_lookup(self) -> TypeLookup:
+        return cast(
+            "TypeLookup",
+            {
+                "tuples": [],
+                "sets": [],
+                **{k: [] for k in self._decoders},
+            },
+        )
+
     def _encode(
         self,
-        obj: Any,
-        path: Optional[List] = None,
-        type_lookup: Optional[Dict] = None,
+        obj: ParameterTypes,
+        path: list[int] | None = None,
+        type_lookup: TypeLookup | None = None,
         **kwargs,
-    ) -> Dict:
+    ) -> EncodedStoreParameter:
         """Recursive encoder."""
 
         path = path or []
         if type_lookup is None:
-            type_lookup = {
-                "tuples": [],
-                "sets": [],
-                **{k: [] for k in self._decoders.keys()},
-            }
+            type_lookup = self._init_type_lookup()
 
-        if len(path) > 50:
+        if len(path) > self._MAX_DEPTH:
             raise RuntimeError("I'm in too deep!")
 
-        if any("ParameterValue" in i.__name__ for i in obj.__class__.__mro__):
-            # TODO: not nice; did this to avoid circular import of `ParameterValue`
+        if self.__is_ParameterValue(obj):
             encoded = self._encode(
                 obj=obj.to_dict(),
                 path=path,
@@ -640,11 +682,12 @@ class StoreParameter:
             for idx, item in enumerate(obj):
                 encoded = self._encode(
                     obj=item,
-                    path=path + [idx],
+                    path=[*path, idx],
                     type_lookup=type_lookup,
                     **kwargs,
                 )
                 item, type_lookup = encoded["data"], encoded["type_lookup"]
+                assert type_lookup is not None
                 data.append(item)
 
             if isinstance(obj, tuple):
@@ -654,21 +697,24 @@ class StoreParameter:
                 type_lookup["sets"].append(path)
 
         elif isinstance(obj, dict):
+            assert type_lookup is not None
             data = {}
             for dct_key, dct_val in obj.items():
                 encoded = self._encode(
                     obj=dct_val,
-                    path=path + [dct_key],
+                    path=[*path, dct_key],
                     type_lookup=type_lookup,
                     **kwargs,
                 )
                 dct_val, type_lookup = encoded["data"], encoded["type_lookup"]
+                assert type_lookup is not None
                 data[dct_key] = dct_val
 
         elif isinstance(obj, PRIMITIVES):
             data = obj
 
         elif type(obj) in self._encoders:
+            assert type_lookup is not None
             data = self._encoders[type(obj)](
                 obj=obj,
                 path=path,
@@ -691,22 +737,23 @@ class StoreParameter:
     def decode(
         cls,
         id_: int,
-        data: Union[None, Dict],
-        source: Dict,
-        path: Optional[List[str]] = None,
+        data: dict[str, Any] | Literal[0] | None,
+        source: ParamSource,
+        *,
+        path: list[str] | None = None,
         **kwargs,
-    ) -> Any:
+    ) -> Self:
         """Initialise from persistent store parameter data."""
         if data and "file" in data:
             return cls(
                 id_=id_,
                 data=None,
-                file=data["file"],
+                file=cast("File", data["file"]),
                 is_set=True,
                 source=source,
                 is_pending=False,
             )
-        elif data == PARAM_DATA_NOT_SET:
+        elif not isinstance(data, dict):
             # parameter is not set
             return cls(
                 id_=id_,
@@ -717,11 +764,12 @@ class StoreParameter:
                 is_pending=False,
             )
 
+        data_ = cast("EncodedStoreParameter", data)
         path = path or []
 
-        obj = get_in_container(data["data"], path)
+        obj = get_in_container(data_["data"], path)
 
-        for tuple_path in data["type_lookup"]["tuples"]:
+        for tuple_path in data_["type_lookup"]["tuples"]:
             try:
                 rel_path = get_relative_path(tuple_path, path)
             except ValueError:
@@ -731,7 +779,7 @@ class StoreParameter:
             else:
                 obj = tuple(obj)
 
-        for set_path in data["type_lookup"]["sets"]:
+        for set_path in data_["type_lookup"]["sets"]:
             try:
                 rel_path = get_relative_path(set_path, path)
             except ValueError:
@@ -744,7 +792,7 @@ class StoreParameter:
         for data_type in cls._decoders:
             obj = cls._decoders[data_type](
                 obj=obj,
-                type_lookup=data["type_lookup"],
+                type_lookup=data_["type_lookup"],
                 path=path,
                 **kwargs,
             )
@@ -758,7 +806,7 @@ class StoreParameter:
             is_pending=False,
         )
 
-    def set_data(self, value: Any) -> None:
+    def set_data(self, value: Any) -> Self:
         """Return a copy, with data set."""
         if self.is_set:
             raise RuntimeError(f"Parameter ID {self.id_!r} is already set!")
@@ -771,7 +819,7 @@ class StoreParameter:
             source=self.source,
         )
 
-    def set_file(self, value: Any) -> None:
+    def set_file(self, value: File) -> Self:
         """Return a copy, with file set."""
         if self.is_set:
             raise RuntimeError(f"Parameter ID {self.id_!r} is already set!")
@@ -784,20 +832,21 @@ class StoreParameter:
             source=self.source,
         )
 
-    def update_source(self, src: Dict) -> None:
+    def update_source(self, src: ParamSource) -> Self:
         """Return a copy, with updated source."""
-        new_src = update_param_source_dict(self.source, src)
         return self.__class__(
             id_=self.id_,
             is_set=self.is_set,
             is_pending=self.is_pending,
             data=self.data,
             file=self.file,
-            source=new_src,
+            source=update_param_source_dict(self.source, src),
         )
 
 
-class PersistentStore(ABC):
+class PersistentStore(
+    ABC, Generic[AnySTask, AnySElement, AnySElementIter, AnySEAR, AnySParameter]
+):
     """
     An abstract class representing a persistent workflow store.
 
@@ -813,35 +862,186 @@ class PersistentStore(ABC):
         Optionally, information about how to access the store.
     """
 
-    _store_task_cls = StoreTask
-    _store_elem_cls = StoreElement
-    _store_iter_cls = StoreElementIter
-    _store_EAR_cls = StoreEAR
-    _store_param_cls = StoreParameter
+    # These would be in the docstring except they render really wrongly!
+    # Type Parameters
+    # ---------------
+    # AnySTask: StoreTask
+    #     The type of stored tasks.
+    # AnySElement: StoreElement
+    #     The type of stored elements.
+    # AnySElementIter: StoreElementIter
+    #     The type of stored element iterations.
+    # AnySEAR: StoreEAR
+    #     The type of stored EARs.
+    # AnySParameter: StoreParameter
+    #     The type of stored parameters.
+
+    _name: ClassVar[str]
+
+    @classmethod
+    @abstractmethod
+    def _store_task_cls(cls) -> type[AnySTask]:
+        ...
+
+    @classmethod
+    @abstractmethod
+    def _store_elem_cls(cls) -> type[AnySElement]:
+        ...
+
+    @classmethod
+    @abstractmethod
+    def _store_iter_cls(cls) -> type[AnySElementIter]:
+        ...
+
+    @classmethod
+    @abstractmethod
+    def _store_EAR_cls(cls) -> type[AnySEAR]:
+        ...
+
+    @classmethod
+    @abstractmethod
+    def _store_param_cls(cls) -> type[AnySParameter]:
+        ...
 
-    _resources = {}
+    _resources: dict[str, StoreResource]
+    _features: ClassVar[PersistentStoreFeatures]
+    _res_map: ClassVar[CommitResourceMap]
 
-    def __init__(self, app, workflow, path, fs=None) -> None:
-        self.app = app
-        self.workflow = workflow
-        self.path = path
+    def __init__(
+        self,
+        app: BaseApp,
+        workflow: Workflow | None,
+        path: Path | str,
+        fs: AbstractFileSystem | None = None,
+    ):
+        self._app = app
+        self.__workflow = workflow
+        self.path = str(path)
         self.fs = fs
 
-        self._pending = PendingChanges(app=app, store=self, resource_map=self._res_map)
+        self._pending: PendingChanges[
+            AnySTask, AnySElement, AnySElementIter, AnySEAR, AnySParameter
+        ] = PendingChanges(app=app, store=self, resource_map=self._res_map)
 
-        self._resources_in_use = set()
+        self._resources_in_use: set[tuple[str, str]] = set()
         self._in_batch_mode = False
 
         self._use_cache = False
-        self._cache = None
         self._reset_cache()
 
+    @abstractmethod
+    def cached_load(self) -> contextlib.AbstractContextManager[None]:
+        """
+        Perform a load with cache enabled while the ``with``-wrapped code runs.
+        """
+
+    @abstractmethod
+    def get_name(self) -> str:
+        """
+        Get the workflow name.
+        """
+
+    @abstractmethod
+    def get_creation_info(self) -> StoreCreationInfo:
+        """
+        Get the workflow creation data.
+        """
+
+    @abstractmethod
+    def get_ts_fmt(self) -> str:
+        """
+        Get the timestamp format.
+        """
+
+    @abstractmethod
+    def get_ts_name_fmt(self) -> str:
+        """
+        Get the timestamp format for names.
+        """
+
+    @abstractmethod
+    def remove_replaced_dir(self) -> None:
+        """
+        Remove a replaced directory.
+        """
+
+    @abstractmethod
+    def reinstate_replaced_dir(self) -> None:
+        """
+        Reinstate a replaced directory.
+        """
+
+    @abstractmethod
+    def zip(
+        self,
+        path: str = ".",
+        log: str | None = None,
+        overwrite=False,
+        include_execute=False,
+        include_rechunk_backups=False,
+    ) -> str:
+        """
+        Convert this store into archival form.
+        """
+
+    @abstractmethod
+    def unzip(self, path: str = ".", log: str | None = None) -> str:
+        """
+        Convert this store into expanded form.
+        """
+
+    @abstractmethod
+    def rechunk_parameter_base(
+        self,
+        chunk_size: int | None = None,
+        backup: bool = True,
+        status: bool = True,
+    ) -> Any:
+        ...
+
+    @abstractmethod
+    def rechunk_runs(
+        self,
+        chunk_size: int | None = None,
+        backup: bool = True,
+        status: bool = True,
+    ) -> Any:
+        ...
+
+    @classmethod
+    @abstractmethod
+    def write_empty_workflow(
+        cls,
+        app: BaseApp,
+        *,
+        template_js: TemplateMeta,
+        template_components_js: dict[str, Any],
+        wk_path: str,
+        fs: AbstractFileSystem,
+        name: str,
+        replaced_wk: str | None,
+        creation_info: StoreCreationInfo,
+        ts_fmt: str,
+        ts_name_fmt: str,
+    ) -> None:
+        """
+        Write an empty workflow.
+        """
+
+    @property
+    def workflow(self) -> Workflow:
+        """
+        The workflow this relates to.
+        """
+        assert self.__workflow is not None
+        return self.__workflow
+
     @property
-    def logger(self):
+    def logger(self) -> Logger:
         """
         The logger to use.
         """
-        return self.app.persistence_logger
+        return self._app.persistence_logger
 
     @property
     def ts_fmt(self) -> str:
@@ -851,74 +1051,76 @@ class PersistentStore(ABC):
         return self.workflow.ts_fmt
 
     @property
-    def has_pending(self):
+    def has_pending(self) -> bool:
         """
         Whether there are any pending changes.
         """
         return bool(self._pending)
 
     @property
-    def is_submittable(self):
+    def is_submittable(self) -> bool:
         """Does this store support workflow submission?"""
         return self.fs.__class__.__name__ == "LocalFileSystem"
 
     @property
-    def use_cache(self):
+    def use_cache(self) -> bool:
         """
         Whether to use a cache.
         """
         return self._use_cache
 
     @property
-    def task_cache(self):
+    def task_cache(self) -> dict[int, AnySTask]:
         """Cache for persistent tasks."""
         return self._cache["tasks"]
 
     @property
-    def element_cache(self):
+    def element_cache(self) -> dict[int, AnySElement]:
         """Cache for persistent elements."""
         return self._cache["elements"]
 
     @property
-    def element_iter_cache(self):
+    def element_iter_cache(self) -> dict[int, AnySElementIter]:
         """Cache for persistent element iterations."""
         return self._cache["element_iters"]
 
     @property
-    def EAR_cache(self):
+    def EAR_cache(self) -> dict[int, AnySEAR]:
         """Cache for persistent EARs."""
         return self._cache["EARs"]
 
     @property
-    def num_tasks_cache(self):
+    def num_tasks_cache(self) -> int | None:
         """Cache for number of persistent tasks."""
         return self._cache["num_tasks"]
 
+    @num_tasks_cache.setter
+    def num_tasks_cache(self, value: int | None):
+        self._cache["num_tasks"] = value
+
     @property
-    def num_EARs_cache(self):
+    def num_EARs_cache(self) -> int | None:
         """Cache for total number of persistent EARs."""
         return self._cache["num_EARs"]
 
+    @num_EARs_cache.setter
+    def num_EARs_cache(self, value: int | None):
+        self._cache["num_EARs"] = value
+
     @property
-    def param_sources_cache(self):
+    def param_sources_cache(self) -> dict[int, ParamSource]:
         """Cache for persistent parameter sources."""
         return self._cache["param_sources"]
 
     @property
-    def parameter_cache(self):
+    def parameter_cache(self) -> dict[int, AnySParameter]:
         """Cache for persistent parameters."""
         return self._cache["parameters"]
 
-    @num_tasks_cache.setter
-    def num_tasks_cache(self, value):
-        self._cache["num_tasks"] = value
-
-    @num_EARs_cache.setter
-    def num_EARs_cache(self, value):
-        self._cache["num_EARs"] = value
-
-    def _reset_cache(self):
-        self._cache = {
+    def _reset_cache(self) -> None:
+        self._cache: PersistenceCache[
+            AnySTask, AnySElement, AnySElementIter, AnySEAR, AnySParameter
+        ] = {
             "tasks": {},
             "elements": {},
             "element_iters": {},
@@ -930,7 +1132,7 @@ class PersistentStore(ABC):
         }
 
     @contextlib.contextmanager
-    def cache_ctx(self):
+    def cache_ctx(self) -> Iterator[None]:
         """Context manager for using the persistent element/iteration/run cache."""
         self._use_cache = True
         try:
@@ -940,15 +1142,19 @@ class PersistentStore(ABC):
             self._reset_cache()
 
     @staticmethod
-    def prepare_test_store_from_spec(task_spec):
+    def prepare_test_store_from_spec(
+        task_spec: Sequence[
+            Mapping[str, Sequence[Mapping[str, Sequence[Mapping[str, Sequence]]]]]
+        ]
+    ) -> tuple[list[dict], list[dict], list[dict], list[dict]]:
         """Generate a valid store from a specification in terms of nested
         elements/iterations/EARs.
 
         """
-        tasks = []
-        elements = []
-        elem_iters = []
-        EARs = []
+        tasks: list[dict] = []
+        elements: list[dict] = []
+        elem_iters: list[dict] = []
+        EARs: list[dict] = []
 
         for task_idx, task_i in enumerate(task_spec):
             elems_i = task_i.get("elements", [])
@@ -965,47 +1171,47 @@ class PersistentStore(ABC):
 
                     for _ in EARs_k:
                         EARs.append(
-                            dict(
-                                id_=len(EARs),
-                                is_pending=False,
-                                elem_iter_ID=len(elem_iters),
-                                action_idx=0,
-                                data_idx={},
-                                metadata={},
-                            )
+                            {
+                                "id_": len(EARs),
+                                "is_pending": False,
+                                "elem_iter_ID": len(elem_iters),
+                                "action_idx": 0,
+                                "data_idx": {},
+                                "metadata": {},
+                            }
                         )
 
                     elem_iters.append(
-                        dict(
-                            id_=len(elem_iters),
-                            is_pending=False,
-                            element_ID=len(elements),
-                            EAR_IDs=EAR_IDs_dct,
-                            data_idx={},
-                            schema_parameters=[],
-                        )
+                        {
+                            "id_": len(elem_iters),
+                            "is_pending": False,
+                            "element_ID": len(elements),
+                            "EAR_IDs": EAR_IDs_dct,
+                            "data_idx": {},
+                            "schema_parameters": [],
+                        }
                     )
                 elements.append(
-                    dict(
-                        id_=len(elements),
-                        is_pending=False,
-                        element_idx=elem_idx,
-                        seq_idx={},
-                        src_idx={},
-                        task_ID=task_idx,
-                        iteration_IDs=iter_IDs,
-                    )
+                    {
+                        "id_": len(elements),
+                        "is_pending": False,
+                        "element_idx": elem_idx,
+                        "seq_idx": {},
+                        "src_idx": {},
+                        "task_ID": task_idx,
+                        "iteration_IDs": iter_IDs,
+                    }
                 )
             tasks.append(
-                dict(
-                    id_=len(tasks),
-                    is_pending=False,
-                    element_IDs=elem_IDs,
-                )
+                {
+                    "id_": len(tasks),
+                    "is_pending": False,
+                    "element_IDs": elem_IDs,
+                }
             )
         return (tasks, elements, elem_iters, EARs)
 
-    def remove_path(self, path: str, fs) -> None:
+    def remove_path(self, path: str | Path) -> None:
         """Try very hard to delete a directory or file.
 
         Dropbox (on Windows, at least) seems to try to re-sync files if the parent directory
@@ -1015,83 +1221,126 @@ class PersistentStore(ABC):
 
         """
 
-        @self.app.perm_error_retry()
-        def _remove_path(path: str, fs) -> None:
-            self.logger.debug(f"_remove_path: path={path}")
-            while fs.exists(path):
-                fs.rm(path, recursive=True)
+        fs = self.fs
+        assert fs is not None
+
+        @self._app.perm_error_retry()
+        def _remove_path(_path: str) -> None:
+            self.logger.debug(f"_remove_path: path={_path}")
+            while fs.exists(_path):
+                fs.rm(_path, recursive=True)
                 time.sleep(0.5)
 
-        return _remove_path(path, fs)
+        return _remove_path(str(path))
 
-    def rename_path(self, replaced: str, original: str, fs) -> None:
+    def rename_path(self, replaced: str, original: str | Path) -> None:
         """Revert the replaced workflow path to its original name.
 
         This happens when new workflow creation fails and there is an existing workflow
         with the same name; the original workflow which was renamed, must be reverted."""
 
-        @self.app.perm_error_retry()
-        def _rename_path(replaced: str, original: str, fs) -> None:
-            self.logger.debug(f"_rename_path: {replaced!r} --> {original!r}.")
+        fs = self.fs
+        assert fs is not None
+
+        @self._app.perm_error_retry()
+        def _rename_path(_replaced: str, _original: str) -> None:
+            self.logger.debug(f"_rename_path: {_replaced!r} --> {_original!r}.")
             try:
-                fs.rename(replaced, original, recursive=True)  # TODO: why need recursive?
+                fs.rename(
+                    _replaced, _original, recursive=True
+                )  # TODO: why need recursive?
             except TypeError:
                 # `SFTPFileSystem.rename` has no  `recursive` argument:
-                fs.rename(replaced, original)
+                fs.rename(_replaced, _original)
+
+        return _rename_path(str(replaced), str(original))
 
-        return _rename_path(replaced, original, fs)
+    @abstractmethod
+    def _get_num_persistent_tasks(self) -> int:
+        ...
 
-    def _get_num_total_tasks(self):
+    def _get_num_total_tasks(self) -> int:
         """Get the total number of persistent and pending tasks."""
         return self._get_num_persistent_tasks() + len(self._pending.add_tasks)
 
-    def _get_num_total_loops(self):
+    @abstractmethod
+    def _get_num_persistent_loops(self) -> int:
+        ...
+
+    def _get_num_total_loops(self) -> int:
         """Get the total number of persistent and pending loops."""
         return self._get_num_persistent_loops() + len(self._pending.add_loops)
 
-    def _get_num_total_submissions(self):
+    @abstractmethod
+    def _get_num_persistent_submissions(self) -> int:
+        ...
+
+    def _get_num_total_submissions(self) -> int:
         """Get the total number of persistent and pending submissions."""
         return self._get_num_persistent_submissions() + len(self._pending.add_submissions)
 
-    def _get_num_total_elements(self):
+    @abstractmethod
+    def _get_num_persistent_elements(self) -> int:
+        ...
+
+    def _get_num_total_elements(self) -> int:
         """Get the total number of persistent and pending elements."""
         return self._get_num_persistent_elements() + len(self._pending.add_elements)
 
-    def _get_num_total_elem_iters(self):
+    @abstractmethod
+    def _get_num_persistent_elem_iters(self) -> int:
+        ...
+
+    def _get_num_total_elem_iters(self) -> int:
         """Get the total number of persistent and pending element iterations."""
         return self._get_num_persistent_elem_iters() + len(self._pending.add_elem_iters)
 
+    @abstractmethod
+    def _get_num_persistent_EARs(self) -> int:
+        ...
+
     @TimeIt.decorator
-    def _get_num_total_EARs(self):
+    def _get_num_total_EARs(self) -> int:
         """Get the total number of persistent and pending EARs."""
         return self._get_num_persistent_EARs() + len(self._pending.add_EARs)
 
-    def _get_task_total_num_elements(self, task_ID: int):
+    def _get_task_total_num_elements(self, task_ID: int) -> int:
         """Get the total number of persistent and pending elements of a given task."""
         return len(self.get_task(task_ID).element_IDs)
 
-    def _get_num_total_parameters(self):
+    @abstractmethod
+    def _get_num_persistent_parameters(self) -> int:
+        ...
+
+    def _get_num_total_parameters(self) -> int:
         """Get the total number of persistent and pending parameters."""
         return self._get_num_persistent_parameters() + len(self._pending.add_parameters)
 
-    def _get_num_total_input_files(self):
+    def _get_num_total_input_files(self) -> int:
         """Get the total number of persistent and pending user-supplied input files."""
-        num_pend_inp_files = len([i for i in self._pending.add_files if i["is_input"]])
-        return self._get_num_persistent_input_files() + num_pend_inp_files
+        return self._get_num_persistent_input_files() + sum(
+            fd["is_input"] for fd in self._pending.add_files
+        )
 
-    def _get_num_total_added_tasks(self):
+    @abstractmethod
+    def _get_num_persistent_added_tasks(self) -> int:
+        ...
+
+    def _get_num_total_added_tasks(self) -> int:
         """Get the total number of tasks ever added to the workflow."""
         return self._get_num_persistent_added_tasks() + len(self._pending.add_tasks)
 
-    def _get_num_persistent_input_files(self):
-        return len(list(self.workflow.input_files_path.glob("*")))
+    def _get_num_persistent_input_files(self) -> int:
+        return sum(1 for _ in self.workflow.input_files_path.glob("*"))
 
-    def save(self):
+    def save(self) -> None:
         """Commit pending changes to disk, if not in batch-update mode."""
         if not self.workflow._in_batch_mode:
             self._pending.commit_all()
 
-    def add_template_components(self, temp_comps: Dict, save: bool = True) -> None:
+    def add_template_components(
+        self, temp_comps: Mapping[str, dict], save: bool = True
+    ) -> None:
         """
         Add template components to the workflow.
         """
@@ -1107,11 +1356,11 @@ class PersistentStore(ABC):
         if save:
             self.save()
 
-    def add_task(self, idx: int, task_template: Dict, save: bool = True):
+    def add_task(self, idx: int, task_template: Mapping, save: bool = True):
         """Add a new task to the workflow."""
-        self.logger.debug(f"Adding store task.")
+        self.logger.debug("Adding store task.")
         new_ID = self._get_num_total_added_tasks()
-        self._pending.add_tasks[new_ID] = self._store_task_cls(
+        self._pending.add_tasks[new_ID] = self._store_task_cls()(
             id_=new_ID,
             index=idx,
             task_template=task_template,
@@ -1124,39 +1373,41 @@ class PersistentStore(ABC):
 
     def add_loop(
         self,
-        loop_template: Dict,
+        loop_template: Mapping[str, Any],
         iterable_parameters,
-        parents: List[str],
-        num_added_iterations: Dict[Tuple[int], int],
-        iter_IDs: List[int],
+        parents: Sequence[str],
+        num_added_iterations: Mapping[tuple[int, ...], int],
+        iter_IDs: Iterable[int],
         save: bool = True,
     ):
         """Add a new loop to the workflow."""
-        self.logger.debug(f"Adding store loop.")
+        self.logger.debug("Adding store loop.")
         new_idx = self._get_num_total_loops()
-        added_iters = [[list(k), v] for k, v in num_added_iterations.items()]
+        added_iters: list[list[list[int] | int]] = [
+            [list(k), v] for k, v in num_added_iterations.items()
+        ]
         self._pending.add_loops[new_idx] = {
-            "loop_template": loop_template,
+            "loop_template": dict(loop_template),
             "iterable_parameters": iterable_parameters,
-            "parents": parents,
+            "parents": list(parents),
             "num_added_iterations": added_iters,
         }
 
         for i in iter_IDs:
-            self._pending.update_loop_indices[i].update({loop_template["name"]: 0})
+            self._pending.update_loop_indices[i][loop_template["name"]] = 0
 
         if save:
             self.save()
 
     @TimeIt.decorator
-    def add_submission(self, sub_idx: int, sub_js: Dict, save: bool = True):
+    def add_submission(self, sub_idx: int, sub_js: JSONDocument, save: bool = True):
         """Add a new submission."""
-        self.logger.debug(f"Adding store submission.")
+        self.logger.debug("Adding store submission.")
         self._pending.add_submissions[sub_idx] = sub_js
         if save:
             self.save()
 
-    def add_element_set(self, task_id: int, es_js: Dict, save: bool = True):
+    def add_element_set(self, task_id: int, es_js: Mapping, save: bool = True):
         """
         Add an element set to a task.
         """
@@ -1165,13 +1416,18 @@ class PersistentStore(ABC):
             self.save()
 
     def add_element(
-        self, task_ID: int, es_idx: int, seq_idx: Dict, src_idx: Dict, save: bool = True
-    ):
+        self,
+        task_ID: int,
+        es_idx: int,
+        seq_idx: dict[str, int],
+        src_idx: dict[str, int],
+        save: bool = True,
+    ) -> int:
         """Add a new element to a task."""
-        self.logger.debug(f"Adding store element.")
+        self.logger.debug("Adding store element.")
         new_ID = self._get_num_total_elements()
         new_elem_idx = self._get_task_total_num_elements(task_ID)
-        self._pending.add_elements[new_ID] = self._store_elem_cls(
+        self._pending.add_elements[new_ID] = self._store_elem_cls()(
             id_=new_ID,
             is_pending=True,
             index=new_elem_idx,
@@ -1189,15 +1445,15 @@ class PersistentStore(ABC):
     def add_element_iteration(
         self,
         element_ID: int,
-        data_idx: Dict,
-        schema_parameters: List[str],
-        loop_idx: Optional[Dict] = None,
+        data_idx: DataIndex,
+        schema_parameters: list[str],
+        loop_idx: Mapping[str, int] | None = None,
         save: bool = True,
     ) -> int:
         """Add a new iteration to an element."""
-        self.logger.debug(f"Adding store element-iteration.")
+        self.logger.debug("Adding store element-iteration.")
         new_ID = self._get_num_total_elem_iters()
-        self._pending.add_elem_iters[new_ID] = self._store_iter_cls(
+        self._pending.add_elem_iters[new_ID] = self._store_iter_cls()(
             id_=new_ID,
             element_ID=element_ID,
             is_pending=True,
@@ -1217,22 +1473,22 @@ class PersistentStore(ABC):
         self,
         elem_iter_ID: int,
         action_idx: int,
-        commands_idx: List[int],
-        data_idx: Dict,
-        metadata: Dict,
+        commands_idx: list[int],
+        data_idx: DataIndex,
+        metadata: Metadata | None = None,
         save: bool = True,
     ) -> int:
         """Add a new EAR to an element iteration."""
-        self.logger.debug(f"Adding store EAR.")
+        self.logger.debug("Adding store EAR.")
         new_ID = self._get_num_total_EARs()
-        self._pending.add_EARs[new_ID] = self._store_EAR_cls(
+        self._pending.add_EARs[new_ID] = self._store_EAR_cls()(
             id_=new_ID,
             is_pending=True,
             elem_iter_ID=elem_iter_ID,
             action_idx=action_idx,
             commands_idx=commands_idx,
             data_idx=data_idx,
-            metadata=metadata,
+            metadata=metadata or {},
         )
         self._pending.add_elem_iter_EAR_IDs[elem_iter_ID][action_idx].append(new_ID)
         if save:
@@ -1240,7 +1496,7 @@ class PersistentStore(ABC):
         return new_ID
 
     def add_submission_part(
-        self, sub_idx: int, dt_str: str, submitted_js_idx: List[int], save: bool = True
+        self, sub_idx: int, dt_str: str, submitted_js_idx: list[int], save: bool = True
     ):
         """
         Add a submission part.
@@ -1264,8 +1520,8 @@ class PersistentStore(ABC):
         """
         Mark an element action run as started.
         """
-        dt = datetime.utcnow()
-        ss_js = self.app.RunDirAppFiles.take_snapshot()
+        dt = current_timestamp()
+        ss_js = self._app.RunDirAppFiles.take_snapshot()
         run_hostname = socket.gethostname()
         self._pending.set_EAR_starts[EAR_ID] = (dt, ss_js, run_hostname)
         if save:
@@ -1279,8 +1535,8 @@ class PersistentStore(ABC):
         Mark an element action run as finished.
         """
         # TODO: save output files
-        dt = datetime.utcnow()
-        ss_js = self.app.RunDirAppFiles.take_snapshot()
+        dt = current_timestamp()
+        ss_js = self._app.RunDirAppFiles.take_snapshot()
         self._pending.set_EAR_ends[EAR_ID] = (dt, ss_js, exit_code, success)
         if save:
             self.save()
@@ -1306,65 +1562,58 @@ class PersistentStore(ABC):
         self,
         sub_idx: int,
         js_idx: int,
-        version_info: Optional[Dict] = None,
-        submit_time: Optional[str] = None,
-        submit_hostname: Optional[str] = None,
-        submit_machine: Optional[str] = None,
-        submit_cmdline: Optional[List[str]] = None,
-        os_name: Optional[str] = None,
-        shell_name: Optional[str] = None,
-        scheduler_name: Optional[str] = None,
-        scheduler_job_ID: Optional[str] = None,
-        process_ID: Optional[int] = None,
+        version_info: VersionInfo | None = None,
+        submit_time: str | None = None,
+        submit_hostname: str | None = None,
+        submit_machine: str | None = None,
+        submit_cmdline: list[str] | None = None,
+        os_name: str | None = None,
+        shell_name: str | None = None,
+        scheduler_name: str | None = None,
+        scheduler_job_ID: str | None = None,
+        process_ID: int | None = None,
         save: bool = True,
     ):
         """
         Set the metadata for a job script.
         """
+        entry = self._pending.set_js_metadata[sub_idx][js_idx]
         if version_info:
-            self._pending.set_js_metadata[sub_idx][js_idx]["version_info"] = version_info
+            entry["version_info"] = version_info
         if submit_time:
-            self._pending.set_js_metadata[sub_idx][js_idx]["submit_time"] = submit_time
+            entry["submit_time"] = submit_time
         if submit_hostname:
-            self._pending.set_js_metadata[sub_idx][js_idx][
-                "submit_hostname"
-            ] = submit_hostname
+            entry["submit_hostname"] = submit_hostname
         if submit_machine:
-            self._pending.set_js_metadata[sub_idx][js_idx][
-                "submit_machine"
-            ] = submit_machine
+            entry["submit_machine"] = submit_machine
         if submit_cmdline:
-            self._pending.set_js_metadata[sub_idx][js_idx][
-                "submit_cmdline"
-            ] = submit_cmdline
+            entry["submit_cmdline"] = submit_cmdline
         if os_name:
-            self._pending.set_js_metadata[sub_idx][js_idx]["os_name"] = os_name
+            entry["os_name"] = os_name
         if shell_name:
-            self._pending.set_js_metadata[sub_idx][js_idx]["shell_name"] = shell_name
+            entry["shell_name"] = shell_name
         if scheduler_name:
-            self._pending.set_js_metadata[sub_idx][js_idx][
-                "scheduler_name"
-            ] = scheduler_name
+            entry["scheduler_name"] = scheduler_name
         if scheduler_job_ID:
-            self._pending.set_js_metadata[sub_idx][js_idx][
-                "scheduler_job_ID"
-            ] = scheduler_job_ID
+            entry["scheduler_job_ID"] = scheduler_job_ID
         if process_ID:
-            self._pending.set_js_metadata[sub_idx][js_idx]["process_ID"] = process_ID
+            entry["process_ID"] = process_ID
         if save:
             self.save()
 
     def _add_parameter(
         self,
         is_set: bool,
-        source: Dict,
-        data: Any = None,
-        file: Dict = None,
+        source: ParamSource,
+        data: (
+            ParameterValue | list | tuple | set | dict | int | float | str | None | Any
+        ) = None,
+        file: File | None = None,
         save: bool = True,
     ) -> int:
         self.logger.debug(f"Adding store parameter{f' (unset)' if not is_set else ''}.")
         new_idx = self._get_num_total_parameters()
-        self._pending.add_parameters[new_idx] = self._store_param_cls(
+        self._pending.add_parameters[new_idx] = self._store_param_cls()(
             id_=new_idx,
             is_pending=True,
             is_set=is_set,
@@ -1380,11 +1629,11 @@ class PersistentStore(ABC):
         self,
         store_contents: bool,
         is_input: bool,
-        path=None,
-        contents: str = None,
-        filename: str = None,
+        path: Path | str,
+        contents: str | None = None,
+        filename: str | None = None,
         clean_up: bool = False,
-    ):
+    ) -> File:
         if filename is None:
             filename = Path(path).name
 
@@ -1396,7 +1645,6 @@ class PersistentStore(ABC):
             else:
                 # assume path is inside the EAR execution directory; transform that to the
                 # equivalent artifacts directory:
-                assert path is not None
                 exec_sub_path = Path(path).relative_to(self.path)
                 dst_path = Path(
                     self.workflow.task_artifacts_path, *exec_sub_path.parts[1:]
@@ -1404,9 +1652,9 @@ class PersistentStore(ABC):
             if dst_path.is_file():
                 dst_path = dst_path.with_suffix(dst_path.suffix + "_2")  # TODO: better!
         else:
-            dst_path = path
+            dst_path = Path(path)
 
-        file_param_dat = {
+        file_param_dat: File = {
             "store_contents": store_contents,
             "path": str(dst_path.relative_to(self.path)),
         }
@@ -1416,7 +1664,7 @@ class PersistentStore(ABC):
                 "is_input": is_input,
                 "dst_path": str(dst_path),
                 "path": str(path),
-                "contents": contents,
+                "contents": contents or "",
                 "clean_up": clean_up,
             }
         )
@@ -1427,17 +1675,17 @@ class PersistentStore(ABC):
         self,
         store_contents: bool,
         is_input: bool,
-        param_id: int = None,
-        path=None,
-        contents: str = None,
-        filename: str = None,
+        param_id: int | None,
+        path: Path | str,
+        contents: str | None = None,
+        filename: str | None = None,
         clean_up: bool = False,
         save: bool = True,
     ):
         """
         Set details of a file, including whether it is associated with a parameter.
         """
-        self.logger.debug(f"Setting new file")
+        self.logger.debug("Setting new file")
         file_param_dat = self._prepare_set_file(
             store_contents=store_contents,
             is_input=is_input,
@@ -1457,16 +1705,16 @@ class PersistentStore(ABC):
         self,
         store_contents: bool,
         is_input: bool,
-        source: Dict,
-        path=None,
-        contents: str = None,
-        filename: str = None,
+        source: ParamSource,
+        path: Path | str,
+        contents: str | None = None,
+        filename: str | None = None,
         save: bool = True,
     ):
         """
         Add a file that will be associated with a parameter.
         """
-        self.logger.debug(f"Adding new file")
+        self.logger.debug("Adding new file")
         file_param_dat = self._prepare_set_file(
             store_contents=store_contents,
             is_input=is_input,
@@ -1484,7 +1732,7 @@ class PersistentStore(ABC):
             self.save()
         return p_id
 
-    def _append_files(self, files: Dict[int, Dict]):
+    def _append_files(self, files: list[FileDescriptor]):
         """Add new files to the files or artifacts directories."""
         for dat in files:
             if dat["store_contents"]:
@@ -1501,18 +1749,27 @@ class PersistentStore(ABC):
                     with dst_path.open("wt") as fp:
                         fp.write(dat["contents"])
 
-    def add_set_parameter(self, data: Any, source: Dict, save: bool = True) -> int:
+    def add_set_parameter(
+        self,
+        data: ParameterValue | list | tuple | set | dict | int | float | str | Any,
+        source: ParamSource,
+        save: bool = True,
+    ) -> int:
         """
         Add a parameter that is set to a value.
         """
         return self._add_parameter(data=data, is_set=True, source=source, save=save)
 
-    def add_unset_parameter(self, source: Dict, save: bool = True) -> int:
+    def add_unset_parameter(self, source: ParamSource, save: bool = True) -> int:
         """
         Add a parameter that is not set to any value.
         """
         return self._add_parameter(data=None, is_set=False, source=source, save=save)
 
+    @abstractmethod
+    def _set_parameter_values(self, set_parameters: dict[int, tuple[Any, bool]]):
+        ...
+
     def set_parameter_value(
         self, param_id: int, value: Any, is_file: bool = False, save: bool = True
     ):
@@ -1528,7 +1785,7 @@ class PersistentStore(ABC):
 
     @TimeIt.decorator
     def update_param_source(
-        self, param_sources: Dict[int, Dict], save: bool = True
+        self, param_sources: Mapping[int, ParamSource], save: bool = True
     ) -> None:
         """
         Set the source of a parameter.
@@ -1539,7 +1796,10 @@ class PersistentStore(ABC):
             self.save()
 
     def update_loop_num_iters(
-        self, index: int, num_added_iters: int, save: bool = True
+        self,
+        index: int,
+        num_added_iters: Mapping[tuple[int, ...], int],
+        save: bool = True,
     ) -> None:
         """
         Add iterations to a loop.
@@ -1547,16 +1807,17 @@ class PersistentStore(ABC):
         self.logger.debug(
             f"Updating loop {index!r} num added iterations to {num_added_iters!r}."
         )
-        num_added_iters = [[list(k), v] for k, v in num_added_iters.items()]
-        self._pending.update_loop_num_iters[index] = num_added_iters
+        self._pending.update_loop_num_iters[index] = [
+            [list(k), v] for k, v in num_added_iters.items()
+        ]
         if save:
             self.save()
 
     def update_loop_parents(
         self,
         index: int,
-        num_added_iters: int,
-        parents: List[str],
+        num_added_iters: Mapping[tuple[int, ...], int],
+        parents: Sequence[str],
         save: bool = True,
     ) -> None:
         """
@@ -1566,31 +1827,38 @@ class PersistentStore(ABC):
             f"Updating loop {index!r} parents to {parents!r}, and num added iterations "
             f"to {num_added_iters}."
         )
-        num_added_iters = [[list(k), v] for k, v in num_added_iters.items()]
-        self._pending.update_loop_num_iters[index] = num_added_iters
-        self._pending.update_loop_parents[index] = parents
+        self._pending.update_loop_num_iters[index] = [
+            [list(k), v] for k, v in num_added_iters.items()
+        ]
+        self._pending.update_loop_parents[index] = list(parents)
         if save:
             self.save()
 
-    def get_template_components(self) -> Dict:
+    def get_template_components(self) -> dict[str, Any]:
         """Get all template components, including pending."""
         tc = copy.deepcopy(self._get_persistent_template_components())
         for typ in TEMPLATE_COMP_TYPES:
             for hash_i, dat_i in self._pending.add_template_components[typ].items():
-                if typ not in tc:
-                    tc[typ] = {}
-                tc[typ][hash_i] = dat_i
+                tc.setdefault(typ, {})[hash_i] = dat_i
 
         return tc
 
-    def get_template(self) -> Dict:
+    @abstractmethod
+    def _get_persistent_template_components(self) -> dict[str, Any]:
+        ...
+
+    def get_template(self) -> dict[str, JSONed]:
         """
         Get the workflow template.
         """
         return self._get_persistent_template()
 
-    def _get_task_id_to_idx_map(self) -> Dict[int, int]:
-        return {i.id_: i.index for i in self.get_tasks()}
+    @abstractmethod
+    def _get_persistent_template(self) -> dict[str, JSONed]:
+        ...
+
+    def _get_task_id_to_idx_map(self) -> dict[int, int]:
+        return {task.id_: task.index for task in self.get_tasks()}
 
     @TimeIt.decorator
     def get_task(self, task_idx: int) -> AnySTask:
@@ -1599,182 +1867,180 @@ class PersistentStore(ABC):
         """
         return self.get_tasks()[task_idx]
 
-    def _process_retrieved_tasks(self, tasks: List[AnySTask]) -> List[AnySTask]:
+    def __process_retrieved_tasks(self, tasks: Iterable[AnySTask]) -> list[AnySTask]:
         """Add pending data to retrieved tasks."""
-        tasks_new = []
-        for task_i in tasks:
+        tasks_new: list[AnySTask] = []
+        for task in tasks:
             # consider pending element IDs:
-            pend_elems = self._pending.add_elem_IDs.get(task_i.id_)
-            if pend_elems:
-                task_i = task_i.append_element_IDs(pend_elems)
-            tasks_new.append(task_i)
+            if pend_elems := self._pending.add_elem_IDs.get(task.id_):
+                task = task.append_element_IDs(pend_elems)
+            tasks_new.append(task)
         return tasks_new
 
-    def _process_retrieved_loops(self, loops: Dict[int, Dict]) -> Dict[int, Dict]:
+    def __process_retrieved_loops(
+        self, loops: Iterable[tuple[int, LoopDescriptor]]
+    ) -> dict[int, LoopDescriptor]:
         """Add pending data to retrieved loops."""
-        loops_new = {}
-        for id_, loop_i in loops.items():
+        loops_new: dict[int, LoopDescriptor] = {}
+        for id_, loop_i in loops:
             if "num_added_iterations" not in loop_i:
                 loop_i["num_added_iterations"] = 1
             # consider pending changes to num added iterations:
-            pend_num_iters = self._pending.update_loop_num_iters.get(id_)
-            if pend_num_iters:
+            if pend_num_iters := self._pending.update_loop_num_iters.get(id_):
                 loop_i["num_added_iterations"] = pend_num_iters
             # consider pending change to parents:
-            pend_parents = self._pending.update_loop_parents.get(id_)
-            if pend_parents:
+            if pend_parents := self._pending.update_loop_parents.get(id_):
                 loop_i["parents"] = pend_parents
 
             loops_new[id_] = loop_i
         return loops_new
 
-    def get_tasks_by_IDs(self, id_lst: Iterable[int]) -> List[AnySTask]:
+    @staticmethod
+    def __split_pending(
+        ids: Iterable[int], all_pending: Mapping[int, Any]
+    ) -> tuple[tuple[int, ...], set[int], set[int]]:
+        id_all = tuple(ids)
+        id_set = set(id_all)
+        id_pers = id_set.difference(all_pending)
+        id_pend = id_set.intersection(all_pending)
+        return id_all, id_pers, id_pend
+
+    @abstractmethod
+    def _get_persistent_tasks(self, id_lst: Iterable[int]) -> dict[int, AnySTask]:
+        ...
+
+    def get_tasks_by_IDs(self, ids: Iterable[int]) -> Sequence[AnySTask]:
         """
         Get tasks with the given IDs.
         """
         # separate pending and persistent IDs:
-        id_set = set(id_lst)
-        all_pending = set(self._pending.add_tasks)
-        id_pers = id_set.difference(all_pending)
-        id_pend = id_set.intersection(all_pending)
 
+        ids, id_pers, id_pend = self.__split_pending(ids, self._pending.add_tasks)
         tasks = self._get_persistent_tasks(id_pers) if id_pers else {}
-        tasks.update({i: self._pending.add_tasks[i] for i in id_pend})
+        tasks.update((id_, self._pending.add_tasks[id_]) for id_ in id_pend)
 
         # order as requested:
-        tasks = [tasks[id_] for id_ in id_lst]
-
-        return self._process_retrieved_tasks(tasks)
+        return self.__process_retrieved_tasks(tasks[id_] for id_ in ids)
 
     @TimeIt.decorator
-    def get_tasks(self) -> List[AnySTask]:
+    def get_tasks(self) -> list[AnySTask]:
         """Retrieve all tasks, including pending."""
         tasks = self._get_persistent_tasks(range(self._get_num_persistent_tasks()))
-        tasks.update({k: v for k, v in self._pending.add_tasks.items()})
+        tasks.update(self._pending.add_tasks)
 
         # order by index:
-        tasks = sorted((i for i in tasks.values()), key=lambda x: x.index)
+        return self.__process_retrieved_tasks(
+            sorted(tasks.values(), key=lambda x: x.index)
+        )
 
-        return self._process_retrieved_tasks(tasks)
+    @abstractmethod
+    def _get_persistent_loops(
+        self, id_lst: Iterable[int] | None = None
+    ) -> dict[int, LoopDescriptor]:
+        ...
 
-    def get_loops_by_IDs(self, id_lst: Iterable[int]) -> Dict[int, Dict]:
+    def get_loops_by_IDs(self, ids: Iterable[int]) -> dict[int, LoopDescriptor]:
         """Retrieve loops by index (ID), including pending."""
 
         # separate pending and persistent IDs:
-        id_set = set(id_lst)
-        all_pending = set(self._pending.add_loops)
-        id_pers = id_set.difference(all_pending)
-        id_pend = id_set.intersection(all_pending)
+        ids, id_pers, id_pend = self.__split_pending(ids, self._pending.add_loops)
 
         loops = self._get_persistent_loops(id_pers) if id_pers else {}
-        loops.update({i: self._pending.add_loops[i] for i in id_pend})
+        loops.update((id_, self._pending.add_loops[id_]) for id_ in id_pend)
 
         # order as requested:
-        loops = {id_: loops[id_] for id_ in id_lst}
+        return self.__process_retrieved_loops((id_, loops[id_]) for id_ in ids)
 
-        return self._process_retrieved_loops(loops)
-
-    def get_loops(self) -> Dict[int, Dict]:
+    def get_loops(self) -> dict[int, LoopDescriptor]:
         """Retrieve all loops, including pending."""
 
         loops = self._get_persistent_loops()
-        loops.update({k: v for k, v in self._pending.add_loops.items()})
+        loops.update(self._pending.add_loops)
 
         # order by index/ID:
-        loops = dict(sorted(loops.items()))
+        return self.__process_retrieved_loops(sorted(loops.items()))
 
-        return self._process_retrieved_loops(loops)
+    @abstractmethod
+    def _get_persistent_submissions(
+        self, id_lst: Iterable[int] | None = None
+    ) -> dict[int, JSONDocument]:
+        ...
 
     @TimeIt.decorator
-    def get_submissions(self) -> Dict[int, Dict]:
+    def get_submissions(self) -> dict[int, JSONDocument]:
         """Retrieve all submissions, including pending."""
 
         subs = self._get_persistent_submissions()
-        subs.update({k: v for k, v in self._pending.add_submissions.items()})
+        subs.update(self._pending.add_submissions)
 
         # order by index/ID
-        subs = dict(sorted(subs.items()))
-
-        return subs
+        return dict(sorted(subs.items()))
 
     @TimeIt.decorator
-    def get_submissions_by_ID(self, id_lst: Iterable[int]) -> Dict[int, Dict]:
+    def get_submissions_by_ID(self, ids: Iterable[int]) -> dict[int, JSONDocument]:
         """
         Get submissions with the given IDs.
         """
         # separate pending and persistent IDs:
-        id_set = set(id_lst)
-        all_pending = set(self._pending.add_submissions)
-        id_pers = id_set.difference(all_pending)
-        id_pend = id_set.intersection(all_pending)
-
+        _, id_pers, id_pend = self.__split_pending(ids, self._pending.add_submissions)
         subs = self._get_persistent_submissions(id_pers) if id_pers else {}
-        subs.update({i: self._pending.add_submissions[i] for i in id_pend})
+        subs.update((id_, self._pending.add_submissions[id_]) for id_ in id_pend)
 
         # order by index/ID
-        subs = dict(sorted(subs.items()))
+        return dict(sorted(subs.items()))
 
-        return subs
+    @abstractmethod
+    def _get_persistent_elements(self, id_lst: Iterable[int]) -> dict[int, AnySElement]:
+        ...
 
     @TimeIt.decorator
-    def get_elements(self, id_lst: Iterable[int]) -> List[AnySElement]:
+    def get_elements(self, ids: Iterable[int]) -> Sequence[AnySElement]:
         """
         Get elements with the given IDs.
         """
-        self.logger.debug(f"PersistentStore.get_elements: id_lst={id_lst!r}")
-
         # separate pending and persistent IDs:
-        id_set = set(id_lst)
-        all_pending = set(self._pending.add_elements)
-        id_pers = id_set.difference(all_pending)
-        id_pend = id_set.intersection(all_pending)
-
+        ids, id_pers, id_pend = self.__split_pending(ids, self._pending.add_elements)
+        self.logger.debug(f"PersistentStore.get_elements: id_lst={ids!r}")
         elems = self._get_persistent_elements(id_pers) if id_pers else {}
-        elems.update({i: self._pending.add_elements[i] for i in id_pend})
+        elems.update((id_, self._pending.add_elements[id_]) for id_ in id_pend)
 
+        elems_new: list[AnySElement] = []
         # order as requested:
-        elems = [elems[id_] for id_ in id_lst]
-
-        elems_new = []
-        for elem_i in elems:
+        for elem_i in (elems[id_] for id_ in ids):
             # consider pending iteration IDs:
             # TODO: does this consider pending iterations from new loop iterations?
-            pend_iters = self._pending.add_elem_iter_IDs.get(elem_i.id_)
-            if pend_iters:
+            if pend_iters := self._pending.add_elem_iter_IDs.get(elem_i.id_):
                 elem_i = elem_i.append_iteration_IDs(pend_iters)
             elems_new.append(elem_i)
 
         return elems_new
 
+    @abstractmethod
+    def _get_persistent_element_iters(
+        self, id_lst: Iterable[int]
+    ) -> dict[int, AnySElementIter]:
+        ...
+
     @TimeIt.decorator
-    def get_element_iterations(self, id_lst: Iterable[int]) -> List[AnySElementIter]:
+    def get_element_iterations(self, ids: Iterable[int]) -> Sequence[AnySElementIter]:
         """
         Get element iterations with the given IDs.
         """
-        self.logger.debug(f"PersistentStore.get_element_iterations: id_lst={id_lst!r}")
-
         # separate pending and persistent IDs:
-        id_set = set(id_lst)
-        all_pending = set(self._pending.add_elem_iters)
-        id_pers = id_set.difference(all_pending)
-        id_pend = id_set.intersection(all_pending)
-
+        ids, id_pers, id_pend = self.__split_pending(ids, self._pending.add_elem_iters)
+        self.logger.debug(f"PersistentStore.get_element_iterations: id_lst={ids!r}")
         iters = self._get_persistent_element_iters(id_pers) if id_pers else {}
-        iters.update({i: self._pending.add_elem_iters[i] for i in id_pend})
+        iters.update((id_, self._pending.add_elem_iters[id_]) for id_ in id_pend)
 
+        iters_new: list[AnySElementIter] = []
         # order as requested:
-        iters = [iters[id_] for id_ in id_lst]
-
-        iters_new = []
-        for iter_i in iters:
+        for iter_i in (iters[id_] for id_ in ids):
             # consider pending EAR IDs:
-            pend_EARs = self._pending.add_elem_iter_EAR_IDs.get(iter_i.id_)
-            if pend_EARs:
+            if pend_EARs := self._pending.add_elem_iter_EAR_IDs.get(iter_i.id_):
                 iter_i = iter_i.append_EAR_IDs(pend_EARs)
 
             # consider pending loop idx
-            pend_loop_idx = self._pending.update_loop_indices.get(iter_i.id_)
-            if pend_loop_idx:
+            if pend_loop_idx := self._pending.update_loop_indices.get(iter_i.id_):
                 iter_i = iter_i.update_loop_idx(pend_loop_idx)
 
             # consider pending `EARs_initialised`:
@@ -1785,47 +2051,41 @@ class PersistentStore(ABC):
 
         return iters_new
 
+    @abstractmethod
+    def _get_persistent_EARs(self, id_lst: Iterable[int]) -> dict[int, AnySEAR]:
+        ...
+
     @TimeIt.decorator
-    def get_EARs(self, id_lst: Iterable[int]) -> List[AnySEAR]:
+    def get_EARs(self, ids: Iterable[int]) -> Sequence[AnySEAR]:
         """
         Get element action runs with the given IDs.
         """
-        self.logger.debug(f"PersistentStore.get_EARs: id_lst={id_lst!r}")
-
         # separate pending and persistent IDs:
-        id_set = set(id_lst)
-        all_pending = set(self._pending.add_EARs)
-        id_pers = id_set.difference(all_pending)
-        id_pend = id_set.intersection(all_pending)
-
+        ids, id_pers, id_pend = self.__split_pending(ids, self._pending.add_EARs)
+        self.logger.debug(f"PersistentStore.get_EARs: id_lst={ids!r}")
         EARs = self._get_persistent_EARs(id_pers) if id_pers else {}
-        EARs.update({i: self._pending.add_EARs[i] for i in id_pend})
+        EARs.update((id_, self._pending.add_EARs[id_]) for id_ in id_pend)
 
+        EARs_new: list[AnySEAR] = []
         # order as requested:
-        EARs = [EARs[id_] for id_ in id_lst]
-
-        EARs_new = []
-        for EAR_i in EARs:
+        for EAR_i in (EARs[id_] for id_ in ids):
             # consider updates:
-            pend_sub = self._pending.set_EAR_submission_indices.get(EAR_i.id_)
-            pend_start = self._pending.set_EAR_starts.get(EAR_i.id_)
-            pend_end = self._pending.set_EAR_ends.get(EAR_i.id_)
-            pend_skip = True if EAR_i.id_ in self._pending.set_EAR_skips else None
-
-            p_st, p_ss, p_hn = pend_start if pend_start else (None, None, None)
-            p_et, p_se, p_ex, p_sx = pend_end if pend_end else (None, None, None, None)
-
-            updates = {
-                "submission_idx": pend_sub,
-                "skip": pend_skip,
-                "success": p_sx,
-                "start_time": p_st,
-                "end_time": p_et,
-                "snapshot_start": p_ss,
-                "snapshot_end": p_se,
-                "exit_code": p_ex,
-                "run_hostname": p_hn,
+            updates: dict[str, Any] = {
+                "submission_idx": self._pending.set_EAR_submission_indices.get(EAR_i.id_)
             }
+            if EAR_i.id_ in self._pending.set_EAR_skips:
+                updates["skip"] = True
+            (
+                updates["start_time"],
+                updates["snapshot_start"],
+                updates["run_hostname"],
+            ) = self._pending.set_EAR_starts.get(EAR_i.id_, (None, None, None))
+            (
+                updates["end_time"],
+                updates["snapshot_end"],
+                updates["exit_code"],
+                updates["success"],
+            ) = self._pending.set_EAR_ends.get(EAR_i.id_, (None, None, None, None))
             if any(i is not None for i in updates.values()):
                 EAR_i = EAR_i.update(**updates)
 
@@ -1834,64 +2094,65 @@ class PersistentStore(ABC):
         return EARs_new
 
     @TimeIt.decorator
-    def _get_cached_persistent_items(
-        self, id_lst: Iterable[int], cache: Dict
-    ) -> Tuple[Dict[int, Any], List[int]]:
-        id_lst = list(id_lst)
+    def __get_cached_persistent_items(
+        self, id_lst: Iterable[int], cache: dict[int, T]
+    ) -> tuple[dict[int, T], list[int]]:
+        """How to get things out of the cache. Caller says which cache."""
         if self.use_cache:
-            id_set = set(id_lst)
-            all_cached = set(cache.keys())
-            id_cached = id_set.intersection(all_cached)
-            id_non_cached = list(id_set.difference(all_cached))
-            items = {k: cache[k] for k in id_cached}
+            id_cached = set(id_lst)
+            id_non_cached = sorted(id_cached.difference(cache))
+            id_cached.intersection_update(cache)
+            items = {id_: cache[id_] for id_ in sorted(id_cached)}
         else:
             items = {}
-            id_non_cached = id_lst
+            id_non_cached = list(id_lst)
         return items, id_non_cached
 
     def _get_cached_persistent_EARs(
         self, id_lst: Iterable[int]
-    ) -> Tuple[Dict[int, AnySEAR], List[int]]:
-        return self._get_cached_persistent_items(id_lst, self.EAR_cache)
+    ) -> tuple[dict[int, AnySEAR], list[int]]:
+        return self.__get_cached_persistent_items(id_lst, self.EAR_cache)
 
     def _get_cached_persistent_element_iters(
         self, id_lst: Iterable[int]
-    ) -> Tuple[Dict[int, AnySEAR], List[int]]:
-        return self._get_cached_persistent_items(id_lst, self.element_iter_cache)
+    ) -> tuple[dict[int, AnySElementIter], list[int]]:
+        return self.__get_cached_persistent_items(id_lst, self.element_iter_cache)
 
     def _get_cached_persistent_elements(
         self, id_lst: Iterable[int]
-    ) -> Tuple[Dict[int, AnySEAR], List[int]]:
-        return self._get_cached_persistent_items(id_lst, self.element_cache)
+    ) -> tuple[dict[int, AnySElement], list[int]]:
+        return self.__get_cached_persistent_items(id_lst, self.element_cache)
 
-    def _get_cached_persistent_tasks(self, id_lst: Iterable[int]):
-        return self._get_cached_persistent_items(id_lst, self.task_cache)
+    def _get_cached_persistent_tasks(
+        self, id_lst: Iterable[int]
+    ) -> tuple[dict[int, AnySTask], list[int]]:
+        return self.__get_cached_persistent_items(id_lst, self.task_cache)
 
-    def _get_cached_persistent_param_sources(self, id_lst: Iterable[int]):
-        return self._get_cached_persistent_items(id_lst, self.param_sources_cache)
+    def _get_cached_persistent_param_sources(
+        self, id_lst: Iterable[int]
+    ) -> tuple[dict[int, ParamSource], list[int]]:
+        return self.__get_cached_persistent_items(id_lst, self.param_sources_cache)
 
-    def _get_cached_persistent_parameters(self, id_lst: Iterable[int]):
-        return self._get_cached_persistent_items(id_lst, self.parameter_cache)
+    def _get_cached_persistent_parameters(
+        self, id_lst: Iterable[int]
+    ) -> tuple[dict[int, AnySParameter], list[int]]:
+        return self.__get_cached_persistent_items(id_lst, self.parameter_cache)
 
     def get_EAR_skipped(self, EAR_ID: int) -> bool:
         """
         Whether the element action run with the given ID was skipped.
         """
         self.logger.debug(f"PersistentStore.get_EAR_skipped: EAR_ID={EAR_ID!r}")
-        return self.get_EARs([EAR_ID])[0].skip
+        return self.get_EARs((EAR_ID,))[0].skip
 
     @TimeIt.decorator
-    def get_parameters(
-        self,
-        id_lst: Iterable[int],
-        **kwargs: Dict,
-    ) -> List[AnySParameter]:
+    def get_parameters(self, ids: Iterable[int], **kwargs) -> list[AnySParameter]:
         """
         Get parameters with the given IDs.
 
         Parameters
         ----------
-        id_lst:
+        ids:
             The IDs of the parameters to get.
 
         Keyword Arguments
@@ -1900,124 +2161,259 @@ class PersistentStore(ABC):
             For Zarr stores only. If True, copy arrays as NumPy arrays.
         """
         # separate pending and persistent IDs:
-        id_set = set(id_lst)
-        all_pending = set(self._pending.add_parameters)
-        id_pers = id_set.difference(all_pending)
-        id_pend = id_set.intersection(all_pending)
-
-        params = self._get_persistent_parameters(id_pers, **kwargs) if id_pers else {}
-        params.update({i: self._pending.add_parameters[i] for i in id_pend})
+        ids, id_pers, id_pend = self.__split_pending(ids, self._pending.add_parameters)
+        params = (
+            dict(self._get_persistent_parameters(id_pers, **kwargs)) if id_pers else {}
+        )
+        params.update((id_, self._pending.add_parameters[id_]) for id_ in id_pend)
 
         # order as requested:
-        params = [params[id_] for id_ in id_lst]
+        return [params[id_] for id_ in ids]
 
-        return params
+    @abstractmethod
+    def _get_persistent_parameters(
+        self, id_lst: Iterable[int], **kwargs
+    ) -> Mapping[int, AnySParameter]:
+        ...
 
     @TimeIt.decorator
-    def get_parameter_set_statuses(self, id_lst: Iterable[int]) -> List[bool]:
+    def get_parameter_set_statuses(self, ids: Iterable[int]) -> list[bool]:
         """
         Get whether the parameters with the given IDs are set.
         """
         # separate pending and persistent IDs:
-        id_set = set(id_lst)
-        all_pending = set(self._pending.add_parameters)
-        id_pers = id_set.difference(all_pending)
-        id_pend = id_set.intersection(all_pending)
-
+        ids, id_pers, id_pend = self.__split_pending(ids, self._pending.add_parameters)
         set_status = self._get_persistent_parameter_set_status(id_pers) if id_pers else {}
-        set_status.update({i: self._pending.add_parameters[i].is_set for i in id_pend})
+        set_status.update(
+            (id_, self._pending.add_parameters[id_].is_set) for id_ in id_pend
+        )
 
         # order as requested:
-        return [set_status[id_] for id_ in id_lst]
+        return [set_status[id_] for id_ in ids]
+
+    @abstractmethod
+    def _get_persistent_parameter_set_status(
+        self, id_lst: Iterable[int]
+    ) -> dict[int, bool]:
+        ...
 
     @TimeIt.decorator
-    def get_parameter_sources(self, id_lst: Iterable[int]) -> List[Dict]:
+    def get_parameter_sources(self, ids: Iterable[int]) -> list[ParamSource]:
         """
         Get the sources of the parameters with the given IDs.
         """
         # separate pending and persistent IDs:
-        id_set = set(id_lst)
-        all_pending = set(self._pending.add_parameters)
-        id_pers = id_set.difference(all_pending)
-        id_pend = id_set.intersection(all_pending)
-
+        ids, id_pers, id_pend = self.__split_pending(ids, self._pending.add_parameters)
         src = self._get_persistent_param_sources(id_pers) if id_pers else {}
-        src.update({i: self._pending.add_parameters[i].source for i in id_pend})
+        src.update((id_, self._pending.add_parameters[id_].source) for id_ in id_pend)
 
-        # order as requested:
-        src = {id_: src[id_] for id_ in id_lst}
+        # order as requested, and consider pending source updates:
+        return [
+            self.__merge_param_source(
+                src[id_i], self._pending.update_param_sources.get(id_i)
+            )
+            for id_i in ids
+        ]
 
-        src_new = []
-        for id_i, src_i in src.items():
-            # consider pending source updates:
-            pend_src = self._pending.update_param_sources.get(id_i)
-            if pend_src:
-                src_i = {**src_i, **pend_src}
-            src_new.append(src_i)
+    @staticmethod
+    def __merge_param_source(
+        src_i: ParamSource, pend_src: ParamSource | None
+    ) -> ParamSource:
+        """
+        Helper to merge a second dict in if it is provided.
+        """
+        return {**src_i, **pend_src} if pend_src else src_i
 
-        return src_new
+    @abstractmethod
+    def _get_persistent_param_sources(
+        self, id_lst: Iterable[int]
+    ) -> dict[int, ParamSource]:
+        ...
 
     @TimeIt.decorator
     def get_task_elements(
         self,
-        task_id,
-        idx_lst: Optional[Iterable[int]] = None,
-    ) -> List[Dict]:
+        task_id: int,
+        idx_lst: Iterable[int] | None = None,
+    ) -> Iterator[Mapping[str, Any]]:
         """
         Get element data by an indices within a given task.
 
         Element iterations and EARs belonging to the elements are included.
-
         """
 
         all_elem_IDs = self.get_task(task_id).element_IDs
-        if idx_lst is None:
-            req_IDs = all_elem_IDs
-        else:
-            req_IDs = [all_elem_IDs[i] for i in idx_lst]
-        store_elements = self.get_elements(req_IDs)
-        iter_IDs = [i.iteration_IDs for i in store_elements]
-        iter_IDs_flat, iter_IDs_lens = flatten(iter_IDs)
+        store_elements = self.get_elements(
+            all_elem_IDs if idx_lst is None else (all_elem_IDs[idx] for idx in idx_lst)
+        )
+        iter_IDs_flat, iter_IDs_lens = flatten(
+            [el.iteration_IDs for el in store_elements]
+        )
         store_iters = self.get_element_iterations(iter_IDs_flat)
 
         # retrieve EARs:
-        EAR_IDs = [list((i.EAR_IDs or {}).values()) for i in store_iters]
-        EAR_IDs_flat, EAR_IDs_lens = flatten(EAR_IDs)
-        EARs_dct = [i.to_dict() for i in self.get_EARs(EAR_IDs_flat)]
-        EARs_dct_rs = reshape(EARs_dct, EAR_IDs_lens)
+        EARs_dcts = remap(
+            [list((elit.EAR_IDs or {}).values()) for elit in store_iters],
+            lambda ears: [ear.to_dict() for ear in self.get_EARs(ears)],
+        )
 
         # add EARs to iterations:
-        iters = []
+        iters: list[dict[str, Any]] = []
         for idx, i in enumerate(store_iters):
-            EARs = None
+            EARs: dict[int, dict[str, Any]] | None = None
             if i.EAR_IDs is not None:
-                EARs = dict(zip(i.EAR_IDs.keys(), EARs_dct_rs[idx]))
+                EARs = dict(zip(i.EAR_IDs, cast("Any", EARs_dcts[idx])))
             iters.append(i.to_dict(EARs))
 
         # reshape iterations:
         iters_rs = reshape(iters, iter_IDs_lens)
 
         # add iterations to elements:
-        elements = []
-        for idx, i in enumerate(store_elements):
-            elements.append(i.to_dict(iters_rs[idx]))
-        return elements
+        for idx, element in enumerate(store_elements):
+            yield element.to_dict(iters_rs[idx])
 
-    def check_parameters_exist(self, id_lst: Iterable[int]) -> List[bool]:
-        """For each parameter ID, return True if it exists, else False"""
+    @abstractmethod
+    def _get_persistent_parameter_IDs(self) -> Iterable[int]:
+        ...
 
-        id_set = set(id_lst)
-        all_pending = set(self._pending.add_parameters)
-        id_not_pend = id_set.difference(all_pending)
+    def check_parameters_exist(self, ids: Sequence[int]) -> Iterator[bool]:
+        """
+        For each parameter ID, return True if it exists, else False.
+        """
         id_miss = set()
-        if id_not_pend:
-            all_id_pers = self._get_persistent_parameter_IDs()
-            id_miss = id_not_pend.difference(all_id_pers)
+        if id_not_pend := set(ids).difference(self._pending.add_parameters):
+            id_miss = id_not_pend.difference(self._get_persistent_parameter_IDs())
+        return (id_ not in id_miss for id_ in ids)
+
+    @abstractmethod
+    def _append_tasks(self, tasks: Iterable[AnySTask]) -> None:
+        ...
 
-        return [False if i in id_miss else True for i in id_lst]
+    @abstractmethod
+    def _append_loops(self, loops: dict[int, LoopDescriptor]) -> None:
+        ...
+
+    @abstractmethod
+    def _append_submissions(self, subs: dict[int, JSONDocument]) -> None:
+        ...
+
+    @abstractmethod
+    def _append_submission_parts(
+        self, sub_parts: dict[int, dict[str, list[int]]]
+    ) -> None:
+        ...
+
+    @abstractmethod
+    def _append_elements(self, elems: Sequence[AnySElement]) -> None:
+        ...
+
+    @abstractmethod
+    def _append_element_sets(self, task_id: int, es_js: Sequence[Mapping]) -> None:
+        ...
+
+    @abstractmethod
+    def _append_elem_iter_IDs(self, elem_ID: int, iter_IDs: Iterable[int]) -> None:
+        ...
+
+    @abstractmethod
+    def _append_elem_iters(self, iters: Sequence[AnySElementIter]) -> None:
+        ...
+
+    @abstractmethod
+    def _append_elem_iter_EAR_IDs(
+        self, iter_ID: int, act_idx: int, EAR_IDs: Sequence[int]
+    ) -> None:
+        ...
+
+    @abstractmethod
+    def _append_EARs(self, EARs: Sequence[AnySEAR]) -> None:
+        ...
+
+    @abstractmethod
+    def _update_elem_iter_EARs_initialised(self, iter_ID: int) -> None:
+        ...
+
+    @abstractmethod
+    def _update_EAR_submission_indices(self, sub_indices: Mapping[int, int]) -> None:
+        ...
+
+    @abstractmethod
+    def _update_EAR_start(
+        self, EAR_id: int, s_time: datetime, s_snap: dict[str, Any], s_hn: str
+    ) -> None:
+        ...
+
+    @abstractmethod
+    def _update_EAR_end(
+        self,
+        EAR_id: int,
+        e_time: datetime,
+        e_snap: dict[str, Any],
+        ext_code: int,
+        success: bool,
+    ) -> None:
+        ...
+
+    @abstractmethod
+    def _update_EAR_skip(self, EAR_id: int) -> None:
+        ...
+
+    @abstractmethod
+    def _update_js_metadata(self, js_meta: dict[int, dict[int, dict[str, Any]]]) -> None:
+        ...
+
+    @abstractmethod
+    def _append_parameters(self, params: Sequence[AnySParameter]) -> None:
+        ...
+
+    @abstractmethod
+    def _update_template_components(self, tc: dict[str, Any]) -> None:
+        ...
+
+    @abstractmethod
+    def _update_parameter_sources(self, sources: Mapping[int, ParamSource]) -> None:
+        ...
+
+    @abstractmethod
+    def _update_loop_index(self, iter_ID: int, loop_idx: dict[str, int]) -> None:
+        ...
+
+    @abstractmethod
+    def _update_loop_num_iters(
+        self, index: int, num_iters: list[list[list[int] | int]]
+    ) -> None:
+        ...
+
+    @abstractmethod
+    def _update_loop_parents(self, index: int, parents: list[str]) -> None:
+        ...
+
+    @overload
+    def using_resource(
+        self, res_label: Literal["metadata"], action: str
+    ) -> AbstractContextManager[Metadata]:
+        ...
+
+    @overload
+    def using_resource(
+        self, res_label: Literal["submissions"], action: str
+    ) -> AbstractContextManager[list[JSONDocument]]:
+        ...
+
+    @overload
+    def using_resource(
+        self, res_label: Literal["parameters"], action: str
+    ) -> AbstractContextManager[dict[str, dict[str, Any]]]:
+        ...
+
+    @overload
+    def using_resource(
+        self, res_label: Literal["attrs"], action: str
+    ) -> AbstractContextManager[ZarrAttrsDict]:
+        ...
 
     @contextlib.contextmanager
-    def using_resource(self, res_label, action):
+    def using_resource(self, res_label: str, action: str) -> Iterator[Any]:
         """Context manager for managing `StoreResource` objects associated with the store."""
 
         try:
@@ -2048,12 +2444,13 @@ class PersistentStore(ABC):
                 res.close(action)
                 self._resources_in_use.remove(key)
 
-    def copy(self, path=None) -> str:
+    def copy(self, path: PathLike = None) -> Path:
         """Copy the workflow store.
 
         This does not work on remote filesystems.
 
         """
+        assert self.fs is not None
         if path is None:
             _path = Path(self.path)
             path = _path.parent / Path(_path.stem + "_copy" + _path.suffix)
@@ -2065,9 +2462,7 @@ class PersistentStore(ABC):
 
         self.fs.copy(self.path, path)
 
-        new_fs_path = self.workflow.fs_path.replace(self.path, path)
-
-        return new_fs_path
+        return Path(self.workflow._store.path).replace(path)
 
     def delete(self) -> None:
         """Delete the persistent workflow."""
@@ -2080,9 +2475,16 @@ class PersistentStore(ABC):
     def delete_no_confirm(self) -> None:
         """Permanently delete the workflow data with no confirmation."""
 
-        @self.app.perm_error_retry()
+        fs = self.fs
+        assert fs is not None
+
+        @self._app.perm_error_retry()
         def _delete_no_confirm() -> None:
             self.logger.debug(f"_delete_no_confirm: {self.path!r}.")
-            self.fs.rm(self.path, recursive=True)
+            fs.rm(self.path, recursive=True)
 
         return _delete_no_confirm()
+
+    @abstractmethod
+    def _append_task_element_IDs(self, task_ID: int, elem_IDs: list[int]):
+        raise NotImplementedError