fix: RFC 0005/0008 typed-arg and null-vs-empty parity with openjd-rs

Two Rust-parity fixes in the v0 session runtime:

1. WrappedAction.Args now uses RFC 0005 1.3.2 typed argument semantics.
   The enforcement path's typed arg loop (null skip, list flattening,
   display coercion) is extracted into a shared module-level helper,
   resolve_action_arg_values, in _runner_base.py; both
   _inject_wrapped_task_symbols and _inject_wrapped_env_symbols now use
   it, so a wrap hook sees exactly the argv the wrapped action would
   have run with unwrapped -- mirroring openjd-rs, whose
   seed_wrapped_action_symbols resolves through the same
   resolve_action_args as the runner. The helper also gains openjd-rs's
   plain-string-resolution fallback when typed resolution fails.

2. An empty string is no longer conflated with null.
   resolve_optional_int_field and resolve_effective_cancelation's
   deferred-mode branch now resolve typed (resolve_value) and treat
   only a typed null result as "field omitted" / "no cancelation
   declared". A genuine empty string now reaches the "must be a
   positive integer, got ''" / "must resolve to ... got ''" errors,
   matching openjd-rs's resolve_action_timeout,
   resolve_notify_period_seconds, and resolve_effective_cancelation,
   which only special-case ExprValue::Null. The
   whole_field_expression() pre-check is removed: resolve_value only
   yields a typed null for whole-field expressions, so null semantics
   remain whole-field-only by construction.

Test updates: the deferred-cancelation unit-test helper now parses its
format strings with the EXPR extension (deferred forwarding is an
RFC 0008 construct and WRAP_ACTIONS requires EXPR), since the previous
legacy parse pinned the non-Rust "" == null behavior.

Signed-off-by: David Leong <116610336+leongdl@users.noreply.github.com>

Author: leongdl

src/openjd/sessions/_embedded_files.py

@@ -220,7 +220,7 @@ def allocate_file_paths(
         the file contents.
 
         Splitting allocation from :meth:`write_file_contents` lets the runner
-        evaluate EXPR ``let`` bindings between the two phases (RFC 0007): a
+        evaluate EXPR ``let`` bindings between the two phases (RFC 0005): a
         file's *path* never depends on ``let`` values (``filename`` is a plain
         string), so the ``Env.File.*``/``Task.File.*`` symbols are available
         to the bindings, while a file's ``data`` is written afterwards so it

src/openjd/sessions/_runner_base.py

@@ -6,7 +6,6 @@
 from typing import Callable, Optional
 
 from openjd.model import SymbolTable
-from openjd.model.v2023_09 import Action as Action_2023_09
 from openjd.model.v2023_09 import EnvironmentScript as EnvironmentScript_2023_09
 from ._embedded_files import EmbeddedFilesScope, _FileRecord
 from ._logging import log_subsection_banner
@@ -141,9 +140,7 @@ def _run_env_action(
         log_subsection_banner(self._logger, "Phase: Setup")
 
         let_bindings = (
-            getattr(self._environment_script, "let", None)
-            if self._environment_script is not None
-            else None
+            self._environment_script.let if self._environment_script is not None else None
         )
         # Write any embedded files to disk. File paths are allocated before
         # the script's EXPR `let` bindings evaluate (so bindings can reference
@@ -174,7 +171,12 @@ def _run_env_action(
 
         # Construct the command by evalutating the format strings in the command
         self._action = action
-        self._run_action(self._action, symtab, default_timeout=default_timeout)
+        self._run_action(
+            self._action,
+            symtab,
+            default_timeout=default_timeout,
+            default_notify_period_seconds=ENV_ACTION_DEFAULT_NOTIFY_PERIOD_SECONDS,
+        )
 
     def enter(self) -> None:
         """Run the Environment's onEnter action."""
@@ -268,13 +270,8 @@ def cancel(
             # Nothing to do.
             return
 
-        # For the type checker
-        assert isinstance(self._action, Action_2023_09)
-
-        self._cancel_with_effective_cancelation(
-            cancelation=self._action.cancelation,
-            symtab=self._symtab,
-            default_notify_period_seconds=ENV_ACTION_DEFAULT_NOTIFY_PERIOD_SECONDS,
-            time_limit=time_limit,
-            mark_action_failed=mark_action_failed,
-        )
+        # Cancel with the effective method resolved at launch time by
+        # _run_action, against the action's own final scope (the script's
+        # lets and Env.File.* symbols, plus WrappedAction.* for a wrap
+        # hook) — openjd-rs parity.
+        self._cancel_with_resolved_method(time_limit, mark_action_failed)

src/openjd/sessions/_runner_env_script.py

@@ -97,7 +97,7 @@ def run(self) -> None:
 
         # For the type checker.
         assert isinstance(self._script, StepScript_2023_09)
-        let_bindings = getattr(self._script, "let", None)
+        let_bindings = self._script.let
         # Write any embedded files to disk. File paths are allocated before
         # the script's EXPR `let` bindings evaluate (so bindings can reference
         # Task.File.*), and contents are written after (so `data` can
@@ -121,18 +121,16 @@ def run(self) -> None:
             symtab = self._symtab
 
         # Construct the command by evalutating the format strings in the command
-        self._run_action(self._script.actions.onRun, symtab)
+        self._run_action(
+            self._script.actions.onRun,
+            symtab,
+            default_notify_period_seconds=TASK_RUN_DEFAULT_NOTIFY_PERIOD_SECONDS,
+        )
 
     def cancel(
         self, *, time_limit: Optional[timedelta] = None, mark_action_failed: bool = False
     ) -> None:
-        # For the type checker.
-        assert isinstance(self._script, StepScript_2023_09)
-
-        self._cancel_with_effective_cancelation(
-            cancelation=self._script.actions.onRun.cancelation,
-            symtab=self._symtab,
-            default_notify_period_seconds=TASK_RUN_DEFAULT_NOTIFY_PERIOD_SECONDS,
-            time_limit=time_limit,
-            mark_action_failed=mark_action_failed,
-        )
+        # Cancel with the effective method resolved at launch time by
+        # _run_action, against the action's own final scope (its lets and
+        # Task.File.* symbols) — openjd-rs parity.
+        self._cancel_with_resolved_method(time_limit, mark_action_failed)

src/openjd/sessions/_runner_step_script.py

@@ -45,6 +45,7 @@
 from ._runner_base import (
     ScriptRunnerBase,
     apply_let_bindings,
+    resolve_action_arg_values,
     resolve_effective_cancelation,
     resolve_optional_int_field,
 )
@@ -373,7 +374,7 @@ def __init__(
                 ParameterValue (a dataclass containing the type and value of the parameter)
             job_name (Optional[str]): The resolved name of the Job this Session belongs to.
                 When provided, it is seeded as the ``Job.Name`` template variable
-                (RFC 0007 §7.3.1, EXPR extension) for the session's actions —
+                (RFC 0005; Template Schemas §7.3.1, EXPR extension) for the session's actions —
                 mirroring the Job.Name symbol that openjd-rs carries in its
                 session symbol tables. Defaults to None (no Job.Name symbol).
             path_mapping_rules (Optional[list[PathMappingRule]]): A list of the path mapping rules to apply
@@ -424,7 +425,7 @@ def __init__(
         # environment exits so its onExit resolves in the same scope.
         self._environment_extra_let_bindings: dict[EnvironmentIdentifier, list[str]] = dict()
         # The owning step's name supplied when an environment was entered
-        # (seeds Step.Name, RFC 0007 EXPR), re-seeded when the environment
+        # (seeds Step.Name, RFC 0005 EXPR), re-seeded when the environment
         # exits so the re-applied extra `let` bindings resolve in the same
         # scope.
         self._environment_step_names: dict[EnvironmentIdentifier, str] = dict()
@@ -711,15 +712,15 @@ def enter_environment(
                     Key: Environment variable name
                     Value: Value for the environment variable.
             extra_let_bindings (Optional[list[str]]): Additional EXPR ``let``
-                bindings (RFC 0007) evaluated into the symbol table before the
+                bindings (RFC 0005) evaluated into the symbol table before the
                 environment's variables and actions resolve. A step's
                 environments are entered with the step-level ``let`` bindings
                 (``Step.let`` on the instantiated Job) so both can reference
                 them — the v0 counterpart of the per-step resolved symbol
                 table that openjd-rs threads into enter_environment.
             step_name (Optional[str]): The name of the step whose
                 stepEnvironments are being entered, if any. Seeds
-                ``Step.Name`` (RFC 0007 EXPR) into the symbol table before
+                ``Step.Name`` (RFC 0005 EXPR) into the symbol table before
                 the extra ``let`` bindings evaluate, so step-level bindings
                 and the environment's variables and actions can reference
                 it — openjd-rs threads a per-step resolved symbol table into
@@ -767,14 +768,14 @@ def enter_environment(
 
         symtab = self._symbol_table(environment.revision)
 
-        # RFC 0007 §7.3.1 (EXPR): the owning step's name. Only EXPR templates
+        # RFC 0005; Template Schemas §7.3.1 (EXPR): the owning step's name. Only EXPR templates
         # pass validation referencing Step.Name, so seeding it when known does
         # not change non-EXPR behavior. Seeded before the extra `let` bindings
         # evaluate so a step-level binding may reference it.
         if step_name is not None:
             symtab["Step.Name"] = step_name
 
-        # Step-level `let` bindings (RFC 0007) accompany a step's
+        # Step-level `let` bindings (RFC 0005) accompany a step's
         # environments: evaluate them first so the environment's variables
         # and actions can reference them.
         if extra_let_bindings:
@@ -796,7 +797,7 @@ def enter_environment(
                 )
                 return identifier
 
-        # Note: the environment script's own EXPR `let` bindings (RFC 0007)
+        # Note: the environment script's own EXPR `let` bindings (RFC 0005)
         # are evaluated by the script runner, after embedded-file paths are
         # allocated (so bindings can reference Env.File.*). The environment's
         # `variables` resolve against the session symbol table without them,
@@ -977,9 +978,9 @@ def exit_environment(
         symtab = self._symbol_table(environment.revision)
         self._materialize_path_mapping(environment.revision, action_env_vars, symtab)
 
-        # Re-seed the owning step's name (Step.Name, RFC 0007 EXPR) and
+        # Re-seed the owning step's name (Step.Name, RFC 0005 EXPR) and
         # re-apply the extra `let` bindings this environment was entered with
-        # (e.g. the owning step's step-level bindings, RFC 0007) so its onExit
+        # (e.g. the owning step's step-level bindings, RFC 0005) so its onExit
         # resolves in the same scope as its onEnter.
         exit_step_name = self._environment_step_names.pop(identifier, None)
         if exit_step_name is not None:
@@ -999,7 +1000,7 @@ def exit_environment(
                 )
                 return
 
-        # Note: the environment script's own EXPR `let` bindings (RFC 0007)
+        # Note: the environment script's own EXPR `let` bindings (RFC 0005)
         # are evaluated by the script runner (after embedded-file path
         # allocation); the wrap-interception branch below evaluates them
         # itself before resolving the wrapped onExit.
@@ -1116,15 +1117,15 @@ def run_task(
 
         self._reset_action_state()
         symtab = self._symbol_table(step_script.revision, task_parameter_values)
-        # RFC 0007 §7.3.1 (EXPR): the running step's name. Only EXPR templates
+        # RFC 0005; Template Schemas §7.3.1 (EXPR): the running step's name. Only EXPR templates
         # pass validation referencing Step.Name, so seeding it when known does
         # not change non-EXPR behavior.
         if step_name is not None:
             symtab["Step.Name"] = step_name
         action_env_vars = self._evaluate_current_session_env_vars(os_env_vars)
         self._materialize_path_mapping(step_script.revision, action_env_vars, symtab)
 
-        # Note: the step script's EXPR `let` bindings (RFC 0007) are evaluated
+        # Note: the step script's EXPR `let` bindings (RFC 0005) are evaluated
         # by the script runner, after embedded-file paths are allocated (so
         # bindings can reference Task.File.*). The wrap-interception branch
         # below evaluates them itself before resolving the wrapped onRun.
@@ -1237,7 +1238,7 @@ def _run_task_without_session_env(
 
         self._materialize_path_mapping(step_script.revision, action_env_vars, symtab)
 
-        # Note: the step script's EXPR `let` bindings (RFC 0007) are evaluated
+        # Note: the step script's EXPR `let` bindings (RFC 0005) are evaluated
         # by the script runner, after embedded-file paths are allocated.
 
         self._runner = StepScriptRunner(
@@ -1461,7 +1462,7 @@ def record_expr_types(
             symtab[working_dir_key] = str(self.working_directory)
             # Session.WorkingDirectory is a host-format path value in openjd-rs.
             symtab.expr_types[working_dir_key] = ParameterValueType.PATH.value
-            # RFC 0007 §7.3.1 (EXPR): the job's resolved name. Only templates
+            # RFC 0005; Template Schemas §7.3.1 (EXPR): the job's resolved name. Only templates
             # declaring EXPR pass validation referencing Job.Name, so seeding
             # it whenever known does not change non-EXPR behavior.
             if self._job_name is not None:
@@ -1654,8 +1655,8 @@ def _try_inject_wrapped_symbols(
         try:
             inner_symtab = self._build_wrapped_inner_scope(
                 scope,
-                getattr(inner_script, "let", None) if inner_script is not None else None,
-                getattr(inner_script, "embeddedFiles", None) if inner_script is not None else None,
+                inner_script.let if inner_script is not None else None,
+                inner_script.embeddedFiles if inner_script is not None else None,
                 symtab,
             )
             inject(inner_symtab)
@@ -1771,9 +1772,13 @@ def _inject_wrapped_env_symbols(
         is removed from tracking, so the wrapped environment's own
         variables are included."""
         command = inner_action.command.resolve(symtab=inner_symtab)
-        args = (
-            [a.resolve(symtab=inner_symtab) for a in inner_action.args] if inner_action.args else []
-        )
+        # RFC 0005 §1.3.2 typed argument semantics (null skip, list
+        # flattening), shared with the enforcement path
+        # (ScriptRunnerBase._run_action) so the hook sees exactly the
+        # arguments the wrapped action would have run with unwrapped —
+        # mirroring openjd-rs's seed_wrapped_action_symbols, which resolves
+        # via the same resolve_action_args as the runner.
+        args = resolve_action_arg_values(inner_action.args, inner_symtab)
         symtab["WrappedAction.Command"] = command
         symtab["WrappedAction.Args"] = args
         symtab["WrappedAction.Environment"] = (
@@ -1807,9 +1812,10 @@ def _inject_wrapped_task_symbols(
         on_run = step_script.actions.onRun
 
         symtab["WrappedAction.Command"] = on_run.command.resolve(symtab=inner_symtab)
-        symtab["WrappedAction.Args"] = (
-            [arg.resolve(symtab=inner_symtab) for arg in on_run.args] if on_run.args else []
-        )
+        # RFC 0005 §1.3.2 typed argument semantics (null skip, list
+        # flattening), shared with the enforcement path — see
+        # _inject_wrapped_env_symbols.
+        symtab["WrappedAction.Args"] = resolve_action_arg_values(on_run.args, inner_symtab)
         symtab["WrappedAction.Environment"] = self._collect_session_env_list()
         symtab["WrappedAction.Timeout"] = self._resolve_action_timeout(on_run, inner_symtab)
         self._inject_wrapped_cancelation_symbols(
@@ -1898,7 +1904,7 @@ def _materialize_path_mapping(
         else:
             rules_dict = dict()
             symtab[ValueReferenceConstants_2023_09.HAS_PATH_MAPPING_RULES.value] = "false"
-        # RFC 0007 §7.3: for EXPR evaluation Session.HasPathMappingRules is a
+        # RFC 0005; Template Schemas §7.3: for EXPR evaluation Session.HasPathMappingRules is a
         # boolean and Session.PathMappingRulesFile is a path, matching
         # openjd-rs's typed session symbols. The legacy (non-EXPR)
         # interpolation path ignores these types and keeps the string forms.

src/openjd/sessions/_session.py

@@ -387,7 +387,9 @@ def test_cancel(
         # The lower-level process runners have been thoroughly tested for cancel's
         # functionality, so this seems fine.
 
-        with patch.object(EnvironmentScriptRunner, "_run_action"):
+        # Patch _run (not _run_action): the effective cancel method is now
+        # resolved by _run_action at launch time and consumed by cancel().
+        with patch.object(EnvironmentScriptRunner, "_run"):
             with patch.object(EnvironmentScriptRunner, "_cancel") as mock_cancel:
                 # GIVEN
                 script = EnvironmentScript_2023_09(
@@ -468,6 +470,7 @@ def test_run_env_action_passes_default_timeout(
             action,
             symtab,
             default_timeout=default_timeout,
+            default_notify_period_seconds=30,
         )
 
     def test_exit_uses_default_timeout(

test/openjd/sessions_v0/test_runner_env_script.py

@@ -252,7 +252,9 @@ def test_cancel(
         # The lower-level process runners have been thoroughly tested for cancel's
         # functionality, so this seems fine.
 
-        with patch.object(StepScriptRunner, "_run_action"):
+        # Patch _run (not _run_action): the effective cancel method is now
+        # resolved by _run_action at launch time and consumed by cancel().
+        with patch.object(StepScriptRunner, "_run"):
             with patch.object(StepScriptRunner, "_cancel") as mock_cancel:
                 # GIVEN
                 script = StepScript_2023_09(